The Macromolecular Structure Classes Documentation


Documentation for the following classes is available:


Class Atom

/*********************************************************************
Class: Atom
Method: ATom()
Description:
Basic ATom object constructor to create an ATom object with
all Null information.
Usage:
ATom atom; /* generate an atom object;
ATom * atomP; /* declare a pointer to an ATom object.
Caution:
None.
Also see:
ATom(atom, rtm11, rtm12, rtm13,
rtm21, rtm22, rtm23,
rtm31, rtm32, rtm33,
tfv1, tfv2, tfv3)
/************************************************************************
/*********************************************************************
Class: Atom
Method: ATom(atom, rtm11, rtm12, rtm13,
rtm21, rtm22, rtm23,
rtm31, rtm32, rtm33,
tfv1, tfv2, tfv3)
const ATom &atom /* the atom object to be copied from.
double rtm11 /* rotation matrix value [1, 1];
double rtm12 /* rotation matrix value [1, 2];
double rtm13 /* rotation matrix value [1, 3];
double rtm21 /* rotation matrix value [2, 1];
double rtm22 /* rotation matrix value [2, 2];
double rtm23 /* rotation matrix value [2, 3];
double rtm31 /* rotation matrix value [3, 1];
double rtm32 /* rotation matrix value [3, 2];
double rtm33 /* rotation matrix value [3, 3];
double tfv1 /* transformation vector [1];
double tfv2 /* transformation vector [2];
double tfv3 /* transformation vector [3];
Description:
This method is served as the atom copy constructor and is also used
to generate symmetric units.
Usage:
ATom ATom(atom); /* create an ATom object with identical
/* information as atom;
ATom ATom(atom, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0);
/* create an ATom object by appling
/* the X,Y,Z transformation to the atom.
Caution:
Parameters are optional except for the "atom". Optional parameters are
default to be 0.
/**********************************************************************
/*********************************************************************
Class: Atom
Method: double X(number);
int number /* the X coordinate of the number-th alternative
/* atom object.
Description:
To retrieve the X coordinate of the n-th alternative atom object.
The parameter parameter is default to be 0 to indicate the 1st atom.
Usage:
ATom atom;
double x_position=atom.X();
Caution:
The parameter number has to be a value smaller than the value retrived
by the method ATom::NumOfNonDummyAtom(); (see ...)
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double X() const
Description: Returns this atoms X coordinate.
Usage: ATom atom;
double d_x = atom.X();
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Y(int) const;
Description:
To retrieve the Y coordinate of the n-th alternative atom object.
The parameter parameter is default to be 0 to indicate the 1st atom.
Usage:
ATom atom;
double y_position=atom.Y();
Caution:
The parameter number has to be a value smaller than the value retrived
by the method ATom::NumOfNonDummyAtom(); (see ...)
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Y() const
Description: Returns this atoms Y coordinate.
Usage: ATom atom;
double d_y = atom.Y();
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Z(int) const;
Description:
To retrieve the Z coordinate of the n-th alternative atom object.
The parameter parameter is default to be 0 to indicate the 1st atom.
Usage:
ATom atom;
double z_position=atom.Z();
Caution:
The parameter number has to be a value smaller than the value retrived
by the method ATom::NumOfNonDummyAtom(); (see ...)
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Z() const
Description: Returns this atoms Z coordinate.
Usage: ATom atom;
double d_z = atom.Z();
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Temperature(int) const;
Description: returns the Temperature of the n-th alternative atom object.
The parameter is defaults to 0, to indicate the 1st atom
Usage:
Caution: The parameter number has to be a value smaller than the value
returned by ATom::NumOfNonDummyAtom();
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Temperature() const
Description: returns the Temperature of this Atom.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Occupancy(int) const;
Description: returns the Occupancy of the n-th alternative atom object.
The parameter is defaults to 0, to indicate the 1st atom
Usage:
Caution: The parameter number has to be a value smaller than the value
returned by ATom::NumOfNonDummyAtom();
/*********************************************************************
/*********************************************************************
Class: Atom

Method: double Occupancy() const
Description: returns the Occupancy of this Atom.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: const SubEntity* MySubEntity() const
Description: Returns the SubEntity that this Atom belongs to.
Usage: ATom atom1;
SubEntity *se = atom1.MySubEntity();
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: void AssignSubEntity(SubEntity& se)
Description: Assigns its SubEntity member to se. This means that this
Atom belongs to se.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: const Entity* MyEntity () const;
Description: returnst the Entity that it belongs to
Usage:
Caution: Before using this method, this ATom's SubEntity member should
be assigned to its SubEntity, by using
ATom::AssignSubEntity(SubEntity& se)
/*********************************************************************
/*********************************************************************
Class: Atom

Method: const LinkListElement * MySubStrucList() const;
Description: returns its SubEntitys Secondary Structure List
Usage:
Caution: Before using this method, this ATom's SubEntity member should
be assigned to its SubEntity, by using
ATom::AssignSubEntity(SubEntity& se)
/*********************************************************************
/*********************************************************************
Class: Atom

Method: const Compound* MyCompound() const;
Description: returns the Compound that it belongs to.
Usage:
Caution: Before using this method, this ATom's SubEntity member should
be assigned to its SubEntity, by using
ATom::AssignSubEntity(SubEntity& se)
/*********************************************************************
/*********************************************************************
Class: Atom

Method: void AddAltAtom(ATom *alt_atm);
Description: Assigns its _alt Atom (Alternative Atom) member to alt_atm
Also, sets alt_atm's SubEntity member.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: char AltLocation(int) const;
Description: returns the AltLocation of the n-th alternative atom object.
The parameter is defaults to 0, to indicate the 1st atom
Usage:
Caution: The parameter number has to be a value smaller than the value
returned by ATom::NumOfNonDummyAtom();
/*********************************************************************
/*********************************************************************
Class: Atom

Method: char AltLocation() const
Description: returns the Occupancy of this Atom.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: int IsMissingAtom() const
Description: returns non-zero value if this Atom is a Missing Atom from
the PDB file, with an ILEGAL_NUMBER as its _id.
Usage: Atom atm;
if (atm.IsMissingAtom())
// do stuff on Missing Atom
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: int NumOfNonDummyAtom() const
Description: returns the num. of Alternative atoms
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: ATom *AltAtom() const
Description: returns the _alt atom list of this Atom.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: ATom *Next() const
Description: returns the _next atom of this Atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: ATom *Previous() const
Description: returns the _previous atom of this Atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: ATom *NthAltAtom(int =0) const; // Return the ith alternative atom.
Description: returns the nth alternative atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: LinkListElement *BoundAtoms() const;
Description: returns a list of Atoms bound to this one, by looking up
its SubEntity connectivity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: int MyID() const
Description: returns its _id
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: int MyQueryMark() const
Description: returns its _queryMark member, which is used by the
pdbtool application
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: void SetQueryMark(int qm)
Description: sets the _queryMark member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: char * MyName() const
Description: returns this atoms name
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: void AssignID(const int i)
Description: Assigns an id to this atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: void AssignName(char * name)
Description: assigns a name to this atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: void AssignNext(ATom * t)
Description: assigns the _next member of this atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Atom

Method: void AssignPrevious(ATom * t)
Description: assigns the _previous member of this atom
Usage:
Caution:
/*********************************************************************


Class SubEntity

/*********************************************************************
Class: SubEntity

Method: IntrSubEntity();
Description: Defaults CTOR for SubEntity. Creates an empty SubEntity
shell, which can be filled in later
Usage:
Caution: Cannot directly instantiate a SubEntity. You have to instantiate
one of its Derived classes.
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: IntrSubEntity(char *name);
Description: CTOR for SubEntity, which creates an empty shell, but
sets the name, as passed in
Usage:
Caution: Cannot directly instantiate a SubEntity. You have to instantiate
one of its Derived classes.
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: IntrSubEntity(const SubEntity&, const Matrix*, const Vector*);
Description: This is the COPY CTOR for SubEntity. This is also used to
generate symettric units, using the Matrix, and Vector parameters
Usage:
Caution: Cannot directly instantiate a SubEntity. You have to instantiate
one of its Derived classes.
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: ATom * NthAtom(int n); // Return th ith atom according to the sequence
Description: returns the n'th Atom in its Atom List
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: ATom * LastAtom(); // similar to nth_atom().
Description: returns the LastAtom in its Atom List
Usage: SubEntity *se;
ATom *last_atom = se->LastAtom();
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: int LastAtomNum(); // The PDB file ATOM serial number of the last
Description: returns the pdb file ATOM serial number of the last atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: const BoundAtom * AtomsBoundTo(const ATom *atm) const;
Description: returns a list of objects called BoundAtom, which
represent atoms bound to atm according to the connectivity
Usage:
Caution: This list needs to be deleted when done with or else, it
will result in a Memory Leak
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: int AssignConnectivity();
Description: Accesses the Connectivity List from its Compound, and then
attempts to find its connectivity in that list by looking up its name
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: SubEntityConnectivity * FindAltConnectivity(char* atom_name) const ;
Description: Looks up its own connectivity's alternate list
to find the atom_name
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: SubEntity * InsertSubEntityAfter(SubEntity* new_subentity);
Description: Insert the new_subentity between the current
subentity and the next subentity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void BuildAtoms();
Description: Create all atoms of the current subentity according to the
SubEntityConnectivity object
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void AddTermOx(); // Add terminal oxygen.
Description: Adds a terminal oxygen atom to the end of its Atom List
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void AssignNext(SubEntity * subentity)
Description: assigns its next member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void AssignPrevious(SubEntity * subentity)
Description: assigns its previous member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void AddAtom(ATom &atom);
Description: Adds the atom to the end of its Atom List
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void AssignAllConnectivity();
Description: Assigns its own SubEntityConnectivity, if needed, and
also allocates and Builds its Atom List if needed.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void AssignAtomsToPreNext();
Description: assigns its _atomToPreSE, _atomToNextSE members
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void BuildAltConnectivity(char * atom_name);
Description: Builds an Alternate Connectivity for this atom_name
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: char* MyName() const
Description: returns the _name of this SubEntity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: int MyQueryMark() const
Description: returns the QueryMark of this SubEntity.
Usage:
Caution: This is only used by an application pdbtool, built on pdblib
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void SetQueryMark(int qm)
Description: Sets the QueryMark of this SubEntity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: char* MyInsertionCode() const
Description: returns its insertion code
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: int MySequenceNumber() const
Description: returnst its Sequence Number
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: void AssignSubStruc(CompSubStruc*);
Description: Adds the CompSubStruc, at the end of its list.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: ATom * AtomToPreviousSubEntity() const
Description: returns the atom in its atom list attached to
the Previous SubEntity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: ATom * AtomToNextSubEntity() const
Description: returns the atom in its atom list attached to
the Previous SubEntity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: ATom * FindAtom(char * atom_name) const;
Description: Finds the atom with atom_name in its atom list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: ATom * MyFirstAtom() const
Description: returns its first ATom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: const Entity* MyEntity() const
Description: returns its Entity, that it belongs to
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: const LinkListElement * MySubStrucList() const
Description: returns the first element of its CompSubStruc Secondary
Structure list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: const Compound* MyCompound() const;
Description: returns the compound that it belongs to
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: int IsMissingSubEntity() const
Description: returns non zero, if its seq num, is undefined
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: int NumOfAtoms() const;
Description: returns the num of atoms according to its Connectivity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: SubEntity * Next() const
Description: returns its next member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: SubEntity * Previous() const
Description: returns its previous member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: SubEntityType MyType() const;
Description: returns its SubEntity type
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: SubEntityConnectivity* MySubEntityProperty() const
Description: returns its SubEntityConnectivity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual ATom * N_atom() const
Description: returns null, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual ATom * CA_atom() const
Description: returns null, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual ATom * C_atom() const
Description: returns null, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual ATom * O_atom() const
Description: returns null, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual ATom * CenterAtom() const
Description: returns null, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual ListMgr * MainChainAtoms() const
Description: returns null, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual double PhiAngle(int =0) const
Description: returns ILEGAL_NUMBER, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual double PsiAngle(int =0) const
Description: returns ILEGAL_NUMBER, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual double DeltaOmega(int =0) const
Description: returns ILEGAL_NUMBER, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual double OmegaAngle(int =0) const
Description: returns ILEGAL_NUMBER, used by its derived classes
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: SubEntity

Method: virtual SubEntity * MySymmetricUnit(const Matrix*, const Vector*)
Description: returns its Symmetric unit generated according to the Matrix and
Vector passed to it., used by its derived classes
Usage:
Caution: The SubEntity List that is returned needs to be deleted after use,
or else it will results in a memory leak
/*********************************************************************


Class Entity

/*********************************************************************
Class: Entity

Method: IntrEntity();
Description: Def CTOR for Entity, builds an empty Entity shell, which
can be filled up later
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: IntrEntity(const Matrix* rotationmatrix,
const Vector* translationvector,
const IntrEntity& entity);
Description: Can be used as a COPY CTOR, or can be used to generate
symettric units, by passing approproiate matrix, and vector
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: void AddSubEntity(SubEntity& subentity );
Description: Adds the following subentity to the end of its SubEntity list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: void AddSStrucSE(SStrucSE*);
Description: Adds the following sstrucSE to the end of its Sec Struc List
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: void InsertFirstSubEntity(SubEntity*);
Description: insert the first SubEntity in its SubEntity List
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: char* MyName() const
Description: returns its name
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: const SubEntity * MyFirstSubEntity() const
Description: returns its first SubEntity
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: const LinearListMgr * MySubEntityList() const
Description: returns its SubEntity List
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: const Compound* MyCompound() const
Description: returns the Compound that it belongs to
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: const SStrucSE * MyFirstSStrucSE() const
Description: returns the first SStrucSE in its SSTrucSE list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: const LinearSSList *MySStrucSEList() const
Description: returns its SSTrucSE list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: Entity* Next()
Description: returns its next member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: Entity* Previous()
Description: returns its previous member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: Entity* MySymmetricUnit(Matrix*, Vector*);
Description: generates is SymmetricUnit using the matrix and vector supplied.
Usage:
Caution: The Entity List recieved from this method needs to be deleted
after use in order to avoid memory leaks
/*********************************************************************
/*********************************************************************
Class: Entity

Method: void Assign1stSStrucSE(SStrucSE * sp)
Description: Assigns its first SStrucSE to be sp
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Entity

Method: SubEntity *NewSubEntity(const SubEntity &se,
const Matrix* rm, const Vector* tv);
Description: checks the se's type and Copy Constructs an appropriate
SubEntity with the matrix and vector passed in.
Usage:
Caution:
/*********************************************************************


Class Compound

/*********************************************************************
Class: Compound

Method: void BuildEntities(const IntrCompound &compound);
Description: Used by the Deep Copy CTOR of this Compound. This method
deep copies all the entities, and related features to this
Compound
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void BuildBonds(const IntrCompound &compound);
Description: Used by the Deep Copy CTOR of this Compound. This method
deep copies all the Bonds to this compound
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void BuildSheets(const IntrCompound &compound);
Description: Used by the Deep Copy CTOR of this Compound. This method
deep copies all the Sheets to this compound
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void BuildSites(const IntrCompound &compound);
Description: Used by the Deep Copy CTOR of this Compound. This method
deep copies all the Sites to this compound
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void BuildPDBInfo(const IntrCompound &compound);
Description: Used by the Deep Copy CTOR of this Compound. This method
deep copies the PDBInfo to this compound
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SubEntity * FindNeighboringSubEntity(SubEntity* se, char* name);
Description: returns se's next or previous, SubEntity which matches
the name passed to it.
Usage:
Caution: returns 0 if not found
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SubEntity * FindFirstSubEntity(char*, char*, int, int);
Description: Used by the pdbfile class to fill up structure
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: IntrCompound();
Description: Default CTOR for the Compound. Builds an empty shell of
a compound
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: IntrCompound(const IntrCompound &c);
Description: Deep Copy CTOR for the Compound
Usage:
Caution: Does not copy the derived attributes, such as exposure and
SubEntityContact's in SubEntities
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AssignContacts(double);
Description: This method calculates and stores derived features such
as Contact Maps.
Usage:
Caution: Can only be used after the whole compound is built.
Cannot be called on an empty Compound shell
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AssignExposure();
Description: This method calculates and stores derived features such
as exposure for the compound
Usage:
Caution: Can only be used after the whole compound is built.
Cannot be called on an empty Compound shell
/*********************************************************************
/*********************************************************************
Class: Compound

Method: int MyExposureFlag()
Description: returns its Exposure flag which tells us whether
the Derived features are built
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: double MyMaxDistance()
Description: returns the threshold for generating the contact map
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void BuildSubEntColl();
Description: Builds a Collection of pointers to SubEntities if OBJECTSTORE
is used, otherwise builds a NonLinear list of SubEntities
Usage:
Caution: Not very usefull without ObjectStore
Caution: Can only be used after the whole compound is built.
Cannot be called on an empty Compound shell
/*********************************************************************
/*********************************************************************
Class: Compound

Method: ListMgr * MySubEntColl()
Description: returns the SubEntity Collection
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: char * BuildSequenceQuery(char **seq, int num);
Description: builds and returns a valid ObjectStore Query String,
once it is given an array of SubEntity names, which represents
the Sequence to be queried and the number of elements in the array
Usage:
Caution: ONLY DEFINED IF NEED_OBJECTSTORE IS DEFINED
Caution: Can only be used after the whole compound is built.
Cannot be called on an empty Compound shell
/*********************************************************************
/*********************************************************************
Class: Compound

Method: CollectionListMgr * SequenceQuery(char **seq, int num);
Description: returns the result of a Seq Query, a CollectionListMgr
once it is given an array of SubEntity names, which represents
the Sequence to be queried and the number of elements in the array
Usage:
Caution: ONLY DEFINED IF NEED_OBJECTSTORE IS DEFINED
Caution: Can only be used after the whole compound is built.
Cannot be called on an empty Compound shell
/*********************************************************************
/*********************************************************************
Class: Compound

Method: CollectionListMgr * SequenceQuery(char *query_str);
Description: returns the result of a Seq Query, a CollectionListMgr
once it is given a valid ObjectStore Query String
Usage: Could be used in conjunction with BuildSequenceQuery
Compound *seq_cmpd;
CollectionListMgr *results;
char *q_str=0,*seqs[5];
seqs[0] = new char[4]; strcpy(seqs[0],"GLU");
seqs[1] = new char[4]; strcpy(seqs[1],"*");
seqs[2] = new char[4]; strcpy(seqs[2],"GLU");
seqs[3] = new char[4]; strcpy(seqs[3],"VAL");
seqs[4] = new char[4]; strcpy(seqs[4],"CYS");
for(DbsIter it; ......all the Compounds in some list.....
{
seq_cmpd = &it();
if (! q_str)
q_str = seq_cmpd->BuildSequenceQuery(seqs,4);
results = seq_cmpd->SequenceQuery(q_str);
........// Process results

}

Caution: ONLY DEFINED IF NEED_OBJECTSTORE IS DEFINED
Caution: Can only be used after the whole compound is built.
Cannot be called on an empty Compound shell
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddEntity(Entity&); // Add polymer entity.
Description: Adds the entity to the end of its Entity List
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddPolyEntity(Entity&); // Add poly ent, but make sure it is in _poly
Description: Adds the entity to the end of its Polymer Entity list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddSStrucSE(SStrucSE&);
Description: Adds the SStrucSE to its SStrucSE list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddBond(CovalBond*);
Description: Adds the Bond to its Coval Bond list in the appropriate order
Also makes sure that it does not already exist in the list and
checks that the covalBonds begin and end atoms do not exist
in each others BoundAtom list
Usage:
Caution: If the coval bond does not get added to its list it gets deleted
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddBond(HydroBond*);
Description: Adds the HydroBond to its HydroBond List
Also makes sure that it does not already exist in the list
Usage:
Caution: If the coval bond does not get added to its list it gets deleted
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddBond(SaltBridge*);
Description: Adds the HydroBond to its SaltBridge List
Also makes sure that it does not already exist in the list
Usage:
Caution: If the coval bond does not get added to its list it gets deleted
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddBond(SSBond*);
Description: Adds the HydroBond to its SSBond List
Also makes sure that it does not already exist in the list
Usage:
Caution: If the coval bond does not get added to its list it gets deleted
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddHetSubEntity(SubEntity&); // add nonpolyentity entity.
Description: creates an Entity, and sets its SubEntity to the SubEntity
passed to it and adds the Entity to its NonPolymer list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddSheet(Sheet*);
Description: Adds the Sheet to its Sheet list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddSite(Site*);
Description: Adds the Site to its Site list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddOrigx(int i, double d1, double d2, double d3, double d4)
Description: calls PDBInfo's AddOrigx...refer to PDBInfo
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddScale(int i, double d1, double d2, double d3, double d4)
Description: calls PDBInfo's AddScale...refer to PDBInfo
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddCrystalLengthVector(Vector& vector)
Description: calls PDBInfo's AddCrystalLengthVector...refer to PDBInfo
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AddCrystalAngleVector(Vector& vector)
Description: calls PDBInfo's AddCrystalAngleVector...refer to PDBInfo
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void Assign1stSheet(Sheet * sp)
Description: assigns its sheet lists first member to sp
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void Assign1stSite(Site * sp)
Description: assigns its site lists first member to sp
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void AssignConnectivityMgr(ConnectivityMgr *mp)
Description: assigns its ConnectivityMgr to mp
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SubEntity * FindEmptySubEntity(SubEntity*, char*, char*, int, int);
Description: Used by the PDBFile class to convert the PDB file into proper
OOP representation, when missing information occurs. Normally
these methods would not be invoked
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SubEntity * InsertSubEntityAfter(SubEntity*, SubEntity*, char*, int);
Description: Used by the PDBFile class to convert the PDB file into proper
OOP representation, when missing information occurs. Normally
these methods would not be invoked
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SubEntity * FindPreNonExcSubEntity(SubEntity*);
Description: Used by the PDBFile class to convert the PDB file into proper
OOP representation, when missing information occurs. Normally
these methods would not be invoked
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: void ReOrganizeSheets();
Description: Used by the PDBFile class to convert the PDB file into proper
OOP representation, when missing information occurs. Normally
these methods would not be invoked
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SubEntity * NewSubEntity(char* name) const;
Description: creates a new SubEntity, with the given name,
according to the first SubEntityConnectivity object that
match the parameter "name" in the ConnectivityMgr
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: char * MyName() const
Description: returns the name of the Compound, as appears in PDB file
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: double Origx_O(int i, int j) const
Description: refer to PDBInfo, based on PDB file
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: double Origx_T(int i) const
Description: refer to PDBInfo, based on PDB file
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: double Scale_S(int i, int j) const
Description: refer to PDBInfo, based on PDB file
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: double Scale_U(int i) const
Description: refer to PDBInfo, based on PDB file
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: PDBInfo * MyPDBInfo() const
Description: returns its PDBInfo member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SpaceGroup * MySpaceGroup() const
Description: returns its SpaceGroup
Usage:
Caution: Do not delete this as usually there is 1 SpaceGroup shared
amongst many compounds
/*********************************************************************
/*********************************************************************
Class: Compound

Method: double RamachandranQuality() const;
Description: Returns the percentage of amino acid residues who's phi/psi
combination falls in the allowable regions.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: HistogramValues * OmegaAngles() const;
Description: turns a sorted list of omega angles and their
associated subentities.
Usage:
// HistogramValues *temp, *head=compound->omega_angles();
//
// while (head) {
// cout<value<<" for subentity "<<
// (head->subentity_p)->_name< // temp=head;
// head=head->next_p;
// delete head;
// };
//
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: HistogramValues * DeltaOmegas() const;
Description: Similar to the previous method except that the values are
the angle of deviation from 180 degree.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: ConnectivityMgr *MyConnectivityMgr() const
Description: returns its ConnectivityMgr, which manages connectiviy info
Usage:
Caution: Do not delete this as usually there is 1 ConnectivityMgr shared
amongst many compounds
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Sheet *FindSheet(char* id); // id = sheet identifier in PDB file.
Description: Find the sheet with the given id in its sheet list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Site *FindSite(char* id); // id = site identifier in PDB file.
Description: Find the sheet with the given id in its site list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Bond *FindBond(Bond * bonds, ATom * a, ATom * b);
Description: Find the Bond with begin,end atoms a and b in the bonds
list passed to it
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Bond *FindBond(Bond * bonds, Bond * target);
Description: Finds the target bond in the bonds list passed to it
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: HydroBond *FindHydroBond(ATom *donor, ATom *acceptor)
Description: Find the HydroBond with the given donor,acceptor atom
in its hydro bond list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: HydroBond *FindHydroBond(HydroBond *hb)
Description: Finds the HydroBond in its HydroBond list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: int NumCrystalSymmetricUnits();
Description: returns the num. of Crystal Symmetric Units, based on its
SpaceGroup member
Usage:
int numofsymatricunit=compound->NumCrystalSymmetricUnits();
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MyPolymers() const
Description: returns its polymers list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MyNonPolymers() const
Description: returns its non polymers list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MyPolymersSymmetricUnit(Matrix*,
Vector*) const;
Description: returns its symmetric unit generated, of all its polymers
with the matrix and vector passed to it
Usage:
Caution: This entity list needs to be deleted after use, in order to
prevent Memory Leaks
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MyNonPolymersSymmetricUnit(Matrix*,
Vector*) const;
Description: returns its symmetric unit generated, of all its nonpolymers
with the matrix and vector passed to it
Usage:
Caution: This entity list needs to be deleted after use, in order to
prevent Memory Leaks
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MySymmetricUnit(Matrix*, Vector*) const;
Description: returns its symmetric unit (Poly && NonPoly) generated with the
matrix and vector passed to it
Usage:
Caution: This entity list needs to be deleted after use, in order to
prevent Memory Leaks
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MyCrystalPolymersSymmetricUnit(int) const;
Description: returns its polymers symmetric unit generated with the
matrix and vector retrieved from its SpaceGroup's member
function NthTransformationValues(int i)
Usage:
if (spacegroup) {
Entity* symatricunits=compound->MyCrystalPolymersSymmetricUnit(1);
for ( EntityIter cit12(*symatricunits);cit12; ++cit12) {
cout << endl << "Entity is: " < << endl << endl;
for (SubEntityIter rit(cit12()); rit; ++rit) {
cout << "The atoms belonged to -- " ;
...........
}
}
THE USAGE OF OTHER SYMMETTRY MEMBER FUNCTIONS ARE VERY SIMILAR
Caution: This entity list needs to be deleted after use, in order to
prevent Memory Leaks
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MyCrystalNonPolymersSymmetricUnit(int) const;
Description: returns its nonpolymers symmetric unit generated with the
matrix and vector retrieved from its SpaceGroup's member
function NthTransformationValues(int i)
Usage:
Caution: This entity list needs to be deleted after use, in order to
prevent Memory Leaks
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Entity * MyCrystalSymmetricUnit(int) const;
Description: returns its (Poly && NonPoly) symmetric unit generated with the
matrix and vector retrieved from its SpaceGroup's member
function NthTransformationValues(int i)
Usage:
Caution: This entity list needs to be deleted after use, in order to
prevent Memory Leaks
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Sheet * MySheets() const
Description: returns its sheet list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: Site * MySites() const
Description: returns its sites list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: CovalBond * MyCovalBonds() const
Description: returns its coval bonds list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: HydroBond * MyHydroBonds() const
Description: returns its hydrobonds list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SaltBridge * MySaltBridges() const
Description: returns its salt bridge list
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: Compound

Method: SSBond * MySSBonds() const
Description: returns its ssbond list
Usage:
Caution:
/*********************************************************************


Class IntrBond

/*********************************************************************
Class: IntrBond

Method: IntrBond();
Description: DEF CTOR for the Bond
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrBond

Method: IntrBond(const IntrBond&);
Description: shallow COPY CTOR for Bond. Just points to the same
begin and end atoms
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrBond

Method: IntrBond(ATom *b, ATom *e);
Description: creates a bond with begin atom b, and end atom e.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrBond

Method: ATom *BeginAtom()
Description: returns its BeginAtom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrBond

Method: ATom *EndAtom()
Description: returns its EndAtom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrBond

Method: Bond *NextBond()
Description: returns its next bond member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrBond

Method: Bond **NextBondAddress()
Description: returns the address of its _next member
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrBond

Method: virtual int operator==(IntrBond&);
Description: returns TRUE if the begin atoms and end atoms are equal.
Usage:
Caution:
/*********************************************************************


Class IntrCovalBond

/*********************************************************************
Class: IntrCovalBond

Method: IntrCovalBond()
Description: DEF CTOR for the CovalBond
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrCovalBond

Method: IntrCovalBond(ATom *b, ATom *e)
Description: creates a CovalBond with begin atom b, and end atom e.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrCovalBond

Method: int operator==(IntrBond&);
Description: returns TRUE if the begin atoms and end atoms are equal OR
both Begin Atoms are equal to the opposite bonds end atoms
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrCovalBond

Method: CovalBond *NextCovalBond()
Description: return its _next member
Usage:
Caution:
/*********************************************************************


Class IntrSSBond

/*********************************************************************
Class: IntrSSBond

Method: IntrSSBond()
Description: DEF CTOR for the SSBond
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrSSBond

Method: IntrSSBond(ATom *b, ATom *e)
Description: creates a bond with begin atom b, and end atom e.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrSSBond

Method: SSBond *NextSSBond()
Description: returns its _next member
Usage:
Caution:
/*********************************************************************


Class IntrHydroBond

/*********************************************************************
Class: IntrHydroBond

Method: IntrHydroBond()
Description: DEF CTOR for the HydroBond
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrHydroBond

Method: IntrHydroBond(ATom *d, ATom *a)
Description: creates a bond with begin/donar atom d, and
end/acceptor atom a.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrHydroBond

Method: ATom *DonorAtom()
Description: returns its begin/donar atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrHydroBond

Method: ATom *AcceptorAtom()
Description: returns its end/acceptor atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrHydroBond

Method: HydroBond *NextHydroBond()
Description: returns its _next member
Usage:
Caution:
/*********************************************************************


Class IntrSaltBridge

/*********************************************************************
Class: IntrSaltBridge

Method: IntrSaltBridge()
Description: DEF CTOR for SaltBridge
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrSaltBridge

Method: IntrSaltBridge(ATom *n, ATom *p)
Description: creates a bond with begin/negative atom n,
and end/positive atom p.
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrSaltBridge

Method: ATom *NegativeAtom()
Description: returns its begin/negative atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrSaltBridge

Method: ATom *PositiveAtom()
Description: returns its end/positive atom
Usage:
Caution:
/*********************************************************************
/*********************************************************************
Class: IntrSaltBridge

Method: SaltBridge *NextSaltBridge()
Description: returns its _next member
Usage:
Caution:
/*********************************************************************

Back to The PDBlib


Back to The Macromolecular Structure Classes


Currently under Heavy Construction, please excuse the mess


jcooper@cuhhca.hhmi.columbia.edu