mdtools/interface_implementation/MakeStamps.cpp

#include <cstdlib>
#include <cstdio>

#include "MakeStamps.hpp"
#include "MoleculeStamp.hpp"
#include "simError.h"
#include "mpiBASS.h"

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