// calculate all mid positions, using the structure of the class MidPoint
public MidPoint[,] calculate_mid_positions(MidPoint[,] pos)
{
int zStart = 50; // z-axis beginning
int xStart = -50; // x-axis beginning
// world representation of 10 x 10 areas
for (int z = 0; z < 10; z++)
{
for (int x = 0; x < 10; x++)
{
Point checking_mid_point = new Point {
x_coord = xStart + 5, z_coord = zStart - 5
};
MidPoint new_mid_point = new MidPoint
{
x_index = x,
z_index = z,
x_position = (xStart + 5),
z_position = (zStart - 5),
type = getObstacleType(checking_mid_point)
};
pos[x, z] = new_mid_point;
xStart = xStart + 10;
}
xStart = -50;
zStart = zStart - 10;
}
return(pos);
}
public void CheckParametersTest()
{
var configString = @"{""solver"":""MID"",""midpoint"":{""epsilon"": -1}}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
var modelInfo = EmodlLoader.LoadEMODLFile("resources//testmodelTau.emodl");
const float duration = 6.28318531f;
const int repeats = 42;
const int samples = 100;
try
{
var unused = new MidPoint(modelInfo, duration, repeats, samples);
Assert.Fail();
}
catch (ApplicationException ex)
{
Assert.That(ex.GetBaseException().ToString(), Is.StringContaining("Epsilon was set to less than or equal to zero."));
}
configString = @"{""solver"":""MID"",""midpoint"":{""Nc"": -1}}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
try
{
var unused = new MidPoint(modelInfo, duration, repeats, samples);
Assert.Fail();
}
catch (ApplicationException ex)
{
Assert.That(ex.GetBaseException().ToString(), Is.StringContaining("Nc was et to less than zero or equal to zero."));
}
configString = @"{""solver"":""MID"",""midpoint"":{""Multiple"": -1}}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
try
{
var unused = new MidPoint(modelInfo, duration, repeats, samples);
Assert.Fail();
}
catch (ApplicationException ex)
{
Assert.That(ex.GetBaseException().ToString(), Is.StringContaining("Multiple was set to less than or equal to zero."));
}
configString = @"{""solver"":""MID"",""midpoint"":{""SSARuns"": 0}}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
try
{
var unused = new MidPoint(modelInfo, duration, repeats, samples);
Assert.Fail();
}
catch (ApplicationException ex)
{
Assert.That(ex.GetBaseException().ToString(), Is.StringContaining("SSAruns was set to less than one."));
}
}
// Use this for initialization
void Start()
{
body = GetComponent <Rigidbody>();
if (springConnection != null)
{
mid = springConnection.GetComponent <MidPoint>();
}
}
public ActionResult DeleteConfirmed(int id)
{
MidPoint midPoint = db.MidPoints.Find(id);
db.MidPoints.Remove(midPoint);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static MidPoint CreateMidPoint(Drawing drawing, IList <IFigure> dependencies)
{
var result = new MidPoint()
{
Drawing = drawing, Dependencies = dependencies
};
return(result);
}
public ActionResult Edit([Bind(Include = "MidPointID,MidPointName,MidPointLatitude,MidPointLongitude")] MidPoint midPoint)
{
if (ModelState.IsValid)
{
db.Entry(midPoint).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(midPoint));
}
public ActionResult Create([Bind(Include = "MidPointID,MidPointName,MidPointLatitude,MidPointLongitude")] MidPoint midPoint)
{
if (ModelState.IsValid)
{
db.MidPoints.Add(midPoint);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(midPoint));
}
public IHttpActionResult GetMidPoint(int id)
{
MidPoint midPoint = db.MidPoints.Find(id);
if (midPoint == null)
{
return(NotFound());
}
return(Ok(midPoint));
}
private static MidPoint InstantiateSolver()
{
const string configString = @"{""solver"":""MID""}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
ModelInfo modelInfo = EmodlLoader.LoadEMODLFile("resources//testmodel.emodl");
var solver = new MidPoint(modelInfo, 6.28318531f, 42, 100);
return(solver);
}
public void TestFireReaction()
{
SpeciesDescription info1;
SpeciesMP reactant1;
CreateSpeciesInfoAndSpecies("reactant1", 10, out info1, out reactant1);
SpeciesDescription info2;
SpeciesMP reactant2;
CreateSpeciesInfoAndSpecies("reactant2", 40, out info2, out reactant2);
SpeciesDescription info3;
SpeciesMP product1;
CreateSpeciesInfoAndSpecies("product1", 90, out info3, out product1);
float rate = 1;
Reaction reaction = CreateReaction(info1, reactant1, info2, reactant2, info3, product1, rate);
MidPoint solver = InstantiateSolver();
// Partial, exploratory leap
solver.FireReaction(reaction, 0.25f);
Assert.AreEqual(9.75f, reactant1.Value);
Assert.AreEqual(39.75f, reactant2.Value);
Assert.AreEqual(90.25f, product1.Value);
// Finish leap
solver.FireReaction(reaction, 0.75f);
Assert.AreEqual(9, reactant1.Count);
Assert.AreEqual(39, reactant2.Count);
Assert.AreEqual(91, product1.Count);
// Partial, exploratory leap
solver.FireReaction(reaction, 4.5f);
Assert.AreEqual(4.5f, reactant1.Value);
Assert.AreEqual(34.5f, reactant2.Value);
Assert.AreEqual(95.5f, product1.Value);
// Undo part of the leap
solver.FireReaction(reaction, -1.5f);
Assert.AreEqual(6, reactant1.Count);
Assert.AreEqual(36, reactant2.Count);
Assert.AreEqual(94, product1.Count);
// Test using a fractional number that can not be exactly represented by a binary/floating point
var change = (float)(1.0 / 3.0);
solver.FireReaction(reaction, change);
Assert.AreEqual(5.66666651f, reactant1.Value);
Assert.AreEqual(35.66666651f, reactant2.Value);
Assert.AreEqual(94.3333359f, product1.Value);
}
public void TestToString()
{
const string configString = @"{""solver"":""MID""}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
ModelInfo modelInfo = EmodlLoader.LoadEMODLFile("resources\\testmodel.emodl");
const float duration = 6.28318531f;
const int repeats = 42;
const int samples = 100;
var solver = new MidPoint(modelInfo, duration, repeats, samples);
Assert.AreEqual("Mid-Point", solver.ToString());
}
// GET: MidPoints/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MidPoint midPoint = db.MidPoints.Find(id);
if (midPoint == null)
{
return(HttpNotFound());
}
return(View(midPoint));
}
public void TestCatchNaNPropensityMidpoint()
{
const string configString = @"{""solver"":""MidPoint""}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
ModelInfo modelInfo = EmodlLoader.LoadEMODLFile("resources\\nanpropensity.emodl");
const double duration = 6.28318531;
const int repeats = 42;
const int samples = 100;
var solver = new MidPoint(modelInfo, duration, repeats, samples);
solver.Solve();
Assert.Fail("Execution should fail on reaction propensity evaluates to NaN.");
}
public void TestMidPointConstructorWithDefaults()
{
const string configString = @"{""solver"":""MID""}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
ModelInfo modelInfo = EmodlLoader.LoadEMODLFile("resources\\testmodel.emodl");
const double duration = 6.28318531;
const int repeats = 42;
const int samples = 100;
var solver = new MidPoint(modelInfo, duration, repeats, samples);
Assert.AreEqual(0.01, ReflectionUtility.GetHiddenField <double>("epsilon", solver));
Assert.AreEqual(2, ReflectionUtility.GetHiddenField <int>("nc", solver));
Assert.AreEqual(10, ReflectionUtility.GetHiddenField <int>("multiple", solver));
Assert.AreEqual(100, ReflectionUtility.GetHiddenField <int>("SSAruns", solver));
string regimeName = ReflectionUtility.GetSolverRegimeName(solver);
Assert.AreEqual("Leaping", regimeName);
}
public void TestMidPointConstructor()
{
const string configString = @"{""solver"":""MID"",""midpoint"":{""epsilon"":0.02,""Nc"":3,""Multiple"":8,""SSARuns"":50}}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
ModelInfo modelInfo = EmodlLoader.LoadEMODLFile("resources\\testmodel.emodl");
const float duration = 6.28318531f;
const int repeats = 42;
const int samples = 100;
var solver = new MidPoint(modelInfo, duration, repeats, samples);
Assert.AreEqual(0.02f, ReflectionUtility.GetHiddenField <float>("epsilon", solver));
Assert.AreEqual(3, ReflectionUtility.GetHiddenField <int>("nc", solver));
Assert.AreEqual(8, ReflectionUtility.GetHiddenField <int>("multiple", solver));
Assert.AreEqual(50, ReflectionUtility.GetHiddenField <int>("SSAruns", solver));
string regimeName = ReflectionUtility.GetSolverRegimeName(solver);
Assert.AreEqual("Leaping", regimeName);
}
public void TestFireNonCriticalReactions()
{
const string configString = @"{""solver"":""MID"",""prng_seed"":123, ""prng_index"":1,""RNG"":{""type"":""PSEUDODES""}}";
Configuration.CurrentConfiguration = Configuration.ConfigurationFromString(configString);
ModelInfo modelInfo = EmodlLoader.LoadEMODLFile("resources\\testmodelMidPoint.emodl");
const float duration = 6.28318531f;
const int repeats = 42;
const int samples = 100;
var solver = new MidPoint(modelInfo, duration, repeats, samples);
//Inputs for the method
// Tau Step
float tau1 = 0.0f;
var tau2 = (1.0f / 200.0f);
//Need a list of reactions
var currentRates = ReflectionUtility.GetHiddenField <float[]>("_currentRates", solver);
var nonCriticalReaction = new List <Reaction>();
//Find Hidden Method to in order to initialize the population of each of the species
MethodInfo resetModelStateMethod = ReflectionUtility.GetHiddenMethod("ResetModelState", solver);
resetModelStateMethod.Invoke(solver, null);
MethodInfo updateAndSumRatesMethod = ReflectionUtility.GetHiddenMethod("UpdateAndSumRates", solver);
var model = ReflectionUtility.GetHiddenField <Model>("model", solver);
nonCriticalReaction.Add(model.Reactions[0]);
object[] inputArray1 = new object[3];
inputArray1[0] = tau1; inputArray1[1] = nonCriticalReaction; inputArray1[2] = currentRates;
object[] inputArray2 = new object[3];
inputArray2[0] = tau2; inputArray2[1] = nonCriticalReaction; inputArray2[2] = currentRates;
MethodInfo fireNonCriticalReactionsMethod = ReflectionUtility.GetHiddenMethod("FireNonCriticalReactions", solver);
// First Test if Tau = 0;
fireNonCriticalReactionsMethod.Invoke(solver, inputArray1);
Assert.AreEqual(400, model.Species[0].Value);
Assert.AreEqual(200, model.Species[1].Value);
Assert.AreEqual(900, model.Species[2].Value);
//Second Test if Tau = 0.05 (Not Zero).
ReflectionUtility.RunResetRngFactory();
ReflectionUtility.SetHiddenField("_distributionSampler", solver, RandLibSampler.CreateRandLibSampler(RNGFactory.GetRNG()));
fireNonCriticalReactionsMethod.Invoke(solver, inputArray2);
Assert.AreEqual(383.0f, model.Species[0].Value);
Assert.AreEqual(183.0f, model.Species[1].Value);
Assert.AreEqual(917.0f, model.Species[2].Value);
resetModelStateMethod.Invoke(solver, null);
object[] inputArray3 = new object[2];
inputArray3[0] = model.Reactions; inputArray3[1] = currentRates;
updateAndSumRatesMethod.Invoke(solver, inputArray3);
ReflectionUtility.RunResetRngFactory();
ReflectionUtility.SetHiddenField("_distributionSampler", solver, RandLibSampler.CreateRandLibSampler(RNGFactory.GetRNG()));
fireNonCriticalReactionsMethod.Invoke(solver, inputArray2);
Assert.AreEqual(383.0f, model.Species[0].Value);
Assert.AreEqual(183.0f, model.Species[1].Value);
Assert.AreEqual(917.0f, model.Species[2].Value);
}
public static ISolver CreateSolver(string solverName, ModelInfo model, int repeats, double duration, int samples)
{
ISolver solver;
switch (solverName.ToUpper())
{
/*
* SSA and variants
*/
case "SSA":
case "GILLESPIE":
case "GILLESPIEDIRECT":
solver = new Gillespie(model, duration, repeats, samples);
break;
case "FIRST":
case "FIRSTREACTION":
case "GILLESPIEFIRSTREACTION":
solver = new GillespieFirstReaction(model, duration, repeats, samples);
break;
case "NEXT":
case "NEXTREACTION":
case "GIBSONBRUCK":
solver = new GibsonBruck(model, duration, repeats, samples);
break;
case "HYBRID":
solver = new HybridSSA(model, duration, repeats, samples);
break;
/*
* Leaping solvers
*/
case "TAU":
case "TAULEAPING":
solver = new TauLeaping(model, duration, repeats, samples);
break;
case "MID":
case "MP":
case "MIDPOINT":
solver = new MidPoint(model, duration, repeats, samples);
break;
case "R":
case "RLEAPING":
solver = new RLeaping(model, duration, repeats, samples);
break;
case "RF":
case "RFAST":
case "RLEAPINGFAST":
solver = new RLeapingFast(model, duration, repeats, samples);
break;
case "BLEAP":
case "BLEAPING":
case "B":
solver = new BLeaping(model, duration, repeats, samples);
break;
/*
* Diffusion/migration solvers
*/
case "TSSA":
case "TRANSPORTSSA":
case "DIFFUSIONSSA":
case "ISSA":
solver = new TransportSSA(model, duration, repeats, samples);
break;
case "DFSP":
case "DIFFUSIONFSP":
case "TRANSPORTFSP":
solver = new DFSP(model, duration, repeats, samples);
break;
case "DFSPPRIME":
case "OTSSA":
case "OPTIMALTRANSPORTSSA":
solver = new OptimalTransportSSA(model, duration, repeats, samples);
break;
case "LEVY":
case "LEVYFLIGHT":
case "FRACTIONAL":
case "FRACTIONALDIFFUSION":
case "FD":
solver = new FractionalDiffusion(model, duration, repeats, samples);
break;
/*
* Specialty solvers
*/
case "ET":
case "EXITTIME":
case "EXITTIMES":
case "TS":
case "TIMESTRETCHING":
solver = new ExitTimes(model, duration, repeats, samples);
break;
case "DWSSA":
solver = new dwSSA(model, duration, repeats, samples);
break;
case "SDWSSA":
solver = new sdwSSA(model, duration, repeats, samples);
break;
default:
Console.Error.WriteLine("Unknown solver selection '{0}'.", solverName);
throw new ArgumentException(string.Format("Unknown solver '{0}'", solverName), "solverName");
}
return(solver);
}
public GoDown(MidPoint characterPosition)
{
this._characterPosition = characterPosition;
}
public GoRest(MidPoint characterPosition)
{
this._characterPosition = characterPosition;
}
protected override IFigure CreateFigure()
{
MidPoint result = Factory.CreateMidPoint(FoundDependencies);
return(result);
}
public void setCharacterPosition(MidPoint _characterPosition)
{
this.characterPosition = _characterPosition;
}
public ISingleFrameExtendedResults GetData()
{
ISingleFrameExtendedResults result = ModelResolver.Resolve <ISingleFrameExtendedResults>();
if (HeadPoints != null)
{
result.HeadPoints = HeadPoints.Select(x => x.GetPoint()).ToArray();
}
else
{
result.HeadPoints = null;
}
if (BodyContour != null)
{
result.BodyContour = BodyContour.Select(x => x.GetPoint()).ToArray();
}
else
{
result.BodyContour = null;
}
if (HeadPoint != null)
{
result.HeadPoint = HeadPoint.GetPoint();
result.MidPoint = MidPoint.GetPoint();
}
if (SmoothedHeadPoint != null)
{
result.SmoothedHeadPoint = SmoothedHeadPoint.GetPoint();
}
if (Orientation != null)
{
result.Orientation = Orientation.GetVector();
}
result.CentroidSize = CentroidSize;
result.PelvicArea = PelvicArea;
result.Velocity = Velocity;
result.AngularVelocity = AngularVelocity;
result.Distance = Distance;
result.PelvicArea2 = PelvicArea2;
result.PelvicArea3 = PelvicArea3;
result.PelvicArea4 = PelvicArea4;
if (Centroid != null)
{
result.Centroid = Centroid.GetPoint();
}
if (Whiskers != null)
{
result.Whiskers = Whiskers.GetWhiskerCollection();
}
if (AllWhiskers != null)
{
result.AllWhiskers = AllWhiskers.GetWhiskerCollection();
}
if (BestTrackedWhisker != null)
{
result.BestTrackedWhisker = BestTrackedWhisker.GetWhiskerCollection();
}
result.DataLoadComplete();
return(result);
}
public GoSleep(MidPoint characterPosition)
{
this._characterPosition = characterPosition;
}
