---

BaseMolecule.h

Go to the documentation of this file.

/***************************************************************************
 *cr                                                                       
 *cr            (C) Copyright 1995-2008 The Board of Trustees of the           
 *cr                        University of Illinois                       
 *cr                         All Rights Reserved                        
 *cr                                                                   
 ***************************************************************************/

/***************************************************************************
 * RCS INFORMATION:
 *
 *      $RCSfile: BaseMolecule.h,v $
 *      $Author: johns $        $Locker:  $             $State: Exp $
 *      $Revision: 1.116 $      $Date: 2008/04/28 21:49:31 $
 *
 ***************************************************************************
 * DESCRIPTION:
 *
 * Base class for all molecules, without display-specific information.  This
 * portion of a molecule contains the structural data, and all routines to
 * find the structure (backbone, residues, etc).  It contains the
 * animation list as well.
 *
 ***************************************************************************/
#ifndef BASEMOLECULE_H
#define BASEMOLECULE_H

#ifndef NAMELIST_TEMPLATE_H
#include "NameList.h"
#endif
#ifndef RESIZEARRAY_TEMPLATE_H
#include "ResizeArray.h"
#endif
#include "Atom.h"
#include "Residue.h"
#include "Timestep.h"
#include "Fragment.h"
#include "intstack.h"

#ifdef VMDWITHCARBS
#include <vector>
#include "SmallRing.h"
#include "SmallRingLinkages.h"
#include "inthash.h"
#endif

#if 0
#define VMDFASTRIBBONS
#endif

class VolumetricData;

class BaseMolecule {
public:
  //
  // public molecular structure data (for ease of access):
  //
  int nAtoms;                         
  int nResidues;                      
  int nWaters;                        
  int nSegments;                      
  int nFragments;                     
  int nProteinFragments;              
  int nNucleicFragments;              

  NameList<int> atomNames;            
  NameList<int> atomTypes;            
  NameList<int> resNames;             
  NameList<int> chainNames;           
  NameList<int> segNames;             
  NameList<int> altlocNames;          

  ResizeArray<Residue *> residueList; 
  ResizeArray<Fragment *> fragList;   

  ResizeArray<Fragment *> pfragList;  

  ResizeArray<int> pfragCyclic;       
#if defined(VMDFASTRIBBONS)
  ResizeArray<int *> pfragCPList;     

#endif


  ResizeArray<Fragment *> nfragList;  
  ResizeArray<int> nfragCyclic;       
#if defined(VMDFASTRIBBONS)
  ResizeArray<int *> nfragCPList;     

#endif

#ifdef VMDWITHCARBS
  ResizeArray<SmallRing *> smallringList; 

  SmallRingLinkages smallringLinkages; 
  int currentMaxRingSize;             
  int currentMaxPathLength;           
#endif


  // Extra floating-point data for each atom.
  // If the name is unassigned then the values can be taken to be zero.
  NameList<float *> extra;

  // Interface to standard extra data.  These will exist and be initialized
  // to zero when init_atoms is called.
  float *radius() { return extra.data("radius"); }
  float *mass() { return extra.data("mass");   }
  float *charge() { return extra.data("charge"); }
  float *beta() { return extra.data("beta");   }
  float *occupancy() { return extra.data("occupancy"); }

  float *bondorders() { return extra.data("bondorders"); }
  void setbondorder(int atom, int bond, float order);
  float getbondorder(int atom, int bond);

  int has_structure() const { return cur_atom > 0; }

  void clear_bonds(void);

  int count_bonds(void);

#ifdef VMDWITHCARBS

  void find_small_rings_and_links(int maxpathlength, int maxringsize);
#endif

private:
  const int ID;          

  //
  // molecular structure data:
  //
  int cur_atom;          
  MolAtom *atomList;     
  int lastbonderratomid; 
  int bonderrorcount;    
 
  //
  // routines to determine components of molecular structure
  //
 
  int find_backbone(void);

  // find the residues in the molecule; return number found.
  // I look for atoms with the same resid connected to 
  // backbone atoms with the same resid (find enough backbone
  // atoms, then find atoms connected to them)
  int find_connected_backbone(IntStackHandle, int, int, int, int, int *);
  void clean_up_connection(IntStackHandle, int, int, int *);
  void find_connected_atoms_in_resid(IntStackHandle, int, int, 
     int, int, int *);
  void find_and_mark(int, int, int,
     int *, int *);
  int make_uniq_resids(int *flgs); 

  int find_residues(void);
  
  // This should take place after find_residues to keep
  // from mistaking a protein resname as a water resname, maybe
  void find_connected_waters(int i, char *tmp);
  int find_connected_waters2(void);

  int find_waters(void);

  void find_connected_residues(int num_residues);
  
  int find_segments(void) { return segNames.num(); }
  
  int find_connected_fragments();

  int find_fragments(void);

  void find_subfragments_cyclic(ResizeArray<Fragment *> *subfragList, int restype);  
  void find_cyclic_subfragments(ResizeArray<Fragment *> *subfragList, ResizeArray<int> *subfragCyclic);
 
  void find_connected_subfragment(int resnum, int fragnum, char *flgs, 
         int endatom, int altendatom, int alt2endatom, int alt3endatom,
         int restype, 
         ResizeArray<Fragment *> *subfragList);

  void find_subfragments(int startatom, int altstartatom, int alt2startatom,
    int endatom, int altendatom, int alt2endatom, int alt3endatom,
    int restype, ResizeArray<Fragment *> *subfragList);

  void find_subfragments_topologically(int restype, ResizeArray<Fragment *> *subfragList, int endatom, int altendatom, int alt2endatom, int alt3endatom);

#if defined(VMDFASTRIBBONS)
  void calculate_ribbon_controlpoints();
#endif

#ifdef VMDWITHCARBS

   int find_small_rings(int maxringsize);
   int find_back_edges(ResizeArray<int> &back_edge_src, ResizeArray<int> &back_edge_dest);
   int find_connected_subgraph_back_edges(int atomid, ResizeArray<int> &back_edge_src, ResizeArray<int> &back_edge_dest,
                                          int *intree_parents);
   int find_small_rings_from_back_edges(int maxringsize, ResizeArray<int> &back_edge_src, ResizeArray<int> &back_edge_dest);
   int find_small_rings_from_partial(SmallRing *ring, int maxringsize, inthash_t *used_edges, inthash_t *used_atoms);
   int get_edge_key(int edge_src, int edge_dest);
   
   // orientate small rings
   void orientate_small_rings(int maxringsize);
   void orientate_small_ring(SmallRing &ring,int maxringsize);
   
   // find links between small rings
   int find_orientated_small_ring_linkages(int maxpathlength,int maxringsize);
   int find_linkages_for_ring_from_partial(LinkagePath &lp, int maxpathlength, inthash_t *atom_to_ring, inthash_t *multi_ring_atoms, inthash_t *used_atoms);
#endif


protected:
  char *moleculename;  
  int need_find_bonds; 

public:
  // constructor; just sets most things to null.  Derived classes must put
  // in structure in 'create' routine.  Typical sequence of creating a
  // molecule should be:
  //    mol = new Molecule(....)
  //    ( specify parameters for creation )
  //    mol->create();  ... return success
  //    mol->analyze(); ... find information about the structure
  BaseMolecule(int);      
  virtual ~BaseMolecule(void); 

  //
  // routines to develop molecular structure
  //
  
  int init_atoms(int n); 

  void find_bonds_from_timestep() { need_find_bonds = 1; }
  void find_unique_bonds_from_timestep() { need_find_bonds = 2; }

  int add_atom(char *name, char *type, int atomicnumber, 
               char *resname, int resid,
               const char *chainid,const char *segname,
               char *insertion = (char *) " ", const char *altloc = "");

  int add_bond(int, int, float, int = ATOMNORMAL);

  int add_bond_dupcheck(int, int, float);
 
  // (By this time, the molecule is on the MoleculeList!)
  void analyze(void);

  //
  // query info about the molecule
  //
  int id(void) const { return ID; } 
  const char *molname() const {return moleculename; } 

  // Return the Nth atom, residue, and fragment.  All assume correct index 
  // and that the structure has been initialized (for speed).
  MolAtom *atom(int n) { return atomList+n; } 
  Residue *residue(int);                      
  Fragment *fragment(int);                    

  // return the residue or fragment in which the given atom is located.
  Residue *atom_residue(int);       
  Fragment *atom_fragment(int);     


  int find_atom_in_residue(int atomnameindex, int residue) {
    const ResizeArray<int> &atoms = residueList[residue]->atoms;
    int num = atoms.num();
    for (int i=0; i<num; i++) {
      if (atom(atoms[i])->nameindex == atomnameindex) return atoms[i];
    }
    return -3;
  }

  int find_atom_in_residue(const char *atomname, int residue);


  float default_charge(char *);
  float default_mass(char *);
  float default_radius(char *);
  float default_occup(void) { return 1.0; }
  float default_beta(void) { return 0.0; }

  void add_volume_data(const char *name, const float *o, 
    const float *xa, const float *ya, const float *za, int x, int y, int z,
    float *voldata); 

  int num_volume_data(); 
  const VolumetricData *get_volume_data(int); 
  void compute_volume_gradient(VolumetricData *);  

protected:
  ResizeArray<VolumetricData *>volumeList;    
};

// Hydrogen atom name detection macro
#define IS_HYDROGEN(s) (s[0] == 'H' || (isdigit(s[0]) && s[1] == 'H' ))

#endif

---