_ZNK9OpenBabel6OBAtom6GetIdxEv: 189| 865M| unsigned int GetIdx() const { return((int)_idx); } _ZNK9OpenBabel6OBAtom12GetAtomicNumEv: 176| 88.3M| unsigned int GetAtomicNum() const { return((unsigned int)_ele); } _ZNK9OpenBabel6OBAtom17GetImplicitHCountEv: 206| 4.95M| unsigned char GetImplicitHCount() const { return _imph; }; _ZNK9OpenBabel6OBAtom15GetFormalChargeEv: 174| 33.0M| int GetFormalCharge() const { return(_fcharge); } _ZNK9OpenBabel6OBAtom5GetIdEv: 191| 1.58M| unsigned long GetId() const { return _id; } _ZN9OpenBabel6OBAtom6SetIdxEi: 131| 138M| void SetIdx(int idx) { _idx = idx; _cidx = (idx-1)*3; } _ZN9OpenBabel6OBAtom11SetCoordPtrEPPd: 156| 67.1M| void SetCoordPtr(double **c) { _c = c; _cidx = (GetIdx()-1)*3; } _ZN9OpenBabel6OBAtom9SetParentEPNS_5OBMolE: 162| 71.8M| void SetParent(OBMol *ptr) { _parent=ptr; } _ZN9OpenBabel6OBAtom5SetIdEm: 132| 71.8M| void SetId(unsigned long id) { _id = id; } _ZN9OpenBabel6OBAtom17SetImplicitHCountEj: 140| 54.5M| void SetImplicitHCount(unsigned int val) { _imph = (unsigned char)val; } _ZN9OpenBabel6OBAtom12SetAtomicNumEi: 136| 71.8M| void SetAtomicNum(int atomicnum) { _ele = (char)atomicnum; } _ZN9OpenBabel6OBAtom7AddBondEPNS_6OBBondE: 317| 143M| void AddBond(OBBond *bond) { _vbond.push_back(bond); } _ZNK9OpenBabel6OBAtom17GetExplicitDegreeEv: 196| 17.0M| unsigned int GetExplicitDegree() const { return (unsigned int)_vbond.size(); } _ZN9OpenBabel6OBAtom10InsertBondERNSt3__111__wrap_iterIPPNS_6OBBondEEES4_: 321| 91.5k| { 322| 91.5k| _vbond.insert(i, bond); 323| 91.5k| } _ZN9OpenBabel6OBAtom11SetAromaticEb: 164| 85.1M| void SetAromatic(bool value=true) { SET_OR_UNSET_FLAG(OB_AROMATIC_ATOM); } ------------------ | | 65| 85.1M| if (value) SetFlag(X); \ | | ------------------ | | | Branch (65:7): [True: 42.0M, False: 43.1M] | | ------------------ | | 66| 85.1M| else UnsetFlag(X); ------------------ _ZN9OpenBabel6OBAtom7SetFlagEi: 98| 44.5M| void SetFlag(int flag) { _flags |= flag; } _ZN9OpenBabel6OBAtom9UnsetFlagEi: 100| 86.4M| void UnsetFlag(int flag) { _flags &= (~(flag)); } _ZN9OpenBabel6OBAtom15SetFormalChargeEi: 142| 14.8k| void SetFormalCharge(int fcharge) { _fcharge = fcharge; } _ZN9OpenBabel6OBAtom7HasFlagEi: 102| 200M| bool HasFlag(int flag) { return((_flags & flag) ? true : false); } ------------------ | Branch (102:41): [True: 85.2M, False: 115M] ------------------ _ZN9OpenBabel6OBAtom19SetSpinMultiplicityEs: 144| 258k| void SetSpinMultiplicity(short spin){ _spinmultiplicity = spin; } _ZN9OpenBabel6OBAtom9SetInRingEb: 166| 45.8M| void SetInRing(bool value=true) { SET_OR_UNSET_FLAG(OB_RING_ATOM); } ------------------ | | 65| 45.8M| if (value) SetFlag(X); \ | | ------------------ | | | Branch (65:7): [True: 2.47M, False: 43.3M] | | ------------------ | | 66| 45.8M| else UnsetFlag(X); ------------------ _ZNK9OpenBabel6OBAtom14GetTotalDegreeEv: 198| 30.6M| unsigned int GetTotalDegree() const { return (unsigned int)(_vbond.size() + _imph); } _ZN9OpenBabel6OBAtom9GetParentEv: 255| 200M| OBMol *GetParent() {return((OBMol*)_parent);} _ZN9OpenBabel13OBGenericDataD2Ev: 211| 9.70M| virtual ~OBGenericData() {} _ZN9OpenBabel13OBGenericData12SetAttributeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 217| 9.35M| { _attr = v; } _ZN9OpenBabel13OBGenericData9SetOriginENS_10DataOriginE: 219| 12.5k| void SetOrigin(const DataOrigin s) { _source = s; } _ZNK9OpenBabel13OBGenericData12GetAttributeEv: 222| 4.61M| { return(_attr); } _ZNK9OpenBabel13OBGenericData11GetDataTypeEv: 225| 658| { return(_type); } _ZN9OpenBabel6OBBaseD2Ev: 243| 143M| { 244| 143M| if (!_vdata.empty()) ------------------ | Branch (244:15): [True: 4.95M, False: 138M] ------------------ 245| 4.95M| { 246| 4.95M| std::vector::iterator m; 247| 14.6M| for (m = _vdata.begin();m != _vdata.end();m++) ------------------ | Branch (247:39): [True: 9.70M, False: 4.95M] ------------------ 248| 9.70M| delete *m; 249| 4.95M| _vdata.clear(); 250| 4.95M| } 251| 143M| } _ZN9OpenBabel6OBBase7SetDataEPNS_13OBGenericDataE: 307| 9.70M| { 308| 9.70M| if(d) _vdata.push_back(d); ------------------ | Branch (308:14): [True: 9.70M, False: 0] ------------------ 309| 9.70M| } _ZN9OpenBabel6OBBase12CastAndClearINS_5OBMolEEEPT_b: 276| 9.18k| { 277| 9.18k| T* pOb = dynamic_cast(this); 278| 9.18k| if(pOb && clear)// Clear only if this is of target class ------------------ | Branch (278:14): [True: 9.18k, False: 0] | Branch (278:21): [True: 9.18k, False: 0] ------------------ 279| 9.18k| Clear(); 280| 9.18k| return pOb; 281| 9.18k| } _ZN9OpenBabel8OBBitVecC2Ev: 75| 8.43M| { _size = _set.size(); } _ZN9OpenBabel8OBBitVec6ResizeEj: 129| 91.6k| { 130| 91.6k| return ResizeWords( WORDSIZE_OF_BITSIZE(size_in_bits) ); ------------------ | | 42| 91.6k|#define WORDSIZE_OF_BITSIZE( bit_size ) ( ( bit_size >> WORDROLL ) + (( bit_size & WORDMASK ) ? 1 : 0) ) | | ------------------ | | | | 38| 91.6k|#define WORDROLL 5 | | ------------------ | | #define WORDSIZE_OF_BITSIZE( bit_size ) ( ( bit_size >> WORDROLL ) + (( bit_size & WORDMASK ) ? 1 : 0) ) | | ------------------ | | | | 40| 91.6k|#define WORDMASK 31 | | ------------------ | | | Branch (42:71): [True: 89.7k, False: 1.86k] | | ------------------ ------------------ 131| 91.6k| } _ZN9OpenBabel8OBBitVec11ResizeWordsEj: 138| 938k| { 139| 938k| if (size_in_words <= _size) ------------------ | Branch (139:7): [True: 34.4k, False: 903k] ------------------ 140| 34.4k| return false; 141| 903k| _set.resize(size_in_words, 0); // increase the vector with zeroed bits 142| 903k| _size = _set.size(); 143| 903k| return true; 144| 938k| } _ZNK9OpenBabel8OBBitVec8BitIsSetEj: 151| 798M| { 152| 798M| bool rtn = false; 153| 798M| unsigned word_offset = bit_offset >> WORDROLL; ------------------ | | 38| 798M|#define WORDROLL 5 ------------------ 154| 798M| if (word_offset < GetSize()) ------------------ | Branch (154:9): [True: 798M, False: 138k] ------------------ 155| 798M| { 156| 798M| bit_offset &= WORDMASK; ------------------ | | 40| 798M|#define WORDMASK 31 ------------------ 157| 798M| rtn = (( _set[word_offset] >> bit_offset ) & 1); 158| 798M| } 159| 798M| return rtn; 160| 798M| } _ZNK9OpenBabel8OBBitVec7GetSizeEv: 117| 35.9G| size_t GetSize() const { return(_size); } _ZNK9OpenBabel8OBBitVec6EndBitEv: 115| 34.8M| int EndBit() const { return -1; } _ZN9OpenBabel8OBBitVecoREi: 199| 33.1M| { 200| 33.1M| SetBitOn(bit_offset); 201| 33.1M| return(*this); 202| 33.1M| } _ZNK9OpenBabel8OBBitVecixEi: 215| 59.5M| { return BitIsSet(bit_offset); } _ZNK9OpenBabel8OBBitVec8FirstBitEj: 109| 14.5k| { 110| 14.5k| return (BitIsSet(bit_offset) ? 0 : NextBit(bit_offset)); ------------------ | Branch (110:19): [True: 1.42k, False: 13.0k] ------------------ 111| 14.5k| } _ZN9OpenBabel8OBBitVecC2Ej: 84| 8.38M| { _size = _set.size(); } _ZN9OpenBabel8OBBitVecC2ERKS0_: 92| 1.18M| { (*this) = bv; } _ZN9OpenBabel6OBBond13GetNbrAtomIdxEPNS_6OBAtomE: 193| 556k| { 194| 556k| if (ptr!=_bgn) ------------------ | Branch (194:15): [True: 278k, False: 278k] ------------------ 195| 278k| return (_bgn ? _bgn->GetIdx() : 0); ------------------ | Branch (195:21): [True: 278k, False: 0] ------------------ 196| 278k| else 197| 278k| return (_end ? _end->GetIdx() : 0); ------------------ | Branch (197:21): [True: 278k, False: 0] ------------------ 198| 556k| } _ZN9OpenBabel6OBBond12GetBeginAtomEv: 168| 186M| OBAtom *GetBeginAtom() { return(_bgn); } _ZN9OpenBabel6OBBond10GetEndAtomEv: 172| 163M| OBAtom *GetEndAtom() { return(_end); } _ZN9OpenBabel6OBBond10GetNbrAtomEPNS_6OBAtomE: 179| 3.01G| { 180| 3.01G| return((ptr != _bgn)? _bgn : _end); ------------------ | Branch (180:18): [True: 184M, False: 2.82G] ------------------ 181| 3.01G| } _ZN9OpenBabel6OBBond5SetIdEm: 111| 71.8M| void SetId(unsigned long id) { _id = id; } _ZNK9OpenBabel6OBBond15GetBeginAtomIdxEv: 163| 277k| { return (_bgn ? _bgn->GetIdx() : 0); } ------------------ | Branch (163:19): [True: 277k, False: 0] ------------------ _ZNK9OpenBabel6OBBond13GetEndAtomIdxEv: 166| 92.6k| { return (_end ? _end->GetIdx() : 0); } ------------------ | Branch (166:19): [True: 92.6k, False: 0] ------------------ _ZNK9OpenBabel6OBBond12GetBondOrderEv: 158| 185M| unsigned int GetBondOrder() const { return(_order); } _ZN9OpenBabel6OBBond9SetParentEPNS_5OBMolE: 119| 71.8M| void SetParent(OBMol *ptr) { _parent= ptr; } _ZN9OpenBabel6OBBond6SetIdxEi: 110| 71.8M| void SetIdx(int idx) { _idx = idx; } _ZNK9OpenBabel6OBBond6GetIdxEv: 155| 207M| unsigned int GetIdx() const { return(_idx); } _ZN9OpenBabel6OBBond11SetAromaticEb: 128| 43.2M| void SetAromatic(bool value=true) { SET_OR_UNSET_FLAG(OB_AROMATIC_BOND); } ------------------ | | 54| 43.2M| if (value) SetFlag(X); \ | | ------------------ | | | Branch (54:7): [True: 67.1k, False: 43.1M] | | ------------------ | | 55| 43.2M| else UnsetFlag(X); ------------------ _ZN9OpenBabel6OBBond7SetFlagEi: 77| 74.5M| void SetFlag(int flag) { _flags |= flag; } _ZN9OpenBabel6OBBond9UnsetFlagEi: 81| 129M| void UnsetFlag(int flag) { _flags &= (~(flag)); } _ZNK9OpenBabel6OBBond7HasFlagEi: 73| 469M| bool HasFlag(int flag) const { return ((_flags & flag) != 0); } _ZN9OpenBabel6OBBond8SetBeginEPNS_6OBAtomE: 115| 71.8M| void SetBegin(OBAtom *begin){ _bgn = begin; } _ZN9OpenBabel6OBBond6SetEndEPNS_6OBAtomE: 117| 71.8M| void SetEnd(OBAtom *end) { _end = end; } _ZN9OpenBabel6OBBond9SetInRingEb: 144| 45.9M| void SetInRing(bool value=true) { SET_OR_UNSET_FLAG(OB_RING_BOND); } ------------------ | | 54| 45.9M| if (value) SetFlag(X); \ | | ------------------ | | | Branch (54:7): [True: 2.54M, False: 43.3M] | | ------------------ | | 55| 45.9M| else UnsetFlag(X); ------------------ _ZN9OpenBabel6OBBond10SetClosureEb: 149| 43.4M| void SetClosure(bool value=true) { SET_OR_UNSET_FLAG(OB_CLOSURE_BOND); } ------------------ | | 54| 43.4M| if (value) SetFlag(X); \ | | ------------------ | | | Branch (54:7): [True: 92.6k, False: 43.3M] | | ------------------ | | 55| 43.4M| else UnsetFlag(X); ------------------ _ZN9OpenBabel6OBBond9GetParentEv: 183| 469M| OBMol *GetParent() {return(_parent);} _ZN9OpenBabel13OBChargeModel6TypeIDEv: 37| 8| const char* TypeID() override { return "charges"; } _ZN9OpenBabel16OBGlobalDataBaseC2Ev: 60| 9| OBGlobalDataBase(): _init(false), _dataptr(nullptr) { } _ZN9OpenBabel16OBGlobalDataBaseD2Ev: 62| 1| virtual ~OBGlobalDataBase() {} _ZN9OpenBabel12OBDescriptor6TypeIDEv: 39| 36| const char* TypeID() override { return "descriptors"; } _ZN9OpenBabel13OBFingerprint6TypeIDEv: 46| 18| { 47| 18| return "fingerprints"; 48| 18| } _ZN9OpenBabel12OBForceField6TypeIDEv: 588| 10| { 589| 10| return "forcefields"; 590| 10| } _ZN9OpenBabel8OBFormatC2Ev: 52| 234| OBFormat(){} _ZN9OpenBabel8OBFormat6TypeIDEv: 54| 322| const char* TypeID() override { return "formats"; } _ZN9OpenBabel8OBFormat5FlagsEv: 119| 18.4k| virtual unsigned int Flags() { return 0;}; _ZN9OpenBabel8OBFormat14FormatsMIMEMapEv: 153| 94| { 154| 94| static PluginMapType m; 155| 94| return m; 156| 94| } _ZN9OpenBabel10OBRingData7GetDataEv: 281| 4.91k| { 282| 4.91k| return(_vr); 283| 4.91k| } _ZN9OpenBabel14OBExternalBondD2Ev: 78| 699| ~OBExternalBond() {} _ZN9OpenBabel10OBRingData7SetDataERNSt3__16vectorIPNS_6OBRingENS1_9allocatorIS4_EEEE: 273| 3.55k| { 274| 3.55k| _vr = vr; 275| 3.55k| } _ZN9OpenBabel14OBPairTemplateIiEC2Ev: 136| 9.35M| OBGenericData("PairData", OBGenericDataType::PairData) {}; _ZN9OpenBabel14OBPairTemplateIiE8SetValueEi: 139| 9.35M| void SetValue(const ValueT t) { _value = t; } _ZN9OpenBabel14OBGroupContribC2EPKcS2_S2_: 55| 6| : OBDescriptor(ID, false), _filename(filename), _descr(descr), _debug(false){} _ZN9OpenBabel19LineEndingExtractorclERNSt3__113basic_istreamIcNS1_11char_traitsIcEEEE: 173| 91.5M| { 174| 91.5M| int ch( src.get() ) ; 175| 91.5M| switch (ch) 176| 91.5M| { 177| 692| case 13: //CR or CRLF ------------------ | Branch (177:7): [True: 692, False: 91.5M] ------------------ 178| 692| if(src.peek() == 10) ------------------ | Branch (178:12): [True: 198, False: 494] ------------------ 179| 198| src.get(); //CRLF 180| | //fall through 181| 1.06k| case 10: //LF ------------------ | Branch (181:7): [True: 376, False: 91.5M] ------------------ 182| 1.06k| return '\n'; 183| 0| break; 184| 91.5M| default: ------------------ | Branch (184:7): [True: 91.5M, False: 1.06k] ------------------ 185| 91.5M| return ch; 186| 91.5M| } 187| 91.5M| } _ZN9OpenBabel20FilteringInputStreamINS_19LineEndingExtractorEEC1ERNSt3__113basic_istreamIcNS3_11char_traitsIcEEEE: 204| 9.18k| FilteringInputStreambuf(&istream),std::istream(this) {} _ZN9OpenBabel23FilteringInputStreambufINS_19LineEndingExtractorEEC2EPNSt3__113basic_istreamIcNS3_11char_traitsIcEEEE: 122| 9.18k| { 123| 9.18k| setg( &myBuffer , &myBuffer , &myBuffer ) ; 124| 9.18k| } _ZN9OpenBabel20FilteringInputStreamINS_19LineEndingExtractorEED2Ev: 205| 9.18k| virtual ~FilteringInputStream() {} _ZN9OpenBabel23FilteringInputStreambufINS_19LineEndingExtractorEE9underflowEv: 130| 91.5M| { 131| 91.5M| int result( EOF ) ; 132| 91.5M| if( gptr() < egptr() ) ------------------ | Branch (132:9): [True: 0, False: 91.5M] ------------------ 133| 0| result = *gptr() ; 134| 91.5M| else if ( mySource != nullptr ) ------------------ | Branch (134:15): [True: 91.5M, False: 0] ------------------ 135| 91.5M| { 136| 91.5M| result = myExtractor( *mySource ) ; 137| 91.5M| if ( result != EOF ) ------------------ | Branch (137:12): [True: 91.5M, False: 9.13k] ------------------ 138| 91.5M| { 139| 91.5M| if( result < 0 || result > UCHAR_MAX ) ------------------ | Branch (139:13): [True: 0, False: 91.5M] | Branch (139:27): [True: 0, False: 91.5M] ------------------ 140| 0| std::cerr << "FilteringInputStreambuf error" << std::endl; 141| 91.5M| myBuffer = result ; 142| 91.5M| setg( &myBuffer , &myBuffer , &myBuffer + 1 ) ; 143| 91.5M| } 144| 91.5M| } 145| 91.5M| return result ; 146| 91.5M| } _ZN9OpenBabel7vector3C2Eddd: 53| 71.8M| {} _ZN9OpenBabel7vector3D2Ev: 63| 71.8M| ~vector3() { } _ZN9OpenBabel7vector33GetEPd: 133| 67.1M| { 134| 67.1M| c[0]=_vx; 135| 67.1M| c[1]=_vy; 136| 67.1M| c[2]=_vz; 137| 67.1M| } _ZNK9OpenBabel5OBMol8NumAtomsEv: 262| 982M| unsigned int NumAtoms() const { return(_natoms); } _ZNK9OpenBabel5OBMol8NumBondsEv: 264| 7.01M| unsigned int NumBonds() const { return(_nbonds); } _ZN9OpenBabel5OBMol12SetDimensionEt: 352| 9.18k| void SetDimension(unsigned short int d) { _dimension = d; } _ZN9OpenBabel5OBMol24SetAutomaticFormalChargeEb: 366| 6.37k| { _autoFormalCharge=val; } _ZN9OpenBabel5OBMol20SetAromaticPerceivedEb: 372| 20.6k| void SetAromaticPerceived(bool value = true) { SET_OR_UNSET_FLAG(OB_AROMATIC_MOL); } ------------------ | | 113| 20.6k| if (value) SetFlag(X); \ | | ------------------ | | | Branch (113:7): [True: 14.1k, False: 6.52k] | | ------------------ | | 114| 20.6k| else UnsetFlag(X); ------------------ _ZN9OpenBabel5OBMol16SetSSSRPerceivedEb: 374| 4.91k| void SetSSSRPerceived(bool value = true) { SET_OR_UNSET_FLAG(OB_SSSR_MOL); } ------------------ | | 113| 4.91k| if (value) SetFlag(X); \ | | ------------------ | | | Branch (113:7): [True: 4.91k, False: 0] | | ------------------ | | 114| 4.91k| else UnsetFlag(X); ------------------ _ZN9OpenBabel5OBMol29SetRingAtomsAndBondsPerceivedEb: 378| 5.24k| void SetRingAtomsAndBondsPerceived(bool value = true) { SET_OR_UNSET_FLAG(OB_RINGFLAGS_MOL); } ------------------ | | 113| 5.24k| if (value) SetFlag(X); \ | | ------------------ | | | Branch (113:7): [True: 5.24k, False: 0] | | ------------------ | | 114| 5.24k| else UnsetFlag(X); ------------------ _ZN9OpenBabel5OBMol21SetChiralityPerceivedEb: 386| 9.18k| void SetChiralityPerceived(bool value = true) { SET_OR_UNSET_FLAG(OB_CHIRALITY_MOL); } ------------------ | | 113| 9.18k| if (value) SetFlag(X); \ | | ------------------ | | | Branch (113:7): [True: 9.18k, False: 0] | | ------------------ | | 114| 9.18k| else UnsetFlag(X); ------------------ _ZN9OpenBabel5OBMol24SetClosureBondsPerceivedEb: 392| 5.24k| void SetClosureBondsPerceived(bool value = true) { SET_OR_UNSET_FLAG(OB_CLOSURE_MOL); } ------------------ | | 113| 5.24k| if (value) SetFlag(X); \ | | ------------------ | | | Branch (113:7): [True: 5.24k, False: 0] | | ------------------ | | 114| 5.24k| else UnsetFlag(X); ------------------ _ZN9OpenBabel5OBMol13SetIsReactionEb: 400| 622| void SetIsReaction(bool value = true) { SET_OR_UNSET_FLAG(OB_REACTION_MOL); } ------------------ | | 113| 622| if (value) SetFlag(X); \ | | ------------------ | | | Branch (113:7): [True: 622, False: 0] | | ------------------ | | 114| 622| else UnsetFlag(X); ------------------ _ZN9OpenBabel5OBMol7HasFlagEi: 404| 670M| bool HasFlag(int flag) { return (_flags & flag) ? true : false; } ------------------ | Branch (404:41): [True: 670M, False: 42.2k] ------------------ _ZN9OpenBabel5OBMol7SetFlagEi: 405| 39.3k| void SetFlag(int flag) { _flags |= flag; } _ZN9OpenBabel5OBMol9UnsetFlagEi: 406| 6.52k| void UnsetFlag(int flag) { _flags &= (~(flag)); } _ZN9OpenBabel5OBMol20HasAromaticPerceivedEv: 570| 448M| bool HasAromaticPerceived() { return(HasFlag(OB_AROMATIC_MOL)); } ------------------ | | 77| 448M|#define OB_AROMATIC_MOL (1<<3) ------------------ _ZN9OpenBabel5OBMol16HasSSSRPerceivedEv: 572| 9.83k| bool HasSSSRPerceived() { return(HasFlag(OB_SSSR_MOL)); } ------------------ | | 73| 9.83k|#define OB_SSSR_MOL (1<<1) ------------------ _ZN9OpenBabel5OBMol29HasRingAtomsAndBondsPerceivedEv: 576| 98.5M| bool HasRingAtomsAndBondsPerceived(){return(HasFlag(OB_RINGFLAGS_MOL));} ------------------ | | 75| 98.5M|#define OB_RINGFLAGS_MOL (1<<2) ------------------ _ZN9OpenBabel5OBMol24HasClosureBondsPerceivedEv: 588| 123M| bool HasClosureBondsPerceived() { return(HasFlag(OB_CLOSURE_MOL)); } ------------------ | | 87| 123M|#define OB_CLOSURE_MOL (1<<11) ------------------ _ZN9OpenBabel5OBMol10IsReactionEv: 598| 13.0k| bool IsReaction() { return HasFlag(OB_REACTION_MOL); } ------------------ | | 107| 13.0k|#define OB_REACTION_MOL (1<<22) ------------------ _ZN9OpenBabel5OBMol5EmptyEv: 603| 18.1k| bool Empty() { return(_natoms == 0); } _ZN9OpenBabel5OBMol12BeginResidueERNSt3__111__wrap_iterIPPNS_9OBResidueEEE: 685| 9.18k| { 686| 9.18k| i = _residue.begin(); 687| 9.18k| return((i == _residue.end()) ? nullptr:*i); ------------------ | Branch (687:14): [True: 9.18k, False: 0] ------------------ 688| 9.18k| } _ZNK9OpenBabel12OBConversion11GetInStreamEv: 107| 9.18k| std::istream* GetInStream() const {return pInput;}; _ZN9OpenBabellsERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEERKNS_7OBErrorE: 69| 113k| { return os << er.message(); }; _ZNK9OpenBabel7OBError8GetLevelEv: 83| 246k| obMessageLevel GetLevel() const { return _level; } _ZN9OpenBabel16OBMessageHandler14GetOutputLevelEv: 142| 19.6k| obMessageLevel GetOutputLevel() { return _outputLevel; } _ZNK9OpenBabel13OBMolAtomItercvbEv: 55| 252M| operator bool() const { return _ptr != nullptr; } _ZNK9OpenBabel13OBMolAtomIterptEv: 61| 367M| OBAtom* operator->() const { return _ptr; } _ZNK9OpenBabel13OBMolAtomIterdeEv: 63| 208M| OBAtom& operator*() const { return *_ptr; } _ZN9OpenBabel13OBMolAtomIterD2Ev: 51| 30.3k| ~OBMolAtomIter() { } _ZNK9OpenBabel14OBAtomBondItercvbEv: 230| 553M| operator bool() const { return _ptr != nullptr; } _ZNK9OpenBabel14OBAtomBondIterptEv: 236| 683M| OBBond* operator->() const { return _ptr; } _ZN9OpenBabel14OBAtomBondIterD2Ev: 226| 164M| ~OBAtomBondIter() { } _ZNK9OpenBabel13OBMolBondItercvbEv: 178| 152M| operator bool() const { return _ptr != nullptr; } _ZNK9OpenBabel13OBMolBondIterptEv: 184| 185M| OBBond* operator->() const { return _ptr; } _ZN9OpenBabel13OBMolBondIterD2Ev: 174| 18.2k| ~OBMolBondIter() { } _ZNK9OpenBabel14OBAtomBondIterdeEv: 238| 56.2M| OBBond& operator*() const { return *_ptr;} _ZN9OpenBabel16OBMolAtomDFSIterD2Ev: 78| 4.39M| ~OBMolAtomDFSIter() { } _ZNK9OpenBabel16OBMolAtomDFSItercvbEv: 82| 3.66k| operator bool() const { return _ptr != nullptr; } _ZN9OpenBabel16OBMolAtomDFSIter4nextEv: 93| 4.39M| { 94| 4.39M| if(_stack.empty()) ------------------ | Branch (94:10): [True: 3.19k, False: 4.39M] ------------------ 95| 3.19k| return nullptr; //end of a disconnected fragment 96| 4.39M| else 97| 4.39M| return _stack.top(); //the next atom 98| 4.39M| } _ZNK9OpenBabel16OBMolAtomDFSIterdeEv: 90| 4.39M| OBAtom& operator*() const { return *_ptr; } _ZNK9OpenBabel13OBMolBondIterdeEv: 186| 54.5M| OBBond& operator*() const { return *_ptr; } _ZN9OpenBabel16OBMoleculeFormatC2Ev: 63| 218| { 64| 218| if(!OptionsRegistered) ------------------ | Branch (64:8): [True: 2, False: 216] ------------------ 65| 2| { 66| 2| OptionsRegistered=true; 67| 2| OBConversion::RegisterOptionParam("b", this, 0, OBConversion::INOPTIONS); 68| 2| OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS); 69| 2| OBConversion::RegisterOptionParam("title", this, 1, OBConversion::GENOPTIONS); 70| 2| OBConversion::RegisterOptionParam("addtotitle",this, 1, OBConversion::GENOPTIONS); 71| 2| OBConversion::RegisterOptionParam("property", this, 2, OBConversion::GENOPTIONS); 72| 2| OBConversion::RegisterOptionParam("C", this, 0, OBConversion::GENOPTIONS); 73| 2| OBConversion::RegisterOptionParam("j", this, 0, OBConversion::GENOPTIONS); 74| 2| OBConversion::RegisterOptionParam("join", this, 0, OBConversion::GENOPTIONS); 75| 2| OBConversion::RegisterOptionParam("separate", this, 0, OBConversion::GENOPTIONS); 76| | 77| | //The follow are OBMol options, which should not be in OBConversion. 78| | //But here isn't entirely appropriate either, since one could have 79| | //OBMol formats loaded but which don't derived from this class. 80| | //However, this possibility is remote. 81| 2| OBConversion::RegisterOptionParam("s", nullptr, 1,OBConversion::GENOPTIONS); 82| 2| OBConversion::RegisterOptionParam("v", nullptr, 1,OBConversion::GENOPTIONS); 83| 2| OBConversion::RegisterOptionParam("h", nullptr, 0,OBConversion::GENOPTIONS); 84| 2| OBConversion::RegisterOptionParam("d", nullptr, 0,OBConversion::GENOPTIONS); 85| 2| OBConversion::RegisterOptionParam("b", nullptr, 0,OBConversion::GENOPTIONS); 86| 2| OBConversion::RegisterOptionParam("c", nullptr, 0,OBConversion::GENOPTIONS); 87| 2| OBConversion::RegisterOptionParam("p", nullptr, 1,OBConversion::GENOPTIONS); 88| 2| OBConversion::RegisterOptionParam("t", nullptr, 0,OBConversion::GENOPTIONS); 89| 2| OBConversion::RegisterOptionParam("k", nullptr, 0,OBConversion::GENOPTIONS); 90| 2| OBConversion::RegisterOptionParam("filter", nullptr, 1,OBConversion::GENOPTIONS); 91| 2| OBConversion::RegisterOptionParam("add", nullptr, 1,OBConversion::GENOPTIONS); 92| 2| OBConversion::RegisterOptionParam("delete", nullptr, 1,OBConversion::GENOPTIONS); 93| 2| OBConversion::RegisterOptionParam("append", nullptr, 1,OBConversion::GENOPTIONS); 94| 2| } 95| 218| } _ZN9OpenBabel4OBOp6TypeIDEv: 41| 36| const char* TypeID() override { return "ops"; } _ZN9OpenBabel15OBSmartsPatternC2Ev: 183| 4| OBSmartsPattern() : _pat(nullptr), _buffer(nullptr), LexPtr(nullptr), MainPtr(nullptr) { } _ZNK9OpenBabel11CharPtrLessclEPKcS2_: 44| 61.0k| { return strcasecmp(p1,p2)<0; } _ZN9OpenBabel8OBPlugin9PluginMapEv: 134| 433| { 135| 433| static PluginMapType m; 136| 433| return m; 137| 433| } _ZN9OpenBabel8OBFormat3MapEv: 197| 9.83k| static PluginMapType& Map() {\ 198| 9.83k| static PluginMapType m;\ 199| 9.83k| return m;\ 200| 9.83k| }\ _ZNK9OpenBabel8OBFormat6GetMapEv: 201| 644| PluginMapType& GetMap() const override {\ 202| 644| return Map();\ 203| 644| }\ _ZN9OpenBabel8OBFormat7DefaultEv: 205| 8| static BaseClass*& Default() {\ 206| 8| static BaseClass* d;\ 207| 8| return d;\ 208| 8| }\ _ZN9OpenBabel8OBFormat8FindTypeEPKc: 221| 9.18k| static BaseClass* FindType(const char* ID) {\ 222| 9.18k| if (!ID || *ID==0 || *ID==' ') {\ ------------------ | Branch (222:9): [True: 0, False: 9.18k] | Branch (222:16): [True: 0, False: 9.18k] | Branch (222:26): [True: 0, False: 9.18k] ------------------ 223| 0| return Default();\ 224| 0| }\ 225| 9.18k| return static_cast(BaseFindType(Map(),ID));\ 226| 9.18k| } _ZN9OpenBabel4OBOp7DefaultEv: 205| 2| static BaseClass*& Default() {\ 206| 2| static BaseClass* d;\ 207| 2| return d;\ 208| 2| }\ _ZN9OpenBabel4OBOp3MapEv: 197| 108| static PluginMapType& Map() {\ 198| 108| static PluginMapType m;\ 199| 108| return m;\ 200| 108| }\ _ZN9OpenBabel12OBDescriptor3MapEv: 197| 108| static PluginMapType& Map() {\ 198| 108| static PluginMapType m;\ 199| 108| return m;\ 200| 108| }\ _ZN9OpenBabel12OBDescriptor7DefaultEv: 205| 2| static BaseClass*& Default() {\ 206| 2| static BaseClass* d;\ 207| 2| return d;\ 208| 2| }\ _ZN9OpenBabel12OBDescriptorC2EPKcb: 209| 36| BaseClass(const char* ID, bool IsDefault=false) {\ 210| 36| _id=ID;\ 211| 36| if (ID&&*ID) {\ ------------------ | Branch (211:9): [True: 36, False: 0] | Branch (211:13): [True: 36, False: 0] ------------------ 212| 36| if (IsDefault || Map().empty()) {\ ------------------ | Branch (212:11): [True: 0, False: 36] | Branch (212:24): [True: 2, False: 34] ------------------ 213| 2| Default() = this;\ 214| 2| }\ 215| 36| if (Map().count(ID) == 0) {\ ------------------ | Branch (215:11): [True: 36, False: 0] ------------------ 216| 36| Map()[ID] = this;\ 217| 36| PluginMap()[TypeID()] = this;\ 218| 36| }\ 219| 36| }\ 220| 36| }\ _ZN9OpenBabel4OBOpC2EPKcb: 209| 36| BaseClass(const char* ID, bool IsDefault=false) {\ 210| 36| _id=ID;\ 211| 36| if (ID&&*ID) {\ ------------------ | Branch (211:9): [True: 36, False: 0] | Branch (211:13): [True: 36, False: 0] ------------------ 212| 36| if (IsDefault || Map().empty()) {\ ------------------ | Branch (212:11): [True: 0, False: 36] | Branch (212:24): [True: 2, False: 34] ------------------ 213| 2| Default() = this;\ 214| 2| }\ 215| 36| if (Map().count(ID) == 0) {\ ------------------ | Branch (215:11): [True: 36, False: 0] ------------------ 216| 36| Map()[ID] = this;\ 217| 36| PluginMap()[TypeID()] = this;\ 218| 36| }\ 219| 36| }\ 220| 36| }\ _ZN9OpenBabel13OBFingerprint3MapEv: 197| 52| static PluginMapType& Map() {\ 198| 52| static PluginMapType m;\ 199| 52| return m;\ 200| 52| }\ _ZN9OpenBabel13OBFingerprint7DefaultEv: 205| 2| static BaseClass*& Default() {\ 206| 2| static BaseClass* d;\ 207| 2| return d;\ 208| 2| }\ _ZN9OpenBabel13OBFingerprintC2EPKcb: 209| 18| BaseClass(const char* ID, bool IsDefault=false) {\ 210| 18| _id=ID;\ 211| 18| if (ID&&*ID) {\ ------------------ | Branch (211:9): [True: 18, False: 0] | Branch (211:13): [True: 18, False: 0] ------------------ 212| 18| if (IsDefault || Map().empty()) {\ ------------------ | Branch (212:11): [True: 2, False: 16] | Branch (212:24): [True: 0, False: 16] ------------------ 213| 2| Default() = this;\ 214| 2| }\ 215| 18| if (Map().count(ID) == 0) {\ ------------------ | Branch (215:11): [True: 18, False: 0] ------------------ 216| 18| Map()[ID] = this;\ 217| 18| PluginMap()[TypeID()] = this;\ 218| 18| }\ 219| 18| }\ 220| 18| }\ _ZN9OpenBabel12OBForceField7DefaultEv: 205| 6| static BaseClass*& Default() {\ 206| 6| static BaseClass* d;\ 207| 6| return d;\ 208| 6| }\ _ZN9OpenBabel12OBForceField3MapEv: 197| 24| static PluginMapType& Map() {\ 198| 24| static PluginMapType m;\ 199| 24| return m;\ 200| 24| }\ _ZN9OpenBabel12OBForceFieldC2EPKcb: 209| 10| BaseClass(const char* ID, bool IsDefault=false) {\ 210| 10| _id=ID;\ 211| 10| if (ID&&*ID) {\ ------------------ | Branch (211:9): [True: 10, False: 0] | Branch (211:13): [True: 10, False: 0] ------------------ 212| 10| if (IsDefault || Map().empty()) {\ ------------------ | Branch (212:11): [True: 6, False: 4] | Branch (212:24): [True: 0, False: 4] ------------------ 213| 6| Default() = this;\ 214| 6| }\ 215| 10| if (Map().count(ID) == 0) {\ ------------------ | Branch (215:11): [True: 10, False: 0] ------------------ 216| 10| Map()[ID] = this;\ 217| 10| PluginMap()[TypeID()] = this;\ 218| 10| }\ 219| 10| }\ 220| 10| }\ _ZN9OpenBabel13OBChargeModel7DefaultEv: 205| 2| static BaseClass*& Default() {\ 206| 2| static BaseClass* d;\ 207| 2| return d;\ 208| 2| }\ _ZN9OpenBabel13OBChargeModel3MapEv: 197| 24| static PluginMapType& Map() {\ 198| 24| static PluginMapType m;\ 199| 24| return m;\ 200| 24| }\ _ZN9OpenBabel13OBChargeModelC2EPKcb: 209| 8| BaseClass(const char* ID, bool IsDefault=false) {\ 210| 8| _id=ID;\ 211| 8| if (ID&&*ID) {\ ------------------ | Branch (211:9): [True: 8, False: 0] | Branch (211:13): [True: 8, False: 0] ------------------ 212| 8| if (IsDefault || Map().empty()) {\ ------------------ | Branch (212:11): [True: 0, False: 8] | Branch (212:24): [True: 2, False: 6] ------------------ 213| 2| Default() = this;\ 214| 2| }\ 215| 8| if (Map().count(ID) == 0) {\ ------------------ | Branch (215:11): [True: 8, False: 0] ------------------ 216| 8| Map()[ID] = this;\ 217| 8| PluginMap()[TypeID()] = this;\ 218| 8| }\ 219| 8| }\ 220| 8| }\ _ZNK9OpenBabel6OBRing4SizeEv: 62| 11.3M| size_t Size() const { return(_path.size()); } _ZN9OpenBabel6OBRingC2ERNSt3__16vectorIiNS1_9allocatorIiEEEENS_8OBBitVecE: 54| 352k| OBRing(std::vector& path, OBBitVec set) : _path(path), _pathset(set) {} _ZN9OpenBabel6OBRing8IsInRingEi: 91| 330M| { 92| 330M| return(_pathset.BitIsSet(i)); 93| 330M| } _ZN9OpenBabel6OBRing9SetParentEPNS_5OBMolE: 96| 59.4M| void SetParent(OBMol *m) { _parent = m; } _ZN9OpenBabel12OBRingSearchC2Ev: 124| 3.55k| OBRingSearch() {} _ZN9OpenBabel12OBRingSearch9SortRingsEv: 129| 3.55k| { 130| 3.55k| std::vector::iterator j; 131| 3.55k| int ring_id; // for each ring, assign a unique id to ensure a stable sort 132| | 133| 356k| for (j = _rlist.begin(), ring_id = 0; j != _rlist.end(); ++j, ++ring_id) ------------------ | Branch (133:45): [True: 352k, False: 3.55k] ------------------ 134| 352k| (*j)->ring_id = ring_id; 135| 3.55k| std::sort(_rlist.begin(),_rlist.end(),CompareRingSize); 136| 3.55k| } _ZN9OpenBabel12OBRingSearch10BeginRingsEv: 151| 3.55k| { 152| 3.55k| return(_rlist.begin()); 153| 3.55k| } _ZN9OpenBabel12OBRingSearch8EndRingsEv: 156| 94.7k| { 157| 94.7k| return(_rlist.end()); 158| 94.7k| } _ZN9OpenBabel7OBRTreeD2Ev: 173| 16.6M| ~OBRTree() {} _ZN9OpenBabel16OBCisTransStereo6ConfigC2Ev: 107| 554k| { } _ZN9OpenBabel20OBSquarePlanarStereo6ConfigC2Ev: 79| 51.1k| { } _ZN9OpenBabel8OBStereo8MakeRefsEmmmm: 176| 277k| { 177| 277k| Refs refs(3); 178| 277k| refs[0] = ref1; 179| 277k| refs[1] = ref2; 180| 277k| refs[2] = ref3; 181| 277k| if (ref4 != NoRef) ------------------ | Branch (181:11): [True: 277k, False: 0] ------------------ 182| 277k| refs.push_back(ref4); 183| 277k| return refs; 184| 277k| } _ZN9OpenBabel12OBStereoBaseC2EPNS_5OBMolE: 333| 347k| { 334| 347k| } _ZN9OpenBabel12OBStereoBaseD2Ev: 338| 347k| virtual ~OBStereoBase() { m_mol = nullptr; } _ZN9OpenBabel19OBTetrahedralStereo6ConfigC2Ev: 94| 111k| { } _ZN9OpenBabel19OBTetraPlanarStereo8ToConfigINS_20OBSquarePlanarStereo6ConfigEEET_RKS4_mNS_8OBStereo5ShapeE: 92| 23.9k| { 93| 23.9k| ConfigType result = cfg; 94| 23.9k| result.shape = shape; 95| | 96| | // convert from U/Z/4 to U shape 97| 23.9k| switch (cfg.shape) { ------------------ | Branch (97:17): [True: 0, False: 23.9k] ------------------ 98| 3.38k| case OBStereo::ShapeU: ------------------ | Branch (98:11): [True: 3.38k, False: 20.5k] ------------------ 99| 3.38k| break; 100| 4.70k| case OBStereo::ShapeZ: ------------------ | Branch (100:11): [True: 4.70k, False: 19.2k] ------------------ 101| 4.70k| OBStereo::Permutate(result.refs, 2, 3); // convert to U shape 102| 4.70k| break; 103| 15.8k| case OBStereo::Shape4: ------------------ | Branch (103:11): [True: 15.8k, False: 8.08k] ------------------ 104| 15.8k| OBStereo::Permutate(result.refs, 1, 2); // convert to U shape 105| 15.8k| break; 106| 23.9k| } 107| | 108| | 109| | // since refs are U shaped we can rotate the refs lexicographically 110| 94.9k| for (int i = 0; i < 4; ++i) { ------------------ | Branch (110:25): [True: 94.9k, False: 0] ------------------ 111| 94.9k| std::rotate(result.refs.begin(), result.refs.begin() + 1, result.refs.end()); 112| | // start at refs[0]? 113| 94.9k| if (result.refs.at(0) == start) ------------------ | Branch (113:15): [True: 23.9k, False: 70.9k] ------------------ 114| 23.9k| break; 115| 94.9k| } 116| | 117| | // convert from U to desired U/Z/4 118| | // (don't change refs[0]!) 119| 23.9k| switch (shape) { ------------------ | Branch (119:17): [True: 0, False: 23.9k] ------------------ 120| 23.9k| case OBStereo::ShapeU: ------------------ | Branch (120:11): [True: 23.9k, False: 0] ------------------ 121| 23.9k| break; 122| 0| case OBStereo::ShapeZ: ------------------ | Branch (122:11): [True: 0, False: 23.9k] ------------------ 123| 0| OBStereo::Permutate(result.refs, 2, 3); // convert to Z shape 124| 0| break; 125| 0| case OBStereo::Shape4: ------------------ | Branch (125:11): [True: 0, False: 23.9k] ------------------ 126| 0| OBStereo::Permutate(result.refs, 1, 2); // convert to 4 shape 127| 0| break; 128| 23.9k| } 129| | 130| 23.9k| return result; 131| 23.9k| } _ZN9OpenBabel19OBTetraPlanarStereo8ToConfigINS_16OBCisTransStereo6ConfigEEET_RKS4_mNS_8OBStereo5ShapeE: 92| 277k| { 93| 277k| ConfigType result = cfg; 94| 277k| result.shape = shape; 95| | 96| | // convert from U/Z/4 to U shape 97| 277k| switch (cfg.shape) { ------------------ | Branch (97:17): [True: 0, False: 277k] ------------------ 98| 277k| case OBStereo::ShapeU: ------------------ | Branch (98:11): [True: 277k, False: 0] ------------------ 99| 277k| break; 100| 0| case OBStereo::ShapeZ: ------------------ | Branch (100:11): [True: 0, False: 277k] ------------------ 101| 0| OBStereo::Permutate(result.refs, 2, 3); // convert to U shape 102| 0| break; 103| 0| case OBStereo::Shape4: ------------------ | Branch (103:11): [True: 0, False: 277k] ------------------ 104| 0| OBStereo::Permutate(result.refs, 1, 2); // convert to U shape 105| 0| break; 106| 277k| } 107| | 108| | 109| | // since refs are U shaped we can rotate the refs lexicographically 110| 1.10M| for (int i = 0; i < 4; ++i) { ------------------ | Branch (110:25): [True: 1.10M, False: 0] ------------------ 111| 1.10M| std::rotate(result.refs.begin(), result.refs.begin() + 1, result.refs.end()); 112| | // start at refs[0]? 113| 1.10M| if (result.refs.at(0) == start) ------------------ | Branch (113:15): [True: 277k, False: 829k] ------------------ 114| 277k| break; 115| 1.10M| } 116| | 117| | // convert from U to desired U/Z/4 118| | // (don't change refs[0]!) 119| 277k| switch (shape) { ------------------ | Branch (119:17): [True: 0, False: 277k] ------------------ 120| 277k| case OBStereo::ShapeU: ------------------ | Branch (120:11): [True: 277k, False: 0] ------------------ 121| 277k| break; 122| 0| case OBStereo::ShapeZ: ------------------ | Branch (122:11): [True: 0, False: 277k] ------------------ 123| 0| OBStereo::Permutate(result.refs, 2, 3); // convert to Z shape 124| 0| break; 125| 0| case OBStereo::Shape4: ------------------ | Branch (125:11): [True: 0, False: 277k] ------------------ 126| 0| OBStereo::Permutate(result.refs, 1, 2); // convert to 4 shape 127| 0| break; 128| 277k| } 129| | 130| 277k| return result; 131| 277k| } _ZN9OpenBabel15OBAromaticTyperC2Ev: 76| 1| OBAromaticTyper() {}; _ZN9OpenBabel15OBAromaticTyperD2Ev: 77| 1| ~OBAromaticTyper() {}; _ZN9OpenBabel10OpGenAliasC2EPKc: 391| 2| OpGenAlias(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel6OBAtomC2Ev: 117| 71.8M| { 118| 71.8M| _parent = nullptr; 119| 71.8M| Clear(); 120| 71.8M| } _ZN9OpenBabel6OBAtomD2Ev: 123| 71.8M| { 124| 71.8M| if (_residue != nullptr) ------------------ | Branch (124:9): [True: 0, False: 71.8M] ------------------ 125| 0| { 126| 0| _residue->RemoveAtom(this); 127| 0| } 128| | /* 129| | if (!_vdata.empty()) 130| | { 131| | vector::iterator m; 132| | for (m = _vdata.begin();m != _vdata.end();++m) 133| | delete *m; 134| | _vdata.clear(); 135| | } 136| | */ 137| 71.8M| } _ZN9OpenBabel6OBAtom5ClearEv: 140| 71.8M| { 141| 71.8M| _c = nullptr; 142| 71.8M| _cidx = 0; 143| 71.8M| _flags=0; 144| 71.8M| _idx = 0; 145| 71.8M| _hyb = 0; 146| 71.8M| _ele = (char)0; 147| 71.8M| _isotope = 0; 148| 71.8M| _spinmultiplicity=0; // CM 18 Sept 2003 149| 71.8M| _imph = 0; 150| 71.8M| _fcharge = 0; 151| 71.8M| _type[0] = '\0'; 152| 71.8M| _pcharge = 0.0; 153| 71.8M| _vbond.clear(); 154| 71.8M| _vbond.reserve(4); 155| 71.8M| _residue = nullptr; 156| 71.8M| _id = NoId; 157| | 158| 71.8M| return(OBBase::Clear()); 159| 71.8M| } _ZN9OpenBabel6OBAtom11IsConnectedEPS0_: 202| 33.0M| { 203| 33.0M| OBBondIterator i; 204| 33.0M| OBBond *bond; 205| | 206| 187M| for (bond = BeginBond(i);bond;bond = NextBond(i)) ------------------ | Branch (206:30): [True: 157M, False: 29.7M] ------------------ 207| 157M| if (bond->GetBeginAtom() == a1 || bond->GetEndAtom() == a1) ------------------ | Branch (207:11): [True: 1.93M, False: 155M] | Branch (207:41): [True: 1.27M, False: 154M] ------------------ 208| 3.21M| return(true); 209| | 210| 29.7M| return(false); 211| 33.0M| } _ZN9OpenBabel6OBAtom9GetVectorEv: 377| 67.1M| { 378| 67.1M| if (!_c) ------------------ | Branch (378:9): [True: 67.1M, False: 0] ------------------ 379| 67.1M| return(_v); 380| | 381| 0| _v.Set((*_c)[_cidx],(*_c)[_cidx+1],(*_c)[_cidx+2]); 382| 0| return(_v); 383| 67.1M| } _ZN9OpenBabel6OBAtom10SetIsotopeEj: 442| 163k| { 443| 163k| _isotope = iso; 444| 163k| } _ZNK9OpenBabel6OBAtom10IsAromaticEv: 775| 134M| { 776| 134M| OBMol *mol = ((OBAtom*)this)->GetParent(); 777| 134M| if (!mol->HasAromaticPerceived()) ------------------ | Branch (777:9): [True: 0, False: 134M] ------------------ 778| 0| aromtyper.AssignAromaticFlags(*mol); 779| | 780| 134M| if (((OBAtom*)this)->HasFlag(OB_AROMATIC_ATOM)) ------------------ | | 56| 134M|#define OB_AROMATIC_ATOM (1<<3) ------------------ | Branch (780:9): [True: 82.0M, False: 52.5M] ------------------ 781| 82.0M| return true; 782| | 783| 52.5M| return false; 784| 134M| } _ZNK9OpenBabel6OBAtom8IsInRingEv: 787| 65.5M| { 788| 65.5M| OBMol *mol = ((OBAtom*)this)->GetParent(); 789| 65.5M| if (!mol->HasRingAtomsAndBondsPerceived()) ------------------ | Branch (789:9): [True: 117, False: 65.5M] ------------------ 790| 117| mol->FindRingAtomsAndBonds(); 791| | 792| 65.5M| if (((OBAtom*)this)->HasFlag(OB_RING_ATOM)) ------------------ | | 58| 65.5M|#define OB_RING_ATOM (1<<4) ------------------ | Branch (792:9): [True: 3.16M, False: 62.4M] ------------------ 793| 3.16M| return true; 794| | 795| 62.4M| return false; 796| 65.5M| } _ZNK9OpenBabel6OBAtom18GetExplicitValenceEv: 979| 2.47M| { 980| 2.47M| unsigned int bosum = 0; 981| | 982| 2.47M| OBBondIterator i; 983| 7.76M| for (OBBond *bond = ((OBAtom*)this)->BeginBond(i); bond; bond = ((OBAtom*)this)->NextBond(i)) ------------------ | Branch (983:56): [True: 5.28M, False: 2.47M] ------------------ 984| 5.28M| bosum += bond->GetBondOrder(); 985| | 986| 2.47M| return bosum; 987| 2.47M| } _ZNK9OpenBabel6OBAtom15GetTotalValenceEv: 990| 1.14k| { 991| 1.14k| return GetExplicitValence() + _imph; 992| 1.14k| } _ZN9OpenBabel6OBAtom9BeginBondERNSt3__111__wrap_iterIPPNS_6OBBondEEE: 1083| 243M| { 1084| 243M| i = _vbond.begin(); 1085| 243M| return i == _vbond.end() ? nullptr : (OBBond*)*i; ------------------ | Branch (1085:12): [True: 40.7k, False: 243M] ------------------ 1086| 243M| } _ZN9OpenBabel6OBAtom8NextBondERNSt3__111__wrap_iterIPPNS_6OBBondEEE: 1089| 635M| { 1090| 635M| i++; 1091| 635M| return i == _vbond.end() ? nullptr : (OBBond*)*i; ------------------ | Branch (1091:12): [True: 232M, False: 402M] ------------------ 1092| 635M| } _ZN9OpenBabel6OBAtom12BeginNbrAtomERNSt3__111__wrap_iterIPPNS_6OBBondEEE: 1095| 98.0M| { 1096| 98.0M| i = _vbond.begin(); 1097| 98.0M| return i != _vbond.end() ? ((OBBond*) *i)->GetNbrAtom(this) : nullptr; ------------------ | Branch (1097:12): [True: 98.0M, False: 38.8k] ------------------ 1098| 98.0M| } _ZN9OpenBabel6OBAtom11NextNbrAtomERNSt3__111__wrap_iterIPPNS_6OBBondEEE: 1101| 2.78G| { 1102| 2.78G| i++; 1103| 2.78G| return i != _vbond.end() ? ((OBBond*) *i)->GetNbrAtom(this) : nullptr; ------------------ | Branch (1103:12): [True: 2.68G, False: 97.2M] ------------------ 1104| 2.78G| } _ZN9OpenBabel6OBAtom7GetBondEPS0_: 1593| 254| { 1594| 254| OBBond *bond; 1595| 254| vector::iterator i; 1596| 254| for (bond = BeginBond(i) ; bond ; bond = NextBond(i)) ------------------ | Branch (1596:32): [True: 254, False: 0] ------------------ 1597| 254| if (bond->GetNbrAtom(this) == nbr) ------------------ | Branch (1597:11): [True: 254, False: 0] ------------------ 1598| 254| return bond; 1599| 0| return nullptr; 1600| 254| } _ZN9OpenBabel6OBBase5ClearEv: 79| 71.8M| { 80| 71.8M| if (!_vdata.empty()) //clean up generic data ------------------ | Branch (80:9): [True: 94, False: 71.8M] ------------------ 81| 94| { 82| 94| OBDataIterator m; 83| 188| for (m = _vdata.begin();m != _vdata.end();++m) ------------------ | Branch (83:33): [True: 94, False: 94] ------------------ 84| 94| delete *m; 85| 94| _vdata.clear(); 86| 94| } 87| | 88| 71.8M| return(true); 89| 71.8M| } _ZN9OpenBabel6OBBase7HasDataERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 93| 9.83k| { 94| 9.83k| if (_vdata.empty()) ------------------ | Branch (94:9): [True: 5.45k, False: 4.37k] ------------------ 95| 5.45k| return(false); 96| | 97| 4.37k| OBDataIterator i; 98| | 99| 143k| for (i = _vdata.begin();i != _vdata.end();++i) ------------------ | Branch (99:29): [True: 142k, False: 826] ------------------ 100| 142k| if ((*i)->GetAttribute() == s) ------------------ | Branch (100:11): [True: 3.55k, False: 138k] ------------------ 101| 3.55k| return(true); 102| | 103| 826| return(false); 104| 4.37k| } _ZN9OpenBabel6OBBase7HasDataEPKc: 107| 9.83k| { 108| 9.83k| string temp(s); 109| 9.83k| return(HasData(temp)); 110| 9.83k| } _ZN9OpenBabel6OBBase7HasDataEj: 115| 71.8M| { 116| 71.8M| if (_vdata.empty()) ------------------ | Branch (116:9): [True: 71.8M, False: 300] ------------------ 117| 71.8M| return(false); 118| | 119| 300| OBDataIterator i; 120| | 121| 450| for (i = _vdata.begin();i != _vdata.end();++i) ------------------ | Branch (121:29): [True: 300, False: 150] ------------------ 122| 300| if ((*i)->GetDataType() == dt) ------------------ | Branch (122:11): [True: 150, False: 150] ------------------ 123| 150| return(true); 124| | 125| 150| return(false); 126| 300| } _ZN9OpenBabel6OBBase7GetDataEPKc: 142| 4.39M| { 143| 4.39M| OBDataIterator i; 144| | 145| 8.86M| for (i = _vdata.begin(); i != _vdata.end(); ++i) ------------------ | Branch (145:30): [True: 4.46M, False: 4.39M] ------------------ 146| 4.46M| if (strcmp((*i)->GetAttribute().c_str(), s)==0) ------------------ | Branch (146:11): [True: 4.91k, False: 4.46M] ------------------ 147| 4.91k| return *i; 148| | 149| 4.39M| return nullptr; 150| 4.39M| } _ZN9OpenBabel6OBBase7GetDataEj: 153| 150| { 154| 150| OBDataIterator i; 155| 150| for (i = _vdata.begin();i != _vdata.end();++i) ------------------ | Branch (155:29): [True: 150, False: 0] ------------------ 156| 150| if ((*i)->GetDataType() == dt) ------------------ | Branch (156:11): [True: 150, False: 0] ------------------ 157| 150| return(*i); 158| 0| return nullptr; 159| 150| } _ZN9OpenBabel6OBBase10DeleteDataEj: 201| 17.2k| { 202| 17.2k| vector vdata; 203| 17.2k| OBDataIterator i; 204| 17.4k| for (i = _vdata.begin();i != _vdata.end();++i) ------------------ | Branch (204:29): [True: 208, False: 17.2k] ------------------ 205| 208| if ((*i)->GetDataType() == dt) ------------------ | Branch (205:11): [True: 0, False: 208] ------------------ 206| 0| delete *i; 207| 208| else 208| 208| vdata.push_back(*i); 209| 17.2k| _vdata = vdata; 210| 17.2k| } _ZN9OpenBabel8OBBitVec8SetBitOnEj: 87| 143M| { 88| 143M| unsigned word_offset = bit_offset >> WORDROLL; ------------------ | | 38| 143M|#define WORDROLL 5 ------------------ 89| 143M| bit_offset &= WORDMASK; ------------------ | | 40| 143M|#define WORDMASK 31 ------------------ 90| | 91| 143M| if (word_offset >= GetSize()) ------------------ | Branch (91:9): [True: 841k, False: 142M] ------------------ 92| 841k| ResizeWords(word_offset + 1); 93| 143M| _set[word_offset] |= (1<> WORDROLL; ------------------ | | 38| 55.6M|#define WORDROLL 5 ------------------ 102| 55.6M| bit_offset &= WORDMASK; ------------------ | | 40| 55.6M|#define WORDMASK 31 ------------------ 103| | 104| 55.6M| if (word_offset < GetSize()) ------------------ | Branch (104:9): [True: 55.6M, False: 0] ------------------ 105| 55.6M| _set[word_offset] &= (~(1 << bit_offset)); 106| 55.6M| } _ZN9OpenBabel8OBBitVec10SetRangeOnEjj: 114| 462| { 115| 462| if (lo_bit_offset > hi_bit_offset) ------------------ | Branch (115:9): [True: 0, False: 462] ------------------ 116| 0| return; 117| 462| else if (lo_bit_offset == hi_bit_offset) ------------------ | Branch (117:14): [True: 5, False: 457] ------------------ 118| 5| SetBitOn(hi_bit_offset); 119| 457| else 120| 457| { 121| 457| unsigned lo_word_offset = lo_bit_offset >> WORDROLL; ------------------ | | 38| 457|#define WORDROLL 5 ------------------ 122| 457| unsigned hi_word_offset = hi_bit_offset >> WORDROLL; ------------------ | | 38| 457|#define WORDROLL 5 ------------------ 123| 457| lo_bit_offset &= WORDMASK; ------------------ | | 40| 457|#define WORDMASK 31 ------------------ 124| 457| hi_bit_offset &= WORDMASK; ------------------ | | 40| 457|#define WORDMASK 31 ------------------ 125| | 126| 457| if (hi_word_offset >= GetSize()) ------------------ | Branch (126:13): [True: 0, False: 457] ------------------ 127| 0| ResizeWords(hi_word_offset + 1); 128| | 129| 457| if (lo_word_offset == hi_word_offset) ------------------ | Branch (129:13): [True: 132, False: 325] ------------------ 130| 132| { 131| 2.50k| for ( unsigned i = lo_bit_offset ; i <= hi_bit_offset ; i++ ) ------------------ | Branch (131:48): [True: 2.37k, False: 132] ------------------ 132| 2.37k| _set[lo_word_offset] |= (1<> WORDROLL; ------------------ | | 38| 34.8M|#define WORDROLL 5 ------------------ 225| | 226| 34.8M| if (wrdcnt >= GetSize()) ------------------ | Branch (226:9): [True: 43.1k, False: 34.8M] ------------------ 227| 43.1k| return(-1); 228| | 229| 34.8M| if (_set[wrdcnt] != 0) ------------------ | Branch (229:9): [True: 31.8M, False: 3.00M] ------------------ 230| 31.8M| { 231| 31.8M| s = _set[wrdcnt] & bitsoff[last_bit_offset & WORDMASK]; ------------------ | | 40| 31.8M|#define WORDMASK 31 ------------------ 232| 31.8M| if (s) ------------------ | Branch (232:13): [True: 25.2M, False: 6.51M] ------------------ 233| 25.2M| { 234| 25.2M| LowBit(s,bit); ------------------ | | 69| 25.2M| {int m; \ | | 70| 25.2M| if (set != 0) \ | | ------------------ | | | Branch (70:9): [True: 25.2M, False: 0] | | ------------------ | | 71| 25.2M| { \ | | 72| 25.2M| bit = 31; \ | | 73| 25.2M| if (set != 0x80000000) { \ | | ------------------ | | | Branch (73:13): [True: 24.4M, False: 834k] | | ------------------ | | 74| 24.4M| if ((m = (set & 0x0000ffff))!=0) {set = m; bit -= 16;} \ | | ------------------ | | | Branch (74:15): [True: 12.1M, False: 12.3M] | | ------------------ | | 75| 24.4M| if ((m = (set & 0x00ff00ff))!=0) {set = m; bit -= 8;} \ | | ------------------ | | | Branch (75:15): [True: 12.1M, False: 12.2M] | | ------------------ | | 76| 24.4M| if ((m = (set & 0x0f0f0f0f))!=0) {set = m; bit -= 4;} \ | | ------------------ | | | Branch (76:15): [True: 12.1M, False: 12.2M] | | ------------------ | | 77| 24.4M| if ((m = (set & 0x33333333))!=0) {set = m; bit -= 2;} \ | | ------------------ | | | Branch (77:15): [True: 12.3M, False: 12.1M] | | ------------------ | | 78| 24.4M| if ((m = (set & 0x55555555))!=0) {set = m; bit -= 1;}}} \ | | ------------------ | | | Branch (78:15): [True: 12.3M, False: 12.1M] | | ------------------ | | 79| 25.2M| else bit = -1;} ------------------ 235| 25.2M| if (bit != -1) ------------------ | Branch (235:17): [True: 25.2M, False: 0] ------------------ 236| 25.2M| return(bit + (wrdcnt << WORDROLL)); ------------------ | | 38| 25.2M|#define WORDROLL 5 ------------------ 237| 25.2M| } 238| 31.8M| } 239| 9.52M| ++ wrdcnt; 240| | 241| 510M| while(wrdcnt < GetSize()) ------------------ | Branch (241:11): [True: 507M, False: 3.50M] ------------------ 242| 507M| { 243| 507M| if (_set[wrdcnt] != 0) ------------------ | Branch (243:13): [True: 6.02M, False: 501M] ------------------ 244| 6.02M| { 245| 6.02M| s = _set[wrdcnt]; 246| 6.02M| LowBit(s, bit); ------------------ | | 69| 6.02M| {int m; \ | | 70| 6.02M| if (set != 0) \ | | ------------------ | | | Branch (70:9): [True: 6.02M, False: 0] | | ------------------ | | 71| 6.02M| { \ | | 72| 6.02M| bit = 31; \ | | 73| 6.02M| if (set != 0x80000000) { \ | | ------------------ | | | Branch (73:13): [True: 5.89M, False: 128k] | | ------------------ | | 74| 5.89M| if ((m = (set & 0x0000ffff))!=0) {set = m; bit -= 16;} \ | | ------------------ | | | Branch (74:15): [True: 3.70M, False: 2.19M] | | ------------------ | | 75| 5.89M| if ((m = (set & 0x00ff00ff))!=0) {set = m; bit -= 8;} \ | | ------------------ | | | Branch (75:15): [True: 3.56M, False: 2.32M] | | ------------------ | | 76| 5.89M| if ((m = (set & 0x0f0f0f0f))!=0) {set = m; bit -= 4;} \ | | ------------------ | | | Branch (76:15): [True: 3.49M, False: 2.40M] | | ------------------ | | 77| 5.89M| if ((m = (set & 0x33333333))!=0) {set = m; bit -= 2;} \ | | ------------------ | | | Branch (77:15): [True: 3.34M, False: 2.55M] | | ------------------ | | 78| 5.89M| if ((m = (set & 0x55555555))!=0) {set = m; bit -= 1;}}} \ | | ------------------ | | | Branch (78:15): [True: 3.26M, False: 2.63M] | | ------------------ | | 79| 6.02M| else bit = -1;} ------------------ 247| | 248| 6.02M| if (bit != -1) ------------------ | Branch (248:17): [True: 6.02M, False: 0] ------------------ 249| 6.02M| return(bit + (wrdcnt << WORDROLL)); ------------------ | | 38| 6.02M|#define WORDROLL 5 ------------------ 250| 6.02M| } 251| 501M| ++ wrdcnt; 252| 501M| } 253| | 254| 3.50M| return(-1); 255| 9.52M| } _ZNK9OpenBabel8OBBitVec9CountBitsEv: 280| 4.79k| { 281| 4.79k| unsigned count = 0; 282| 1.70M| for (word_vector::const_iterator sx = _set.begin(), sy = _set.end(); sx != sy; ++ sx) ------------------ | Branch (282:74): [True: 1.70M, False: 4.79k] ------------------ 283| 1.70M| { 284| 1.70M| uint32_t word = *sx; 285| 7.93M| while (word) ------------------ | Branch (285:14): [True: 6.23M, False: 1.70M] ------------------ 286| 6.23M| { 287| 6.23M| count += nibble_bit_count[word & 0xF]; 288| 6.23M| word >>= 4; 289| 6.23M| } 290| 1.70M| } 291| 4.79k| return count; 292| 4.79k| } _ZNK9OpenBabel8OBBitVec7IsEmptyEv: 298| 3.55M| { 299| 369M| for (word_vector::const_iterator sx = _set.begin(), sy = _set.end(); sx != sy; ++ sx) ------------------ | Branch (299:74): [True: 369M, False: 36.4k] ------------------ 300| 369M| if (* sx) ------------------ | Branch (300:11): [True: 3.51M, False: 365M] ------------------ 301| 3.51M| return(false); 302| | 303| 36.4k| return(true); 304| 3.55M| } _ZN9OpenBabel8OBBitVec10FromVecIntERKNSt3__16vectorIiNS1_9allocatorIiEEEE: 310| 91.1k| { 311| 446k| for (std::vector::const_iterator i = bit_offsets.begin(), j = bit_offsets.end(); i != j; ++i) ------------------ | Branch (311:91): [True: 354k, False: 91.1k] ------------------ 312| 354k| SetBitOn(* i); 313| 91.1k| } _ZN9OpenBabel8OBBitVec5ClearEv: 382| 3.82M| { 383| 504M| for (word_vector::iterator wx = _set.begin(), wy = _set.end(); wx != wy; ++wx) ------------------ | Branch (383:68): [True: 500M, False: 3.82M] ------------------ 384| 500M| * wx = 0; 385| 3.82M| } _ZN9OpenBabel8OBBitVecaSERKS0_: 392| 9.89M| { 393| 9.89M| _set = bv._set; 394| 9.89M| _size = _set.size(); 395| 9.89M| return(*this); 396| 9.89M| } _ZN9OpenBabel8OBBitVecaNERKS0_: 403| 288k| { 404| 288k| unsigned min = (bv.GetSize() < _size) ? bv.GetSize() : _size; ------------------ | Branch (404:20): [True: 75.8k, False: 212k] ------------------ 405| 288k| unsigned i; 406| | 407| 9.62M| for (i = 0;i < min;++i) ------------------ | Branch (407:16): [True: 9.33M, False: 288k] ------------------ 408| 9.33M| _set[i] &= bv._set[i]; 409| 4.70M| for (;i < _size;++i) ------------------ | Branch (409:11): [True: 4.41M, False: 288k] ------------------ 410| 4.41M| _set[i] = 0; 411| | 412| 288k| return(*this); 413| 288k| } _ZN9OpenBabel8OBBitVecoRERKS0_: 420| 266M| { 421| 266M| if (_size < bv.GetSize()) ------------------ | Branch (421:9): [True: 4.84k, False: 266M] ------------------ 422| 4.84k| ResizeWords(bv.GetSize()); 423| | 424| 6.42G| for (unsigned i = 0;i < bv.GetSize(); ++i) ------------------ | Branch (424:25): [True: 6.15G, False: 266M] ------------------ 425| 6.15G| _set[i] |= bv._set[i]; 426| | 427| 266M| return(*this); 428| 266M| } _ZN9OpenBabelorERKNS_8OBBitVecES2_: 476| 185k| { 477| 185k| OBBitVec bv(bv1); 478| 185k| bv |= bv2; 479| 185k| return(bv); 480| 185k| } _ZN9OpenBabelanERKNS_8OBBitVecES2_: 488| 288k| { 489| 288k| OBBitVec bv(bv1); 490| 288k| bv &= bv2; 491| 288k| return(bv); 492| 288k| } _ZN9OpenBabeleqERKNS_8OBBitVecES2_: 526| 2.44G| { 527| 2.44G| if (bv1.GetSize() < bv2.GetSize()) ------------------ | Branch (527:9): [True: 15.1M, False: 2.43G] ------------------ 528| 15.1M| { // bv1 smaller than bv2 529| 15.1M| unsigned i; 530| 742M| for (i = 0; i < bv1.GetSize(); ++ i) ------------------ | Branch (530:19): [True: 742M, False: 1.19k] ------------------ 531| 742M| if (bv1._set[i] != bv2._set[i]) ------------------ | Branch (531:13): [True: 15.1M, False: 726M] ------------------ 532| 15.1M| return false; 533| 45.8k| for (; i < bv2.GetSize(); ++ i) ------------------ | Branch (533:14): [True: 45.8k, False: 0] ------------------ 534| 45.8k| if (bv2._set[i] != 0) ------------------ | Branch (534:13): [True: 1.19k, False: 44.6k] ------------------ 535| 1.19k| return false; 536| 1.19k| } 537| 2.43G| else 538| 2.43G| { // bv2 smaller or equal than bv1 539| 2.43G| unsigned i; 540| 22.0G| for (i = 0; i < bv2.GetSize(); ++ i) ------------------ | Branch (540:19): [True: 22.0G, False: 3.11M] ------------------ 541| 22.0G| if (bv1._set[i] != bv2._set[i]) ------------------ | Branch (541:13): [True: 2.42G, False: 19.6G] ------------------ 542| 2.42G| return false; 543| 4.52M| for (; i < bv1.GetSize(); ++ i) ------------------ | Branch (543:14): [True: 1.40M, False: 3.11M] ------------------ 544| 1.40M| if (bv1._set[i] != 0) ------------------ | Branch (544:13): [True: 4.50k, False: 1.40M] ------------------ 545| 4.50k| return false; 546| 3.11M| } 547| 3.11M| return true; 548| 2.44G| } _ZN9OpenBabel6OBBondC2Ev: 64| 71.8M| { 65| 71.8M| _idx=0; 66| 71.8M| _order=0; 67| 71.8M| _flags=0; 68| 71.8M| _bgn=nullptr; 69| 71.8M| _end=nullptr; 70| 71.8M| _vdata.clear(); 71| 71.8M| _parent=nullptr; 72| 71.8M| } _ZN9OpenBabel6OBBondD2Ev: 75| 71.8M| { 76| | // OBGenericData handled in OBBase parent class. 77| 71.8M| } _ZN9OpenBabel6OBBond3SetEiPNS_6OBAtomES2_ii: 87| 71.8M| { 88| 71.8M| SetIdx(idx); 89| 71.8M| SetBegin(begin); 90| 71.8M| SetEnd(end); 91| 71.8M| SetBondOrder(order); 92| 71.8M| SetFlag(flags); 93| 71.8M| } _ZN9OpenBabel6OBBond12SetBondOrderEi: 96| 78.8M| { 97| 78.8M| _order = (char)order; 98| 78.8M| } _ZNK9OpenBabel6OBBond10IsAromaticEv: 467| 313M| { 468| 313M| OBMol *mol = ((OBBond*)this)->GetParent(); 469| 313M| if (!mol->HasAromaticPerceived()) ------------------ | Branch (469:9): [True: 4.91k, False: 313M] ------------------ 470| 4.91k| aromtyper.AssignAromaticFlags(*mol); 471| | 472| 313M| if (this->HasFlag(OB_AROMATIC_BOND)) ------------------ | | 41| 313M|#define OB_AROMATIC_BOND (1<<1) ------------------ | Branch (472:9): [True: 235M, False: 77.9M] ------------------ 473| 235M| return true; 474| | 475| 77.9M| return false; 476| 313M| } _ZNK9OpenBabel6OBBond8IsInRingEv: 519| 32.9M| { 520| 32.9M| OBMol *mol = ((OBBond*)this)->GetParent(); 521| 32.9M| if (!mol->HasRingAtomsAndBondsPerceived()) ------------------ | Branch (521:9): [True: 5.12k, False: 32.9M] ------------------ 522| 5.12k| mol->FindRingAtomsAndBonds(); 523| | 524| 32.9M| if (((OBBond*)this)->HasFlag(OB_RING_BOND)) ------------------ | | 47| 32.9M|#define OB_RING_BOND (1<<4) ------------------ | Branch (524:9): [True: 11.0M, False: 21.8M] ------------------ 525| 11.0M| return true; 526| | 527| 21.8M| return false; 528| 32.9M| } _ZN9OpenBabel6OBBond9IsClosureEv: 551| 123M| { 552| 123M| OBMol *mol = (OBMol*)GetParent(); 553| 123M| if (!mol) ------------------ | Branch (553:9): [True: 0, False: 123M] ------------------ 554| 0| return false; 555| 123M| if (!mol->HasClosureBondsPerceived()) ------------------ | Branch (555:9): [True: 0, False: 123M] ------------------ 556| 0| mol->FindRingAtomsAndBonds(); 557| 123M| return HasFlag(OB_CLOSURE_BOND); ------------------ | | 49| 123M|#define OB_CLOSURE_BOND (1<<10) ------------------ 558| 123M| } _ZN9OpenBabel17GenerateByteCodesEPPNS_9_ByteCodeEiiii: 505| 1.94k| { 506| 1.94k| StackType neighbour[4]; 507| 1.94k| StackType original; 508| 1.94k| int count,i,j; 509| 1.94k| ByteCode *ptr; 510| 1.94k| bool done,found; 511| | 512| 1.94k| if( curr != prev ) ------------------ | Branch (512:9): [True: 1.88k, False: 54] ------------------ 513| 1.88k| { 514| 1.88k| if( MonoAtom[curr].atomid < ATOMMINAMINO ) ------------------ | | 62| 1.88k|#define ATOMMINAMINO 4 ------------------ | Branch (514:13): [True: 6, False: 1.88k] ------------------ 515| 6| { 516| 6| found = false; 517| 6| while( *node && ((*node)->type==BC_IDENT) ) ------------------ | | 136| 4|#define BC_IDENT 0x05 ------------------ | Branch (517:20): [True: 4, False: 2] | Branch (517:29): [True: 0, False: 4] ------------------ 518| 0| { 519| 0| if( (*node)->ident.value == MonoAtom[curr].atomid ) ------------------ | Branch (519:21): [True: 0, False: 0] ------------------ 520| 0| { 521| 0| node = (ByteCode**)&(*node)->ident.tcond; 522| 0| found = true; 523| 0| break; 524| 0| } 525| 0| else 526| 0| node = (ByteCode**)&(*node)->ident.fcond; 527| 0| } 528| | 529| 6| if (!found) ------------------ | Branch (529:17): [True: 6, False: 0] ------------------ 530| 6| { 531| 6| ptr = AllocateByteCode(BC_IDENT); ------------------ | | 136| 6|#define BC_IDENT 0x05 ------------------ 532| 6| ptr->ident.tcond = nullptr; 533| 6| ptr->ident.fcond = *node; 534| 6| *node = ptr; 535| 6| node = (ByteCode**)&ptr->ident.tcond; 536| 6| ptr->ident.value = MonoAtom[curr].atomid; 537| 6| } 538| 6| MonoBond[bond].index = BondIndex++; 539| 6| done = true; 540| 6| } 541| 1.88k| else if( MonoAtom[curr].index != -1 ) ------------------ | Branch (541:18): [True: 716, False: 1.16k] ------------------ 542| 716| { 543| 716| while( *node && ((*node)->type==BC_IDENT) ) ------------------ | | 136| 108|#define BC_IDENT 0x05 ------------------ | Branch (543:20): [True: 108, False: 608] | Branch (543:29): [True: 0, False: 108] ------------------ 544| 0| node = (ByteCode**)&(*node)->ident.fcond; 545| | 546| 716| found = false; 547| 734| while( *node && ((*node)->type==BC_LOCAL) ) ------------------ | | 137| 116|#define BC_LOCAL 0x06 ------------------ | Branch (547:20): [True: 116, False: 618] | Branch (547:29): [True: 76, False: 40] ------------------ 548| 76| { 549| 76| if( (*node)->local.value == MonoAtom[curr].index ) ------------------ | Branch (549:21): [True: 58, False: 18] ------------------ 550| 58| { 551| 58| node = (ByteCode**)&(*node)->local.tcond; 552| 58| found = true; 553| 58| break; 554| 58| } 555| 18| else 556| 18| node = (ByteCode**)&(*node)->local.fcond; 557| 76| } 558| | 559| 716| if (!found) ------------------ | Branch (559:17): [True: 658, False: 58] ------------------ 560| 658| { 561| 658| ptr = AllocateByteCode(BC_LOCAL); ------------------ | | 137| 658|#define BC_LOCAL 0x06 ------------------ 562| 658| ptr->local.tcond = nullptr; 563| 658| ptr->local.fcond = *node; 564| 658| *node = ptr; 565| 658| node = (ByteCode**)&ptr->local.tcond; 566| 658| ptr->local.value = MonoAtom[curr].index; 567| 658| } 568| | 569| 716| MonoBond[bond].index = BondIndex++; 570| 716| done = true; 571| 716| } 572| 1.16k| else 573| 1.16k| { 574| 1.17k| while( *node && ((*node)->type==BC_IDENT) ) ------------------ | | 136| 562|#define BC_IDENT 0x05 ------------------ | Branch (574:20): [True: 562, False: 614] | Branch (574:29): [True: 10, False: 552] ------------------ 575| 10| node = (ByteCode**)&(*node)->ident.fcond; 576| 1.21k| while( *node && ((*node)->type==BC_LOCAL) ) ------------------ | | 137| 580|#define BC_LOCAL 0x06 ------------------ | Branch (576:20): [True: 580, False: 632] | Branch (576:29): [True: 46, False: 534] ------------------ 577| 46| node = (ByteCode**)&(*node)->local.fcond; 578| | 579| 1.16k| found = false; 580| 1.38k| while( *node && ((*node)->type==BC_ELEM) ) ------------------ | | 134| 652|#define BC_ELEM 0x03 ------------------ | Branch (580:20): [True: 652, False: 728] | Branch (580:29): [True: 652, False: 0] ------------------ 581| 652| { 582| 652| if( (*node)->elem.value == MonoAtom[curr].elem ) ------------------ | Branch (582:21): [True: 438, False: 214] ------------------ 583| 438| { 584| 438| node = (ByteCode**)&(*node)->elem.tcond; 585| 438| found = true; 586| 438| break; 587| 438| } 588| 214| else 589| 214| node = (ByteCode**)&(*node)->elem.fcond; 590| 652| } 591| | 592| 1.16k| if( !found ) ------------------ | Branch (592:17): [True: 728, False: 438] ------------------ 593| 728| { 594| 728| ptr = AllocateByteCode(BC_ELEM); ------------------ | | 134| 728|#define BC_ELEM 0x03 ------------------ 595| 728| ptr->elem.tcond = nullptr; 596| 728| ptr->elem.fcond = *node; 597| 728| *node = ptr; 598| 728| node = (ByteCode**)&ptr->elem.tcond; 599| 728| ptr->elem.value = MonoAtom[curr].elem; 600| 728| } 601| | 602| 1.16k| MonoAtom[curr].index = AtomIndex++; 603| 1.16k| MonoBond[bond].index = BondIndex++; 604| 1.16k| done = false; 605| 1.16k| } 606| 1.88k| } 607| 54| else 608| 54| { 609| 54| MonoAtom[curr].index = AtomIndex++; 610| 54| done = false; 611| 54| } 612| | 613| 1.94k| count = 0; 614| 1.94k| if (!done) ------------------ | Branch (614:9): [True: 1.22k, False: 722] ------------------ 615| 1.22k| { 616| 13.5k| for( i=0; itype==BC_EVAL) ) ------------------ | | 135| 488|#define BC_EVAL 0x04 ------------------ | Branch (638:14): [True: 488, False: 732] | Branch (638:23): [True: 480, False: 8] ------------------ 639| 480| { 640| 480| found = false; 641| 480| node = (ByteCode**)&(*node)->eval.next; 642| 674| while( *node && ((*node)->type==BC_COUNT) ) ------------------ | | 133| 584|#define BC_COUNT 0x02 ------------------ | Branch (642:20): [True: 584, False: 90] | Branch (642:29): [True: 584, False: 0] ------------------ 643| 584| { 644| 584| if( (*node)->count.value == count ) ------------------ | Branch (644:21): [True: 390, False: 194] ------------------ 645| 390| { 646| 390| node = (ByteCode**)&(*node)->count.tcond; 647| 390| found = true; 648| 390| break; 649| 390| } 650| 194| else 651| 194| node = (ByteCode**)&(*node)->count.fcond; 652| 584| } 653| | 654| 480| if( !found ) ------------------ | Branch (654:17): [True: 90, False: 390] ------------------ 655| 90| { 656| 90| ptr = AllocateByteCode(BC_COUNT); ------------------ | | 133| 90|#define BC_COUNT 0x02 ------------------ 657| 90| ptr->count.tcond = nullptr; 658| 90| ptr->count.fcond = *node; 659| 90| *node = ptr; 660| 90| node = (ByteCode**)&ptr->count.tcond; 661| 90| ptr->count.value = count; 662| 90| } 663| 480| } 664| 740| else if( count || StrictFlag || StackPtr ) ------------------ | Branch (664:18): [True: 436, False: 304] | Branch (664:27): [True: 0, False: 304] | Branch (664:41): [True: 262, False: 42] ------------------ 665| 698| { 666| 698| ptr = AllocateByteCode(BC_EVAL); ------------------ | | 135| 698|#define BC_EVAL 0x04 ------------------ 667| 698| ptr->eval.next = *node; 668| 698| *node = ptr; 669| 698| node = (ByteCode**)&ptr->eval.next; 670| | 671| 698| ptr = AllocateByteCode(BC_COUNT); ------------------ | | 133| 698|#define BC_COUNT 0x02 ------------------ 672| 698| ptr->count.tcond = nullptr; 673| 698| ptr->count.fcond = *node; 674| 698| *node = ptr; 675| 698| node = (ByteCode**)&ptr->count.tcond; 676| 698| ptr->count.value = count; 677| 698| } 678| 1.22k| } 679| | 680| 1.94k| if( count == 1 ) ------------------ | Branch (680:9): [True: 612, False: 1.33k] ------------------ 681| 612| { 682| 612| GenerateByteCodes(node,resid,neighbour[0].atom, curr,neighbour[0].bond); 683| 612| } 684| 1.33k| else if( count == 2 ) ------------------ | Branch (684:14): [True: 224, False: 1.10k] ------------------ 685| 224| { 686| 224| original = Stack[StackPtr++]; 687| 224| Stack[StackPtr-1] = neighbour[0]; 688| 224| Stack[StackPtr-1].prev = curr; 689| 224| GenerateByteCodes(node,resid,neighbour[1].atom, 690| 224| curr,neighbour[1].bond); 691| 224| Stack[StackPtr-1] = neighbour[1]; 692| 224| Stack[StackPtr-1].prev = curr; 693| 224| GenerateByteCodes(node,resid,neighbour[0].atom, 694| 224| curr,neighbour[0].bond); 695| 224| Stack[--StackPtr] = original; 696| 224| } 697| 1.10k| else if( count ) ------------------ | Branch (697:14): [True: 0, False: 1.10k] ------------------ 698| 0| { 699| 0| stringstream errorMsg; 700| 0| errorMsg << "Maximum Monomer Fanout Exceeded!" << endl; 701| 0| errorMsg << "Residue " << ChainsResName[resid] << " atom " 702| 0| << curr << endl; 703| 0| errorMsg << "Previous = " << prev << " Fanout = " << count << endl; 704| 0| obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning); 705| 0| } 706| 1.10k| else if( StackPtr ) ------------------ | Branch (706:14): [True: 828, False: 278] ------------------ 707| 828| { 708| 828| StackPtr--; 709| 828| GenerateByteCodes(node,resid,Stack[StackPtr].atom, 710| 828| Stack[StackPtr].prev,Stack[StackPtr].bond); 711| 828| StackPtr++; 712| 828| } 713| 278| else if( !(*node) ) ------------------ | Branch (713:14): [True: 262, False: 16] ------------------ 714| 262| { 715| 262| ptr = AllocateByteCode(BC_ASSIGN); ------------------ | | 132| 262|#define BC_ASSIGN 0x01 ------------------ 716| 262| ptr->assign.resid = resid; 717| 262| ptr->assign.atomid = new int[AtomIndex]; 718| 262| if( !ptr->assign.atomid ) ------------------ | Branch (718:13): [True: 0, False: 262] ------------------ 719| 0| FatalMemoryError(); 720| 2.80k| for( i=0; iassign.atomid[j] = MonoAtom[i].atomid; 723| 262| if( BondIndex ) ------------------ | Branch (723:13): [True: 260, False: 2] ------------------ 724| 260| { 725| 260| ptr->assign.bflags = new int[BondIndex]; 726| 2.90k| for( i=0; iassign.bflags[j] = MonoBond[i].flag; 729| 260| } 730| 262| *node = ptr; 731| 262| } 732| 16| else if( (*node)->type == BC_ASSIGN ) ------------------ | | 132| 16|#define BC_ASSIGN 0x01 ------------------ | Branch (732:14): [True: 16, False: 0] ------------------ 733| 16| { 734| 16| if( (*node)->assign.resid != resid ) ------------------ | Branch (734:13): [True: 0, False: 16] ------------------ 735| 0| { 736| 0| stringstream errorMsg; 737| 0| errorMsg << "Duplicated Monomer Specification!\n"; 738| 0| errorMsg << "Residue " << ChainsResName[resid] 739| 0| << " matches residue "; 740| 0| errorMsg << ChainsResName[(*node)->assign.resid] << endl; 741| 0| obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning); 742| 0| } 743| 16| } 744| | 745| | /* Restore State! */ 746| 1.94k| if( curr != prev ) ------------------ | Branch (746:9): [True: 1.88k, False: 54] ------------------ 747| 1.88k| { 748| 1.88k| if( !done ) ------------------ | Branch (748:13): [True: 1.16k, False: 722] ------------------ 749| 1.16k| { 750| 1.16k| MonoAtom[curr].index = -1; 751| 1.16k| AtomIndex--; 752| 1.16k| } 753| 1.88k| MonoBond[bond].index = -1; 754| 1.88k| BondIndex--; 755| 1.88k| } 756| 1.94k| } _ZN9OpenBabel14OBChainsParserC2Ev: 764| 2| { 765| 2| int i, res = RESIDMIN; ------------------ | | 49| 2|#define RESIDMIN 4 ------------------ 766| | 767| 2| PDecisionTree = (ByteCode*)nullptr; 768| 44| for( i=0 ; i < AMINOMAX ; i++ ) ------------------ | | 69| 44|#define AMINOMAX 21 ------------------ | Branch (768:16): [True: 42, False: 2] ------------------ 769| 42| { 770| 42| strncpy(ChainsResName[res],AminoAcids[i].name, sizeof(ChainsResName[res]) - 1); 771| 42| ChainsResName[res][sizeof(ChainsResName[res]) - 1] = '\0'; 772| 42| DefineMonomer(&PDecisionTree,res,AminoAcids[i].data); 773| 42| res++; 774| 42| } 775| | 776| 2| NDecisionTree = (ByteCode*)nullptr; 777| 14| for( i=0 ; i< NUCLEOMAX ; i++ ) ------------------ | | 72| 14|#define NUCLEOMAX 6 ------------------ | Branch (777:16): [True: 12, False: 2] ------------------ 778| 12| { 779| 12| strncpy(ChainsResName[res],Nucleotides[i].name, sizeof(ChainsResName[res]) - 1); 780| 12| ChainsResName[res][sizeof(ChainsResName[res]) - 1] = '\0'; 781| 12| DefineMonomer(&NDecisionTree,res,Nucleotides[i].data); 782| 12| res++; 783| 12| } 784| 2| } _ZN9OpenBabel14OBChainsParser13DefineMonomerEPPviPKc: 1870| 54| { 1871| 54| int i; 1872| | 1873| 54| MonoAtomCount = 0; 1874| 54| MonoBondCount = 0; 1875| | 1876| 54| ParseSmiles(smiles,-1); 1877| | 1878| 380| for( i=0; i='0') && (*ptr<='9') ) ------------------ | Branch (2185:9): [True: 0, False: 0] | Branch (2185:24): [True: 0, False: 0] ------------------ 2186| 0| if( (ch=='H') || (ch=='D') ) ------------------ | Branch (2186:11): [True: 0, False: 0] | Branch (2186:24): [True: 0, False: 0] ------------------ 2187| 0| return( 1 ); /* Hydrogen */ 2188| | 2189| 0| return( 0 ); 2190| 0| } _ZN9OpenBabel14OBChainsParser11ParseSmilesEPKci: 2193| 106| { 2194| 106| char *name; 2195| 106| int atomid; 2196| 106| int next; 2197| 106| int type; 2198| 106| int ch; 2199| | 2200| 106| type = 0; 2201| 864| while( (ch = *ptr++) ) ------------------ | Branch (2201:12): [True: 810, False: 54] ------------------ 2202| 810| { 2203| 810| switch( ch ) 2204| 810| { 2205| 262| case('-'): type = BF_SINGLE; ------------------ | | 139| 262|#define BF_SINGLE 0x01 ------------------ | Branch (2205:11): [True: 262, False: 548] ------------------ 2206| 262| break; 2207| 10| case('='): type = BF_DOUBLE; ------------------ | | 140| 10|#define BF_DOUBLE 0x02 ------------------ | Branch (2207:11): [True: 10, False: 800] ------------------ 2208| 10| break; 2209| 0| case('#'): type = BF_TRIPLE; ------------------ | | 141| 0|#define BF_TRIPLE 0x04 ------------------ | Branch (2209:11): [True: 0, False: 810] ------------------ 2210| 0| break; 2211| 30| case('^'): type = BF_SINGLE|BF_AROMATIC; ------------------ | | 139| 30|#define BF_SINGLE 0x01 ------------------ case('^'): type = BF_SINGLE|BF_AROMATIC; ------------------ | | 142| 30|#define BF_AROMATIC 0x08 ------------------ | Branch (2211:11): [True: 30, False: 780] ------------------ 2212| 30| break; 2213| 24| case('~'): type = BF_DOUBLE|BF_AROMATIC; ------------------ | | 140| 24|#define BF_DOUBLE 0x02 ------------------ case('~'): type = BF_DOUBLE|BF_AROMATIC; ------------------ | | 142| 24|#define BF_AROMATIC 0x08 ------------------ | Branch (2213:11): [True: 24, False: 786] ------------------ 2214| 24| break; 2215| | 2216| 52| case(')'): return( ptr ); ------------------ | Branch (2216:11): [True: 52, False: 758] ------------------ 2217| 0| case('.'): prev = -1; ------------------ | Branch (2217:11): [True: 0, False: 810] ------------------ 2218| 0| break; 2219| 52| case('('): ptr = ParseSmiles(ptr,prev); ------------------ | Branch (2219:11): [True: 52, False: 758] ------------------ 2220| 52| break; 2221| | 2222| 380| default: ------------------ | Branch (2222:11): [True: 380, False: 430] ------------------ 2223| 380| atomid = ch-'0'; 2224| 628| while( isdigit(*ptr) ) ------------------ | Branch (2224:20): [True: 248, False: 380] ------------------ 2225| 248| atomid = (atomid*10)+(*ptr++)-'0'; 2226| | 2227| 1.64k| for( next=0; nexttype = type; 428| 3.14k| result->eval.next = nullptr; 429| 3.14k| result->count.tcond = nullptr; 430| 3.14k| result->count.fcond = nullptr; 431| 3.14k| result->elem.tcond = nullptr; 432| 3.14k| result->elem.fcond = nullptr; 433| 3.14k| result->ident.tcond = nullptr; 434| 3.14k| result->ident.fcond = nullptr; 435| 3.14k| result->local.tcond = nullptr; 436| 3.14k| result->local.fcond = nullptr; 437| 3.14k| result->assign.atomid = nullptr; 438| 3.14k| result->assign.bflags = nullptr; 439| | 440| 3.14k| return (result); 441| 3.14k| } _ZN9OpenBabel15FromFileChargesC2EPKc: 45| 2| FromFileCharges(const char* ID) : OBChargeModel(ID, false){ 46| 2| }; _ZN9OpenBabel16GasteigerChargesC2EPKc: 30| 2| GasteigerCharges(const char* ID) : OBChargeModel(ID, false){}; _ZN9OpenBabel13MMFF94ChargesC2EPKc: 34| 2| MMFF94Charges(const char* ID) : OBChargeModel(ID, false){}; _ZN9OpenBabel9NoChargesC2EPKc: 32| 2| NoCharges(const char* ID) : OBChargeModel(ID, false){}; _ZN9OpenBabel11OBTypeTableC2Ev: 248| 2| { 249| 2| _init = false; 250| 2| _dir = BABEL_DATADIR; ------------------ | | 4| 2|#define BABEL_DATADIR "/usr/local/share/openbabel" ------------------ 251| 2| _envvar = "BABEL_DATADIR"; 252| 2| _filename = "types.txt"; 253| 2| _subdir = "data"; 254| 2| _dataptr = TypesData; 255| 2| _linecount = 0; 256| 2| _from = _to = -1; 257| 2| } _ZN9OpenBabel13OBResidueDataC2Ev: 433| 2| { 434| 2| _init = false; 435| 2| _dir = BABEL_DATADIR; ------------------ | | 4| 2|#define BABEL_DATADIR "/usr/local/share/openbabel" ------------------ 436| 2| _envvar = "BABEL_DATADIR"; 437| 2| _filename = "resdata.txt"; 438| 2| _subdir = "data"; 439| 2| _dataptr = ResidueData; 440| 2| } _ZN9OpenBabel9CanSmilesC2EPKcb: 31| 4| CanSmiles(const char* ID, bool noStereo) : OBDescriptor(ID), _noStereo(noStereo){}; _ZN9OpenBabel14CompoundFilterC2EPKcS2_S2_: 55| 2| : OBDescriptor(ID), _descr(descr), _macroText(macrotext){} _ZN9OpenBabel8MWFilterC2EPKc: 33| 2| MWFilter(const char *ID) : OBDescriptor(ID){}; _ZN9OpenBabel20RotatableBondsFilterC2EPKc: 47| 2| RotatableBondsFilter(const char *ID) : OBDescriptor(ID){}; _ZN9OpenBabel12SmartsFilterC2EPKc: 64| 4| SmartsFilter(const char *ID) : OBDescriptor(ID){}; _ZN9OpenBabel11TitleFilterC2EPKc: 107| 2| TitleFilter(const char *ID) : OBDescriptor(ID){}; _ZN9OpenBabel17FormulaDescriptorC2EPKc: 151| 2| FormulaDescriptor(const char *ID) : OBDescriptor(ID){}; _ZN9OpenBabel11InChIFilterC2EPKcb: 33| 4| InChIFilter(const char* ID, bool useKey=false) : OBDescriptor(ID), bKey(useKey) {}; _ZN9OpenBabel16SmartsDescriptorC2EPKcS2_S2_: 35| 8| : OBDescriptor(ID, false), _smarts(smarts), _descr(descr){} _ZN9OpenBabel12fingerprint2C2EPKcb: 38| 2| : OBFingerprint(ID, IsDefault), _flags(0){}; _ZN9OpenBabel9PatternFPC2EPKcS2_b: 55| 4| { 56| 4| if (filename == nullptr) ------------------ | Branch (56:9): [True: 2, False: 2] ------------------ 57| 2| _patternsfile="patterns.txt"; 58| 2| else 59| 2| _patternsfile = filename; 60| 4| } _ZN9OpenBabel15fingerprintECFPC2EPKcbjb: 38| 12| _radius(radius), _keepdups(keepdups), _flags(0){}; _ZN9OpenBabel15OBFFConstraintsC2Ev: 420| 2| { 421| 2| _factor = 50000.0; 422| 2| } _ZN9OpenBabel16OBForceFieldGaffC2EPKcb: 124| 2| { 125| 2| _validSetup = false; 126| 2| _init = false; 127| 2| _rvdw = 7.0; 128| 2| _rele = 15.0; 129| 2| _epsilon = 1.0; 130| 2| _pairfreq = 10; 131| 2| _cutoff = false; 132| 2| _linesearch = LineSearchType::Newton2Num; 133| 2| } _ZN9OpenBabel20OBForceFieldGhemicalC2EPKcb: 115| 2| { 116| 2| _validSetup = false; 117| 2| _init = false; 118| 2| _rvdw = 7.0; 119| 2| _rele = 15.0; 120| 2| _epsilon = 1.0; 121| 2| _pairfreq = 10; 122| 2| _cutoff = false; 123| 2| _linesearch = LineSearchType::Newton2Num; 124| 2| } _ZN9OpenBabel18OBForceFieldMMFF94C2EPKcb: 233| 4| { 234| 4| _validSetup = false; 235| 4| _init = false; 236| 4| _rvdw = 7.0; 237| 4| _rele = 15.0; 238| 4| _epsilon = 1.0; // default electrostatics 239| 4| _pairfreq = 15; 240| 4| _cutoff = false; 241| 4| _linesearch = LineSearchType::Newton2Num; 242| 4| _gradientPtr = nullptr; 243| 4| _grad1 = nullptr; 244| 4| if (!strncmp(ID, "MMFF94s", 7)) { ------------------ | Branch (244:6): [True: 2, False: 2] ------------------ 245| 2| mmff94s = true; 246| 2| _parFile = std::string("mmff94s.ff"); 247| 2| } else { 248| 2| mmff94s = false; 249| 2| _parFile = std::string("mmff94.ff"); 250| 2| } 251| 4| } _ZN9OpenBabel15OBForceFieldUFFC2EPKcb: 125| 2| { 126| 2| _validSetup = false; 127| 2| _init = false; 128| 2| _rvdw = 7.0; 129| 2| _rele = 15.0; 130| 2| _epsilon = 1.0; // electrostatics not used 131| 2| _pairfreq = 10; 132| 2| _cutoff = false; 133| 2| _linesearch = LineSearchType::Newton2Num; 134| 2| } _ZN9OpenBabel8OBFormat14RegisterFormatEPKcS2_: 32| 322|{ 33| 322| GetMap()[ID] = this; 34| 322| if (MIME) ------------------ | Branch (34:7): [True: 94, False: 228] ------------------ 35| 94| FormatsMIMEMap()[MIME] = this; 36| 322| if(Flags() & DEFAULTFORMAT) ------------------ | | 40| 322|#define DEFAULTFORMAT 0x4000 ------------------ | Branch (36:6): [True: 8, False: 314] ------------------ 37| 8| Default() = this; 38| | 39| | //ensure "formats" is registered as a plugin 40| 322| PluginMap()[TypeID()] =this; 41| 322| _id=ID; 42| 322| return GetMap().size(); 43| 322|} _ZN9OpenBabel14OBAPIInterfaceC2Ev: 29| 2| { 30| 2| OBConversion::RegisterFormat("obapi",this); 31| 2| OBConversion::RegisterOptionParam("-errorlevel", this, 1, OBConversion::GENOPTIONS); 32| 2| } _ZN9OpenBabel14OBAPIInterface5FlagsEv: 41| 2| unsigned int Flags() override { return (NOTWRITABLE | NOTREADABLE); } ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ unsigned int Flags() override { return (NOTWRITABLE | NOTREADABLE); } ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ _ZN9OpenBabel9CSRFormatC2Ev: 32| 2| { 33| 2| OBConversion::RegisterFormat("csr",this); 34| 2| } _ZN9OpenBabel9CSRFormat5FlagsEv: 49| 2| { 50| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 51| 2| } _ZN9OpenBabel10MCDLFormat4initEv: 142| 2| void MCDLFormat::init(){ 143| 2| fsastart="{SA:"; 144| 2| fsbstart="{SB:"; 145| 2| fchstart="{CZ:"; 146| 2| fradstart="{RA:"; 147| | //coordinates string 148| 2| fnastart="{NA:"; 149| 2| fnbstart="{NB:"; 150| 2| fzcoorstart="{ZV:"; 151| 2| fablockstart="{CC:"; 152| 2| fbblockstart="{BB:"; 153| 2| fchargeblockstart="{MM:CHG,"; 154| 2| fstereobondstart="{BS:"; 155| 2| ftitlestart="{CN:}"; 156| | 157| 2| }; _ZN9OpenBabel10MCDLFormatC2Ev: 38| 2| { 39| 2| OBConversion::RegisterFormat("mcdl",this); 40| 2| init(); 41| 2| } _ZN9OpenBabel10MCDLFormat5FlagsEv: 72| 2| { 73| 2| return 0; 74| 2| } _ZN9OpenBabel9MNAFormatC2Ev: 55| 2| { 56| 2| OBConversion::RegisterFormat("mna", this); 57| 2| OBConversion::RegisterOptionParam(levels_option, this, 1); 58| 2| } _ZN9OpenBabel9MNAFormat5FlagsEv: 155| 2| { 156| 2| return NOTREADABLE; // possibly WRITEONEONLY?? ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 157| 2| } _ZN9OpenBabel9PQSFormatC2Ev: 37| 2| { 38| 2| OBConversion::RegisterFormat("pqs",this); 39| 2| } _ZN9OpenBabel9PQSFormat5FlagsEv: 54| 2| { 55| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 56| 2| } _ZN9OpenBabel12ABINITFormatC2Ev: 39| 2| { 40| 2| OBConversion::RegisterFormat("abinit",this); 41| 2| } _ZN9OpenBabel12ABINITFormat5FlagsEv: 58| 2| { 59| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 60| 2| } _ZN9OpenBabel16AcesOutputFormatC2Ev: 38| 2| { 39| 2| OBConversion::RegisterFormat("acesout",this); 40| 2| } _ZN9OpenBabel15AcesInputFormatC2Ev: 75| 2| { 76| 2| OBConversion::RegisterFormat("acesin",this); 77| 2| } _ZN9OpenBabel16AcesOutputFormat5FlagsEv: 58| 2| { 59| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 60| 2| } _ZN9OpenBabel15AcesInputFormat5FlagsEv: 93| 2| { 94| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 95| 2| } _ZN9OpenBabel9ACRFormatC2Ev: 39| 2| { 40| 2| OBConversion::RegisterFormat("acr", this, "chemical/x-acr"); 41| | // OBConversion::RegisterOptionParam("f", this, 1); 42| | // OBConversion::RegisterOptionParam("n", this); 43| 2| OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS); 44| | 45| 2| } _ZN9OpenBabel9ACRFormat5FlagsEv: 65| 2| { 66| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 67| 2| } _ZN9OpenBabel15ADFOutputFormatC2Ev: 63| 2| { 64| 2| OBConversion::RegisterFormat("adfout",this); 65| 2| } _ZN9OpenBabel14ADFInputFormatC2Ev: 264| 2| { 265| 2| OBConversion::RegisterFormat("adf", this); 266| 2| } _ZN9OpenBabel13ADFBandFormatC2Ev: 371| 2| { 372| 2| OBConversion::RegisterFormat("adfband",this); 373| 2| } _ZN9OpenBabel13ADFDftbFormatC2Ev: 507| 2| { 508| 2| OBConversion::RegisterFormat("adfdftb",this); 509| 2| } _ZN9OpenBabel11OBT41FormatC2Ev: 651| 2| { 652| 2| OBConversion::RegisterFormat( "t41", this ); 653| 2| OBConversion::RegisterFormat( "T41", this ); 654| 2| } _ZN9OpenBabel15ADFOutputFormat5FlagsEv: 82| 2| { 83| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 84| 2| } _ZN9OpenBabel14ADFInputFormat5FlagsEv: 288| 2| { 289| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 290| 2| } _ZN9OpenBabel13ADFBandFormat5FlagsEv: 386| 2| { 387| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 388| 2| } _ZN9OpenBabel13ADFDftbFormat5FlagsEv: 522| 2| { 523| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 524| 2| } _ZN9OpenBabel11OBT41Format5FlagsEv: 683| 4| { 684| 4| return READONEONLY | READBINARY | NOTWRITABLE; ------------------ | | 32| 4|#define READONEONLY 0x02 ------------------ return READONEONLY | READBINARY | NOTWRITABLE; ------------------ | | 33| 4|#define READBINARY 0x04 ------------------ return READONEONLY | READBINARY | NOTWRITABLE; ------------------ | | 35| 4|#define NOTWRITABLE 0x10 ------------------ 685| 4| } _ZN9OpenBabel13AlchemyFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("alc",this, "chemical/x-alchemy"); 37| 2| } _ZN9OpenBabel13AlchemyFormat5FlagsEv: 55| 2| { 56| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 57| 2| } _ZN9OpenBabel15AmberPrepFormatC2Ev: 34| 2| { 35| 2| OBConversion::RegisterFormat("prep",this); 36| 2| } _ZN9OpenBabel15AmberPrepFormat5FlagsEv: 53| 2| { 54| 2| return NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 55| 2| } _ZN9OpenBabel13AoforceFormatC2Ev: 31| 2| AoforceFormat() { OBConversion::RegisterFormat("aoforce", this); } _ZN9OpenBabel13AoforceFormat5FlagsEv: 43| 2| unsigned int Flags() override { return READONEONLY | NOTWRITABLE; } ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ unsigned int Flags() override { return READONEONLY | NOTWRITABLE; } ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ _ZN9OpenBabel15BallStickFormatC2Ev: 33| 2| { 34| 2| OBConversion::RegisterFormat("bs",this); 35| 2| } _ZN9OpenBabel15BallStickFormat5FlagsEv: 50| 2| { 51| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 52| 2| } _ZN9OpenBabel9BGFFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("bgf",this); 38| 2| } _ZN9OpenBabel9BGFFormat5FlagsEv: 53| 2| { 54| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 55| 2| } _ZN9OpenBabel9BoxFormatC2Ev: 32| 2| { 33| 2| OBConversion::RegisterFormat("box",this); 34| 2| } _ZN9OpenBabel9BoxFormat5FlagsEv: 49| 2| { 50| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 51| 2| } _ZN9OpenBabel11CacaoFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("caccrt",this); 37| 2| } _ZN9OpenBabel19CacaoInternalFormatC2Ev: 290| 2| { 291| 2| OBConversion::RegisterFormat("cacint",this); 292| 2| } _ZN9OpenBabel11CacaoFormat5FlagsEv: 54| 2| { 55| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 56| 2| } _ZN9OpenBabel19CacaoInternalFormat5FlagsEv: 308| 2| { 309| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 310| 2| } _ZN9OpenBabel11CacheFormatC2Ev: 32| 2| { 33| 2| OBConversion::RegisterFormat("cac",this); 34| 2| OBConversion::RegisterFormat("cache",this); 35| 2| } _ZN9OpenBabel11CacheFormat5FlagsEv: 53| 4| { 54| 4| return NOTREADABLE; ------------------ | | 31| 4|#define NOTREADABLE 0x01 ------------------ 55| 4| } _ZN9OpenBabel9CARFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("car",this, "chemical/x-msi-car"); 37| 2| OBConversion::RegisterFormat("arc",this, "chemical/x-msi-car"); 38| 2| } _ZN9OpenBabel9CARFormat5FlagsEv: 56| 4| { 57| 4| return NOTWRITABLE; ------------------ | | 35| 4|#define NOTWRITABLE 0x10 ------------------ 58| 4| } _ZN9OpenBabel12CASTEPFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("castep",this); 38| 2| } _ZN9OpenBabel12CASTEPFormat5FlagsEv: 54| 2| { 55| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 56| 2| } _ZN9OpenBabel9CCCFormatC2Ev: 33| 2| { 34| 2| OBConversion::RegisterFormat("ccc",this); 35| 2| } _ZN9OpenBabel9CCCFormat5FlagsEv: 50| 2| { 51| 2| return NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 52| 2| } _ZN9OpenBabel13CHEM3D1FormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("c3d1",this); 37| 2| } _ZN9OpenBabel13CHEM3D2FormatC2Ev: 108| 2| { 109| 2| OBConversion::RegisterFormat("c3d2",this); 110| 2| } _ZN9OpenBabel13CHEM3D1Format5FlagsEv: 52| 2| { 53| 2| return READONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ 54| 2| } _ZN9OpenBabel13CHEM3D2Format5FlagsEv: 125| 2| { 126| 2| return READONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ 127| 2| } _ZN9OpenBabel21ChemDrawBinaryXFormatC2Ev: 128| 2| { 129| 2| OBConversion::RegisterFormat("cdx",this); 130| 2| } _ZN9OpenBabel21ChemDrawBinaryXFormat5FlagsEv: 162| 2| { 163| 2| return READBINARY|NOTWRITABLE; ------------------ | | 33| 2|#define READBINARY 0x04 ------------------ return READBINARY|NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 164| 2| } _ZN9OpenBabel14ChemDrawFormatC2Ev: 33| 2| { 34| 2| OBConversion::RegisterFormat("ct",this); 35| 2| } _ZN9OpenBabel14ChemDrawFormat5FlagsEv: 50| 2| { 51| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 52| 2| } _ZN9OpenBabel13ChemKinFormat4InitEv: 216| 2|{ //initialize the member variables used during input 217| 2| ln.clear(); 218| 2| AUnitsFactor = 1.0; 219| 2| EUnitsFactor = 1.0; 220| 2| SpeciesListed=false; 221| 2| IMols.clear(); 222| | //Special species name 223| 2| std::shared_ptr sp(new OBMol); 224| 2| sp.get()->SetTitle("M"); 225| 2| IMols["M"] = sp; 226| 2|} _ZN9OpenBabel13ChemKinFormatC2Ev: 47| 2| { 48| 2| OBConversion::RegisterFormat("ck",this); 49| 2| OBConversion::RegisterOptionParam("s", this); //no params 50| 2| OBConversion::RegisterOptionParam("t", this); 51| 2| Init(); 52| 2| } _ZN9OpenBabel9CHTFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("cht",this); 38| 2| } _ZN9OpenBabel9CHTFormat5FlagsEv: 53| 2| { 54| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 55| 2| } _ZN9OpenBabel9CIFFormatC2Ev: 62| 2| { 63| 2| RegisterFormat("cif", "chemical/x-cif"); 64| 2| } _ZN9OpenBabel10CopyFormatC2Ev: 24| 2| { 25| 2| OBConversion::RegisterFormat("copy",this); 26| 2| } _ZN9OpenBabel10CopyFormat5FlagsEv: 54| 2| { 55| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 56| 2| } _ZN9OpenBabel11CRK2DFormatC2Ev: 34| 2| { 35| 2| OBConversion::RegisterFormat("crk2d", this, "chemical/x-crk2d"); 36| 2| } _ZN9OpenBabel11CRK3DFormatC2Ev: 137| 2| { 138| 2| OBConversion::RegisterFormat("crk3d", this, "chemical/x-crk3d"); 139| 2| } _ZN9OpenBabel11CRK2DFormat5FlagsEv: 54| 2| { 55| 2| return READONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ 56| 2| } _ZN9OpenBabel11CRK3DFormat5FlagsEv: 157| 2| { 158| 2| return READONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ 159| 2| } _ZN9OpenBabel10CSSRFormatC2Ev: 32| 2| { 33| 2| OBConversion::RegisterFormat("cssr",this); 34| 2| } _ZN9OpenBabel10CSSRFormat5FlagsEv: 49| 2| { 50| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 51| 2| } _ZN9OpenBabel18DlpolyConfigFormatC2Ev: 261| 2| { 262| 2| OBConversion::RegisterFormat("CONFIG",this); 263| 2| } _ZN9OpenBabel19DlpolyHISTORYFormatC2Ev: 393| 2| { 394| 2| OBConversion::RegisterFormat("HISTORY",this); 395| 2| } _ZN9OpenBabel18DlpolyConfigFormat5FlagsEv: 278| 2| { 279| 2| return WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 280| 2| } _ZN9OpenBabel19DlpolyHISTORYFormat5FlagsEv: 410| 2| { 411| 2| return NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 412| 2| } _ZN9OpenBabel10DMolFormatC2Ev: 38| 2| { 39| 2| OBConversion::RegisterFormat("dmol",this); 40| 2| OBConversion::RegisterFormat("outmol",this, "chemical/x-dmol"); 41| 2| } _ZN9OpenBabel10DMolFormat5FlagsEv: 58| 4| { 59| 4| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 4|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 4|#define WRITEONEONLY 0x20 ------------------ 60| 4| } _ZN9OpenBabel10EXYZFormatC2Ev: 40| 2| { 41| 2| OBConversion::RegisterFormat("exyz", this, "chemical/x-xyz"); 42| 2| } _ZN9OpenBabel11FASTAFormatC2Ev: 40| 2| FASTAFormat() { 41| 2| OBConversion::RegisterFormat("fasta", this, "chemical/x-fasta"); 42| 2| OBConversion::RegisterFormat("fa", this); 43| 2| OBConversion::RegisterFormat("fsa", this); 44| | 45| 2| OBConversion::RegisterOptionParam("s", this); 46| 2| OBConversion::RegisterOptionParam("b", this); 47| 2| OBConversion::RegisterOptionParam("n", this); 48| 2| OBConversion::RegisterOptionParam("1", this); 49| 2| OBConversion::RegisterOptionParam("t", nullptr, 1, OBConversion::INOPTIONS); 50| 2| } _ZN9OpenBabel11FASTAFormat5FlagsEv: 74| 6| unsigned int Flags() override { 75| 6| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 6|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 6|#define WRITEONEONLY 0x20 ------------------ 76| 6| } _ZN9OpenBabel16FastSearchFormatC2Ev: 40| 2|{ 41| 2| OBConversion::RegisterFormat("fs",this); 42| | //Specify the number of option taken by options 43| 2| OBConversion::RegisterOptionParam("S", this, 1, OBConversion::GENOPTIONS); 44| 2| OBConversion::RegisterOptionParam("S", this, 1, OBConversion::INOPTIONS); 45| 2| OBConversion::RegisterOptionParam("f", this, 1); 46| 2| OBConversion::RegisterOptionParam("N", this, 1); 47| 2| OBConversion::RegisterOptionParam("u", this, 0); 48| 2| OBConversion::RegisterOptionParam("t", this, 1, OBConversion::INOPTIONS); 49| 2| OBConversion::RegisterOptionParam("l", this, 1, OBConversion::INOPTIONS); 50| 2| OBConversion::RegisterOptionParam("a", this, 0, OBConversion::INOPTIONS); 51| 2| OBConversion::RegisterOptionParam("e", this, 0, OBConversion::INOPTIONS); 52| 2|} _ZN9OpenBabel16FastSearchFormat5FlagsEv: 107| 2| unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; } ------------------ | | 33| 2|#define READBINARY 0x04 ------------------ unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; } ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ unsigned int Flags() override { return READBINARY | READONEONLY | WRITEBINARY; } ------------------ | | 37| 2|#define WRITEBINARY 0x40 ------------------ _ZN9OpenBabel10FCHKFormatC2Ev: 50| 2| { 51| 2| OBConversion::RegisterFormat("fchk", this, 52| 2| "chemical/x-gaussian-checkpoint"); 53| 2| OBConversion::RegisterFormat("fch", this, 54| 2| "chemical/x-gaussian-checkpoint"); 55| 2| OBConversion::RegisterFormat("fck", this, 56| 2| "chemical/x-gaussian-checkpoint"); 57| 2| } _ZN9OpenBabel10FCHKFormat5FlagsEv: 78| 6| { 79| 6| return NOTWRITABLE; ------------------ | | 35| 6|#define NOTWRITABLE 0x10 ------------------ 80| 6| } _ZN9OpenBabel10FEATFormatC2Ev: 32| 2| { 33| 2| OBConversion::RegisterFormat("feat",this); 34| 2| } _ZN9OpenBabel10FEATFormat5FlagsEv: 51| 2| { 52| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 53| 2| } _ZN9OpenBabel16FenskeZmatFormatC2Ev: 33| 2| { 34| 2| OBConversion::RegisterFormat("fh",this); 35| 2| } _ZN9OpenBabel16FenskeZmatFormat5FlagsEv: 50| 2| { 51| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 52| 2| } _ZN9OpenBabel13FHIaimsFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("fhiaims",this); 37| 2| } _ZN9OpenBabel13FHIaimsFormat5FlagsEv: 54| 2| { 55| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 56| 2| } _ZN9OpenBabel17FingerprintFormatC2Ev: 36| 2| FingerprintFormat() {OBConversion::RegisterFormat("fpt",this);} _ZN9OpenBabel17FingerprintFormat5FlagsEv: 111| 2| unsigned int Flags() override { return NOTREADABLE; } ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ _ZN9OpenBabel24FreeFormFractionalFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("fract",this); 37| 2| } _ZN9OpenBabel18GAMESSOutputFormatC2Ev: 41| 2| GAMESSOutputFormat() { 42| 2| OBConversion::RegisterFormat("gam", this, "chemical/x-gamess-output"); 43| 2| OBConversion::RegisterFormat("gamout", this); 44| 2| OBConversion::RegisterFormat("gamess", this); 45| 2| } _ZN9OpenBabel17GAMESSInputFormatC2Ev: 86| 2| GAMESSInputFormat() { 87| 2| OBConversion::RegisterFormat("inp", this, "chemical/x-gamess-input"); 88| 2| OBConversion::RegisterFormat("gamin", this); 89| | // Command-line keywords 90| 2| OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS); 91| | // Command-line keyword file 92| 2| OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS); 93| 2| } _ZN9OpenBabel18GAMESSOutputFormat5FlagsEv: 69| 6| unsigned int Flags() override { 70| 6| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 6|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 6|#define NOTWRITABLE 0x10 ------------------ 71| 6| } _ZN9OpenBabel17GAMESSInputFormat5FlagsEv: 116| 4| unsigned int Flags() override { 117| 4| return WRITEONEONLY; // | NOTREADABLE; ------------------ | | 36| 4|#define WRITEONEONLY 0x20 ------------------ 118| 4| } _ZN9OpenBabel20OBGaussianCubeFormatC2Ev: 56| 2| { 57| 2| OpenBabel::OBConversion::RegisterFormat( "cube", this ); 58| 2| OpenBabel::OBConversion::RegisterFormat( "cub", this ); 59| 2| } _ZN9OpenBabel20OBGaussianCubeFormat5FlagsEv: 89| 4| { 90| 4| return 0; 91| 4| } _ZN9OpenBabel20GaussianOutputFormatC2Ev: 38| 2| { 39| 2| OBConversion::RegisterFormat("gal",this, "chemical/x-gaussian-log"); 40| 2| OBConversion::RegisterFormat("g92",this); 41| 2| OBConversion::RegisterFormat("g94",this); 42| 2| OBConversion::RegisterFormat("g98",this); 43| 2| OBConversion::RegisterFormat("g03",this); 44| 2| OBConversion::RegisterFormat("g09",this); 45| 2| OBConversion::RegisterFormat("g16",this); 46| 2| } _ZN9OpenBabel19GaussianInputFormatC2Ev: 82| 2| { 83| 2| OBConversion::RegisterFormat("com",this, "chemical/x-gaussian-input"); 84| 2| OBConversion::RegisterFormat("gau",this); 85| 2| OBConversion::RegisterFormat("gjc",this); 86| 2| OBConversion::RegisterFormat("gjf",this); 87| 2| OBConversion::RegisterOptionParam("b", nullptr, 0, OBConversion::OUTOPTIONS); 88| | // Command-line keywords 89| 2| OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS); 90| | // Command-line keyword file 91| 2| OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS); 92| 2| } _ZN9OpenBabel20GaussianOutputFormat5FlagsEv: 66| 14| { 67| 14| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 14|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 14|#define NOTWRITABLE 0x10 ------------------ 68| 14| } _ZN9OpenBabel19GaussianInputFormat5FlagsEv: 114| 8| { 115| 8| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 8|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 8|#define WRITEONEONLY 0x20 ------------------ 116| 8| } _ZN9OpenBabel26GaussianZMatrixInputFormatC2Ev: 43| 2| { 44| 2| OBConversion::RegisterFormat("gzmat",this, "chemical/x-gaussian-input"); 45| 2| } _ZN9OpenBabel13GenBankFormatC2Ev: 32| 2| { // Copied from the Chemical MIME Page at http://www.ch.ic.ac.uk/chemime/ 33| 2| OBConversion::RegisterFormat("gen", this, "chemical/x-genbank"); 34| 2| OBConversion::RegisterFormat("embl", this); 35| 2| OBConversion::RegisterFormat("ddbj", this); 36| | 37| 2| OBConversion::RegisterOptionParam("s", this); 38| 2| OBConversion::RegisterOptionParam("b", this); 39| 2| } _ZN9OpenBabel13GenBankFormat5FlagsEv: 61| 6| { return NOTWRITABLE | READONEONLY; } ------------------ | | 35| 6|#define NOTWRITABLE 0x10 ------------------ { return NOTWRITABLE | READONEONLY; } ------------------ | | 32| 6|#define READONEONLY 0x02 ------------------ _ZN9OpenBabel14GhemicalFormatC2Ev: 36| 2| { 37| | // OBConversion::RegisterFormat("mm1gp",this); 38| | // OBConversion::RegisterFormat("qm1gp",this); 39| 2| OBConversion::RegisterFormat("gpr",this); 40| 2| } _ZN9OpenBabel14GhemicalFormat5FlagsEv: 55| 2| { 56| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 57| 2| } _ZN9OpenBabel9GROFormatC2Ev: 36| 2| { 37| | /* GRO is the file extension and is case insensitive. A MIME type can be 38| | added as an optional third parameter. 39| | Multiple file extensions can be registered by adding extra statements.*/ 40| 2| OBConversion::RegisterFormat("gro",this); 41| | 42| | /* If there are any format specific options they should be registered here 43| | so that the commandline interface works properly. 44| | The first parameter is the option name. If it is a single letter it can 45| | be concatinated with other single letter options. For output options it 46| | can be multicharcter and is then written as --optionname on the command 47| | line. The third parameter is the number of parameters the option takes. 48| | Currently this is either 1 or 0 and if it is 0 can be omitted for output 49| | options. The parameter is always text and needs to be parsed to extract 50| | a number. 51| | 52| | Options can apply when writing - 4th parameter is 53| | OBConversion::OUTOPTIONS or can be omitted as shown. A single letter 54| | output option is preceded by -x on the command line. 55| | Or options can apply to the input format - the 4th parameter is 56| | OBConversion::INOPTIONS. They are then preceded by -a on the command 57| | line. 58| | 59| | Each option letter may be reused in other formats, but within the same 60| | group, INOPTIONS or OUTOPTIONS, must take the same number of parameters 61| | (0 or 1). There will be an error message when OpenBabel runs if there 62| | are conflicts between formats. A list of formats currently used (which 63| | may not be comprehensive) is in docs/options.html. 64| | */ 65| 2| OBConversion::RegisterOptionParam("f", this, 1); 66| 2| OBConversion::RegisterOptionParam("n", this); 67| 2| OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS); 68| | 69| 2| } _ZN9OpenBabel14GROMOS96FormatC2Ev: 69| 2| { 70| 2| OBConversion::RegisterFormat("gr96",this); 71| 2| } _ZN9OpenBabel14GROMOS96Format5FlagsEv: 89| 2| { 90| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 91| 2| } _ZN9OpenBabel10GULPFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("got",this); 37| 2| } _ZN9OpenBabel10GULPFormat5FlagsEv: 53| 2| { 54| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 55| 2| } _ZN9OpenBabel9HINFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("hin",this, "chemical/x-hin"); 37| 2| } _ZN9OpenBabel18JaguarOutputFormatC2Ev: 37| 2| { 38| 2| OBConversion::RegisterFormat("jout",this); 39| 2| } _ZN9OpenBabel17JaguarInputFormatC2Ev: 72| 2| { 73| 2| OBConversion::RegisterFormat("jin",this); 74| 2| } _ZN9OpenBabel18JaguarOutputFormat5FlagsEv: 55| 2| unsigned int Flags() override { return READONEONLY | NOTWRITABLE; } ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ unsigned int Flags() override { return READONEONLY | NOTWRITABLE; } ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ _ZN9OpenBabel17JaguarInputFormat5FlagsEv: 90| 2| unsigned int Flags() override { return WRITEONEONLY; } ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ _ZN9OpenBabel12LMPDATFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("lmpdat", this, "chemical/x-lmpdat"); 38| 2| OBConversion::RegisterOptionParam("q", nullptr, 1, OBConversion::OUTOPTIONS); 39| 2| OBConversion::RegisterOptionParam("d", nullptr, 1, OBConversion::OUTOPTIONS); 40| 2| } _ZN9OpenBabel12LMPDATFormat5FlagsEv: 65| 2| { 66| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 67| 2| } _ZN9OpenBabel9MOLFormatC2Ev: 175| 2| { 176| 2| OBConversion::RegisterFormat("mol",this, "chemical/x-mdl-molfile"); 177| 2| OBConversion::RegisterFormat("mdl",this, "chemical/x-mdl-molfile"); 178| 2| OBConversion::RegisterOptionParam("2", this); 179| 2| OBConversion::RegisterOptionParam("3", this); 180| 2| } _ZN9OpenBabel8SDFormatC2Ev: 191| 2| { 192| 2| OBConversion::RegisterFormat("sd",this, "chemical/x-mdl-sdfile"); 193| 2| OBConversion::RegisterFormat("sdf",this, "chemical/x-mdl-sdfile"); 194| 2| } _ZN9OpenBabel9MDLFormat5FlagsEv: 118| 8| unsigned int Flags() override { return DEFAULTFORMAT | ZEROATOMSOK; } ------------------ | | 40| 8|#define DEFAULTFORMAT 0x4000 ------------------ unsigned int Flags() override { return DEFAULTFORMAT | ZEROATOMSOK; } ------------------ | | 34| 8|#define ZEROATOMSOK 0x08 ------------------ _ZN9OpenBabel11mmCIFFormatC2Ev: 41| 2| { // Copied from the Chemical MIME Page at http://www.ch.ic.ac.uk/chemime/ 42| 2| OBConversion::RegisterFormat("mcif", this, "chemical/x-mmcif"); 43| 2| OBConversion::RegisterFormat("mmcif", this, "chemical/x-mmcif"); 44| | // Uncomment the following line, and this file will handle all CIF formats 45| | // OBConversion::RegisterFormat("cif", this, "chemical/x-cif"); 46| | 47| 2| OBConversion::RegisterOptionParam("s", this); 48| 2| OBConversion::RegisterOptionParam("p", this); 49| 2| OBConversion::RegisterOptionParam("b", this); 50| 2| OBConversion::RegisterOptionParam("w", this); 51| 2| } _ZN9OpenBabel14MacroModFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("mmd",this, "chemical/x-macromodel-input"); 38| 2| OBConversion::RegisterFormat("mmod",this, "chemical/x-macromodel-input"); 39| 2| } _ZN9OpenBabel14MacroModFormat5FlagsEv: 57| 4| { 58| 4| return READONEONLY; ------------------ | | 32| 4|#define READONEONLY 0x02 ------------------ 59| 4| } _ZN9OpenBabel10MOL2FormatC2Ev: 41| 2| { 42| 2| OBConversion::RegisterFormat("mol2",this, "chemical/x-mol2"); 43| 2| OBConversion::RegisterFormat("ml2",this); 44| 2| OBConversion::RegisterFormat("sy2",this); 45| 2| OBConversion::RegisterOptionParam("c", this, 0, OBConversion::INOPTIONS); 46| 2| OBConversion::RegisterOptionParam("c", this, 0, OBConversion::OUTOPTIONS); 47| 2| OBConversion::RegisterOptionParam("l", this, 0, OBConversion::OUTOPTIONS); 48| 2| OBConversion::RegisterOptionParam("u", this, 0, OBConversion::OUTOPTIONS); 49| 2| } _ZN9OpenBabel14OBMoldenFormatC2Ev: 58| 2| { 59| 2| OBConversion::RegisterFormat( "molden", this ); 60| 2| OBConversion::RegisterFormat( "mold", this ); 61| 2| OBConversion::RegisterFormat( "molf", this ); 62| 2| } _ZN9OpenBabel14OBMoldenFormat5FlagsEv: 86| 6| { 87| 6| return READONEONLY | WRITEONEONLY ; ------------------ | | 32| 6|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY ; ------------------ | | 36| 6|#define WRITEONEONLY 0x20 ------------------ 88| 6| } _ZN9OpenBabel18MolproOutputFormatC2Ev: 40| 2| { 41| 2| OBConversion::RegisterFormat("mpo",this); 42| 2| } _ZN9OpenBabel17MolproInputFormatC2Ev: 76| 2| { 77| 2| OBConversion::RegisterFormat("mp",this); 78| 2| } _ZN9OpenBabel18MolproOutputFormat5FlagsEv: 59| 2| { 60| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 61| 2| } _ZN9OpenBabel17MolproInputFormat5FlagsEv: 93| 2| { 94| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 95| 2| } _ZN9OpenBabel15MolReportFormatC2Ev: 37| 2| { 38| 2| OBConversion::RegisterFormat("molreport",this); 39| 2| } _ZN9OpenBabel15MolReportFormat5FlagsEv: 81| 2| { 82| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 83| 2| } _ZN9OpenBabel11MOPACFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("mopout",this, "chemical/x-mopac-out"); 38| 2| OBConversion::RegisterFormat("moo",this, "chemical/x-mopac-out"); 39| 2| } _ZN9OpenBabel15MOPACCARTFormatC2Ev: 507| 2| { 508| 2| OBConversion::RegisterFormat("mopcrt",this, "chemical/x-mopac-input"); 509| 2| OBConversion::RegisterFormat("mop",this, "chemical/x-mopac-input"); 510| 2| OBConversion::RegisterFormat("mpc",this, "chemical/x-mopac-input"); 511| | // Command-line keywords 512| 2| OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS); 513| | // Command-line keyword file 514| 2| OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS); 515| 2| } _ZN9OpenBabel14MOPACINTFormatC2Ev: 839| 2| { 840| 2| OBConversion::RegisterFormat("mopin", this, "chemical/x-mopac-input"); 841| | // Command-line keywords 842| 2| OBConversion::RegisterOptionParam("k", nullptr, 1, OBConversion::OUTOPTIONS); 843| | // Command-line keyword file 844| 2| OBConversion::RegisterOptionParam("f", nullptr, 1, OBConversion::OUTOPTIONS); 845| 2| } _ZN9OpenBabel11MOPACFormat5FlagsEv: 51| 4| { 52| 4| return NOTWRITABLE; ------------------ | | 35| 4|#define NOTWRITABLE 0x10 ------------------ 53| 4| } _ZN9OpenBabel9MPDFormatC2Ev: 44| 2| { 45| 2| OBConversion::RegisterFormat("mpd",this); 46| 2| OBConversion::RegisterOptionParam("n", this); 47| 2| OBConversion::RegisterOptionParam("c", this); 48| 2| OBConversion::RegisterOptionParam("i", this); 49| 2| } _ZN9OpenBabel9MPDFormat5FlagsEv: 84| 2| { // NOTREADABLE READONEONLY NOTWRITABLE WRITEONEONLY 85| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 86| 2| } _ZN9OpenBabel10MPQCFormatC2Ev: 34| 2| { 35| 2| OBConversion::RegisterFormat("mpqc",this); 36| 2| } _ZN9OpenBabel15MPQCInputFormatC2Ev: 72| 2| { 73| 2| OBConversion::RegisterFormat("mpqcin",this); 74| 2| } _ZN9OpenBabel10MPQCFormat5FlagsEv: 53| 2| { 54| 2| return NOTWRITABLE | READONEONLY; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ return NOTWRITABLE | READONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ 55| 2| } _ZN9OpenBabel15MPQCInputFormat5FlagsEv: 89| 2| { 90| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 91| 2| } _ZN9OpenBabel9MSIFormatC2Ev: 34| 2| { 35| 2| OBConversion::RegisterFormat("msi", this, "chemical/x-msi-msi"); 36| 2| } _ZN9OpenBabel9MSIFormat5FlagsEv: 53| 2| { 54| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 55| 2| } _ZN9OpenBabel12OBMSMSFormatC2Ev: 55| 2| { 56| 2| OpenBabel::OBConversion::RegisterFormat( "msms", this ); 57| 2| } _ZN9OpenBabel12OBMSMSFormat5FlagsEv: 81| 2| { 82| 2| return WRITEONEONLY | NOTREADABLE; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ return WRITEONEONLY | NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 83| 2| } _ZN9OpenBabel9NulFormatC2Ev: 23| 2| NulFormat() { OBConversion::RegisterFormat("nul",this); } _ZN9OpenBabel9NulFormat5FlagsEv: 27| 2| unsigned int Flags() override { return NOTREADABLE; } ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ _ZN9OpenBabel18NWChemOutputFormatC2Ev: 43| 2| { 44| 2| OBConversion::RegisterFormat("nwo",this); 45| 2| } _ZN9OpenBabel17NWChemInputFormatC2Ev: 136| 2| { 137| 2| OBConversion::RegisterFormat("nw",this); 138| 2| } _ZN9OpenBabel18NWChemOutputFormat5FlagsEv: 66| 2| { 67| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 68| 2| } _ZN9OpenBabel17NWChemInputFormat5FlagsEv: 153| 2| { 154| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 155| 2| } _ZN9OpenBabel18OBOpenDXCubeFormatC2Ev: 45| 2| { 46| 2| OpenBabel::OBConversion::RegisterFormat( "dx", this ); 47| 2| } _ZN9OpenBabel18OBOpenDXCubeFormat5FlagsEv: 73| 2| { 74| 2| return READONEONLY | WRITEONEONLY | ZEROATOMSOK; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY | ZEROATOMSOK; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ return READONEONLY | WRITEONEONLY | ZEROATOMSOK; ------------------ | | 34| 2|#define ZEROATOMSOK 0x08 ------------------ 75| 2| } _ZN9OpenBabel12OutputFormatC2Ev: 37| 2| { 38| 2| OBConversion::RegisterFormat("out", this); 39| 2| OBConversion::RegisterFormat("output", this); 40| 2| OBConversion::RegisterFormat("log", this); 41| 2| OBConversion::RegisterFormat("dat", this); 42| 2| } _ZN9OpenBabel12OutputFormat5FlagsEv: 62| 8| { 63| 8| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 8|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 8|#define NOTWRITABLE 0x10 ------------------ 64| 8| } _ZN9OpenBabel13PCModelFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("pcm", this); 37| 2| } _ZN9OpenBabel9PDBFormatC2Ev: 42| 2| { 43| 2| OBConversion::RegisterFormat("pdb",this, "chemical/x-pdb"); 44| 2| OBConversion::RegisterFormat("ent",this, "chemical/x-pdb"); 45| | 46| 2| OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS); 47| 2| OBConversion::RegisterOptionParam("b", this, 0, OBConversion::INOPTIONS); 48| 2| OBConversion::RegisterOptionParam("c", this, 0, OBConversion::INOPTIONS); 49| | 50| 2| OBConversion::RegisterOptionParam("o", this, 0, OBConversion::OUTOPTIONS); 51| 2| OBConversion::RegisterOptionParam("n", this, 0, OBConversion::OUTOPTIONS); 52| 2| } _ZN9OpenBabel11PDBQTFormatC2Ev: 73| 2| { 74| 2| OBConversion::RegisterFormat("pdbqt",this, "chemical/x-pdbqt"); 75| 2| } _ZN9OpenBabel16PointCloudFormatC2Ev: 62| 2| { 63| 2| OpenBabel::OBConversion::RegisterFormat( "pointcloud", this ); 64| | /* 65| | OBConversion::RegisterOptionParam("r", this, 1, OBConversion::OUTOPTIONS); 66| | OBConversion::RegisterOptionParam("d", this, 1, OBConversion::OUTOPTIONS); 67| | OBConversion::RegisterOptionParam("p", this, 1, OBConversion::OUTOPTIONS); 68| | OBConversion::RegisterOptionParam("x", this, 1, OBConversion::OUTOPTIONS); 69| | */ 70| 2| } _ZN9OpenBabel16PointCloudFormat5FlagsEv: 108| 2| { 109| 2| return WRITEONEONLY | NOTREADABLE; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ return WRITEONEONLY | NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 110| 2| } _ZN9OpenBabel12PovrayFormatC2Ev: 105| 2| { 106| 2| OBConversion::RegisterFormat("pov",this); 107| 2| } _ZN9OpenBabel12PovrayFormat5FlagsEv: 151| 2| { 152| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 153| 2| } _ZN9OpenBabel9PQRFormatC2Ev: 41| 2| { 42| 2| OBConversion::RegisterFormat("pqr",this, "chemical/x-pqr"); 43| 2| } _ZN9OpenBabel11PWscfFormatC2Ev: 38| 2| { 39| 2| OBConversion::RegisterFormat("pwscf",this); 40| 2| } _ZN9OpenBabel11PWscfFormat5FlagsEv: 57| 2| { 58| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 59| 2| } _ZN9OpenBabel17QChemOutputFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("qcout",this); 38| 2| } _ZN9OpenBabel16QChemInputFormatC2Ev: 73| 2| { 74| 2| OBConversion::RegisterFormat("qcin",this); 75| 2| } _ZN9OpenBabel17QChemOutputFormat5FlagsEv: 55| 2| { 56| 2| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 2|#define NOTWRITABLE 0x10 ------------------ 57| 2| } _ZN9OpenBabel16QChemInputFormat5FlagsEv: 92| 2| { 93| 2| return WRITEONEONLY | NOTREADABLE; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ return WRITEONEONLY | NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 94| 2| } _ZN9OpenBabel12ReportFormatC2Ev: 40| 2| { 41| 2| OBConversion::RegisterFormat("report",this); 42| 2| } _ZN9OpenBabel12ReportFormat5FlagsEv: 174| 2| { 175| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 176| 2| } _ZN9OpenBabel14SmiReactFormatC2Ev: 36| 2| { 37| 2| OBConversion::RegisterFormat("rsmi",this); 38| 2| } _ZN9OpenBabel9RXNFormatC2Ev: 39| 2| { 40| 2| OBConversion::RegisterFormat("rxn",this); 41| 2| } _ZN9OpenBabel11ShelXFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("res",this, "chemical/x-shelx"); 37| 2| OBConversion::RegisterFormat("ins",this, "chemical/x-shelx"); 38| 2| } _ZN9OpenBabel11ShelXFormat5FlagsEv: 58| 4| { 59| 4| return NOTWRITABLE; ------------------ | | 35| 4|#define NOTWRITABLE 0x10 ------------------ 60| 4| } _ZN9OpenBabel13SMIBaseFormat12ReadMoleculeEPNS_6OBBaseEPNS_12OBConversionE: 348| 9.18k| { 349| 9.18k| OBMol* pmol = pOb->CastAndClear(); 350| | 351| 9.18k| istream &ifs = *pConv->GetInStream(); 352| 9.18k| string ln, smiles, title; 353| 9.18k| string::size_type pos; 354| | 355| | //Ignore lines that start with # 356| 10.2k| while(ifs && ifs.peek()=='#') ------------------ | Branch (356:11): [True: 10.2k, False: 0] | Branch (356:18): [True: 1.03k, False: 9.18k] ------------------ 357| 1.03k| if(!getline(ifs, ln)) ------------------ | Branch (357:10): [True: 0, False: 1.03k] ------------------ 358| 0| return false; 359| | 360| | //Get title 361| 9.18k| if(getline(ifs, ln)) ------------------ | Branch (361:8): [True: 9.16k, False: 23] ------------------ 362| 9.16k| { 363| 9.16k| pos = ln.find_first_of(" \t"); 364| 9.16k| if(pos!=string::npos) ------------------ | Branch (364:10): [True: 347, False: 8.81k] ------------------ 365| 347| { 366| 347| smiles = ln.substr(0,pos); 367| 347| title = ln.substr(pos+1); 368| 347| Trim(title); 369| 347| pmol->SetTitle(title.c_str()); 370| 347| } 371| 8.81k| else 372| 8.81k| smiles = ln; 373| 9.16k| } 374| | 375| 9.18k| pmol->SetDimension(0); 376| 9.18k| OBSmilesParser sp(pConv->IsOption("a", OBConversion::INOPTIONS)); 377| 9.18k| if (!pConv->IsOption("S", OBConversion::INOPTIONS)) ------------------ | Branch (377:9): [True: 9.18k, False: 0] ------------------ 378| 9.18k| pmol->SetChiralityPerceived(); 379| | 380| 9.18k| return sp.SmiToMol(*pmol, smiles); //normal return 381| 9.18k| } _ZN9OpenBabel14OBSmilesParser8SmiToMolERNS_5OBMolERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 386| 9.18k| { 387| 9.18k| _vprev.clear(); 388| 9.18k| _rclose.clear(); 389| 9.18k| _prev=0; 390| 9.18k| chiralWatch=false; 391| 9.18k| squarePlanarWatch = false; 392| | 393| | // We allow the empty reaction (">>") but not the empty molecule ("") 394| 9.18k| if (!ParseSmiles(mol, s) || (!mol.IsReaction() && mol.NumAtoms() == 0)) ------------------ | Branch (394:9): [True: 2.66k, False: 6.52k] | Branch (394:34): [True: 6.05k, False: 463] | Branch (394:55): [True: 152, False: 5.90k] ------------------ 395| 2.81k| { 396| 2.81k| mol.Clear(); 397| 2.81k| return(false); 398| 2.81k| } 399| | 400| | // TODO: Is the following a memory leak? - there are return statements above 401| 6.37k| map::iterator i; 402| 58.8k| for (i = _tetrahedralMap.begin(); i != _tetrahedralMap.end(); ++i) ------------------ | Branch (402:39): [True: 52.5k, False: 6.37k] ------------------ 403| 52.5k| delete i->second; 404| 6.37k| _tetrahedralMap.clear(); 405| | 406| 6.37k| map::iterator j; 407| 30.3k| for (j = _squarePlanarMap.begin(); j != _squarePlanarMap.end(); ++j) ------------------ | Branch (407:40): [True: 23.9k, False: 6.37k] ------------------ 408| 23.9k| delete j->second; 409| 6.37k| _squarePlanarMap.clear(); 410| | 411| 6.37k| mol.SetAutomaticFormalCharge(false); 412| | 413| 6.37k| return(true); 414| 9.18k| } _ZN9OpenBabel14OBSmilesParser11ParseSmilesERNS_5OBMolERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 417| 9.18k| { 418| 9.18k| mol.SetAromaticPerceived(); // Turn off perception until the end of this function 419| 9.18k| mol.BeginModify(); 420| | 421| 74.0M| for (_ptr=smiles.c_str();*_ptr;_ptr++) ------------------ | Branch (421:30): [True: 74.0M, False: 7.03k] ------------------ 422| 74.0M| { 423| 74.0M| switch(*_ptr) 424| 74.0M| { 425| 1| case '\r': ------------------ | Branch (425:7): [True: 1, False: 74.0M] ------------------ 426| 1| if (*(_ptr+1) == '\0') // may have a terminating '\r' due to Windows line-endings ------------------ | Branch (426:13): [True: 1, False: 0] ------------------ 427| 1| break; 428| 0| return false; 429| 167k| case '0': case '1': case '2': case '3': case '4': ------------------ | Branch (429:7): [True: 60.1k, False: 73.9M] | Branch (429:17): [True: 44.0k, False: 73.9M] | Branch (429:27): [True: 27.2k, False: 74.0M] | Branch (429:37): [True: 16.8k, False: 74.0M] | Branch (429:47): [True: 19.2k, False: 74.0M] ------------------ 430| 252k| case '5': case '6': case '7': case '8': case '9': ------------------ | Branch (430:7): [True: 13.0k, False: 74.0M] | Branch (430:17): [True: 37.0k, False: 73.9M] | Branch (430:27): [True: 14.8k, False: 74.0M] | Branch (430:37): [True: 16.0k, False: 74.0M] | Branch (430:47): [True: 4.22k, False: 74.0M] ------------------ 431| 253k| case '%': //ring open/close ------------------ | Branch (431:7): [True: 719, False: 74.0M] ------------------ 432| 253k| if (_prev == 0) ------------------ | Branch (432:13): [True: 15, False: 253k] ------------------ 433| 15| return false; 434| 253k| if (!ParseRingBond(mol)) ------------------ | Branch (434:13): [True: 146, False: 253k] ------------------ 435| 146| return false; 436| 253k| break; 437| 253k| case '&': //external bond ------------------ | Branch (437:7): [True: 69.1k, False: 73.9M] ------------------ 438| 69.1k| if (_prev == 0) ------------------ | Branch (438:13): [True: 1, False: 69.1k] ------------------ 439| 1| return false; 440| 69.1k| if (!ParseExternalBond(mol)) ------------------ | Branch (440:13): [True: 0, False: 69.1k] ------------------ 441| 0| return false; 442| 69.1k| break; 443| 69.1k| case '.': ------------------ | Branch (443:7): [True: 43.7k, False: 73.9M] ------------------ 444| 43.7k| _prev=0; 445| 43.7k| break; 446| 1.20k| case '>': ------------------ | Branch (446:7): [True: 1.20k, False: 74.0M] ------------------ 447| 1.20k| _prev = 0; 448| 1.20k| _rxnrole++; 449| 1.20k| if (_rxnrole == 2) { ------------------ | Branch (449:13): [True: 622, False: 579] ------------------ 450| 622| mol.SetIsReaction(); 451| | // Handle all the reactant atoms 452| | // - the remaining atoms will be handled on-the-fly 453| 2.29M| FOR_ATOMS_OF_MOL(atom, mol) { ------------------ | | 398| 2.30M|#define FOR_ATOMS_OF_MOL(a,m) for( OpenBabel::OBMolAtomIter a(m); a; ++a ) | | ------------------ | | | Branch (398:75): [True: 2.29M, False: 622] | | ------------------ ------------------ 454| 2.29M| OBPairInteger *pi = new OBPairInteger(); 455| 2.29M| pi->SetAttribute("rxnrole"); 456| 2.29M| pi->SetValue(1); 457| 2.29M| atom->SetData(pi); 458| 2.29M| } 459| 622| } 460| 579| else if (_rxnrole == 4) { ------------------ | Branch (460:18): [True: 49, False: 530] ------------------ 461| 49| stringstream errorMsg; 462| 49| errorMsg << "Too many greater-than signs in SMILES string"; 463| 49| std::string title = mol.GetTitle(); 464| 49| if (!title.empty()) ------------------ | Branch (464:15): [True: 46, False: 3] ------------------ 465| 46| errorMsg << " (title is " << title << ")"; 466| 49| errorMsg << endl; 467| 49| obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning); 468| 49| return false; 469| 49| } 470| 1.15k| break; 471| 737k| case '(': ------------------ | Branch (471:7): [True: 737k, False: 73.2M] ------------------ 472| 737k| _vprev.push_back(_prev); 473| 737k| break; 474| 693k| case ')': ------------------ | Branch (474:7): [True: 693k, False: 73.3M] ------------------ 475| 693k| if(_vprev.empty()) //CM ------------------ | Branch (475:12): [True: 7, False: 693k] ------------------ 476| 7| return false; 477| 693k| _prev = _vprev.back(); 478| 693k| _vprev.pop_back(); 479| 693k| break; 480| 165k| case '[': ------------------ | Branch (480:7): [True: 165k, False: 73.8M] ------------------ 481| 165k| if (!ParseComplex(mol)) ------------------ | Branch (481:13): [True: 1.73k, False: 163k] ------------------ 482| 1.73k| { 483| 1.73k| mol.EndModify(); 484| 1.73k| mol.Clear(); 485| 1.73k| return false; 486| 1.73k| } 487| 163k| break; 488| 163k| case '-': ------------------ | Branch (488:7): [True: 2.23k, False: 74.0M] ------------------ 489| 2.23k| if (_prev == 0) ------------------ | Branch (489:13): [True: 1, False: 2.23k] ------------------ 490| 1| return false; 491| 2.23k| _order = 1; 492| 2.23k| break; 493| 20.1k| case '=': ------------------ | Branch (493:7): [True: 20.1k, False: 74.0M] ------------------ 494| 20.1k| if (_prev == 0) ------------------ | Branch (494:13): [True: 2, False: 20.0k] ------------------ 495| 2| return false; 496| 20.0k| _order = 2; 497| 20.0k| break; 498| 22.1k| case '#': ------------------ | Branch (498:7): [True: 22.1k, False: 74.0M] ------------------ 499| 22.1k| if (_prev == 0) ------------------ | Branch (499:13): [True: 1, False: 22.1k] ------------------ 500| 1| return false; 501| 22.1k| _order = 3; 502| 22.1k| break; 503| 49.5k| case '$': ------------------ | Branch (503:7): [True: 49.5k, False: 73.9M] ------------------ 504| 49.5k| if (_prev == 0) ------------------ | Branch (504:13): [True: 1, False: 49.5k] ------------------ 505| 1| return false; 506| 49.5k| _order = 4; 507| 49.5k| break; 508| 14.8k| case ':': ------------------ | Branch (508:7): [True: 14.8k, False: 74.0M] ------------------ 509| 14.8k| if (_prev == 0) ------------------ | Branch (509:13): [True: 1, False: 14.8k] ------------------ 510| 1| return false; 511| 14.8k| _order = 0; // no-op 512| 14.8k| break; 513| 297k| case '/': ------------------ | Branch (513:7): [True: 297k, False: 73.7M] ------------------ 514| 297k| if (_prev == 0) ------------------ | Branch (514:13): [True: 1, False: 297k] ------------------ 515| 1| return false; 516| 297k| _order = 1; 517| 297k| _updown = BondDownChar; 518| 297k| break; 519| 21.5k| case '\\': ------------------ | Branch (519:7): [True: 21.5k, False: 74.0M] ------------------ 520| 21.5k| if (_prev == 0) ------------------ | Branch (520:13): [True: 3, False: 21.5k] ------------------ 521| 3| return false; 522| 21.5k| _order = 1; 523| 21.5k| _updown = BondUpChar; 524| 21.5k| break; 525| 71.6M| default: ------------------ | Branch (525:7): [True: 71.6M, False: 2.39M] ------------------ 526| 71.6M| if (!ParseSimple(mol)) ------------------ | Branch (526:13): [True: 195, False: 71.6M] ------------------ 527| 195| { 528| 195| mol.EndModify(); 529| 195| mol.Clear(); 530| 195| return false; 531| 195| } 532| 74.0M| } // end switch 533| 74.0M| } // end for _ptr 534| | 535| | // place dummy atoms for each unfilled external bond 536| 7.03k| if(!_extbond.empty()) ------------------ | Branch (536:8): [True: 104, False: 6.92k] ------------------ 537| 104| CapExternalBonds(mol); 538| | 539| | // Check to see if we've balanced out all ring closures 540| | // They are removed from _rclose when matched 541| 7.03k| if (!_rclose.empty()) { ------------------ | Branch (541:9): [True: 442, False: 6.59k] ------------------ 542| 442| mol.EndModify(); 543| 442| mol.Clear(); 544| | 545| 442| stringstream errorMsg; 546| 442| errorMsg << "Invalid SMILES string: " << _rclose.size() << " unmatched " 547| 442| << "ring bonds." << endl; 548| 442| obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning); 549| 442| return false; // invalid SMILES since rings aren't properly closed 550| 442| } 551| | 552| | // Check to see if we've the right number of '>' for reactions 553| 6.59k| if (_rxnrole > 1 && _rxnrole !=3) { ------------------ | Branch (553:9): [True: 532, False: 6.05k] | Branch (553:25): [True: 69, False: 463] ------------------ 554| 69| mol.EndModify(); 555| 69| stringstream errorMsg; 556| 69| errorMsg << "Invalid reaction SMILES string: only a single '>' sign found (two required to be valid)."; 557| 69| obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning); 558| 69| return false; // invalid SMILES since rings aren't properly closed 559| 69| } 560| 6.52k| if (mol.IsReaction()) { ------------------ | Branch (560:9): [True: 463, False: 6.05k] ------------------ 561| 463| OBReactionFacade facade(&mol); 562| 463| facade.AssignComponentIds(); 563| 463| } 564| | 565| | // Apply the SMILES valence model 566| 54.5M| FOR_ATOMS_OF_MOL(atom, mol) { ------------------ | | 398| 54.5M|#define FOR_ATOMS_OF_MOL(a,m) for( OpenBabel::OBMolAtomIter a(m); a; ++a ) | | ------------------ | | | Branch (398:75): [True: 54.5M, False: 6.52k] | | ------------------ ------------------ 567| 54.5M| unsigned int idx = atom->GetIdx(); 568| 54.5M| int hcount = _hcount[idx - 1]; 569| 54.5M| if (hcount == -1) { // Apply SMILES implicit valence model ------------------ | Branch (569:11): [True: 54.3M, False: 121k] ------------------ 570| 54.3M| unsigned int bosum = 0; 571| 108M| FOR_BONDS_OF_ATOM(bond, &(*atom)) { ------------------ | | 401| 163M|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 108M, False: 54.3M] | | ------------------ ------------------ 572| 108M| bosum += bond->GetBondOrder(); 573| 108M| } 574| 54.3M| unsigned int impval = SmilesValence(atom->GetAtomicNum(), bosum); 575| 54.3M| unsigned int imph = impval - bosum; 576| 54.3M| if (imph > 0 && atom->IsAromatic()) ------------------ | Branch (576:13): [True: 37.9M, False: 16.4M] | Branch (576:25): [True: 22.3M, False: 15.6M] ------------------ 577| 22.3M| imph--; 578| 54.3M| atom->SetImplicitHCount(imph); 579| 54.3M| } 580| 121k| else // valence is explicit e.g. [CH3] 581| 121k| atom->SetImplicitHCount(hcount); 582| 54.5M| } 583| | 584| 6.52k| mol.EndModify(false); 585| | 586| | // Unset any aromatic bonds that *are not* in rings where the two aromatic atoms *are* in a ring 587| | // This is rather subtle, but it's correct and reduces the burden of kekulization 588| 54.5M| FOR_BONDS_OF_MOL(bond, mol) { ------------------ | | 399| 54.5M|#define FOR_BONDS_OF_MOL(b,m) for( OpenBabel::OBMolBondIter b(m); b; ++b ) | | ------------------ | | | Branch (399:75): [True: 54.5M, False: 6.52k] | | ------------------ ------------------ 589| 54.5M| if (bond->IsAromatic() && !bond->IsInRing()) { ------------------ | Branch (589:11): [True: 22.4M, False: 32.1M] | Branch (589:33): [True: 21.5M, False: 852k] ------------------ 590| 21.5M| if (bond->GetBeginAtom()->IsInRing() && bond->GetEndAtom()->IsInRing()) ------------------ | Branch (590:13): [True: 125k, False: 21.4M] | Branch (590:49): [True: 6.34k, False: 118k] ------------------ 591| 6.34k| bond->SetAromatic(false); 592| 21.5M| } 593| 54.5M| } 594| | 595| | // TODO: Only Kekulize if the molecule has a lower case atom 596| 6.52k| bool ok = OBKekulize(&mol); 597| 6.52k| if (!ok) { ------------------ | Branch (597:9): [True: 4.70k, False: 1.81k] ------------------ 598| 4.70k| stringstream errorMsg; 599| 4.70k| errorMsg << "Failed to kekulize aromatic SMILES"; 600| 4.70k| std::string title = mol.GetTitle(); 601| 4.70k| if (!title.empty()) ------------------ | Branch (601:11): [True: 142, False: 4.56k] ------------------ 602| 142| errorMsg << " (title is " << title << ")"; 603| 4.70k| errorMsg << endl; 604| 4.70k| obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning); 605| | // return false; // Should we return false for a kekulization failure? 606| 4.70k| } 607| | 608| | // Add the data stored inside the _tetrahedralMap to the atoms now after end 609| | // modify so they don't get lost. 610| 6.52k| if(!_tetrahedralMap.empty()) { ------------------ | Branch (610:8): [True: 655, False: 5.86k] ------------------ 611| 655| OBAtom* atom; 612| 655| map::iterator ChiralSearch; 613| 53.1k| for(ChiralSearch = _tetrahedralMap.begin(); ChiralSearch != _tetrahedralMap.end(); ++ChiralSearch) { ------------------ | Branch (613:51): [True: 52.5k, False: 655] ------------------ 614| 52.5k| atom = ChiralSearch->first; 615| 52.5k| OBTetrahedralStereo::Config *ts = ChiralSearch->second; 616| 52.5k| if (!ts) ------------------ | Branch (616:13): [True: 0, False: 52.5k] ------------------ 617| 0| continue; 618| 52.5k| if (ts->refs.size() != 3) ------------------ | Branch (618:13): [True: 0, False: 52.5k] ------------------ 619| 0| continue; 620| 52.5k| if (ts->refs[2] == OBStereo::NoRef) { ------------------ | Branch (620:13): [True: 51.6k, False: 839] ------------------ 621| | // This happens where there is chiral lone pair or where there simply aren't enough connections 622| | // around a chiral atom. We handle the case where there is a S with a chiral lone pair. 623| | // All other cases are ignored, and raise a warning. (Note that S can be chiral even without 624| | // a lone pair, think of C[S@](=X)(=Y)Cl. 625| | 626| | // We have remembered where to insert the lone pair in the _chiralLonePair map 627| 51.6k| map::iterator m_it = _chiralLonePair.find(atom->GetIdx()); 628| 51.6k| if (CanHaveLonePair(atom->GetAtomicNum()) && m_it != _chiralLonePair.end()) { ------------------ | Branch (628:15): [True: 45.4k, False: 6.26k] | Branch (628:15): [True: 45.4k, False: 6.26k] | Branch (628:56): [True: 45.4k, False: 0] ------------------ 629| 45.4k| ts->refs[2] = ts->refs[1]; ts->refs[1] = ts->refs[0]; 630| 45.4k| if (m_it->second == 0) { // Insert in the 'from' position ------------------ | Branch (630:17): [True: 8.03k, False: 37.3k] ------------------ 631| 8.03k| ts->refs[0] = ts->from; 632| 8.03k| ts->from = OBStereo::ImplicitRef; 633| 8.03k| } 634| 37.3k| else // Insert in the refs[0] position 635| 37.3k| ts->refs[0] = OBStereo::ImplicitRef; 636| 45.4k| } 637| 6.26k| else { // Ignored by Open Babel 638| 6.26k| stringstream ss; 639| 6.26k| ss << "Ignoring stereochemistry. Not enough connections to this atom. " << mol.GetTitle(); 640| 6.26k| obErrorLog.ThrowError(__FUNCTION__, ss.str(), obWarning); 641| 6.26k| continue; 642| 6.26k| } 643| 51.6k| } 644| | 645| | // cout << "*ts = " << *ts << endl; 646| 46.2k| OBTetrahedralStereo *obts = new OBTetrahedralStereo(&mol); 647| 46.2k| obts->SetConfig(*ts); 648| 46.2k| mol.SetData(obts); 649| 46.2k| } 650| 655| } 651| | 652| | // Add the data stored inside the _squarePlanarMap to the atoms now after end 653| | // modify so they don't get lost. 654| 6.52k| if(!_squarePlanarMap.empty()) { ------------------ | Branch (654:8): [True: 391, False: 6.13k] ------------------ 655| 391| OBAtom* atom; 656| 391| map::iterator ChiralSearch; 657| 24.3k| for(ChiralSearch = _squarePlanarMap.begin(); ChiralSearch != _squarePlanarMap.end(); ++ChiralSearch) { ------------------ | Branch (657:52): [True: 23.9k, False: 391] ------------------ 658| 23.9k| atom = ChiralSearch->first; 659| 23.9k| OBSquarePlanarStereo::Config *sp = ChiralSearch->second; 660| 23.9k| if (!sp) ------------------ | Branch (660:13): [True: 0, False: 23.9k] ------------------ 661| 0| continue; 662| 23.9k| if (sp->refs.size() != 4) ------------------ | Branch (662:13): [True: 0, False: 23.9k] ------------------ 663| 0| continue; 664| | 665| | // cout << "*ts = " << *ts << endl; 666| 23.9k| OBSquarePlanarStereo *obsp = new OBSquarePlanarStereo(&mol); 667| 23.9k| obsp->SetConfig(*sp); 668| 23.9k| mol.SetData(obsp); 669| 23.9k| } 670| 391| } 671| | 672| 6.52k| if (!_preserve_aromaticity) ------------------ | Branch (672:9): [True: 6.52k, False: 0] ------------------ 673| 6.52k| mol.SetAromaticPerceived(false); 674| | 675| 6.52k| CreateCisTrans(mol); 676| | 677| 6.52k| return(true); 678| 6.59k| } _ZN9OpenBabel14OBSmilesParser4IsUpEPNS_6OBBondE: 681| 14.5M| { 682| 14.5M| map::iterator UpDownSearch; 683| 14.5M| UpDownSearch = _upDownMap.find(bond); 684| 14.5M| if (UpDownSearch != _upDownMap.end()) ------------------ | Branch (684:9): [True: 1.12M, False: 13.4M] ------------------ 685| 1.12M| if (UpDownSearch->second == BondUpChar) ------------------ | Branch (685:11): [True: 4.92k, False: 1.11M] ------------------ 686| 4.92k| return true; 687| 14.5M| return false; 688| 14.5M| } _ZN9OpenBabel14OBSmilesParser6IsDownEPNS_6OBBondE: 691| 14.0M| { 692| 14.0M| map::iterator UpDownSearch; 693| 14.0M| UpDownSearch = _upDownMap.find(bond); 694| 14.0M| if (UpDownSearch != _upDownMap.end()) ------------------ | Branch (694:9): [True: 560k, False: 13.4M] ------------------ 695| 560k| if (UpDownSearch->second == BondDownChar) ------------------ | Branch (695:11): [True: 560k, False: 0] ------------------ 696| 560k| return true; 697| 13.4M| return false; 698| 14.0M| } _ZN9OpenBabel14OBSmilesParser20SetRingClosureStereoENS0_14StereoRingBondEPNS_6OBBondE: 701| 6.69k| { 702| | // Ring Closure bonds appear twice (at opening and closure). 703| | // If involved in cis/trans stereo, then the stereo may be 704| | // specified at either end or indeed both. Although Open Babel 705| | // will only write out SMILES with the stereo at one end (the end 706| | // on the double bond), it must handle all cases when reading. 707| | 708| | // For example: 709| | // 710| | // C 711| | // /| 712| | // C = C | 713| | // / \| 714| | // C N 715| | // 716| | // Can be written as: 717| | // (a) C/C=C/1\NC1 -- preferred 718| | // (b) C/C=C1\NC\1 719| | // (c) C/C=C/1\NC\1 720| | // or indeed by replacing the "\N" with "N". 721| | 722| | // If the stereo chemistry for a ring closure is inconsistently specified, 723| | // it is ignored. In that case, if a stereo symbol does not exist for its 724| | // partner bond on the double bond (e.g. (b) below), then the stereo is unspecified. 725| | 726| | // (a) C/C=C/1NC\1 -- specified stereo 727| | // (b) C/C=C/1NC/1 -- ignore ring closure stereo => treated as C/C=C1NC1 => CC=C1NC1 728| | // (c) C/C=C/1\NC/1 -- ignore ring closure stereo => treated as C/C=C1\NC1 => C/C=C/1\NC1 729| | 730| | // The ring closure bond is either up or down with respect 731| | // to the double bond. Our task here is to figure out which it is, 732| | // based on the contents of _stereorbond. 733| | 734| 6.69k| bool found = false; // We have found the answer 735| 6.69k| bool updown = true; // The answer 736| | 737| 6.69k| if (rcstereo.updown[0] == BondUpChar || rcstereo.updown[0] == BondDownChar) { // Is there a stereo symbol at the opening? ------------------ | Branch (737:9): [True: 949, False: 5.74k] | Branch (737:45): [True: 3.01k, False: 2.72k] ------------------ 738| 3.96k| bool on_dbl_bond = (rcstereo.atoms[0] == dbl_bond->GetBeginAtom() || rcstereo.atoms[0] == dbl_bond->GetEndAtom()); ------------------ | Branch (738:27): [True: 1.13k, False: 2.82k] | Branch (738:76): [True: 1.10k, False: 1.72k] ------------------ 739| 3.96k| updown = (rcstereo.updown[0]==BondUpChar) ^ on_dbl_bond; 740| 3.96k| found = true; 741| 3.96k| } 742| 6.69k| if (rcstereo.updown[1] == BondUpChar || rcstereo.updown[1] == BondDownChar) { // Is there a stereo symbol at the closing? ------------------ | Branch (742:9): [True: 622, False: 6.07k] | Branch (742:45): [True: 3.87k, False: 2.20k] ------------------ 743| 4.49k| bool on_dbl_bond = (rcstereo.atoms[1] == dbl_bond->GetBeginAtom() || rcstereo.atoms[1] == dbl_bond->GetEndAtom()); ------------------ | Branch (743:27): [True: 1.12k, False: 3.37k] | Branch (743:76): [True: 915, False: 2.45k] ------------------ 744| 4.49k| bool new_updown = (rcstereo.updown[1]==BondUpChar) ^ on_dbl_bond; 745| 4.49k| if (!found) { ------------------ | Branch (745:11): [True: 2.42k, False: 2.06k] ------------------ 746| 2.42k| updown = new_updown; 747| 2.42k| found = true; 748| 2.42k| } 749| 2.06k| else if (new_updown != updown) { ------------------ | Branch (749:16): [True: 1.48k, False: 584] ------------------ 750| 1.48k| obErrorLog.ThrowError(__FUNCTION__, "Ignoring the cis/trans stereochemistry specified for the ring closure\n as it is inconsistent.", obWarning); 751| 1.48k| found = false; 752| 1.48k| } 753| 4.49k| } 754| | 755| 6.69k| if (!found) ------------------ | Branch (755:9): [True: 1.78k, False: 4.91k] ------------------ 756| 1.78k| return 0; 757| 4.91k| else 758| 4.91k| return updown ? 1 : 2; ------------------ | Branch (758:14): [True: 2.10k, False: 2.80k] ------------------ 759| 6.69k| } _ZN9OpenBabel14OBSmilesParser14CreateCisTransERNS_5OBMolE: 762| 6.52k| { 763| | // Create a vector of CisTransStereo objects for the molecule 764| 54.5M| FOR_BONDS_OF_MOL(dbi, mol) { ------------------ | | 399| 54.5M|#define FOR_BONDS_OF_MOL(b,m) for( OpenBabel::OBMolBondIter b(m); b; ++b ) | | ------------------ | | | Branch (399:75): [True: 54.5M, False: 6.52k] | | ------------------ ------------------ 765| | 766| 54.5M| OBBond *dbl_bond = &(*dbi); 767| | 768| | // Not a double bond? 769| 54.5M| if (dbl_bond->GetBondOrder()!=2 || dbl_bond->IsAromatic()) ------------------ | Branch (769:11): [True: 47.5M, False: 7.02M] | Branch (769:42): [True: 802, False: 7.02M] ------------------ 770| 47.5M| continue; 771| | 772| | // Find the single bonds around the atoms connected by the double bond. 773| | 774| 7.02M| OBAtom *a1 = dbl_bond->GetBeginAtom(); 775| 7.02M| OBAtom *a2 = dbl_bond->GetEndAtom(); 776| | 777| | // Check that both atoms on the double bond have at least one 778| | // other neighbor, but not more than two other neighbors; 779| | // Note: In theory, we could relax the second requirement but we would 780| | // need to change the data structure we use to store cis/trans 781| | // stereo to only store 2 refs instead of 4 782| 7.02M| int v1 = a1->GetExplicitDegree(); 783| 7.02M| int v2 = a2->GetExplicitDegree(); 784| 7.02M| if (v1 < 2 || v1 > 3 || v2 < 2 || v2 > 3) { ------------------ | Branch (784:11): [True: 10.2k, False: 7.01M] | Branch (784:21): [True: 16.1k, False: 6.99M] | Branch (784:31): [True: 13.6k, False: 6.98M] | Branch (784:41): [True: 3.75k, False: 6.97M] ------------------ 785| 43.7k| continue; 786| 43.7k| } 787| | 788| 6.97M| vector dbl_bond_atoms; 789| 6.97M| dbl_bond_atoms.push_back(a1); 790| 6.97M| dbl_bond_atoms.push_back(a2); 791| | 792| 6.97M| vector bond_stereo(2, true); // Store the stereo of the chosen bonds at each end of the dbl bond 793| 6.97M| vector stereo_bond(2, nullptr); // These are the chosen stereo bonds 794| 6.97M| vector other_bond(2, nullptr); // These are the 'other' bonds at each end 795| | 796| 20.9M| for (int i = 0; i < 2; ++i) { // Loop over each end of the double bond in turn ------------------ | Branch (796:23): [True: 13.9M, False: 6.97M] ------------------ 797| | 798| 27.9M| FOR_BONDS_OF_ATOM(bi, dbl_bond_atoms[i]) { ------------------ | | 401| 41.9M|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 27.9M, False: 13.9M] | | ------------------ ------------------ 799| 27.9M| OBBond *b = &(*bi); 800| 27.9M| if (b == dbl_bond) continue; ------------------ | Branch (800:15): [True: 13.9M, False: 14.0M] ------------------ 801| 14.0M| if (!(IsUp(b) || IsDown(b))) { ------------------ | Branch (801:17): [True: 3.17k, False: 14.0M] | Branch (801:28): [True: 560k, False: 13.4M] ------------------ 802| 13.4M| other_bond[i] = b; // Use this for the 'other' bond 803| 13.4M| continue; 804| 13.4M| } 805| | 806| 563k| bool found = true; 807| 563k| bool stereo; 808| 563k| map::iterator sb_it = _stereorbond.find(b); 809| 563k| if (sb_it == _stereorbond.end()) // Not a ring closure ------------------ | Branch (809:15): [True: 556k, False: 6.69k] ------------------ 810| | // True/False for "up/down if moved to before the double bond C" 811| 556k| stereo = !(IsUp(b) ^ (b->GetNbrAtomIdx(dbl_bond_atoms[i]) < dbl_bond_atoms[i]->GetIdx())) ; 812| 6.69k| else { // Is a ring closure 813| 6.69k| char bc_result = SetRingClosureStereo(sb_it->second, dbl_bond); 814| 6.69k| if (bc_result) ------------------ | Branch (814:17): [True: 4.91k, False: 1.78k] ------------------ 815| 4.91k| stereo = bc_result == 1 ? true : false; ------------------ | Branch (815:24): [True: 2.10k, False: 2.80k] ------------------ 816| 1.78k| else 817| 1.78k| found = false; 818| 6.69k| } 819| | 820| 563k| if (!found) { // This cannot be used as the stereo bond ------------------ | Branch (820:15): [True: 1.78k, False: 561k] ------------------ 821| 1.78k| other_bond[i] = b; // Use this for the 'other' bond 822| 1.78k| continue; 823| 1.78k| } 824| | 825| 561k| if (stereo_bond[i] == nullptr) { // This is a first stereo bond ------------------ | Branch (825:15): [True: 560k, False: 1.61k] ------------------ 826| 560k| stereo_bond[i] = b; // Use this for the 'stereo' bond 827| 560k| bond_stereo[i] = stereo; 828| 560k| } 829| 1.61k| else { // This is a second stereo bond 830| 1.61k| if (stereo != bond_stereo[i]) { // Verify that the other stereo bond (on the same atom) has opposite stereo ------------------ | Branch (830:17): [True: 1.17k, False: 437] ------------------ 831| 1.17k| other_bond[i] = b; // Use this for the 'other' bond 832| 1.17k| } 833| 437| else { 834| 437| obErrorLog.ThrowError(__FUNCTION__, "Error in cis/trans stereochemistry specified for the double bond\n", obWarning); 835| 437| stereo_bond[i] = nullptr; 836| 437| } 837| 1.61k| } 838| 561k| } 839| 13.9M| } 840| | 841| 6.97M| if (stereo_bond[0] == nullptr || stereo_bond[1] == nullptr) continue; // No cis/trans ------------------ | Branch (841:11): [True: 6.69M, False: 279k] | Branch (841:40): [True: 2.23k, False: 277k] ------------------ 842| | 843| | // other_bond will contain NULLs if there are bonds to implicit hydrogens 844| 277k| unsigned int second = (other_bond[0] == nullptr) ? OBStereo::ImplicitRef : other_bond[0]->GetNbrAtom(a1)->GetId(); ------------------ | Branch (844:29): [True: 273k, False: 4.09k] ------------------ 845| 277k| unsigned int fourth = (other_bond[1] == nullptr) ? OBStereo::ImplicitRef : other_bond[1]->GetNbrAtom(a2)->GetId(); ------------------ | Branch (845:29): [True: 274k, False: 2.84k] ------------------ 846| | 847| | 848| 277k| OBCisTransStereo *ct = new OBCisTransStereo(&mol); 849| 277k| OBCisTransStereo::Config cfg; 850| 277k| cfg.begin = a1->GetId(); 851| 277k| cfg.end = a2->GetId(); 852| | 853| | // If bond_stereo[0]==bond_stereo[1], this means cis for stereo_bond[0] and stereo_bond[1]. 854| 277k| if (bond_stereo[0] == bond_stereo[1]) ------------------ | Branch (854:11): [True: 2.62k, False: 274k] ------------------ 855| 2.62k| cfg.refs = OBStereo::MakeRefs(stereo_bond[0]->GetNbrAtom(a1)->GetId(), second, 856| 2.62k| fourth, stereo_bond[1]->GetNbrAtom(a2)->GetId()); 857| 274k| else 858| 274k| cfg.refs = OBStereo::MakeRefs(stereo_bond[0]->GetNbrAtom(a1)->GetId(), second, 859| 274k| stereo_bond[1]->GetNbrAtom(a2)->GetId(), fourth); 860| 277k| ct->SetConfig(cfg); 861| | // add the data to the atom 862| 277k| mol.SetData(ct); 863| 277k| } 864| 6.52k| } _ZN9OpenBabel14OBSmilesParser20InsertTetrahedralRefERNS_5OBMolEm: 867| 71.9M| { 868| 71.9M| map::iterator ChiralSearch; 869| 71.9M| ChiralSearch = _tetrahedralMap.find(mol.GetAtom(_prev)); 870| 71.9M| if (ChiralSearch != _tetrahedralMap.end() && ChiralSearch->second != nullptr) ------------------ | Branch (870:9): [True: 159k, False: 71.7M] | Branch (870:9): [True: 159k, False: 71.7M] | Branch (870:50): [True: 159k, False: 0] ------------------ 871| 159k| { 872| 159k| int insertpos = NumConnections(ChiralSearch->first, id == OBStereo::ImplicitRef) - 2; // -1 indicates "from" 873| 159k| if (insertpos > 2) ------------------ | Branch (873:11): [True: 80.6k, False: 79.0k] ------------------ 874| 80.6k| return; 875| 79.0k| if (insertpos < 0) { ------------------ | Branch (875:11): [True: 10.8k, False: 68.2k] ------------------ 876| 10.8k| if (ChiralSearch->second->from != OBStereo::NoRef) ------------------ | Branch (876:13): [True: 3.42k, False: 7.38k] ------------------ 877| 3.42k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Overwriting previous from reference id.", obWarning); 878| | 879| 10.8k| (ChiralSearch->second)->from = id; 880| | // cerr << "Adding " << id << " at Config.from to " << ChiralSearch->second << endl; 881| 68.2k| } else { 882| 68.2k| if (ChiralSearch->second->refs[insertpos] != OBStereo::NoRef) ------------------ | Branch (882:13): [True: 6.17k, False: 62.0k] ------------------ 883| 6.17k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Overwriting previously set reference id.", obWarning); 884| | 885| 68.2k| (ChiralSearch->second)->refs[insertpos] = id; 886| | // cerr << "Adding " << id << " at " << insertpos << " to " << ChiralSearch->second << endl; 887| 68.2k| } 888| 79.0k| } 889| 71.9M| } _ZN9OpenBabel14OBSmilesParser21InsertSquarePlanarRefERNS_5OBMolEm: 892| 71.9M| { 893| 71.9M| map::iterator ChiralSearch; 894| 71.9M| ChiralSearch = _squarePlanarMap.find(mol.GetAtom(_prev)); 895| 71.9M| if (ChiralSearch != _squarePlanarMap.end() && ChiralSearch->second != nullptr) ------------------ | Branch (895:9): [True: 108k, False: 71.8M] | Branch (895:9): [True: 108k, False: 71.8M] | Branch (895:51): [True: 108k, False: 0] ------------------ 896| 108k| { 897| 108k| int insertpos = NumConnections(ChiralSearch->first) - 1; 898| 108k| switch(insertpos) { 899| 10.9k| case -1: ------------------ | Branch (899:7): [True: 10.9k, False: 97.7k] ------------------ 900| 10.9k| if (ChiralSearch->second->refs[0] != OBStereo::NoRef) ------------------ | Branch (900:13): [True: 9.18k, False: 1.74k] ------------------ 901| 9.18k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Overwriting previous from reference id.", obWarning); 902| 10.9k| (ChiralSearch->second)->refs[0] = id; 903| 10.9k| break; 904| 31.7k| case 0: case 1: case 2: case 3: ------------------ | Branch (904:7): [True: 3.66k, False: 105k] | Branch (904:15): [True: 25.8k, False: 82.7k] | Branch (904:23): [True: 1.39k, False: 107k] | Branch (904:31): [True: 862, False: 107k] ------------------ 905| 31.7k| if (ChiralSearch->second->refs[insertpos] != OBStereo::NoRef) ------------------ | Branch (905:13): [True: 5.12k, False: 26.6k] ------------------ 906| 5.12k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Overwriting previously set reference id.", obWarning); 907| 31.7k| (ChiralSearch->second)->refs[insertpos] = id; 908| 31.7k| break; 909| 65.9k| default: ------------------ | Branch (909:7): [True: 65.9k, False: 42.7k] ------------------ 910| 65.9k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Square planar stereo specified for atom with more than 4 connections.", obWarning); 911| 65.9k| break; 912| 108k| } 913| 108k| } 914| 71.9M| } _ZN9OpenBabel14OBSmilesParser11ParseSimpleERNS_5OBMolE: 917| 71.6M| { 918| 71.6M| int element; 919| 71.6M| bool arom=false; 920| | 921| 71.6M| switch(*_ptr) 922| 71.6M| { 923| 12.9M| case '*': ------------------ | Branch (923:7): [True: 12.9M, False: 58.6M] ------------------ 924| 12.9M| element = 0; 925| 12.9M| arom = false; 926| 12.9M| break; 927| | 928| 14.5k| case 'C': ------------------ | Branch (928:7): [True: 14.5k, False: 71.6M] ------------------ 929| 14.5k| _ptr++; 930| 14.5k| if (*_ptr == 'l') ------------------ | Branch (930:13): [True: 202, False: 14.3k] ------------------ 931| 202| { 932| 202| element = 17; 933| 202| } 934| 14.3k| else 935| 14.3k| { 936| 14.3k| element = 6; 937| 14.3k| _ptr--; 938| 14.3k| } 939| 14.5k| break; 940| | 941| 16.1M| case 'N': ------------------ | Branch (941:7): [True: 16.1M, False: 55.4M] ------------------ 942| 16.1M| element = 7; 943| 16.1M| break; 944| 180k| case 'O': ------------------ | Branch (944:7): [True: 180k, False: 71.4M] ------------------ 945| 180k| element = 8; 946| 180k| break; 947| 123k| case 'S': ------------------ | Branch (947:7): [True: 123k, False: 71.5M] ------------------ 948| 123k| element = 16; 949| 123k| break; 950| 113k| case 'P': ------------------ | Branch (950:7): [True: 113k, False: 71.5M] ------------------ 951| 113k| element = 15; 952| 113k| break; 953| 134k| case 'F': ------------------ | Branch (953:7): [True: 134k, False: 71.5M] ------------------ 954| 134k| element = 9; 955| 134k| break; 956| 9.48k| case 'I': ------------------ | Branch (956:7): [True: 9.48k, False: 71.6M] ------------------ 957| 9.48k| element = 53; 958| 9.48k| break; 959| | 960| 11.9k| case 'B': ------------------ | Branch (960:7): [True: 11.9k, False: 71.6M] ------------------ 961| 11.9k| _ptr++; 962| 11.9k| if (*_ptr == 'r') ------------------ | Branch (962:13): [True: 195, False: 11.7k] ------------------ 963| 195| { 964| 195| element = 35; 965| 195| } 966| 11.7k| else 967| 11.7k| { 968| 11.7k| element = 5; 969| 11.7k| _ptr--; 970| 11.7k| } 971| 11.9k| break; 972| | 973| | // aromatics 974| 12.3M| case 'b': ------------------ | Branch (974:7): [True: 12.3M, False: 59.2M] ------------------ 975| 12.3M| arom = true; 976| 12.3M| element = 5; 977| 12.3M| break; 978| 370k| case 'c': ------------------ | Branch (978:7): [True: 370k, False: 71.2M] ------------------ 979| 370k| arom = true; 980| 370k| element = 6; 981| 370k| break; 982| 11.9M| case 'n': ------------------ | Branch (982:7): [True: 11.9M, False: 59.6M] ------------------ 983| 11.9M| arom = true; 984| 11.9M| element = 7; 985| 11.9M| break; 986| 9.54M| case 'o': ------------------ | Branch (986:7): [True: 9.54M, False: 62.1M] ------------------ 987| 9.54M| arom = true; 988| 9.54M| element = 8; 989| 9.54M| break; 990| 6.72M| case 'p': ------------------ | Branch (990:7): [True: 6.72M, False: 64.9M] ------------------ 991| 6.72M| arom = true; 992| 6.72M| element = 15; 993| 6.72M| break; 994| 903k| case 's': ------------------ | Branch (994:7): [True: 903k, False: 70.7M] ------------------ 995| 903k| arom = true; 996| 903k| element = 16; 997| 903k| break; 998| 195| default: ------------------ | Branch (998:7): [True: 195, False: 71.6M] ------------------ 999| 195| { 1000| 195| std::string err; 1001| 195| err += "SMILES string contains a character '"; 1002| 195| err += *_ptr; 1003| 195| err += "' which is invalid"; 1004| 195| obErrorLog.ThrowError(__FUNCTION__, 1005| 195| err, obError); 1006| 195| return false; 1007| 0| } 1008| 71.6M| } 1009| | 1010| 71.6M| OBAtom *atom = mol.NewAtom(); 1011| 71.6M| atom->SetAtomicNum(element); 1012| 71.6M| if (_rxnrole > 1) { // Quick test for reaction ------------------ | Branch (1012:9): [True: 2.65M, False: 68.9M] ------------------ 1013| | // Set reaction role 1014| 2.65M| OBPairInteger *pi = new OBPairInteger(); 1015| 2.65M| pi->SetAttribute("rxnrole"); 1016| 2.65M| pi->SetValue(_rxnrole); 1017| 2.65M| atom->SetData(pi); 1018| 2.65M| } 1019| | 1020| 71.6M| if (arom) ------------------ | Branch (1020:9): [True: 41.8M, False: 29.7M] ------------------ 1021| 41.8M| atom->SetAromatic(); 1022| | 1023| 71.6M| if (_prev) //need to add bond ------------------ | Branch (1023:9): [True: 71.6M, False: 30.6k] ------------------ 1024| 71.6M| { 1025| 71.6M| OBAtom* prevatom = mol.GetAtom(_prev); 1026| 71.6M| assert(prevatom); 1027| 71.6M| if (arom && prevatom->IsAromatic() && _order == 0) ------------------ | Branch (1027:13): [True: 41.8M, False: 29.7M] | Branch (1027:21): [True: 28.8M, False: 13.0M] | Branch (1027:47): [True: 28.5M, False: 308k] ------------------ 1028| 28.5M| mol.AddBond(_prev, mol.NumAtoms(), 1, OB_AROMATIC_BOND); // this will be kekulized later ------------------ | | 41| 28.5M|#define OB_AROMATIC_BOND (1<<1) ------------------ 1029| 43.0M| else 1030| 43.0M| mol.AddBond(_prev, mol.NumAtoms(), _order == 0 ? 1 : _order); ------------------ | Branch (1030:46): [True: 42.7M, False: 335k] ------------------ 1031| | // store up/down 1032| 71.6M| if (_updown == BondUpChar || _updown == BondDownChar) ------------------ | Branch (1032:13): [True: 6.27k, False: 71.6M] | Branch (1032:38): [True: 289k, False: 71.3M] ------------------ 1033| 295k| _upDownMap[mol.GetBond(_prev, mol.NumAtoms())] = _updown; 1034| | 1035| 71.6M| InsertTetrahedralRef(mol, mol.NumAtoms() - 1); 1036| 71.6M| InsertSquarePlanarRef(mol, mol.NumAtoms() - 1); 1037| 71.6M| } 1038| | 1039| | //set values 1040| 71.6M| _prev = mol.NumAtoms(); 1041| 71.6M| _order = 0; // the default is that no bond symbol has been seen 1042| 71.6M| _updown = ' '; 1043| | 1044| 71.6M| _hcount.push_back(-1); // implicit hydrogen count 1045| | 1046| 71.6M| return(true); 1047| 71.6M| } _ZN9OpenBabel14OBSmilesParser12ParseComplexERNS_5OBMolE: 1050| 165k| { 1051| 165k| int element=0; 1052| 165k| bool arom=false; 1053| | 1054| 165k| _ptr++; 1055| | 1056| | // Parse isotope information 1057| | // - we parse anything with 1 to 4 digits 1058| | // - any bigger and we risk overflowing the short int used to 1059| | // store the isotope information (max 65536) 1060| 165k| int isotope = 0; 1061| 165k| unsigned int size = 0; 1062| 167k| for (;*_ptr && isdigit(*_ptr) && size < 5;_ptr++) { ------------------ | Branch (1062:11): [True: 167k, False: 50] | Branch (1062:20): [True: 2.39k, False: 165k] | Branch (1062:38): [True: 2.39k, False: 2] ------------------ 1063| 2.39k| isotope *= 10; 1064| 2.39k| isotope += *_ptr - '0'; 1065| 2.39k| size++; 1066| 2.39k| } 1067| 165k| if (size == 5) ------------------ | Branch (1067:9): [True: 9, False: 165k] ------------------ 1068| 9| return false; 1069| | 1070| | //parse element data 1071| 165k| switch(*_ptr) 1072| 165k| { 1073| 1.78k| case '*': ------------------ | Branch (1073:7): [True: 1.78k, False: 163k] ------------------ 1074| 1.78k| element = 0; 1075| 1.78k| break; 1076| | 1077| 12.8k| case 'C': ------------------ | Branch (1077:7): [True: 12.8k, False: 152k] ------------------ 1078| 12.8k| _ptr++; 1079| 12.8k| switch(*_ptr) 1080| 12.8k| { 1081| 222| case 'a': ------------------ | Branch (1081:11): [True: 222, False: 12.6k] ------------------ 1082| 222| element = 20; 1083| 222| break; 1084| 196| case 'd': ------------------ | Branch (1084:11): [True: 196, False: 12.6k] ------------------ 1085| 196| element = 48; 1086| 196| break; 1087| 196| case 'e': ------------------ | Branch (1087:11): [True: 196, False: 12.6k] ------------------ 1088| 196| element = 58; 1089| 196| break; 1090| 196| case 'f': ------------------ | Branch (1090:11): [True: 196, False: 12.6k] ------------------ 1091| 196| element = 98; 1092| 196| break; 1093| 205| case 'l': ------------------ | Branch (1093:11): [True: 205, False: 12.6k] ------------------ 1094| 205| element = 17; 1095| 205| break; 1096| 9.24k| case 'm': ------------------ | Branch (1096:11): [True: 9.24k, False: 3.58k] ------------------ 1097| 9.24k| element = 96; 1098| 9.24k| break; 1099| 198| case 'n': ------------------ | Branch (1099:11): [True: 198, False: 12.6k] ------------------ 1100| 198| element = 112; 1101| 198| break; 1102| 194| case 'o': ------------------ | Branch (1102:11): [True: 194, False: 12.6k] ------------------ 1103| 194| element = 27; 1104| 194| break; 1105| 22| case 'r': ------------------ | Branch (1105:11): [True: 22, False: 12.8k] ------------------ 1106| 22| element = 24; 1107| 22| break; 1108| 66| case 's': ------------------ | Branch (1108:11): [True: 66, False: 12.7k] ------------------ 1109| 66| element = 55; 1110| 66| break; 1111| 742| case 'u': ------------------ | Branch (1111:11): [True: 742, False: 12.0k] ------------------ 1112| 742| element = 29; 1113| 742| break; 1114| 1.34k| default: ------------------ | Branch (1114:11): [True: 1.34k, False: 11.4k] ------------------ 1115| 1.34k| element = 6; 1116| 1.34k| _ptr--; 1117| 12.8k| } 1118| 12.8k| break; 1119| | 1120| 12.8k| case 'N': ------------------ | Branch (1120:7): [True: 2.41k, False: 162k] ------------------ 1121| 2.41k| _ptr++; 1122| 2.41k| switch(*_ptr) 1123| 2.41k| { 1124| 195| case 'a': ------------------ | Branch (1124:11): [True: 195, False: 2.22k] ------------------ 1125| 195| element = 11; 1126| 195| break; 1127| 194| case 'b': ------------------ | Branch (1127:11): [True: 194, False: 2.22k] ------------------ 1128| 194| element = 41; 1129| 194| break; 1130| 68| case 'd': ------------------ | Branch (1130:11): [True: 68, False: 2.34k] ------------------ 1131| 68| element = 60; 1132| 68| break; 1133| 194| case 'e': ------------------ | Branch (1133:11): [True: 194, False: 2.22k] ------------------ 1134| 194| element = 10; 1135| 194| break; 1136| 194| case 'h': ------------------ | Branch (1136:11): [True: 194, False: 2.22k] ------------------ 1137| 194| element = 113; 1138| 194| break; 1139| 195| case 'i': ------------------ | Branch (1139:11): [True: 195, False: 2.22k] ------------------ 1140| 195| element = 28; 1141| 195| break; 1142| 194| case 'o': ------------------ | Branch (1142:11): [True: 194, False: 2.22k] ------------------ 1143| 194| element = 102; 1144| 194| break; 1145| 195| case 'p': ------------------ | Branch (1145:11): [True: 195, False: 2.22k] ------------------ 1146| 195| element = 93; 1147| 195| break; 1148| 987| default: ------------------ | Branch (1148:11): [True: 987, False: 1.42k] ------------------ 1149| 987| element = 7; 1150| 987| _ptr--; 1151| 2.41k| } 1152| 2.41k| break; 1153| | 1154| 2.41k| case 'O': ------------------ | Branch (1154:7): [True: 1.35k, False: 163k] ------------------ 1155| 1.35k| _ptr++; 1156| 1.35k| switch(*_ptr) { 1157| 209| case 'g': ------------------ | Branch (1157:9): [True: 209, False: 1.14k] ------------------ 1158| 209| element = 118; 1159| 209| break; 1160| 197| case 's': ------------------ | Branch (1160:9): [True: 197, False: 1.15k] ------------------ 1161| 197| element = 76; 1162| 197| break; 1163| 945| default: ------------------ | Branch (1163:9): [True: 945, False: 406] ------------------ 1164| 945| element = 8; 1165| 945| _ptr--; 1166| 1.35k| } 1167| 1.35k| break; 1168| | 1169| 18.6k| case 'P': ------------------ | Branch (1169:7): [True: 18.6k, False: 146k] ------------------ 1170| 18.6k| _ptr++; 1171| 18.6k| switch(*_ptr) 1172| 18.6k| { 1173| 218| case 'a': ------------------ | Branch (1173:11): [True: 218, False: 18.4k] ------------------ 1174| 218| element = 91; 1175| 218| break; 1176| 194| case 'b': ------------------ | Branch (1176:11): [True: 194, False: 18.4k] ------------------ 1177| 194| element = 82; 1178| 194| break; 1179| 193| case 'd': ------------------ | Branch (1179:11): [True: 193, False: 18.4k] ------------------ 1180| 193| element = 46; 1181| 193| break; 1182| 194| case 'm': ------------------ | Branch (1182:11): [True: 194, False: 18.4k] ------------------ 1183| 194| element = 61; 1184| 194| break; 1185| 203| case 'o': ------------------ | Branch (1185:11): [True: 203, False: 18.4k] ------------------ 1186| 203| element = 84; 1187| 203| break; 1188| 213| case 'r': ------------------ | Branch (1188:11): [True: 213, False: 18.4k] ------------------ 1189| 213| element = 59; 1190| 213| break; 1191| 259| case 't': ------------------ | Branch (1191:11): [True: 259, False: 18.3k] ------------------ 1192| 259| element = 78; 1193| 259| break; 1194| 200| case 'u': ------------------ | Branch (1194:11): [True: 200, False: 18.4k] ------------------ 1195| 200| element = 94; 1196| 200| break; 1197| 16.9k| default: ------------------ | Branch (1197:11): [True: 16.9k, False: 1.67k] ------------------ 1198| 16.9k| element = 15; 1199| 16.9k| _ptr--; 1200| 18.6k| } 1201| 18.6k| break; 1202| | 1203| 18.6k| case('S'): ------------------ | Branch (1203:7): [True: 3.19k, False: 162k] ------------------ 1204| 3.19k| _ptr++; 1205| 3.19k| switch(*_ptr) 1206| 3.19k| { 1207| 165| case 'b': ------------------ | Branch (1207:11): [True: 165, False: 3.03k] ------------------ 1208| 165| element = 51; 1209| 165| break; 1210| 194| case 'c': ------------------ | Branch (1210:11): [True: 194, False: 3.00k] ------------------ 1211| 194| element = 21; 1212| 194| break; 1213| 225| case 'e': ------------------ | Branch (1213:11): [True: 225, False: 2.97k] ------------------ 1214| 225| element = 34; 1215| 225| break; 1216| 200| case 'g': ------------------ | Branch (1216:11): [True: 200, False: 2.99k] ------------------ 1217| 200| element = 106; 1218| 200| break; 1219| 195| case 'i': ------------------ | Branch (1219:11): [True: 195, False: 3.00k] ------------------ 1220| 195| element = 14; 1221| 195| break; 1222| 197| case 'm': ------------------ | Branch (1222:11): [True: 197, False: 2.99k] ------------------ 1223| 197| element = 62; 1224| 197| break; 1225| 195| case 'n': ------------------ | Branch (1225:11): [True: 195, False: 3.00k] ------------------ 1226| 195| element = 50; 1227| 195| break; 1228| 194| case 'r': ------------------ | Branch (1228:11): [True: 194, False: 3.00k] ------------------ 1229| 194| element = 38; 1230| 194| break; 1231| 1.63k| default: ------------------ | Branch (1231:11): [True: 1.63k, False: 1.56k] ------------------ 1232| 1.63k| element = 16; 1233| 1.63k| _ptr--; 1234| 3.19k| } 1235| 3.19k| break; 1236| | 1237| 3.19k| case 'B': ------------------ | Branch (1237:7): [True: 1.74k, False: 163k] ------------------ 1238| 1.74k| _ptr++; 1239| 1.74k| switch(*_ptr) 1240| 1.74k| { 1241| 69| case 'a': ------------------ | Branch (1241:11): [True: 69, False: 1.67k] ------------------ 1242| 69| element = 56; 1243| 69| break; 1244| 268| case 'e': ------------------ | Branch (1244:11): [True: 268, False: 1.47k] ------------------ 1245| 268| element = 4; 1246| 268| break; 1247| 194| case 'h': ------------------ | Branch (1247:11): [True: 194, False: 1.54k] ------------------ 1248| 194| element = 107; 1249| 194| break; 1250| 208| case 'i': ------------------ | Branch (1250:11): [True: 208, False: 1.53k] ------------------ 1251| 208| element = 83; 1252| 208| break; 1253| 195| case 'k': ------------------ | Branch (1253:11): [True: 195, False: 1.54k] ------------------ 1254| 195| element = 97; 1255| 195| break; 1256| 207| case 'r': ------------------ | Branch (1256:11): [True: 207, False: 1.53k] ------------------ 1257| 207| element = 35; 1258| 207| break; 1259| 601| default: ------------------ | Branch (1259:11): [True: 601, False: 1.14k] ------------------ 1260| 601| element = 5; 1261| 601| _ptr--; 1262| 1.74k| } 1263| 1.74k| break; 1264| | 1265| 1.74k| case 'F': ------------------ | Branch (1265:7): [True: 927, False: 164k] ------------------ 1266| 927| _ptr++; 1267| 927| switch(*_ptr) 1268| 927| { 1269| 78| case 'e': ------------------ | Branch (1269:11): [True: 78, False: 849] ------------------ 1270| 78| element = 26; 1271| 78| break; 1272| 194| case 'l': ------------------ | Branch (1272:11): [True: 194, False: 733] ------------------ 1273| 194| element = 114; 1274| 194| break; 1275| 66| case 'm': ------------------ | Branch (1275:11): [True: 66, False: 861] ------------------ 1276| 66| element = 100; 1277| 66| break; 1278| 205| case 'r': ------------------ | Branch (1278:11): [True: 205, False: 722] ------------------ 1279| 205| element = 87; 1280| 205| break; 1281| 384| default: ------------------ | Branch (1281:11): [True: 384, False: 543] ------------------ 1282| 384| element = 9; 1283| 384| _ptr--; 1284| 927| } 1285| 927| break; 1286| | 1287| 1.81k| case 'I': ------------------ | Branch (1287:7): [True: 1.81k, False: 163k] ------------------ 1288| 1.81k| _ptr++; 1289| 1.81k| switch(*_ptr) 1290| 1.81k| { 1291| 201| case 'n': ------------------ | Branch (1291:11): [True: 201, False: 1.61k] ------------------ 1292| 201| element = 49; 1293| 201| break; 1294| 200| case 'r': ------------------ | Branch (1294:11): [True: 200, False: 1.61k] ------------------ 1295| 200| element = 77; 1296| 200| break; 1297| 1.41k| default: ------------------ | Branch (1297:11): [True: 1.41k, False: 401] ------------------ 1298| 1.41k| element = 53; 1299| 1.41k| _ptr--; 1300| 1.81k| } 1301| 1.81k| break; 1302| | 1303| 2.64k| case 'A': ------------------ | Branch (1303:7): [True: 2.64k, False: 162k] ------------------ 1304| 2.64k| _ptr++; 1305| 2.64k| switch(*_ptr) 1306| 2.64k| { 1307| 207| case 'c': ------------------ | Branch (1307:11): [True: 207, False: 2.43k] ------------------ 1308| 207| element = 89; 1309| 207| break; 1310| 323| case 'g': ------------------ | Branch (1310:11): [True: 323, False: 2.31k] ------------------ 1311| 323| element = 47; 1312| 323| break; 1313| 195| case 'l': ------------------ | Branch (1313:11): [True: 195, False: 2.44k] ------------------ 1314| 195| element = 13; 1315| 195| break; 1316| 198| case 'm': ------------------ | Branch (1316:11): [True: 198, False: 2.44k] ------------------ 1317| 198| element = 95; 1318| 198| break; 1319| 231| case 'r': ------------------ | Branch (1319:11): [True: 231, False: 2.40k] ------------------ 1320| 231| element = 18; 1321| 231| break; 1322| 1.00k| case 's': ------------------ | Branch (1322:11): [True: 1.00k, False: 1.63k] ------------------ 1323| 1.00k| element = 33; 1324| 1.00k| break; 1325| 204| case 't': ------------------ | Branch (1325:11): [True: 204, False: 2.43k] ------------------ 1326| 204| element = 85; 1327| 204| break; 1328| 276| case 'u': ------------------ | Branch (1328:11): [True: 276, False: 2.36k] ------------------ 1329| 276| element = 79; 1330| 276| break; 1331| 2| default: ------------------ | Branch (1331:11): [True: 2, False: 2.63k] ------------------ 1332| 2| return(false); 1333| 2.64k| } 1334| 2.63k| break; 1335| | 1336| 2.63k| case 'D': ------------------ | Branch (1336:7): [True: 613, False: 164k] ------------------ 1337| 613| _ptr++; 1338| 613| switch(*_ptr) 1339| 613| { 1340| 197| case 'b': ------------------ | Branch (1340:11): [True: 197, False: 416] ------------------ 1341| 197| element = 105; 1342| 197| break; 1343| 196| case 's': ------------------ | Branch (1343:11): [True: 196, False: 417] ------------------ 1344| 196| element = 110; 1345| 196| break; 1346| 218| case 'y': ------------------ | Branch (1346:11): [True: 218, False: 395] ------------------ 1347| 218| element = 66; 1348| 218| break; 1349| 2| default: ------------------ | Branch (1349:11): [True: 2, False: 611] ------------------ 1350| 2| return(false); 1351| 613| } 1352| 611| break; 1353| | 1354| 611| case 'E': ------------------ | Branch (1354:7): [True: 584, False: 164k] ------------------ 1355| 584| _ptr++; 1356| 584| switch(*_ptr) 1357| 584| { 1358| 194| case 'r': ------------------ | Branch (1358:11): [True: 194, False: 390] ------------------ 1359| 194| element = 68; 1360| 194| break; 1361| 194| case 's': ------------------ | Branch (1361:11): [True: 194, False: 390] ------------------ 1362| 194| element = 99; 1363| 194| break; 1364| 195| case 'u': ------------------ | Branch (1364:11): [True: 195, False: 389] ------------------ 1365| 195| element = 63; 1366| 195| break; 1367| 1| default: ------------------ | Branch (1367:11): [True: 1, False: 583] ------------------ 1368| 1| return(false); 1369| 584| } 1370| 583| break; 1371| | 1372| 583| case 'G': ------------------ | Branch (1372:7): [True: 433, False: 164k] ------------------ 1373| 433| _ptr++; 1374| 433| switch (*_ptr) 1375| 433| { 1376| 34| case 'a': ------------------ | Branch (1376:11): [True: 34, False: 399] ------------------ 1377| 34| element = 31; 1378| 34| break; 1379| 194| case 'd': ------------------ | Branch (1379:11): [True: 194, False: 239] ------------------ 1380| 194| element = 64; 1381| 194| break; 1382| 202| case 'e': ------------------ | Branch (1382:11): [True: 202, False: 231] ------------------ 1383| 202| element = 32; 1384| 202| break; 1385| 3| default: ------------------ | Branch (1385:11): [True: 3, False: 430] ------------------ 1386| 3| return(false); 1387| 433| } 1388| 430| break; 1389| | 1390| 2.32k| case 'H': ------------------ | Branch (1390:7): [True: 2.32k, False: 163k] ------------------ 1391| 2.32k| _ptr++; 1392| 2.32k| switch (*_ptr) 1393| 2.32k| { 1394| 195| case 'e': ------------------ | Branch (1394:11): [True: 195, False: 2.13k] ------------------ 1395| 195| element = 2; 1396| 195| break; 1397| 196| case 'f': ------------------ | Branch (1397:11): [True: 196, False: 2.13k] ------------------ 1398| 196| element = 72; 1399| 196| break; 1400| 203| case 'g': ------------------ | Branch (1400:11): [True: 203, False: 2.12k] ------------------ 1401| 203| element = 80; 1402| 203| break; 1403| 204| case 'o': ------------------ | Branch (1403:11): [True: 204, False: 2.12k] ------------------ 1404| 204| element = 67; 1405| 204| break; 1406| 196| case 's': ------------------ | Branch (1406:11): [True: 196, False: 2.13k] ------------------ 1407| 196| element = 108; 1408| 196| break; 1409| 1.33k| default: ------------------ | Branch (1409:11): [True: 1.33k, False: 994] ------------------ 1410| 1.33k| element = 1; 1411| 1.33k| _ptr--; 1412| 2.32k| } 1413| 2.32k| break; 1414| | 1415| 2.32k| case 'K': ------------------ | Branch (1415:7): [True: 732, False: 164k] ------------------ 1416| 732| _ptr++; 1417| 732| if(*_ptr == 'r') ------------------ | Branch (1417:12): [True: 201, False: 531] ------------------ 1418| 201| { 1419| 201| element = 36; 1420| 201| } 1421| 531| else 1422| 531| { 1423| 531| element = 19; 1424| 531| _ptr--; 1425| 531| } 1426| 732| break; 1427| | 1428| 984| case 'L': ------------------ | Branch (1428:7): [True: 984, False: 164k] ------------------ 1429| 984| _ptr++; 1430| 984| switch(*_ptr) 1431| 984| { 1432| 168| case 'a': ------------------ | Branch (1432:11): [True: 168, False: 816] ------------------ 1433| 168| element = 57; 1434| 168| break; 1435| 216| case 'i': ------------------ | Branch (1435:11): [True: 216, False: 768] ------------------ 1436| 216| element = 3; 1437| 216| break; 1438| 201| case 'r': ------------------ | Branch (1438:11): [True: 201, False: 783] ------------------ 1439| 201| element = 103; 1440| 201| break; 1441| 202| case 'u': ------------------ | Branch (1441:11): [True: 202, False: 782] ------------------ 1442| 202| element = 71; 1443| 202| break; 1444| 194| case 'v': ------------------ | Branch (1444:11): [True: 194, False: 790] ------------------ 1445| 194| element = 116; 1446| 194| break; 1447| 3| default: ------------------ | Branch (1447:11): [True: 3, False: 981] ------------------ 1448| 3| return(false); 1449| 984| } 1450| 981| break; 1451| | 1452| 981| case 'M': ------------------ | Branch (1452:7): [True: 934, False: 164k] ------------------ 1453| 934| _ptr++; 1454| 934| switch(*_ptr) 1455| 934| { 1456| 194| case 'c': ------------------ | Branch (1456:11): [True: 194, False: 740] ------------------ 1457| 194| element = 115; 1458| 194| break; 1459| 63| case 'd': ------------------ | Branch (1459:11): [True: 63, False: 871] ------------------ 1460| 63| element = 101; 1461| 63| break; 1462| 73| case 'g': ------------------ | Branch (1462:11): [True: 73, False: 861] ------------------ 1463| 73| element = 12; 1464| 73| break; 1465| 213| case 'n': ------------------ | Branch (1465:11): [True: 213, False: 721] ------------------ 1466| 213| element = 25; 1467| 213| break; 1468| 194| case 'o': ------------------ | Branch (1468:11): [True: 194, False: 740] ------------------ 1469| 194| element = 42; 1470| 194| break; 1471| 195| case 't': ------------------ | Branch (1471:11): [True: 195, False: 739] ------------------ 1472| 195| element = 109; 1473| 195| break; 1474| 2| default: ------------------ | Branch (1474:11): [True: 2, False: 932] ------------------ 1475| 2| return(false); 1476| 934| } 1477| 932| break; 1478| | 1479| 1.48k| case 'R': ------------------ | Branch (1479:7): [True: 1.48k, False: 163k] ------------------ 1480| 1.48k| _ptr++; 1481| 1.48k| switch(*_ptr) 1482| 1.48k| { 1483| 194| case 'a': ------------------ | Branch (1483:11): [True: 194, False: 1.29k] ------------------ 1484| 194| element = 88; 1485| 194| break; 1486| 196| case 'b': ------------------ | Branch (1486:11): [True: 196, False: 1.29k] ------------------ 1487| 196| element = 37; 1488| 196| break; 1489| 196| case 'e': ------------------ | Branch (1489:11): [True: 196, False: 1.29k] ------------------ 1490| 196| element = 75; 1491| 196| break; 1492| 71| case 'f': ------------------ | Branch (1492:11): [True: 71, False: 1.41k] ------------------ 1493| 71| element = 104; 1494| 71| break; 1495| 197| case 'g': ------------------ | Branch (1495:11): [True: 197, False: 1.29k] ------------------ 1496| 197| element = 111; 1497| 197| break; 1498| 200| case 'h': ------------------ | Branch (1498:11): [True: 200, False: 1.28k] ------------------ 1499| 200| element = 45; 1500| 200| break; 1501| 233| case 'n': ------------------ | Branch (1501:11): [True: 233, False: 1.25k] ------------------ 1502| 233| element = 86; 1503| 233| break; 1504| 197| case 'u': ------------------ | Branch (1504:11): [True: 197, False: 1.29k] ------------------ 1505| 197| element = 44; 1506| 197| break; 1507| 3| default: ------------------ | Branch (1507:11): [True: 3, False: 1.48k] ------------------ 1508| 3| return(false); 1509| 1.48k| } 1510| 1.48k| break; 1511| | 1512| 5.89k| case 'T': ------------------ | Branch (1512:7): [True: 5.89k, False: 159k] ------------------ 1513| 5.89k| _ptr++; 1514| 5.89k| switch(*_ptr) 1515| 5.89k| { 1516| 196| case 'a': ------------------ | Branch (1516:11): [True: 196, False: 5.69k] ------------------ 1517| 196| element = 73; 1518| 196| break; 1519| 206| case 'b': ------------------ | Branch (1519:11): [True: 206, False: 5.68k] ------------------ 1520| 206| element = 65; 1521| 206| break; 1522| 196| case 'c': ------------------ | Branch (1522:11): [True: 196, False: 5.69k] ------------------ 1523| 196| element = 43; 1524| 196| break; 1525| 67| case 'e': ------------------ | Branch (1525:11): [True: 67, False: 5.82k] ------------------ 1526| 67| element = 52; 1527| 67| break; 1528| 4.42k| case 'h': ------------------ | Branch (1528:11): [True: 4.42k, False: 1.47k] ------------------ 1529| 4.42k| element = 90; 1530| 4.42k| break; 1531| 204| case 'i': ------------------ | Branch (1531:11): [True: 204, False: 5.69k] ------------------ 1532| 204| element = 22; 1533| 204| break; 1534| 199| case 'l': ------------------ | Branch (1534:11): [True: 199, False: 5.69k] ------------------ 1535| 199| element = 81; 1536| 199| break; 1537| 195| case 'm': ------------------ | Branch (1537:11): [True: 195, False: 5.69k] ------------------ 1538| 195| element = 69; 1539| 195| break; 1540| 208| case 's': ------------------ | Branch (1540:11): [True: 208, False: 5.68k] ------------------ 1541| 208| element = 117; 1542| 208| break; 1543| 3| default: ------------------ | Branch (1543:11): [True: 3, False: 5.89k] ------------------ 1544| 3| return(false); 1545| 5.89k| } 1546| 5.89k| break; 1547| | 1548| 5.89k| case('U'): element = 92; ------------------ | Branch (1548:7): [True: 1.76k, False: 163k] ------------------ 1549| 1.76k| break; 1550| 269| case('V'): element = 23; ------------------ | Branch (1550:7): [True: 269, False: 165k] ------------------ 1551| 269| break; 1552| 6.51k| case('W'): element = 74; ------------------ | Branch (1552:7): [True: 6.51k, False: 158k] ------------------ 1553| 6.51k| break; 1554| | 1555| 418| case('X'): ------------------ | Branch (1555:7): [True: 418, False: 164k] ------------------ 1556| 418| _ptr++; 1557| 418| if (*_ptr == 'e') ------------------ | Branch (1557:13): [True: 408, False: 10] ------------------ 1558| 408| { 1559| 408| element = 54; 1560| 408| } 1561| 10| else 1562| 10| { 1563| 10| return(false); 1564| 10| } 1565| 408| break; 1566| | 1567| 484| case('Y'): ------------------ | Branch (1567:7): [True: 484, False: 164k] ------------------ 1568| 484| _ptr++; 1569| 484| if (*_ptr == 'b') ------------------ | Branch (1569:13): [True: 190, False: 294] ------------------ 1570| 190| { 1571| 190| element = 70; 1572| 190| } 1573| 294| else 1574| 294| { 1575| 294| element = 39; 1576| 294| _ptr--; 1577| 294| } 1578| 484| break; 1579| | 1580| 265| case('Z'): ------------------ | Branch (1580:7): [True: 265, False: 165k] ------------------ 1581| 265| _ptr++; 1582| 265| switch(*_ptr) 1583| 265| { 1584| 69| case 'n': ------------------ | Branch (1584:11): [True: 69, False: 196] ------------------ 1585| 69| element = 30; 1586| 69| break; 1587| 194| case 'r': ------------------ | Branch (1587:11): [True: 194, False: 71] ------------------ 1588| 194| element = 40; 1589| 194| break; 1590| 2| default: ------------------ | Branch (1590:11): [True: 2, False: 263] ------------------ 1591| 2| return false; 1592| 265| } 1593| 263| break; 1594| | 1595| 1.06k| case 'a': ------------------ | Branch (1595:7): [True: 1.06k, False: 164k] ------------------ 1596| 1.06k| _ptr++; 1597| 1.06k| if (*_ptr == 's') { ------------------ | Branch (1597:13): [True: 1.06k, False: 2] ------------------ 1598| 1.06k| arom = true; 1599| 1.06k| element = 33; 1600| 1.06k| } 1601| 2| else 1602| 2| return false; 1603| 1.06k| break; 1604| | 1605| 1.70k| case 'b': ------------------ | Branch (1605:7): [True: 1.70k, False: 163k] ------------------ 1606| 1.70k| _ptr++; 1607| 1.70k| if (*_ptr == 'i') { ------------------ | Branch (1607:13): [True: 351, False: 1.35k] ------------------ 1608| 351| arom = true; 1609| 351| element = 83; 1610| 351| } 1611| 1.35k| else { 1612| 1.35k| arom = true; 1613| 1.35k| element = 5; 1614| 1.35k| _ptr--; 1615| 1.35k| } 1616| 1.70k| break; 1617| | 1618| 3.08k| case 'c': ------------------ | Branch (1618:7): [True: 3.08k, False: 162k] ------------------ 1619| 3.08k| arom = true; 1620| 3.08k| element = 6; 1621| 3.08k| break; 1622| | 1623| 226| case 'g': ------------------ | Branch (1623:7): [True: 226, False: 165k] ------------------ 1624| 226| _ptr++; 1625| 226| if (*_ptr == 'e') { ------------------ | Branch (1625:13): [True: 212, False: 14] ------------------ 1626| 212| arom = true; 1627| 212| element = 32; 1628| 212| } 1629| 14| else 1630| 14| return false; 1631| 212| break; 1632| | 1633| 77.0k| case 'n': ------------------ | Branch (1633:7): [True: 77.0k, False: 88.2k] ------------------ 1634| 77.0k| arom = true; 1635| 77.0k| element = 7; 1636| 77.0k| break; 1637| | 1638| 3.61k| case 'o': ------------------ | Branch (1638:7): [True: 3.61k, False: 161k] ------------------ 1639| 3.61k| arom = true; 1640| 3.61k| element = 8; 1641| 3.61k| break; 1642| | 1643| 2.76k| case 'p': ------------------ | Branch (1643:7): [True: 2.76k, False: 162k] ------------------ 1644| 2.76k| arom = true; 1645| 2.76k| element = 15; 1646| 2.76k| break; 1647| | 1648| 3.83k| case 's': ------------------ | Branch (1648:7): [True: 3.83k, False: 161k] ------------------ 1649| 3.83k| arom = true; 1650| 3.83k| _ptr++; 1651| 3.83k| switch (*_ptr) { 1652| 257| case 'e': ------------------ | Branch (1652:9): [True: 257, False: 3.57k] ------------------ 1653| 257| element = 34; 1654| 257| break; 1655| 197| case 'i': ------------------ | Branch (1655:9): [True: 197, False: 3.63k] ------------------ 1656| 197| element = 14; 1657| 197| break; 1658| 196| case 'n': ------------------ | Branch (1658:9): [True: 196, False: 3.63k] ------------------ 1659| 196| element = 50; 1660| 196| break; 1661| 259| case 'b': ------------------ | Branch (1661:9): [True: 259, False: 3.57k] ------------------ 1662| 259| element = 51; 1663| 259| break; 1664| 2.92k| default: ------------------ | Branch (1664:9): [True: 2.92k, False: 909] ------------------ 1665| 2.92k| element = 16; 1666| 2.92k| _ptr--; 1667| 3.83k| } 1668| 3.83k| break; 1669| | 1670| 3.83k| case 't': ------------------ | Branch (1670:7): [True: 270, False: 165k] ------------------ 1671| 270| _ptr++; 1672| 270| if (*_ptr == 'e') { ------------------ | Branch (1672:13): [True: 261, False: 9] ------------------ 1673| 261| arom = true; 1674| 261| element = 52; 1675| 261| } 1676| 9| else 1677| 9| return false; 1678| 261| break; 1679| | 1680| 506| case '#': ------------------ | Branch (1680:7): [True: 506, False: 164k] ------------------ 1681| | // Only support three digits for this extension 1682| 506| if ((_ptr[1] == '1' || _ptr[1] == '2') && ------------------ | Branch (1682:14): [True: 221, False: 285] | Branch (1682:32): [True: 268, False: 17] ------------------ 1683| 506| (_ptr[2] >= '0' && _ptr[2] <= '9') && ------------------ | Branch (1683:14): [True: 473, False: 16] | Branch (1683:32): [True: 469, False: 4] ------------------ 1684| 506| (_ptr[3] >= '0' && _ptr[3] <= '9')) { ------------------ | Branch (1684:14): [True: 458, False: 11] | Branch (1684:32): [True: 451, False: 7] ------------------ 1685| 451| element = (_ptr[1]-'0')*100 + (_ptr[2]-'0')*10 + (_ptr[3]-'0'); 1686| 451| if (element > 255) { ------------------ | Branch (1686:15): [True: 1, False: 450] ------------------ 1687| 1| std::string err = "Element number must be <= 255)"; 1688| 1| obErrorLog.ThrowError(__FUNCTION__, 1689| 1| err, obError); 1690| 1| return false; 1691| 1| } 1692| 450| _ptr += 3; 1693| 450| break; 1694| 451| } 1695| | /* fall through to default */ 1696| | 1697| 183| default: ------------------ | Branch (1697:7): [True: 128, False: 165k] ------------------ 1698| 183| { 1699| 183| std::string err; 1700| 183| err += "SMILES string contains a character '"; 1701| 183| err += *_ptr; 1702| 183| err += "' which is invalid"; 1703| 183| obErrorLog.ThrowError(__FUNCTION__, 1704| 183| err, obError); 1705| 183| return false; 1706| 506| } 1707| 165k| } 1708| | 1709| | //handle hydrogen count, stereochemistry, and charge 1710| | 1711| 165k| OBAtom *atom = mol.NewAtom(); 1712| 165k| int hcount = 0; 1713| 165k| int charge=0; 1714| 165k| int rad=0; 1715| 165k| int clval=0; 1716| 165k| char tmpc[2]; 1717| 165k| tmpc[1] = '\0'; 1718| | 1719| 165k| stringstream errorMsg; 1720| | 1721| 293k| for (_ptr++;*_ptr && *_ptr != ']';_ptr++) ------------------ | Branch (1721:17): [True: 292k, False: 1.09k] | Branch (1721:26): [True: 128k, False: 163k] ------------------ 1722| 128k| { 1723| 128k| switch(*_ptr) 1724| 128k| { 1725| 94.0k| case '@': ------------------ | Branch (1725:11): [True: 94.0k, False: 34.7k] ------------------ 1726| 94.0k| _ptr++; 1727| 94.0k| if (*_ptr == 'S' && _ptr[1] == 'P') { // @SP1/2/3 ------------------ | Branch (1727:17): [True: 28.0k, False: 65.9k] | Branch (1727:33): [True: 28.0k, False: 3] ------------------ 1728| | // square planar atom found 1729| 28.0k| squarePlanarWatch = true; 1730| 28.0k| if (_squarePlanarMap.find(atom)==_squarePlanarMap.end()) // Prevent memory leak for malformed smiles (PR#3428432) ------------------ | Branch (1730:19): [True: 27.2k, False: 848] ------------------ 1731| 27.2k| _squarePlanarMap[atom] = new OBSquarePlanarStereo::Config; 1732| 28.0k| _squarePlanarMap[atom]->refs = OBStereo::Refs(4, OBStereo::NoRef); 1733| 28.0k| _squarePlanarMap[atom]->center = atom->GetId(); 1734| 28.0k| _ptr += 2; 1735| 28.0k| switch(*_ptr) { 1736| 4.87k| case '1': ------------------ | Branch (1736:15): [True: 4.87k, False: 23.2k] ------------------ 1737| 4.87k| _squarePlanarMap[atom]->shape = OBStereo::ShapeU; break; 1738| 17.4k| case '2': ------------------ | Branch (1738:15): [True: 17.4k, False: 10.6k] ------------------ 1739| 17.4k| _squarePlanarMap[atom]->shape = OBStereo::Shape4; break; 1740| 5.72k| case '3': ------------------ | Branch (1740:15): [True: 5.72k, False: 22.3k] ------------------ 1741| 5.72k| _squarePlanarMap[atom]->shape = OBStereo::ShapeZ; break; 1742| 41| default: ------------------ | Branch (1742:15): [True: 41, False: 28.0k] ------------------ 1743| 41| obErrorLog.ThrowError(__FUNCTION__, "Square planar stereochemistry must be one of SP1, SP2 or SP3", obWarning); 1744| 41| return false; 1745| 28.0k| } 1746| 65.9k| } else { 1747| | // tetrahedral atom found 1748| 65.9k| chiralWatch=true; 1749| 65.9k| if (_tetrahedralMap.find(atom)==_tetrahedralMap.end()) // Prevent memory leak for malformed smiles (PR#3428432) ------------------ | Branch (1749:19): [True: 65.0k, False: 925] ------------------ 1750| 65.0k| _tetrahedralMap[atom] = new OBTetrahedralStereo::Config; 1751| 65.9k| _tetrahedralMap[atom]->refs = OBStereo::Refs(3, OBStereo::NoRef); 1752| 65.9k| _tetrahedralMap[atom]->center = atom->GetId(); 1753| 65.9k| if (*_ptr == '@') { ------------------ | Branch (1753:19): [True: 886, False: 65.0k] ------------------ 1754| 886| _tetrahedralMap[atom]->winding = OBStereo::Clockwise; 1755| 65.0k| } else if (*_ptr == '?') { ------------------ | Branch (1755:26): [True: 798, False: 64.2k] ------------------ 1756| 798| _tetrahedralMap[atom]->specified = false; 1757| 64.2k| } else { 1758| 64.2k| _tetrahedralMap[atom]->winding = OBStereo::AntiClockwise; 1759| 64.2k| _ptr--; 1760| 64.2k| } 1761| 65.9k| } 1762| 94.0k| break; 1763| 94.0k| case '-': ------------------ | Branch (1763:11): [True: 6.01k, False: 122k] ------------------ 1764| 6.01k| if (charge) { ------------------ | Branch (1764:17): [True: 48, False: 5.96k] ------------------ 1765| 48| obErrorLog.ThrowError(__FUNCTION__, "Charge can only be specified once", obWarning); 1766| 48| return false; 1767| 48| } 1768| 1.72M| while (*++_ptr == '-') ------------------ | Branch (1768:20): [True: 1.72M, False: 5.96k] ------------------ 1769| 1.72M| charge--; // handle [O--] 1770| 5.96k| if (charge == 0) { ------------------ | Branch (1770:17): [True: 5.64k, False: 317] ------------------ 1771| 9.62k| while (isdigit(*_ptr)) // handle [O-2] ------------------ | Branch (1771:22): [True: 3.97k, False: 5.64k] ------------------ 1772| 3.97k| charge = charge * 10 - ((*_ptr++) - '0'); 1773| 5.64k| if (charge == 0) // handle [Cl-] ------------------ | Branch (1773:19): [True: 4.36k, False: 1.28k] ------------------ 1774| 4.36k| charge = -1; 1775| 5.64k| } 1776| 317| else 1777| 317| charge--; // finish handling [Ca++] 1778| 5.96k| _ptr--; 1779| 5.96k| break; 1780| 9.25k| case '+': ------------------ | Branch (1780:11): [True: 9.25k, False: 119k] ------------------ 1781| 9.25k| if (charge) { ------------------ | Branch (1781:17): [True: 53, False: 9.20k] ------------------ 1782| 53| obErrorLog.ThrowError(__FUNCTION__, "Charge can only be specified once", obWarning); 1783| 53| return false; 1784| 53| } 1785| 83.5k| while (*++_ptr == '+') ------------------ | Branch (1785:20): [True: 74.3k, False: 9.20k] ------------------ 1786| 74.3k| charge++; // handle [Ca++] 1787| 9.20k| if (charge == 0) { ------------------ | Branch (1787:17): [True: 7.90k, False: 1.29k] ------------------ 1788| 9.89k| while (isdigit(*_ptr)) // handle [Ca+2] ------------------ | Branch (1788:22): [True: 1.99k, False: 7.90k] ------------------ 1789| 1.99k| charge = charge * 10 + ((*_ptr++) - '0'); 1790| 7.90k| if (charge == 0) // handle [Na+] ------------------ | Branch (1790:19): [True: 7.27k, False: 631] ------------------ 1791| 7.27k| charge = 1; 1792| 7.90k| } 1793| 1.29k| else 1794| 1.29k| charge++; // finish handling [Ca++] 1795| 9.20k| _ptr--; 1796| 9.20k| break; 1797| 7.64k| case 'H': ------------------ | Branch (1797:11): [True: 7.64k, False: 121k] ------------------ 1798| 7.64k| _ptr++; 1799| 7.64k| if (isdigit(*_ptr)) ------------------ | Branch (1799:17): [True: 1.72k, False: 5.92k] ------------------ 1800| 1.72k| { 1801| 1.72k| tmpc[0] = *_ptr; 1802| 1.72k| hcount = atoi(tmpc); 1803| 1.72k| } 1804| 5.92k| else 1805| 5.92k| { 1806| 5.92k| hcount = 1; 1807| 5.92k| _ptr--; 1808| 5.92k| } 1809| 7.64k| break; 1810| 7.62k| case '.': //CM Feb05 ------------------ | Branch (1810:11): [True: 7.62k, False: 121k] ------------------ 1811| 7.62k| rad=2; 1812| 7.62k| if(*(++_ptr)=='.') ------------------ | Branch (1812:16): [True: 293, False: 7.32k] ------------------ 1813| 293| rad=3; 1814| 7.32k| else 1815| 7.32k| _ptr--; 1816| 7.62k| break; 1817| | 1818| 4.00k| case ':': ------------------ | Branch (1818:11): [True: 4.00k, False: 124k] ------------------ 1819| 4.00k| if(!isdigit(*(++_ptr))) ------------------ | Branch (1819:16): [True: 17, False: 3.98k] ------------------ 1820| 17| { 1821| 17| obErrorLog.ThrowError(__FUNCTION__,"The atom class following : must be a number", obWarning); 1822| 17| return false; 1823| 17| } 1824| 9.37k| while( isdigit(*_ptr) && clval < 100000000) ------------------ | Branch (1824:20): [True: 5.39k, False: 3.98k] | Branch (1824:38): [True: 5.38k, False: 6] ------------------ 1825| 5.38k| clval = clval*10 + ((*_ptr++)-'0'); 1826| 3.98k| --_ptr; 1827| 3.98k| { // a block is needed here to scope the OBPairInteger assignment 1828| 3.98k| OBPairInteger *atomclass = new OBPairInteger(); 1829| 3.98k| atomclass->SetAttribute("Atom Class"); 1830| 3.98k| atomclass->SetValue(clval); 1831| 3.98k| atomclass->SetOrigin(fileformatInput); 1832| 3.98k| atom->SetData(atomclass); 1833| 3.98k| } 1834| 3.98k| break; 1835| | 1836| 228| default: ------------------ | Branch (1836:11): [True: 228, False: 128k] ------------------ 1837| 228| return(false); 1838| 128k| } 1839| 128k| } 1840| | 1841| 164k| if (!*_ptr || *_ptr != ']') ------------------ | Branch (1841:9): [True: 1.09k, False: 163k] | Branch (1841:19): [True: 0, False: 163k] ------------------ 1842| 1.09k| return(false); // we should have a trailing ']' now 1843| | 1844| 163k| if (charge) { ------------------ | Branch (1844:9): [True: 14.8k, False: 148k] ------------------ 1845| 14.8k| atom->SetFormalCharge(charge); 1846| 14.8k| if (abs(charge) > 10 || (element && charge > element)) { // if the charge is +/- 10 or more than the number of electrons ------------------ | Branch (1846:11): [True: 1.00k, False: 13.8k] | Branch (1846:32): [True: 13.4k, False: 452] | Branch (1846:43): [True: 663, False: 12.7k] ------------------ 1847| 1.67k| errorMsg << "Atom " << atom->GetIdx() << " had an unrealistic charge of " << charge 1848| 1.67k| << "." << endl; 1849| 1.67k| obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning); 1850| 1.67k| } 1851| 14.8k| } 1852| 163k| if (rad) ------------------ | Branch (1852:9): [True: 6.98k, False: 156k] ------------------ 1853| 6.98k| atom->SetSpinMultiplicity(rad); 1854| 163k| atom->SetAtomicNum(element); 1855| 163k| atom->SetIsotope(isotope); 1856| 163k| if (arom) ------------------ | Branch (1856:9): [True: 93.1k, False: 70.4k] ------------------ 1857| 93.1k| atom->SetAromatic(); 1858| 163k| if (_rxnrole > 1) { // Quick test for reaction ------------------ | Branch (1858:9): [True: 2.20k, False: 161k] ------------------ 1859| | // Set reaction role 1860| 2.20k| OBPairInteger *pi = new OBPairInteger(); 1861| 2.20k| pi->SetAttribute("rxnrole"); 1862| 2.20k| pi->SetValue(_rxnrole); 1863| 2.20k| atom->SetData(pi); 1864| 2.20k| } 1865| | 1866| 163k| if (_prev) //need to add bond ------------------ | Branch (1866:9): [True: 143k, False: 19.7k] ------------------ 1867| 143k| { 1868| 143k| OBAtom* prevatom = mol.GetAtom(_prev); 1869| 143k| if (arom && prevatom->IsAromatic() && _order == 0) ------------------ | Branch (1869:13): [True: 81.6k, False: 62.2k] | Branch (1869:21): [True: 77.8k, False: 3.81k] | Branch (1869:47): [True: 76.4k, False: 1.34k] ------------------ 1870| 76.4k| mol.AddBond(_prev, mol.NumAtoms(), 1, OB_AROMATIC_BOND); // this will be kekulized later ------------------ | | 41| 76.4k|#define OB_AROMATIC_BOND (1<<1) ------------------ 1871| 67.3k| else 1872| 67.3k| mol.AddBond(_prev, mol.NumAtoms(), _order == 0 ? 1 : _order); ------------------ | Branch (1872:46): [True: 65.1k, False: 2.18k] ------------------ 1873| | // store up/down 1874| 143k| if (_updown == BondUpChar || _updown == BondDownChar) ------------------ | Branch (1874:13): [True: 1.01k, False: 142k] | Branch (1874:38): [True: 748, False: 142k] ------------------ 1875| 1.76k| _upDownMap[mol.GetBond(_prev, mol.NumAtoms())] = _updown; 1876| | 1877| 143k| if(chiralWatch) { // if tetrahedral atom, set previous as from atom ------------------ | Branch (1877:12): [True: 49.4k, False: 94.3k] ------------------ 1878| 49.4k| _tetrahedralMap[atom]->from = mol.GetAtom(_prev)->GetId(); 1879| 49.4k| if (CanHaveLonePair(element)) // Handle chiral lone pair as in X[S@@](Y)Z ------------------ | Branch (1879:15): [True: 40.8k, False: 8.59k] ------------------ 1880| 40.8k| _chiralLonePair[mol.NumAtoms()] = 1; // First of the refs 1881| | 1882| | //cerr <<"NB7: line 1622: Added atom ref "<<_prev<<" at " << 0 << " to "<<_mapcd[atom]<refs[0] = mol.GetAtom(_prev)->GetId(); 1886| | //cerr <<"TV7: line 1748: Added atom ref " << mol.GetAtom(_prev)->GetId() 1887| | // << " at " << 0 << " to " << _squarePlanarMap[atom] << endl; 1888| 24.9k| } 1889| 143k| InsertTetrahedralRef(mol, atom->GetId()); 1890| 143k| InsertSquarePlanarRef(mol, atom->GetId()); 1891| 143k| } 1892| 19.7k| else 1893| 19.7k| { 1894| | // Handle chiral lone pair as in [S@@](X)(Y)Z 1895| 19.7k| if (chiralWatch && CanHaveLonePair(element)) // Handle chiral lone pair (only S at the moment) ------------------ | Branch (1895:13): [True: 15.4k, False: 4.31k] | Branch (1895:28): [True: 8.17k, False: 7.29k] ------------------ 1896| 8.17k| _chiralLonePair[mol.NumAtoms()] = 0; // 'from' atom 1897| 19.7k| } 1898| | 1899| | //set values 1900| 163k| _prev = mol.NumAtoms(); 1901| 163k| _order = 0; 1902| 163k| _updown = ' '; 1903| | 1904| 163k| if (hcount > 0) { ------------------ | Branch (1904:9): [True: 6.96k, False: 156k] ------------------ 1905| 6.96k| if (chiralWatch) ------------------ | Branch (1905:11): [True: 3.37k, False: 3.59k] ------------------ 1906| 3.37k| InsertTetrahedralRef(mol, OBStereo::ImplicitRef); 1907| 6.96k| if (squarePlanarWatch) ------------------ | Branch (1907:11): [True: 422, False: 6.54k] ------------------ 1908| 422| InsertSquarePlanarRef(mol, OBStereo::ImplicitRef); 1909| 6.96k| } 1910| 163k| _hcount.push_back(hcount); 1911| | 1912| 163k| chiralWatch=false; 1913| 163k| squarePlanarWatch = false; 1914| 163k| return(true); 1915| 164k| } _ZN9OpenBabel14OBSmilesParser16CapExternalBondsERNS_5OBMolE: 1918| 104| { 1919| 104| if (_extbond.empty()) ------------------ | Branch (1919:9): [True: 0, False: 104] ------------------ 1920| 0| return true; 1921| | 1922| 104| OBAtom *atom; 1923| 104| vector::iterator bond; 1924| 358| for (bond = _extbond.begin(); bond != _extbond.end(); ++bond) { ------------------ | Branch (1924:35): [True: 254, False: 104] ------------------ 1925| | // create new dummy atom 1926| 254| atom = mol.NewAtom(); 1927| 254| atom->SetAtomicNum(0); 1928| | 1929| | // bond dummy atom to mol via external bond 1930| 254| mol.AddBond(bond->prev, atom->GetIdx(), bond->order); 1931| | // store up/down 1932| 254| if (bond->updown == BondUpChar || bond->updown == BondDownChar) ------------------ | Branch (1932:11): [True: 61, False: 193] | Branch (1932:41): [True: 13, False: 180] ------------------ 1933| 74| _upDownMap[mol.GetBond(bond->prev, atom->GetIdx())] = bond->updown; 1934| | 1935| 254| OBBond *refbond = atom->GetBond(mol.GetAtom(bond->prev)); 1936| | 1937| | //record external bond information 1938| 254| OBExternalBondData *xbd; 1939| 254| if (mol.HasData(OBGenericDataType::ExternalBondData)) { ------------------ | Branch (1939:11): [True: 150, False: 104] ------------------ 1940| 150| xbd = (OBExternalBondData*) mol.GetData(OBGenericDataType::ExternalBondData); 1941| 150| } else { 1942| 104| xbd = new OBExternalBondData; 1943| 104| xbd->SetOrigin(fileformatInput); 1944| 104| mol.SetData(xbd); 1945| 104| } 1946| 254| xbd->SetData(atom,refbond, bond->digit); 1947| | //this data gets cleaned up in mol.Clear. 1948| 254| } 1949| | 1950| 104| return true; 1951| 104| } _ZN9OpenBabel14OBSmilesParser17ParseExternalBondERNS_5OBMolE: 1954| 69.1k| { 1955| 69.1k| int digit; 1956| 69.1k| char str[10]; 1957| | 1958| | //*_ptr should == '&' 1959| 69.1k| _ptr++; 1960| | 1961| 69.1k| switch (*_ptr) // check for bond order indicators CC&=1.C&1 1962| 69.1k| { 1963| 327| case '-': ------------------ | Branch (1963:7): [True: 327, False: 68.8k] ------------------ 1964| 327| _order = 1; 1965| 327| _ptr++; 1966| 327| break; 1967| 2.50k| case '=': ------------------ | Branch (1967:7): [True: 2.50k, False: 66.6k] ------------------ 1968| 2.50k| _order = 2; 1969| 2.50k| _ptr++; 1970| 2.50k| break; 1971| 228| case '#': ------------------ | Branch (1971:7): [True: 228, False: 68.9k] ------------------ 1972| 228| _order = 3; 1973| 228| _ptr++; 1974| 228| break; 1975| 743| case '$': ------------------ | Branch (1975:7): [True: 743, False: 68.3k] ------------------ 1976| 743| _order = 4; 1977| 743| _ptr++; 1978| 743| break; 1979| 202| case ';': ------------------ | Branch (1979:7): [True: 202, False: 68.9k] ------------------ 1980| 202| _order = 5; 1981| 202| _ptr++; 1982| 202| break; 1983| 1.11k| case '/': //chiral, but _order still == 1 ------------------ | Branch (1983:7): [True: 1.11k, False: 68.0k] ------------------ 1984| 1.11k| _order = 1; 1985| 1.11k| _updown = BondDownChar; 1986| 1.11k| _ptr++; 1987| 1.11k| break; 1988| 8.15k| case '\\': // chiral, but _order still == 1 ------------------ | Branch (1988:7): [True: 8.15k, False: 60.9k] ------------------ 1989| 8.15k| _order = 1; 1990| 8.15k| _updown = BondUpChar; 1991| 8.15k| _ptr++; 1992| 8.15k| break; 1993| 55.8k| default: // no bond indicator just leave order = 0 ------------------ | Branch (1993:7): [True: 55.8k, False: 13.2k] ------------------ 1994| 55.8k| break; 1995| 69.1k| } 1996| | 1997| 69.1k| if (*_ptr == '%') // external bond indicator > 10 ------------------ | Branch (1997:9): [True: 220, False: 68.9k] ------------------ 1998| 220| { 1999| 220| _ptr++; 2000| 220| str[0] = *_ptr; 2001| 220| _ptr++; 2002| 220| str[1] = *_ptr; 2003| 220| str[2] = '\0'; 2004| 220| } 2005| 68.9k| else // simple single digit external bond indicator 2006| 68.9k| { 2007| 68.9k| str[0] = *_ptr; 2008| 68.9k| str[1] = '\0'; 2009| 68.9k| } 2010| 69.1k| digit = atoi(str); // convert indicator to digit 2011| | 2012| | //check for dot disconnect closures 2013| 69.1k| vector::iterator bond; 2014| 69.1k| int upDown, bondOrder; 2015| 87.1k| for (bond = _extbond.begin(); bond != _extbond.end(); ++bond) { ------------------ | Branch (2015:35): [True: 52.4k, False: 34.7k] ------------------ 2016| | 2017| 52.4k| if (bond->digit == digit) { ------------------ | Branch (2017:11): [True: 34.3k, False: 18.0k] ------------------ 2018| 34.3k| upDown = (_updown > bond->updown) ? _updown : bond->updown; ------------------ | Branch (2018:18): [True: 3.44k, False: 30.9k] ------------------ 2019| 34.3k| bondOrder = (_order > bond->order) ? _order : bond->order; ------------------ | Branch (2019:21): [True: 4.34k, False: 30.0k] ------------------ 2020| 34.3k| mol.AddBond(bond->prev, _prev, bondOrder); 2021| | // store up/down 2022| 34.3k| if (upDown == BondUpChar || upDown == BondDownChar) ------------------ | Branch (2022:13): [True: 7.79k, False: 26.6k] | Branch (2022:37): [True: 1.10k, False: 25.4k] ------------------ 2023| 8.89k| _upDownMap[mol.GetBond(bond->prev, _prev)] = upDown; 2024| | 2025| | 2026| | // after adding a bond to atom "_prev" 2027| | // search to see if atom is bonded to a chiral atom 2028| 34.3k| InsertTetrahedralRef(mol, bond->prev - 1); 2029| 34.3k| InsertSquarePlanarRef(mol, bond->prev - 1); 2030| | 2031| 34.3k| _extbond.erase(bond); 2032| 34.3k| _updown = ' '; 2033| 34.3k| _order = 0; 2034| 34.3k| return true; 2035| 34.3k| } 2036| 52.4k| } 2037| | 2038| | //since no closures save another ext bond 2039| 34.7k| ExternalBond extBond; 2040| 34.7k| extBond.digit = digit; 2041| 34.7k| extBond.prev = _prev; 2042| 34.7k| extBond.order = _order; 2043| 34.7k| extBond.updown = _updown; 2044| | 2045| 34.7k| _extbond.push_back(extBond); 2046| 34.7k| _order = 0; 2047| 34.7k| _updown = ' '; 2048| | 2049| 34.7k| return(true); 2050| | 2051| 69.1k| } _ZN9OpenBabel14OBSmilesParser13ParseRingBondERNS_5OBMolE: 2054| 253k| { 2055| | // The ring closure must be associated with a 'prev' atom 2056| 253k| OBAtom* prevatom = mol.GetAtom(_prev); 2057| 253k| if (!prevatom) { ------------------ | Branch (2057:9): [True: 0, False: 253k] ------------------ 2058| 0| obErrorLog.ThrowError(__FUNCTION__,"Number not parsed correctly as a ring bond", obWarning); 2059| 0| return false; 2060| 0| } 2061| | 2062| | // Parse the ring closure digit or digits 2063| 253k| int digit = 0; 2064| 253k| if (*_ptr == '%') { ------------------ | Branch (2064:9): [True: 718, False: 252k] ------------------ 2065| 718| _ptr++; 2066| 718| if (*_ptr == '(') { // %(NNN) extension to OpenSMILES ------------------ | Branch (2066:11): [True: 465, False: 253] ------------------ 2067| 465| _ptr++; 2068| 465| const char* start = _ptr; 2069| 1.67k| while (isdigit(*_ptr)) { ------------------ | Branch (2069:16): [True: 1.20k, False: 464] ------------------ 2070| 1.20k| digit *= 10; 2071| 1.20k| digit += *_ptr - '0'; 2072| 1.20k| _ptr++; 2073| 1.20k| if (_ptr - start > 5) { ------------------ | Branch (2073:15): [True: 1, False: 1.20k] ------------------ 2074| 1| obErrorLog.ThrowError(__FUNCTION__, "Ring closure numbers with more than 5 digits are not supported", obWarning); 2075| 1| return false; 2076| 1| } 2077| 1.20k| } 2078| 464| if (*_ptr != ')') { ------------------ | Branch (2078:13): [True: 24, False: 440] ------------------ 2079| 24| obErrorLog.ThrowError(__FUNCTION__, "Matching close parenthesis not found for ring closure number", obWarning); 2080| 24| return false; 2081| 24| } 2082| 464| } 2083| 253| else { // % followed by two-digit ring closure 2084| 253| if (!isdigit(*_ptr) || !isdigit(*(_ptr + 1))) { ------------------ | Branch (2084:13): [True: 25, False: 228] | Branch (2084:32): [True: 13, False: 215] ------------------ 2085| 38| obErrorLog.ThrowError(__FUNCTION__, "Two digits expected after %", obWarning); 2086| 38| return false; 2087| 38| } 2088| 215| digit = (*_ptr - '0') * 10 + *(_ptr+1) - '0'; 2089| 215| _ptr++; 2090| 215| } 2091| 718| } 2092| 252k| else { 2093| 252k| digit = *_ptr - '0'; 2094| 252k| } 2095| | 2096| 253k| vector::iterator bond; 2097| 253k| int upDown, bondOrder; 2098| 598k| for (bond = _rclose.begin(); bond != _rclose.end(); ++bond) { ------------------ | Branch (2098:34): [True: 471k, False: 127k] ------------------ 2099| 471k| if (bond->digit == digit) { ------------------ | Branch (2099:11): [True: 125k, False: 345k] ------------------ 2100| | // Check for self-bonding, e.g. C11 2101| 125k| if (bond->prev == _prev) { ------------------ | Branch (2101:13): [True: 83, False: 125k] ------------------ 2102| 83| obErrorLog.ThrowError(__FUNCTION__, "Invalid SMILES: Ring closures imply atom bonded to itself.", obWarning); 2103| 83| return false; 2104| 83| } 2105| 125k| upDown = (_updown > bond->updown) ? _updown : bond->updown; ------------------ | Branch (2105:18): [True: 5.44k, False: 120k] ------------------ 2106| 125k| bondOrder = (_order > bond->order) ? _order : bond->order; ------------------ | Branch (2106:21): [True: 6.63k, False: 119k] ------------------ 2107| | // Check if this ring closure bond may be aromatic and set order accordingly 2108| 125k| bool aromatic_bond = false; 2109| 125k| if (bondOrder == 0) { ------------------ | Branch (2109:13): [True: 110k, False: 15.6k] ------------------ 2110| 110k| OBAtom *a1 = mol.GetAtom(bond->prev); 2111| 110k| OBAtom *a2 = mol.GetAtom(_prev); 2112| 110k| if (a1->IsAromatic() && a2->IsAromatic()) ------------------ | Branch (2112:15): [True: 91.2k, False: 18.9k] | Branch (2112:35): [True: 85.4k, False: 5.74k] ------------------ 2113| 85.4k| aromatic_bond = true; 2114| 110k| } 2115| 125k| mol.AddBond(bond->prev, _prev, bondOrder == 0 ? 1 : bondOrder, aromatic_bond ? OB_AROMATIC_BOND : 0, bond->numConnections); ------------------ | | 41| 85.4k|#define OB_AROMATIC_BOND (1<<1) ------------------ | Branch (2115:40): [True: 110k, False: 15.6k] | Branch (2115:72): [True: 85.4k, False: 40.2k] ------------------ 2116| | // store up/down 2117| 125k| if (upDown == BondUpChar || upDown == BondDownChar) ------------------ | Branch (2117:13): [True: 9.87k, False: 115k] | Branch (2117:37): [True: 4.69k, False: 111k] ------------------ 2118| 14.5k| _upDownMap[mol.GetBond(bond->prev, _prev)] = upDown; 2119| | 2120| | // For assigning cis/trans in the presence of bond closures, we need to 2121| | // remember info on all bond closure bonds. 2122| 125k| StereoRingBond sb; 2123| 125k| sb.updown.push_back(_updown); 2124| 125k| sb.atoms.push_back(mol.GetAtom(_prev)); 2125| 125k| sb.updown.push_back(bond->updown); 2126| 125k| sb.atoms.push_back(mol.GetAtom(bond->prev)); 2127| 125k| _stereorbond[mol.GetBond(bond->prev, _prev)] = sb; // Store for later 2128| | 2129| | // after adding a bond to atom "_prev" 2130| | // search to see if atom is bonded to a chiral atom 2131| | // need to check both _prev and bond->prev as closure is direction independent 2132| 125k| InsertTetrahedralRef(mol, bond->prev - 1); 2133| 125k| InsertSquarePlanarRef(mol, bond->prev - 1); 2134| | 2135| | // FIXME: needed for squreplanar too?? 2136| 125k| map::iterator ChiralSearch; 2137| 125k| ChiralSearch = _tetrahedralMap.find(mol.GetAtom(bond->prev)); 2138| 125k| if (ChiralSearch != _tetrahedralMap.end() && ChiralSearch->second != nullptr) { ------------------ | Branch (2138:13): [True: 14.6k, False: 111k] | Branch (2138:13): [True: 14.6k, False: 111k] | Branch (2138:54): [True: 14.6k, False: 0] ------------------ 2139| 14.6k| int insertpos = bond->numConnections - 1; 2140| 14.6k| switch(insertpos) { 2141| 2.36k| case -1: ------------------ | Branch (2141:11): [True: 2.36k, False: 12.3k] ------------------ 2142| 2.36k| if (ChiralSearch->second->from != OBStereo::NoRef) ------------------ | Branch (2142:17): [True: 1.95k, False: 403] ------------------ 2143| 1.95k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Overwriting previous from reference id.", obWarning); 2144| 2.36k| (ChiralSearch->second)->from = mol.GetAtom(_prev)->GetId(); 2145| 2.36k| break; 2146| 7.52k| case 0: case 1: case 2: ------------------ | Branch (2146:11): [True: 3.24k, False: 11.4k] | Branch (2146:19): [True: 2.64k, False: 12.0k] | Branch (2146:27): [True: 1.63k, False: 13.0k] ------------------ 2147| 7.52k| if (ChiralSearch->second->refs[insertpos] != OBStereo::NoRef) ------------------ | Branch (2147:17): [True: 1.17k, False: 6.35k] ------------------ 2148| 1.17k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Overwriting previously set reference id.", obWarning); 2149| 7.52k| (ChiralSearch->second)->refs[insertpos] = mol.GetAtom(_prev)->GetId(); 2150| 7.52k| break; 2151| 4.78k| default: ------------------ | Branch (2151:11): [True: 4.78k, False: 9.88k] ------------------ 2152| 4.78k| obErrorLog.ThrowError(__FUNCTION__, "Warning: Tetrahedral stereo specified for atom with more than 4 connections.", obWarning); 2153| 4.78k| break; 2154| 14.6k| } 2155| 14.6k| } 2156| | 2157| | //CM ensure neither atoms in ring closure is a radical centre 2158| 125k| OBAtom* patom = mol.GetAtom(_prev); 2159| 125k| patom->SetSpinMultiplicity(0); 2160| 125k| patom = mol.GetAtom(bond->prev); 2161| 125k| patom->SetSpinMultiplicity(0); 2162| | //CM end 2163| 125k| _rclose.erase(bond); 2164| 125k| _updown = ' '; 2165| 125k| _order = 0; 2166| 125k| return true; 2167| 125k| } 2168| 471k| } 2169| | 2170| | //since no closures save another rclose bond 2171| 127k| RingClosureBond ringClosure; 2172| 127k| ringClosure.digit = digit; 2173| 127k| ringClosure.prev = _prev; 2174| 127k| ringClosure.order = _order; 2175| 127k| ringClosure.updown = _updown; 2176| | 2177| 127k| OBAtom* atom = mol.GetAtom(_prev); 2178| 127k| ringClosure.numConnections = NumConnections(atom); //store position to insert closure bond 2179| 127k| _rclose.push_back(ringClosure); 2180| 127k| _order = 0; 2181| 127k| _updown = ' '; 2182| | 2183| 127k| return(true); 2184| 253k| } _ZN9OpenBabel14OBSmilesParser14NumConnectionsEPNS_6OBAtomEb: 2190| 395k| { 2191| 395k| int val = atom->GetExplicitDegree(); 2192| | // The implicit H is not included in "val" so we need to adjust by 1 2193| 395k| if (isImplicitRef) ------------------ | Branch (2193:9): [True: 3.37k, False: 392k] ------------------ 2194| 3.37k| return val+1; 2195| | 2196| 392k| int idx = atom->GetIdx(); 2197| | // Need to adjust for any implicit H (e.g. [C@@H]) but only for atoms after the H. 2198| | // The following line controls for this. It uses the fact the _hcount is only set 2199| | // after this function is called to handle inserting the stereo ref for the implicit H. 2200| 392k| if (idx-1 < _hcount.size() && _hcount[idx-1] > 0) ------------------ | Branch (2200:9): [True: 392k, False: 422] | Branch (2200:35): [True: 18.8k, False: 373k] ------------------ 2201| 18.8k| val += _hcount[idx-1]; 2202| 392k| vector::iterator bond; 2203| | //correct for multiple closure bonds to a single atom 2204| 969k| for (bond = _rclose.begin(); bond != _rclose.end(); ++bond) ------------------ | Branch (2204:34): [True: 577k, False: 392k] ------------------ 2205| 577k| if (bond->prev == idx) ------------------ | Branch (2205:11): [True: 99.0k, False: 478k] ------------------ 2206| 99.0k| val++; 2207| | 2208| 392k| return val; 2209| 395k| } _ZN9OpenBabel9SMIFormatC2Ev: 119| 2| { 120| 2| OBConversion::RegisterFormat("smi",this, "chemical/x-daylight-smiles"); 121| 2| OBConversion::RegisterFormat("smiles",this, "chemical/x-daylight-smiles"); 122| 2| OBConversion::RegisterOptionParam("n", this); 123| 2| OBConversion::RegisterOptionParam("t", this); 124| 2| OBConversion::RegisterOptionParam("r", this); 125| 2| OBConversion::RegisterOptionParam("a", this); 126| 2| OBConversion::RegisterOptionParam("h", this); 127| 2| OBConversion::RegisterOptionParam("x", this); 128| 2| OBConversion::RegisterOptionParam("C", this); // "anti-canonical" form (random order) 129| 2| } _ZN9OpenBabel12CANSMIFormatC2Ev: 212| 2| { 213| 2| OBConversion::RegisterFormat("can", this, "chemical/x-daylight-cansmiles"); 214| 2| } _ZN9OpenBabel14OBSmilesParserC2Eb: 318| 9.18k| OBSmilesParser(bool preserve_aromaticity=false): _preserve_aromaticity(preserve_aromaticity), _rxnrole(1) { } _ZN9OpenBabel14OBSmilesParserD2Ev: 319| 9.18k| ~OBSmilesParser() { } smilesformat.cpp:_ZN9OpenBabelL15CanHaveLonePairEj: 64| 116k| { 65| 116k| switch (elem) { 66| 93.7k| case OBElements::Nitrogen: ------------------ | Branch (66:5): [True: 93.7k, False: 22.8k] ------------------ 67| 94.4k| case OBElements::Sulfur: ------------------ | Branch (67:5): [True: 683, False: 115k] ------------------ 68| 94.4k| return true; 69| 22.1k| default: ------------------ | Branch (69:5): [True: 22.1k, False: 94.4k] ------------------ 70| 22.1k| return false; 71| 116k| } 72| 116k| } _ZN9OpenBabel9FIXFormatC2Ev: 4249| 2| { 4250| 2| OBConversion::RegisterFormat("fix",this); 4251| 2| } _ZN9OpenBabel9FIXFormat5FlagsEv: 4266| 2| { 4267| 2| return NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 4268| 2| } smilesformat.cpp:_ZL13SmilesValencejjb: 43| 54.3M|{ 44| 54.3M| switch (elem) { ------------------ | Branch (44:11): [True: 7.88M, False: 46.5M] ------------------ 45| 7.92M| case 5: // B ------------------ | Branch (45:3): [True: 7.92M, False: 46.4M] ------------------ 46| 7.92M| if (val <= 3) return 3; ------------------ | Branch (46:9): [True: 7.91M, False: 7.21k] ------------------ 47| 7.21k| break; 48| 352k| case 6: // C ------------------ | Branch (48:3): [True: 352k, False: 54.0M] ------------------ 49| 352k| if (val <= 4) return 4; ------------------ | Branch (49:9): [True: 345k, False: 7.03k] ------------------ 50| 7.03k| break; 51| 23.2M| case 7: // N ------------------ | Branch (51:3): [True: 23.2M, False: 31.1M] ------------------ 52| 29.1M| case 15: // P ------------------ | Branch (52:3): [True: 5.80M, False: 48.5M] ------------------ 53| 29.1M| switch (val) { ------------------ | Branch (53:13): [True: 552, False: 29.1M] ------------------ 54| 188| case 0: ------------------ | Branch (54:5): [True: 188, False: 29.1M] ------------------ 55| 10.7k| case 1: ------------------ | Branch (55:5): [True: 10.5k, False: 29.0M] ------------------ 56| 29.0M| case 2: ------------------ | Branch (56:5): [True: 29.0M, False: 26.6k] ------------------ 57| 29.0M| case 3: ------------------ | Branch (57:5): [True: 5.59k, False: 29.0M] ------------------ 58| 29.0M| return 3; 59| 7.16k| case 4: ------------------ | Branch (59:5): [True: 7.16k, False: 29.0M] ------------------ 60| 9.76k| case 5: ------------------ | Branch (60:5): [True: 2.59k, False: 29.0M] ------------------ 61| 9.76k| return 5; 62| 29.1M| } 63| 552| break; 64| 8.27M| case 8: // O ------------------ | Branch (64:3): [True: 8.27M, False: 46.1M] ------------------ 65| 8.27M| if (val <= 2) return 2; ------------------ | Branch (65:9): [True: 8.26M, False: 18.3k] ------------------ 66| 18.3k| break; 67| 758k| case 16: // S ------------------ | Branch (67:3): [True: 758k, False: 53.6M] ------------------ 68| 758k| switch (val) { ------------------ | Branch (68:13): [True: 1.15k, False: 757k] ------------------ 69| 550| case 0: ------------------ | Branch (69:5): [True: 550, False: 757k] ------------------ 70| 574k| case 1: ------------------ | Branch (70:5): [True: 573k, False: 184k] ------------------ 71| 720k| case 2: ------------------ | Branch (71:5): [True: 145k, False: 612k] ------------------ 72| 720k| return 2; 73| 29.8k| case 3: ------------------ | Branch (73:5): [True: 29.8k, False: 728k] ------------------ 74| 35.1k| case 4: ------------------ | Branch (74:5): [True: 5.21k, False: 753k] ------------------ 75| 35.1k| return 4; 76| 1.47k| case 5: ------------------ | Branch (76:5): [True: 1.47k, False: 756k] ------------------ 77| 1.98k| case 6: ------------------ | Branch (77:5): [True: 517, False: 757k] ------------------ 78| 1.98k| return 6; 79| 758k| } 80| 1.15k| break; 81| 86.8k| case 9: // F ------------------ | Branch (81:3): [True: 86.8k, False: 54.3M] ------------------ 82| 87.0k| case 17: // Cl ------------------ | Branch (82:3): [True: 196, False: 54.3M] ------------------ 83| 87.2k| case 35: // Br ------------------ | Branch (83:3): [True: 194, False: 54.3M] ------------------ 84| 94.2k| case 53: // I ------------------ | Branch (84:3): [True: 7.05k, False: 54.3M] ------------------ 85| 94.2k| if (val <= 1) return 1; ------------------ | Branch (85:9): [True: 777, False: 93.4k] ------------------ 86| 93.4k| break; 87| 54.3M| } 88| 8.01M| return reading ? val : 0; ------------------ | Branch (88:10): [True: 8.01M, False: 0] ------------------ 89| 54.3M|} _ZN9OpenBabel9STLFormatC2Ev: 67| 2| { 68| 2| OpenBabel::OBConversion::RegisterFormat( "stl", this ); 69| | /* 70| | OBConversion::RegisterOptionParam("p", this, 1, OBConversion::OUTOPTIONS); 71| | OBConversion::RegisterOptionParam("s", this, 1, OBConversion::OUTOPTIONS); 72| | OBConversion::RegisterOptionParam("c", this, 1, OBConversion::OUTOPTIONS); 73| | */ 74| 2| } _ZN9OpenBabel9STLFormat5FlagsEv: 98| 2| { 99| 2| return WRITEONEONLY | NOTREADABLE; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ return WRITEONEONLY | NOTREADABLE; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ 100| 2| } _ZN9OpenBabel9SVGFormatC2Ev: 33| 2| { 34| 2| OBConversion::RegisterFormat("svg",this); 35| 2| OBConversion::RegisterOptionParam("N", this, 1, OBConversion::OUTOPTIONS); 36| 2| OBConversion::RegisterOptionParam("rows", this, 1, OBConversion::GENOPTIONS); 37| 2| OBConversion::RegisterOptionParam("cols", this, 1, OBConversion::GENOPTIONS); 38| 2| OBConversion::RegisterOptionParam("px", this, 1, OBConversion::GENOPTIONS); 39| 2| } _ZN9OpenBabel9SVGFormat5FlagsEv: 157| 2| { 158| 2| return NOTREADABLE | ZEROATOMSOK | DEPICTION2D; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | ZEROATOMSOK | DEPICTION2D; ------------------ | | 34| 2|#define ZEROATOMSOK 0x08 ------------------ return NOTREADABLE | ZEROATOMSOK | DEPICTION2D; ------------------ | | 39| 2|#define DEPICTION2D 0x100 ------------------ 159| 2| } _ZN9OpenBabel10TextFormatC2Ev: 25| 2| { 26| 2| OBConversion::RegisterFormat("text",this); 27| 2| } _ZN9OpenBabel12ThermoFormatC2Ev: 38| 2| { 39| 2| OBConversion::RegisterFormat("therm",this); 40| 2| OBConversion::RegisterFormat("tdd",this); 41| 2| } _ZN9OpenBabel12TinkerFormatC2Ev: 38| 2| { 39| 2| OBConversion::RegisterFormat("txyz",this); 40| 2| } _ZN9OpenBabel12TinkerFormat5FlagsEv: 65| 2| { 66| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 67| 2| } _ZN9OpenBabel11TitleFormatC2Ev: 29| 2| { 30| 2| OBConversion::RegisterFormat("txt",this); 31| 2| } _ZN9OpenBabel11TitleFormat5FlagsEv: 39| 2| unsigned int Flags() override { return ZEROATOMSOK; } ------------------ | | 34| 2|#define ZEROATOMSOK 0x08 ------------------ _ZN9OpenBabel15TurbomoleFormatC2Ev: 37| 2| { 38| 2| OBConversion::RegisterFormat("tmol",this); 39| 2| OBConversion::RegisterOptionParam("a", this, OBConversion::INOPTIONS); 40| 2| } _ZN9OpenBabel15TurbomoleFormat5FlagsEv: 60| 2| { 61| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 62| 2| } _ZN9OpenBabel13UniChemFormatC2Ev: 33| 2| { 34| 2| OBConversion::RegisterFormat("unixyz",this); 35| 2| } _ZN9OpenBabel13UniChemFormat5FlagsEv: 52| 2| { 53| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 54| 2| } _ZN9OpenBabel10VASPFormatC2Ev: 65| 2| { 66| | // This will actually read the CONTCAR file: 67| 2| OBConversion::RegisterFormat("CONTCAR",this); 68| 2| OBConversion::RegisterFormat("POSCAR",this); 69| 2| OBConversion::RegisterFormat("VASP",this); 70| 2| OBConversion::RegisterOptionParam("s", this, 0, OBConversion::INOPTIONS); 71| 2| OBConversion::RegisterOptionParam("b", this, 0, OBConversion::INOPTIONS); 72| 2| OBConversion::RegisterOptionParam("w", this, 0, OBConversion::OUTOPTIONS); 73| 2| OBConversion::RegisterOptionParam("z", this, 0, OBConversion::OUTOPTIONS); 74| 2| OBConversion::RegisterOptionParam("4", this, 0, OBConversion::OUTOPTIONS); 75| 2| } _ZN9OpenBabel10VASPFormat5FlagsEv: 122| 6| { 123| 6| return READONEONLY; ------------------ | | 32| 6|#define READONEONLY 0x02 ------------------ 124| 6| } _ZN9OpenBabel13ViewMolFormatC2Ev: 32| 2| { 33| 2| OBConversion::RegisterFormat("vmol",this); 34| 2| } _ZN9OpenBabel13ViewMolFormat5FlagsEv: 51| 2| { 52| 2| return READONEONLY | WRITEONEONLY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 53| 2| } _ZN9OpenBabel9XEDFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("xed",this); 37| 2| } _ZN9OpenBabel9XEDFormat5FlagsEv: 52| 2| { 53| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 54| 2| } _ZN9OpenBabel9XSFFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("xsf",this); 37| | // animation variant 38| 2| OBConversion::RegisterFormat("axsf",this); 39| 2| } _ZN9OpenBabel9XSFFormat5FlagsEv: 56| 4| { 57| 4| return READONEONLY | NOTWRITABLE; ------------------ | | 32| 4|#define READONEONLY 0x02 ------------------ return READONEONLY | NOTWRITABLE; ------------------ | | 35| 4|#define NOTWRITABLE 0x10 ------------------ 58| 4| } _ZN9OpenBabel9XYZFormatC2Ev: 35| 2| { 36| 2| OBConversion::RegisterFormat("xyz", this, "chemical/x-xyz"); 37| 2| } _ZN9OpenBabel9YOBFormatC2Ev: 320| 2| { 321| 2| OBConversion::RegisterFormat("yob",this); 322| 2| } _ZN9OpenBabel9YOBFormat5FlagsEv: 337| 2| { 338| 2| return READONEONLY|READBINARY|WRITEBINARY; ------------------ | | 32| 2|#define READONEONLY 0x02 ------------------ return READONEONLY|READBINARY|WRITEBINARY; ------------------ | | 33| 2|#define READBINARY 0x04 ------------------ return READONEONLY|READBINARY|WRITEBINARY; ------------------ | | 37| 2|#define WRITEBINARY 0x40 ------------------ 339| 2| } _ZN9OpenBabel11ZINDOFormatC2Ev: 33| 2| { 34| 2| OBConversion::RegisterFormat("zin",this); 35| 2| } _ZN9OpenBabel11ZINDOFormat5FlagsEv: 52| 2| { 53| 2| return NOTREADABLE | WRITEONEONLY; ------------------ | | 31| 2|#define NOTREADABLE 0x01 ------------------ return NOTREADABLE | WRITEONEONLY; ------------------ | | 36| 2|#define WRITEONEONLY 0x20 ------------------ 54| 2| } _ZN9OpenBabel13OBGenericDataC2ENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjNS_10DataOriginE: 169| 9.70M| { } _ZN9OpenBabel14OBExternalBondC2EPNS_6OBAtomEPNS_6OBBondEi: 208| 254| { } _ZN9OpenBabel14OBExternalBondC2ERKS0_: 212| 445| { } _ZN9OpenBabel18OBExternalBondDataC2Ev: 221| 104| { } _ZN9OpenBabel18OBExternalBondData7SetDataEPNS_6OBAtomEPNS_6OBBondEi: 224| 254| { 225| 254| OBExternalBond xb(atom,bond,idx); 226| 254| _vexbnd.push_back(xb); 227| 254| } _ZN9OpenBabel10OBRingDataC2Ev: 810| 4.91k| { 811| 4.91k| _vr.clear(); 812| 4.91k| } _ZN9OpenBabel10OBRingDataD2Ev: 836| 4.91k| { 837| 4.91k| vector::iterator ring; 838| 96.0k| for (ring = _vr.begin();ring != _vr.end();++ring) ------------------ | Branch (838:29): [True: 91.1k, False: 4.91k] ------------------ 839| 91.1k| { 840| 91.1k| delete *ring; 841| 91.1k| } 842| 4.91k| } _ZN9OpenBabel9Kekulizer17AssignDoubleBondsEv: 184| 6.52k| { 185| 6.52k| int bit; 186| 7.01M| for (bit = doubleBonds->FirstBit(); bit != doubleBonds->EndBit(); bit = doubleBonds->NextBit(bit)) { ------------------ | Branch (186:41): [True: 7.00M, False: 6.52k] ------------------ 187| 7.00M| m_mol->GetBond(bit)->SetBondOrder(2); 188| 7.00M| } 189| 6.52k| } _ZN9OpenBabel9Kekulizer11GreedyMatchEv: 192| 6.52k| { 193| | 194| | // What atoms need a double bond? The job of kekulization is 195| | // to give all of these atoms a single double bond. 196| 6.52k| needs_dbl_bond = new OBBitVec(atomArraySize); // defaults to all False 197| 54.5M| FOR_ATOMS_OF_MOL(atom, m_mol) { ------------------ | | 398| 54.5M|#define FOR_ATOMS_OF_MOL(a,m) for( OpenBabel::OBMolAtomIter a(m); a; ++a ) | | ------------------ | | | Branch (398:75): [True: 54.5M, False: 6.52k] | | ------------------ ------------------ 198| 54.5M| if (NeedsDoubleBond(&*atom)) { ------------------ | Branch (198:11): [True: 22.3M, False: 32.1M] ------------------ 199| 22.3M| needs_dbl_bond->SetBitOn(atom->GetIdx()); 200| 22.3M| } 201| 54.5M| } 202| | // Make a copy of needs_dbl_bond, to restrict the traversal in BackTrack() 203| 6.52k| kekule_system = new OBBitVec(*needs_dbl_bond); 204| | 205| | // Create lookup of degrees 206| 6.52k| unsigned int *degrees = (unsigned int*)calloc(atomArraySize,sizeof(unsigned int)); 207| 6.52k| std::vector degreeOneAtoms; 208| 54.5M| FOR_ATOMS_OF_MOL(atom, m_mol) { ------------------ | | 398| 54.5M|#define FOR_ATOMS_OF_MOL(a,m) for( OpenBabel::OBMolAtomIter a(m); a; ++a ) | | ------------------ | | | Branch (398:75): [True: 54.5M, False: 6.52k] | | ------------------ ------------------ 209| 54.5M| unsigned int atom_idx = atom->GetIdx(); 210| 54.5M| if (!needs_dbl_bond->BitIsSet(atom_idx)) { ------------------ | Branch (210:11): [True: 32.1M, False: 22.3M] ------------------ 211| 32.1M| degrees[atom_idx] = 0; 212| 32.1M| continue; 213| 32.1M| } 214| 22.3M| unsigned int mdeg = 0; 215| 44.2M| FOR_BONDS_OF_ATOM(bond, &*atom) { ------------------ | | 401| 66.6M|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 44.2M, False: 22.3M] | | ------------------ ------------------ 216| 44.2M| if (!bond->IsAromatic()) continue; ------------------ | Branch (216:13): [True: 10.9M, False: 33.3M] ------------------ 217| 33.3M| OBAtom *nbr = bond->GetNbrAtom(&*atom); 218| 33.3M| if (needs_dbl_bond->BitIsSet(nbr->GetIdx())) ------------------ | Branch (218:13): [True: 27.4M, False: 5.93M] ------------------ 219| 27.4M| mdeg++; 220| 33.3M| } 221| 22.3M| degrees[atom_idx] = mdeg; 222| 22.3M| if (mdeg == 1) ------------------ | Branch (222:11): [True: 765k, False: 21.6M] ------------------ 223| 765k| degreeOneAtoms.push_back(&*atom); 224| 22.3M| } 225| | 226| | // Location of assigned double bonds 227| 6.52k| doubleBonds = new OBBitVec(bondArraySize); // defaults to all False 228| | 229| 6.52k| bool finished = false; 230| 13.3k| while (true) { // Main loop ------------------ | Branch (230:12): [Folded - Ignored] ------------------ 231| | 232| | // Complete all of the degree one nodes 233| 7.41M| while (!degreeOneAtoms.empty()) { ------------------ | Branch (233:14): [True: 7.40M, False: 13.3k] ------------------ 234| 7.40M| OBAtom* atom = degreeOneAtoms.back(); 235| 7.40M| degreeOneAtoms.pop_back(); 236| | // some nodes may already have been handled 237| 7.40M| if (!needs_dbl_bond->BitIsSet(atom->GetIdx())) continue; ------------------ | Branch (237:13): [True: 338k, False: 7.06M] ------------------ 238| 7.17M| FOR_BONDS_OF_ATOM(bond, atom) { ------------------ | | 401| 7.23M|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 7.17M, False: 66.3k] | | ------------------ ------------------ 239| 7.17M| if (!bond->IsAromatic()) continue; ------------------ | Branch (239:15): [True: 42.0k, False: 7.13M] ------------------ 240| 7.13M| OBAtom *nbr = bond->GetNbrAtom(&*atom); 241| 7.13M| if (!needs_dbl_bond->BitIsSet(nbr->GetIdx())) continue; ------------------ | Branch (241:15): [True: 133k, False: 6.99M] ------------------ 242| | // create a double bond from atom -> nbr 243| 6.99M| doubleBonds->SetBitOn(bond->GetIdx()); 244| 6.99M| needs_dbl_bond->SetBitOff(atom->GetIdx()); 245| 6.99M| needs_dbl_bond->SetBitOff(nbr->GetIdx()); 246| | // now update degree information for nbr's neighbors 247| 14.0M| FOR_BONDS_OF_ATOM(nbrbond, nbr) { ------------------ | | 401| 21.0M|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 14.0M, False: 6.99M] | | ------------------ ------------------ 248| 14.0M| if (&(*nbrbond) == &(*bond) || !nbrbond->IsAromatic()) continue; ------------------ | Branch (248:17): [True: 6.99M, False: 7.05M] | Branch (248:44): [True: 311k, False: 6.74M] ------------------ 249| 6.74M| OBAtom* nbrnbr = nbrbond->GetNbrAtom(nbr); 250| 6.74M| unsigned int nbrnbrIdx = nbrnbr->GetIdx(); 251| 6.74M| if (!needs_dbl_bond->BitIsSet(nbrnbrIdx)) continue; ------------------ | Branch (251:17): [True: 52.1k, False: 6.69M] ------------------ 252| 6.69M| degrees[nbrnbrIdx]--; 253| 6.69M| if (degrees[nbrnbrIdx] == 1) ------------------ | Branch (253:17): [True: 6.62M, False: 68.6k] ------------------ 254| 6.62M| degreeOneAtoms.push_back(nbrnbr); 255| 6.69M| } 256| | // only a single double bond can be made to atom so we can break here 257| 6.99M| break; 258| 7.13M| } 259| 7.06M| } 260| | 261| 13.3k| if (needs_dbl_bond->IsEmpty()) { ------------------ | Branch (261:11): [True: 1.72k, False: 11.5k] ------------------ 262| 1.72k| finished = true; 263| 1.72k| break; 264| 1.72k| } 265| | 266| | // Now handle any remaining degree 2 or 3 nodes 267| | // We handle deg 2 nodes first and then 3, and the iteration over these nodes 268| | // is abstracted away. Once a double-bond is added that generates more 269| | // degree one nodes, then the iterator is exited 270| 11.5k| NodeIterator iterator(degrees, atomArraySize); 271| 11.5k| bool change = false; 272| 9.15M| while (unsigned int atomIdx = iterator.next()) { ------------------ | Branch (272:27): [True: 9.14M, False: 4.79k] ------------------ 273| 9.14M| if (!needs_dbl_bond->BitIsSet(atomIdx)) continue; ------------------ | Branch (273:13): [True: 9.13M, False: 7.99k] ------------------ 274| | // The following is almost identical to the code above for deg 1 atoms 275| | // except for handling the variable 'change' 276| 7.99k| OBAtom *atom = m_mol->GetAtom(atomIdx); 277| 17.4k| FOR_BONDS_OF_ATOM(bond, atom) { ------------------ | | 401| 17.4k|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 17.4k, False: 0] | | ------------------ ------------------ 278| 17.4k| if (!bond->IsAromatic()) continue; ------------------ | Branch (278:15): [True: 4.93k, False: 12.5k] ------------------ 279| 12.5k| OBAtom *nbr = bond->GetNbrAtom(&*atom); 280| 12.5k| if (!needs_dbl_bond->BitIsSet(nbr->GetIdx())) continue; ------------------ | Branch (280:15): [True: 4.53k, False: 7.99k] ------------------ 281| | // create a double bond from atom -> nbr 282| 7.99k| doubleBonds->SetBitOn(bond->GetIdx()); 283| 7.99k| needs_dbl_bond->SetBitOff(atomIdx); 284| 7.99k| needs_dbl_bond->SetBitOff(nbr->GetIdx()); 285| | // now update degree information for both atom's and nbr's neighbors 286| 23.9k| for(int N=0; N<2; N++) { ------------------ | Branch (286:24): [True: 15.9k, False: 7.99k] ------------------ 287| 15.9k| OBAtom *ref = N == 0 ? atom : nbr; ------------------ | Branch (287:27): [True: 7.99k, False: 7.99k] ------------------ 288| 58.9k| FOR_BONDS_OF_ATOM(nbrbond, ref) { ------------------ | | 401| 74.9k|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 58.9k, False: 15.9k] | | ------------------ ------------------ 289| 58.9k| if (&(*nbrbond) == &(*bond) || !nbrbond->IsAromatic()) continue; ------------------ | Branch (289:19): [True: 15.9k, False: 42.9k] | Branch (289:46): [True: 7.71k, False: 35.2k] ------------------ 290| 35.2k| OBAtom* nbrnbr = nbrbond->GetNbrAtom(ref); 291| 35.2k| unsigned int nbrnbrIdx = nbrnbr->GetIdx(); 292| 35.2k| if (!needs_dbl_bond->BitIsSet(nbrnbrIdx)) continue; ------------------ | Branch (292:19): [True: 13.2k, False: 22.0k] ------------------ 293| 22.0k| degrees[nbrnbrIdx]--; 294| 22.0k| if (degrees[nbrnbrIdx] == 1) { ------------------ | Branch (294:19): [True: 9.77k, False: 12.2k] ------------------ 295| 9.77k| degreeOneAtoms.push_back(nbrnbr); 296| 9.77k| change = true; 297| 9.77k| } 298| 22.0k| } 299| 15.9k| } 300| | // only a single double bond can be made to atom so we can break here 301| 7.99k| break; 302| 12.5k| } 303| 7.99k| if (change) ------------------ | Branch (303:13): [True: 6.79k, False: 1.19k] ------------------ 304| 6.79k| break; // exit the iterator once we have actually set a double bond 305| 7.99k| } 306| | 307| | // We exit if we are finished or if no degree 2/3 nodes can be set 308| 11.5k| if (!change) ------------------ | Branch (308:11): [True: 4.79k, False: 6.79k] ------------------ 309| 4.79k| break; 310| 11.5k| } 311| | 312| | // Tidy up 313| 6.52k| free(degrees); 314| | 315| 6.52k| return finished; 316| 6.52k| } _ZN9OpenBabel9Kekulizer8FindPathEjbRNS_8OBBitVecE: 321| 28.9M| { 322| 28.9M| if (needs_dbl_bond->BitIsSet(atomidx)) ------------------ | Branch (322:9): [True: 759, False: 28.9M] ------------------ 323| 759| return true; 324| 28.9M| visited.SetBitOn(atomidx); 325| 28.9M| OBAtom* atom = m_mol->GetAtom(atomidx); 326| 132M| FOR_BONDS_OF_ATOM(bond, atom) { ------------------ | | 401| 161M|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 132M, False: 28.7M] | | ------------------ ------------------ 327| 132M| if (!bond->IsAromatic()) continue; ------------------ | Branch (327:11): [True: 11.0M, False: 121M] ------------------ 328| 121M| OBAtom *nbr = bond->GetNbrAtom(atom); 329| 121M| if (!kekule_system->BitIsSet(nbr->GetIdx())) continue; ------------------ | Branch (329:11): [True: 7.52M, False: 113M] ------------------ 330| 113M| if (doubleBonds->BitIsSet(bond->GetIdx()) == isDoubleBond) { ------------------ | Branch (330:11): [True: 25.5M, False: 88.3M] ------------------ 331| 25.5M| if (visited.BitIsSet(nbr->GetIdx())) continue; ------------------ | Branch (331:13): [True: 4.95M, False: 20.5M] ------------------ 332| 20.5M| bool found_path = FindPath(nbr->GetIdx(), !isDoubleBond, visited); 333| 20.5M| if (found_path) { ------------------ | Branch (333:13): [True: 195k, False: 20.3M] ------------------ 334| 195k| m_path.push_back(nbr->GetIdx()); 335| 195k| return true; 336| 195k| } 337| 20.5M| } 338| 113M| } 339| 28.7M| visited.SetBitOff(atomidx); 340| 28.7M| return false; 341| 28.9M| } _ZN9OpenBabel9Kekulizer9BackTrackEv: 344| 4.79k| { 345| | // With an odd number of bits, it's never going to kekulize fully, but let's fill in as many as we can 346| 4.79k| unsigned int count = needs_dbl_bond->CountBits(); 347| | 348| 4.79k| unsigned int total_handled = 0; 349| 4.79k| int idx; 350| 8.37M| for (idx = needs_dbl_bond->FirstBit(); idx != needs_dbl_bond->EndBit(); idx = needs_dbl_bond->NextBit(idx)) { ------------------ | Branch (350:44): [True: 8.37M, False: 95] ------------------ 351| 8.37M| total_handled++; 352| | // If there is no additional bit available to match this bit, then terminate 353| 8.37M| if (total_handled == count) ------------------ | Branch (353:11): [True: 4.69k, False: 8.37M] ------------------ 354| 4.69k| return false; 355| | 356| | // Our goal is to find an alternating path to another atom 357| | // that needs a double bond 358| 8.37M| needs_dbl_bond->SetBitOff(idx); // to avoid the trivial null path being found 359| 8.37M| OBBitVec visited(atomArraySize); 360| 8.37M| m_path.clear(); 361| 8.37M| bool found_path = FindPath(idx, false, visited); 362| 8.37M| if (!found_path) { // could only happen if not kekulizable ------------------ | Branch (362:11): [True: 8.36M, False: 759] ------------------ 363| 8.36M| needs_dbl_bond->SetBitOn(idx); // reset 364| 8.36M| continue; 365| 8.36M| } 366| 759| total_handled++; 367| 759| m_path.push_back(idx); 368| 759| needs_dbl_bond->SetBitOff(m_path[0]); 369| | // Flip all of the bond orders on the path from double<-->single 370| 195k| for (unsigned int i = 0; i < m_path.size()-1; ++i) { ------------------ | Branch (370:32): [True: 195k, False: 759] ------------------ 371| 195k| OBBond *bond = m_mol->GetBond(m_path[i], m_path[i + 1]); 372| 195k| if (i % 2 == 0) ------------------ | Branch (372:13): [True: 97.9k, False: 97.1k] ------------------ 373| 97.9k| doubleBonds->SetBitOn(bond->GetIdx()); 374| 97.1k| else 375| 97.1k| doubleBonds->SetBitOff(bond->GetIdx()); 376| 195k| } 377| 759| } 378| 95| return needs_dbl_bond->IsEmpty(); 379| 4.79k| } _ZN9OpenBabel10OBKekulizeEPNS_5OBMolE: 412| 6.52k| { 413| 6.52k| Kekulizer kekulizer(mol); 414| 6.52k| bool success = kekulizer.GreedyMatch(); 415| 6.52k| if (!success) { ------------------ | Branch (415:9): [True: 4.79k, False: 1.72k] ------------------ 416| 4.79k| success = kekulizer.BackTrack(); 417| 4.79k| } 418| | 419| 6.52k| kekulizer.AssignDoubleBonds(); 420| | 421| 6.52k| return success; 422| 6.52k| } kekulize.cpp:_ZN9OpenBabelL15NeedsDoubleBondEPNS_6OBAtomE: 87| 54.5M| { 88| 54.5M| if (!atom->IsAromatic()) ------------------ | Branch (88:9): [True: 23.8M, False: 30.6M] ------------------ 89| 23.8M| return false; 90| | 91| | // Does it already have an explicit double bond? 92| 61.1M| FOR_BONDS_OF_ATOM(bond, atom) { ------------------ | | 401| 91.7M|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 61.1M, False: 30.5M] | | ------------------ ------------------ 93| 61.1M| if (bond->IsAromatic()) continue; ------------------ | Branch (93:11): [True: 44.7M, False: 16.4M] ------------------ 94| 16.4M| OBAtom *nbr = bond->GetNbrAtom(atom); 95| 16.4M| switch (bond->GetBondOrder()) { 96| 16.4M| case 0: case 1: ------------------ | Branch (96:7): [True: 3.83k, False: 16.4M] | Branch (96:15): [True: 16.4M, False: 45.9k] ------------------ 97| 16.4M| continue; 98| 21.5k| case 2: ------------------ | Branch (98:7): [True: 21.5k, False: 16.4M] ------------------ 99| 21.5k| if (IsSpecialCase(atom)) ------------------ | Branch (99:13): [True: 4.17k, False: 17.3k] ------------------ 100| 4.17k| return true; 101| 17.3k| return false; 102| 20.5k| default: // bond order > 2 ------------------ | Branch (102:7): [True: 20.5k, False: 16.4M] ------------------ 103| 20.5k| return false; 104| 16.4M| } 105| 16.4M| } 106| | 107| | // Is it one of the cases where we know that it only has single bonds? 108| 30.5M| int chg = atom->GetFormalCharge(); 109| 30.5M| int deg = atom->GetTotalDegree(); 110| 30.5M| switch (atom->GetAtomicNum()) { ------------------ | Branch (110:13): [True: 407, False: 30.5M] ------------------ 111| 343k| case 6: ------------------ | Branch (111:5): [True: 343k, False: 30.2M] ------------------ 112| 343k| if (deg == 3 && (chg == 1 || chg == -1)) ------------------ | Branch (112:11): [True: 323k, False: 20.6k] | Branch (112:24): [True: 107, False: 323k] | Branch (112:36): [True: 380, False: 322k] ------------------ 113| 487| return false; 114| 343k| break; 115| 21.4M| case 5: case 7: case 15: case 33: case 51: case 83: ------------------ | Branch (115:5): [True: 7.91M, False: 22.6M] | Branch (115:13): [True: 7.80M, False: 22.7M] | Branch (115:21): [True: 5.72M, False: 24.8M] | Branch (115:30): [True: 980, False: 30.5M] | Branch (115:39): [True: 209, False: 30.5M] | Branch (115:48): [True: 198, False: 30.5M] ------------------ 116| 21.4M| switch (chg) { ------------------ | Branch (116:15): [True: 661, False: 21.4M] ------------------ 117| 21.4M| case 0: // e.g. a pyrrole-type nitrogen ------------------ | Branch (117:7): [True: 21.4M, False: 3.80k] ------------------ 118| 21.4M| if (deg == 3 || deg > 4) ------------------ | Branch (118:13): [True: 7.30k, False: 21.4M] | Branch (118:25): [True: 3.17k, False: 21.4M] ------------------ 119| 10.4k| return false; 120| 21.4M| break; 121| 21.4M| case -1: ------------------ | Branch (121:7): [True: 1.03k, False: 21.4M] ------------------ 122| 1.03k| if (deg == 2) ------------------ | Branch (122:13): [True: 622, False: 410] ------------------ 123| 622| return false; 124| 410| break; 125| 2.11k| case 1: ------------------ | Branch (125:7): [True: 2.11k, False: 21.4M] ------------------ 126| 2.11k| if (deg > 3) ------------------ | Branch (126:13): [True: 662, False: 1.44k] ------------------ 127| 662| return false; 128| 21.4M| } 129| 21.4M| break; 130| 21.4M| case 8: case 16: case 34: case 52: ------------------ | Branch (130:5): [True: 8.15M, False: 22.4M] | Branch (130:13): [True: 640k, False: 29.9M] | Branch (130:22): [True: 195, False: 30.5M] | Branch (130:31): [True: 195, False: 30.5M] ------------------ 131| 8.79M| switch (chg) { ------------------ | Branch (131:15): [True: 389, False: 8.79M] ------------------ 132| 8.79M| case 0: ------------------ | Branch (132:7): [True: 8.79M, False: 3.61k] ------------------ 133| 8.79M| if (deg == 2 || deg == 4 || deg > 5) ------------------ | Branch (133:13): [True: 8.18M, False: 606k] | Branch (133:25): [True: 6.43k, False: 600k] | Branch (133:37): [True: 517, False: 599k] ------------------ 134| 8.19M| return false; 135| 599k| break; 136| 599k| case -1: case 1: ------------------ | Branch (136:7): [True: 1.25k, False: 8.79M] | Branch (136:16): [True: 1.97k, False: 8.79M] ------------------ 137| 3.22k| if (deg == 3 || deg == 5 || deg > 6) ------------------ | Branch (137:13): [True: 756, False: 2.47k] | Branch (137:25): [True: 211, False: 2.25k] | Branch (137:37): [True: 303, False: 1.95k] ------------------ 138| 1.27k| return false; 139| 8.79M| } 140| 30.5M| } 141| | 142| 22.3M| return true; // It needs a double bond 143| 30.5M| } kekulize.cpp:_ZN9OpenBabelL13IsSpecialCaseEPNS_6OBAtomE: 69| 21.5k| { 70| 21.5k| switch(atom->GetAtomicNum()) { ------------------ | Branch (70:12): [True: 11.2k, False: 10.3k] ------------------ 71| 4.93k| case 7: ------------------ | Branch (71:5): [True: 4.93k, False: 16.6k] ------------------ 72| | // Any exo-cyclic double bond from a N 73| | // e.g. pyridine N-oxide as the double bond form 74| 4.93k| if (atom->GetTotalDegree() == 3 && atom->GetFormalCharge() == 0) ------------------ | Branch (74:11): [True: 3.79k, False: 1.14k] | Branch (74:42): [True: 3.54k, False: 241] ------------------ 75| 3.54k| return true; 76| 1.38k| break; 77| 5.37k| case 16: // e.g. Cs1(=O)ccccn1 but not O=s1(=O)cccn1 ------------------ | Branch (77:5): [True: 5.37k, False: 16.1k] ------------------ 78| 5.37k| if (atom->GetTotalDegree() == 4 && atom->GetFormalCharge() == 0 ------------------ | Branch (78:11): [True: 1.35k, False: 4.02k] | Branch (78:42): [True: 1.14k, False: 208] ------------------ 79| 5.37k| && atom->GetTotalValence() < 6) ------------------ | Branch (79:14): [True: 626, False: 522] ------------------ 80| 626| return true; 81| 4.75k| break; 82| 21.5k| } 83| 17.3k| return false; 84| 21.5k| } _ZN9OpenBabel12NodeIteratorC2ERPjj: 151| 11.5k| { } _ZN9OpenBabel12NodeIterator4nextEv: 153| 9.15M| { 154| 9.15M| m_counter++; 155| | 156| 9.15M| if (!finishedDegTwo) { // return deg 2 nodes first ------------------ | Branch (156:11): [True: 9.04M, False: 103k] ------------------ 157| 65.3M| for (; m_counter < m_atomArraySize; ++m_counter) { ------------------ | Branch (157:16): [True: 65.3M, False: 6.08k] ------------------ 158| 65.3M| if (m_degrees[m_counter] == 2) { ------------------ | Branch (158:15): [True: 9.04M, False: 56.2M] ------------------ 159| 9.04M| return m_counter; 160| 9.04M| } 161| 65.3M| } 162| 6.08k| finishedDegTwo = true; 163| 6.08k| m_counter = 1; // first atom has idx 1 164| 6.08k| } 165| | 166| | // return nodes with degree > 2 167| 54.9M| for (; m_counter < m_atomArraySize; ++m_counter) { ------------------ | Branch (167:14): [True: 54.9M, False: 4.79k] ------------------ 168| 54.9M| if (m_degrees[m_counter] > 2) { ------------------ | Branch (168:13): [True: 104k, False: 54.8M] ------------------ 169| 104k| return m_counter; 170| 104k| } 171| 54.9M| } 172| | 173| | // Finished - return 0 signalling the end of iteration 174| 4.79k| return 0; 175| 109k| } _ZN9OpenBabel9KekulizerC2EPNS_5OBMolE: 45| 6.52k| { 46| 6.52k| atomArraySize = GetMaxAtomIdx(m_mol) + 1; 47| 6.52k| bondArraySize = GetMaxBondIdx(m_mol) + 1; 48| 6.52k| } kekulize.cpp:_ZN9OpenBabelL13GetMaxAtomIdxEPNS_5OBMolE: 32| 6.52k| { 33| 6.52k| return mol->NumAtoms() + 1; 34| 6.52k| } kekulize.cpp:_ZN9OpenBabelL13GetMaxBondIdxEPNS_5OBMolE: 37| 6.52k| { 38| 6.52k| return mol->NumBonds(); 39| 6.52k| } _ZN9OpenBabel9KekulizerD2Ev: 49| 6.52k| ~Kekulizer() { 50| 6.52k| delete needs_dbl_bond; 51| 6.52k| delete doubleBonds; 52| 6.52k| delete kekule_system; 53| 6.52k| } _ZN9OpenBabel8OBLocaleC2Ev: 80| 2| { 81| 2| d = new OBLocalePrivate; 82| 2| } _ZN9OpenBabel8OBLocale9SetLocaleEv: 93| 9.18k| { 94| 9.18k| if (d->counter == 0) { ------------------ | Branch (94:9): [True: 9.18k, False: 0] ------------------ 95| | // Set the locale for number parsing to avoid locale issues: PR#1785463 96| |#if HAVE_USELOCALE 97| | // Extended per-thread interface 98| | d->old_locale = uselocale(d->new_c_num_locale); 99| |#else 100| 9.18k|#ifndef ANDROID 101| | // Original global POSIX interface 102| | // regular UNIX, no USELOCALE, no ANDROID 103| 9.18k| d->old_locale_string = strdup(setlocale(LC_NUMERIC, nullptr)); 104| |#else 105| | // ANDROID should stay as "C" -- Igor Filippov 106| | d->old_locale_string = "C"; 107| |#endif 108| 9.18k| setlocale(LC_NUMERIC, "C"); 109| 9.18k|#endif 110| 9.18k| } 111| | 112| 9.18k| ++d->counter; 113| 9.18k| } _ZN9OpenBabel8OBLocale13RestoreLocaleEv: 116| 9.18k| { 117| 9.18k| --d->counter; 118| 9.18k| if(d->counter == 0) { ------------------ | Branch (118:8): [True: 9.18k, False: 0] ------------------ 119| | // return the locale to the original one 120| |#ifdef HAVE_USELOCALE 121| | uselocale(d->old_locale); 122| |#else 123| 9.18k| setlocale(LC_NUMERIC, d->old_locale_string); 124| 9.18k|#ifndef ANDROID 125| | // Don't free on Android because "C" is a static ctring constant 126| 9.18k| free (d->old_locale_string); 127| 9.18k|#endif 128| 9.18k|#endif 129| 9.18k| } 130| 9.18k| } _ZN9OpenBabel15OBLocalePrivateC2Ev: 42| 2| { 43| |#if HAVE_USELOCALE 44| | new_c_num_locale = newlocale(LC_NUMERIC_MASK, NULL, NULL); 45| |#endif 46| 2| } _ZN9OpenBabel11SpaceGroupsC2Ev: 69| 2| { 70| 2| sgbi.assign(230, list()); 71| 2| _dir = BABEL_DATADIR; ------------------ | | 4| 2|#define BABEL_DATADIR "/usr/local/share/openbabel" ------------------ 72| 2| _envvar = "BABEL_DATADIR"; 73| 2| _filename = "space-groups.txt"; 74| 2| _subdir = "data"; 75| 2| _dataptr = SpaceGroupsData; 76| 2| } _ZN9OpenBabel5OBMol8SetTitleEPKc: 172| 349| { 173| 349| _title = title; 174| 349| Trim(_title); 175| 349| } _ZNK9OpenBabel5OBMol8GetTitleEb: 184| 11.0k| { 185| 11.0k| if (!replaceNewlines || _title.find('\n')== string::npos ) ------------------ | Branch (185:9): [True: 0, False: 11.0k] | Branch (185:29): [True: 11.0k, False: 0] ------------------ 186| 11.0k| return(_title.c_str()); 187| | 188| | //Only multiline titles use the following to replace newlines by spaces 189| 0| static string title; 190| 0| title=_title; 191| 0| string::size_type j; 192| 0| for ( ; (j = title.find_first_of( "\n\r" )) != string::npos ; ) { ------------------ | Branch (192:13): [True: 0, False: 0] ------------------ 193| 0| title.replace( j, 1, " "); 194| 0| } 195| | 196| 0| return(title.c_str()); 197| 11.0k| } _ZNK9OpenBabel5OBMol7GetAtomEi: 831| 550M| { 832| 550M| if ((unsigned)idx < 1 || (unsigned)idx > NumAtoms()) ------------------ | Branch (832:9): [True: 0, False: 550M] | Branch (832:30): [True: 1, False: 550M] ------------------ 833| 1| { 834| 1| obErrorLog.ThrowError(__FUNCTION__, "Requested Atom Out of Range", obDebug); 835| 1| return nullptr; 836| 1| } 837| | 838| 550M| return((OBAtom*)_vatom[idx-1]); 839| 550M| } _ZNK9OpenBabel5OBMol7GetBondEi: 859| 7.00M| { 860| 7.00M| if (idx < 0 || (unsigned)idx >= NumBonds()) ------------------ | Branch (860:9): [True: 0, False: 7.00M] | Branch (860:20): [True: 0, False: 7.00M] ------------------ 861| 0| { 862| 0| obErrorLog.ThrowError(__FUNCTION__, "Requested Bond Out of Range", obDebug); 863| 0| return nullptr; 864| 0| } 865| | 866| 7.00M| return((OBBond*)_vbond[idx]); 867| 7.00M| } _ZNK9OpenBabel5OBMol7GetBondEii: 880| 72.5M| { 881| 72.5M| return(GetBond(GetAtom(bgn),GetAtom(end))); 882| 72.5M| } _ZNK9OpenBabel5OBMol7GetBondEPNS_6OBAtomES2_: 885| 72.5M| { 886| 72.5M| OBAtom *nbr; 887| 72.5M| vector::iterator i; 888| | 889| 72.5M| if (!bgn || !end) return nullptr; ------------------ | Branch (889:9): [True: 0, False: 72.5M] | Branch (889:17): [True: 0, False: 72.5M] ------------------ 890| | 891| 2.78G| for (nbr = bgn->BeginNbrAtom(i);nbr;nbr = bgn->NextNbrAtom(i)) ------------------ | Branch (891:37): [True: 2.71G, False: 71.8M] ------------------ 892| 2.71G| if (nbr == end) ------------------ | Branch (892:11): [True: 657k, False: 2.71G] ------------------ 893| 657k| return((OBBond *)*i); 894| | 895| 71.8M| return nullptr; //just to keep the SGI compiler happy 896| 72.5M| } _ZN9OpenBabel5OBMol7GetSSSREv: 925| 4.91k| { 926| 4.91k| if (!HasSSSRPerceived()) ------------------ | Branch (926:9): [True: 4.91k, False: 0] ------------------ 927| 4.91k| FindSSSR(); 928| | 929| 4.91k| OBRingData *rd = nullptr; 930| 4.91k| if (!HasData("SSSR")) { ------------------ | Branch (930:9): [True: 1.36k, False: 3.55k] ------------------ 931| 1.36k| rd = new OBRingData(); 932| 1.36k| rd->SetAttribute("SSSR"); 933| 1.36k| SetData(rd); 934| 1.36k| } 935| | 936| 4.91k| rd = (OBRingData *) GetData("SSSR"); 937| 4.91k| rd->SetOrigin(perceived); 938| 4.91k| return(rd->GetData()); 939| 4.91k| } _ZN9OpenBabel5OBMol5ClearEv: 1439| 14.3k| { 1440| 14.3k| if (obErrorLog.GetOutputLevel() >= obAuditMsg) ------------------ | Branch (1440:9): [True: 0, False: 14.3k] ------------------ 1441| 0| obErrorLog.ThrowError(__FUNCTION__, 1442| 0| "Ran OpenBabel::Clear Molecule", obAuditMsg); 1443| | 1444| 14.3k| vector::iterator i; 1445| 14.3k| vector::iterator j; 1446| 30.2M| for (i = _vatom.begin();i != _vatom.end();++i) ------------------ | Branch (1446:29): [True: 30.2M, False: 14.3k] ------------------ 1447| 30.2M| { 1448| 30.2M| DestroyAtom(*i); 1449| 30.2M| *i = nullptr; 1450| 30.2M| } 1451| 30.0M| for (j = _vbond.begin();j != _vbond.end();++j) ------------------ | Branch (1451:29): [True: 30.0M, False: 14.3k] ------------------ 1452| 30.0M| { 1453| 30.0M| DestroyBond(*j); 1454| 30.0M| *j = nullptr; 1455| 30.0M| } 1456| | 1457| 14.3k| _atomIds.clear(); 1458| 14.3k| _bondIds.clear(); 1459| 14.3k| _natoms = _nbonds = 0; 1460| | 1461| | //Delete residues 1462| 14.3k| unsigned int ii; 1463| 14.3k| for (ii=0 ; ii<_residue.size() ; ++ii) ------------------ | Branch (1463:17): [True: 0, False: 14.3k] ------------------ 1464| 0| { 1465| 0| DestroyResidue(_residue[ii]); 1466| 0| } 1467| 14.3k| _residue.clear(); 1468| | 1469| | //clear out the multiconformer data 1470| 14.3k| vector::iterator k; 1471| 16.6k| for (k = _vconf.begin();k != _vconf.end();++k) ------------------ | Branch (1471:29): [True: 2.24k, False: 14.3k] ------------------ 1472| 2.24k| delete [] *k; 1473| 14.3k| _vconf.clear(); 1474| | 1475| | //Clear flags except OB_PATTERN_STRUCTURE which is left the same 1476| 14.3k| _flags &= OB_PATTERN_STRUCTURE; ------------------ | | 101| 14.3k|#define OB_PATTERN_STRUCTURE (1<<19) ------------------ 1477| | 1478| 14.3k| _c = nullptr; 1479| 14.3k| _mod = 0; 1480| | 1481| | // Clean up generic data via the base class 1482| 14.3k| return(OBBase::Clear()); 1483| 14.3k| } _ZN9OpenBabel5OBMol11BeginModifyEv: 1486| 9.18k| { 1487| | //suck coordinates from _c into _v for each atom 1488| 9.18k| if (!_mod && !Empty()) ------------------ | Branch (1488:9): [True: 9.18k, False: 0] | Branch (1488:18): [True: 0, False: 9.18k] ------------------ 1489| 0| { 1490| 0| OBAtom *atom; 1491| 0| vector::iterator i; 1492| 0| for (atom = BeginAtom(i);atom;atom = NextAtom(i)) ------------------ | Branch (1492:34): [True: 0, False: 0] ------------------ 1493| 0| { 1494| 0| atom->SetVector(); 1495| 0| atom->ClearCoordPtr(); 1496| 0| } 1497| | 1498| 0| vector::iterator j; 1499| 0| for (j = _vconf.begin();j != _vconf.end();++j) ------------------ | Branch (1499:33): [True: 0, False: 0] ------------------ 1500| 0| delete [] *j; 1501| | 1502| 0| _c = nullptr; 1503| 0| _vconf.clear(); 1504| | 1505| | //Destroy rotamer list if necessary 1506| 0| if ((OBRotamerList *)GetData(OBGenericDataType::RotamerList)) ------------------ | Branch (1506:13): [True: 0, False: 0] ------------------ 1507| 0| { 1508| 0| delete (OBRotamerList *)GetData(OBGenericDataType::RotamerList); 1509| 0| DeleteData(OBGenericDataType::RotamerList); 1510| 0| } 1511| 0| } 1512| | 1513| 9.18k| _mod++; 1514| 9.18k| } _ZN9OpenBabel5OBMol9EndModifyEb: 1517| 8.95k| { 1518| 8.95k| if (_mod == 0) ------------------ | Branch (1518:9): [True: 0, False: 8.95k] ------------------ 1519| 0| { 1520| 0| obErrorLog.ThrowError(__FUNCTION__, "_mod is negative - EndModify() called too many times", obDebug); 1521| 0| return; 1522| 0| } 1523| | 1524| 8.95k| _mod--; 1525| | 1526| 8.95k| if (_mod) ------------------ | Branch (1526:9): [True: 0, False: 8.95k] ------------------ 1527| 0| return; 1528| | 1529| | // wipe all but whether it has aromaticity perceived, is a reaction, or has periodic boundaries enabled 1530| 8.95k| if (nukePerceivedData) ------------------ | Branch (1530:9): [True: 2.43k, False: 6.52k] ------------------ 1531| 2.43k| _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL); ------------------ | | 77| 2.43k|#define OB_AROMATIC_MOL (1<<3) ------------------ _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL); ------------------ | | 107| 2.43k|#define OB_REACTION_MOL (1<<22) ------------------ _flags = _flags & (OB_AROMATIC_MOL|OB_REACTION_MOL|OB_PERIODIC_MOL); ------------------ | | 109| 2.43k|#define OB_PERIODIC_MOL (1<<23) ------------------ 1532| | 1533| 8.95k| _c = nullptr; 1534| | 1535| 8.95k| if (Empty()) ------------------ | Branch (1535:9): [True: 346, False: 8.61k] ------------------ 1536| 346| return; 1537| | 1538| | //if atoms present convert coords into array 1539| 8.61k| double *c = new double [NumAtoms()*3]; 1540| 8.61k| _c = c; 1541| | 1542| 8.61k| unsigned int idx; 1543| 8.61k| OBAtom *atom; 1544| 8.61k| vector::iterator j; 1545| 67.1M| for (idx=0,atom = BeginAtom(j);atom;atom = NextAtom(j),++idx) ------------------ | Branch (1545:36): [True: 67.1M, False: 8.61k] ------------------ 1546| 67.1M| { 1547| 67.1M| atom->SetIdx(idx+1); 1548| 67.1M| (atom->GetVector()).Get(&_c[idx*3]); 1549| 67.1M| atom->SetCoordPtr(&_c); 1550| 67.1M| } 1551| 8.61k| _vconf.push_back(c); 1552| | 1553| | // Always remove angle and torsion data, since they will interfere with the iterators 1554| | // PR#2812013 1555| 8.61k| DeleteData(OBGenericDataType::AngleData); 1556| 8.61k| DeleteData(OBGenericDataType::TorsionData); 1557| 8.61k| } _ZN9OpenBabel5OBMol11DestroyAtomEPNS_6OBAtomE: 1560| 84.7M| { 1561| 84.7M| if (atom) ------------------ | Branch (1561:9): [True: 71.8M, False: 12.9M] ------------------ 1562| 71.8M| { 1563| 71.8M| delete atom; 1564| 71.8M| atom = nullptr; 1565| 71.8M| } 1566| 84.7M| } _ZN9OpenBabel5OBMol11DestroyBondEPNS_6OBBondE: 1569| 84.6M| { 1570| 84.6M| if (bond) ------------------ | Branch (1570:9): [True: 71.8M, False: 12.7M] ------------------ 1571| 71.8M| { 1572| 71.8M| delete bond; 1573| 71.8M| bond = nullptr; 1574| 71.8M| } 1575| 84.6M| } _ZN9OpenBabel5OBMol7NewAtomEv: 1587| 71.8M| { 1588| 71.8M| return NewAtom(_atomIds.size()); 1589| 71.8M| } _ZN9OpenBabel5OBMol7NewAtomEm: 1596| 71.8M| { 1597| | // BeginModify(); 1598| | 1599| | // resize _atomIds if needed 1600| 71.8M| if (id >= _atomIds.size()) { ------------------ | Branch (1600:9): [True: 71.8M, False: 0] ------------------ 1601| 71.8M| unsigned int size = _atomIds.size(); 1602| 71.8M| _atomIds.resize(id+1); 1603| 71.8M| for (unsigned long i = size; i < id; ++i) ------------------ | Branch (1603:36): [True: 0, False: 71.8M] ------------------ 1604| 0| _atomIds[i] = nullptr; 1605| 71.8M| } 1606| | 1607| 71.8M| if (_atomIds.at(id)) ------------------ | Branch (1607:9): [True: 0, False: 71.8M] ------------------ 1608| 0| return nullptr; 1609| | 1610| 71.8M| OBAtom *obatom = new OBAtom; 1611| 71.8M| obatom->SetIdx(_natoms+1); 1612| 71.8M| obatom->SetParent(this); 1613| | 1614| 71.8M| _atomIds[id] = obatom; 1615| 71.8M| obatom->SetId(id); 1616| | 1617| 71.8M|#define OBAtomIncrement 100 1618| | 1619| 71.8M| if (_natoms+1 >= _vatom.size()) ------------------ | Branch (1619:9): [True: 732k, False: 71.0M] ------------------ 1620| 732k| { 1621| 732k| _vatom.resize(_natoms+OBAtomIncrement); ------------------ | | 1617| 732k|#define OBAtomIncrement 100 ------------------ 1622| 732k| vector::iterator j; 1623| 73.2M| for (j = _vatom.begin(),j+=(_natoms+1);j != _vatom.end();++j) ------------------ | Branch (1623:48): [True: 72.4M, False: 732k] ------------------ 1624| 72.4M| *j = nullptr; 1625| 732k| } 1626| 71.8M|#undef OBAtomIncrement 1627| | 1628| | 1629| 71.8M| _vatom[_natoms] = obatom; 1630| 71.8M| _natoms++; 1631| | 1632| 71.8M| if (HasData(OBGenericDataType::VirtualBondData)) ------------------ | Branch (1632:9): [True: 0, False: 71.8M] ------------------ 1633| 0| { 1634| | /*add bonds that have been queued*/ 1635| 0| OBVirtualBond *vb; 1636| 0| vector verase; 1637| 0| vector::iterator i; 1638| 0| for (i = BeginData();i != EndData();++i) ------------------ | Branch (1638:30): [True: 0, False: 0] ------------------ 1639| 0| if ((*i)->GetDataType() == OBGenericDataType::VirtualBondData) ------------------ | Branch (1639:15): [True: 0, False: 0] ------------------ 1640| 0| { 1641| 0| vb = (OBVirtualBond*)*i; 1642| 0| if (vb->GetBgn() > _natoms || vb->GetEnd() > _natoms) ------------------ | Branch (1642:19): [True: 0, False: 0] | Branch (1642:45): [True: 0, False: 0] ------------------ 1643| 0| continue; 1644| 0| if (obatom->GetIdx() == static_cast(vb->GetBgn()) ------------------ | Branch (1644:19): [True: 0, False: 0] ------------------ 1645| 0| || obatom->GetIdx() == static_cast(vb->GetEnd())) ------------------ | Branch (1645:22): [True: 0, False: 0] ------------------ 1646| 0| { 1647| 0| AddBond(vb->GetBgn(),vb->GetEnd(),vb->GetOrder()); 1648| 0| verase.push_back(*i); 1649| 0| } 1650| 0| } 1651| | 1652| 0| if (!verase.empty()) ------------------ | Branch (1652:13): [True: 0, False: 0] ------------------ 1653| 0| DeleteData(verase); 1654| 0| } 1655| | 1656| | // EndModify(); 1657| | 1658| 71.8M| return(obatom); 1659| 71.8M| } _ZN9OpenBabel5OBMol7AddBondEiiiii: 2514| 71.9M| { 2515| | // Don't add the bond if it already exists 2516| 71.9M| if (first == second || GetBond(first, second) != nullptr) ------------------ | Branch (2516:9): [True: 23.7k, False: 71.8M] | Branch (2516:28): [True: 21.1k, False: 71.8M] ------------------ 2517| 44.8k| return(false); 2518| | 2519| | // BeginModify(); 2520| | 2521| 71.8M| if ((unsigned)first <= NumAtoms() && (unsigned)second <= NumAtoms()) ------------------ | Branch (2521:9): [True: 71.8M, False: 0] | Branch (2521:42): [True: 71.8M, False: 0] ------------------ 2522| | //atoms exist and bond doesn't 2523| 71.8M| { 2524| 71.8M| OBBond *bond = new OBBond; 2525| 71.8M| if (!bond) ------------------ | Branch (2525:13): [True: 0, False: 71.8M] ------------------ 2526| 0| { 2527| | //EndModify(); 2528| 0| return(false); 2529| 0| } 2530| | 2531| 71.8M| OBAtom *bgn,*end; 2532| 71.8M| bgn = GetAtom(first); 2533| 71.8M| end = GetAtom(second); 2534| 71.8M| if (!bgn || !end) ------------------ | Branch (2534:13): [True: 0, False: 71.8M] | Branch (2534:21): [True: 0, False: 71.8M] ------------------ 2535| 0| { 2536| 0| obErrorLog.ThrowError(__FUNCTION__, "Unable to add bond - invalid atom index", obDebug); 2537| 0| return(false); 2538| 0| } 2539| 71.8M| bond->Set(_nbonds,bgn,end,order,flags); 2540| 71.8M| bond->SetParent(this); 2541| | 2542| 71.8M| bond->SetId(_bondIds.size()); 2543| 71.8M| _bondIds.push_back(bond); 2544| | 2545| 71.8M|#define OBBondIncrement 100 2546| 71.8M| if (_nbonds+1 >= _vbond.size()) ------------------ | Branch (2546:13): [True: 731k, False: 71.1M] ------------------ 2547| 731k| { 2548| 731k| _vbond.resize(_nbonds+OBBondIncrement); ------------------ | | 2545| 731k|#define OBBondIncrement 100 ------------------ 2549| 731k| vector::iterator i; 2550| 73.1M| for (i = _vbond.begin(),i+=(_nbonds+1);i != _vbond.end();++i) ------------------ | Branch (2550:52): [True: 72.3M, False: 731k] ------------------ 2551| 72.3M| *i = nullptr; 2552| 731k| } 2553| 71.8M|#undef OBBondIncrement 2554| | 2555| 71.8M| _vbond[_nbonds] = (OBBond*)bond; 2556| 71.8M| _nbonds++; 2557| | 2558| 71.8M| if (insertpos == -1) ------------------ | Branch (2558:13): [True: 71.7M, False: 105k] ------------------ 2559| 71.7M| { 2560| 71.7M| bgn->AddBond(bond); 2561| 71.7M| end->AddBond(bond); 2562| 71.7M| } 2563| 105k| else 2564| 105k| { 2565| 105k| if (insertpos >= static_cast(bgn->GetExplicitDegree())) ------------------ | Branch (2565:17): [True: 14.0k, False: 91.5k] ------------------ 2566| 14.0k| bgn->AddBond(bond); 2567| 91.5k| else //need to insert the bond for the connectivity order to be preserved 2568| 91.5k| { //otherwise stereochemistry gets screwed up 2569| 91.5k| vector::iterator bi; 2570| 91.5k| bgn->BeginNbrAtom(bi); 2571| 91.5k| bi += insertpos; 2572| 91.5k| bgn->InsertBond(bi,bond); 2573| 91.5k| } 2574| 105k| end->AddBond(bond); 2575| 105k| } 2576| 71.8M| } 2577| 0| else //at least one atom doesn't exist yet - add to bond_q 2578| 0| SetData(new OBVirtualBond(first,second,order,flags)); 2579| | 2580| | // EndModify(); 2581| | 2582| 71.8M| return(true); 2583| 71.8M| } _ZN9OpenBabel5OBMolC2Ev: 2717| 9.19k| { 2718| 9.19k| _natoms = _nbonds = 0; 2719| 9.19k| _mod = 0; 2720| 9.19k| _totalCharge = 0; 2721| 9.19k| _dimension = 3; 2722| 9.19k| _vatom.clear(); 2723| 9.19k| _atomIds.clear(); 2724| 9.19k| _vbond.clear(); 2725| 9.19k| _bondIds.clear(); 2726| 9.19k| _vdata.clear(); 2727| 9.19k| _title = ""; 2728| 9.19k| _c = nullptr; 2729| 9.19k| _flags = 0; 2730| 9.19k| _vconf.clear(); 2731| 9.19k| _autoPartialCharge = true; 2732| 9.19k| _autoFormalCharge = true; 2733| 9.19k| _energy = 0.0; 2734| 9.19k| } _ZN9OpenBabel5OBMolD2Ev: 2759| 9.18k| { 2760| 9.18k| OBAtom *atom; 2761| 9.18k| OBBond *bond; 2762| 9.18k| OBResidue *residue; 2763| 9.18k| vector::iterator i; 2764| 9.18k| vector::iterator j; 2765| 9.18k| vector::iterator r; 2766| 54.5M| for (atom = BeginAtom(i);atom;atom = NextAtom(i)) ------------------ | Branch (2766:30): [True: 54.5M, False: 9.18k] ------------------ 2767| 54.5M| DestroyAtom(atom); 2768| 54.5M| for (bond = BeginBond(j);bond;bond = NextBond(j)) ------------------ | Branch (2768:30): [True: 54.5M, False: 9.18k] ------------------ 2769| 54.5M| DestroyBond(bond); 2770| 9.18k| for (residue = BeginResidue(r);residue;residue = NextResidue(r)) ------------------ | Branch (2770:36): [True: 0, False: 9.18k] ------------------ 2771| 0| DestroyResidue(residue); 2772| | 2773| | //clear out the multiconformer data 2774| 9.18k| vector::iterator k; 2775| 15.5k| for (k = _vconf.begin();k != _vconf.end();++k) ------------------ | Branch (2775:29): [True: 6.36k, False: 9.18k] ------------------ 2776| 6.36k| delete [] *k; 2777| 9.18k| _vconf.clear(); 2778| 9.18k| } _ZN9OpenBabel5OBMol9BeginAtomERNSt3__111__wrap_iterIPPNS_6OBAtomEEE: 3949| 67.8k| { 3950| 67.8k| i = _vatom.begin(); 3951| 67.8k| return i == _vatom.end() ? nullptr : (OBAtom*)*i; ------------------ | Branch (3951:12): [True: 1.01k, False: 66.7k] ------------------ 3952| 67.8k| } _ZN9OpenBabel5OBMol8NextAtomERNSt3__111__wrap_iterIPPNS_6OBAtomEEE: 3961| 546M| { 3962| 546M| ++i; 3963| 546M| return i == _vatom.end() ? nullptr : (OBAtom*)*i; ------------------ | Branch (3963:12): [True: 0, False: 546M] ------------------ 3964| 546M| } _ZN9OpenBabel5OBMol9BeginBondERNSt3__111__wrap_iterIPPNS_6OBBondEEE: 3973| 45.7k| { 3974| 45.7k| i = _vbond.begin(); 3975| 45.7k| return i == _vbond.end() ? nullptr : (OBBond*)*i; ------------------ | Branch (3975:12): [True: 3.17k, False: 42.6k] ------------------ 3976| 45.7k| } _ZN9OpenBabel5OBMol8NextBondERNSt3__111__wrap_iterIPPNS_6OBBondEEE: 3979| 373M| { 3980| 373M| ++i; 3981| 373M| return i == _vbond.end() ? nullptr : (OBBond*)*i; ------------------ | Branch (3981:12): [True: 0, False: 373M] ------------------ 3982| 373M| } _ZN9OpenBabel12OBConversionC2EPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEPNS1_13basic_ostreamIcS4_EE: 237| 9.18k| { 238| 9.18k| SetInStream(is); 239| 9.18k| SetOutStream(os); 240| | 241| | //These options take a parameter 242| 9.18k| RegisterOptionParam("f", nullptr, 1,GENOPTIONS); 243| 9.18k| RegisterOptionParam("l", nullptr, 1,GENOPTIONS); 244| 9.18k| } _ZN9OpenBabel12OBConversionD2Ev: 312| 9.18k| { 313| 9.18k| if(pAuxConv!=this) ------------------ | Branch (313:8): [True: 9.18k, False: 0] ------------------ 314| 9.18k| delete pAuxConv; 315| | // Free any remaining streams from convenience functions 316| 9.18k| SetInStream(nullptr); 317| 9.18k| SetOutStream(nullptr); 318| | 319| 9.18k| } _ZN9OpenBabel12OBConversion14RegisterFormatEPKcPNS_8OBFormatES2_: 329| 320| { 330| 320| return pFormat->RegisterFormat(ID, MIME); 331| 320| } _ZN9OpenBabel12OBConversion11SetInStreamEPNSt3__113basic_istreamIcNS1_11char_traitsIcEEEEb: 336| 27.5k| { 337| | //clear and deallocate any existing streams 338| 45.9k| for(unsigned i = 0, n = ownedInStreams.size(); i < n; i++) ------------------ | Branch (338:54): [True: 18.3k, False: 27.5k] ------------------ 339| 18.3k| { 340| 18.3k| delete ownedInStreams[i]; 341| 18.3k| } 342| 27.5k| ownedInStreams.clear(); 343| 27.5k| pInput = nullptr; 344| | 345| 27.5k| if (pIn) ------------------ | Branch (345:11): [True: 9.18k, False: 18.3k] ------------------ 346| 9.18k| { 347| 9.18k| if(takeOwnership) ------------------ | Branch (347:14): [True: 9.18k, False: 0] ------------------ 348| 9.18k| ownedInStreams.push_back(pIn); 349| 9.18k| pInput = pIn; //simplest case 350| | 351| | #ifdef HAVE_LIBZ 352| | if(IsOption("zin", GENOPTIONS) || inFormatGzip) 353| | { 354| | zlib_stream::zip_istream *zIn = new zlib_stream::zip_istream(*pInput); 355| | ownedInStreams.push_back(zIn); 356| | pInput = zIn; 357| | } 358| | #endif 359| | //always transform newlines if input isn't binary/xml 360| 9.18k| if(pInFormat && !(pInFormat->Flags() & (READBINARY | READXML)) && ------------------ | | 33| 9.18k|#define READBINARY 0x04 ------------------ if(pInFormat && !(pInFormat->Flags() & (READBINARY | READXML)) && ------------------ | | 38| 9.18k|#define READXML 0x80 ------------------ | Branch (360:14): [True: 9.18k, False: 0] | Branch (360:27): [True: 9.18k, False: 0] ------------------ 361| 9.18k| pIn != &std::cin) //avoid filtering stdin as well ------------------ | Branch (361:15): [True: 9.18k, False: 0] ------------------ 362| 9.18k| { 363| 9.18k| LEInStream *leIn = new LEInStream(*pInput); 364| 9.18k| ownedInStreams.push_back(leIn); 365| 9.18k| pInput = leIn; 366| 9.18k| } 367| 9.18k| } 368| 27.5k| } _ZN9OpenBabel12OBConversion12SetOutStreamEPNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEb: 376| 18.3k| { 377| | //clear and deallocate any existing streams 378| 18.3k| for (unsigned i = 0, n = ownedOutStreams.size(); i < n; i++) ------------------ | Branch (378:54): [True: 0, False: 18.3k] ------------------ 379| 0| { 380| 0| delete ownedOutStreams[i]; 381| 0| } 382| 18.3k| ownedOutStreams.clear(); 383| 18.3k| pOutput = nullptr; 384| | 385| 18.3k| if (pOut) ------------------ | Branch (385:9): [True: 0, False: 18.3k] ------------------ 386| 0| { 387| 0| if (takeOwnership) ------------------ | Branch (387:11): [True: 0, False: 0] ------------------ 388| 0| ownedOutStreams.push_back(pOut); 389| 0| pOutput = pOut; 390| | 391| |#ifdef HAVE_LIBZ 392| | 393| | if (IsOption("z", GENOPTIONS) || outFormatGzip) 394| | { 395| | zlib_stream::zip_ostream *zOut = new zlib_stream::zip_ostream(*pOutput, true); 396| | //we need to delete the zstream _before_ the underlying stream so it can add the footer 397| | ownedOutStreams.insert(ownedOutStreams.begin(),zOut); 398| | pOutput = zOut; 399| | } 400| |#endif 401| 0| } 402| 18.3k| } _ZN9OpenBabel12OBConversion11SetInFormatEPKcb: 438| 9.18k| { 439| 9.18k| inFormatGzip = gzip; 440| 9.18k| if(inID) ------------------ | Branch (440:8): [True: 9.18k, False: 0] ------------------ 441| 9.18k| pInFormat = FindFormat(inID); 442| 9.18k| return pInFormat && !(pInFormat->Flags() & NOTREADABLE); ------------------ | | 31| 9.18k|#define NOTREADABLE 0x01 ------------------ | Branch (442:12): [True: 9.18k, False: 0] | Branch (442:25): [True: 9.18k, False: 0] ------------------ 443| 9.18k| } _ZN9OpenBabel12OBConversion14SetStartAndEndEv: 617| 9.18k| { 618| 9.18k| unsigned int TempStartNumber=0; 619| 9.18k| const char* p = IsOption("f",GENOPTIONS); 620| 9.18k| if(p) ------------------ | Branch (620:8): [True: 0, False: 9.18k] ------------------ 621| 0| { 622| 0| StartNumber=atoi(p); 623| 0| if(StartNumber>1) ------------------ | Branch (623:12): [True: 0, False: 0] ------------------ 624| 0| { 625| 0| TempStartNumber=StartNumber; 626| | //Try to skip objects now 627| 0| int ret = pInFormat->SkipObjects(StartNumber-1,this); 628| 0| if(ret==-1) //error ------------------ | Branch (628:16): [True: 0, False: 0] ------------------ 629| 0| return false; 630| 0| if(ret==1) //success:objects skipped ------------------ | Branch (630:16): [True: 0, False: 0] ------------------ 631| 0| { 632| 0| Count = StartNumber-1; 633| 0| StartNumber=0; 634| 0| } 635| 0| } 636| 0| } 637| | 638| 9.18k| p = IsOption("l",GENOPTIONS); 639| 9.18k| if(p) ------------------ | Branch (639:8): [True: 0, False: 9.18k] ------------------ 640| 0| { 641| 0| EndNumber=atoi(p); 642| 0| if(TempStartNumber && EndNumbereof()) pInput->get(); ------------------ | Branch (847:8): [True: 0, False: 9.18k] ------------------ 848| | 849| | // Set the locale for number parsing to avoid locale issues: PR#1785463 850| 9.18k| obLocale.SetLocale(); 851| | 852| | // Also set the C++ stream locale 853| 9.18k| locale originalLocale = pInput->getloc(); // save the original 854| 9.18k| locale cNumericLocale(originalLocale, "C", locale::numeric); 855| 9.18k| pInput->imbue(cNumericLocale); 856| | 857| | // skip molecules if -f or -l option is set 858| 9.18k| if (!SkippedMolecules) { ------------------ | Branch (858:9): [True: 9.18k, False: 0] ------------------ 859| 9.18k| Count = 0; // make sure it's 0 860| 9.18k| if(!SetStartAndEnd()) { ------------------ | Branch (860:12): [True: 0, False: 9.18k] ------------------ 861| 0| return false; 862| 0| } 863| 9.18k| SkippedMolecules = true; 864| 9.18k| } 865| | 866| | // catch last molecule acording to -l 867| 9.18k| Count++; 868| 9.18k| bool success = false; 869| 9.18k| if (EndNumber==0 || (unsigned)Count<=EndNumber) { ------------------ | Branch (869:9): [True: 9.18k, False: 0] | Branch (869:25): [True: 0, False: 0] ------------------ 870| 9.18k| success = pInFormat->ReadMolecule(pOb, this); 871| 9.18k| } 872| | 873| | // return the C locale to the original one 874| 9.18k| obLocale.RestoreLocale(); 875| | // Restore the original C++ locale as well 876| 9.18k| pInput->imbue(originalLocale); 877| | 878| | // If we failed to read, plus the stream is over, then check if this is a stream from ReadFile 879| 9.18k| if (!success && !pInput->good() && ownedInStreams.size() > 0) { ------------------ | Branch (879:9): [True: 2.81k, False: 6.37k] | Branch (879:21): [True: 2.77k, False: 38] | Branch (879:40): [True: 2.77k, False: 0] ------------------ 880| 2.77k| ifstream *inFstream = dynamic_cast(ownedInStreams[0]); 881| 2.77k| if (inFstream != nullptr) ------------------ | Branch (881:11): [True: 0, False: 2.77k] ------------------ 882| 0| inFstream->close(); // We will free the stream later, but close the file now 883| 2.77k| } 884| | 885| 9.18k| return success; 886| 9.18k| } _ZN9OpenBabel12OBConversion10ReadStringEPNS_6OBBaseENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 1072| 9.18k| { 1073| 9.18k| SetInStream(new stringstream(input), true); 1074| 9.18k| return Read(pOb); 1075| 9.18k| } _ZN9OpenBabel12OBConversion8IsOptionEPKcNS0_11Option_typeE: 1617| 36.7k| { 1618| | //Returns NULL if option not found or a pointer to the text if it is 1619| 36.7k| map::iterator pos; 1620| 36.7k| pos = OptionsArray[opttyp].find(opt); 1621| 36.7k| if(pos==OptionsArray[opttyp].end()) ------------------ | Branch (1621:8): [True: 36.7k, False: 0] ------------------ 1622| 36.7k| return nullptr; 1623| 0| return pos->second.c_str(); 1624| 36.7k| } _ZN9OpenBabel12OBConversion16OptionParamArrayENS0_11Option_typeE: 1657| 55.6k| { 1658| 55.6k| static OPAMapType opa[3]; 1659| 55.6k| return opa[typ]; 1660| 55.6k| } _ZN9OpenBabel12OBConversion19RegisterOptionParamENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8OBFormatEiNS0_11Option_typeE: 1664| 18.5k| { 1665| | //Gives error message if the number of parameters conflicts with an existing registration 1666| 18.5k| map::iterator pos; 1667| 18.5k| pos = OptionParamArray(typ).find(name); 1668| 18.5k| if(pos!=OptionParamArray(typ).end()) ------------------ | Branch (1668:8): [True: 18.4k, False: 128] ------------------ 1669| 18.4k| { 1670| 18.4k| if(pos->second!=numberParams) ------------------ | Branch (1670:12): [True: 0, False: 18.4k] ------------------ 1671| 0| { 1672| 0| string description("API"); 1673| 0| if(pFormat) ------------------ | Branch (1673:16): [True: 0, False: 0] ------------------ 1674| 0| description=pFormat->Description(); 1675| 0| obErrorLog.ThrowError(__FUNCTION__, 1676| 0| "The number of parameters needed by option \"" + name + "\" in " 1677| 0| + description.substr(0,description.find('\n')) 1678| 0| + " differs from an earlier registration.", obError); 1679| 0| return; 1680| 0| } 1681| 18.4k| } 1682| 18.5k| OptionParamArray(typ)[name] = numberParams; 1683| 18.5k| } _ZN9OpenBabel7OBErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_S9_S9_NS_14obMessageLevelE: 44| 123k| { } _ZNK9OpenBabel7OBError7messageEv: 47| 113k| { 48| 113k| string tmp = "==============================\n"; 49| | 50| 113k| if (_level == obError) ------------------ | Branch (50:9): [True: 379, False: 113k] ------------------ 51| 379| tmp += "*** Open Babel Error "; 52| 113k| else if (_level == obWarning) ------------------ | Branch (52:14): [True: 113k, False: 0] ------------------ 53| 113k| tmp += "*** Open Babel Warning "; 54| 0| else if (_level == obInfo) ------------------ | Branch (54:14): [True: 0, False: 0] ------------------ 55| 0| tmp += "*** Open Babel Information "; 56| 0| else if (_level == obAuditMsg) ------------------ | Branch (56:14): [True: 0, False: 0] ------------------ 57| 0| tmp += "*** Open Babel Audit Log "; 58| 0| else 59| 0| tmp += "*** Open Babel Debugging Message "; 60| | 61| 113k| if (_method.length() != 0) ------------------ | Branch (61:9): [True: 113k, False: 0] ------------------ 62| 113k| { 63| 113k| tmp += " in " + _method + string("\n "); 64| 113k| } 65| 113k| tmp += _errorMsg + "\n"; 66| 113k| if (!_explanation.empty()) ------------------ | Branch (66:9): [True: 0, False: 113k] ------------------ 67| 0| tmp += " " + _explanation + "\n"; 68| 113k| if (!_possibleCause.empty()) ------------------ | Branch (68:9): [True: 0, False: 113k] ------------------ 69| 0| tmp += " Possible reason: " + _possibleCause + "\n"; 70| 113k| if (!_suggestedRemedy.empty()) ------------------ | Branch (70:9): [True: 0, False: 113k] ------------------ 71| 0| tmp += " Suggestion: " + _suggestedRemedy + "\n"; 72| 113k| return tmp; 73| 113k| } _ZN9OpenBabel16OBMessageHandlerC2Ev: 147| 2| { 148| 2| _messageCount[0] = _messageCount[1] = _messageCount[2] = 0; 149| 2| _messageCount[3] = _messageCount[4] = 0; 150| 2| _filterStreamBuf = _inWrapStreamBuf = nullptr; 151| | // StartErrorWrap(); // (don't turn on error wrapping by default) 152| 2| } _ZN9OpenBabel16OBMessageHandler10ThrowErrorENS_7OBErrorENS_14errorQualifierE: 163| 123k| { 164| 123k| if (!_logging) ------------------ | Branch (164:9): [True: 0, False: 123k] ------------------ 165| 0| return; 166| | 167| | //Output error message if level sufficiently high and, if onceOnly set, it has not been logged before 168| 123k| if (err.GetLevel() <= _outputLevel && ------------------ | Branch (168:9): [True: 113k, False: 9.83k] | Branch (168:9): [True: 113k, False: 9.83k] ------------------ 169| 123k| (qualifier!=onceOnly || find(_messageList.begin(), _messageList.end(), err)==_messageList.end())) ------------------ | Branch (169:8): [True: 113k, False: 0] | Branch (169:31): [True: 0, False: 0] ------------------ 170| 113k| { 171| 113k| *_outputStream << err; 172| 113k| } 173| | 174| 123k| _messageList.push_back(err); 175| 123k| _messageCount[err.GetLevel()]++; 176| 123k| if (_maxEntries != 0 && _messageList.size() > _maxEntries) ------------------ | Branch (176:9): [True: 123k, False: 0] | Branch (176:29): [True: 123k, False: 100] ------------------ 177| 123k| _messageList.pop_front(); 178| 123k| } _ZN9OpenBabel16OBMessageHandler10ThrowErrorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_14obMessageLevelENS_14errorQualifierE: 183| 123k| { 184| 123k| if (errorMsg.length() > 1) ------------------ | Branch (184:9): [True: 123k, False: 0] ------------------ 185| 123k| { 186| 123k| OBError err(method, errorMsg, "", "", "", level); 187| 123k| ThrowError(err, qualifier); 188| 123k| } 189| 123k| } _ZN9OpenBabel13OBMolAtomIterC2EPNS_5OBMolE: 66| 13.0k| { 67| 13.0k| _parent = mol; 68| 13.0k| _ptr = _parent->BeginAtom(_i); 69| 13.0k| } _ZN9OpenBabel13OBMolAtomIterC2ERNS_5OBMolE: 72| 17.3k| { 73| 17.3k| _parent = &mol; 74| 17.3k| _ptr = _parent->BeginAtom(_i); 75| 17.3k| } _ZN9OpenBabel13OBMolAtomIterppEv: 96| 252M| { 97| 252M| _ptr = _parent->NextAtom(_i); 98| 252M| return *this; 99| 252M| } _ZN9OpenBabel16OBMolAtomDFSIterC2EPNS_5OBMolEi: 150| 463| { 151| 463| if (!_ptr) return; ------------------ | Branch (151:9): [True: 1, False: 462] ------------------ 152| | 153| 462| _notVisited.Resize(_parent->NumAtoms()); 154| 462| _notVisited.SetRangeOn(0, _parent->NumAtoms() - 1); 155| | 156| 462| _notVisited.SetBitOff(_ptr->GetIdx() - 1); 157| | 158| 462| vector::iterator i; 159| 462| OBAtom *a; 160| | 161| 255k| for (a = _ptr->BeginNbrAtom(i); a; a = _ptr->NextNbrAtom(i)) ------------------ | Branch (161:37): [True: 255k, False: 462] ------------------ 162| 255k| { 163| 255k| _stack.push(a); 164| 255k| _notVisited.SetBitOff(a->GetIdx() - 1); 165| 255k| } 166| 462| } _ZN9OpenBabel16OBMolAtomDFSIterC2ERKS0_: 189| 4.39M| { 190| 4.39M| _parent = ai._parent; 191| 4.39M| _ptr = ai._ptr; 192| 4.39M| _notVisited = ai._notVisited; 193| 4.39M| _stack = ai._stack; 194| 4.39M| } _ZN9OpenBabel16OBMolAtomDFSIterppEv: 209| 4.39M| { 210| 4.39M| if (!_stack.empty()) ------------------ | Branch (210:9): [True: 4.39M, False: 3.19k] ------------------ 211| 4.39M| { 212| 4.39M| _ptr = _stack.top(); 213| 4.39M| _stack.pop(); 214| 4.39M| } 215| 3.19k| else // are there any disconnected subgraphs? 216| 3.19k| { 217| 3.19k| int next = _notVisited.FirstBit(); 218| 3.19k| if (next != _notVisited.EndBit()) ------------------ | Branch (218:13): [True: 2.73k, False: 462] ------------------ 219| 2.73k| { 220| 2.73k| _ptr = _parent->GetAtom(next + 1); 221| 2.73k| _notVisited.SetBitOff(next); 222| 2.73k| } 223| 462| else 224| 462| _ptr = nullptr; 225| 3.19k| } 226| | 227| 4.39M| if (_ptr) ------------------ | Branch (227:9): [True: 4.39M, False: 462] ------------------ 228| 4.39M| { 229| 4.39M| vector::iterator i; 230| 4.39M| OBAtom *a; 231| | 232| 12.9M| for (a = _ptr->BeginNbrAtom(i); a; a = _ptr->NextNbrAtom(i)) ------------------ | Branch (232:41): [True: 8.53M, False: 4.39M] ------------------ 233| 8.53M| if (_notVisited[a->GetIdx() - 1]) ------------------ | Branch (233:15): [True: 4.13M, False: 4.39M] ------------------ 234| 4.13M| { 235| 4.13M| _stack.push(a); 236| 4.13M| _notVisited.SetBitOff(a->GetIdx() - 1); 237| 4.13M| } 238| 4.39M| } 239| | 240| 4.39M| return *this; 241| 4.39M| } _ZN9OpenBabel16OBMolAtomDFSIterppEi: 244| 4.39M| { 245| 4.39M| OBMolAtomDFSIter tmp(*this); 246| 4.39M| operator++(); 247| 4.39M| return tmp; 248| 4.39M| } _ZN9OpenBabel13OBMolBondIterC2ERNS_5OBMolE: 650| 18.2k| { 651| 18.2k| _parent = &mol; 652| 18.2k| _ptr = _parent->BeginBond(_i); 653| 18.2k| } _ZN9OpenBabel13OBMolBondIterppEv: 674| 152M| { 675| 152M| _ptr = _parent->NextBond(_i); 676| 152M| return *this; 677| 152M| } _ZN9OpenBabel14OBAtomBondIterC2EPNS_6OBAtomE: 793| 164M| { 794| 164M| _parent = atm; 795| 164M| _ptr = _parent->BeginBond(_i); 796| 164M| } _ZN9OpenBabel14OBAtomBondIterppEv: 823| 388M| { 824| 388M| _ptr = _parent->NextBond(_i); 825| 388M| return *this; 826| 388M| } _ZN9OpenBabel12OpAddInIndexC2EPKc: 30| 2| OpAddInIndex(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel14OpAddNonPolarHC2EPKc: 29| 2| OpAddNonPolarH(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel11OpAddPolarHC2EPKc: 29| 2| OpAddPolarH(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel11OpCanonicalC2EPKc: 31| 2| OpCanonical(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel14OpDelNonPolarHC2EPKc: 29| 2| OpDelNonPolarH(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel11OpDelPolarHC2EPKc: 29| 2| OpDelPolarH(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel8OpFillUCC2EPKc: 38| 2| OpFillUC(const char* ID) : OBOp(ID, false){ 39| 2| OBConversion::RegisterOptionParam("fillUC", nullptr, 1, OBConversion::GENOPTIONS); 40| 2| } _ZN9OpenBabel8OpEnergyC2EPKc: 49| 2| OpEnergy(const char *ID) : OBOp(ID, false) {} _ZN9OpenBabel10OpMinimizeC2EPKc: 138| 2| OpMinimize(const char* ID) : OBOp(ID, false) {} _ZN9OpenBabel7OpGen2DC2EPKc: 33| 2| OpGen2D(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel7OpGen3DC2EPKc: 36| 2| OpGen3D(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel6OpNewSC2EPKc: 48| 4| OpNewS(const char* ID) : OBOp(ID, false){} _ZN9OpenBabel15OpPartialChargeC2EPKc: 34| 2| OpPartialCharge(const char* ID) : OBOp(ID, false) { 35| 2| OBConversion::RegisterOptionParam(ID, nullptr, 1, OBConversion::GENOPTIONS); 36| 2| } _ZN9OpenBabel16OpReadConformersC2EPKc: 31| 2| OpReadConformers(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel6OpSortC2EPKc: 49| 2| { 50| 2| OBConversion::RegisterOptionParam(ID, nullptr, 1, OBConversion::GENOPTIONS); 51| 2| } _ZN9OpenBabel10OpExtraOutC2EPKc: 122| 2| OpExtraOut(const char* ID) : OBOp(ID, false){}; _ZN9OpenBabel8OBPlugin10GetTypeMapEPKc: 30| 1|{ 31| 1| PluginMapType::iterator itr; 32| | 33| | // Make sure the plugins are loaded 34| 1| if (AllPluginsLoaded == 0) { ------------------ | Branch (34:7): [True: 0, False: 1] ------------------ 35| 0| OBPlugin::LoadAllPlugins(); 36| 0| } 37| | 38| 1| itr = PluginMap().find(PluginID); 39| 1| if(itr!=PluginMap().end()) ------------------ | Branch (39:6): [True: 0, False: 1] ------------------ 40| 0| return itr->second->GetMap(); 41| 1| return PluginMap();//error: type not found; return plugins map 42| 1|} _ZN9OpenBabel8OBPlugin14LoadAllPluginsEv: 47| 1|{ 48| 1| int count = 0; 49| |#if defined(USING_DYNAMIC_LIBS) 50| | // Depending on availability, look successively in 51| | // FORMATFILE_DIR, executable directory or current directory 52| | string TargetDir; 53| | 54| |#ifdef FORMATFILE_DIR 55| | TargetDir="FORMATFILE_DIR"; 56| |#endif 57| | 58| | DLHandler::getConvDirectory(TargetDir); 59| | 60| | vector files; 61| | if(!DLHandler::findFiles(files,DLHandler::getFormatFilePattern(),TargetDir)) { 62| | obErrorLog.ThrowError(__FUNCTION__, "Unable to find OpenBabel plugins. Try setting the BABEL_LIBDIR environment variable.", obError); 63| | return; 64| | } 65| | 66| | vector::iterator itr; 67| | for(itr=files.begin();itr!=files.end();++itr) { 68| | if(DLHandler::openLib(*itr)) 69| | count++; 70| | } 71| | if(!count) { 72| | string error = "No valid OpenBabel plugs found in "+TargetDir; 73| | obErrorLog.ThrowError(__FUNCTION__, error, obError); 74| | return; 75| | } 76| |#else 77| 1| count = 1; // Avoid calling this function several times 78| 1|#endif //USING_DYNAMIC_LIBS 79| | 80| | // Status have to be updated now 81| 1| AllPluginsLoaded = count; 82| | 83| | // Make instances for plugin classes defined in the data file. 84| | // This is hook for OBDefine, but does nothing if it is not loaded 85| | // or if plugindefines.txt is not found. 86| 1| OBPlugin* pdef = OBPlugin::GetPlugin("loaders","define"); 87| 1| if(pdef) { ------------------ | Branch (87:6): [True: 0, False: 1] ------------------ 88| 0| static vector vec(3); 89| 0| vec[1] = string("define"); 90| 0| vec[2] = string("plugindefines.txt"); 91| 0| pdef->MakeInstance(vec); 92| 0| } 93| | 94| 1| return; 95| 1|} _ZN9OpenBabel8OBPlugin12BaseFindTypeERNSt3__13mapIPKcPS0_NS_11CharPtrLessENS1_9allocatorINS1_4pairIKS4_S5_EEEEEES4_: 98| 9.18k|{ 99| | // Make sure the plugins are loaded 100| 9.18k| if (AllPluginsLoaded == 0) { ------------------ | Branch (100:7): [True: 1, False: 9.18k] ------------------ 101| 1| OBPlugin::LoadAllPlugins(); 102| 1| } 103| | 104| 9.18k| if(!ID || !*ID) ------------------ | Branch (104:6): [True: 0, False: 9.18k] | Branch (104:13): [True: 0, False: 9.18k] ------------------ 105| 0| return nullptr; 106| 9.18k| PluginMapType::iterator itr = Map.find(ID); 107| 9.18k| if(itr==Map.end()) ------------------ | Branch (107:6): [True: 1, False: 9.18k] ------------------ 108| 1| return nullptr; 109| 9.18k| else 110| 9.18k| return itr->second; 111| 9.18k|} _ZN9OpenBabel8OBPlugin9GetPluginEPKcS2_: 114| 1|{ 115| 1| if (Type != nullptr) ------------------ | Branch (115:7): [True: 1, False: 0] ------------------ 116| 1| return BaseFindType(GetTypeMap(Type), ID); 117| | 118| | // Make sure the plugins are loaded 119| 0| if (AllPluginsLoaded == 0) { ------------------ | Branch (119:7): [True: 0, False: 0] ------------------ 120| 0| OBPlugin::LoadAllPlugins(); 121| 0| } 122| | 123| | //When Type==NULL, search all types for matching ID and stop when found 124| 0| PluginMapType::iterator itr; 125| 0| for(itr=PluginMap().begin();itr!= PluginMap().end();++itr) ------------------ | Branch (125:31): [True: 0, False: 0] ------------------ 126| 0| { 127| 0| OBPlugin* result = BaseFindType(itr->second->GetMap(), ID); 128| 0| if(result) ------------------ | Branch (128:8): [True: 0, False: 0] ------------------ 129| 0| return result; 130| 0| } 131| 0| return nullptr; //not found 132| 0|} _ZN9OpenBabel23OBReactionFacadePrivate18AssignComponentIdsEb: 96| 463| { 97| 463| unsigned int compid = 1; 98| | 99| 463| OBMolAtomDFSIter iter(_mol); 100| 3.66k| while(iter) { // for each connected component ------------------ | Branch (100:11): [True: 3.19k, False: 463] ------------------ 101| 4.39M| do { // for each atom in connected component 102| 4.39M| if (wipe || !(iter->HasData("rxncomp"))) ------------------ | Branch (102:13): [True: 4.39M, False: 0] | Branch (102:21): [True: 0, False: 0] ------------------ 103| 4.39M| SetComponentId(&*iter, compid); 104| 4.39M| } while ((iter++).next()); ------------------ | Branch (104:16): [True: 4.39M, False: 3.19k] ------------------ 105| 3.19k| compid++; 106| 3.19k| } 107| 463| } _ZN9OpenBabel23OBReactionFacadePrivate5SetIdEPKcPNS_6OBAtomEi: 301| 4.39M| { 302| | // Note: this replaces any existing data 303| 4.39M| OBGenericData *data = atom->GetData(idtype); 304| 4.39M| OBPairInteger *pi; 305| 4.39M| if (data) { ------------------ | Branch (305:9): [True: 0, False: 4.39M] ------------------ 306| 0| pi = (OBPairInteger*)data; 307| 0| pi->SetValue(idval); 308| 0| } 309| 4.39M| else { 310| 4.39M| pi = new OBPairInteger(); 311| 4.39M| pi->SetAttribute(idtype); 312| 4.39M| pi->SetValue(idval); 313| 4.39M| atom->SetData(pi); 314| 4.39M| } 315| 4.39M| } _ZN9OpenBabel23OBReactionFacadePrivate14SetComponentIdEPNS_6OBAtomEj: 318| 4.39M| { 319| 4.39M| SetId("rxncomp", atom, compid); 320| 4.39M| } _ZN9OpenBabel16OBReactionFacadeC2EPNS_5OBMolE: 332| 463| { 333| 463| }; _ZN9OpenBabel16OBReactionFacadeD2Ev: 335| 463| { 336| 463| delete d; 337| 463| } _ZN9OpenBabel16OBReactionFacade18AssignComponentIdsEb: 343| 463| { 344| 463| d->AssignComponentIds(wipe); 345| 463| } _ZN9OpenBabel23OBReactionFacadePrivateC2EPNS_5OBMolE: 37| 463| { 38| 463| } _ZN9OpenBabel5OBMol8FindSSSREv: 90| 4.91k| { 91| 4.91k| if (HasSSSRPerceived()) ------------------ | Branch (91:9): [True: 0, False: 4.91k] ------------------ 92| 0| return; 93| 4.91k| SetSSSRPerceived(); 94| 4.91k| obErrorLog.ThrowError(__FUNCTION__, 95| 4.91k| "Ran OpenBabel::FindSSSR", obAuditMsg); 96| | 97| | // Delete any old data before we start finding new rings 98| | // The following procedure is slow 99| | // So if client code is multi-threaded, we don't want to make them wait 100| 4.91k| if (HasData("SSSR")) { ------------------ | Branch (100:9): [True: 0, False: 4.91k] ------------------ 101| 0| DeleteData("SSSR"); 102| 0| } 103| | 104| 4.91k| OBRing *ring; 105| 4.91k| vector::iterator j; 106| | 107| | //get Fr�rejacque taking int account multiple possible spanning graphs 108| 4.91k| int frj = DetermineFRJ(*this); 109| 4.91k| if (frj) ------------------ | Branch (109:9): [True: 3.55k, False: 1.36k] ------------------ 110| 3.55k| { 111| 3.55k| vector vr; 112| 3.55k| FindRingAtomsAndBonds(); 113| | 114| 3.55k| OBBond *bond; 115| 3.55k| vector cbonds; 116| 3.55k| vector::iterator k; 117| | 118| | //restrict search for rings around closure bonds 119| 36.7M| for (bond = BeginBond(k);bond;bond = NextBond(k)) ------------------ | Branch (119:34): [True: 36.7M, False: 3.55k] ------------------ 120| 36.7M| if (bond->IsClosure()) ------------------ | Branch (120:15): [True: 92.6k, False: 36.6M] ------------------ 121| 92.6k| cbonds.push_back(bond); 122| | 123| 3.55k| if (!cbonds.empty()) ------------------ | Branch (123:13): [True: 3.55k, False: 0] ------------------ 124| 3.55k| { 125| 3.55k| OBRingSearch rs; 126| | //search for all rings about closures 127| 3.55k| vector::iterator i; 128| | 129| 96.1k| for (i = cbonds.begin();i != cbonds.end();++i) ------------------ | Branch (129:37): [True: 92.6k, False: 3.55k] ------------------ 130| 92.6k| rs.AddRingFromClosure(*this,(OBBond*)*i); 131| | 132| 3.55k| rs.SortRings(); 133| 3.55k| rs.RemoveRedundant(frj); 134| | //store the SSSR set 135| | 136| 94.7k| for (j = rs.BeginRings();j != rs.EndRings();++j) ------------------ | Branch (136:38): [True: 91.1k, False: 3.55k] ------------------ 137| 91.1k| { 138| 91.1k| ring = new OBRing ((*j)->_path,NumAtoms()+1); 139| 91.1k| ring->SetParent(this); 140| 91.1k| vr.push_back(ring); 141| 91.1k| } 142| | //rs.WriteRings(); 143| 3.55k| } 144| | 145| 3.55k| OBRingData *rd = new OBRingData(); 146| 3.55k| rd->SetOrigin(perceived); // to separate from user or file input 147| 3.55k| rd->SetAttribute("SSSR"); 148| 3.55k| rd->SetData(vr); 149| 3.55k| SetData(rd); 150| 3.55k| } 151| 4.91k| } _ZN9OpenBabel12OBRingSearch15RemoveRedundantEi: 318| 3.55k| { 319| 3.55k| int i,j; 320| | 321| | //remove identical rings 322| 352k| for (i = _rlist.size()-1;i > 0;i--) ------------------ | Branch (322:30): [True: 349k, False: 3.55k] ------------------ 323| 277M| for (j = i-1;j >= 0;j--) ------------------ | Branch (323:20): [True: 277M, False: 349k] ------------------ 324| 277M| if ((_rlist[i])->_pathset == (_rlist[j])->_pathset) ------------------ | Branch (324:13): [True: 0, False: 277M] ------------------ 325| 0| { 326| 0| delete _rlist[i]; 327| 0| _rlist.erase(_rlist.begin()+i); 328| 0| break; 329| 0| } 330| | 331| 3.55k| if (_rlist.size() == 0) ------------------ | Branch (331:9): [True: 170, False: 3.38k] ------------------ 332| 170| return; // nothing to do 333| | 334| | // handle LSSR 335| 3.38k| if (frj < 0) { ------------------ | Branch (335:9): [True: 0, False: 3.38k] ------------------ 336| 0| OBMol *mol = _rlist[0]->GetParent(); 337| 0| std::vector rlist, rignored; 338| 0| for (unsigned int i = 0; i < _rlist.size(); ++i) { ------------------ | Branch (338:32): [True: 0, False: 0] ------------------ 339| 0| visitRing(mol, _rlist[i], rlist, rignored); 340| 0| } 341| 0| for (unsigned int i = 0; i < rignored.size(); ++i) ------------------ | Branch (341:32): [True: 0, False: 0] ------------------ 342| 0| delete rignored[i]; 343| 0| _rlist = rlist; 344| 0| return; 345| 0| } 346| | 347| | // exit if we already have frj rings 348| 3.38k| if (_rlist.size() == (unsigned)frj) ------------------ | Branch (348:9): [True: 1.53k, False: 1.84k] ------------------ 349| 1.53k| return; 350| | 351| | //make sure tmp is the same size as the rings 352| 1.84k| OBBitVec tmp; 353| 340k| for (j = 0;j < (signed)_rlist.size();++j) ------------------ | Branch (353:16): [True: 338k, False: 1.84k] ------------------ 354| 338k| tmp = (_rlist[j])->_pathset; 355| | 356| | //remove larger rings that cover the same atoms as smaller rings 357| 288k| for (i = _rlist.size()-1;i >= 0;i--) ------------------ | Branch (357:30): [True: 288k, False: 245] ------------------ 358| 288k| { 359| 288k| tmp.Clear(); 360| 270M| for (j = 0;j < (signed)_rlist.size();++j) ------------------ | Branch (360:20): [True: 270M, False: 288k] ------------------ 361| 270M| if ((_rlist[j])->_path.size() <= (_rlist[i])->_path.size() && i != j) ------------------ | Branch (361:15): [True: 266M, False: 3.69M] | Branch (361:73): [True: 266M, False: 288k] ------------------ 362| 266M| tmp |= (_rlist[j])->_pathset; 363| | 364| 288k| tmp = tmp & (_rlist[i])->_pathset; 365| | 366| 288k| if (tmp == (_rlist[i])->_pathset) ------------------ | Branch (366:13): [True: 261k, False: 26.5k] ------------------ 367| 261k| { 368| 261k| delete _rlist[i]; 369| 261k| _rlist.erase(_rlist.begin()+i); 370| 261k| } 371| | 372| 288k| if (_rlist.size() == (unsigned)frj) ------------------ | Branch (372:13): [True: 1.60k, False: 286k] ------------------ 373| 1.60k| break; 374| 288k| } 375| 1.84k| } _ZN9OpenBabel12OBRingSearch18AddRingFromClosureERNS_5OBMolEPNS_6OBBondE: 379| 92.6k| { 380| 92.6k| vector t1(mol.NumAtoms()+1, nullptr); 381| 92.6k| vector t2(mol.NumAtoms()+1, nullptr); 382| 92.6k| OBBitVec bv1,bv2; 383| | 384| 92.6k| bv1.SetBitOn(cbond->GetEndAtomIdx()); 385| 92.6k| bv2.SetBitOn(cbond->GetBeginAtomIdx()); 386| 92.6k| BuildOBRTreeVector(cbond->GetBeginAtom(), nullptr, t1, bv1); 387| 92.6k| BuildOBRTreeVector(cbond->GetEndAtom(), nullptr, t2, bv2); 388| | 389| 92.6k| bool pathok; 390| 92.6k| deque p1,p2; 391| 92.6k| vector path1,path2; 392| 92.6k| vector::iterator m,n; 393| 92.6k| vector::iterator i; 394| | 395| 649M| for (i = t1.begin();i != t1.end();++i) ------------------ | Branch (395:25): [True: 649M, False: 92.6k] ------------------ 396| 649M| if (*i) ------------------ | Branch (396:11): [True: 8.96M, False: 640M] ------------------ 397| 8.96M| { 398| 8.96M| path1.clear(); 399| 8.96M| (*i)->PathToRoot(path1); 400| | 401| 8.96M| if (t2[(*i)->GetAtomIdx()]) ------------------ | Branch (401:15): [True: 5.31M, False: 3.65M] ------------------ 402| 5.31M| { 403| 5.31M| pathok = true; 404| 5.31M| path2.clear(); 405| 5.31M| t2[(*i)->GetAtomIdx()]->PathToRoot(path2); 406| | 407| 5.31M| p1.clear(); 408| 5.31M| m = path1.begin(); 409| 5.31M| if (m != path1.end()) ------------------ | Branch (409:19): [True: 5.31M, False: 0] ------------------ 410| 5.31M| p1.push_back((*m)->GetIdx()); 411| 8.53M| for (m = path1.begin(),++m;m != path1.end();++m) ------------------ | Branch (411:42): [True: 7.91M, False: 622k] ------------------ 412| 7.91M| { 413| 7.91M| p1.push_back((*m)->GetIdx()); 414| 7.91M| p2.clear(); 415| 40.9M| for (n = path2.begin(),++n;n != path2.end();++n) ------------------ | Branch (415:46): [True: 37.6M, False: 3.22M] ------------------ 416| 37.6M| { 417| 37.6M| p2.push_front((*n)->GetIdx()); 418| 37.6M| if (*n == *m)//don't traverse across identical atoms ------------------ | Branch (418:27): [True: 4.68M, False: 32.9M] ------------------ 419| 4.68M| { 420| 4.68M| p2.pop_front(); 421| 4.68M| if (p1.size()+p2.size() > 2) ------------------ | Branch (421:31): [True: 0, False: 4.68M] ------------------ 422| 0| SaveUniqueRing(p1,p2); 423| 4.68M| pathok = false; 424| 4.68M| break; 425| 4.68M| } 426| 32.9M| if ((*n)->IsConnected(*m) && p1.size()+p2.size() > 2) ------------------ | Branch (426:27): [True: 3.20M, False: 29.7M] | Branch (426:52): [True: 3.20M, False: 0] ------------------ 427| 3.20M| SaveUniqueRing(p1,p2); 428| 32.9M| } 429| 7.91M| if (!pathok) ------------------ | Branch (429:23): [True: 4.68M, False: 3.22M] ------------------ 430| 4.68M| break; 431| 7.91M| } 432| 5.31M| } 433| 8.96M| } 434| | 435| | //clean up OBRTree vectors 436| 649M| for (i = t1.begin();i != t1.end();++i) ------------------ | Branch (436:25): [True: 649M, False: 92.6k] ------------------ 437| 649M| if (*i) ------------------ | Branch (437:11): [True: 8.96M, False: 640M] ------------------ 438| 8.96M| delete *i; 439| | 440| 649M| for (i = t2.begin();i != t2.end();++i) ------------------ | Branch (440:25): [True: 649M, False: 92.6k] ------------------ 441| 649M| if (*i) ------------------ | Branch (441:11): [True: 7.69M, False: 641M] ------------------ 442| 7.69M| delete *i; 443| | 444| | // set parent for all rings 445| 59.4M| for (unsigned int j = 0; j < _rlist.size(); ++j) ------------------ | Branch (445:30): [True: 59.3M, False: 92.6k] ------------------ 446| 59.3M| _rlist[j]->SetParent(&mol); 447| 92.6k| } _ZN9OpenBabel12OBRingSearch14SaveUniqueRingERNSt3__15dequeIiNS1_9allocatorIiEEEES6_: 450| 3.20M| { 451| 3.20M| vector path; 452| 3.20M| OBBitVec bv; 453| 3.20M| deque::iterator i; 454| | 455| 25.2M| for (i = d1.begin();i != d1.end();++i) ------------------ | Branch (455:25): [True: 22.0M, False: 3.20M] ------------------ 456| 22.0M| { 457| 22.0M| bv.SetBitOn(*i); 458| 22.0M| path.push_back(*i); 459| 22.0M| } 460| | 461| 23.7M| for (i = d2.begin();i != d2.end();++i) ------------------ | Branch (461:25): [True: 20.5M, False: 3.20M] ------------------ 462| 20.5M| { 463| 20.5M| bv.SetBitOn(*i); 464| 20.5M| path.push_back(*i); 465| 20.5M| } 466| | 467| 3.20M| vector::iterator j; 468| 2.16G| for (j = _rlist.begin();j != _rlist.end();++j) ------------------ | Branch (468:29): [True: 2.16G, False: 352k] ------------------ 469| 2.16G| if (bv == (*j)->_pathset) ------------------ | Branch (469:11): [True: 2.85M, False: 2.16G] ------------------ 470| 2.85M| return(false); 471| | 472| 352k| OBRing *ring = new OBRing(path, bv); 473| 352k| _rlist.push_back(ring); 474| | 475| 352k| return(true); 476| 3.20M| } _ZN9OpenBabel12OBRingSearchD2Ev: 480| 3.55k| { 481| 3.55k| vector::iterator i; 482| 94.7k| for (i = _rlist.begin();i != _rlist.end();++i) ------------------ | Branch (482:29): [True: 91.1k, False: 3.55k] ------------------ 483| 91.1k| delete *i; 484| 3.55k| } _ZN9OpenBabel15CompareRingSizeEPKNS_6OBRingES2_: 487| 4.20M| { 488| 4.20M| return(a->Size() == b->Size() ? a->ring_id < b->ring_id : a->Size() < b->Size()); // ensure stable sort ------------------ | Branch (488:12): [True: 2.72M, False: 1.48M] ------------------ 489| 4.20M| } _ZN9OpenBabel5OBMol21FindRingAtomsAndBondsEv: 571| 8.79k| { 572| 8.79k| if (HasFlag(OB_RINGFLAGS_MOL)) ------------------ | | 75| 8.79k|#define OB_RINGFLAGS_MOL (1<<2) ------------------ | Branch (572:9): [True: 3.55k, False: 5.24k] ------------------ 573| 3.55k| return; 574| 5.24k| if (obErrorLog.GetOutputLevel() >= obAuditMsg) ------------------ | Branch (574:9): [True: 0, False: 5.24k] ------------------ 575| 0| obErrorLog.ThrowError(__FUNCTION__, 576| 0| "Ran OpenBabel::FindRingAtomsAndBonds", obAuditMsg); 577| 5.24k| FindRingAtomsAndBonds2(*this); 578| 5.24k| } _ZN9OpenBabel6OBRingC2ERNSt3__16vectorIiNS1_9allocatorIiEEEEi: 658| 91.1k| { 659| 91.1k| _pathset.FromVecInt(_path); 660| 91.1k| _pathset.Resize(size); 661| 91.1k| _type[0] = '\0'; 662| 91.1k| } _ZN9OpenBabel7OBRTreeC2EPNS_6OBAtomEPS0_: 740| 16.6M| { 741| 16.6M| _atom = atom; 742| 16.6M| _prv = prv; 743| 16.6M| } _ZN9OpenBabel7OBRTree10PathToRootERNSt3__16vectorIPNS_6OBAtomENS1_9allocatorIS4_EEEE: 748| 166M| { 749| 166M| path.push_back(_atom); 750| 166M| if (_prv) ------------------ | Branch (750:9): [True: 152M, False: 14.2M] ------------------ 751| 152M| _prv->PathToRoot(path); 752| 166M| } _ZN9OpenBabel7OBRTree10GetAtomIdxEv: 755| 14.2M| { 756| 14.2M| return(_atom->GetIdx()); 757| 14.2M| } ring.cpp:_ZN9OpenBabelL12DetermineFRJERNS_5OBMolE: 304| 4.91k| { 305| 4.91k| if (!mol.HasClosureBondsPerceived()) ------------------ | Branch (305:9): [True: 0, False: 4.91k] ------------------ 306| 0| return (int)FindRingAtomsAndBonds2(mol); 307| | 308| 4.91k| int frj = 0; 309| 4.91k| OBBond *bond; 310| 4.91k| vector::iterator j; 311| 43.1M| for (bond = mol.BeginBond(j);bond;bond = mol.NextBond(j)) ------------------ | Branch (311:34): [True: 43.1M, False: 4.91k] ------------------ 312| 43.1M| if (bond->IsClosure()) // bond->HasFlag(OB_CLOSURE_BOND)? ------------------ | Branch (312:11): [True: 92.6k, False: 43.0M] ------------------ 313| 92.6k| frj++; 314| 4.91k| return frj; 315| 4.91k| } ring.cpp:_ZN9OpenBabelL22FindRingAtomsAndBonds2ERNS_5OBMolE: 538| 5.24k| { 539| 5.24k| mol.SetRingAtomsAndBondsPerceived(); // mol.SetFlag(OB_RINGFLAGS_MOL); 540| 5.24k| mol.SetClosureBondsPerceived(); // mol.SetFlag(OB_CLOSURE_MOL); 541| | 542| 5.24k| FOR_ATOMS_OF_MOL(atom, mol) ------------------ | | 398| 43.3M|#define FOR_ATOMS_OF_MOL(a,m) for( OpenBabel::OBMolAtomIter a(m); a; ++a ) | | ------------------ | | | Branch (398:75): [True: 43.3M, False: 5.24k] | | ------------------ ------------------ 543| 43.3M| atom->SetInRing(false); 544| 43.3M| FOR_BONDS_OF_MOL(bond, mol) { ------------------ | | 399| 43.3M|#define FOR_BONDS_OF_MOL(b,m) for( OpenBabel::OBMolBondIter b(m); b; ++b ) | | ------------------ | | | Branch (399:75): [True: 43.3M, False: 5.24k] | | ------------------ ------------------ 545| 43.3M| bond->SetInRing(false); 546| 43.3M| bond->SetClosure(false); 547| 43.3M| } 548| | 549| 5.24k| unsigned int bsize = mol.NumBonds()+1; 550| 5.24k| unsigned char *bvisit = (unsigned char*)malloc(bsize); 551| 5.24k| memset(bvisit,0,bsize); 552| | 553| 5.24k| unsigned int acount = mol.NumAtoms(); 554| 5.24k| unsigned int asize = (unsigned int)((acount+1)*sizeof(int)); 555| 5.24k| int *avisit = (int*)malloc(asize); 556| 5.24k| memset(avisit,0,asize); 557| | 558| 5.24k| unsigned int frj = 0; 559| 43.3M| for(unsigned int i=1; i<=acount; i++ ) ------------------ | Branch (559:27): [True: 43.3M, False: 5.24k] ------------------ 560| 43.3M| if(avisit[i] == 0) { ------------------ | Branch (560:10): [True: 29.3k, False: 43.3M] ------------------ 561| 29.3k| avisit[i] = 1; 562| 29.3k| OBAtom *atom = mol.GetAtom(i); 563| 29.3k| FindRings(atom,avisit,bvisit,frj,1); 564| 29.3k| } 565| 5.24k| free(avisit); 566| 5.24k| free(bvisit); 567| 5.24k| return frj; 568| 5.24k| } ring.cpp:_ZN9OpenBabelL9FindRingsEPNS_6OBAtomEPiPhRji: 502| 43.3M| { 503| 43.3M| OBBond *bond; 504| 43.3M| int result = -1; 505| 43.3M| vector::iterator k; 506| 130M| for(bond = atom->BeginBond(k);bond;bond=atom->NextBond(k)) { ------------------ | Branch (506:35): [True: 86.7M, False: 43.3M] ------------------ 507| 86.7M| unsigned int bidx = bond->GetIdx(); 508| 86.7M| if (bvisit[bidx] == 0) { ------------------ | Branch (508:11): [True: 43.3M, False: 43.3M] ------------------ 509| 43.3M| bvisit[bidx] = 1; 510| 43.3M| OBAtom *nbor = bond->GetNbrAtom(atom); 511| 43.3M| unsigned int nidx = nbor->GetIdx(); 512| 43.3M| int nvisit = avisit[nidx]; 513| 43.3M| if (nvisit == 0) { ------------------ | Branch (513:13): [True: 43.3M, False: 92.6k] ------------------ 514| 43.3M| avisit[nidx] = depth+1; 515| 43.3M| nvisit = FindRings(nbor,avisit,bvisit,frj,depth+1); 516| 43.3M| if (nvisit > 0) { ------------------ | Branch (516:15): [True: 2.47M, False: 40.8M] ------------------ 517| 2.47M| if (nvisit <= depth) { ------------------ | Branch (517:17): [True: 2.44M, False: 28.3k] ------------------ 518| 2.44M| bond->SetInRing(); 519| 2.44M| if (result < 0 || nvisit < result) ------------------ | Branch (519:19): [True: 2.41M, False: 32.6k] | Branch (519:33): [True: 6.29k, False: 26.3k] ------------------ 520| 2.42M| result = nvisit; 521| 2.44M| } 522| 2.47M| } 523| 43.3M| } else { 524| 92.6k| if (result < 0 || nvisit < result) ------------------ | Branch (524:15): [True: 63.2k, False: 29.3k] | Branch (524:29): [True: 9.10k, False: 20.2k] ------------------ 525| 72.3k| result = nvisit; 526| 92.6k| bond->SetClosure(); 527| 92.6k| bond->SetInRing(); 528| 92.6k| frj++; 529| 92.6k| } 530| 43.3M| } 531| 86.7M| } 532| 43.3M| if (result > 0 && result <= depth) ------------------ | Branch (532:9): [True: 2.47M, False: 40.8M] | Branch (532:23): [True: 2.47M, False: 0] ------------------ 533| 2.47M| atom->SetInRing(); 534| 43.3M| return result; 535| 43.3M| } ring.cpp:_ZN9OpenBabelL18BuildOBRTreeVectorEPNS_6OBAtomEPNS_7OBRTreeERNSt3__16vectorIS3_NS4_9allocatorIS3_EEEERNS_8OBBitVecE: 700| 185k| { 701| 185k| vt[atom->GetIdx()] = new OBRTree (atom,prv); 702| | 703| 185k| int i; 704| 185k| OBAtom *nbr; 705| 185k| OBMol *mol = (OBMol*)atom->GetParent(); 706| 185k| OBBitVec curr,used,next; 707| 185k| vector::iterator j; 708| 185k| curr |= atom->GetIdx(); 709| 185k| used = bv|curr; 710| | 711| 185k|#define OB_RTREE_CUTOFF 20 712| | 713| 185k| int level=0; 714| 185k| for (;;) 715| 3.53M| { 716| 3.53M| next.Clear(); 717| 19.4M| for (i = curr.NextBit(0);i != bv.EndBit();i = curr.NextBit(i)) ------------------ | Branch (717:34): [True: 15.9M, False: 3.53M] ------------------ 718| 15.9M| { 719| 15.9M| atom = mol->GetAtom(i); 720| 66.9M| for (nbr = atom->BeginNbrAtom(j);nbr;nbr = atom->NextNbrAtom(j)) ------------------ | Branch (720:46): [True: 51.0M, False: 15.9M] ------------------ 721| 51.0M| if (!used[nbr->GetIdx()]) ------------------ | Branch (721:19): [True: 16.4M, False: 34.5M] ------------------ 722| 16.4M| { 723| 16.4M| next |= nbr->GetIdx(); 724| 16.4M| used |= nbr->GetIdx(); 725| 16.4M| vt[nbr->GetIdx()] = new OBRTree (nbr,vt[atom->GetIdx()]); 726| 16.4M| } 727| 15.9M| } 728| | 729| 3.53M| if (next.IsEmpty()) ------------------ | Branch (729:13): [True: 34.5k, False: 3.50M] ------------------ 730| 34.5k| break; 731| 3.50M| curr = next; 732| 3.50M| level++; 733| 3.50M| if (level > OB_RTREE_CUTOFF) ------------------ | | 711| 3.50M|#define OB_RTREE_CUTOFF 20 ------------------ | Branch (733:13): [True: 150k, False: 3.35M] ------------------ 734| 150k| break; 735| 3.50M| } 736| 185k|#undef OB_RTREE_CUTOFF 737| 185k| } _ZN9OpenBabel16OBCisTransStereoC2EPNS_5OBMolE: 81| 277k| { 82| 277k| } _ZN9OpenBabel16OBCisTransStereoD2Ev: 85| 277k| { 86| 277k| } _ZN9OpenBabel16OBCisTransStereo9SetConfigERKNS0_6ConfigE: 98| 277k| { 99| 277k| if (config.begin == OBStereo::NoRef) { ------------------ | Branch (99:9): [True: 0, False: 277k] ------------------ 100| 0| obErrorLog.ThrowError(__FUNCTION__, 101| 0| "OBCisTransStereo::SetConfig : double bond begin id is invalid.", obError); 102| 0| m_cfg = Config(); 103| 0| return; 104| 0| } 105| 277k| if (config.end == OBStereo::NoRef) { ------------------ | Branch (105:9): [True: 0, False: 277k] ------------------ 106| 0| obErrorLog.ThrowError(__FUNCTION__, 107| 0| "OBCisTransStereo::SetConfig : double bond end id is invalid.", obError); 108| 0| m_cfg = Config(); 109| 0| return; 110| 0| } 111| 277k| if (config.refs.size() != 4) { ------------------ | Branch (111:9): [True: 0, False: 277k] ------------------ 112| 0| std::stringstream ss; 113| 0| ss << "OBCisTransStereo::SetConfig : found " << config.refs.size(); 114| 0| ss << " reference ids, should be 4."; 115| 0| obErrorLog.ThrowError(__FUNCTION__, ss.str(), obError); 116| 0| m_cfg = Config(); 117| 0| return; 118| 0| } 119| | 120| | // store using U shape 121| 277k| m_cfg = OBTetraPlanarStereo::ToConfig(config, config.refs.at(0), OBStereo::ShapeU); 122| 277k| } _ZN9OpenBabel20OBSquarePlanarStereoC2EPNS_5OBMolE: 79| 23.9k| { 80| 23.9k| } _ZN9OpenBabel20OBSquarePlanarStereoD2Ev: 83| 23.9k| { 84| 23.9k| } _ZN9OpenBabel20OBSquarePlanarStereo9SetConfigERKNS0_6ConfigE: 96| 23.9k| { 97| 23.9k| if (config.center == OBStereo::NoRef) { ------------------ | Branch (97:9): [True: 0, False: 23.9k] ------------------ 98| 0| obErrorLog.ThrowError(__FUNCTION__, 99| 0| "OBSquarePlanarStereo::SetConfig : center id is invalid.", obError); 100| 0| m_cfg = Config(); 101| 0| return; 102| 0| } 103| 23.9k| if (config.refs.size() != 4) { ------------------ | Branch (103:9): [True: 0, False: 23.9k] ------------------ 104| 0| std::stringstream ss; 105| 0| ss << "OBSquarePlanarStereo::SetConfig : found " << config.refs.size(); 106| 0| ss << " reference ids, should be 4."; 107| 0| obErrorLog.ThrowError(__FUNCTION__, ss.str(), obError); 108| 0| m_cfg = Config(); 109| 0| return; 110| 0| } 111| | 112| | // store using U shape 113| 23.9k| m_cfg = OBTetraPlanarStereo::ToConfig(config, config.refs.at(0), OBStereo::ShapeU); 114| 23.9k| } _ZN9OpenBabel8OBStereo9PermutateERNSt3__16vectorImNS1_9allocatorImEEEEjj: 76| 20.5k| { 77| 20.5k| if (i >= refs.size()) ------------------ | Branch (77:9): [True: 0, False: 20.5k] ------------------ 78| 0| return; 79| 20.5k| if (j >= refs.size()) ------------------ | Branch (79:9): [True: 0, False: 20.5k] ------------------ 80| 0| return; 81| 20.5k| unsigned long id = refs.at(i); 82| 20.5k| refs[i] = refs.at(j); 83| 20.5k| refs[j] = id; 84| 20.5k| } _ZN9OpenBabel19OBTetrahedralStereoC2EPNS_5OBMolE: 119| 46.2k| { 120| 46.2k| } _ZN9OpenBabel19OBTetrahedralStereoD2Ev: 123| 46.2k| { 124| 46.2k| } _ZN9OpenBabel19OBTetrahedralStereo9SetConfigERKNS0_6ConfigE: 138| 46.2k| { 139| 46.2k| if (config.center == OBStereo::NoRef) { ------------------ | Branch (139:9): [True: 0, False: 46.2k] ------------------ 140| 0| obErrorLog.ThrowError(__FUNCTION__, 141| 0| "OBTetrahedralStereo::SetConfig : center atom id is invalid.", obError); 142| 0| m_cfg = Config(); 143| 0| return; 144| 0| } 145| 46.2k| if (config.from == OBStereo::NoRef) { ------------------ | Branch (145:9): [True: 0, False: 46.2k] ------------------ 146| 0| obErrorLog.ThrowError(__FUNCTION__, 147| 0| "OBTetrahedralStereo::SetConfig : from/towards atom id is invalid.", obError); 148| 0| m_cfg = Config(); 149| 0| return; 150| 0| } 151| 46.2k| if (config.refs.size() != 3) { ------------------ | Branch (151:9): [True: 0, False: 46.2k] ------------------ 152| 0| std::stringstream ss; 153| 0| ss << "OBTetrahedralStereo::SetConfig : found " << config.refs.size(); 154| 0| ss << " reference ids, should be 3."; 155| 0| obErrorLog.ThrowError(__FUNCTION__, ss.str(), obError); 156| 0| m_cfg = Config(); 157| 0| return; 158| 0| } 159| | 160| 46.2k| m_cfg = config; 161| 46.2k| } _ZN9OpenBabel22OBTetraNonPlanarStereoC2EPNS_5OBMolE: 29| 46.2k| { 30| 46.2k| } _ZN9OpenBabel22OBTetraNonPlanarStereoD2Ev: 33| 46.2k| { 34| 46.2k| } _ZN9OpenBabel19OBTetraPlanarStereoC2EPNS_5OBMolE: 30| 301k| { 31| 301k| } _ZN9OpenBabel19OBTetraPlanarStereoD2Ev: 34| 301k| { 35| 301k| } _ZN9OpenBabel4TrimERNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEE: 136| 696| { 137| 696| string::size_type pos = txt.find_last_not_of(" \t\n\r"); 138| 696| if(pos!=string::npos) ------------------ | Branch (138:8): [True: 614, False: 82] ------------------ 139| 614| txt.erase(pos+1); 140| 82| else 141| 82| txt.erase(); 142| | 143| 696| pos = txt.find_first_not_of(" \t\n\r"); 144| 696| if(pos!=string::npos) ------------------ | Branch (144:8): [True: 614, False: 82] ------------------ 145| 614| txt.erase(0, pos); 146| 82| else 147| 82| txt.erase(); 148| 696| return txt; 149| 696| } _ZN9OpenBabel11OBAtomTyperC2Ev: 62| 1| { 63| 1| _init = false; 64| 1| _dir = BABEL_DATADIR; ------------------ | | 4| 1|#define BABEL_DATADIR "/usr/local/share/openbabel" ------------------ 65| 1| _envvar = "BABEL_DATADIR"; 66| 1| _filename = "atomtyp.txt"; 67| 1| _subdir = "data"; 68| 1| _dataptr = AtomTypeData; 69| 1| } _ZN9OpenBabel11OBAtomTyperD2Ev: 118| 1| { 119| 1| vector >::iterator i; 120| 1| for (i = _vinthyb.begin();i != _vinthyb.end();++i) ------------------ | Branch (120:31): [True: 0, False: 1] ------------------ 121| 0| { 122| 0| delete i->first; 123| 0| i->first = nullptr; 124| 0| } 125| | 126| 1| vector >::iterator j; 127| 1| for (j = _vexttyp.begin();j != _vexttyp.end();++j) ------------------ | Branch (127:31): [True: 0, False: 1] ------------------ 128| 0| { 129| 0| delete j->first; 130| 0| j->first = nullptr; 131| 0| } 132| | 133| 1| } _ZN9OpenBabel11OBRingTyperC2Ev: 245| 2| { 246| 2| _init = false; 247| 2| _dir = BABEL_DATADIR; ------------------ | | 4| 2|#define BABEL_DATADIR "/usr/local/share/openbabel" ------------------ 248| 2| _envvar = "BABEL_DATADIR"; 249| 2| _filename = "ringtyp.txt"; 250| 2| _subdir = "data"; 251| 2| _dataptr = RingTypeData; 252| 2| } _ZN9OpenBabel23OBAromaticTyperMolState19AssignAromaticFlagsEv: 613| 4.91k| { 614| 4.91k| OBBond *bond; 615| 4.91k| OBAtom *atom; 616| 4.91k| vector::iterator i; 617| 4.91k| vector::iterator j; 618| | 619| | //unset all aromatic flags 620| 43.1M| for (atom = mol.BeginAtom(i); atom; atom = mol.NextAtom(i)) ------------------ | Branch (620:35): [True: 43.1M, False: 4.91k] ------------------ 621| 43.1M| atom->SetAromatic(false); 622| 43.1M| for (bond = mol.BeginBond(j); bond; bond = mol.NextBond(j)) ------------------ | Branch (622:35): [True: 43.1M, False: 4.91k] ------------------ 623| 43.1M| bond->SetAromatic(false); 624| | 625| | // New code using lookups instead of SMARTS patterns 626| 43.1M| FOR_ATOMS_OF_MOL(atom, mol) { ------------------ | | 398| 43.1M|#define FOR_ATOMS_OF_MOL(a,m) for( OpenBabel::OBMolAtomIter a(m); a; ++a ) | | ------------------ | | | Branch (398:75): [True: 43.1M, False: 4.91k] | | ------------------ ------------------ 627| 43.1M| unsigned int idx = atom->GetIdx(); 628| 43.1M| _vpa[idx] = AssignOBAromaticityModel(&(*atom), _velec[idx].first, _velec[idx].second); 629| 43.1M| } 630| | 631| | //propagate potentially aromatic atoms 632| 43.1M| for (atom = mol.BeginAtom(i); atom; atom = mol.NextAtom(i)) ------------------ | Branch (632:35): [True: 43.1M, False: 4.91k] ------------------ 633| 43.1M| if (_vpa[atom->GetIdx()]) ------------------ | Branch (633:11): [True: 667k, False: 42.4M] ------------------ 634| 667k| PropagatePotentialAromatic(atom); 635| | 636| | //select root atoms 637| 4.91k| SelectRootAtoms(); 638| | 639| 4.91k| ExcludeSmallRing(); //remove 3 membered rings from consideration 640| | 641| | //loop over root atoms and look for aromatic rings 642| | 643| 43.1M| for (atom = mol.BeginAtom(i); atom; atom = mol.NextAtom(i)) ------------------ | Branch (643:35): [True: 43.1M, False: 4.91k] ------------------ 644| 43.1M| if (_root[atom->GetIdx()]) ------------------ | Branch (644:11): [True: 73.6k, False: 43.0M] ------------------ 645| 73.6k| CheckAromaticity(atom, 14); 646| | 647| | //for (atom = mol.BeginAtom(i);atom;atom = mol.NextAtom(i)) 648| | // if (atom->IsAromatic()) 649| | // cerr << "aro = " <GetIdx() << endl; 650| | 651| | //for (bond = mol.BeginBond(j);bond;bond = mol.NextBond(j)) 652| | //if (bond->IsAromatic()) 653| | //cerr << bond->GetIdx() << ' ' << bond->IsAromatic() << endl; 654| 4.91k| } _ZN9OpenBabel15OBAromaticTyper19AssignAromaticFlagsERNS_5OBMolE: 671| 4.91k| { 672| 4.91k| if (mol.HasAromaticPerceived()) ------------------ | Branch (672:9): [True: 0, False: 4.91k] ------------------ 673| 0| return; 674| 4.91k| mol.SetAromaticPerceived(); 675| 4.91k| obErrorLog.ThrowError(__FUNCTION__, 676| 4.91k| "Ran OpenBabel::AssignAromaticFlags", obAuditMsg); 677| | 678| 4.91k| OBAromaticTyperMolState molstate(mol); 679| 4.91k| molstate.AssignAromaticFlags(); 680| 4.91k| } _ZN9OpenBabel23OBAromaticTyperMolState13TraverseCycleEPNS_6OBAtomES2_PNS_6OBBondERNSt3__14pairIiiEEi: 697| 1.36M| { 698| 1.36M| if (atom == root) ------------------ | Branch (698:9): [True: 27.2k, False: 1.33M] ------------------ 699| 27.2k| { 700| 27.2k| int i; 701| 76.1k| for (i = er.first;i <= er.second;++i) ------------------ | Branch (701:27): [True: 60.0k, False: 16.1k] ------------------ 702| 60.0k| if (i%4 == 2 && i > 2) ------------------ | Branch (702:15): [True: 19.0k, False: 41.0k] | Branch (702:27): [True: 11.1k, False: 7.86k] ------------------ 703| 11.1k| return(true); 704| | 705| 16.1k| return(false); 706| 27.2k| } 707| | 708| 1.33M| if (!depth || !_vpa[atom->GetIdx()] || _visit[atom->GetIdx()]) ------------------ | Branch (708:9): [True: 309k, False: 1.02M] | Branch (708:9): [True: 725k, False: 611k] | Branch (708:19): [True: 227k, False: 800k] | Branch (708:44): [True: 189k, False: 611k] ------------------ 709| 725k| return(false); 710| | 711| 611k| bool result = false; 712| | 713| 611k| depth--; 714| 611k| er.first += _velec[atom->GetIdx()].first; 715| 611k| er.second += _velec[atom->GetIdx()].second; 716| | 717| 611k| _visit[atom->GetIdx()] = true; 718| 611k| OBAtom *nbr; 719| 611k| vector::iterator i; 720| 2.40M| for (nbr = atom->BeginNbrAtom(i);nbr;nbr = atom->NextNbrAtom(i)) ------------------ | Branch (720:38): [True: 1.79M, False: 611k] ------------------ 721| 1.79M| if (*i != prev && (*i)->IsInRing() && _vpa[nbr->GetIdx()]) ------------------ | Branch (721:11): [True: 1.18M, False: 611k] | Branch (721:11): [True: 1.13M, False: 665k] | Branch (721:25): [True: 1.16M, False: 23.5k] | Branch (721:45): [True: 1.13M, False: 29.9k] ------------------ 722| 1.13M| { 723| 1.13M| if (TraverseCycle(root,nbr,(OBBond*)(*i),er,depth)) ------------------ | Branch (723:15): [True: 65.1k, False: 1.06M] ------------------ 724| 65.1k| { 725| 65.1k| result = true; 726| 65.1k| ((OBBond*) *i)->SetAromatic(); 727| 65.1k| } 728| 1.13M| } 729| | 730| 611k| _visit[atom->GetIdx()] = false; 731| 611k| if (result) ------------------ | Branch (731:9): [True: 56.0k, False: 555k] ------------------ 732| 56.0k| atom->SetAromatic(); 733| | 734| 611k| er.first -= _velec[atom->GetIdx()].first; 735| 611k| er.second -= _velec[atom->GetIdx()].second; 736| | 737| 611k| return(result); 738| 1.33M| } _ZN9OpenBabel23OBAromaticTyperMolState16CheckAromaticityEPNS_6OBAtomEi: 741| 73.6k| { 742| 73.6k| OBAtom *nbr; 743| 73.6k| vector::iterator i; 744| | 745| 73.6k| pair erange; 746| 410k| for (nbr = atom->BeginNbrAtom(i);nbr;nbr = atom->NextNbrAtom(i)) ------------------ | Branch (746:38): [True: 337k, False: 73.6k] ------------------ 747| 337k| if ((*i)->IsInRing()) // check all rings, regardless of assumed aromaticity ------------------ | Branch (747:11): [True: 233k, False: 103k] ------------------ 748| 233k| { 749| 233k| erange = _velec[atom->GetIdx()]; 750| | 751| 233k| if (TraverseCycle(atom,nbr,(OBBond *)*i,erange,depth-1)) ------------------ | Branch (751:15): [True: 2.06k, False: 231k] ------------------ 752| 2.06k| { 753| 2.06k| atom->SetAromatic(); 754| 2.06k| ((OBBond*) *i)->SetAromatic(); 755| 2.06k| } 756| 233k| } 757| 73.6k| } _ZN9OpenBabel23OBAromaticTyperMolState26PropagatePotentialAromaticEPNS_6OBAtomE: 760| 2.44M| { 761| 2.44M| int count = 0; 762| 2.44M| OBAtom *nbr; 763| 2.44M| vector::iterator i; 764| | 765| 7.36M| for (nbr = atom->BeginNbrAtom(i);nbr;nbr = atom->NextNbrAtom(i)) ------------------ | Branch (765:38): [True: 4.92M, False: 2.44M] ------------------ 766| 4.92M| if ((*i)->IsInRing() && _vpa[nbr->GetIdx()]) ------------------ | Branch (766:11): [True: 4.90M, False: 22.5k] | Branch (766:11): [True: 2.72M, False: 2.20M] | Branch (766:31): [True: 2.72M, False: 2.17M] ------------------ 767| 2.72M| count++; 768| | 769| 2.44M| if (count < 2) ------------------ | Branch (769:9): [True: 1.96M, False: 473k] ------------------ 770| 1.96M| { 771| 1.96M| _vpa[atom->GetIdx()] = false; 772| 1.96M| if (count == 1) ------------------ | Branch (772:13): [True: 1.77M, False: 194k] ------------------ 773| 5.33M| for (nbr = atom->BeginNbrAtom(i);nbr;nbr = atom->NextNbrAtom(i)) ------------------ | Branch (773:44): [True: 3.56M, False: 1.77M] ------------------ 774| 3.56M| if ((*i)->IsInRing() && _vpa[nbr->GetIdx()]) ------------------ | Branch (774:17): [True: 3.55M, False: 5.37k] | Branch (774:17): [True: 1.77M, False: 1.79M] | Branch (774:37): [True: 1.77M, False: 1.78M] ------------------ 775| 1.77M| PropagatePotentialAromatic(nbr); 776| 1.96M| } 777| 2.44M| } _ZN9OpenBabel23OBAromaticTyperMolState15SelectRootAtomsEb: 797| 4.91k| { 798| 4.91k| OBBond *bond; 799| 4.91k| OBAtom *atom, *nbr, *nbr2; 800| 4.91k| OBRing *ring; 801| | // vector::iterator i; 802| 4.91k| vector::iterator j, l, nbr2Iter; 803| 4.91k| vector sssRings = mol.GetSSSR(); 804| 4.91k| vector::iterator k; 805| | 806| 4.91k| int rootAtom; 807| 4.91k| int ringNbrs; 808| 4.91k| int heavyNbrs; 809| 4.91k| int newRoot = -1; 810| 4.91k| vector tmpRootAtoms; 811| 4.91k| vector tmp; 812| | 813| 4.91k| vector cbonds; 814| 4.91k| vector< vector > ringAtoms; // store ring pointers on an atom basis 815| | 816| | //generate list of closure bonds 817| 43.1M| for (bond = mol.BeginBond(j);bond;bond = mol.NextBond(j)) ------------------ | Branch (817:34): [True: 43.1M, False: 4.91k] ------------------ 818| 43.1M| { 819| 43.1M| if( bond->IsClosure() ) ------------------ | Branch (819:13): [True: 92.6k, False: 43.0M] ------------------ 820| 92.6k| { 821| 92.6k| cbonds.push_back(bond); 822| 92.6k| if(avoidInnerRingAtoms) ------------------ | Branch (822:16): [True: 92.6k, False: 0] ------------------ 823| 92.6k| { 824| 92.6k| tmpRootAtoms.push_back(bond->GetBeginAtomIdx()); 825| 92.6k| } 826| 92.6k| } 827| 43.1M| } 828| | 829| 4.91k| if(avoidInnerRingAtoms) ------------------ | Branch (829:8): [True: 4.91k, False: 0] ------------------ 830| 4.91k| { 831| | //for every atom fill vector with ring pointer it's associated with 832| 4.91k| ringAtoms.resize(mol.NumAtoms()+1); 833| 96.0k| for (k = sssRings.begin();k != sssRings.end();++k) ------------------ | Branch (833:35): [True: 91.1k, False: 4.91k] ------------------ 834| 91.1k| { 835| 91.1k| tmp = (*k)->_path; 836| 446k| for (unsigned int j (0),j_end(tmp.size()); j < j_end; ++j) ------------------ | Branch (836:56): [True: 354k, False: 91.1k] ------------------ 837| 354k| { 838| 354k| ringAtoms[tmp[j]].push_back(*k); 839| 354k| } 840| 91.1k| } 841| 4.91k| } 842| | 843| | 844| | //loop over closure bonds 845| 97.5k| for(OBBondIterator bd(cbonds.begin()),bd_end(cbonds.end());bd!=bd_end;++bd) ------------------ | Branch (845:64): [True: 92.6k, False: 4.91k] ------------------ 846| 92.6k| { 847| 92.6k| bond = *bd; 848| | 849| | // BASIC APPROACH 850| | // pick beginning atom at closure bond 851| | // this is really ready, isn't it ! ;-) 852| 92.6k| rootAtom = bond->GetBeginAtomIdx(); 853| 92.6k| _root[rootAtom] = true; 854| | 855| | // EXTENDED APPROACH 856| 92.6k| if (avoidInnerRingAtoms) ------------------ | Branch (856:13): [True: 92.6k, False: 0] ------------------ 857| 92.6k| { 858| | // count the number of neighbor ring atoms 859| 92.6k| atom = mol.GetAtom(rootAtom); 860| 92.6k| ringNbrs = heavyNbrs = 0; 861| | 862| 723k| for (nbr = atom->BeginNbrAtom(l);nbr;nbr = atom->NextNbrAtom(l)) ------------------ | Branch (862:46): [True: 630k, False: 92.6k] ------------------ 863| 630k| { 864| | // we can get this from atom->GetHvyDegree() 865| | // but we need to find neighbors in rings too 866| | // so let's save some time 867| 630k| if (nbr->GetAtomicNum() != OBElements::Hydrogen) ------------------ | Branch (867:21): [True: 630k, False: 337] ------------------ 868| 630k| { 869| 630k| heavyNbrs++; 870| 630k| if (nbr->IsInRing()) ------------------ | Branch (870:25): [True: 416k, False: 213k] ------------------ 871| 416k| ringNbrs++; 872| 630k| } 873| | 874| | // if this atom has more than 2 neighbor ring atoms 875| | // we could get trapped later when traversing cycles 876| | // which can cause aromaticity false detection 877| 630k| newRoot = -1; 878| | 879| 630k| if (ringNbrs > 2) ------------------ | Branch (879:21): [True: 335k, False: 295k] ------------------ 880| 335k| { 881| | // try to find another root atom 882| | // only loop over rings which contain rootAtom 883| 21.4M| for(k = ringAtoms[rootAtom].begin() ; k != ringAtoms[rootAtom].end(); ++k) ------------------ | Branch (883:59): [True: 21.1M, False: 335k] ------------------ 884| 21.1M| { 885| 21.1M| ring = (*k); 886| 21.1M| tmp = ring->_path; 887| | 888| 21.1M| bool checkThisRing = false; 889| 21.1M| int rootAtomNumber=0; 890| 21.1M| int idx=0; 891| | // avoiding two root atoms in one ring ! 892| 330M| for (unsigned int j = 0; j < tmpRootAtoms.size(); ++j) ------------------ | Branch (892:50): [True: 330M, False: 14.6k] ------------------ 893| 330M| { 894| 330M| idx= tmpRootAtoms[j]; 895| 330M| if(ring->IsInRing(idx)) ------------------ | Branch (895:32): [True: 42.2M, False: 288M] ------------------ 896| 42.2M| { 897| 42.2M| rootAtomNumber++; 898| 42.2M| if(rootAtomNumber>=2) ------------------ | Branch (898:36): [True: 21.1M, False: 21.1M] ------------------ 899| 21.1M| break; 900| 42.2M| } 901| 330M| } 902| 21.1M| if(rootAtomNumber<2) ------------------ | Branch (902:28): [True: 14.6k, False: 21.1M] ------------------ 903| 14.6k| { 904| 72.9k| for (unsigned int j = 0; j < tmp.size(); ++j) ------------------ | Branch (904:54): [True: 60.9k, False: 12.0k] ------------------ 905| 60.9k| { 906| | // find critical ring 907| 60.9k| if (tmp[j] == rootAtom) ------------------ | Branch (907:37): [True: 13.1k, False: 47.7k] ------------------ 908| 13.1k| { 909| 13.1k| checkThisRing = true; 910| 13.1k| } 911| 47.7k| else 912| 47.7k| { 913| | // second root atom in this ring ? 914| 47.7k| if (_root[tmp[j]] == true) ------------------ | Branch (914:41): [True: 2.66k, False: 45.1k] ------------------ 915| 2.66k| { 916| | // when there is a second root 917| | // atom this ring can not be 918| | // used for getting an other 919| | // root atom 920| 2.66k| checkThisRing = false; 921| | 922| 2.66k| break; 923| 2.66k| } 924| 47.7k| } 925| 60.9k| } 926| 14.6k| } 927| | 928| | // check ring for getting another 929| | // root atom to avoid aromaticity typer problems 930| 21.1M| if (checkThisRing) ------------------ | Branch (930:29): [True: 12.0k, False: 21.1M] ------------------ 931| 12.0k| { 932| | // check if we can find another root atom 933| 63.9k| for (unsigned int m = 0; m < tmp.size(); ++m) ------------------ | Branch (933:54): [True: 51.9k, False: 12.0k] ------------------ 934| 51.9k| { 935| 51.9k| ringNbrs = heavyNbrs = 0; 936| 51.9k| for (nbr2 = (mol.GetAtom(tmp[m]))->BeginNbrAtom(nbr2Iter); 937| 200k| nbr2;nbr2 = (mol.GetAtom(tmp[m]))->NextNbrAtom(nbr2Iter)) ------------------ | Branch (937:38): [True: 148k, False: 51.9k] ------------------ 938| 148k| { 939| 148k| if (nbr2->GetAtomicNum() != OBElements::Hydrogen) ------------------ | Branch (939:41): [True: 148k, False: 239] ------------------ 940| 148k| { 941| 148k| heavyNbrs++; 942| | 943| 148k| if (nbr2->IsInRing()) ------------------ | Branch (943:45): [True: 134k, False: 14.6k] ------------------ 944| 134k| ringNbrs++; 945| 148k| } 946| 148k| } 947| | 948| | // if the number of neighboured heavy atoms is also 949| | // the number of neighboured ring atoms, the aromaticity 950| | // typer could be stuck in a local traversing trap 951| 51.9k| if (ringNbrs <= 2 && ring->IsInRing((mol.GetAtom(tmp[m])->GetIdx()))) ------------------ | Branch (951:37): [True: 26.7k, False: 25.1k] | Branch (951:54): [True: 26.7k, False: 0] ------------------ 952| 26.7k| { 953| 26.7k| newRoot = tmp[m]; 954| 26.7k| } 955| 51.9k| } 956| 12.0k| } 957| 21.1M| } 958| | 959| 335k| if ((newRoot != -1) && (rootAtom != newRoot)) ------------------ | Branch (959:25): [True: 9.96k, False: 325k] | Branch (959:44): [True: 9.96k, False: 0] ------------------ 960| 9.96k| { 961| | // unset root atom 962| 9.96k| _root[rootAtom] = false; 963| | 964| | // pick new root atom 965| 9.96k| _root[newRoot] = true; 966| 9.96k| } 967| 335k| } // if (ringNbrs > 2) 968| | 969| 630k| } // end for 970| 92.6k| } // if (avoid) 971| 92.6k| } // end for(closure bonds) 972| 4.91k| } _ZN9OpenBabel23OBAromaticTyperMolState16ExcludeSmallRingEv: 975| 4.91k| { 976| 4.91k| OBAtom *atom,*nbr1,*nbr2; 977| 4.91k| vector::iterator i; 978| 4.91k| vector::iterator j,k; 979| | 980| 43.1M| for (atom = mol.BeginAtom(i);atom;atom = mol.NextAtom(i)) ------------------ | Branch (980:34): [True: 43.1M, False: 4.91k] ------------------ 981| 43.1M| if (_root[atom->GetIdx()]) ------------------ | Branch (981:11): [True: 76.8k, False: 43.0M] ------------------ 982| 422k| for (nbr1 = atom->BeginNbrAtom(j);nbr1;nbr1 = atom->NextNbrAtom(j)) ------------------ | Branch (982:43): [True: 345k, False: 76.8k] ------------------ 983| 345k| if ((*j)->IsInRing() && _vpa[nbr1->GetIdx()]) ------------------ | Branch (983:15): [True: 240k, False: 105k] | Branch (983:15): [True: 13.2k, False: 332k] | Branch (983:35): [True: 13.2k, False: 227k] ------------------ 984| 50.5k| for (nbr2 = nbr1->BeginNbrAtom(k);nbr2;nbr2 = nbr1->NextNbrAtom(k)) ------------------ | Branch (984:47): [True: 37.2k, False: 13.2k] ------------------ 985| 37.2k| if (nbr2 != atom && (*k)->IsInRing() && _vpa[nbr2->GetIdx()]) ------------------ | Branch (985:19): [True: 23.9k, False: 13.2k] | Branch (985:19): [True: 19.2k, False: 18.0k] | Branch (985:35): [True: 21.0k, False: 2.92k] | Branch (985:55): [True: 19.2k, False: 1.81k] ------------------ 986| 19.2k| if (atom->IsConnected(nbr2)) ------------------ | Branch (986:21): [True: 7.46k, False: 11.7k] ------------------ 987| 7.46k| _root[atom->GetIdx()] = false; 988| 4.91k| } typer.cpp:_ZN9OpenBabelL24AssignOBAromaticityModelEPNS_6OBAtomERiS2_: 385| 43.1M| { 386| | // The Open Babel aromaticity model 387| | // 388| | // Return minimum and maximum pi-electrons contributed to an aromatic system 389| | // The return value indicates a potentially aromatic atom (i.e. any patterns matched) 390| | // 391| | // The original code used SMARTS patterns organised in increasing order of 392| | // prioirity (i.e. later matches overrode earlier ones). These SMARTS patterns 393| | // are now implemented in the code below, but are included in the comments 394| | // for reference (Case 1->22). 395| | 396| 43.1M| if (!atm->IsInRing()) { ------------------ | Branch (396:9): [True: 40.6M, False: 2.47M] ------------------ 397| 40.6M| min = 0; max = 0; return false; 398| 40.6M| } 399| | 400| 2.47M| unsigned int elem = atm->GetAtomicNum(); 401| 2.47M| int chg = atm->GetFormalCharge(); 402| 2.47M| unsigned int deg = atm->GetExplicitDegree() + atm->GetImplicitHCount(); 403| 2.47M| unsigned int val = atm->GetExplicitValence() + atm->GetImplicitHCount(); 404| | 405| 2.47M| switch (elem) { ------------------ | Branch (405:13): [True: 76.3k, False: 2.40M] ------------------ 406| 110k| case OBElements::Carbon: ------------------ | Branch (406:5): [True: 110k, False: 2.36M] ------------------ 407| 110k| switch (chg) { ------------------ | Branch (407:15): [True: 233, False: 110k] ------------------ 408| 108k| case 0: ------------------ | Branch (408:7): [True: 108k, False: 1.54k] ------------------ 409| 108k| if (val == 4 && deg == 3) { ------------------ | Branch (409:13): [True: 73.3k, False: 35.4k] | Branch (409:25): [True: 68.3k, False: 4.99k] ------------------ 410| 68.3k| if (HasExocyclicDblBondToHet(atm)) { ------------------ | Branch (410:15): [True: 733, False: 67.6k] ------------------ 411| 733| min = 0; max = 0; return true; 412| 733| } 413| 67.6k| else { 414| 67.6k| min = 1; max = 1; return true; 415| 67.6k| } 416| 68.3k| } 417| 40.4k| break; 418| 40.4k| case 1: ------------------ | Branch (418:7): [True: 562, False: 109k] ------------------ 419| 562| if (val == 3) { ------------------ | Branch (419:13): [True: 481, False: 81] ------------------ 420| 481| switch (deg) { ------------------ | Branch (420:19): [True: 195, False: 286] ------------------ 421| 82| case 3: ------------------ | Branch (421:11): [True: 82, False: 399] ------------------ 422| 82| min = 0; max = 0; return true; 423| 204| case 2: ------------------ | Branch (423:11): [True: 204, False: 277] ------------------ 424| 204| min = 1; max = 1; return true; 425| 481| } 426| 481| } 427| 276| break; 428| 750| case -1: ------------------ | Branch (428:7): [True: 750, False: 109k] ------------------ 429| 750| if (val == 3) { ------------------ | Branch (429:13): [True: 501, False: 249] ------------------ 430| 501| switch (deg) { ------------------ | Branch (430:19): [True: 197, False: 304] ------------------ 431| 236| case 3: ------------------ | Branch (431:11): [True: 236, False: 265] ------------------ 432| 236| min = 2; max = 2; return true; 433| 68| case 2: ------------------ | Branch (433:11): [True: 68, False: 433] ------------------ 434| 68| min = 1; max = 1; return true; 435| 501| } 436| 501| } 437| 446| break; 438| 110k| } 439| 41.4k| break; 440| | 441| 1.58M| case OBElements::Nitrogen: // nitrogen ------------------ | Branch (441:5): [True: 1.58M, False: 888k] ------------------ 442| 1.78M| case OBElements::Phosphorus: // phosphorus ------------------ | Branch (442:5): [True: 200k, False: 2.27M] ------------------ 443| 1.78M| switch (chg) { ------------------ | Branch (443:15): [True: 297, False: 1.78M] ------------------ 444| 1.78M| case 0: ------------------ | Branch (444:7): [True: 1.78M, False: 1.91k] ------------------ 445| 1.78M| switch (val) { ------------------ | Branch (445:17): [True: 95.9k, False: 1.69M] ------------------ 446| 1.68M| case 3: ------------------ | Branch (446:9): [True: 1.68M, False: 102k] ------------------ 447| 1.68M| switch (deg) { ------------------ | Branch (447:19): [True: 577, False: 1.68M] ------------------ 448| 1.24M| case 3: ------------------ | Branch (448:11): [True: 1.24M, False: 443k] ------------------ 449| 1.24M| min = 2; max = 2; return true; 450| 442k| case 2: ------------------ | Branch (450:11): [True: 442k, False: 1.24M] ------------------ 451| 442k| min = 1; max = 1; return true; 452| 1.68M| } 453| 577| break; 454| 6.88k| case 5: ------------------ | Branch (454:9): [True: 6.88k, False: 1.78M] ------------------ 455| 6.88k| if (deg == 3) { ------------------ | Branch (455:15): [True: 4.81k, False: 2.06k] ------------------ 456| 4.81k| ExocyclicAtom exoatom = FindExocyclicAtom(atm); 457| 4.81k| switch (exoatom) { 458| 985| case EXO_OXYGEN: ------------------ | Branch (458:13): [True: 985, False: 3.83k] ------------------ 459| 985| min = 1; max = 1; return true; 460| 935| case EXO_NONOXYGEN: ------------------ | Branch (460:13): [True: 935, False: 3.88k] ------------------ 461| 935| min = 2; max = 2; return true; 462| 2.89k| default: ------------------ | Branch (462:13): [True: 2.89k, False: 1.92k] ------------------ 463| 2.89k| ; 464| 4.81k| } 465| 4.81k| } 466| 1.78M| } 467| 101k| break; 468| 101k| case 1: ------------------ | Branch (468:7): [True: 973, False: 1.78M] ------------------ 469| 973| if (val == 4 && deg == 3) { ------------------ | Branch (469:13): [True: 595, False: 378] | Branch (469:25): [True: 486, False: 109] ------------------ 470| 486| min = 1; max = 1; return true; 471| 486| } 472| 487| break; 473| 640| case -1: ------------------ | Branch (473:7): [True: 640, False: 1.78M] ------------------ 474| 640| if (val == 2 && deg == 2) { ------------------ | Branch (474:13): [True: 386, False: 254] | Branch (474:25): [True: 199, False: 187] ------------------ 475| 199| min = 2; max = 2; return true; 476| 199| } 477| 1.78M| } 478| 102k| break; 479| | 480| 141k| case OBElements::Oxygen: ------------------ | Branch (480:5): [True: 141k, False: 2.33M] ------------------ 481| 142k| case OBElements::Selenium: ------------------ | Branch (481:5): [True: 194, False: 2.47M] ------------------ 482| 142k| switch (chg) { ------------------ | Branch (482:15): [True: 231, False: 141k] ------------------ 483| 141k| case 0: ------------------ | Branch (483:7): [True: 141k, False: 460] ------------------ 484| 141k| if (val == 2 && deg == 2) { ------------------ | Branch (484:13): [True: 125k, False: 15.8k] | Branch (484:25): [True: 125k, False: 449] ------------------ 485| 125k| min = 2; max = 2; return true; 486| 125k| } 487| 16.5k| case 1: ------------------ | Branch (487:7): [True: 229, False: 141k] ------------------ 488| 16.5k| if (val == 3 && deg == 2) { ------------------ | Branch (488:13): [True: 8.94k, False: 7.61k] | Branch (488:25): [True: 1.64k, False: 7.30k] ------------------ 489| 1.64k| min = 1; max = 1; return true; 490| 1.64k| } 491| 142k| } 492| 15.1k| break; 493| | 494| 122k| case OBElements::Sulfur: ------------------ | Branch (494:5): [True: 122k, False: 2.35M] ------------------ 495| 122k| switch (chg) { ------------------ | Branch (495:15): [True: 199, False: 122k] ------------------ 496| 119k| case 0: ------------------ | Branch (496:7): [True: 119k, False: 2.96k] ------------------ 497| 119k| switch (val) { ------------------ | Branch (497:17): [True: 4.02k, False: 115k] ------------------ 498| 97.7k| case 2: ------------------ | Branch (498:9): [True: 97.7k, False: 21.6k] ------------------ 499| 97.7k| if (deg == 2) { ------------------ | Branch (499:15): [True: 96.4k, False: 1.32k] ------------------ 500| 96.4k| min = 2; max = 2; return true; 501| 96.4k| } 502| 1.32k| break; 503| 17.6k| case 4: ------------------ | Branch (503:9): [True: 17.6k, False: 101k] ------------------ 504| 17.6k| if (deg == 3 && HasExocyclicDblBondToOxygen(atm)) { ------------------ | Branch (504:15): [True: 13.3k, False: 4.23k] | Branch (504:27): [True: 378, False: 13.0k] ------------------ 505| 378| min = 2; max = 2; return true; 506| 378| } 507| 119k| } 508| 22.5k| break; 509| 22.5k| case 1: ------------------ | Branch (509:7): [True: 2.76k, False: 119k] ------------------ 510| 2.76k| if (val == 3) { ------------------ | Branch (510:13): [True: 1.93k, False: 830] ------------------ 511| 1.93k| switch (deg) { ------------------ | Branch (511:19): [True: 197, False: 1.73k] ------------------ 512| 352| case 2: ------------------ | Branch (512:11): [True: 352, False: 1.57k] ------------------ 513| 352| min = 1; max = 1; return true; 514| 1.38k| case 3: ------------------ | Branch (514:11): [True: 1.38k, False: 549] ------------------ 515| 1.38k| if (HasExocyclicBondToOxygenMinus(atm)) { ------------------ | Branch (515:17): [True: 195, False: 1.18k] ------------------ 516| 195| min = 2; max = 2; return true; 517| 195| } 518| 1.93k| } 519| 1.93k| } 520| 122k| } 521| 25.0k| break; 522| | 523| 136k| case OBElements::Boron: ------------------ | Branch (523:5): [True: 136k, False: 2.34M] ------------------ 524| 136k| if (chg == 0 && val == 3) { ------------------ | Branch (524:11): [True: 136k, False: 397] | Branch (524:23): [True: 125k, False: 10.6k] ------------------ 525| 125k| switch (deg) { ------------------ | Branch (525:17): [True: 247, False: 125k] ------------------ 526| 119k| case 2: ------------------ | Branch (526:9): [True: 119k, False: 5.77k] ------------------ 527| 119k| min = 1; max = 1; return true; 528| 5.53k| case 3: ------------------ | Branch (528:9): [True: 5.53k, False: 120k] ------------------ 529| 5.53k| min = 0; max = 0; return true; 530| 125k| } 531| 125k| } 532| 11.3k| break; 533| | 534| 11.3k| case OBElements::Arsenic: ------------------ | Branch (534:5): [True: 1.73k, False: 2.47M] ------------------ 535| 1.73k| switch (chg) { ------------------ | Branch (535:15): [True: 198, False: 1.53k] ------------------ 536| 1.04k| case 0: ------------------ | Branch (536:7): [True: 1.04k, False: 687] ------------------ 537| 1.04k| if (val == 3) { ------------------ | Branch (537:13): [True: 651, False: 394] ------------------ 538| 651| switch (deg) { ------------------ | Branch (538:19): [True: 218, False: 433] ------------------ 539| 212| case 2: ------------------ | Branch (539:11): [True: 212, False: 439] ------------------ 540| 212| min = 1; max = 1; return true; 541| 221| case 3: ------------------ | Branch (541:11): [True: 221, False: 430] ------------------ 542| 221| min = 2; max = 2; return true; 543| 651| } 544| 651| } 545| 612| break; 546| 612| case 1: ------------------ | Branch (546:7): [True: 489, False: 1.24k] ------------------ 547| 489| if (val == 4 && deg == 3) { ------------------ | Branch (547:13): [True: 261, False: 228] | Branch (547:25): [True: 194, False: 67] ------------------ 548| 194| min = 1; max = 1; return true; 549| 194| } 550| 1.73k| } 551| 1.10k| break; 552| | 553| | 554| 98.3k| case 0: // Asterisk ------------------ | Branch (554:5): [True: 98.3k, False: 2.37M] ------------------ 555| 98.3k| if (chg == 0) { ------------------ | Branch (555:11): [True: 98.1k, False: 202] ------------------ 556| 98.1k| switch (val) { ------------------ | Branch (556:17): [True: 543, False: 97.6k] ------------------ 557| 95.7k| case 2: ------------------ | Branch (557:9): [True: 95.7k, False: 2.43k] ------------------ 558| 95.7k| switch (deg) { ------------------ | Branch (558:19): [True: 163, False: 95.5k] ------------------ 559| 95.4k| case 2: ------------------ | Branch (559:11): [True: 95.4k, False: 280] ------------------ 560| 95.5k| case 3: ------------------ | Branch (560:11): [True: 117, False: 95.6k] ------------------ 561| 95.5k| min = 0; max = 2; return true; 562| 95.7k| } 563| 163| break; 564| 1.89k| case 3: ------------------ | Branch (564:9): [True: 1.89k, False: 96.2k] ------------------ 565| 1.89k| switch (deg) { ------------------ | Branch (565:19): [True: 613, False: 1.27k] ------------------ 566| 457| case 2: ------------------ | Branch (566:11): [True: 457, False: 1.43k] ------------------ 567| 1.27k| case 3: ------------------ | Branch (567:11): [True: 820, False: 1.07k] ------------------ 568| 1.27k| min = 0; max = 1; return true; 569| 1.89k| } 570| 613| break; 571| 98.1k| } 572| 98.1k| } 573| 1.52k| break; 574| 2.47M| } 575| | 576| 274k| min = 0; max = 0; // nothing matched 577| 274k| return false; 578| 2.47M| } typer.cpp:_ZN9OpenBabelL24HasExocyclicDblBondToHetEPNS_6OBAtomE: 367| 68.3k| { 368| 165k| FOR_BONDS_OF_ATOM(bond, atm) { ------------------ | | 401| 233k|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 165k, False: 67.6k] | | ------------------ ------------------ 369| 165k| if (bond->GetBondOrder() == 2 && !bond->IsInRing()) { ------------------ | Branch (369:11): [True: 68.3k, False: 97.1k] | Branch (369:40): [True: 1.98k, False: 66.3k] ------------------ 370| 1.98k| unsigned int atomicnum = bond->GetNbrAtom(atm)->GetAtomicNum(); 371| 1.98k| switch (atomicnum) { 372| 1.24k| case OBElements::Carbon: ------------------ | Branch (372:9): [True: 1.24k, False: 733] ------------------ 373| 1.24k| case OBElements::Hydrogen: ------------------ | Branch (373:9): [True: 0, False: 1.98k] ------------------ 374| 1.24k| break; 375| 733| default: ------------------ | Branch (375:9): [True: 733, False: 1.24k] ------------------ 376| 733| return true; 377| 1.98k| } 378| 1.98k| } 379| 165k| } 380| 67.6k| return false; 381| 68.3k| } typer.cpp:_ZN9OpenBabelL17FindExocyclicAtomEPNS_6OBAtomE: 329| 4.81k| { 330| 13.1k| FOR_BONDS_OF_ATOM(bond, atm) { ------------------ | | 401| 16.0k|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 13.1k, False: 2.89k] | | ------------------ ------------------ 331| 13.1k| if (bond->GetBondOrder() == 2 && !bond->IsInRing()) { ------------------ | Branch (331:11): [True: 8.59k, False: 4.54k] | Branch (331:40): [True: 1.92k, False: 6.67k] ------------------ 332| 1.92k| unsigned int atomicnum = bond->GetNbrAtom(atm)->GetAtomicNum(); 333| 1.92k| switch (atomicnum) { 334| 985| case OBElements::Oxygen: ------------------ | Branch (334:9): [True: 985, False: 935] ------------------ 335| 985| return EXO_OXYGEN; 336| 935| default: ------------------ | Branch (336:9): [True: 935, False: 985] ------------------ 337| 935| return EXO_NONOXYGEN; 338| 1.92k| } 339| 1.92k| } 340| 13.1k| } 341| 2.89k| return NO_EXOCYCLIC_ATOM; 342| 4.81k| } typer.cpp:_ZN9OpenBabelL27HasExocyclicDblBondToOxygenEPNS_6OBAtomE: 357| 13.3k| { 358| 39.0k| FOR_BONDS_OF_ATOM(bond, atm) { ------------------ | | 401| 52.0k|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 39.0k, False: 13.0k] | | ------------------ ------------------ 359| 39.0k| if (bond->GetBondOrder() == 2 && !bond->IsInRing() && ------------------ | Branch (359:11): [True: 13.3k, False: 25.6k] | Branch (359:40): [True: 5.81k, False: 7.56k] ------------------ 360| 39.0k| bond->GetNbrAtom(atm)->GetAtomicNum() == OBElements::Oxygen) ------------------ | Branch (360:11): [True: 378, False: 5.43k] ------------------ 361| 378| return true; 362| 39.0k| } 363| 13.0k| return false; 364| 13.3k| } typer.cpp:_ZN9OpenBabelL29HasExocyclicBondToOxygenMinusEPNS_6OBAtomE: 345| 1.38k| { 346| 3.70k| FOR_BONDS_OF_ATOM(bond, atm) { ------------------ | | 401| 4.89k|#define FOR_BONDS_OF_ATOM(b,p) for( OpenBabel::OBAtomBondIter b(p); b; ++b ) | | ------------------ | | | Branch (401:75): [True: 3.70k, False: 1.18k] | | ------------------ ------------------ 347| 3.70k| if (bond->GetBondOrder() == 1 && !bond->IsInRing()) { ------------------ | Branch (347:11): [True: 3.36k, False: 342] | Branch (347:40): [True: 1.08k, False: 2.27k] ------------------ 348| 1.08k| OBAtom* nbr = bond->GetNbrAtom(atm); 349| 1.08k| if (nbr->GetAtomicNum() == OBElements::Oxygen && nbr->GetFormalCharge() == -1) ------------------ | Branch (349:13): [True: 449, False: 637] | Branch (349:58): [True: 195, False: 254] ------------------ 350| 195| return true; 351| 1.08k| } 352| 3.70k| } 353| 1.18k| return false; 354| 1.38k| } _ZN9OpenBabel23OBAromaticTyperMolStateC2ERNS_5OBMolE: 584| 4.91k| { 585| 4.91k| _vpa.resize(mol.NumAtoms() + 1); 586| 4.91k| _velec.resize(mol.NumAtoms() + 1); 587| 4.91k| _root.resize(mol.NumAtoms() + 1); 588| 4.91k| _visit.resize(mol.NumAtoms() + 1); 589| 4.91k| } LLVMFuzzerTestOneInput: 15| 9.18k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 16| 9.18k| using namespace std; 17| 9.18k| using namespace OpenBabel; 18| 9.18k| OBConversion obconv; 19| 9.18k| OpenBabel::OBMol obmol; 20| 9.18k| std::string str (reinterpret_cast(Data), Size); 21| | 22| | //FUZZ_INPUT_FORMAT is defined at compile time 23| 9.18k| if(!obconv.SetInFormat(FUZZ_INPUT_FORMAT)){ ------------------ | Branch (23:8): [True: 0, False: 9.18k] ------------------ 24| 0| abort(); 25| 0| } 26| 9.18k| obconv.ReadString(&obmol, str); 27| 9.18k| return 0; 28| 9.18k|}