15 |
|
#include "mpiForceField.h" |
16 |
|
#endif // is_mpi |
17 |
|
|
18 |
– |
namespace TPE { // restrict the access of the folowing to this file only. |
18 |
|
|
19 |
+ |
// define some bond Types |
20 |
|
|
21 |
+ |
#define FIXED_BOND 0 |
22 |
+ |
#define HARMONIC_BOND 1 |
23 |
+ |
|
24 |
+ |
|
25 |
+ |
namespace DUFF_NS { // restrict the access of the folowing to this file only. |
26 |
+ |
|
27 |
+ |
|
28 |
|
// Declare the structures that will be passed by MPI |
29 |
|
|
30 |
|
typedef struct{ |
35 |
|
double dipole; |
36 |
|
double w0; |
37 |
|
double v0; |
38 |
+ |
double v0p; |
39 |
+ |
double rl; |
40 |
+ |
double ru; |
41 |
+ |
double rlp; |
42 |
+ |
double rup; |
43 |
|
int isSSD; |
44 |
|
int isDipole; |
45 |
|
int ident; |
51 |
|
typedef struct{ |
52 |
|
char nameA[15]; |
53 |
|
char nameB[15]; |
42 |
– |
char type[30]; |
54 |
|
double d0; |
55 |
+ |
double k0; |
56 |
|
int last; // 0 -> default |
57 |
|
// 1 -> tells nodes to stop listening |
58 |
+ |
int type; |
59 |
|
} bondStruct; |
60 |
|
|
61 |
|
|
143 |
|
next->dipole = info.dipole; |
144 |
|
next->w0 = info.w0; |
145 |
|
next->v0 = info.v0; |
146 |
+ |
next->v0p = info.v0p; |
147 |
+ |
next->rl = info.rl; |
148 |
+ |
next->ru = info.ru; |
149 |
+ |
next->rlp = info.rlp; |
150 |
+ |
next->rup = info.rup; |
151 |
|
next->ident = info.ident; |
152 |
|
} |
153 |
|
} |
164 |
|
info.dipole = dipole; |
165 |
|
info.w0 = w0; |
166 |
|
info.v0 = v0; |
167 |
+ |
info.v0p = v0p; |
168 |
+ |
info.rl = rl; |
169 |
+ |
info.ru = ru; |
170 |
+ |
info.rlp = rlp; |
171 |
+ |
info.rup = rup; |
172 |
|
info.ident = ident; |
173 |
|
info.last = 0; |
174 |
|
} |
185 |
|
double dipole; |
186 |
|
double w0; |
187 |
|
double v0; |
188 |
+ |
double v0p; |
189 |
+ |
double rl; |
190 |
+ |
double ru; |
191 |
+ |
double rlp; |
192 |
+ |
double rup; |
193 |
|
int ident; |
194 |
|
LinkedAtomType* next; |
195 |
|
}; |
200 |
|
next = NULL; |
201 |
|
nameA[0] = '\0'; |
202 |
|
nameB[0] = '\0'; |
175 |
– |
type[0] = '\0'; |
203 |
|
} |
204 |
|
~LinkedBondType(){ if( next != NULL ) delete next; } |
205 |
|
|
234 |
|
next = new LinkedBondType(); |
235 |
|
strcpy(next->nameA, info.nameA); |
236 |
|
strcpy(next->nameB, info.nameB); |
237 |
< |
strcpy(next->type, info.type); |
237 |
> |
next->type = info.type; |
238 |
|
next->d0 = info.d0; |
239 |
+ |
next->k0 = info.k0; |
240 |
|
} |
241 |
|
} |
242 |
|
|
244 |
|
void duplicate( bondStruct &info ){ |
245 |
|
strcpy(info.nameA, nameA); |
246 |
|
strcpy(info.nameB, nameB); |
247 |
< |
strcpy(info.type, type); |
247 |
> |
info.type = type; |
248 |
|
info.d0 = d0; |
249 |
+ |
info.k0 = k0; |
250 |
|
info.last = 0; |
251 |
|
} |
252 |
|
|
255 |
|
|
256 |
|
char nameA[15]; |
257 |
|
char nameB[15]; |
258 |
< |
char type[30]; |
258 |
> |
int type; |
259 |
|
double d0; |
260 |
+ |
double k0; |
261 |
|
|
262 |
|
LinkedBondType* next; |
263 |
|
}; |
440 |
|
|
441 |
|
} // namespace |
442 |
|
|
443 |
< |
using namespace TPE; |
443 |
> |
using namespace DUFF_NS; |
444 |
|
|
445 |
|
|
446 |
|
//**************************************************************** |
454 |
|
char* ffPath_env = "FORCE_PARAM_PATH"; |
455 |
|
char* ffPath; |
456 |
|
char temp[200]; |
427 |
– |
char errMsg[1000]; |
457 |
|
|
458 |
|
headAtomType = NULL; |
459 |
|
currentAtomType = NULL; |
475 |
|
// Init the atomStruct mpi type |
476 |
|
|
477 |
|
atomStruct atomProto; // mpiPrototype |
478 |
< |
int atomBC[3] = {15,6,4}; // block counts |
478 |
> |
int atomBC[3] = {15,11,4}; // block counts |
479 |
|
MPI_Aint atomDspls[3]; // displacements |
480 |
|
MPI_Datatype atomMbrTypes[3]; // member mpi types |
481 |
|
|
497 |
|
// Init the bondStruct mpi type |
498 |
|
|
499 |
|
bondStruct bondProto; // mpiPrototype |
500 |
< |
int bondBC[3] = {60,1,1}; // block counts |
500 |
> |
int bondBC[3] = {30,2,2}; // block counts |
501 |
|
MPI_Aint bondDspls[3]; // displacements |
502 |
|
MPI_Datatype bondMbrTypes[3]; // member mpi types |
503 |
|
|
657 |
|
|
658 |
|
void DUFF::readParams( void ){ |
659 |
|
|
631 |
– |
int i, a, b, c, d; |
660 |
|
int identNum; |
633 |
– |
char* atomA; |
634 |
– |
char* atomB; |
635 |
– |
char* atomC; |
636 |
– |
char* atomD; |
661 |
|
|
662 |
|
atomStruct atomInfo; |
663 |
|
bondStruct bondInfo; |
778 |
|
|
779 |
|
int isGB = 0; |
780 |
|
int isLJ = 1; |
781 |
< |
double GB_dummy = 0.0; |
782 |
< |
|
759 |
< |
|
781 |
> |
int isEAM =0; |
782 |
> |
|
783 |
|
currentAtomType = headAtomType->next;; |
784 |
|
while( currentAtomType != NULL ){ |
785 |
|
|
786 |
|
if(currentAtomType->isDipole) entry_plug->useDipole = 1; |
787 |
|
if(currentAtomType->isSSD) { |
788 |
|
entry_plug->useSticky = 1; |
789 |
< |
set_sticky_params( &(currentAtomType->w0), &(currentAtomType->v0)); |
789 |
> |
set_sticky_params( &(currentAtomType->w0), &(currentAtomType->v0), |
790 |
> |
&(currentAtomType->v0p), |
791 |
> |
&(currentAtomType->rl), &(currentAtomType->ru), |
792 |
> |
&(currentAtomType->rlp), &(currentAtomType->rup)); |
793 |
|
} |
794 |
|
|
795 |
|
if( currentAtomType->name[0] != '\0' ){ |
799 |
|
&(currentAtomType->isSSD), |
800 |
|
&(currentAtomType->isDipole), |
801 |
|
&isGB, |
802 |
+ |
&isEAM, |
803 |
|
&(currentAtomType->epslon), |
804 |
|
&(currentAtomType->sigma), |
805 |
|
&(currentAtomType->dipole), |
1216 |
|
simError(); |
1217 |
|
} |
1218 |
|
|
1219 |
< |
if( !strcmp( currentBondType->type, "fixed" ) ){ |
1220 |
< |
|
1219 |
> |
switch( currentBondType->type ){ |
1220 |
> |
|
1221 |
> |
case FIXED_BOND: |
1222 |
> |
|
1223 |
|
bondArray[i] = new ConstrainedBond( *the_atoms[a], |
1224 |
|
*the_atoms[b], |
1225 |
|
currentBondType->d0 ); |
1226 |
|
entry_plug->n_constraints++; |
1227 |
+ |
break; |
1228 |
+ |
|
1229 |
+ |
case HARMONIC_BOND: |
1230 |
+ |
|
1231 |
+ |
bondArray[i] = new HarmonicBond( *the_atoms[a], |
1232 |
+ |
*the_atoms[b], |
1233 |
+ |
currentBondType->d0, |
1234 |
+ |
currentBondType->k0 ); |
1235 |
+ |
break; |
1236 |
+ |
|
1237 |
+ |
default: |
1238 |
+ |
|
1239 |
+ |
break; |
1240 |
+ |
// do nothing |
1241 |
|
} |
1242 |
|
} |
1243 |
|
} |
1302 |
|
} |
1303 |
|
|
1304 |
|
gBend = new GhostBend( *the_atoms[a], |
1305 |
< |
*the_atoms[b] ); |
1305 |
> |
*the_atoms[b]); |
1306 |
> |
|
1307 |
|
gBend->setConstants( currentBendType->k1, |
1308 |
|
currentBendType->k2, |
1309 |
|
currentBendType->k3, |
1319 |
|
currentBendType->k3, |
1320 |
|
currentBendType->t0 ); |
1321 |
|
bendArray[i] = qBend; |
1322 |
< |
} |
1322 |
> |
} |
1323 |
|
} |
1324 |
|
} |
1325 |
|
} |
1426 |
|
} |
1427 |
|
|
1428 |
|
|
1429 |
< |
int TPE::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){ |
1429 |
> |
int DUFF_NS::parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){ |
1430 |
|
|
1431 |
|
char* the_token; |
1432 |
|
|
1512 |
|
} |
1513 |
|
|
1514 |
|
info.v0 = atof( the_token ); |
1515 |
+ |
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1516 |
+ |
sprintf( painCave.errMsg, |
1517 |
+ |
"Error parseing AtomTypes: line %d\n", lineNum ); |
1518 |
+ |
painCave.isFatal = 1; |
1519 |
+ |
simError(); |
1520 |
+ |
} |
1521 |
+ |
|
1522 |
+ |
info.v0p = atof( the_token ); |
1523 |
+ |
|
1524 |
+ |
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1525 |
+ |
sprintf( painCave.errMsg, |
1526 |
+ |
"Error parseing AtomTypes: line %d\n", lineNum ); |
1527 |
+ |
painCave.isFatal = 1; |
1528 |
+ |
simError(); |
1529 |
+ |
} |
1530 |
+ |
|
1531 |
+ |
info.rl = atof( the_token ); |
1532 |
+ |
|
1533 |
+ |
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1534 |
+ |
sprintf( painCave.errMsg, |
1535 |
+ |
"Error parseing AtomTypes: line %d\n", lineNum ); |
1536 |
+ |
painCave.isFatal = 1; |
1537 |
+ |
simError(); |
1538 |
+ |
} |
1539 |
+ |
|
1540 |
+ |
info.ru = atof( the_token ); |
1541 |
+ |
|
1542 |
+ |
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1543 |
+ |
sprintf( painCave.errMsg, |
1544 |
+ |
"Error parseing AtomTypes: line %d\n", lineNum ); |
1545 |
+ |
painCave.isFatal = 1; |
1546 |
+ |
simError(); |
1547 |
+ |
} |
1548 |
+ |
|
1549 |
+ |
info.rlp = atof( the_token ); |
1550 |
+ |
|
1551 |
+ |
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1552 |
+ |
sprintf( painCave.errMsg, |
1553 |
+ |
"Error parseing AtomTypes: line %d\n", lineNum ); |
1554 |
+ |
painCave.isFatal = 1; |
1555 |
+ |
simError(); |
1556 |
+ |
} |
1557 |
+ |
|
1558 |
+ |
info.rup = atof( the_token ); |
1559 |
|
} |
1560 |
< |
else info.v0 = info.w0 = 0.0; |
1560 |
> |
else info.v0 = info.w0 = info.v0p = info.rl = info.ru = info.rlp = info.rup = 0.0; |
1561 |
|
|
1562 |
|
return 1; |
1563 |
|
} |
1564 |
|
else return 0; |
1565 |
|
} |
1566 |
|
|
1567 |
< |
int TPE::parseBond( char *lineBuffer, int lineNum, bondStruct &info ){ |
1567 |
> |
int DUFF_NS::parseBond( char *lineBuffer, int lineNum, bondStruct &info ){ |
1568 |
|
|
1569 |
|
char* the_token; |
1570 |
+ |
char bondType[30]; |
1571 |
|
|
1572 |
|
the_token = strtok( lineBuffer, " \n\t,;" ); |
1573 |
|
if( the_token != NULL ){ |
1590 |
|
simError(); |
1591 |
|
} |
1592 |
|
|
1593 |
< |
strcpy( info.type, the_token ); |
1593 |
> |
strcpy( bondType, the_token ); |
1594 |
|
|
1595 |
< |
if( !strcmp( info.type, "fixed" ) ){ |
1595 |
> |
if( !strcmp( bondType, "fixed" ) ){ |
1596 |
> |
info.type = FIXED_BOND; |
1597 |
> |
|
1598 |
> |
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1599 |
> |
sprintf( painCave.errMsg, |
1600 |
> |
"Error parseing BondTypes: line %d\n", lineNum ); |
1601 |
> |
painCave.isFatal = 1; |
1602 |
> |
simError(); |
1603 |
> |
} |
1604 |
> |
|
1605 |
> |
info.d0 = atof( the_token ); |
1606 |
> |
|
1607 |
> |
info.k0=0.0; |
1608 |
> |
} |
1609 |
> |
else if( !strcmp( bondType, "harmonic" ) ){ |
1610 |
> |
info.type = HARMONIC_BOND; |
1611 |
> |
|
1612 |
|
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1613 |
|
sprintf( painCave.errMsg, |
1614 |
|
"Error parseing BondTypes: line %d\n", lineNum ); |
1617 |
|
} |
1618 |
|
|
1619 |
|
info.d0 = atof( the_token ); |
1620 |
+ |
|
1621 |
+ |
if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){ |
1622 |
+ |
sprintf( painCave.errMsg, |
1623 |
+ |
"Error parseing BondTypes: line %d\n", lineNum ); |
1624 |
+ |
painCave.isFatal = 1; |
1625 |
+ |
simError(); |
1626 |
+ |
} |
1627 |
+ |
|
1628 |
+ |
info.k0 = atof( the_token ); |
1629 |
|
} |
1630 |
+ |
|
1631 |
|
else{ |
1632 |
|
sprintf( painCave.errMsg, |
1633 |
|
"Unknown DUFF bond type \"%s\" at line %d\n", |
1634 |
< |
info.type, |
1634 |
> |
bondType, |
1635 |
|
lineNum ); |
1636 |
|
painCave.isFatal = 1; |
1637 |
|
simError(); |
1643 |
|
} |
1644 |
|
|
1645 |
|
|
1646 |
< |
int TPE::parseBend( char *lineBuffer, int lineNum, bendStruct &info ){ |
1646 |
> |
int DUFF_NS::parseBend( char *lineBuffer, int lineNum, bendStruct &info ){ |
1647 |
|
|
1648 |
|
char* the_token; |
1649 |
|
|
1731 |
|
else return 0; |
1732 |
|
} |
1733 |
|
|
1734 |
< |
int TPE::parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){ |
1734 |
> |
int DUFF_NS::parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){ |
1735 |
|
|
1736 |
|
char* the_token; |
1737 |
|
|