public void runThreadedSimulation(Simulation simulation, ISimulationListener listener)
{
lock (runningSimulations)
{
bool contains = false;
foreach (SimulatorThread s in runningSimulations)
{
if (s.simulation == simulation)
{
contains = true;
break;
}
}
if (!contains)
{
simulation.setSimulationListener(listener);
//start a thread for the simulation and return
SimulatorThread threadTarget = new SimulatorThread(simulation);
Thread newThread = new Thread(new ThreadStart(threadTarget.run));
threadTarget.runningThread = newThread;
runningSimulations.AddLast(threadTarget);
newThread.Start();
}
}
}
/// <summary>
/// Base constructor
/// </summary>
public AggregateReferenceNode(Experiment experiment, Simulation simulation)
{
this.cellDefinition = null;
this.group = null;
this.species = null;
this.experiment = experiment;
this.simulation = simulation;
}
/// <summary>
///
/// </summary>
/// <param name="sim"></param>
public void setSimulation(Simulation sim)
{
spatialViewState = sim.Parameters.EnvironmentViewState;
spatialViewState.SimParams = sim.Parameters;
spatialViewState.InitialSimState = sim.Parameters.InitialState;
spatialViewState.CurrentSimState = sim.GetCurrentState();
OpenGLPanelAnalyser.SpatialViewState = spatialViewState;
simRef = sim;
OpenGLPanelAnalyser.Refresh();
}
public bool isSimulationRunning(Simulation simulation)
{
lock (runningSimulations)
{
foreach (SimulatorThread s in runningSimulations)
{
if (s.simulation == simulation)
{
return true;
}
}
return false;
}
}
public void TestSpeciesWithSpaces()
{
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experiment1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
Setup(experiment, simulation, "s1 species_protein");
// Species
AssertDouble.AreEqual(1.0d * 10d, evaluate("A", experiment, simulation));
AssertDouble.AreEqual(x1 * 10d, evaluate("X", experiment, simulation));
AssertDouble.AreEqual(y1 * 10d + s2 * 20d, evaluate("Y", experiment, simulation));
AssertDouble.AreEqual(z1 * 10d, evaluate("Z", experiment, simulation));
AssertDouble.AreEqual(s1 * 20d, evaluate("s1_species_protein", experiment, simulation));
}
public void TestGroups()
{
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experiment1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
Setup(experiment, simulation);
AssertDouble.AreEqual(10, evaluate("group1", experiment, simulation));
AssertDouble.AreEqual(10, evaluate("group2", experiment, simulation));
AssertDouble.AreEqual(22, evaluate("2.2*group3", experiment, simulation));
}
public void testWithSpecies()
{
MuCell.Model.SBML.Model model = new MuCell.Model.SBML.Model();
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experimen1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
setupExperiment(model, experiment, simulation);
// Test parsing cell def references, group references etc.
MuCell.Model.SBML.Reader.SBMLReader reader = new MuCell.Model.SBML.Reader.SBMLReader();
FormulaParser fp = new FormulaParser(reader, "5.2+s2", model, experiment, simulation);
MathTree formulaTree = fp.getFormulaTree();
MuCell.Model.SBML.InnerNode root = (InnerNode)formulaTree.root;
Assert.AreEqual(BinaryMathOperators.Plus, root.data);
Assert.AreEqual(5.2, ((MuCell.Model.SBML.NumberLeafNode)(root.subtree.ToArray()[0])).data);
Assert.AreEqual("5.2+s2", root.ToString());
MuCell.Model.SBML.AggregateReferenceNode right = (MuCell.Model.SBML.AggregateReferenceNode)(root.subtree.ToArray()[1]);
Assert.AreEqual("s2", right.ToString());
Assert.AreEqual(null, right.CellDefinition);
Assert.AreEqual(null, right.Group);
Assert.AreEqual("s2", right.Species.ID);
}
public void testWithCellDefWithSpaces()
{
MuCell.Model.SBML.Model model = new MuCell.Model.SBML.Model();
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experimen1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
setupExperiment(model, experiment, simulation);
experiment.GetCellDefinition("celldef1").Name = "cell def1";
Assert.That(experiment.ContainsCellDefinition("cell_def1"));
// Test parsing cell def references, group references etc.
MuCell.Model.SBML.Reader.SBMLReader reader = new MuCell.Model.SBML.Reader.SBMLReader();
FormulaParser fp = new FormulaParser(reader, "cell_def1", model, experiment, simulation);
MathTree formulaTree = fp.getFormulaTree();
MuCell.Model.SBML.AggregateReferenceNode root = (MuCell.Model.SBML.AggregateReferenceNode)formulaTree.root;
Assert.AreEqual("cell def1", root.ToString());
Assert.AreEqual(experiment.getCellDefinitions()[0], root.CellDefinition);
Assert.AreEqual(null, root.Group);
Assert.AreEqual(null, root.Species);
}
public bool exptEquals(Simulation other)
{
if (this.Name != other.Name)
{
Console.Write("Simulation objects not equal: ");
Console.WriteLine("this.Name='" + this.Name + "'; other.Name='" + other.Name);
return false;
}
if (this.SimulationResults.exptEquals(other.SimulationResults) == false)
{
Console.Write("Simulation objects not equal: ");
Console.WriteLine("this.SimulationResults != other.SimulationResults");
return false;
}
if (this.Parameters.exptEquals(other.Parameters) == false)
{
Console.Write("Simulation objects not equal: ");
Console.WriteLine("this.Parameters != other.Parameters");
return false;
}
return true;
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="models">
/// A <see cref="List`1"/>
/// </param>
/// <param name="experiment">
/// A <see cref="Experiment"/>
/// </param>
/// <param name="simulation">
/// A <see cref="Simulation"/>
/// </param>
public void Initialize(List<Model.SBML.Model> models, Experiment experiment, Simulation simulation)
{
if (this.parameters != null)
{
this.parameters.InitializeTimeSeriesFunction(models, experiment, simulation);
}
}
/// <summary>
/// Creates a new simulation, choosing an appropriate name
/// </summary>
public void createNewSimulation()
{
Experiment parentExperiment = null;
String namePrefix = "sim ";
int highestID = 1;
for (int attempt = 0; attempt < 1000; attempt++)
{
if (isSimulationNameTaken(namePrefix + highestID))
{
highestID++;
}
else
{
break;
}
}
foreach (Experiment experiment in openExperiments)
{
if (experiment.Id == currentExperimentID)
{
parentExperiment = experiment;
break;
}
}
if (parentExperiment != null)
{
Simulation simulation = new Simulation(namePrefix + highestID);
parentExperiment.addSimulation(simulation);
experimentTreePanelController.refreshTreeElements(getExperiments());
experimentTreePanelController.setSelectedSimulation(simulation.Name);
}
}
/// <summary>
/// Initalizes the time series function - must be called after setting the function string
/// </summary>
/// <param name="models">
/// A <see cref="List`1"/>
/// </param>
/// <param name="experiment">
/// A <see cref="Experiment"/>
/// </param>
/// <param name="simulation">
/// A <see cref="Simulation"/>
/// </param>
public void InitializeTimeSeriesFunction(List<Model.SBML.Model> models, Experiment experiment, Simulation simulation)
{
if (this.functionString!=null)
{
// create a reader
MuCell.Model.SBML.Reader.SBMLReader reader = new MuCell.Model.SBML.Reader.SBMLReader();
// parse the formular
SBML.FormulaParser fp = new SBML.FormulaParser(reader, this.functionString, models, experiment, simulation);
// Get the formula tree
SBML.MathTree formulaTree = fp.getFormulaTree();
// Convert to a function
this.function = formulaTree.ToAggregateEvaluationFunction();
units = formulaTree.ApproximateUnits();
}
}
public void removeSimulation(Simulation simulation)
{
this.simulations.Remove(simulation);
}
/// <summary>
/// Add a simulation to the experiment
/// </summary>
/// <param name="simulation">
/// A <see cref="Simulation"/>
/// </param>
public void addSimulation(Simulation simulation)
{
this.simulations.Add(simulation);
}
public void Setup(Experiment experiment, Simulation simulation)
{
Setup(experiment, simulation, "s1");
}
public void Setup(Experiment experiment, Simulation simulation, string speciesName)
{
// ********* INITIAL SETUP
// Hopf model
MuCell.Model.SBML.Reader.SBMLReader s = new MuCell.Model.SBML.Reader.SBMLReader("../../UnitTests/smallest.Hopf.xml");
// Cell definition 1
MuCell.Model.CellDefinition celldef1 = new MuCell.Model.CellDefinition("celldef1");
celldef1.addSBMLModel(s.model);
// Create a NEW model
MuCell.Model.SBML.Model model = new MuCell.Model.SBML.Model();
MuCell.Model.SBML.Species species1 = new MuCell.Model.SBML.Species();
MuCell.Model.SBML.Species species2 = new MuCell.Model.SBML.Species();
model.listOfSpecies = new List<MuCell.Model.SBML.Species>();
model.listOfSpecies.Add(species1);
model.listOfSpecies.Add(species2);
// Set some values for species1
species1.ID = speciesName;
species1.InitialAmount = 4.0d;
// Set some values for species2
species2.ID = "Y";
species2.InitialAmount = 0.1d;
model.AddId(speciesName, species1);
model.AddId("Y", species2);
// Set up the reaction
MuCell.Model.SBML.Reaction reaction1 = new MuCell.Model.SBML.Reaction("reaction1");
model.listOfReactions = new List<MuCell.Model.SBML.Reaction>();
model.listOfReactions.Add(reaction1);
// Set up the kinetic law
reaction1.KineticLaw = new MuCell.Model.SBML.KineticLaw(model);
reaction1.KineticLaw.Formula = speciesName.Replace(' ', '_')+"*2";
// set up the species reference for the reactants
MuCell.Model.SBML.SpeciesReference ref1 = new MuCell.Model.SBML.SpeciesReference(species1, 1);
// set up the species references for the products
MuCell.Model.SBML.SpeciesReference ref2 = new MuCell.Model.SBML.SpeciesReference(species1, 0.75);
MuCell.Model.SBML.SpeciesReference ref3 = new MuCell.Model.SBML.SpeciesReference(species2, 2);
// Add the references
reaction1.Reactants.Add(ref1);
reaction1.Products.Add(ref2);
reaction1.Products.Add(ref3);
// set up the cell definition
MuCell.Model.CellDefinition celldef2 = new MuCell.Model.CellDefinition("celldef2");
celldef2.addSBMLModel(model);
// instantiat the environment
MuCell.Model.Vector3 size = new MuCell.Model.Vector3(1, 1, 1);
MuCell.Model.Environment environment = new MuCell.Model.Environment(size);
// Cells
List<MuCell.Model.CellInstance> cells = new List<MuCell.Model.CellInstance>();
// Create 10 cells of celldef1 and 20 cells of celldef2
for(int i=0;i<10;i++){
int a = ((i+2)%3)+1;
int b = (i%3)+1;
int c = ((i+1)%3)+1;
CellInstance cell11 = celldef1.createCell();
cells.Add(cell11);
environment.AddCellToGroup(a, cell11);
CellInstance cell21 = celldef2.createCell();
CellInstance cell22 = celldef2.createCell();
cells.Add(cell21);
cells.Add(cell22);
environment.AddCellToGroup(b, cell21);
environment.AddCellToGroup(c, cell22);
}
// StateSnapshot for intial state
MuCell.Model.StateSnapshot initialState = new MuCell.Model.StateSnapshot(cells);
initialState.SimulationEnvironment = environment;
// Parameters
MuCell.Model.SimulationParameters parameters = new MuCell.Model.SimulationParameters();
parameters.InitialState = initialState;
parameters.SimulationLength = 0.01001d;
parameters.SnapshotInterval = 1;
parameters.StepTime = 0.01001d;
parameters.SolverMethod = MuCell.Model.Solver.SolverMethods.RungeKutta;
// Simulation
simulation.Parameters = parameters;
// Experiment
experiment.addCellDefinition(celldef1);
experiment.addCellDefinition(celldef2);
experiment.addSimulation(simulation);
// Start simulation
simulation.StartSimulation();
this.models = new List<MuCell.Model.SBML.Model>();
this.models.Add(s.model);
this.models.Add(model);
}
private List<Experiment> generateHardcodedExperiment()
{
List<Experiment> exps = new List<Experiment>();
Simulation sim1 = new Simulation("sim 1");
Simulation sim2 = new Simulation("sim 2");
Simulation sim3 = new Simulation("sim 3");
Simulation sim4 = new Simulation("sim 4");
Simulation sim5 = new Simulation("sim 5");
Simulation sim6 = new Simulation("sim 6");
sim1.Parameters.StepTime = 5.3d;
sim5.Parameters.StepTime = -6.3d;
CellDefinition cellDef1 = new CellDefinition("CellDef 1");
cellDef1.addSBMLModel("Models/smallest.Hopf.xml");
//CellDefinition cellDef2 = new CellDefinition("CellDef 2");
//CellDefinition cellDef3 = new CellDefinition("CellDef 3");
//CellDefinition cellDef4 = new CellDefinition("CellDef 4");
//CellDefinition cellDef5 = new CellDefinition("CellDef 5");
//CellDefinition cellDef6 = new CellDefinition("CellDef 6");
//CellDefinition cellDef7 = new CellDefinition("CellDef 7");
Experiment exp1 = new Experiment("Experiment 1");
Experiment exp2 = new Experiment("Experiment 2");
Experiment exp3 = new Experiment("Experiment 3");
exp1.Id = 1;
exp2.Id = 2;
exp3.Id = 3;
exp1.addCellDefinition(cellDef1);
exp1.addSimulation(sim1);
exp1.addSimulation(sim2);
exp1.addSimulation(sim3);
/*exp2.addCellDefinition(cellDef2);
exp2.addCellDefinition(cellDef3);
exp2.addCellDefinition(cellDef4);
exp2.addCellDefinition(cellDef5);*/
exp2.addSimulation(sim4);
//exp3.addCellDefinition(cellDef6);
//exp3.addCellDefinition(cellDef7);
exp3.addSimulation(sim5);
exp3.addSimulation(sim6);
exps.Add(exp1);
exps.Add(exp2);
exps.Add(exp3);
return exps;
}
public void TestSerializationEquality()
{
String filename = "../../UnitTests/expt1.serialized.xml";
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experiment1");
Simulation simulation1 = new Simulation("simulation1");
Results results = new Results();
MuCell.Model.SBML.Model model = new MuCell.Model.SBML.Model();
CellDefinition cellDef1 = new CellDefinition("cellDef1");
cellDef1.addSBMLModel(model);
for (int i = 0; i < 5; i++)
{
StateSnapshot snapshot = new StateSnapshot();
for (int j = 0; j < 10; j++)
{
CellInstance cell = new CellInstance(cellDef1);
cell.GroupID = j;
cell.CellInstanceSpatialContext.Position = new Vector3(1*j, 1+i, 2+j);
cell.CellInstanceSpatialContext.Velocity = new Vector3(4*i, 5+j, 3+i);
cell.CellInstanceSpatialContext.Volume = new Vector3(10+j, 14*i, 15*i);
cell.CellInstanceSpatialContext.Orientation = new Vector3(2+i, 3*j, 4*j);
snapshot.Cells.Add(cell);
}
MuCell.Model.Environment environment = new MuCell.Model.Environment(new Vector3(10 * i, 14 * i, 15 * i));
SerializableDictionary<int, MuCell.Model.SBML.Group> dict = new SerializableDictionary<int, MuCell.Model.SBML.Group>();
// create new groups x3
MuCell.Model.SBML.Group group1 = new MuCell.Model.SBML.Group(1);
group1.Col = System.Drawing.Color.Beige;
MuCell.Model.SBML.Group group2 = new MuCell.Model.SBML.Group(2);
group2.Col = System.Drawing.Color.Brown;
MuCell.Model.SBML.Group group3 = new MuCell.Model.SBML.Group(3);
group3.Col = System.Drawing.Color.Green;
dict.Add(1, group1); dict.Add(2, group2); dict.Add(3, group3);
environment.Groups = dict;
//SerializableDictionary<int, MuCell.Model.NutrientField> nutDict = new SerializableDictionary<int, MuCell.Model.NutrientField>();
//// create new nutrients x2
//MuCell.Model.NutrientField nut1 = new MuCell.Model.NutrientField(1);
//MuCell.Model.NutrientField nut2 = new MuCell.Model.NutrientField(2);
//nut2.Col = System.Drawing.Color.Fuchsia;
//nutDict.Add(1,nut1); nutDict.Add(2,nut2);
//environment.Nutrients = nutDict;
snapshot.SimulationEnvironment = environment;
results.StateSnapshots.Add(snapshot);
}
results.CurrentState = results.StateSnapshots[4];
for (int i = 0; i < 3; i++)
{
TimeSeries timeSeries = new TimeSeries("Function" + i, 1.2 * i);
for (int j = 0; j < 20; j++)
{
timeSeries.Series.Add(0.43+i*j+0.031*j);
}
results.TimeSeries.Add(timeSeries);
}
results.FilePath = "some-file-path";
simulation1.SimulationResults = results;
SimulationParameters simulationParams1 = new SimulationParameters();
simulationParams1.TimeSeries = results.TimeSeries;
simulationParams1.InitialState = results.StateSnapshots[0];
// add to simulation
simulation1.Parameters = simulationParams1;
// expt.addSimulation
experiment.addSimulation(simulation1);
XmlSerializer s = new XmlSerializer(typeof(MuCell.Model.Experiment));
TextWriter w = new StreamWriter(filename);
s.Serialize(w, experiment);
w.Close();
TextReader tr = new StreamReader(filename);
Experiment deserializedExpt = (Experiment)s.Deserialize(tr);
tr.Close();
Assert.IsTrue(experiment.exptEquals(deserializedExpt));
}
public void TestCellDefAndGroup()
{
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experiment1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
Setup(experiment, simulation);
// cell def and group
// Groups
AssertDouble.AreEqual(3, evaluate("celldef1.group1", experiment, simulation));
AssertDouble.AreEqual(3, evaluate("celldef1.group2", experiment, simulation));
AssertDouble.AreEqual(4, evaluate("celldef1.group3", experiment, simulation));
AssertDouble.AreEqual(7, evaluate("celldef2.group1", experiment, simulation));
AssertDouble.AreEqual(7, evaluate("celldef2.group2", experiment, simulation));
AssertDouble.AreEqual(6, evaluate("celldef2.group3", experiment, simulation));
}
public void testApproximateUnits()
{
MuCell.Model.SBML.Model model = new MuCell.Model.SBML.Model();
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experimen1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
setupExperiment(model, experiment, simulation);
// Test parsing cell def references, group references etc.
MuCell.Model.SBML.Reader.SBMLReader reader = new MuCell.Model.SBML.Reader.SBMLReader();
FormulaParser fp = new FormulaParser(reader, "5.2", model, experiment, simulation);
MathTree formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "5.2+10", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "5.2-10", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "5.2*10", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "5.2/10", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1+celldef2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1-celldef1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1*celldef2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells*Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1/celldef2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells/Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1*celldef2*celldef1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells*Cells*Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1+10", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1*10", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1 / 34.2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "4/celldef1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("1/Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "24/(celldef1*celldef1)", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("1/Cells*Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1.group1/(celldef1*celldef1)", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells/Cells*Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1/celldef1+10", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells/Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1.group1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1.group2 + celldef1.group1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1.group1/celldef1.group2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells/Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "143/celldef1.group1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("1/Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s1*4", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s1*s2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration*Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s1*s2*celldef1.s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration*Concentration*Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s1*celldef1.group1.s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration*Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "group2.s2*celldef1.group1.s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration*Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s1/s2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration/Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "4.345/s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("1/Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s1+celldef1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "4.345/s1+celldef1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1*celldef1.group1.s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells*Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s2/celldef1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration/Cells", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s2/celldef1+s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "s2/celldef1+celldef2", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("No units", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "celldef1/celldef1.group1.s1", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Cells/Concentration", formulaTree.ApproximateUnits());
fp = new FormulaParser(reader, "Abs(s1)", model, experiment, simulation);
formulaTree = fp.getFormulaTree();
Assert.AreEqual("Concentration", formulaTree.ApproximateUnits());
}
public void TestCellDefAndSpecies()
{
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experiment1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
Setup(experiment, simulation);
// cell def and Species
AssertDouble.AreEqual(1.0d*10d, evaluate("celldef1.A", experiment, simulation));
AssertDouble.AreEqual(x1*10d, evaluate("celldef1.X", experiment, simulation));
AssertDouble.AreEqual(y1*10d, evaluate("celldef1.Y", experiment, simulation));
AssertDouble.AreEqual(z1*10d, evaluate("celldef1.Z", experiment, simulation));
AssertDouble.AreEqual(0, evaluate("celldef1.s1", experiment, simulation));
AssertDouble.AreEqual(s1*20d, evaluate("celldef2.s1", experiment, simulation));
AssertDouble.AreEqual(s2*20d, evaluate("celldef2.Y", experiment, simulation));
AssertDouble.AreEqual(0, evaluate("celldef2.A", experiment, simulation));
AssertDouble.AreEqual(0, evaluate("celldef2.X", experiment, simulation));
AssertDouble.AreEqual(0, evaluate("celldef2.Z", experiment, simulation));
}
public void testWithGroup()
{
MuCell.Model.SBML.Model model = new MuCell.Model.SBML.Model();
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experimen1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
setupExperiment(model, experiment, simulation);
// Test parsing cell def references, group references etc.
MuCell.Model.SBML.Reader.SBMLReader reader = new MuCell.Model.SBML.Reader.SBMLReader();
FormulaParser fp = new FormulaParser(reader, "group1", model, experiment, simulation);
MathTree formulaTree = fp.getFormulaTree();
MuCell.Model.SBML.AggregateReferenceNode root = (MuCell.Model.SBML.AggregateReferenceNode)formulaTree.root;
Assert.AreEqual("group1", root.ToString());
Assert.AreEqual(null, root.CellDefinition);
Assert.AreEqual("1", root.Group.ID);
Assert.AreEqual(null, root.Species);
}
public void TestCellDefinitionsWithSpaces()
{
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experiment1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
Setup(experiment, simulation);
experiment.GetCellDefinition("celldef1").Name = "cell def1";
// Check cell definitions
AssertDouble.AreEqual(10, evaluate("cell_def1", experiment, simulation));
AssertDouble.AreEqual(20, evaluate("celldef2", experiment, simulation));
AssertDouble.AreEqual(12.3, evaluate("cell_def1+2.3", experiment, simulation));
AssertDouble.AreEqual(11.0, evaluate("1.1*(celldef2/2.0)", experiment, simulation));
}
public void TestGroupAndSpecies()
{
MuCell.Model.Experiment experiment = new MuCell.Model.Experiment("experiment1");
MuCell.Model.Simulation simulation = new MuCell.Model.Simulation("simulation1");
Setup(experiment, simulation);
// group and Species
// 3 of celldef1 in group 1 and 2
AssertDouble.AreEqual(1.0d*3d, evaluate("group1.A", experiment, simulation));
AssertDouble.AreEqual(x1*3d, evaluate("group1.X", experiment, simulation));
AssertDouble.AreEqual(y1*3d+s2*7d, evaluate("group1.Y", experiment, simulation));
AssertDouble.AreEqual(z1*3d, evaluate("group1.Z", experiment, simulation));
AssertDouble.AreEqual(1.0*3d*2d, evaluate("group1.A+group2.A", experiment, simulation));
AssertDouble.AreEqual(x1*3d*2d, evaluate("group1.X+group2.X", experiment, simulation));
AssertDouble.AreEqual(y1*3d*2d+s2*7d*2d, evaluate("group1.Y+group2.Y", experiment, simulation));
AssertDouble.AreEqual(z1*3d*2d, evaluate("group1.Z+group2.Z", experiment, simulation));
// 4 of celldef1 in group 3
AssertDouble.AreEqual(1.0d*4d, evaluate("group3.A", experiment, simulation));
AssertDouble.AreEqual(x1*4d, evaluate("group3.X", experiment, simulation));
AssertDouble.AreEqual(y1*4d+s2*6d, evaluate("group3.Y", experiment, simulation));
AssertDouble.AreEqual(z1*4d, evaluate("group3.Z", experiment, simulation));
// 7 of celldef2 in group 1 and 2
AssertDouble.AreEqual(s1*7d, evaluate("group1.s1", experiment, simulation));
AssertDouble.AreEqual(s1*7d, evaluate("group2.s1", experiment, simulation));
// 6 of celldef2 in group 3
AssertDouble.AreEqual(s1*6d, evaluate("group3.s1", experiment, simulation));
}
public SimulatorThread(Simulation simulation)
{
this.simulation = simulation;
}
