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 (21 years, 7 months ago) by mmeineke
File size:	8617 byte(s)
Log Message:	* empty log message *
#	Content
1	#include <cstdlib>
2	#include <cstdio>
3
4	#include "MakeStamps.hpp"
5	#include "MoleculeStamp.hpp"
6	#include "simError.h"
7	#include "mpiBASS.h"
8
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	sprintf( painCave.errMsg,
64	"There has been an overflow error in the MakeStamps hash key.");
65	painCave.isFatal = 1;
66	simError();
67	#ifdef IS_MPI
68	if( painCave.isEventLoop ){
69	if( worldRank == 0 ) mpiInterfaceExit();
70	}
71	#endif //is_mpi
72	}
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	the_event->err_msg = current_mol->assignString( the_event->evt.asmt.lhs,
115	the_event->evt.asmt.rhs.sval );
116	break;
117
118	case DOUBLE:
119	the_event->err_msg = current_mol->assignDouble( the_event->evt.asmt.lhs,
120	the_event->evt.asmt.rhs.dval );
121	break;
122
123	case INT:
124	the_event->err_msg = current_mol->assignInt( the_event->evt.asmt.lhs,
125	the_event->evt.asmt.rhs.ival );
126	break;
127
128	default:
129	the_event->err_msg = strdup( "MakeStamp error. Invalid molecule"
130	" assignment type" );
131	return 0;
132	break;
133	}
134	if( the_event->err_msg != NULL ) return 0;
135	return 1;
136	}
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	the_event->err_msg =
181	current_atom->assignString( the_event->evt.asmt.lhs,
182	the_event->evt.asmt.rhs.sval );
183	if( the_event->err_msg != NULL ) return 0;
184	return 1;
185	break;
186
187	case DOUBLE:
188	the_event->err_msg =
189	current_atom->assignDouble( the_event->evt.asmt.lhs,
190	the_event->evt.asmt.rhs.dval );
191	if( the_event->err_msg != NULL ) return 0;
192	return 1;
193	break;
194
195	case INT:
196	the_event->err_msg =
197	current_atom->assignInt( the_event->evt.asmt.lhs,
198	the_event->evt.asmt.rhs.ival );
199	if( the_event->err_msg != NULL ) return 0;
200	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	}