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:	1930
Committed:	Wed Jan 12 22:41:40 2005 UTC (19 years, 5 months ago) by gezelter
Content type:	text/plain
File size:	12078 byte(s)
Log Message:	merging new_design branch into OOPSE-2.0
#	Content
1	/*
2	* 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	#ifdef IS_MPI
43	#include <stdlib.h>
44	#include <stdio.h>
45	#include <string.h>
46
47	#define __mpiBASSEVENT
48	#include "io/mpiBASS.h"
49	#include "utils/simError.h"
50
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	break;
104
105	case RIGIDBODY:
106	mpiEventContainer.type = mpiRIGIDBODY;
107	mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
108	break;
109
110	case CUTOFFGROUP:
111	mpiEventContainer.type = mpiCUTOFFGROUP;
112	mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
113	break;
114
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	sizeof(int));
351
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