mdtools/interface_implementation/MakeStamps.cpp

#include <cstdlib>
#include <cstdio>

#include "MakeStamps.hpp"
#include "MoleculeStamp.hpp"
#include "simError.h"
#ifdef IS_MPI
#include "mpiBASS.h"
#endif // is_mpi

LinkedMolStamp::~LinkedMolStamp(){ 
  if( mol_stamp != NULL ) delete mol_stamp;
  if( next != NULL ) delete next; 
}

MoleculeStamp* LinkedMolStamp::match( char* id ){

  if( mol_stamp != NULL ){
    
    if(!strcmp( mol_stamp->getID(), id )) return mol_stamp;
    
    if( next != NULL ) return next->match( id );
  }
  
  return NULL;
}

MakeStamps::MakeStamps(){
  
  int i;
  
  my_mols = new LinkedMolStamp*[hash_size];
  for( i=0; i<hash_size; i++ ){
    my_mols[i] = NULL;
  }

}

MakeStamps::~MakeStamps(){
  
  int i;

  for( i=0; i<hash_size; i++ ){
    if( my_mols[i] != NULL ) delete my_mols[i];
  }
  delete[] my_mols;
}

int MakeStamps::hash( char* text ){

  register unsigned short int i = 0; // loop counter
  int key = 0; // the hash key

  while( text[i] != '\0' ){

    key = ( ( key << hash_shift ) + text[i] ) % hash_size;
    
    i++;
  }
  
  if( key < 0 ){

    // if the key is less than zero, we've had an overflow error

    sprintf( painCave.errMsg,
             "There has been an overflow error in the MakeStamps hash key.");
    painCave.isFatal = 1;
    simError();
#ifdef IS_MPI
    if( painCave.isEventLoop ){
      if( worldRank == 0 ) mpiInterfaceExit();
    }
#endif //is_mpi
  }
  
  return key;
}

MoleculeStamp* MakeStamps::getMolecule( char* the_id ){
  int key;
  
  key = hash( the_id );
  if( my_mols[key] != NULL ){
    return my_mols[key]->match( the_id );
  }
  
  return NULL;
}

void MakeStamps::addMolStamp( MoleculeStamp* the_stamp ){

  int key;
  LinkedMolStamp* linked_mol;
  
  key = hash( the_stamp->getID() );

  linked_mol = new LinkedMolStamp;
  linked_mol->setStamp( the_stamp );
  linked_mol->setNext( my_mols[key] );

  my_mols[key] = linked_mol;
}


int MakeStamps::newMolecule( event* the_event ){
  
  current_mol = new MoleculeStamp;
  return 1;
}

int MakeStamps::moleculeAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    the_event->err_msg = current_mol->assignString( the_event->evt.asmt.lhs,
                                      the_event->evt.asmt.rhs.sval );
    break;

  case DOUBLE:
    the_event->err_msg = current_mol->assignDouble( the_event->evt.asmt.lhs,
                                      the_event->evt.asmt.rhs.dval );
    break;
    
  case INT:
    the_event->err_msg = current_mol->assignInt( the_event->evt.asmt.lhs,
                                   the_event->evt.asmt.rhs.ival );
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid molecule"
                                 " assignment type" );
    return 0;
    break;
  }
  if( the_event->err_msg != NULL ) return 0;
  return 1;
}

int MakeStamps::moleculeEnd( event* the_event ){

  the_event->err_msg = current_mol->checkMe();
  // if err_msg is set, then something is wrong
  if( the_event->err_msg != NULL ) return 0; 

  addMolStamp( current_mol );
  return 1;
}

int MakeStamps::newAtom( event* the_event ){
  
  current_atom = new AtomStamp;
  
  the_event->err_msg = current_mol->addAtom( current_atom,
                                             the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;
  return 1;
}

int MakeStamps::atomPosition( event* the_event ){
  
  current_atom->setPosition( the_event->evt.pos.x,
                             the_event->evt.pos.y,
                             the_event->evt.pos.z );
  return 1;
}


int MakeStamps::atomOrientation( event* the_event ){
  
  current_atom->setOrientation( the_event->evt.ornt.x,
                                the_event->evt.ornt.y,
                                the_event->evt.ornt.z );
  return 1;
}

int MakeStamps::atomAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    the_event->err_msg = 
      current_atom->assignString( the_event->evt.asmt.lhs,
                                  the_event->evt.asmt.rhs.sval );
    if( the_event->err_msg != NULL ) return 0;
    return 1;
    break;

  case DOUBLE:
    the_event->err_msg = 
      current_atom->assignDouble( the_event->evt.asmt.lhs,
                                  the_event->evt.asmt.rhs.dval );
    if( the_event->err_msg != NULL ) return 0;
    return 1;    
    break;

  case INT:
    the_event->err_msg = 
      current_atom->assignInt( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.ival );
    if( the_event->err_msg != NULL ) return 0;
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid atom"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::atomEnd( event* the_event ){

  the_event->err_msg = current_atom->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}

int MakeStamps::newBond( event* the_event ){
  
  current_bond = new BondStamp;
  
  the_event->err_msg = current_mol->addBond( current_bond,
                                             the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int MakeStamps::bondAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    current_bond->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

  case DOUBLE:
    current_bond->assignDouble( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.dval );
    return 1;
    break;

  case INT:
    current_bond->assignInt( the_event->evt.asmt.lhs,
                            the_event->evt.asmt.rhs.ival );
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid bond"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::bondMember( event* the_event ){

  current_bond->members( the_event->evt.mbr.a,
                         the_event->evt.mbr.b );
  return 1;
}

int MakeStamps::bondConstraint( event* the_event ){

  current_bond->constrain( the_event->evt.cnstr );
  return 1;
}

int MakeStamps::bondEnd( event* the_event ){

  the_event->err_msg = current_bond->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}

int MakeStamps::newBend( event* the_event ){
  
  current_bend = new BendStamp;
  
  the_event->err_msg = current_mol->addBend( current_bend,
                                             the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int MakeStamps::bendAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    current_bend->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

  case DOUBLE:
    current_bend->assignDouble( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.dval );
    return 1;
    break;

  case INT:
    current_bend->assignInt( the_event->evt.asmt.lhs,
                            the_event->evt.asmt.rhs.ival );
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid bend"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::bendMember( event* the_event ){

  current_bend->members( the_event->evt.mbr.a,
                         the_event->evt.mbr.b,
                         the_event->evt.mbr.c );
  return 1;
}

int MakeStamps::bendConstraint( event* the_event ){

  current_bend->constrain( the_event->evt.cnstr );
  return 1;
}

int MakeStamps::bendEnd( event* the_event ){

  the_event->err_msg = current_bend->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}

int MakeStamps::newTorsion( event* the_event ){
  
  current_torsion = new TorsionStamp;
  
  the_event->err_msg = current_mol->addTorsion( current_torsion,
                                                the_event->evt.blk_index );
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int MakeStamps::torsionAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    current_torsion->assignString( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.sval );
    return 1;
    break;

  case DOUBLE:
    current_torsion->assignDouble( the_event->evt.asmt.lhs,
                               the_event->evt.asmt.rhs.dval );
    return 1;
    break;

  case INT:
    current_torsion->assignInt( the_event->evt.asmt.lhs,
                            the_event->evt.asmt.rhs.ival );
    return 1;
    break;

  default:
    the_event->err_msg = strdup( "MakeStamp error. Invalid torsion"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int MakeStamps::torsionMember( event* the_event ){

  current_torsion->members( the_event->evt.mbr.a,
                            the_event->evt.mbr.b,
                            the_event->evt.mbr.c,
                            the_event->evt.mbr.d );
  return 1;
}

int MakeStamps::torsionConstraint( event* the_event ){

  current_torsion->constrain( the_event->evt.cnstr );
  return 1;
}

int MakeStamps::torsionEnd( event* the_event ){

  the_event->err_msg = current_torsion->checkMe();
  if( the_event->err_msg != NULL ) return 0;
  
  return 1;
}
Revision:	178
Committed:	Mon Nov 18 21:24:02 2002 UTC (21 years, 10 months ago) by mmeineke
File size:	8648 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	mmeineke	10	#include <cstdlib>
2			#include <cstdio>
3
4			#include "MakeStamps.hpp"
5			#include "MoleculeStamp.hpp"
6	mmeineke	160	#include "simError.h"
7	mmeineke	178	#ifdef IS_MPI
8	mmeineke	164	#include "mpiBASS.h"
9	mmeineke	178	#endif // is_mpi
10	mmeineke	10
11			LinkedMolStamp::~LinkedMolStamp(){
12			if( mol_stamp != NULL ) delete mol_stamp;
13			if( next != NULL ) delete next;
14			}
15
16			MoleculeStamp* LinkedMolStamp::match( char* id ){
17
18			if( mol_stamp != NULL ){
19
20			if(!strcmp( mol_stamp->getID(), id )) return mol_stamp;
21
22			if( next != NULL ) return next->match( id );
23			}
24
25			return NULL;
26			}
27
28			MakeStamps::MakeStamps(){
29
30			int i;
31
32			my_mols = new LinkedMolStamp*[hash_size];
33			for( i=0; i<hash_size; i++ ){
34			my_mols[i] = NULL;
35			}
36
37			}
38
39			MakeStamps::~MakeStamps(){
40
41			int i;
42
43			for( i=0; i<hash_size; i++ ){
44			if( my_mols[i] != NULL ) delete my_mols[i];
45			}
46			delete[] my_mols;
47			}
48
49			int MakeStamps::hash( char* text ){
50
51			register unsigned short int i = 0; // loop counter
52			int key = 0; // the hash key
53
54			while( text[i] != '\0' ){
55
56			key = ( ( key << hash_shift ) + text[i] ) % hash_size;
57
58			i++;
59			}
60
61			if( key < 0 ){
62
63			// if the key is less than zero, we've had an overflow error
64
65	mmeineke	160	sprintf( painCave.errMsg,
66	mmeineke	164	"There has been an overflow error in the MakeStamps hash key.");
67	mmeineke	160	painCave.isFatal = 1;
68			simError();
69	mmeineke	164	#ifdef IS_MPI
70			if( painCave.isEventLoop ){
71			if( worldRank == 0 ) mpiInterfaceExit();
72			}
73			#endif //is_mpi
74	mmeineke	10	}
75
76			return key;
77			}
78
79			MoleculeStamp* MakeStamps::getMolecule( char* the_id ){
80			int key;
81
82			key = hash( the_id );
83			if( my_mols[key] != NULL ){
84			return my_mols[key]->match( the_id );
85			}
86
87			return NULL;
88			}
89
90			void MakeStamps::addMolStamp( MoleculeStamp* the_stamp ){
91
92			int key;
93			LinkedMolStamp* linked_mol;
94
95			key = hash( the_stamp->getID() );
96
97			linked_mol = new LinkedMolStamp;
98			linked_mol->setStamp( the_stamp );
99			linked_mol->setNext( my_mols[key] );
100
101			my_mols[key] = linked_mol;
102			}
103
104
105			int MakeStamps::newMolecule( event* the_event ){
106
107			current_mol = new MoleculeStamp;
108			return 1;
109			}
110
111			int MakeStamps::moleculeAssign( event* the_event ){
112
113			switch( the_event->evt.asmt.asmt_type ){
114
115			case STRING:
116	mmeineke	176	the_event->err_msg = current_mol->assignString( the_event->evt.asmt.lhs,
117	mmeineke	164	the_event->evt.asmt.rhs.sval );
118	mmeineke	10	break;
119
120			case DOUBLE:
121	mmeineke	176	the_event->err_msg = current_mol->assignDouble( the_event->evt.asmt.lhs,
122	mmeineke	164	the_event->evt.asmt.rhs.dval );
123	mmeineke	10	break;
124	mmeineke	164
125	mmeineke	10	case INT:
126	mmeineke	176	the_event->err_msg = current_mol->assignInt( the_event->evt.asmt.lhs,
127	mmeineke	164	the_event->evt.asmt.rhs.ival );
128	mmeineke	10	break;
129
130			default:
131			the_event->err_msg = strdup( "MakeStamp error. Invalid molecule"
132			" assignment type" );
133			return 0;
134			break;
135			}
136	mmeineke	176	if( the_event->err_msg != NULL ) return 0;
137			return 1;
138	mmeineke	10	}
139
140			int MakeStamps::moleculeEnd( event* the_event ){
141
142			the_event->err_msg = current_mol->checkMe();
143			// if err_msg is set, then something is wrong
144			if( the_event->err_msg != NULL ) return 0;
145
146			addMolStamp( current_mol );
147			return 1;
148			}
149
150			int MakeStamps::newAtom( event* the_event ){
151
152			current_atom = new AtomStamp;
153
154			the_event->err_msg = current_mol->addAtom( current_atom,
155			the_event->evt.blk_index );
156			if( the_event->err_msg != NULL ) return 0;
157			return 1;
158			}
159
160			int MakeStamps::atomPosition( event* the_event ){
161
162			current_atom->setPosition( the_event->evt.pos.x,
163			the_event->evt.pos.y,
164			the_event->evt.pos.z );
165			return 1;
166			}
167
168
169			int MakeStamps::atomOrientation( event* the_event ){
170
171			current_atom->setOrientation( the_event->evt.ornt.x,
172			the_event->evt.ornt.y,
173			the_event->evt.ornt.z );
174			return 1;
175			}
176
177			int MakeStamps::atomAssign( event* the_event ){
178
179			switch( the_event->evt.asmt.asmt_type ){
180
181			case STRING:
182	mmeineke	176	the_event->err_msg =
183			current_atom->assignString( the_event->evt.asmt.lhs,
184			the_event->evt.asmt.rhs.sval );
185	mmeineke	166	if( the_event->err_msg != NULL ) return 0;
186	mmeineke	10	return 1;
187			break;
188
189			case DOUBLE:
190	mmeineke	176	the_event->err_msg =
191			current_atom->assignDouble( the_event->evt.asmt.lhs,
192			the_event->evt.asmt.rhs.dval );
193	mmeineke	166	if( the_event->err_msg != NULL ) return 0;
194			return 1;
195	mmeineke	10	break;
196
197			case INT:
198	mmeineke	176	the_event->err_msg =
199			current_atom->assignInt( the_event->evt.asmt.lhs,
200			the_event->evt.asmt.rhs.ival );
201	mmeineke	166	if( the_event->err_msg != NULL ) return 0;
202	mmeineke	10	return 1;
203			break;
204
205			default:
206			the_event->err_msg = strdup( "MakeStamp error. Invalid atom"
207			" assignment type" );
208			return 0;
209			break;
210			}
211			return 0;
212			}
213
214			int MakeStamps::atomEnd( event* the_event ){
215
216			the_event->err_msg = current_atom->checkMe();
217			if( the_event->err_msg != NULL ) return 0;
218
219			return 1;
220			}
221
222			int MakeStamps::newBond( event* the_event ){
223
224			current_bond = new BondStamp;
225
226			the_event->err_msg = current_mol->addBond( current_bond,
227			the_event->evt.blk_index );
228			if( the_event->err_msg != NULL ) return 0;
229
230			return 1;
231			}
232
233			int MakeStamps::bondAssign( event* the_event ){
234
235			switch( the_event->evt.asmt.asmt_type ){
236
237			case STRING:
238			current_bond->assignString( the_event->evt.asmt.lhs,
239			the_event->evt.asmt.rhs.sval );
240			return 1;
241			break;
242
243			case DOUBLE:
244			current_bond->assignDouble( the_event->evt.asmt.lhs,
245			the_event->evt.asmt.rhs.dval );
246			return 1;
247			break;
248
249			case INT:
250			current_bond->assignInt( the_event->evt.asmt.lhs,
251			the_event->evt.asmt.rhs.ival );
252			return 1;
253			break;
254
255			default:
256			the_event->err_msg = strdup( "MakeStamp error. Invalid bond"
257			" assignment type" );
258			return 0;
259			break;
260			}
261			return 0;
262			}
263
264			int MakeStamps::bondMember( event* the_event ){
265
266			current_bond->members( the_event->evt.mbr.a,
267			the_event->evt.mbr.b );
268			return 1;
269			}
270
271			int MakeStamps::bondConstraint( event* the_event ){
272
273			current_bond->constrain( the_event->evt.cnstr );
274			return 1;
275			}
276
277			int MakeStamps::bondEnd( event* the_event ){
278
279			the_event->err_msg = current_bond->checkMe();
280			if( the_event->err_msg != NULL ) return 0;
281
282			return 1;
283			}
284
285			int MakeStamps::newBend( event* the_event ){
286
287			current_bend = new BendStamp;
288
289			the_event->err_msg = current_mol->addBend( current_bend,
290			the_event->evt.blk_index );
291			if( the_event->err_msg != NULL ) return 0;
292
293			return 1;
294			}
295
296			int MakeStamps::bendAssign( event* the_event ){
297
298			switch( the_event->evt.asmt.asmt_type ){
299
300			case STRING:
301			current_bend->assignString( the_event->evt.asmt.lhs,
302			the_event->evt.asmt.rhs.sval );
303			return 1;
304			break;
305
306			case DOUBLE:
307			current_bend->assignDouble( the_event->evt.asmt.lhs,
308			the_event->evt.asmt.rhs.dval );
309			return 1;
310			break;
311
312			case INT:
313			current_bend->assignInt( the_event->evt.asmt.lhs,
314			the_event->evt.asmt.rhs.ival );
315			return 1;
316			break;
317
318			default:
319			the_event->err_msg = strdup( "MakeStamp error. Invalid bend"
320			" assignment type" );
321			return 0;
322			break;
323			}
324			return 0;
325			}
326
327			int MakeStamps::bendMember( event* the_event ){
328
329			current_bend->members( the_event->evt.mbr.a,
330			the_event->evt.mbr.b,
331			the_event->evt.mbr.c );
332			return 1;
333			}
334
335			int MakeStamps::bendConstraint( event* the_event ){
336
337			current_bend->constrain( the_event->evt.cnstr );
338			return 1;
339			}
340
341			int MakeStamps::bendEnd( event* the_event ){
342
343			the_event->err_msg = current_bend->checkMe();
344			if( the_event->err_msg != NULL ) return 0;
345
346			return 1;
347			}
348
349			int MakeStamps::newTorsion( event* the_event ){
350
351			current_torsion = new TorsionStamp;
352
353			the_event->err_msg = current_mol->addTorsion( current_torsion,
354			the_event->evt.blk_index );
355			if( the_event->err_msg != NULL ) return 0;
356
357			return 1;
358			}
359
360			int MakeStamps::torsionAssign( event* the_event ){
361
362			switch( the_event->evt.asmt.asmt_type ){
363
364			case STRING:
365			current_torsion->assignString( the_event->evt.asmt.lhs,
366			the_event->evt.asmt.rhs.sval );
367			return 1;
368			break;
369
370			case DOUBLE:
371			current_torsion->assignDouble( the_event->evt.asmt.lhs,
372			the_event->evt.asmt.rhs.dval );
373			return 1;
374			break;
375
376			case INT:
377			current_torsion->assignInt( the_event->evt.asmt.lhs,
378			the_event->evt.asmt.rhs.ival );
379			return 1;
380			break;
381
382			default:
383			the_event->err_msg = strdup( "MakeStamp error. Invalid torsion"
384			" assignment type" );
385			return 0;
386			break;
387			}
388			return 0;
389			}
390
391			int MakeStamps::torsionMember( event* the_event ){
392
393			current_torsion->members( the_event->evt.mbr.a,
394			the_event->evt.mbr.b,
395			the_event->evt.mbr.c,
396			the_event->evt.mbr.d );
397			return 1;
398			}
399
400			int MakeStamps::torsionConstraint( event* the_event ){
401
402			current_torsion->constrain( the_event->evt.cnstr );
403			return 1;
404			}
405
406			int MakeStamps::torsionEnd( event* the_event ){
407
408			the_event->err_msg = current_torsion->checkMe();
409			if( the_event->err_msg != NULL ) return 0;
410
411			return 1;
412			}