OOPSE/libBASS/MoleculeStamp.cpp

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>

#include "MoleculeStamp.hpp"

char MoleculeStamp::errMsg[500];

MoleculeStamp::MoleculeStamp(){
  
  n_atoms = 0;
  n_bonds = 0;
  n_bends = 0;
  n_torsions = 0;
  n_rigidbodies = 0;
  n_cutoffgroups = 0;
  n_integrable = 0;

  unhandled = NULL;
  atoms = NULL;
  bonds = NULL;
  bends = NULL;
  torsions = NULL;
  rigidBodies = NULL;
  cutoffGroups = NULL;

  have_name = 0;
  have_atoms = 0;
  have_bonds = 0;
  have_bends = 0;
  have_torsions = 0;
  have_rigidbodies = 0;
  have_cutoffgroups = 0;

}

MoleculeStamp::~MoleculeStamp(){
  int i;
  
  if( unhandled != NULL) delete unhandled;
  
  if( rigidBodies != NULL ) {
    for( i=0; i<n_rigidbodies; i++ ) delete rigidBodies[i];
  }

  if( cutoffGroups != NULL ) {
    for( i=0; i<n_cutoffgroups; i++ ) delete cutoffGroups[i];
  }
  
  if( atoms != NULL ){
    for( i=0; i<n_atoms; i++ ) delete atoms[i];
  }
  
  if( bonds != NULL ){
    for( i=0; i<n_bonds; i++ ) delete bonds[i];
  }
  
  if( bends != NULL ){
    for( i=0; i<n_bends; i++ ) delete bends[i];
  }
  
  if( torsions != NULL ){
    for( i=0; i<n_torsions; i++ ) delete torsions[i];
  }
  
}

char* MoleculeStamp::assignString( char* lhs, char* rhs ){
  
  if( !strcmp( lhs, "name" ) ){
    strcpy( name, rhs );
    have_name = 1;
  }
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char* MoleculeStamp::assignDouble( char* lhs, double rhs ){
  int i;

  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = (int)rhs;
    
    if( have_atoms ){
      sprintf( errMsg,
               "MoleculeStamp error, n_atoms already declared"
               " for molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_atoms = 1;
    atoms = new AtomStamp*[n_atoms];
    for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBonds" ) ){
    n_bonds = (int)rhs;

    if( have_bonds ){
      sprintf( errMsg,  
               "MoleculeStamp error, n_bonds already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_bonds = 1;
    bonds = new BondStamp*[n_bonds];
    for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBends" ) ){
    n_bends = (int)rhs;

    if( have_bends ){
      sprintf( errMsg,
               "MoleculeStamp error, n_bends already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_bends = 1;
    bends = new BendStamp*[n_bends];
    for( i=0; i<n_bends; i++ ) bends[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nTorsions" ) ){
    n_torsions = (int)rhs;

    if( have_torsions ){
      sprintf( errMsg,
               "MoleculeStamp error, n_torsions already declared for"
               " molecule: %s\n",
               name );
      return strdup( errMsg );
    }
    have_torsions = 1;
    torsions = new TorsionStamp*[n_torsions];
    for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
  }

  else if( !strcmp( lhs, "nRigidBodies" ) ){
    n_rigidbodies = (int)rhs;

    if( have_rigidbodies ){
      sprintf( errMsg,
               "MoleculeStamp error, n_rigidbodies already declared for"
               " molecule: %s\n",
               name );
      return strdup( errMsg );
    }
    have_rigidbodies = 1;
    rigidBodies = new RigidBodyStamp*[n_rigidbodies];
    for( i=0; i<n_rigidbodies; i++ ) rigidBodies[i] = NULL;
  }

  else if( !strcmp( lhs, "nCutoffGroups" ) ){
    n_cutoffgroups = (int)rhs;

    if( have_cutoffgroups ){
      sprintf( errMsg,
               "MoleculeStamp error, n_cutoffgroups already declared for"
               " molecule: %s\n",
               name );
      return strdup( errMsg );
    }
    have_cutoffgroups = 1;
    cutoffGroups = new CutoffGroupStamp*[n_cutoffgroups];
    for( i=0; i<n_cutoffgroups; i++ ) cutoffGroups[i] = NULL;
  }
  
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char*  MoleculeStamp::assignInt( char* lhs, int rhs ){
  int i;
  
  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = rhs;
    
    if( have_atoms ){
      sprintf( errMsg,
               "MoleculeStamp error, n_atoms already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_atoms = 1;
    atoms = new AtomStamp*[n_atoms];
    for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBonds" ) ){
    n_bonds = rhs;

    if( have_bonds ){
      sprintf( errMsg,
               "MoleculeStamp error, n_bonds already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_bonds = 1;
    bonds = new BondStamp*[n_bonds];
    for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nBends" ) ){
    n_bends = rhs;

    if( have_bends ){
      sprintf( errMsg,
               "MoleculeStamp error, n_bends already declared for"
               " molecule: %s\n",
               name );
      return strdup( errMsg );
    }
    have_bends = 1;
    bends = new BendStamp*[n_bends];
    for( i=0; i<n_bends; i++ ) bends[i] = NULL;
  }
  
  else if( !strcmp( lhs, "nTorsions" ) ){
    n_torsions = rhs;

    if( have_torsions ){
      sprintf( errMsg,
               "MoleculeStamp error, n_torsions already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_torsions = 1;
    torsions = new TorsionStamp*[n_torsions];
    for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
  }

  else if( !strcmp( lhs, "nRigidBodies" ) ){
    n_rigidbodies = rhs;

    if( have_rigidbodies ){
      sprintf( errMsg,
               "MoleculeStamp error, n_rigidbodies already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_rigidbodies = 1;
    rigidBodies = new RigidBodyStamp*[n_rigidbodies];
    for( i=0; i<n_rigidbodies; i++ ) rigidBodies[i] = NULL;
  }
  else if( !strcmp( lhs, "nCutoffGroups" ) ){
    n_cutoffgroups = rhs;

    if( have_cutoffgroups ){
      sprintf( errMsg,
               "MoleculeStamp error, n_cutoffgroups already declared for"
               " molecule: %s\n",
               name);
      return strdup( errMsg );
    }
    have_cutoffgroups = 1;
    cutoffGroups = new CutoffGroupStamp*[n_cutoffgroups];
    for( i=0; i<n_cutoffgroups; i++ ) cutoffGroups[i] = NULL;
  }
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
  return NULL;
}

char* MoleculeStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
  
  if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
  else {
    if( have_atoms ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nAtoms range", 
               atomIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nAtoms not given before"
                       " first atom declaration." );
  }

  return NULL;
}

char* MoleculeStamp::addRigidBody( RigidBodyStamp* the_rigidbody, 
                                   int rigidBodyIndex ){
  
  if( have_rigidbodies && rigidBodyIndex < n_rigidbodies ) 
    rigidBodies[rigidBodyIndex] = the_rigidbody;
  else {
    if( have_rigidbodies ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nRigidBodies range", 
               rigidBodyIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nRigidBodies not given before"
                       " first rigidBody declaration." );
  }
  
  return NULL;
}

char* MoleculeStamp::addCutoffGroup( CutoffGroupStamp* the_cutoffgroup, 
                                     int cutoffGroupIndex ){
  
  if( have_cutoffgroups && cutoffGroupIndex < n_cutoffgroups ) 
    cutoffGroups[cutoffGroupIndex] = the_cutoffgroup;
  else {
    if( have_cutoffgroups ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nCutoffGroups range", 
               cutoffGroupIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nCutoffGroups not given before"
                       " first CutoffGroup declaration." );
  }
  
  return NULL;
}

char* MoleculeStamp::addBond( BondStamp* the_bond, int bondIndex ){
  
  
  if( have_bonds && bondIndex < n_bonds ) bonds[bondIndex] = the_bond;
  else{
    if( have_bonds ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nBonds range", 
               bondIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nBonds not given before"
                       "first bond declaration." );
  }

  return NULL;
}

char* MoleculeStamp::addBend( BendStamp* the_bend, int bendIndex ){
  
  
  if( have_bends && bendIndex < n_bends ) bends[bendIndex] = the_bend;
  else{
    if( have_bends ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nBends range", 
               bendIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nBends not given before"
                       "first bend declaration." );
  }

  return NULL;
}

char* MoleculeStamp::addTorsion( TorsionStamp* the_torsion, int torsionIndex ){
  
  
  if( have_torsions && torsionIndex < n_torsions ) 
    torsions[torsionIndex] = the_torsion;
  else{
    if( have_torsions ){
      sprintf( errMsg, "MoleculeStamp error, %d out of nTorsions range", 
               torsionIndex );
      return strdup( errMsg );
    }
    else return strdup("MoleculeStamp error, nTorsions not given before"
                       "first torsion declaration." );
  }

  return NULL;
}

char* MoleculeStamp::checkMe( void ){
  
  int i;
  short int no_atom, no_rigidbody, no_cutoffgroup;

  if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name"
                                  " was not given.\n" );
  
  if( !have_atoms ){
    return strdup( "MoleculeStamp error. Molecule contains no atoms." );
  }
  
  no_rigidbody = 0;
  for( i=0; i<n_rigidbodies; i++ ){
    if( rigidBodies[i] == NULL ) no_rigidbody = 1;
  }

  if( no_rigidbody ){
    sprintf( errMsg, 
             "MoleculeStamp error. Not all of the RigidBodies were"
             " declared in molecule \"%s\".\n", name );
    return strdup( errMsg );
  }

  no_cutoffgroup = 0;
  for( i=0; i<n_cutoffgroups; i++ ){
    if( cutoffGroups[i] == NULL ) no_cutoffgroup = 1;
  }

  if( no_cutoffgroup ){
    sprintf( errMsg, 
             "MoleculeStamp error. Not all of the CutoffGroups were"
             " declared in molecule \"%s\".\n", name );
    return strdup( errMsg );
  }
  
  no_atom = 0;
  for( i=0; i<n_atoms; i++ ){
    if( atoms[i] == NULL ) no_atom = 1;
  }

  if( no_atom ){
    sprintf( errMsg, 
             "MoleculeStamp error. Not all of the atoms were"
             " declared in molecule \"%s\".\n", name );
    return strdup( errMsg );
  }

  n_integrable = n_atoms;
  for (i = 0; i < n_rigidbodies; i++) 
    n_integrable = n_integrable - rigidBodies[i]->getNMembers() + 1; //rigidbody is an integrable object
  
  if (n_integrable <= 0 || n_integrable > n_atoms) {
    sprintf( errMsg, 
             "MoleculeStamp error. n_integrable is either <= 0 or"
             " greater than n_atoms in molecule \"%s\".\n", name );
    return strdup( errMsg );
  }

  return NULL;
}  
Revision:	1153
Committed:	Tue May 11 04:21:52 2004 UTC (21 years, 5 months ago) by gezelter
File size:	11114 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	gezelter	828	#include <stdlib.h>
2			#include <stdio.h>
3			#include <string.h>
4	mmeineke	377	#include <iostream>
5
6			#include "MoleculeStamp.hpp"
7
8			char MoleculeStamp::errMsg[500];
9
10			MoleculeStamp::MoleculeStamp(){
11
12			n_atoms = 0;
13			n_bonds = 0;
14			n_bends = 0;
15			n_torsions = 0;
16	gezelter	957	n_rigidbodies = 0;
17	gezelter	1153	n_cutoffgroups = 0;
18	gezelter	1103	n_integrable = 0;
19	mmeineke	377
20			unhandled = NULL;
21			atoms = NULL;
22			bonds = NULL;
23			bends = NULL;
24			torsions = NULL;
25	gezelter	957	rigidBodies = NULL;
26	gezelter	1153	cutoffGroups = NULL;
27	mmeineke	377
28			have_name = 0;
29			have_atoms = 0;
30			have_bonds = 0;
31			have_bends = 0;
32			have_torsions = 0;
33	gezelter	957	have_rigidbodies = 0;
34	gezelter	1153	have_cutoffgroups = 0;
35	mmeineke	377
36			}
37
38			MoleculeStamp::~MoleculeStamp(){
39			int i;
40
41			if( unhandled != NULL) delete unhandled;
42	gezelter	957
43			if( rigidBodies != NULL ) {
44			for( i=0; i<n_rigidbodies; i++ ) delete rigidBodies[i];
45			}
46	gezelter	1153
47			if( cutoffGroups != NULL ) {
48			for( i=0; i<n_cutoffgroups; i++ ) delete cutoffGroups[i];
49			}
50	gezelter	957
51	mmeineke	377	if( atoms != NULL ){
52			for( i=0; i<n_atoms; i++ ) delete atoms[i];
53			}
54
55			if( bonds != NULL ){
56			for( i=0; i<n_bonds; i++ ) delete bonds[i];
57			}
58
59			if( bends != NULL ){
60			for( i=0; i<n_bends; i++ ) delete bends[i];
61			}
62
63			if( torsions != NULL ){
64			for( i=0; i<n_torsions; i++ ) delete torsions[i];
65			}
66
67			}
68
69			char* MoleculeStamp::assignString( char* lhs, char* rhs ){
70
71			if( !strcmp( lhs, "name" ) ){
72			strcpy( name, rhs );
73			have_name = 1;
74			}
75			else{
76			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
77			else unhandled->add( lhs, rhs );
78			have_extras = 1;
79			}
80			return NULL;
81			}
82
83			char* MoleculeStamp::assignDouble( char* lhs, double rhs ){
84			int i;
85
86			if( !strcmp( lhs, "nAtoms" ) ){
87			n_atoms = (int)rhs;
88
89			if( have_atoms ){
90			sprintf( errMsg,
91			"MoleculeStamp error, n_atoms already declared"
92	gezelter	981	" for molecule: %s\n",
93	mmeineke	377	name);
94			return strdup( errMsg );
95			}
96			have_atoms = 1;
97			atoms = new AtomStamp*[n_atoms];
98			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
99			}
100
101			else if( !strcmp( lhs, "nBonds" ) ){
102			n_bonds = (int)rhs;
103
104			if( have_bonds ){
105			sprintf( errMsg,
106			"MoleculeStamp error, n_bonds already declared for"
107			" molecule: %s\n",
108			name);
109			return strdup( errMsg );
110			}
111			have_bonds = 1;
112			bonds = new BondStamp*[n_bonds];
113			for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
114			}
115
116			else if( !strcmp( lhs, "nBends" ) ){
117			n_bends = (int)rhs;
118
119			if( have_bends ){
120			sprintf( errMsg,
121			"MoleculeStamp error, n_bends already declared for"
122			" molecule: %s\n",
123			name);
124			return strdup( errMsg );
125			}
126			have_bends = 1;
127			bends = new BendStamp*[n_bends];
128			for( i=0; i<n_bends; i++ ) bends[i] = NULL;
129			}
130
131			else if( !strcmp( lhs, "nTorsions" ) ){
132			n_torsions = (int)rhs;
133
134			if( have_torsions ){
135			sprintf( errMsg,
136			"MoleculeStamp error, n_torsions already declared for"
137			" molecule: %s\n",
138			name );
139			return strdup( errMsg );
140			}
141			have_torsions = 1;
142			torsions = new TorsionStamp*[n_torsions];
143			for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
144			}
145	gezelter	957
146			else if( !strcmp( lhs, "nRigidBodies" ) ){
147			n_rigidbodies = (int)rhs;
148
149			if( have_rigidbodies ){
150			sprintf( errMsg,
151			"MoleculeStamp error, n_rigidbodies already declared for"
152			" molecule: %s\n",
153			name );
154			return strdup( errMsg );
155			}
156			have_rigidbodies = 1;
157			rigidBodies = new RigidBodyStamp*[n_rigidbodies];
158			for( i=0; i<n_rigidbodies; i++ ) rigidBodies[i] = NULL;
159			}
160
161	gezelter	1153	else if( !strcmp( lhs, "nCutoffGroups" ) ){
162			n_cutoffgroups = (int)rhs;
163
164			if( have_cutoffgroups ){
165			sprintf( errMsg,
166			"MoleculeStamp error, n_cutoffgroups already declared for"
167			" molecule: %s\n",
168			name );
169			return strdup( errMsg );
170			}
171			have_cutoffgroups = 1;
172			cutoffGroups = new CutoffGroupStamp*[n_cutoffgroups];
173			for( i=0; i<n_cutoffgroups; i++ ) cutoffGroups[i] = NULL;
174			}
175
176	mmeineke	377	else{
177			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
178			else unhandled->add( lhs, rhs );
179			have_extras = 1;
180			}
181			return NULL;
182			}
183
184			char* MoleculeStamp::assignInt( char* lhs, int rhs ){
185			int i;
186
187			if( !strcmp( lhs, "nAtoms" ) ){
188			n_atoms = rhs;
189
190			if( have_atoms ){
191			sprintf( errMsg,
192			"MoleculeStamp error, n_atoms already declared for"
193			" molecule: %s\n",
194			name);
195			return strdup( errMsg );
196			}
197			have_atoms = 1;
198			atoms = new AtomStamp*[n_atoms];
199			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
200			}
201
202			else if( !strcmp( lhs, "nBonds" ) ){
203			n_bonds = rhs;
204
205			if( have_bonds ){
206			sprintf( errMsg,
207			"MoleculeStamp error, n_bonds already declared for"
208			" molecule: %s\n",
209			name);
210			return strdup( errMsg );
211			}
212			have_bonds = 1;
213			bonds = new BondStamp*[n_bonds];
214			for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
215			}
216
217			else if( !strcmp( lhs, "nBends" ) ){
218			n_bends = rhs;
219
220			if( have_bends ){
221			sprintf( errMsg,
222			"MoleculeStamp error, n_bends already declared for"
223			" molecule: %s\n",
224			name );
225			return strdup( errMsg );
226			}
227			have_bends = 1;
228			bends = new BendStamp*[n_bends];
229			for( i=0; i<n_bends; i++ ) bends[i] = NULL;
230			}
231
232			else if( !strcmp( lhs, "nTorsions" ) ){
233			n_torsions = rhs;
234
235			if( have_torsions ){
236			sprintf( errMsg,
237			"MoleculeStamp error, n_torsions already declared for"
238			" molecule: %s\n",
239			name);
240			return strdup( errMsg );
241			}
242			have_torsions = 1;
243			torsions = new TorsionStamp*[n_torsions];
244			for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
245			}
246	gezelter	957
247			else if( !strcmp( lhs, "nRigidBodies" ) ){
248			n_rigidbodies = rhs;
249
250			if( have_rigidbodies ){
251			sprintf( errMsg,
252	gezelter	1153	"MoleculeStamp error, n_rigidbodies already declared for"
253	gezelter	957	" molecule: %s\n",
254			name);
255			return strdup( errMsg );
256			}
257			have_rigidbodies = 1;
258			rigidBodies = new RigidBodyStamp*[n_rigidbodies];
259			for( i=0; i<n_rigidbodies; i++ ) rigidBodies[i] = NULL;
260			}
261	gezelter	1153	else if( !strcmp( lhs, "nCutoffGroups" ) ){
262			n_cutoffgroups = rhs;
263
264			if( have_cutoffgroups ){
265			sprintf( errMsg,
266			"MoleculeStamp error, n_cutoffgroups already declared for"
267			" molecule: %s\n",
268			name);
269			return strdup( errMsg );
270			}
271			have_cutoffgroups = 1;
272			cutoffGroups = new CutoffGroupStamp*[n_cutoffgroups];
273			for( i=0; i<n_cutoffgroups; i++ ) cutoffGroups[i] = NULL;
274			}
275	mmeineke	377	else{
276			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
277			else unhandled->add( lhs, rhs );
278			have_extras = 1;
279			}
280			return NULL;
281			}
282
283			char* MoleculeStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
284
285			if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
286	gezelter	1103	else {
287	mmeineke	377	if( have_atoms ){
288			sprintf( errMsg, "MoleculeStamp error, %d out of nAtoms range",
289			atomIndex );
290			return strdup( errMsg );
291			}
292			else return strdup("MoleculeStamp error, nAtoms not given before"
293	gezelter	981	" first atom declaration." );
294	mmeineke	377	}
295
296			return NULL;
297			}
298
299	gezelter	957	char* MoleculeStamp::addRigidBody( RigidBodyStamp* the_rigidbody,
300			int rigidBodyIndex ){
301
302			if( have_rigidbodies && rigidBodyIndex < n_rigidbodies )
303			rigidBodies[rigidBodyIndex] = the_rigidbody;
304	gezelter	1103	else {
305	gezelter	957	if( have_rigidbodies ){
306			sprintf( errMsg, "MoleculeStamp error, %d out of nRigidBodies range",
307			rigidBodyIndex );
308			return strdup( errMsg );
309			}
310			else return strdup("MoleculeStamp error, nRigidBodies not given before"
311	gezelter	981	" first rigidBody declaration." );
312	gezelter	957	}
313
314			return NULL;
315			}
316
317	gezelter	1153	char* MoleculeStamp::addCutoffGroup( CutoffGroupStamp* the_cutoffgroup,
318			int cutoffGroupIndex ){
319
320			if( have_cutoffgroups && cutoffGroupIndex < n_cutoffgroups )
321			cutoffGroups[cutoffGroupIndex] = the_cutoffgroup;
322			else {
323			if( have_cutoffgroups ){
324			sprintf( errMsg, "MoleculeStamp error, %d out of nCutoffGroups range",
325			cutoffGroupIndex );
326			return strdup( errMsg );
327			}
328			else return strdup("MoleculeStamp error, nCutoffGroups not given before"
329			" first CutoffGroup declaration." );
330			}
331
332			return NULL;
333			}
334
335	mmeineke	377	char* MoleculeStamp::addBond( BondStamp* the_bond, int bondIndex ){
336
337
338			if( have_bonds && bondIndex < n_bonds ) bonds[bondIndex] = the_bond;
339			else{
340			if( have_bonds ){
341			sprintf( errMsg, "MoleculeStamp error, %d out of nBonds range",
342			bondIndex );
343			return strdup( errMsg );
344			}
345			else return strdup("MoleculeStamp error, nBonds not given before"
346			"first bond declaration." );
347			}
348
349			return NULL;
350			}
351
352			char* MoleculeStamp::addBend( BendStamp* the_bend, int bendIndex ){
353
354
355			if( have_bends && bendIndex < n_bends ) bends[bendIndex] = the_bend;
356			else{
357			if( have_bends ){
358			sprintf( errMsg, "MoleculeStamp error, %d out of nBends range",
359			bendIndex );
360			return strdup( errMsg );
361			}
362			else return strdup("MoleculeStamp error, nBends not given before"
363			"first bend declaration." );
364			}
365
366			return NULL;
367			}
368
369			char* MoleculeStamp::addTorsion( TorsionStamp* the_torsion, int torsionIndex ){
370
371
372			if( have_torsions && torsionIndex < n_torsions )
373			torsions[torsionIndex] = the_torsion;
374			else{
375			if( have_torsions ){
376			sprintf( errMsg, "MoleculeStamp error, %d out of nTorsions range",
377			torsionIndex );
378			return strdup( errMsg );
379			}
380			else return strdup("MoleculeStamp error, nTorsions not given before"
381			"first torsion declaration." );
382			}
383
384			return NULL;
385			}
386
387			char* MoleculeStamp::checkMe( void ){
388
389			int i;
390	gezelter	1153	short int no_atom, no_rigidbody, no_cutoffgroup;
391	gezelter	957
392			if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name"
393			" was not given.\n" );
394	gezelter	988
395			if( !have_atoms ){
396			return strdup( "MoleculeStamp error. Molecule contains no atoms." );
397	mmeineke	377	}
398
399	gezelter	957	no_rigidbody = 0;
400			for( i=0; i<n_rigidbodies; i++ ){
401			if( rigidBodies[i] == NULL ) no_rigidbody = 1;
402			}
403
404			if( no_rigidbody ){
405			sprintf( errMsg,
406			"MoleculeStamp error. Not all of the RigidBodies were"
407			" declared in molecule \"%s\".\n", name );
408			return strdup( errMsg );
409			}
410
411	gezelter	1153	no_cutoffgroup = 0;
412			for( i=0; i<n_cutoffgroups; i++ ){
413			if( cutoffGroups[i] == NULL ) no_cutoffgroup = 1;
414			}
415
416			if( no_cutoffgroup ){
417			sprintf( errMsg,
418			"MoleculeStamp error. Not all of the CutoffGroups were"
419			" declared in molecule \"%s\".\n", name );
420			return strdup( errMsg );
421			}
422
423	mmeineke	377	no_atom = 0;
424			for( i=0; i<n_atoms; i++ ){
425			if( atoms[i] == NULL ) no_atom = 1;
426			}
427
428			if( no_atom ){
429			sprintf( errMsg,
430			"MoleculeStamp error. Not all of the atoms were"
431			" declared in molecule \"%s\".\n", name );
432			return strdup( errMsg );
433			}
434
435	gezelter	1103	n_integrable = n_atoms;
436			for (i = 0; i < n_rigidbodies; i++)
437	tim	1113	n_integrable = n_integrable - rigidBodies[i]->getNMembers() + 1; //rigidbody is an integrable object
438	gezelter	1103
439			if (n_integrable <= 0 \|\| n_integrable > n_atoms) {
440			sprintf( errMsg,
441			"MoleculeStamp error. n_integrable is either <= 0 or"
442			" greater than n_atoms in molecule \"%s\".\n", name );
443			return strdup( errMsg );
444			}
445
446	mmeineke	377	return NULL;
447	gezelter	988	}