src/mmdb_model.h
Go to the documentation of this file.
00001 // $Id: mmdb_model.h $ 00002 // ================================================================= 00003 // 00004 // CCP4 Coordinate Library: support of coordinate-related 00005 // functionality in protein crystallography applications. 00006 // 00007 // Copyright (C) Eugene Krissinel 2000-2013. 00008 // 00009 // This library is free software: you can redistribute it and/or 00010 // modify it under the terms of the GNU Lesser General Public 00011 // License version 3, modified in accordance with the provisions 00012 // of the license to address the requirements of UK law. 00013 // 00014 // You should have received a copy of the modified GNU Lesser 00015 // General Public License along with this library. If not, copies 00016 // may be downloaded from http://www.ccp4.ac.uk/ccp4license.php 00017 // 00018 // This program is distributed in the hope that it will be useful, 00019 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00020 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00021 // GNU Lesser General Public License for more details. 00022 // 00023 // ================================================================= 00024 // 00025 // 12.09.13 <-- Date of Last Modification. 00026 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 00027 // ----------------------------------------------------------------- 00028 // 00029 // **** Module : MMDB_Model <interface> 00030 // ~~~~~~~~~ 00031 // **** Project : MacroMolecular Data Base (MMDB) 00032 // ~~~~~~~~~ 00033 // **** Classes : mmdb::HetCompound ( description of het compounds ) 00034 // ~~~~~~~~~ mmdb::HetCompounds (HETNAM, HETSYN, FORMULA records) 00035 // mmdb::SSContainer (container for helixes and turns) 00036 // mmdb::Helix ( helix info ) 00037 // mmdb::Strand ( strand info ) 00038 // mmdb::Sheet ( sheet info ) 00039 // mmdb::Sheets ( container for sheets ) 00040 // mmdb::Turn ( turn info ) 00041 // mmdb::LinkContainer ( container for link data ) 00042 // mmdb::Link ( link data ) 00043 // mmdb::LinkRContainer ( container for refmac link ) 00044 // mmdb::LinkR ( link data ) 00045 // mmdb::CisPepContainer ( container for CisPep data ) 00046 // mmdb::CisPep ( CisPep data ) 00047 // mmdb::Model ( PDB model ) 00048 // 00049 // Copyright (C) E. Krissinel 2000-2013 00050 // 00051 // ================================================================= 00052 // 00053 00054 #ifndef __MMDB_Model__ 00055 #define __MMDB_Model__ 00056 00057 #include "mmdb_io_stream.h" 00058 #include "mmdb_utils.h" 00059 #include "mmdb_chain.h" 00060 #include "mmdb_defs.h" 00061 00062 namespace mmdb { 00063 00064 // ==================== HetCompound ======================= 00065 00066 DefineClass(HetCompound); 00067 DefineStreamFunctions(HetCompound); 00068 00069 class HetCompound : public io::Stream { 00070 00071 public : 00072 00073 ResName hetID; // Het identifiers, right-justified 00074 pstr comment; 00075 int nSynonyms; 00076 psvector hetSynonym; // synonyms 00077 int compNum; // component number 00078 char wc; // '*' for water, otherwise space 00079 pstr Formula; // formulas 00080 00081 HetCompound ( cpstr HetName ); 00082 HetCompound ( io::RPStream Object ); 00083 ~HetCompound(); 00084 00085 void AddKeyWord ( cpstr W, bool Closed ); 00086 void HETNAM_PDBDump ( io::RFile f ); 00087 void HETSYN_PDBDump ( io::RFile f ); 00088 void FORMUL_PDBDump ( io::RFile f ); 00089 00090 void FormComString ( pstr & F ); 00091 void FormSynString ( pstr & F ); 00092 void FormForString ( pstr & F ); 00093 00094 void Copy ( PHetCompound hetCompound ); 00095 00096 void write ( io::RFile f ); 00097 void read ( io::RFile f ); 00098 00099 protected : 00100 00101 void InitHetCompound ( cpstr HetName ); 00102 void FreeMemory (); 00103 00104 }; 00105 00106 00107 // ==================== SSContainer ====================== 00108 00109 DefineClass(SSContainer); 00110 DefineStreamFunctions(SSContainer); 00111 00112 class SSContainer : public ClassContainer { 00113 00114 public : 00115 00116 SSContainer () : ClassContainer() {} 00117 SSContainer ( io::RPStream Object ) 00118 : ClassContainer ( Object ) {} 00119 ~SSContainer () {} 00120 00121 PContainerClass MakeContainerClass ( int ClassID ); 00122 00123 }; 00124 00125 00126 // ==================== Helix ============================ 00127 00128 DefineClass(Helix); 00129 DefineStreamFunctions(Helix); 00130 00131 class Helix : public ContainerClass { 00132 00133 public : 00134 int serNum; // serial number 00135 HelixID helixID; // helix ID 00136 ResName initResName; // name of the helix's initial residue 00137 ChainID initChainID; // chain ID for the chain containing the helix 00138 int initSeqNum; // sequence number of the initial residue 00139 InsCode initICode; // insertion code of the initial residue 00140 ResName endResName; // name of the helix's terminal residue 00141 ChainID endChainID; // chain ID for the chain containing the helix 00142 int endSeqNum; // sequence number of the terminal residue 00143 InsCode endICode; // insertion code of the terminal residue 00144 int helixClass; // helix class 00145 pstr comment; // comment about the helix 00146 int length; // length of the helix 00147 00148 Helix (); 00149 Helix ( cpstr S ); 00150 Helix ( io::RPStream Object ); 00151 ~Helix(); 00152 00153 void PDBASCIIDump ( pstr S, int N ); 00154 void MakeCIF ( mmcif::PData CIF, int N ); 00155 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00156 ERROR_CODE GetCIF ( mmcif::PData CIF, int & n ); 00157 CLASS_ID GetClassID () { return ClassID_Helix; } 00158 00159 void Copy ( PContainerClass Helix ); 00160 00161 void write ( io::RFile f ); 00162 void read ( io::RFile f ); 00163 00164 protected : 00165 00166 void InitHelix(); 00167 00168 }; 00169 00170 00171 00172 // ==================== Strand ============================ 00173 00174 DefineClass(Strand); 00175 DefineStreamFunctions(Strand); 00176 00177 class Strand : public io::Stream { 00178 00179 public : 00180 00181 StrandID sheetID; // sheet ID 00182 int strandNo; // strand number 00183 ResName initResName; // name of the strand's initial residue 00184 ChainID initChainID; // chain ID of initial residue in the strand 00185 int initSeqNum; // sequence number of the initial residue 00186 InsCode initICode; // insertion code of the initial residue 00187 ResName endResName; // name of the strand's terminal residue 00188 ChainID endChainID; // chain ID of terminal residue in the strand 00189 int endSeqNum; // sequence number of the terminal residue 00190 InsCode endICode; // insertion code of the terminal residue 00191 int sense; // sense of strand with respect to previous 00192 // strand 00193 AtomName curAtom; // registration; atom name in current strand 00194 ResName curResName; // registration; residue name in current 00195 // strand 00196 ChainID curChainID; // registration; chain ID in current strand 00197 int curResSeq; // registration; res-e seq numb in current 00198 // strand 00199 InsCode curICode; // registration; ins code in current strand 00200 AtomName prevAtom; // registration; atom name in previous strand 00201 ResName prevResName; // registration; residue name in previous 00202 // strand 00203 ChainID prevChainID; // registration; chain ID in previous strand 00204 int prevResSeq; // registration; res-e seq numb in previous 00205 // strand 00206 InsCode prevICode; // registration; ins code in previous strand 00207 00208 Strand (); 00209 Strand ( io::RPStream Object ); 00210 ~Strand(); 00211 00212 void PDBASCIIDump ( pstr S ); 00213 void MakeCIF ( mmcif::PData CIF ); 00214 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00215 int GetCIF ( mmcif::PData CIF, cpstr sheet_id ); 00216 00217 void Copy ( PStrand Strand ); 00218 00219 void write ( io::RFile f ); 00220 void read ( io::RFile f ); 00221 00222 protected : 00223 00224 void InitStrand(); 00225 00226 }; 00227 00228 00229 // ==================== Sheet ============================ 00230 00231 DefineClass(Sheet); 00232 DefineStreamFunctions(Sheet); 00233 00234 class Sheet : public io::Stream { 00235 00236 public : 00237 SheetID sheetID; // sheet ID 00238 int nStrands; // number of strands in the sheet 00239 PPStrand strand; // array of strands 00240 00241 Sheet (); 00242 Sheet ( io::RPStream Object ); 00243 ~Sheet(); 00244 00245 void FreeMemory(); 00246 void OrderSheet(); 00247 00248 void PDBASCIIDump ( io::RFile f ); 00249 void MakeCIF ( mmcif::PData CIF ); 00250 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00251 int GetCIF ( mmcif::PData CIF ); 00252 00253 void Copy ( PSheet sheet ); 00254 00255 void write ( io::RFile f ); 00256 void read ( io::RFile f ); 00257 00258 protected : 00259 void InitSheet (); 00260 void CIFFindStrands ( mmcif::PData CIF, cpstr Category ); 00261 void TryStrand ( int strand_no ); 00262 int GetStrand ( int strand_no ); 00263 00264 }; 00265 00266 00267 // ==================== Sheets ============================ 00268 00269 DefineClass(Sheets); 00270 DefineStreamFunctions(Sheets); 00271 00272 class Sheets : public io::Stream { 00273 00274 public : 00275 int nSheets; 00276 PPSheet sheet; 00277 00278 Sheets (); 00279 Sheets ( io::RPStream Object ); 00280 ~Sheets(); 00281 00282 void FreeMemory(); 00283 00284 void PDBASCIIDump ( io::RFile f ); 00285 void MakeCIF ( mmcif::PData CIF ); 00286 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00287 int GetCIF ( mmcif::PData CIF ); 00288 00289 void Copy ( PSheets Sheets ); 00290 00291 void write ( io::RFile f ); 00292 void read ( io::RFile f ); 00293 00294 protected : 00295 void InitSheets (); 00296 void CIFFindSheets ( mmcif::PData CIF, cpstr Category ); 00297 00298 }; 00299 00300 00301 // ==================== Turn ============================ 00302 00303 DefineClass(Turn); 00304 DefineStreamFunctions(Turn); 00305 00306 class Turn : public ContainerClass { 00307 00308 public : 00309 int serNum; // serial number 00310 TurnID turnID; // turn ID 00311 ResName initResName; // name of the turn's initial residue 00312 ChainID initChainID; // chain ID for the chain containing the turn 00313 int initSeqNum; // sequence number of the initial residue 00314 InsCode initICode; // insertion code of the initial residue 00315 ResName endResName; // name of the turn's terminal residue 00316 ChainID endChainID; // chain ID for the chain containing the turn 00317 int endSeqNum; // sequence number of the terminal residue 00318 InsCode endICode; // insertion code of the terminal residue 00319 pstr comment; // comment about the helix 00320 00321 Turn (); 00322 Turn ( cpstr S ); 00323 Turn ( io::RPStream Object ); 00324 ~Turn(); 00325 00326 void PDBASCIIDump ( pstr S, int N ); 00327 void MakeCIF ( mmcif::PData CIF, int N ); 00328 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00329 ERROR_CODE GetCIF ( mmcif::PData CIF, int & n ); 00330 CLASS_ID GetClassID () { return ClassID_Turn; } 00331 00332 void Copy ( PContainerClass turn ); 00333 00334 void write ( io::RFile f ); 00335 void read ( io::RFile f ); 00336 00337 protected : 00338 00339 void InitTurn(); 00340 00341 }; 00342 00343 00344 00345 // ==================== HetCompounds ======================= 00346 00347 DefineClass(HetCompounds); 00348 DefineStreamFunctions(HetCompounds); 00349 00350 class HetCompounds : public io::Stream { 00351 00352 public : 00353 00354 int nHets; 00355 PPHetCompound hetCompound; 00356 00357 HetCompounds (); 00358 HetCompounds ( io::RPStream Object ); 00359 ~HetCompounds(); 00360 00361 void FreeMemory (); 00362 00363 void PDBASCIIDump ( io::RFile f ); 00364 void ConvertHETNAM ( cpstr S ); 00365 void ConvertHETSYN ( cpstr S ); 00366 void ConvertFORMUL ( cpstr S ); 00367 00368 void MakeCIF ( mmcif::PData CIF ); 00369 ERROR_CODE GetCIF ( mmcif::PData CIF ); 00370 00371 void Copy ( PHetCompounds hetCompounds ); 00372 00373 void write ( io::RFile f ); 00374 void read ( io::RFile f ); 00375 00376 protected : 00377 bool Closed; 00378 00379 void InitHetCompounds(); 00380 int AddHetName ( cpstr H ); 00381 00382 }; 00383 00384 00385 // =================== LinkContainer ===================== 00386 00387 DefineClass(LinkContainer); 00388 DefineStreamFunctions(LinkContainer); 00389 00390 class LinkContainer : public ClassContainer { 00391 00392 public : 00393 00394 LinkContainer () : ClassContainer() {} 00395 LinkContainer ( io::RPStream Object ) 00396 : ClassContainer ( Object ) {} 00397 ~LinkContainer () {} 00398 00399 PContainerClass MakeContainerClass ( int ClassID ); 00400 00401 }; 00402 00403 00404 // ==================== Link ============================ 00405 00406 DefineClass(Link); 00407 DefineStreamFunctions(Link); 00408 00409 class Link : public ContainerClass { 00410 00411 public : 00412 AtomName atName1; // name of 1st linked atom 00413 AltLoc aloc1; // alternative location of 1st linked atom 00414 ResName resName1; // residue name of 1st linked atom 00415 ChainID chainID1; // chain ID of 1st linked atom 00416 int seqNum1; // sequence number of 1st linked atom 00417 InsCode insCode1; // insertion code of 1st linked atom 00418 AtomName atName2; // name of 2nd linked atom 00419 AltLoc aloc2; // alternative location of 2nd linked atom 00420 ResName resName2; // residue name of 2nd linked atom 00421 ChainID chainID2; // chain ID of 2nd linked atom 00422 int seqNum2; // sequence number of 2nd linked atom 00423 InsCode insCode2; // insertion code of 2nd linked atom 00424 int s1,i1,j1,k1; // sym id of 1st atom 00425 int s2,i2,j2,k2; // sym id of 2nd atom 00426 00427 Link (); 00428 Link ( cpstr S ); 00429 Link ( io::RPStream Object ); 00430 ~Link(); 00431 00432 void PDBASCIIDump ( pstr S, int N ); 00433 void MakeCIF ( mmcif::PData CIF, int N ); 00434 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00435 ERROR_CODE GetCIF ( mmcif::PData CIF, int & n ); 00436 CLASS_ID GetClassID () { return ClassID_Link; } 00437 00438 void Copy ( PContainerClass link ); 00439 00440 void write ( io::RFile f ); 00441 void read ( io::RFile f ); 00442 00443 protected : 00444 00445 void InitLink(); 00446 00447 }; 00448 00449 // =================== LinkRContainer ==================== 00450 00451 DefineClass(LinkRContainer); 00452 DefineStreamFunctions(LinkRContainer); 00453 00454 class LinkRContainer : public ClassContainer { 00455 00456 public : 00457 00458 LinkRContainer () : ClassContainer() {} 00459 LinkRContainer ( io::RPStream Object ) 00460 : ClassContainer ( Object ) {} 00461 ~LinkRContainer () {} 00462 00463 PContainerClass MakeContainerClass ( int ClassID ); 00464 00465 }; 00466 00467 00468 // ==================== LinkR ============================ 00469 00470 DefineClass(LinkR); 00471 DefineStreamFunctions(LinkR); 00472 00473 /* 00474 00475 Garib's 00476 LINK LYS A 27 PLP A 255 PLPLYS 00477 LINK MAN S 3 MAN S 4 BETA1-4 00478 LINK C6 BBEN B 1 O1 BMAF S 2 BEN-MAF 00479 LINK OE2 AGLU A 320 C1 AMAF S 2 GLU-MAF 00480 LINK OE2 GLU A 67 1.895 ZN ZN R 5 GLU-ZN 00481 LINK NE2 HIS A 71 2.055 ZN ZN R 5 HIS-ZN 00482 LINK O ARG A 69 2.240 NA NA R 9 ARG-NA 00483 00484 Coot's 00485 LINKR O VAL C 103 NA NA C 401 VAL-NA 00486 LINKR OD1 ASP D 58 NA NA D 401 ASP-NA 00487 LINKR O ALA D 97 NA NA D 401 ALA-NA 00488 LINKR OG1 THR D 99 NA NA D 401 THR-NA 00489 LINKR O SER D 101 NA NA D 401 SER-NA 00490 LINKR O VAL D 103 NA NA D 401 VAL-NA 00491 00492 PDB's 00493 LINK O GLY A 49 NA NA A6001 1555 1555 2.98 00494 LINK OG1 THR A 51 NA NA A6001 1555 1555 2.72 00495 LINK OD2 ASP A 66 NA NA A6001 1555 1555 2.72 00496 LINK NE ARG A 68 NA NA A6001 1555 1555 2.93 00497 00498 LINK NE ARG A 68 NA NA A6001 1555 1555 2.93 00499 LINK C21 2EG A 7 C22 2EG B 19 1555 1555 1.56 00500 */ 00501 00502 class LinkR : public ContainerClass { 00503 00504 public : 00505 LinkRID linkRID; // link name 00506 AtomName atName1; // name of 1st linked atom 00507 AltLoc aloc1; // alternative location of 1st linked atom 00508 ResName resName1; // residue name of 1st linked atom 00509 ChainID chainID1; // chain ID of 1st linked atom 00510 int seqNum1; // sequence number of 1st linked atom 00511 InsCode insCode1; // insertion code of 1st linked atom 00512 AtomName atName2; // name of 2nd linked atom 00513 AltLoc aloc2; // alternative location of 2nd linked atom 00514 ResName resName2; // residue name of 2nd linked atom 00515 ChainID chainID2; // chain ID of 2nd linked atom 00516 int seqNum2; // sequence number of 2nd linked atom 00517 InsCode insCode2; // insertion code of 2nd linked atom 00518 realtype dist; // link distance 00519 00520 LinkR (); 00521 LinkR ( cpstr S ); 00522 LinkR ( io::RPStream Object ); 00523 ~LinkR(); 00524 00525 void PDBASCIIDump ( pstr S, int N ); 00526 void MakeCIF ( mmcif::PData CIF, int N ); 00527 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00528 ERROR_CODE GetCIF ( mmcif::PData CIF, int & n ); 00529 CLASS_ID GetClassID () { return ClassID_LinkR; } 00530 00531 void Copy ( PContainerClass LinkR ); 00532 00533 void write ( io::RFile f ); 00534 void read ( io::RFile f ); 00535 00536 protected : 00537 00538 void InitLinkR(); 00539 00540 }; 00541 00542 00543 00544 // =================== CisPepContainer ===================== 00545 00546 DefineClass(CisPepContainer); 00547 DefineStreamFunctions(CisPepContainer); 00548 00549 class CisPepContainer : public ClassContainer { 00550 00551 public : 00552 00553 CisPepContainer () : ClassContainer() {} 00554 CisPepContainer ( io::RPStream Object ) 00555 : ClassContainer ( Object ) {} 00556 ~CisPepContainer () {} 00557 00558 PContainerClass MakeContainerClass ( int ClassID ); 00559 00560 }; 00561 00562 00563 // ===================== CisPep =========================== 00564 00565 DefineClass(CisPep); 00566 DefineStreamFunctions(CisPep); 00567 00568 class CisPep : public ContainerClass { 00569 00570 public : 00571 int serNum; // record serial number 00572 ResName pep1; // residue name 00573 ChainID chainID1; // chain identifier 1 00574 int seqNum1; // residue sequence number 1 00575 InsCode icode1; // insertion code 1 00576 ResName pep2; // residue name 2 00577 ChainID chainID2; // chain identifier 2 00578 int seqNum2; // residue sequence number 2 00579 InsCode icode2; // insertion code 2 00580 int modNum; // model number 00581 realtype measure; // measure of the angle in degrees. 00582 00583 CisPep (); 00584 CisPep ( cpstr S ); 00585 CisPep ( io::RPStream Object ); 00586 ~CisPep(); 00587 00588 void PDBASCIIDump ( pstr S, int N ); 00589 ERROR_CODE ConvertPDBASCII ( cpstr S ); 00590 CLASS_ID GetClassID () { return ClassID_CisPep; } 00591 00592 void Copy ( PContainerClass cisPep ); 00593 00594 void write ( io::RFile f ); 00595 void read ( io::RFile f ); 00596 00597 protected : 00598 00599 void InitCisPep(); 00600 00601 }; 00602 00603 00604 00605 // ==================== Model =============================== 00606 00607 enum SSE_RC { 00608 SSERC_Ok = 0, 00609 SSERC_noResidues = 1, 00610 SSERC_noAminoacids = 2, 00611 SSERC_noSSE = 3 00612 }; 00613 00614 enum SORT_CHAIN_DIR { 00615 SORT_CHAIN_ChainID_Asc = 0, 00616 SORT_CHAIN_ChainID_Desc = 1 00617 }; 00618 00619 DefineFactoryFunctions(Model); 00620 00621 class Model : public ProModel { 00622 00623 friend class Manager; 00624 friend class BondManager; 00625 friend class SelManager; 00626 friend class CoorManager; 00627 friend class Root; 00628 friend class Chain; 00629 friend class Residue; 00630 friend class Atom; 00631 00632 public : 00633 00634 Model (); // SetMMDBFile() MUST be used after this constructor! 00635 Model ( PManager MMDBF, int serialNum ); 00636 Model ( io::RPStream Object ); 00637 ~Model(); 00638 00639 void SetMMDBManager ( PManager MMDBM, int serialNum ); 00640 PManager GetCoordHierarchy() { return manager; } 00641 00642 // GetChainCreate() returns pointer on chain, whose identifier 00643 // is given in chID. If such a chain is absent in the model, 00644 // it is created. If enforceUniqueChainID is true and chain with 00645 // the same first letter in chain ID already exists in the model, 00646 // then the new chain ID will be appended with a serial number 00647 // in order to keep it unique. The model will contain chains like 00648 // A, A0, A1, A2, ... in such cases. 00649 PChain GetChainCreate ( const ChainID chID, 00650 bool enforceUniqueChainID ); 00651 00652 // CreateChain() creates a new chain with chain ID regardless 00653 // the presence of same-ID chains in the model. This function 00654 // was introduced only for compatibility with older CCP4 00655 // applications and using it in any new developments should be 00656 // strictly discouraged. 00657 PChain CreateChain ( const ChainID chID ); 00658 00659 cpstr GetEntryID (); 00660 void SetEntryID ( const IDCode idCode ); 00661 00662 int GetSerNum (); // returns the model's serial number 00663 00664 cpstr GetModelID ( pstr modelID ); // returns "/mdl" 00665 00666 int GetNumberOfModels (); // returns TOTAL number of models 00667 int GetNumberOfAtoms ( bool countTers ); // returns number 00668 // of atoms in the model 00669 int GetNumberOfResidues(); // returns number of residues in 00670 // the model 00671 00672 00673 // ---------------- Extracting chains -------------------------- 00674 00675 int GetNumberOfChains(); // returns number of chains in the model 00676 bool GetNewChainID ( ChainID chID, int length=1 ); 00677 // GetChain() returns pointer on chain, whose identifier 00678 // is given in chID. If such a chain is absent in the model, 00679 // returns NULL. 00680 PChain GetChain ( const ChainID chID ); 00681 PChain GetChain ( int chainNo ); // returns chainNo-th chain 00682 // in the model; 00683 // 0<=chainNo<nChains 00684 void GetChainTable ( PPChain & chainTable, 00685 int & NumberOfChains ); 00686 00687 // ------------------ Deleting chains -------------------------- 00688 00689 int DeleteChain ( const ChainID chID ); 00690 int DeleteChain ( int chainNo ); 00691 int DeleteAllChains (); 00692 int DeleteSolventChains(); 00693 void TrimChainTable (); 00694 00695 // ------------------- Adding chains --------------------------- 00696 00697 int AddChain ( PChain chn ); 00698 00699 // -------------------- Sort chains ---------------------------- 00700 00701 void SortChains ( int sortKey ); // SORT_CHAIN_XXXX 00702 00703 // ---------------- Extracting residues ------------------------ 00704 00705 int GetNumberOfResidues ( const ChainID chainID ); 00706 int GetNumberOfResidues ( int chainNo ); 00707 PResidue GetResidue ( const ChainID chainID, int seqNo, 00708 const InsCode insCode ); 00709 PResidue GetResidue ( const ChainID chainID, int resNo ); 00710 PResidue GetResidue ( int chainNo, int seqNo, 00711 const InsCode insCode ); 00712 PResidue GetResidue ( int chainNo, int resNo ); 00713 int GetResidueNo ( const ChainID chainID, int seqNo, 00714 const InsCode insCode ); 00715 int GetResidueNo ( int chainNo, int seqNo, 00716 const InsCode insCode ); 00717 void GetResidueTable ( PPResidue & resTable, 00718 int & NumberOfResidues ); 00719 void GetResidueTable ( const ChainID chainID, 00720 PPResidue & resTable, 00721 int & NumberOfResidues ); 00722 void GetResidueTable ( int chainNo, PPResidue & resTable, 00723 int & NumberOfResidues ); 00724 00725 // ----------------- Deleting residues ------------------------- 00726 00727 int DeleteResidue ( const ChainID chainID, int seqNo, 00728 const InsCode insCode ); 00729 int DeleteResidue ( const ChainID chainID, int resNo ); 00730 int DeleteResidue ( int chainNo, int seqNo, 00731 const InsCode insCode ); 00732 int DeleteResidue ( int chainNo, int resNo ); 00733 int DeleteAllResidues ( const ChainID chainID ); 00734 int DeleteAllResidues ( int chainNo ); 00735 int DeleteSolvent (); // in difference of DeleteSolventChains, 00736 // this will remove all solvent molecules 00737 // from the file rather then 00738 // solely-solvent chains 00739 int DeleteAllResidues (); 00740 00741 // ------------------ Adding residues -------------------------- 00742 00743 int AddResidue ( const ChainID chainID, PResidue res ); 00744 int AddResidue ( int chainNo, PResidue res ); 00745 00746 // ------------------- Extracting atoms ------------------------ 00747 00748 int GetNumberOfAllAtoms(); // returns TOTAL number of atoms in all 00749 // models 00750 PPAtom GetAllAtoms (); // returns pointer to Atom array 00751 00752 int GetNumberOfAtoms ( const ChainID chainID, int seqNo, 00753 const InsCode insCode ); 00754 int GetNumberOfAtoms ( int chainNo, int seqNo, 00755 const InsCode insCode ); 00756 int GetNumberOfAtoms ( const ChainID chainID, int resNo ); 00757 int GetNumberOfAtoms ( int chainNo, int resNo ); 00758 00759 PAtom GetAtom ( const ChainID chID, 00760 int seqNo, 00761 const InsCode insCode, 00762 const AtomName aname, 00763 const Element elmnt, 00764 const AltLoc aloc ); 00765 PAtom GetAtom ( const ChainID chID, int seqNo, 00766 const InsCode insCode, int atomNo ); 00767 PAtom GetAtom ( const ChainID chID, 00768 int resNo, 00769 const AtomName aname, 00770 const Element elmnt, 00771 const AltLoc aloc ); 00772 PAtom GetAtom ( const ChainID chID, int resNo, int atomNo ); 00773 PAtom GetAtom ( int chNo, int seqNo, 00774 const InsCode insCode, 00775 const AtomName aname, 00776 const Element elmnt, 00777 const AltLoc aloc ); 00778 PAtom GetAtom ( int chNo, int seqNo, const InsCode insCode, 00779 int atomNo ); 00780 PAtom GetAtom ( int chNo, int resNo, 00781 const AtomName aname, 00782 const Element elmnt, 00783 const AltLoc aloc ); 00784 PAtom GetAtom ( int chNo, int resNo, int atomNo ); 00785 00786 void GetAtomTable ( const ChainID chainID, int seqNo, 00787 const InsCode insCode, 00788 PPAtom & atomTable, int & NumberOfAtoms ); 00789 void GetAtomTable ( int chainNo, int seqNo, 00790 const InsCode insCode, 00791 PPAtom & atomTable, int & NumberOfAtoms ); 00792 void GetAtomTable ( const ChainID chainID, int resNo, 00793 PPAtom & atomTable, int & NumberOfAtoms ); 00794 void GetAtomTable ( int chainNo, int resNo, 00795 PPAtom & atomTable, int & NumberOfAtoms ); 00796 00797 // GetAtomTable1(..) returns atom table without TER atoms and 00798 // without NULL atom pointers. NumberOfAtoms returns the actual 00799 // number of atom pointers in atomTable. 00800 // atomTable is allocated withing the function. If it was 00801 // not set to NULL before calling the function, the latter will 00802 // attempt to deallocate it first. 00803 // The application is responsible for deleting atomTable, 00804 // however it must not touch atom pointers, i.e. use simply 00805 // "delete atomTable;". Never pass atomTable from GetAtomTable(..) 00806 // into this function, unless you set it to NULL before doing that. 00807 void GetAtomTable1 ( const ChainID chainID, int seqNo, 00808 const InsCode insCode, 00809 PPAtom & atomTable, int & NumberOfAtoms ); 00810 void GetAtomTable1 ( int chainNo, int seqNo, 00811 const InsCode insCode, 00812 PPAtom & atomTable, int & NumberOfAtoms ); 00813 void GetAtomTable1 ( const ChainID chainID, int resNo, 00814 PPAtom & atomTable, int & NumberOfAtoms ); 00815 void GetAtomTable1 ( int chainNo, int resNo, 00816 PPAtom & atomTable, int & NumberOfAtoms ); 00817 00818 void GetAtomStatistics ( RAtomStat AS ); 00819 void CalAtomStatistics ( RAtomStat AS ); 00820 00821 00822 // -------------------- Deleting atoms ------------------------- 00823 00824 int DeleteAtom ( const ChainID chID, 00825 int seqNo, 00826 const InsCode insCode, 00827 const AtomName aname, 00828 const Element elmnt, 00829 const AltLoc aloc ); 00830 int DeleteAtom ( const ChainID chID, int seqNo, 00831 const InsCode insCode, int atomNo ); 00832 int DeleteAtom ( const ChainID chID, 00833 int resNo, 00834 const AtomName aname, 00835 const Element elmnt, 00836 const AltLoc aloc ); 00837 int DeleteAtom ( const ChainID chID, int resNo, int atomNo ); 00838 int DeleteAtom ( int chNo, int seqNo, 00839 const InsCode insCode, 00840 const AtomName aname, 00841 const Element elmnt, 00842 const AltLoc aloc ); 00843 int DeleteAtom ( int chNo, int seqNo, const InsCode insCode, 00844 int atomNo ); 00845 int DeleteAtom ( int chNo, int resNo, 00846 const AtomName aname, 00847 const Element elmnt, 00848 const AltLoc aloc ); 00849 int DeleteAtom ( int chNo, int resNo, int atomNo ); 00850 00851 int DeleteAllAtoms ( const ChainID chID, int seqNo, 00852 const InsCode insCode ); 00853 int DeleteAllAtoms ( const ChainID chID, int resNo ); 00854 int DeleteAllAtoms ( const ChainID chID ); 00855 int DeleteAllAtoms ( int chNo, int seqNo, const InsCode insCode ); 00856 int DeleteAllAtoms ( int chNo, int resNo ); 00857 int DeleteAllAtoms ( int chNo ); 00858 int DeleteAllAtoms (); 00859 00860 // DeleteAltLocs() leaves only alternative location with maximal 00861 // occupancy, if those are equal or unspecified, the one with 00862 // "least" alternative location indicator. 00863 // The function returns the number of deleted. All tables remain 00864 // untrimmed, so that explicit trimming or calling 00865 // FinishStructEdit() is required. 00866 int DeleteAltLocs(); 00867 00868 00869 // --------------------- Adding atoms -------------------------- 00870 00871 int AddAtom ( const ChainID chID, int seqNo, 00872 const InsCode insCode, PAtom atom ); 00873 int AddAtom ( const ChainID chID, int resNo, PAtom atom ); 00874 int AddAtom ( int chNo, int seqNo, const InsCode insCode, 00875 PAtom atom ); 00876 int AddAtom ( int chNo, int resNo, PAtom atom ); 00877 00878 00879 // --------------------------------------------------------------- 00880 00881 // ConvertPDBString(..) interprets PDB records DBREF, SEQADV, 00882 // SEQRES, MODRES. 00883 // Returns zero if the line was converted, otherwise returns a 00884 // non-negative value of Error_XXXX. 00885 // PDBString must be not shorter than 81 characters. 00886 ERROR_CODE ConvertPDBString ( pstr PDBString ); 00887 00888 // PDBASCIIDumpPS(..) makes output of PDB primary structure records 00889 // excluding cispeps 00890 void PDBASCIIDumpPS ( io::RFile f ); 00891 00892 // PDBASCIIDumpCP(..) makes output of cispep records 00893 void PDBASCIIDumpCP ( io::RFile f ); 00894 00895 // PDBASCIIDump(..) makes output of PDB coordinate (ATOM etc.) 00896 // records 00897 void PDBASCIIDump ( io::RFile f ); 00898 00899 void MakeAtomCIF ( mmcif::PData CIF ); 00900 void MakePSCIF ( mmcif::PData CIF ); 00901 ERROR_CODE GetCIF ( mmcif::PData CIF ); 00902 00903 // MoveChain(..) adds chain m_chain on the top Chain array. 00904 // The pointer on chain is then set to NULL (m_chain=NULL). 00905 // If chain_ext is greater than 0, the moved chain will be 00906 // forcefully renamed; the new name is composed as the previous 00907 // one + underscore + chain_ext (e.g. A_1). If thus generated 00908 // name duplicates any of existing chain IDs, or if chain_ext 00909 // was set to 0 and there is a duplication of chain IDs, the 00910 // name is again modified as above, with the extension number 00911 // generated automatically (this may result in IDs like 00912 // A_1_10). 00913 // m_atom must give pointer to the Atom array, from which 00914 // the atoms belonging to m_chain, are moved to Atom array 00915 // given by 'atom', starting from poisition 'atom_index'. 00916 // 'atom_index' is then automatically updated to the next 00917 // free position in 'atom'. 00918 // Note1: the moved atoms will occupy a continuous range 00919 // in 'atom' array; no checks on whether the corresponding 00920 // cells are occupied or not, are performed. 00921 // Note2: the 'atom_index' is numbered from 0 on, i.e. 00922 // it is equal to atom[atom_index]->index-1; atom[]->index 00923 // is assigned automatically. 00924 void MoveChain ( PChain & m_chain, PPAtom m_atom, 00925 PPAtom atom, int & atom_index, 00926 int chain_ext ); 00927 00928 void GetAIndexRange ( int & i1, int & i2 ); 00929 00930 void MaskAtoms ( PMask mask ); 00931 void MaskResidues ( PMask mask ); 00932 void MaskChains ( PMask mask ); 00933 void UnmaskAtoms ( PMask mask ); 00934 void UnmaskResidues ( PMask mask ); 00935 void UnmaskChains ( PMask mask ); 00936 00937 00938 // ---- Getting Secondary Structure Elements 00939 00940 int GetNumberOfHelices (); 00941 int GetNumberOfSheets (); 00942 00943 PHelix GetHelix ( int serialNum ); // 1<=serNum<=NofHelices 00944 00945 void GetSheetID ( int serialNum, SheetID sheetID ); 00946 // '\0' for none 00947 00948 PSheet GetSheet ( int serialNum ); //1<=serNum<=NofSheets 00949 PSheet GetSheet ( const SheetID sheetID ); // NULL for none 00950 int GetNumberOfStrands ( int sheetSerNum ); 00951 int GetNumberOfStrands ( const SheetID sheetID ); 00952 PStrand GetStrand ( int sheetSerNum, 00953 int strandSerNum ); 00954 PStrand GetStrand ( const SheetID sheetID, 00955 int strandSerNum ); 00956 00957 inline PSSContainer GetHelices() { return &helices; } 00958 inline PSheets GetSheets () { return &sheets; } 00959 00960 void RemoveSecStructure(); 00961 int CalcSecStructure ( bool flagBulge=true, 00962 int aminoSelHnd=-1 ); 00963 // int CalcSecStructure ( bool flagBulge=true ); 00964 00965 PHetCompounds GetHetInfo() { return &hetCompounds; } 00966 void RemoveHetInfo (); 00967 00968 00969 // ---- Working Links 00970 00971 int GetNumberOfLinks (); 00972 PLink GetLink ( int serialNum ); // 1<=serNum<=NofLinks 00973 PLinkContainer GetLinks() { return &links; } 00974 00975 void RemoveLinks(); 00976 void AddLink ( PLink link ); 00977 00978 // ---- Working Refmac Links 00979 00980 int GetNumberOfLinkRs (); 00981 PLinkR GetLinkR ( int serialNum ); // 1<=serNum<=NofLinks 00982 PLinkRContainer GetLinkRs() { return &linkRs; } 00983 00984 void RemoveLinkRs(); 00985 void AddLinkR ( PLinkR linkR ); 00986 00987 00988 // ---- Working CisPeps 00989 00990 int GetNumberOfCisPeps(); 00991 PCisPep GetCisPep ( int CisPepNum ); 00992 PCisPepContainer GetCisPeps() { return &cisPeps; } 00993 00994 void RemoveCisPeps(); 00995 void AddCisPep ( PCisPep cisPep ); 00996 00997 00998 00999 void ApplyTransform ( mat44 & TMatrix ); // transforms all 01000 // coordinates by multiplying 01001 // with matrix TMatrix 01002 01003 bool isInSelection ( int selHnd ); 01004 01005 01006 // ------- user-defined data handlers 01007 int PutUDData ( int UDDhandle, int iudd ); 01008 int PutUDData ( int UDDhandle, realtype rudd ); 01009 int PutUDData ( int UDDhandle, cpstr sudd ); 01010 01011 int GetUDData ( int UDDhandle, int & iudd ); 01012 int GetUDData ( int UDDhandle, realtype & rudd ); 01013 int GetUDData ( int UDDhandle, pstr sudd, int maxLen ); 01014 int GetUDData ( int UDDhandle, pstr & sudd ); 01015 01016 01017 void Copy ( PModel model ); 01018 void CopyHets ( PModel model ); 01019 void CopySecStructure ( PModel model ); 01020 void CopyLinks ( PModel model ); 01021 void CopyLinkRs ( PModel model ); 01022 void CopyCisPeps ( PModel model ); 01023 01024 void write ( io::RFile f ); 01025 void read ( io::RFile f ); 01026 01027 protected : 01028 01029 int serNum; // the model serial number 01030 PManager manager; // pointer to mmdbmanager class 01031 01032 HetCompounds hetCompounds; // information on heterocompounds 01033 SSContainer helices; // information on helices 01034 Sheets sheets; // information on sheets 01035 SSContainer turns; // information on turns 01036 LinkContainer links; // information on links 01037 LinkRContainer linkRs; // information on refmac links 01038 CisPepContainer cisPeps; // information on cispeps 01039 01040 int nChains; // number of chains 01041 int nChainsAlloc; // actual length of Chain[] 01042 PPChain chain; // array of chains 01043 01044 bool Exclude; // used internally 01045 01046 void InitModel (); 01047 void FreeMemory (); 01048 void ExpandChainArray ( int nOfChains ); 01049 ERROR_CODE GetCIFPSClass ( mmcif::PData CIF, int ClassID ); 01050 01051 // _ExcludeChain(..) excludes (but does not dispose!) a chain 01052 // from the model. Returns 1 if the chain gets empty and 0 01053 // otherwise. 01054 int _ExcludeChain ( const ChainID chainID ); 01055 01056 // _copy(PModel) does not copy atoms! -- not for use in 01057 // applications 01058 void _copy ( PModel Model ); 01059 01060 // _copy(PModel,PPAtom,int&) does copy atoms into array 'atom' 01061 // starting from position atom_index. 'atom' should be able to 01062 // accept all new atoms - no checks on the length of 'atom' 01063 // is being made. This function should not be used in applications. 01064 void _copy ( PModel Model, PPAtom atom, int & atom_index ); 01065 01066 void CheckInAtoms (); 01067 01068 }; 01069 01070 } // namespace mmdb 01071 01072 #endif 01073
