src/mmdb_coormngr.h
Go to the documentation of this file.
00001 // $Id: mmdb_coormngr.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 // 14.07.13 <-- Date of Last Modification. 00026 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 00027 // ----------------------------------------------------------------- 00028 // 00029 // **** Module : mmdb_coormngr <interface> 00030 // ~~~~~~~~~ 00031 // Project : MacroMolecular Data Base (MMDB) 00032 // ~~~~~~~~~ 00033 // **** Classes : mmdb::Brick ( space brick ) 00034 // ~~~~~~~~~ mmdb::CoorManager ( MMDB atom coordinate manager ) 00035 // 00036 // (C) E. Krissinel 2000-2013 00037 // 00038 // ================================================================= 00039 // 00040 00041 #ifndef __MMDB_CoorMngr__ 00042 #define __MMDB_CoorMngr__ 00043 00044 #include "mmdb_root.h" 00045 00046 namespace mmdb { 00047 00048 // =========================== Brick ============================== 00049 00050 // bricking control 00051 enum BRICK_STATE { 00052 BRICK_ON_1 = 0x00000001, 00053 BRICK_ON_2 = 0x00000002, 00054 BRICK_READY = 0x00000004 00055 }; 00056 00057 DefineClass(Brick); 00058 typedef PPBrick * PPPBrick; 00059 00060 class Brick { 00061 00062 public : 00063 int nAtoms; // number of atoms hit into brick 00064 PPAtom atom; // pointers to atoms 00065 ivector id; // atom ids (in present realization, these are 00066 // indices of atoms from the bricked array) 00067 00068 Brick (); 00069 ~Brick(); 00070 00071 void Clear (); 00072 void AddAtom ( PAtom A, int atomid ); 00073 00074 protected : 00075 int nAllocAtoms; 00076 void InitBrick(); 00077 00078 }; 00079 00080 00081 // =========================== MBrick ============================= 00082 00083 // Bricking multiple structures 00084 00085 DefineClass(MBrick); 00086 typedef PPMBrick * PPPMBrick; 00087 00088 class MBrick { 00089 00090 public : 00091 ivector nAtoms; // number of atoms in the brick 00092 PPAtom *atom; // pointers to atoms 00093 imatrix id; // atom ids (in present realization, these are 00094 // indices of atoms from the bricked array) 00095 00096 MBrick ( int nStructures ); 00097 ~MBrick(); 00098 00099 void Clear (); 00100 void AddAtom ( PAtom A, int structNo, int atomid ); 00101 00102 protected : 00103 ivector nAlloAtoms; 00104 int nStruct; 00105 void InitMBrick ( int nStructures ); 00106 00107 }; 00108 00109 00110 00111 // ==================== GenSym ======================== 00112 00113 DefineClass(GenSym); 00114 DefineStreamFunctions(GenSym); 00115 00116 class GenSym : public SymOps { 00117 00118 friend class CoorManager; 00119 00120 public : 00121 00122 GenSym (); 00123 GenSym ( io::RPStream Object ); 00124 ~GenSym(); 00125 00126 void FreeMemory(); 00127 00128 int AddSymOp ( cpstr XYZOperation ); 00129 // the number of just added operation may be obtained as 00130 // Nop = GenSym::GetNofSymOps()-1 . 00131 00132 int AddRenChain ( int Nop, const ChainID ch1, const ChainID ch2 ); 00133 00134 void Copy ( PSymOps genSym ); 00135 00136 void write ( io::RFile f ); 00137 void read ( io::RFile f ); 00138 00139 protected : 00140 00141 PChainID * chID1; // pairs of chains to rename from chID1[n][i] 00142 PChainID * chID2; // to chID2[n][i] for each operation n<Nops 00143 ivector nChains; // number of chains to rename for each oper-n 00144 00145 void InitGenSym(); 00146 00147 private : 00148 int nOpAlloc; // number of allocated operations 00149 00150 }; 00151 00152 00153 // ========================= Contact ============================= 00154 00155 DefineStructure(Contact); 00156 00157 struct Contact { 00158 int id1,id2; 00159 long group; 00160 realtype dist; 00161 void Copy ( RContact c ); 00162 void Swap ( RContact c ); 00163 }; 00164 00165 00166 // ======================== MContact ============================= 00167 00168 DefineClass(MContact); 00169 00170 class MContact : public io::Stream { 00171 00172 public : 00173 int nStruct,contactID; 00174 ivector nAtoms; 00175 PPAtom * atom; 00176 imatrix id; 00177 00178 MContact ( int nStructures ); 00179 ~MContact(); 00180 00181 void AddContact ( PAtom A, int structNo, int atomid ); 00182 00183 protected: 00184 ivector nAlloc; 00185 00186 }; 00187 00188 extern void DeleteMContacts ( PPMContact & mcontact, int nContacts ); 00189 00190 00191 // ====================== CoorManager ========================= 00192 00193 DefineClass(CoorManager); 00194 DefineStreamFunctions(CoorManager); 00195 00196 // ---- Atom extraction return 00197 enum CID_RC { 00198 CID_Ok = 0, 00199 CID_NoModel = 1, 00200 CID_NoChain = 2, 00201 CID_NoResidue = 3, 00202 CID_NoAtom = 4, 00203 CID_WrongPath = 5 00204 }; 00205 00206 // ---- generate symmetry mates return codes 00207 enum GSM_RC { 00208 GSM_Ok = 0, 00209 GSM_NoSymOps = 1, 00210 GSM_NoTransfMatrices = 2, 00211 GSM_NoCell = 3 00212 }; 00213 00214 class CoorManager : public Root { 00215 00216 public : 00217 00218 int CoorIDCode; // last return from atom extraction procedure 00219 00220 CoorManager (); 00221 CoorManager ( io::RPStream Object ); 00222 ~CoorManager(); 00223 00224 00225 // ---------------------------------------------------------- 00226 00227 int SetDefaultCoorID ( cpstr CID ); 00228 00229 00230 // ---------------- Bricking ------------------------------ 00231 00232 void RemoveBricks (); 00233 bool areBricks () { return (brick!=NULL); } 00234 void MakeBricks ( PPAtom atmvec, int avlen, 00235 realtype Margin, realtype BrickSize=6.0 ); 00236 void GetBrickDimension ( 00237 int & nxmax, int & nymax, int & nzmax ); 00238 void GetBrickCoor ( PAtom A, int & nx, int & ny, int & nz ); 00239 void GetBrickCoor ( realtype x, realtype y, realtype z, 00240 int & nx, int & ny, int & nz ); 00241 PBrick GetBrick ( int nx, int ny, int nz ); 00242 00243 void RemoveMBricks (); 00244 bool areMBricks () { return (mbrick!=NULL); } 00245 void MakeMBricks ( PPAtom * atmvec, ivector avlen, 00246 int nStructures, realtype Margin, 00247 realtype BrickSize=6.0 ); 00248 void GetMBrickDimension ( 00249 int & nxmax, int & nymax, int & nzmax ); 00250 void GetMBrickCoor ( PAtom A, int & nx, int & ny, int & nz ); 00251 void GetMBrickCoor ( realtype x, realtype y, realtype z, 00252 int & nx, int & ny, int & nz ); 00253 PMBrick GetMBrick ( int nx, int ny, int nz ); 00254 00255 // ---------------- Extracting models --------------------- 00256 00257 int GetNumberOfModels () { return nModels; } 00258 int GetFirstModelNum (); 00259 PModel GetFirstDefinedModel(); 00260 PModel GetModel ( int modelNo ); // 1<=modelNo<=nModels 00261 PModel GetModel ( cpstr CID ); 00262 void GetModelTable ( PPModel & modTable, 00263 int & NumberOfModels ); 00264 00265 // ---------------- Deleting models ----------------------- 00266 00267 int DeleteModel ( cpstr CID ); 00268 int DeleteModel ( int modelNo ); // 1<=modelNo<=nOfModels 00269 00270 // ---------------- Adding/Inserting models --------------- 00271 00272 int AddModel ( PModel mdl ); 00273 int InsModel ( PModel mdl, int modelNo ); 00274 void RotateModels ( int modelNo1, int modelNo2, int rotdir ); 00275 void SwapModels ( int modelNo1, int modelNo2 ); 00276 00277 // ---------------- Extracting chains --------------------- 00278 00279 int GetNumberOfChains ( int modelNo ); 00280 int GetNumberOfChains ( cpstr CID ); 00281 PChain GetChain ( int modelNo, const ChainID chainID ); 00282 PChain GetChain ( int modelNo, int chainNo ); 00283 PChain GetChain ( cpstr CID ); 00284 void GetChainTable ( int modelNo, PPChain & chainTable, 00285 int & NumberOfChains ); 00286 void GetChainTable ( cpstr CID, PPChain & chainTable, 00287 int & NumberOfChains ); 00288 00289 // ----------------- Deleting chains ---------------------- 00290 00291 int DeleteChain ( int modelNo, const ChainID chID ); 00292 int DeleteChain ( int modelNo, int chainNo ); 00293 int DeleteAllChains ( int modelNo ); 00294 int DeleteAllChains (); 00295 00296 // ------------------ Adding chains ----------------------- 00297 00298 int AddChain ( int modelNo, PChain chain ); 00299 00300 // ---------------- Extracting residues ------------------- 00301 00302 int GetNumberOfResidues ( int modelNo, const ChainID chainID ); 00303 int GetNumberOfResidues ( int modelNo, int chainNo ); 00304 int GetNumberOfResidues ( cpstr CID ); 00305 PResidue GetResidue ( int modelNo, const ChainID chainID, 00306 int seqNo, const InsCode insCode ); 00307 PResidue GetResidue ( int modelNo, int chainNo, 00308 int seqNo, const InsCode insCode ); 00309 PResidue GetResidue ( int modelNo, const ChainID chainID, 00310 int resNo ); 00311 PResidue GetResidue ( int modelNo, int chainNo, int resNo ); 00312 PResidue GetResidue ( cpstr CID ); 00313 int GetResidueNo ( int modelNo, const ChainID chainID, 00314 int seqNo, const InsCode insCode ); 00315 int GetResidueNo ( int modelNo, int chainNo, 00316 int seqNo, const InsCode insCode ); 00317 void GetResidueTable ( PPResidue & resTable, 00318 int & NumberOfResidues ); 00319 void GetResidueTable ( int modelNo, const ChainID chainID, 00320 PPResidue & resTable, 00321 int & NumberOfResidues ); 00322 void GetResidueTable ( int modelNo, int chainNo, 00323 PPResidue & resTable, 00324 int & NumberOfResidues ); 00325 void GetResidueTable ( cpstr CID, PPResidue & resTable, 00326 int & NumberOfResidues ); 00327 00328 00329 // ----------------- Deleting residues ----------------------- 00330 00331 int DeleteResidue ( int modelNo, const ChainID chainID, 00332 int seqNo, const InsCode insCode ); 00333 int DeleteResidue ( int modelNo, const ChainID chainID, 00334 int resNo ); 00335 int DeleteResidue ( int modelNo, int chainNo, 00336 int seqNo, const InsCode insCode ); 00337 int DeleteResidue ( int modelNo, int chainNo, int resNo ); 00338 int DeleteAllResidues ( int modelNo, const ChainID chainID ); 00339 int DeleteAllResidues ( int modelNo, int chainNo ); 00340 int DeleteAllResidues ( int modelNo ); 00341 int DeleteAllResidues (); 00342 int DeleteSolvent (); 00343 00344 // ------------------- Adding residues ----------------------- 00345 00346 int AddResidue ( int modelNo, const ChainID chainID, 00347 PResidue res ); 00348 int AddResidue ( int modelNo, int chainNo, PResidue res ); 00349 00350 // -------------------- Extracting atoms ---------------------- 00351 00352 int GetNumberOfAtoms () { return nAtoms; } 00353 int GetNumberOfAtoms ( int modelNo, const ChainID chainID, 00354 int seqNo, const InsCode insCode ); 00355 int GetNumberOfAtoms ( int modelNo, int chainNo, 00356 int seqNo, const InsCode insCode ); 00357 int GetNumberOfAtoms ( int modelNo, const ChainID chainID, 00358 int resNo ); 00359 int GetNumberOfAtoms ( int modelNo, int chainNo, int resNo ); 00360 int GetNumberOfAtoms ( cpstr CID ); 00361 00362 PAtom GetAtom ( 00363 int modelNo, // model serial number 1... 00364 const ChainID chID, // chain ID 00365 int seqNo, // residue sequence number 00366 const InsCode insCode, // residue insertion code 00367 const AtomName aname, // atom name 00368 const Element elmnt, // chemical element code or '*' 00369 const AltLoc aloc // alternate location indicator 00370 ); 00371 00372 PAtom GetAtom ( 00373 int modelNo, // model serial number 1... 00374 const ChainID chID, // chain ID 00375 int seqNo, // residue sequence number 00376 const InsCode insCode, // residue insertion code 00377 int atomNo // atom number 0.. 00378 ); 00379 00380 PAtom GetAtom ( 00381 int modelNo, // model serial number 1... 00382 const ChainID chID, // chain ID 00383 int resNo, // residue number 0.. 00384 const AtomName aname, // atom name 00385 const Element elmnt, // chemical element code or '*' 00386 const AltLoc aloc // alternate location indicator 00387 ); 00388 00389 PAtom GetAtom ( 00390 int modelNo, // model serial number 1... 00391 const ChainID chID, // chain ID 00392 int resNo, // residue number 0.. 00393 int atomNo // atom number 0.. 00394 ); 00395 00396 PAtom GetAtom ( 00397 int modelNo, // model serial number 1... 00398 int chNo, // chain number 0.. 00399 int seqNo, // residue sequence number 00400 const InsCode insCode, // residue insertion code 00401 const AtomName aname, // atom name 00402 const Element elmnt, // chemical element code or '*' 00403 const AltLoc aloc // alternate location indicator 00404 ); 00405 00406 PAtom GetAtom ( 00407 int modelNo, // model serial number 1... 00408 int chNo, // chain number 0... 00409 int seqNo, // residue sequence number 00410 const InsCode insCode, // residue insertion code 00411 int atomNo // atom number 0... 00412 ); 00413 00414 PAtom GetAtom ( 00415 int modelNo, // model serial number 1... 00416 int chNo, // chain number 0... 00417 int resNo, // residue number 0... 00418 const AtomName aname, // atom name 00419 const Element elmnt, // chemical element code or '*' 00420 const AltLoc aloc // alternate location indicator 00421 ); 00422 00423 PAtom GetAtom ( 00424 int modelNo, // model serial number 1... 00425 int chNo, // chain number 0... 00426 int resNo, // residue number 0... 00427 int atomNo // atom number 0... 00428 ); 00429 00430 00431 // GetAtom(CID) returns atom answering to the following 00432 // CID pattern: 00433 // /mdl/chn/seq(res).i/atm[elm]:a 00434 // where 00435 // mdl - model number (mandatory); at least model #1 is always 00436 // present 00437 // chn - chain identifier ( mandatory) 00438 // seq - residue sequence number (mandatory) 00439 // (res) - residue name in round brackets (may be omitted) 00440 // .i - insert code after a dot; if '.i' or 'i' is missing 00441 // then residue without an insertion code is looked 00442 // for 00443 // atm - atom name (mandatory) 00444 // [elm] - chemical element code in square brackets; it may 00445 // be omitted but could be helpful for e.g. 00446 // distinguishing C_alpha and CA 00447 // :a - alternate location indicator after colon; if 00448 // ':a' or 'a' is missing then an atom without 00449 // alternate location indicator is looked for. 00450 // All spaces are ignored, all identifiers should be in capital 00451 // letters (comparisons are case-sensitive). 00452 PAtom GetAtom ( cpstr CID ); 00453 00454 00455 void GetAtomTable ( PPAtom & atomTable, int & NumberOfAtoms ); 00456 void GetAtomTable ( int modelNo, const ChainID chainID, 00457 int seqNo, const InsCode insCode, 00458 PPAtom & atomTable, int & NumberOfAtoms ); 00459 void GetAtomTable ( int modelNo, int chainNo, 00460 int seqNo, const InsCode insCode, 00461 PPAtom & atomTable, int & NumberOfAtoms ); 00462 void GetAtomTable ( int modelNo, const ChainID chainID, int resNo, 00463 PPAtom & atomTable, int & NumberOfAtoms ); 00464 void GetAtomTable ( int modelNo, int chainNo, int resNo, 00465 PPAtom & atomTable, int & NumberOfAtoms ); 00466 void GetAtomTable ( cpstr CID, PPAtom & atomTable, 00467 int & NumberOfAtoms ); 00468 00469 00470 // GetAtomTable1(..) returns atom table without TER atoms and 00471 // without NULL atom pointers. NumberOfAtoms returns the actual 00472 // number of atom pointers in atomTable. 00473 // atomTable is allocated within the function. If it was 00474 // not set to NULL before calling the function, the function will 00475 // attempt to deallocate it first. 00476 // The application is responsible for deleting atomTable, 00477 // however it must not touch atom pointers, i.e. use simply 00478 // "delete atomTable;". Never pass atomTable from GetAtomTable(..) 00479 // into this function, unless you set it to NULL before doing that. 00480 void GetAtomTable1 ( PPAtom & atomTable, int & NumberOfAtoms ); 00481 void GetAtomTable1 ( int modelNo, const ChainID chainID, 00482 int seqNo, const InsCode insCode, 00483 PPAtom & atomTable, int & NumberOfAtoms ); 00484 void GetAtomTable1 ( int modelNo, int chainNo, 00485 int seqNo, const InsCode insCode, 00486 PPAtom & atomTable, int & NumberOfAtoms ); 00487 void GetAtomTable1 ( int modelNo, const ChainID chainID, int resNo, 00488 PPAtom & atomTable, int & NumberOfAtoms ); 00489 void GetAtomTable1 ( int modelNo, int chainNo, int resNo, 00490 PPAtom & atomTable, int & NumberOfAtoms ); 00491 void GetAtomTable1 ( cpstr CID, PPAtom & atomTable, 00492 int & NumberOfAtoms ); 00493 00494 00495 // -------------------- Deleting atoms ----------------------- 00496 00497 int DeleteAtom ( int modelNo, 00498 const ChainID chID, 00499 int seqNo, 00500 const InsCode insCode, 00501 const AtomName aname, 00502 const Element elmnt, 00503 const AltLoc aloc ); 00504 int DeleteAtom ( int modelNo, 00505 const ChainID chID, 00506 int seqNo, 00507 const InsCode insCode, 00508 int atomNo ); 00509 int DeleteAtom ( int modelNo, 00510 const ChainID chID, 00511 int resNo, 00512 const AtomName aname, 00513 const Element elmnt, 00514 const AltLoc aloc ); 00515 int DeleteAtom ( int modelNo, const ChainID chID, 00516 int resNo, int atomNo ); 00517 int DeleteAtom ( int modelNo, int chNo, int seqNo, 00518 const InsCode insCode, 00519 const AtomName aname, 00520 const Element elmnt, 00521 const AltLoc aloc ); 00522 int DeleteAtom ( int modelNo, int chNo, int seqNo, 00523 const InsCode insCode, int atomNo ); 00524 int DeleteAtom ( int modelNo, int chNo, int resNo, 00525 const AtomName aname, 00526 const Element elmnt, 00527 const AltLoc aloc ); 00528 int DeleteAtom ( int modelNo, int chNo, int resNo, int atomNo ); 00529 00530 int DeleteAllAtoms ( int modelNo, const ChainID chID, 00531 int seqNo, const InsCode insCode ); 00532 int DeleteAllAtoms ( int modelNo, const ChainID chID, int resNo ); 00533 int DeleteAllAtoms ( int modelNo, const ChainID chID ); 00534 int DeleteAllAtoms ( int modelNo, int chNo, int seqNo, 00535 const InsCode insCode ); 00536 int DeleteAllAtoms ( int modelNo, int chNo, int resNo ); 00537 int DeleteAllAtoms ( int modelNo, int chNo ); 00538 int DeleteAllAtoms ( int modelNo ); 00539 int DeleteAllAtoms (); 00540 00541 // This function leaves only alternative location with maximal 00542 // occupancy, if those are equal or unspecified, the one with 00543 // "least" alternative location indicator. 00544 // The function returns the number of deleted atoms and optimizes 00545 // the atom index. 00546 int DeleteAltLocs (); 00547 00548 00549 // --------------------- Adding atoms ------------------------ 00550 00551 int AddAtom ( int modelNo, const ChainID chID, 00552 int seqNo, const InsCode insCode, PAtom atom ); 00553 int AddAtom ( int modelNo, const ChainID chID, int resNo, 00554 PAtom atom ); 00555 int AddAtom ( int modelNo, int chNo, int seqNo, 00556 const InsCode insCode, PAtom atom ); 00557 int AddAtom ( int modelNo, int chNo, int resNo, PAtom atom ); 00558 00559 00560 // -------------------- Transformations ----------------------- 00561 00562 int GenerateSymMates ( PGenSym genSym=NULL ); 00563 // 1: no Sym operations, 00564 // 2: no fract/orth matrices 00565 // 3: no cell parameters 00566 // 0: Ok 00567 00568 void ApplyTransform ( mat44 & TMatrix ); // simply transforms all 00569 // coordinates by multiplying 00570 // with matrix TMatrix 00571 00572 int BringToUnitCell(); // brings all chains into 0th unit cell 00573 00574 // Frac2Orth(..) and Orth2Frac(..) transform between fractional 00575 // and orthogonal coordinates, if areMatrices() returns true. 00576 // If the transformation matrices were not set, the functions just 00577 // copy the coordinates. Returns true if the transformation was 00578 // done; False return means that transformation matrices were not 00579 // calculated 00580 bool Frac2Orth ( 00581 realtype xfrac, realtype yfrac, realtype zfrac, 00582 realtype & xorth, realtype & yorth, realtype & zorth ); 00583 bool Orth2Frac ( 00584 realtype xorth, realtype yorth, realtype zorth, 00585 realtype & xfrac, realtype & yfrac, realtype & zfrac ); 00586 00587 00588 // Below, F and T are transformation matrices in fractional and 00589 // orthogonal coordinates, respectively. 00590 bool Frac2Orth ( mat44 & F, mat44 & T ); 00591 bool Orth2Frac ( mat44 & T, mat44 & F ); 00592 00593 // ==================== Seeking contacts ====================== 00594 00595 void SeekContacts ( 00596 PPAtom AIndex, // index of atoms [0..ilen-1] 00597 int ilen, // length of index 00598 int atomNum, // number of 1st contact atom 00599 // in the index. All other atoms 00600 // are checked for contact with 00601 // 1st atom 00602 realtype dist1, // minimal contact distance 00603 realtype dist2, // maximal contact distance 00604 int seqDist, // the sequence distance to neglect. 00605 // If seqDist==0, all atoms are 00606 // checked for contact. If 00607 // seqDist==1, the atoms belonging 00608 // to the same residue as atom 00609 // AIndex[atomNum], are neglected. 00610 // If seqDist>1, all atoms belonging 00611 // to residues closer than 00612 // +/-(seqDist-1) around that of 00613 // atom AIndex[atomNum], are 00614 // neglected. If chain is broken 00615 // (has a gap) on section 00616 // [-(seqDist-1)..seqDist-1], the 00617 // section of neglection is 00618 // shortened to that gap. 00619 RPContact contact, // indices of contacting atoms 00620 // [0..ncontacts-1]. contact[i].id1 00621 // is set to atomNum and 00622 // contact[i].id2 is set to the 00623 // index of 2nd contacting atom 00624 // in vector AIndex 00625 int & ncontacts, // number of contacts found. If 00626 // ncontacts>0 on input, it is 00627 // assumed that new contacts that 00628 // newly found contacts should be 00629 // appended to those already 00630 // existing 00631 int maxlen=0, // if <=0, then vector contact is 00632 // allocated dynamically. If 00633 // contact!=NULL, then it is 00634 // appended with new contacts. 00635 // The application is responsible 00636 // for deallocation of contact 00637 // after use. 00638 // If maxlen>0 then vector contact 00639 // is prohibited of dynamical 00640 // allocation/deallocation. In this 00641 // case, not more than maxlen 00642 // contacts will be returned. 00643 long group=0 // a contact group ID, which will be 00644 // simply stored in contact[i].group 00645 // fields. This ID may be useful 00646 // if contacts are obtained in 00647 // multiple calls of the function 00648 ); 00649 00650 void SeekContacts ( 00651 PAtom A, // 1st atom in contact 00652 PPAtom AIndex, // index of atoms [0..ilen-1] to 00653 // check for contact with 1st atom 00654 int ilen, // length of index 00655 realtype dist1, // minimal contact distance 00656 realtype dist2, // maximal contact distance 00657 int seqDist, // the sequence distance to neglect. 00658 // If seqDist==0, all atoms are 00659 // checked for contact. If 00660 // seqDist==1, the atoms belonging 00661 // to the same residue as atom 00662 // A, are neglected. If seqDist>1, 00663 // all atoms belonging to residues 00664 // closer than +/-(seqDist-1) around 00665 // that of atom A, are neglected. If 00666 // chain is broken (has a gap) on 00667 // section 00668 // [-(seqDist-1)..seqDist-1], the 00669 // section of neglection is 00670 // shortened to that gap. 00671 RPContact contact, // indices of contacting atoms 00672 // [0..ncontacts-1]. contact[i].id1 00673 // is set to -1, and contact[i].id2 00674 // is set to the index of 2nd 00675 // contacting atom in vector AIndex 00676 int & ncontacts, // number of contacts found. If 00677 // ncontacts>0 on input, it is 00678 // assumed that new contacts that 00679 // newly found contacts should be 00680 // appended those already existing 00681 int maxlen=0, // if <=0, then vector contact is 00682 // allocated dynamically. If 00683 // contact!=NULL, then it is 00684 // appended with new contacts. 00685 // The application is responsible 00686 // for deallocation of contact 00687 // after use. 00688 // If maxlen>0 then vector contact 00689 // is prohibited of dynamical 00690 // allocation/deallocation. In this 00691 // case, not more than maxlen 00692 // contacts will be returned. 00693 long group=0 // a contact group ID, which will be 00694 // simply stored in contact[i].group 00695 // fields. This ID may be useful 00696 // if contacts are obtained in 00697 // multiple calls of the function 00698 ); 00699 00700 void SeekContacts ( 00701 PPAtom AIndex1, // 1st atom index [0..ilen1-1] 00702 int ilen1, // length of 1st index 00703 PPAtom AIndex2, // 2nd atom index [0..ilen2-1] to 00704 // check for contact with 1st index 00705 int ilen2, // length of 2nd index 00706 realtype dist1, // minimal contact distance 00707 realtype dist2, // maximal contact distance 00708 int seqDist, // the sequence distance to 00709 // neglect. 00710 // If seqDist==0, all atoms are 00711 // checked for contact. 00712 // If seqDist==1, the atoms 00713 // belonging to the same residue 00714 // are neglected. 00715 // If seqDist>1, all atoms 00716 // belonging to residues closer than 00717 // +/-(seqDist-1) to each other, 00718 // are neglected. If chain is broken 00719 // (has a gap) on section 00720 // [-(seqDist-1)..seqDist-1], the 00721 // section of neglection is 00722 // shortened to that gap. 00723 RPContact contact, // indices of contacting atoms 00724 // [0..ncontacts-1]. contact[i].id1 00725 // contains number of atom from 1st 00726 // index, and contact[i].id2 00727 // contains number of atom from 2nd 00728 // index, contacting with the former 00729 // one 00730 int & ncontacts, // number of contacts found. If 00731 // ncontacts>0 on input, it is 00732 // assumed that newly found 00733 // contacts should be appended to 00734 // those already existing 00735 int maxlen=0, // if <=0, then vector contact is 00736 // allocated dynamically. If 00737 // contact!=NULL, then it is 00738 // appended with new contacts. 00739 // The application is responsible 00740 // for deallocation of contact 00741 // after use. 00742 // If maxlen>0 then vector contact 00743 // is prohibited of dynamical 00744 // allocation/deallocation. In this 00745 // case, not more than maxlen 00746 // contacts will be returned. 00747 mat44 * TMatrix=NULL, // transformation matrix for 2nd 00748 // set of atoms (AIndex2) 00749 long group=0, // a contact group ID, which will 00750 // be stored in contact[i].group 00751 // fields. This ID may be useful 00752 // if contacts are obtained in 00753 // multiple calls of the function 00754 int bricking=0, // bricking control; may be a 00755 // combination of BRICK_ON_1 or 00756 // BRICK_ON_2 with BRICK_READY 00757 bool doSqrt=true // if False, then Contact contains 00758 // square distances 00759 ); 00760 00761 // Simplified optimized for speed version: 00762 // - no NULL pointers and Ters in AIndex1 and AIndex2 00763 // - no checks for identity atoms in AIndex1 and AIndex2 00764 // - contact must be pre-allocated with at least ilen1*ilen2 00765 // elements 00766 // - contact returns square distances 00767 // - ncontacts is always reset 00768 void SeekContacts ( 00769 PPAtom AIndex1, // 1st atom index [0..ilen1-1] 00770 int ilen1, // length of 1st index 00771 PPAtom AIndex2, // 2nd atom index [0..ilen2-1] to 00772 // check for contact with 1st index 00773 int ilen2, // length of 2nd index 00774 realtype contDist, // maximal contact distance 00775 PContact contact, // indices of contacting atoms 00776 // [0..ncontacts-1]. contact[i].id1 00777 // contains number of atom from 1st 00778 // index, and contact[i].id2 00779 // contains number of atom from 2nd 00780 // index, contacting with the former 00781 // one. Must be pre-allocated 00782 int & ncontacts, // number of contacts found 00783 int bricking=0 // bricking control; may be a 00784 // combination of BRICK_ON_1 or 00785 // BRICK_ON_2 with BRICK_READY 00786 ); 00787 00788 void SeekContacts ( 00789 PPAtom AIndex1, // 1st atom index [0..ilen1-1] 00790 int ilen1, // length of 1st index 00791 PPAtom * AIndex2, // indexes of atoms to be checked 00792 // for contact with each atom from 00793 // Aindex1; dimension 00794 // [0..nStructures-1][0..ilen2[i]-1] 00795 ivector ilen2, // lengths of indexes AIndex2 00796 int nStructures, // number of indexes AIndex2 00797 realtype dist1, // minimal contact distance 00798 realtype dist2, // maximal contact distance 00799 PPMContact & contact, // resulting contacts, one structure 00800 // per each position in AIndex1. If 00801 // AIndex1[i] is NULL, contact[i] is 00802 // also NULL. "contact" is always 00803 // allocated, no re-use or 00804 // re-allocation is attempted. 00805 int bricking=0 // bricking control; may be 00806 // BRICK_READY if AIndex2 does not 00807 // change 00808 ); 00809 00810 protected : 00811 00812 // bricks 00813 realtype brick_size, xbrick_0,ybrick_0,zbrick_0; 00814 int nbrick_x,nbrick_y,nbrick_z; 00815 PPPBrick * brick; 00816 00817 realtype mbrick_size, xmbrick_0,ymbrick_0,zmbrick_0; 00818 int nmbrick_x,nmbrick_y,nmbrick_z; 00819 PPPMBrick * mbrick; 00820 00821 // --------------- Stream I/O ----------------------------- 00822 void write ( io::RFile f ); 00823 void read ( io::RFile f ); 00824 00825 void InitMMDBCoorManager(); 00826 00827 void ApplySymTransform ( int SymMatrixNo, PGenSym genSym=NULL ); 00828 00829 void ResetManager (); 00830 00831 void FindSeqSection ( PAtom atom, int seqDist, 00832 int & seq1, int & seq2 ); 00833 bool iContact ( PAtom a1, PAtom a2, 00834 int seq1, int seq2, 00835 realtype dd, realtype d12, 00836 realtype d22, realtype & d2 ); 00837 bool iContact ( realtype x, realtype y, 00838 realtype z, PAtom a2, 00839 realtype dd, realtype d12, 00840 realtype d22, realtype & d2 ); 00841 00842 }; 00843 00844 00845 00846 // =================================================================== 00847 00848 00849 00850 // GetEulerRotMatrix(..) calculates the Euler rotation matrix 00851 // for rotation: 00852 // 1) about z-axis by angle alpha 00853 // 2) about new y-axis by angle beta 00854 // 3) about new z-axis by angle gamma 00855 extern void GetEulerRotMatrix ( mat33 & erm, realtype alpha, 00856 realtype beta, realtype gamma ); 00857 00858 // GetEulerTMatrix(..) calculates the Euler rotation-translation 00859 // matrix for rotation: 00860 // 1) about z-axis by angle alpha 00861 // 2) about new y-axis by angle beta 00862 // 3) about new z-axis by angle gamma 00863 // Point (x0,y0,z0) is the center of rotation. 00864 extern void GetEulerTMatrix ( mat44 & erm, realtype alpha, 00865 realtype beta, realtype gamma, 00866 realtype x0, realtype y0, realtype z0 ); 00867 00868 // Euler rotation: 1) about z-axis by angle alpha 00869 // 2) about new y-axis by angle beta 00870 // 3) about new z-axis by angle gamma 00871 // Point (x0,y0,z0) is the center of rotation. 00872 extern void EulerRotation ( PPAtom A, int nA, 00873 realtype alpha, realtype beta, realtype gamma, 00874 realtype x0, realtype y0, realtype z0 ); 00875 00876 // GetVecRotMatrix(..) calculates the rotation matrix for 00877 // rotation by angle alpha about arbitrary vector directed 00878 // as (vx,vy,vz) = (vx2-vx1,vy2-vy1,vz2-vz1). 00879 extern void GetVecRotMatrix ( mat33 & vrm, realtype alpha, 00880 realtype vx, realtype vy, realtype vz ); 00881 00882 00883 // Given the rotation matrix vrm, GetRotParameters(..) 00884 // returns the rotation angle alpha and the normalized 00885 // rotation axis vector (vx,vy,vz). 00886 // The rotation angle and vector are determined up to 00887 // their sign (however correlated, so that being substituted 00888 // into GetVecRotMatrix(..) they yield the same rotation 00889 // matrix). 00890 // The function does not check for vrm to be a valid 00891 // rotation matrix. 00892 extern void GetRotParameters ( mat33 & vrm, realtype & alpha, 00893 realtype & vx, realtype & vy, realtype & vz ); 00894 00895 00896 // GetVecTMatrix(..) calculates the rotation-translation matrix 00897 // for rotation by angle alpha about arbitrary vector directed as 00898 // (vx,vy,vz) = (vx2-vx1,vy2-vy1,vz2-vz1). Point (x0,y0,z0) is 00899 // the center of rotation -- actually a point belonging to the 00900 // rotation axis. 00901 extern void GetVecTMatrix ( mat44 & vrm, realtype alpha, 00902 realtype vx, realtype vy, realtype vz, 00903 realtype x0, realtype y0, realtype z0 ); 00904 00905 // Vector rotation is rotation by angle alpha about arbitrary 00906 // vector directed as (vx,vy,vz) = (vx2-vx1,vy2-vy1,vz2-vz1). 00907 // Point (x0,y0,z0) is the center of rotation -- actually 00908 // a point belonging to the rotation axis. 00909 extern void VectorRotation ( PPAtom A, int nA, realtype alpha, 00910 realtype vx, realtype vy, realtype vz, 00911 realtype x0, realtype y0, realtype z0 ); 00912 00913 extern void GetMassCenter ( PPAtom A, int nA, 00914 realtype & xmc, realtype & ymc, realtype & zmc ); 00915 00916 00917 enum SPOSEAT_RC { 00918 SPOSEAT_Ok = 0, 00919 SPOSEAT_NoAtoms = 1, 00920 SPOSEAT_SVD_Fail = 2 00921 }; 00922 00923 // Given two sets of atoms, A1 and A2, SuperposeAtoms(...) calculates 00924 // the rotational-translational matrix T such that |T*A1 - A2| is 00925 // minimal in least-square terms. 00926 // If vector C is not given (default), all nA atoms of set A1 are 00927 // considered as corresponding to nA first atoms of set A2, 00928 // A1[i] <-> A2[i], 0<=i<nA . 00929 // If vector C is given, then the correspondence of atoms is 00930 // established as A1[i] <-> A2[C[i]] only for those i that C[i]>=0. 00931 // The default option (C==NULL) is thus identical to C[i]==i, 0<=i<nA. 00932 // Upon normal completion, the procedure returns SPOSEAT_Ok. 00933 00934 extern int SuperposeAtoms ( mat44 & T, PPAtom A1, int nA, PPAtom A2, 00935 ivector C=NULL ); 00936 00937 enum CNSORT_DIR { 00938 CNSORT_OFF = 0, 00939 CNSORT_1INC = 1, 00940 CNSORT_1DEC = 2, 00941 CNSORT_2INC = 3, 00942 CNSORT_2DEC = 4, 00943 CNSORT_DINC = 5, 00944 CNSORT_DDEC = 6 00945 }; 00946 00947 extern void SortContacts ( PContact contact, int ncontacts, 00948 CNSORT_DIR sortmode ); 00949 00950 00951 extern const realtype NO_TORSION; 00952 00953 extern realtype getPhi ( PPAtom A ); // A[0] - A[3] used 00954 extern realtype getPsi ( PPAtom A ); // A[0] - A[2] used 00955 00956 } // namespace mmdb 00957 00958 #endif 00959
