ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libBASS/MakeStamps.cpp
(Generate patch)

Comparing trunk/OOPSE/libBASS/MakeStamps.cpp (file contents):
Revision 378 by mmeineke, Fri Mar 21 17:42:12 2003 UTC vs.
Revision 1256 by gezelter, Thu Jun 10 14:59:14 2004 UTC

# Line 1 | Line 1
1 < #include <cstdlib>
2 < #include <cstdio>
1 > #include <stdlib.h>
2 > #include <stdio.h>
3 > #include <string.h>
4  
5   #include "MakeStamps.hpp"
6   #include "MoleculeStamp.hpp"
7 + #include "RigidBodyStamp.hpp"
8 + #include "CutoffGroupStamp.hpp"
9   #include "simError.h"
10   #ifdef IS_MPI
11   #include "mpiBASS.h"
# Line 89 | Line 92 | MakeStamps::MakeStamps(){
92   MakeStamps::MakeStamps(){
93    
94    int i;
95 +
96 +  hash_size = 47;
97 +  hash_shift = 4;
98    
99    my_mols = new LinkedMolStamp*[hash_size];
100    for( i=0; i<hash_size; i++ ){
# Line 208 | Line 214 | int MakeStamps::moleculeEnd( event* the_event ){
214    return 1;
215   }
216  
217 + int MakeStamps::newRigidBody( event* the_event ){
218 +  
219 +  current_rigidbody = new RigidBodyStamp;
220 +
221 +  printf("makeStamps rb index = %d\n", the_event->evt.blk_index);
222 +  
223 +  the_event->err_msg = current_mol->addRigidBody( current_rigidbody,
224 +                                                  the_event->evt.blk_index );
225 +  if( the_event->err_msg != NULL ) return 0;
226 +  return 1;
227 + }
228 +
229 + int MakeStamps::rigidBodyAssign( event* the_event ){
230 +
231 +  switch( the_event->evt.asmt.asmt_type ){
232 +    
233 +  case STRING:
234 +    the_event->err_msg =
235 +      current_rigidbody->assignString( the_event->evt.asmt.lhs,
236 +                                       the_event->evt.asmt.rhs.sval );
237 +    if( the_event->err_msg != NULL ) return 0;
238 +    return 1;
239 +    break;
240 +    
241 +  case DOUBLE:
242 +    the_event->err_msg =
243 +      current_rigidbody->assignDouble( the_event->evt.asmt.lhs,
244 +                                       the_event->evt.asmt.rhs.dval );
245 +    if( the_event->err_msg != NULL ) return 0;
246 +    return 1;    
247 +    break;
248 +
249 +  case INT:
250 +    the_event->err_msg =
251 +      current_rigidbody->assignInt( the_event->evt.asmt.lhs,
252 +                                    the_event->evt.asmt.rhs.ival );
253 +    if( the_event->err_msg != NULL ) return 0;
254 +    return 1;
255 +    break;
256 +    
257 +  default:
258 +    the_event->err_msg = strdup( "MakeStamp error. Invalid rigidBody"
259 +                                 " assignment type" );
260 +    return 0;
261 +    break;
262 +  }
263 +  return 0;
264 + }
265 +
266 + int MakeStamps::rigidBodyMembers( event* the_event ){
267 +
268 +  int i;
269 +
270 +  if( the_event->evt.mbrs.nMembers > 0 ){
271 +
272 +    for (i = 0; i < the_event->evt.mbrs.nMembers; i++) {      
273 +      current_rigidbody->addMember(the_event->evt.mbrs.memberList[i]);
274 +    }
275 +    
276 +    return 1;
277 +    
278 +  } else {
279 +    the_event->err_msg = strdup( "MakeStamp error. No members in memberList "
280 +                                 " for this rigidBody.");
281 +    return 0;
282 +
283 +  }
284 + }
285 +
286 + int MakeStamps::rigidBodyEnd( event* the_event ){
287 +
288 +  the_event->err_msg = current_rigidbody->checkMe();
289 +  if( the_event->err_msg != NULL ) return 0;
290 +  
291 +  return 1;
292 + }
293 +
294 + int MakeStamps::newCutoffGroup( event* the_event ){
295 +  
296 +  current_cutoffgroup = new CutoffGroupStamp;
297 +  
298 +  the_event->err_msg = current_mol->addCutoffGroup( current_cutoffgroup,
299 +                                                    the_event->evt.blk_index );
300 +  if( the_event->err_msg != NULL ) return 0;
301 +  return 1;
302 + }
303 +
304 + int MakeStamps::cutoffGroupAssign( event* the_event ){
305 +  
306 +  switch( the_event->evt.asmt.asmt_type ){
307 +    
308 +  case STRING:
309 +    the_event->err_msg =
310 +      current_cutoffgroup->assignString( the_event->evt.asmt.lhs,
311 +                                         the_event->evt.asmt.rhs.sval );
312 +    if( the_event->err_msg != NULL ) return 0;
313 +    return 1;
314 +    break;
315 +    
316 +  case DOUBLE:
317 +    the_event->err_msg =
318 +      current_cutoffgroup->assignDouble( the_event->evt.asmt.lhs,
319 +                                         the_event->evt.asmt.rhs.dval );
320 +    if( the_event->err_msg != NULL ) return 0;
321 +    return 1;    
322 +    break;
323 +    
324 +  case INT:
325 +    the_event->err_msg =
326 +      current_cutoffgroup->assignInt( the_event->evt.asmt.lhs,
327 +                                      the_event->evt.asmt.rhs.ival );
328 +    if( the_event->err_msg != NULL ) return 0;
329 +    return 1;
330 +    break;
331 +    
332 +  default:
333 +    the_event->err_msg = strdup( "MakeStamp error. Invalid CutoffGroup"
334 +                                 " assignment type" );
335 +    return 0;
336 +    break;
337 +  }
338 +  return 0;
339 + }
340 +
341 + int MakeStamps::cutoffGroupMembers( event* the_event ){
342 +
343 +  int i;
344 +  
345 +  if( the_event->evt.mbrs.nMembers > 0 ){
346 +    
347 +    for (i = 0; i < the_event->evt.mbrs.nMembers; i++) {      
348 +      current_cutoffgroup->addMember(the_event->evt.mbrs.memberList[i]);
349 +    }
350 +    
351 +    return 1;
352 +    
353 +  } else {
354 +    the_event->err_msg = strdup( "MakeStamp error. No members in memberList "
355 +                                 " for this CutoffGroup.");
356 +    return 0;
357 +
358 +  }
359 + }
360 +
361 + int MakeStamps::cutoffGroupEnd( event* the_event ){
362 +  
363 +  the_event->err_msg = current_cutoffgroup->checkMe();
364 +  if( the_event->err_msg != NULL ) return 0;
365 +  
366 +  return 1;
367 + }
368 +
369   int MakeStamps::newAtom( event* the_event ){
370    
371    current_atom = new AtomStamp;
372    
373    the_event->err_msg = current_mol->addAtom( current_atom,
374                                               the_event->evt.blk_index );
375 +  
376    if( the_event->err_msg != NULL ) return 0;
377    return 1;
378   }
# Line 229 | Line 388 | int MakeStamps::atomOrientation( event* the_event ){
388  
389   int MakeStamps::atomOrientation( event* the_event ){
390    
391 <  current_atom->setOrientation( the_event->evt.ornt.x,
392 <                                the_event->evt.ornt.y,
393 <                                the_event->evt.ornt.z );
391 >  current_atom->setOrientation( the_event->evt.ornt.phi,
392 >                                the_event->evt.ornt.theta,
393 >                                the_event->evt.ornt.psi );
394    return 1;
395   }
396  
# Line 322 | Line 481 | int MakeStamps::bondAssign( event* the_event ){
481    return 0;
482   }
483  
484 < int MakeStamps::bondMember( event* the_event ){
484 > int MakeStamps::bondMembers( event* the_event ){
485 >  
486 >  if( the_event->evt.mbrs.nMembers == 2 ){
487 >    
488 >    current_bond->members( the_event->evt.mbrs.memberList[0],
489 >                           the_event->evt.mbrs.memberList[1] );
490 >    return 1;
491  
492 <  current_bond->members( the_event->evt.mbr.a,
493 <                         the_event->evt.mbr.b );
494 <  return 1;
492 >  } else {
493 >    the_event->err_msg = strdup( "MakeStamp error. Wrong number of members "
494 >                                 " in bond");
495 >    return 0;
496 >
497 >  }
498 >
499   }
500  
501   int MakeStamps::bondConstraint( event* the_event ){
# Line 385 | Line 554 | int MakeStamps::bendAssign( event* the_event ){
554    return 0;
555   }
556  
557 < int MakeStamps::bendMember( event* the_event ){
557 > int MakeStamps::bendMembers( event* the_event ){
558  
559 <  current_bend->members( the_event->evt.mbr.a,
560 <                         the_event->evt.mbr.b,
561 <                         the_event->evt.mbr.c );
562 <  return 1;
559 >
560 >  switch( the_event->evt.mbrs.nMembers ) {
561 >  case 3:
562 >    current_bend->members( the_event->evt.mbrs.memberList[0],
563 >                           the_event->evt.mbrs.memberList[1],
564 >                           the_event->evt.mbrs.memberList[2]);
565 >    return 1;
566 >    break;
567 >  case 2:
568 >    current_bend->members( the_event->evt.mbrs.memberList[0],
569 >                           the_event->evt.mbrs.memberList[1],
570 >                           0 );
571 >    return 1;
572 >    break;
573 >  default:      
574 >    the_event->err_msg = strdup( "MakeStamp error. Wrong number of members "
575 >                                 "in bend.");
576 >    return 0;
577 >    break;
578 >  }
579 >  return 0;
580   }
581  
582   int MakeStamps::bendConstraint( event* the_event ){
# Line 449 | Line 635 | int MakeStamps::torsionAssign( event* the_event ){
635    return 0;
636   }
637  
638 < int MakeStamps::torsionMember( event* the_event ){
638 > int MakeStamps::torsionMembers( event* the_event ){
639  
640 <  current_torsion->members( the_event->evt.mbr.a,
641 <                            the_event->evt.mbr.b,
642 <                            the_event->evt.mbr.c,
643 <                            the_event->evt.mbr.d );
644 <  return 1;
640 >  if( the_event->evt.mbrs.nMembers == 4 ){
641 >    
642 >    current_torsion->members( the_event->evt.mbrs.memberList[0],
643 >                              the_event->evt.mbrs.memberList[1],
644 >                              the_event->evt.mbrs.memberList[2],
645 >                              the_event->evt.mbrs.memberList[3]);
646 >    return 1;
647 >    
648 >  } else {
649 >    the_event->err_msg = strdup( "MakeStamp error. Wrong number of members "
650 >                                 " in torsion");
651 >    return 0;
652 >
653 >  }
654   }
655  
656   int MakeStamps::torsionConstraint( event* the_event ){

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines