private void OnPaintCanvas(object sender, SKPaintSurfaceEventArgs e)
{
Painter painter = new SKPainter(e.Surface.Canvas);
KScoreHandler.Draw(painter, 0, 0, e.Info.Width, e.Info.Height, forcePacked: false); // forcePacked is no longer used since we added a button to switch packing also on iOS/Android
data.DisplayTouchLocation(painter);
}
private static NSScoreView scoreControl = null; // The only NSScoreView, same as "this", but accessible from static methods
private void OnLoad()
{
this.WantsLayer = true;
this.LayerContentsRedrawPolicy = NSViewLayerContentsRedrawPolicy.OnSetNeedsDisplay;
scoreControl = this;
KScoreHandler.Register(scoreControl);
Tracking();
}
// Implement this to draw on the canvas.
public override void DrawRect(CGRect dirtyRect)
{
base.DrawRect(dirtyRect);
var context = NSGraphicsContext.CurrentContext.CGContext;
CG.FlipCoordinateSystem(context);
KScoreHandler.Draw(new CGPainter(context), 0, 0, (int)dirtyRect.Width, (int)dirtyRect.Height);
}
public /* Interface KGuiControl */ void GuiScoreUpdate()
{
if (!this.InvokeRequired)
{
KScoreHandler.DoInvalidate();
}
else
{
this.Invoke((Action) delegate { GuiScoreUpdate(); });
}
}
public ScoreView()
{
// register this as KTouchable so that touch callbacks can be attached through interface KTouchable:
KScoreHandler.Register(this);
this.BackgroundColor = Color.Transparent;
this.PaintSurface += OnPaintCanvas;
/* Attact Touch effect from KTouch.OnTouchEffectAction */
TouchEffect touchEffect = new TouchEffect();
touchEffect.TouchAction += KTouchServer.OnTouchEffectAction;
touchEffect.Capture = true; // "This has the effect of delivering all subsequent events to the same event handler"
this.Effects.Add(touchEffect);
/* Initialize Interface KTouchClient with a locally-sourced KTouchClientData closure */
this.data = new KTouchClientData(
invalidateSurface: () => { this.InvalidateSurface(); },
setManualPinchPan: (Swipe pinchPan) => { KScoreHandler.SetManualPinchPan(pinchPan); }
);
}
private void SettingsMenu()
{
guiControls.menuSettings.SetImage("icons8_settings_384_W_48x48");
guiControls.menuSettings.autoClose = true;
var header = guiControls.menuSettings.NewMenuSection(level: -2); header.SetText("Settings");
var score = guiControls.menuSettings.NewMenuSection(level: 2); score.SetText("Reaction score");
var mozart = guiControls.menuSettings.NewMenuItemButton(); mozart.SetText("Mozart");
var bach = guiControls.menuSettings.NewMenuItemButton(); bach.SetText("Bach"); bach.Selected(true);
// var influence = guiControls.menuSettings.NewMenuItemButton(); influence.SetText("influence"); // now unused in Settings
// var binpacking = guiControls.menuSettings.NewMenuItemButton(); binpacking.SetText("[pack]"); // now unused in Settings
mozart.OnClick((object s, EventArgs e) => {
bach.Selected(false);
scoreStyle = "Mozart";
mozart.Selected(true);
KScoreHandler.ScoreUpdate();
});
bach.OnClick((object s, EventArgs e) => {
mozart.Selected(false);
scoreStyle = "Bach";
bach.Selected(true);
KScoreHandler.ScoreUpdate();
});
//influence.OnClick((object s, EventArgs e) => {
// if (influence.IsSelected()) {
// KScoreHandler.showInfluences = false;
// influence.Selected(false);
// } else {
// KScoreHandler.showInfluences = true;
// influence.Selected(true);
// }
// KScoreHandler.ScoreUpdate();
//});
//binpacking.OnClick((object s, EventArgs e) => {
// if (binpacking.IsSelected()) {
// packReactions = false;
// binpacking.Selected(false);
// } else {
// packReactions = true;
// binpacking.Selected(true);
// }
// KScoreHandler.ScoreUpdate();
//});
var solvers = guiControls.menuSettings.NewMenuSection(level: 2); solvers.SetText("ODE Solvers");
var rk547m = guiControls.menuSettings.NewMenuItemButton(); rk547m.SetText("RK547M"); rk547m.Selected(true);
var gearBDF = guiControls.menuSettings.NewMenuItemButton(); gearBDF.SetText("GearBDF");
rk547m.OnClick((object s, EventArgs e) => {
gearBDF.Selected(false);
solver = "RK547M";
rk547m.Selected(true);
});
gearBDF.OnClick((object s, EventArgs e) => {
rk547m.Selected(false);
solver = "GearBDF";
gearBDF.Selected(true);
});
var lna = guiControls.menuSettings.NewMenuSection(level: 2); lna.SetText("LNA");
var drift = guiControls.menuSettings.NewMenuItemButton(); drift.SetText("Precompute drift");
drift.OnClick((object s, EventArgs e) => {
if (drift.IsSelected())
{
precomputeLNA = false;
drift.Selected(false);
}
else
{
precomputeLNA = true;
drift.Selected(true);
}
});
var directories = guiControls.menuSettings.NewMenuSection(level: 2); directories.SetText("Set directories");
var forModels = guiControls.menuSettings.NewMenuItemButton(); forModels.SetText("For model files");
forModels.OnClick((object s, EventArgs e) => {
guiControls.SetDirectory();
});
var privacy = guiControls.menuSettings.NewMenuSection(level: 2); privacy.SetText("Privacy policy");
var policyURL = guiControls.menuSettings.NewMenuItemButton(); policyURL.SetText("Copy url to clipboard");
policyURL.OnClick((object s, EventArgs e) => {
guiControls.PrivacyPolicyToClipboard();
});
var version = guiControls.menuSettings.NewMenuSection(level: 4); version.SetText("Version " + Gui.KaemikaVersion); // version.SetText("Version 6.02214076e23");
version.OnClick((object s, EventArgs e) => { guiControls.SetSnapshotSize(); });
guiControls.menuSettings.OnClick((object s, EventArgs e) => {
mozart.Selected(scoreStyle == "Mozart");
bach.Selected(scoreStyle == "Bach");
gearBDF.Selected(solver == "GearBDF");
rk547m.Selected(solver == "RK547M");
drift.Selected(precomputeLNA);
MenuClicked(guiControls.menuSettings);
});
guiControls.menuSettings.ClearMenuItems();
guiControls.menuSettings.AddMenuItem(header);
guiControls.menuSettings.AddSeparator();
guiControls.menuSettings.AddMenuItem(score);
guiControls.menuSettings.AddMenuItems(new KButton[2] {
mozart, bach
});
//guiControls.menuSettings.AddMenuItems(new KButton[3] { mozart, bach, binpacking });
//guiControls.menuSettings.AddMenuItems(new KButton[2] { influence, binpacking });
guiControls.menuSettings.AddSeparator();
guiControls.menuSettings.AddMenuItem(solvers);
guiControls.menuSettings.AddMenuItems(new KButton[2] {
rk547m, gearBDF
});
guiControls.menuSettings.AddSeparator();
guiControls.menuSettings.AddMenuItem(lna);
guiControls.menuSettings.AddMenuItem(drift);
guiControls.menuSettings.AddSeparator();
guiControls.menuSettings.AddMenuItem(directories);
guiControls.menuSettings.AddMenuItem(forModels);
guiControls.menuSettings.AddSeparator();
guiControls.menuSettings.AddMenuItem(privacy);
guiControls.menuSettings.AddMenuItem(policyURL);
guiControls.menuSettings.AddSeparator();
guiControls.menuSettings.AddMenuItem(version);
guiControls.menuSettings.Visible(true);
guiControls.menuSettings.Enabled(true);
}
private static void Execute_Worker(bool doParse, bool doAST, bool doScope, bool autoContinue, bool chartOutput)
{
KGui.gui.GuiBeginningExecution();
lastExecution = null;
KGui.gui.GuiSaveInput();
KGui.gui.GuiOutputClear();
DateTime startTime = DateTime.Now;
if (TheParser.Parser().Parse(KGui.gui.GuiInputGetText(), out IReduction root))
{
if (doParse)
{
root.DrawReductionTree();
}
else
{
Netlist netlist = new Netlist(autoContinue);
try
{
Statements statements = Parser.ParseTop(root);
if (doAST)
{
KGui.gui.GuiOutputAppendText(statements.Format());
}
else
{
SampleValue vessel = Vessel(KControls.SelectNoiseSelectedItem != Noise.None);
Env initialEnv = new ValueEnv("vessel", Type.Sample, vessel, new BuiltinEnv(new NullEnv()));
Scope initialScope = initialEnv.ToScope();
Scope scope = statements.Scope(initialScope);
if (doScope)
{
KGui.gui.GuiOutputAppendText(scope.Format());
}
else
{
Style style = new Style(varchar: scopeVariants ? defaultVarchar : null, new SwapMap(),
map: remapVariants ? new AlphaMap() : null, numberFormat: "G4", dataFormat: "full", // we want it full for samples, but maybe only headers for functions/networks?
exportTarget: ExportTarget.Standard, traceFull: false, chartOutput: chartOutput);
KChartHandler.ChartClear("", "s", "M", style);
KChartHandler.LegendUpdate(style);
KScoreHandler.ScoreClear();
KControls.ParametersClear(style);
KDeviceHandler.Clear(style);
KDeviceHandler.Sample(vessel, style);
netlist.Emit(new SampleEntry(vessel));
DateTime evalTime = DateTime.Now;
lastExecution = new ExecutionInstance(vessel, netlist, style, startTime, evalTime);
lastExecution.environment = statements.EvalReject(initialEnv, netlist, style, 0);
if (lastExecution.environment == null)
{
throw new Error("Top level reject");
}
lastExecution.EndTime();
if (style.chartOutput)
{
foreach (ParameterEntry parameter in netlist.Parameters())
{
KControls.AddParameter(parameter.symbol.Format(style), (parameter.value as NumberValue).value, parameter.distribution, style);
}
KGui.gui.GuiParametersUpdate(); // calls back KControls.ParametersUpdate, but only on Win/Mac
}
KGui.gui.GuiProcessOutput();
}
}
}
catch (ExecutionEnded) { lastExecution.EndTime(); KGui.gui.GuiOutputAppendText(lastExecution.ElapsedTime()); }
catch (ConstantEvaluation ex) { string cat = "Does not have a value: "; netlist.Emit(new CommentEntry(cat + ": " + ex.Message)); KGui.gui.GuiInputSetErrorSelection(-1, -1, 0, cat, ex.Message); }
catch (Error ex) { netlist.Emit(new CommentEntry(ex.Message)); KGui.gui.GuiInputSetErrorSelection(-1, -1, 0, "Error", ex.Message); try { KGui.gui.GuiProcessOutput(); } catch { }; }
catch (StackOverflowException ex) { netlist.Emit(new CommentEntry(ex.Message)); KGui.gui.GuiInputSetErrorSelection(-1, -1, 0, "Stack Overflow", ex.Message); }
catch (Exception ex) { string cat = "Something happened"; netlist.Emit(new CommentEntry(cat + ": " + ex.Message)); KGui.gui.GuiInputSetErrorSelection(-1, -1, 0, cat, ex.Message); }
}
}
else
{
KGui.gui.GuiInputSetErrorSelection(TheParser.Parser().FailLineNumber(), TheParser.Parser().FailColumnNumber(), TheParser.Parser().FailLength(), TheParser.Parser().FailCategory(), TheParser.Parser().FailMessage());
}
EndingExecution();
}
public static List <ExportAction> exportActionsList()
{
return(new List <ExportAction>()
{
new ExportAction("Export output text to clipboard", ExportAs.OutputCopy, () => { KGui.gui.GuiOutputCopy(); }),
new ExportAction("Export images bitmap to clipboard", ExportAs.ChartSnapToClipboard, () => { KGui.gui.GuiChartSnap(); }),
new ExportAction("Export images to SVG (InkScape) file", ExportAs.ChartSnapToSvg, () => { KGui.gui.GuiChartSnapToSvg(); }),
new ExportAction("Export visible chart data to CSV (Excel) file", ExportAs.ChartData, () => { KGui.gui.GuiChartData(); }),
new ExportAction("Export last sample to SBML (Copasi) file", ExportAs.SBML, () => { KGui.gui.GuiModelToSBML(); }),
new ExportAction("Export last sample to ODE (Oscill8) text", ExportAs.ODE, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.ODE); }),
new ExportAction("Export last sample to LBS/html5 text", ExportAs.MSRC_CRN, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.MSRC_CRN); }),
new ExportAction("Export last sample to LBS/silverlight text", ExportAs.MSRC_LBS, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.MSRC_LBS); }),
new ExportAction("Export steady state equations (Wolfram) text", ExportAs.SteadyState, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.SteadyState); }),
new ExportAction("Export protocol step graph to GraphViz text", ExportAs.ProtocolGraph, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.ProtocolGraph); }),
new ExportAction("Export protocol state graph to GraphViz text", ExportAs.PDMPGraph, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.PDMPGraph); }),
//new ExportAction("Export reaction graph", ExportAs.ReactionGraph, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.ReactionGraph); }),
//new ExportAction("Export reaction complex graph", ExportAs.ComplexGraph, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.ComplexGraph); }),
//new ExportAction("PDMP GraphViz", ExportAs.PDMP_GraphViz, () => { Exec.Execute_Exporter(false, ExportAs.PDMP_GraphViz); }),
//new ExportAction("PDMP Parallel", ExportAs.PDMP_Parallel, () => { Exec.Execute_Exporter(false, ExportAs.PDMP_Parallel); }),
//new ExportAction("PDMP Parallel GraphViz", ExportAs.PDMP_Parallel_GraphViz, () => { Exec.Execute_Exporter(false, ExportAs.PDMP_Parallel_GraphViz); }),
});
}
public static ExportAction currentOutputAction = showReactionScoreOutputAction; // initialized by RestorePreferences
public static List <ExportAction> outputActionsList()
{
return(new List <ExportAction>()
{
showReactionScoreOutputAction,
showInitialCRNOutputAction,
showEvaluationOutputAction,
//new ExportAction("Show full trace", ExportAs.FullTrace, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.FullTrace); }),
new ExportAction("Show chemical trace", ExportAs.ChemicalTrace, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.ChemicalTrace); }),
new ExportAction("Show reactions", ExportAs.PDMPreactions, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.PDMPreactions); }),
new ExportAction("Show equations", ExportAs.PDMPequations, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.PDMPequations); }),
new ExportAction("Show stoichiometry", ExportAs.PDMPstoichiometry, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.PDMPstoichiometry); }),
new ExportAction("Show protocol", ExportAs.Protocol, () => { KGui.gui.GuiOutputTextShow(); KScoreHandler.ScoreHide(); KGui.gui.GuiOutputSetText(""); Exec.Execute_Exporter(false, ExportAs.Protocol); }),
//new ExportAction("Show last simulation state", ExportAs.None, () => {
// KGui.gui.GuiOutputSetText("");
// string s = Exec.lastReport + Environment.NewLine + Exec.lastState + Environment.NewLine;
// KGui.gui.GuiOutputAppendText(s);
// // try { System.Windows.Forms.Clipboard.SetText(s); } catch (ArgumentException) { };
//}),
});
}
partial void PrefsScoreBach(NSObject sender)
{
KControls.scoreStyle = "Bach";
PrefsScoreMozartOutlet.State = NSCellStateValue.Off;
KScoreHandler.ScoreUpdate();
}
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);
}
private static KScoreSKControl scoreControl = null; // The only KScoreSKControl, same as "this", but accessible from static methods
public KScoreSKControl() : base()
{
scoreControl = this;
scoreControl.Location = new System.Drawing.Point(0, 0);
KScoreHandler.Register(scoreControl);
}
// Implement this to draw on the canvas.
protected override void OnPaintSurface(SkiaSharp.Views.Desktop.SKPaintSurfaceEventArgs e)
{
base.OnPaintSurface(e);
KScoreHandler.Draw(new SKPainter(e.Surface.Canvas), Location.X, Location.Y, e.Info.Width, e.Info.Height);
}
