soapchem.msd

//--------------------------------
// soapchem.msd
//
// Project: PDBe API Framework, EBI 
// Module: SOAP compatible Class Hirarchy of PDBe Data Structure
// for PDBe API Framework 
//
// SOAP User Layer
// Last updated: 25 February 2004 10:17
// (C) Siamak Sobhany
//--------------------------------

// SOAP compatible Class Hirarchy of PDBe Data Structure:
// 
// PDBe Definitions: 
//  Groups
//   A Group of Assemblies is defined as a family of structures/sequence that can be aligned 
//   together. Since alignment is based on the chain structure/sequence of the molecules it is 
//   possible to have multiple groups with the same membership by combination of the different 
//   chains within a set of molecules. 
//  
//  Assembly
//   The Assembly is our name for the biological reconstruction of a molecule and is often 
//   different from the flat PDB file. Experimental procedures that generate atomic coordinates 
//   produce correct experimental representations of that molecule. For X-ray this is the 
//   asymmetric unit, and for NMR this means multiple solutions. A program PQS is run on these 
//   PDB files that identifies a single or a small number of ambiguous compact molecules that are 
//   sensible guestimates of biological molecules. These can be matched to the physio-chemical 
//   properties of these molecules such as the sedimentation coefficient. Although we provide a 
//   link to download the original PDB flat file from our Atlas pages, all of our search, 
//   sites and visualization is based on the assembly construction and therefore the biological 
//   context.
//  
//  Chain
//   We define a chain in a macromolecule as a polymer of residues that does not have connectivity 
//   breaks, and contains at least 3 residues. 
//  
//  Residue
//   A residue is a monomer unit that can form a polymer chain, or a discrete group of atoms that 
//   forms a chemical entity. For example, alanine, cytosine, water and adenosine triphosphate.
//  
//  Atom
//   The basic "indivisible" unit which has a single coordinate in 3D.
//   
//   
//   





class ns__CHetCompound  {

  public :

    xsd__string  hetID;      // Het identifiers, right-justified
    xsd__string     comment;
    int      nSynonyms;
    struct StrVec hetSynonym; // synonyms
    int      compNum;    // component number
    char     wc;         // '*' for water, otherwise space
    xsd__string     Formula;    // formulas

    ns__CHetCompound ();
        ns__CHetCompound ( xsd__string HetName );
   
    ~ns__CHetCompound();

  
};
//  ====================  CHetCompounds  =======================

class ns__CHetCompounds: public ns__CHetCompound {
  public :
    ns__CHetCompound ** __ptr;
    int __size;
  //int            nHets;
    //ns__CHetCompound ** hetCompound;
    ns__CHetCompounds ();
    ~ns__CHetCompounds();
        virtual ns__CHetCompound*& operator[](int i);
  protected :
    xsd__boolean Closed;
};



class ns__CHelix   {
  public :
    int     serNum;      // serial number
    xsd__string helixID;     // helix ID
    xsd__string initResName; // name of the helix's initial residue
    xsd__string initChainID; // chain ID for the chain containing the helix
    int     initSeqNum;  // sequence number of the initial residue
    xsd__string initICode;   // insertion code of the initial residue
    xsd__string endResName;  // name of the helix's terminal residue
    xsd__string endChainID;  // chain ID for the chain containing the helix
    int     endSeqNum;   // sequence number of the terminal residue
    xsd__string endICode;    // insertion code of the terminal residue
    int     helixClass;  // helix class
    xsd__string    comment;     // comment about the helix
    int     length;      // length of the helix
    ns__CHelix ();
    ns__CHelix ( xsd__string S );
    ~ns__CHelix();
};



//  ====================  CStrand  ============================
class ns__CStrand   {

  public :

    xsd__string sheetID;     // sheet ID
    int      strandNo;    // strand number
    xsd__string  initResName; // name of the strand's initial residue
    xsd__string  initChainID; // chain ID of initial residue in the strand
    int      initSeqNum;  // sequence number of the initial residue
    xsd__string  initICode;   // insertion code of the initial residue
    xsd__string  endResName;  // name of the strand's terminal residue
    xsd__string  endChainID;  // chain ID of terminal residue in the strand
    int      endSeqNum;   // sequence number of the terminal residue
    xsd__string  endICode;    // insertion code of the terminal residue
    int      sense;       // sense of strand with respect to previous strand
    xsd__string curAtom;     // registration; atom name in current strand
    xsd__string  curResName;  // registration; residue name in current strand
    xsd__string  curChainID;  // registration; chain ID in current strand
    int      curResSeq;   // registration; res-e seq numb in current strand
    xsd__string  curICode;    // registration; ins code in current strand
    xsd__string prevAtom;    // registration; atom name in previous strand
    xsd__string  prevResName; // registration; residue name in previous strand
    xsd__string  prevChainID; // registration; chain ID in previous strand
    int      prevResSeq;  // registration; res-e seq numb in previous strand
    xsd__string  prevICode;   // registration; ins code in previous strand

    ns__CStrand ();
   
    ~ns__CStrand();

};

//====================== array of CStrands ============================
class ns__CStrands:  public ns__CStrand {
  public :
    ns__CStrand ** __ptr;    //pointer to array of pointers to ns__CStrands // array of strands
    int __size;
    ns__CStrands ();
    ~ns__CStrands();
        virtual ns__CStrand*& operator[](int i);

};


//  ====================  CSheet  ============================




class ns__CSheet  {

  public :

    xsd__string   sheetID;   // sheet ID
    int       nStrands;  // number of strands in the sheet
    ns__CStrands Strand;    // array of strands

    ns__CSheet ();
    
    ~ns__CSheet();

};


//  ====================  array of CSheets  ============================

class ns__CSheets: public ns__CSheet {

  public :
    ns__CSheet ** __ptr;
    int __size;
  //int      nSheets;
    //ns__CSheet ** Sheet;

    ns__CSheets ();
   
    ~ns__CSheets();
        virtual ns__CSheet*& operator[](int i);

};


//  ====================  CTurn  ============================

class ns__CTurn  {

  public :
    int     serNum;      // serial number
    xsd__string  turnID;      // turn ID
    xsd__string initResName; // name of the turn's initial residue
    xsd__string initChainID; // chain ID for the chain containing the turn
    int     initSeqNum;  // sequence number of the initial residue
    xsd__string initICode;   // insertion code of the initial residue
    xsd__string endResName;  // name of the turn's terminal residue
    xsd__string endChainID;  // chain ID for the chain containing the turn
    int     endSeqNum;   // sequence number of the terminal residue
    xsd__string endICode;    // insertion code of the terminal residue
    xsd__string    comment;     // comment about the helix

    ns__CTurn ();
    ns__CTurn ( xsd__string S );
  
    ~ns__CTurn();

};






class ns__CChain;

class ns__CChainContainer   {

  public :

    ns__CChainContainer  ();
   
     
    ~ns__CChainContainer ();

  

  protected :
    ns__CChain * Chain;

};




//  ==================  CSeqRes  ========================

class ns__CSeqRes  {


  public :
 
    int       numRes;   // number of residues in the chain
    struct StrVec  resName;  // residue names
    
    ns__CSeqRes ();
    
    ~ns__CSeqRes();

  protected :
    ns__CChain * Chain;
    xsd__string chainID;
    int     serNum;


};

struct ns__SAtomStat  {

  public :
    int       nAtoms;          // number of atoms in statistics

    xsd__double  xmin,ymin,zmin;  // minimums of coordinates
    xsd__double  xmax,ymax,zmax;  // maximums of coordinates
    xsd__double  xm  ,ym  ,zm;    // mediums  of coordinates
    xsd__double  xm2 ,ym2 ,zm2;   // square mediums of coordinates

    xsd__double  occ_min,occ_max; // minimum/maximum occupancy
    xsd__double  occ_m  ,occ_m2;  // medium and square medium occupancy

    xsd__double  tFmin,tFmax;     // minimum/maximum temperature factor
    xsd__double  tFm  ,tFm2;      // medium and sq. med. temperature factor

    xsd__double  u11_min,u11_max; // minimums and
    xsd__double  u22_min,u22_max; //   maximums of
    xsd__double  u33_min,u33_max; //     anisotropic
    xsd__double  u12_min,u12_max; //       temperature
    xsd__double  u13_min,u13_max; //         factors
    xsd__double  u23_min,u23_max;

    xsd__double  u11_m,u11_m2;    // mediums and
    xsd__double  u22_m,u22_m2;    //   square mediums of
    xsd__double  u33_m,u33_m2;    //     anisotropic
    xsd__double  u12_m,u12_m2;    //       temperature
    xsd__double  u13_m,u13_m2;    //         factors
    xsd__double  u23_m,u23_m2;

    xsd__unsignedInt      WhatIsSet;       //   mask field

    //void  Init  ();
    //void  Finish();

  private : 
    xsd__boolean finished;

};

struct ns__SAtomBondI  {
  int  index;  // bonded atom index
  xsd__unsignedByte order;  // bond order
};



class ns__CResidue;


class ns__CAtom   {

  public :

    int       serNum;         // serial number
    xsd__string  name;           // atom name (ALIGNED)
    xsd__string    altLoc;         // alternate location indicator ("" for none)
    ns__CResidue * residue;        // reference to residue
    xsd__double  x,y,z;          // orthogonal coordinates in angstroms
    xsd__double  occupancy;      // occupancy
    xsd__double  tempFactor;     // temperature factor
    xsd__string     segID;          // segment identifier
    xsd__string   element;        // element symbol (ALIGNED)
    xsd__string  charge;         // charge on the atom
    xsd__double  sigX,sigY,sigZ; // standard deviations of the stored coords
    xsd__double  sigOcc;         // standard deviation of occupancy
    xsd__double  sigTemp;        // standard deviation of temperature factor
    xsd__double  u11,u22,u33;    // anisotropic temperature
    xsd__double  u12,u13,u23;    //    factors
    xsd__double  su11,su22,su33; // standard deviations of
    xsd__double  su12,su13,su23; //    anisotropic temperature factors
    xsd__boolean   Het;            // indicator of atom within non-standard groups
    xsd__boolean   Ter;            // chain terminator

    xsd__unsignedInt      WhatIsSet;      //   mask      field
                              //  0x0001   atomic coordinates
                              //  0x0002   occupancy
                              //  0x0004   temperature factor
                              //  0x0010   coordinate standard deviations
                              //  0x0020   deviation of occupancy
                              //  0x0040   deviation of temperature factor
                              //  0x0100   anisotropic temperature factors
                              //  0x1000   anis. temp. fact-s st-d deviations

    
        
  int props;
 
        ns__CAtom ();
    
    ~ns__CAtom();


  protected:
    int m_nId, m_nSiteId, m_nSupChemId;
    // hydrogen bond caracteristics 
    int m_nDonorAcceptor;
     int m_nDonorHybridisation, m_nAcceptorHybridisation;
    int         index;   // index in the file
    int         nBonds;  // number of bonds in the lowest byte (!)
    struct ns__SAtomBondI * Bond;    // atom bonds

   
};
//======================== Array of CAtoms ============================
class ns__CAtoms:  public ns__CAtom  {

  public :

   ns__CAtom ** __ptr;
   int __size;
    
    ns__CAtoms();
    
    ~ns__CAtoms();
    virtual ns__CAtom*& operator[](int i);
  
};

struct ns__SAtomBond  {
  ns__CAtom * atom;  // bonded atom pointer
  xsd__unsignedByte  order;  // bond order
};




//  ======================  CResidue  ==========================

//#define ALF_NoAltCodes    0x00000000
//#define ALF_EmptyAltLoc   0x00000001
//#define ALF_NoEmptyAltLoc 0x00000002
//#define ALF_Mess          0x00000004
//#define ALF_Occupancy     0x00000008
//
//#define SSE_None          0
//#define SSE_Strand        1
//#define SSE_Bulge         2
//#define SSE_3Turn         3
//#define SSE_4Turn         4
//#define SSE_5Turn         5
//#define SSE_Helix         6
//



class ns__CResidue   {
 
  public :

    xsd__string  name;     // residue name - all spaces cut
    int      seqNum;   // residue sequence number
    xsd__string  insCode;  // residue insertion code
    ns__CChain * chain;    // reference to chain
    int      index;    // index in the chain
    int      nAtoms;   // number of atoms in the residue
    ns__CAtoms  atom;     // array of atoms
    xsd__unsignedByte     SSE;      // SSE type
    
    ns__CResidue ();
    
    ~ns__CResidue();

   

  protected:
  int m_nId;
  int m_nSupChemCompId;
  int m_nAssemblyId;
  xsd__boolean m_bIsHet;

    int      AtmLen;   // length of atom array
    xsd__boolean  Exclude;  // used internally
    
   
};

class ns__CListResidue : public ns__CResidue
{  
 public:
 ns__CListResidue();
 virtual ~ns__CListResidue();
  
  ns__CListResidue* m_pPrev;
};


//==================== Array of CResidues =========================
class ns__CResidues:  public ns__CResidue  {

  public :

   ns__CResidue ** __ptr;
   int __size;
    
    ns__CResidues ();
    
    ~ns__CResidues();
    virtual ns__CResidue*& operator[](int i);
  
};






//  =================  CChain  =======================



class ns__CChain   {
   
  public :

    ns__CChainContainer DBReference; // database reference
    ns__CChainContainer SeqAdv;      // SEQADV records
    ns__CSeqRes         SeqRes;      // Sequence residues, SEQRES records
    ns__CChainContainer ModRes;      // modification descriptions
    ns__CChainContainer Het;         // non-standard residues descriptions

    ns__CChain ();  // SetModel() MUST be used after this constructor!
   
    ~ns__CChain();

   
  protected :

    xsd__string         chainID;     // chain ID
    xsd__string         prevChainID; // if chain is renamed, its original
                                 // name may be saved here.
    //ns__CProModel  *    model;       // pointer to model class

    int             nWeights;    // used externally for sorting
    xsd__double        Weight;      // the chains

    int             nResidues;   // number of residues
    ns__CResidues    Residue;     // array of residues

    xsd__boolean         Exclude;     // used internally
    int m_nId;
    xsd__string  m_szType;
    xsd__boolean m_bIsProtein;
    xsd__boolean m_bIsNucleoAcid;
  

  private :
    int  ResLen;      // length of Residue array

};


class ns__CListChain : public ns__CChain
{  
 public:
  ns__CListChain();
  virtual ~ns__CListChain();
  ns__CListChain* m_pPrev;
};



//======================== array of CChains =================================
class ns__CChains:  public ns__CChain  {

  public :

   ns__CChain ** __ptr;
   int __size;
    
    ns__CChains ();
    
    ~ns__CChains();
    virtual ns__CChain*& operator[](int i);
  
};



class ns__CAssembly;

 // Presents a chain associated with an assembly
 // it presents chain and applied matrix (offset plus symmetry operation)
 //
class ns__CChainAssembly
{
 
 public:
  //**
  // * Empty constructor
  // */
  ns__CChainAssembly();
  ~ns__CChainAssembly();
  //**
  // * Constructor
  // * @param pAssembly pointer to CDBAssembly
  // * @param nId integer database id of the chain inside the assembly (chain_id from warehouse or DGAC_ID from deposition db)
  // * @param nSymOpId integer database id of the symmetry operation (RSE_ID from warehouse or depostion DB)
  // * @param nChainId integer database id of the chain (chain_id from warebouse or DEP_CHAIN_ID from depostion DB)
  // * @param t11 double parameter of the transformation matrix
  // * @param t12 double parameter of the transformation matrix
  // * @param t13 double parameter of the transformation matrix
  // * @param t14 double parameter of the transformation matrix
  // * @param t21 double parameter of the transformation matrix
  // * @param t22 double parameter of the transformation matrix
  // * @param t23 double parameter of the transformation matrix
  // * @param t24 double parameter of the transformation matrix
  // * @param t31 double parameter of the transformation matrix
  // * @param t32 double parameter of the transformation matrix
  // * @param t33 double parameter of the transformation matrix
  // * @param t34 double parameter of the transformation matrix
  // */
  protected:
  t__rmat m_T;
  int m_nId;
  int m_nSymOpId;
  int m_nChainId;
  ns__CAssembly* m_pAssembly; // reference to assembly
  
};

//**
// * Presents a connected list of CDBChainAssembly 
// */
class ns__CListChainAssembly : public ns__CChainAssembly
{  
 public:
  //**
  // * Constructor
  // * @param pAssembly pointer to CDBAssembly
  // * @param nId integer database id of the chain inside the assembly (chain_id from warehouse or DGAC_ID from deposition db)
  // * @param nSymOpId integer database id of the symmetry operation (RSE_ID from warehouse or depostion DB)
  // * @param nChainId integer database id of the chain (chain_id from warebouse or DEP_CHAIN_ID from depostion DB)
  // * @param t11 double parameter of the transformation matrix
  // * @param t12 double parameter of the transformation matrix
  // * @param t13 double parameter of the transformation matrix
  // * @param t14 double parameter of the transformation matrix
  // * @param t21 double parameter of the transformation matrix
  // * @param t22 double parameter of the transformation matrix
  // * @param t23 double parameter of the transformation matrix
  // * @param t24 double parameter of the transformation matrix
  // * @param t31 double parameter of the transformation matrix
  // * @param t32 double parameter of the transformation matrix
  // * @param t33 double parameter of the transformation matrix
  // * @param t34 double parameter of the transformation matrix
  // * @param pPrev pointer to the previous CDBListChainAssembly in the list
  // */
  ns__CListChainAssembly();
  virtual ~ns__CListChainAssembly();
  ns__CListChainAssembly* m_pPrev;
};


// * Cell in 3D space (unit cell system)
// */
struct ns__SCell 
{
  int m_nX;
  int m_nY;
  int m_nZ;
//####  ns__SCell() : m_nX(0), m_nY(0), m_nZ(0) {}
//####  SCell(int nx, int ny, int nz) 
//####  {
//####    m_nX = nx;
//####    m_nY = ny;
//####    m_nZ = nz;
//####  }
//####  void Set(int nx, int ny, int nz) 
//####  {
//####    m_nX = nx;
//####    m_nY = ny;
//####    m_nZ = nz;
//####  }
//####  ns__SCell(const ns__SCell& cell) 
//####  {
//####    m_nX = cell.m_nX;
//####    m_nY = cell.m_nY;
//####    m_nZ = cell.m_nZ;
//####  }
};

//####inline bool operator == (const ns__SCell& c1, const ns__SCell& c2) 
//####{
//####  return c1.m_nX == c2.m_nX && c1.m_nY == c2.m_nY && c1.m_nZ == c2.m_nZ;
//####}
//####inline bool operator != (const ns__SCell& c1, const ns__SCell& c2) 
//####{
//####  return 
//####    c1.m_nX != c2.m_nX || c1.m_nY != c2.m_nY || c1.m_nZ != c2.m_nZ;
//####}

// * Presents model - assembly association
// * 
// * Contains coordinate information that is associated with the model and the assembly
// */
class ns__CModel;
//class ns__CAssembly;
class ns__CManager;

class ns__CModelAssembly 
{
 
 public:
  
 int m_nAtomCount;
  //**
  // * Constructor 
  // * @param pModel pointer to CDBModel
  // * @param pAssembly pointer to CDBAssembly
  // * @param pMgr pointer to CDBManager
  // * @param bBuildAtoms boolean tells whether to extract coordinate information that is associated with the model and the assembly or not (means do it later)
  // */
  ns__CModelAssembly();
  // * Destructor
  // */
  ~ns__CModelAssembly();
//####    {
//####      for (int i = 0; i < m_nAtomCount; i++)
//####  {
//####    m_vpAtom[i]->SetIndex(-1);
//####    m_vpAtom[i]->SetResidue(NULL);
//####    delete m_vpAtom[i];
//####  }
//####      if (m_vpAtom)
//####  delete [] m_vpAtom;
//####      if (m_vCell)
//####  delete [] m_vCell;
//####/*       if (m_vnCellX) */
//####/*        delete [] m_vnCellX; */
//####/*       if (m_vnCellY) */
//####/*        delete [] m_vnCellY; */
//####/*       if (m_vnCellZ) */
//####/*        delete [] m_vnCellZ; */
//####      for (std::vector<ns__CAtom*>::const_iterator it = m_vpBoundMolAtom.begin(); it !=  m_vpBoundMolAtom.end(); it++)
//####  {
//####    (*it)->SetIndex(-1);
//####    (*it)->SetResidue(NULL);
//####    delete  *it;
//####  }
//####      for (std::vector<ns__CAtom*>::const_iterator it = m_vpSolventAtom.begin(); it !=  m_vpSolventAtom.end(); it++)
//####  {
//####    (*it)->SetIndex(-1);
//####    (*it)->SetResidue(NULL);
//####    delete  *it;
//####  }
//####    }
protected:
  ns__CModel* m_pModel; // reference to model
  ns__CAssembly* m_pAssembly; // reference to assembly
  ns__CManager* m_pMgr;  // reference to manager
  // calculated information
 
  ns__CAtom** m_vpAtom; // copy of atoms with assembly coordinates
  //std::vector<ns__CAtom*> m_vpBoundMolAtom;
  //std::ns__CAtom*> m_vpSolventAtom;
  ns__CAtom** m_vpBoundMolAtom;
  ns__CAtom** m_vpSolventAtom;
  //int* m_vnCellX;
  //int m_nCellXCount;
  //int* m_vnCellY;
  //int m_nCellYCount;
  //int* m_vnCellZ;
  //int m_nCellZCount;
  int m_nCellCount;
  struct ns__SCell* m_vCell;
 
};

//**
// * Connected list of CDBModelAssembly
// */
class ns__CListModelAssembly : public ns__CModelAssembly
{  
 public:
         ns__CListModelAssembly();
    virtual ~ns__CListModelAssembly();
  //**
  // * Constructor 
  // * @param pModel pointer to CDBModel
 //  * @param pAssembly pointer to CDBAssembly
  // * @param pMgr pointer to CDBManager
   //* @param pPrev pointer to previous CDBModelAssembly in the list
   //*/
  
  ns__CListModelAssembly* m_pPrev;
};

//**
// * Assembly (about assemblies see PQS assemblies on www.ebi.ac.uk/msd)
// *
// * This class is container of array of CDBChainAssembly and array of CDBModelAssembly
// */
class ns__CAssembly
{
 
 public:
 // /**
 //  * Constructor
 //  * @param pmgr pointer to CDBManager
 //  * @param nId integer database id of assembly (DA_ID from deposition db or assembly_id from warehouse)
 //  * @param nSerial integer serial number of assembly within the PDB entry
 //  */
  ns__CAssembly();
   
 // /**
 //  * Destructor
 //  */
  ~ns__CAssembly();
   
  protected:
  ns__CManager* m_pMgr;
  int m_nId;
  int m_nSerial;
  ns__CChainAssembly** m_vpChainAssembly;
  ns__CModelAssembly** m_vpModelAssembly;
  int m_nChainAssemblyCount;
  int m_nModelAssemblyCount; 
  
};









// ===================== CAssembly ==============================
//     class ns__CAssembly {
//      public :
//       int  assembly_id;         
//         accession_code;     
//         assembly_serial;    
//         assembly_class;     
//         assembly_form;      
//         assembly_title;     
//         assembly_type;      
//         entry_id;           
//         num_chains;         
//         num_nstd_atom;      
//         num_residues;       
//         num_xchain_ss;      
//         rel_status;         
//         score              
//         status             
//         n_repeat           
//         repeat_dist        
//         n_unique           
//         helical_height     
//         helical_twist      
//         srch_assembly_type 
//     
//       ns__CAssembly ();
//       ~ns__CAssembly ();
//       
//     };


//  ====================  CModel  ===============================

class ns__CModel  {

 public :
    ns__CModel ();  // SetMMDBFile() MUST be used after this constructor!
    ~ns__CModel();
     protected :
     int m_nId;
         int             serNum;       // the model serial number
   // ns__CMMDBManager *  manager;      // pointer to mmdbmanager class
    ns__CHetCompounds   HetCompounds; // information on heterocompounds
   // ns__CSSContainer    Helix;        // information on helices
    ns__CSheets         Sheets;       // information on sheets
   // ns__CSSContainer    Turn;         // information on turns
    int             nChains;      // number of chains
    int             nChainsAlloc; // actual length of Chain[]
    ns__CChains   Chain;        // array of chains
    xsd__boolean         Exclude;      // used internally
};





//  ==================  CContainerChain  =====================

class ns__CContainerChain  {

 

  public :

    ns__CContainerChain ();
    ~ns__CContainerChain ();
    
  protected :
    ns__CChain * Chain;
    xsd__string chainID;  // just a copy of Chain->chainID

};


//  ==================  CDBReference  ========================


class ns__CDBReference : public ns__CContainerChain  {

  public :

    int      seqBeg;      // initial sequence number of the PDB seq-ce segment
    xsd__string  insBeg;      // initial insertion code of the PDB sequence segm-t
    int      seqEnd;      // ending sequence number of the PDB sequence segm-t
    xsd__string  insEnd;      // ending insertion code of the PDB sequence segment
    xsd__string   database;    // sequence database name
    xsd__string dbAccession; // sequence database accession code
    xsd__string dbIdCode;    // sequence database identification code
    int      dbseqBeg;    // initial sequence number of the database segment
    xsd__string  dbinsBeg;    // insertion code of initial residue of the segment
    int      dbseqEnd;    // ending sequence number of the database segment
    xsd__string  dbinsEnd;    // ins-n code of the ending residue of the segment
    
    ns__CDBReference ();
   
    ~ns__CDBReference();

   
};


//  ==================  CSeqAdv  ========================


class ns__CSeqAdv : public ns__CContainerChain  {

  public :
 
    xsd__string  resName;     // residue name in conflict
    int      seqNum;      // residue sequence number
    xsd__string  insCode;     // residue insertion code
    xsd__string   database;    // sequence database name
    xsd__string dbAccession; // sequence database accession code
    xsd__string  dbRes;       // sequence database residue name
    int      dbSeq;       // sequence database sequence number
    xsd__string     conflict;    // conflict comment
    
    ns__CSeqAdv ();
   
    ~ns__CSeqAdv();

};




//  ==================  CModRes  ========================


class ns__CModRes : public ns__CContainerChain  {

  public :
 
    xsd__string  resName;     // residue name used
    int      seqNum;      // residue sequence number
    xsd__string  insCode;     // residue insertion code
    xsd__string  stdRes;      // standard residue name
    xsd__string     comment;     // description of the residue modification
    
    ns__CModRes ();
   
    ~ns__CModRes();

    
};


//  ==================  CHetRec  ===========================


class ns__CHetRec : public ns__CContainerChain  {

  public :
 
    xsd__string  hetID;       // Het identifier (right-justified)
    int      seqNum;      // sequence number
    xsd__string  insCode;     // insertion code
    int      numHetAtoms; // number of HETATM records for the
                          // group present in the entry
    xsd__string     comment;     // text describing Het group
    
    ns__CHetRec ();
    
    ~ns__CHetRec();

};



class ns__CAtomPath  {

  public :

    int      modelNo;
    xsd__string  chainID;
    int      seqNum;
    xsd__string  insCode;
    xsd__string  resName;
    xsd__string atomName;
    xsd__string  element;
    xsd__string   altLoc;
    int      isSet;

    ns__CAtomPath  ();
    
    ~ns__CAtomPath ();

    //  SetPath(..) parses the Atom Path ID string, which
    //  may be incomplete. Below {..} means blocks that
    //  may be omitted; any elements within such blocks
    //  may be omitted as well.
    //
    //  1. If ID starts with '/' then the ID must be of
    //     the following form:
    //   /mdl{/chn{/seq(res).i{/atm[elm]:a}}}
    //
    //  2. If ID starts with a letter:
    //        chn{/seq(res).i{/atm[elm]:a}}
    //
    //  3. If ID starts with a number or '(':
    //            seq(res).i{/atm[elm]:a}
    //
    //  4. If ID contains colon ':' or '[' then
    //     it may be just
    //                       atm[elm]:a
    //
    //  The following are valid samples of IDs:
    //
    //     /1      model number 1
    //     /1/A/23(GLU).A/CA[C]:A  model number 1, chain A,
    //             residue 23 GLU insertion code A, C-alpha
    //             atom in alternative location A
    //     A/23    residue 23 of chain A
    //     CA[C]:  atom C-alpha
    //     [C]     a carbon
    //     *[C]:*  same as above
    //     :A      an atom with insertion code A
    //     5       residue number 5
    //     (GLU)   residue GLU
    // 
    //   All spaces are ignored. SetPath(..) sets bit of isSet
    // for each element present. Any element may be a wildcard
    // '*'. Wildcard for model will set modelNo=0, for sequence
    // number will set seqNum=MinInt4.
    //
    // Returns:
    //   0   <-> Ok
    //   -1  <-> wrong numerical format for model
    //   -2  <-> wrong numerical format for sequence number
   
};

//####class ns__CDBSupChemPlane
//####{
//####  int m_nId;
//####  int m_nCompId;
//####  int m_vnAtomId[100]; // vector of atoms in the plane
//####  int m_nAtomCount;
//####
//####};
//####
//####class CDBPlaneAtom : public virtual CDBAtom
//####{
//####protected:
//####  algebra::vec3 m_Norm;
//####  CDBSupChemPlane* m_pPlane;
//####};
//####

class ns__CListAtom : public  ns__CAtom
{  
 public:
  ns__CListAtom();
  virtual ~ns__CListAtom();
 // /**
 //  * Constructor
 //  * @param nId integer id of atoms location in DB (see CDBAtom)
 //  * @param nSiteId integer id of atom in DB (see CDBAtom)
 //  * @param nSupChemId integer id of reference data about atom type (see CDBAtom)
 //  * @param pPrev pointer to the previous CDBListAtom in the list
 //  */
 
  //**
 //  * pointer to the previous CDBListAtom in the list
 //  */ 
  ns__CListAtom* m_pPrev;
};





struct ns__SContact  {
  int      id1,id2;
  xsd__long     group;
  xsd__double dist;
  
};


// ========================  CMContact  =============================


class ns__CMContact  {

  public :
    int       nStruct;
    int       contactID;
    t__ivec   nAtoms;
    ns__CAtom *** Atom;
    t__imat   id;

    ns__CMContact ();
    ~ns__CMContact();



  protected:
    t__ivec nAlloc;

};

class ns__CManager 
{
 
 public:
  int m_nAtomIndex;
  int m_nResidueIndex;
  xsd__boolean m_bIgnorePlanes;

  // */
  ns__CManager();
  // * Destructor, performs cleanup
  // */
  ~ns__CManager();
//###    {
//###      for (int i = 0; i < m_nAssemblyCount; i++)
//###   delete m_vpAssembly[i];
//###      for (int i = 0; i < m_nSupChemPlaneCount; i++)
//###   delete m_vpSupChemPlane[i];
//###      if (m_vpSupChemPlane)
//###   delete [] m_vpSupChemPlane;
//###      if (m_vpAssembly)
//###   delete [] m_vpAssembly;
//###      for (std::vector<CCalcGraph*>::const_iterator it = m_vpSupChemCompGraph.begin();
//###      it != m_vpSupChemCompGraph.end(); it++)
//###   delete (*it);
//###    }
 protected:
  ns__CAssembly **m_vpAssembly;
  int m_nAssemblyCount;
  //ns__CSupChemPlane **m_vpSupChemPlane;
  //int m_nSupChemPlaneCount;
  //  int m_nLigandChainCount;
 
  // helper for load data
  int m_nLigandChainCount; 
};

---