001/* 002 * BioJava development code 003 * 004 * This code may be freely distributed and modified under the 005 * terms of the GNU Lesser General Public Licence. This should 006 * be distributed with the code. If you do not have a copy, 007 * see: 008 * 009 * http://www.gnu.org/copyleft/lesser.html 010 * 011 * Copyright for this code is held jointly by the individual 012 * authors. These should be listed in @author doc comments. 013 * 014 * For more information on the BioJava project and its aims, 015 * or to join the biojava-l mailing list, visit the home page 016 * at: 017 * 018 * http://www.biojava.org/ 019 * 020 * Created on 26.04.2004 021 * @author Andreas Prlic 022 * 023 */ 024package org.biojava.nbio.structure; 025 026import java.util.ArrayList; 027import java.util.List; 028import java.util.ListIterator; 029 030import org.biojava.nbio.structure.io.FileConvert; 031import org.slf4j.Logger; 032import org.slf4j.LoggerFactory; 033 034/** 035 * Implementation of a PDB Structure. This class 036 * provides the data contained in a PDB file. 037 * to get structure objects from different sources 038 * see io package. 039 * 040 * @author Andreas Prlic 041 * @author Jules Jacobsen 042 * @since 1.4 043 * @version %I% %G% 044 */ 045public class StructureImpl implements Structure { 046 047 private static final long serialVersionUID = -8344837138032851348L; 048 049 private static final Logger logger = LoggerFactory.getLogger(StructureImpl.class); 050 051 private String pdb_id ; 052 053 private List<Model> models; 054 055 private List<EntityInfo> entityInfos; 056 private List<DBRef> dbrefs; 057 private List<Bond> ssbonds; 058 private List<Site> sites; 059 private String name ; 060 private StructureIdentifier structureIdentifier; 061 062 private PDBHeader pdbHeader; 063 064 private Long id; 065 private boolean biologicalAssembly; 066 067 /** 068 * Constructs a StructureImpl object. 069 */ 070 public StructureImpl() { 071 super(); 072 073 models = new ArrayList<>(); 074 name = ""; 075 entityInfos = new ArrayList<>(); 076 dbrefs = new ArrayList<>(); 077 pdbHeader = new PDBHeader(); 078 ssbonds = new ArrayList<>(); 079 sites = new ArrayList<>(); 080 } 081 082 083 /** get the ID used by Hibernate 084 * 085 * @return the ID used by Hibernate 086 */ 087 @Override 088 public Long getId() { 089 return id; 090 } 091 092 /** set the ID used by Hibernate 093 * 094 * @param id the hibernate ID 095 */ 096 @Override 097 public void setId(Long id) { 098 this.id = id; 099 } 100 101 102 103 /** Construct a Structure object that only contains a single group 104 * 105 * @param g group object 106 */ 107 public StructureImpl(Group g){ 108 this(); 109 110 Chain c = new ChainImpl(); 111 c.addGroup(g); 112 113 addChain(c); 114 } 115 116 /** construct a Structure object that contains a particular chain 117 * 118 * @param c chain 119 */ 120 public StructureImpl(Chain c){ 121 this(); 122 addChain(c); 123 } 124 125 /** returns an identical copy of this structure . 126 * @return an identical Structure object 127 */ 128 @Override 129 public Structure clone() { 130 // Note: structures are also cloned in SubstructureIdentifier.reduce(). 131 // Changes might need to be made there as well 132 133 Structure n = new StructureImpl(); 134 // go through whole substructure and clone ... 135 136 // copy structure data 137 138 n.setPDBCode(getPDBCode()); 139 n.setName(getName()); 140 //TODO the header data is not being deep-copied, that's a minor issue since it is just some static metadata, but we should recheck this if needed - JD 2014-12-11 141 n.setPDBHeader(pdbHeader); 142 n.setDBRefs(this.getDBRefs()); 143 n.setSites(getSites()); 144 145 146 // go through each chain and clone chain 147 for (int i=0;i<nrModels();i++){ 148 List<Chain> cloned_model = new ArrayList<Chain>(); 149 150 for (int j=0;j<size(i);j++){ 151 152 Chain cloned_chain = (Chain) getChainByIndex(i,j).clone(); 153 154 // setting the parent: can only be done from the parent 155 cloned_chain.setStructure(n); 156 157 cloned_model.add(cloned_chain); 158 159 } 160 n.addModel(cloned_model); 161 162 } 163 164 // deep-copying of entityInfofos is tricky: there's cross references also in the Chains 165 // beware: if we copy the entityInfos we would also need to reset the references to entityInfos in the individual chains 166 List<EntityInfo> newEntityInfoList = new ArrayList<EntityInfo>(); 167 for (EntityInfo entityInfo : this.entityInfos) { 168 EntityInfo newEntityInfo = new EntityInfo(entityInfo); // this sets everything but the chains 169 for (String asymId:entityInfo.getChainIds()) { 170 171 for (int modelNr=0;modelNr<n.nrModels();modelNr++) { 172 Chain newChain = n.getChain(asymId,modelNr); 173 if (newChain==null) { 174 // this actually happens for structure 1msh, which has no chain B for model 29 (clearly a deposition error) 175 logger.warn("Could not find chain asymId "+asymId+" of model "+modelNr+" while cloning entityInfo "+entityInfo.getMolId()+". Something is wrong!"); 176 continue; 177 } 178 newChain.setEntityInfo(newEntityInfo); 179 newEntityInfo.addChain(newChain); 180 } 181 } 182 newEntityInfoList.add(newEntityInfo); 183 } 184 n.setEntityInfos(newEntityInfoList); 185 // TODO ssbonds are complicated to clone: there are deep references inside Atom objects, how would we do it? - JD 2016-03-03 186 187 return n ; 188 } 189 190 191 /** {@inheritDoc} */ 192 @Override 193 public Group findGroup(String chainName, String pdbResnum, int modelnr) 194 throws StructureException { 195 196 197 // if structure is xray there will be only one "model". 198 if ( modelnr > models.size()) 199 throw new StructureException(" no model nr " + modelnr + 200 " in this structure. (contains "+models.size()+")"); 201 202 203 // first we need to gather all groups with the author id chainName: polymers, non-polymers and waters 204 Chain polyChain = getPolyChainByPDB(chainName, modelnr); 205 if(polyChain != null) { 206 List<Group> groups = new ArrayList<>(); 207 208 groups.addAll(polyChain.getAtomGroups()); 209 210 211 // there can be more than one non-poly chain for a given author id 212 for (Chain chain: getNonPolyChainsByPDB(chainName, modelnr)) { 213 groups.addAll(chain.getAtomGroups()); 214 } 215 216 Chain water = getWaterChainByPDB(chainName, modelnr); 217 218 if (water!=null) 219 groups.addAll(water.getAtomGroups()); 220 221 222 223 // now iterate over all groups 224 // in order to find the amino acid that has this pdbRenum. 225 226 for (Group g : groups) { 227 String rnum = g.getResidueNumber().toString(); 228 //System.out.println(g + " >" + rnum + "< >" + pdbResnum + "<"); 229 // we only mutate amino acids 230 // and ignore hetatoms and nucleotides in this case 231 if (rnum.equals(pdbResnum)) { 232 return g; 233 } 234 } 235 } 236 throw new StructureException("could not find group " + pdbResnum + 237 " in chain " + chainName); 238 } 239 240 241 /** {@inheritDoc} */ 242 @Override 243 public Group findGroup(String chainName, String pdbResnum) throws StructureException 244 { 245 return findGroup(chainName, pdbResnum, 0); 246 247 } 248 249 250 251 252 /** {@inheritDoc} */ 253 @Override 254 public Chain findChain(String chainName, int modelnr) throws StructureException { 255 256 return getChainByPDB(chainName, modelnr); 257 258 } 259 260 261 /** {@inheritDoc} */ 262 @Override 263 public Chain findChain(String chainId) throws StructureException { 264 265 return findChain(chainId,0); 266 } 267 268 269 /** {@inheritDoc} */ 270 @Override 271 public void setPDBCode (String pdb_id_) { 272 pdb_id = pdb_id_ ; 273 } 274 275 /** {@inheritDoc} */ 276 @Override 277 public String getPDBCode () { 278 return pdb_id ; 279 } 280 281 282 283 /** {@inheritDoc} */ 284 @Override 285 public void setName(String nam) { name = nam; } 286 287 /** {@inheritDoc} */ 288 @Override 289 public String getName() { return name; } 290 291 292 293 /** 294 * @return The StructureIdentifier used to create this structure 295 */ 296 @Override 297 public StructureIdentifier getStructureIdentifier() { 298 return structureIdentifier; 299 } 300 301 /** 302 * @param structureIdentifier the structureIdentifier corresponding to this structure 303 */ 304 @Override 305 public void setStructureIdentifier(StructureIdentifier structureIdentifier) { 306 this.structureIdentifier = structureIdentifier; 307 } 308 309 /** {@inheritDoc} */ 310 @Override 311 public void addChain(Chain chain) { 312 int modelnr = 0 ; 313 addChain(chain,modelnr); 314 } 315 316 /** {@inheritDoc} */ 317 @Override 318 public void addChain(Chain chain, int modelnr) { 319 // if model has not been initialized, init it! 320 chain.setStructure(this); 321 if (models.isEmpty()) { 322 Model model = new Model(); 323 List<Chain> modelChains = new ArrayList<>() ; 324 modelChains.add(chain); 325 model.setChains(modelChains); 326 models.add(model); 327 328 } else { 329 Model model = models.get(modelnr); 330 model.addChain(chain); 331 } 332 333 334 335 } 336 337 338 339 /** {@inheritDoc} */ 340 @Override 341 public Chain getChainByIndex(int number) { 342 343 int modelnr = 0 ; 344 345 return getChainByIndex(modelnr,number); 346 } 347 348 349 /** {@inheritDoc} */ 350 @Override 351 public Chain getChainByIndex(int modelnr,int number) { 352 353 Model model = models.get(modelnr); 354 355 return model.getChains().get(number); 356 } 357 358 359 360 /** {@inheritDoc} */ 361 @Override 362 public void addModel(List<Chain> modelChains){ 363 for (Chain c: modelChains){ 364 c.setStructure(this); 365 } 366 Model model = new Model(); 367 model.setChains(modelChains); 368 models.add(model); 369 } 370 371 372 /** {@inheritDoc} */ 373 @Override 374 public void setChains(List<Chain> chains){ 375 376 setModel(0,chains); 377 } 378 379 380 381 /** {@inheritDoc} */ 382 @Override 383 public void setModel(int position, List<Chain> modelChains){ 384 if (modelChains == null) 385 throw new IllegalArgumentException("trying to set model to null!"); 386 387 for (Chain c: modelChains) 388 c.setStructure(this); 389 390 //System.out.println("model size:" + models.size()); 391 392 393 Model model = new Model(); 394 model.setChains(modelChains); 395 396 if (models.isEmpty()){ 397 models.add(model); 398 } else { 399 models.set(position, model); 400 } 401 } 402 403 /** String representation. 404 * 405 */ 406 @Override 407 public String toString(){ 408 String newline = System.getProperty("line.separator"); 409 StringBuilder str = new StringBuilder(); 410 str.append("structure "); 411 str.append(name); 412 str.append(" "); 413 str.append(pdb_id); 414 str.append(" "); 415 416 if ( nrModels()>1 ){ 417 str.append( " models: "); 418 str.append(nrModels()); 419 str.append(newline) ; 420 } 421 422 str.append(pdbHeader); 423 str.append(newline) ; 424 425 for (int i=0;i<nrModels();i++){ 426 if ( nrModels()>1 ) { 427 str.append(" model["); 428 str.append(i); 429 str.append("]:"); 430 str.append(newline); 431 } 432 str.append(" chains:"); 433 str.append(newline); 434 435 for (int j=0;j<size(i);j++){ 436 437 Chain cha = getChainByIndex(i,j); 438 List<Group> agr = cha.getAtomGroups(GroupType.AMINOACID); 439 List<Group> hgr = cha.getAtomGroups(GroupType.HETATM); 440 List<Group> ngr = cha.getAtomGroups(GroupType.NUCLEOTIDE); 441 442 443 444 445 str.append("chain ") 446 .append(j).append(": asymId:") 447 .append(cha.getId()) 448 .append(" authId:") 449 .append(cha.getName()).append(" "); 450 451 452 if ( cha.getEntityInfo() != null){ 453 EntityInfo comp = cha.getEntityInfo(); 454 String molName = comp.getDescription(); 455 if ( molName != null){ 456 str.append(molName); 457 } 458 String type = comp.getType().toString(); 459 str.append(" (") 460 .append(type) 461 .append(")"); 462 } 463 464 465 str.append(newline); 466 str.append(" length SEQRES: ").append(cha.getSeqResLength()); 467 str.append(" length ATOM: ").append(cha.getAtomLength()); 468 str.append(" aminos: ").append(agr.size()); 469 str.append(" hetatms: ").append(hgr.size()); 470 str.append(" nucleotides: ").append(ngr.size()).append(newline); 471 } 472 473 } 474 str.append("DBRefs: ").append(dbrefs.size()).append(newline); 475 for (DBRef dbref: dbrefs){ 476 str.append(dbref.toPDB()).append(newline); 477 } 478 str.append("Molecules: ").append(newline); 479 for (EntityInfo mol : entityInfos) { 480 str.append(mol).append(newline); 481 } 482 483 484 return str.toString() ; 485 } 486 487 @Override 488 public int size() { 489 int modelnr = 0 ; 490 491 if (!models.isEmpty()) { 492 return models.get(modelnr).getPolyChains().size(); 493 } 494 else { 495 return 0 ; 496 } 497 498 } 499 500 /** return number of chains of model. 501 * 502 */ 503 @Override 504 public int size(int modelnr) { return models.get(modelnr).size(); } 505 506 // some NMR stuff : 507 508 /** return number of models. */ 509 @Override 510 public int nrModels() { 511 return models.size() ; 512 } 513 514 /** 515 * Whether this Structure is a crystallographic structure or not. 516 * It will first check the experimental technique and if not present it will try 517 * to guess from the presence of a space group and sensible cell parameters 518 * 519 * @return true if crystallographic, false otherwise 520 */ 521 @Override 522 public boolean isCrystallographic() { 523 if (pdbHeader.getExperimentalTechniques()!=null) { 524 return ExperimentalTechnique.isCrystallographic(pdbHeader.getExperimentalTechniques()); 525 } else { 526 // no experimental technique known, we try to guess... 527 if (pdbHeader.getCrystallographicInfo().getSpaceGroup()!=null) { 528 // space group defined but no crystal cell: incomplete info, return false 529 return pdbHeader.getCrystallographicInfo().getCrystalCell() != null && 530 pdbHeader.getCrystallographicInfo().getCrystalCell().isCellReasonable(); 531 } 532 } 533 return false; 534 } 535 536 /** 537 * Whether this Structure is a NMR structure or not. 538 * It will first check the experimental technique and if not present it will try 539 * to guess from the presence of more than 1 model and from b-factors being 0 in first chain of first model 540 * @return true if NMR, false otherwise 541 */ 542 @Override 543 public boolean isNmr() { 544 545 // old implementation was: 546 //return nmrflag; 547 548 if (pdbHeader.getExperimentalTechniques()!=null) { 549 return ExperimentalTechnique.isNmr(pdbHeader.getExperimentalTechniques()); 550 } else { 551 // no experimental technique known, we try to guess... 552 if (nrModels()>1) { 553 if (pdbHeader.getCrystallographicInfo().getSpaceGroup()!=null) { 554 // multimodel, sg defined, but missing cell: must be NMR 555 if (pdbHeader.getCrystallographicInfo().getCrystalCell()==null) 556 return true; 557 // multi-model, sg defined and cell unreasonable: must be NMR 558 if (!pdbHeader.getCrystallographicInfo().getCrystalCell().isCellReasonable()) 559 return true; 560 } else { 561 // multi-model and missing space group: must be NMR 562 return true; 563 } 564 } 565 } 566 return false; 567 } 568 569 /** {@inheritDoc} */ 570 @Override 571 public List<Chain> getChains(int modelIdx){ 572 return getModel(modelIdx); 573 } 574 575 /** {@inheritDoc} */ 576 @Override 577 public List<Chain> getChains(){ 578 if (models.size()==0) { 579 return new ArrayList<>(0); 580 } 581 return getChains(0); 582 583 } 584 585 @Override 586 public List<Chain> getPolyChains() { 587 if (models.size()==0) { 588 return new ArrayList<>(0); 589 } 590 return getPolyChains(0); 591 } 592 593 @Override 594 public List<Chain> getPolyChains(int modelIdx) { 595 return models.get(modelIdx).getPolyChains(); 596 } 597 598 @Override 599 public List<Chain> getNonPolyChains() { 600 if (models.size()==0) { 601 return new ArrayList<>(0); 602 } 603 return getNonPolyChains(0); 604 } 605 606 @Override 607 public List<Chain> getNonPolyChains(int modelIdx) { 608 return models.get(modelIdx).getNonPolyChains(); 609 } 610 611 @Override 612 public List<Chain> getWaterChains() { 613 if (models.size()==0) { 614 return new ArrayList<>(0); 615 } 616 return getWaterChains(0); 617 } 618 619 @Override 620 public List<Chain> getWaterChains(int modelIdx) { 621 return models.get(modelIdx).getWaterChains(); 622 } 623 624 625 626 /** {@inheritDoc} */ 627 @Override 628 public void setChains(int modelnr, List<Chain> chains){ 629 for (Chain c: chains){ 630 c.setStructure(this); 631 } 632 if (models.size()>modelnr) { 633 models.remove(modelnr); 634 } 635 636 Model model = new Model(); 637 model.setChains(chains); 638 models.add(modelnr, model); 639 640 } 641 642 /** Retrieve all Chains belonging to a model . 643 * 644 * @param modelnr an int 645 * @return a List object 646 */ 647 @Override 648 public List<Chain> getModel(int modelnr) { 649 650 return models.get(modelnr).getChains(); 651 } 652 653 /** {@inheritDoc} */ 654 @Override 655 public Chain getChainByPDB(String authId, int modelnr) 656 throws StructureException{ 657 658 Chain c = getPolyChainByPDB(authId, modelnr); 659 660 if (c==null ) { 661 throw new StructureException("Could not find chain with authId \"" + authId + "\"" + " for PDB id " + pdb_id + ", model "+modelnr); 662 } 663 664 return c; 665 } 666 667 /** {@inheritDoc} */ 668 @Override 669 public Chain getChain(String asymId, int modelnr) { 670 671 List<Chain> chains = getChains(modelnr); 672 for (Chain c : chains) { 673 if (c.getId().equals(asymId)) { 674 return c; 675 } 676 } 677 return null; 678 679 } 680 681 /** {@inheritDoc} */ 682 @Override 683 public Chain getChain(String asymId) { 684 685 return getChain(asymId,0); 686 687 } 688 689 /** {@inheritDoc} */ 690 @Override 691 public Chain getChainByPDB(String chainId) 692 throws StructureException{ 693 if(nrModels() < 1 ) { 694 throw new StructureException("No chains are present."); 695 } 696 return getChainByPDB(chainId,0); 697 } 698 699 @Override 700 public Chain getPolyChain(String asymId) { 701 return getPolyChain(asymId, 0); 702 703 } 704 705 @Override 706 public Chain getPolyChain(String asymId, int modelIdx) { 707 Model model = models.get(modelIdx); 708 if (model==null) { 709 return null; 710 } 711 List<Chain> polyChains = model.getPolyChains(); 712 for (Chain c : polyChains){ 713 if (c.getId().equals(asymId)) 714 return c; 715 } 716 return null; 717 } 718 719 720 @Override 721 public Chain getNonPolyChain(String asymId) { 722 return getNonPolyChain(asymId, 0); 723 } 724 725 @Override 726 public Chain getNonPolyChain(String asymId, int modelIdx) { 727 Model model = models.get(modelIdx); 728 if (model==null) { 729 return null; 730 } 731 732 List<Chain> nonpolyChains = model.getNonPolyChains(); 733 for (Chain c : nonpolyChains){ 734 if (c.getId().equals(asymId)) 735 return c; 736 } 737 738 return null; 739 } 740 741 @Override 742 public Chain getPolyChainByPDB(String authId) { 743 return getPolyChainByPDB(authId, 0); 744 } 745 746 @Override 747 public Chain getPolyChainByPDB(String authId, int modelIdx) { 748 Model model = models.get(modelIdx); 749 if (model==null) { 750 return null; 751 } 752 753 List<Chain> polyChains = model.getPolyChains(); 754 for (Chain c : polyChains){ 755 if (c.getName().equals(authId)) 756 return c; 757 } 758 759 return null; 760 } 761 762 @Override 763 public List<Chain> getNonPolyChainsByPDB(String authId) { 764 return getNonPolyChainsByPDB(authId, 0); 765 } 766 767 @Override 768 public List<Chain> getNonPolyChainsByPDB(String authId, int modelIdx) { 769 List<Chain> chains = new ArrayList<>(); 770 Model model = models.get(modelIdx); 771 if (model==null) { 772 return chains; 773 } 774 775 776 List<Chain> nonpolyChains = model.getNonPolyChains(); 777 for (Chain c : nonpolyChains){ 778 if (c.getName().equals(authId)) 779 chains.add(c); 780 } 781 782 return chains; 783 } 784 785 @Override 786 public Chain getWaterChain(String asymId) { 787 return getWaterChain(asymId, 0); 788 } 789 790 791 @Override 792 public Chain getWaterChain(String asymId, int modelIdx) { 793 Model model = models.get(modelIdx); 794 if (model==null) { 795 return null; 796 } 797 List<Chain> waterChains = model.getWaterChains(); 798 for (Chain c : waterChains){ 799 if (c.getId().equals(asymId)) 800 return c; 801 } 802 return null; 803 } 804 805 806 @Override 807 public Chain getWaterChainByPDB(String authId) { 808 return getWaterChainByPDB(authId, 0); 809 } 810 811 812 @Override 813 public Chain getWaterChainByPDB(String authId, int modelIdx) { 814 Model model = models.get(modelIdx); 815 if (model==null) { 816 return null; 817 } 818 List<Chain> waterChains = model.getWaterChains(); 819 for (Chain c : waterChains){ 820 if (c.getName().equals(authId)) 821 return c; 822 } 823 824 return null; 825 } 826 827 828 829 /** {@inheritDoc} */ 830 @Override 831 public String toPDB() { 832 FileConvert f = new FileConvert(this) ; 833 return f.toPDB(); 834 } 835 836 /** {@inheritDoc} */ 837 @Override 838 public String toMMCIF() { 839 FileConvert f = new FileConvert(this); 840 return f.toMMCIF(); 841 } 842 843 /** {@inheritDoc} */ 844 @Override 845 public boolean hasChain(String authId) { 846 int modelnr = 0; 847 848 List<Chain> chains = getChains(modelnr); 849 for (Chain c : chains) { 850 // we check here with equals because we might want to distinguish between upper and lower case chains! 851 if (c.getId().equals(authId)) { 852 return true; 853 } 854 } 855 return false; 856 } 857 858 /** {@inheritDoc} */ 859 @Override 860 public boolean hasNonPolyChain(String asymId){ 861 int modelnr = 0; 862 863 List<Chain> chains = models.get(modelnr).getNonPolyChains(); 864 for (Chain c : chains) { 865 // we check here with equals because we might want to distinguish between upper and lower case chains! 866 if (c.getId().equals(asymId)) { 867 return true; 868 } 869 } 870 return false; 871 } 872 873 /** {@inheritDoc} */ 874 @Override 875 public boolean hasPdbChain(String authId) { 876 int modelnr = 0; 877 878 List<Chain> chains = getChains(modelnr); 879 for (Chain c : chains) { 880 // we check here with equals because we might want to distinguish between upper and lower case chains! 881 if (c.getName().equals(authId)) { 882 return true; 883 } 884 } 885 return false; 886 } 887 888 /** {@inheritDoc} */ 889 @Override 890 public void setEntityInfos(List<EntityInfo> molList){ 891 this.entityInfos = molList; 892 } 893 894 /** {@inheritDoc} */ 895 @Override 896 public void addEntityInfo(EntityInfo entityInfo) { 897 this.entityInfos.add(entityInfo); 898 } 899 900 /** {@inheritDoc} */ 901 @Override 902 public List<EntityInfo> getEntityInfos() { 903 return entityInfos; 904 } 905 906 /** {@inheritDoc} */ 907 @Override 908 public EntityInfo getCompoundById(int molId) { 909 return getEntityById(molId); 910 } 911 912 /** {@inheritDoc} */ 913 @Override 914 public EntityInfo getEntityById(int entityId) { 915 for (EntityInfo mol : this.entityInfos){ 916 if (mol.getMolId()==entityId){ 917 return mol; 918 } 919 } 920 return null; 921 } 922 923 924 /** {@inheritDoc} */ 925 @Override 926 public List<DBRef> getDBRefs() { 927 return dbrefs; 928 } 929 930 931 /** {@inheritDoc} */ 932 @Override 933 public void setDBRefs(List<DBRef> dbrefs) { 934 if ( dbrefs == null) 935 throw new IllegalArgumentException("trying to set dbrefs to null!"); 936 937 for( DBRef ref : dbrefs){ 938 ref.setParent(this); 939 } 940 this.dbrefs = dbrefs; 941 } 942 943 944 /** {@inheritDoc} */ 945 @Override 946 public PDBHeader getPDBHeader() { 947 return pdbHeader; 948 } 949 950 /** {@inheritDoc} */ 951 @Override 952 public void setPDBHeader(PDBHeader pdbHeader){ 953 this.pdbHeader = pdbHeader; 954 } 955 956 /** {@inheritDoc} */ 957 @Override 958 public List<Bond> getSSBonds(){ 959 return ssbonds; 960 961 } 962 963 /** {@inheritDoc} */ 964 @Override 965 public void setSSBonds(List<Bond> ssbonds){ 966 this.ssbonds = ssbonds; 967 } 968 969 /** 970 * Adds a single disulfide Bond to this structure 971 * 972 * @param ssbond the SSBond. 973 */ 974 @Override 975 public void addSSBond(Bond ssbond){ 976 ssbonds.add(ssbond); 977 } 978 979 /** 980 * Return whether or not the entry has an associated journal article 981 * or publication. The JRNL section is not mandatory and thus may not be 982 * present. 983 * @return flag if a JournalArticle could be found. 984 */ 985 @Override 986 public boolean hasJournalArticle() { 987 return this.pdbHeader.hasJournalArticle(); 988 } 989 990 /** 991 * get the associated publication as defined by the JRNL records in a PDB 992 * file. 993 * @return a JournalArticle 994 */ 995 @Override 996 public JournalArticle getJournalArticle() { 997 return this.pdbHeader.getJournalArticle(); 998 } 999 1000 /** 1001 * set the associated publication as defined by the JRNL records in a PDB 1002 * file. 1003 * @param journalArticle the article 1004 */ 1005 @Override 1006 public void setJournalArticle(JournalArticle journalArticle) { 1007 this.pdbHeader.setJournalArticle(journalArticle); 1008 } 1009 1010 /** 1011 * @return the sites contained in this structure 1012 */ 1013 1014 @Override 1015 public List<Site> getSites() { 1016 return sites; 1017 } 1018 1019 /** 1020 * @param sites the sites to set in the structure 1021 */ 1022 1023 @Override 1024 public void setSites(List<Site> sites) { 1025 this.sites = sites; 1026 } 1027 1028 /** Caution: we should probably remove this to avoid confusion. Currently this is always an empty list! 1029 * 1030 * @return a list of Groups listed in the HET records - this will not 1031 * include any waters. 1032 */ 1033 1034 /** 1035 * Sets a flag to indicate if this structure is a biological assembly 1036 * @param biologicalAssembly true if biological assembly, otherwise false 1037 * @since 3.2 1038 */ 1039 @Override 1040 public void setBiologicalAssembly(boolean biologicalAssembly) { 1041 this.biologicalAssembly = biologicalAssembly; 1042 } 1043 1044 /** 1045 * Gets flag that indicates if this structure is a biological assembly 1046 * @return the sites contained in this structure 1047 * @since 3.2 1048 */ 1049 @Override 1050 public boolean isBiologicalAssembly() { 1051 return biologicalAssembly; 1052 } 1053 1054 /** 1055 * Sets crystallographic information for this structure 1056 * @param crystallographicInfo crystallographic information 1057 * @since 3.2 1058 */ 1059 1060 @Override 1061 public void setCrystallographicInfo(PDBCrystallographicInfo crystallographicInfo) { 1062 this.pdbHeader.setCrystallographicInfo(crystallographicInfo); 1063 } 1064 1065 /** 1066 * Gets crystallographic information for this structure 1067 * @return PDBCrystallographicInfo crystallographic information 1068 * @since 3.2 1069 */ 1070 @Override 1071 public PDBCrystallographicInfo getCrystallographicInfo() { 1072 return pdbHeader.getCrystallographicInfo(); 1073 } 1074 1075 /** {@inheritDoc} */ 1076 @Override 1077 public String getIdentifier() { 1078 //1. StructureIdentifier 1079 if(getStructureIdentifier() != null) { 1080 return getStructureIdentifier().getIdentifier(); 1081 } 1082 //2. Name 1083 if(getName() != null) { 1084 return getName(); 1085 } 1086 //3. PDBCode + ranges 1087 return toCanonical().getIdentifier(); 1088 } 1089 1090 /** {@inheritDoc} */ 1091 @Deprecated 1092 @Override 1093 public String getPdbId() { 1094 return pdb_id; 1095 } 1096 1097 /** {@inheritDoc} */ 1098 @Override 1099 public void resetModels() { 1100 models = new ArrayList<>(); 1101 } 1102 /** {@inheritDoc} */ 1103 @Deprecated 1104 @Override 1105 public List<ResidueRange> getResidueRanges() { 1106 return toCanonical().getResidueRanges(); 1107 } 1108 /** {@inheritDoc} */ 1109 @Deprecated 1110 @Override 1111 public List<String> getRanges() { 1112 return ResidueRange.toStrings(getResidueRanges()); 1113 } 1114 1115 /** 1116 * Creates a SubstructureIdentifier based on the residues in this Structure. 1117 * 1118 * Only the first and last residues of each chain are considered, so chains 1119 * with gaps 1120 * @return A {@link SubstructureIdentifier} with residue ranges constructed from each chain 1121 */ 1122 private SubstructureIdentifier toCanonical() { 1123 StructureIdentifier real = getStructureIdentifier(); 1124 if(real != null) { 1125 try { 1126 return real.toCanonical(); 1127 } catch (StructureException e) { 1128 // generate fake one if needed 1129 } 1130 } 1131 1132 // No identifier set, so generate based on residues present in the structure 1133 List<ResidueRange> range = new ArrayList<>(); 1134 for (Chain chain : getChains()) { 1135 List<Group> groups = chain.getAtomGroups(); 1136 ListIterator<Group> groupsIt = groups.listIterator(); 1137 if(!groupsIt.hasNext()) { 1138 continue; // no groups in chain 1139 } 1140 Group g = groupsIt.next(); 1141 ResidueNumber first = g.getResidueNumber(); 1142 1143 //TODO Detect missing intermediate residues -sbliven, 2015-01-28 1144 //Already better than previous whole-chain representation 1145 1146 // get last residue 1147 while(groupsIt.hasNext()) { 1148 g = groupsIt.next(); 1149 } 1150 ResidueNumber last = g.getResidueNumber(); 1151 1152 range.add(new ResidueRange(chain.getName(),first,last)); 1153 } 1154 return new SubstructureIdentifier(getPDBCode(),range); 1155 } 1156 1157 1158 1159 1160 1161}