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

LinkedMolStamp* LinkedMolStamp::extract( 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
        }
      }
          
      prev->setNext( next );
      if( next != NULL ) next->setPrev( prev );
      return this;
    }
  }
  
  if( next != NULL ) return next->extract( 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;
}

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