/* The function evaluates the state of the integration-using component
and runs the appropriate integrator function. */
void integrator::integrate (int qstate, nr_double_t cap, nr_double_t& geq,
nr_double_t& ceq) {
int cstate = qstate + 1;
if (state & MODE_INIT) fillState (qstate, getState (qstate));
(*integrate_func) (this, qstate, cap, geq, ceq);
if (state & MODE_INIT) fillState (cstate, getState (cstate));
}
void ResourceSkin::addInfo(const SubWidgetBinding& _bind)
{
checkState(_bind.mStates);
mBasis.push_back(SubWidgetInfo(_bind.mType, _bind.mOffset, _bind.mAlign));
checkBasis();
fillState(_bind.mStates, mBasis.size() - 1);
}
/* Goes through the list of circuit objects and runs its initTR()
function. */
void e_trsolver::initETR (nr_double_t start, nr_double_t firstdelta, int mode)
{
const char * const IMethod = getPropertyString ("IntegrationMethod");
//nr_double_t start = getPropertyDouble ("Start");
//nr_double_t stop = start + firstdelta;
//nr_double_t points = 1.0;
// fetch corrector integration method and determine predicor method
corrMaxOrder = getPropertyInteger ("Order");
corrType = CMethod = correctorType (IMethod, corrMaxOrder);
predType = PMethod = predictorType (CMethod, corrMaxOrder, predMaxOrder);
corrOrder = corrMaxOrder;
predOrder = predMaxOrder;
// initialize step values
if (mode == ETR_MODE_ASYNC){
delta = getPropertyDouble ("InitialStep");
deltaMin = getPropertyDouble ("MinStep");
deltaMax = getPropertyDouble ("MaxStep");
if (deltaMax == 0.0)
deltaMax = firstdelta; // MIN ((stop - start) / (points - 1), stop / 200);
if (deltaMin == 0.0)
deltaMin = NR_TINY * 10 * deltaMax;
if (delta == 0.0)
delta = firstdelta; // MIN (stop / 200, deltaMax) / 10;
if (delta < deltaMin) delta = deltaMin;
if (delta > deltaMax) delta = deltaMax;
}
else if (mode == ETR_MODE_SYNC)
{
delta = firstdelta;
deltaMin = NR_TINY * 10;
deltaMax = std::numeric_limits<nr_double_t>::max() / 10;
}
// initialize step history
setStates (2);
initStates ();
// initialise the history of states, setting them all to 'delta'
fillState (dState, delta);
// copy the initialised states to the 'deltas' array
saveState (dState, deltas);
// copy the deltas to all the circuits
setDelta ();
// set the initial corrector and predictor coefficients
calcCorrectorCoeff (corrType, corrOrder, corrCoeff, deltas);
calcPredictorCoeff (predType, predOrder, predCoeff, deltas);
// initialize history of solution vectors (solutions)
for (int i = 0; i < 8; i++)
{
// solution contains the last sets of node voltages and branch
// currents at each of the last 8 'deltas'.
// Note for convenience the definition:
// #define SOL(state) (solution[(int) getState (sState, (state))])
// is provided and used elsewhere to update the solutions
solution[i] = new tvector<nr_double_t>;
setState (sState, (nr_double_t) i, i);
lastsolution[i] = new tvector<nr_double_t>;
}
// Initialise history tracking for asynchronous solvers
// See acceptstep_async and rejectstep_async for more
// information
lastasynctime = start;
saveState (dState, lastdeltas);
lastdelta = delta;
// tell circuit elements about the transient analysis
circuit *c, * root = subnet->getRoot ();
for (c = root; c != NULL; c = (circuit *) c->getNext ())
initCircuitTR (c);
// also initialize the created circuit elements
for (c = root; c != NULL; c = (circuit *) c->getPrev ())
initCircuitTR (c);
}
/* This is the initialisation function for the slaved transient
netlist solver. It prepares the circuit for simulation. */
int e_trsolver::init (nr_double_t start, nr_double_t firstdelta, int mode)
{
// run the equation solver for the netlist
this->getEnv()->runSolver();
int error = 0;
const char * const solver = getPropertyString ("Solver");
relaxTSR = !strcmp (getPropertyString ("relaxTSR"), "yes") ? true : false;
initialDC = !strcmp (getPropertyString ("initialDC"), "yes") ? true : false;
// fetch simulation properties
MaxIterations = getPropertyInteger ("MaxIter");
reltol = getPropertyDouble ("reltol");
abstol = getPropertyDouble ("abstol");
vntol = getPropertyDouble ("vntol");
runs++;
saveCurrent = current = 0;
stepDelta = -1;
converged = 0;
fixpoint = 0;
lastsynctime = 0.0;
statRejected = statSteps = statIterations = statConvergence = 0;
// Choose a solver.
if (!strcmp (solver, "CroutLU"))
eqnAlgo = ALGO_LU_DECOMPOSITION;
else if (!strcmp (solver, "DoolittleLU"))
eqnAlgo = ALGO_LU_DECOMPOSITION_DOOLITTLE;
else if (!strcmp (solver, "HouseholderQR"))
eqnAlgo = ALGO_QR_DECOMPOSITION;
else if (!strcmp (solver, "HouseholderLQ"))
eqnAlgo = ALGO_QR_DECOMPOSITION_LS;
else if (!strcmp (solver, "GolubSVD"))
eqnAlgo = ALGO_SV_DECOMPOSITION;
// Perform initial DC analysis.
if (initialDC)
{
error = dcAnalysis ();
if (error)
return -1;
}
// Initialize transient analysis.
setDescription ("transient");
initETR (start, firstdelta, mode);
setCalculation ((calculate_func_t) &calcTR);
solve_pre ();
// Recall the DC solution.
recallSolution ();
// Apply the nodesets and adjust previous solutions.
applyNodeset (false);
fillSolution (x);
fillLastSolution (x);
// Tell integrators to be initialized.
setMode (MODE_INIT);
// reset the circuit status to not running so the histories
// etc will be reinitialised on the first time step
running = 0;
rejected = 0;
if (mode == ETR_MODE_ASYNC)
{
delta /= 10;
}
else if (mode == ETR_MODE_SYNC)
{
//lastsynctime = start - delta;
}
else
{
qucs::exception * e = new qucs::exception (EXCEPTION_UNKNOWN_ETR_MODE);
e->setText ("Unknown ETR mode.");
throw_exception (e);
return -2;
}
fillState (dState, delta);
adjustOrder (1);
storeHistoryAges ();
return 0;
}