mdtools/generic_stamps/MoleculeStamp.cpp

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>

#include "MoleculeStamp.hpp"

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

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

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

}

MoleculeStamp::~MoleculeStamp(){
  int i;
  
  if( unhandled != NULL) delete unhandled;

  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];
  }
  
}

void 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;
  }
}

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

  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = (int)rhs;
    
    if( have_atoms ){
      std::cerr << "MoleculeStamp error, n_atoms already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    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 ){
      std::cerr << "MoleculeStamp error, n_bonds already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    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 ){
      std::cerr << "MoleculeStamp error, n_bends already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    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 ){
      std::cerr << "MoleculeStamp error, n_torsions already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    have_torsions = 1;
    torsions = new TorsionStamp*[n_torsions];
    for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
  }
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
}

void MoleculeStamp::assignInt( char* lhs, int rhs ){
  int i;
  
  if( !strcmp( lhs, "nAtoms" ) ){
    n_atoms = rhs;
    
    if( have_atoms ){
      std::cerr << "MoleculeStamp error, n_atoms already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    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 ){
      std::cerr << "MoleculeStamp error, n_bonds already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    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 ){
      std::cerr << "MoleculeStamp error, n_bends already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    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 ){
      std::cerr << "MoleculeStamp error, n_torsions already declared for"
                << " molecule: " << name << "\n";
      exit(1);
    }
    have_torsions = 1;
    torsions = new TorsionStamp*[n_torsions];
    for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
  }
  else{
    if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
    else unhandled->add( lhs, rhs );
    have_extras = 1;
  }
}

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

  return NULL;
}

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

  return NULL;
}

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

  return NULL;
}

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

  return NULL;
}

char* MoleculeStamp::checkMe( void ){
  
  int i;
  short int no_atom;
  char err[120];
  
  if( !have_name || !have_atoms ){
    if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name"
                                    " was not given.\n" );
    else return strdup( "MoleculeStamp error. Molecule contains no atoms." );
  }
  
  no_atom = 0;
  for( i=0; i<n_atoms; i++ ){
    if( atoms[i] == NULL ) no_atom = 1;
  }

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

  return NULL;
}
Revision:	10
Committed:	Tue Jul 9 18:40:59 2002 UTC (22 years ago) by mmeineke
File size:	6576 byte(s)
Log Message:	everything you need to make libmdtools
#	User	Rev	Content
1	mmeineke	10	#include <cstdlib>
2			#include <cstdio>
3			#include <cstring>
4			#include <iostream>
5
6			#include "MoleculeStamp.hpp"
7
8			MoleculeStamp::MoleculeStamp(){
9
10			n_atoms = 0;
11			n_bonds = 0;
12			n_bends = 0;
13			n_torsions = 0;
14
15			unhandled = NULL;
16			atoms = NULL;
17			bonds = NULL;
18			bends = NULL;
19			torsions = NULL;
20
21			have_name = 0;
22			have_atoms = 0;
23			have_bonds = 0;
24			have_bends = 0;
25			have_torsions = 0;
26
27			}
28
29			MoleculeStamp::~MoleculeStamp(){
30			int i;
31
32			if( unhandled != NULL) delete unhandled;
33
34			if( atoms != NULL ){
35			for( i=0; i<n_atoms; i++ ) delete atoms[i];
36			}
37
38			if( bonds != NULL ){
39			for( i=0; i<n_bonds; i++ ) delete bonds[i];
40			}
41
42			if( bends != NULL ){
43			for( i=0; i<n_bends; i++ ) delete bends[i];
44			}
45
46			if( torsions != NULL ){
47			for( i=0; i<n_torsions; i++ ) delete torsions[i];
48			}
49
50			}
51
52			void MoleculeStamp::assignString( char* lhs, char* rhs ){
53
54			if( !strcmp( lhs, "name" ) ){
55			strcpy( name, rhs );
56			have_name = 1;
57			}
58			else{
59			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
60			else unhandled->add( lhs, rhs );
61			have_extras = 1;
62			}
63			}
64
65			void MoleculeStamp::assignDouble( char* lhs, double rhs ){
66			int i;
67
68			if( !strcmp( lhs, "nAtoms" ) ){
69			n_atoms = (int)rhs;
70
71			if( have_atoms ){
72			std::cerr << "MoleculeStamp error, n_atoms already declared for"
73			<< " molecule: " << name << "\n";
74			exit(1);
75			}
76			have_atoms = 1;
77			atoms = new AtomStamp*[n_atoms];
78			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
79			}
80
81			else if( !strcmp( lhs, "nBonds" ) ){
82			n_bonds = (int)rhs;
83
84			if( have_bonds ){
85			std::cerr << "MoleculeStamp error, n_bonds already declared for"
86			<< " molecule: " << name << "\n";
87			exit(1);
88			}
89			have_bonds = 1;
90			bonds = new BondStamp*[n_bonds];
91			for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
92			}
93
94			else if( !strcmp( lhs, "nBends" ) ){
95			n_bends = (int)rhs;
96
97			if( have_bends ){
98			std::cerr << "MoleculeStamp error, n_bends already declared for"
99			<< " molecule: " << name << "\n";
100			exit(1);
101			}
102			have_bends = 1;
103			bends = new BendStamp*[n_bends];
104			for( i=0; i<n_bends; i++ ) bends[i] = NULL;
105			}
106
107			else if( !strcmp( lhs, "nTorsions" ) ){
108			n_torsions = (int)rhs;
109
110			if( have_torsions ){
111			std::cerr << "MoleculeStamp error, n_torsions already declared for"
112			<< " molecule: " << name << "\n";
113			exit(1);
114			}
115			have_torsions = 1;
116			torsions = new TorsionStamp*[n_torsions];
117			for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
118			}
119			else{
120			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
121			else unhandled->add( lhs, rhs );
122			have_extras = 1;
123			}
124			}
125
126			void MoleculeStamp::assignInt( char* lhs, int rhs ){
127			int i;
128
129			if( !strcmp( lhs, "nAtoms" ) ){
130			n_atoms = rhs;
131
132			if( have_atoms ){
133			std::cerr << "MoleculeStamp error, n_atoms already declared for"
134			<< " molecule: " << name << "\n";
135			exit(1);
136			}
137			have_atoms = 1;
138			atoms = new AtomStamp*[n_atoms];
139			for( i=0; i<n_atoms; i++ ) atoms[i] = NULL;
140			}
141
142			else if( !strcmp( lhs, "nBonds" ) ){
143			n_bonds = rhs;
144
145			if( have_bonds ){
146			std::cerr << "MoleculeStamp error, n_bonds already declared for"
147			<< " molecule: " << name << "\n";
148			exit(1);
149			}
150			have_bonds = 1;
151			bonds = new BondStamp*[n_bonds];
152			for( i=0; i<n_bonds; i++ ) bonds[i] = NULL;
153			}
154
155			else if( !strcmp( lhs, "nBends" ) ){
156			n_bends = rhs;
157
158			if( have_bends ){
159			std::cerr << "MoleculeStamp error, n_bends already declared for"
160			<< " molecule: " << name << "\n";
161			exit(1);
162			}
163			have_bends = 1;
164			bends = new BendStamp*[n_bends];
165			for( i=0; i<n_bends; i++ ) bends[i] = NULL;
166			}
167
168			else if( !strcmp( lhs, "nTorsions" ) ){
169			n_torsions = rhs;
170
171			if( have_torsions ){
172			std::cerr << "MoleculeStamp error, n_torsions already declared for"
173			<< " molecule: " << name << "\n";
174			exit(1);
175			}
176			have_torsions = 1;
177			torsions = new TorsionStamp*[n_torsions];
178			for( i=0; i<n_torsions; i++ ) torsions[i] = NULL;
179			}
180			else{
181			if( unhandled == NULL ) unhandled = new LinkedAssign( lhs, rhs );
182			else unhandled->add( lhs, rhs );
183			have_extras = 1;
184			}
185			}
186
187			char* MoleculeStamp::addAtom( AtomStamp* the_atom, int atomIndex ){
188
189			char err[200];
190
191			if( have_atoms && atomIndex < n_atoms ) atoms[atomIndex] = the_atom;
192			else{
193			if( have_atoms ){
194			sprintf( err, "MoleculeStamp error, %d out of nAtoms range",
195			atomIndex );
196			return strdup( err );
197			}
198			else return strdup("MoleculeStamp error, nAtoms not given before"
199			"first atom declaration." );
200			}
201
202			return NULL;
203			}
204
205			char* MoleculeStamp::addBond( BondStamp* the_bond, int bondIndex ){
206
207			char err[200];
208
209			if( have_bonds && bondIndex < n_bonds ) bonds[bondIndex] = the_bond;
210			else{
211			if( have_bonds ){
212			sprintf( err, "MoleculeStamp error, %d out of nBonds range",
213			bondIndex );
214			return strdup( err );
215			}
216			else return strdup("MoleculeStamp error, nBonds not given before"
217			"first bond declaration." );
218			}
219
220			return NULL;
221			}
222
223			char* MoleculeStamp::addBend( BendStamp* the_bend, int bendIndex ){
224
225			char err[200];
226
227			if( have_bends && bendIndex < n_bends ) bends[bendIndex] = the_bend;
228			else{
229			if( have_bends ){
230			sprintf( err, "MoleculeStamp error, %d out of nBends range",
231			bendIndex );
232			return strdup( err );
233			}
234			else return strdup("MoleculeStamp error, nBends not given before"
235			"first bend declaration." );
236			}
237
238			return NULL;
239			}
240
241			char* MoleculeStamp::addTorsion( TorsionStamp* the_torsion, int torsionIndex ){
242
243			char err[200];
244
245			if( have_torsions && torsionIndex < n_torsions )
246			torsions[torsionIndex] = the_torsion;
247			else{
248			if( have_torsions ){
249			sprintf( err, "MoleculeStamp error, %d out of nTorsions range",
250			torsionIndex );
251			return strdup( err );
252			}
253			else return strdup("MoleculeStamp error, nTorsions not given before"
254			"first torsion declaration." );
255			}
256
257			return NULL;
258			}
259
260			char* MoleculeStamp::checkMe( void ){
261
262			int i;
263			short int no_atom;
264			char err[120];
265
266			if( !have_name \|\| !have_atoms ){
267			if( !have_name ) return strdup( "MoleculeStamp error. Molecule's name"
268			" was not given.\n" );
269			else return strdup( "MoleculeStamp error. Molecule contains no atoms." );
270			}
271
272			no_atom = 0;
273			for( i=0; i<n_atoms; i++ ){
274			if( atoms[i] == NULL ) no_atom = 1;
275			}
276
277			if( no_atom ){
278			sprintf( err,
279			"MoleculeStamp error. Not all of the atoms were"
280			" declared in molecule \"%s\".\n", name );
281			return strdup( err );
282			}
283
284			return NULL;
285			}