OOPSE/libBASS/MoleculeStamp.hpp

#ifndef __MOLECULESTAMP_H__
#define __MOLECULESTAMP_H__

#include "AtomStamp.hpp"
#include "BondStamp.hpp"
#include "BendStamp.hpp"
#include "TorsionStamp.hpp"
#include "RigidBodyStamp.hpp"
#include "CutoffGroupStamp.hpp"
#include "LinkedAssign.hpp"

class MoleculeStamp{

public:
  MoleculeStamp();
  ~MoleculeStamp();

  char* assignString( char* lhs, char* rhs );
  char* assignDouble( char* lhs, double rhs );
  char* assignInt( char* lhs, int rhs );
  char* checkMe( void );

  char* addAtom( AtomStamp* the_atom, int atomIndex );
  char* addRigidBody( RigidBodyStamp* the_rigidbody, int rigidBodyIndex );
  char* addCutoffGroup( CutoffGroupStamp* the_cutoffgroup, int cutoffGroupIndex );
  char* addBond( BondStamp* the_bond, int bondIndex );
  char* addBend( BendStamp* the_bend, int bendIndex );
  char* addTorsion( TorsionStamp* the_torsion, int torsionIndex );  

  char* getID( void )         { return name; }
  int   getNAtoms( void )     { return n_atoms; }
  int   getNBonds( void )     { return n_bonds; }
  int   getNBends( void )     { return n_bends; }
  int   getNTorsions( void )  { return n_torsions; }
  int   getNRigidBodies(void) { return n_rigidbodies; }
  int   getNCutoffGroups(void){ return n_cutoffgroups; }  
  int   getNIntegrable(void)  { return n_integrable; }

  AtomStamp* getAtom( int index ) { return atoms[index]; }
  BondStamp* getBond( int index ) { return bonds[index]; }
  BendStamp* getBend( int index ) { return bends[index]; }
  TorsionStamp* getTorsion( int index ) { return torsions[index]; }
  RigidBodyStamp* getRigidBody( int index ) { return rigidBodies[index]; }
  CutoffGroupStamp* getCutoffGroup( int index ) { return cutoffGroups[index]; }
  
  int haveExtras( void ) { return have_extras; }
  LinkedAssign* getUnhandled( void ) { return unhandled; }
  
  static char errMsg[500];
private:
  
  
  char name[100];
  int n_atoms;
  int n_bonds;
  int n_bends;
  int n_torsions;
  int n_rigidbodies;
  int n_cutoffgroups;
  int n_integrable;
  
  int have_name, have_atoms, have_bonds, have_bends, have_torsions;
  int have_rigidbodies, have_cutoffgroups;

  AtomStamp** atoms;
  BondStamp** bonds;
  BendStamp** bends;
  TorsionStamp** torsions;  
  RigidBodyStamp** rigidBodies;  
  CutoffGroupStamp** cutoffGroups;  

  LinkedAssign* unhandled; // the unhandled assignments
  short int have_extras;
};

#endif
Revision:	1153
Committed:	Tue May 11 04:21:52 2004 UTC (21 years, 5 months ago) by gezelter
File size:	2366 byte(s)
Log Message:	BASS changes for adding CutoffGroups to molecules. Also restructured the plethora of cutoff radii into one cutoffRadius and one switchingRadius. Also removed the useMolecularCutoffs keyword
#	User	Rev	Content
1	mmeineke	377	#ifndef __MOLECULESTAMP_H__
2			#define __MOLECULESTAMP_H__
3
4			#include "AtomStamp.hpp"
5			#include "BondStamp.hpp"
6			#include "BendStamp.hpp"
7			#include "TorsionStamp.hpp"
8	gezelter	957	#include "RigidBodyStamp.hpp"
9	gezelter	1153	#include "CutoffGroupStamp.hpp"
10	mmeineke	377	#include "LinkedAssign.hpp"
11
12			class MoleculeStamp{
13
14			public:
15			MoleculeStamp();
16			~MoleculeStamp();
17
18			char* assignString( char* lhs, char* rhs );
19			char* assignDouble( char* lhs, double rhs );
20			char* assignInt( char* lhs, int rhs );
21			char* checkMe( void );
22
23			char* addAtom( AtomStamp* the_atom, int atomIndex );
24	gezelter	957	char* addRigidBody( RigidBodyStamp* the_rigidbody, int rigidBodyIndex );
25	gezelter	1153	char* addCutoffGroup( CutoffGroupStamp* the_cutoffgroup, int cutoffGroupIndex );
26	mmeineke	377	char* addBond( BondStamp* the_bond, int bondIndex );
27			char* addBend( BendStamp* the_bend, int bendIndex );
28			char* addTorsion( TorsionStamp* the_torsion, int torsionIndex );
29
30	gezelter	1153	char* getID( void ) { return name; }
31			int getNAtoms( void ) { return n_atoms; }
32			int getNBonds( void ) { return n_bonds; }
33			int getNBends( void ) { return n_bends; }
34			int getNTorsions( void ) { return n_torsions; }
35			int getNRigidBodies(void) { return n_rigidbodies; }
36			int getNCutoffGroups(void){ return n_cutoffgroups; }
37			int getNIntegrable(void) { return n_integrable; }
38	mmeineke	377
39			AtomStamp* getAtom( int index ) { return atoms[index]; }
40			BondStamp* getBond( int index ) { return bonds[index]; }
41			BendStamp* getBend( int index ) { return bends[index]; }
42			TorsionStamp* getTorsion( int index ) { return torsions[index]; }
43	gezelter	957	RigidBodyStamp* getRigidBody( int index ) { return rigidBodies[index]; }
44	gezelter	1153	CutoffGroupStamp* getCutoffGroup( int index ) { return cutoffGroups[index]; }
45
46	mmeineke	583	int haveExtras( void ) { return have_extras; }
47			LinkedAssign* getUnhandled( void ) { return unhandled; }
48	gezelter	1153
49	mmeineke	377	static char errMsg[500];
50			private:
51	gezelter	1153
52
53	mmeineke	377	char name[100];
54			int n_atoms;
55			int n_bonds;
56			int n_bends;
57			int n_torsions;
58	gezelter	957	int n_rigidbodies;
59	gezelter	1153	int n_cutoffgroups;
60	gezelter	1103	int n_integrable;
61	mmeineke	377
62			int have_name, have_atoms, have_bonds, have_bends, have_torsions;
63	gezelter	1153	int have_rigidbodies, have_cutoffgroups;
64	mmeineke	377
65			AtomStamp** atoms;
66			BondStamp** bonds;
67			BendStamp** bends;
68			TorsionStamp** torsions;
69	gezelter	957	RigidBodyStamp** rigidBodies;
70	gezelter	1153	CutoffGroupStamp** cutoffGroups;
71	mmeineke	377
72			LinkedAssign* unhandled; // the unhandled assignments
73			short int have_extras;
74			};
75
76			#endif