public void TestSerialization()
{
EventBuilder x1 = CreateObject <EventBuilder>().WithName("Eve.Builder").WithDimension(DimensionLength);
x1.Formula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4);
x1.OneTime = true;
IFormula f1 = CreateObject <ExplicitFormula>().WithDimension(DimensionLength).WithFormulaString("3*Patty");
IFormulaUsablePath fup = new FormulaUsablePath(new string[] { "Patricia" }).WithAlias("Patty").WithDimension(DimensionLength);
f1.AddObjectPath(fup);
IFormula f2 = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4);
IParameter p1 = WithExtensions.WithValue <Parameter>(CreateObject <Parameter>().WithName("Patricia").WithFormula(f1), 3.1);
IParameter p2 = WithExtensions.WithValue <Parameter>(CreateObject <Parameter>().WithName("Pascal").WithFormula(f1), 3.2);
x1.AddParameter(p1);
x1.AddParameter(p2);
IEventAssignmentBuilder eab1 = CreateObject <EventAssignmentBuilder>().WithDimension(DimensionLength).WithFormula(f1).WithName("eab1");
IEventAssignmentBuilder eab2 = CreateObject <EventAssignmentBuilder>().WithFormula(f2).WithName("eab2");
x1.AddAssignment(eab1);
x1.AddAssignment(eab2);
var x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualEventBuilder(x1, x2);
}
public EventAssignmentBuilderDTO MapFrom(IEventAssignmentBuilder eventAssignmentBuilder)
{
var dto = Map <EventAssignmentBuilderDTO>(eventAssignmentBuilder);
dto.ChangedEntityPath = eventAssignmentBuilder.ObjectPath == null ? string.Empty : eventAssignmentBuilder.ObjectPath.PathAsString;
dto.NewFormula = _formulaDTOMapper.MapFrom(eventAssignmentBuilder.Formula);
dto.UseAsValue = eventAssignmentBuilder.UseAsValue;
return(dto);
}
public SetEventAssignmentObjectPathCommand(IEventAssignmentBuilder assignment, IFormulaUsablePath newObjectPath, IBuildingBlock buildingBlock)
: base(buildingBlock)
{
_assignment = assignment;
_assignmentId = assignment.Id;
_newObjectPath = newObjectPath;
_oldObjectPath = _assignment.ObjectPath as IFormulaUsablePath;
ObjectType = ObjectTypes.EventAssignmentBuilder;
CommandType = AppConstants.Commands.EditCommand;
}
public IReadOnlyList <IEventAssignment> MapFrom(IEventAssignmentBuilder assignmentBuilder, IBuildConfiguration buildConfiguration)
{
if (!isForAllFloating(assignmentBuilder))
{
return new[] { createAssignment(assignmentBuilder, buildConfiguration) }
}
;
return(buildConfiguration.Molecules.AllFloating()
.Select(x => createMoleculeAssignment(x, assignmentBuilder, buildConfiguration))
.ToList());
}
public void Visit(IEventAssignmentBuilder eventAssignmentBuilder)
{
Visit(eventAssignmentBuilder as IUsingFormula);
if (!eventAssignmentBuilder.ObjectPath.Contains(_oldName))
{
return;
}
var oldPath = eventAssignmentBuilder.ObjectPath;
var newPath = generateNewPath(eventAssignmentBuilder.ObjectPath);
_changes.Add(eventAssignmentBuilder, _buildingBlock, new EditObjectBasePropertyInBuildingBlockCommand(_eventObjectPathPropertyName, newPath, oldPath, eventAssignmentBuilder, _buildingBlock));
}
public void TestSerialization()
{
EventAssignmentBuilder x1 = CreateObject <EventAssignmentBuilder>().WithName("Eva.Builder").WithDimension(DimensionLength);
x1.UseAsValue = true;
x1.ObjectPath = new ObjectPath(new string[] { "aa", "bb" });
x1.Dimension = DimensionLength;
x1.Formula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4);
IEventAssignmentBuilder x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualEventAssignmentBuilder(x1, x2);
}
public IEventAssignment MapFrom(IEventAssignmentBuilder assignmentBuilder, IBuildConfiguration buildConfiguration)
{
var assignment = _objectBaseFactory.Create <IEventAssignment>()
.WithName(assignmentBuilder.Name)
.WithDimension(assignmentBuilder.Dimension)
.WithFormula(_formulaMapper.MapFrom(assignmentBuilder.Formula, buildConfiguration));
assignment.ObjectPath = assignmentBuilder.ObjectPath.Clone <IObjectPath>();
assignment.UseAsValue = assignmentBuilder.UseAsValue;
buildConfiguration.AddBuilderReference(assignment, assignmentBuilder);
return(assignment);
}
/// <summary>
/// Parses a SBML MathML expression from a SBML Event Assignment into a MoBi Formula.
/// </summary>
/// <param name="rootNode"> The MathMl Expression of the SBML Event Assignment the assignmentVariable should be assigned with.</param>
/// <param name="eventAssignmentBuilder"> The MoBi Event Assignment Builder the SBML Event Assigment should be build with. </param>
/// <param name="assignmentVariable"> The Parameter, Molecule, Species or SpeciesReference that should be assigned when the Event is triggered. </param>
/// <param name="sbmlProject"></param>
/// <param name="sbmlInformation"></param>
public IFormula Parse(ASTNode rootNode, IEventAssignmentBuilder eventAssignmentBuilder, string assignmentVariable,
IMoBiProject sbmlProject, SBMLInformation sbmlInformation)
{
try
{
_sbmlProject = sbmlProject;
_sbmlInformation = sbmlInformation;
_counter++;
var formulaString = Eval(rootNode);
if (string.IsNullOrEmpty(formulaString))
{
return(null);
}
var formula = _objectBaseFactory.Create <ExplicitFormula>()
.WithName(SBMLConstants.SBML_EVENT_ASSIGNMENT + assignmentVariable + _counter)
.WithFormulaString(formulaString);
foreach (var opath in _objectPaths.Where(opath => opath != null))
{
formula.AddObjectPath(opath);
}
var path = getObjectPathForAssignment(assignmentVariable);
if (path != null)
{
eventAssignmentBuilder.ObjectPath = path;
}
if (string.IsNullOrEmpty(formula?.FormulaString))
{
createErrorMsg(rootNode);
return(null);
}
else
{
return(formula);
}
}
finally
{
_sbmlProject = null;
_sbmlInformation = null;
}
}
protected override void Context()
{
base.Context();
var eg1 = new EventGroupBuilder().WithName("Events");
var app1 = new ApplicationBuilder().WithName("App").WithParentContainer(eg1);
app1.MoleculeName = "Drug";
var c1 = new Container().WithName("ProtocolSchemaItem").WithParentContainer(app1);
_e1 = new EventBuilder().WithName("Event").WithParentContainer(app1);
_eventAssignmentBuilder1 = new EventAssignmentBuilder();
_eventAssignmentBuilder1.ObjectPath = new ObjectPath("Sim|A|B|C");
_eventAssignmentBuilder1.Name = "EAB";
_eventAssignmentBuilder1.UseAsValue = true;
_eventAssignmentBuilder1.Formula = new ExplicitFormula("a+b");
_e1.AddAssignment(_eventAssignmentBuilder1);
_explicitFormula1 = new ExplicitFormula("1+2");
_p1 = new Parameter().WithName("P").WithFormula(_explicitFormula1).WithParentContainer(c1);
var eg2 = new EventGroupBuilder().WithName("Events");
var app2 = new ApplicationBuilder().WithName("App").WithParentContainer(eg2);
app2.MoleculeName = "Drug";
var c2 = new Container().WithName("ProtocolSchemaItem").WithParentContainer(app2);
var e2 = new EventBuilder().WithName("Event").WithParentContainer(app2);
var eventAssignmentBuilder2 = new EventAssignmentBuilder();
eventAssignmentBuilder2.ObjectPath = new ObjectPath("Sim|A|B|C");
eventAssignmentBuilder2.Name = "EAB";
eventAssignmentBuilder2.UseAsValue = false;
eventAssignmentBuilder2.Formula = new ExplicitFormula("a+b");
e2.AddAssignment(eventAssignmentBuilder2);
var p2 = new Parameter().WithName("P").WithFormula(new ExplicitFormula("2+1")).WithParentContainer(c2);
_object1 = eg1;
_object2 = eg2;
}
public override void RestoreExecutionData(IMoBiContext context)
{
base.RestoreExecutionData(context);
_assignment = context.Get <IEventAssignmentBuilder>(_assignmentId);
}
protected override void ClearReferences()
{
base.ClearReferences();
_assignment = null;
}
public void AddAssignment(IEventAssignmentBuilder assignment)
{
Add(assignment);
}
protected override void Context()
{
base.Context();
_root = new Container().WithName("Root");
_eventAssignment = new EventAssignmentBuilder().WithName("Container").WithParentContainer(_root);
}
public IEnumerable <IObjectBase> RetrieveFor(IEventAssignmentBuilder eventAssignment)
{
return(new IObjectBase[] { eventAssignment.RootContainer });
}
public void RemoveAssignment(IEventAssignmentBuilder assignment)
{
RemoveChild(assignment);
}
private bool isForAllFloating(IEventAssignmentBuilder assignmentBuilder) => assignmentBuilder.ObjectPath.Contains(ObjectPathKeywords.ALL_FLOATING_MOLECULES);
private IEventAssignment createMoleculeAssignment(IMoleculeBuilder moleculeBuilder, IEventAssignmentBuilder assignmentBuilder, IBuildConfiguration buildConfiguration)
{
//We change the original name to ensure unicity in the container.
//Assignment are named programatically and not by the user so there should not be any conflict.
var name = $"{assignmentBuilder.Name}_{moleculeBuilder.Name}";
var assignment = createAssignment(assignmentBuilder, buildConfiguration, name);
assignment.ObjectPath.Replace(ObjectPathKeywords.ALL_FLOATING_MOLECULES, moleculeBuilder.Name);
return(assignment);
}
