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 (20 years, 2 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
#	Content
1	#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	#include "RigidBodyStamp.hpp"
9	#include "CutoffGroupStamp.hpp"
10	#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	char* addRigidBody( RigidBodyStamp* the_rigidbody, int rigidBodyIndex );
25	char* addCutoffGroup( CutoffGroupStamp* the_cutoffgroup, int cutoffGroupIndex );
26	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	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
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	RigidBodyStamp* getRigidBody( int index ) { return rigidBodies[index]; }
44	CutoffGroupStamp* getCutoffGroup( int index ) { return cutoffGroups[index]; }
45
46	int haveExtras( void ) { return have_extras; }
47	LinkedAssign* getUnhandled( void ) { return unhandled; }
48
49	static char errMsg[500];
50	private:
51
52
53	char name[100];
54	int n_atoms;
55	int n_bonds;
56	int n_bends;
57	int n_torsions;
58	int n_rigidbodies;
59	int n_cutoffgroups;
60	int n_integrable;
61
62	int have_name, have_atoms, have_bonds, have_bends, have_torsions;
63	int have_rigidbodies, have_cutoffgroups;
64
65	AtomStamp** atoms;
66	BondStamp** bonds;
67	BendStamp** bends;
68	TorsionStamp** torsions;
69	RigidBodyStamp** rigidBodies;
70	CutoffGroupStamp** cutoffGroups;
71
72	LinkedAssign* unhandled; // the unhandled assignments
73	short int have_extras;
74	};
75
76	#endif