/* * International Chemical Identifier (InChI) * Version 1 * Software version 1.04 * September 9, 2011 * * The InChI library and programs are free software developed under the * auspices of the International Union of Pure and Applied Chemistry (IUPAC). * Originally developed at NIST. Modifications and additions by IUPAC * and the InChI Trust. * * IUPAC/InChI-Trust Licence No.1.0 for the * International Chemical Identifier (InChI) Software version 1.04 * Copyright (C) IUPAC and InChI Trust Limited * * This library is free software; you can redistribute it and/or modify it * under the terms of the IUPAC/InChI Trust InChI Licence No.1.0, * or any later version. * * Please note that this library is distributed WITHOUT ANY WARRANTIES * whatsoever, whether expressed or implied. See the IUPAC/InChI Trust * Licence for the International Chemical Identifier (InChI) Software * version 1.04, October 2011 ("IUPAC/InChI-Trust InChI Licence No.1.0") * for more details. * * You should have received a copy of the IUPAC/InChI Trust InChI * Licence No. 1.0 with this library; if not, please write to: * * The InChI Trust * c/o FIZ CHEMIE Berlin * * Franklinstrasse 11 * 10587 Berlin * GERMANY * * or email to: ulrich@inchi-trust.org. * */ #include #include #include #include "mode.h" #include "inpdef.h" #include "extr_ct.h" #include "inpdef.h" #include "ichitaut.h" #include "ichinorm.h" #include "ichicant.h" #include "ichicomn.h" #include "ichicomp.h" #include "util.h" #include "ichi_bns.h" /* Local prototypes */ int SetTautomericBonds( inp_ATOM *at, int nNumBondPos, T_BONDPOS *BondPos ); int CompRankTautomer(const void* a1, const void* a2 ); int RegisterEndPoints( T_GROUP_INFO *t_group_info, /* T_GROUP *t_group, int *pnum_t, int max_num_t,*/ T_ENDPOINT *EndPoint, int nNumEndPoints, inp_ATOM *at, int num_atoms, C_GROUP_INFO *cgi , struct BalancedNetworkStructure *pBNS ); int cmpTGroupNumber( const void *a1, const void *a2 ); int comp_candidates( const void *a1, const void *a2 ); int MoveEndpoint( inp_ATOM *at, S_CANDIDATE *s_candidate, AT_NUMB endpoint, AT_NUMB *nTGroupNewNumbers, AT_NUMB *nTGroupPosition, int nNewTGroupOrd, T_GROUP_INFO *t_group_info); int FindAccessibleEndPoints( T_ENDPOINT *EndPoint, int *nNumEndPoints, T_BONDPOS *BondPos, int *nNumBondPos, struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD, inp_ATOM *at, int num_atoms, C_GROUP_INFO *cgi, int taut_mode ); /* Bits for GetChargeType */ #define C_SUBTYPE_CHARGED 0 #define C_SUBTYPE_p_DONOR 1 /* new */ #define C_SUBTYPE_p_ACCEPT 2 /* new */ #define C_SUBTYPE_H_ACCEPT 4 #define C_SUBTYPE_H_DONOR 8 #define C_SUBTYPE_NEUTRAL 16 /* Internal stack array size */ #define MAX_STACK_ARRAY_LEN 127 #define MAX_TGROUP_ARRAY_LEN 127 /* local prototypes */ int GetChargeType( inp_ATOM *atom, int iat, S_CHAR *cChargeSubtype ); int GetNeutralRepsIfNeeded( AT_NUMB *pri, AT_NUMB *prj, inp_ATOM *at, int num_atoms, T_ENDPOINT *EndPoint, int nNumEndPoints, C_GROUP_INFO *cgi ); int bCanBeACPoint( inp_ATOM *at, S_CHAR cCharge, S_CHAR cChangeValence, S_CHAR neutral_bonds_valence, S_CHAR neutral_valence, S_CHAR nEndpointValence, S_CHAR *cChargeSubtype ); int CmpCCandidates( const void *a1, const void *a2 ); int RegisterCPoints( C_GROUP *c_group, int *pnum_c, int max_num_c, T_GROUP_INFO *t_group_info, int point1, int point2, int ctype, inp_ATOM *at, int num_atoms ); int GetSaltChargeType( inp_ATOM *at, int at_no, T_GROUP_INFO *t_group_info, int *s_subtype ); int GetOtherSaltChargeType( inp_ATOM *at, int at_no, T_GROUP_INFO *t_group_info, int *s_subtype, int bAccept_O ); int MergeSaltTautGroupsBlind( inp_ATOM *at, int s_type, int num_atoms, S_GROUP_INFO *s_group_info, int nNumCandidates, T_GROUP_INFO *t_group_info, C_GROUP_INFO *c_group_info, struct BalancedNetworkStructure *pBNS ); int ConnectSaltTGroups2SuperTGroup( inp_ATOM *at, int num_atoms, S_GROUP_INFO *s_group_info, int nNumCandidates, T_GROUP_INFO *t_group_info, C_GROUP_INFO *c_group_info, struct BalancedNetworkStructure *pBNS, int *nNewTGroupNumber, int *vertSuperTGroup ); int bDoNotMergeNonTautAtom(inp_ATOM *at, int at_no); int GetOtherSaltType( inp_ATOM *at, int at_no, int *s_subtype ); /*****************************************************************************/ /* Tautomers: Sorting globals */ AT_RANK *pn_tRankForSort; /*****************************************************************************/ /*****************************************************************************/ int is_centerpoint_elem( U_CHAR el_number ) { static U_CHAR el_numb[12]; static int len; int i; if ( !el_numb[0] && !len ) { el_numb[len++] = (U_CHAR)get_periodic_table_number( "C" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "N" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "P" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "S" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "I" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "As" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Sb" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Se" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Te" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Cl" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Br" ); } for ( i = 0; i < len; i ++ ) { if ( el_numb[i] == el_number ) { return 1; } } return 0; } #if ( KETO_ENOL_TAUT == 1 ) /* post v.1 feature */ /*****************************************************************************/ int is_centerpoint_elem_KET( U_CHAR el_number ) { static U_CHAR el_numb[1]; static int len; int i; if ( !el_numb[0] && !len ) { el_numb[len++] = (U_CHAR)get_periodic_table_number( "C" ); } for ( i = 0; i < len; i ++ ) { if ( el_numb[i] == el_number ) { return 1; } } return 0; } #endif /*****************************************************************************/ int is_centerpoint_elem_strict( U_CHAR el_number ) { static U_CHAR el_numb[6]; static int len; int i; if ( !el_numb[0] && !len ) { el_numb[len++] = (U_CHAR)get_periodic_table_number( "C" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "N" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "P" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "As" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Sb" ); } for ( i = 0; i < len; i ++ ) { if ( el_numb[i] == el_number ) { return 1; } } return 0; } /*****************************************************************************/ int get_endpoint_valence( U_CHAR el_number ) { static U_CHAR el_numb[6]; static int len, len2; int i; if ( !el_numb[0] && !len ) { el_numb[len++] = (U_CHAR)get_periodic_table_number( "O" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "S" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Se" ); el_numb[len++] = (U_CHAR)get_periodic_table_number( "Te" ); len2 = len; el_numb[len++] = (U_CHAR)get_periodic_table_number( "N" ); } for ( i = 0; i < len; i ++ ) { if ( el_numb[i] == el_number ) { return i < len2? 2 : 3; } } return 0; } /*****************************************************************************/ #if ( KETO_ENOL_TAUT == 1 ) /* post v.1 feature */ /*****************************************************************************/ int get_endpoint_valence_KET( U_CHAR el_number ) { static U_CHAR el_numb[2]; static int len, len2; int i; if ( !el_numb[0] && !len ) { el_numb[len++] = (U_CHAR)get_periodic_table_number( "O" ); len2 = len; el_numb[len++] = (U_CHAR)get_periodic_table_number( "C" ); } for ( i = 0; i < len; i ++ ) { if ( el_numb[i] == el_number ) { return i < len2? 2 : 4; } } return 0; } #endif /*****************************************************************************/ /*****************************************************************************/ int AddAtom2num( AT_RANK num[], inp_ATOM *atom, int at_no, int bSubtract ) { /* bSubtract: 0=> add, 1=>subtract, 2=> fill */ inp_ATOM *at = atom + at_no; int k; int nMobile = (at->charge == -1); if ( bSubtract == 1 ) { /* 1: subtract */ num[1] -= nMobile; nMobile += at->num_H; num[0] -= nMobile; for ( k = 0; k < T_NUM_ISOTOPIC; k ++ ) { /* T (3H isotope) first because it has higher weight */ num[T_NUM_NO_ISOTOPIC+k] -= at->num_iso_H[NUM_H_ISOTOPES-k-1]; } } else { if ( bSubtract == 2 ) { /* fill */ memset( num, 0, (T_NUM_NO_ISOTOPIC + T_NUM_ISOTOPIC)*sizeof(num[0]) ); } /* else (0): add */ num[1] += nMobile; nMobile += at->num_H; num[0] += nMobile; for ( k = 0; k < T_NUM_ISOTOPIC; k ++ ) { /* T (3H isotope) first because it has higher weight */ num[T_NUM_NO_ISOTOPIC+k] += at->num_iso_H[NUM_H_ISOTOPES-k-1]; } } return nMobile; } /*****************************************************************************/ void AddAtom2DA( AT_RANK num_DA[], inp_ATOM *atom, int at_no, int bSubtract ) { /* bSubtract: 0=> add, 1=>subtract, 2=> fill */ inp_ATOM *at = atom + at_no; int nDelta, nAcidic_O; if (at->charge < -1 || at->charge == 1 && !at->c_point || at->charge > 1 ) return; nDelta = ( bSubtract == 1 )? -1 : 1; /* "Acidic" O, S, Se, Te recognition */ if ( at->at_type & ATT_ACIDIC_CO ) { nAcidic_O = nDelta; } else { nAcidic_O = 0; } if ( bSubtract == 2 ) { /* 2: fill, otherwise add */ memset( num_DA, 0, TG_NUM_DA * sizeof(num_DA[0]) ); } if ( at->charge <= 0 && at->valence == at->chem_bonds_valence || /* neutral or negative donor */ at->charge > 0 && at->valence + 1 == at->chem_bonds_valence /* positively charged donor */ ) { if ( at->charge < 0 ) { num_DA[TG_Num_dM] += nDelta; num_DA[TG_Num_dO] += nAcidic_O; } else if ( at->num_H ) { num_DA[TG_Num_dH] += nDelta; num_DA[TG_Num_dO] += nAcidic_O; } } else if ( at->charge <= 0 && at->valence + 1 == at->chem_bonds_valence || at->charge > 0 && at->valence + 2 == at->chem_bonds_valence ) { /* acceptor */ if ( at->charge < 0 ) { num_DA[TG_Num_aM] += nDelta; } else if ( at->num_H ) { num_DA[TG_Num_aH] += nDelta; } else { num_DA[TG_Num_aO] += nAcidic_O; /* acidic O-acceptor has no H or charge */ } } return; } /*****************************************************************************/ int AddEndPoint( T_ENDPOINT *pEndPoint, inp_ATOM *at, int iat ) { pEndPoint->nAtomNumber = iat; pEndPoint->nEquNumber = 0; pEndPoint->nGroupNumber = at[iat].endpoint; if ( at[iat].endpoint ) { /* already an endpoint */ memset( pEndPoint->num, 0, sizeof(pEndPoint->num) ); } else { /* not an endpoint yet, make it an endpoint */ AddAtom2num( pEndPoint->num, at, iat, 2 ); /* fill */ AddAtom2DA( pEndPoint->num_DA, at, iat, 2 ); /* nMobile = pEndPoint->num[1] = (at[iat].charge == -1); nMobile = pEndPoint->num[0] = at[iat].num_H + nMobile; for ( k = 0; k < T_NUM_ISOTOPIC; k ++ ) { pEndPoint->num[T_NUM_NO_ISOTOPIC+k] = at[iat].num_iso_H[NUM_H_ISOTOPES-k-1]; } */ } return 0; } /*****************************************************************************/ int nGetEndpointInfo( inp_ATOM *atom, int iat, ENDPOINT_INFO *eif ) { int nEndpointValence; int nMobile; S_CHAR cChargeSubtype; if ( atom[iat].radical && atom[iat].radical != RADICAL_SINGLET ) return 0; /* a radical */ if ( !(nEndpointValence = get_endpoint_valence( atom[iat].el_number )) ) return 0; /* not an endpoint */ if ( nEndpointValence <= atom[iat].valence ) return 0; /* not an endpoint, for example >N(+)< or >N< or >O(+)- or >O- or >N- or -O- */ if ( atom[iat].charge == -1 || atom[iat].charge == 0 ) { /* not a positive charge-point */ if ( nEndpointValence < atom[iat].chem_bonds_valence ) return 0; /* abnormal valence > standard endpoint valence */ nMobile = atom[iat].num_H + (atom[iat].charge == -1); if ( nMobile + atom[iat].chem_bonds_valence != nEndpointValence ) return 0; /* non-standard endpoint valence */ switch ( atom[iat].chem_bonds_valence - atom[iat].valence ) { case 0: eif->cDonor = 1; eif->cAcceptor = 0; break; case 1: eif->cDonor = 0; eif->cAcceptor = 1; break; default: return 0; } eif->cMobile = nMobile; eif->cNeutralBondsValence = nEndpointValence-nMobile; eif->cMoveableCharge = 0; #if ( KETO_ENOL_TAUT == 1 ) eif->cKetoEnolCode = 0; #endif return nEndpointValence; } else if ( atom[iat].c_point && 0 <= GetChargeType( atom, iat, &cChargeSubtype ) && ((int)cChargeSubtype & (C_SUBTYPE_H_ACCEPT|C_SUBTYPE_H_DONOR)) ) { /* charge-point */ if ( cChargeSubtype & C_SUBTYPE_H_ACCEPT ) { eif->cDonor = 0; eif->cAcceptor = 1; } else if ( cChargeSubtype & C_SUBTYPE_H_DONOR ) { eif->cDonor = 1; eif->cAcceptor = 0; } else { return 0; } eif->cMobile = atom[iat].num_H; eif->cNeutralBondsValence = nEndpointValence-atom[iat].num_H; eif->cMoveableCharge = atom[iat].charge; #if ( KETO_ENOL_TAUT == 1 ) eif->cKetoEnolCode = 0; #endif return nEndpointValence; } return 0; } /*****************************************************************************/ #if ( KETO_ENOL_TAUT == 1 ) /* post v.1 feature */ /*****************************************************************************/ int nGetEndpointInfo_KET( inp_ATOM *atom, int iat, ENDPOINT_INFO *eif ) { int nEndpointValence; int nMobile; S_CHAR cChargeSubtype; /* static U_CHAR el_number_O, el_number_C; if ( !el_number_O ) { el_number_O = (U_CHAR)get_periodic_table_number( "O" ); el_number_C = (U_CHAR)get_periodic_table_number( "C" ); } */ if ( atom[iat].radical && atom[iat].radical != RADICAL_SINGLET ) return 0; /* a radical */ if ( !(nEndpointValence = get_endpoint_valence_KET( atom[iat].el_number )) ) return 0; /* not an endpoint; only O and C can be an endpoint for keto-enol tautomerism */ if ( nEndpointValence <= atom[iat].valence ) return 0; /* not an endpoint, for example >N(+)< or >N< or >O(+)- or >O- or >N- or -O- */ if ( nEndpointValence == 4 && atom[iat].valence < 2 ) return 0; /* exclude O==C--CH3 <=> HO--C==CH2 */ if ( nEndpointValence == 2 && atom[iat].valence > 1 ) return 0; /* exclude --O--C==CH-- */ if ( atom[iat].charge == -1 || atom[iat].charge == 0 ) { /* not a positive charge-point */ if ( nEndpointValence < atom[iat].chem_bonds_valence ) return 0; /* abnormal valence > standard endpoint valence */ nMobile = atom[iat].num_H + (atom[iat].charge == -1); if ( nMobile + atom[iat].chem_bonds_valence != nEndpointValence ) return 0; /* non-standard endpoint valence */ switch ( atom[iat].chem_bonds_valence - atom[iat].valence ) { case 0: eif->cDonor = 1; eif->cAcceptor = 0; break; case 1: eif->cDonor = 0; eif->cAcceptor = 1; break; default: return 0; } eif->cMobile = nMobile; eif->cNeutralBondsValence = nEndpointValence-nMobile; eif->cMoveableCharge = 0; eif->cKetoEnolCode = (nEndpointValence == 2)? 1 : (nEndpointValence == 4)? 2 : 0; return nEndpointValence; } else if ( atom[iat].c_point && 0 <= GetChargeType( atom, iat, &cChargeSubtype ) && ((int)cChargeSubtype & (C_SUBTYPE_H_ACCEPT|C_SUBTYPE_H_DONOR)) ) { /* charge-point; currently only O for keto-enol tautomerism */ if ( cChargeSubtype & C_SUBTYPE_H_ACCEPT ) { eif->cDonor = 0; eif->cAcceptor = 1; } else if ( cChargeSubtype & C_SUBTYPE_H_DONOR ) { eif->cDonor = 1; eif->cAcceptor = 0; } else { return 0; } eif->cMobile = atom[iat].num_H; eif->cNeutralBondsValence = nEndpointValence-atom[iat].num_H; eif->cMoveableCharge = atom[iat].charge; eif->cKetoEnolCode = (nEndpointValence == 2)? 1 : (nEndpointValence == 4)? 2 : 0; return nEndpointValence; } return 0; } #endif /*****************************************************************************/ /*****************************************************************************/ /* RegisterEndPoints ret>0 => new registration happened, */ /* =0 => no changes, -1 => program error (debug) */ /*****************************************************************************/ int RegisterEndPoints( T_GROUP_INFO *t_group_info, /* T_GROUP *t_group, int *pnum_t, int max_num_t,*/ T_ENDPOINT *EndPoint, int nNumEndPoints, inp_ATOM *at, int num_atoms, C_GROUP_INFO *cgi, struct BalancedNetworkStructure *pBNS ) { T_GROUP *t_group = t_group_info->t_group; int *pnum_t = &t_group_info->num_t_groups; int max_num_t = t_group_info->max_num_t_groups; int nNumZeroEqu, nNumNewTGroups; AT_NUMB group, prev_group, prev_eqnum, nNextGroupNumber, nLeastGroupNumber; int nNumGroups, num_t, difference; int i, j, k, ret; AT_NUMB nNewTgNumberStackArray[MAX_STACK_ARRAY_LEN+1]; AT_NUMB nGroupNumberStackArray[MAX_STACK_ARRAY_LEN+1]; AT_NUMB nGroupNewNumberStackArray[MAX_STACK_ARRAY_LEN+1]; AT_NUMB *nNewTgNumber = nNewTgNumberStackArray; AT_NUMB *nGroupNumber = nGroupNumberStackArray; AT_NUMB *nGroupNewNumber = nGroupNewNumberStackArray; if ( nNumEndPoints <= 0 ) return 0; /* nothing to do */ num_t = *pnum_t; difference = 0; nNextGroupNumber = 0; nNumZeroEqu = 0; ret = 0; /* find max group number; increment it to obtain next available group number */ for ( i = 0; i < num_t; i ++ ) { if ( nNextGroupNumber < t_group[i].nGroupNumber ) nNextGroupNumber = t_group[i].nGroupNumber; } nNextGroupNumber ++; /* find min non-zero group number nLeastGroupNumber; count zero EndPoint[i].nEquNumber if all EndPoint[i].nGroupNumber are equal and non-zero then exit: nothing to do. */ nLeastGroupNumber = nNextGroupNumber; prev_group = EndPoint[0].nGroupNumber; prev_eqnum = EndPoint[0].nEquNumber; for ( i = j = k = 0; i < nNumEndPoints; i ++ ) { if ( group = EndPoint[i].nGroupNumber ) { if ( group < nLeastGroupNumber ) { nLeastGroupNumber = group; } } j += (prev_group == EndPoint[i].nGroupNumber); /* count endpoints that belong to the 1st group */ k += (prev_eqnum == EndPoint[i].nEquNumber); /* count endpoints that belongo to a group equivalent to the 1st group */ nNumZeroEqu += !EndPoint[i].nEquNumber; /* count endpoints that have been processed by FindAccessibleEndPoints() */ } if ( j == nNumEndPoints && prev_group && k == nNumEndPoints ) { /* all endpoints already belong to one t-group; the last comparison is not needed for now because EndPoint[i].nEquNumber cannot make endpont partitioning finer */ return 0; } nNumNewTGroups = 0; if ( !nNumZeroEqu ) { /* EndPoint[] has been processed by FindAccessibleEndPoints; * equal EndPoint[i].nEquNumber mark endpoints belonging to * the same t-group * Since now the next available t-group number, nNextGroupNumber, * is known,replace fict. IDs assigned by FindAccessibleEndPoints * with correct new t-group numbers. */ for ( i = 0; i < nNumEndPoints; i ++ ) { if ( (group = EndPoint[i].nEquNumber) >= nNextGroupNumber ) { /* replace fict. IDs assigned by FindAccessibleEndPoints() with new t-group numbers */ /* these fict. IDs have values = (num_atoms+1), (num_atoms+2),...; they may be non-contiguous */ for ( j = 0; j < nNumNewTGroups; j ++ ) { if ( group == nGroupNewNumber[j] ) break; } if ( j == nNumNewTGroups ) { /* found new fict. ID = group */ if ( j == MAX_STACK_ARRAY_LEN && nGroupNewNumber == nGroupNewNumberStackArray ) { /* stack array overflow; allocate more memory than may be needed */ nGroupNewNumber = (AT_NUMB *) inchi_malloc(nNumEndPoints*sizeof(nGroupNewNumber[0])); if ( !nGroupNewNumber ) { ret = -1; goto exit_function; } memcpy( nGroupNewNumber, nGroupNewNumberStackArray, nNumNewTGroups*sizeof(nGroupNewNumber[0])); } /* save newly found fict. t-group ID to compare to the next values of EndPoint[].nEquNumber */ nGroupNewNumber[j] = group; nNumNewTGroups ++; } EndPoint[i].nEquNumber = nNextGroupNumber + j; } } /* after this point the values just stored in nGroupNewNumber[] will not be used. However, the obtained nNumNewTGroups value will be used */ } else if ( nNumZeroEqu == nNumEndPoints ) { /* EndPoint[] has NOT been processed by FindAccessibleEndPoints; all atoms and t-groups to which endpoints belong should be merged into a single t-group */ if ( nLeastGroupNumber == nNextGroupNumber ) { /* flag to create a new t-group: none of the found * endpoints belong to an already known t-group */ nNumNewTGroups = 1; /* otherwise 0 */ } /* All EndPoint[*].nEquNumber are zeroes. All endpoints will * belong to one new or old t-group; its ID is nLeastGroupNumber. * Set EndPoint[i].nEquNumber = nLeastGroupNumber; */ for ( i = 0; i < nNumEndPoints; i ++ ) { EndPoint[i].nEquNumber = nLeastGroupNumber; } } else { ret = -1; /* program error: only some of EndPoint[i].nEquNumber are zero */ /* */ goto exit_function; } if ( nNumNewTGroups ) { /* create new nNumNewTGroups t-group(s) */ if ( num_t + nNumNewTGroups > max_num_t ) { ret = -1; /* found too many t-groups */ /* */ goto exit_function; } /* initialize new t-group(s) */ memset( t_group + num_t, 0, nNumNewTGroups * sizeof(t_group[0]) ); for ( i = 0; i < nNumNewTGroups; i ++ ) { t_group[num_t+i].nGroupNumber = nNextGroupNumber + i; } } /* At this point: * EndPoint[i].nGroupNumber == 0 => the endpoint atom does not belong to a t-group yet * EndPoint[i].nGroupNumber > 0 => current t-group ID of the endpoint atom * EndPoint[i].nEquNumber --> new ID of a tautomeric group of this endpoint atom * EndPoint[i].nAtomNumber --> number of the endpoint atom */ nNumGroups = 0; /* counts the groups to be renumbered */ for ( i = j = 0; i < nNumEndPoints; i ++ ) { if ( group = EndPoint[i].nGroupNumber ) { if ( group == EndPoint[i].nEquNumber ) { continue; /* ignore: the endpoint belongs to the same t-group as before */ } /* save information for renumbering of the existing t-groups */ for ( j = 0; j < nNumGroups; j ++ ) { if ( group == nGroupNumber[j] ) { if ( EndPoint[i].nEquNumber != nGroupNewNumber[j] ) { ret = -1; /* program error */ /* */ goto exit_function; } break; } } if ( j == nNumGroups ) { /* discovered a new t-group number; store it together with its nEquNumber */ if ( j == MAX_STACK_ARRAY_LEN ) { if ( nGroupNewNumber == nGroupNewNumberStackArray ) { nGroupNewNumber = (AT_NUMB *) inchi_malloc(nNumEndPoints*sizeof(nGroupNewNumber[0])); if ( !nGroupNewNumber ) { ret = -1; goto exit_function; } memcpy( nGroupNewNumber, nGroupNewNumberStackArray, nNumGroups*sizeof(nGroupNewNumber[0])); } if ( nGroupNumber == nGroupNumberStackArray ) { nGroupNumber = (AT_NUMB *) inchi_malloc(nNumEndPoints*sizeof(nGroupNumber[0])); if ( !nGroupNumber ) { ret = -1; goto exit_function; } memcpy( nGroupNumber, nGroupNumberStackArray, nNumGroups*sizeof(nGroupNumber[0])); } } nGroupNumber[j] = group; /* old t-group ID */ nGroupNewNumber[j] = EndPoint[i].nEquNumber; /* new t-group ID */ nNumGroups ++; } } else { /* add a new endpoint to the newly created or previously existing t-groups */ group = EndPoint[i].nEquNumber; if ( group >= nNextGroupNumber ) { /* get index of a new t-group from equ number */ j = num_t + group - nNextGroupNumber; /* newly assigned IDs are contiguous */ } else { /* old t-group */ if ( j >= num_t || group != t_group[j].nGroupNumber ) { /* search only if j is not a needed group index */ for ( j = 0; j < num_t; j ++ ) { if ( group == t_group[j].nGroupNumber ) break; } if ( j == num_t ) { ret = -1; /* program error: t-group not found */ /* */ goto exit_function; } } } /* add aton to existing or new t-group */ t_group[j].nNumEndpoints ++; for ( k = 0; k < (int)(sizeof(t_group->num)/sizeof(t_group->num[0])); k ++ ) t_group[j].num[k] += EndPoint[i].num[k]; for ( k = 0; k < (int)(sizeof(t_group->num_DA)/sizeof(t_group->num_DA[0])); k ++ ) t_group[j].num_DA[k] += EndPoint[i].num_DA[k]; /* mark endpoint */ at[EndPoint[i].nAtomNumber].endpoint = group; difference ++; } } difference += nNumGroups; num_t += nNumNewTGroups; if ( !difference ) { ret = 0; /* nothing to do. Not necessarily a program error: happens if all EndPoint[i].nGroupNumber==EndPoint[i].nEquNumber */ goto exit_function; } if ( nNumGroups ) { /* prepare for renumbering: find max t-group number */ for ( i = 0, nNextGroupNumber = 0; i < num_t; i ++ ) { if ( nNextGroupNumber < t_group[i].nGroupNumber ) { nNextGroupNumber = t_group[i].nGroupNumber; } } } /* renumber and merge t-groups */ for ( i = 0; i < nNumGroups; i ++ ) { int i1, i2; AT_NUMB group1 = nGroupNumber[i]; AT_NUMB group2 = nGroupNewNumber[i]; /* add group1 to group2, then delete group1. */ for ( j = 0, i1 = i2 = -1; j < num_t && (i1 < 0 || i2 < 0); j ++ ) { if ( i1 < 0 && group1 == t_group[j].nGroupNumber ) i1 = j; if ( i2 < 0 && group2 == t_group[j].nGroupNumber ) i2 = j; } if ( i1 < 0 || i2 < 0 ) { ret = -1; /* program error */ /* */ goto exit_function; } /* add t_group[i1] to t_group[i2] and remove t_group[i1] */ for ( k = 0; k < (int)(sizeof(t_group->num)/sizeof(t_group->num[0])); k ++ ) t_group[i2].num[k] += t_group[i1].num[k]; for ( k = 0; k < (int)(sizeof(t_group->num_DA)/sizeof(t_group->num_DA[0])); k ++ ) t_group[i2].num_DA[k] += t_group[i1].num_DA[k]; t_group[i2].nNumEndpoints += t_group[i1].nNumEndpoints; num_t --; if ( num_t > i1 ) { memmove( t_group+i1, t_group+i1+1, ( num_t - i1)*sizeof(t_group[0]) ); } } if ( nNumGroups ) { /* there are groups to merge */ if ( nNextGroupNumber >= MAX_STACK_ARRAY_LEN ) { nNewTgNumber = (AT_NUMB *) inchi_malloc((nNextGroupNumber+1)*sizeof(*nNewTgNumber)); if ( !nNewTgNumber ) { ret = -1; goto exit_function; /* error: out of RAM */ } } memset( nNewTgNumber, 0, (nNextGroupNumber+1)*sizeof(*nNewTgNumber) ); for ( i = 0; i < num_t; i ++ ) { nNewTgNumber[t_group[i].nGroupNumber] = i+1; /* new t-group numbers */ } for ( j = 0; j < nNumGroups; j ++ ) { if ( !nNewTgNumber[nGroupNumber[j]] && nNewTgNumber[nGroupNewNumber[j]] ) { nNewTgNumber[nGroupNumber[j]] = nNewTgNumber[nGroupNewNumber[j]]; } else { ret = -1; /* program error: all new numbers must have been marked */ goto exit_function; } } /* renumber t-groups */ for ( i = 0; i < num_t; i ++ ) { t_group[i].nGroupNumber = nNewTgNumber[t_group[i].nGroupNumber]; } #if ( bRELEASE_VERSION != 1 ) /* Check: debug only */ for ( i = 1; i < num_t; i ++ ) { if ( 1 != t_group[i].nGroupNumber - t_group[i-1].nGroupNumber ) { ret = -1; /* debug */ goto exit_function; } } #endif /* renumber endpoints */ for ( i = 0; i < num_atoms; i ++ ) { if ( group = at[i].endpoint ) { if ( !(at[i].endpoint = nNewTgNumber[group]) || nNextGroupNumber <= nNewTgNumber[group] ) { ret = -1; /* program error */ goto exit_function; } } } } if ( nNewTgNumber != nNewTgNumberStackArray ) { inchi_free( nNewTgNumber ); nNewTgNumber = nNewTgNumberStackArray; } if ( nGroupNumber != nGroupNumberStackArray ) { inchi_free(nGroupNumber); nGroupNumber = nGroupNumberStackArray; } if ( nGroupNewNumber != nGroupNewNumberStackArray ) { inchi_free( nGroupNewNumber ); nGroupNewNumber = nGroupNewNumberStackArray; } if ( !t_group_info->tGroupNumber ) { t_group_info->tGroupNumber = (AT_NUMB *) inchi_malloc(2*max_num_t*sizeof(t_group_info->tGroupNumber[0])); if ( !t_group_info->tGroupNumber ) { ret = -1; goto exit_function; } } /* fill out t-group index 2004-02-27 */ memset( t_group_info->tGroupNumber, 0, 2*max_num_t*sizeof(t_group_info->tGroupNumber[0]) ); for ( i = 0; i < num_t; i ++ ) { if ( t_group[i].nNumEndpoints && t_group[i].nGroupNumber ) t_group_info->tGroupNumber[t_group[i].nGroupNumber] = i+1; } if ( pBNS && (pBNS->tot_st_cap == pBNS->tot_st_flow || ALWAYS_ADD_TG_ON_THE_FLY) ) { T_GROUP_INFO tgi; int ret_bns; memset( &tgi, 0, sizeof(tgi) ); tgi.num_t_groups = num_t; tgi.t_group = t_group; #if ( KETO_ENOL_TAUT == 1 ) tgi.bTautFlags |= (t_group_info->bTautFlags & TG_FLAG_KETO_ENOL_TAUT); /* needed in AddTGroups2BnStruct() */ #endif /* reinitialize BN Structure */ ret_bns = ReInitBnStruct( pBNS, at, num_atoms, 0 ); if ( IS_BNS_ERROR( ret_bns ) ) { return ret_bns; } if ( *pBNS->pbTautFlags & TG_FLAG_MOVE_POS_CHARGES ) { /* set new charge groups */ ret_bns = AddCGroups2BnStruct( pBNS, at, num_atoms, cgi ); if ( IS_BNS_ERROR( ret_bns ) ) { return ret_bns; } } /* set new tautomeric groups */ ret_bns = AddTGroups2BnStruct( pBNS, at, num_atoms, &tgi ); if ( IS_BNS_ERROR( ret_bns ) ) { return ret_bns; } } *pnum_t = num_t; return difference; exit_function: if ( nNewTgNumber != nNewTgNumberStackArray ) { inchi_free( nNewTgNumber ); } if ( nGroupNumber != nGroupNumberStackArray ) { inchi_free(nGroupNumber); } if ( nGroupNewNumber != nGroupNewNumberStackArray ) { inchi_free( nGroupNewNumber ); } return ret; } /***************************************************************************** * Change non-alternating and non-tautomeric bonds * (that is, single and double bonds) to tautomeric *****************************************************************************/ int SetTautomericBonds( inp_ATOM *at, int nNumBondPos, T_BONDPOS *BondPos ) { int k, n; for ( k = n = 0; k < nNumBondPos; k ++ ) { int neighbor_index = BondPos[k].neighbor_index; int center = BondPos[k].nAtomNumber; int bond_mark = at[center].bond_type[neighbor_index]; int bond_type = bond_mark & ~BOND_MARK_ALL; int neighbor; #if ( REPLACE_ALT_WITH_TAUT == 1 ) if ( bond_type != BOND_TAUTOM ) #else if ( bond_type != BOND_ALTERN && bond_type != BOND_TAUTOM ) #endif { int ii; /* change bond type to BOND_TAUTOM presering higher bits marks */ bond_type = (bond_mark & BOND_MARK_ALL) | BOND_TAUTOM; /* change center-neighbor bond */ at[center].bond_type[neighbor_index] = bond_type; neighbor = at[center].neighbor[neighbor_index]; for ( ii = 0; ii < at[neighbor].valence; ii ++ ) { if ( at[neighbor].neighbor[ii] == center ) { /* neighbor-center bond found */ at[neighbor].bond_type[ii] = bond_type; break; } } n ++; } } return n; } /*****************************************************************************/ int GetNeutralRepsIfNeeded( AT_NUMB *pri, AT_NUMB *prj, inp_ATOM *at, int num_atoms, T_ENDPOINT *EndPoint, int nNumEndPoints, C_GROUP_INFO *cgi ) { AT_NUMB ri = *pri; AT_NUMB rj = *prj; int i, k; AT_NUMB c_point, endpoint, r; if ( (c_point = at[ri].c_point) && (c_point == at[rj].c_point) && (at[ri].charge == 1 || at[rj].charge == 1) && cgi && cgi->num_c_groups > 0 ) { /* at[ri] and at[rj] belong to the same charge group, at least one is charged */ /* MS VC++ 2005 reports unreachable code here ??? */ for ( k = 0; k < cgi->num_c_groups; k ++ ) { if ( cgi->c_group[k].nGroupNumber == c_point ) { /* cgi->c_group[k] is found to be this charge group */ if ( cgi->c_group[k].num_CPoints - cgi->c_group[k].num[0] < 2 ) { /* Only one neutral in the c-group: we will not be able to neutralize both when looking for the alt path to discover the tautomerism. Therefore we need to find a neutral t-group representative */ /* at[rj] */ if ( endpoint = at[rj].endpoint ) { for ( i = 0; i < nNumEndPoints; i ++ ) { if ( (r=EndPoint[i].nAtomNumber) == *prj ) continue; /* ignore at[*prj] */ if ( at[r].endpoint != endpoint ) continue; /* at[r] does not belong to the same t-group as at[*prj]; ignore the atom */ if ( !at[r].c_point ) { rj = r; /* found a neutral t-group representative */ break; } if ( at[r].c_point != c_point && c_point == at[rj].c_point ) { /* replace only once because of (c_point == at[rj].c_point) condition */ rj = r; } } if ( rj == *prj /*&& at[ri].endpoint*/ ) { /* !!! "&& at[ri].endpoint": only between 2 t-groups 2004-02-27; the change disabled due to undiscovered yet possibility of ambiguity*/ /* no replacement has been found in EndPoint[]; try all atoms in the t-group */ for ( i = 0; i < num_atoms; i ++ ) { if ( at[i].endpoint != endpoint ) continue; if ( i == (int)*prj ) continue; if ( !at[i].c_point ) { rj = (AT_NUMB)i; /* found neutral t-group representative */ break; } if ( at[i].c_point != c_point && c_point == at[rj].c_point ) { /* replace only once */ rj = (AT_NUMB)i; } } } } /* at[ri] */ if ( endpoint = at[ri].endpoint ) { for ( i = 0; i < nNumEndPoints; i ++ ) { if ( (r=EndPoint[i].nAtomNumber) == *pri ) continue; if ( at[r].endpoint != endpoint ) continue; if ( !at[r].c_point ) { ri = r; /* found neutral t-group representative */ break; } if ( at[r].c_point != c_point && c_point == at[ri].c_point && at[r].c_point != at[rj].c_point ) { /* replace only once */ ri = r; } } if ( ri == *pri && at[rj].endpoint ) { /* !!! "&& at[rj].endpoint": only between 2 t-groups 2004-02-27; the change disabled due to undiscovered yet possibility of ambiguity */ for ( i = 0; i < num_atoms; i ++ ) { if ( at[i].endpoint != endpoint ) continue; if ( i == (int)*pri ) continue; if ( !at[i].c_point ) { ri = (AT_NUMB)i; /* found neutral t-group representative */ break; } if ( at[i].c_point != c_point && c_point == at[ri].c_point && at[i].c_point != at[rj].c_point) { /* replace only once */ ri = (AT_NUMB)i; } } } } } } break; } *prj = rj; *pri = ri; } return 0; } /*****************************************************************************/ int FindAccessibleEndPoints( T_ENDPOINT *EndPoint, int *nNumEndPoints, T_BONDPOS *BondPos, int *nNumBondPos, struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD, inp_ATOM *at, int num_atoms, C_GROUP_INFO *cgi, int taut_mode ) { AT_NUMB nTGroupRepresenative[MAXVAL], nTGroupEqu[MAXVAL], nTGEndPointNo[MAXVAL], ri, rj; AT_NUMB nCurTGroupNumber, nMaxTGroupNumber, nNumTgroupNumbers, nMaxEquNumber; int i, j, k, nNumDiffTGroupNumbers = 0, nNumFoundEqu, nErr; if ( *nNumEndPoints != *nNumBondPos ) return 0; /* collect all group numbers. Fill EndPoint[i].nEquNumber */ for ( i = 0; i < *nNumEndPoints; i ++ ) { nCurTGroupNumber = EndPoint[i].nEquNumber = EndPoint[i].nGroupNumber; /* initial equivalence */ if ( nCurTGroupNumber ) { /* found endpoint that already belongs to a t-group */ for ( j = 0; j < nNumDiffTGroupNumbers; j ++ ) { if ( nTGroupEqu[j] == nCurTGroupNumber ) break; } if ( j == nNumDiffTGroupNumbers ) { nTGroupRepresenative[nNumDiffTGroupNumbers] = EndPoint[i].nAtomNumber; nTGroupEqu[nNumDiffTGroupNumbers] = EndPoint[i].nGroupNumber; nTGEndPointNo[nNumDiffTGroupNumbers] = i; nNumDiffTGroupNumbers ++; } } } /* check whether each pair belongs to the same t-group and establish the equivalence(s) */ for ( i = 0, nNumFoundEqu=0; i < nNumDiffTGroupNumbers; i ++ ) { for ( j = i+1; j < nNumDiffTGroupNumbers; j ++ ) { ri = nTGroupRepresenative[i]; rj = nTGroupRepresenative[j]; /* both at[ri] and at[rj] are known to belong to tautomeric groups */ GetNeutralRepsIfNeeded( &ri, &rj, at, num_atoms, EndPoint, *nNumEndPoints, cgi ); nErr = bExistsAnyAltPath( pBNS, pBD, at, num_atoms, ri, rj, taut_mode ); if ( IS_BNS_ERROR(nErr) ) return nErr; if ( 0 == nErr ) continue; /* alt path between at[ri] and at[rj] not found */ nCurTGroupNumber = inchi_min( nTGroupEqu[i], nTGroupEqu[j] ); nMaxTGroupNumber = inchi_max( nTGroupEqu[i], nTGroupEqu[j] ); for ( k = 0; k < nNumDiffTGroupNumbers; k ++ ) { if ( nTGroupEqu[k]==nMaxTGroupNumber ) { nTGroupEqu[k] = nCurTGroupNumber; nNumFoundEqu ++; } } for ( k = 0; k < *nNumEndPoints; k ++ ) { if ( EndPoint[k].nEquNumber == nMaxTGroupNumber ) { EndPoint[k].nEquNumber = nCurTGroupNumber; } } } } if ( nNumFoundEqu ) { /* leave in only non-equivalent representatives */ for ( i = 1, k = 0; i < nNumDiffTGroupNumbers; i ++ ) { for ( j = 0; j < i; j ++ ) { if ( nTGroupEqu[j] == nTGroupEqu[i] ) { nTGroupEqu[i] = 0; /* i > j; mark equivalent for removal*/ break; } } } for ( i = j = 0; i < nNumDiffTGroupNumbers; i ++ ) { if ( nTGroupEqu[i] ) { if ( i != j ) { /* remove the marked */ nTGroupEqu[j] = nTGroupEqu[i]; nTGroupRepresenative[j] = nTGroupRepresenative[i]; nTGEndPointNo[j] = nTGEndPointNo[i]; } j ++; } } nNumDiffTGroupNumbers = j; /* number of known t-group representatives */ } /* collect endpoints that have not been assigned to t-groups */ for ( i = 0, j = nNumDiffTGroupNumbers; i < *nNumEndPoints; i ++ ) { if ( EndPoint[i].nEquNumber ) continue; nTGroupEqu[j] = 0; nTGroupRepresenative[j] = EndPoint[i].nAtomNumber; nTGEndPointNo[j] = i; j ++; } nNumTgroupNumbers = j; nMaxEquNumber = num_atoms + 1; /* impossible atom or t-group number */ /* check whether each pair belongs to the same group and establish the equivalence(s) */ for ( i = 0, nNumFoundEqu=0; i < nNumTgroupNumbers; i ++ ) { for ( j = i+1; j < nNumTgroupNumbers; j ++ ) { if ( nTGroupEqu[i] != nTGroupEqu[j] && (i>=nNumDiffTGroupNumbers || j>=nNumDiffTGroupNumbers) || /* equivalence of a t-group and a non-t-group atom */ !nTGroupEqu[i] && !nTGroupEqu[j] /* equivalence of two non-t-group atoms */ ) { ri = nTGroupRepresenative[i]; rj = nTGroupRepresenative[j]; /*------------------------------!!!--------------------------------------------- Explanation why GetNeutralRepsIfNeeded() may need to be changed 2004-02-27 The change has been disabled due to undiscovered yet possibility of ambiguity to search for neutral only among EndPoint[] in case taut-not_taut pairs Counterexample: O=C-NH(+)=C-NH2 1 2 3 Has already been found: 2-3 (+)-charge exchange 1-2 tautomerism (charge removed to 3) Now testing: 2-3 tautomerism. If not commented out, GetNeutralRepsIfNeeded() would replace 2-3 test with 1-3 test because: o Charge group has only one neutral and both 2 and 3 belong to it, therefore we cannot neutralize both; search for neutral representative; o Since 1 and 2 belong to the same t-group and 1 is neutral, test 1-3 instead of 2-3. This breaks our condition: Test tautomeric H movement only between neutral atoms. -----------------------------------------------------------------------------*/ GetNeutralRepsIfNeeded( &ri, &rj, at, num_atoms, EndPoint, *nNumEndPoints, cgi ); nErr = bExistsAnyAltPath( pBNS, pBD, at, num_atoms, ri, rj, taut_mode ); if ( IS_BNS_ERROR(nErr) ) return nErr; if ( nErr <= 0 ) continue; if ( nTGroupEqu[i] && nTGroupEqu[j] ) { /* found equivalence of two t-groups; at least one of them must be a new one */ nCurTGroupNumber = inchi_min( nTGroupEqu[i], nTGroupEqu[j] ); nMaxTGroupNumber = inchi_max( nTGroupEqu[i], nTGroupEqu[j] ); for ( k = 0; k < nNumTgroupNumbers; k ++ ) { if ( nTGroupEqu[k]==nMaxTGroupNumber ) { nTGroupEqu[k] = nCurTGroupNumber; nNumFoundEqu ++; } } for ( k = 0; k < *nNumEndPoints; k ++ ) { if ( EndPoint[k].nEquNumber == nMaxTGroupNumber ) { EndPoint[k].nEquNumber = nCurTGroupNumber; } } } else if ( nTGroupEqu[i] ) { /* extend existing t-group */ nTGroupEqu[j] = nTGroupEqu[i]; EndPoint[nTGEndPointNo[j]].nEquNumber = nTGroupEqu[i]; } else if ( nTGroupEqu[j] ) { /* extend existing t-group */ nTGroupEqu[i] = nTGroupEqu[j]; EndPoint[nTGEndPointNo[i]].nEquNumber = nTGroupEqu[j]; } else { /* establis a new t-group */ nTGroupEqu[i] = nTGroupEqu[j] = nMaxEquNumber; /* assign a fict. ID to establish equivalence */ EndPoint[nTGEndPointNo[i]].nEquNumber = EndPoint[nTGEndPointNo[j]].nEquNumber = nMaxEquNumber; nMaxEquNumber ++; } } } } /* eliminate endpoints and bonds that do not belong to t-group(s) (they have not been found connected by an alt path to any other endpoint) */ for ( i = 0, j = 0; i < *nNumEndPoints; i ++ ) { if ( EndPoint[i].nEquNumber ) { #if ( IGNORE_SINGLE_ENDPOINTS == 1 ) /* 1-28-2003 */ for ( k = 0, nNumFoundEqu = 0; k < *nNumEndPoints; k ++ ) { nNumFoundEqu += (EndPoint[i].nEquNumber == EndPoint[k].nEquNumber); } if ( nNumFoundEqu <= 1 ) { /* one time it is equal to itself when i == k above */ /* if EndPoint[i] is not "equivalent" to any other EndPoint then ignore it */ continue; } #endif if ( i != j ) { /* save endpoints that are found to be connected to other endpoints by alt paths */ EndPoint[j] = EndPoint[i]; BondPos[j] = BondPos[i]; } j ++; } } #if ( IGNORE_SINGLE_ENDPOINTS != 1 ) /* 1-28-2003 */ /* Do not allow a centerpoint to have only one tautomeric bond */ /* Hack: we may have only one centerpoint */ /* BondPos[*].nAtomNumber are centerpoints */ if ( j == 1 ) { /* check if there exist other centerpoint neighbors * connected to it by another tautomeric-bond */ for ( i = 0, k = 0; i < at[BondPos[0].nAtomNumber].valence; i ++ ) { k += ( i != BondPos[0].neighbor_index && BOND_TAUTOM == (at[BondPos[0].nAtomNumber].bond_type[i] & ~BOND_MARK_ALL)); } if ( !k ) { j = 0; } } #endif *nNumEndPoints = *nNumBondPos = j; return j; } /*****************************************************************************/ /*#if ( MOVE_CHARGES == 1 ) */ /* { */ /*****************************************************************************/ /**********************************************/ /* */ /* definitions for positive ion recognition */ /* */ /**********************************************/ /*****************************************************************************/ typedef struct tagChargeType { /* meaning see in bCanBeACPoint() */ char elname[3]; S_CHAR charge; S_CHAR neutral_valence; S_CHAR neutral_bonds_valence; /* valence of a neutral atom */ S_CHAR cChangeValence; /* charge increases valence by this value */ S_CHAR cChargeType; /* different types are treated separately */ S_CHAR num_bonds; /* added 02-06-2005 */ } CHARGE_TYPE; CHARGE_TYPE CType[] = { { "N\0", 1, 3, 3, 1, 0, 0 }, { "P\0", 1, 3, 3, 1, 1, 0 }, #if ( ADD_MOVEABLE_O_PLUS == 1 ) { "O\0", 1, 2, 2, 1, 2, 2 }, /* added 02-06-2005 */ { "S\0", 1, 2, 2, 1, 3, 2 }, /* added 03-18-2005 */ { "Se", 1, 2, 2, 1, 4, 2 }, /* added 03-18-2005 */ { "Te", 1, 2, 2, 1, 5, 2 }, /* added 03-18-2005 */ #endif }; /* bits */ #define C_SUBTYPE_CHARGED 0 #define C_SUBTYPE_p_DONOR 1 /* new */ #define C_SUBTYPE_p_ACCEPT 2 /* new */ #define C_SUBTYPE_H_ACCEPT 4 #define C_SUBTYPE_H_DONOR 8 #define C_SUBTYPE_NEUTRAL 16 /* make sure any C_SUBTYPE_CHARGED_... < any C_SUBTYPE_NEUTRAL_... */ /* charged */ #define C_SUBTYPE_CHARGED_NON_TAUT (C_SUBTYPE_CHARGED) #define C_SUBTYPE_CHARGED_p_DONOR (C_SUBTYPE_CHARGED|C_SUBTYPE_p_DONOR) #define C_SUBTYPE_CHARGED_H_ACCEPT (C_SUBTYPE_CHARGED|C_SUBTYPE_H_ACCEPT) #define C_SUBTYPE_CHARGED_H_ACCEPT_p_DONOR (C_SUBTYPE_CHARGED|C_SUBTYPE_H_ACCEPT|C_SUBTYPE_p_DONOR) #define C_SUBTYPE_CHARGED_H_DONOR (C_SUBTYPE_CHARGED|C_SUBTYPE_H_DONOR |C_SUBTYPE_p_DONOR) /* neutral */ #define C_SUBTYPE_NEUTRAL_NON_TAUT (C_SUBTYPE_NEUTRAL) #define C_SUBTYPE_NEUTRAL_H_ACCEPT (C_SUBTYPE_NEUTRAL|C_SUBTYPE_H_ACCEPT) #define C_SUBTYPE_NEUTRAL_H_ACCEPT_p_ACCEPT (C_SUBTYPE_NEUTRAL|C_SUBTYPE_H_ACCEPT|C_SUBTYPE_p_ACCEPT) #define C_SUBTYPE_NEUTRAL_H_DONOR (C_SUBTYPE_NEUTRAL|C_SUBTYPE_H_DONOR) #define NUM_C_TYPES (int)(sizeof( CType )/sizeof(CType[0])) /*****************************************************************************/ /*****************************************************************************/ int bCanBeACPoint( inp_ATOM *at, S_CHAR cCharge, S_CHAR cChangeValence, S_CHAR neutral_bonds_valence, S_CHAR neutral_valence, S_CHAR nEndpointValence, S_CHAR *cChargeSubtype ) { int nChangeValence; int nNumBonds; int nBondsValence; int bNegCharge = (at->charge == -1); /* add fict. bonds to (-) 2004-02-24*/ if ( at->charge == cCharge && at->valence == at->chem_bonds_valence && at->num_H ) { /* proton donors candidates >NH(+)-, >NH2(+), -NH3(+), >OH(+), -OH2(+) */ /* charged, added p-transfer -- 01-28-2004 */ nChangeValence = at->charge * cChangeValence; /* +1 or -1; currently only +1 */ nBondsValence = at->chem_bonds_valence + at->num_H; if ( nBondsValence == neutral_bonds_valence + nChangeValence && nEndpointValence ) { *cChargeSubtype = C_SUBTYPE_CHARGED_p_DONOR; /* ignore Phosphorus p-donors for now */ } return 0; } else if ( at->charge == cCharge && at->valence < at->chem_bonds_valence ) { /* the requirement at->valence < at->chem_bonds_valence rejects candidates >NH(+)-, >NH2(+), -NH3(+), >N(+)<, >OH(+), -OH2(+), >O(+)- Moveable charge requires double bonds; these ions have no double bonds */ /* charged */ nChangeValence = at->charge * cChangeValence; /* +1 or -1; currently only +1 */ nBondsValence = at->chem_bonds_valence + at->num_H; nNumBonds = at->valence + at->num_H; if ( nBondsValence == neutral_bonds_valence + nChangeValence ) { /* known valence */ if ( nNumBonds == neutral_valence ) { /* non-tautomeric: >N(+)=, =O(+)- possibly tautomeric donor: =NH(+)-, =NH2(+), =OH(+) */ if ( at->valence == neutral_valence || !nEndpointValence ) { /* non-tautomeric: >N(+)=, =O(+)-; any suitable P+: >P(+)=, =PH(+)-, =PH2(+) */ *cChargeSubtype = C_SUBTYPE_CHARGED_NON_TAUT; } else { /* possibly tautomeric donor: =NH(+)-, =NH2(+), =OH(+) */ *cChargeSubtype = C_SUBTYPE_CHARGED_H_DONOR; } return 1; } if ( nNumBonds == neutral_valence - 1 ) { /* possibly tutomeric acceptor: =N(+)=, #N(+)-, #NH(+), #O(+) */ if ( nEndpointValence ) { *cChargeSubtype = at->num_H? C_SUBTYPE_CHARGED_H_ACCEPT_p_DONOR : C_SUBTYPE_CHARGED_H_ACCEPT; } else { /* =P(+)=, #P(+)-, #PH(+) */ *cChargeSubtype = C_SUBTYPE_CHARGED_NON_TAUT; } return 1; /* charge type, charged */ } } } else if ( at->charge == 0 || bNegCharge ) { /* neutral atom or anion, all bonds are single */ nBondsValence = at->chem_bonds_valence + at->num_H + bNegCharge; /* add fict. bonds to (-) 2004-02-24*/ nNumBonds = at->valence + at->num_H + bNegCharge; /* add fict. bonds to (-) 2004-02-24*/ if ( nBondsValence == neutral_bonds_valence ) { if ( nNumBonds == neutral_valence ) { /* only single bonds: >N-, >NH, -NH2, -O-, -OH, >P- >PH -PH2 */ /* >N(-), -NH(-), -O(-). >P(-) -PH(-) */ if ( at->valence == neutral_valence || !nEndpointValence ) { /* >N-, -O-, any P(3 single bonds): >P- >PH -PH2 */ *cChargeSubtype = C_SUBTYPE_NEUTRAL_NON_TAUT; } else if ( at->valence < neutral_valence /*&& nEndpointValence */ ) { /* num_H > 0: >NH -NH2 -OH */ /* num_H = 0: none C_SUBTYPE_NEUTRAL_H_ACCEPT for now */ *cChargeSubtype = at->num_H? C_SUBTYPE_NEUTRAL_H_DONOR: C_SUBTYPE_NEUTRAL_H_ACCEPT; } else { return 0; } return 1; /* charge type, neutral */ } if ( nNumBonds == neutral_valence - 1 ) { /* possibly tautomeric acceptor =N-, =NH, =O or non-taut =P-, =PH */ if ( nEndpointValence ) { /* =N-, =NH, =O */ *cChargeSubtype = C_SUBTYPE_NEUTRAL_H_ACCEPT_p_ACCEPT; } else { /* =P-, =PH */ *cChargeSubtype = C_SUBTYPE_NEUTRAL_NON_TAUT; } return 1; /* charge type, (+) => neutral */ } } } return 0; } /*****************************************************************************/ int GetChargeType( inp_ATOM *atom, int iat, S_CHAR *cChargeSubtype ) { int i, n; S_CHAR nEndpointValence; inp_ATOM *at = atom + iat; *cChargeSubtype = 0; /* ignore ion pairs and charges != 1 */ if ( abs(at->charge) == 1 ) { for ( i = 0; i < at->valence; i ++ ) { n = at->neighbor[i]; /* allow negatively charged tautomeric neighbors 2004-02-26 */ if ( abs(atom[n].charge + at->charge) < abs(atom[n].charge - at->charge) && !atom[n].endpoint ) { return -1; /* charges have different signs */ } } } else if ( at->charge ) { return -1; /* abs(charge) != 1 */ } /* find candidates */ for ( i = 0; i < NUM_C_TYPES; i ++ ) { if ( !strcmp( at->elname, CType[i].elname ) && (!CType[i].num_bonds || CType[i].num_bonds==at->valence && at->nNumAtInRingSystem >= 5) ) { nEndpointValence = (S_CHAR)get_endpoint_valence(at->el_number ); if ( bCanBeACPoint( at, CType[i].charge, CType[i].cChangeValence, CType[i].neutral_bonds_valence, CType[i].neutral_valence, nEndpointValence, cChargeSubtype ) ) { return CType[i].cChargeType; } } } return -1; } /*****************************************************************************/ int CmpCCandidates( const void *a1, const void *a2 ) { const C_CANDIDATE *c1 = (const C_CANDIDATE *)a1; const C_CANDIDATE *c2 = (const C_CANDIDATE *)a2; int ret; if ( ret = (int)c1->type - (int)c2->type ) return ret; if ( ret = (int)c1->subtype - (int)c2->subtype ) return ret; ret = (int)c1->atnumber - (int)c2->atnumber; return ret; } /*****************************************************************************/ int RegisterCPoints( C_GROUP *c_group, int *pnum_c, int max_num_c, T_GROUP_INFO *t_group_info, int point1, int point2, int ctype, inp_ATOM *at, int num_atoms ) { int num_c = *pnum_c, i, i1, i2; AT_NUMB nGroupNumber = 0, nNewGroupNumber; if ( at[point1].c_point == at[point2].c_point ) { if ( at[point1].c_point ) return 0; memset( c_group+num_c, 0, sizeof(c_group[0]) ); if ( num_c < max_num_c ) { c_group[num_c].num[0] = CHARGED_CPOINT(at,point1) + CHARGED_CPOINT(at, point2); c_group[num_c].num_CPoints += 2; c_group[num_c].cGroupType = ctype; /* get next available c-group number */ for ( i = 0; i < num_c; i ++ ) { if ( nGroupNumber < c_group[i].nGroupNumber ) nGroupNumber = c_group[i].nGroupNumber; } nGroupNumber ++; c_group[num_c].nGroupNumber = at[point1].c_point = at[point2].c_point = nGroupNumber; *pnum_c = num_c+1; /* count protons */ if ( at[point1].num_H ) { c_group[num_c].num[1] ++; } else if ( at[point2].num_H ) { c_group[num_c].num[1] ++; } else if ( (at[point1].endpoint || at[point2].endpoint) && t_group_info && t_group_info->t_group && t_group_info->num_t_groups ) { /* !!! add later !!! */ } return 1; } return BNS_CPOINT_ERR; /* overflow */ } if ( at[point1].c_point > at[point2].c_point ) { /* make sure at[point1].c_point < at[point2].c_point */ i = point1; point1 = point2; point2 = i; } if ( !at[point1].c_point ) { /* add a new c-endpoint to an existing c-group */ nGroupNumber = at[point2].c_point; for ( i = 0; i < num_c; i ++ ) { if ( nGroupNumber == c_group[i].nGroupNumber ) { at[point1].c_point = at[point2].c_point; c_group[i].num_CPoints ++; c_group[i].num[0] += CHARGED_CPOINT(at,point1); return 1; } } return BNS_CPOINT_ERR; /* program error: c-group not found */ } else { /* merge two c-groups */ nNewGroupNumber = at[point1].c_point; nGroupNumber = at[point2].c_point; for ( i = 0, i1=i2=-1; i < num_c && (i1 < 0 || i2 < 0); i ++ ) { if ( nNewGroupNumber == c_group[i].nGroupNumber ) { i1 = i; continue; } if ( nGroupNumber == c_group[i].nGroupNumber ) { i2 = i; continue; } } if ( i1 < 0 || i2 < 0 ) { return BNS_CPOINT_ERR; /* at least one not found */ } c_group[i1].num[0] += c_group[i2].num[0]; c_group[i1].num_CPoints += c_group[i2].num_CPoints; num_c --; if ( num_c > i2 ) { memmove( c_group+i2, c_group+i2+1, ( num_c - i2)*sizeof(c_group[0]) ); } *pnum_c = num_c; /* renumber c-groups */ for ( i = 0; i < num_c; i ++ ) { if ( c_group[i].nGroupNumber > nGroupNumber ) { c_group[i].nGroupNumber --; } } /* renumber c-points */ for ( i = 0; i < num_atoms; i ++ ) { if ( at[i].c_point > nGroupNumber ) { at[i].c_point --; } else if ( at[i].c_point == nGroupNumber ) { at[i].c_point = nNewGroupNumber; } } return 1; } } /*****************************************************************************/ int MarkChargeGroups(inp_ATOM *at, int num_atoms, C_GROUP_INFO *c_group_info, T_GROUP_INFO *t_group_info, struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD) { int nNumChanges = 0; if ( c_group_info && c_group_info->c_candidate && c_group_info->max_num_candidates > 0 ) { int i, i1, i2, i3, j, num_tested; C_CANDIDATE *c_candidate = c_group_info->c_candidate; int nMaxNumCandidates = c_group_info->max_num_candidates; int nNumCandidates = c_group_info->num_candidates; S_CHAR c_type, c_subtype; int iat1, iat2, ret, nDelta; if ( nNumCandidates == -1 ) { nNumCandidates = 0; /* 2004-02-26 they could appear after t-group discovery */ /*return 0;*/ } if ( nNumCandidates == 0 ) { for ( i = 0, nNumCandidates = 0; i < num_atoms; i ++ ) { if ( 0 <= (c_type = GetChargeType( at, i, &c_subtype )) ) { if ( nNumCandidates >= nMaxNumCandidates ) { return BNS_VERT_EDGE_OVFL; } c_candidate[nNumCandidates].atnumber = i; c_candidate[nNumCandidates].type = c_type; c_candidate[nNumCandidates].subtype = c_subtype; nNumCandidates ++; } } if ( nNumCandidates <= 1 ) { c_group_info->num_candidates = -1; /* no candidate exists */ return 0; } } /* sorting keys: (1) atom type (N,P); (2) uncharged=16/charged=0; (3) other; atom-charged-N .... i1 ... atom-charged-N atom-neutral-N .... i2 ... atom-neutral-N atom-charged-P .... i3 ... i1 ... atom-charged-P atom-neutral-P ........... i2 ... atom-neutral-P end. ........... i3 */ qsort(c_candidate, nNumCandidates, sizeof(c_candidate[0]), CmpCCandidates); i1 = 0; num_tested = 0; nDelta = 0; while ( i1 < nNumCandidates ) { /* the the first charged candidate of a new atom type */ for (; i1 < nNumCandidates && (c_candidate[i1].subtype & C_SUBTYPE_NEUTRAL); i1 ++) ; if ( i1 == nNumCandidates ) break; /* not found */ /* bypass other charged candidates of the same atom type */ for ( i2 = i1+1; i2 < nNumCandidates && c_candidate[i2].type == c_candidate[i1].type && !(c_candidate[i2].subtype & C_SUBTYPE_NEUTRAL); i2++ ) ; if ( i2 == nNumCandidates ) break; /* no neutral candidates */ /* find next to the last neutral candidate of the same atom type */ for ( i3 = i2; i3 < nNumCandidates && c_candidate[i3].type == c_candidate[i1].type; i3 ++ ) ; if ( i3 == i2 ) { /* no neutral candidates found */ if ( i2 < nNumCandidates ) { i1 = i3; continue; /* move to the next atom type */ } break; /* nothing more to do */ } /* found charged candidates: i1...i2-1; neutral candidates: i2...i3-1 */ for ( i = i1; i < i2; i ++ ) { iat1 = c_candidate[i].atnumber; for ( j = i2; j < i3; j ++ ) { /* check alt path at[iat1]=-=-...-at[iat2]; at[iat1] is charged, at[iat2] is neutral */ num_tested ++; iat2 = c_candidate[j].atnumber; if ( at[iat1].c_point && at[iat1].c_point == at[iat2].c_point ) continue; ret = bExistsAltPath( pBNS, pBD, NULL, at, num_atoms, iat1, iat2, ALT_PATH_MODE_CHARGE ); if ( IS_BNS_ERROR( ret ) ) { return ret; } if ( ret & 1 ) { nDelta = (ret & ~3) >> 2; nNumChanges += (ret & 2); ret = RegisterCPoints( c_group_info->c_group, &c_group_info->num_c_groups, c_group_info->max_num_c_groups, t_group_info, iat1, iat2, c_candidate[i1].type, at, num_atoms ); if ( IS_BNS_ERROR( ret ) ) { return ret; } if ( nDelta ) { goto quick_exit; } } } } i1 = i3; } quick_exit: if ( c_group_info->num_candidates == 0 ) { /* first time: initialize */ c_group_info->num_candidates = num_tested? nNumCandidates : -1; /* no candidate exists */ } } return nNumChanges; } /*****************************************************************************/ int GetSaltChargeType(inp_ATOM *at, int at_no, T_GROUP_INFO *t_group_info, int *s_subtype ) { static int el_number_C = 0; static int el_number_O = 0; static int el_number_S = 0; static int el_number_Se = 0; static int el_number_Te = 0; /* type (returned value): -1 => ignore 0 => oxygen subtype: 1 = SALT_DONOR_H => has H 2 = SALT_DONOR_Neg => has (-) charge 4 = SALT_ACCEPTOR => may be an acceptor of H or (-), but not necessarily O-atom should be: - a terminal atom - connected to unsaturated, uncharged, non-radical atom C that has chemical valence 4: H-donors: =CH-OH, =C(-X)-OH possible H-acceptors: -CH=O, >C=O H-acceptors are true if O is tautomeric */ int iC, tg, i, type; /* one-time initialization */ if ( !el_number_O ) { el_number_C = get_periodic_table_number( "C" ); el_number_O = get_periodic_table_number( "O" ); el_number_S = get_periodic_table_number( "S" ); el_number_Se = get_periodic_table_number( "Se" ); el_number_Te = get_periodic_table_number( "Te" ); } *s_subtype = 0; /* initialize the output */ /* check whether it is a candidate */ if ( at[at_no].valence != 1 || at[at_no].radical && at[at_no].radical != RADICAL_SINGLET || at[at_no].charge < -1 || at[at_no].charge > 0 && !at[at_no].c_point ) { return -1; } if ( at[at_no].el_number == el_number_O || at[at_no].el_number == el_number_S || at[at_no].el_number == el_number_Se || at[at_no].el_number == el_number_Te ) { type = 0; /* terminal oxygen atom, needs more to be checked... */ } else { type = -1; /* ignore this atom */ } if ( type < 0 || at[at_no].chem_bonds_valence + at[at_no].num_H != get_el_valence(at[at_no].el_number, at[at_no].charge, 0) ) { return -1; /* non-standard valence or not an oxygen */ } iC = at[at_no].neighbor[0]; #if ( SALT_WITH_PROTONS == 1 ) if ( at[iC].el_number != el_number_C || at[iC].chem_bonds_valence + at[iC].num_H != 4 || /* allow =C(H)-OH or -C(H)=O */ at[iC].charge || at[iC].radical && at[iC].radical != RADICAL_SINGLET || at[iC].valence == at[iC].chem_bonds_valence ) { return -1; /* oxigen is connected to a wrong atom */ } #else if ( at[iC].el_number != el_number_C || at[iC].num_H || at[iC].chem_bonds_valence != 4 || /* allow only no H on C */ at[iC].charge || at[iC].radical && at[iC].radical != RADICAL_SINGLET || at[iC].valence == at[iC].chem_bonds_valence ) { return -1; /* oxigen is connected to a wrong atom */ } #endif if ( (tg = at[at_no].endpoint) && t_group_info && t_group_info->t_group ) { /* O-atom is in a tautomeric group */ for ( i = 0; i < t_group_info->num_t_groups; i ++ ) { if ( tg == t_group_info->t_group[i].nGroupNumber ) { /* t_group_info->t_group[i].num[0] = number of attached H-atoms and negative charges t_group_info->t_group[i].num[1] = number of attached negative charges */ if ( t_group_info->t_group[i].num[0] > t_group_info->t_group[i].num[1] ) { *s_subtype |= SALT_DONOR_H; /* has H */ } if ( t_group_info->t_group[i].num[1] ) { *s_subtype |= SALT_DONOR_Neg; /* has (-) */ } *s_subtype |= SALT_ACCEPTOR; /* there is always an acceptor in a t-group */ return type; } } return -1; /* error: t-group not found */ } /* O is not not in a tautomeric group */ /* assume valence(O-) < valence(O) < valence(O+) */ if ( at[at_no].charge == -1 ) { *s_subtype |= SALT_DONOR_Neg; /* has (-) */ } if ( at[at_no].charge <= 0 && at[at_no].num_H ) { *s_subtype |= SALT_DONOR_H; /* has H */ } if ( at[at_no].charge == 0 && at[at_no].chem_bonds_valence == 2 ) { *s_subtype |= SALT_ACCEPTOR; } /* since O cannot be a charge point, the following cannot happen: */ if ( at[at_no].charge == 1 && at[at_no].c_point && at[at_no].chem_bonds_valence == 2 && at[at_no].num_H ) { *s_subtype |= SALT_DONOR_H; /* has H */ } return type; } /*****************************************************************************/ int bDoNotMergeNonTautAtom(inp_ATOM *at, int at_no) { static int el_number_N = 0; if ( !el_number_N ) { el_number_N = get_periodic_table_number( "N" ); } if ( at[at_no].el_number == el_number_N ) { return 1; } return 0; } /*****************************************************************************/ int GetOtherSaltChargeType( inp_ATOM *at, int at_no, T_GROUP_INFO *t_group_info, int *s_subtype, int bAccept_O ) { /* static int el_number_C = 0; */ /* static int el_number_N = 0; */ static int el_number_O = 0; static int el_number_S = 0; static int el_number_Se = 0; static int el_number_Te = 0; /* type (returned value): -1 => ignore 1 => not an oxygen subtype: 1 = SALT_DONOR_H => has H 2 = SALT_DONOR_Neg => has (-) charge 4 = SALT_ACCEPTOR => may be an acceptor of H or (-), but not necessarily the atom should be: - a tautomeric endpoint atom - connected to possible centerpoint atom another description of the atom searched here: any possibly tautomeric atom adjacent to a possibly centerpoint that has at least one double bond (possibly if positively charged); if eif.cAcceptor then the bond between the atom and the centerpoint must be possibly double if eif.cAcceptor then the bond must be possibly single Donors that belong to a t-group are also acceptors */ int tg, i, j, type, endpoint_valence, num_centerpoints, bond_type, centerpoint; ENDPOINT_INFO eif; /* one-time initialization */ if ( !el_number_O && !bAccept_O ) { /* el_number_C = get_periodic_table_number( "C" ); */ /* el_number_N = get_periodic_table_number( "N" ); */ el_number_O = get_periodic_table_number( "O" ); el_number_S = get_periodic_table_number( "S" ); el_number_Se = get_periodic_table_number( "Se" ); el_number_Te = get_periodic_table_number( "Te" ); } *s_subtype = 0; /* initialize the output */ if ( !bAccept_O /* only N */ && (at[at_no].el_number == el_number_O || at[at_no].el_number == el_number_S || at[at_no].el_number == el_number_Se || at[at_no].el_number == el_number_Te ) ) { return -1; /* we are not looking for oxygen here */ } type = 1; if ( !(endpoint_valence = nGetEndpointInfo( at, at_no, &eif )) ) { return -1; /* not a possible endpoint */ } else { /* at[at_no] is not not in a tautomeric group; use eif previously filled out by nGetEndpointInfo */ /* check whether there is adjacent atom-candidate for a centerpoint */ num_centerpoints = 0; for ( j = 0; j < at[at_no].valence; j ++ ) { bond_type = (int)at[at_no].bond_type[j] & BOND_TYPE_MASK; centerpoint = (int)at[at_no].neighbor[j]; /* a centerpoint candidate */ if ( ( eif.cAcceptor && (bond_type == BOND_DOUBLE || bond_type == BOND_ALTERN || /* possibly double */ bond_type == BOND_ALT12NS || bond_type == BOND_TAUTOM ) || eif.cDonor && (bond_type == BOND_SINGLE || bond_type == BOND_ALTERN || /* possibly single */ bond_type == BOND_ALT12NS || bond_type == BOND_TAUTOM ) ) && (at[centerpoint].chem_bonds_valence > at[centerpoint].valence || /* check for possible endpoint added 2004-02-24 */ at[centerpoint].chem_bonds_valence == at[centerpoint].valence && (at[centerpoint].endpoint || at[centerpoint].c_point) /* tautomerism or charge may increment at[centerpoint].chem_bonds_valence*/ ) && is_centerpoint_elem( at[centerpoint].el_number ) ) { num_centerpoints ++; break; /* at least one possibly centerpoint neighbor has been found */ } } if ( !num_centerpoints ) { return -1; } /* moved here from just after "type = 1;" line 2004-02-26 */ if ( (tg = at[at_no].endpoint) && t_group_info && t_group_info->t_group ) { /* atom is in a tautomeric group */ for ( i = 0; i < t_group_info->num_t_groups; i ++ ) { if ( tg == t_group_info->t_group[i].nGroupNumber ) { /* t_group_info->t_group[i].num[0] = number of attached H-atoms and negative charges t_group_info->t_group[i].num[1] = number of attached negative charges */ if ( t_group_info->t_group[i].num[0] > t_group_info->t_group[i].num[1] ) { *s_subtype |= SALT_DONOR_H; /* has H */ } if ( t_group_info->t_group[i].num[1] ) { *s_subtype |= SALT_DONOR_Neg; /* has (-) */ } *s_subtype |= SALT_ACCEPTOR; /* there is always an acceptor in a t-group */ return type; } } return -1; /* error: t-group not found */ } if ( eif.cAcceptor ) { *s_subtype |= SALT_ACCEPTOR; } if ( eif.cDonor ) { if ( at[at_no].charge == -1 ) { *s_subtype |= SALT_DONOR_Neg; /* has (-) */ } if ( at[at_no].num_H ) { *s_subtype |= SALT_DONOR_H; /* has H */ } } } return type; } /*****************************************************************************/ int GetOtherSaltType( inp_ATOM *at, int at_no, int *s_subtype ) { static int el_number_C = 0; /* static int el_number_N = 0; */ /* static int el_number_O = 0; */ static int el_number_S = 0; static int el_number_Se = 0; static int el_number_Te = 0; /* type (returned value): -1 => ignore 2 => found: SH proton donor -CH2-SH, >CH-SH, >C< S(-) proton acceptor -CH2-S(-), >CH-S(-), >C< subtype: 1 = SALT_DONOR_H => has H 2 = SALT_DONOR_Neg => has (-) charge 4 = SALT_ACCEPTOR => may be an acceptor of H or (-), but not necessarily non-O-atom should be: - a tautomeric endpoint atom - connected to possible middle point atom */ int type, endpoint_valence, bond_type, centerpoint; ENDPOINT_INFO eif; if ( at[at_no].valence != 1 || at[at_no].chem_bonds_valence != 1 || 1 != (at[at_no].num_H==1) + (at[at_no].charge==-1) ) { return -1; } /* one-time initialization */ if ( !el_number_S ) { el_number_C = get_periodic_table_number( "C" ); /* el_number_N = get_periodic_table_number( "N" ); */ /* el_number_O = get_periodic_table_number( "O" ); */ el_number_S = get_periodic_table_number( "S" ); el_number_Se = get_periodic_table_number( "Se" ); el_number_Te = get_periodic_table_number( "Te" ); } *s_subtype = 0; /* initialize the output */ if ( !(at[at_no].el_number == el_number_S || at[at_no].el_number == el_number_Se || at[at_no].el_number == el_number_Te ) ) { return -1; /* we are not looking for oxygen here */ } type = 2; /* non-tautomeric p-donor or acceptor: C-SH, C-S(-) */ if ( !(endpoint_valence = nGetEndpointInfo( at, at_no, &eif )) || eif.cMoveableCharge && !at[at_no].c_point || !eif.cDonor || eif.cAcceptor ) { return -1; /* not a possible -SH or -S(-) */ } else { /* at[at_no] is not not in a tautomeric group; use eif previously filled out by nGetEndpointInfo */ /* check whether there is adjacent atom-candidate for a centerpoint */ centerpoint = (int)at[at_no].neighbor[0]; bond_type = (int)at[at_no].bond_type[0] & BOND_TYPE_MASK; if ( at[centerpoint].el_number != el_number_C || at[centerpoint].charge || at[centerpoint].radical && at[centerpoint].radical != RADICAL_SINGLET || at[centerpoint].valence != at[centerpoint].chem_bonds_valence ) { return -1; /* not a carbon with all single bonds */ } if ( at[at_no].num_H == 1 ) { *s_subtype |= SALT_p_DONOR; } else if ( at[at_no].charge == -1 ) { *s_subtype |= SALT_p_ACCEPTOR; } else { return -1; } } return type; } /********************************************************************************************************/ /* new version: merge all, check alt paths, then unmerge unreachable O-atoms if any */ /* Check for oxygen negative charge-H tautomerism (Salts) allowed long-range tautomerism; more than one H or (-) can be moved, for example: HO-C=C-O(-) O=C-C=O / \ / \ R R R R | | => | | R' R' R' R' \ / \ / O=C-C=O HO-C=C-O(-) To check: | | -add all possible HO-C=, O=C, (-)O-C= (including all containing O t-groups) into one t-group; -temporarily disconnect one of previously not belonging to any t-group O-atoms from the one t-group; -find whether there is an alt path allowing H or (-) to migrate from the temp. disconnected O to any one left in the group. If the alt path does not exist then the temp. disconnected atom does not participate in the H/(-) migrartion and it will be unmarked/unmerged. */ /*****************************************************************************/ int comp_candidates( const void *a1, const void *a2 ) { const S_CANDIDATE *s1 = (const S_CANDIDATE *)a1; const S_CANDIDATE *s2 = (const S_CANDIDATE *)a2; int ret; if ( s1->type >= 0 /* enabled < */ && s2->type < 0 /* disabled */ ) return -1; /* enabled goes first */ if ( s1->type < 0 /* disabled > */ && s2->type >= 0 /* enabled */ ) return 1; if ( s1->endpoint && !s2->endpoint ) return -1; /* tautomeric goes first; only tautomeric may be disabled */ if ( !s1->endpoint && s2->endpoint ) return 1; /* tautomeric goes first; only tautomeric may be disabled */ if ( s1->endpoint && s2->endpoint && (ret = (int)s1->endpoint - (int)s2->endpoint) ) { return ret; } return (int)s1->atnumber - (int)s2->atnumber; } /*****************************************************************************/ int MarkSaltChargeGroups2 ( inp_ATOM *at, int num_atoms, S_GROUP_INFO *s_group_info, T_GROUP_INFO *t_group_info, C_GROUP_INFO *c_group_info, struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD ) { /* BNS_EDGE_FORBIDDEN_TEMP */ #define ALT_PATH_FOUND (MAX_ATOMS+1) #define NO_ENDPOINT (MAX_ATOMS+2) /* the two defines must be different */ #define DISABLE_CANDIDATE 10 #define cPAIR(a,b) cPair[a+b*nNumLeftCandidates] #define ACCEPTOR_PAIR 1 #define DONOR_PAIR 2 int nNumChanges = 0, nNumOtherChanges = 0, nNumAcidicChanges = 0, nTotNumChanges = 0; S_CHAR *cPair = NULL; T_ENDPOINT *EndPoint = NULL; if ( s_group_info && s_group_info->s_candidate && s_group_info->max_num_candidates > 0 ) { int i, j, i1, j1; S_CANDIDATE *s_candidate = s_group_info->s_candidate; int nMaxNumCandidates = s_group_info->max_num_candidates; int nNumCandidates = s_group_info->num_candidates; int nNumOtherCandidates = s_group_info->num_other_candidates; int nNumPOnlyCandidates = s_group_info->num_p_only_candidates; int nNumLeftCandidates = 0; int nNumMarkedCandidates = 0; int s_type, s_subtype; int ret, nDelta; int bHardAddedRemovedProtons = t_group_info && (t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT); int s_subtype_all = 0; int nDonorPairs, nAcceptorPairs, nCurDonorPairs, nCurAcceptorPairs, bAlreadyTested; /* ENDPOINT_INFO eif; */ #if ( IGNORE_TGROUP_WITHOUT_H == 1 ) int bTGroupHasNegativeChargesOnly = 1; #endif /*return 0;*/ /* debug only */ i1 = -1; if ( nNumCandidates <= -2 || !t_group_info || !t_group_info->t_group ) { return 0; } /*************************************************************************/ /* find all candidates including those with differen s_type (other type) */ /*************************************************************************/ for ( i = 0, nNumCandidates = nNumOtherCandidates = nNumPOnlyCandidates = 0; i < num_atoms; i ++ ) { if ( 0 == (s_type = GetSaltChargeType( at, i, t_group_info, &s_subtype )) || /* -C=O or =C-OH, O = S, Se, Te */ 1 == (s_type = GetOtherSaltChargeType( at, i, t_group_info, &s_subtype, 1/* bAccept_O*/ )) || /* =Z-MH or -Z=M, Z = centerpoint, M = endpoint, other than above */ 2 == (s_type = GetOtherSaltType( at, i, &s_subtype ) ) || ( bHardAddedRemovedProtons && 4 == (s_type = bIsHardRemHCandidate( at, i, &s_subtype ) ) ) /* >C-SH, >C-S(-); S=S,Se,Te */ ) { if ( nNumCandidates >= nMaxNumCandidates ) { return BNS_VERT_EDGE_OVFL; } s_candidate[nNumCandidates].atnumber = i; s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i].endpoint; nNumCandidates ++; nNumOtherCandidates += (1 == s_type); s_subtype_all |= s_subtype; i1 = i; /* save a representative of a tautomeric group */ } } if ( nNumCandidates <= 1 || /* TG_FLAG_ALLOW_NO_NEGTV_O <=> CHARGED_SALTS_ONLY=0 */ !(s_subtype_all & SALT_ACCEPTOR) || (((t_group_info->bTautFlags & TG_FLAG_ALLOW_NO_NEGTV_O) || (t_group_info->bTautFlagsDone & TG_FLAG_FOUND_SALT_CHARGES_DONE) || (t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT)) ? !(s_subtype_all & (SALT_DONOR)): (!(s_subtype_all & SALT_DONOR_Neg) || nNumOtherCandidates == nNumCandidates )) ) { s_group_info->num_candidates = 0; /* no candidate exists */ return 0; } if ( !(s_subtype_all & (SALT_DONOR_Neg) ) ) { t_group_info->bTautFlagsDone |= TG_FLAG_ALLOW_NO_NEGTV_O_DONE; } /************************************************************************************/ /* Mark redundant candidates so that only one candidate from one t-group is left in */ /************************************************************************************/ for ( i = 0; i < nNumCandidates; i ++ ) { if ( 2 == s_candidate[nNumCandidates].type ) { s_candidate[i].type -= DISABLE_CANDIDATE; /* disable >C-SH candidates */ nNumLeftCandidates ++; /* count rejected */ continue; } if ( s_candidate[i].endpoint ) { for ( j = i-1; 0 <= j; j -- ) { if ( s_candidate[i].endpoint == s_candidate[j].endpoint ) { s_candidate[i].type -= DISABLE_CANDIDATE; /* disable subsequent redundant */ nNumLeftCandidates ++; /* count rejected */ break; } } } } nNumLeftCandidates = nNumCandidates - nNumLeftCandidates; /* subtract num. rejected from the total */ s_group_info->num_candidates = 0; /* reinit next time */ /*********************************************************************/ /* reorder so that all disabled are at the end, tautomeric are first */ /*********************************************************************/ qsort ( s_candidate, nNumCandidates, sizeof(s_candidate[0]), comp_candidates ); cPair = (S_CHAR *)inchi_calloc( nNumLeftCandidates*nNumLeftCandidates, sizeof(cPair[0]) ); if ( !cPair ) { /*printf("BNS_OUT_OF_RAM-6\n");*/ nTotNumChanges = BNS_OUT_OF_RAM; goto quick_exit; } nDonorPairs = nAcceptorPairs = 0; /**********************************************************************/ /* Find whether we have at least one donor pair and one acceptor pair */ /**********************************************************************/ for ( i = 0; i < nNumLeftCandidates; i ++ ) { nCurDonorPairs = nCurAcceptorPairs = 0; for ( j = 0; j <= i; j ++ ) { if ( i == j && !s_candidate[i].endpoint ) { continue; /* same non-taut atom. However, success for i==j means * * that the whole tautomeric group may donate or accept 2H */ } /* check for acceptor pair */ if ( (s_candidate[i].subtype & SALT_ACCEPTOR) && (s_candidate[j].subtype & SALT_ACCEPTOR) && (ret = bExistsAltPath( pBNS, pBD, NULL, at, num_atoms, s_candidate[i].atnumber, s_candidate[j].atnumber, ALT_PATH_MODE_ADD2H_TST ))) { if ( IS_BNS_ERROR( ret ) ) { nTotNumChanges = ret; goto quick_exit; } if ( ret & 1 ) { nDelta = (ret & ~3) >> 2; /*nNumChanges += (ret & 2);*/ if ( nDelta ) { /* alt path unleashed previously localized radicals and they annihilated */ nNumChanges = 0; nTotNumChanges = BNS_RADICAL_ERR; goto quick_exit; } cPAIR(i,j) |= ACCEPTOR_PAIR; /* the result: mark the pair */ /*cPAIR(j,i) |= ACCEPTOR_PAIR;*/ } } /* check for donor pair */ if ( (s_candidate[i].subtype & SALT_DONOR) && (s_candidate[j].subtype & SALT_DONOR) && (ret = bExistsAltPath( pBNS, pBD, NULL, at, num_atoms, s_candidate[i].atnumber, s_candidate[j].atnumber, ALT_PATH_MODE_REM2H_TST ))) { if ( IS_BNS_ERROR( ret ) ) { nTotNumChanges = ret; goto quick_exit; } if ( ret & 1 ) { nDelta = (ret & ~3) >> 2; /*nNumChanges += (ret & 2);*/ if ( nDelta ) { /* alt path unleashed previously localized radicals and they annihilated */ nNumChanges = 0; nTotNumChanges = BNS_RADICAL_ERR; goto quick_exit; } cPAIR(i,j) |= DONOR_PAIR; /* the result: mark the pair */ /*cPAIR(j,i) |= ACCEPTOR_PAIR;*/ } } /* since the results will be used later to change bonds, check only now */ /* when both results for (i,j) have been obtained. */ if ( cPAIR(i,j) & ACCEPTOR_PAIR ) { nCurAcceptorPairs ++; if ( nDonorPairs ) { /* find donor pair (i1,j1) such that i!=i1, i!=j1, j!=i1, j!=j1 */ for ( i1 = 0; i1 < i; i1 ++ ) { for ( j1 = 0; j1 <= i1; j1 ++ ) { /* here always j1 < i && i1 < i therefore we do not compare i to i1 or j1 */ if ( j1 != j && i1 != j && (cPAIR(i1,j1) & DONOR_PAIR) ) { /* both the donor and the acceptor pairs have been found */ goto bFound2Pairs; } } } } } if ( cPAIR(i,j) & DONOR_PAIR ) { nCurDonorPairs ++; if ( nAcceptorPairs ) { /* find acceptor pair (i1,j1) such that i!=i1, i!=j1, j!=i1, j!=j1 */ for ( i1 = 0; i1 < i; i1 ++ ) { for ( j1 = 0; j1 <= i1; j1 ++ ) { /* here always j1 < i && i1 < i therefore we do not compare i to i1 or j1 */ if ( j1 != j && i1 != j && (cPAIR(i1,j1) & ACCEPTOR_PAIR) ) { /* both the donor and the acceptor pairs have been found */ goto bFound2Pairs; } } } } } } nDonorPairs += nCurDonorPairs; nAcceptorPairs += nCurAcceptorPairs; } /* nothing has been found */ nNumChanges = 0; inchi_free( cPair ); cPair = NULL; goto quick_exit; /* both the donor and the acceptor pairs have been found */ bFound2Pairs: /* first, try already found pairs */ i1 = i; j1 = j; /* Find all possible donor and acceptor pairs */ nNumMarkedCandidates = 0; for ( i = 0; i < nNumLeftCandidates; i ++ ) { nCurDonorPairs = nCurAcceptorPairs = 0; for ( j = 0; j <= i; j ++ ) { bAlreadyTested = (i < i1 || i == i1 && j <= j1); if ( bAlreadyTested && (cPAIR(i,j) & ACCEPTOR_PAIR) || !bAlreadyTested ) { /* checking for acceptor pair */ if ( (s_candidate[i].subtype & SALT_ACCEPTOR) && (s_candidate[j].subtype & SALT_ACCEPTOR) && (ret = bExistsAltPath( pBNS, pBD, NULL, at, num_atoms, s_candidate[i].atnumber, s_candidate[j].atnumber, ALT_PATH_MODE_ADD2H_CHG ))) { if ( IS_BNS_ERROR( ret ) ) { nTotNumChanges = ret; goto quick_exit; } if ( ret & 1 ) { nDelta = (ret & ~3) >> 2; nNumChanges += (ret & 2); if ( nDelta ) { /* alt path unleashed previously localized radicals and they annihilated */ nNumChanges = 0; nTotNumChanges = BNS_RADICAL_ERR; goto quick_exit; } cPAIR(i,j) |= ACCEPTOR_PAIR; /*cPAIR(j,i) |= ACCEPTOR_PAIR;*/ nCurAcceptorPairs += !bAlreadyTested; if ( !(s_candidate[i].subtype & SALT_SELECTED) ) { s_candidate[i].subtype |= SALT_SELECTED; nNumMarkedCandidates ++; if ( !s_candidate[i].endpoint && s_candidate[i].type ) { nNumOtherChanges ++; } else { nNumAcidicChanges ++; } } if ( !(s_candidate[j].subtype & SALT_SELECTED) ) { s_candidate[j].subtype |= SALT_SELECTED; nNumMarkedCandidates ++; if ( !s_candidate[j].endpoint && s_candidate[j].type ) { nNumOtherChanges ++; } else { nNumAcidicChanges ++; } } } } } if ( bAlreadyTested && (cPAIR(i,j) & DONOR_PAIR) || !bAlreadyTested ) { /* checking for donor pair */ if ( (s_candidate[i].subtype & SALT_DONOR) && (s_candidate[j].subtype & SALT_DONOR) && (ret = bExistsAltPath( pBNS, pBD, NULL, at, num_atoms, s_candidate[i].atnumber, s_candidate[j].atnumber, ALT_PATH_MODE_REM2H_CHG ))) { if ( IS_BNS_ERROR( ret ) ) { nTotNumChanges = ret; goto quick_exit; } if ( ret & 1 ) { nDelta = (ret & ~3) >> 2; nNumChanges += (ret & 2); if ( nDelta ) { /* alt path unleashed previously localized radicals and they annihilated */ nNumChanges = 0; nTotNumChanges = BNS_RADICAL_ERR; goto quick_exit; } cPAIR(i,j) |= DONOR_PAIR; /*cPAIR(j,i) |= ACCEPTOR_PAIR;*/ nCurDonorPairs += !bAlreadyTested; if ( !(s_candidate[i].subtype & SALT_SELECTED) ) { s_candidate[i].subtype |= SALT_SELECTED; nNumMarkedCandidates ++; if ( !s_candidate[i].endpoint && s_candidate[i].type ) { nNumOtherChanges ++; } else { nNumAcidicChanges ++; } } if ( !(s_candidate[j].subtype & SALT_SELECTED) ) { s_candidate[j].subtype |= SALT_SELECTED; nNumMarkedCandidates ++; if ( !s_candidate[j].endpoint && s_candidate[j].type ) { nNumOtherChanges ++; } else { nNumAcidicChanges ++; } } } } } } nDonorPairs += nCurDonorPairs; nAcceptorPairs += nCurAcceptorPairs; } inchi_free( cPair ); cPair = NULL; if ( nNumMarkedCandidates ) { EndPoint = (T_ENDPOINT *)inchi_calloc( nNumMarkedCandidates, sizeof(EndPoint[0])); if ( !EndPoint ) { /*printf("BNS_OUT_OF_RAM-7\n");*/ nTotNumChanges = BNS_OUT_OF_RAM; goto quick_exit; } for ( i = 0, j = 0; i < nNumLeftCandidates; i ++ ) { if ( s_candidate[i].subtype & SALT_SELECTED ) { s_candidate[i].subtype ^= SALT_SELECTED; /* remove the flag */ if ( j < nNumMarkedCandidates ) { i1 = s_candidate[i].atnumber; /* save a representative of the t-group to be created */ AddEndPoint( EndPoint+j, at, i1 ); } j ++; } } if ( j != nNumMarkedCandidates ) { nTotNumChanges = BNS_PROGRAM_ERR; goto quick_exit; } /* merge all marked atoms and their t-groups into one t-group */ ret = RegisterEndPoints( t_group_info, EndPoint, nNumMarkedCandidates, at, num_atoms, c_group_info, pBNS ); if ( ret == -1 ) { ret = BNS_PROGRAM_ERR; } if ( ret < 0 ) { nTotNumChanges = ret; goto quick_exit; } nTotNumChanges += (ret > 0); inchi_free( EndPoint ); EndPoint = NULL; if ( nNumMarkedCandidates ) { for ( i = nNumLeftCandidates; i < nNumCandidates; i ++ ) { s_candidate[i].type += DISABLE_CANDIDATE; j1 = s_candidate[i].atnumber; if ( at[j1].endpoint == at[i1].endpoint ) { if ( !s_candidate[i].endpoint && s_candidate[i].type ) { nNumOtherChanges ++; } else { nNumAcidicChanges ++; } } } } else { for ( i = nNumLeftCandidates; i < nNumCandidates; i ++ ) { s_candidate[i].type += DISABLE_CANDIDATE; } } /* find whether the new t-group have any movable H */ for ( i = 0, bTGroupHasNegativeChargesOnly = 0; i < t_group_info->num_t_groups; i ++ ) { if ( t_group_info->t_group[i].nGroupNumber == at[i1].endpoint && t_group_info->t_group[i].num[0] == t_group_info->t_group[i].num[1] ) { bTGroupHasNegativeChargesOnly = 1; break; } } } nTotNumChanges = ( nTotNumChanges > 0); #if ( IGNORE_TGROUP_WITHOUT_H == 1 ) if ( nTotNumChanges && bTGroupHasNegativeChargesOnly ) { nTotNumChanges = 2; /* means no moveable H has been affected */ } #endif } quick_exit: if ( nNumOtherChanges && nTotNumChanges == 1 ) { nTotNumChanges = 5; /* not only acidic atoms merged */ } if ( cPair ) { inchi_free( cPair ); /*cPair = NULL;*/ } if ( EndPoint ) { inchi_free ( EndPoint ); /*EndPoint = NULL;*/ } return nTotNumChanges; /* 0=>no changes, 1=>new salt tautomerism found, 2=>only new charge tautomerism found */ #undef ALT_PATH_FOUND #undef NO_ENDPOINT } /********************************************************************************************************/ /* regular one-path version: find alt paths then merge */ /* Check for oxygen negative charge-H tautomerism (Salts) allowed long-range tautomerism; only one H or (-) can be moved, for example: HO-C=X-Y=Z-...-C=O => O=C-X=Y-Z=...=C-OH */ #if ( SALT_WITH_PROTONS == 1 ) #define MAX_LOCAL_TGNUM 0 /* was 32; disable since it has not been used */ #if ( MAX_LOCAL_TGNUM > 0 ) typedef struct tagTGroupData { S_SHORT nGroupNumber; /* t-group number from t_group_info->t_group->nGroupNumber */ S_SHORT nGroupIndex; /* TGroupData[nGroupNumber]nGroupIndex = index of t_group in t_group_info */ S_SHORT nDonorM; /* number of endpoint-donors that have negative charge (Minus) */ S_SHORT nDonorH; /* number of endpoint-donors that have only H */ S_SHORT nAccepM; /* number of endpoint-acceptors that have negative charge (Minus) */ S_SHORT nAccepH; /* number of endpoint-acceptors that have H and no negative charge */ S_SHORT nAccep0; /* number of endpoint-acceptors that have no H and no negative charge */ S_SHORT nDonorA; /* number of acidic endpoint-donors */ S_SHORT nAccepS; /* number of acidic endpoint-acceptors */ } TGroupData; #endif /*****************************************************************************/ int MarkSaltChargeGroups ( inp_ATOM *at, int num_atoms, S_GROUP_INFO *s_group_info, T_GROUP_INFO *t_group_info, C_GROUP_INFO *c_group_info, struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD ) { int nNumChanges = 0, nTotNumChanges = 0; if ( s_group_info && s_group_info->s_candidate && s_group_info->max_num_candidates > 0 ) { int i, i1, i2, j, j1, j2, jj, ii1, ii2, jj1, jj2, /*k,*/ num_tested; S_CANDIDATE *s_candidate = s_group_info->s_candidate; int nMaxNumCandidates = s_group_info->max_num_candidates; int nNumCandidates = s_group_info->num_candidates; int nNumOtherCandidates = s_group_info->num_other_candidates; int nNumPOnlyCandidates = s_group_info->num_p_only_candidates; int s_type, s_subtype; int ret, nDelta, /*nMobile,*/ err = 0; int s_subtype_all = 0; int nGroupNumber; T_ENDPOINT EndPoint[2]; #if ( MAX_LOCAL_TGNUM > 0 ) TGroupData tgData[MAX_LOCAL_TGNUM]; TGroupData *ptgData = tgData; #endif int cond1=0,cond2a=0,cond2b=0,cond2c=0,cond2=0; if ( nNumCandidates <= -1 || !t_group_info || !t_group_info->t_group ) { return 0; } /* count t-groups */ for ( i = 0, nGroupNumber = 0; i < t_group_info->num_t_groups; i ++ ) { if ( nGroupNumber < t_group_info->t_group[i].nGroupNumber ) { nGroupNumber = t_group_info->t_group[i].nGroupNumber; /* max. t-group number */ } } #if ( MAX_LOCAL_TGNUM > 0 ) /* prepare memory */ if ( nGroupNumber >= MAX_LOCAL_TGNUM ) { if ( !( ptgData = (TGroupData*)inchi_calloc( nGroupNumber+1, sizeof(TGroupData) ) ) ) { err = BNS_OUT_OF_RAM; goto quick_exit; } } else { memset( ptgData, 0, sizeof(tgData) ); } ptgData[0].nGroupIndex = -1; /* data for non-tautomeric atoms */ for ( i = 0, nGroupNumber = 0; i < t_group_info->num_t_groups; i ++ ) { if ( nGroupNumber = t_group_info->t_group[i].nGroupNumber ) { ptgData[nGroupNumber].nGroupIndex = i; ptgData[i].nGroupNumber = nGroupNumber; } } #endif nNumCandidates = 0; /* always recalculate 2004-03-22 */ num_tested = 0; if ( nNumCandidates == 0 ) { for ( i = 0, nNumCandidates = nNumOtherCandidates = nNumPOnlyCandidates = 0; i < num_atoms; i ++ ) { if ( 0 == (s_type = GetSaltChargeType( at, i, t_group_info, &s_subtype )) || /* -C=O or =C-OH, O = S, Se, Te */ #if ( INCL_NON_SALT_CANDIDATATES == 1 ) 1 == (s_type = GetOtherSaltChargeType( at, i, t_group_info, &s_subtype, 1 )) || /* =Z-MH or -Z=M, Z = centerpoint, M = endpoint, other than above */ #endif 2 == (s_type = GetOtherSaltType( at, i, &s_subtype ) ) /* >C-SH, >C-S(-); S=S,Se,Te */ ) { if ( nNumCandidates >= nMaxNumCandidates ) { err = BNS_VERT_EDGE_OVFL; goto quick_exit; } s_candidate[nNumCandidates].atnumber = i; s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i].endpoint; nNumCandidates ++; nNumOtherCandidates += (1 == s_type); nNumPOnlyCandidates += (2 == s_type); s_subtype_all |= s_subtype; /*i1 = i;*/ /* save a representative of a tautomeric group */ } } /* for */ /* changes: TG_FLAG_ALLOW_NO_NEGTV_O replaced CHARGED_SALTS_ONLY==0 */ #if 0 if ( nNumCandidates <= 1 || !(s_subtype_all & SALT_ACCEPTOR) || (((t_group_info->bTautFlags & TG_FLAG_ALLOW_NO_NEGTV_O)|| (t_group_info->bTautFlagsDone & TG_FLAG_FOUND_SALT_CHARGES_DONE) || (t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT)) ? !(s_subtype_all & (SALT_DONOR_Neg | SALT_DONOR_H)): (!(s_subtype_all & SALT_DONOR_Neg) || nNumOtherCandidates==nNumCandidates)) ) { #endif cond1 = s_subtype_all & SALT_ACCEPTOR; cond2a = t_group_info->bTautFlags & TG_FLAG_ALLOW_NO_NEGTV_O; cond2b = t_group_info->bTautFlagsDone & TG_FLAG_FOUND_SALT_CHARGES_DONE; cond2c = t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT; if ( cond2a || cond2b|| cond2c ) cond2 = !(s_subtype_all & (SALT_DONOR_Neg | SALT_DONOR_H)); else cond2 = !(s_subtype_all & SALT_DONOR_Neg) || nNumOtherCandidates==nNumCandidates; if ( nNumCandidates <= 1 || !cond1 || cond2 /*( ( cond2a || cond2b || cond2c ) ? !(s_subtype_all & (SALT_DONOR_Neg | SALT_DONOR_H)) : ( !(s_subtype_all & SALT_DONOR_Neg) || nNumOtherCandidates==nNumCandidates) ) */ ) { s_group_info->num_candidates = -1; /* no candidate exists */ goto quick_exit; } if ( !(s_subtype_all & (SALT_DONOR_Neg) ) ) { t_group_info->bTautFlagsDone |= TG_FLAG_ALLOW_NO_NEGTV_O_DONE; } } else { for ( i = 0; i < nNumCandidates; i ++ ) { i1 = s_candidate[i].atnumber; if ( 0 <= (s_type = GetSaltChargeType( at, i1, t_group_info, &s_subtype )) #if ( INCL_NON_SALT_CANDIDATATES == 1 ) || 0 < (s_type = GetOtherSaltChargeType( at, i1, t_group_info, &s_subtype, 1 /* bAccept_O*/ )) #endif ) { s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i1].endpoint; } } } /* Look for alt paths connecting: SALT_DONOR_Neg to SALT_ACCEPTOR : long distance migration of negative charges SALT_DONOR_H to SALT_ACCEPTOR : long distance migration of H-atoms */ do { nNumChanges = 0; for ( i1 = 0; i1 < nNumCandidates; i1 ++ ) { j1 = s_candidate[i1].atnumber; for ( i2 = i1+1; i2 < nNumCandidates; i2 ++ ) { /* prev. approach: do not test if both candidates are not "salt-type". Disabled 2004-03-18 if ( s_candidate[i1].type && s_candidate[i2].type ) continue; */ j2 = s_candidate[i2].atnumber; if ( at[j1].endpoint && at[j1].endpoint == at[j2].endpoint ) { continue; } for ( j = 0; j < 2; j ++ ) { if ( j ) { ii1 = i2; /* candidate 1 (donor) ordering number */ ii2 = i1; /* candidate 2 (acceptor) ordering number */ jj1 = j2; /* candidate 1 (donor) atom number */ jj2 = j1; /* candidate 2 (acceptor) atom number */ } else { /* transposition */ ii1 = i1; /* candidate 1 (donor) ordering number */ ii2 = i2; /* candidate 2 (acceptor) ordering number */ jj1 = j1; /* candidate 1 (donor) atom number */ jj2 = j2; /* candidate 2 (acceptor) atom number */ } if ( ( s_candidate[ii1].subtype & (SALT_DONOR_Neg | SALT_DONOR_H) ) && ( s_candidate[ii2].subtype & SALT_ACCEPTOR ) ) { ret = bExistsAltPath( pBNS, pBD, NULL, at, num_atoms, jj2, jj1, ALT_PATH_MODE_4_SALT ); num_tested ++; if ( IS_BNS_ERROR( ret ) ) { err = ret; goto quick_exit; } if ( ret & 1 ) { nDelta = (ret & ~3) >> 2; nNumChanges += (ret & 2); for ( i = 0; i < 2; i ++ ) { jj = i? jj2 : jj1; AddEndPoint( EndPoint+i, at, jj ); } /* add/merge taut groups and reinit pBNS in the fly */ ret = RegisterEndPoints( t_group_info, EndPoint, 2, at, num_atoms, c_group_info, pBNS ); if ( ret == -1 ) { ret = BNS_PROGRAM_ERR; } if ( ret < 0 ) { err = ret; goto quick_exit; } if ( nDelta ) { err = BNS_RADICAL_ERR; goto quick_exit; } nNumChanges += (ret > 0); break; /* avoid redundant repetition */ } } } } } nTotNumChanges += nNumChanges; } while ( num_tested && nNumChanges ); quick_exit: if ( !err ) { nTotNumChanges += nNumChanges; /* nNumChanges != 0 only in case of 'goto quick_exit' */ if ( s_group_info->num_candidates == 0 ) { /* first time: initialize */ s_group_info->num_candidates = num_tested? nNumCandidates : -1; /* no candidate exists */ } } else { nTotNumChanges = err; } #if ( MAX_LOCAL_TGNUM > 0 ) if ( ptgData != tgData ) { inchi_free( ptgData ); } #endif } return nTotNumChanges; } #else /*****************************************************************************/ int MarkSaltChargeGroups ( inp_ATOM *at, int num_atoms, S_GROUP_INFO *s_group_info, T_GROUP_INFO *t_group_info, C_GROUP_INFO *c_group_info, struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD ) { int nNumChanges = 0, nTotNumChanges = 0; if ( s_group_info && s_group_info->s_candidate && s_group_info->max_num_candidates > 0 ) { int i, i1, i2, j, j1, j2, jj, ii1, ii2, jj1, jj2, k, num_tested; S_CANDIDATE *s_candidate = s_group_info->s_candidate; int nMaxNumCandidates = s_group_info->max_num_candidates; int nNumCandidates = s_group_info->num_candidates; int nNumOtherCandidates = s_group_info->num_other_candidates; int s_type, s_subtype; int ret, nDelta, nMobile; int s_subtype_all = 0; T_ENDPOINT EndPoint[2]; if ( nNumCandidates <= -1 || !t_group_info || !t_group_info->t_group ) { return 0; } else if ( nNumCandidates == 0 ) { for ( i = 0, nNumCandidates = nNumOtherCandidates = 0; i < num_atoms; i ++ ) { if ( 0 <= (s_type = GetSaltChargeType( at, i, t_group_info, &s_subtype )) ) { if ( nNumCandidates >= nMaxNumCandidates ) { return BNS_VERT_EDGE_OVFL; } s_candidate[nNumCandidates].atnumber = i; s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i].endpoint; nNumCandidates ++; s_subtype_all |= s_subtype; /*i1 = i;*/ /* save a representative of a tautomeric group */ } #if ( INCL_NON_SALT_CANDIDATATES == 1 ) else /* new */ if ( 0 < (s_type = GetOtherSaltChargeType( at, i, t_group_info, &s_subtype, 1 /* bAccept_O*/ )) ) { if ( nNumCandidates >= nMaxNumCandidates ) { return BNS_VERT_EDGE_OVFL; } s_candidate[nNumCandidates].atnumber = i; s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i].endpoint; nNumCandidates ++; nNumOtherCandidates ++; s_subtype_all |= s_subtype; } #endif } /* changes: TG_FLAG_ALLOW_NO_NEGTV_O replaced CHARGED_SALTS_ONLY==0 */ if ( nNumCandidates <= 1 || nNumOtherCandidates == nNumCandidates || ((t_group_info->bTautFlags & TG_FLAG_ALLOW_NO_NEGTV_O) ? !(s_subtype_all & (SALT_DONOR_Neg | SALT_DONOR_H)): !(s_subtype_all & SALT_DONOR_Neg)) || !(s_subtype_all & SALT_ACCEPTOR)) { s_group_info->num_candidates = -1; /* no candidate exists */ return 0; } if ( !(s_subtype_all & (SALT_DONOR_Neg) ) ) { t_group_info->bTautFlagsDone |= TG_FLAG_ALLOW_NO_NEGTV_O_DONE; } } else { for ( i = 0; i < nNumCandidates; i ++ ) { i1 = s_candidate[i].atnumber; if ( 0 <= (s_type = GetSaltChargeType( at, i1, t_group_info, &s_subtype )) #if ( INCL_NON_SALT_CANDIDATATES == 1 ) || 0 < (s_type = GetOtherSaltChargeType( at, i1, t_group_info, &s_subtype, 1 /* bAccept_O*/ )) #endif ) { s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i1].endpoint; } } } /* Look for alt paths connecting: SALT_DONOR_Neg to SALT_ACCEPTOR : long distance migration of negative charges SALT_DONOR_H to SALT_ACCEPTOR : long distance migration of H-atoms */ num_tested = 0; do { nNumChanges = 0; for ( i1 = 0; i1 < nNumCandidates; i1 ++ ) { j1 = s_candidate[i1].atnumber; for ( i2 = i1+1; i2 < nNumCandidates; i2 ++ ) { if ( s_candidate[i1].type && s_candidate[i2].type ) continue; /* both candidates are not "salt-type" */ j2 = s_candidate[i2].atnumber; if ( at[j1].endpoint && at[j1].endpoint == at[j2].endpoint ) { continue; } for ( j = 0; j < 2; j ++ ) { if ( j ) { ii1 = i2; /* candidate 1 (donor) ordering number */ ii2 = i1; /* candidate 2 (acceptor) ordering number */ jj1 = j2; /* candidate 1 (donor) atom number */ jj2 = j1; /* candidate 2 (acceptor) atom number */ } else { /* transposition */ ii1 = i1; /* candidate 1 (donor) ordering number */ ii2 = i2; /* candidate 2 (acceptor) ordering number */ jj1 = j1; /* candidate 1 (donor) atom number */ jj2 = j2; /* candidate 2 (acceptor) atom number */ } if ( ( s_candidate[ii1].subtype & (SALT_DONOR_Neg | SALT_DONOR_H) ) && ( s_candidate[ii2].subtype & SALT_ACCEPTOR ) ) { ret = bExistsAltPath( pBNS, pBD, NULL, at, num_atoms, jj2, jj1, ALT_PATH_MODE_4_SALT ); num_tested ++; if ( IS_BNS_ERROR( ret ) ) { return ret; } if ( ret & 1 ) { nDelta = (ret & ~3) >> 2; nNumChanges += (ret & 2); for ( i = 0; i < 2; i ++ ) { jj = i? jj2 : jj1; EndPoint[i].nAtomNumber = jj; EndPoint[i].nEquNumber = 0; EndPoint[i].nGroupNumber = at[jj].endpoint; if ( at[jj].endpoint ) { memset( EndPoint[i].num, 0, sizeof(EndPoint[i].num) ); } else { AddAtom2num( EndPoint[i].num, at, jj, 2 ); /* fill out */ AddAtom2DA( EndPoint[i].num_DA, at, jj, 2 ); /* nMobile = EndPoint[i].num[1] = (at[jj].charge == -1); nMobile = EndPoint[i].num[0] = at[jj].num_H + nMobile; for ( k = 0; k < T_NUM_ISOTOPIC; k ++ ) { EndPoint[i].num[T_NUM_NO_ISOTOPIC+k] = at[jj].num_iso_H[NUM_H_ISOTOPES-k-1]; } */ } } /* add/merge taut groups and reinit pBNS */ ret = RegisterEndPoints( t_group_info, EndPoint, 2, at, num_atoms, c_group_info, pBNS ); if ( ret < 0 ) { return ret; } nNumChanges += (ret > 0); if ( nDelta ) { goto quick_exit; } break; /* avoid redundant repetition */ } } } } } nTotNumChanges += nNumChanges; } while ( num_tested && nNumChanges ); quick_exit: nTotNumChanges += nNumChanges; /* nNumChanges != 0 only in case of 'goto quick_exit' */ if ( s_group_info->num_candidates == 0 ) { /* first time: initialize */ s_group_info->num_candidates = num_tested? nNumCandidates : -1; /* no candidate exists */ } } return nTotNumChanges; } #endif /*****************************************************************************/ int MergeSaltTautGroups( inp_ATOM *at, int num_atoms, S_GROUP_INFO *s_group_info, T_GROUP_INFO *t_group_info, C_GROUP_INFO *c_group_info, struct BalancedNetworkStructure *pBNS ) { /* count candidates to be connected: exclude pure donors that do not belong to any t-group */ AT_NUMB nCurTGroupNumber; int i, j, /*k,*/ ret, iat, /*nMobile,*/ nMinNumEndpoints; int s_subtype_all, s_subtype_taut; int nMaxNumCandidates, nNumCandidates, nNumCandidates2; T_ENDPOINT EndPointStackArray[MAX_STACK_ARRAY_LEN]; /* will be reallocated if too short */ T_ENDPOINT *EndPoint = EndPointStackArray; if ( !s_group_info || !s_group_info->s_candidate || /*s_group_info->num_candidates <= 0 ||*/ !t_group_info || !t_group_info->t_group || !c_group_info ) { return 0; } nMinNumEndpoints = 0; nMaxNumCandidates = s_group_info->max_num_candidates; nCurTGroupNumber = MAX_ATOMS; /* impossible t-group number */ s_subtype_all = s_subtype_taut = 0; /* collect tautomeric acidic O and previously non-tautomeric C-OH, C-SH, C-O(-), C-S(-) */ /* find whether previously found tautomeric atoms have both mobile H and (-) */ if ( 1 || (s_group_info->num_candidates < 0) ) { /* can be only -O(-) and -OH */ int s_type, s_subtype; S_CANDIDATE *s_candidate = s_group_info->s_candidate; for ( i = 0, nNumCandidates = nNumCandidates2 = 0; i < num_atoms; i ++ ) { s_subtype = 0; if ( 0 == (s_type = GetSaltChargeType( at, i, t_group_info, &s_subtype )) || /* -C=O or =C-OH, O = S, Se, Te */ /*(t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT) &&*/ 1 == (s_type = GetOtherSaltChargeType( at, i, t_group_info, &s_subtype, 1/* bAccept_O*/ )) || /* =Z-MH or -Z=M, Z = centerpoint, M = endpoint, other than above. M may be N */ 2 == (s_type = GetOtherSaltType( at, i, &s_subtype )) || /* >C-SH, >C-S(-); S=S,Se,Te */ /* other proton donor or acceptor */ bHasAcidicHydrogen( at, i) && ((s_type=3), (s_subtype = SALT_p_DONOR)) || bHasAcidicMinus( at, i) && ((s_type=3), (s_subtype = SALT_p_ACCEPTOR)) ) { if ( nNumCandidates >= nMaxNumCandidates ) { return BNS_VERT_EDGE_OVFL; } if ( at[i].endpoint ) { s_subtype_taut |= s_subtype; } else if ( bDoNotMergeNonTautAtom(at, i) ) { continue; /* ignore non-tautomeric N */ } if ( !( s_subtype & SALT_DONOR_ALL ) || (s_subtype & SALT_ACCEPTOR) && !at[i].endpoint ) { continue; /* do not include non-taut acceptors like -C=O */ } s_candidate[nNumCandidates].atnumber = i; s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i].endpoint; nNumCandidates ++; s_subtype_all |= s_subtype; } } /* Forced merging occurs upon: =========================== (t_group_info->bTautFlags & TG_FLAG_ALLOW_NO_NEGTV_O) or (t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT) Allow forced merging in cases: {t-groups} (H, (-)} {H, (-), t-groups} Normal salt merging in cases: (H, (-)} {H, (-), t-groups}, Cannot merge H into t-groups if no (-) is present */ if ( (t_group_info->bTautFlags & TG_FLAG_ALLOW_NO_NEGTV_O) || (t_group_info->bTautFlagsDone & TG_FLAG_FOUND_SALT_CHARGES_DONE) || (t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT) ) { /* force merge even though no negative charges are present */ if ( nNumCandidates <= 1 || (!(s_subtype_all & SALT_DONOR_Neg2) || !(s_subtype_all & SALT_DONOR_H2)) && !t_group_info->num_t_groups ) { s_group_info->num_candidates = -1; /* no candidate exists */ return 0; } } else { /* normal salt mode: merge if both -XH and -X(-) are present */ if ( nNumCandidates <= 1 || (!(s_subtype_all & SALT_DONOR_Neg2) || !(s_subtype_all & SALT_DONOR_H2)) ) { s_group_info->num_candidates = -1; /* no candidate exists */ return 0; } } /* -- old code -- if ( nNumCandidates <= 1 || (((t_group_info->bTautFlags & TG_FLAG_ALLOW_NO_NEGTV_O) || (t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT)) ? !(s_subtype_all & SALT_DONOR_ALL): !(s_subtype_all & SALT_DONOR_Neg2) ) ) { s_group_info->num_candidates = -1; return 0; } */ if ( !(s_subtype_all & (SALT_DONOR_Neg2) ) ) { t_group_info->bTautFlagsDone |= TG_FLAG_ALLOW_NO_NEGTV_O_DONE; } s_group_info->num_candidates = nNumCandidates; } for ( i = 0; i < s_group_info->num_candidates; i ++ ) { iat = s_group_info->s_candidate[i].atnumber; if ( (s_group_info->s_candidate[i].subtype & SALT_ACCEPTOR) && !at[iat].endpoint ) { continue; /* should not happen */ } s_subtype_all |= s_group_info->s_candidate[i].subtype; if ( at[iat].endpoint != nCurTGroupNumber || !at[iat].endpoint ) { nMinNumEndpoints ++; } nCurTGroupNumber = (int)at[iat].endpoint; } if ( nMinNumEndpoints <= 1 ) { return 0; /* too few endpoints */ } /* make sure we have enough memory */ if ( nMinNumEndpoints > MAX_STACK_ARRAY_LEN ) { if ( !(EndPoint = (T_ENDPOINT *)inchi_calloc( nMinNumEndpoints, sizeof(EndPoint[0]) ) ) ) { /*printf("BNS_OUT_OF_RAM-8\n");*/ return BNS_OUT_OF_RAM; } } nCurTGroupNumber = MAX_ATOMS; /* impossible t-group number */ for ( i = j = 0; i < s_group_info->num_candidates; i ++ ) { iat = s_group_info->s_candidate[i].atnumber; if ( s_group_info->s_candidate[i].subtype == SALT_ACCEPTOR && !at[iat].endpoint ) { continue; } if ( at[iat].endpoint != nCurTGroupNumber || !at[iat].endpoint ) { AddEndPoint( EndPoint+j, at, iat ); j ++; } nCurTGroupNumber = (int)at[iat].endpoint; } ret = RegisterEndPoints( t_group_info, EndPoint, j, at, num_atoms, c_group_info, pBNS ); if ( ret == -1 ) { ret = BNS_PROGRAM_ERR; } if ( EndPoint != EndPointStackArray ) { inchi_free( EndPoint ); } return ret; } /*****************************************************************************/ int MakeIsotopicHGroup(inp_ATOM *at, int num_atoms, S_GROUP_INFO *s_group_info, T_GROUP_INFO *t_group_info) { /* all tautomeric atoms and all possible H+ donors and acceptors that have H */ int i, j, k, n, bHasH, tg, nError=0; int s_subtype_all, s_subtype_taut; int nMaxNumCandidates, nNumCandidates, nNumNonTautCandidates; if ( !s_group_info || !s_group_info->s_candidate || /*s_group_info->num_candidates <= 0 ||*/ !t_group_info || !t_group_info->t_group ) { return 0; } nMaxNumCandidates = s_group_info->max_num_candidates; s_subtype_all = s_subtype_taut = 0; memset( t_group_info->num_iso_H, 0, sizeof(t_group_info->num_iso_H) ); if ( 1 || (s_group_info->num_candidates < 0) ) { int s_type, s_subtype; S_CANDIDATE *s_candidate = s_group_info->s_candidate; for ( i = 0, nNumCandidates = nNumNonTautCandidates = 0; i < num_atoms; i ++ ) { s_subtype = 0; s_type = 0; if ( at[i].endpoint ) { if ( (tg = t_group_info->tGroupNumber[at[i].endpoint]) && at[i].endpoint == t_group_info->t_group[tg-=1].nGroupNumber ) { bHasH = (int)t_group_info->t_group[tg].num[0] - (int)t_group_info->t_group[tg].num[1]; } else { nError = BNS_PROGRAM_ERR; break; } } else { bHasH = (int)at[i].num_H; } if ( bHasH && at[i].endpoint || /* tautomeric atoms */ /* non-tautomeric heteroatoms that (a) have H and (b) may be donors of H therefore may exchange isotopic-non-isotopic H */ bHasH && (0 == (s_type = GetSaltChargeType( at, i, t_group_info, &s_subtype )) || /* -C=O or =C-OH, O = S, Se, Te */ /*(t_group_info->tni.bNormalizationFlags & FLAG_FORCE_SALT_TAUT) &&*/ 1 == (s_type = GetOtherSaltChargeType( at, i, t_group_info, &s_subtype, 1/* bAccept_O*/ )) || /* =Z-MH or -Z=M, Z = centerpoint, M = endpoint, other than above. M may be N */ 2 == (s_type = GetOtherSaltType( at, i, &s_subtype )) || /* >C-SH, >C-S(-); S=S,Se,Te */ /* other proton donor or acceptor */ bHasAcidicHydrogen( at, i) && ((s_type=3), (s_subtype = SALT_p_DONOR)) || bHasAcidicMinus( at, i) && ((s_type=3), (s_subtype = SALT_p_ACCEPTOR)) || bHasOtherExchangableH (at, i) && ((s_type=3), (s_subtype = SALT_DONOR_H)) ) ) { if ( nNumCandidates >= nMaxNumCandidates ) { return BNS_VERT_EDGE_OVFL; } s_candidate[nNumCandidates].atnumber = i; s_candidate[nNumCandidates].type = s_type; s_candidate[nNumCandidates].subtype = s_subtype; s_candidate[nNumCandidates].endpoint = at[i].endpoint; nNumCandidates ++; nNumNonTautCandidates += !at[i].endpoint; s_subtype_all |= s_subtype; } } if ( nError ) { return nError; } if ( nNumCandidates > 0 ) { t_group_info->nIsotopicEndpointAtomNumber = (AT_NUMB *)inchi_calloc( nNumNonTautCandidates+1, sizeof(t_group_info->nIsotopicEndpointAtomNumber[0])); t_group_info->nIsotopicEndpointAtomNumber[0] = nNumNonTautCandidates; for ( i = 0, n = 1; i < nNumCandidates; i ++ ) { k = s_candidate[i].atnumber; if ( !at[k].endpoint ) { t_group_info->nIsotopicEndpointAtomNumber[n++] = k; } for ( j = 0; j < NUM_H_ISOTOPES; j ++ ) { t_group_info->num_iso_H[j] += at[k].num_iso_H[j]; } at[k].cFlags |= AT_FLAG_ISO_H_POINT; } t_group_info->nNumIsotopicEndpoints = nNumNonTautCandidates+1; } } return nNumCandidates; } /*#else*/ /* } DISCONNECT_SALTS == 0 */ /********************************************************************************** Charges and tautomeric endpoints (N only) ********************************************************************************** H = number of possibly moveable hydrogen atoms C = possibly moveable positive charge - = single bond = = double bond # = triple bond +-----------------------------------------------------------------------------+ |ca-| H | edges to t- | 1 bond | 2 bonds | 3 bonds *) | |se | C | and c-groups | (valence) | (valence) | (valence) | | # | | (edges flow) | | | | +---|------+---------------+----------------+----------------+----------------| | 1 | H=0 | -- (1) | =NH (3) | =N- (3) | >N- (3) | | | C=0 | == | | | | +---|------+---------------+----------------+----------------+----------------| | 2 | H=1 | == (2) | -NH2 (3) | -NH- (3) | none | | | C=0 | == | | | | +---|------+---------------+----------------+----------------+----------------| | 3 | H=0 | -- (0) | #NH(+) (4) | =N(+)= (4) +)| >N(+)= (4) | | | C=1 | -- | (prohibited | | | | | | | by edge cap) | | | +---|------+---------------+----------------+----------------+----------------| | 4 | H=1 | == (1) | =NH2(+) (4) +)| =NH(+)- (4) +)| >NH(+)- (4) | | | C=1 | -- | | | | +---+-------------------------------------------------------------------------+ *) Cannot be a tautomeric endpoint +) The three charged types of atoms [=N(+)=, =NH(+)-, =NH2(+)] should be checked for possible H-tautomerism. Other types in the marked by *) column should not be checked as long as H(+) exchange is not considered tautomeric. Other possibilities: -NH3(+) >NH2(+) >N(+)< cannot be H-tautomeric endpoints. Case #1 (H=0, C=0) and #4 (H=1,C=0) is indistinguishable from the viewpoint of edges flow and capacities except for flow from N to (+) vertex. Without taking precautions H(+) can be transferred from =NH2(+) to =NH, from =NH(+)- to =N-, from >NH(+)- to >N- or to any other appropriate atom that has a lone electron pair and bonds will not change. In this case no bond must be marked as tautomeric. For this reason before attempting to transfer H from one endpoint to another the charges on the two atoms should be set to zero by forcing zero flow from each of atoms to the (+)-vertices if the atoms belong to a c-group. **********************************************************************************/ /***********************************************************************************/ /* MarkTautomerGroups: do not identify positively charged N as endpoints for now */ /***********************************************************************************/ int MarkTautomerGroups( inp_ATOM *at, int num_atoms, T_GROUP_INFO *t_group_info, C_GROUP_INFO *c_group_info , struct BalancedNetworkStructure *pBNS, struct BalancedNetworkData *pBD ) { int i, j, k, m, endpoint_valence, centerpoint, endpoint, bond_type, nMobile, num_changes=0, tot_changes=0; T_ENDPOINT EndPoint[MAXVAL]; T_BONDPOS BondPos[MAXVAL]; AT_NUMB nGroupNumber; int bDiffGroups; int nNumEndPoints, nNumBondPos, nNumPossibleMobile; int bTautBond, bNonTautBond, bAltBond; int nNumDonor, nNumAcceptor, bPossiblyEndpoint; T_GROUP *t_group; int *pnum_t, max_num_t, bIgnoreIsotopic; ENDPOINT_INFO eif1, eif2; int nErr = 0; #define ALLOWED_EDGE(PBNS, IAT,IBOND) ( !(PBNS) || !(PBNS)->edge || !(PBNS)->vert || !(PBNS)->edge[(PBNS)->vert[IAT].iedge[IBOND]].forbidden) #define ACTUAL_ORDER(PBNS, IAT,IBOND, BTYPE) ( ((PBNS) && (PBNS)->edge && (PBNS)->vert &&\ ((BTYPE)==BOND_ALT_123 || (BTYPE)==BOND_ALT_13 || (BTYPE)==BOND_ALT_23))? (PBNS)->edge[(PBNS)->vert[IAT].iedge[IBOND]].flow+BOND_TYPE_SINGLE:(BTYPE)) if ( !t_group_info || !(t_group_info->bTautFlags & TG_FLAG_TEST_TAUT__ATOMS) ) return 0; /* initial t_group allocation */ if ( !t_group_info->t_group && !t_group_info->max_num_t_groups ) { INCHI_MODE bTautFlags = t_group_info->bTautFlags; /* save initial setting */ INCHI_MODE bTautFlagsDone = t_group_info->bTautFlagsDone; /* save previous findings, if any */ TNI tni = t_group_info->tni; AT_NUMB *tGroupNumber = t_group_info->tGroupNumber; bIgnoreIsotopic = t_group_info->bIgnoreIsotopic; memset( t_group_info, 0, sizeof(*t_group_info) ); t_group_info->bIgnoreIsotopic = bIgnoreIsotopic; /* restore initial setting */ t_group_info->bTautFlags = bTautFlags; t_group_info->bTautFlagsDone = bTautFlagsDone; t_group_info->tni = tni; t_group_info->tGroupNumber = tGroupNumber; t_group_info->max_num_t_groups = num_atoms/2+1; /* upper limit */ if (!(t_group_info->t_group = (T_GROUP*)inchi_calloc(t_group_info->max_num_t_groups, sizeof(t_group[0])))) { return (t_group_info->max_num_t_groups = -1); /* failed, out of RAM */ } } /* check if t_group_info exists */ if ( !t_group_info->t_group || !t_group_info->max_num_t_groups ) return 0; if ( 0 > t_group_info->max_num_t_groups ) return t_group_info->max_num_t_groups; pnum_t = &t_group_info->num_t_groups; /* number of found tautomer endpoint groups */ t_group = t_group_info->t_group; max_num_t = t_group_info->max_num_t_groups; bIgnoreIsotopic = t_group_info->bIgnoreIsotopic; /* 1-3 tautomers */ for ( i = 0; i < num_atoms; i ++ ) { /* find possible endpoint Z = at[i] */ if ( endpoint_valence = nGetEndpointInfo( at, i, &eif1 ) ) { /* 1st endpoint candidate found. Find centerpoint candidate */ for ( j = 0; j < at[i].valence; j ++ ) { bond_type = (int)at[i].bond_type[j] & ~BOND_MARK_ALL; #if ( FIX_BOND23_IN_TAUT == 1 ) bond_type = ACTUAL_ORDER(pBNS,i,j,bond_type); #endif centerpoint = (int)at[i].neighbor[j]; /* a centerpoint candidate */ if ( (bond_type == BOND_DOUBLE || bond_type == BOND_ALTERN || bond_type == BOND_ALT12NS || bond_type == BOND_TAUTOM) && is_centerpoint_elem( at[centerpoint].el_number ) && ALLOWED_EDGE(pBNS, i, j) ) { /* test a centerpoint candidate. */ /* find all endpoints including at[i] and store them into EndPoint[] */ nNumPossibleMobile = 0; nGroupNumber = (AT_NUMB)num_atoms; /* greater than any tautomeric group number */ bDiffGroups = -1; /* ignore the first difference */ nNumDonor = nNumAcceptor = 0; for ( k = 0, nNumEndPoints = 0, nNumBondPos = 0; k < at[centerpoint].valence; k ++ ) { endpoint = at[centerpoint].neighbor[k]; /* endpoint candidate */ bond_type = (int)at[centerpoint].bond_type[k] & ~BOND_MARK_ALL; #if ( FIX_BOND23_IN_TAUT == 1 ) bond_type = ACTUAL_ORDER(pBNS,centerpoint,k,bond_type); #endif bTautBond = bNonTautBond = bAltBond = bPossiblyEndpoint = 0; if ( !ALLOWED_EDGE(pBNS, centerpoint, k) ) { continue; } else if ( bond_type == BOND_ALTERN || bond_type == BOND_ALT12NS || bond_type == BOND_TAUTOM ) { bTautBond = 1; #if ( REPLACE_ALT_WITH_TAUT == 1 ) bAltBond = (bond_type == BOND_ALTERN || bond_type == BOND_ALT12NS); #endif } else if ( bond_type == BOND_SINGLE || bond_type == BOND_DOUBLE ) bNonTautBond = 1; else continue; if ( !(endpoint_valence = nGetEndpointInfo( at, endpoint, &eif1 )) ) continue; /* not an endpoint element or can't have mobile groups */ /* save information about the found possible tautomeric endpoint */ /* 2 = T_NUM_NO_ISOTOPIC non-isotopic values */ nMobile = AddAtom2num( EndPoint[nNumEndPoints].num, at, endpoint, 2 ); /* fill out */ AddAtom2DA( EndPoint[nNumEndPoints].num_DA, at, endpoint, 2 ); /* --- why is isitopic info missing ? -- see below nMobile = EndPoint[nNumEndPoints].num[1] = (at[endpoint].charge == -1); nMobile = EndPoint[nNumEndPoints].num[0] = at[endpoint].num_H + nMobile; */ if ( bNonTautBond ) { m = (bond_type == BOND_SINGLE && (nMobile || at[endpoint].endpoint)); nNumDonor += m; bPossiblyEndpoint += m; m = (bond_type == BOND_DOUBLE ); nNumAcceptor += m; bPossiblyEndpoint += m; } else { /* tautomeric or alternating bond */ m = (0 != at[endpoint].endpoint || eif1.cDonor ); nNumDonor += m; bPossiblyEndpoint += m; m = ( at[endpoint].endpoint || eif1.cNeutralBondsValence > at[endpoint].valence ); nNumAcceptor += m; bPossiblyEndpoint += m; } if ( !bPossiblyEndpoint ) continue; EndPoint[nNumEndPoints].nGroupNumber = at[endpoint].endpoint; /* =0 if it is an endpoint for the 1st time */ EndPoint[nNumEndPoints].nEquNumber = 0; EndPoint[nNumEndPoints].nAtomNumber = (AT_NUMB)endpoint; if ( nGroupNumber != at[endpoint].endpoint ) { bDiffGroups ++; nGroupNumber = at[endpoint].endpoint; } /* save positions of all, not only possibly tautomeric bonds */ #if ( REPLACE_ALT_WITH_TAUT != 1 ) if ( bNonTautBond || bAltBond ) { #endif BondPos[nNumBondPos].nAtomNumber = (AT_NUMB)centerpoint; BondPos[nNumBondPos].neighbor_index = (AT_NUMB)k; /* bond ordering number; used to change bonds to tautomeric only */ nNumBondPos ++; #if ( REPLACE_ALT_WITH_TAUT != 1 ) } #endif /* mobile group is possible if (a) the endpoint has a mobile group or */ /* (b) the centerpoint is adjacent to another endpoint */ nNumPossibleMobile += (nMobile>0 || at[endpoint].endpoint); nNumEndPoints ++; } if ( nNumEndPoints > 1 && nNumPossibleMobile && nNumDonor && nNumAcceptor ) { /* * a tautomeric group has been found * * at this point: * nGroupNumber = 0 if all endpoints belong to a newly discovered tautomeric group * bDiffGroups > 0 if at least 2 tautomeric groups are to be merged (one of them can be new) * case (nGroupNumber != 0 && bDiffGroups = 0 ) ignored because all endpoints belong to the same known t-group * case (nGroupNumber != 0 && bDiffGroups < 0 ) cannot happen */ nErr=FindAccessibleEndPoints( EndPoint, &nNumEndPoints, BondPos, &nNumBondPos, pBNS, pBD, at, num_atoms, c_group_info, ALT_PATH_MODE_TAUTOM ); if ( IS_BNS_ERROR(nErr) ) { return nErr; } nErr = 0; if ( nNumEndPoints > 0 ) { if ( !nGroupNumber || bDiffGroups > 0 ) { num_changes = RegisterEndPoints( t_group_info, EndPoint, nNumEndPoints, at, num_atoms, c_group_info, pBNS ); if ( num_changes == -1 ) { nErr = CT_TAUCOUNT_ERR; } if ( num_changes < 0 ) { nErr = num_changes; } if ( nErr ) goto exit_function; tot_changes += (num_changes>0); } if ( nNumBondPos > 0 ) { /* some of the bonds have not been marked as tautomeric yet */ num_changes = SetTautomericBonds( at, nNumBondPos, BondPos ); tot_changes += (num_changes>0); } } } } } } } #if ( KETO_ENOL_TAUT == 1 ) /***** post v.1 feature *****/ if ( t_group_info->bTautFlags & TG_FLAG_KETO_ENOL_TAUT ) { /* 1,3 keto-enol tautomerism */ for ( i = 0; i < num_atoms; i ++ ) { /* find possible endpoint Z = at[i] */ if ( endpoint_valence = nGetEndpointInfo_KET( at, i, &eif1 ) ) { /* 1st endpoint candidate found. Find centerpoint candidate */ for ( j = 0; j < at[i].valence; j ++ ) { bond_type = (int)at[i].bond_type[j] & ~BOND_MARK_ALL; #if ( FIX_BOND23_IN_TAUT == 1 ) bond_type = ACTUAL_ORDER(pBNS,i,j,bond_type); #endif centerpoint = (int)at[i].neighbor[j]; /* a centerpoint candidate */ if ( (bond_type == BOND_DOUBLE || bond_type == BOND_ALTERN || bond_type == BOND_ALT12NS || bond_type == BOND_TAUTOM) && is_centerpoint_elem_KET( at[centerpoint].el_number ) && !at[centerpoint].charge && !at[centerpoint].radical && /* only normal carbon is allowed */ 4 == at[centerpoint].chem_bonds_valence + at[centerpoint].num_H && ALLOWED_EDGE(pBNS, i, j) ) { int num_O = 0; int num_C = 0; /* test a centerpoint candidate. */ /* find all endpoints including at[i] and store them into EndPoint[] */ nNumPossibleMobile = 0; nGroupNumber = (AT_NUMB)num_atoms; /* greater than any tautomeric group number */ bDiffGroups = -1; /* ignore the first difference */ nNumDonor = nNumAcceptor = 0; for ( k = 0, nNumEndPoints = 0, nNumBondPos = 0; k < at[centerpoint].valence; k ++ ) { endpoint = at[centerpoint].neighbor[k]; /* endpoint candidate */ bond_type = (int)at[centerpoint].bond_type[k] & ~BOND_MARK_ALL; #if ( FIX_BOND23_IN_TAUT == 1 ) bond_type = ACTUAL_ORDER(pBNS,centerpoint,k,bond_type); #endif bTautBond = bNonTautBond = bAltBond = bPossiblyEndpoint = 0; if ( !ALLOWED_EDGE(pBNS, centerpoint, k) ) { continue; } else if ( bond_type == BOND_ALTERN || bond_type == BOND_ALT12NS || bond_type == BOND_TAUTOM ) { bTautBond = 1; #if ( REPLACE_ALT_WITH_TAUT == 1 ) bAltBond = (bond_type == BOND_ALTERN || bond_type == BOND_ALT12NS); #endif } else if ( bond_type == BOND_SINGLE || bond_type == BOND_DOUBLE ) bNonTautBond = 1; else continue; if ( !(endpoint_valence = nGetEndpointInfo_KET( at, endpoint, &eif2 )) ) { continue; } /* if ( 3 != eif1.cKetoEnolCode + eif2.cKetoEnolCode && endpoint != i ) continue; */ /* save information about the found possible tautomeric endpoint */ /* 2 = T_NUM_NO_ISOTOPIC non-isotopic values */ nMobile = AddAtom2num( EndPoint[nNumEndPoints].num, at, endpoint, 2 ); /* fill out */ AddAtom2DA( EndPoint[nNumEndPoints].num_DA, at, endpoint, 2 ); /* --- why is isitopic info missing ? -- see below nMobile = EndPoint[nNumEndPoints].num[1] = (at[endpoint].charge == -1); nMobile = EndPoint[nNumEndPoints].num[0] = at[endpoint].num_H + nMobile; */ if ( bNonTautBond ) { m = (bond_type == BOND_SINGLE && (nMobile || at[endpoint].endpoint)); nNumDonor += m; bPossiblyEndpoint += m; m = (bond_type == BOND_DOUBLE ); nNumAcceptor += m; bPossiblyEndpoint += m; } else { /* tautomeric or alternating bond */ m = (0 != at[endpoint].endpoint || eif1.cDonor ); nNumDonor += m; bPossiblyEndpoint += m; m = ( at[endpoint].endpoint || eif1.cNeutralBondsValence > at[endpoint].valence ); nNumAcceptor += m; bPossiblyEndpoint += m; } if ( !bPossiblyEndpoint ) continue; num_O += (endpoint_valence == 2); num_C += (endpoint_valence == 4); EndPoint[nNumEndPoints].nGroupNumber = at[endpoint].endpoint; /* =0 if it is an endpoint for the 1st time */ EndPoint[nNumEndPoints].nEquNumber = 0; EndPoint[nNumEndPoints].nAtomNumber = (AT_NUMB)endpoint; if ( nGroupNumber != at[endpoint].endpoint ) { bDiffGroups ++; nGroupNumber = at[endpoint].endpoint; } /* save positions of all, not only possibly tautomeric bonds */ #if ( REPLACE_ALT_WITH_TAUT != 1 ) if ( bNonTautBond || bAltBond ) { #endif BondPos[nNumBondPos].nAtomNumber = (AT_NUMB)centerpoint; BondPos[nNumBondPos].neighbor_index = (AT_NUMB)k; /* bond ordering number; used to change bonds to tautomeric only */ nNumBondPos ++; #if ( REPLACE_ALT_WITH_TAUT != 1 ) } #endif /* mobile group is possible if (a) the endpoint has a mobile group or */ /* (b) the centerpoint is adjacent to another endpoint */ nNumPossibleMobile += (nMobile>0 || at[endpoint].endpoint); nNumEndPoints ++; } if ( nNumEndPoints > 1 && nNumPossibleMobile && nNumDonor && nNumAcceptor && num_O==1 && num_C ) { /* * a tautomeric group has been found * * at this point: * nGroupNumber = 0 if all endpoints belong to a newly discovered tautomeric group * bDiffGroups > 0 if at least 2 tautomeric groups are to be merged (one of them can be new) * case (nGroupNumber != 0 && bDiffGroups = 0 ) ignored because all endpoints belong to the same known t-group * case (nGroupNumber != 0 && bDiffGroups < 0 ) cannot happen */ nErr=FindAccessibleEndPoints( EndPoint, &nNumEndPoints, BondPos, &nNumBondPos, pBNS, pBD, at, num_atoms, c_group_info, ALT_PATH_MODE_TAUTOM_KET ); if ( IS_BNS_ERROR(nErr) ) { return nErr; } nErr = 0; if ( nNumEndPoints > 0 ) { if ( !nGroupNumber || bDiffGroups > 0 ) { num_changes = RegisterEndPoints( t_group_info, EndPoint, nNumEndPoints, at, num_atoms, c_group_info, pBNS ); if ( num_changes == -1 ) { nErr = CT_TAUCOUNT_ERR; } if ( num_changes < 0 ) { nErr = num_changes; } if ( nErr ) goto exit_function; tot_changes += (num_changes>0); } if ( nNumBondPos > 0 ) { /* some of the bonds have not been marked as tautomeric yet */ num_changes = SetTautomericBonds( at, nNumBondPos, BondPos ); tot_changes += (num_changes>0); } } } } } } } } #endif /* KETO_ENOL_TAUT */ #if ( TAUT_OTHER == 1 ) /* { */ if ( !tot_changes ) { #define MAX_ALT_PATH_LEN 8 int nMaxLenDfsPath = MAX_ALT_PATH_LEN; int i1, i2; AT_RANK *nDfsPathPos = (AT_RANK *)inchi_calloc( num_atoms, sizeof(nDfsPathPos[0]) ); DFS_PATH DfsPath[MAX_ALT_PATH_LEN]; int ret; if ( !nDfsPathPos || !DfsPath ) { tot_changes = CT_OUT_OF_RAM; /* */ goto free_memory; } #if ( TAUT_15_NON_RING == 1 ) /***** post v.1 feature *****/ if ( t_group_info->bTautFlags & TG_FLAG_1_5_TAUT ) { /* 1,5 tautomerism; one of the endpoints should no be on a ring */ /* O OH O || | || A--pos- A--pos- A--pos- / sib- // sib- ? / sib- C ly C ly CH ly \\ a <--> \ a <--> \ a B--ring B--ring B--ring | || || NH N N Note: few recent modifications now allow the terminal N be in a ring, too */ for ( i1 = 0; i1 < num_atoms; i1 ++ ) { /* find possible endpoint Z = at[i1] */ if ( !(endpoint_valence = nGetEndpointInfo( at, i1, &eif1 ) ) /*|| at[i1].nNumAtInRingSystem > 1*/ ) { continue; /* not a possibly endpoint */ } if ( 1 ) { nNumEndPoints = 0; nNumBondPos = 0; ret = nGet15TautInAltPath( at, i1, nDfsPathPos, DfsPath, nMaxLenDfsPath, EndPoint, sizeof(EndPoint)/sizeof(EndPoint[0]), BondPos, sizeof(BondPos)/sizeof(BondPos[0]), &nNumEndPoints, &nNumBondPos, pBNS, pBD, num_atoms); if ( ret > 0 ) { if ( nNumEndPoints ) { num_changes = RegisterEndPoints( t_group_info, EndPoint, nNumEndPoints, at, num_atoms, c_group_info, pBNS); if ( num_changes == -1 ) { nErr = CT_TAUCOUNT_ERR; } if ( num_changes < 0 ) { nErr = num_changes; } if ( nErr ) goto free_memory; tot_changes += (num_changes > 0); } if ( nNumBondPos ) { tot_changes += ( 0 < SetTautomericBonds( at, nNumBondPos, BondPos ) ); } } else if ( IS_BNS_ERROR( ret ) ) { nErr = ret; goto free_memory; } } } } #endif #if ( TAUT_4PYRIDINOL_RINGS == 1 ) /* 6-member rings */ /* O OH OH || | | / \ // \ / \\ || || <--> | || <--> || | \ / \\ / \ // NH N N */ for ( i1 = 0; i1 < num_atoms; i1 ++ ) { /* find possible endpoint Z = at[i1] */ if ( 3 != (endpoint_valence = nGetEndpointInfo( at, i1, &eif1 ) ) || 2 != at[i1].valence ) { continue; /* not a nitrogen atom or a wrong valence */ } if ( at[i1].nNumAtInRingSystem >= 6 ) { nNumEndPoints = 0; nNumBondPos = 0; ret = nGet15TautIn6MembAltRing( at, i1, nDfsPathPos, DfsPath, nMaxLenDfsPath, EndPoint, sizeof(EndPoint)/sizeof(EndPoint[0]), BondPos, sizeof(BondPos)/sizeof(BondPos[0]), &nNumEndPoints, &nNumBondPos, pBNS, pBD, num_atoms); if ( ret > 0 ) { if ( nNumEndPoints ) { num_changes = RegisterEndPoints( t_group_info, EndPoint, nNumEndPoints, at, num_atoms, c_group_info, pBNS); if ( num_changes == -1 ) { nErr = CT_TAUCOUNT_ERR; } if ( num_changes < 0 ) { nErr = num_changes; } if ( nErr ) goto free_memory; tot_changes += (num_changes > 0); } if ( nNumBondPos ) { tot_changes += ( 0 < SetTautomericBonds( at, nNumBondPos, BondPos ) ); } } else if ( IS_BNS_ERROR( ret ) ) { nErr = ret; goto free_memory; } } } #endif /* TAUT_4PYRIDINOL_RINGS */ #if ( TAUT_PYRAZOLE_RINGS == 1 ) /* 5-member rings: Z Z / \\ // \ X Y <--> X Y \\ / \ // N--NH HN--N ^ ^ search for these NH */ /* 5-member rings (pyrazole derivatives): look for the neighboring N */ for ( i1 = 0; i1 < num_atoms; i1 ++ ) { if ( 2 == at[i1].valence && at[i1].nNumAtInRingSystem >= 5 && 3 == (endpoint_valence = nGetEndpointInfo( at, i1, &eif1 )) ) { nMobile = at[i1].num_H + (at[i1].charge == -1); for ( j = 0; j < at[i1].valence; j ++ ) { int nMobile2, endpoint_valence2; i2 = at[i1].neighbor[j]; /* may be important */ if ( i2 >= i1 ) continue; /* do not try same pair 2 times */ if ( at[i2].nRingSystem != at[i1].nRingSystem ) continue; bond_type = (at[i1].bond_type[j] & ~BOND_MARK_ALL); if ( bond_type != BOND_SINGLE && bond_type != BOND_TAUTOM && bond_type != BOND_ALT12NS && bond_type != BOND_ALTERN || /* added 1-15-2002 */ 2 != at[i2].valence || 3 != (endpoint_valence2 = nGetEndpointInfo( at, i2, &eif2 ) ) ) { continue; /* not a nitrogen atom or a wrong valence or not a single bond */ } nMobile2 = at[i2].num_H + (at[i2].charge == -1); /* number of mobile groups */ #if ( TAUT_IGNORE_EQL_ENDPOINTS == 1 ) if ( at[i1].endpoint && at[i1].endpoint == at[i2].endpoint ) continue; /* atoms already belong to the same t-group */ #endif if ( !at[i1].endpoint && !at[i2].endpoint && 1!=nMobile + nMobile2 ) continue; ret = nGet12TautIn5MembAltRing( at, i1, j, nDfsPathPos, DfsPath, nMaxLenDfsPath, EndPoint, sizeof(EndPoint)/sizeof(EndPoint[0]), BondPos, sizeof(BondPos)/sizeof(BondPos[0]), &nNumEndPoints, &nNumBondPos , pBNS, pBD, num_atoms); if ( ret > 0 ) { if ( nNumEndPoints ) { num_changes = RegisterEndPoints( t_group_info, EndPoint, nNumEndPoints, at, num_atoms, c_group_info, pBNS); if ( num_changes == -1 ) { nErr = CT_TAUCOUNT_ERR; } if ( num_changes < 0 ) { nErr = num_changes; } if ( nErr ) goto free_memory; tot_changes += (num_changes > 0); } if ( nNumBondPos ) { tot_changes += ( 0 < SetTautomericBonds( at, nNumBondPos, BondPos ) ); } } else if ( IS_BNS_ERROR( ret ) ) { nErr = ret; goto free_memory; } } } } #endif /* TAUT_PYRAZOLE_RINGS */ #if ( TAUT_TROPOLONE_7 == 1 || TAUT_TROPOLONE_5 == 1 ) /* { */ /******************************************************** * A B * | || * 7-member rings (tropolones): look for M=Q--R--ZH, * ^ ^ ^ ^ * endpoint1 i1 i2 endpoint2 * where A-Q-R=B belong to a 7-member alt. (except Q-R bond) ring: ..=A-(Q-R)=B-.. * Bond Q-R should be single or tautomeric or alternating * M=Q and R-ZH should be chain (non-ring) bonds * Same for 5-member rings */ for ( i1 = 0; i1 < num_atoms; i1 ++ ) { if ( at[i1].nNumAtInRingSystem >= #if ( TAUT_TROPOLONE_5 == 1 ) 5 #else 7 #endif && bIsCenterPointStrict( at, i1 ) && #if ( TAUT_RINGS_ATTACH_CHAIN == 1 ) at[i1].bCutVertex && #endif at[i1].valence == 3 && !at[i1].endpoint ) { int nMobile1, endpoint1, endpoint1_valence, bond_type1; int nMobile2, endpoint2, endpoint2_valence, bond_type2; for ( j = 0; j < at[i1].valence; j ++ ) { i2 = at[i1].neighbor[j]; /* // may be important if ( i2 > i1 ) continue; // do not try same pair 2 times */ if ( at[i2].nRingSystem != at[i1].nRingSystem || !bIsCenterPointStrict( at, i2 ) || #if ( TAUT_RINGS_ATTACH_CHAIN == 1 ) !at[i2].bCutVertex || #endif at[i2].valence != 3 || at[i2].endpoint ) continue; bond_type = (at[i1].bond_type[j] & ~BOND_MARK_ALL); if ( bond_type != BOND_SINGLE && bond_type != BOND_TAUTOM && bond_type != BOND_ALT12NS && bond_type != BOND_ALTERN ) { continue; /* not a single bond between Q-R */ } /* find endpoints */ for ( k = 0; k < at[i1].valence; k ++ ) { endpoint1 = at[i1].neighbor[k]; if ( endpoint1 == i2 ) continue; /* j == k */ if ( !(endpoint1_valence = nGetEndpointInfo( at, endpoint1, &eif1 ) ) ) continue; /* not an endpoint1 element or can't have mobile groups */ #if ( TAUT_RINGS_ATTACH_CHAIN == 1 ) if ( at[endpoint1].nRingSystem == at[i1].nRingSystem ) continue; #endif nMobile1 = at[endpoint1].num_H + (at[endpoint1].charge == -1); /* number of mobile groups */ if ( nMobile1 + at[endpoint1].chem_bonds_valence != endpoint1_valence ) continue; /* abnormal endpoint1 valence; ignore. */ bond_type1 = (at[i1].bond_type[k] & ~BOND_MARK_ALL); if ( bond_type1 != BOND_SINGLE && bond_type1 != BOND_DOUBLE && bond_type1 != BOND_TAUTOM && bond_type1 != BOND_ALT12NS && bond_type1 != BOND_ALTERN ) continue; for ( m = 0; m < at[i2].valence; m ++ ) { endpoint2 = at[i2].neighbor[m]; if ( endpoint2 == i1 ) continue; if ( !(endpoint2_valence = nGetEndpointInfo( at, endpoint2, &eif2 )) ) continue; /* not an endpoint2 element or can't have mobile groups */ #if ( TAUT_RINGS_ATTACH_CHAIN == 1 ) if ( at[endpoint2].nRingSystem == at[i2].nRingSystem ) continue; #endif nMobile2 = at[endpoint2].num_H + (at[endpoint2].charge == -1); /* number of mobile groups */ bond_type2 = (at[i2].bond_type[m] & ~BOND_MARK_ALL); if ( bond_type2 != BOND_SINGLE && bond_type2 != BOND_DOUBLE && bond_type2 != BOND_TAUTOM && bond_type2 != BOND_ALT12NS && bond_type2 != BOND_ALTERN ) continue; /* final test for possible tautomerism */ nMobile = 0; if ( ALLOWED_EDGE(pBNS, i1, k) && ALLOWED_EDGE(pBNS, i2, m) ) { /* can mobile group move from 1 to 2? */ nMobile += (at[endpoint1].endpoint || nMobile1) && /* from endpoint1 */ (bond_type1 != BOND_DOUBLE) && (at[endpoint2].endpoint || /* to endpoint2 */ eif2.cNeutralBondsValence > at[endpoint2].valence ) && (bond_type2 != BOND_SINGLE); /* can mobile group move from 2 to 1? */ nMobile += (at[endpoint2].endpoint || nMobile2) && /* from endpoint2 */ (bond_type2 != BOND_DOUBLE) && /*changed from BOND_SINGLE 2004-02-26 */ (at[endpoint1].endpoint || /* to endpoint1 */ eif1.cNeutralBondsValence > at[endpoint1].valence ) && (bond_type1 != BOND_SINGLE); } if ( !nMobile ) continue; if ( bond_type1 == bond_type2 && (bond_type1 == BOND_SINGLE || bond_type1 == BOND_DOUBLE) ) continue; /* -- old -- if ( !at[endpoint1].endpoint && !at[endpoint2].endpoint && 1 != nMobile1 + nMobile2 ) continue; */ /* -- new -- if ( !at[endpoint1].endpoint && !at[endpoint2].endpoint ) { if ( !(bond_type1 == BOND_SINGLE || bond_type1 == BOND_DOUBLE) || !(bond_type2 == BOND_SINGLE || bond_type2 == BOND_DOUBLE) ) { // at this point bond_type1 != bond_type2 continue; } if ( bond_type1 == BOND_SINGLE && !nMobile1 || bond_type2 == BOND_SINGLE && !nMobile2 || 0 == nMobile1 + nMobile2 ) { continue; } } */ #if ( TAUT_TROPOLONE_7 == 1 ) if ( at[i1].nNumAtInRingSystem >= 7 ) { ret = nGet14TautIn7MembAltRing( at, i1, j, k, m, nDfsPathPos, DfsPath, nMaxLenDfsPath, EndPoint, sizeof(EndPoint)/sizeof(EndPoint[0]), BondPos, sizeof(BondPos)/sizeof(BondPos[0]), &nNumEndPoints, &nNumBondPos, pBNS, pBD, num_atoms); if ( ret > 0 ) { if ( nNumEndPoints ) { num_changes = RegisterEndPoints( t_group_info, EndPoint, nNumEndPoints, at, num_atoms, c_group_info, pBNS); if ( num_changes == -1 ) { nErr = CT_TAUCOUNT_ERR; } if ( num_changes < 0 ) { nErr = num_changes; } if ( nErr ) goto free_memory; tot_changes += (num_changes > 0); } if ( nNumBondPos ) { tot_changes += ( 0 < SetTautomericBonds( at, nNumBondPos, BondPos ) ); } } else if ( IS_BNS_ERROR( ret ) ) { nErr = ret; goto free_memory; } } #endif #if ( TAUT_TROPOLONE_5 == 1 ) if ( at[i1].nNumAtInRingSystem >= 5 ) { ret = nGet14TautIn5MembAltRing( at, i1, j, k, m, nDfsPathPos, DfsPath, nMaxLenDfsPath, EndPoint, sizeof(EndPoint)/sizeof(EndPoint[0]), BondPos, sizeof(BondPos)/sizeof(BondPos[0]), &nNumEndPoints, &nNumBondPos, pBNS, pBD, num_atoms); if ( ret > 0 ) { if ( nNumEndPoints ) { num_changes = RegisterEndPoints( t_group_info, EndPoint, nNumEndPoints, at, num_atoms, c_group_info, pBNS); if ( num_changes == -1 ) { nErr = CT_TAUCOUNT_ERR; } if ( num_changes < 0 ) { nErr = num_changes; } if ( nErr ) goto free_memory; tot_changes += (num_changes > 0); } if ( nNumBondPos ) { tot_changes += ( 0 < SetTautomericBonds( at, nNumBondPos, BondPos ) ); } } else if ( IS_BNS_ERROR( ret ) ) { nErr = ret; goto free_memory; } } #endif } } } } } #endif /* } TAUT_TROPOLONE */ free_memory: if ( nDfsPathPos ) { inchi_free( nDfsPathPos ); } #undef MAX_ALT_PATH_LEN } #endif /* } FIND_RING_SYSTEMS */ exit_function: return nErr < 0? nErr : tot_changes; } /*****************************************************************************/ int free_t_group_info( T_GROUP_INFO *t_group_info ) { if ( t_group_info ) { if ( t_group_info->t_group ) { inchi_free( t_group_info->t_group ); } if ( t_group_info->nEndpointAtomNumber ) { inchi_free( t_group_info->nEndpointAtomNumber ); } if ( t_group_info->tGroupNumber ) { inchi_free( t_group_info->tGroupNumber ); } if ( t_group_info->nIsotopicEndpointAtomNumber ) { inchi_free( t_group_info->nIsotopicEndpointAtomNumber ); } memset( t_group_info, 0, sizeof(*t_group_info)); } return 0; } /*****************************************************************************/ int make_a_copy_of_t_group_info( T_GROUP_INFO *t_group_info, T_GROUP_INFO *t_group_info_orig ) { int err = 0, len; free_t_group_info( t_group_info ); if ( t_group_info_orig && t_group_info ) { if ( (len=t_group_info_orig->max_num_t_groups) > 0 ) { if (t_group_info->t_group = (T_GROUP*) inchi_malloc( len * sizeof(t_group_info->t_group[0]))) { memcpy(t_group_info->t_group, t_group_info_orig->t_group, len * sizeof(t_group_info->t_group[0])); } else { err ++; } } if ( (len = t_group_info_orig->nNumEndpoints) > 0 ) { if (t_group_info->nEndpointAtomNumber = (AT_NUMB*) inchi_malloc( len * sizeof(t_group_info->nEndpointAtomNumber[0]))) { memcpy(t_group_info->nEndpointAtomNumber, t_group_info_orig->nEndpointAtomNumber, len * sizeof(t_group_info->nEndpointAtomNumber[0])); } else { err ++; } } if ( (len = t_group_info_orig->num_t_groups) > 0 ) { if (t_group_info->tGroupNumber = (AT_NUMB*) inchi_malloc( len * TGSO_TOTAL_LEN * sizeof(t_group_info->tGroupNumber[0]))) { memcpy(t_group_info->tGroupNumber, t_group_info_orig->tGroupNumber, len * TGSO_TOTAL_LEN * sizeof(t_group_info->tGroupNumber[0])); } else { err ++; } } if ( (len = t_group_info_orig->nNumIsotopicEndpoints) > 0 ) { if (t_group_info->nIsotopicEndpointAtomNumber = (AT_NUMB*) inchi_malloc( len * sizeof(t_group_info->nIsotopicEndpointAtomNumber[0]))) { memcpy(t_group_info->nIsotopicEndpointAtomNumber, t_group_info_orig->nIsotopicEndpointAtomNumber, len * sizeof(t_group_info->nIsotopicEndpointAtomNumber[0])); } else { err ++; } } if ( !err ) { t_group_info->nNumEndpoints = t_group_info_orig->nNumEndpoints; t_group_info->num_t_groups = t_group_info_orig->num_t_groups; t_group_info->max_num_t_groups = t_group_info_orig->max_num_t_groups; t_group_info->bIgnoreIsotopic = t_group_info_orig->bIgnoreIsotopic; t_group_info->nNumIsotopicEndpoints = t_group_info_orig->nNumIsotopicEndpoints; t_group_info->tni = t_group_info_orig->tni; /* t_group_info->nNumRemovedExplicitH = t_group_info_orig->nNumRemovedExplicitH; t_group_info->nNumRemovedProtons = t_group_info_orig->nNumRemovedProtons; t_group_info->bNormalizationFlags = t_group_info_orig->bNormalizationFlags; */ /* t_group_info->bHardAddedRemovedProtons = t_group_info_orig->bHardAddedRemovedProtons; t_group_info->bSimpleAddedRemovedProtons = t_group_info_orig->bSimpleAddedRemovedProtons; t_group_info->nNumCanceledCharges = t_group_info_orig->nNumCanceledCharges; */ } t_group_info->bTautFlags = t_group_info_orig->bTautFlags; t_group_info->bTautFlagsDone = t_group_info_orig->bTautFlagsDone; } return err; } /*****************************************************************************/ /* Set tautomer group isotopic sort keys */ /*****************************************************************************/ int set_tautomer_iso_sort_keys( T_GROUP_INFO *t_group_info ) { T_GROUP *t_group; T_GROUP_ISOWT Mult = 1; int i, j, num_t_groups, num_iso_t_groups = 0; if ( !t_group_info || !(t_group = t_group_info->t_group) || 0 >= (num_t_groups = t_group_info->num_t_groups) || t_group_info->nNumIsotopicEndpoints ) return 0; for ( i = 0; i < num_t_groups; i ++ ) { t_group[i].iWeight = 0; j = T_NUM_ISOTOPIC - 1; Mult = 1; do { t_group[i].iWeight += Mult * (T_GROUP_ISOWT)t_group[i].num[T_NUM_NO_ISOTOPIC+j]; } while ( --j >= 0 && (Mult *= T_GROUP_ISOWT_MULT) ); num_iso_t_groups += (t_group[i].iWeight != 0); } return num_iso_t_groups; } /****************************************************************************** * * Fill t_group_info with information necessary to fill out tautomer part * of the linear connection table record. * Note: on input, t_group_info should contain information created by MarkTautomerGroups() * No previous t_group_info adjustment due to throwing out disconnected parts of * the chemical structure is needed. * * Note2: throws out t_groups containing negative charges only (IGNORE_TGROUP_WITHOUT_H==1) * (leave their tautomeric bonds unchanged) * Note3: removes negative charges from other tautomeric groups * and adjust counts of mobile atoms if permitted (REMOVE_TGROUP_CHARGE==1) */ int CountTautomerGroups( sp_ATOM *at, int num_atoms, T_GROUP_INFO *t_group_info ) { int i, j, ret = 0, nNumEndpoints, max_t_group, num_groups_noH; AT_NUMB nGroupNumber, nNewGroupNumber, *nCurrEndpointAtNoPos = NULL; T_GROUP *t_group; int num_t; /* int bIgnoreIsotopic, max_num_t; */ AT_NUMB *nTautomerGroupNumber = NULL; AT_NUMB *nEndpointAtomNumber = NULL; AT_NUMB *tGroupNumber = NULL; if ( !t_group_info || !t_group_info->t_group || 0 >= t_group_info->max_num_t_groups ) { return 0; /* empty t-groups */ } num_t = t_group_info->num_t_groups; t_group = t_group_info->t_group; /* max_num_t = t_group_info->max_num_t_groups; bIgnoreIsotopic = t_group_info->bIgnoreIsotopic; */ num_groups_noH = 0; /* the following 2 arrays are to be rebuilt here */ if ( t_group_info->nEndpointAtomNumber ) { inchi_free ( t_group_info->nEndpointAtomNumber ); t_group_info->nEndpointAtomNumber = NULL; } if ( t_group_info->tGroupNumber ) { inchi_free ( t_group_info->tGroupNumber ); t_group_info->tGroupNumber = NULL; } /* find max_t_group */ for ( i = 0, max_t_group = 0; i < t_group_info->num_t_groups; i ++ ) { if ( max_t_group < t_group[i].nGroupNumber ) max_t_group = t_group[i].nGroupNumber; } /* allocate memory for temp storage of numbers of endpoints */ if ( max_t_group && !(nTautomerGroupNumber = (AT_NUMB*) inchi_calloc( max_t_group+1, sizeof(nTautomerGroupNumber[0]) ) /*temp*/ ) ) { goto err_exit_function; /* program error: out of RAM */ /* */ } /* count endpoints for each tautomer group */ for ( i = 0, nNumEndpoints = 0; i < num_atoms; i ++ ) { if ( (j = at[i].endpoint) == 0 ) continue; if ( j > max_t_group ) /* debug only */ goto err_exit_function; /* program error */ /* */ nTautomerGroupNumber[j] ++; nNumEndpoints ++; } if ( !nNumEndpoints ) { goto exit_function; /* not a tautomer */ } /* allocate temporary array */ if ( !(nEndpointAtomNumber = (AT_NUMB*) inchi_calloc( nNumEndpoints, sizeof(nEndpointAtomNumber[0]) ) ) || !(nCurrEndpointAtNoPos = (AT_NUMB*) inchi_calloc( num_t, sizeof(nCurrEndpointAtNoPos[0]) ) /*temp*/ ) ) { goto err_exit_function; /* program error: out of RAM */ /* */ } /* * Remove missing endpoints from t_group. Since only one * disconnected part is processed, some endpoints groups may have disappeared. * Mark t_groups containing charges only for subsequent removal */ for ( i = 0, nNewGroupNumber = 0; i < num_t; /*i ++*/ ) { int bNoH = 0, nNumH; nGroupNumber = t_group[i].nGroupNumber; for ( j = 1, nNumH = t_group[i].num[0]; j < T_NUM_NO_ISOTOPIC; j ++ ) { nNumH -= (int)t_group[i].num[j]; } if ( t_group[i].nNumEndpoints != nTautomerGroupNumber[(int)nGroupNumber] #if ( IGNORE_TGROUP_WITHOUT_H == 1 ) || (bNoH = (t_group[i].num[0]==t_group[i].num[1])) /* only for (H,-) t-groups; (+) t-groups are not removed */ #endif ) { if ( !nTautomerGroupNumber[(int)nGroupNumber] || bNoH ) { /* the group belongs to another disconnected part of the structure or has only charges */ /* Remove the group */ num_t --; if ( i < num_t ) memmove( t_group+i, t_group+i+1, (num_t-i)*sizeof(t_group[0]) ); if ( bNoH ) { /* group contains no mobile hydrogen atoms, only charges. Prepare to remove it. */ nTautomerGroupNumber[(int)nGroupNumber] = 0; num_groups_noH ++; } /*i --;*/ } else { /* different number of endpoints */ goto err_exit_function; /* program error */ /* */ } } else { /* renumber t_group and prepare to renumber at[i].endpoint */ nTautomerGroupNumber[(int)nGroupNumber] = t_group[i].nGroupNumber = ++nNewGroupNumber; /* = i+1 */ /* get first group atom orig. number position in the nEndpointAtomNumber[] */ /* and in the tautomer endpoint canon numbers part of the connection table */ t_group[i].nFirstEndpointAtNoPos = nCurrEndpointAtNoPos[i] = i? (t_group[i-1].nFirstEndpointAtNoPos+t_group[i-1].nNumEndpoints) : 0; t_group[i].num[0] = nNumH; #if ( REMOVE_TGROUP_CHARGE == 1 ) t_group[i].num[1] = 0; /* remove only (-) charges */ #endif /* -- wrong condition. Disabled. if ( t_group[i].nGroupNumber != i + 1 ) { // for debug only goto err_exit_function; // program error } */ i ++; } } if ( num_t != nNewGroupNumber ) { /* for debug only */ goto err_exit_function; /* program error */ /* */ } /* check if any tautomer group was left */ if ( !nNewGroupNumber ) { if ( !num_groups_noH ) goto err_exit_function; /* program error: not a tautomer */ /* */ else goto exit_function; } /* * an array for tautomer group sorting later, at the time of storing Connection Table * Later the sorting consists out of 2 steps: * 1) Sort t_group[i].nNumEndpoints endpoint atom ranks within each endpoint group * starting from t_group[i].nFirstEndpointAtNoPos; i = 0..t_group_info->num_t_groups-1 * 2) Sort the groups indexes t_group_info->tGroupNumber[] */ if ( !(tGroupNumber= (AT_NUMB*)inchi_calloc(nNewGroupNumber*TGSO_TOTAL_LEN, sizeof(tGroupNumber[0])))) { goto err_exit_function; /* out of RAM */ } for ( i = 0; i < nNewGroupNumber; i ++ ) { tGroupNumber[i] = (AT_NUMB)i; /* initialization: original t_group number = (at[i]->endpoint-1) */ } /* * renumber endpoint atoms and save their orig. atom * numbers for filling out the tautomer part of the LinearCT. * nCurrEndpointAtNoPos[j] is an index of the atom number in the nEndpointAtomNumber[] */ for ( i = 0; i < num_atoms; i ++ ) { if ( j = (int)at[i].endpoint ) { j = (int)(at[i].endpoint = nTautomerGroupNumber[j])-1; /* new t_group number */ if ( j >= 0 ) { /* j=-1 in case of no mobile hydrogen atoms (charges only), group being removed */ if ( nCurrEndpointAtNoPos[j] >= /* debug only */ t_group[j].nFirstEndpointAtNoPos+t_group[j].nNumEndpoints ) { goto err_exit_function; /* program error */ /* */ } nEndpointAtomNumber[(int)nCurrEndpointAtNoPos[j] ++] = (AT_NUMB)i; } else { nNumEndpoints --; /* endpoint has been removed */ } } } t_group_info->num_t_groups = nNewGroupNumber; t_group_info->nNumEndpoints = nNumEndpoints; t_group_info->nEndpointAtomNumber = nEndpointAtomNumber; t_group_info->tGroupNumber = tGroupNumber; /* only the 1st segment filled */ inchi_free ( nTautomerGroupNumber ); inchi_free ( nCurrEndpointAtNoPos ); return nNumEndpoints + T_GROUP_HDR_LEN * nNewGroupNumber + 1; /* nLenLinearCTTautomer */ err_exit_function: ret = CT_TAUCOUNT_ERR; exit_function: /* release allocated memory; set "no tautomeric group" */ if ( nEndpointAtomNumber ) inchi_free ( nEndpointAtomNumber ); if ( nTautomerGroupNumber ) inchi_free ( nTautomerGroupNumber ); if ( tGroupNumber ) inchi_free ( tGroupNumber ); if ( nCurrEndpointAtNoPos ) inchi_free ( nCurrEndpointAtNoPos ); t_group_info->nNumEndpoints = 0; t_group_info->num_t_groups = 0; if ( !ret && ((t_group_info->tni.bNormalizationFlags & FLAG_NORM_CONSIDER_TAUT) || t_group_info->nNumIsotopicEndpoints>1 && (t_group_info->bTautFlagsDone & (TG_FLAG_FOUND_ISOTOPIC_H_DONE | TG_FLAG_FOUND_ISOTOPIC_ATOM_DONE))) ) { ret = 1; /* only protons have been (re)moved or neitralization happened */ } return ret; } #if ( READ_INCHI_STRING == 1 ) #if ( INCLUDE_NORMALIZATION_ENTRY_POINT == 1 ) /*****************************************************************************/ int CountTautomerGroupsInpAt( inp_ATOM *at, int num_atoms, T_GROUP_INFO *t_group_info ) { int i, j, ret = 0, nNumEndpoints, max_t_group, num_groups_noH; AT_NUMB nGroupNumber, nNewGroupNumber, *nCurrEndpointAtNoPos = NULL; T_GROUP *t_group; int num_t; /* int bIgnoreIsotopic, max_num_t; */ AT_NUMB *nTautomerGroupNumber = NULL; AT_NUMB *nEndpointAtomNumber = NULL; AT_NUMB *tGroupNumber = NULL; if ( !t_group_info || !t_group_info->t_group || 0 >= t_group_info->max_num_t_groups ) { return 0; /* empty t-groups */ } num_t = t_group_info->num_t_groups; t_group = t_group_info->t_group; /* max_num_t = t_group_info->max_num_t_groups; bIgnoreIsotopic = t_group_info->bIgnoreIsotopic; */ num_groups_noH = 0; /* the following 2 arrays are to be rebuilt here */ if ( t_group_info->nEndpointAtomNumber ) { inchi_free ( t_group_info->nEndpointAtomNumber ); t_group_info->nEndpointAtomNumber = NULL; } if ( t_group_info->tGroupNumber ) { inchi_free ( t_group_info->tGroupNumber ); t_group_info->tGroupNumber = NULL; } /* find max_t_group */ for ( i = 0, max_t_group = 0; i < t_group_info->num_t_groups; i ++ ) { if ( max_t_group < t_group[i].nGroupNumber ) max_t_group = t_group[i].nGroupNumber; } /* allocate memory for temp storage of numbers of endpoints */ if ( max_t_group && !(nTautomerGroupNumber = (AT_NUMB*) inchi_calloc( max_t_group+1, sizeof(nTautomerGroupNumber[0]) ) /*temp*/ ) ) { goto err_exit_function; /* program error: out of RAM */ /* */ } /* count endpoints for each tautomer group */ for ( i = 0, nNumEndpoints = 0; i < num_atoms; i ++ ) { if ( (j = at[i].endpoint) == 0 ) continue; if ( j > max_t_group ) /* debug only */ goto err_exit_function; /* program error */ /* */ nTautomerGroupNumber[j] ++; nNumEndpoints ++; } if ( !nNumEndpoints ) { goto exit_function; /* not a tautomer */ } /* allocate temporary array */ if ( !(nEndpointAtomNumber = (AT_NUMB*) inchi_calloc( nNumEndpoints, sizeof(nEndpointAtomNumber[0]) ) ) || !(nCurrEndpointAtNoPos = (AT_NUMB*) inchi_calloc( num_t, sizeof(nCurrEndpointAtNoPos[0]) ) /*temp*/ ) ) { goto err_exit_function; /* program error: out of RAM */ /* */ } /* * Remove missing endpoints from t_group. Since only one * disconnected part is processed, some endpoints groups may have disappeared. * Mark t_groups containing charges only for subsequent removal */ for ( i = 0, nNewGroupNumber = 0; i < num_t; /*i ++*/ ) { int bNoH = 0, nNumH; nGroupNumber = t_group[i].nGroupNumber; for ( j = 1, nNumH = t_group[i].num[0]; j < T_NUM_NO_ISOTOPIC; j ++ ) { nNumH -= (int)t_group[i].num[j]; } if ( t_group[i].nNumEndpoints != nTautomerGroupNumber[(int)nGroupNumber] #if ( IGNORE_TGROUP_WITHOUT_H == 1 ) || (bNoH = (t_group[i].num[0]==t_group[i].num[1])) /* only for (H,-) t-groups; (+) t-groups are not removed */ #endif ) { if ( !nTautomerGroupNumber[(int)nGroupNumber] || bNoH ) { /* the group belongs to another disconnected part of the structure or has only charges */ /* Remove the group */ num_t --; if ( i < num_t ) memmove( t_group+i, t_group+i+1, (num_t-i)*sizeof(t_group[0]) ); if ( bNoH ) { /* group contains no mobile hydrogen atoms, only charges. Prepare to remove it. */ nTautomerGroupNumber[(int)nGroupNumber] = 0; num_groups_noH ++; } /*i --;*/ } else { /* different number of endpoints */ goto err_exit_function; /* program error */ /* */ } } else { /* renumber t_group and prepare to renumber at[i].endpoint */ nTautomerGroupNumber[(int)nGroupNumber] = t_group[i].nGroupNumber = ++nNewGroupNumber; /* = i+1 */ /* get first group atom orig. number position in the nEndpointAtomNumber[] */ /* and in the tautomer endpoint canon numbers part of the connection table */ t_group[i].nFirstEndpointAtNoPos = nCurrEndpointAtNoPos[i] = i? (t_group[i-1].nFirstEndpointAtNoPos+t_group[i-1].nNumEndpoints) : 0; t_group[i].num[0] = nNumH; #if ( REMOVE_TGROUP_CHARGE == 1 ) t_group[i].num[1] = 0; /* remove only (-) charges */ #endif /* -- wrong condition. Disabled. if ( t_group[i].nGroupNumber != i + 1 ) { // for debug only goto err_exit_function; // program error } */ i ++; } } if ( num_t != nNewGroupNumber ) { /* for debug only */ goto err_exit_function; /* program error */ /* */ } /* check if any tautomer group was left */ if ( !nNewGroupNumber ) { if ( !num_groups_noH ) goto err_exit_function; /* program error: not a tautomer */ /* */ else goto exit_function; } /* * an array for tautomer group sorting later, at the time of storing Connection Table * Later the sorting consists out of 2 steps: * 1) Sort t_group[i].nNumEndpoints endpoint atom ranks within each endpoint group * starting from t_group[i].nFirstEndpointAtNoPos; i = 0..t_group_info->num_t_groups-1 * 2) Sort the groups indexes t_group_info->tGroupNumber[] */ if ( !(tGroupNumber= (AT_NUMB*)inchi_calloc(nNewGroupNumber*TGSO_TOTAL_LEN, sizeof(tGroupNumber[0])))) { goto err_exit_function; /* out of RAM */ } for ( i = 0; i < nNewGroupNumber; i ++ ) { tGroupNumber[i] = (AT_NUMB)i; /* initialization: original t_group number = (at[i]->endpoint-1) */ } /* * renumber endpoint atoms and save their orig. atom * numbers for filling out the tautomer part of the LinearCT. * nCurrEndpointAtNoPos[j] is an index of the atom number in the nEndpointAtomNumber[] */ for ( i = 0; i < num_atoms; i ++ ) { if ( j = (int)at[i].endpoint ) { j = (int)(at[i].endpoint = nTautomerGroupNumber[j])-1; /* new t_group number */ if ( j >= 0 ) { /* j=-1 in case of no mobile hydrogen atoms (charges only), group being removed */ if ( nCurrEndpointAtNoPos[j] >= /* debug only */ t_group[j].nFirstEndpointAtNoPos+t_group[j].nNumEndpoints ) { goto err_exit_function; /* program error */ /* */ } nEndpointAtomNumber[(int)nCurrEndpointAtNoPos[j] ++] = (AT_NUMB)i; } else { nNumEndpoints --; /* endpoint has been removed */ } } } t_group_info->num_t_groups = nNewGroupNumber; t_group_info->nNumEndpoints = nNumEndpoints; t_group_info->nEndpointAtomNumber = nEndpointAtomNumber; t_group_info->tGroupNumber = tGroupNumber; /* only the 1st segment filled */ inchi_free ( nTautomerGroupNumber ); inchi_free ( nCurrEndpointAtNoPos ); return nNumEndpoints + T_GROUP_HDR_LEN * nNewGroupNumber + 1; /* nLenLinearCTTautomer */ err_exit_function: ret = CT_TAUCOUNT_ERR; exit_function: /* release allocated memory; set "no tautomeric group" */ if ( nEndpointAtomNumber ) inchi_free ( nEndpointAtomNumber ); if ( nTautomerGroupNumber ) inchi_free ( nTautomerGroupNumber ); if ( tGroupNumber ) inchi_free ( tGroupNumber ); if ( nCurrEndpointAtNoPos ) inchi_free ( nCurrEndpointAtNoPos ); t_group_info->nNumEndpoints = 0; t_group_info->num_t_groups = 0; if ( !ret && ((t_group_info->tni.bNormalizationFlags & FLAG_NORM_CONSIDER_TAUT) || t_group_info->nNumIsotopicEndpoints>1 && (t_group_info->bTautFlagsDone & (TG_FLAG_FOUND_ISOTOPIC_H_DONE | TG_FLAG_FOUND_ISOTOPIC_ATOM_DONE))) ) { ret = 1; /* only protons have been (re)moved or neitralization happened */ } return ret; } #endif #endif /***************************************************************************** * tautomers: Compare for sorting *****************************************************************************/ /* Compare for sorting Ranks only */ /* Globals: pn_tRankForSort */ int CompRankTautomer(const void* a1, const void* a2 ) { int ret = (int)pn_tRankForSort[(int)(*(const AT_RANK*)a1)] - (int)pn_tRankForSort[(int)(*(const AT_RANK*)a2)]; return ret; } /*****************************************************************************/ int SortTautomerGroupsAndEndpoints( T_GROUP_INFO *t_group_info, int num_atoms, int num_at_tg, AT_RANK *nRank ) { int i, nFirstEndpointAtNoPos, nNumEndpoints; AT_NUMB *nEndpointAtomNumber; int num_t_groups = num_at_tg - num_atoms; T_GROUP *t_group = NULL; /* check if sorting is required */ if ( num_t_groups <= 0 || t_group_info->nNumEndpoints < 2 ) { return 0; /* no tautomer data */ } t_group = t_group_info->t_group; /* sort endpoints within the groups */ for ( i = 0; i < num_t_groups; i ++ ) { if ( t_group[i].nNumEndpoints < 2 ) continue; /* program error; should not happen */ /* */ /* set globals for sorting */ nFirstEndpointAtNoPos = t_group[i].nFirstEndpointAtNoPos; nNumEndpoints = t_group[i].nNumEndpoints; if ( nNumEndpoints + nFirstEndpointAtNoPos > t_group_info->nNumEndpoints ) { /* for debug only */ return CT_TAUCOUNT_ERR; /* program error */ /* */ } nEndpointAtomNumber = t_group_info->nEndpointAtomNumber+(int)nFirstEndpointAtNoPos; pn_tRankForSort = nRank; insertions_sort( nEndpointAtomNumber, nNumEndpoints, sizeof(nEndpointAtomNumber[0]), CompRankTautomer); } /* sort the tautomeric groups according to their ranks only (that is, ignoring the isotopic composition of the mobile groups and ranks of the endpoints) */ if ( t_group_info->num_t_groups > 1 ) { /* set globals for sorting */ /* a hack: the ranks of all tautomeric groups are */ /* located at nRank[num_atoms..num_at_tg-1] */ pn_tRankForSort = nRank+num_atoms; /* sort */ /* ordering numbers to sort : t_group_info->tGroupNumber; */ insertions_sort( t_group_info->tGroupNumber, num_t_groups, sizeof(t_group_info->tGroupNumber[0]), CompRankTautomer); } return t_group_info->num_t_groups; }