9 |
|
#include "parse_me.h" |
10 |
|
#include "Integrator.hpp" |
11 |
|
#include "simError.h" |
12 |
+ |
#include "ConjugateMinimizer.hpp" |
13 |
|
|
14 |
|
#ifdef IS_MPI |
15 |
|
#include "mpiBASS.h" |
25 |
|
#define NPTxyz_ENS 4 |
26 |
|
|
27 |
|
|
28 |
< |
#define FF_DUFF 0 |
29 |
< |
#define FF_LJ 1 |
30 |
< |
#define FF_EAM 2 |
28 |
> |
#define FF_DUFF 0 |
29 |
> |
#define FF_LJ 1 |
30 |
> |
#define FF_EAM 2 |
31 |
> |
#define FF_H2O 3 |
32 |
|
|
33 |
|
using namespace std; |
34 |
|
|
35 |
+ |
/** |
36 |
+ |
* Check whether dividend is divisble by divisor or not |
37 |
+ |
*/ |
38 |
+ |
bool isDivisible(double dividend, double divisor){ |
39 |
+ |
double tolerance = 0.000001; |
40 |
+ |
double quotient; |
41 |
+ |
double diff; |
42 |
+ |
int intQuotient; |
43 |
+ |
|
44 |
+ |
quotient = dividend / divisor; |
45 |
+ |
|
46 |
+ |
if (quotient < 0) |
47 |
+ |
quotient = -quotient; |
48 |
+ |
|
49 |
+ |
intQuotient = int (quotient + tolerance); |
50 |
+ |
|
51 |
+ |
diff = fabs(fabs(dividend) - intQuotient * fabs(divisor)); |
52 |
+ |
|
53 |
+ |
if (diff <= tolerance) |
54 |
+ |
return true; |
55 |
+ |
else |
56 |
+ |
return false; |
57 |
+ |
} |
58 |
+ |
|
59 |
|
SimSetup::SimSetup(){ |
60 |
|
|
61 |
|
initSuspend = false; |
129 |
|
|
130 |
|
sysObjectsCreation(); |
131 |
|
|
132 |
+ |
// check on the post processing info |
133 |
+ |
|
134 |
+ |
finalInfoCheck(); |
135 |
+ |
|
136 |
|
// initialize the system coordinates |
137 |
|
|
138 |
|
if ( !initSuspend ){ |
142 |
|
info[0].currentTime = 0.0; |
143 |
|
} |
144 |
|
|
115 |
– |
// check on the post processing info |
116 |
– |
|
117 |
– |
finalInfoCheck(); |
118 |
– |
|
145 |
|
// make the output filenames |
146 |
|
|
147 |
|
makeOutNames(); |
148 |
|
|
149 |
< |
// make the integrator |
150 |
< |
|
151 |
< |
makeIntegrator(); |
152 |
< |
|
149 |
> |
if (globals->haveMinimizer()) |
150 |
> |
// make minimizer |
151 |
> |
makeMinimizer(); |
152 |
> |
else |
153 |
> |
// make the integrator |
154 |
> |
makeIntegrator(); |
155 |
> |
|
156 |
|
#ifdef IS_MPI |
157 |
|
mpiSim->mpiRefresh(); |
158 |
|
#endif |
179 |
|
bend_set* theBends; |
180 |
|
torsion_set* theTorsions; |
181 |
|
|
153 |
– |
|
182 |
|
//init the forceField paramters |
183 |
|
|
184 |
|
the_ff->readParams(); |
186 |
|
|
187 |
|
// init the atoms |
188 |
|
|
189 |
+ |
double phi, theta, psi; |
190 |
+ |
double sux, suy, suz; |
191 |
+ |
double Axx, Axy, Axz, Ayx, Ayy, Ayz, Azx, Azy, Azz; |
192 |
|
double ux, uy, uz, u, uSqr; |
193 |
|
|
194 |
|
for (k = 0; k < nInfo; k++){ |
225 |
|
info[k].n_oriented++; |
226 |
|
molInfo.myAtoms[j] = dAtom; |
227 |
|
|
228 |
< |
ux = currentAtom->getOrntX(); |
229 |
< |
uy = currentAtom->getOrntY(); |
230 |
< |
uz = currentAtom->getOrntZ(); |
228 |
> |
// Directional Atoms have standard unit vectors which are oriented |
229 |
> |
// in space using the three Euler angles. We assume the standard |
230 |
> |
// unit vector was originally along the z axis below. |
231 |
> |
|
232 |
> |
phi = currentAtom->getEulerPhi() * M_PI / 180.0; |
233 |
> |
theta = currentAtom->getEulerTheta() * M_PI / 180.0; |
234 |
> |
psi = currentAtom->getEulerPsi()* M_PI / 180.0; |
235 |
> |
|
236 |
> |
Axx = (cos(phi) * cos(psi)) - (sin(phi) * cos(theta) * sin(psi)); |
237 |
> |
Axy = (sin(phi) * cos(psi)) + (cos(phi) * cos(theta) * sin(psi)); |
238 |
> |
Axz = sin(theta) * sin(psi); |
239 |
> |
|
240 |
> |
Ayx = -(cos(phi) * sin(psi)) - (sin(phi) * cos(theta) * cos(psi)); |
241 |
> |
Ayy = -(sin(phi) * sin(psi)) + (cos(phi) * cos(theta) * cos(psi)); |
242 |
> |
Ayz = sin(theta) * cos(psi); |
243 |
> |
|
244 |
> |
Azx = sin(phi) * sin(theta); |
245 |
> |
Azy = -cos(phi) * sin(theta); |
246 |
> |
Azz = cos(theta); |
247 |
|
|
248 |
+ |
sux = 0.0; |
249 |
+ |
suy = 0.0; |
250 |
+ |
suz = 1.0; |
251 |
+ |
|
252 |
+ |
ux = (Axx * sux) + (Ayx * suy) + (Azx * suz); |
253 |
+ |
uy = (Axy * sux) + (Ayy * suy) + (Azy * suz); |
254 |
+ |
uz = (Axz * sux) + (Ayz * suy) + (Azz * suz); |
255 |
+ |
|
256 |
|
uSqr = (ux * ux) + (uy * uy) + (uz * uz); |
257 |
|
|
258 |
|
u = sqrt(uSqr); |
640 |
|
else if (!strcasecmp(force_field, "EAM")){ |
641 |
|
ffCase = FF_EAM; |
642 |
|
} |
643 |
+ |
else if (!strcasecmp(force_field, "WATER")){ |
644 |
+ |
ffCase = FF_H2O; |
645 |
+ |
} |
646 |
|
else{ |
647 |
|
sprintf(painCave.errMsg, "SimSetup Error. Unrecognized force field -> %s\n", |
648 |
|
force_field); |
671 |
|
} |
672 |
|
else{ |
673 |
|
sprintf(painCave.errMsg, |
674 |
< |
"SimSetup Warning. Unrecognized Ensemble -> %s, " |
675 |
< |
"reverting to NVE for this simulation.\n", |
674 |
> |
"SimSetup Warning. Unrecognized Ensemble -> %s \n" |
675 |
> |
"\treverting to NVE for this simulation.\n", |
676 |
|
ensemble); |
677 |
|
painCave.isFatal = 0; |
678 |
|
simError(); |
704 |
|
if (!the_components[i]->haveNMol()){ |
705 |
|
// we have a problem |
706 |
|
sprintf(painCave.errMsg, |
707 |
< |
"SimSetup Error. No global NMol or component NMol" |
708 |
< |
" given. Cannot calculate the number of atoms.\n"); |
707 |
> |
"SimSetup Error. No global NMol or component NMol given.\n" |
708 |
> |
"\tCannot calculate the number of atoms.\n"); |
709 |
|
painCave.isFatal = 1; |
710 |
|
simError(); |
711 |
|
} |
725 |
|
simError(); |
726 |
|
} |
727 |
|
|
728 |
+ |
//check whether sample time, status time, thermal time and reset time are divisble by dt |
729 |
+ |
if (!isDivisible(globals->getSampleTime(), globals->getDt())){ |
730 |
+ |
sprintf(painCave.errMsg, |
731 |
+ |
"Sample time is not divisible by dt.\n" |
732 |
+ |
"\tThis will result in samples that are not uniformly\n" |
733 |
+ |
"\tdistributed in time. If this is a problem, change\n" |
734 |
+ |
"\tyour sampleTime variable.\n"); |
735 |
+ |
painCave.isFatal = 0; |
736 |
+ |
simError(); |
737 |
+ |
} |
738 |
+ |
|
739 |
+ |
if (globals->haveStatusTime() && !isDivisible(globals->getSampleTime(), globals->getDt())){ |
740 |
+ |
sprintf(painCave.errMsg, |
741 |
+ |
"Status time is not divisible by dt.\n" |
742 |
+ |
"\tThis will result in status reports that are not uniformly\n" |
743 |
+ |
"\tdistributed in time. If this is a problem, change \n" |
744 |
+ |
"\tyour statusTime variable.\n"); |
745 |
+ |
painCave.isFatal = 0; |
746 |
+ |
simError(); |
747 |
+ |
} |
748 |
+ |
|
749 |
+ |
if (globals->haveThermalTime() && !isDivisible(globals->getThermalTime(), globals->getDt())){ |
750 |
+ |
sprintf(painCave.errMsg, |
751 |
+ |
"Thermal time is not divisible by dt.\n" |
752 |
+ |
"\tThis will result in thermalizations that are not uniformly\n" |
753 |
+ |
"\tdistributed in time. If this is a problem, change \n" |
754 |
+ |
"\tyour thermalTime variable.\n"); |
755 |
+ |
painCave.isFatal = 0; |
756 |
+ |
simError(); |
757 |
+ |
} |
758 |
+ |
|
759 |
+ |
if (globals->haveResetTime() && !isDivisible(globals->getResetTime(), globals->getDt())){ |
760 |
+ |
sprintf(painCave.errMsg, |
761 |
+ |
"Reset time is not divisible by dt.\n" |
762 |
+ |
"\tThis will result in integrator resets that are not uniformly\n" |
763 |
+ |
"\tdistributed in time. If this is a problem, change\n" |
764 |
+ |
"\tyour resetTime variable.\n"); |
765 |
+ |
painCave.isFatal = 0; |
766 |
+ |
simError(); |
767 |
+ |
} |
768 |
+ |
|
769 |
|
// set the status, sample, and thermal kick times |
770 |
|
|
771 |
|
for (i = 0; i < nInfo; i++){ |
798 |
|
|
799 |
|
if (globals->haveTempSet()) |
800 |
|
info[i].setTemp = globals->getTempSet(); |
801 |
+ |
|
802 |
+ |
// check for the extended State init |
803 |
+ |
|
804 |
+ |
info[i].useInitXSstate = globals->getUseInitXSstate(); |
805 |
+ |
info[i].orthoTolerance = globals->getOrthoBoxTolerance(); |
806 |
|
|
807 |
|
} |
808 |
|
|
845 |
|
for (int i = 0; i < nInfo; i++){ |
846 |
|
info[i].setSeed(seedValue); |
847 |
|
} |
848 |
< |
|
848 |
> |
|
849 |
|
#ifdef IS_MPI |
850 |
< |
strcpy(checkPointMsg, "Succesfully gathered all information from Bass\n"); |
850 |
> |
strcpy(checkPointMsg, "Successfully gathered all information from Bass\n"); |
851 |
|
MPIcheckPoint(); |
852 |
|
#endif // is_mpi |
853 |
|
} |
880 |
|
|
881 |
|
if (!globals->haveECR()){ |
882 |
|
sprintf(painCave.errMsg, |
883 |
< |
"SimSetup Warning: using default value of 1/2 the smallest " |
884 |
< |
"box length for the electrostaticCutoffRadius.\n" |
885 |
< |
"I hope you have a very fast processor!\n"); |
883 |
> |
"SimSetup Warning: No value was set for electrostaticCutoffRadius.\n" |
884 |
> |
"\tOOPSE will use a default value of 15.0 angstroms" |
885 |
> |
"\tfor the electrostaticCutoffRadius.\n"); |
886 |
|
painCave.isFatal = 0; |
887 |
|
simError(); |
888 |
< |
double smallest; |
785 |
< |
smallest = info[i].boxL[0]; |
786 |
< |
if (info[i].boxL[1] <= smallest) |
787 |
< |
smallest = info[i].boxL[1]; |
788 |
< |
if (info[i].boxL[2] <= smallest) |
789 |
< |
smallest = info[i].boxL[2]; |
790 |
< |
theEcr = 0.5 * smallest; |
888 |
> |
theEcr = 15.0; |
889 |
|
} |
890 |
|
else{ |
891 |
|
theEcr = globals->getECR(); |
893 |
|
|
894 |
|
if (!globals->haveEST()){ |
895 |
|
sprintf(painCave.errMsg, |
896 |
< |
"SimSetup Warning: using default value of 0.05 * the " |
897 |
< |
"electrostaticCutoffRadius for the electrostaticSkinThickness\n"); |
896 |
> |
"SimSetup Warning: No value was set for electrostaticSkinThickness.\n" |
897 |
> |
"\tOOPSE will use a default value of\n" |
898 |
> |
"\t0.05 * electrostaticCutoffRadius\n" |
899 |
> |
"\tfor the electrostaticSkinThickness\n"); |
900 |
|
painCave.isFatal = 0; |
901 |
|
simError(); |
902 |
|
theEst = 0.05 * theEcr; |
909 |
|
|
910 |
|
if (!globals->haveDielectric()){ |
911 |
|
sprintf(painCave.errMsg, |
912 |
< |
"SimSetup Error: You are trying to use Reaction Field without" |
913 |
< |
"setting a dielectric constant!\n"); |
912 |
> |
"SimSetup Error: No Dielectric constant was set.\n" |
913 |
> |
"\tYou are trying to use Reaction Field without" |
914 |
> |
"\tsetting a dielectric constant!\n"); |
915 |
|
painCave.isFatal = 1; |
916 |
|
simError(); |
917 |
|
} |
921 |
|
if (usesDipoles){ |
922 |
|
if (!globals->haveECR()){ |
923 |
|
sprintf(painCave.errMsg, |
924 |
< |
"SimSetup Warning: using default value of 1/2 the smallest " |
925 |
< |
"box length for the electrostaticCutoffRadius.\n" |
926 |
< |
"I hope you have a very fast processor!\n"); |
927 |
< |
painCave.isFatal = 0; |
928 |
< |
simError(); |
929 |
< |
double smallest; |
829 |
< |
smallest = info[i].boxL[0]; |
830 |
< |
if (info[i].boxL[1] <= smallest) |
831 |
< |
smallest = info[i].boxL[1]; |
832 |
< |
if (info[i].boxL[2] <= smallest) |
833 |
< |
smallest = info[i].boxL[2]; |
834 |
< |
theEcr = 0.5 * smallest; |
924 |
> |
"SimSetup Warning: No value was set for electrostaticCutoffRadius.\n" |
925 |
> |
"\tOOPSE will use a default value of 15.0 angstroms" |
926 |
> |
"\tfor the electrostaticCutoffRadius.\n"); |
927 |
> |
painCave.isFatal = 0; |
928 |
> |
simError(); |
929 |
> |
theEcr = 15.0; |
930 |
|
} |
931 |
|
else{ |
932 |
|
theEcr = globals->getECR(); |
933 |
|
} |
934 |
< |
|
934 |
> |
|
935 |
|
if (!globals->haveEST()){ |
936 |
|
sprintf(painCave.errMsg, |
937 |
< |
"SimSetup Warning: using default value of 0.05 * the " |
938 |
< |
"electrostaticCutoffRadius for the " |
939 |
< |
"electrostaticSkinThickness\n"); |
937 |
> |
"SimSetup Warning: No value was set for electrostaticSkinThickness.\n" |
938 |
> |
"\tOOPSE will use a default value of\n" |
939 |
> |
"\t0.05 * electrostaticCutoffRadius\n" |
940 |
> |
"\tfor the electrostaticSkinThickness\n"); |
941 |
|
painCave.isFatal = 0; |
942 |
|
simError(); |
943 |
|
theEst = 0.05 * theEcr; |
945 |
|
else{ |
946 |
|
theEst = globals->getEST(); |
947 |
|
} |
948 |
< |
|
948 |
> |
|
949 |
|
info[i].setDefaultEcr(theEcr, theEst); |
950 |
|
} |
951 |
|
} |
952 |
|
} |
857 |
– |
|
953 |
|
#ifdef IS_MPI |
954 |
|
strcpy(checkPointMsg, "post processing checks out"); |
955 |
|
MPIcheckPoint(); |
956 |
|
#endif // is_mpi |
957 |
|
} |
958 |
< |
|
958 |
> |
|
959 |
|
void SimSetup::initSystemCoords(void){ |
960 |
|
int i; |
961 |
|
|
983 |
|
delete fileInit; |
984 |
|
} |
985 |
|
else{ |
986 |
< |
#ifdef IS_MPI |
892 |
< |
|
986 |
> |
|
987 |
|
// no init from bass |
988 |
< |
|
988 |
> |
|
989 |
|
sprintf(painCave.errMsg, |
990 |
< |
"Cannot intialize a parallel simulation without an initial configuration file.\n"); |
990 |
> |
"Cannot intialize a simulation without an initial configuration file.\n"); |
991 |
|
painCave.isFatal = 1;; |
992 |
|
simError(); |
993 |
< |
|
900 |
< |
#else |
901 |
< |
|
902 |
< |
initFromBass(); |
903 |
< |
|
904 |
< |
|
905 |
< |
#endif |
993 |
> |
|
994 |
|
} |
995 |
|
|
996 |
|
#ifdef IS_MPI |
1144 |
|
the_ff = new EAM_FF(); |
1145 |
|
break; |
1146 |
|
|
1147 |
+ |
case FF_H2O: |
1148 |
+ |
the_ff = new WATER(); |
1149 |
+ |
break; |
1150 |
+ |
|
1151 |
|
default: |
1152 |
|
sprintf(painCave.errMsg, |
1153 |
|
"SimSetup Error. Unrecognized force field in case statement.\n"); |
1290 |
|
|
1291 |
|
if (local_atoms != info[0].n_atoms){ |
1292 |
|
sprintf(painCave.errMsg, |
1293 |
< |
"SimSetup error: mpiSim's localAtom (%d) and SimSetup's" |
1294 |
< |
" localAtom (%d) are not equal.\n", |
1293 |
> |
"SimSetup error: mpiSim's localAtom (%d) and SimSetup's\n" |
1294 |
> |
"\tlocalAtom (%d) are not equal.\n", |
1295 |
|
info[0].n_atoms, local_atoms); |
1296 |
|
painCave.isFatal = 1; |
1297 |
|
simError(); |
1433 |
|
else{ |
1434 |
|
sprintf(painCave.errMsg, |
1435 |
|
"SimSetup error: If you use the NVT\n" |
1436 |
< |
" ensemble, you must set tauThermostat.\n"); |
1436 |
> |
"\tensemble, you must set tauThermostat.\n"); |
1437 |
|
painCave.isFatal = 1; |
1438 |
|
simError(); |
1439 |
|
} |
1456 |
|
else{ |
1457 |
|
sprintf(painCave.errMsg, |
1458 |
|
"SimSetup error: If you use a constant pressure\n" |
1459 |
< |
" ensemble, you must set targetPressure in the BASS file.\n"); |
1459 |
> |
"\tensemble, you must set targetPressure in the BASS file.\n"); |
1460 |
|
painCave.isFatal = 1; |
1461 |
|
simError(); |
1462 |
|
} |
1466 |
|
else{ |
1467 |
|
sprintf(painCave.errMsg, |
1468 |
|
"SimSetup error: If you use an NPT\n" |
1469 |
< |
" ensemble, you must set tauThermostat.\n"); |
1469 |
> |
"\tensemble, you must set tauThermostat.\n"); |
1470 |
|
painCave.isFatal = 1; |
1471 |
|
simError(); |
1472 |
|
} |
1476 |
|
else{ |
1477 |
|
sprintf(painCave.errMsg, |
1478 |
|
"SimSetup error: If you use an NPT\n" |
1479 |
< |
" ensemble, you must set tauBarostat.\n"); |
1479 |
> |
"\tensemble, you must set tauBarostat.\n"); |
1480 |
|
painCave.isFatal = 1; |
1481 |
|
simError(); |
1482 |
|
} |
1499 |
|
else{ |
1500 |
|
sprintf(painCave.errMsg, |
1501 |
|
"SimSetup error: If you use a constant pressure\n" |
1502 |
< |
" ensemble, you must set targetPressure in the BASS file.\n"); |
1502 |
> |
"\tensemble, you must set targetPressure in the BASS file.\n"); |
1503 |
|
painCave.isFatal = 1; |
1504 |
|
simError(); |
1505 |
|
} |
1506 |
|
|
1507 |
|
if (globals->haveTauThermostat()) |
1508 |
|
myNPTf->setTauThermostat(globals->getTauThermostat()); |
1509 |
+ |
|
1510 |
|
else{ |
1511 |
|
sprintf(painCave.errMsg, |
1512 |
|
"SimSetup error: If you use an NPT\n" |
1513 |
< |
" ensemble, you must set tauThermostat.\n"); |
1513 |
> |
"\tensemble, you must set tauThermostat.\n"); |
1514 |
|
painCave.isFatal = 1; |
1515 |
|
simError(); |
1516 |
|
} |
1517 |
|
|
1518 |
|
if (globals->haveTauBarostat()) |
1519 |
|
myNPTf->setTauBarostat(globals->getTauBarostat()); |
1520 |
+ |
|
1521 |
|
else{ |
1522 |
|
sprintf(painCave.errMsg, |
1523 |
|
"SimSetup error: If you use an NPT\n" |
1524 |
< |
" ensemble, you must set tauBarostat.\n"); |
1524 |
> |
"\tensemble, you must set tauBarostat.\n"); |
1525 |
|
painCave.isFatal = 1; |
1526 |
|
simError(); |
1527 |
|
} |
1544 |
|
else{ |
1545 |
|
sprintf(painCave.errMsg, |
1546 |
|
"SimSetup error: If you use a constant pressure\n" |
1547 |
< |
" ensemble, you must set targetPressure in the BASS file.\n"); |
1547 |
> |
"\tensemble, you must set targetPressure in the BASS file.\n"); |
1548 |
|
painCave.isFatal = 1; |
1549 |
|
simError(); |
1550 |
|
} |
1554 |
|
else{ |
1555 |
|
sprintf(painCave.errMsg, |
1556 |
|
"SimSetup error: If you use an NPT\n" |
1557 |
< |
" ensemble, you must set tauThermostat.\n"); |
1557 |
> |
"\tensemble, you must set tauThermostat.\n"); |
1558 |
|
painCave.isFatal = 1; |
1559 |
|
simError(); |
1560 |
|
} |
1564 |
|
else{ |
1565 |
|
sprintf(painCave.errMsg, |
1566 |
|
"SimSetup error: If you use an NPT\n" |
1567 |
< |
" ensemble, you must set tauBarostat.\n"); |
1567 |
> |
"\tensemble, you must set tauBarostat.\n"); |
1568 |
|
painCave.isFatal = 1; |
1569 |
|
simError(); |
1570 |
|
} |
1617 |
|
} |
1618 |
|
else{ |
1619 |
|
sprintf(painCave.errMsg, |
1620 |
< |
"ZConstraint error: If you use an ZConstraint\n" |
1621 |
< |
" , you must set sample time.\n"); |
1620 |
> |
"ZConstraint error: If you use a ZConstraint,\n" |
1621 |
> |
"\tyou must set zconsTime.\n"); |
1622 |
|
painCave.isFatal = 1; |
1623 |
|
simError(); |
1624 |
|
} |
1633 |
|
else{ |
1634 |
|
double defaultZConsTol = 0.01; |
1635 |
|
sprintf(painCave.errMsg, |
1636 |
< |
"ZConstraint Waring: Tolerance for z-constraint methodl is not specified\n" |
1637 |
< |
" , default value %f is used.\n", |
1636 |
> |
"ZConstraint Warning: Tolerance for z-constraint method is not specified.\n" |
1637 |
> |
"\tOOPSE will use a default value of %f.\n" |
1638 |
> |
"\tTo set the tolerance, use the zconsTol variable.\n", |
1639 |
|
defaultZConsTol); |
1640 |
|
painCave.isFatal = 0; |
1641 |
|
simError(); |
1653 |
|
} |
1654 |
|
else{ |
1655 |
|
sprintf(painCave.errMsg, |
1656 |
< |
"ZConstraint Warning: User does not set force Subtraction policy, " |
1657 |
< |
"PolicyByMass is used\n"); |
1656 |
> |
"ZConstraint Warning: No force subtraction policy was set.\n" |
1657 |
> |
"\tOOPSE will use PolicyByMass.\n" |
1658 |
> |
"\tTo set the policy, use the zconsForcePolicy variable.\n"); |
1659 |
|
painCave.isFatal = 0; |
1660 |
|
simError(); |
1661 |
|
zconsForcePolicy->setData("BYMASS"); |
1699 |
|
//check the uniqueness of index |
1700 |
|
if(!zconsParaData->isIndexUnique()){ |
1701 |
|
sprintf(painCave.errMsg, |
1702 |
< |
"ZConstraint Error: molIndex is not unique\n"); |
1702 |
> |
"ZConstraint Error: molIndex is not unique!\n"); |
1703 |
|
painCave.isFatal = 1; |
1704 |
|
simError(); |
1705 |
|
} |
1710 |
|
//push data into siminfo, therefore, we can retrieve later |
1711 |
|
theInfo.addProperty(zconsParaData); |
1712 |
|
} |
1713 |
+ |
|
1714 |
+ |
void SimSetup::makeMinimizer(){ |
1715 |
+ |
/* |
1716 |
+ |
OOPSEMinimizerBase* myOOPSEMinimizerBase; |
1717 |
+ |
ObjFunctor1 * objFunc; |
1718 |
+ |
OutputFunctor* outputFunc; |
1719 |
+ |
ConcreteNLModel1* nlp; |
1720 |
+ |
MinimizerParameterSet* param; |
1721 |
+ |
ConjugateMinimizerBase* minimizer; |
1722 |
+ |
int dim; |
1723 |
+ |
|
1724 |
+ |
for (int i = 0; i < nInfo; i++){ |
1725 |
+ |
//creat |
1726 |
+ |
myOOPSEMinimizerBase = new OOPSEMinimizerBase(&(info[i]), the_ff); |
1727 |
+ |
|
1728 |
+ |
//creat the object functor; |
1729 |
+ |
objFunc = (ObjFunctor1*) new ClassMemObjFunctor1<OOPSEMinimizerBase> |
1730 |
+ |
(myOOPSEMinimizerBase, &OOPSEMinimizerBase::calcGradient); |
1731 |
+ |
|
1732 |
+ |
//creat output functor; |
1733 |
+ |
outputFunc = new ClassMemOutputFunctor<OOPSEMinimizerBase> |
1734 |
+ |
(myOOPSEMinimizerBase, &OOPSEMinimizerBase::output); |
1735 |
+ |
|
1736 |
+ |
//creat nonlinear model |
1737 |
+ |
dim = myOOPSEMinimizerBase->getDim(); |
1738 |
+ |
nlp = new ConcreteNLModel1(dim, objFunc); |
1739 |
+ |
|
1740 |
+ |
//prepare parameter set for minimizer |
1741 |
+ |
param = new MinimizerParameterSet(); |
1742 |
+ |
param->setDefaultParameter(); |
1743 |
+ |
|
1744 |
+ |
if (globals->haveMinimizer()){ |
1745 |
+ |
param->setFTol(globals->getMinFTol()); |
1746 |
+ |
} |
1747 |
+ |
|
1748 |
+ |
if (globals->haveMinGTol()){ |
1749 |
+ |
param->setGTol(globals->getMinGTol()); |
1750 |
+ |
} |
1751 |
+ |
|
1752 |
+ |
if (globals->haveMinMaxIter()){ |
1753 |
+ |
param->setMaxIteration(globals->getMinMaxIter()); |
1754 |
+ |
} |
1755 |
+ |
|
1756 |
+ |
if (globals->haveMinWriteFrq()){ |
1757 |
+ |
param->setMaxIteration(globals->getMinMaxIter()); |
1758 |
+ |
} |
1759 |
+ |
|
1760 |
+ |
if (globals->haveMinWriteFrq()){ |
1761 |
+ |
param->setWriteFrq(globals->getMinWriteFrq()); |
1762 |
+ |
} |
1763 |
+ |
|
1764 |
+ |
if (globals->haveMinResetFrq()){ |
1765 |
+ |
param->setResetFrq(globals->getMinResetFrq()); |
1766 |
+ |
} |
1767 |
+ |
|
1768 |
+ |
if (globals->haveMinLSMaxIter()){ |
1769 |
+ |
param->setLineSearchMaxIteration(globals->getMinLSMaxIter()); |
1770 |
+ |
} |
1771 |
+ |
|
1772 |
+ |
if (globals->haveMinLSTol()){ |
1773 |
+ |
param->setLineSearchTol(globals->getMinLSTol()); |
1774 |
+ |
} |
1775 |
+ |
|
1776 |
+ |
//creat the minimizer |
1777 |
+ |
minimizer = new PRCGMinimizer(nlp, param); |
1778 |
+ |
minimizer->setLineSearchStrategy(nlp, GoldenSection); |
1779 |
+ |
minimizer->setOutputFunctor(outputFunc); |
1780 |
+ |
|
1781 |
+ |
//store the minimizer into simInfo |
1782 |
+ |
info[i].the_minimizer = minimizer; |
1783 |
+ |
info[i].has_minimizer = true; |
1784 |
+ |
} |
1785 |
+ |
*/ |
1786 |
+ |
} |