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

void LinkedMolStamp::add( LinkedMolStamp* newbie ){
  
  if( next != NULL ) next->add( newbie );
  else{
    next = newbie;
    next->setPrev( this );
  }
}

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

  if( mol_stamp != NULL ){
    if(!strcmp( mol_stamp->getID(), id )){
      
      // make sure we aren't hiding somebody else with the same name
      if(next != NULL ){
        if( next->match( id ) != NULL){
          sprintf( painCave.errMsg,
                   "Molecule Stamp Error. Two separate of declarations of %s present.\n",
                   id );
          painCave.isFatal = 1;
          simError();
#ifdef IS_MPI
          if( painCave.isEventLoop ){
            if( worldRank == 0 ) mpiInterfaceExit();
          }
#endif //is_mpi
        }
        else return mol_stamp;
      }
      else  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] = new LinkedMolStamp();
  }

}

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 );

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