/* * International Union of Pure and Applied Chemistry (IUPAC) * International Chemical Identifier (InChI) * Version 1 * Software version 1.01 * July 21, 2006 * Developed at NIST */ #ifndef __ICHIRVRS_H__ #define __ICHIRVRS_H__ #define ICHICONST const #define RI_ERR_ALLOC (-1) #define RI_ERR_SYNTAX (-2) #define RI_ERR_PROGR (-3) #define RI_ERR_EOL (-4) #define RI_ERR_EOF (0) #define NO_VALUE_INT 9999 #define NOT_READ_INT 9998 /* has not been read yet */ #define VALUE_OCTET 8 /* number of electrons in a full shell */ #define INC_EDGE_LIST_DEFAULT 64 typedef struct tagXYZCoord { double xyz[3]; } XYZ_COORD; typedef struct tagStructRestoreMode { int bMetalAddFlower; /* 1 => allow adjustable metal valence and charge; 0=> use std charge/valence */ /* the following three apply only if bMetalAddFlower = 1 */ int nMetalMinBondOrder; /* edge_flow=f means bond order=cMetalMinBondOrder+f */ int nMetalInitEdgeFlow; /* one bond contribution to metal's (st-cap - st-flow) = */ /* (nMetalInitBondOrder-nMetalMinBondOrder) - nMetalInitEdgeFlow */ int nMetalInitBondOrder; /* >= nMetalMinBondOrder + nMetalInitEdgeFlow */ /* same for metal-endpoint bonds */ int nMetal2EndpointMinBondOrder; int nMetal2EndpointInitBondOrder; int nMetal2EndpointInitEdgeFlow; int nMetalFlowerParam_D; /* additional edge capacity for canceling radicals */ int nMetalMaxCharge_D; /* cap and/or flow for metal charge group */ int bStereoRemovesMetalFlag; /* 1=> treat stereogenic atoms and atoms connected by a stereo bond as non-metals */ int bFixStereoBonds; /* 1=> forbid stereogenic double bonds from changing */ } SRM; typedef struct tagReversedInChI { PINChI2 *pINChI[INCHI_NUM]; PINChI_Aux2 *pINChI_Aux[INCHI_NUM]; int num_components[INCHI_NUM]; int nRetVal; } REV_INCHI; /**************************************/ #define BFS_Q_CLEAR (-1) #define BFS_Q_FREE (-2) typedef struct tagBfsQueue { QUEUE *q; AT_RANK *nAtomLevel; S_CHAR *cSource; int num_at; AT_RANK min_ring_size; /* 8 => detect 7-member and smaller rings */ } BFS_Q; /**************************************/ #define EXTRACT_STRUCT_NUMBER 1 /* additional Mobile-H parities to be added to Fixed-H parities */ /* This allows to set parities that exist in Mobile-H layer only */ typedef struct tagInpAtomAddParities { /* cml 0D parities */ S_CHAR bUsed0DParity; /* bit=1 => stereobond; bit=2 => stereocenter */ /* cml tetrahedral parity */ S_CHAR p_parity; AT_NUMB p_orig_at_num[MAX_NUM_STEREO_ATOM_NEIGH]; /* cml bond parities */ S_CHAR sb_ord[MAX_NUM_STEREO_BONDS]; /* stereo bond/neighbor ordering number, starts from 0 */ /* neighbors on both sides of stereobond have same sign=> trans/T/E, diff. signs => cis/C/Z */ S_CHAR sn_ord[MAX_NUM_STEREO_BONDS]; /* ord. num. of the neighbor adjacent to the SB; starts from 0; -1 means removed explicit H */ /* neighbors on both sides of stereobond have same parity => trans/T/E/2, diff. parities => cis/C/Z/1 */ S_CHAR sb_parity[MAX_NUM_STEREO_BONDS]; AT_NUMB sn_orig_at_num[MAX_NUM_STEREO_BONDS]; /* orig. at number of sn_ord[] neighbors */ } inp_ATOM_STEREO; #define FIX_STEREO_BOND_ORDER 0 /* 1=> fix stereobonds; treat metal as non-metal if it is stereogenic or has a stereobond */ #define METAL_FREE_CHARGE_VAL 1 /* 1=> allow free changing charges/valences of metals; initial bond order=0 or 1 */ #define ALLOW_METAL_BOND_ZERO 1 /* 1=> allow zero flow (bobd order) to metals */ #if ( ALLOW_METAL_BOND_ZERO == 1 ) /* INIT_METAL_BOND_ZERO=1 => INIT_METAL_BOND_FLOW=0 */ #define INIT_METAL_BOND_ZERO 0 /* 1=> initialize zero order bond to metals */ #define INIT_METAL_BOND_FLOW 1 /* 1=> init flow=1, 0 => init. flow = 0 */ #else #define INIT_METAL_BOND_ZERO 0 #define INIT_METAL_BOND_FLOW 0 /* always 0 */ #endif #define I2A_FLAG_FIXEDH 0x0001 #define I2A_FLAG_RECMET 0x0002 #define EL_NUMBER_H 1 #define ATYPE_H 1 #define ATYPE_Na 2 #define ATYPE_Mg 3 #define ATYPE_B 4 #define ATYPE_C 5 #define ATYPE_N 6 #define ATYPE_O 7 #define ATYPE_Cl 8 /* first bonds valence for charge = c is cValence[0][c+VAL_BASE]; VAL_MIN_CHARGE <= c <= VAL_MAX_CHARGE */ /* second bonds valence for charge = c is cValence[1][c+VAL_BASE]; VAL_MIN_CHARGE <= c <= VAL_MAX_CHARGE */ /* total number of valences is 2 = VAL_NUMBER */ /* neutral bond valence orders are cValence[0][VAL_NEUTR_ORDER], cValence[1][VAL_NEUTR_ORDER] */ #define VAL_BASE ( 1) #define VAL_MIN_CHARGE (-1) #define VAL_MAX_CHARGE ( 1) #define VAL_NUMBER ( 2) #define VAL_NEUTR_ORDER (VAL_MAX_CHARGE-VAL_MIN_CHARGE+1) #define VAL_LENGTH (VAL_NEUTR_ORDER+1) #define VAL_NEGAT_CHARGE 0 #define VAL_NEUTR_CHARGE 1 #define VAL_POSIT_CHARGE 2 typedef struct tagAtomIonPrperies { /* char cValence[VAL_NUMBER][VAL_LENGTH]; */ /* ordering numbers of minimal valence, 0-based */ char cDoNotAddH; /* InChI does not add H to this element */ char cMetal; /* the element is a metal */ char cNumBondsToMetal; /* number of bonds to metal */ char cInitFlowToMetal; /* sum of init flow to metal atoms */ char cInitValenceToMetal; /* sum of init adjusted bond orders to metal atoms */ char cInitOrigValenceToMetal; /* sum of init bond orders to metal atoms */ char cMaxFlowToMetal; /* max total edge flow to metal atoms */ char cInitFreeValences; /* number of 'dots' to connect; charges are marked separately */ S_CHAR cInitCharge; /* initial charge on the atom (not included in ChargeStruct */ char cNumValenceElectrons; char cPeriodicRowNumber; char cMinRingSize; /* min ring size for atoms that have 2 bonds only */ U_CHAR cPeriodicNumber; /* number in Periodic Table of elements */ S_CHAR cnListIndex; /* (index in the cnList) + 1; 0 => none */ int nCMinusGroupEdge; /* (index of the edge to the atom's (-) group) + 1 */ int nCPlusGroupEdge; /* (index of the edge to the atom's (+) group) + 1 */ int nMetalGroupEdge; /* index of the edge to the atom's M-group + 1 */ int nTautGroupEdge; /* index of the edge from the atom to the t-group + 1 */ } VAL_AT; /******************************************************************************************************/ #define INI_NUM_TCGROUPS 16 #define INC_NUM_TCGROUPS 16 typedef enum tagTgRestoreFlags { TGRF_MINUS_FIRST = 1 } TGRF; typedef struct tagTCGroup { int type; /* group type */ int ord_num; /* ordering number within the type, typically t-group number */ int num_edges; /* charge group specific */ int st_cap; int st_flow; int edges_cap; int edges_flow; int nVertexNumber; /* group vertex number; 0 = unassigned */ int nForwardEdge; /* edge index: from c-group to central Y-connecting vertex or from supergroup to (+/-) vertex; 0 => unassigned */ int nBackwardEdge; /* edge index: from central Y-connecting vertex to supergroup; 0 => unassigned */ /* tautomeric group specific */ short tg_num_H; /* number of H in a tautomeric group */ short tg_num_Minus; /* negative charge on t-group */ Vertex tg_set_Minus; /* the vertex+1 that has to have (-) */ short tg_RestoreFlags; /* Set (-) to first memberst of a t-group (usually, N) */ } TC_GROUP; typedef enum tagTCGroupTypes { TCG_None = -1, /* so far only ord=0 is used */ /* group type ord */ TCG_Plus0 = 0, /* BNS_VT_C_POS 0 */ TCG_Plus1, /* BNS_VT_C_POS 1 */ TCG_Minus0, /* BNS_VT_C_NEG 0 */ TCG_Minus1, /* BNS_VT_C_NEG 1 */ TCG_Plus_C0, /* BNS_VT_C_POS_C 0 */ TCG_Plus_C1, /* BNS_VT_C_POS_C 1 */ TCG_Minus_C0, /* BNS_VT_C_NEG_C 0 */ TCG_Minus_C1, /* BNS_VT_C_NEG_C 1 */ TCG_Plus_M0, /* BNS_VT_C_POS_M 0 */ TCG_Plus_M1, /* BNS_VT_C_POS_M 1 */ TCG_Minus_M0, /* BNS_VT_C_NEG_M 0 */ TCG_Minus_M1, /* BNS_VT_C_NEG_M 1 */ TCG_MeFlower0, /* BNS_VT_M_GROUP 0 */ /* base */ TCG_MeFlower1, /* BNS_VT_M_GROUP 1 */ TCG_MeFlower2, /* BNS_VT_M_GROUP 2 */ TCG_MeFlower3, /* BNS_VT_M_GROUP 3 */ TCG_Plus, /* BNS_VT_C_POS_ALL 0 */ TCG_Minus, /* BNS_VT_C_NEG_ALL 0 */ NUM_TCGROUP_TYPES /* number of group types */ }TCGR_TYPE; typedef struct tagAllTCGroups { TC_GROUP *pTCG; int num_tc_groups; /* number of charge groups and metal-flower vertices */ int max_tc_groups; /* number of allocated of pTCG[] elements */ int nGroup[NUM_TCGROUP_TYPES]; /* tagTCGroupTypes */ int nVertices; /* total number of vertices */ int nEdges; /* total number of edges */ int nAddIedges; /* additional increase of number of iedges for edge switching to another group */ int num_atoms; /* number of atoms */ int num_bonds; /* number of bonds */ int num_tgroups; /* number t-groups */ int num_tgroup_edges; /* number of edges to t-groups */ /* charges */ int tgroup_charge; /* total charge of all t-groups */ int charge_on_atoms; /* charge permanently sitting on atoms */ int added_charge; /* charge added to the c-groups */ int total_charge; /* total charge of the component */ int total_electrons; /* total number of electrons on all atoms */ int total_electrons_metals; /* total number of electrons on unbonded metals */ int num_metal_atoms; /* number of metal atoms */ int num_metal_bonds; /* number of atom-metal bonds */ /* excess_charge = total_charge - added_charge - tgroup_charge: add to metals etc. */ int nEdge4charge; /* edge used to add charges; neighbor1=supercharge, another = (+/-) vertex */ int nEdgePlus; /* edge to (+) supergroup; 0 means none */ int nEdgeMinus; /* edge to (-) supergroup; 0 means none */ int iComponent; /* component number */ int iAtNoOffset; /* first atom number -- always 0 for now */ } ALL_TC_GROUPS; /**************************************/ #define EDGE_LIST_CLEAR (-1) #define EDGE_LIST_FREE (-2) typedef struct tagEdgeList { int num_alloc; int num_edges; EdgeIndex *pnEdges; } EDGE_LIST; /**************************************/ #define BOND_MARK_STEREO 0x10 #define BOND_TYPE_STEREO (BOND_TYPE_SINGLE | BOND_MARK_STEREO) /* local */ #define RESET_EDGE_FORBIDDEN_MASK 0 #define TREAT_ATOM_AS_METAL 99 /************************************************************************************/ typedef struct tagChargeValence { int nValence; int nCharge; int nValenceOrderingNumber; } CHARGE_VAL; #define MY_CONST const /*************************************************************************************/ typedef struct tagChargeChangeCandidate { Vertex iat; char num_bonds; char chem_valence; char cMetal; char cNumBondsToMetal; char cNumValenceElectrons; char cPeriodicRowNumber; char cNumChargeStates; U_CHAR el_number; } CC_CAND; typedef struct tagOneComponentRemovedAndExchangeableH { NUM_H nNumRemovedProtons; NUM_H nNumRemovedIsotopicH[NUM_H_ISOTOPES]; /* isotopic H that may be exchanged and considered randomly distributed, including removed protons */ } COMPONENT_REM_PROTONS; typedef struct tagRemovedAndExchangeableH { /* totals for Mobile-H layer */ NUM_H nNumRemovedProtons; NUM_H nNumRemovedIsotopicH[NUM_H_ISOTOPES]; /* isotopic H that may be exchanged and considered randomly distributed, including removed protons */ /* for individual components from comparing Fixed-H vs Mobile-H formulas; NULL if not available */ COMPONENT_REM_PROTONS *pNumProtons; } REM_PROTONS; typedef struct tagInputInChI { INChI *pInpInChI[INCHI_NUM][TAUT_NUM]; int nNumComponents[INCHI_NUM][TAUT_NUM]; REM_PROTONS nNumProtons[INCHI_NUM][TAUT_NUM]; int s[INCHI_NUM][TAUT_NUM][2]; /* s[0=non-iso, 1=iso] = 0,1,2,3 <= regular /s; -1=> "/s" (empty) */ long num_inp; inp_ATOM *atom; /* the whole restored structure made out of all components */ int num_atoms; /* number of atoms including explicit H */ int num_explicit_H; /* number of explicit H in the atom */ INCHI_MODE CompareInchiFlags[INCHI_NUM][TAUT_NUM]; } InpInChI; typedef struct tagStructFromInChI { /* InChI component -> Structure result */ inp_ATOM *at; /* length = num_atoms + num_deleted_H, zero pint struct for BNS->struct conversion */ inp_ATOM_STEREO *st; /* additional stereo that exists only in Mobile-H layer */ inp_ATOM *at2; /* length = num_atoms + num_deleted_H, the conversion result */ /* information from InChI only */ T_GROUP_INFO ti; /* from original InChI[0] if Mobile-H from the beginning or later from InChI[1] if Fixed-H */ AT_NUMB *endpoint; /* from original InChI[1] in case of Fixed-H only */ S_CHAR *fixed_H; /* from original InChI[0] in case of Fixed-H only */ XYZ_COORD *pXYZ; int num_atoms; int num_deleted_H; /* if requested and Fixed-H InChI is available */ int nNumRemovedProtonsMobHInChI; /* number of protons removed from Mobile-H struct in original InChI */ S_CHAR charge; char bIsotopic; /* InChI -> Structure conversion parms and intermediate data */ BN_STRUCT *pBNS; BN_DATA *pBD; ICHICONST SRM *pSrm; /* InChI layer to reverse */ char bMobileH; char iINCHI; char bFixedHExists; /* fixed-H InChI exists or not */ /* InChI -> Struct component -> Full InChI result (both disconnected and connected if exist) */ REV_INCHI RevInChI; int nRemovedProtonsByNormFromRevrs; /* number of H(+) removed by normalization after Struct Restore and before Add/Remove Protons */ int nNumRemovedProtonsByRevrs; /* number of H(+) removed by the reconstruction, before Add/Remove Protons, only from TAUT_YES */ int bExtract; /* for debugging */ /* single component InChI calculation */ INChI *pOneINChI[TAUT_NUM]; /* InChI of restored structure */ INChI_Aux *pOneINChI_Aux[TAUT_NUM]; INP_ATOM_DATA *pOne_norm_data[TAUT_NUM]; /* normalized restored structure */ S_CHAR *pOne_fixed_H; /* !!! from normalized restored structure in case of Fixed-H only */ T_GROUP_INFO One_ti; /* t-groups of normalized canonicalized restored structure */ int nOneINChI_bMobileH; /* type of restored structure InChI */ int nNumRemovedProtons; /* =0 for Fixed-H, = num. removed protons in case of Mobile-H InChI */ /* in case of Fixed-H processing see pStruct->One_ti.tni.nNumRemovedProtons */ AT_NUMB *nAtno2Canon[TAUT_NUM]; /* nAtno2Canon[restored_at_no][*] = (atom canon number in restored struct)-1*/ AT_NUMB *nCanon2Atno[TAUT_NUM]; /* nCanon2Atno[(atom canon number in restored struct)-1][*] = restored_at_no; */ int nError; /* other parms */ char iInchiRec; /* index in the original InChI array */ char iMobileH; /* index in the original InChI array */ char bDeleted; /* InChI component marked as Deleted, means a proton in Mobile-H layer */ /* struct. ordering number "Structure: nnn" if present */ long num_inp_actual; /* utility data */ BFS_Q *pbfsq; VAL_AT *pVA; int nLink; /* same as in INChI */ int bPostProcessed; /* recalculate after add/remove protons */ /* TAUT_YES layer charges */ int nChargeRevrs; /* component charge of the reconstructed structure, TAUT_YES layer */ int nChargeInChI; /* component charge from the original InChI, TAUT_YES layer */ } StrFromINChI; #define EL_TYPE_O 0x0001 #define EL_TYPE_S 0x0002 #define EL_TYPE_N 0x0004 #define EL_TYPE_P 0x0008 #define EL_TYPE_C 0x0010 #define EL_TYPE_X 0x0020 /* any not metal */ #define EL_TYPE_MASK 0x003f #define EL_TYPE_OSt 0x0100 /* terminal -OH, -O(-), -SH, -S(-), ... from fix_special_bonds(...) */ #define EL_TYPE_PT 0x0200 /* may be a tautomeric endpoint */ /* the atom to which the node is attached has number 1; added atoms have numbers 2,3,... */ #define MAX_CN_VAL 3 typedef struct tagVertCapFlow { S_SHORT type; S_CHAR cap; S_CHAR flow; S_CHAR valence; } VCF; typedef struct tagEdgeCapFlow { S_SHORT neigh; S_CHAR cap; S_CHAR bForbiddenEdge; S_CHAR flow; } ECF; typedef struct tagChargeNodes { VCF v; ECF e[MAX_CN_VAL]; } C_NODE; #define cn_bits_N 1 /* Neutral: charge = 0 */ #define cn_bits_P 2 /* Plus 1: charge = +1 */ #define cn_bits_M 4 /* Minus 1: charge = -1 */ #define cn_bits_shift 3 #define MAX_NUM_CN_BITS 4 #define MAKE_CN_BITS(A, B, C, D ) (( (( ((D) << cn_bits_shift | (C)) << cn_bits_shift ) | (B)) << cn_bits_shift ) | (A)) #define cn_bits_PNPN MAKE_CN_BITS(cn_bits_P, cn_bits_N, cn_bits_P, cn_bits_N) #define cn_bits_NPNP MAKE_CN_BITS(cn_bits_N, cn_bits_P, cn_bits_N, cn_bits_P) #define cn_bits_NPN MAKE_CN_BITS(cn_bits_N, cn_bits_P, cn_bits_N, 0) #define cn_bits_PNP MAKE_CN_BITS(cn_bits_P, cn_bits_N, cn_bits_P, 0) #define cn_bits_MNP MAKE_CN_BITS(cn_bits_M, cn_bits_N, cn_bits_P, 0) #define cn_bits_PNM MAKE_CN_BITS(cn_bits_P, cn_bits_N, cn_bits_M, 0) #define cn_bits_EN MAKE_CN_BITS(cn_bits_P | cn_bits_M, cn_bits_N, 0, 0) #define cn_bits_NMN MAKE_CN_BITS(cn_bits_N, cn_bits_M, cn_bits_N, 0) #define cn_bits_NE MAKE_CN_BITS(cn_bits_N, cn_bits_P | cn_bits_M, 0, 0) #define cn_bits_NEN MAKE_CN_BITS(cn_bits_N, cn_bits_M | cn_bits_N, cn_bits_N, 0) #define cn_bits_NP MAKE_CN_BITS(cn_bits_N, cn_bits_P, 0, 0) #define cn_bits_PN MAKE_CN_BITS(cn_bits_P, cn_bits_N, 0, 0) #define cn_bits_NM MAKE_CN_BITS(cn_bits_N, cn_bits_M, 0, 0) #define cn_bits_MN MAKE_CN_BITS(cn_bits_M, cn_bits_N, 0, 0) #define cn_bits_P_ MAKE_CN_BITS(cn_bits_P, 0, 0, 0) #define cn_bits_M_ MAKE_CN_BITS(cn_bits_M, 0, 0, 0) #define cn_bits_N_ MAKE_CN_BITS(cn_bits_N, 0, 0, 0) #define cn_bits_Me (-1) #define cnListIndexMe (17) /* index of {cnMe, cn_bits_Me,... } element of cnList[] */ extern int cnListNumEl; /* number of elements in cnList[] */ typedef struct tagChargeNodeList { MY_CONST C_NODE *pCN; int bits; int nInitialCharge; int len; } CN_LIST; extern MY_CONST CN_LIST cnList[]; /************************ fixed H comparison ******************************************************/ #define MAX_DIFF_FIXH 256 #define MAX_DIFF_MOBH 256 typedef struct tagAtomsCmpTwoFixedH { AT_NUMB endptInChI; AT_NUMB endptRevrs; AT_NUMB atomNumber; U_CHAR nValElectr; U_CHAR nPeriodNum; S_CHAR nFixHInChI; S_CHAR nFixHRevrs; S_CHAR nMobHInChI; S_CHAR nMobHRevrs; S_CHAR nNumHRevrs; S_CHAR nAtChargeRevrs; S_CHAR nValue; /* flag(s) */ } CMP2FHATOMS; typedef struct tagStructCmpTwoFixedH { CMP2FHATOMS c2at[MAX_DIFF_FIXH]; short len_c2at; short nNumRemHInChI; short nNumRemHRevrs; short nNumTgInChI; short nNumTgRevrs; short nNumEndpInChI; short nNumEndpRevrs; short nNumTgDiffMinus; /* number of would-be-identical t-groups that have different number of (-) */ short nNumTgDiffH; /* number of would-be-identical t-groups that have different number of H */ short nNumTgMInChI; /* number of (-) in orig. InChI t-groups */ short nNumTgHInChI; /* number of H in orig. InChI t-groups */ short nNumTgMRevrs; /* number of (-) in reversed structure t-groups */ short nNumTgHRevrs; /* number of H in reversed structure t-groups */ S_CHAR nChargeFixHInChI; S_CHAR nChargeMobHInChI; S_CHAR nChargeFixHRevrs; S_CHAR nChargeMobHRevrs; S_CHAR nChargeFixHRevrsNonMetal; /* charge does not include charges on metals */ S_CHAR nChargeMobHRevrsNonMetal; /* charge does not include charges on metals */ char bFixedHLayerExistsRevrs; char bHasDifference; U_CHAR nNumDiffMobH; } CMP2FHINCHI; /************************ Mobile H comparison *********************************************/ typedef struct tagAtomsCmpTwoMobileH { AT_NUMB endptInChI; AT_NUMB endptRevrs; AT_NUMB atomNumber; U_CHAR nValElectr; U_CHAR nPeriodNum; S_CHAR nMobHInChI; /* number of H on the atom in the orig. InChI */ S_CHAR nMobHRevrs; /* number of H on the atom in InChI from the reconstructed structure */ S_CHAR nNumHRevrs; /* number of H on the atom in the being reconstructed structure */ S_CHAR nAtChargeRevrs; S_CHAR nValue; /* flag(s) */ } CMP2MHATOMS; typedef struct tagStructCmpTwoMobileH { CMP2MHATOMS c2at[MAX_DIFF_FIXH]; short len_c2at; short nNumRemHInChI; short nNumRemHRevrs; short nNumTgInChI; short nNumTgRevrs; short nNumEndpInChI; short nNumEndpRevrs; short nNumTgDiffMinus; /* number of would-be-identical t-groups that have different number of (-) */ short nNumTgDiffH; /* number of would-be-identical t-groups that have different number of H */ short nNumTgMInChI; /* number of (-) in orig. InChI t-groups */ short nNumTgHInChI; /* number of H in orig. InChI t-groups */ short nNumTgOInChI; /* number of tautomeric O,S,Se in orig. InChI t-groups */ short nNumTgNInChI; /* number of tautomeric N in orig. InChI t-groups */ short nNumTgMRevrs; /* number of (-) in reversed structure t-groups */ short nNumTgHRevrs; /* number of H in reversed structure t-groups */ short nNumTgORevrs; /* number of tautomeric O,S,Se in reversed structure t-groups */ short nNumTgNRevrs; /* number of tautomeric N in reversed structure t-groups */ short nNumTgOMinusRevrs; /* number of -O(-) on endpoints found in restored structure */ short nNumTgOHRevrs; /* number of -OH on endpoints found in restored structure */ short nNumTgDBORevrs; /* number of =O on endpoints found in restored structure */ short nNumTgNMinusRevrs; /* number of -N(-)- on endpoints found in restored structure */ short nNumTgNHMinusRevrs; /* number of -NH(-) on endpoints found in restored structure */ short nNumTgNHRevrs; /* number of -NH- on endpoints found in restored structure */ short nNumTgNH2Revrs; /* number of -NH2 on endpoints found in restored structure */ short nNumTgDBNHRevrs; /* number of =NH on endpoints found in restored structure */ short nNumTgDBNMinusRevrs; /* number of =N(-) on endpoints found in restored structure */ short nNumTgDBNRevrs; /* number of =N- on endpoints found in restored structure */ short nNumTgOMinusInChI; /* number of -O(-) on endpoints according to original InChI */ short nNumTgOHInChI; /* number of -OH on endpoints according to original InChI */ short nNumTgDBOInChI; /* number of =O on endpoints according to original InChI */ short nNumTgNMinusInChI; /* number of -N(-)- on endpoints according to original InChI */ short nNumTgNHMinusInChI; /* number of -NH(-) on endpoints according to original InChI */ short nNumTgNHInChI; /* number of -NH- on endpoints according to original InChI */ short nNumTgNH2InChI; /* number of -NH2 on endpoints according to original InChI */ short nNumTgDBNHInChI; /* number of =NH on endpoints according to original InChI */ short nNumTgDBNMinusInChI; /* number of =N(-) on endpoints according to original InChI */ short nNumTgDBNInChI; /* number of =N- on endpoints according to original InChI */ S_CHAR nChargeMobHInChI; S_CHAR nChargeMobHRevrs; S_CHAR nChargeMobHRevrsNonMetal; /* charge does not include charges on metals; later add ion pairs rejection */ char bFixedHLayerExistsRevrs; char bHasDifference; U_CHAR nNumDiffMobH; } CMP2MHINCHI; #ifndef INCHI_ALL_CPP #ifdef __cplusplus extern "C" { #endif #endif int OneInChI2Atom( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, const char *szCurHdr, long num_inp, StrFromINChI *pStruct, int iComponent, int iAtNoOffset, int bHasSomeFixedH, INChI *pInChI[]); int get_sp_element_type( int nPeriodicNumber, int *nRow ); int get_bonds_valences( int nPeriodicNum, int bonds_valence, int num_H, VAL_AT *pVA ); /* local prototypes */ int AddExplicitDeletedH( inp_ATOM *at, int jv, int num_at, int *iDeletedH, int *iH, int nNumDeletedH, int bTwoStereo ); int bFindCumuleneChain( inp_ATOM *at, AT_NUMB i1, AT_NUMB i2, AT_NUMB nCumulene[], int nMaxLen ); int set_bond_type( inp_ATOM *at, AT_NUMB i1, AT_NUMB i2, int bType ); int set_cumulene_0D_parity( inp_ATOM *at, inp_ATOM_STEREO *st, int num_at, int idelH1, int i1, int i2, int idelH2, int parity, int len ); int set_atom_0D_parity( inp_ATOM *at, inp_ATOM_STEREO *st, int num_at, int num_deleted_H, int i1, int parity ); int GetTgroupInfoFromInChI( T_GROUP_INFO *ti, inp_ATOM *at, AT_NUMB *endpoint, INChI *pInChI ); int FillOutpStructEndpointFromInChI( INChI *pInChI, AT_NUMB **pEndpoint ); int SetStereoBondTypeFor0DParity( inp_ATOM *at, int i1, int m1 ); int SetStereoBondTypesFrom0DStereo( StrFromINChI *pStruct, INChI *pInChI); void CopyAt2St( inp_ATOM *at, inp_ATOM_STEREO * st, int num_atoms ); void CopySt2At( inp_ATOM *at, inp_ATOM_STEREO * st, int num_atoms ); int RestoreAtomConnectionsSetStereo( StrFromINChI *pStruct, int iComponent, int iAtNoOffset, INChI *pInChI, INChI *pInChIMobH); int RestoreAtomMakeBNS( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, StrFromINChI *pStruct, int iComponent, int iAtNoOffset, INChI *pInChI[], const char *szCurHdr, long num_inp, int bHasSomeFixedH ); int nAddSuperCGroups( ALL_TC_GROUPS *pTCGroups ); int AddCGroups2TCGBnStruct( BN_STRUCT *pBNS, StrFromINChI *pStruct, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int nMaxAddEdges ); int AddTGroups2TCGBnStruct( BN_STRUCT *pBNS, StrFromINChI *pStruct, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int nMaxAddEdges ); BN_STRUCT* AllocateAndInitTCGBnStruct( StrFromINChI *pStruct, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int nMaxAddAtoms, int nMaxAddEdges, int max_altp, int *pNum_changed_bonds ); int nCountBnsSizes( inp_ATOM *at, int num_at, int nAddEdges2eachAtom, int nAddVertices, T_GROUP_INFO *ti, VAL_AT *pVA, ICHICONST SRM *pSrm, ALL_TC_GROUPS *pTCGroups ); int GetAtomRestoreInfo( inp_ATOM *atom, int iat, VAL_AT *pVArray, ICHICONST SRM *pSrm, int bMobileH, AT_NUMB *endpoint ); int AddEdgeFlow( int edge_cap, int edge_flow, BNS_EDGE *e01, BNS_VERTEX *pv0 /*src*/, BNS_VERTEX *pv1/*dest*/, int *tot_st_cap, int *tot_st_flow ); void SetEdgeCapFlow( BNS_EDGE *e, int edge_cap, int edge_flow ); void AddStCapFlow( BNS_VERTEX *vert_ficpoint, int *tot_st_flow, int *tot_st_cap, int cap, int flow ); void SetStCapFlow( BNS_VERTEX *vert_ficpoint, int *tot_st_flow, int *tot_st_cap, int cap, int flow ); int ConnectSuperCGroup( int nTCG_Plus, int nAddGroups[], int num_add, int *pcur_num_vertices, int *pcur_num_edges, int *tot_st_cap, int *tot_st_flow, BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups ); int ConnectTwoVertices( BNS_VERTEX *p1, BNS_VERTEX *p2, BNS_EDGE *e, BN_STRUCT *pBNS, int bClearEdge ); int nTautEndpointEdgeCap( inp_ATOM *at, VAL_AT *pVA, int i ); /* int GetAtomBondFlow( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int ineigh ); void GetAtomStCapFlow( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int *pCap, int *pFlow ); int GetAtomToMCGroupInitEdgeCapFlow( EdgeFlow *nEdgeCap, EdgeFlow *nEdgeFlow, ICHICONST SRM *pSrm, inp_ATOM *at, VAL_AT *pVA, int iat ); void GetAtomToMetalInitEdgeCapFlow( EdgeFlow *nEdgeCap, EdgeFlow *nEdgeFlow ); */ int AtomStcapStflow( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int *pnStcap, int *pnStflow, EdgeFlow *pnMGroupEdgeCap, EdgeFlow *pnMGroupEdgeFlow ); int BondFlowMaxcapMinorder( inp_ATOM *atom, VAL_AT *pVA, ICHICONST SRM *pSrm, int iat, int ineigh, int *pnMaxcap, int *pnMinorder, int *pbNeedsFlower ); int clean_charge_val( CHARGE_VAL *pChargeVal, int len, inp_ATOM *atom, VAL_AT *pVA, int iat, int bIsMetal, int bMobileH, AT_NUMB *endpoint ); int ReallocTCGroups( ALL_TC_GROUPS *pTCGroups, int nAdd ); int RegisterTCGroup( ALL_TC_GROUPS *pTCGroups, int nGroupType, int nGroupOrdNum, int nVertexCap, int nVertexFlow, int nEdgeCap, int nEdgeFlow, int nNumEdges); int CopyBnsToAtom( StrFromINChI *pStruct, BN_STRUCT *pBNS, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int bAllowZeroBondOrder ); int CheckBnsConsistency( StrFromINChI *pStruct, BN_STRUCT *pBNS, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int bNoRad ); int RunBnsRestore1( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, INChI *pInChI[], long num_inp, int bHasSomeFixedH); int RunBnsRestoreOnce( BN_STRUCT *pBNS, BN_DATA *pBD, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups ); int nNumEdgesToCnVertex( MY_CONST C_NODE *pCN, int len, int v ); int ConnectMetalFlower( int *pcur_num_vertices, int *pcur_num_edges, int *tot_st_cap, int *tot_st_flow, ICHICONST SRM *pSrm, BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups ); int AddRadicalToMetal( int *tot_st_cap, int *tot_st_flow, ICHICONST SRM *pSrm, BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups ); int bMayBeACationInMobileHLayer( inp_ATOM *at, VAL_AT *pVA, int iat, int bMobileH ); int MakeOneInChIOutOfStrFromINChI( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, StrFromINChI *pStruct, inp_ATOM *at2, inp_ATOM *at3, ALL_TC_GROUPS *pTCGroups ); void IncrZeroBondsAndClearEndpts(inp_ATOM *at, int num_at, int iComponent); void IncrZeroBonds(inp_ATOM *at, int num_at, int iComponent ); void ClearEndpts(inp_ATOM *at, int num_at ); int DisplayRestoredComponent( StrFromINChI *pStruct, int iComponent, int iAtNoOffset, INChI *pInChI, const char *szCurHdr ); int cmp_charge_val( const void *a1, const void *a2 ); int EvaluateChargeChanges( BN_STRUCT *pBNS, VAL_AT *pVA, int *pnDeltaH, int *pnDeltaCharge, int *pnNumVisitedAtoms ); int RunBnsTestOnce( BN_STRUCT *pBNS, BN_DATA *pBD, VAL_AT *pVA, Vertex *pvFirst, Vertex *pvLast, int *pPathLen, int *pnDeltaH, int *pnDeltaCharge, int *pnNumVisitedAtoms ); int comp_cc_cand( const void *a1, const void *a2 ); int MoveRadToAtomsAddCharges( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int forbidden_mask ); void RemoveForbiddenBondFlowBits( BN_STRUCT *pBNS, int forbidden_edge_mask_int ); int PlusFromDB_N_DB_O_to_Metal(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int AdjustTgroupsToForbiddenEdges2( BN_STRUCT *pBNS, inp_ATOM *at, VAL_AT *pVA, int num_atoms, int forbidden_mask ); int AllocEdgeList( EDGE_LIST *pEdges, int nLen ); int AddToEdgeList( EDGE_LIST *pEdges, int iedge, int nAddLen ); int RemoveFromEdgeListByIndex( EDGE_LIST *pEdges, int index ); int RemoveFromEdgeListByValue( EDGE_LIST *pEdges, int iedge ); int FindInEdgeList( EDGE_LIST *pEdges, int iedge ); int AllocBfsQueue( BFS_Q *pQ, int num_at, int min_ring_size ); void RemoveForbiddenEdgeMask( BN_STRUCT *pBNS, EDGE_LIST *pEdges, int forbidden_edge_mask ); void SetForbiddenEdgeMask( BN_STRUCT *pBNS, EDGE_LIST *pEdges, int forbidden_edge_mask ); int ForbidCarbonChargeEdges( BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups, EDGE_LIST *pCarbonChargeEdges, int forbidden_edge_mask ); int ForbidMetalCarbonEdges( BN_STRUCT *pBNS, inp_ATOM *at, int num_at, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, EDGE_LIST *pMetalCarbonEdges, int forbidden_edge_mask ); int ForbidNintrogenPlus2BondsInSmallRings( BN_STRUCT *pBNS, inp_ATOM *at, int num_at, VAL_AT *pVA, int min_ring_size, ALL_TC_GROUPS *pTCGroups, EDGE_LIST *pNplus2BondsEdges, int forbidden_edge_mask ); int RearrangePlusMinusEdgesFlow( BN_STRUCT *pBNS, BN_DATA *pBD, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int forbidden_edge_mask ); int IncrementZeroOrderBondsToHeteroat( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int MoveChargeFromHeteroatomsToMetals( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int EliminateChargeSeparationOnHeteroatoms( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask); int MovePlusFromS2DiaminoCarbon( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int RestoreCyanoGroup( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int RestoreIsoCyanoGroup( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int RestoreNNNgroup( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int FixMetal_Nminus_Ominus( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int EliminateNitrogen5Val3Bonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int Convert_SIV_to_SVI(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int MoveMobileHToAvoidFixedBonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int RemoveRadFromMobileHEndpoint(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int RemoveRadFromMobileHEndpointFixH(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int MoveChargeToMakeCenerpoints(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int CheckAndRefixStereobonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int MoveChargeToRemoveCenerpoints(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int MakeSingleBondsMetal2ChargedHeteroat(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int SaltBondsToCoordBonds(BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask); int FixLessHydrogenInFormula( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *atf, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask ); int FixMoreHydrogenInFormula( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *atf, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask ); int FixAddProtonForADP( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *atf, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, ICR *picr, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask ); int ConnectDisconnectedH( inp_ATOM *at, int num_atoms, int num_deleted_H ); int DisconnectedConnectedH( inp_ATOM *at, int num_atoms, int num_deleted_H ); int MakeInChIOutOfStrFromINChI2( ICHICONST INPUT_PARMS *ip_inp, STRUCT_DATA *sd_inp, StrFromINChI *pStruct, int iComponent, int iAtNoOffset, long num_inp ); int GetChargeFlowerUpperEdge( BN_STRUCT *pBNS, VAL_AT *pVA, int nChargeEdge ); int get_pVA_atom_type( VAL_AT *pVA, inp_ATOM *at, int iat, int bond_type ); int NormalizeAndCompare(ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, INChI *pInChI[], long num_inp, int bHasSomeFixedH, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask); /* call InChI normalization only */ int NormalizeStructure( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, inp_ATOM *at_norm, inp_ATOM *at_fixed_bonds_out, T_GROUP_INFO *t_group_info ); /* create one InChI */ int MakeOneInChIOutOfStrFromINChI2( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, T_GROUP_INFO **t_group_info, inp_ATOM **at_norm, inp_ATOM **at_prep ); /* fixed-H */ int FillOutExtraFixedHDataRestr( StrFromINChI *pStruct ); int FillOutExtraFixedHDataInChI( StrFromINChI *pStruct, INChI *pInChI[] ); int FixFixedHRestoredStructure(ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, T_GROUP_INFO **ti, inp_ATOM **at_norm, inp_ATOM **at_prep, INChI *pInChI[], long num_inp, int bHasSomeFixedH, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask); int FixRemoveExtraTautEndpoints( BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *atf, inp_ATOM *atn, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, ICR *picr, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask ); int FillOutCMP2FHINCHI( StrFromINChI *pStruct, inp_ATOM *at2, VAL_AT *pVA, INChI *pInChI[], CMP2FHINCHI *pc2i ); int FillOutCMP2MHINCHI( StrFromINChI *pStruct, ALL_TC_GROUPS *pTCGroups, inp_ATOM *at2, VAL_AT *pVA, INChI *pInChI[], CMP2MHINCHI *pc2i ); int bHas_N_V( inp_ATOM *at2, int num_atoms ); int GetPlusMinusVertex( BN_STRUCT *pBNS, ALL_TC_GROUPS *pTCGroups, int bCheckForbiddenPlus, int bCheckForbiddenMinus ); int FixMobileHRestoredStructure(ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, T_GROUP_INFO **ppt_group_info, inp_ATOM **ppat_norm, inp_ATOM **ppat_prep, INChI *pInChI[], long num_inp, int bHasSomeFixedH, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask); int FixRestoredStructureStereo( INCHI_MODE cmpInChI, ICR *icr, INCHI_MODE cmpInChI2, ICR *icr2, ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, BN_STRUCT *pBNS, BN_DATA *pBD, StrFromINChI *pStruct, inp_ATOM *at, inp_ATOM *at2, inp_ATOM *at3, VAL_AT *pVA, ALL_TC_GROUPS *pTCGroups, T_GROUP_INFO **ppt_group_info, inp_ATOM **ppat_norm, inp_ATOM **ppat_prep, INChI *pInChI[], long num_inp, int *pnNumRunBNS, int *pnTotalDelta, int forbidden_edge_mask, int forbidden_stereo_edge_mask); int AddRemProtonsInRestrStruct( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, int bHasSomeFixedH, StrFromINChI *pStruct, int num_components, StrFromINChI *pStructR, int num_componentsR, NUM_H *pProtonBalance, int *recmet_change_balance ); int AllInchiToStructure( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, char *szCurHdr, ICHICONST SRM *pSrm, int bReqNonTaut, StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput ); int AddProtonAndIsoHBalanceToMobHStruct( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, int bHasSomeFixedH, char *szCurHdr, StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput); int InChI2Atom( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, const char *szCurHdr, long num_inp, StrFromINChI *pStruct, int iComponent, int iAtNoOffset, int bI2A_Flag, int bHasSomeFixedH, InpInChI *pOneInput); int MarkDisconectedIdenticalToReconnected ( InpInChI *pOneInput ); void RemoveFixHInChIIdentical2MobH( InpInChI *pOneInput ); void SetUpSrm( SRM *pSrm ); void FreeInpInChI( InpInChI *pOneInput ); void FreeStrFromINChI( StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], int nNumComponents[INCHI_NUM][TAUT_NUM] ); int OldPrintCompareOneOrigInchiToRevInChI(StrFromINChI *pStruct, INChI *pInChI[TAUT_NUM], int bMobileH, int iComponent, long num_inp, char *szCurHdr); int CompareOneOrigInchiToRevInChI(StrFromINChI *pStruct, INChI *pInChI[TAUT_NUM], int bMobileH, int iComponent, long num_inp, char *szCurHdr, COMPONENT_REM_PROTONS *nCurRemovedProtons, INCHI_MODE CompareInchiFlags[]); int CompareTwoPairsOfInChI( INChI *pInChI1[TAUT_NUM], INChI *pInChI2[TAUT_NUM], int bMobileH, INCHI_MODE CompareInchiFlags[] ); INCHI_MODE CompareReversedINChI3( INChI *i1 /* InChI from reversed struct */, INChI *i2 /* input InChI */, INChI_Aux *a1, INChI_Aux *a2, int *err ); INCHI_MODE CompareReversedStereoINChI3( INChI_Stereo *s1/* InChI from reversed struct */, INChI_Stereo *s2 /* input InChI */, ICR *picr); int CompareAllOrigInchiToRevInChI(StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput, int bReqNonTaut, long num_inp, char *szCurHdr); int CompareAllDisconnectedOrigInchiToRevInChI(StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput, int bHasSomeFixedH, long num_inp, char *szCurHdr); int insertions_sort_AT_NUMB( AT_NUMB *base, int num ); int AddRemIsoProtonsInRestrStruct( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, int bHasSomeFixedH, StrFromINChI *pStruct, int num_components, StrFromINChI *pStructR, int num_componentsR, NUM_H pProtonBalance[], NUM_H recmet_change_balance[] ); int OutputInChIOutOfStrFromINChI( ICHICONST INPUT_PARMS *ip_inp, STRUCT_DATA *sd_inp, long num_inp, INCHI_FILE *pout, INCHI_FILE *plog, InpInChI *pOneInput, int bHasSomeFixedH ); int MergeStructureComponents( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, char *szCurHdr, ICHICONST SRM *pSrm, int bReqNonTaut, StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput ); int AddOneMsg( char *szMsg, int used_len, int tot_len, const char *szAddMsg, const char *szDelim ); int FillOutCompareMessage( char *szMsg, int nLenMsg, INCHI_MODE bits[] ); void clear_t_group_info( T_GROUP_INFO *ti ); int bInpInchiComponentExists( InpInChI *pOneInput, int iINCHI, int bMobileH, int k ); int bInpInchiComponentDeleted( InpInChI *pOneInput, int iInChI, int bMobileH, int k ); int bRevInchiComponentExists( StrFromINChI *pStruct, int iInChI, int bMobileH, int k ); int bRevInchiComponentDeleted( StrFromINChI *pStruct, int iInChI, int bMobileH, int k ); int DetectInpInchiCreationOptions ( InpInChI *pOneInput, int *bHasReconnected, int *bHasMetal, int *bHasFixedH, int *sFlag, int *bTautFlag ); int DisplayStructureComponents( ICHICONST INPUT_PARMS *ip, STRUCT_DATA *sd, long num_inp, char *szCurHdr, ICHICONST SRM *pSrm, int bReqNonTaut, StrFromINChI *pStruct[INCHI_NUM][TAUT_NUM], InpInChI *pOneInput ); int DisplayOneRestoredComponent( StrFromINChI *pStruct, inp_ATOM *at, int iComponent, int nNumComponents, int bMobileH, const char *szCurHdr ); int DisplayAllRestoredComponents( inp_ATOM *at, int num_at, const char *szCurHdr ); int CountStereoTypes( INChI *pInChI, int *num_known_SB, int *num_known_SC, int *num_unk_und_SB, int *num_unk_und_SC, int *num_SC_PIII, int *num_SC_AsIII); int GetNumNeighborsFromInchi( INChI *pInChI, AT_NUMB nAtNumber ); int bIsUnsatCarbonInASmallRing( inp_ATOM *at, VAL_AT *pVA, int iat, BFS_Q *pbfsq, int min_ring_size ); int MakeProtonComponent( StrFromINChI *pStruct, int iComponent, int num_prot ); /* extra configurarion */ #define KEEP_METAL_EDGE_FLOW 0 /* counterexample: mdb0-1738.sdf.txt */ #define MOVE_CHARGES_FROM_HETEREO_TO_METAL 0 /* disabled */ #define FIX_ADD_PROTON_FOR_ADP 0 /* not used */ #ifndef INCHI_ALL_CPP #ifdef __cplusplus } #endif #endif #endif