40 #include <Xyce_config.h>
51 #include <N_ERH_Message.h>
52 #include <N_ERH_ErrorMgr.h>
53 #include <N_IO_CircuitBlock.h>
54 #include <N_IO_CmdParse.h>
55 #include <N_IO_InitialConditions.h>
56 #include <N_IO_OptionBlock.h>
57 #include <N_IO_PkgOptionsMgr.h>
58 #include <N_IO_SpiceSeparatedFieldTool.h>
59 #include <N_LAS_BlockMatrix.h>
60 #include <N_LAS_BlockSystemHelpers.h>
61 #include <N_LAS_BlockVector.h>
62 #include <N_LAS_Builder.h>
63 #include <N_LAS_Matrix.h>
64 #include <N_LAS_MultiVector.h>
65 #include <N_LAS_System.h>
74 #include <N_UTL_Diagnostic.h>
75 #include <N_UTL_FeatureTest.h>
76 #include <N_UTL_LogStream.h>
77 #include <N_UTL_Math.h>
78 #include <N_UTL_Timer.h>
79 #include <N_PDS_Comm.h>
80 #include <N_PDS_MPI.h>
81 #include <N_PDS_Manager.h>
82 #include <N_PDS_Serial.h>
84 #include <N_PDS_ParMap.h>
86 #include <N_TOP_Topology.h>
88 #include <Epetra_SerialComm.h>
89 #include <Epetra_Map.h>
90 #include <Epetra_BlockMap.h>
91 #include <Epetra_CrsMatrix.h>
92 #include <Epetra_CrsGraph.h>
93 #include <Epetra_MultiVector.h>
94 #include <Epetra_Vector.h>
95 #include <Epetra_Export.h>
96 #include <Epetra_LinearProblem.h>
99 #include<N_UTL_ExtendedString.h>
100 #include<N_UTL_ExpressionData.h>
103 #include <Teuchos_RCP.hpp>
108 #define N_MINLOG 1E-38
109 #define N_MINGAIN 1E-20 // the smallest input-output gain we can tolerate
113 #define N_INTFTHRESH 1E-10 // the largest slope (of a log-log noise spectral
117 #define N_INTUSELOG 1E-10 // decides which expression to use for the integral of
135 const Util::OptionBlock & option_block)
137 for (Util::ParamList::const_iterator it = option_block.begin(),
138 end = option_block.end(); it != end; ++it)
140 const Util::Param ¶m = *it;
142 if (param.uTag() ==
"DEBUGLEVEL" )
160 Report::UserError() << param.uTag()
161 <<
" is not a recognized time integration option";
178 Linear::System & linear_system,
181 Topo::Topology & topology,
182 IO::InitialConditionsManager & initial_conditions_manager)
191 outputManagerAdapter_(analysis_manager.getOutputManagerAdapter()),
196 hackOutputCalledBefore_(false),
198 outputNodeSingle_(true),
201 specifiedSource_(
""),
217 pts_per_summary_Given(false),
226 totalOutputNoise_(0.0),
227 totalInputNoise_(0.0),
228 totalOutputNoiseDens_(0.0),
229 totalInputNoiseDens_(0.0)
259 for (
int i=0;i<size;++i)
300 for (Util::ParamList::const_iterator it = paramsBlock.begin(),
301 end = paramsBlock.end(); it != end; ++it)
303 if ((*it).uTag() ==
"V")
305 if ((*it).getImmutableValue<
double>()==1.0)
308 Util::ParamList::const_iterator itNode = it;
312 else if ((*it).getImmutableValue<
double>()==2.0)
315 Util::ParamList::const_iterator itNode = it;
322 else if ((*it).uTag() ==
"SOURCE")
326 else if ((*it).uTag() ==
"TYPE")
328 type_ = (*it).stringValue();
330 else if ((*it).uTag() ==
"NP")
332 np_ = (*it).getImmutableValue<
double>();
334 else if ((*it).uTag() ==
"FSTART")
336 fStart_ = (*it).getImmutableValue<
double>();
338 else if ((*it).uTag() ==
"FSTOP")
340 fStop_ = (*it).getImmutableValue<
double>();
342 else if ((*it).uTag() ==
"PTS_PER_SUMMARY")
348 if (DEBUG_ANALYSIS && isActive(Diag::TIME_PARAMETERS))
350 dout() << section_divider << std::endl
351 <<
"NOISE simulation parameters"
356 dout() <<
"Output Node: V(" <<
outputNode1_ <<
")" <<std::endl;
364 <<
"number of points = " <<
np_ << std::endl
365 <<
"starting frequency = " <<
fStart_ << std::endl
366 <<
"stop frequency = " <<
fStop_ << std::endl
410 bool bsuccess =
true;
421 static_cast<Xyce::Util::Notifier<AnalysisEvent> &
>(
analysisManager_).publish
458 Report::UserError() <<
"Solving for DC operating point failed! Cannot continue NOISE analysis";
486 static_cast<Xyce::Util::Notifier<AnalysisEvent> &
>(
analysisManager_).publish
560 if (DEBUG_TIME && isActive(Diag::TIME_PARAMETERS))
562 Xyce::dout() <<
"dQdxMatrixPtr:" << std::endl;
565 Xyce::dout() <<
"dFdxMatrixPtr:" << std::endl;
568 Xyce::dout() << std::endl;
574 static_cast<Xyce::Util::Notifier<AnalysisEvent> &
>(
analysisManager_).publish
579 for (
int i=0;i<numNoiseDevices;++i)
587 for (
int i=0;i<numNoiseDevices;++i)
590 for (
int j=0;j<numNoiseThisDevice;++j)
604 N_PDS_Comm & comm = *(pds_manager.getPDSComm());
605 int myPID = comm.procID();
609 for (
int currentStep = 0; currentStep <
noiseLoopSize_; ++currentStep)
616 static_cast<Xyce::Util::Notifier<AnalysisEvent> &
>(
analysisManager_).publish
619 bool stepAttemptStatus;
621 Stats::StatTop _nonlinearStat(
"Nonlinear Solve");
622 Stats::TimeBlock _nonlinearTimer(_nonlinearStat);
632 Linear::Vector & Xreal =
X_->block( 0 );
633 Linear::Vector & Ximag =
X_->block( 1 );
650 Xyce::Parallel::AllReduce(comm.comm(), MPI_MAX, &root, 1);
651 comm.bcast( &v1r, 1, root );
652 comm.bcast( &v1i, 1, root );
664 Xyce::Parallel::AllReduce(comm.comm(), MPI_MAX, &root, 1);
665 comm.bcast( &v2r, 1, root );
666 comm.bcast( &v2i, 1, root );
670 double realVal = v1r-v2r;
671 double imagVal = v1i-v2i;
679 for (
int j=0;j<numNoiseThisDevice;++j)
697 if (currentStep != 0)
702 for (
int j=0;j<numNoiseThisDevice;++j)
708 double tempOutNoise =
noiseIntegral( noizDens, lnDens, lnlastDens,
728 if (stepAttemptStatus)
730 static_cast<Xyce::Util::Notifier<AnalysisEvent> &
>(
analysisManager_).publish
736 static_cast<Xyce::Util::Notifier<AnalysisEvent> &
>(
analysisManager_).publish
747 Xyce::lout() <<
"Total Output Noise = " << totalOutputNoise_ <<std::endl;
748 Xyce::lout() <<
"Total Input Noise = " << totalInputNoise_ <<std::endl;
750 static_cast<Xyce::Util::Notifier<AnalysisEvent> &
>(
analysisManager_).publish
766 bool bsuccess =
true;
770 RCP<N_PDS_ParMap> baseMap = rcp(pds_manager.getParallelMap( Parallel::SOLUTION ),
false);
771 Epetra_CrsGraph &baseFullGraph = *pds_manager.getMatrixGraph(Parallel::JACOBIAN);
775 RCP<N_PDS_ParMap> blockMap = Linear::createBlockParMap(numBlocks, *baseMap);
779 B_ =
new Linear::BlockVector(numBlocks, blockMap, baseMap);
785 std::vector<std::vector<int> > blockPattern(2);
786 blockPattern[0].resize(2);
787 blockPattern[0][0] = 0; blockPattern[0][1] = 1;
788 blockPattern[1].resize(2);
789 blockPattern[1][0] = 0; blockPattern[1][1] = 1;
791 int offset = Linear::generateOffset( *baseMap );
793 RCP<Epetra_CrsGraph> blockGraph = Linear::createBlockGraph( offset, blockPattern, *blockMap, baseFullGraph);
796 ACMatrix_ =
new Linear::BlockMatrix( numBlocks, offset, blockPattern, *blockGraph, baseFullGraph);
805 B_->putScalar( 0.0 );
809 Amesos amesosFactory;
812 X_ =
new Linear::BlockVector (numBlocks, blockMap, baseMap);
813 X_->putScalar( 0.0 );
816 saved_AC_X_ =
new Linear::BlockVector (numBlocks, blockMap, baseMap);
823 blockSolver_ = amesosFactory.Create(
"Klu", *
blockProblem_ );
826 Teuchos::ParameterList params;
827 params.set(
"Reindex",
true );
828 blockSolver_->SetParameters( params );
832 int linearStatus = blockSolver_->SymbolicFactorization();
833 if (linearStatus != 0)
835 Xyce::dout() <<
"Amesos symbolic factorization exited with error: " << linearStatus;
870 B_->putScalar( 0.0 );
875 X_->putScalar( 0.0 );
890 bool bsuccess =
true;
893 int linearStatus =
blockSolver_->SymbolicFactorization();
894 if (linearStatus != 0)
896 Xyce::dout() <<
"Amesos symbolic factorization exited with error: " << linearStatus;
901 if (linearStatus != 0)
903 Xyce::dout() <<
"Amesos numeric factorization exited with error: " << linearStatus;
908 if (linearStatus != 0)
910 Xyce::dout() <<
"Amesos solve exited with error: " << linearStatus;
941 bool foundLocal(
false);
942 bool foundLocal2(
false);
945 N_PDS_Comm & comm = *(pds_manager.getPDSComm());
946 int myPID = comm.procID();
949 for (
int iout = 0; iout < numOutVars; ++iout)
951 std::vector<int> svGIDList1, dummyList;
954 svGIDList1, dummyList, type1);
956 found =
static_cast<int>(foundLocal);
957 Xyce::Parallel::AllReduce(comm.comm(), MPI_LOR, &found, 1);
963 svGIDList1, dummyList, type1);
965 found2 =
static_cast<int>(foundLocal2);
966 Xyce::Parallel::AllReduce(comm.comm(), MPI_LOR, &found2, 1);
968 if (!found && !found2)
970 Report::UserError() <<
"Output function variable " <<
outputVarNames_[iout] <<
" not found";
976 if(svGIDList1.size()==1)
978 tmpGID = svGIDList1.front();
995 bool bsuccess =
true;
1041 N_PDS_Comm & comm = *(pds_manager.getPDSComm());
1042 int myPID = comm.procID();
1049 for (
int iout=0;iout<numOutVars;++iout)
1055 if (iout>0) val=-1.0;
1077 B_->putScalar( 0.0 );
1083 Xyce::dout()<<
"adjoint noise B vector:"<<std::endl;
1084 B_->printPetraObject(Xyce::dout());
1097 Xyce::dout()<<
"matrix:"<<std::endl;
1098 ACMatrix_->printPetraObject(Xyce::dout());
1113 bool bsuccess =
true;
1116 int linearStatus =
blockSolver_->SymbolicFactorization();
1117 if (linearStatus != 0)
1119 Xyce::dout() <<
"Amesos symbolic factorization exited with error: " << linearStatus;
1124 if (linearStatus != 0)
1126 Xyce::dout() <<
"Amesos numeric factorization exited with error: " << linearStatus;
1131 if (linearStatus != 0)
1133 Xyce::dout() <<
"Amesos solve exited with error: " << linearStatus;
1140 for (
int i=0;i<numNoiseDevices;++i)
1148 std::vector< Teuchos::RCP<Linear::Vector> > outputVectors;
1149 outputVectors.push_back( rcp(
linearSystem_.builder().createVector()) );
1150 outputVectors.push_back( rcp(
linearSystem_.builder().createVector()) );
1152 copyFromBlockVector( *
X_, outputVectors );
1153 Linear::Vector & Xreal = *(outputVectors[0]);
1154 Linear::Vector & Ximag = *(outputVectors[1]);
1157 std::cout <<
"Xreal: ------------------------------------"<<std::endl;
1158 Xreal.printPetraObject( Xyce::dout() );
1159 std::cout <<
"Ximag: ------------------------------------"<<std::endl;
1160 Ximag.printPetraObject( Xyce::dout() );
1164 N_PDS_Comm & comm = *(pds_manager.getPDSComm());
1165 int myPID = comm.procID();
1169 for (
int i=0;i<numNoiseDevices;++i)
1175 for (
int j=0;j<numNoiseThisDevice;++j)
1180 double realVal = Xreal[li_Pos] - Xreal[li_Neg];
1181 double imagVal = Ximag[li_Pos] - Ximag[li_Neg];
1182 double gain = (realVal*realVal) + (imagVal*imagVal);
1189 std::cout << std::left <<
"noise: " << std::setw(20)<< namestring <<std::right <<
":";
1190 std::cout.setf(std::ios::scientific);
1191 std::cout <<
" li_Pos="<<li_Pos<<
" li_Neg="<<li_Neg
1192 <<
" gain="<<gain<<
" noiseDens="<<
noiseDataVec_[i]->noiseDens[j]
1193 <<
" onoise="<<
noiseDataVec_[i]->outputNoiseDens[j] <<std::endl;
1203 std::cout << std::endl;
1212 if (comm.isSerial() )
1234 std::ofstream output_stream(fileName.c_str(),
1240 output_stream <<
"TITLE=\"noise output\"\tVARIABLES=\"frequency\" "<<std::endl;
1241 output_stream <<
"\t\"Re(V(" <<
outputNode1_ <<
"))\""<<std::endl;
1242 output_stream <<
"\t\"Im(V(" <<
outputNode1_ <<
"))\""<<std::endl;
1246 output_stream <<
"\t\"Re(V(" <<
outputNode2_ <<
"))\""<<std::endl;
1247 output_stream <<
"\t\"Im(V(" <<
outputNode2_ <<
"))\""<<std::endl;
1249 output_stream <<
"\t\"onoise_spectrum \""<<std::endl;
1250 output_stream <<
"\t\"inoise_spectrum \""<<std::endl;
1254 for (
int i=0;i<numNoiseDevices;++i)
1257 for (
int j=0;j<numNoiseThisDevice;++j)
1260 std::transform(namestring.begin(), namestring.end(), namestring.begin(), ::tolower);
1261 output_stream <<
"\t\"" << namestring <<
"\"";
1265 if (numNoiseThisDevice > 1)
1267 std::string totalOutputNoiseName =
"onoise_" +
noiseDataVec_[i]->deviceName;
1269 std::transform(totalOutputNoiseName.begin(), totalOutputNoiseName.end(), totalOutputNoiseName.begin(), ::tolower);
1271 output_stream <<
"\t\""<<totalOutputNoiseName<<
"\"";
1276 output_stream << std::endl;
1277 output_stream <<
"ZONE F=POINT T=\"Xyce data\""<<std::endl;
1282 output_stream.setf(std::ios::scientific);
1290 output_stream <<
currentFreq_ <<
"\t" << v1r <<
"\t" << v1i;
1298 output_stream <<
"\t" << v2r <<
"\t" << v2i;
1305 for (
int i=0;i<numNoiseDevices;++i)
1308 for (
int j=0;j<numNoiseThisDevice;++j)
1310 output_stream <<
"\t" <<
noiseDataVec_[i]->outputNoiseDens[j];
1313 if (numNoiseThisDevice > 1)
1315 output_stream <<
"\t" <<
noiseDataVec_[i]->totalOutputNoise;
1320 output_stream << std::endl;
1343 double delLnFreq,
double delFreq,
double lnFreq,
double lnLastFreq)
1348 exponent = (lnNdens - lnNlstDens) / delLnFreq;
1351 return (noizDens * delFreq);
1354 a = std::exp(lnNdens - exponent*lnFreq);
1358 return (a * (lnFreq - lnLastFreq));
1362 return (a * ((std::exp(exponent * lnFreq) - std::exp(exponent * lnLastFreq)) /
1378 bool bsuccess =
true;
1411 bool bsuccess =
true;
1431 bool bsuccess =
true;
1435 Xyce::dout() <<
"Calling NOISE::doFinish() outputs!" << std::endl;
1499 Report::DevelFatal().in(
"NOISE::updateCurrentFreq_")
1500 <<
"NOISE::updateCurrentFreq_: unsupported STEP type";
1522 double fstart, fstop;
1523 double fcount = 0.0;
1528 if (DEBUG_ANALYSIS && isActive(Diag::TIME_PARAMETERS))
1530 Xyce::dout() << std::endl << std::endl;
1531 Xyce::dout() << section_divider << std::endl;
1532 Xyce::dout() <<
"NOISE::setupSweepParam_" << std::endl;
1537 int np =
static_cast<int>(
np_);
1545 if (DEBUG_ANALYSIS && isActive(Diag::TIME_PARAMETERS))
1547 Xyce::dout() <<
"fstep = " <<
fstep_ << std::endl;
1550 else if (
type_ ==
"DEC")
1553 fcount = floor(fabs(std::log10(fstart) - std::log10(fstop)) *
np_ + 1.0);
1554 if (DEBUG_ANALYSIS && isActive(Diag::TIME_PARAMETERS))
1556 Xyce::dout() <<
"stepMult_ = " <<
stepMult_ << std::endl;
1559 else if (
type_ ==
"OCT")
1566 double ln2 = std::log(2.0);
1567 fcount = floor(fabs(std::log(fstart) - std::log(fstop))/ln2 *
np_ + 1.0);
1568 if (DEBUG_ANALYSIS && isActive(Diag::TIME_PARAMETERS))
1570 Xyce::dout() <<
"stepMult_ = " <<
stepMult_ << std::endl;
1575 Report::DevelFatal().in(
"NOISE::setupSweepParam") <<
"Unsupported type";
1580 return static_cast<int> (fcount);
1585 typedef Util::Factory<AnalysisBase, NOISE> NOISEFactoryBase;
1598 class NOISEFactory :
public NOISEFactoryBase
1626 Linear::System & linear_system,
1629 Topo::Topology & topology,
1630 IO::InitialConditionsManager & initial_conditions_manager)
1631 : NOISEFactoryBase(),
1640 virtual ~NOISEFactory()
1656 NOISE *create()
const
1681 void setNOISEAnalysisOptionBlock(
const Util::OptionBlock &option_block)
1701 bool setTimeIntegratorOptionBlock(
const Util::OptionBlock &option_block)
1722 struct NOISEAnalysisReg :
public IO::PkgOptionsReg
1725 NOISEFactory & factory )
1729 bool operator()(
const Util::OptionBlock &option_block)
1731 factory_.setNOISEAnalysisOptionBlock(option_block);
1757 IO::PkgOptionsMgr & options_manager,
1758 IO::CircuitBlock & circuit_block,
1759 const std::string & netlist_filename,
1760 const IO::TokenVector & parsed_line)
1762 Util::OptionBlock option_block(
"NOISE", Util::OptionBlock::NO_EXPRESSIONS, netlist_filename, parsed_line[0].lineNumber_);
1764 int numFields = parsed_line.size();
1769 Report::UserError0().at(netlist_filename, parsed_line[0].lineNumber_)
1770 <<
".NOISE line has an unexpected number of fields. NumFields = " << numFields;
1774 int linePosition = 1;
1776 Util::Param parameter(
"",
"");
1779 ExtendedString stringVal(
"");
1780 std::ostringstream msg;
1782 if( parsed_line[linePosition].string_ ==
"V" || parsed_line[linePosition].string_ ==
"v")
1784 if( parsed_line[linePosition+3].string_ ==
")" )
1786 stringVal = parsed_line[linePosition].string_;
1787 stringVal.toUpper();
1788 parameter.setTag(stringVal);
1789 parameter.setVal( 1.0 );
1790 option_block.addParam( parameter );
1792 stringVal = parsed_line[linePosition+2].string_;
1793 stringVal.toUpper();
1794 parameter.setTag( stringVal );
1795 parameter.setVal( 0.0 );
1796 option_block.addParam( parameter );
1800 else if( parsed_line[linePosition+5].string_ ==
")" )
1802 stringVal = parsed_line[linePosition].string_;
1803 stringVal.toUpper();
1804 parameter.setTag(stringVal);
1805 parameter.setVal( 2.0 );
1806 option_block.addParam( parameter );
1808 stringVal = parsed_line[linePosition+2].string_;
1809 stringVal.toUpper();
1810 parameter.setTag( stringVal );
1811 parameter.setVal( 0.0 );
1812 option_block.addParam( parameter );
1814 stringVal = parsed_line[linePosition+4].string_;
1815 stringVal.toUpper();
1816 parameter.setTag( stringVal );
1817 parameter.setVal( 0.0 );
1818 option_block.addParam( parameter );
1824 msg <<
"Unrecognized parenthetical specification for NOISE output ";
1825 p_err = linePosition;
1830 msg <<
"Incorrect format for NOISE output.";
1831 p_err = linePosition;
1835 stringVal = parsed_line[linePosition].string_;
1836 stringVal.toUpper();
1837 parameter.setTag(
"SOURCE" );
1838 parameter.setVal(std::string(stringVal));
1839 option_block.addParam( parameter );
1841 std::cout <<
"Source is at linePosition="<<linePosition<<
" source="<<stringVal<<std::endl;
1846 stringVal = parsed_line[linePosition].string_;
1847 stringVal.toUpper();
1848 parameter.setTag(
"TYPE" );
1849 parameter.setVal(std::string(stringVal));
1850 option_block.addParam( parameter );
1852 std::cout <<
"Type is at linePosition="<<linePosition<<
" type="<<stringVal<<std::endl;
1857 parameter.setTag(
"NP" );
1858 parameter.setVal( parsed_line[linePosition].string_ );
1859 option_block.addParam( parameter );
1861 std::cout <<
"NP is at linePosition="<<linePosition<<
" np="
1862 << parsed_line[linePosition].string_ <<std::endl;
1867 parameter.setTag(
"FSTART" );
1868 parameter.setVal( parsed_line[linePosition].string_ );
1869 option_block.addParam( parameter );
1871 std::cout <<
"fstart is at linePosition="<<linePosition<<
" fstart="
1872 << parsed_line[linePosition].string_ <<std::endl;
1878 parameter.setTag(
"FSTOP" );
1879 parameter.setVal( parsed_line[linePosition].string_ );
1880 option_block.addParam( parameter );
1882 std::cout <<
"fstop is at linePosition="<<linePosition<<
" fstop="
1883 << parsed_line[linePosition].string_ <<std::endl;
1887 parameter.setTag(
"PTS_PER_SUMMARY" );
1888 if (numFields >= 11)
1892 parameter.setVal( parsed_line[linePosition].string_ );
1895 std::cout <<
"pts_per_summary is at linePosition="<<linePosition<<
" pts_per_summary="
1896 << parsed_line[linePosition].string_ <<std::endl;
1901 parameter.setVal( std::string(
"-1") );
1903 std::cout <<
"pts_per_summary was not specified. It is set to: pts_per_summary=-1" <<std::endl;
1906 option_block.addParam( parameter );
1908 circuit_block.addOptions(option_block);
1927 factory_block.
optionsManager_.addCommandParser(
".NOISE", extractNOISEData);
1929 factory_block.
optionsManager_.addCommandProcessor(
"NOISE",
new NOISEAnalysisReg(*factory));
1931 factory_block.
optionsManager_.addOptionsProcessor(
"TIMEINT", IO::createRegistrationOptions<NOISEFactory>(*factory, &NOISEFactory::setTimeIntegratorOptionBlock));
Util::OptionBlock noiseAnalysisOptionBlock_
Linear::Vector * lastSolutionPtr
bool doProcessSuccessfulStep()
IO::PkgOptionsMgr & optionsManager_
unsigned int successStepsThisParameter_
unsigned int successfulStepsTaken_
Number of consecutive successful time-integration steps.
std::vector< double > dOdpVec_
int newtonConvergenceStatus
virtual bool setInitialGuess(Linear::Vector *solVectorPtr)
Nonlinear::Manager & nonlinearManager_
Linear::Vector * lastLeadDeltaVPtr
Nonlinear::Manager & nonlinearManager_
std::vector< double > scaled_dOdpAdjVec_
bool setTimeIntegratorOption(const Util::Param ¶m)
double totalInputNoiseDens_
TimeIntg::TIAParams tiaParams_
Linear::System & linearSystem_
void outputAC(double freq, const Linear::Vector &solnVecRealPtr, const Linear::Vector &solnVecImaginaryPtr)
void evaluateStepError(const Loader::Loader &loader, const TIAParams &tia_params)
Pure virtual class to augment a linear system.
double totalOutputNoiseDens_
virtual bool loadDAEVectors(Linear::Vector *nextSolVectorPtr, Linear::Vector *currSolVectorPtr, Linear::Vector *lastSolVectorPtr, Linear::Vector *nextStaVectorPtr, Linear::Vector *currStaVectorPtr, Linear::Vector *lastStaVectorPtr, Linear::Vector *StaDerivVectorPtr, Linear::Vector *nextStoVectorPtr, Linear::Vector *currStoVectorPtr, Linear::Vector *lastStoVectorPtr, Linear::Vector *stoLeadCurrQVectorPtr, Linear::Vector *nextLeadFVectorPtr, Linear::Vector *currLeadFVectorPtr, Linear::Vector *lastLeadFVectorPtr, Linear::Vector *nextLeadQVectorPtr, Linear::Vector *nextJunctionVVectorPtr, Linear::Vector *currJunctionVVectorPtr, Linear::Vector *lastJunctionVVectorPtr, Linear::Vector *QVectorPtr, Linear::Vector *FVectorPtr, Linear::Vector *BVectorPtr, Linear::Vector *dFdxdVpVectorPtr, Linear::Vector *dQdxdVpVectorPtr)
virtual bool outputPlotFiles() const
bool resetForStepAnalysis()
virtual int getNumNoiseDevices()
unsigned int stepNumber
Time-integration step number counter.
virtual bool loadBVectorsforAC(Linear::Vector *bVecRealPtr, Linear::Vector *bVecImagPtr)
Linear::Vector * bNoiseVecImagPtr
Linear::Vector * currStorePtr
Linear::Vector * lastStatePtr
Epetra_LinearProblem * blockProblem_
void gatherStepStatistics(StatCounts &stats, Nonlinear::NonLinearSolver &nonlinear_solver, int newton_convergence_status)
Topo::Topology & topology_
void createTimeIntegratorMethod(const TimeIntg::TIAParams &tia_params, const unsigned int integration_method)
Linear::BlockVector * saved_AC_X_
std::vector< double > objectiveVec_
bool resetAll(const TIAParams &tia_params)
std::string specifiedSource_
std::vector< int > noiseSweepFailures_
NOISE(AnalysisManager &analysis_manager, Linear::System &linear_system, Nonlinear::Manager &nonlinear_manager, Loader::Loader &loader, Topo::Topology &topology, IO::InitialConditionsManager &initial_conditions_manager)
Linear::Vector * bVecImagPtr
Util::ListenerAutoSubscribe< StepEvent > StepEventListener
Linear::Vector * nextLeadDeltaVPtr
Linear::Vector * currStatePtr
unsigned int failedStepsAttempted_
Total number of failed time-integration steps.
void obtainCorrectorDeriv()
Parallel::Manager * getPDSManager() const
bool setDCOPOption(const Util::Param ¶m)
TimeIntg::StepErrorControl & getStepErrorControl()
bool getBeginningIntegrationFlag() const
const std::string & getNetlistFilename() const
void computeDividedDifferences()
NonLinearSolver & getNonlinearSolver()
Linear::BlockMatrix * ACMatrix_
Linear::Vector * daeQVectorPtr
void setConstantHistory()
AnalysisManager & analysisManager_
AnalysisManager & analysisManager_
Linear::Vector * lastLeadCurrentPtr
virtual bool startTimeStep(bool beginIntegrationFlag, double nextTimeStep, double nextTime, int currentOrder)
void setErrorWtVector(const TIAParams &tia_params)
virtual bool isPDESystem() const
IO::InitialConditionsManager & initialConditionsManager_
Linear::Vector * daeFVectorPtr
void processOutputNodes()
bool hackOutputCalledBefore_
The FactoryBlock contains parameters needed by the analysis creation functions.
Linear::System & linearSystem_
IO::InitialConditionsManager & initialConditionsManager_
Linear::Matrix * dFdxMatrixPtr
virtual bool updateSources()
Linear::Vector * nextStatePtr
bool solveACLinearSystem_()
AnalysisManager & analysisManager_
Linear::Vector * dFdxdVpVectorPtr
bool updateCurrentFreq_(int stepNumber)
virtual bool loadDAEMatrices(Linear::Vector *tmpSolVectorPtr, Linear::Vector *tmpStaVectorPtr, Linear::Vector *tmpStaDerivVectorPtr, Linear::Vector *tmpStoVectorPtr, Linear::Matrix *tmpdQdxMatrixPtr, Linear::Matrix *tmpdFdxMatrixPtr)
virtual bool updateState(Linear::Vector *nextSolVectorPtr, Linear::Vector *currSolVectorPtr, Linear::Vector *lastSolVectorPtr, Linear::Vector *nextStaVectorPtr, Linear::Vector *currStaVectorPtr, Linear::Vector *lastStaVectorPtr, Linear::Vector *nextStoVectorPtr, Linear::Vector *currStoVectorPtr, Linear::Vector *lastStoVectorPtr)
Linear::Vector * currLeadDeltaVPtr
void setDoubleDCOPEnabled(bool enable)
int numberSuccessiveFailures
Linear::Vector * bNoiseVecRealPtr
bool solveAdjointNOISE_()
Nonlinear::Manager & nonlinearManager_
std::vector< Xyce::Analysis::NoiseData * > noiseDataVec_
bool registerNOISEFactory(FactoryBlock &factory_block)
virtual void getNoiseSources(std::vector< Xyce::Analysis::NoiseData * > &noiseDataVec)
Linear::Vector * nextSolutionPtr
bool resetACLinearSystem_()
std::vector< double > scaled_dOdpVec_
void dcOutput(int dcStepNumber, Linear::Vector &currSolutionPtr, Linear::Vector &stateVecPtr, Linear::Vector &storeVecPtr, Linear::Vector &lead_current_vector, Linear::Vector &junction_voltage_vector, Linear::Vector &lead_current_dqdt_vector, std::vector< double > &objectiveVec_, std::vector< double > &dOdpVec_, std::vector< double > &dOdpAdjVec_, std::vector< double > &scaled_dOdpVec_, std::vector< double > &scaled_dOdpAdjVec_)
Topo::Topology & topology_
void notify(const StepEvent &event)
virtual void setupNoiseSources(std::vector< Xyce::Analysis::NoiseData * > &noiseDataVec)
Linear::Vector * nextStorePtr
bool setTimeIntegratorOptions(const Util::OptionBlock &option_block)
bool createACLinearSystem_()
void addAnalysisFactory(FactoryBlock &factory_block, Util::Factory< AnalysisBase, void > *factory)
Amesos_BaseSolver * blockSolver_
Linear::Vector * dQdxdVpVectorPtr
Linear::Vector * bVecRealPtr
Topo::Topology & topology_
std::vector< std::string > outputVarNames_
Linear::Vector * currLeadCurrentPtr
Linear::Vector * lastStorePtr
void setInputOPFlag(bool initial_conditions_loaded)
TimeIntg::WorkingIntegrationMethod & getWorkingIntegrationMethod()
const IO::CmdParse & getCommandLine() const
void obtainPredictorDeriv()
std::vector< int > outputVarGIDs_
bool setAnalysisParams(const Util::OptionBlock ¶msBlock)
OutputMgrAdapter & outputManagerAdapter_
Linear::Vector * nextLeadCurrentQDerivPtr
int getIntegrationMethod() const
Linear::Vector * currSolutionPtr
bool firstDoubleDCOPStep() const
TimeIntg::DataStore * getDataStore()
bool doProcessFailedStep()
unsigned int baseIntegrationMethod_
Current time-integration method flag.
Parallel::Machine getComm()
void resetAdjointNOISELinearSystem_()
Linear::Vector * nextStoreLeadCurrQPtr
Util::OptionBlock timeIntegratorOptionBlock_
Linear::Vector * nextStateDerivPtr
void outputNoise(double freq, double totalOutputNoiseDens_, double totalInputNoiseDens_, const std::vector< Xyce::Analysis::NoiseData * > &noiseDataVec_)
double noiseIntegral(double noizDens, double lnNdens, double lnNlstDens, double delLnFreq, double delFreq, double lnFreq, double lnLastFreq)
Linear::Matrix * dQdxMatrixPtr
Linear::Vector * flagSolutionPtr
std::vector< double > dOdpAdjVec_
Linear::Vector * daeBVectorPtr
IO::InitialConditionsManager & initialConditionsManager_
bool setReturnCodeOption(const Util::Param ¶m)
Linear::System & linearSystem_
Linear::Vector * nextLeadCurrentPtr