46 #include <Xyce_config.h>
57 #include <N_DEV_ExternDevice.h>
63 #include <N_ERH_ErrorMgr.h>
64 #include <N_ERH_Message.h>
65 #include <N_IO_CmdParse.h>
67 #include <N_IO_OutputMgr.h>
68 #include <N_LAS_Builder.h>
69 #include <N_LAS_Matrix.h>
70 #include <N_LAS_System.h>
71 #include <N_PDS_Comm.h>
72 #include <N_PDS_MPI.h>
73 #include <N_PDS_Manager.h>
74 #include <N_UTL_Algorithm.h>
94 struct OptionsReg :
public IO::PkgOptionsReg
96 OptionsReg(DeviceMgr * mgr) :
devMgr(mgr) {}
98 bool operator()(
const Util::OptionBlock & options)
99 {
return devMgr->registerOptions(options);}
104 struct SensOptionsReg :
public IO::PkgOptionsReg
106 SensOptionsReg(DeviceMgr * mgr) :
devMgr(mgr) {}
108 bool operator()(
const Util::OptionBlock & options)
109 {
return devMgr->registerSensParams(options);}
114 struct TimeOptionsReg :
public IO::PkgOptionsReg
116 TimeOptionsReg(DeviceMgr * mgr) :
devMgr(mgr) {}
118 bool operator()(
const Util::OptionBlock & options)
119 {
return devMgr->registerTimeOptions(options);}
125 struct TransAnalysisReg :
public IO::PkgOptionsReg
127 TransAnalysisReg(DeviceMgr * mgr) :
Mgr(mgr) {}
129 bool operator()(
const Util::OptionBlock & options)
130 {
return Mgr->setTranAnalysisParams(options);}
136 struct DCAnalysisReg :
public IO::PkgOptionsReg
138 DCAnalysisReg(DeviceMgr * mgr) :
Mgr(mgr) {}
140 bool operator()(
const Util::OptionBlock & options)
141 {
return Mgr->setDCAnalysisParams(options);}
147 struct OPAnalysisReg :
public IO::PkgOptionsReg
149 OPAnalysisReg(DeviceMgr * mgr) :
Mgr(mgr) {}
151 bool operator()(
const Util::OptionBlock & options)
152 {
return Mgr->setOPAnalysisParams(options);}
158 struct STEPAnalysisReg :
public IO::PkgOptionsReg
160 STEPAnalysisReg(DeviceMgr * mgr) :
Mgr(mgr) {}
162 bool operator()(
const Util::OptionBlock & options)
163 {
return Mgr->setSTEPAnalysisParams(options);}
169 struct MPDE_AnalysisReg :
public IO::PkgOptionsReg
173 bool operator()(
const Util::OptionBlock & options)
174 {
return devMgr_->setMPDEAnalysisParams(options);}
180 struct HB_AnalysisReg :
public IO::PkgOptionsReg
184 bool operator()(
const Util::OptionBlock & options)
185 {
return devMgr_->setHBAnalysisParams(options);}
191 struct AC_AnalysisReg :
public IO::PkgOptionsReg
193 AC_AnalysisReg(DeviceMgr * devMgr) :
devMgr_(devMgr) {}
195 bool operator()(
const Util::OptionBlock & options)
196 {
return devMgr_->setACAnalysisParams(options);}
202 struct MOR_AnalysisReg :
public IO::PkgOptionsReg
204 MOR_AnalysisReg(DeviceMgr * devMgr) :
devMgr_(devMgr) {}
206 bool operator()(
const Util::OptionBlock & options)
207 {
return devMgr_->setMORAnalysisParams(options);}
223 const std::string setupIOName(
const InstanceName &entity_name)
225 return entity_name.getDeviceName();
228 DeviceEntity *findDeviceEntity(EntityTypeIdDeviceMap::const_iterator begin, EntityTypeIdDeviceMap::const_iterator end,
const std::string entity_name) {
229 for (EntityTypeIdDeviceMap::const_iterator it = begin; it != end; ++it) {
230 DeviceEntity *device_entity = (*it).second->findInstance(InstanceName(entity_name));
232 return device_entity;
234 device_entity = (*it).second->findModel(
ModelName(entity_name));
236 return device_entity;
260 virtual Util::Op::Operator *
makeOp(ParameterList::const_iterator &it)
const
262 Util::Op::Operator *new_op = 0;
263 const std::string ¶m_tag = (*it).tag();
264 const std::string ¶m_string = (*it).stringValue();
266 if (param_tag ==
"GLOBAL_PARAMETER") {
268 new_op->addArg(param_string);
303 virtual Util::Op::Operator *
makeOp(ParameterList::const_iterator &it)
const {
304 Util::Op::Operator *new_op = 0;
305 const std::string ¶m_tag = (*it).tag();
306 const std::string ¶m_string = (*it).stringValue();
311 std::string param_name = Util::paramNameFromFullParamName(param_tag);
324 typedef std::list<Util::Param> ParameterList;
326 void parameterNameAndArgs(std::string &name, std::vector<std::string> &args, ParameterList::const_iterator &it)
328 const std::string ¶m_tag = (*it).tag();
330 if (param_tag[0] ==
'V' || param_tag[0] ==
'I' || param_tag[0] ==
'N')
332 std::ostringstream oss;
333 oss << param_tag <<
"(";
334 int arg_count = (*it).getImmutableValue<
int>();
335 for (
int i = 0; i < arg_count; ++i)
341 args.push_back((*it).tag());
359 virtual Util::Op::Operator *
makeOp(ParameterList::const_iterator &it)
const {
360 Util::Op::Operator *new_op = 0;
361 const std::string ¶m_tag = (*it).tag();
362 const std::string ¶m_string = (*it).stringValue();
461 static_cast<Xyce::Util::Notifier<Analysis::StepEvent> &
>(*anaIntPtr_).subscribe(*
this);
487 : commandLine_(command_line),
491 calledBeforeCSPI (false),
493 linearSystemFlag_(true),
494 firstDependent_(true),
495 externalStateFlag_(false),
496 parameterChanged_(false),
497 breakPointInstancesInitialized(false),
498 timeParamsProcessed_(0.0),
499 nonTrivialDeviceMaskFlag(false),
500 dotOpOutputFlag(false),
501 numJacStaVectorPtr_(0),
502 numJacSolVectorPtr_(0),
503 numJacStoVectorPtr_(0),
504 diagonalVectorPtr_(0),
505 globals_(solState_.globals_)
563 for (EntityTypeIdDeviceMap::iterator it =
deviceMap_.begin(), end =
deviceMap_.end(); it != end; ++it)
585 std::string netListFile(
"");
587 if (
commandLine_.getArgumentValue(std::string(
"netlist")) !=
"")
589 netListFile =
commandLine_.getArgumentValue(std::string(
"netlist"));
593 "DEVICE", netListFile,
new OptionsReg(
this));
596 "SENS", netListFile,
new SensOptionsReg(
this));
599 "TIMEINT", netListFile,
new TimeOptionsReg(
this));
603 "TRAN", netListFile,
new TransAnalysisReg(
this));
606 "DC", netListFile,
new DCAnalysisReg(
this));
609 "OP", netListFile,
new OPAnalysisReg(
this));
612 "STEP", netListFile,
new STEPAnalysisReg(
this));
616 "MPDE", netListFile,
new MPDE_AnalysisReg(
this));
620 "HB", netListFile,
new HB_AnalysisReg(
this));
624 "AC", netListFile,
new AC_AnalysisReg(
this));
628 "MOR", netListFile,
new MOR_AnalysisReg(
this));
647 dout() <<
"DeviceMgr::registerSensParams called!" <<std::endl;
676 dout() <<
"DeviceMgr::registerLeadCurrentRequests Devices for which lead currents were requested: ";
679 dout() << (*it) <<
" ";
811 int numFastSrcs = sourceNames.size();
814 std::vector<double> srcPeriods(numFastSrcs);
817 for(
int i = 0; i < numFastSrcs; ++i)
819 std::map<std::string, SourceInstance *, LessNoCase>::iterator iterFS =
indepSourcePtrMap_.find(sourceNames[i]);
823 srcPeriods[i] = SIPtr->
period();
827 #ifndef Xyce_PARALLEL_MPI
828 Report::UserError message;
830 <<
"Potential names are: ";
832 message << (*it).first <<
" ";
837 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_MAX, srcPeriods);
859 int numFastSrcs = sourceNames.size();
861 std::vector<double> srcPeriods;
865 srcPeriods.resize(numFastSrcs, 0.0);
869 std::copy(sourceNames.begin(), sourceNames.end(),
fastSourceNames_.begin());
872 for(
int i = 0; i < numFastSrcs; ++i)
879 srcPeriods[i] = SIPtr->
period();
883 #ifndef Xyce_PARALLEL_MPI
884 Report::UserError message;
886 <<
"Potential names are: ";
888 message << (*it).first <<
" ";
901 pdsMgrPtr_->getPDSComm()->sumAll( &myNumFastSrcs, &numFastSrcs, 1 );
902 srcPeriods.resize(numFastSrcs, -1.0);
903 for (
int i=0 ; i<myNumFastSrcs ; ++i) {
909 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_MAX, srcPeriods);
925 int numFastSrcs = sourceNames.size();
931 std::copy(sourceNames.begin(), sourceNames.end(),
fastSourceNames_.begin());
934 for(
int i = 0; i < numFastSrcs; ++i)
944 #ifndef Xyce_PARALLEL_MPI
945 Report::DevelFatal message;
946 message.in(
"DeviceMgr::deRegisterFastSources");
948 <<
"Potential names are: ";
950 message << (*it).first <<
" ";
959 for (
int i=0 ; i<numFastSrcs ; ++i) {
986 std::vector<SourceInstance*>::iterator iter;
989 for (iter=begin; iter!=end;++iter)
991 if ((*iter)->getFastSourceFlag())
1066 bool bsuccess =
true;
1098 #ifdef Xyce_DEBUG_VOLTLIM
1101 bsuccess = bsuccess && (
externData_.JTestMatrixPtr != 0);
1105 bsuccess = bsuccess && (
externData_.FTestMatrixPtr != 0);
1107 bsuccess = bsuccess && (
externData_.QTestMatrixPtr != 0);
1111 bsuccess = bsuccess && (
externData_.dxVoltlimVectorPtr != 0);
1115 bsuccess = bsuccess && (
externData_.Jdx2VectorPtr != 0);
1119 bsuccess = bsuccess && (
externData_.Fdx2VectorPtr != 0);
1121 bsuccess = bsuccess && (
externData_.Qdx2VectorPtr != 0);
1158 int size =
sizeof(*this);
1159 dout() <<
"Size of device package after initializeAll = " << size << std::endl;
1210 if (model_type_id.defined())
1212 EntityTypeIdDeviceMap::const_iterator it =
deviceMap_.find(model_type_id);
1222 if (device->isPDEDevice())
1228 device = (*it).second;
1274 if (!model_block.
getName().empty()) {
1277 if (!model_type.defined())
1278 Report::UserError() <<
"There is no device " << model_block.
getType() <<
" of level " << model_block.
getLevel() <<
" to define model " << model_block.
getName();
1281 if (!model_type.defined())
1282 model_type = model_group;
1284 if (!model_type.defined())
1289 DeviceModel *device_model = device.addModel(model_block, factory_block);
1295 if (device_model != 0)
1302 return device_model != 0;
1306 std::pair<ModelTypeId, ModelTypeId>
1317 model_group = model_type;
1325 if (!model_type.defined())
1327 Report::UserError message;
1328 message <<
"Unable to determine type of device for instance name " << instance_block.
getInstanceName();
1331 message <<
" with model name " << instance_block.
getModelName();
1349 std::vector<Param>::const_iterator currentParam = instance_block.
params.begin();
1350 std::vector<Param>::const_iterator endParam = instance_block.
params.end();
1351 while(currentParam != endParam)
1353 if ((currentParam->uTag() ==
"R"))
1355 if (currentParam->given())
1357 std::vector<std::string> variables, specials;
1361 const Param * devPar = &(*(currentParam));
1362 const Util::Param * tmpPar = (
dynamic_cast<const Util::Param*
> (devPar));
1364 if (tmpPar->getType() == Util::EXPR)
1366 Util::Expression tmpExp = tmpPar->getValue<Util::Expression>();
1367 tmpExp.get_names(XEXP_VARIABLE, variables);
1368 tmpExp.get_names(XEXP_SPECIAL, specials);
1371 if (specials.empty() && variables.empty())
1386 return std::pair<ModelTypeId, ModelTypeId>(model_type, model_group);
1414 std::pair<ModelTypeId, ModelTypeId> x =
getModelType(instance_block);
1415 model_type = x.first;
1416 model_group = x.second;
1418 if (!model_type.defined())
1420 Report::UserError message;
1421 message <<
"Unable to determine model type of device for instance name " << instance_block.
getInstanceName();
1424 message <<
" with model name" << instance_block.
getModelName();
1452 std::pair<ModelTypeId, ModelTypeId> x =
getModelType(instance_block);
1453 model_type = x.first;
1454 model_group = x.second;
1456 if (!model_type.defined())
1458 Report::UserError message;
1459 message <<
"Unable to determine type of device for instance name " << instance_block.
getInstanceName();
1462 message <<
" with model name " << instance_block.
getModelName();
1473 std::string outputName = setupIOName(instance->
getName());
1482 dout() <<
"DeviceMgr::addDeviceInstance Enabling lead current load for device \""
1486 <<
"\"" << std::endl;
1491 dout() <<
"DeviceMgr::addDeviceInstance Cannot enable lead current load for device \""
1510 if (device.isPDEDevice())
1553 Report::DevelFatal().in(
"DeviceMgr::deleteDeviceInstance") <<
"Not ready with the new boilerplate-free device package";
1555 bool bsuccess =
true;
1610 char fn_fv[256];
for (
int ich = 0; ich < 256; ++ich) fn_fv[ich] = 0;
1611 sprintf(fn_fv,
"fvector.%03d.txt", outIter);
1619 char fn_jdxp[256];
for (
int ich = 0; ich < 256; ++ich) fn_jdxp[ich] = 0;
1620 sprintf(fn_jdxp,
"Jdxp.%03d.txt", outIter);
1623 #ifdef Xyce_DEBUG_VOLTLIM
1625 char fn_dxvl[256];
for (
int ich = 0; ich < 256; ++ich) fn_dxvl[ich] = 0;
1626 sprintf(fn_dxvl,
"dxVL.%03d.txt", outIter);
1627 (
externData_.dxVoltlimVectorPtr)->writeToFile(fn_dxvl);
1630 char fn_jdx2[256];
for (
int ich = 0; ich < 256; ++ich) fn_jdx2[ich] = 0;
1631 sprintf(fn_jdx2,
"Jdx2.%03d.txt", outIter);
1632 (
externData_.Jdx2VectorPtr)->writeToFile(fn_jdx2);
1654 int outputStepNumber = 0;
1658 outputStepNumber = 0;
1669 #ifdef Xyce_DEBUG_VOLTLIM
1671 char fn_dxvl[256];
for (
int ich = 0; ich < 256; ++ich) fn_dxvl[ich] = 0;
1672 sprintf(fn_dxvl,
"dxVL.%03d.%03d.txt", outputStepNumber, newtonIter);
1673 (
externData_.dxVoltlimVectorPtr)->writeToFile(fn_dxvl);
1676 char fn_fdx2[256];
for (
int ich = 0; ich < 256; ++ich) fn_fdx2[ich] = 0;
1677 sprintf(fn_fdx2,
"Fdx2.%03d.%03d.txt", outputStepNumber, newtonIter);
1678 (
externData_.Fdx2VectorPtr)->writeToFile(fn_fdx2);
1681 char fn_qdx2[256];
for (
int ich = 0; ich < 256; ++ich) fn_qdx2[ich] = 0;
1682 sprintf(fn_qdx2,
"Qdx2.%03d.%03d.txt", outputStepNumber, newtonIter);
1683 (
externData_.Qdx2VectorPtr)->writeToFile(fn_qdx2);
1702 bool bsuccess =
true;
1704 if (solVectorPtr != 0)
1709 InstanceVector::iterator iter;
1710 InstanceVector::iterator begin;
1711 InstanceVector::iterator end;
1714 for (iter=begin; iter!=end;++iter)
1716 bool tmpBool = (*iter)->setInitialGuess ();
1717 bsuccess = bsuccess && tmpBool;
1739 int entityFound = (device_entity != 0);
1743 std::string paramName = Util::paramNameFromFullParamName(name);
1746 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_LOR, &available, 1);
1748 return static_cast<bool>(available);
1760 (std::string & name,
1761 std::vector<double> & dfdpVec,
1762 std::vector<double> & dqdpVec,
1763 std::vector<double> & dbdpVec,
1764 std::vector<int> & FindicesVec,
1765 std::vector<int> & QindicesVec,
1766 std::vector<int> & BindicesVec)
1771 int entityFound = (device_entity != 0);
1776 std::string paramName = Util::paramNameFromFullParamName(name);
1778 dfdpVec, dqdpVec, dbdpVec,
1779 FindicesVec, QindicesVec, BindicesVec);
1806 bool bsuccess =
true, success =
true;
1810 std::string netListFile(
"");
1811 if (
commandLine_.getArgumentValue(std::string(
"netlist")) !=
"")
1813 netListFile =
commandLine_.getArgumentValue(std::string(
"netlist"));
1816 dout() << netListFile <<
"\t\t";
1817 dout() <<
"DeviceMgr::setParam. ";
1819 dout() <<
" " << val;
1820 dout() << std::endl;
1826 (*artificial_param_it).second->setValue(*
this, val);
1833 if ((*global_param_it).second != val)
1835 (*global_param_it).second = val;
1840 (*it)->processParams();
1841 (*it)->processInstanceParams();
1851 int entityFound = (device_entity != 0);
1855 std::string paramName = Util::paramNameFromFullParamName(name);
1856 if (paramName ==
"")
1862 found = device_entity->
setParam(paramName, val);
1872 entityFound = found;
1875 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_LOR, &entityFound, 1);
1877 if (entityFound == 0)
1881 Report::DevelWarning() <<
"DeviceMgr::setParam. Unable to find parameter " << name;
1885 Report::UserError() <<
"Unable to find parameter " << name;
1896 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
1898 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
1900 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
1902 bool bs1 = extern_device.setInternalParam(name, val);
1927 bool entityFound =
false;
1932 value = (*artificial_param_it).second->getValue(*
this);
1940 value = (*global_param_it).second;
1946 entityFound = device_entity != 0;
1950 std::string paramName = Util::paramNameFromFullParamName(name);
1951 entityFound = device_entity->
getParam(paramName, value);
1952 if (paramName ==
"")
2004 bool found =
getParam(name, value);
2005 int found_count = found ? 1 : 0;
2006 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_SUM, &found_count, 1);
2009 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_SUM, &
value, 1);
2010 value /= found_count;
2013 return found_count != 0;
2033 Report::DevelWarning() <<
2034 "DeviceMgr::getParamAndReduce. Unable to find parameter " << name;
2038 Report::UserError() <<
"Unable to find parameter " << name;
2054 N_LAS_Vector * nextSolVectorPtr,
2055 N_LAS_Vector * currSolVectorPtr,
2056 N_LAS_Vector * lastSolVectorPtr,
2057 N_LAS_Vector * nextStaVectorPtr,
2058 N_LAS_Vector * currStaVectorPtr,
2059 N_LAS_Vector * lastStaVectorPtr,
2060 N_LAS_Vector * nextStoVectorPtr,
2061 N_LAS_Vector * currStoVectorPtr,
2062 N_LAS_Vector * lastStoVectorPtr
2065 bool bsuccess =
true;
2066 bool tmpBool =
true;
2069 bsuccess = bsuccess && tmpBool;
2082 #ifdef Xyce_PARALLEL_MPI
2104 std::vector<Device*>::iterator iter;
2107 for (iter=begin; iter!=end;++iter)
2112 bsuccess = bsuccess && tmpBool;
2118 for(
int i=0; i< numDevices; ++i)
2128 #ifdef Xyce_PARALLEL_MPI
2133 Report::safeBarrier(
pdsMgrPtr_->getPDSComm()->comm());
2181 (N_LAS_Vector * tmpSolVectorPtr,
2182 N_LAS_Vector * tmpStateVectorPtr,
2183 N_LAS_Vector * tmpStateDerivVectorPtr,
2184 N_LAS_Vector * tmpStoreVectorPtr,
2185 N_LAS_Matrix * tmpdQdxMatrixPtr,
2186 N_LAS_Matrix * tmpdFdxMatrixPtr)
2188 bool bsuccess =
true;
2189 bool tmpBool =
true;
2192 (externData_.nextSolVectorPtr) = tmpSolVectorPtr;
2193 bool resetRawMatrixPointers =
true;
2195 (externData_.dQdxMatrixPtr == tmpdQdxMatrixPtr) &&
2196 (externData_.dFdxMatrixPtr == tmpdFdxMatrixPtr)
2199 resetRawMatrixPointers =
false;
2201 if (resetRawMatrixPointers)
2203 externData_.dQdxMatrixPtr = tmpdQdxMatrixPtr;
2204 externData_.dFdxMatrixPtr = tmpdFdxMatrixPtr;
2207 externData_.nextStaVectorPtr = tmpStateVectorPtr;
2208 externData_.nextStaDerivVectorPtr = tmpStateDerivVectorPtr;
2209 externData_.nextStoVectorPtr = tmpStoreVectorPtr;
2212 externData_.nextSolVectorRawPtr = &((*externData_.nextSolVectorPtr)[0]);
2213 externData_.nextStaVectorRawPtr = &((*externData_.nextStaVectorPtr)[0]);
2214 externData_.nextStaDerivVectorRawPtr = &((*externData_.nextStaDerivVectorPtr)[0]);
2215 externData_.nextStoVectorRawPtr = &((*externData_.nextStoVectorPtr)[0]);
2219 if (resetRawMatrixPointers || solState_.blockAnalysisFlag)
2221 this->setupRawMatrixPointers_();
2225 InstanceVector::iterator iter;
2226 InstanceVector::iterator begin;
2227 InstanceVector::iterator end;
2238 begin = nonPdeInstancePtrVec_.begin();
2239 end = nonPdeInstancePtrVec_.end();
2240 for (iter=begin; iter!=end;++iter)
2242 (*iter)->loadTrivialDAE_FMatrixStamp ();
2245 begin = pdeInstancePtrVec_.begin();
2246 end = pdeInstancePtrVec_.end();
2247 for (iter=begin; iter!=end;++iter)
2249 tmpBool = (*iter)->loadDAEdQdx();bsuccess = bsuccess && tmpBool;
2250 tmpBool = (*iter)->loadDAEdFdx();bsuccess = bsuccess && tmpBool;
2256 int numDevices = devicePtrVec_.size();
2257 for(
int i=0; i< numDevices; ++i)
2259 bsuccess=devicePtrVec_.at(i)->loadDAEMatrices
2260 (*(externData_.dFdxMatrixPtr) , *(externData_.dQdxMatrixPtr));
2265 if (devOptions_.testJacobianFlag &&
2266 (solState_.timeStepNumber >= devOptions_.testJacStartStep &&
2267 solState_.timeStepNumber <= devOptions_.testJacStopStep)
2272 devOptions_.debugLevel -= 2;
2276 if ((devOptions_.testJacDeviceNameGiven))
2278 begin = testJacDevicePtrVec_.begin();
2279 end = testJacDevicePtrVec_.end();
2283 begin = instancePtrVec_.begin();
2284 end = instancePtrVec_.end();
2287 for (iter=begin; iter!=end;++iter)
2289 (*iter)->testDAEMatrices (nameVec_);
2293 devOptions_.debugLevel += 2;
2297 externData_.dQdxMatrixPtr->fillComplete();
2298 externData_.dFdxMatrixPtr->fillComplete();
2300 Report::safeBarrier(pdsMgrPtr_->getPDSComm()->comm());
2302 if (DEBUG_DEVICE && devOptions_.debugLevel > 1 && solState_.debugTimeFlag)
2304 int newtonIter = solState_.newtonIter;
2305 dout() << section_divider << std::endl;
2306 dout() <<
"Q-matrix: nonlinear iteration = " << newtonIter <<
"\n";
2307 externData_.dQdxMatrixPtr->printPetraObject(dout());
2308 dout() << std::endl;
2309 dout() << section_divider << std::endl;
2310 dout() <<
"F-matrix: nonlinear iteration = " << newtonIter <<
"\n";
2311 externData_.dFdxMatrixPtr->printPetraObject(dout());
2312 dout() << std::endl;
2313 dout() << section_divider << std::endl;
2359 (N_LAS_Vector * tmpSolVectorPtr,
2360 N_LAS_Vector * tmpCurrSolVectorPtr,
2361 N_LAS_Vector * tmpLastSolVectorPtr,
2362 N_LAS_Vector * tmpStaVectorPtr,
2363 N_LAS_Vector * tmpCurrStaVectorPtr,
2364 N_LAS_Vector * tmpLastStaVectorPtr,
2365 N_LAS_Vector * tmpStaDerivVectorPtr,
2366 N_LAS_Vector * tmpStoVectorPtr,
2367 N_LAS_Vector * tmpCurrStoVectorPtr,
2368 N_LAS_Vector * tmpLastStoVectorPtr,
2369 N_LAS_Vector * tmpStoLeadCurrQCompVectorPtr,
2370 N_LAS_Vector * tmpQVectorPtr,
2371 N_LAS_Vector * tmpFVectorPtr,
2372 N_LAS_Vector * tmpBVectorPtr,
2373 N_LAS_Vector * tmpdFdxdVpVectorPtr,
2374 N_LAS_Vector * tmpdQdxdVpVectorPtr)
2376 bool bsuccess =
true;
2377 bool tmpBool =
true;
2380 externData_.nextSolVectorPtr = tmpSolVectorPtr;
2381 externData_.currSolVectorPtr = tmpCurrSolVectorPtr;
2382 externData_.lastSolVectorPtr = tmpLastSolVectorPtr;
2383 externData_.daeQVectorPtr = tmpQVectorPtr;
2384 externData_.daeFVectorPtr = tmpFVectorPtr;
2385 externData_.daeBVectorPtr = tmpBVectorPtr;
2386 externData_.dFdxdVpVectorPtr = tmpdFdxdVpVectorPtr;
2387 externData_.dQdxdVpVectorPtr = tmpdQdxdVpVectorPtr;
2388 externData_.nextStaVectorPtr = tmpStaVectorPtr;
2389 externData_.currStaVectorPtr = tmpCurrStaVectorPtr;
2390 externData_.lastStaVectorPtr = tmpLastStaVectorPtr;
2391 externData_.storeLeadCurrQCompPtr = tmpStoLeadCurrQCompVectorPtr;
2392 externData_.nextStaDerivVectorPtr = tmpStaDerivVectorPtr;
2393 externData_.nextStoVectorPtr = tmpStoVectorPtr;
2394 externData_.currStoVectorPtr = tmpCurrStoVectorPtr;
2395 externData_.lastStoVectorPtr = tmpLastStoVectorPtr;
2398 #ifdef Xyce_PARALLEL_MPI
2399 externData_.nextSolVectorPtr->importOverlap();
2400 externData_.nextStaDerivVectorPtr->importOverlap();
2404 setupRawVectorPointers_ ();
2407 std::vector<Device*>::iterator iter;
2408 std::vector<Device*>::iterator begin;
2409 std::vector<Device*>::iterator end;
2414 begin = pdeDevicePtrVec_.begin ();
2415 end = pdeDevicePtrVec_.end ();
2419 begin = devicePtrVec_.begin ();
2420 end = devicePtrVec_.end ();
2423 #ifndef Xyce_EXCLUDE_SECONDARY_STATE
2424 for (iter=begin; iter!=end;++iter)
2426 tmpBool = (*iter)->updateSecondaryState
2427 (externData_.nextStaDerivVectorRawPtr, externData_.nextStoVectorRawPtr);
2428 bsuccess = bsuccess && tmpBool;
2430 #endif // Xyce_EXCLUDE_SECONDARY_STATE
2432 #ifdef Xyce_PARALLEL_MPI
2433 externData_.nextStaVectorPtr->importOverlap();
2434 externData_.nextStoVectorPtr->importOverlap();
2439 int numDevices = pdeDevicePtrVec_.size();
2440 for(
int i=0; i< numDevices; ++i)
2442 bsuccess=pdeDevicePtrVec_.at(i)->loadDAEVectors(externData_.nextSolVectorRawPtr,
2443 externData_.daeFVectorRawPtr,
2444 externData_.daeQVectorRawPtr,
2445 externData_.daeBVectorRawPtr,
2446 externData_.nextStoVectorRawPtr,
2447 externData_.storeLeadCurrQCompRawPtr);
2452 int numDevices = devicePtrVec_.size();
2453 for(
int i=0; i< numDevices; ++i)
2455 bsuccess=devicePtrVec_.at(i)->loadDAEVectors(externData_.nextSolVectorRawPtr,
2456 externData_.daeFVectorRawPtr,
2457 externData_.daeQVectorRawPtr,
2458 externData_.daeBVectorRawPtr,
2459 externData_.nextStoVectorRawPtr,
2460 externData_.storeLeadCurrQCompRawPtr);
2465 if (DEBUG_DEVICE && devOptions_.debugLevel > 1 && solState_.debugTimeFlag)
2467 int newtonIter = solState_.newtonIter;
2468 dout() <<
"Q-vector: nonlinear iteration = " << newtonIter <<
"\n";
2469 externData_.daeQVectorPtr->printPetraObject(std::cout);
2470 dout() << std::endl;
2471 dout() <<
"F-vector: nonlinear iteration = " << newtonIter <<
"\n";
2472 externData_.daeFVectorPtr->printPetraObject(std::cout);
2473 dout() << std::endl;
2475 if (devOptions_.voltageLimiterFlag)
2477 dout() <<
"\n\n dFdxdVp vector: nonlinear iteration = " << newtonIter <<
"\n";
2478 externData_.dFdxdVpVectorPtr->printPetraObject(std::cout);
2479 dout() << std::endl;
2480 dout() <<
"\n\n dQdxdVp vector: nonlinear iteration = " << newtonIter <<
"\n";
2481 externData_.dQdxdVpVectorPtr->printPetraObject(std::cout);
2482 dout() << std::endl;
2489 externData_.daeQVectorPtr->fillComplete();
2490 externData_.daeFVectorPtr->fillComplete();
2491 externData_.dFdxdVpVectorPtr->fillComplete();
2492 externData_.dQdxdVpVectorPtr->fillComplete();
2494 Report::safeBarrier(pdsMgrPtr_->getPDSComm()->comm());
2497 int size =
sizeof(*this);
2498 dout() <<
"Size of device package after vector load = " << size << std::endl;
2520 InstanceVector::iterator iter;
2521 InstanceVector::iterator begin;
2522 InstanceVector::iterator end;
2529 for (iter=begin; iter!=end;++iter)
2552 if (par.getType() == Util::EXPR)
2559 std::vector<std::string> variables;
2560 expression.get_names(XEXP_VARIABLE, variables);
2561 std::vector<std::string> specials;
2562 expression.get_names(XEXP_SPECIAL, specials);
2563 if (!specials.empty())
2568 for (std::vector<std::string>::const_iterator it = variables.begin(),
2569 end = variables.end() ; it != end ; ++it)
2575 expression.evaluateFunction(val);
2600 retVal = parLocItr->second;
2604 Report::UserError() <<
"Could not find global parameter \"" << parName <<
"\"";
2621 return &(*it).second;
2637 bool bsuccess =
true;
2639 InstanceVector::iterator iter;
2642 for (iter=begin; iter!=end;++iter)
2644 (*iter)->updateIntermediateVars ();
2661 bool bsuccess =
true;
2663 InstanceVector::iterator iter;
2666 for (iter=begin; iter!=end;++iter)
2668 (*iter)->updatePrimaryState ();
2685 bool bsuccess =
true;
2687 InstanceVector::iterator iter;
2690 for (iter=begin; iter!=end;++iter)
2692 (*iter)->updateSecondaryState ();
2709 bool bsuccess =
true;
2720 for (std::vector<Util::Expression>::iterator g_i = ge.begin(), g_end = ge.end();
2721 g_i != g_end; ++g_i)
2723 bool changed =
false;
2727 std::vector<std::string> variables;
2728 g_i->get_names(XEXP_VARIABLE, variables);
2729 for (std::vector<std::string>::iterator vs_i = variables.begin(), vs_end = variables.end();
2730 vs_i != vs_end; ++vs_i)
2732 if (g_i->set_var(*vs_i, gp[*vs_i]))
2741 g_i->evaluateFunction(val);
2754 ModelVector::iterator iterM;
2757 for (iterM=beginM; iterM!=endM;++iterM)
2759 if (!(*iterM)->getDependentParams().empty())
2762 bool tmpBool = (*iterM)->updateGlobalParameters(gp);
2763 bsuccess = bsuccess && tmpBool;
2764 tmpBool = (*iterM)->updateDependentParameters (*solVectorPtr);
2765 bsuccess = bsuccess && tmpBool;
2766 (*iterM)->processParams();
2767 (*iterM)->processInstanceParams();
2772 InstanceVector::iterator iter;
2775 for (iter=begin; iter!=end;++iter)
2777 if (!(*iter)->getDependentParams().empty())
2780 bool tmpBool = (*iter)->updateGlobalParameters(gp);
2781 bsuccess = bsuccess && tmpBool;
2782 tmpBool = (*iter)->updateDependentParameters (*solVectorPtr);
2783 bsuccess = bsuccess && tmpBool;
2784 (*iter)->processParams();
2790 EntityVector::iterator iter;
2793 for (iter=begin; iter!=end;++iter)
2795 bool changed =
false;
2798 bool tmpBool = (*iter)->updateGlobalParameters(gp);
2799 changed = changed || tmpBool;
2800 bsuccess = bsuccess && tmpBool;
2802 bool tmpBool = (*iter)->updateDependentParameters (*solVectorPtr);
2803 changed = changed || tmpBool;
2804 bsuccess = bsuccess && tmpBool;
2807 (*iter)->processParams();
2808 (*iter)->processInstanceParams();
2829 bool bsuccess =
true;
2835 #ifdef Xyce_PARALLEL_MPI
2842 std::vector<SourceInstance*>::iterator vIter;
2845 for (vIter=vBegin; vIter!=vEnd;++vIter)
2862 std::vector<int>& bMatPosEntriesVec)
2864 bool bsuccess =
true;
2866 int lpos, lneg, lbra;
2867 std::vector<SourceInstance *>::iterator vIter;
2871 for (vIter=vBegin; vIter!=vEnd;++vIter)
2876 vsrc->
getLIDs(lpos, lneg, lbra);
2877 bMatEntriesVec.push_back(lbra);
2878 bMatPosEntriesVec.push_back(lpos);
2896 bool bsuccess =
true;
2900 std::vector<SourceInstance*>::iterator vIter;
2903 for (vIter=vBegin; vIter!=vEnd; ++vIter)
2905 (*vIter)->updateSource();
2920 N_LAS_Vector * tmpSolVectorPtr,
2921 N_LAS_Vector * tmpCurrSolVectorPtr,
2922 N_LAS_Vector * tmpLastSolVectorPtr,
2923 N_LAS_Vector * tmpStaVectorPtr,
2924 N_LAS_Vector * tmpCurrStaVectorPtr,
2925 N_LAS_Vector * tmpLastStaVectorPtr,
2926 N_LAS_Vector * tmpStaDerivVectorPtr,
2927 N_LAS_Vector * tmpStoVectorPtr,
2928 N_LAS_Vector * tmpCurrStoVectorPtr,
2929 N_LAS_Vector * tmpLastStoVectorPtr,
2930 N_LAS_Vector * tmpQVectorPtr,
2931 N_LAS_Vector * tmpFVectorPtr,
2932 N_LAS_Vector * tmpBVectorPtr,
2933 N_LAS_Vector * tmpdFdxdVpVectorPtr,
2934 N_LAS_Vector * tmpdQdxdVpVectorPtr)
2936 bool bsuccess =
true;
2956 #ifdef Xyce_PARALLEL_MPI
2984 bool bsuccess =
true;
2986 InstanceVector::iterator iter;
2989 for (iter=begin; iter!=end;++iter)
2991 bool tmpBool = (*iter)->outputPlotFiles ();
2992 bsuccess = bsuccess && tmpBool;
3019 bool bsuccess =
true;
3020 bool tmpBool =
true;
3024 bsuccess = bsuccess && tmpBool;
3043 std::map<std::string, Device *> device_map;
3044 for (EntityTypeIdDeviceMap::const_iterator it =
deviceMap_.begin();
3047 device_map[(*it).second->getName()] = (*it).second;
3050 lout() << section_divider <<
"\n"
3051 <<
"Operating point information:";
3053 for (std::map<std::string, Device *>::const_iterator it = device_map.begin();
3054 it != device_map.end(); ++it)
3059 lout() << section_divider << std::endl;
3074 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_LOR, &pde_flag, 1);
3089 InstanceVector::iterator iterI;
3090 ModelVector::iterator iterM;
3091 bool bsuccess =
true;
3092 bool tmpBool =
true;
3095 bsuccess = bsuccess && tmpBool;
3103 if (!(*iterM)->getDependentParams().empty())
3105 tmpBool = (*iterM)->getParamBreakpoints(breakPointTimes);
3106 bsuccess = bsuccess && tmpBool;
3112 if (!(*iterI)->getDependentParams().empty())
3114 tmpBool = (*iterI)->getParamBreakpoints(breakPointTimes);
3115 bsuccess = bsuccess && tmpBool;
3120 std::vector<Util::Expression>::iterator globalExp_i =
3122 std::vector<Util::Expression>::iterator globalExp_end =
3124 for (; globalExp_i != globalExp_end; ++globalExp_i)
3126 double bTime = globalExp_i->get_break_time();
3128 breakPointTimes.push_back(bTime);
3136 for (iterI=beginI;iterI!=endI;++iterI)
3139 bool functionSetup = (*iterI)->getInstanceBreakPoints (breakPointTimes);
3151 for (iterI=beginI;iterI!=endI;++iterI)
3153 bool functionSetup = (*iterI)->getInstanceBreakPoints (breakPointTimes);
3157 ModelTypeInstanceVectorMap::const_iterator model_type_it =
3161 for (InstanceVector::const_iterator it = (*model_type_it).second.begin();
3162 it != (*model_type_it).second.end(); ++it)
3164 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
3166 extern_device.getBreakPoints(breakPointTimes);
3220 bool bsuccess =
true;
3353 const NodeNamePairMap & nodeNames =
outputMgrPtr_->getAllNodes();
3354 int nodeNameSize = nodeNames.size();
3355 nameVec_.resize(nodeNameSize+1,
"gnd");
3356 NodeNamePairMap::const_iterator mapI, mapEnd;
3357 mapEnd = nodeNames.end();
3358 mapI = nodeNames.begin();
3359 for (; mapI != mapEnd ; ++mapI)
3361 nameVec_[(*mapI).second.first] = (*mapI).first;
3484 InstanceVector::iterator iter;
3485 InstanceVector::iterator begin;
3486 InstanceVector::iterator end;
3489 for (iter=begin; iter!=end;++iter)
3491 (*iter)->setupPointers();
3508 InstanceVector::iterator iter;
3511 for (iter=begin; iter!=end;++iter)
3513 double step = (*iter)->getMaxTimeStepSize ();
3516 maxStep =
Xycemin(step, maxStep);
3555 dout() <<
"DeviceMgr::enablePDEContinuation" << std::endl;
3557 bool bsuccess =
true;
3562 InstanceVector::iterator iter;
3566 for (iter=begin; iter!=end;++iter)
3568 bool tmpSuccess = (*iter)->enablePDEContinuation();
3569 bsuccess = bsuccess && tmpSuccess;
3576 for (iter=begin; iter!=end;++iter)
3578 bool tmpSuccess = (*iter)->enablePDEContinuation();
3579 bsuccess = bsuccess && tmpSuccess;
3585 if (!bsuccess) returnedSteps = -1;
3588 return returnedSteps;
3601 bool bsuccess =
true;
3604 InstanceVector::iterator iter;
3607 for (iter=begin; iter!=end;++iter)
3609 bool tmpSuccess = (*iter)->disablePDEContinuation();
3610 bsuccess = bsuccess && tmpSuccess;
3662 int size = numINodes.size ();
3665 if (size < size2) numINodes.resize(size2);
3667 for (
int i=0;i<size2;++i)
3739 bool bsuccess =
true, success =
true;
3746 dout() <<
"In DeviceMgr::updateTemperature. new C temp = " << Ctemp <<
" K temp = " << Ktemp << std::endl;
3757 for (ModelVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
3759 (*it)->clearTemperatureData ();
3769 for (ModelVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
3771 (*it)->clearTemperatureData ();
3781 for (ModelVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
3783 (*it)->clearTemperatureData ();
3793 std::string tname(
"TEMP");
3794 std::string tname2(
"XYCEADMSMODTEMP");
3795 std::string tname3(
"XYCEADMSINSTTEMP");
3798 success = (*it)->setParam (tname, Ctemp);
3799 success = (*it)->setParam (tname2, Ktemp) || success;
3800 success = success && (*it)->processParams ();
3806 InstanceVector::const_iterator iter;
3807 InstanceVector::const_iterator begin;
3808 InstanceVector::const_iterator end;
3812 for (iter=begin; iter!=end;++iter)
3814 success = (*iter)->setParam (tname, Ctemp);
3815 success = (*iter)->setParam (tname3, Ktemp) || success;
3816 success = success && (*iter)->processParams ();
3834 int allDevsConv =
true;
3838 InstanceVector::iterator iter;
3839 InstanceVector::iterator begin;
3840 InstanceVector::iterator end;
3852 for (iter=begin; iter!=end;++iter)
3854 bool tmpBool = (*iter)->isConverged();
3855 allDevsConv = allDevsConv && tmpBool;
3858 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_LAND, &allDevsConv, 1);
3864 dout() <<
"All devices converged!" << std::endl;
3868 dout() <<
"At least one device NOT converged!" << std::endl;
3872 return allDevsConv != 0;
3885 int innerDevsConv =
true;
3887 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
3889 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
3891 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
3893 bool tmpFlag = extern_device.isInnerSolveConverged();
3894 innerDevsConv = innerDevsConv && tmpFlag;
3898 Parallel::AllReduce(
pdsMgrPtr_->getPDSComm()->comm(), MPI_LAND, &innerDevsConv, 1);
3900 return innerDevsConv != 0;
3914 N_PDS_Comm * pdsCommPtr =
pdsMgrPtr_->getPDSComm();
3916 #ifdef Xyce_PARALLEL_MPI
3919 int procID = pdsCommPtr->procID();
3920 int numProc = pdsCommPtr->numProc();
3922 int numExt = extern_device_vector.size();
3923 int numExtTotal = 0;
3924 pdsCommPtr->sumAll(&numExt, &numExtTotal, 1);
3930 if (numExtTotal > 0)
3932 extern_device_vector.resize(numExtTotal);
3935 for (
int proc = 0; proc < numProc; ++proc)
3938 if (proc == procID) cnt = numExt;
3939 pdsCommPtr->bcast(&cnt, 1, proc);
3941 for(
int i = 0; i < cnt; ++i)
3945 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*extern_device_vector[loc]);
3946 int size = extern_device.getInstanceBlock().packedByteCount();
3947 int bufSize = size+100;
3948 char *buf=
new char[bufSize];
3949 pdsCommPtr->bcast(&size, 1, proc);
3951 extern_device.getInstanceBlock().pack(buf, bufSize, pos, pdsCommPtr);
3952 pdsCommPtr->bcast(buf, size, proc);
3953 extern_device_vector[loc] = orig_extern_device_vector[i];
3959 pdsCommPtr->bcast(&size, 1, proc);
3960 int bufSize = size+100;
3961 char *buf=
new char[bufSize];
3962 pdsCommPtr->bcast(buf, size, proc);
3965 instance_block.
unpack(buf, bufSize, pos, pdsCommPtr);
3969 static_cast<ExternDevice::Instance *
>(extern_device_vector[loc])->setOwningProc(proc);
3970 static_cast<ExternDevice::Instance *
>(extern_device_vector[loc])->setComm(pdsCommPtr);
3975 assert(loc == numExtTotal);
3978 #else // not Xyce_PARALLEL_MPI
3979 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
3981 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
3983 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
3985 extern_device.setComm(pdsCommPtr);
3988 #endif // Xyce_PARALLEL_MPI
4003 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4005 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
4007 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4009 extern_device.runExternalDevice();
4023 ExternDevice::Instance *
4026 ExternDevice::Instance *external_instance = 0;
4039 if (!model_type.defined())
4041 Report::UserError message;
4042 message <<
"Unable to determine type of device for instance name " << instance_block.
getInstanceName();
4045 message <<
" with model name " << instance_block.
getModelName();
4053 external_instance =
static_cast<ExternDevice::Instance *
>(instance);
4055 return external_instance;
4067 (
const std::vector<std::string> & paramNames,
4068 const std::vector<double> & paramVals)
4070 ModelTypeInstanceVectorMap::const_iterator model_type_it = modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4071 if (model_type_it != modelTypeInstanceVector_.end()) {
4072 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
4074 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4076 extern_device.homotopyStepSuccess (paramNames, paramVals);
4091 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4093 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
4095 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4097 extern_device.homotopyStepFailure ();
4112 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4114 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
4116 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4118 extern_device.stepSuccess(analysis);
4133 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4135 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
4137 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4139 extern_device.stepFailure(analysis);
4188 (*iter)->acceptStep();
4218 bool bsuccess =
true;
4220 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4222 int numExt = (*model_type_it).second.size();
4224 tleVec.resize(numExt);
4226 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it, ++iext)
4228 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4230 bool bs1 = extern_device.getInitialQnorm(tleVec[iext]);
4231 bsuccess = bsuccess && bs1;
4247 std::vector<N_TIA_TwoLevelError> & tleVec)
4249 bool bsuccess =
true;
4251 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4253 int numExt = (*model_type_it).second.size();
4255 tleVec.resize(numExt);
4257 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it, ++iext)
4259 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4261 bool bs1 = extern_device.getInnerLoopErrorSum(tleVec[iext]);
4262 bsuccess = bsuccess && bs1;
4279 bool bsuccess =
true;
4281 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4283 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
4285 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4287 bool bs1 = extern_device.updateStateArrays();
4288 bsuccess = bsuccess && bs1;
4306 bool bsuccess =
true;
4309 ModelTypeInstanceVectorMap::const_iterator model_type_it =
modelTypeInstanceVector_.find(ExternDevice::Traits::modelType());
4311 for (InstanceVector::const_iterator it = (*model_type_it).second.begin(); it != (*model_type_it).second.end(); ++it)
4313 ExternDevice::Instance &extern_device =
static_cast<ExternDevice::Instance &
>(*(*it));
4315 bool bs1 = extern_device.startTimeStep ();
4316 bsuccess = bsuccess && bs1;
4350 int count =
sizeof(double) * (numdoubles);
4351 count +=
sizeof(size_t) * numSize_t;
4374 (
char * buf,
int bsize,
int & pos, N_PDS_Comm * comm,
bool pack)
4380 size_t size=solState_.ltraTimePoints.size();
4381 comm->pack(&(solState_.ltraTimeIndex), 1, buf, bsize, pos);
4382 comm->pack(&(solState_.ltraTimeHistorySize), 1, buf, bsize, pos);
4383 comm->pack(&(size), 1, buf, bsize, pos);
4384 comm->pack(&(solState_.ltraTimePoints[0]), size, buf, bsize, pos);
4388 int count = restartDataSize(
false);
4389 int startIndex = pos;
4390 for(
int i = startIndex; i < (startIndex+count); ++i) buf[i] =
' ';
4392 size_t size=solState_.ltraTimePoints.size();
4393 std::ostringstream ost;
4394 ost.width(24);ost.precision(16);ost.setf(std::ios::scientific);
4395 ost << solState_.ltraTimeIndex <<
" ";
4396 ost << solState_.ltraTimeHistorySize <<
" ";
4397 #ifdef Xyce_DEBUG_RESTART
4399 "DeviceMgr::getRestartData: ltraTimeIndex = " << solState_.ltraTimeIndex <<std::endl;
4401 "DeviceMgr::getRestartData: ltraTimeHistorySize = " << solState_.ltraTimeHistorySize <<std::endl;
4404 for (
int i=0;i<size;i++)
4406 ost << solState_.ltraTimePoints[i] <<
" ";
4407 #ifdef Xyce_DEBUG_RESTART
4409 "DeviceMgr::dumpRestartData: ltraTimePoints["<<i<<
"] ="
4410 << solState_.ltraTimePoints[i]<<std::endl;
4414 std::string data(ost.str());
4415 for(
unsigned int i = 0; i < data.length(); ++i) buf[startIndex+i] = data[i];
4421 buf[startIndex+data.length()] =
'\0';
4422 pos += data.length();
4445 comm->unpack(buf, bsize, pos, &(size), 1);
4451 std::string str1(buf);
4452 int length = str1.size() - pos;
4453 std::string str2(str1,pos,length);
4455 std::istringstream ist(str2);
4459 #ifdef Xyce_DEBUG_RESTART
4468 for (
int i=0;i<size;++i)
4471 #ifdef Xyce_DEBUG_RESTART
4472 dout() <<
"DeviceMgr::restoreRestartData: ltraTimePoints["<<i<<
"] = " <<
solState_.
ltraTimePoints[i] << std::endl;
4492 std::string entity_name = Xyce::Util::entityNameFromFullParamName(full_param_name).getEncodedName();
4499 return device_entity;
4501 else if (!(*it).second)
4504 (*it).second = device_entity;
4505 return device_entity;
4508 return (*it).second;
4522 std::map<std::string,int>::const_iterator dm_begin = device_map.begin();
4523 std::map<std::string,int>::const_iterator dm_end = device_map.end();
4524 std::map<std::string,int>::const_iterator dm_iter = dm_begin;
4525 for ( ; dm_iter != dm_end; ++dm_iter)