public static SampleValue MassCompileSample(Symbol outSymbol, SampleValue inSample, Netlist netlist, Style style)
{
//inSample.Consume(null, 0, null, netlist, style); // this prevents simulating a sample and its massaction version in succession
List <ReactionValue> inReactions = inSample.RelevantReactions(netlist, style);
CRN inCrn = new CRN(inSample, inReactions);
Gui.Log(Environment.NewLine + inCrn.FormatNice(style));
(Lst <Polynomize.ODE> odes, Lst <Polynomize.Equation> eqs) = Polynomize.FromCRN(inCrn);
(Lst <Polynomize.PolyODE> polyOdes, Lst <Polynomize.Equation> polyEqs) = Polynomize.PolynomizeODEs(odes, eqs.Reverse(), style);
Gui.Log("Polynomize:" + Environment.NewLine + Polynomize.PolyODE.Format(polyOdes, style)
+ "Initial:" + Environment.NewLine + Polynomize.Equation.Format(polyEqs, style));
(Lst <Polynomize.PolyODE> posOdes, Lst <Polynomize.Equation> posEqs, Dictionary <Symbol, SpeciesFlow> dict, Lst <Positivize.Subst> substs) = Positivize.PositivizeODEs(polyOdes, polyEqs, style);
Gui.Log("Positivize:" + Environment.NewLine + Polynomize.PolyODE.Format(posOdes, style)
+ "Initial:" + Environment.NewLine + Polynomize.Equation.Format(posEqs, style));
Lst <ReactionValue> outReactions = Hungarize.ToReactions(posOdes, style);
Gui.Log("Hungarize:" + Environment.NewLine + outReactions.FoldR((r, s) => { return(r.FormatNormal(style) + Environment.NewLine + s); }, "")
+ "Initial:" + Environment.NewLine + Polynomize.Equation.Format(posEqs, style));
SampleValue outSample = new SampleValue(outSymbol, new StateMap(outSymbol, new List <SpeciesValue> {
}, new State(0, lna: inSample.stateMap.state.lna)), new NumberValue(inSample.Volume()), new NumberValue(inSample.Temperature()), produced: true);
netlist.Emit(new SampleEntry(outSample));
posOdes.Each(ode => {
Flow initFlow = Polynomize.Equation.ToFlow(ode.var, posEqs, style).Normalize(style);
double init; if (initFlow is NumberFlow num)
{
init = num.value;
}
else
{
throw new Error("Cannot generate a simulatable sample because initial values contain constants (but the symbolic version has been generated assuming constants are nonnegative).");
}
if (init < 0)
{
throw new Error("Negative initial value of Polynomized ODE for: " + Polynomize.Lookup(ode.var, eqs, style).Format(style) + " = " + init + Environment.NewLine + Polynomize.Equation.Format(eqs, style));
}
outSample.stateMap.AddDimensionedSpecies(new SpeciesValue(ode.var.species, -1.0), init, 0.0, "M", outSample.Volume(), style);
});
outReactions.Each(reaction => { netlist.Emit(new ReactionEntry(reaction)); });
substs.Each(subst => { ReportEntry report = new ReportEntry(null, OpFlow.Op(subst.plus, "-", subst.minus), null, outSample); outSample.AddReport(report); });
foreach (KeyValuePair <Symbol, SpeciesFlow> keypair in dict)
{
ReportEntry report = new ReportEntry(null, keypair.Value, null, outSample); outSample.AddReport(report);
}
;
return(outSample);
}
Integrate(Func <double, double, Vector, Func <double, Vector, Vector>, IEnumerable <SolPoint> > Solver,
State initialState, double initialTime, double finalTime, Func <double, Vector, Vector> Flux,
SampleValue sample, List <ReportEntry> reports, Noise noise, bool nonTrivialSolution, Style style)
{
double redrawTick = initialTime; double redrawStep = (finalTime - initialTime) / 50;
double densityTick = initialTime; double densityStep = (finalTime - initialTime) / 1000;
int pointsCounter = 0;
int renderedCounter = 0;
double lastTime = finalTime;
State lastState = null;
if (initialState.NaN())
{
Gui.Log("Initial state contains NaN.");
return(lastTime, lastState);
}
KChartHandler.ChartClearData(style);
(string[] series, string[] seriesLNA) = GenerateSeries(reports, noise, style);
KChartHandler.LegendUpdate(style);
KScoreHandler.ScoreUpdate();
IEnumerable <SolPoint> solution = SolutionGererator(Solver, initialState, initialTime, finalTime, Flux, nonTrivialSolution, style);
List <TriggerEntry> triggers = sample.Triggers(style);
bool[] triggered = new bool[triggers.Count]; for (int i = 0; i < triggers.Count; i++)
{
triggered[i] = false;
}
// BEGIN foreach (SolPoint solPoint in solution) -- done by hand to catch exceptions in MoveNext()
SolPoint solPoint = new SolPoint(initialTime, initialState.Clone().ToArray());
bool hasSolPoint = false;
var enumerator = solution.GetEnumerator();
do
{
// Handle triggers first, they can apply to the initial state
if (triggers.Count > 0)
{
State state = null; // allocated on need from solPoint
State modifiedState = null; // allocated on need from state
for (int i = 0; i < triggers.Count; i++)
{
if (triggered[i] == false)
{
TriggerEntry trigger = triggers[i];
if (state == null)
{
state = new State(sample.Count(), lna: noise != Noise.None).InitAll(solPoint.X);
}
if (trigger.condition.ObserveBool(sample, solPoint.T, state, Flux, style))
{
if (modifiedState == null)
{
modifiedState = state.Clone();
}
double rawValue = trigger.assignment.ObserveMean(sample, solPoint.T, state, Flux, style);
double assignment = trigger.sample.stateMap.NormalizeDimension(trigger.target, rawValue, trigger.dimension, trigger.sample.Volume(), style);
int index = sample.stateMap.IndexOf(trigger.target.symbol);
modifiedState.SetMean(index, assignment);
if (noise != Noise.None && trigger.assignmentVariance != null)
{
double rawValueVariance = trigger.assignmentVariance.ObserveMean(sample, solPoint.T, state, Flux, style);
double assignmentVariance = trigger.sample.stateMap.NormalizeDimension(trigger.target, rawValueVariance, trigger.dimension, trigger.sample.Volume(), style);
modifiedState.SetCovar(index, index, assignmentVariance);
}
triggered[i] = true;
}
}
}
if (modifiedState != null) //restart the solver
{
State newState = modifiedState; // new State(sample.Count(), lna: noise != Noise.None).InitAll(modifiedState.ToArray());
solution = SolutionGererator(Solver, newState, solPoint.T, finalTime, Flux, nonTrivialSolution, style);
enumerator = solution.GetEnumerator();
}
}
try {
if (!enumerator.MoveNext())
{
break;
}
solPoint = enumerator.Current; // get next step of integration from solver
hasSolPoint = true;
}
catch (ConstantEvaluation e) { // stop simulation but allow execution to proceed
Gui.Log("Simulation stopped and ignored: cannot evaluate constant '" + e.Message + "'");
return(lastTime, lastState);
}
catch (Error e) { throw new Error(e.Message); }
catch (Exception e) { KChartHandler.ChartUpdate(style, false); throw new Error("ODE Solver FAILED: " + e.Message); }
pointsCounter++;
// LOOP BODY of foreach (SolPoint solPoint in solution):
if (!Exec.IsExecuting())
{
KChartHandler.ChartUpdate(style); throw new ExecutionEnded("");
} // break;
if (style.chartOutput) // Plot the new solution point
{
if (solPoint.T >= densityTick) // avoid drawing too many points
{
State state = new State(sample.Count(), lna: noise != Noise.None).InitAll(solPoint.X);
for (int i = 0; i < reports.Count; i++)
{
if (series[i] != null) // if a series was actually generated from this report
// generate deterministic series
{
if ((noise == Noise.None && reports[i].flow.HasDeterministicValue()) ||
(noise != Noise.None && reports[i].flow.HasStochasticMean()))
{
double mean = reports[i].flow.ObserveMean(sample, solPoint.T, state, Flux, style);
KChartHandler.ChartAddPoint(series[i], solPoint.T, mean, 0.0, Noise.None);
}
// generate LNA-dependent series
if (noise != Noise.None && reports[i].flow.HasStochasticVariance() && !reports[i].flow.HasNullVariance())
{
double mean = reports[i].flow.ObserveMean(sample, solPoint.T, state, Flux, style);
double variance = reports[i].flow.ObserveVariance(sample, solPoint.T, state, style);
KChartHandler.ChartAddPoint(seriesLNA[i], solPoint.T, mean, variance, noise);
}
}
}
renderedCounter++;
densityTick += densityStep;
}
if (solPoint.T >= redrawTick) // avoid redrawing the plot too often
{
KChartHandler.ChartUpdate(style, incremental: true);
redrawTick += redrawStep;
}
}
lastTime = solPoint.T;
// END foreach (SolPoint solPoint in solution)
} while (true);
if (hasSolPoint)
{
lastState = new State(sample.Count(), lna: noise != Noise.None).InitAll(solPoint.X);
}
KChartHandler.ChartUpdate(style, incremental: false);
return(lastTime, lastState);
}