public static void setupExperiment(MuCell.Model.SBML.Model model, MuCell.Model.Experiment experiment, MuCell.Model.Simulation simulation)
{
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 = "s1";
species1.InitialAmount = 4.0d;
// Set some values for species2
species2.ID = "s2";
species2.InitialAmount = 0.1d;
model.AddId("s1", species1);
model.AddId("s2", species2);
// set up the cell definition
MuCell.Model.CellDefinition celldef1 = new MuCell.Model.CellDefinition("celldef1");
celldef1.addSBMLModel(model);
MuCell.Model.CellDefinition celldef2 = new MuCell.Model.CellDefinition("celldef2");
celldef2.addSBMLModel(model);
MuCell.Model.CellInstance cell1 = celldef1.createCell();
MuCell.Model.CellInstance cell2 = celldef2.createCell();
List<MuCell.Model.CellInstance> cells = new List<CellInstance>();
cells.Add(cell1);
cells.Add(cell2);
// StateSnapshot for intial state
MuCell.Model.StateSnapshot initialState = new MuCell.Model.StateSnapshot(cells);
MuCell.Model.Vector3 size = new MuCell.Model.Vector3(1, 1, 1);
initialState.SimulationEnvironment = new MuCell.Model.Environment(size);
// Create two groups with one cell of each type in each
initialState.SimulationEnvironment.AddCellToGroup(1, celldef1.createCell());
initialState.SimulationEnvironment.AddCellToGroup(2, celldef2.createCell());
// Parameters
MuCell.Model.SimulationParameters parameters = new MuCell.Model.SimulationParameters();
parameters.InitialState = initialState;
// Simulation
simulation.Parameters = parameters;
// Experiment
experiment.addCellDefinition(celldef1);
experiment.addCellDefinition(celldef2);
experiment.addSimulation(simulation);
}
/// <summary>
/// Constructor for the Simulator
/// </summary>
/// <param name="name">
/// A <see cref="String"/>
/// </param>
public Simulation(String name)
{
this.name = name;
this.parameters = new SimulationParameters();
this.SimulationResults = new Results();
this.listener = null;
// Seeds the random object
this.randomObject = new Random(0);
this.snapshotCache = new SnapshotCache(10);
this.currentState = null;
}
/// <summary>
/// Constructor for the Simulator
/// </summary>
/// <param name="name">
/// A <see cref="String"/>
/// </param>
public Simulation(String name)
{
this.name = name;
this.parameters = new SimulationParameters();
this.SimulationResults = new Results();
this.listener = null;
// Seeds the random object based on the time
int seed = Math.Abs((int)(DateTime.Now.Ticks));
System.Console.WriteLine("Seeding simulation random object - seed = "+seed.ToString());
this.randomObject = new Random(seed);
this.snapshotCache = new SnapshotCache(10);
this.currentState = null;
}
public void getSimulationParameters(SimulationParameters simulationParameters)
{
Console.WriteLine("Getting simulation parameters from UI");
//fill in the values here
simulationParameters.StepTime = (double)timeStep.Value;
//Console.WriteLine("my step time is =" + timeStep.Value);
simulationParameters.SnapshotInterval = (double)snapshotInterval.Value;
simulationParameters.SimulationLength = (double)simulationLength.Value;
simulationParameters.SolverMethod = (SolverMethods)solverSelect.SelectedValue;
simulationParameters.RelativeTolerance = (double)relativeTolerance.Value;
//Console.WriteLine("steptime=" + simulationParameters.StepTime);
//Console.WriteLine("snapshot=" + simulationParameters.SnapshotInterval);
//Console.WriteLine("simlength=" + simulationParameters.SimulationLength);
//Console.WriteLine("solver=" + simulationParameters.SolverMethod);
}
public void setSimulationParameters(SimulationParameters simulationParameters)
{
Console.WriteLine("Setting UI from simulation "+simulationParameters);
try
{
timeStep.Value = (decimal)simulationParameters.StepTime;
}
catch
{
MessageBox.Show("Invalid number (negative)", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
try
{
snapshotInterval.Value = (decimal)simulationParameters.SnapshotInterval;
}
catch
{
MessageBox.Show("Invalid number (negative)", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
try
{
simulationLength.Value = (decimal)simulationParameters.SimulationLength;
}
catch
{
MessageBox.Show("Invalid number (negative)", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
solverSelect.SelectedItem = simulationParameters.SolverMethod;
try
{
relativeTolerance.Value = (decimal)simulationParameters.RelativeTolerance;
}
catch
{
MessageBox.Show("Invalid number (negative)", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
public void setSimulationParameters(SimulationParameters simulationParameters)
{
//set viewState to display the initial state of the given simulation parameter set
spatialViewState = simulationParameters.EnvironmentViewState;
spatialViewState.SimParams = simulationParameters;
spatialViewState.InitialSimState = simulationParameters.InitialState;
OpenGLPanelXY.SpatialViewState = spatialViewState;
OpenGLPanelXZ.SpatialViewState = spatialViewState;
OpenGLPanel3D.SpatialViewState = spatialViewState;
setBoundaryShape(simulationParameters.InitialState.SimulationEnvironment.Boundary.Shape);
setBoundaryWidth(simulationParameters.InitialState.SimulationEnvironment.Boundary.Width);
setBoundaryHeight(simulationParameters.InitialState.SimulationEnvironment.Boundary.Height);
setBoundaryDepth(simulationParameters.InitialState.SimulationEnvironment.Boundary.Depth);
setBoundaryRadius(simulationParameters.InitialState.SimulationEnvironment.Boundary.Radius);
spatialViewState.UpdateCursorOutOfBounds();
controller.updateCellGroups();
controller.updateNutrientList();
setSelectedGroupByIndex(spatialViewState.SelectedGroupIndex);
setSelectedNutrientByIndex(spatialViewState.SelectedNutrientIndex);
updateNutrientFieldProperties();
updateAddCellsEnabled();
spatialViewState.UpdateSelectedGroupBox();
viscosityNumericUpDown.Value = (decimal)simulationParameters.InitialState.SimulationEnvironment.Viscosity;
collisionsCheckBox.Checked = simulationParameters.InitialState.SimulationEnvironment.EnableCellCollisions;
OpenGLPanelXY.Refresh();
OpenGLPanelXZ.Refresh();
OpenGLPanel3D.Refresh();
}
private void liftBoundaryShapeSelected(SimulationParameters paras)
{
//return if simulation is not yet set
if (controller.GetSelectedSimulationParameters() == null)
{
return;
}
if (cuboidRadioButton.Checked)
{
paras.InitialState.SimulationEnvironment.Boundary.Shape = BoundaryShapes.Cuboid;
}
else if (cylinderRadioButton.Checked)
{
paras.InitialState.SimulationEnvironment.Boundary.Shape = BoundaryShapes.Cylinder;
}
else if (sphereRadioButton.Checked)
{
paras.InitialState.SimulationEnvironment.Boundary.Shape = BoundaryShapes.Sphere;
}
}
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 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);
}
public bool exptEquals(SimulationParameters other)
{
if (this.StepTime != other.StepTime)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.StepTime='" + this.StepTime + "'; other.StepTime='" + other.StepTime);
return false;
}
if (this.SimulationLength != other.SimulationLength)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.SimulationLength='" + this.SimulationLength + "'; other.SimulationLength='" + other.SimulationLength);
return false;
}
if (this.SnapshotInterval != other.SnapshotInterval)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.SnapshotInterval='" + this.SnapshotInterval + "'; other.SnapshotInterval='" + other.SnapshotInterval);
return false;
}
if (this.RelativeTolerance != other.RelativeTolerance)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.RelativeTolerance='" + this.RelativeTolerance + "'; other.RelativeTolerance='" + other.RelativeTolerance);
return false;
}
if (this.CvodeType != other.CvodeType)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.CvodeType='" + this.CvodeType + "'; other.CvodeType='" + other.CvodeType);
return false;
}
if (this.SolverMethod != other.SolverMethod)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.SolverMethod='" + this.SolverMethod + "'; other.SolverMethod='" + other.SolverMethod);
return false;
}
if (this.InitialState.exptEquals(other.InitialState) == false)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.InitialState != other.InitialState");
return false;
}
try
{
for (int i = 0; i < this.TimeSeries.Count; i++)
{
if (this.TimeSeries[i].exptEquals(other.TimeSeries[i]) == false)
{
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("this.TimeSeries[" + i + "] != other.TimeSeries[" + i + "]");
return false;
}
}
}
catch (Exception e)
{
// Array out of bounds; lists are unequal
Console.Write("SimulationParameters objects not equal: ");
Console.WriteLine("List lengths differed");
return false;
}
return true;
}
/// <summary>
/// Initializes a cell model for simulation solving
/// </summary>
/// <param name="solverMethod">
/// A <see cref="Solver.SolverMethods"/>
/// </param>
/// <param name="parameters">
/// A <see cref="SimulationParameters"/>
/// </param>
public unsafe void InitializeCellModel(Solver.SolverMethods solverMethod, SimulationParameters parameters)
{
// Find out number of variable species
int n = 0;
foreach (Species s in this.species)
{
if (!s.BoundaryCondition)
{
n++;
}
}
this.N = n;
// Cvode method
if (solverMethod == Solver.SolverMethods.CVode_BDF_Newton || solverMethod == Solver.SolverMethods.CVode_Adams_Moulton)
{
double[] values = new double[n];
double[] absoluteTolerances = new double[n];
if (solverMethod == Solver.SolverMethods.CVode_BDF_Newton)
{
parameters.CvodeType = 2;
}
else
{
parameters.CvodeType = 1;
}
// Set initial values
foreach (Species s in this.species)
{
if (!s.BoundaryCondition)
{
// collect the initial values
values[speciesToIndexMap[s.ID]] = s.initialValue;
// collect the absolute tolerances
absoluteTolerances[speciesToIndexMap[s.ID]] = s.AbsoluteTolerance;
}
}
// Create CVODE interface object
this.solver = new Solver.CVode(n, values,
new Solver.CVode.ModelFunction(delegate(double time, IntPtr y, IntPtr ydot, IntPtr fdata)
{
double* yp = (double*)y.ToPointer();
double* ydotp = (double*)ydot.ToPointer();
int i;
double[] data = new double[this.N];
for (i = 0; i < this.N; i++)
{
data[i] = yp[i];
}
double[] result = this.ModelDeltaFunction(time, data);
// Get the values out
for (i = 0; i < this.N; i++)
{
ydotp[i] = result[i];
}
return 0;
}),
absoluteTolerances,
parameters.RelativeTolerance,
parameters.CvodeType);
}
else if (solverMethod == Solver.SolverMethods.Euler)
{
double[] values = new double[n];
// Set initial values
foreach (Species s in this.species)
{
if (!s.BoundaryCondition)
{
// collect the initial values
values[speciesToIndexMap[s.ID]] = s.initialValue;
}
}
this.solver = new Solver.Euler(n, values, this.ModelDeltaFunction);
}
else if (solverMethod == Solver.SolverMethods.RungeKutta)
{
double[] values = new double[n];
// Set initial values
foreach (Species s in this.species)
{
if (!s.BoundaryCondition)
{
// collect the initial values
values[speciesToIndexMap[s.ID]] = s.initialValue;
}
}
this.solver = new Solver.RungeKutta(n, values, this.ModelDeltaFunction);
}
}
