# | Line 85 | Line 85 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
---|---|---|
85 | #endif //is_mpi | |
86 | ||
87 | const int BUFFERSIZE = 2000; // size of the read buffer | |
88 | < | int n_atoms; // the number of atoms |
88 | > | int nTotObjs; // the number of atoms |
89 | char read_buffer[BUFFERSIZE]; //the line buffer for reading | |
90 | ||
91 | char *eof_test; // ptr to see when we reach the end of the file | |
92 | char *parseErr; | |
93 | ||
94 | + | vector<StuntDouble*> integrableObjects; |
95 | + | |
96 | simnfo = the_simnfo; | |
97 | ||
98 | ||
# | Line 104 | Line 106 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
106 | simError(); | |
107 | } | |
108 | ||
109 | < | n_atoms = atoi( read_buffer ); |
109 | > | nTotObjs = atoi( read_buffer ); |
110 | ||
111 | < | if( n_atoms != simnfo->n_atoms ){ |
111 | > | if( nTotObjs != simnfo->getTotIntegrableObjects() ){ |
112 | sprintf( painCave.errMsg, | |
113 | "Initialize from File error. %s n_atoms, %d, " | |
114 | "does not match the BASS file's n_atoms, %d.\n", | |
115 | < | c_in_name, n_atoms, simnfo->n_atoms ); |
115 | > | c_in_name, nTotObjs, simnfo->getTotIntegrableObjects()); |
116 | painCave.isFatal = 1; | |
117 | simError(); | |
118 | } | |
# | Line 125 | Line 127 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
127 | simError(); | |
128 | } | |
129 | ||
128 | – | |
129 | – | |
130 | parseErr = parseCommentLine( read_buffer, simnfo); | |
131 | if( parseErr != NULL ){ | |
132 | strcpy( painCave.errMsg, parseErr ); | |
# | Line 136 | Line 136 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
136 | ||
137 | //parse dump lines | |
138 | ||
139 | < | for( i=0; i < n_atoms; i++){ |
139 | > | for( i=0; i < simnfo->n_mol; i++){ |
140 | ||
141 | < | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); |
142 | < | if(eof_test == NULL){ |
143 | < | sprintf(painCave.errMsg, |
144 | < | "error in reading file %s\n" |
145 | < | "natoms = %d; index = %d\n" |
146 | < | "error reading the line from the file.\n", |
147 | < | c_in_name, n_atoms, i ); |
148 | < | painCave.isFatal = 1; |
149 | < | simError(); |
150 | < | } |
141 | > | integrableObjects = (simnfo->molecules[i]).getIntegrableObjects(); |
142 | ||
143 | + | for(j = 0; j < integrableObjects.size(); j++){ |
144 | ||
145 | < | parseErr = parseDumpLine( read_buffer, i ); |
146 | < | if( parseErr != NULL ){ |
147 | < | strcpy( painCave.errMsg, parseErr ); |
148 | < | painCave.isFatal = 1; |
149 | < | simError(); |
145 | > | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); |
146 | > | if(eof_test == NULL){ |
147 | > | sprintf(painCave.errMsg, |
148 | > | "error in reading file %s\n" |
149 | > | "natoms = %d; index = %d\n" |
150 | > | "error reading the line from the file.\n", |
151 | > | c_in_name, nTotObjs, i ); |
152 | > | painCave.isFatal = 1; |
153 | > | simError(); |
154 | > | } |
155 | > | |
156 | > | parseErr = parseDumpLine( read_buffer, integrableObjects[j]); |
157 | > | if( parseErr != NULL ){ |
158 | > | strcpy( painCave.errMsg, parseErr ); |
159 | > | painCave.isFatal = 1; |
160 | > | simError(); |
161 | > | } |
162 | } | |
163 | } | |
164 | ||
161 | – | |
165 | // MPI Section of code.......... | |
166 | #else //IS_MPI | |
167 | ||
# | Line 169 | Line 172 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
172 | int haveError; | |
173 | ||
174 | MPI_Status istatus; | |
175 | < | int *AtomToProcMap = mpiSim->getAtomToProcMap(); |
175 | > | int *MolToProcMap = mpiSim->getMolToProcMap(); |
176 | > | int localIndex; |
177 | > | int nCurObj; |
178 | > | int nItems; |
179 | ||
180 | < | |
180 | > | nTotObjs = simnfo->getTotIntegrableObjects(); |
181 | haveError = 0; | |
182 | if (worldRank == 0) { | |
183 | ||
# | Line 183 | Line 189 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
189 | simError(); | |
190 | } | |
191 | ||
192 | < | n_atoms = atoi( read_buffer ); |
192 | > | nItems = atoi( read_buffer ); |
193 | ||
194 | < | // Check to see that the number of atoms in the intial configuration file is the |
194 | > | // Check to see that the number of integrable objects in the intial configuration file is the |
195 | // same as declared in simBass. | |
196 | ||
197 | < | if( n_atoms != mpiSim->getTotAtoms() ){ |
197 | > | if( nTotObjs != nItems){ |
198 | sprintf( painCave.errMsg, | |
199 | "Initialize from File error. %s n_atoms, %d, " | |
200 | "does not match the BASS file's n_atoms, %d.\n", | |
201 | < | c_in_name, n_atoms, simnfo->n_atoms ); |
201 | > | c_in_name, nTotObjs, simnfo->getTotIntegrableObjects()); |
202 | haveError= 1; | |
203 | simError(); | |
204 | } | |
# | Line 222 | Line 228 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
228 | simError(); | |
229 | } | |
230 | ||
231 | < | for (i=0 ; i < mpiSim->getTotAtoms(); i++) { |
231 | > | for (i=0 ; i < mpiSim->getTotNmol(); i++) { |
232 | > | which_node = MolToProcMap[i]; |
233 | > | if(which_node == 0){ |
234 | > | //molecules belong to master node |
235 | ||
236 | < | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); |
237 | < | if(eof_test == NULL){ |
238 | < | sprintf(painCave.errMsg, |
239 | < | "error in reading file %s\n" |
240 | < | "natoms = %d; index = %d\n" |
241 | < | "error reading the line from the file.\n", |
233 | < | c_in_name, n_atoms, i ); |
234 | < | haveError= 1; |
235 | < | simError(); |
236 | > | localIndex = mpiSim->getGlobalToLocalMol(i); |
237 | > | |
238 | > | if(localIndex == -1) { |
239 | > | strcpy(painCave.errMsg, "Molecule not found on node 0!"); |
240 | > | haveError = 1; |
241 | > | simError(); |
242 | } | |
243 | ||
244 | < | if(haveError) nodeZeroError(); |
244 | > | integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects(); |
245 | > | for(j=0; j < integrableObjects.size(); j++){ |
246 | > | |
247 | > | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); |
248 | > | if(eof_test == NULL){ |
249 | > | sprintf(painCave.errMsg, |
250 | > | "error in reading file %s\n" |
251 | > | "natoms = %d; index = %d\n" |
252 | > | "error reading the line from the file.\n", |
253 | > | c_in_name, nTotObjs, i ); |
254 | > | haveError= 1; |
255 | > | simError(); |
256 | > | } |
257 | > | |
258 | > | if(haveError) nodeZeroError(); |
259 | ||
260 | < | // Get the Node number which wants this atom: |
261 | < | which_node = AtomToProcMap[i]; |
262 | < | if (which_node == 0) { |
263 | < | parseErr = parseDumpLine( read_buffer, i ); |
264 | < | if( parseErr != NULL ){ |
245 | < | strcpy( painCave.errMsg, parseErr ); |
246 | < | haveError = 1; |
247 | < | simError(); |
248 | < | } |
249 | < | if(haveError) nodeZeroError(); |
260 | > | parseDumpLine(read_buffer, integrableObjects[j]); |
261 | > | |
262 | > | } |
263 | > | |
264 | > | |
265 | } | |
266 | + | else{ |
267 | + | //molecule belongs to slave nodes |
268 | ||
269 | < | else { |
269 | > | MPI_Recv(&nCurObj, 1, MPI_INT, which_node, |
270 | > | TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus); |
271 | > | |
272 | > | for(j=0; j < integrableObjects.size(); j++){ |
273 | > | |
274 | > | eof_test = fgets(read_buffer, sizeof(read_buffer), c_in_file); |
275 | > | if(eof_test == NULL){ |
276 | > | sprintf(painCave.errMsg, |
277 | > | "error in reading file %s\n" |
278 | > | "natoms = %d; index = %d\n" |
279 | > | "error reading the line from the file.\n", |
280 | > | c_in_name, nTotObjs, i ); |
281 | > | haveError= 1; |
282 | > | simError(); |
283 | > | } |
284 | > | |
285 | > | if(haveError) nodeZeroError(); |
286 | ||
287 | < | myStatus = 1; |
288 | < | MPI_Send(&myStatus, 1, MPI_INT, which_node, |
289 | < | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); |
290 | < | MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node, |
258 | < | TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD); |
259 | < | MPI_Send(&i, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT, |
260 | < | MPI_COMM_WORLD); |
261 | < | MPI_Recv(&myStatus, 1, MPI_INT, which_node, TAKE_THIS_TAG_INT, |
262 | < | MPI_COMM_WORLD, &istatus); |
287 | > | MPI_Send(read_buffer, BUFFERSIZE, MPI_CHAR, which_node, |
288 | > | TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD); |
289 | > | |
290 | > | } |
291 | ||
264 | – | if(!myStatus) nodeZeroError(); |
292 | } | |
293 | + | |
294 | } | |
295 | < | myStatus = -1; |
296 | < | for (j = 1; j < mpiSim->getNumberProcessors(); j++) { |
297 | < | MPI_Send( &myStatus, 1, MPI_INT, j, |
298 | < | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); |
271 | < | } |
295 | > | |
296 | > | } |
297 | > | else{ |
298 | > | //actions taken at slave nodes |
299 | ||
273 | – | } else { |
274 | – | |
300 | MPI_Bcast(read_buffer, BUFFERSIZE, MPI_CHAR, 0, MPI_COMM_WORLD); | |
301 | ||
302 | parseErr = parseCommentLine( read_buffer, simnfo); | |
# | Line 281 | Line 306 | void InitializeFromFile :: readInit( SimInfo* the_simn | |
306 | haveError = 1; | |
307 | simError(); | |
308 | } | |
309 | + | |
310 | + | for (i=0 ; i < mpiSim->getTotNmol(); i++) { |
311 | + | which_node = MolToProcMap[i]; |
312 | + | |
313 | + | if(which_node == worldRank){ |
314 | + | //molecule with global index i belongs to this processor |
315 | + | |
316 | + | localIndex = mpiSim->getGlobalToLocalMol(i); |
317 | ||
318 | + | if(localIndex == -1) { |
319 | + | sprintf(painCave.errMsg, "Molecule not found on node %d\n", worldRank); |
320 | + | haveError = 1; |
321 | + | simError(); |
322 | + | } |
323 | ||
324 | < | done = 0; |
287 | < | while (!done) { |
324 | > | integrableObjects = (simnfo->molecules[localIndex]).getIntegrableObjects(); |
325 | ||
326 | < | MPI_Recv(&myStatus, 1, MPI_INT, 0, |
327 | < | TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus); |
326 | > | nCurObj = integrableObjects.size(); |
327 | > | |
328 | > | MPI_Send(&nCurObj, 1, MPI_INT, 0, |
329 | > | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); |
330 | ||
331 | < | if(!myStatus) anonymousNodeDie(); |
331 | > | for(j = 0; j < integrableObjects.size(); j++){ |
332 | > | |
333 | > | MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0, |
334 | > | TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus); |
335 | ||
336 | < | if(myStatus < 0) break; |
336 | > | parseErr = parseDumpLine(read_buffer, integrableObjects[j]); |
337 | ||
338 | < | MPI_Recv(read_buffer, BUFFERSIZE, MPI_CHAR, 0, |
339 | < | TAKE_THIS_TAG_CHAR, MPI_COMM_WORLD, &istatus); |
340 | < | MPI_Recv(&which_atom, 1, MPI_INT, 0, |
341 | < | TAKE_THIS_TAG_INT, MPI_COMM_WORLD, &istatus); |
338 | > | if( parseErr != NULL ){ |
339 | > | strcpy( painCave.errMsg, parseErr ); |
340 | > | simError(); |
341 | > | } |
342 | ||
343 | < | myStatus = 1; |
344 | < | parseErr = parseDumpLine( read_buffer, which_atom ); |
303 | < | if( parseErr != NULL ){ |
304 | < | strcpy( painCave.errMsg, parseErr ); |
305 | < | myStatus = 0;; |
306 | < | simError(); |
343 | > | } |
344 | > | |
345 | } | |
346 | < | |
309 | < | MPI_Send( &myStatus, 1, MPI_INT, 0, |
310 | < | TAKE_THIS_TAG_INT, MPI_COMM_WORLD); |
311 | < | |
346 | > | |
347 | } | |
313 | – | } |
348 | ||
349 | < | // last thing last, enable fatalities. |
316 | < | painCave.isEventLoop = 0; |
317 | < | |
318 | < | |
319 | < | |
349 | > | } |
350 | #endif | |
351 | } | |
352 | ||
353 | < | char* InitializeFromFile::parseDumpLine(char* readLine, int globalIndex){ |
353 | > | char* InitializeFromFile::parseDumpLine(char* readLine, StuntDouble* sd){ |
354 | ||
355 | char *foo; // the pointer to the current string token | |
356 | ||
357 | double pos[3]; // position place holders | |
358 | double vel[3]; // velocity placeholders | |
359 | double q[4]; // the quaternions | |
360 | < | double jx, jy, jz; // angular velocity placeholders; |
360 | > | double ji[3]; // angular velocity placeholders; |
361 | double qSqr, qLength; // needed to normalize the quaternion vector. | |
362 | ||
333 | – | Atom **atoms = simnfo->atoms; |
334 | – | DirectionalAtom* dAtom; |
363 | ||
336 | – | int n_atoms, atomIndex; |
337 | – | |
338 | – | #ifdef IS_MPI |
339 | – | int j; |
340 | – | |
341 | – | n_atoms = mpiSim->getTotAtoms(); |
342 | – | atomIndex=-1; |
343 | – | for (j=0; j < mpiSim->getMyNlocal(); j++) { |
344 | – | if (atoms[j]->getGlobalIndex() == globalIndex) atomIndex = j; |
345 | – | } |
346 | – | if (atomIndex == -1) { |
347 | – | sprintf( painCave.errMsg, |
348 | – | "Initialize from file error. Atom at index %d " |
349 | – | "in file %s does not exist on processor %d .\n", |
350 | – | globalIndex, c_in_name, mpiSim->getMyNode() ); |
351 | – | return strdup( painCave.errMsg ); |
352 | – | } |
353 | – | #else |
354 | – | n_atoms = simnfo->n_atoms; |
355 | – | atomIndex = globalIndex; |
356 | – | #endif // is_mpi |
357 | – | |
364 | // set the string tokenizer | |
365 | ||
366 | foo = strtok(readLine, " ,;\t"); | |
367 | ||
368 | // check the atom name to the current atom | |
369 | ||
370 | < | if( strcmp( foo, atoms[atomIndex]->getType() ) ){ |
370 | > | if( strcmp( foo, sd->getType() ) ){ |
371 | sprintf( painCave.errMsg, | |
372 | < | "Initialize from file error. Atom %s at index %d " |
367 | < | "in file %s does not" |
372 | > | "Initialize from file error. Does not" |
373 | " match the BASS atom %s.\n", | |
374 | < | foo, atomIndex, c_in_name, atoms[atomIndex]->getType() ); |
374 | > | sd->getType() ); |
375 | return strdup( painCave.errMsg ); | |
376 | } | |
377 | ||
# | Line 375 | Line 380 | char* InitializeFromFile::parseDumpLine(char* readLine | |
380 | foo = strtok(NULL, " ,;\t"); | |
381 | if(foo == NULL){ | |
382 | sprintf( painCave.errMsg, | |
383 | < | "error in reading postition x from %s\n" |
384 | < | "natoms = %d, index = %d\n", |
380 | < | c_in_name, n_atoms, atomIndex ); |
383 | > | "error in reading postition x from %s\n", |
384 | > | c_in_name); |
385 | return strdup( painCave.errMsg ); | |
386 | } | |
387 | pos[0] = atof( foo ); | |
# | Line 385 | Line 389 | char* InitializeFromFile::parseDumpLine(char* readLine | |
389 | foo = strtok(NULL, " ,;\t"); | |
390 | if(foo == NULL){ | |
391 | sprintf( painCave.errMsg, | |
392 | < | "error in reading postition y from %s\n" |
393 | < | "natoms = %d, index = %d\n", |
390 | < | c_in_name, n_atoms, atomIndex ); |
392 | > | "error in reading postition y from %s\n", |
393 | > | c_in_name); |
394 | return strdup( painCave.errMsg ); | |
395 | } | |
396 | pos[1] = atof( foo ); | |
# | Line 395 | Line 398 | char* InitializeFromFile::parseDumpLine(char* readLine | |
398 | foo = strtok(NULL, " ,;\t"); | |
399 | if(foo == NULL){ | |
400 | sprintf( painCave.errMsg, | |
401 | < | "error in reading postition z from %s\n" |
402 | < | "natoms = %d, index = %d\n", |
400 | < | c_in_name, n_atoms, atomIndex ); |
401 | > | "error in reading postition z from %s\n", |
402 | > | c_in_name); |
403 | return strdup( painCave.errMsg ); | |
404 | } | |
405 | pos[2] = atof( foo ); | |
# | Line 408 | Line 410 | char* InitializeFromFile::parseDumpLine(char* readLine | |
410 | foo = strtok(NULL, " ,;\t"); | |
411 | if(foo == NULL){ | |
412 | sprintf( painCave.errMsg, | |
413 | < | "error in reading velocity x from %s\n" |
414 | < | "natoms = %d, index = %d\n", |
413 | < | c_in_name, n_atoms, atomIndex ); |
413 | > | "error in reading velocity x from %s\n", |
414 | > | c_in_name ); |
415 | return strdup( painCave.errMsg ); | |
416 | } | |
417 | vel[0] = atof( foo ); | |
# | Line 418 | Line 419 | char* InitializeFromFile::parseDumpLine(char* readLine | |
419 | foo = strtok(NULL, " ,;\t"); | |
420 | if(foo == NULL){ | |
421 | sprintf( painCave.errMsg, | |
422 | < | "error in reading velocity y from %s\n" |
423 | < | "natoms = %d, index = %d\n", |
423 | < | c_in_name, n_atoms, atomIndex ); |
422 | > | "error in reading velocity x from %s\n", |
423 | > | c_in_name ); |
424 | return strdup( painCave.errMsg ); | |
425 | } | |
426 | vel[1] = atof( foo ); | |
# | Line 428 | Line 428 | char* InitializeFromFile::parseDumpLine(char* readLine | |
428 | foo = strtok(NULL, " ,;\t"); | |
429 | if(foo == NULL){ | |
430 | sprintf( painCave.errMsg, | |
431 | < | "error in reading velocity z from %s\n" |
432 | < | "natoms = %d, index = %d\n", |
433 | < | c_in_name, n_atoms, atomIndex ); |
431 | > | "error in reading velocity x from %s\n", |
432 | > | c_in_name ); |
433 | return strdup( painCave.errMsg ); | |
434 | } | |
435 | vel[2] = atof( foo ); | |
436 | ||
437 | ||
438 | + | // add the positions and velocities to the atom |
439 | + | |
440 | + | sd->setPos( pos ); |
441 | + | sd->setVel( vel ); |
442 | + | |
443 | + | if (!sd->isDirectional()) |
444 | + | return NULL; |
445 | + | |
446 | // get the quaternions | |
447 | ||
448 | < | if( atoms[atomIndex]->isDirectional() ){ |
448 | > | if( sd->isDirectional() ){ |
449 | ||
450 | foo = strtok(NULL, " ,;\t"); | |
451 | if(foo == NULL){ | |
452 | < | sprintf(painCave.errMsg, |
453 | < | "error in reading quaternion 0 from %s\n" |
454 | < | "natoms = %d, index = %d\n", |
448 | < | c_in_name, n_atoms, atomIndex ); |
452 | > | sprintf( painCave.errMsg, |
453 | > | "error in reading velocity x from %s\n", |
454 | > | c_in_name ); |
455 | return strdup( painCave.errMsg ); | |
456 | } | |
457 | q[0] = atof( foo ); | |
# | Line 453 | Line 459 | char* InitializeFromFile::parseDumpLine(char* readLine | |
459 | foo = strtok(NULL, " ,;\t"); | |
460 | if(foo == NULL){ | |
461 | sprintf( painCave.errMsg, | |
462 | < | "error in reading quaternion 1 from %s\n" |
463 | < | "natoms = %d, index = %d\n", |
458 | < | c_in_name, n_atoms, atomIndex ); |
462 | > | "error in reading velocity x from %s\n", |
463 | > | c_in_name ); |
464 | return strdup( painCave.errMsg ); | |
465 | } | |
466 | q[1] = atof( foo ); | |
# | Line 463 | Line 468 | char* InitializeFromFile::parseDumpLine(char* readLine | |
468 | foo = strtok(NULL, " ,;\t"); | |
469 | if(foo == NULL){ | |
470 | sprintf( painCave.errMsg, | |
471 | < | "error in reading quaternion 2 from %s\n" |
472 | < | "natoms = %d, index = %d\n", |
468 | < | c_in_name, n_atoms, atomIndex ); |
471 | > | "error in reading velocity x from %s\n", |
472 | > | c_in_name ); |
473 | return strdup( painCave.errMsg ); | |
474 | } | |
475 | q[2] = atof( foo ); | |
# | Line 473 | Line 477 | char* InitializeFromFile::parseDumpLine(char* readLine | |
477 | foo = strtok(NULL, " ,;\t"); | |
478 | if(foo == NULL){ | |
479 | sprintf( painCave.errMsg, | |
480 | < | "error in reading quaternion 3 from %s\n" |
481 | < | "natoms = %d, index = %d\n", |
478 | < | c_in_name, n_atoms, atomIndex ); |
480 | > | "error in reading velocity x from %s\n", |
481 | > | c_in_name ); |
482 | return strdup( painCave.errMsg ); | |
483 | } | |
484 | q[3] = atof( foo ); | |
# | Line 485 | Line 488 | char* InitializeFromFile::parseDumpLine(char* readLine | |
488 | foo = strtok(NULL, " ,;\t"); | |
489 | if(foo == NULL){ | |
490 | sprintf( painCave.errMsg, | |
491 | < | "error in reading angular momentum jx from %s\n" |
492 | < | "natoms = %d, index = %d\n", |
490 | < | c_in_name, n_atoms, atomIndex ); |
491 | > | "error in reading velocity x from %s\n", |
492 | > | c_in_name ); |
493 | return strdup( painCave.errMsg ); | |
494 | } | |
495 | < | jx = atof( foo ); |
495 | > | ji[0] = atof( foo ); |
496 | ||
497 | foo = strtok(NULL, " ,;\t"); | |
498 | if(foo == NULL){ | |
499 | sprintf( painCave.errMsg, | |
500 | < | "error in reading angular momentum jy from %s\n" |
501 | < | "natoms = %d, index = %d\n", |
500 | < | c_in_name, n_atoms, atomIndex ); |
500 | > | "error in reading velocity x from %s\n", |
501 | > | c_in_name ); |
502 | return strdup( painCave.errMsg ); | |
503 | } | |
504 | < | jy = atof(foo ); |
504 | > | ji[1] = atof(foo ); |
505 | ||
506 | foo = strtok(NULL, " ,;\t"); | |
507 | if(foo == NULL){ | |
508 | sprintf( painCave.errMsg, | |
509 | < | "error in reading angular momentum jz from %s\n" |
510 | < | "natoms = %d, index = %d\n", |
510 | < | c_in_name, n_atoms, atomIndex ); |
509 | > | "error in reading velocity x from %s\n", |
510 | > | c_in_name ); |
511 | return strdup( painCave.errMsg ); | |
512 | } | |
513 | < | jz = atof( foo ); |
513 | > | ji[2] = atof( foo ); |
514 | ||
515 | – | dAtom = ( DirectionalAtom* )atoms[atomIndex]; |
515 | ||
516 | // check that the quaternion vector is normalized | |
517 | ||
# | Line 524 | Line 523 | char* InitializeFromFile::parseDumpLine(char* readLine | |
523 | q[2] = q[2] / qLength; | |
524 | q[3] = q[3] / qLength; | |
525 | ||
526 | < | dAtom->setQ( q ); |
526 | > | // add quaternion and angular velocities |
527 | ||
528 | < | // add the angular velocities |
529 | < | |
531 | < | dAtom->setJx( jx ); |
532 | < | dAtom->setJy( jy ); |
533 | < | dAtom->setJz( jz ); |
528 | > | sd->setQ( q ); |
529 | > | sd->setJ( ji ); |
530 | } | |
531 | ||
536 | – | // add the positions and velocities to the atom |
532 | ||
538 | – | atoms[atomIndex]->setPos( pos ); |
539 | – | atoms[atomIndex]->setVel( vel ); |
533 | ||
534 | return NULL; | |
535 | } | |
# | Line 618 | Line 611 | char* InitializeFromFile::parseCommentLine(char* readL | |
611 | return NULL; | |
612 | ||
613 | //get eta | |
614 | < | foo = strtok(NULL, " ,;\t"); |
614 | > | foo = strtok(NULL, " ,;\t\n"); |
615 | if(foo != NULL ){ | |
616 | + | |
617 | for(int i = 0 ; i < 9; i++){ | |
618 | ||
619 | if(foo == NULL){ | |
# | Line 628 | Line 622 | char* InitializeFromFile::parseCommentLine(char* readL | |
622 | return strdup( painCave.errMsg ); | |
623 | } | |
624 | eta[i] = atof( foo ); | |
625 | < | foo = strtok(NULL, " ,;\t"); |
625 | > | foo = strtok(NULL, " ,;\t\n"); |
626 | } | |
627 | } | |
628 | else | |
# | Line 636 | Line 630 | char* InitializeFromFile::parseCommentLine(char* readL | |
630 | ||
631 | //push eta into SimInfo::properties which can be | |
632 | //retrieved by integrator later | |
633 | < | //entry_plug->setBoxM( theBoxMat3 ); |
633 | > | |
634 | DoubleArrayData* etaValue = new DoubleArrayData(); | |
635 | etaValue->setID(ETAVALUE_ID); | |
636 | etaValue->setData(eta, 9); |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |