46 #include <Xyce_config.h>
54 #include <N_UTL_Algorithm.h>
58 #include <N_DEV_RegisterDevices.h>
78 #include <N_LAS_System.h>
79 #include <N_LAS_Builder.h>
80 #include <N_LAS_Matrix.h>
82 #include <N_PDS_Manager.h>
83 #include <N_PDS_Comm.h>
85 #include <N_IO_CmdParse.h>
86 #include <N_IO_OutputMgr.h>
89 #include <N_DEV_ExternDevice.h>
120 : commandLine_(command_line),
124 jacobianLoadCalledBefore_(false),
125 entityMapDone_ (false),
127 calledBeforeCSPI (false),
128 allDevsConverged_(false),
130 linearSystemFlag_(true),
131 firstDependent(true),
132 externalStateFlag_(false),
133 parameterChanged_(false),
134 breakPointInstancesInitialized(false),
135 timeParamsProcessed_(0.0),
137 multiThreading_(false),
138 nonTrivialDeviceMaskFlag(false),
139 dotOpOutputFlag(false),
140 numJacStaVectorPtr_(0),
141 numJacSolVectorPtr_(0),
142 numJacStoVectorPtr_(0),
143 diagonalVectorPtr_(0)
149 setUpPassThroughParamsMap_();
183 for (
int i = 0; i < extDevIBPtrVec_.size(); ++i)
185 if (extDevIBPtrVec_[i] != NULL)
187 delete extDevIBPtrVec_[i];
188 extDevIBPtrVec_[i] = 0;
208 std::string netListFile(
"");
209 if (
commandLine_.getArgumentValue(std::string(
"netlist")) !=
"")
211 netListFile =
commandLine_.getArgumentValue(std::string(
"netlist"));
268 dout() <<
"DeviceMgr::registerSensParams called!" <<std::endl;
299 dout() <<
"DeviceMgr::registerLeadCurrentRequests Devices for which lead currents were requested: ";
300 while (currentDeviceNameItr != endDeviceNameItr)
302 dout() << *currentDeviceNameItr <<
" ";
303 currentDeviceNameItr++;
435 int numFastSrcs = sourceNames.size();
438 std::vector<double> srcPeriods(numFastSrcs);
441 for(
int i = 0; i < numFastSrcs; ++i)
443 ExtendedString tmpName(sourceNames[i]);
445 std::map<std::string,SourceInstance*>::iterator iterFS =
indepSourcePtrMap_.find(tmpName);
449 srcPeriods[i] = SIPtr->
period();
453 #ifndef Xyce_PARALLEL_MPI
454 Report::UserError message;
456 <<
"Potential names are: ";
458 message << (*it).first <<
" ";
463 #ifdef Xyce_PARALLEL_MPI
465 std::vector<double> tmpSrcPeriods( srcPeriods );
466 pdsMgrPtr_->getPDSComm()->maxAll( &tmpSrcPeriods[0], &srcPeriods[0], numFastSrcs );
483 int numFastSrcs = sourceNames.size();
485 std::vector<double> srcPeriods;
489 srcPeriods.resize(numFastSrcs, 0.0);
496 for(
int i = 0; i < numFastSrcs; ++i)
500 std::map<std::string,SourceInstance*>::iterator iterFS =
indepSourcePtrMap_.find(tmpName);
505 srcPeriods[i] = SIPtr->
period();
509 #ifndef Xyce_PARALLEL_MPI
510 Report::UserError message;
512 <<
"Potential names are: ";
514 message << (*it).first <<
" ";
527 pdsMgrPtr_->getPDSComm()->sumAll( &myNumFastSrcs, &numFastSrcs, 1 );
528 srcPeriods.resize(numFastSrcs, -1.0);
529 for (
int i=0 ; i<myNumFastSrcs ; ++i) {
535 #ifdef Xyce_PARALLEL_MPI
537 std::vector<double> tmpSrcPeriods( srcPeriods );
538 pdsMgrPtr_->getPDSComm()->maxAll( &tmpSrcPeriods[0], &srcPeriods[0], numFastSrcs );
555 int numFastSrcs = sourceNames.size();
564 for(
int i = 0; i < numFastSrcs; ++i)
568 std::map<std::string,SourceInstance*>::iterator iterFS =
indepSourcePtrMap_.find(tmpName);
576 #ifndef Xyce_PARALLEL_MPI
577 Report::DevelFatal message;
578 message <<
"DeviceMgr::deRegisterFastSources: Unable to find source: " <<
fastSourceNames_[i] <<
"\n"
579 <<
"Potential names are: ";
581 message << (*it).first <<
" ";
590 for (
int i=0 ; i<numFastSrcs ; ++i) {
618 std::vector<SourceInstance*>::iterator iter;
621 for (iter=begin; iter!=end;++iter)
623 if ((*iter)->getFastSourceFlag())
699 bool bsuccess =
true;
730 #ifdef Xyce_DEBUG_VOLTLIM
733 bsuccess = bsuccess && (
externData_.JTestMatrixPtr != 0);
737 bsuccess = bsuccess && (
externData_.FTestMatrixPtr != 0);
739 bsuccess = bsuccess && (
externData_.QTestMatrixPtr != 0);
743 bsuccess = bsuccess && (
externData_.dxVoltlimVectorPtr != 0);
747 bsuccess = bsuccess && (
externData_.Jdx2VectorPtr != 0);
751 bsuccess = bsuccess && (
externData_.Fdx2VectorPtr != 0);
753 bsuccess = bsuccess && (
externData_.Qdx2VectorPtr != 0);
790 int size =
sizeof(*this);
791 dout() <<
"Size of device package after initializeAll = " << size << std::endl;
838 if (model_type_id.defined())
840 EntityTypeIdDeviceMap::const_iterator it =
deviceMap_.find(model_type_id);
850 if (device->isPDEDevice())
860 device = (*it).second;
893 if (model_group.defined())
897 std::string device_letter(model_type_name, 0, 1);
898 if (device_letter !=
"Y")
908 std::string device_name = model_type_name.substr(model_type_name.find_first_of(
"%") + 1, model_type_name.find_last_of(
"%") - 2);
928 if (!model_block.
name.empty()) {
931 if (!model_type.defined())
932 Report::UserError() <<
"There is no device " << model_block.
type <<
" of level " << model_block.
level <<
" to define model " << model_block.
name;
935 if (!model_type.defined())
936 model_type = model_group;
938 if (!model_type.defined())
943 DeviceModel *device_model = device.addModel(model_block, factory_block);
949 if (device_model != 0)
962 return device_model != 0;
999 if (!model_type.defined())
1001 Report::UserFatal message;
1003 message <<
"Unable to determine model type of device for instance name " << instance_block.
getName();
1006 message<<
" with model name" + instance_block.
getModelName();
1022 std::vector<Param>::iterator currentParam = instance_block.
params.begin();
1023 std::vector<Param>::iterator endParam = instance_block.
params.end();
1024 while(currentParam != endParam)
1026 if ((currentParam->uTag() ==
"R"))
1028 if (currentParam->given())
1030 std::vector<std::string> variables, specials;
1034 Param * devPar = &(*(currentParam));
1035 Util::Param * tmpPar = (
dynamic_cast<Util::Param*
> (devPar));
1037 if (tmpPar->getType() == Util::EXPR)
1039 Util::Expression tmpExp = tmpPar->getValue<Util::Expression>();
1040 tmpExp.get_names(XEXP_VARIABLE, variables);
1041 tmpExp.get_names(XEXP_SPECIAL, specials);
1044 if (specials.empty() && variables.empty())
1084 model_group = model_type;
1092 if (!model_type.defined())
1094 Report::UserError message;
1095 message <<
"Unable to determine type of device for instance name " << instance_block.
getName();
1098 message <<
" with model name" + instance_block.
getModelName();
1115 std::vector<Param>::iterator currentParam = instance_block.
params.begin();
1116 std::vector<Param>::iterator endParam = instance_block.
params.end();
1117 while(currentParam != endParam)
1119 if ((currentParam->uTag() ==
"R"))
1121 if (currentParam->given())
1123 std::vector<std::string> variables, specials;
1127 Param * devPar = &(*(currentParam));
1128 Util::Param * tmpPar = (
dynamic_cast<Util::Param*
> (devPar));
1130 if (tmpPar->getType() == Util::EXPR)
1132 Util::Expression tmpExp = tmpPar->getValue<Util::Expression>();
1133 tmpExp.get_names(XEXP_VARIABLE, variables);
1134 tmpExp.get_names(XEXP_SPECIAL, specials);
1137 if (specials.empty() && variables.empty())
1159 std::string outputName;
1169 dout() <<
"DeviceMgr::addDeviceInstance Enabling lead current load for device \""
1173 <<
"\"" << std::endl;
1178 dout() <<
"DeviceMgr::addDeviceInstance Cannot enable lead current load for device \""
1197 if (device.isPDEDevice())
1219 if (model_type == ExternDevice::Traits::modelType())
1221 extDevInstancePtrVec_.push_back(dynamic_cast<ExternDevice::Instance*>(instance));
1222 extDevIBPtrVec_.push_back(
new InstanceBlock(instance_block));
1229 ExtendedString tmpName(instance_block.
getName());
1238 ExtendedString tmpName(instance_block.
getName());
1249 if (model_type == TWO_D_PDE)
1263 tmpDevName.toUpper();
1265 if (instance->
getName() == tmpDevName)
1283 Report::DevelFatal().in(
"DeviceMgr::deleteDeviceInstance") <<
"Not ready with the new boilerplate-free device package";
1285 bool bsuccess =
true;
1358 char fn_fv[256];
for (
int ich = 0; ich < 256; ++ich) fn_fv[ich] = 0;
1359 sprintf(fn_fv,
"fvector.%03d.txt", outIter);
1367 char fn_jdxp[256];
for (
int ich = 0; ich < 256; ++ich) fn_jdxp[ich] = 0;
1368 sprintf(fn_jdxp,
"Jdxp.%03d.txt", outIter);
1371 #ifdef Xyce_DEBUG_VOLTLIM
1373 char fn_dxvl[256];
for (
int ich = 0; ich < 256; ++ich) fn_dxvl[ich] = 0;
1374 sprintf(fn_dxvl,
"dxVL.%03d.txt", outIter);
1375 (
externData_.dxVoltlimVectorPtr)->writeToFile(fn_dxvl);
1378 char fn_jdx2[256];
for (
int ich = 0; ich < 256; ++ich) fn_jdx2[ich] = 0;
1379 sprintf(fn_jdx2,
"Jdx2.%03d.txt", outIter);
1380 (
externData_.Jdx2VectorPtr)->writeToFile(fn_jdx2);
1402 int outputStepNumber = 0;
1406 outputStepNumber = 0;
1417 #ifdef Xyce_DEBUG_VOLTLIM
1419 char fn_dxvl[256];
for (
int ich = 0; ich < 256; ++ich) fn_dxvl[ich] = 0;
1420 sprintf(fn_dxvl,
"dxVL.%03d.%03d.txt", outputStepNumber, newtonIter);
1421 (
externData_.dxVoltlimVectorPtr)->writeToFile(fn_dxvl);
1424 char fn_fdx2[256];
for (
int ich = 0; ich < 256; ++ich) fn_fdx2[ich] = 0;
1425 sprintf(fn_fdx2,
"Fdx2.%03d.%03d.txt", outputStepNumber, newtonIter);
1426 (
externData_.Fdx2VectorPtr)->writeToFile(fn_fdx2);
1429 char fn_qdx2[256];
for (
int ich = 0; ich < 256; ++ich) fn_qdx2[ich] = 0;
1430 sprintf(fn_qdx2,
"Qdx2.%03d.%03d.txt", outputStepNumber, newtonIter);
1431 (
externData_.Qdx2VectorPtr)->writeToFile(fn_qdx2);
1450 bool bsuccess =
true;
1452 if (solVectorPtr != 0)
1457 InstanceVector::iterator iter;
1458 InstanceVector::iterator begin;
1459 InstanceVector::iterator end;
1463 for (iter=begin; iter!=end;++iter)
1465 bool tmpBool = (*iter)->setInitialGuess ();
1466 bsuccess = bsuccess && tmpBool;
1482 void DeviceMgr::setUpPassThroughParamsMap_()
1484 passThroughParamsMap_[
"MOSFET:GAINSCALE" ] = 1;
1485 passThroughParamsMap_[
"MOSFET:GAIN" ] = 1;
1486 passThroughParamsMap_[
"MOSFET:NLTERMSCALE" ] = 1;
1487 passThroughParamsMap_[
"MOSFET:NLTERM" ] = 1;
1488 passThroughParamsMap_[
"MOSFET_ALL:GAINSCALE" ] = 1;
1489 passThroughParamsMap_[
"MOSFET_ALL:NLTERMSCALE" ] = 1;
1490 passThroughParamsMap_[
"MOSFET1:GAINSCALE" ] = 1;
1491 passThroughParamsMap_[
"MOSFET1:NLTERMSCALE" ] = 1;
1492 passThroughParamsMap_[
"MOSFET:W" ] = 1;
1493 passThroughParamsMap_[
"MOSFET:L" ] = 1;
1494 passThroughParamsMap_[
"MOSFET:SIZESCALE" ] = 1;
1495 passThroughParamsMap_[
"MOSFET:TOX" ] = 1;
1496 passThroughParamsMap_[
"TEMP" ] = 1;
1497 passThroughParamsMap_[
"BJT:NF" ] = 1;
1498 passThroughParamsMap_[
"BJT:NR" ] = 1;
1499 passThroughParamsMap_[
"BJT:EXPORD" ] = 1;
1525 bool bsuccess =
true, success =
true;
1526 InstanceVector::const_iterator iter;
1527 InstanceVector::const_iterator begin;
1528 InstanceVector::const_iterator end;
1530 ModelVector::const_iterator iterM;
1531 ModelVector::const_iterator beginM;
1532 ModelVector::const_iterator endM;
1534 ExtendedString tmpName(name);
1539 std::string netListFile(
"");
1540 if (
commandLine_.getArgumentValue(std::string(
"netlist")) !=
"")
1542 netListFile =
commandLine_.getArgumentValue(std::string(
"netlist"));
1545 dout() << netListFile <<
"\t\t";
1546 dout() <<
"DeviceMgr::setParam. ";
1548 dout() <<
" " << val;
1549 dout() << std::endl;
1554 if (tmpName ==
"MOSFET:GAINSCALE" ||
1555 tmpName ==
"MOSFET:GAIN")
1560 else if (tmpName ==
"MOSFET:NLTERMSCALE" ||
1561 tmpName ==
"MOSFET:NLTERM")
1567 else if (tmpName ==
"MOSFET_ALL:GAINSCALE")
1576 else if (tmpName ==
"MOSFET_ALL:NLTERMSCALE")
1585 else if (tmpName ==
"MOSFET_13:GAINSCALE")
1592 else if (tmpName ==
"MOSFET_13:NLTERMSCALE")
1599 else if (tmpName ==
"MOSFET1:GAINSCALE")
1604 else if (tmpName ==
"MOSFET1:NLTERMSCALE")
1609 else if (tmpName ==
"MOSFET3:GAINSCALE")
1614 else if (tmpName ==
"MOSFET3:NLTERMSCALE")
1620 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_0")
1625 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_1")
1630 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_2")
1635 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_3")
1640 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_4")
1645 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_5")
1650 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_6")
1655 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_7")
1660 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_8")
1665 else if (tmpName ==
"MOSFET:GAINSCALE_BLOCK_9")
1670 else if (tmpName ==
"MOSFET:L")
1679 for (iter=begin; iter!=end;++iter)
1681 std::string nameL(
"l");
1682 success = (*iter)->setParam (nameL, newL);
1683 success = success && (*iter)->processParams ();
1687 else if (tmpName ==
"MOSFET:W")
1695 for (iter=begin; iter!=end;++iter)
1697 std::string nameW(
"w");
1698 success = (*iter)->setParam (nameW, newW);
1699 success = success && (*iter)->processParams ();
1703 else if (tmpName ==
"MOSFET:SIZESCALE")
1717 for (iter=begin; iter!=end;++iter)
1719 std::string nameL(
"l");
1720 std::string nameW(
"w");
1724 success = success && (*iter)->processParams ();
1728 else if (tmpName ==
"MOSFET:TOX")
1742 for (iterM=beginM; iterM!=endM;++iterM)
1744 std::string nameTOX(
"tox");
1748 success = success && (*iterM)->processParams ();
1749 success = success && (*iterM)->processInstanceParams ();
1753 else if (tmpName ==
"VSRCSCALE")
1756 for (
int i=0;i<vsrcSize;++i)
1760 success = success && s1 && s2;
1763 else if (tmpName ==
"TEMP")
1769 else if (tmpName ==
"PDEALPHA")
1775 Report::DevelFatal message;
1776 message <<
"DeviceMgr::setParam: tried to set pdeAlpha without first calling enablePDEContinuation";
1781 InstanceVector::iterator iter;
1782 InstanceVector::iterator begin;
1783 InstanceVector::iterator end;
1787 for (iter=begin; iter!=end;++iter)
1789 (*iter)->setPDEContinuationAlpha (val);
1792 else if (tmpName ==
"PDEBETA")
1796 InstanceVector::iterator iter;
1797 InstanceVector::iterator begin;
1798 InstanceVector::iterator end;
1802 for (iter=begin; iter!=end;++iter)
1804 (*iter)->setPDEContinuationBeta (val);
1807 else if (tmpName ==
"PDECHARGEALPHA")
1812 else if (tmpName ==
"BJT:BF")
1815 std::string newBF(
"bf");
1820 for (iterM=beginM; iterM!=endM;++iterM)
1822 success = (*iterM)->scaleParam(newBF, scale, 0.0);
1823 success = success && (*iterM)->processParams();
1824 success = success && (*iterM)->processInstanceParams();
1827 else if (tmpName ==
"BJT:NF")
1830 std::string newNF(
"nf");
1835 for (iterM=beginM; iterM!=endM;++iterM)
1837 success = (*iterM)->scaleParam(newNF, scale, 10.0);
1838 success = success && (*iterM)->processParams();
1839 success = success && (*iterM)->processInstanceParams();
1842 else if (tmpName ==
"BJT:NR")
1845 std::string newNR(
"nr");
1850 for (iterM=beginM; iterM!=endM;++iterM)
1852 success = (*iterM)->scaleParam(newNR, scale, 10.0);
1853 success = success && (*iterM)->processParams();
1854 success = success && (*iterM)->processInstanceParams();
1857 else if (tmpName ==
"BJT:EXPORD")
1862 else if (tmpName ==
"GSTEPPING")
1867 else if (tmpName ==
"DIODE:N")
1870 std::string newN(
"n");
1875 for (iterM=beginM; iterM!=endM;++iterM)
1877 success = (*iterM)->scaleParam(newN, scale, 10.0);
1878 success = success && (*iterM)->processParams();
1879 success = success && (*iterM)->processInstanceParams();
1882 else if (tmpName ==
"GMIN")
1891 std::vector<DeviceEntity*>::iterator iter;
1894 for (iter=begin; iter!=end;++iter)
1898 (*iter)->processParams();
1899 (*iter)->processInstanceParams();
1909 #ifdef Xyce_PARALLEL_MPI
1910 double foundParam = 0.0;
1911 double finalParam = 0.0;
1913 bool entityFound = (dePtr!=0)?
true:
false;
1918 std::string paramName = Util::paramNameFromFullParamName(name);
1919 if (paramName ==
"")
1925 found = dePtr->
setParam (paramName, val);
1935 #ifdef Xyce_PARALLEL_MPI
1936 foundParam = found?1.0:0.0;
1938 entityFound = found;
1941 #ifdef Xyce_PARALLEL_MPI
1942 N_PDS_Comm * pdsCommPtr =
pdsMgrPtr_->getPDSComm();
1943 pdsCommPtr->barrier();
1944 pdsCommPtr->sumAll(&foundParam, &finalParam, 1);
1945 entityFound = (finalParam != 0.0)?
true:
false;
1950 Report::UserFatal0 message;
1951 message <<
"Unable to find parameter " << name;
1959 if (passThroughParamsMap_.find(tmpName) != passThroughParamsMap_.end())
1962 std::vector<ExternDevice::Instance*>::iterator iter;
1963 std::vector<ExternDevice::Instance*>::iterator begin;
1964 std::vector<ExternDevice::Instance*>::iterator end;
1965 begin = extDevInstancePtrVec_.begin ();
1966 end = extDevInstancePtrVec_.end ();
1968 for (iter=begin; iter!=end;++iter)
1970 bool bs1 = (*iter)->setInternalParam (name, val);
1996 ExtendedString tmpName(name);
1998 bool entityFound =
false;
2001 if (tmpName ==
"MOSFET:GAINSCALE")
2006 else if (tmpName ==
"MOSFET:NLTERMSCALE")
2011 else if (tmpName ==
"MOSFET:L")
2016 else if (tmpName ==
"MOSFET:W")
2021 else if (tmpName ==
"TEMP")
2035 entityFound = dePtr != 0;
2039 std::string paramName = Util::paramNameFromFullParamName(name);
2040 entityFound = dePtr->
getParam (paramName, val);
2041 if (paramName ==
"")
2048 #ifdef Xyce_PARALLEL_MPI
2049 double foundParam = entityFound ? 1 : 0;
2050 double finalParam = 0.0;
2052 N_PDS_Comm * pdsCommPtr =
pdsMgrPtr_->getPDSComm();
2053 pdsCommPtr->barrier();
2054 pdsCommPtr->sumAll(&foundParam, &finalParam, 1);
2055 if (finalParam != 0.0)
2058 pdsCommPtr->sumAll(&val, &globalVal, 1);
2059 val = globalVal/finalParam;
2069 ExtendedString tmpName(name);
2072 bool entityFound =
false;
2075 if (tmpName ==
"MOSFET:GAINSCALE")
2079 else if (tmpName ==
"MOSFET:NLTERMSCALE")
2083 else if (tmpName ==
"MOSFET:L")
2087 else if (tmpName ==
"MOSFET:W")
2091 else if (tmpName ==
"TEMP")
2102 ExtendedString tmpName(name);
2106 if (tmpName ==
"MOSFET:GAINSCALE")
2110 else if (tmpName ==
"MOSFET:NLTERMSCALE")
2114 else if (tmpName ==
"MOSFET:L")
2118 else if (tmpName ==
"MOSFET:W")
2122 else if (tmpName ==
"TEMP")
2147 bool bsuccess =
false;
2153 Report::UserFatal0 message;
2154 message <<
"Unable to find parameter " << name;
2172 std::string & srcName,
int & li_Pos,
int & li_Neg,
int & li_Bra)
2174 ExtendedString tmpName(srcName);
2176 std::map<std::string, Vsrc::Instance *>::iterator iterVsrc =
vsrcInstancePtrMap_.find(tmpName);
2180 vsrcPtr->
getLIDs(li_Pos,li_Neg,li_Bra);
2184 #ifndef Xyce_PARALLEL_MPI
2185 Report::DevelFatal message;
2186 message <<
"DeviceMgr::getVoltageDropRow: Unable to find source: " << srcName;
2202 N_LAS_Vector * nextSolVectorPtr,
2203 N_LAS_Vector * currSolVectorPtr,
2204 N_LAS_Vector * lastSolVectorPtr,
2205 N_LAS_Vector * nextStaVectorPtr,
2206 N_LAS_Vector * currStaVectorPtr,
2207 N_LAS_Vector * lastStaVectorPtr,
2208 N_LAS_Vector * nextStoVectorPtr,
2209 N_LAS_Vector * currStoVectorPtr,
2210 N_LAS_Vector * lastStoVectorPtr
2213 bool bsuccess =
true;
2214 bool tmpBool =
true;
2217 bsuccess = bsuccess && tmpBool;
2230 #ifdef Xyce_PARALLEL_MPI
2253 std::vector<Device*>::iterator iter;
2256 for (iter=begin; iter!=end;++iter)
2260 bsuccess = bsuccess && tmpBool;
2266 for(
int i=0; i< numDevices; ++i)
2274 updateExternalDevices_();
2277 #ifdef Xyce_PARALLEL_MPI
2282 Report::safeBarrier(
pdsMgrPtr_->getPDSComm()->comm());
2330 (N_LAS_Vector * tmpSolVectorPtr,
2331 N_LAS_Vector * tmpStateVectorPtr,
2332 N_LAS_Vector * tmpStateDerivVectorPtr,
2333 N_LAS_Vector * tmpStoreVectorPtr,
2334 N_LAS_Matrix * tmpdQdxMatrixPtr,
2335 N_LAS_Matrix * tmpdFdxMatrixPtr)
2337 bool bsuccess =
true;
2338 bool tmpBool =
true;
2341 (externData_.nextSolVectorPtr) = tmpSolVectorPtr;
2342 bool resetRawMatrixPointers =
true;
2344 (externData_.dQdxMatrixPtr == tmpdQdxMatrixPtr) &&
2345 (externData_.dFdxMatrixPtr == tmpdFdxMatrixPtr)
2348 resetRawMatrixPointers =
false;
2350 if (resetRawMatrixPointers)
2352 externData_.dQdxMatrixPtr = tmpdQdxMatrixPtr;
2353 externData_.dFdxMatrixPtr = tmpdFdxMatrixPtr;
2356 externData_.nextStaVectorPtr = tmpStateVectorPtr;
2357 externData_.nextStaDerivVectorPtr = tmpStateDerivVectorPtr;
2358 externData_.nextStoVectorPtr = tmpStoreVectorPtr;
2361 externData_.nextSolVectorRawPtr = &((*externData_.nextSolVectorPtr)[0]);
2362 externData_.nextStaVectorRawPtr = &((*externData_.nextStaVectorPtr)[0]);
2363 externData_.nextStaDerivVectorRawPtr = &((*externData_.nextStaDerivVectorPtr)[0]);
2364 externData_.nextStoVectorRawPtr = &((*externData_.nextStoVectorPtr)[0]);
2368 if (resetRawMatrixPointers || solState_.blockAnalysisFlag)
2370 this->setupRawMatrixPointers_();
2374 InstanceVector::iterator iter;
2375 InstanceVector::iterator begin;
2376 InstanceVector::iterator end;
2387 begin = nonPdeInstancePtrVec_.begin();
2388 end = nonPdeInstancePtrVec_.end();
2389 for (iter=begin; iter!=end;++iter)
2391 (*iter)->loadTrivialDAE_FMatrixStamp ();
2394 begin = pdeInstancePtrVec_.begin();
2395 end = pdeInstancePtrVec_.end();
2396 for (iter=begin; iter!=end;++iter)
2398 tmpBool = (*iter)->loadDAEdQdx();bsuccess = bsuccess && tmpBool;
2399 tmpBool = (*iter)->loadDAEdFdx();bsuccess = bsuccess && tmpBool;
2405 int numDevices = devicePtrVec_.size();
2406 for(
int i=0; i< numDevices; ++i)
2408 bsuccess=devicePtrVec_.at(i)->loadDAEMatrices (*(externData_.dFdxMatrixPtr) , *(externData_.dQdxMatrixPtr));
2413 if (devOptions_.testJacobianFlag &&
2414 (solState_.timeStepNumber >= devOptions_.testJacStartStep &&
2415 solState_.timeStepNumber <= devOptions_.testJacStopStep)
2419 devOptions_.debugLevel -= 2;
2422 if ((devOptions_.testJacDeviceNameGiven))
2424 begin = testJacDevicePtrVec_.begin();
2425 end = testJacDevicePtrVec_.end();
2429 begin = instancePtrVec_.begin();
2430 end = instancePtrVec_.end();
2433 for (iter=begin; iter!=end;++iter)
2435 (*iter)->testDAEMatrices (nameVec_);
2439 devOptions_.debugLevel += 2;
2447 if (icLoads_ != NULL && solState_.dcopFlag)
2449 double diag = 10000.0;
2450 int size = icLoads_->size();
2451 for (
int i = 0; i < size; ++i)
2452 externData_.JMatrixPtr->sumIntoRow((*icLoads_)[i].first, 1, &diag,
2453 &((*icLoads_)[i].first));
2459 externData_.dQdxMatrixPtr->fillComplete();
2460 externData_.dFdxMatrixPtr->fillComplete();
2462 Report::safeBarrier(pdsMgrPtr_->getPDSComm()->comm());
2464 if (DEBUG_DEVICE && devOptions_.debugLevel > 1 && solState_.debugTimeFlag)
2466 int newtonIter = solState_.newtonIter;
2467 dout() << section_divider << std::endl;
2468 dout() <<
"Q-matrix: nonlinear iteration = " << newtonIter <<
"\n";
2469 externData_.dQdxMatrixPtr->printPetraObject(dout());
2470 dout() << std::endl;
2471 dout() << section_divider << std::endl;
2472 dout() <<
"F-matrix: nonlinear iteration = " << newtonIter <<
"\n";
2473 externData_.dFdxMatrixPtr->printPetraObject(dout());
2474 dout() << std::endl;
2475 dout() << section_divider << std::endl;
2521 (N_LAS_Vector * tmpSolVectorPtr,
2522 N_LAS_Vector * tmpCurrSolVectorPtr,
2523 N_LAS_Vector * tmpLastSolVectorPtr,
2524 N_LAS_Vector * tmpStaVectorPtr,
2525 N_LAS_Vector * tmpCurrStaVectorPtr,
2526 N_LAS_Vector * tmpLastStaVectorPtr,
2527 N_LAS_Vector * tmpStaDerivVectorPtr,
2528 N_LAS_Vector * tmpStoVectorPtr,
2529 N_LAS_Vector * tmpCurrStoVectorPtr,
2530 N_LAS_Vector * tmpLastStoVectorPtr,
2531 N_LAS_Vector * tmpStoLeadCurrQCompVectorPtr,
2532 N_LAS_Vector * tmpQVectorPtr,
2533 N_LAS_Vector * tmpFVectorPtr,
2534 N_LAS_Vector * tmpdFdxdVpVectorPtr,
2535 N_LAS_Vector * tmpdQdxdVpVectorPtr)
2537 bool bsuccess =
true;
2538 bool tmpBool =
true;
2541 externData_.nextSolVectorPtr = tmpSolVectorPtr;
2542 externData_.currSolVectorPtr = tmpCurrSolVectorPtr;
2543 externData_.lastSolVectorPtr = tmpLastSolVectorPtr;
2544 externData_.daeQVectorPtr = tmpQVectorPtr;
2545 externData_.daeFVectorPtr = tmpFVectorPtr;
2546 externData_.dFdxdVpVectorPtr = tmpdFdxdVpVectorPtr;
2547 externData_.dQdxdVpVectorPtr = tmpdQdxdVpVectorPtr;
2548 externData_.nextStaVectorPtr = tmpStaVectorPtr;
2549 externData_.currStaVectorPtr = tmpCurrStaVectorPtr;
2550 externData_.lastStaVectorPtr = tmpLastStaVectorPtr;
2551 externData_.storeLeadCurrQCompPtr = tmpStoLeadCurrQCompVectorPtr;
2552 externData_.nextStaDerivVectorPtr = tmpStaDerivVectorPtr;
2553 externData_.nextStoVectorPtr = tmpStoVectorPtr;
2554 externData_.currStoVectorPtr = tmpCurrStoVectorPtr;
2555 externData_.lastStoVectorPtr = tmpLastStoVectorPtr;
2558 #ifdef Xyce_PARALLEL_MPI
2559 externData_.nextSolVectorPtr->importOverlap();
2560 externData_.nextStaDerivVectorPtr->importOverlap();
2564 setupRawVectorPointers_ ();
2567 std::vector<Device*>::iterator iter;
2568 std::vector<Device*>::iterator begin;
2569 std::vector<Device*>::iterator end;
2574 begin = pdeDevicePtrVec_.begin ();
2575 end = pdeDevicePtrVec_.end ();
2579 begin = devicePtrVec_.begin ();
2580 end = devicePtrVec_.end ();
2585 #ifndef Xyce_EXCLUDE_SECONDARY_STATE
2586 for (iter=begin; iter!=end;++iter)
2588 tmpBool = (*iter)->updateSecondaryState (externData_.nextStaDerivVectorRawPtr, externData_.nextStoVectorRawPtr);
2589 bsuccess = bsuccess && tmpBool;
2591 #endif // Xyce_EXCLUDE_SECONDARY_STATE
2593 #ifdef Xyce_PARALLEL_MPI
2594 externData_.nextStaVectorPtr->importOverlap();
2595 externData_.nextStoVectorPtr->importOverlap();
2600 int numDevices = pdeDevicePtrVec_.size();
2601 for(
int i=0; i< numDevices; ++i)
2603 bsuccess=pdeDevicePtrVec_.at(i)->loadDAEVectors(externData_.nextSolVectorRawPtr,
2604 externData_.daeFVectorRawPtr,
2605 externData_.daeQVectorRawPtr,
2606 externData_.nextStoVectorRawPtr,
2607 externData_.storeLeadCurrQCompRawPtr);
2612 int numDevices = devicePtrVec_.size();
2613 for(
int i=0; i< numDevices; ++i)
2615 bsuccess=devicePtrVec_.at(i)->loadDAEVectors(externData_.nextSolVectorRawPtr,
2616 externData_.daeFVectorRawPtr,
2617 externData_.daeQVectorRawPtr,
2618 externData_.nextStoVectorRawPtr,
2619 externData_.storeLeadCurrQCompRawPtr);
2624 if (DEBUG_DEVICE && devOptions_.debugLevel > 1 && solState_.debugTimeFlag)
2626 int newtonIter = solState_.newtonIter;
2627 dout() <<
"Q-vector: nonlinear iteration = " << newtonIter <<
"\n";
2628 externData_.daeQVectorPtr->printPetraObject(std::cout);
2629 dout() << std::endl;
2630 dout() <<
"F-vector: nonlinear iteration = " << newtonIter <<
"\n";
2631 externData_.daeFVectorPtr->printPetraObject(std::cout);
2632 dout() << std::endl;
2634 if (devOptions_.voltageLimiterFlag)
2636 dout() <<
"\n\n dFdxdVp vector: nonlinear iteration = " << newtonIter <<
"\n";
2637 externData_.dFdxdVpVectorPtr->printPetraObject(std::cout);
2638 dout() << std::endl;
2639 dout() <<
"\n\n dQdxdVp vector: nonlinear iteration = " << newtonIter <<
"\n";
2640 externData_.dQdxdVpVectorPtr->printPetraObject(std::cout);
2641 dout() << std::endl;
2648 externData_.daeQVectorPtr->fillComplete();
2649 externData_.daeFVectorPtr->fillComplete();
2650 externData_.dFdxdVpVectorPtr->fillComplete();
2651 externData_.dQdxdVpVectorPtr->fillComplete();
2653 Report::safeBarrier(pdsMgrPtr_->getPDSComm()->comm());
2656 int size =
sizeof(*this);
2657 dout() <<
"Size of device package after vector load = " << size << std::endl;
2679 InstanceVector::iterator iter;
2680 InstanceVector::iterator begin;
2681 InstanceVector::iterator end;
2688 for (iter=begin; iter!=end;++iter)
2712 if (par.getType() == Util::EXPR)
2714 std::vector<std::string> variables, specials;
2715 std::vector<std::string>::iterator vs_i;
2722 e->get_names(XEXP_VARIABLE, variables);
2723 e->get_names(XEXP_SPECIAL, specials);
2724 if (!specials.empty())
2728 if (!variables.empty())
2730 for (vs_i=variables.begin() ; vs_i!=variables.end() ; ++vs_i)
2733 e->evaluateFunction (val);
2758 retVal = parLocItr->second;
2762 Report::UserFatal0 message;
2763 message <<
"Could not find global parameter \"" << parName <<
"\"";
2772 return &(*it).second;
2793 bool DeviceMgr::loadPerturbationVector_()
2797 for (i = 0; i < isize; ++i)
2817 bool bsuccess =
true;
2819 InstanceVector::iterator iter;
2822 for (iter=begin; iter!=end;++iter)
2824 (*iter)->updateIntermediateVars ();
2841 bool bsuccess =
true;
2843 InstanceVector::iterator iter;
2846 for (iter=begin; iter!=end;++iter)
2848 (*iter)->updatePrimaryState ();
2865 bool bsuccess =
true;
2867 InstanceVector::iterator iter;
2870 for (iter=begin; iter!=end;++iter)
2872 (*iter)->updateSecondaryState ();
2889 bool bsuccess =
true;
2890 bool tmpBool =
true;
2901 std::vector<std::string> variables;
2902 std::vector<std::string>::iterator vs_i;
2903 std::vector<std::string>::iterator vs_end;
2908 std::vector<Util::Expression>::iterator g_i = ge.begin();
2909 std::vector<Util::Expression>::iterator g_end = ge.end();
2910 for (; g_i != g_end; ++g_i)
2913 g_i->get_names(XEXP_VARIABLE, variables);
2916 if (!variables.empty())
2918 vs_i=variables.begin();
2919 vs_end=variables.end();
2920 for (; vs_i!=vs_end; ++vs_i)
2922 if (g_i->set_var(*vs_i,gp[*vs_i]))
2929 g_i->evaluateFunction (val);
2942 ModelVector::iterator iterM;
2945 for (iterM=beginM; iterM!=endM;++iterM)
2947 if (!(*iterM)->getDependentParams().empty())
2950 tmpBool = (*iterM)->updateGlobalParameters(gp);
2951 bsuccess = bsuccess && tmpBool;
2952 tmpBool = (*iterM)->updateDependentParameters (*solVectorPtr);
2953 bsuccess = bsuccess && tmpBool;
2954 (*iterM)->processParams();
2955 (*iterM)->processInstanceParams();
2960 InstanceVector::iterator iter;
2963 for (iter=begin; iter!=end;++iter)
2965 if (!(*iter)->getDependentParams().empty())
2968 tmpBool = (*iter)->updateGlobalParameters (gp);
2969 bsuccess = bsuccess && tmpBool;
2970 tmpBool = (*iter)->updateDependentParameters (*solVectorPtr);
2971 bsuccess = bsuccess && tmpBool;
2972 (*iter)->processParams();
2979 std::vector<DeviceEntity*>::iterator iter;
2982 for (iter=begin; iter!=end;++iter)
2987 tmpBool = (*iter)->updateGlobalParameters (gp);
2988 changed = changed || tmpBool;
2989 bsuccess = bsuccess && tmpBool;
2991 tmpBool = (*iter)->updateDependentParameters (*solVectorPtr);
2992 changed = changed || tmpBool;
2993 bsuccess = bsuccess && tmpBool;
2996 (*iter)->processParams();
2997 (*iter)->processInstanceParams();
3017 N_LAS_Vector * bVecImagPtr)
3019 bool bsuccess =
true;
3027 #ifdef Xyce_PARALLEL_MPI
3034 std::vector<SourceInstance*>::iterator vIter;
3037 for (vIter=vBegin; vIter!=vEnd;++vIter)
3054 std::vector<int>& bMatPosEntriesVec)
3056 bool bsuccess =
true;
3058 int lpos, lneg, lbra;
3059 std::vector<SourceInstance *>::iterator vIter;
3063 for (vIter=vBegin; vIter!=vEnd;++vIter)
3068 vsrc->
getLIDs(lpos, lneg, lbra);
3069 bMatEntriesVec.push_back(lbra);
3070 bMatPosEntriesVec.push_back(lpos);
3088 bool bsuccess =
true;
3092 std::vector<SourceInstance*>::iterator vIter;
3095 for (vIter=vBegin; vIter!=vEnd;++vIter)
3097 (*vIter)->updateSource();
3112 N_LAS_Vector * tmpSolVectorPtr,
3113 N_LAS_Vector * tmpCurrSolVectorPtr,
3114 N_LAS_Vector * tmpLastSolVectorPtr,
3115 N_LAS_Vector * tmpStaVectorPtr,
3116 N_LAS_Vector * tmpCurrStaVectorPtr,
3117 N_LAS_Vector * tmpLastStaVectorPtr,
3118 N_LAS_Vector * tmpStaDerivVectorPtr,
3119 N_LAS_Vector * tmpStoVectorPtr,
3120 N_LAS_Vector * tmpCurrStoVectorPtr,
3121 N_LAS_Vector * tmpLastStoVectorPtr,
3122 N_LAS_Vector * tmpQVectorPtr,
3123 N_LAS_Vector * tmpFVectorPtr,
3124 N_LAS_Vector * tmpdFdxdVpVectorPtr,
3125 N_LAS_Vector * tmpdQdxdVpVectorPtr)
3127 bool bsuccess =
true;
3146 #ifdef Xyce_PARALLEL_MPI
3155 InstanceVector::iterator iter;
3158 for (iter=begin; iter!=end;++iter)
3216 bool bsuccess =
true;
3231 bool bsuccess =
true;
3232 bool tmpBool =
true;
3234 InstanceVector::iterator iter;
3237 for (iter=begin; iter!=end;++iter)
3239 tmpBool = (*iter)->outputPlotFiles ();
3240 bsuccess = bsuccess && tmpBool;
3267 bool bsuccess =
true;
3268 bool tmpBool =
true;
3272 bsuccess = bsuccess && tmpBool;
3291 std::map<std::string, Device *> device_map;
3292 for (EntityTypeIdDeviceMap::const_iterator it =
deviceMap_.begin(); it !=
deviceMap_.end(); ++it)
3293 device_map[(*it).second->getName()] = (*it).second;
3295 lout() << section_divider <<
"\n"
3296 <<
"Operating point information:";
3298 for (std::map<std::string, Device *>::const_iterator it = device_map.begin(); it != device_map.end(); ++it)
3301 lout() << section_divider << std::endl;
3314 #ifdef Xyce_PARALLEL_MPI
3316 double pdeSys_glob=0.0;
3319 N_PDS_Comm *pdsCommPtr =
pdsMgrPtr_->getPDSComm();
3320 pdsCommPtr->barrier();
3321 pdsCommPtr->sumAll(&pdeSys_par, &pdeSys_glob, 1);
3326 dout() <<
"PDESystemFlag = TRUE"<<std::endl;
3328 dout() <<
"PDESystemFlag = FALSE"<<std::endl;
3345 InstanceVector::iterator iterI;
3346 ModelVector::iterator iterM;
3347 bool bsuccess =
true;
3348 bool tmpBool =
true;
3351 bsuccess = bsuccess && tmpBool;
3359 if (!(*iterM)->getDependentParams().empty())
3361 tmpBool = (*iterM)->getParamBreakpoints(breakPointTimes);
3362 bsuccess = bsuccess && tmpBool;
3368 if (!(*iterI)->getDependentParams().empty())
3370 tmpBool = (*iterI)->getParamBreakpoints(breakPointTimes);
3371 bsuccess = bsuccess && tmpBool;
3376 std::vector<Util::Expression>::iterator globalExp_i =
3378 std::vector<Util::Expression>::iterator globalExp_end =
3380 for (; globalExp_i != globalExp_end; ++globalExp_i)
3382 double bTime = globalExp_i->get_break_time();
3384 breakPointTimes.push_back(bTime);
3392 for (iterI=beginI;iterI!=endI;++iterI)
3395 bool functionSetup = (*iterI)->getInstanceBreakPoints (breakPointTimes);
3407 for (iterI=beginI;iterI!=endI;++iterI)
3409 bool functionSetup = (*iterI)->getInstanceBreakPoints (breakPointTimes);
3414 std::vector<ExternDevice::Instance*>::iterator iter;
3415 std::vector<ExternDevice::Instance*>::iterator begin;
3416 std::vector<ExternDevice::Instance*>::iterator end;
3417 begin = extDevInstancePtrVec_.begin ();
3418 end = extDevInstancePtrVec_.end ();
3419 for (iter=begin; iter!=end;++iter)
3421 (*iter)->getBreakPoints (breakPointTimes);
3475 bool bsuccess =
true;
3609 int nodeNameSize = nodeNames.size();
3610 nameVec_.resize(nodeNameSize+1,
"gnd");
3611 NodeNamePairMap::iterator mapI, mapEnd;
3612 mapEnd = nodeNames.end();
3613 mapI = nodeNames.begin();
3614 for (; mapI != mapEnd ; ++mapI)
3616 nameVec_[(*mapI).second.first] = (*mapI).first;
3734 InstanceVector::iterator iter;
3735 InstanceVector::iterator begin;
3736 InstanceVector::iterator end;
3739 for (iter=begin; iter!=end;++iter)
3741 (*iter)->setupPointers();
3758 InstanceVector::iterator iter;
3761 for (iter=begin; iter!=end;++iter)
3763 double step = (*iter)->getMaxTimeStepSize ();
3766 maxStep = Xycemin(step, maxStep);
3805 dout() <<
"DeviceMgr::enablePDEContinuation" << std::endl;
3807 bool bsuccess =
true;
3812 InstanceVector::iterator iter;
3816 for (iter=begin; iter!=end;++iter)
3818 bool tmpSuccess = (*iter)->enablePDEContinuation();
3819 bsuccess = bsuccess && tmpSuccess;
3826 for (iter=begin; iter!=end;++iter)
3828 bool tmpSuccess = (*iter)->enablePDEContinuation();
3829 bsuccess = bsuccess && tmpSuccess;
3835 if (!bsuccess) returnedSteps = -1;
3838 return returnedSteps;
3851 bool bsuccess =
true;
3854 InstanceVector::iterator iter;
3857 for (iter=begin; iter!=end;++iter)
3859 bool tmpSuccess = (*iter)->disablePDEContinuation();
3860 bsuccess = bsuccess && tmpSuccess;
3884 bool bsuccess =
true;
3916 int size = numINodes.size ();
3919 if (size < size2) numINodes.resize(size2);
3921 for (
int i=0;i<size2;++i)
3980 bool bSuccess =
true;
3994 Report::UserWarning0 message;
3995 message <<
"Circuit does not have any DAC devices";
4017 bool bSuccess =
true;
4031 Report::UserWarning0 message;
4032 message <<
"Circuit does not have any ADC devices";
4058 std::map< std::string, std::vector< std::pair<double,double> >* >
const & timeVoltageUpdateMap)
4060 bool bSuccess =
true;
4079 std::vector<DeviceInstance*> deviceInstances;
4083 InstanceVector::iterator iterI;
4084 InstanceVector::iterator beginI = deviceInstances.begin();
4085 InstanceVector::iterator endI = deviceInstances.end();
4086 for (iterI = beginI; iterI != endI; ++iterI)
4090 std::string
const & dacName(dacInstancePtr->
getName());
4092 std::map< std::string, std::vector< std::pair<double,double> >* >::const_iterator mapIter;
4093 mapIter = timeVoltageUpdateMap.find(dacName);
4094 if (mapIter == timeVoltageUpdateMap.end())
4101 mapIter = timeVoltageUpdateMap.find(dacName);
4102 if (mapIter == timeVoltageUpdateMap.end())
4104 Report::UserWarning0 message;
4105 message <<
"Could not find DAC " << dacName;
4111 dout() <<
"DeviceMgr::updateTimeVoltagePairs: found DAC with name: "
4115 if (!dacInstancePtr->
updateTVVEC(*(*mapIter).second))
4117 Report::UserWarning0 message;
4118 message <<
"Failed to update the time-voltage pairs for the DAC " << dacName;
4138 bool bSuccess =
true;
4140 dout() <<
"entering DeviceMgr::setADCWidths " << std::endl;
4159 std::vector<DeviceInstance*> deviceInstances;
4163 InstanceVector::iterator iterI;
4164 InstanceVector::iterator beginI = deviceInstances.begin();
4165 InstanceVector::iterator endI = deviceInstances.end();
4166 for (iterI = beginI; iterI != endI; ++iterI)
4170 std::string
const & adcName(adcInstancePtr->
getName());
4172 std::map< std::string, int >::const_iterator mapIter;
4173 mapIter = ADCWidthMap.find(adcName);
4174 if (mapIter == ADCWidthMap.end())
4181 mapIter = ADCWidthMap.find(adcName);
4182 if (mapIter == ADCWidthMap.end())
4184 Report::UserWarning0 message;
4185 message <<
"Could not find ADC " << adcName;
4191 dout() <<
"DeviceMgr::setADCWidths found ADC with name: "
4192 << adcName <<
" and will set bit vector width to: "
4193 << (*mapIter).second <<
"\n";
4198 Report::UserWarning0 message;
4199 message <<
"Failed to update the width for ADC " << adcName;
4217 std::map<std::string, std::vector< std::pair<double,double> > >&TimeVoltageMap)
4219 bool bSuccess =
true;
4221 TimeVoltageMap.clear();
4254 bool bSuccess =
false;
4256 deviceNames.clear();
4267 Report::UserWarning0 message;
4268 message <<
"Circuit does not have any devices matching " << model_type_name;
4290 std::map<std::string,Xygra::Instance *>::iterator mapIter;
4307 Report::UserFatal message;
4308 message <<
"Circuit does not have any Xygra devices";
4314 std::vector<DeviceInstance*> deviceInstances;
4317 int theNamedInstanceIndex = -1;
4319 int numInstances = deviceInstances.size();
4320 for (
int i = 0 ; i < numInstances; ++i)
4322 if (deviceInstances[i]->getName() == deviceName)
4324 theNamedInstanceIndex = i;
4328 if (theNamedInstanceIndex == -1)
4330 Report::UserFatal message;
4331 message <<
"No Xygra device named " << deviceName;
4356 return xygraInstancePtr -> getNumNodes();
4371 return xygraInstancePtr -> getNumWindings();
4385 std::vector<int> & cW)
4388 xygraInstancePtr -> getCoilWindings(cW);
4401 std::vector<std::string> & cN)
4404 xygraInstancePtr -> getCoilNames(cN);
4416 const std::vector<std::vector<double> > & cM)
4419 return xygraInstancePtr -> setConductances(cM);
4431 const std::vector<std::vector<double> > & kM,
4435 return xygraInstancePtr -> setK(kM,t);
4447 const std::vector<double> & sV,
4451 return xygraInstancePtr -> setSources(sV,t);
4464 std::vector<double> & vN)
4467 return xygraInstancePtr -> getVoltages(vN);
4495 bool bsuccess =
true, success =
true;
4502 dout() <<
"In DeviceMgr::updateTemperature. new C temp = " << Ctemp <<
" K temp = " << Ktemp << std::endl;
4509 std::vector<DeviceModel *>::const_iterator iterM;
4512 for (iterM=beginM;iterM!=endM;++iterM)
4514 (*iterM)->clearTemperatureData ();
4520 for (iterM=beginM;iterM!=endM;++iterM)
4522 (*iterM)->clearTemperatureData ();
4528 for (iterM=beginM;iterM!=endM;++iterM)
4530 (*iterM)->clearTemperatureData ();
4539 std::string tname(
"TEMP");
4540 std::string tname2(
"XYCEADMSMODTEMP");
4541 std::string tname3(
"XYCEADMSINSTTEMP");
4544 for (iterM=beginM; iterM!=endM;++iterM)
4546 success = (*iterM)->setParam (tname, Ctemp);
4547 success = (*iterM)->setParam (tname2, Ktemp) || success;
4548 success = success && (*iterM)->processParams ();
4554 InstanceVector::const_iterator iter;
4555 InstanceVector::const_iterator begin;
4556 InstanceVector::const_iterator end;
4560 for (iter=begin; iter!=end;++iter)
4562 success = (*iter)->setParam (tname, Ctemp);
4563 success = (*iter)->setParam (tname3, Ktemp) || success;
4564 success = success && (*iter)->processParams ();
4582 bool allDevsConv =
true;
4583 #ifdef Xyce_PARALLEL_MPI
4590 InstanceVector::iterator iter;
4591 InstanceVector::iterator begin;
4592 InstanceVector::iterator end;
4603 for (iter=begin; iter!=end;++iter)
4605 bool tmpBool = (*iter)->isConverged();
4606 allDevsConv = allDevsConv && tmpBool;
4609 #ifdef Xyce_PARALLEL_MPI
4619 N_PDS_Comm *pdsCommPtr =
pdsMgrPtr_->getPDSComm();
4620 pdsCommPtr->barrier();
4621 pdsCommPtr->sumAll(&dc_par, &dc_glob, 1);
4627 allDevsConv =
false;
4634 dout() <<
"All devices converged!" << std::endl;
4638 dout() <<
"At least one device NOT converged!" << std::endl;
4655 bool innerDevsConv =
true;
4659 #ifdef Xyce_PARALLEL_MPI
4664 std::vector<ExternDevice::Instance*>::iterator iter;
4665 std::vector<ExternDevice::Instance*>::iterator begin;
4666 std::vector<ExternDevice::Instance*>::iterator end;
4667 begin = extDevInstancePtrVec_.begin ();
4668 end = extDevInstancePtrVec_.end ();
4670 for (iter=begin; iter!=end;++iter)
4672 bool tmpFlag = (*iter)->isInnerSolveConverged();
4673 innerDevsConv = innerDevsConv && tmpFlag;
4676 #ifdef Xyce_PARALLEL_MPI
4686 N_PDS_Comm *pdsCommPtr =
pdsMgrPtr_->getPDSComm();
4687 pdsCommPtr->barrier();
4688 pdsCommPtr->sumAll(&dc_par, &dc_glob, 1);
4692 innerDevsConv =
true;
4694 innerDevsConv =
false;
4699 return innerDevsConv;
4712 bool DeviceMgr::setupExternalDevices()
4714 N_PDS_Comm * pdsCommPtr =
pdsMgrPtr_->getPDSComm();
4716 #ifdef Xyce_PARALLEL_MPI
4717 int procID = pdsCommPtr->procID();
4718 int numProc = pdsCommPtr->numProc();
4720 int numExt = extDevInstancePtrVec_.size();
4721 int numExtTotal = 0;
4722 pdsCommPtr->sumAll(&numExt, &numExtTotal, 1);
4724 std::vector<ExternDevice::Instance*> tmpVec = extDevInstancePtrVec_;
4728 if (numExtTotal > 0)
4730 extDevInstancePtrVec_.resize(numExtTotal);
4735 for(
int proc = 0; proc < numProc; ++proc)
4738 if (proc == procID) cnt = numExt;
4739 pdsCommPtr->bcast(&cnt, 1, proc);
4741 for(
int i = 0; i < cnt; ++i)
4745 int size = extDevIBPtrVec_[i]->packedByteCount();
4746 int bufSize = size+100;
4747 char *buf=
new char[bufSize];
4748 pdsCommPtr->bcast(&size, 1, proc);
4750 extDevIBPtrVec_[i]->pack(buf, bufSize, pos, pdsCommPtr);
4751 pdsCommPtr->bcast(buf, size, proc);
4752 extDevInstancePtrVec_[loc] = tmpVec[i];
4758 pdsCommPtr->bcast(&size, 1, proc);
4759 int bufSize = size+100;
4760 char *buf=
new char[bufSize];
4761 pdsCommPtr->bcast(buf, size, proc);
4763 InstanceBlock instance_block;
4764 instance_block.unpack(buf, bufSize, pos, pdsCommPtr);
4765 extDevInstancePtrVec_[loc] = addExtDeviceInstance_(instance_block);
4768 extDevInstancePtrVec_[loc]->setOwningProc(proc);
4769 extDevInstancePtrVec_[loc]->setComm(pdsCommPtr);
4774 assert(loc == numExtTotal);
4777 for (std::vector<ExternDevice::Instance *>::iterator it = extDevInstancePtrVec_.begin(); it != extDevInstancePtrVec_.end(); ++it)
4778 (*it)->setComm(pdsCommPtr);
4791 void DeviceMgr::updateExternalDevices_()
4793 std::vector<ExternDevice::Instance*>::iterator iter;
4794 std::vector<ExternDevice::Instance*>::iterator begin;
4795 std::vector<ExternDevice::Instance*>::iterator end;
4796 begin = extDevInstancePtrVec_.begin ();
4797 end = extDevInstancePtrVec_.end ();
4798 for (iter=begin; iter!=end;++iter)
4800 (*iter)->runExternalDevice();
4813 ExternDevice::Instance *
4814 DeviceMgr::addExtDeviceInstance_(InstanceBlock & instance_block)
4818 if (instance_block.getModelName().empty())
4827 if (!model_type.defined())
4829 Report::UserError message;
4830 message <<
"Unable to determine type of device for instance name " << instance_block.getName();
4831 if (instance_block.getModelName() !=
"")
4833 message <<
" with model name" + instance_block.getModelName();
4841 ExternDevice::Instance *external_instance =
dynamic_cast<ExternDevice::Instance*
>(instance);
4843 return external_instance;
4845 #endif // Xyce_EXTDEV
4856 (
const std::vector<std::string> & paramNames,
4857 const std::vector<double> & paramVals)
4860 int numExt = extDevInstancePtrVec_.size();
4861 std::vector<ExternDevice::Instance*>::iterator iter;
4862 std::vector<ExternDevice::Instance*>::iterator begin;
4863 std::vector<ExternDevice::Instance*>::iterator end;
4864 begin = extDevInstancePtrVec_.begin ();
4865 end = extDevInstancePtrVec_.end ();
4866 for (iter=begin; iter!=end;++iter)
4868 (*iter)->homotopyStepSuccess (paramNames, paramVals);
4870 #endif // Xyce_EXTDEV
4886 int numExt = extDevInstancePtrVec_.size();
4887 std::vector<ExternDevice::Instance*>::iterator iter;
4888 std::vector<ExternDevice::Instance*>::iterator begin;
4889 std::vector<ExternDevice::Instance*>::iterator end;
4890 begin = extDevInstancePtrVec_.begin ();
4891 end = extDevInstancePtrVec_.end ();
4892 for (iter=begin; iter!=end;++iter)
4894 (*iter)->homotopyStepFailure ();
4896 #endif // Xyce_EXTDEV
4912 int numExt = extDevInstancePtrVec_.size();
4913 std::vector<ExternDevice::Instance *>::iterator iter;
4914 std::vector<ExternDevice::Instance *>::iterator begin;
4915 std::vector<ExternDevice::Instance *>::iterator end;
4916 begin = extDevInstancePtrVec_.begin ();
4917 end = extDevInstancePtrVec_.end ();
4918 for (iter=begin; iter!=end;++iter)
4920 (*iter)->stepSuccess (analysis);
4922 #endif // Xyce_EXTDEV
4938 int numExt = extDevInstancePtrVec_.size();
4939 std::vector<ExternDevice::Instance*>::iterator iter;
4940 std::vector<ExternDevice::Instance*>::iterator begin;
4941 std::vector<ExternDevice::Instance*>::iterator end;
4942 begin = extDevInstancePtrVec_.begin ();
4943 end = extDevInstancePtrVec_.end ();
4944 for (iter=begin; iter!=end;++iter)
4946 (*iter)->stepFailure (analysis);
4948 #endif // Xyce_EXTDEV
4997 (*iter)->acceptStep();
5027 bool bsuccess =
true;
5030 int numExt = extDevInstancePtrVec_.size();
5032 tleVec.resize(numExt);
5034 std::vector<ExternDevice::Instance*>::iterator iter;
5035 std::vector<ExternDevice::Instance*>::iterator begin;
5036 std::vector<ExternDevice::Instance*>::iterator end;
5037 begin = extDevInstancePtrVec_.begin ();
5038 end = extDevInstancePtrVec_.end ();
5041 for (iter=begin; iter!=end;++iter,++iext)
5043 bool bs1 = (*iter)->getInitialQnorm (tleVec[iext]);
5044 bsuccess = bsuccess && bs1;
5046 #endif // Xyce_EXTDEV
5060 std::vector<N_TIA_TwoLevelError> & tleVec)
5062 bool bsuccess =
true;
5065 int numExt = extDevInstancePtrVec_.size();
5067 tleVec.resize(numExt);
5069 std::vector<ExternDevice::Instance*>::iterator iter;
5070 std::vector<ExternDevice::Instance*>::iterator begin;
5071 std::vector<ExternDevice::Instance*>::iterator end;
5072 begin = extDevInstancePtrVec_.begin ();
5073 end = extDevInstancePtrVec_.end ();
5076 for (iter=begin; iter!=end;++iter,++iext)
5078 bool bs1 = (*iter)->getInnerLoopErrorSum (tleVec[iext]);
5079 bsuccess = bsuccess && bs1;
5081 #endif // Xyce_EXTDEV
5096 bool bsuccess =
true;
5100 std::vector<ExternDevice::Instance*>::iterator iter;
5101 std::vector<ExternDevice::Instance*>::iterator begin;
5102 std::vector<ExternDevice::Instance*>::iterator end;
5103 begin = extDevInstancePtrVec_.begin ();
5104 end = extDevInstancePtrVec_.end ();
5106 for (iter=begin; iter!=end;++iter)
5108 bool bs1 = (*iter)->updateStateArrays();
5109 bsuccess = bsuccess && bs1;
5111 #endif // Xyce_EXTDEV
5127 bool bsuccess =
true;
5131 std::vector<ExternDevice::Instance*>::iterator iter;
5132 std::vector<ExternDevice::Instance*>::iterator begin;
5133 std::vector<ExternDevice::Instance*>::iterator end;
5134 begin = extDevInstancePtrVec_.begin ();
5135 end = extDevInstancePtrVec_.end ();
5137 for (iter=begin; iter!=end;++iter)
5139 bool bs1 = (*iter)->startTimeStep ();
5140 bsuccess = bsuccess && bs1;
5142 #endif // Xyce_EXTDEV
5175 int count =
sizeof(double) * (numdoubles);
5176 count +=
sizeof(size_t) * numSize_t;
5199 (
char * buf,
int bsize,
int & pos, N_PDS_Comm * comm,
bool pack)
5205 size_t size=solState_.ltraTimePoints.size();
5206 comm->pack(&(solState_.ltraTimeIndex), 1, buf, bsize, pos);
5207 comm->pack(&(solState_.ltraTimeHistorySize), 1, buf, bsize, pos);
5208 comm->pack(&(size), 1, buf, bsize, pos);
5209 comm->pack(&(solState_.ltraTimePoints[0]), size, buf, bsize, pos);
5213 int count = restartDataSize(
false);
5214 int startIndex = pos;
5215 for(
int i = startIndex; i < (startIndex+count); ++i) buf[i] =
' ';
5217 size_t size=solState_.ltraTimePoints.size();
5218 std::ostringstream ost;
5219 ost.width(24);ost.precision(16);ost.setf(std::ios::scientific);
5220 ost << solState_.ltraTimeIndex <<
" ";
5221 ost << solState_.ltraTimeHistorySize <<
" ";
5222 #ifdef Xyce_DEBUG_RESTART
5224 "DeviceMgr::getRestartData: ltraTimeIndex = " << solState_.ltraTimeIndex <<std::endl;
5226 "DeviceMgr::getRestartData: ltraTimeHistorySize = " << solState_.ltraTimeHistorySize <<std::endl;
5229 for (
int i=0;i<size;i++)
5231 ost << solState_.ltraTimePoints[i] <<
" ";
5232 #ifdef Xyce_DEBUG_RESTART
5234 "DeviceMgr::dumpRestartData: ltraTimePoints["<<i<<
"] ="
5235 << solState_.ltraTimePoints[i]<<std::endl;
5239 std::string data(ost.str());
5240 for(
unsigned int i = 0; i < data.length(); ++i) buf[startIndex+i] = data[i];
5246 buf[startIndex+data.length()] =
'\0';
5247 pos += data.length();
5270 comm->unpack(buf, bsize, pos, &(size), 1);
5276 std::string str1(buf);
5277 int length = str1.size() - pos;
5278 std::string str2(str1,pos,length);
5280 std::istringstream ist(str2);
5284 #ifdef Xyce_DEBUG_RESTART
5293 for (
int i=0;i<size;++i)
5296 #ifdef Xyce_DEBUG_RESTART
5297 dout() <<
"DeviceMgr::restoreRestartData: ltraTimePoints["<<i<<
"] = " <<
solState_.
ltraTimePoints[i] << std::endl;
5321 std::string::size_type pos1 = name.find_first_of(
"Y%");
5322 std::string::size_type pos2 = name.find_last_of(
"%");
5324 if (pos1 != std::string::npos && pos2 != std::string::npos)
5326 std::string tmp1 =
"";
5327 if (pos1 > 0) tmp1 = name.substr(0,pos1);
5328 std::string tmp2 = name.substr(pos2+1, name.length()-1);
5329 outputName = tmp1 + tmp2;
5354 return device_entity;
5357 return (*it).second;