src/io/mpiBASS.c

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Acknowledgement of the program authors must be made in any
 *    publication of scientific results based in part on use of the
 *    program.  An acceptable form of acknowledgement is citation of
 *    the article in which the program was described (Matthew
 *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
 *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
 *    Parallel Simulation Engine for Molecular Dynamics,"
 *    J. Comput. Chem. 26, pp. 252-271 (2005))
 *
 * 2. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 3. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 */
 
#ifdef IS_MPI
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define __mpiBASSEVENT
#include "io/mpiBASS.h"
#include "utils/simError.h"


void mpiCatchEvent(void);


void mpiEventInit(void)
{
  int blockCounts[5] = {1,3,1,120,80};
  MPI_Aint dspls[5];
  MPI_Datatype types[5];
  mBEvent protoEvent;

  int i;  

  MPI_Address(&protoEvent.type, &dspls[0]);
  MPI_Address(&protoEvent.d1, &dspls[1]);
  MPI_Address(&protoEvent.i1, &dspls[2]);
  MPI_Address(&protoEvent.cArray, &dspls[3]);
  MPI_Address(&protoEvent.lhs   , &dspls[4]);


  types[0] = MPI_INT;
  types[1] = MPI_DOUBLE;
  types[2] = MPI_INT;
  types[3] = MPI_CHAR;
  types[4] = MPI_CHAR;


  for (i =4; i >= 0; i--) dspls[i] -= dspls[0];

  MPI_Type_struct(5,blockCounts,dspls,types,&mpiBASSEventType);
  MPI_Type_commit(&mpiBASSEventType);
}


void throwMPIEvent(event* the_event)
{
  mBEvent mpiEventContainer;
  int mpiStatus;


  if (the_event == NULL)     mpiStatus = MPI_INTERFACE_DONE;
  else                       mpiStatus = MPI_INTERFACE_CONTINUE;
  
  MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
  
  if (!mpiStatus){
    switch (the_event->event_type){
    case MOLECULE:
      mpiEventContainer.type = mpiMOLECULE;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int  
      break;

    case RIGIDBODY:
      mpiEventContainer.type = mpiRIGIDBODY;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int  
      break;

    case CUTOFFGROUP:
      mpiEventContainer.type = mpiCUTOFFGROUP;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int  
      break;

    case ATOM:
      mpiEventContainer.type = mpiATOM;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case BOND:
      mpiEventContainer.type = mpiBOND;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case BEND:
      mpiEventContainer.type = mpiBEND;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case TORSION:
      mpiEventContainer.type = mpiTORSION;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case ZCONSTRAINT:
      mpiEventContainer.type = mpiZCONSTRAINT;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case COMPONENT:
      mpiEventContainer.type = mpiCOMPONENT;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case POSITION:
      mpiEventContainer.type = mpiPOSITION;
      mpiEventContainer.d1 = the_event->evt.pos.x; // pack pos coord into d
      mpiEventContainer.d2 = the_event->evt.pos.y; 
      mpiEventContainer.d3 = the_event->evt.pos.z;   
      break;

    case ORIENTATION:
      mpiEventContainer.type = mpiORIENTATION;
      mpiEventContainer.d1 = the_event->evt.ornt.phi; // pack orientation coord into d
      mpiEventContainer.d2 = the_event->evt.ornt.theta; 
      mpiEventContainer.d3 = the_event->evt.ornt.psi;   
      break;
      
    case CONSTRAINT:
      mpiEventContainer.type = mpiCONSTRAINT;
      mpiEventContainer.d1 = the_event->evt.cnstr; // pack constraint coord into d
      break;
      
    case MEMBERS:
      mpiEventContainer.type = mpiMEMBERS;
      mpiEventContainer.i1 = the_event->evt.mbrs.nMembers ; // pack member ints into i
      break;
      
    case ASSIGNMENT:

      strcpy(mpiEventContainer.lhs,the_event->evt.asmt.lhs);

#ifdef MPIBASS_VERBOSE

      fprintf(stderr, 
              "mpiDiag at node %d: evt Assignment: \"%s\" = ?\n"
              "                    mpi Assignment: \"%s\" = ?\n",
              worldRank, 
              the_event->evt.asmt.lhs,
              mpiEventContainer.lhs);
#endif

      switch (the_event->evt.asmt.asmt_type){
      case STRING:
        mpiEventContainer.type = mpiASSIGNMENT_s;
        strcpy(mpiEventContainer.cArray,the_event->evt.asmt.rhs.sval);
        break;

      case INT:
        mpiEventContainer.type = mpiASSIGNMENT_i;
        mpiEventContainer.i1 = the_event->evt.asmt.rhs.ival;
        break;

      case DOUBLE:
        mpiEventContainer.type = mpiASSIGNMENT_d;
        mpiEventContainer.d1 = the_event->evt.asmt.rhs.dval;
        break;
      }
      break;

    case BLOCK_END:
      mpiEventContainer.type = mpiBLOCK_END;
      break;
    }


    MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);

    if (the_event->event_type == MEMBERS) {

      // For member lists, we need a separate broadcast to spew out the
      // membership array:
      MPI_Bcast(the_event->evt.mbrs.memberList, the_event->evt.mbrs.nMembers, 
                MPI_INT, 0, MPI_COMM_WORLD);
      
    }   

    sprintf( checkPointMsg, 
             "BASS Event broadcast successful" );

    MPIcheckPoint();
  }
}


// Everybody but node 0 runs this
void mpiEventLoop(void)
{
  int mpiContinue;

#ifdef MPIBASS_VERBOSE
  fprintf(stderr, 
          "event key List at node %d:\n"
          "  MOLECULE    %d\n"
          "  ATOM        %d\n"
          "  BOND        %d\n"
          "  BEND        %d\n"
          "  TORSION     %d\n"
          "  COMPONENT   %d\n"
          "  POSITION    %d\n"
          "  ASSIGNMENT  %d\n"
          "  MEMBERS     %d\n"
          "  CONSTRAINT  %d\n"
          "  ORIENTATION %d\n"
          "  ZCONSTRAINT %d\n"
          "  RIGIDBODY   %d\n"
          "  CUTOFFGROUP %d\n"
          "  BLOCK_END   %d\n"
          "\n",
          worldRank,
          MOLECULE, ATOM, BOND, BEND, TORSION, COMPONENT, 
          POSITION, ASSIGNMENT, MEMBERS, CONSTRAINT, ORIENTATION,
          ZCONSTRAINT, RIGIDBODY, CUTOFFGROUP, BLOCK_END );
#endif

  MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);

  while(!mpiContinue){
    
    mpiCatchEvent();

    MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
  }

  if (mpiContinue == MPI_INTERFACE_ABORT){
    MPI_Finalize();
    exit (0);
  }
}

void mpiCatchEvent(void)
{
  event the_event;
  mBEvent mpiEventContainer;

  
  MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);

  switch (mpiEventContainer.type){
  case mpiMOLECULE:
    the_event.event_type = MOLECULE;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;

  case mpiRIGIDBODY:
    the_event.event_type = RIGIDBODY;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;

  case mpiCUTOFFGROUP:
    the_event.event_type = CUTOFFGROUP;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
    
  case mpiATOM:
    the_event.event_type = ATOM;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
    
  case mpiBOND:
    the_event.event_type = BOND;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
      
  case mpiBEND:
    the_event.event_type = BEND;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;

  case mpiTORSION:
    the_event.event_type = TORSION;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;

  case mpiZCONSTRAINT:
    the_event.event_type = ZCONSTRAINT;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
    
  case mpiCOMPONENT:
    the_event.event_type = COMPONENT;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;


  case mpiPOSITION:
    the_event.event_type = POSITION;
    the_event.evt.pos.x = mpiEventContainer.d1; 
    the_event.evt.pos.y = mpiEventContainer.d2; 
    the_event.evt.pos.z = mpiEventContainer.d3;   
    break;

  case mpiORIENTATION:
    the_event.event_type = ORIENTATION;
    the_event.evt.ornt.phi   = mpiEventContainer.d1; 
    the_event.evt.ornt.theta = mpiEventContainer.d2; 
    the_event.evt.ornt.psi   = mpiEventContainer.d3;   
    break;
      
  case mpiCONSTRAINT:
    the_event.event_type = CONSTRAINT;
    the_event.evt.cnstr = mpiEventContainer.d1; 
    break;
    
  case mpiMEMBERS:
    the_event.event_type = MEMBERS;
    the_event.evt.mbrs.nMembers = mpiEventContainer.i1; 

    the_event.evt.mbrs.memberList = (int *) calloc(the_event.evt.mbrs.nMembers,
                                                   sizeof(int));
    
    // Grab the member list since we have a number of members:
    MPI_Bcast(the_event.evt.mbrs.memberList, the_event.evt.mbrs.nMembers, 
              MPI_INT, 0, MPI_COMM_WORLD);
    
    break;
    
  case mpiASSIGNMENT_s:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = STRING;
    strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
    strcpy(the_event.evt.asmt.rhs.sval,mpiEventContainer.cArray);
    
#ifdef MPIBASS_VERBOSE

    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %s\n", worldRank, 
            the_event.evt.asmt.lhs,
            the_event.evt.asmt.rhs.sval );
#endif

    break;

  case mpiASSIGNMENT_i:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = INT;
    strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
    the_event.evt.asmt.rhs.ival = mpiEventContainer.i1;      

#ifdef MPIBASS_VERBOSE

    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %d\n", worldRank, 
            the_event.evt.asmt.lhs,
            the_event.evt.asmt.rhs.ival );
#endif

    break;

  case mpiASSIGNMENT_d:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = DOUBLE;
    strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
    the_event.evt.asmt.rhs.dval = mpiEventContainer.d1;      

#ifdef MPIBASS_VERBOSE

    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %lf\n", worldRank, 
            the_event.evt.asmt.lhs,
            the_event.evt.asmt.rhs.dval );
#endif

    break;

  case mpiBLOCK_END:
    the_event.event_type = BLOCK_END;
    break;
  }

#ifdef MPIBASS_VERBOSE

  fprintf(stderr, "mpiDiag at node %d: event type is %d\n", worldRank, 
          the_event.event_type);
#endif

  if (!event_handler(&the_event)){ 

    sprintf(painCave.errMsg,
            "MPI event handling error at node %d => %s\n",
            worldRank,
            the_event.err_msg);
    painCave.isFatal = 1;
    simError();
  }
  MPIcheckPoint();
}


void mpiInterfaceExit(void){
  int mpiStatus = MPI_INTERFACE_ABORT;
  
  MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
  MPI_Finalize();
  exit (0);

}
#endif
Revision:	2204
Committed:	Fri Apr 15 22:04:00 2005 UTC (19 years, 2 months ago) by gezelter
Content type:	text/plain
File size:	12040 byte(s)
Log Message:	xemacs has been drafted to perform our indentation services
#	User	Rev	Content
1	gezelter	2204	/*
2	gezelter	1930	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3			*
4			* The University of Notre Dame grants you ("Licensee") a
5			* non-exclusive, royalty free, license to use, modify and
6			* redistribute this software in source and binary code form, provided
7			* that the following conditions are met:
8			*
9			* 1. Acknowledgement of the program authors must be made in any
10			* publication of scientific results based in part on use of the
11			* program. An acceptable form of acknowledgement is citation of
12			* the article in which the program was described (Matthew
13			* A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14			* J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15			* Parallel Simulation Engine for Molecular Dynamics,"
16			* J. Comput. Chem. 26, pp. 252-271 (2005))
17			*
18			* 2. Redistributions of source code must retain the above copyright
19			* notice, this list of conditions and the following disclaimer.
20			*
21			* 3. Redistributions in binary form must reproduce the above copyright
22			* notice, this list of conditions and the following disclaimer in the
23			* documentation and/or other materials provided with the
24			* distribution.
25			*
26			* This software is provided "AS IS," without a warranty of any
27			* kind. All express or implied conditions, representations and
28			* warranties, including any implied warranty of merchantability,
29			* fitness for a particular purpose or non-infringement, are hereby
30			* excluded. The University of Notre Dame and its licensors shall not
31			* be liable for any damages suffered by licensee as a result of
32			* using, modifying or distributing the software or its
33			* derivatives. In no event will the University of Notre Dame or its
34			* licensors be liable for any lost revenue, profit or data, or for
35			* direct, indirect, special, consequential, incidental or punitive
36			* damages, however caused and regardless of the theory of liability,
37			* arising out of the use of or inability to use software, even if the
38			* University of Notre Dame has been advised of the possibility of
39			* such damages.
40			*/
41
42	gezelter	1490	#ifdef IS_MPI
43			#include <stdlib.h>
44			#include <stdio.h>
45			#include <string.h>
46
47			#define __mpiBASSEVENT
48	tim	1492	#include "io/mpiBASS.h"
49			#include "utils/simError.h"
50	gezelter	1490
51
52			void mpiCatchEvent(void);
53
54
55
56
57			void mpiEventInit(void)
58			{
59			int blockCounts[5] = {1,3,1,120,80};
60			MPI_Aint dspls[5];
61			MPI_Datatype types[5];
62			mBEvent protoEvent;
63
64			int i;
65
66			MPI_Address(&protoEvent.type, &dspls[0]);
67			MPI_Address(&protoEvent.d1, &dspls[1]);
68			MPI_Address(&protoEvent.i1, &dspls[2]);
69			MPI_Address(&protoEvent.cArray, &dspls[3]);
70			MPI_Address(&protoEvent.lhs , &dspls[4]);
71
72
73			types[0] = MPI_INT;
74			types[1] = MPI_DOUBLE;
75			types[2] = MPI_INT;
76			types[3] = MPI_CHAR;
77			types[4] = MPI_CHAR;
78
79
80			for (i =4; i >= 0; i--) dspls[i] -= dspls[0];
81
82			MPI_Type_struct(5,blockCounts,dspls,types,&mpiBASSEventType);
83			MPI_Type_commit(&mpiBASSEventType);
84			}
85
86
87			void throwMPIEvent(event* the_event)
88			{
89			mBEvent mpiEventContainer;
90			int mpiStatus;
91
92
93			if (the_event == NULL) mpiStatus = MPI_INTERFACE_DONE;
94			else mpiStatus = MPI_INTERFACE_CONTINUE;
95
96			MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
97
98			if (!mpiStatus){
99			switch (the_event->event_type){
100			case MOLECULE:
101			mpiEventContainer.type = mpiMOLECULE;
102			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
103	gezelter	2204	break;
104	gezelter	1490
105			case RIGIDBODY:
106			mpiEventContainer.type = mpiRIGIDBODY;
107			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
108	gezelter	2204	break;
109	gezelter	1490
110			case CUTOFFGROUP:
111			mpiEventContainer.type = mpiCUTOFFGROUP;
112			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
113	gezelter	2204	break;
114	gezelter	1490
115			case ATOM:
116			mpiEventContainer.type = mpiATOM;
117			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
118			break;
119
120			case BOND:
121			mpiEventContainer.type = mpiBOND;
122			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
123			break;
124
125			case BEND:
126			mpiEventContainer.type = mpiBEND;
127			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
128			break;
129
130			case TORSION:
131			mpiEventContainer.type = mpiTORSION;
132			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
133			break;
134
135			case ZCONSTRAINT:
136			mpiEventContainer.type = mpiZCONSTRAINT;
137			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
138			break;
139
140			case COMPONENT:
141			mpiEventContainer.type = mpiCOMPONENT;
142			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
143			break;
144
145			case POSITION:
146			mpiEventContainer.type = mpiPOSITION;
147			mpiEventContainer.d1 = the_event->evt.pos.x; // pack pos coord into d
148			mpiEventContainer.d2 = the_event->evt.pos.y;
149			mpiEventContainer.d3 = the_event->evt.pos.z;
150			break;
151
152			case ORIENTATION:
153			mpiEventContainer.type = mpiORIENTATION;
154			mpiEventContainer.d1 = the_event->evt.ornt.phi; // pack orientation coord into d
155			mpiEventContainer.d2 = the_event->evt.ornt.theta;
156			mpiEventContainer.d3 = the_event->evt.ornt.psi;
157			break;
158
159			case CONSTRAINT:
160			mpiEventContainer.type = mpiCONSTRAINT;
161			mpiEventContainer.d1 = the_event->evt.cnstr; // pack constraint coord into d
162			break;
163
164			case MEMBERS:
165			mpiEventContainer.type = mpiMEMBERS;
166			mpiEventContainer.i1 = the_event->evt.mbrs.nMembers ; // pack member ints into i
167			break;
168
169			case ASSIGNMENT:
170
171			strcpy(mpiEventContainer.lhs,the_event->evt.asmt.lhs);
172
173			#ifdef MPIBASS_VERBOSE
174
175			fprintf(stderr,
176			"mpiDiag at node %d: evt Assignment: \"%s\" = ?\n"
177			" mpi Assignment: \"%s\" = ?\n",
178			worldRank,
179			the_event->evt.asmt.lhs,
180			mpiEventContainer.lhs);
181			#endif
182
183			switch (the_event->evt.asmt.asmt_type){
184			case STRING:
185			mpiEventContainer.type = mpiASSIGNMENT_s;
186			strcpy(mpiEventContainer.cArray,the_event->evt.asmt.rhs.sval);
187			break;
188
189			case INT:
190			mpiEventContainer.type = mpiASSIGNMENT_i;
191			mpiEventContainer.i1 = the_event->evt.asmt.rhs.ival;
192			break;
193
194			case DOUBLE:
195			mpiEventContainer.type = mpiASSIGNMENT_d;
196			mpiEventContainer.d1 = the_event->evt.asmt.rhs.dval;
197			break;
198			}
199			break;
200
201			case BLOCK_END:
202			mpiEventContainer.type = mpiBLOCK_END;
203			break;
204			}
205
206
207			MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);
208
209			if (the_event->event_type == MEMBERS) {
210
211			// For member lists, we need a separate broadcast to spew out the
212			// membership array:
213			MPI_Bcast(the_event->evt.mbrs.memberList, the_event->evt.mbrs.nMembers,
214			MPI_INT, 0, MPI_COMM_WORLD);
215
216			}
217
218			sprintf( checkPointMsg,
219			"BASS Event broadcast successful" );
220
221			MPIcheckPoint();
222			}
223			}
224
225
226			// Everybody but node 0 runs this
227			void mpiEventLoop(void)
228			{
229			int mpiContinue;
230
231			#ifdef MPIBASS_VERBOSE
232			fprintf(stderr,
233			"event key List at node %d:\n"
234			" MOLECULE %d\n"
235			" ATOM %d\n"
236			" BOND %d\n"
237			" BEND %d\n"
238			" TORSION %d\n"
239			" COMPONENT %d\n"
240			" POSITION %d\n"
241			" ASSIGNMENT %d\n"
242			" MEMBERS %d\n"
243			" CONSTRAINT %d\n"
244			" ORIENTATION %d\n"
245			" ZCONSTRAINT %d\n"
246			" RIGIDBODY %d\n"
247			" CUTOFFGROUP %d\n"
248			" BLOCK_END %d\n"
249			"\n",
250			worldRank,
251			MOLECULE, ATOM, BOND, BEND, TORSION, COMPONENT,
252			POSITION, ASSIGNMENT, MEMBERS, CONSTRAINT, ORIENTATION,
253			ZCONSTRAINT, RIGIDBODY, CUTOFFGROUP, BLOCK_END );
254			#endif
255
256			MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
257
258			while(!mpiContinue){
259
260			mpiCatchEvent();
261
262			MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
263			}
264
265			if (mpiContinue == MPI_INTERFACE_ABORT){
266			MPI_Finalize();
267			exit (0);
268			}
269			}
270
271			void mpiCatchEvent(void)
272			{
273			event the_event;
274			mBEvent mpiEventContainer;
275
276
277			MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);
278
279			switch (mpiEventContainer.type){
280			case mpiMOLECULE:
281			the_event.event_type = MOLECULE;
282			the_event.evt.blk_index = mpiEventContainer.i1;
283			break;
284
285			case mpiRIGIDBODY:
286			the_event.event_type = RIGIDBODY;
287			the_event.evt.blk_index = mpiEventContainer.i1;
288			break;
289
290			case mpiCUTOFFGROUP:
291			the_event.event_type = CUTOFFGROUP;
292			the_event.evt.blk_index = mpiEventContainer.i1;
293			break;
294
295			case mpiATOM:
296			the_event.event_type = ATOM;
297			the_event.evt.blk_index = mpiEventContainer.i1;
298			break;
299
300			case mpiBOND:
301			the_event.event_type = BOND;
302			the_event.evt.blk_index = mpiEventContainer.i1;
303			break;
304
305			case mpiBEND:
306			the_event.event_type = BEND;
307			the_event.evt.blk_index = mpiEventContainer.i1;
308			break;
309
310			case mpiTORSION:
311			the_event.event_type = TORSION;
312			the_event.evt.blk_index = mpiEventContainer.i1;
313			break;
314
315			case mpiZCONSTRAINT:
316			the_event.event_type = ZCONSTRAINT;
317			the_event.evt.blk_index = mpiEventContainer.i1;
318			break;
319
320			case mpiCOMPONENT:
321			the_event.event_type = COMPONENT;
322			the_event.evt.blk_index = mpiEventContainer.i1;
323			break;
324
325
326			case mpiPOSITION:
327			the_event.event_type = POSITION;
328			the_event.evt.pos.x = mpiEventContainer.d1;
329			the_event.evt.pos.y = mpiEventContainer.d2;
330			the_event.evt.pos.z = mpiEventContainer.d3;
331			break;
332
333			case mpiORIENTATION:
334			the_event.event_type = ORIENTATION;
335			the_event.evt.ornt.phi = mpiEventContainer.d1;
336			the_event.evt.ornt.theta = mpiEventContainer.d2;
337			the_event.evt.ornt.psi = mpiEventContainer.d3;
338			break;
339
340			case mpiCONSTRAINT:
341			the_event.event_type = CONSTRAINT;
342			the_event.evt.cnstr = mpiEventContainer.d1;
343			break;
344
345			case mpiMEMBERS:
346			the_event.event_type = MEMBERS;
347			the_event.evt.mbrs.nMembers = mpiEventContainer.i1;
348
349			the_event.evt.mbrs.memberList = (int *) calloc(the_event.evt.mbrs.nMembers,
350	gezelter	2204	sizeof(int));
351	gezelter	1490
352			// Grab the member list since we have a number of members:
353			MPI_Bcast(the_event.evt.mbrs.memberList, the_event.evt.mbrs.nMembers,
354			MPI_INT, 0, MPI_COMM_WORLD);
355
356			break;
357
358			case mpiASSIGNMENT_s:
359			the_event.event_type = ASSIGNMENT;
360			the_event.evt.asmt.asmt_type = STRING;
361			strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
362			strcpy(the_event.evt.asmt.rhs.sval,mpiEventContainer.cArray);
363
364			#ifdef MPIBASS_VERBOSE
365
366			fprintf(stderr, "mpiDiag at node %d: Assignment: %s = %s\n", worldRank,
367			the_event.evt.asmt.lhs,
368			the_event.evt.asmt.rhs.sval );
369			#endif
370
371			break;
372
373			case mpiASSIGNMENT_i:
374			the_event.event_type = ASSIGNMENT;
375			the_event.evt.asmt.asmt_type = INT;
376			strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
377			the_event.evt.asmt.rhs.ival = mpiEventContainer.i1;
378
379			#ifdef MPIBASS_VERBOSE
380
381			fprintf(stderr, "mpiDiag at node %d: Assignment: %s = %d\n", worldRank,
382			the_event.evt.asmt.lhs,
383			the_event.evt.asmt.rhs.ival );
384			#endif
385
386			break;
387
388			case mpiASSIGNMENT_d:
389			the_event.event_type = ASSIGNMENT;
390			the_event.evt.asmt.asmt_type = DOUBLE;
391			strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
392			the_event.evt.asmt.rhs.dval = mpiEventContainer.d1;
393
394			#ifdef MPIBASS_VERBOSE
395
396			fprintf(stderr, "mpiDiag at node %d: Assignment: %s = %lf\n", worldRank,
397			the_event.evt.asmt.lhs,
398			the_event.evt.asmt.rhs.dval );
399			#endif
400
401			break;
402
403			case mpiBLOCK_END:
404			the_event.event_type = BLOCK_END;
405			break;
406			}
407
408			#ifdef MPIBASS_VERBOSE
409
410			fprintf(stderr, "mpiDiag at node %d: event type is %d\n", worldRank,
411			the_event.event_type);
412			#endif
413
414			if (!event_handler(&the_event)){
415
416			sprintf(painCave.errMsg,
417			"MPI event handling error at node %d => %s\n",
418			worldRank,
419			the_event.err_msg);
420			painCave.isFatal = 1;
421			simError();
422			}
423			MPIcheckPoint();
424			}
425
426
427			void mpiInterfaceExit(void){
428			int mpiStatus = MPI_INTERFACE_ABORT;
429
430			MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
431			MPI_Finalize();
432			exit (0);
433
434			}
435			#endif