# | Line 5 | Line 5 | |
---|---|---|
5 | #include <string> | |
6 | ||
7 | #include "SimSetup.hpp" | |
8 | + | #include "ReadWrite.hpp" |
9 | #include "parse_me.h" | |
10 | #include "Integrator.hpp" | |
11 | #include "simError.h" | |
# | Line 22 | Line 23 | |
23 | #define NPTf_ENS 3 | |
24 | #define NPTim_ENS 4 | |
25 | #define NPTfm_ENS 5 | |
25 | – | #define NVEZCONS_ENS 6 |
26 | – | #define NVTZCONS_ENS 7 |
27 | – | #define NPTiZCONS_ENS 8 |
28 | – | #define NPTfZCONS_ENS 9 |
29 | – | #define NPTimZCONS_ENS 10 |
30 | – | #define NPTfmZCONS_ENS 11 |
26 | ||
27 | #define FF_DUFF 0 | |
28 | #define FF_LJ 1 | |
# | Line 102 | Line 97 | void SimSetup::createSim(void){ | |
97 | int i, j, k, globalAtomIndex; | |
98 | ||
99 | // gather all of the information from the Bass file | |
100 | < | |
100 | > | |
101 | > | std::cerr << "gathering info\n"; |
102 | > | |
103 | gatherInfo(); | |
104 | ||
105 | // creation of complex system objects | |
106 | ||
107 | + | std::cerr << "creating system objects\n"; |
108 | + | |
109 | sysObjectsCreation(); | |
110 | ||
111 | // check on the post processing info | |
112 | ||
113 | + | std::cerr << "performing final info check.\n"; |
114 | + | |
115 | finalInfoCheck(); | |
116 | ||
117 | // initialize the system coordinates | |
118 | ||
119 | + | std::cerr << "about to init coords\n"; |
120 | + | |
121 | if( !isInfoArray ) initSystemCoords(); | |
122 | ||
123 | // make the output filenames | |
# | Line 639 | Line 642 | void SimSetup::gatherInfo( void ){ | |
642 | else if( !strcasecmp( ensemble, "NPTf" )) ensembleCase = NPTf_ENS; | |
643 | else if( !strcasecmp( ensemble, "NPTim" )) ensembleCase = NPTim_ENS; | |
644 | else if( !strcasecmp( ensemble, "NPTfm" )) ensembleCase = NPTfm_ENS; | |
642 | – | |
643 | – | else if( !strcasecmp( ensemble, "NVEZCONS")) ensembleCase = NVEZCONS_ENS; |
644 | – | else if( !strcasecmp( ensemble, "NVTZCONS")) ensembleCase = NVTZCONS_ENS; |
645 | – | else if( !strcasecmp( ensemble, "NPTiZCONS") || !strcasecmp( ensemble, "NPTZCONS")) |
646 | – | ensembleCase = NPTiZCONS_ENS; |
647 | – | else if( !strcasecmp( ensemble, "NPTfZCONS")) ensembleCase = NPTfZCONS_ENS; |
648 | – | else if( !strcasecmp( ensemble, "NPTimZCONS")) ensembleCase = NPTimZCONS_ENS; |
649 | – | else if( !strcasecmp( ensemble, "NPTfmZCONS")) ensembleCase = NPTfmZCONS_ENS; |
650 | – | |
645 | else{ | |
646 | sprintf( painCave.errMsg, | |
647 | "SimSetup Warning. Unrecognized Ensemble -> %s, " | |
# | Line 903 | Line 897 | void SimSetup::initSystemCoords( void ){ | |
897 | void SimSetup::initSystemCoords( void ){ | |
898 | int i; | |
899 | ||
900 | + | char* inName; |
901 | + | |
902 | std::cerr << "Setting atom Coords\n"; | |
903 | ||
904 | (info[0].getConfiguration())->createArrays( info[0].n_atoms ); | |
# | Line 915 | Line 911 | void SimSetup::initSystemCoords( void ){ | |
911 | #ifdef IS_MPI // is_mpi | |
912 | if( worldRank == 0 ){ | |
913 | #endif //is_mpi | |
914 | < | fileInit = new InitializeFromFile( globals->getInitialConfig() ); |
914 | > | inName = globals->getInitialConfig(); |
915 | > | fileInit = new InitializeFromFile( inName ); |
916 | #ifdef IS_MPI | |
917 | }else fileInit = new InitializeFromFile( NULL ); | |
918 | #endif | |
# | Line 1048 | Line 1045 | void SimSetup::sysObjectsCreation( void ){ | |
1045 | int i,k; | |
1046 | ||
1047 | // create the forceField | |
1048 | < | |
1048 | > | |
1049 | createFF(); | |
1050 | ||
1051 | // extract componentList | |
# | Line 1066 | Line 1063 | void SimSetup::sysObjectsCreation( void ){ | |
1063 | #endif //is_mpi | |
1064 | ||
1065 | // create the atom and SRI arrays. Also initialize Molecule Stamp ID's | |
1066 | < | |
1066 | > | |
1067 | makeSysArrays(); | |
1068 | ||
1069 | // make and initialize the molecules (all but atomic coordinates) | |
1070 | < | |
1070 | > | |
1071 | makeMolecules(); | |
1072 | ||
1073 | for(k=0; k<nInfo; k++){ | |
# | Line 1367 | Line 1364 | void SimSetup::makeIntegrator( void ){ | |
1364 | NPTf<RealIntegrator>* myNPTf = NULL; | |
1365 | NPTim<RealIntegrator>* myNPTim = NULL; | |
1366 | NPTfm<RealIntegrator>* myNPTfm = NULL; | |
1370 | – | ZConstraint<NVE<RealIntegrator> >* myNVEZCons = NULL; |
1371 | – | ZConstraint<NVT<RealIntegrator> >* myNVTZCons = NULL; |
1372 | – | ZConstraint<NPTi<RealIntegrator> >* myNPTiZCons = NULL; |
1373 | – | ZConstraint<NPTf<RealIntegrator> >* myNPTfZCons = NULL; |
1374 | – | ZConstraint<NPTim<RealIntegrator> >* myNPTimZCons = NULL; |
1375 | – | ZConstraint<NPTfm<RealIntegrator> >* myNPTfmZCons = NULL; |
1367 | ||
1368 | for(k=0; k<nInfo; k++){ | |
1369 | ||
1370 | switch( ensembleCase ){ | |
1371 | ||
1372 | case NVE_ENS: | |
1373 | < | new NVE<RealIntegrator>( &(info[k]), the_ff ); |
1373 | > | if (globals->haveZconstraints()){ |
1374 | > | setupZConstraint(info[k]); |
1375 | > | new ZConstraint<NVE<RealIntegrator> >( &(info[k]), the_ff ); |
1376 | > | } |
1377 | > | |
1378 | > | else |
1379 | > | new NVE<RealIntegrator>( &(info[k]), the_ff ); |
1380 | break; | |
1381 | ||
1382 | case NVT_ENS: | |
1383 | < | myNVT = new NVT<RealIntegrator>( &(info[k]), the_ff ); |
1383 | > | if (globals->haveZconstraints()){ |
1384 | > | setupZConstraint(info[k]); |
1385 | > | myNVT = new ZConstraint<NVT<RealIntegrator> >( &(info[k]), the_ff ); |
1386 | > | } |
1387 | > | else |
1388 | > | myNVT = new NVT<RealIntegrator>( &(info[k]), the_ff ); |
1389 | > | |
1390 | myNVT->setTargetTemp(globals->getTargetTemp()); | |
1391 | ||
1392 | if (globals->haveTauThermostat()) | |
# | Line 1399 | Line 1402 | void SimSetup::makeIntegrator( void ){ | |
1402 | break; | |
1403 | ||
1404 | case NPTi_ENS: | |
1405 | < | myNPTi = new NPTi<RealIntegrator>( &(info[k]), the_ff ); |
1406 | < | myNPTi->setTargetTemp( globals->getTargetTemp() ); |
1405 | > | if (globals->haveZconstraints()){ |
1406 | > | setupZConstraint(info[k]); |
1407 | > | myNPTi = new ZConstraint<NPTi<RealIntegrator> >( &(info[k]), the_ff ); |
1408 | > | } |
1409 | > | else |
1410 | > | myNPTi = new NPTi<RealIntegrator>( &(info[k]), the_ff ); |
1411 | > | |
1412 | > | myNPTi->setTargetTemp( globals->getTargetTemp() ); |
1413 | ||
1414 | if (globals->haveTargetPressure()) | |
1415 | myNPTi->setTargetPressure(globals->getTargetPressure()); | |
# | Line 1434 | Line 1443 | void SimSetup::makeIntegrator( void ){ | |
1443 | break; | |
1444 | ||
1445 | case NPTf_ENS: | |
1446 | < | myNPTf = new NPTf<RealIntegrator>( &(info[k]), the_ff ); |
1446 | > | if (globals->haveZconstraints()){ |
1447 | > | setupZConstraint(info[k]); |
1448 | > | myNPTf = new ZConstraint<NPTf<RealIntegrator> >( &(info[k]), the_ff ); |
1449 | > | } |
1450 | > | else |
1451 | > | myNPTf = new NPTf<RealIntegrator>( &(info[k]), the_ff ); |
1452 | > | |
1453 | myNPTf->setTargetTemp( globals->getTargetTemp()); | |
1454 | ||
1455 | if (globals->haveTargetPressure()) | |
# | Line 1469 | Line 1484 | void SimSetup::makeIntegrator( void ){ | |
1484 | break; | |
1485 | ||
1486 | case NPTim_ENS: | |
1487 | < | myNPTim = new NPTim<RealIntegrator>( &(info[k]), the_ff ); |
1488 | < | myNPTim->setTargetTemp( globals->getTargetTemp()); |
1487 | > | if (globals->haveZconstraints()){ |
1488 | > | setupZConstraint(info[k]); |
1489 | > | myNPTim = new ZConstraint<NPTim<RealIntegrator> >( &(info[k]), the_ff ); |
1490 | > | } |
1491 | > | else |
1492 | > | myNPTim = new NPTim<RealIntegrator>( &(info[k]), the_ff ); |
1493 | > | |
1494 | > | myNPTim->setTargetTemp( globals->getTargetTemp()); |
1495 | ||
1496 | if (globals->haveTargetPressure()) | |
1497 | myNPTim->setTargetPressure(globals->getTargetPressure()); | |
# | Line 1504 | Line 1525 | void SimSetup::makeIntegrator( void ){ | |
1525 | break; | |
1526 | ||
1527 | case NPTfm_ENS: | |
1528 | < | myNPTfm = new NPTfm<RealIntegrator>( &(info[k]), the_ff ); |
1529 | < | myNPTfm->setTargetTemp( globals->getTargetTemp()); |
1528 | > | if (globals->haveZconstraints()){ |
1529 | > | setupZConstraint(info[k]); |
1530 | > | myNPTfm = new ZConstraint<NPTfm<RealIntegrator> >( &(info[k]), the_ff ); |
1531 | > | } |
1532 | > | else |
1533 | > | myNPTfm = new NPTfm<RealIntegrator>( &(info[k]), the_ff ); |
1534 | > | |
1535 | > | myNPTfm->setTargetTemp( globals->getTargetTemp()); |
1536 | ||
1537 | if (globals->haveTargetPressure()) | |
1538 | myNPTfm->setTargetPressure(globals->getTargetPressure()); | |
# | Line 1529 | Line 1556 | void SimSetup::makeIntegrator( void ){ | |
1556 | ||
1557 | if( globals->haveTauBarostat() ) | |
1558 | myNPTfm->setTauBarostat( globals->getTauBarostat() ); | |
1532 | – | else{ |
1533 | – | sprintf( painCave.errMsg, |
1534 | – | "SimSetup error: If you use an NPT\n" |
1535 | – | " ensemble, you must set tauBarostat.\n"); |
1536 | – | painCave.isFatal = 1; |
1537 | – | simError(); |
1538 | – | } |
1539 | – | break; |
1540 | – | |
1541 | – | case NVEZCONS_ENS: |
1542 | – | |
1543 | – | |
1544 | – | //setup index of z-constraint molecules, z-constraint sampel time |
1545 | – | //and z-constraint force output name. These parameter should be known |
1546 | – | //before constructing the z-constraint integrator |
1547 | – | setupZConstraint(); |
1548 | – | |
1549 | – | myNVEZCons = new ZConstraint<NVE<RealIntegrator> >( &(info[k]), the_ff ); |
1550 | – | |
1551 | – | break; |
1552 | – | |
1553 | – | |
1554 | – | case NVTZCONS_ENS: |
1555 | – | |
1556 | – | setupZConstraint(); |
1557 | – | |
1558 | – | myNVTZCons = new ZConstraint<NVT<RealIntegrator> >( &(info[k]), the_ff ); |
1559 | – | myNVTZCons->setTargetTemp(globals->getTargetTemp()); |
1560 | – | |
1561 | – | if (globals->haveTauThermostat()) |
1562 | – | myNVTZCons->setTauThermostat(globals->getTauThermostat()); |
1563 | – | |
1564 | – | else { |
1565 | – | sprintf( painCave.errMsg, |
1566 | – | "SimSetup error: If you use the NVT\n" |
1567 | – | " ensemble, you must set tauThermostat.\n"); |
1568 | – | painCave.isFatal = 1; |
1569 | – | simError(); |
1570 | – | } |
1571 | – | break; |
1572 | – | |
1573 | – | case NPTiZCONS_ENS: |
1574 | – | |
1575 | – | setupZConstraint(); |
1576 | – | |
1577 | – | myNPTiZCons = new ZConstraint<NPTi<RealIntegrator> >( &(info[k]), the_ff ); |
1578 | – | myNPTiZCons->setTargetTemp( globals->getTargetTemp() ); |
1579 | – | |
1580 | – | if (globals->haveTargetPressure()) |
1581 | – | myNPTiZCons->setTargetPressure(globals->getTargetPressure()); |
1582 | – | else { |
1583 | – | sprintf( painCave.errMsg, |
1584 | – | "SimSetup error: If you use a constant pressure\n" |
1585 | – | " ensemble, you must set targetPressure in the BASS file.\n"); |
1586 | – | painCave.isFatal = 1; |
1587 | – | simError(); |
1588 | – | } |
1589 | – | |
1590 | – | if( globals->haveTauThermostat() ) |
1591 | – | myNPTiZCons->setTauThermostat( globals->getTauThermostat() ); |
1592 | – | else{ |
1593 | – | sprintf( painCave.errMsg, |
1594 | – | "SimSetup error: If you use an NPT\n" |
1595 | – | " ensemble, you must set tauThermostat.\n"); |
1596 | – | painCave.isFatal = 1; |
1597 | – | simError(); |
1598 | – | } |
1599 | – | |
1600 | – | if( globals->haveTauBarostat() ) |
1601 | – | myNPTiZCons->setTauBarostat( globals->getTauBarostat() ); |
1602 | – | else{ |
1603 | – | sprintf( painCave.errMsg, |
1604 | – | "SimSetup error: If you use an NPT\n" |
1605 | – | " ensemble, you must set tauBarostat.\n"); |
1606 | – | painCave.isFatal = 1; |
1607 | – | simError(); |
1608 | – | } |
1609 | – | |
1610 | – | break; |
1611 | – | |
1612 | – | case NPTfZCONS_ENS: |
1613 | – | |
1614 | – | setupZConstraint(); |
1615 | – | |
1616 | – | myNPTfZCons = new ZConstraint<NPTf<RealIntegrator> >( &(info[k]), the_ff ); |
1617 | – | myNPTfZCons->setTargetTemp( globals->getTargetTemp()); |
1618 | – | |
1619 | – | if (globals->haveTargetPressure()) |
1620 | – | myNPTfZCons->setTargetPressure(globals->getTargetPressure()); |
1621 | – | else { |
1622 | – | sprintf( painCave.errMsg, |
1623 | – | "SimSetup error: If you use a constant pressure\n" |
1624 | – | " ensemble, you must set targetPressure in the BASS file.\n"); |
1625 | – | painCave.isFatal = 1; |
1626 | – | simError(); |
1627 | – | } |
1628 | – | |
1629 | – | if( globals->haveTauThermostat() ) |
1630 | – | myNPTfZCons->setTauThermostat( globals->getTauThermostat() ); |
1559 | else{ | |
1560 | sprintf( painCave.errMsg, | |
1561 | "SimSetup error: If you use an NPT\n" | |
1634 | – | " ensemble, you must set tauThermostat.\n"); |
1635 | – | painCave.isFatal = 1; |
1636 | – | simError(); |
1637 | – | } |
1638 | – | |
1639 | – | if( globals->haveTauBarostat() ) |
1640 | – | myNPTfZCons->setTauBarostat( globals->getTauBarostat() ); |
1641 | – | else{ |
1642 | – | sprintf( painCave.errMsg, |
1643 | – | "SimSetup error: If you use an NPT\n" |
1562 | " ensemble, you must set tauBarostat.\n"); | |
1563 | painCave.isFatal = 1; | |
1564 | simError(); | |
1647 | – | } |
1648 | – | |
1649 | – | break; |
1650 | – | |
1651 | – | case NPTimZCONS_ENS: |
1652 | – | |
1653 | – | setupZConstraint(); |
1654 | – | |
1655 | – | myNPTimZCons = new ZConstraint<NPTim<RealIntegrator> >( &(info[k]), the_ff ); |
1656 | – | myNPTimZCons->setTargetTemp( globals->getTargetTemp()); |
1657 | – | |
1658 | – | if (globals->haveTargetPressure()) |
1659 | – | myNPTimZCons->setTargetPressure(globals->getTargetPressure()); |
1660 | – | else { |
1661 | – | sprintf( painCave.errMsg, |
1662 | – | "SimSetup error: If you use a constant pressure\n" |
1663 | – | " ensemble, you must set targetPressure in the BASS file.\n"); |
1664 | – | painCave.isFatal = 1; |
1665 | – | simError(); |
1565 | } | |
1667 | – | |
1668 | – | if( globals->haveTauThermostat() ) |
1669 | – | myNPTimZCons->setTauThermostat( globals->getTauThermostat() ); |
1670 | – | else{ |
1671 | – | sprintf( painCave.errMsg, |
1672 | – | "SimSetup error: If you use an NPT\n" |
1673 | – | " ensemble, you must set tauThermostat.\n"); |
1674 | – | painCave.isFatal = 1; |
1675 | – | simError(); |
1676 | – | } |
1677 | – | |
1678 | – | if( globals->haveTauBarostat() ) |
1679 | – | myNPTimZCons->setTauBarostat( globals->getTauBarostat() ); |
1680 | – | else{ |
1681 | – | sprintf( painCave.errMsg, |
1682 | – | "SimSetup error: If you use an NPT\n" |
1683 | – | " ensemble, you must set tauBarostat.\n"); |
1684 | – | painCave.isFatal = 1; |
1685 | – | simError(); |
1686 | – | } |
1687 | – | |
1566 | break; | |
1567 | ||
1690 | – | case NPTfmZCONS_ENS: |
1691 | – | |
1692 | – | setupZConstraint(); |
1693 | – | |
1694 | – | myNPTfmZCons = new ZConstraint<NPTfm<RealIntegrator> >( &(info[k]), the_ff ); |
1695 | – | myNPTfmZCons->setTargetTemp( globals->getTargetTemp()); |
1696 | – | |
1697 | – | if (globals->haveTargetPressure()) |
1698 | – | myNPTfmZCons->setTargetPressure(globals->getTargetPressure()); |
1699 | – | else { |
1700 | – | sprintf( painCave.errMsg, |
1701 | – | "SimSetup error: If you use a constant pressure\n" |
1702 | – | " ensemble, you must set targetPressure in the BASS file.\n"); |
1703 | – | painCave.isFatal = 1; |
1704 | – | simError(); |
1705 | – | } |
1706 | – | |
1707 | – | if( globals->haveTauThermostat() ) |
1708 | – | myNPTfmZCons->setTauThermostat( globals->getTauThermostat() ); |
1709 | – | else{ |
1710 | – | sprintf( painCave.errMsg, |
1711 | – | "SimSetup error: If you use an NPT\n" |
1712 | – | " ensemble, you must set tauThermostat.\n"); |
1713 | – | painCave.isFatal = 1; |
1714 | – | simError(); |
1715 | – | } |
1716 | – | |
1717 | – | if( globals->haveTauBarostat() ) |
1718 | – | myNPTfmZCons->setTauBarostat( globals->getTauBarostat() ); |
1719 | – | else{ |
1720 | – | sprintf( painCave.errMsg, |
1721 | – | "SimSetup error: If you use an NPT\n" |
1722 | – | " ensemble, you must set tauBarostat.\n"); |
1723 | – | painCave.isFatal = 1; |
1724 | – | simError(); |
1725 | – | } |
1726 | – | break; |
1727 | – | |
1728 | – | |
1729 | – | |
1568 | default: | |
1569 | sprintf( painCave.errMsg, | |
1570 | "SimSetup Error. Unrecognized ensemble in case statement.\n"); | |
# | Line 1763 | Line 1601 | void SimSetup::initFortran( void ){ | |
1601 | ||
1602 | } | |
1603 | ||
1604 | < | void SimSetup::setupZConstraint() |
1604 | > | void SimSetup::setupZConstraint(SimInfo& theInfo) |
1605 | { | |
1606 | < | int k; |
1607 | < | |
1608 | < | for(k=0; k<nInfo; k++){ |
1609 | < | |
1772 | < | if(globals->haveZConsTime()){ |
1606 | > | int nZConstraints; |
1607 | > | ZconStamp** zconStamp; |
1608 | > | |
1609 | > | if(globals->haveZconstraintTime()){ |
1610 | ||
1611 | //add sample time of z-constraint into SimInfo's property list | |
1612 | DoubleData* zconsTimeProp = new DoubleData(); | |
1613 | < | zconsTimeProp->setID("zconstime"); |
1614 | < | zconsTimeProp->setData(globals->getZConsTime()); |
1615 | < | info[k].addProperty(zconsTimeProp); |
1613 | > | zconsTimeProp->setID(ZCONSTIME_ID); |
1614 | > | zconsTimeProp->setData(globals->getZconsTime()); |
1615 | > | theInfo.addProperty(zconsTimeProp); |
1616 | } | |
1617 | else{ | |
1618 | sprintf( painCave.errMsg, | |
# | Line 1784 | Line 1621 | void SimSetup::setupZConstraint() | |
1621 | painCave.isFatal = 1; | |
1622 | simError(); | |
1623 | } | |
1624 | < | |
1625 | < | if(globals->haveIndexOfAllZConsMols()){ |
1626 | < | |
1627 | < | //add index of z-constraint molecules into SimInfo's property list |
1628 | < | vector<int> tempIndex = globals->getIndexOfAllZConsMols(); |
1629 | < | |
1630 | < | //sort the index |
1631 | < | sort(tempIndex.begin(), tempIndex.end()); |
1632 | < | |
1633 | < | IndexData* zconsIndex = new IndexData(); |
1634 | < | zconsIndex->setID("zconsindex"); |
1635 | < | zconsIndex->setIndexData(tempIndex); |
1636 | < | info[k].addProperty(zconsIndex); |
1624 | > | |
1625 | > | // |
1626 | > | nZConstraints = globals->getNzConstraints(); |
1627 | > | zconStamp = globals->getZconStamp(); |
1628 | > | ZConsParaItem tempParaItem; |
1629 | > | |
1630 | > | ZConsParaData* zconsParaData = new ZConsParaData(); |
1631 | > | zconsParaData->setID(ZCONSPARADATA_ID); |
1632 | > | |
1633 | > | for(int i = 0; i < nZConstraints; i++){ |
1634 | > | tempParaItem.havingZPos = zconStamp[i]->haveZpos(); |
1635 | > | tempParaItem.zPos = zconStamp[i]->getZpos(); |
1636 | > | tempParaItem.zconsIndex = zconStamp[i]->getMolIndex(); |
1637 | > | tempParaItem.kRatio = zconStamp[i]->getKratio(); |
1638 | > | |
1639 | > | zconsParaData->addItem(tempParaItem); |
1640 | } | |
1641 | < | else{ |
1642 | < | sprintf( painCave.errMsg, |
1643 | < | "SimSetup error: If you use an ZConstraint\n" |
1644 | < | " , you must set index of z-constraint molecules.\n"); |
1645 | < | painCave.isFatal = 1; |
1646 | < | simError(); |
1647 | < | |
1641 | > | |
1642 | > | //sort the parameters by index of molecules |
1643 | > | zconsParaData->sortByIndex(); |
1644 | > | |
1645 | > | //push data into siminfo, therefore, we can retrieve later |
1646 | > | theInfo.addProperty(zconsParaData); |
1647 | > | |
1648 | > | //push zconsTol into siminfo, if user does not specify |
1649 | > | //value for zconsTol, a default value will be used |
1650 | > | DoubleData* zconsTol = new DoubleData(); |
1651 | > | zconsTol->setID(ZCONSTOL_ID); |
1652 | > | if(globals->haveZconsTol()){ |
1653 | > | zconsTol->setData(globals->getZconsTol()); |
1654 | } | |
1655 | < | |
1655 | > | else{ |
1656 | > | double defaultZConsTol = 1E-6; |
1657 | > | sprintf( painCave.errMsg, |
1658 | > | "ZConstraint Waring: Tolerance for z-constraint methodl is not specified\n" |
1659 | > | " , default value %f is used.\n", defaultZConsTol); |
1660 | > | painCave.isFatal = 0; |
1661 | > | simError(); |
1662 | > | |
1663 | > | zconsTol->setData(defaultZConsTol); |
1664 | > | } |
1665 | > | theInfo.addProperty(zconsTol); |
1666 | > | |
1667 | //Determine the name of ouput file and add it into SimInfo's property list | |
1668 | //Be careful, do not use inFileName, since it is a pointer which | |
1669 | //point to a string at master node, and slave nodes do not contain that string | |
1670 | ||
1671 | < | string zconsOutput(info[k].finalName); |
1671 | > | string zconsOutput(theInfo.finalName); |
1672 | ||
1673 | zconsOutput = zconsOutput.substr(0, zconsOutput.rfind(".")) + ".fz"; | |
1674 | ||
1675 | StringData* zconsFilename = new StringData(); | |
1676 | < | zconsFilename->setID("zconsfilename"); |
1676 | > | zconsFilename->setID(ZCONSFILENAME_ID); |
1677 | zconsFilename->setData(zconsOutput); | |
1678 | ||
1679 | < | info[k].addProperty(zconsFilename); |
1823 | < | } |
1679 | > | theInfo.addProperty(zconsFilename); |
1680 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |