OOPSE/libBASS/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;

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