# | Line 1 | Line 1 | |
---|---|---|
1 | + | #define _FILE_OFFSET_BITS 64 |
2 | #include <iostream> | |
3 | < | #include <cmath> |
3 | > | #include <math.h> |
4 | ||
5 | #include <stdio.h> | |
6 | #include <stdlib.h> | |
# | Line 10 | Line 11 | |
11 | ||
12 | #include "ReadWrite.hpp" | |
13 | #include "simError.h" | |
14 | + | #include "GenericData.hpp" |
15 | ||
16 | #ifdef IS_MPI | |
17 | #include <mpi.h> | |
# | Line 26 | Line 28 | using namespace initFile; | |
28 | ||
29 | #endif // is_mpi | |
30 | ||
31 | < | InitializeFromFile :: InitializeFromFile( char *in_name ){ |
31 | > | InitializeFromFile::InitializeFromFile( char *in_name ){ |
32 | > | |
33 | #ifdef IS_MPI | |
34 | if (worldRank == 0) { | |
35 | #endif | |
# | Line 38 | Line 41 | InitializeFromFile :: InitializeFromFile( char *in_nam | |
41 | painCave.isFatal = 1; | |
42 | simError(); | |
43 | } | |
44 | < | |
44 | > | |
45 | strcpy( c_in_name, in_name); | |
46 | #ifdef IS_MPI | |
47 | } | |
48 | strcpy( checkPointMsg, "Infile opened for reading successfully." ); | |
49 | MPIcheckPoint(); | |
50 | #endif | |
51 | < | return; |
51 | > | return; |
52 | } | |
53 | ||
54 | < | InitializeFromFile :: ~InitializeFromFile( ){ |
54 | > | InitializeFromFile::~InitializeFromFile( ){ |
55 | #ifdef IS_MPI | |
56 | if (worldRank == 0) { | |
57 | #endif | |
# | Line 71 | Line 74 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
74 | ||
75 | void InitializeFromFile :: readInit( SimInfo* the_simnfo ){ | |
76 | ||
77 | < | int i, j, done, which_node, which_atom; // loop counter |
77 | > | int i, j; |
78 | ||
79 | + | #ifdef IS_MPI |
80 | + | int done, which_node, which_atom; // loop counter |
81 | + | #endif //is_mpi |
82 | + | |
83 | const int BUFFERSIZE = 2000; // size of the read buffer | |
84 | int n_atoms; // the number of atoms | |
85 | < | char read_buffer[BUFFERSIZE]; //the line buffer for reading |
79 | < | #ifdef IS_MPI |
80 | < | char send_buffer[BUFFERSIZE]; |
81 | < | #endif |
85 | > | char read_buffer[BUFFERSIZE]; //the line buffer for reading |
86 | ||
87 | < | char *eof_test; // ptr to see when we reach the end of the file |
87 | > | char *eof_test; // ptr to see when we reach the end of the file |
88 | char *parseErr; | |
85 | – | int procIndex; |
86 | – | double boxMat[9]; |
87 | – | double theBoxMat3[3][3]; |
89 | ||
90 | simnfo = the_simnfo; | |
91 | ||
# | Line 101 | Line 102 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
102 | ||
103 | n_atoms = atoi( read_buffer ); | |
104 | ||
104 | – | Atom **atoms = simnfo->atoms; |
105 | – | DirectionalAtom* dAtom; |
106 | – | |
105 | if( n_atoms != simnfo->n_atoms ){ | |
106 | sprintf( painCave.errMsg, | |
107 | "Initialize from File error. %s n_atoms, %d, " | |
# | Line 112 | Line 110 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
110 | painCave.isFatal = 1; | |
111 | simError(); | |
112 | } | |
113 | < | |
114 | < | //read the box mat from the comment line |
115 | < | |
113 | > | |
114 | > | //read the box mat from the comment line |
115 | > | |
116 | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); | |
117 | if(eof_test == NULL){ | |
118 | sprintf( painCave.errMsg, | |
# | Line 123 | Line 121 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
121 | simError(); | |
122 | } | |
123 | ||
124 | < | parseErr = parseBoxLine( read_buffer, boxMat ); |
124 | > | |
125 | > | |
126 | > | parseErr = parseCommentLine( read_buffer, simnfo); |
127 | if( parseErr != NULL ){ | |
128 | strcpy( painCave.errMsg, parseErr ); | |
129 | painCave.isFatal = 1; | |
130 | simError(); | |
131 | } | |
132 | ||
133 | < | for(i=0;i<3;i++) |
134 | < | for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i]; |
133 | > | //parse dump lines |
134 | ||
136 | – | simnfo->setBoxM( theBoxMat3 ); |
137 | – | |
138 | – | |
135 | for( i=0; i < n_atoms; i++){ | |
136 | < | |
136 | > | |
137 | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); | |
138 | if(eof_test == NULL){ | |
139 | sprintf(painCave.errMsg, | |
# | Line 149 | Line 145 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
145 | simError(); | |
146 | } | |
147 | ||
148 | < | |
148 | > | |
149 | parseErr = parseDumpLine( read_buffer, i ); | |
150 | if( parseErr != NULL ){ | |
151 | strcpy( painCave.errMsg, parseErr ); | |
# | Line 167 | Line 163 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
163 | ||
164 | int myStatus; // 1 = wakeup & success; 0 = error; -1 = AllDone | |
165 | int haveError; | |
166 | < | |
166 | > | |
167 | MPI_Status istatus; | |
168 | int *AtomToProcMap = mpiSim->getAtomToProcMap(); | |
169 | ||
170 | < | |
170 | > | |
171 | haveError = 0; | |
172 | if (worldRank == 0) { | |
173 | ||
174 | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); | |
175 | if( eof_test == NULL ){ | |
176 | sprintf( painCave.errMsg, | |
177 | < | "Error reading 1st line of %d \n ",c_in_name); |
177 | > | "Error reading 1st line of %s \n ",c_in_name); |
178 | haveError = 1; | |
179 | simError(); | |
180 | } | |
181 | < | |
181 | > | |
182 | n_atoms = atoi( read_buffer ); | |
183 | < | |
188 | < | Atom **atoms = simnfo->atoms; |
189 | < | DirectionalAtom* dAtom; |
190 | < | |
183 | > | |
184 | // Check to see that the number of atoms in the intial configuration file is the | |
185 | // same as declared in simBass. | |
186 | < | |
186 | > | |
187 | if( n_atoms != mpiSim->getTotAtoms() ){ | |
188 | sprintf( painCave.errMsg, | |
189 | "Initialize from File error. %s n_atoms, %d, " | |
# | Line 199 | Line 192 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
192 | haveError= 1; | |
193 | simError(); | |
194 | } | |
195 | < | |
196 | < | //read the boxMat from the comment line |
197 | < | |
195 | > | |
196 | > | //read the boxMat from the comment line |
197 | > | |
198 | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); | |
199 | if(eof_test == NULL){ | |
200 | sprintf( painCave.errMsg, | |
# | Line 209 | Line 202 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
202 | haveError = 1; | |
203 | simError(); | |
204 | } | |
205 | < | |
206 | < | parseErr = parseBoxLine( read_buffer, boxMat ); |
205 | > | |
206 | > | //Every single processor will parse the comment line by itself |
207 | > | //By using this way, we might lose some efficiency, but if we want to add |
208 | > | //more parameters into comment line, we only need to modify function |
209 | > | //parseCommentLine |
210 | > | |
211 | > | MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD); |
212 | > | |
213 | > | parseErr = parseCommentLine( read_buffer, simnfo); |
214 | > | |
215 | if( parseErr != NULL ){ | |
216 | strcpy( painCave.errMsg, parseErr ); | |
217 | haveError = 1; | |
218 | simError(); | |
219 | } | |
220 | ||
220 | – | MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD ); |
221 | – | |
222 | – | if(haveError) nodeZeroError(); |
223 | – | |
221 | for (i=0 ; i < mpiSim->getTotAtoms(); i++) { | |
222 | < | |
222 | > | |
223 | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); | |
224 | if(eof_test == NULL){ | |
225 | sprintf(painCave.errMsg, | |
# | Line 233 | Line 230 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
230 | haveError= 1; | |
231 | simError(); | |
232 | } | |
233 | < | |
233 | > | |
234 | if(haveError) nodeZeroError(); | |
235 | ||
236 | // Get the Node number which wants this atom: | |
237 | < | which_node = AtomToProcMap[i]; |
237 | > | which_node = AtomToProcMap[i]; |
238 | if (which_node == 0) { | |
239 | parseErr = parseDumpLine( read_buffer, i ); | |
240 | if( parseErr != NULL ){ | |
241 | strcpy( painCave.errMsg, parseErr ); | |
242 | haveError = 1; | |
243 | simError(); | |
244 | < | } |
244 | > | } |
245 | if(haveError) nodeZeroError(); | |
246 | < | } |
247 | < | |
246 | > | } |
247 | > | |
248 | else { | |
249 | < | |
249 | > | |
250 | myStatus = 1; | |
251 | < | MPI_Send(&myStatus, 1, MPI_INT, which_node, |
251 | > | MPI_Send(&myStatus, 1, MPI_INT, which_node, |
252 | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); | |
253 | < | MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node, |
253 | > | MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node, |
254 | TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD); | |
255 | MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT, | |
256 | MPI_COMM_WORLD); | |
257 | < | MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT, |
257 | > | MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT, |
258 | MPI_COMM_WORLD, &istatus); | |
259 | < | |
259 | > | |
260 | if(!myStatus) nodeZeroError(); | |
261 | } | |
262 | } | |
263 | myStatus = -1; | |
264 | < | for (j = 0; j < mpiSim->getNumberProcessors(); j++) { |
265 | < | MPI_Send( &myStatus, 1, MPI_INT, j, |
264 | > | for (j = 0; j < mpiSim->getNumberProcessors(); j++) { |
265 | > | MPI_Send( &myStatus, 1, MPI_INT, j, |
266 | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); | |
267 | } | |
268 | < | |
268 | > | |
269 | } else { | |
270 | < | |
271 | < | MPI_Bcast(boxMat, 9, MPI_DOUBLE, 0, MPI_COMM_WORLD); |
270 | > | |
271 | > | MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD); |
272 | ||
273 | + | parseErr = parseCommentLine( read_buffer, simnfo); |
274 | + | |
275 | + | if( parseErr != NULL ){ |
276 | + | strcpy( painCave.errMsg, parseErr ); |
277 | + | haveError = 1; |
278 | + | simError(); |
279 | + | } |
280 | + | |
281 | + | |
282 | done = 0; | |
283 | while (!done) { | |
284 | ||
285 | < | MPI_Recv(&myStatus, 1, MPI_INT, 0, |
285 | > | MPI_Recv(&myStatus, 1, MPI_INT, 0, |
286 | TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus); | |
287 | < | |
287 | > | |
288 | if(!myStatus) anonymousNodeDie(); | |
289 | < | |
289 | > | |
290 | if(myStatus < 0) break; | |
291 | ||
292 | < | MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0, |
292 | > | MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0, |
293 | TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus); | |
294 | < | MPI_Recv(&which_atom, 1, MPI_INT, 0, |
294 | > | MPI_Recv(&which_atom, 1, MPI_INT, 0, |
295 | TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus); | |
296 | < | |
296 | > | |
297 | myStatus = 1; | |
298 | parseErr = parseDumpLine( read_buffer, which_atom ); | |
299 | if( parseErr != NULL ){ | |
# | Line 295 | Line 301 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
301 | myStatus = 0;; | |
302 | simError(); | |
303 | } | |
304 | < | |
305 | < | MPI_Send( &myStatus, 1, MPI_INT, 0, |
304 | > | |
305 | > | MPI_Send( &myStatus, 1, MPI_INT, 0, |
306 | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); | |
307 | < | |
307 | > | |
308 | } | |
309 | } | |
310 | < | |
310 | > | |
311 | // last thing last, enable fatalities. | |
312 | painCave.isEventLoop = 0; | |
313 | ||
308 | – | for(i=0;i<3;i++) |
309 | – | for(j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i]; |
314 | ||
311 | – | simnfo->setBoxM( theBoxMat3 ); |
315 | ||
313 | – | |
316 | #endif | |
317 | } | |
318 | ||
319 | char* InitializeFromFile::parseDumpLine(char* readLine, int globalIndex){ | |
320 | ||
321 | < | char *foo; // the pointer to the current string token |
322 | < | |
323 | < | double rx, ry, rz; // position place holders |
324 | < | double vx, vy, vz; // velocity placeholders |
321 | > | char *foo; // the pointer to the current string token |
322 | > | |
323 | > | double pos[3]; // position place holders |
324 | > | double vel[3]; // velocity placeholders |
325 | double q[4]; // the quaternions | |
326 | double jx, jy, jz; // angular velocity placeholders; | |
327 | double qSqr, qLength; // needed to normalize the quaternion vector. | |
328 | < | |
328 | > | |
329 | Atom **atoms = simnfo->atoms; | |
330 | DirectionalAtom* dAtom; | |
329 | – | |
330 | – | int j, n_atoms, atomIndex; |
331 | ||
332 | + | int n_atoms, atomIndex; |
333 | + | |
334 | #ifdef IS_MPI | |
335 | + | int j; |
336 | + | |
337 | n_atoms = mpiSim->getTotAtoms(); | |
338 | < | atomIndex=-1; |
338 | > | atomIndex=-1; |
339 | for (j=0; j < mpiSim->getMyNlocal(); j++) { | |
340 | if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j; | |
341 | } | |
# | Line 341 | Line 345 | char* InitializeFromFile::parseDumpLine(char* readLine | |
345 | "in file %s does not exist on processor %d .\n", | |
346 | globalIndex, c_in_name, mpiSim->getMyNode() ); | |
347 | return strdup( painCave.errMsg ); | |
348 | < | } |
348 | > | } |
349 | #else | |
350 | n_atoms = simnfo->n_atoms; | |
351 | atomIndex = globalIndex; | |
352 | #endif // is_mpi | |
353 | ||
354 | // set the string tokenizer | |
355 | < | |
355 | > | |
356 | foo = strtok(readLine, " ,;\t"); | |
357 | < | |
357 | > | |
358 | // check the atom name to the current atom | |
359 | < | |
359 | > | |
360 | if( strcmp( foo, atoms[atomIndex]->getType() ) ){ | |
361 | sprintf( painCave.errMsg, | |
362 | "Initialize from file error. Atom %s at index %d " | |
# | Line 361 | Line 365 | char* InitializeFromFile::parseDumpLine(char* readLine | |
365 | foo, atomIndex, c_in_name, atoms[atomIndex]->getType() ); | |
366 | return strdup( painCave.errMsg ); | |
367 | } | |
368 | < | |
368 | > | |
369 | // get the positions | |
370 | ||
371 | foo = strtok(NULL, " ,;\t"); | |
# | Line 372 | Line 376 | char* InitializeFromFile::parseDumpLine(char* readLine | |
376 | c_in_name, n_atoms, atomIndex ); | |
377 | return strdup( painCave.errMsg ); | |
378 | } | |
379 | < | rx = atof( foo ); |
380 | < | |
379 | > | pos[0] = atof( foo ); |
380 | > | |
381 | foo = strtok(NULL, " ,;\t"); | |
382 | if(foo == NULL){ | |
383 | sprintf( painCave.errMsg, | |
# | Line 382 | Line 386 | char* InitializeFromFile::parseDumpLine(char* readLine | |
386 | c_in_name, n_atoms, atomIndex ); | |
387 | return strdup( painCave.errMsg ); | |
388 | } | |
389 | < | ry = atof( foo ); |
390 | < | |
389 | > | pos[1] = atof( foo ); |
390 | > | |
391 | foo = strtok(NULL, " ,;\t"); | |
392 | if(foo == NULL){ | |
393 | sprintf( painCave.errMsg, | |
# | Line 392 | Line 396 | char* InitializeFromFile::parseDumpLine(char* readLine | |
396 | c_in_name, n_atoms, atomIndex ); | |
397 | return strdup( painCave.errMsg ); | |
398 | } | |
399 | < | rz = atof( foo ); |
399 | > | pos[2] = atof( foo ); |
400 | ||
401 | ||
402 | // get the velocities | |
# | Line 405 | Line 409 | char* InitializeFromFile::parseDumpLine(char* readLine | |
409 | c_in_name, n_atoms, atomIndex ); | |
410 | return strdup( painCave.errMsg ); | |
411 | } | |
412 | < | vx = atof( foo ); |
413 | < | |
412 | > | vel[0] = atof( foo ); |
413 | > | |
414 | foo = strtok(NULL, " ,;\t"); | |
415 | if(foo == NULL){ | |
416 | sprintf( painCave.errMsg, | |
# | Line 415 | Line 419 | char* InitializeFromFile::parseDumpLine(char* readLine | |
419 | c_in_name, n_atoms, atomIndex ); | |
420 | return strdup( painCave.errMsg ); | |
421 | } | |
422 | < | vy = atof( foo ); |
423 | < | |
422 | > | vel[1] = atof( foo ); |
423 | > | |
424 | foo = strtok(NULL, " ,;\t"); | |
425 | if(foo == NULL){ | |
426 | sprintf( painCave.errMsg, | |
# | Line 425 | Line 429 | char* InitializeFromFile::parseDumpLine(char* readLine | |
429 | c_in_name, n_atoms, atomIndex ); | |
430 | return strdup( painCave.errMsg ); | |
431 | } | |
432 | < | vz = atof( foo ); |
433 | < | |
434 | < | |
432 | > | vel[2] = atof( foo ); |
433 | > | |
434 | > | |
435 | // get the quaternions | |
436 | < | |
436 | > | |
437 | if( atoms[atomIndex]->isDirectional() ){ | |
438 | < | |
438 | > | |
439 | foo = strtok(NULL, " ,;\t"); | |
440 | if(foo == NULL){ | |
441 | sprintf(painCave.errMsg, | |
# | Line 441 | Line 445 | char* InitializeFromFile::parseDumpLine(char* readLine | |
445 | return strdup( painCave.errMsg ); | |
446 | } | |
447 | q[0] = atof( foo ); | |
448 | < | |
448 | > | |
449 | foo = strtok(NULL, " ,;\t"); | |
450 | if(foo == NULL){ | |
451 | sprintf( painCave.errMsg, | |
# | Line 451 | Line 455 | char* InitializeFromFile::parseDumpLine(char* readLine | |
455 | return strdup( painCave.errMsg ); | |
456 | } | |
457 | q[1] = atof( foo ); | |
458 | < | |
458 | > | |
459 | foo = strtok(NULL, " ,;\t"); | |
460 | if(foo == NULL){ | |
461 | sprintf( painCave.errMsg, | |
# | Line 461 | Line 465 | char* InitializeFromFile::parseDumpLine(char* readLine | |
465 | return strdup( painCave.errMsg ); | |
466 | } | |
467 | q[2] = atof( foo ); | |
468 | < | |
468 | > | |
469 | foo = strtok(NULL, " ,;\t"); | |
470 | if(foo == NULL){ | |
471 | sprintf( painCave.errMsg, | |
# | Line 471 | Line 475 | char* InitializeFromFile::parseDumpLine(char* readLine | |
475 | return strdup( painCave.errMsg ); | |
476 | } | |
477 | q[3] = atof( foo ); | |
478 | < | |
478 | > | |
479 | // get the angular velocities | |
480 | < | |
480 | > | |
481 | foo = strtok(NULL, " ,;\t"); | |
482 | if(foo == NULL){ | |
483 | sprintf( painCave.errMsg, | |
# | Line 483 | Line 487 | char* InitializeFromFile::parseDumpLine(char* readLine | |
487 | return strdup( painCave.errMsg ); | |
488 | } | |
489 | jx = atof( foo ); | |
490 | < | |
490 | > | |
491 | foo = strtok(NULL, " ,;\t"); | |
492 | if(foo == NULL){ | |
493 | sprintf( painCave.errMsg, | |
# | Line 493 | Line 497 | char* InitializeFromFile::parseDumpLine(char* readLine | |
497 | return strdup( painCave.errMsg ); | |
498 | } | |
499 | jy = atof(foo ); | |
500 | < | |
500 | > | |
501 | foo = strtok(NULL, " ,;\t"); | |
502 | if(foo == NULL){ | |
503 | sprintf( painCave.errMsg, | |
# | Line 503 | Line 507 | char* InitializeFromFile::parseDumpLine(char* readLine | |
507 | return strdup( painCave.errMsg ); | |
508 | } | |
509 | jz = atof( foo ); | |
510 | < | |
510 | > | |
511 | dAtom = ( DirectionalAtom* )atoms[atomIndex]; | |
512 | ||
513 | // check that the quaternion vector is normalized | |
514 | ||
515 | qSqr = (q[0] * q[0]) + (q[1] * q[1]) + (q[2] * q[2]) + (q[3] * q[3]); | |
516 | < | |
516 | > | |
517 | qLength = sqrt( qSqr ); | |
518 | q[0] = q[0] / qLength; | |
519 | q[1] = q[1] / qLength; | |
520 | q[2] = q[2] / qLength; | |
521 | q[3] = q[3] / qLength; | |
522 | < | |
522 | > | |
523 | dAtom->setQ( q ); | |
524 | < | |
524 | > | |
525 | // add the angular velocities | |
526 | ||
527 | dAtom->setJx( jx ); | |
528 | dAtom->setJy( jy ); | |
529 | dAtom->setJz( jz ); | |
530 | } | |
531 | < | |
531 | > | |
532 | // add the positions and velocities to the atom | |
529 | – | |
530 | – | atoms[atomIndex]->setX( rx ); |
531 | – | atoms[atomIndex]->setY( ry ); |
532 | – | atoms[atomIndex]->setZ( rz ); |
533 | – | |
534 | – | atoms[atomIndex]->set_vx( vx ); |
535 | – | atoms[atomIndex]->set_vy( vy ); |
536 | – | atoms[atomIndex]->set_vz( vz ); |
533 | ||
534 | + | atoms[atomIndex]->setPos( pos ); |
535 | + | atoms[atomIndex]->setVel( vel ); |
536 | + | |
537 | return NULL; | |
538 | } | |
539 | ||
540 | ||
541 | < | char* InitializeFromFile::parseBoxLine(char* readLine, double boxMat[9]){ |
541 | > | char* InitializeFromFile::parseCommentLine(char* readLine, SimInfo* entry_plug){ |
542 | ||
543 | < | char *foo; // the pointer to the current string token |
544 | < | int j; |
543 | > | double currTime; |
544 | > | double boxMat[9]; |
545 | > | double theBoxMat3[3][3]; |
546 | > | double chi; |
547 | > | double integralOfChidt; |
548 | > | double eta[9]; |
549 | ||
550 | + | char *foo; // the pointer to the current string token |
551 | + | |
552 | // set the string tokenizer | |
553 | < | |
553 | > | |
554 | foo = strtok(readLine, " ,;\t"); | |
555 | // set the timeToken. | |
556 | ||
# | Line 555 | Line 560 | char* InitializeFromFile::parseBoxLine(char* readLine, | |
560 | c_in_name ); | |
561 | return strdup( painCave.errMsg ); | |
562 | } | |
558 | – | simnfo->setTime( atof( foo ) ); |
563 | ||
564 | < | // get the Hx vector |
564 | > | currTime = atof( foo ); |
565 | > | entry_plug->setTime( currTime ); |
566 | ||
567 | < | foo = strtok(NULL, " ,;\t"); |
568 | < | if(foo == NULL){ |
569 | < | sprintf( painCave.errMsg, |
570 | < | "error in reading Hx[0] from %s\n", |
571 | < | c_in_name ); |
572 | < | return strdup( painCave.errMsg ); |
567 | > | //get H-Matrix |
568 | > | |
569 | > | for(int i = 0 ; i < 9; i++){ |
570 | > | foo = strtok(NULL, " ,;\t"); |
571 | > | if(foo == NULL){ |
572 | > | sprintf( painCave.errMsg, |
573 | > | "error in reading H[%d] from %s\n", i, c_in_name ); |
574 | > | return strdup( painCave.errMsg ); |
575 | > | } |
576 | > | boxMat[i] = atof( foo ); |
577 | } | |
569 | – | boxMat[0] = atof( foo ); |
570 | – | |
571 | – | foo = strtok(NULL, " ,;\t"); |
572 | – | if(foo == NULL){ |
573 | – | sprintf( painCave.errMsg, |
574 | – | "error in reading Hx[1] from %s\n", |
575 | – | c_in_name ); |
576 | – | return strdup( painCave.errMsg ); |
577 | – | } |
578 | – | boxMat[1] = atof( foo ); |
579 | – | |
580 | – | foo = strtok(NULL, " ,;\t"); |
581 | – | if(foo == NULL){ |
582 | – | sprintf( painCave.errMsg, |
583 | – | "error in reading Hx[2] from %s\n", |
584 | – | c_in_name ); |
585 | – | return strdup( painCave.errMsg ); |
586 | – | } |
587 | – | boxMat[2] = atof( foo ); |
578 | ||
579 | < | // get the Hy vector |
579 | > | for(int i=0;i<3;i++) |
580 | > | for(int j=0;j<3;j++) theBoxMat3[i][j] = boxMat[3*j+i]; |
581 | ||
582 | < | foo = strtok(NULL, " ,;\t"); |
583 | < | if(foo == NULL){ |
593 | < | sprintf( painCave.errMsg, |
594 | < | "error in reading Hy[0] from %s\n", |
595 | < | c_in_name ); |
596 | < | return strdup( painCave.errMsg ); |
597 | < | } |
598 | < | boxMat[3] = atof( foo ); |
599 | < | |
600 | < | foo = strtok(NULL, " ,;\t"); |
601 | < | if(foo == NULL){ |
602 | < | sprintf( painCave.errMsg, |
603 | < | "error in reading Hy[1] from %s\n", |
604 | < | c_in_name ); |
605 | < | return strdup( painCave.errMsg ); |
606 | < | } |
607 | < | boxMat[4] = atof( foo ); |
608 | < | |
609 | < | foo = strtok(NULL, " ,;\t"); |
610 | < | if(foo == NULL){ |
611 | < | sprintf( painCave.errMsg, |
612 | < | "error in reading Hy[2] from %s\n", |
613 | < | c_in_name ); |
614 | < | return strdup( painCave.errMsg ); |
615 | < | } |
616 | < | boxMat[5] = atof( foo ); |
582 | > | //set H-Matrix |
583 | > | entry_plug->setBoxM( theBoxMat3 ); |
584 | ||
585 | < | // get the Hz vector |
585 | > | //get chi and integralOfChidt, they should appear by pair |
586 | > | foo = strtok(NULL, " ,;\t\n"); |
587 | > | if(foo != NULL){ |
588 | > | chi = atof(foo); |
589 | ||
590 | < | foo = strtok(NULL, " ,;\t"); |
591 | < | if(foo == NULL){ |
592 | < | sprintf( painCave.errMsg, |
593 | < | "error in reading Hz[0] from %s\n", |
594 | < | c_in_name ); |
595 | < | return strdup( painCave.errMsg ); |
590 | > | foo = strtok(NULL, " ,;\t\n"); |
591 | > | if(foo == NULL){ |
592 | > | sprintf( painCave.errMsg, |
593 | > | "chi and integralOfChidt should appear by pair in %s\n", c_in_name ); |
594 | > | return strdup( painCave.errMsg ); |
595 | > | } |
596 | > | integralOfChidt = atof( foo ); |
597 | > | |
598 | > | //push chi and integralOfChidt into SimInfo::properties which can be |
599 | > | //retrieved by integrator later |
600 | > | DoubleData* chiValue = new DoubleData(); |
601 | > | chiValue->setID(CHIVALUE_ID); |
602 | > | chiValue->setData(chi); |
603 | > | entry_plug->addProperty(chiValue); |
604 | > | |
605 | > | DoubleData* integralOfChidtValue = new DoubleData(); |
606 | > | integralOfChidtValue->setID(INTEGRALOFCHIDT_ID); |
607 | > | integralOfChidtValue->setData(integralOfChidt); |
608 | > | entry_plug->addProperty(integralOfChidtValue); |
609 | > | |
610 | } | |
611 | < | boxMat[6] = atof( foo ); |
612 | < | |
613 | < | foo = strtok(NULL, " ,;\t"); |
614 | < | if(foo == NULL){ |
615 | < | sprintf( painCave.errMsg, |
616 | < | "error in reading Hz[1] from %s\n", |
617 | < | c_in_name ); |
618 | < | return strdup( painCave.errMsg ); |
611 | > | else |
612 | > | return NULL; |
613 | > | |
614 | > | //get eta |
615 | > | for(int i = 0 ; i < 9; i++){ |
616 | > | foo = strtok(NULL, " ,;\t"); |
617 | > | if(foo == NULL){ |
618 | > | sprintf( painCave.errMsg, |
619 | > | "error in reading eta[%d] from %s\n", i, c_in_name ); |
620 | > | return strdup( painCave.errMsg ); |
621 | > | } |
622 | > | eta[i] = atof( foo ); |
623 | } | |
636 | – | boxMat[7] = atof( foo ); |
637 | – | |
638 | – | foo = strtok(NULL, " ,;\t"); |
639 | – | if(foo == NULL){ |
640 | – | sprintf( painCave.errMsg, |
641 | – | "error in reading Hz[2] from %s\n", |
642 | – | c_in_name ); |
643 | – | return strdup( painCave.errMsg ); |
644 | – | } |
645 | – | boxMat[8] = atof( foo ); |
624 | ||
625 | + | //push eta into SimInfo::properties which can be |
626 | + | //retrieved by integrator later |
627 | + | //entry_plug->setBoxM( theBoxMat3 ); |
628 | + | DoubleArrayData* etaValue = new DoubleArrayData(); |
629 | + | etaValue->setID(ETAVALUE_ID); |
630 | + | etaValue->setData(eta, 9); |
631 | + | entry_plug->addProperty(etaValue); |
632 | + | |
633 | + | |
634 | return NULL; | |
635 | } | |
636 | ||
650 | – | |
637 | #ifdef IS_MPI | |
638 | ||
639 | // a couple of functions to let us escape the read loop | |
640 | ||
641 | void initFile::nodeZeroError( void ){ | |
642 | int j, myStatus; | |
643 | < | |
643 | > | |
644 | myStatus = 0; | |
645 | < | for (j = 0; j < mpiSim->getNumberProcessors(); j++) { |
646 | < | MPI_Send( &myStatus, 1, MPI_INT, j, |
645 | > | for (j = 0; j < mpiSim->getNumberProcessors(); j++) { |
646 | > | MPI_Send( &myStatus, 1, MPI_INT, j, |
647 | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); | |
648 | < | } |
663 | < | |
648 | > | } |
649 | ||
650 | + | |
651 | MPI_Finalize(); | |
652 | exit (0); | |
653 | < | |
653 | > | |
654 | } | |
655 | ||
656 | void initFile::anonymousNodeDie( void ){ |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |