/// <summary>
/// Adds the neighbourhood that is necessary for the Passive Transport.
/// </summary>
private void AddNeighbourhood(IContainer reactantCompartment, IContainer productCompartment, Model model)
{
var existant = false;
if (GetMainSpatialStructure(model) == null)
{
return;
}
foreach (var n in GetMainSpatialStructure(model).Neighborhoods)
{
if (n.Name == (reactantCompartment.Id + "_" + productCompartment.Id))
{
existant = true;
}
}
if (existant)
{
return;
}
var nbuilder = ObjectBaseFactory.Create <INeighborhoodBuilder>()
.WithName(reactantCompartment.Id + "_" + productCompartment.Id)
.WithFirstNeighbor(reactantCompartment)
.WithSecondNeighbor(productCompartment);
GetMainSpatialStructure(model).AddNeighborhood(nbuilder);
}
/// <summary>
/// Creates the Local Parameters of the MoBi Reaction by the given local Parameters
/// of the SBML Reaction.
/// </summary>
private List <IParameter> CreateLocalParameters(Reaction sbmlReaction)
{
if (sbmlReaction.getKineticLaw() == null)
{
return(null);
}
if (sbmlReaction.getKineticLaw().getNumLocalParameters() <= 0)
{
return(null);
}
var parameter = new List <IParameter>();
for (long i = 0; i < sbmlReaction.getKineticLaw().getNumLocalParameters(); i++)
{
var p = sbmlReaction.getKineticLaw().getLocalParameter(i);
var formula = ObjectBaseFactory.Create <ConstantFormula>()
.WithValue(p.getValue());
var localParameter = ObjectBaseFactory.Create <IParameter>()
.WithName(p.getId())
.WithDescription(p.getNotesString())
.WithFormula(formula);
var dim = GetDimension(p);
if (dim != null)
{
localParameter.Dimension = dim;
}
if (localParameter != null)
{
parameter.Add(localParameter);
}
}
return(parameter);
}
/// <summary>
/// Creates a "standard" MoBi reaction by a given one compartment reaction.
/// </summary>
private void CreateStandardReaction(Reaction sbmlReaction, Model model)
{
var reactionBuilder = ObjectBaseFactory.Create <IReactionBuilder>()
.WithName(sbmlReaction.getId())
.WithDescription(sbmlReaction.getNotesString());
CreateModifiers(sbmlReaction, reactionBuilder, String.Empty, model);
var parameters = CreateLocalParameters(sbmlReaction);
if (parameters != null)
{
parameters.ForEach(reactionBuilder.AddParameter);
}
if (sbmlReaction.isSetKineticLaw())
{
CreateKineticLaw(sbmlReaction.getKineticLaw(), reactionBuilder, false);
}
CreateProducts(sbmlReaction, reactionBuilder, model);
CreateEducts(sbmlReaction, reactionBuilder, model);
if (reactionBuilder != null)
{
ReactionBuilderList.Add(reactionBuilder);
}
}
/// <summary>
/// Creates the Condition of the MoBi Event by the given SBML condition (= trigger).
/// </summary>
internal void CreateCondition(Trigger trigger)
{
var formula = _astHandler.Parse(trigger.getMath(), trigger.getId(), _sbmlProject, _sbmlInformation) ??
ObjectBaseFactory.Create <ExplicitFormula>().WithFormulaString(String.Empty).WithName(SBMLConstants.DEFAULT_FORMULA_NAME);
EventBuilder.Formula = formula;
}
/// <summary>
/// Creates a MoBi Parameter from a given SBML Parameter.
/// </summary>
public IFormulaUsable CreateParameter(Parameter sbmlParameter)
{
var value = 0.0;
if (sbmlParameter.isSetValue())
{
value = sbmlParameter.getValue();
}
IFormula formula = ObjectBaseFactory.Create <ConstantFormula>().WithValue(value);
var parameter = ObjectBaseFactory.Create <IParameter>()
.WithName(sbmlParameter.getId())
.WithFormula(formula);
if (!sbmlParameter.isSetUnits())
{
return(parameter);
}
if (_sbmlInformation.MobiDimension.ContainsKey(sbmlParameter.getUnits()))
{
parameter.Dimension = _sbmlInformation.MobiDimension[sbmlParameter.getUnits()];
}
return(parameter);
}
/// <summary>
/// This is for the special Species Assignment in a RateRule.
/// </summary>
private void DoSpeciesAssignment(Rule rule)
{
var formula = _astHandler.Parse(rule.getMath(), rule.getVariable(), true, _sbmlProject, _sbmlInformation);
if (formula == null)
{
return;
}
var reactionBuilder = ObjectBaseFactory.Create <IReactionBuilder>()
.WithName(SBMLConstants.RATE_RULE + rule.getMetaId())
.WithFormula(formula);
var product = CreateProduct(rule.getVariable());
reactionBuilder.AddProduct(product);
var rbb = GetMainReactionBuildingBlock();
if (rbb == null)
{
rbb = _reactionBuildingBlockFactory.Create()
.WithName(SBMLConstants.SBML_REACTION_BB);
_context.AddToHistory(new AddBuildingBlockCommand <IMoBiReactionBuildingBlock>(rbb));
}
rbb.FormulaCache.Add(formula);
rbb.Add(reactionBuilder);
}
/// <summary>
/// Creates the Mobi Event Assignment for one SBML Event Assignment.
/// </summary>
internal void CreateEventAssignment(EventAssignment eventAssignment)
{
_counter++;
var assignmentVar = eventAssignment.getVariable();
var alias = _sbmlInformation.AliasCreator.CreateAliasFrom(assignmentVar) + _counter;
var description = String.Empty;
if (eventAssignment.isSetNotes())
{
description += eventAssignment.getNotesString();
}
if (eventAssignment.isSetSBOTerm())
{
description += (SBMLConstants.SPACE + eventAssignment.getSBOTerm());
}
IEventAssignmentBuilder eab = new EventAssignmentBuilder()
.WithId(eventAssignment.getId() + SBMLConstants.SPACE + eventAssignment.getName() + SBMLConstants.SPACE + alias)
.WithName(SBMLConstants.SBML_EVENT_ASSIGNMENT + eventAssignment.getId())
.WithDescription(description);
var formula = _astHandler.Parse(eventAssignment.getMath(), eab, assignmentVar, _sbmlProject, _sbmlInformation) ??
ObjectBaseFactory.Create <ExplicitFormula>().WithFormulaString(String.Empty).WithName(SBMLConstants.DEFAULT_FORMULA_NAME);
eab.Formula = formula;
EventGroupBuildingBlock.FormulaCache.Add(formula);
EventBuilder.AddAssignment(eab);
}
protected override void Context()
{
_noDimension = A.Fake <IDimension>();
_dimensionFactory = A.Fake <IDimensionFactory>();
_creationMetaDataFactory = A.Fake <ICreationMetaDataFactory>();
A.CallTo(() => _dimensionFactory.NoDimension).Returns(_noDimension);
sut = new ObjectBaseFactory(IoC.Container, _dimensionFactory, new IdGenerator(), _creationMetaDataFactory);
}
public ReactionImporter(IObjectPathFactory objectPathFactory, IObjectBaseFactory objectBaseFactory, IMoBiDimensionFactory moBiDimensionFactory, ASTHandler astHandler, IMoBiContext context, IReactionBuildingBlockFactory reactionBuildingBlockFactory)
: base(objectPathFactory, objectBaseFactory, astHandler, context)
{
_dimensionFactory = moBiDimensionFactory;
ReactionBuilderList = new List <IReactionBuilder>();
_passiveTransportList = new List <ITransportBuilder>();
_reactionBuildingBlock = reactionBuildingBlockFactory.Create().WithName(SBMLConstants.SBML_REACTION_BB);
_passiveTransportBuildingBlock = ObjectBaseFactory.Create <IPassiveTransportBuildingBlock>()
.WithName(SBMLConstants.SBML_PASSIVETRANSPORTS_BB);
}
/// <summary>
/// Creates a container's size parameter to import the size of the particular SBML compartment.
/// </summary>
private IParameter CreateSizeParameter(Compartment compartment)
{
IFormula formula = ObjectBaseFactory.Create <ConstantFormula>().WithValue(compartment.getSize());
var sizeParameter = _objectBaseFactory.Create <IParameter>()
.WithName(SBMLConstants.SIZE)
.WithDescription(SBMLConstants.SBML_SIZE_DESCRIPTION)
.WithFormula(formula);
return(SetDimension(compartment, sizeParameter));
}
/// <summary>
/// Creates a Volume Parameter for a MoBi Container.
/// </summary>
private IEntity CreateVolumeParameter()
{
IFormula formula = ObjectBaseFactory.Create <ConstantFormula>().WithValue(1);
var volumeParameter = _objectBaseFactory.Create <IParameter>()
.WithName(SBMLConstants.VOLUME)
.WithDimension(_dimensionFactory.Dimension(OSPSuite.Core.Domain.Constants.Dimension.VOLUME))
.WithFormula(formula);
return(volumeParameter);
}
/// <summary>
/// Sets the Parameter Start Value of a given Parameter to the given Math Formula.
/// </summary>
protected internal void SetPSV(ASTNode math, IParameter parameter, string containerName)
{
if (parameter == null)
{
CreateErrorMsg();
return;
}
var formula = _astHandler.Parse(math, parameter.Name, false, _sbmlProject, _sbmlInformation);
if (formula == null)
{
return;
}
var psvbb = GetMainParameterStartValuesBuildingBlock();
if (psvbb == null)
{
return;
}
psvbb.AddFormula(formula);
foreach (var declaredPSV in psvbb.Where(declaredPSV => declaredPSV.Name == parameter.Name))
{
if (string.IsNullOrEmpty(containerName))
{
declaredPSV.Formula = formula;
return;
}
if (!declaredPSV.Path.Contains(containerName))
{
continue;
}
declaredPSV.Formula = formula;
return;
}
var psv = ObjectBaseFactory.Create <IParameterStartValue>()
.WithName(parameter.Name)
.WithFormula(formula)
.WithDimension(parameter.Dimension);
psvbb.Add(psv);
}
/// <summary>
/// Creates the Kinetic Formula for a passive Transport.
/// </summary>
private void CreateKinetic(Reaction sbmlReaction, ITransportBuilder passiveTransport)
{
_astHandler.NeedAbsolutePath = true;
var formula = sbmlReaction.getKineticLaw() == null
? ObjectBaseFactory.Create <ExplicitFormula>().WithFormulaString(String.Empty)
: _astHandler.Parse(sbmlReaction.getKineticLaw().getMath(), sbmlReaction.getId(), _sbmlProject, _sbmlInformation);
if (formula == null)
{
passiveTransport.Formula = ObjectBaseFactory.Create <ExplicitFormula>()
.WithFormulaString(String.Empty)
.WithName(SBMLConstants.DEFAULT_FORMULA_NAME);
}
else
{
passiveTransport.Formula = formula;
_passiveTransportBuildingBlock.FormulaCache.Add(formula);
}
}
protected override void Context()
{
base.Context();
var container = A.Fake <IContainer>();
var noDimension = A.Fake <IDimension>();
var dimensionFactory = A.Fake <IDimensionFactory>();
A.CallTo(() => dimensionFactory.NoDimension).Returns(noDimension);
var objectBaseFactory = new ObjectBaseFactory(container, dimensionFactory, new IdGenerator(), A.Fake <ICreationMetaDataFactory>());
_dataRepositoryTask = A.Fake <IDataRepositoryTask>();
_cloneManagerForBuildingBlock = new CloneManagerForBuildingBlock(objectBaseFactory, _dataRepositoryTask);
sut.ForAll = false;
sut.AddMoleculeName("A");
sut.AddMoleculeName("B");
sut.AddMoleculeNameToExclude("C");
sut.AddMoleculeNameToExclude("D");
}
/// <summary>
/// Creates the MoBi Reaction Formula by the given SBML Kinetic Law.
/// </summary>
private void CreateKineticLaw(KineticLaw kineticLaw, IReactionBuilder reactionBuilder, bool needAbsolutePath)
{
if (needAbsolutePath)
{
_astHandler.NeedAbsolutePath = true;
}
var formula = kineticLaw == null?ObjectBaseFactory.Create <ExplicitFormula>().WithFormulaString(String.Empty).WithName(SBMLConstants.DEFAULT_FORMULA_NAME) : _astHandler.Parse(kineticLaw.getMath(), reactionBuilder, _sbmlProject, _sbmlInformation);
if (formula == null)
{
reactionBuilder.Formula = ObjectBaseFactory.Create <ExplicitFormula>()
.WithFormulaString(String.Empty)
.WithName(SBMLConstants.DEFAULT_FORMULA_NAME);
}
else
{
reactionBuilder.Formula = formula;
_reactionBuildingBlock.FormulaCache.Add(formula);
}
}
/// <summary>
/// Creates a MoBi Parameter from a given SBML Parameter.
/// </summary>
public IFormulaUsable CreateParameter(Parameter sbmlParameter)
{
var value = 0.0;
if (sbmlParameter.isSetValue())
{
value = sbmlParameter.getValue();
}
if (!sbmlParameter.isSetUnits())
{
return(ObjectBaseFactory.Create <IParameter>()
.WithName(sbmlParameter.getId())
.WithFormula(ObjectBaseFactory.Create <ConstantFormula>().WithValue(value)));
}
var sbmlUnit = sbmlParameter.getUnits();
var baseValue = _unitDefinitionImporter.ToMobiBaseUnit(sbmlUnit, value);
return(ObjectBaseFactory.Create <IParameter>()
.WithName(sbmlParameter.getId())
.WithFormula(_formulaFactory.ConstantFormula(baseValue.value, baseValue.dimension))
.WithDimension(baseValue.dimension));
}
/// <summary>
/// Creates for each compartment of the SBML Reaction one "Ghostreaction" to import multicompartment reactions.
/// </summary>
private void CreateGhostReactions(Reaction sbmlReaction, Dictionary <string, List <SpeciesReference> > eductCompartmentMoleculeDictionary, Dictionary <string, List <SpeciesReference> > productCompartmentMoleculeDictionary, Model model)
{
var usedProducts = new List <string>();
foreach (var keyValuePair in eductCompartmentMoleculeDictionary)
{
var reactionBuilder = ObjectBaseFactory.Create <IReactionBuilder>()
.WithName(sbmlReaction.getId() + "_" + keyValuePair.Key + "_ghostReaction")
.WithDescription(sbmlReaction.getNotesString());
CreateModifiers(sbmlReaction, reactionBuilder, keyValuePair.Key, model);
var parameters = CreateLocalParameters(sbmlReaction);
if (parameters != null)
{
parameters.ForEach(reactionBuilder.AddParameter);
}
CreateKineticLaw(sbmlReaction.getKineticLaw(), reactionBuilder, true);
var compartmentName = keyValuePair.Key;
if (!_sbmlInformation.DummyNameContainerDictionary.ContainsValue(compartmentName))
{
return;
}
var dummyMolecule = _sbmlInformation.DummyNameContainerDictionary.FirstOrDefault(x => x.Value == compartmentName).Key;
reactionBuilder.AddModifier(dummyMolecule);
foreach (var species in keyValuePair.Value)
{
var reactionPartner = CreateReactionPartner(species, model);
if (reactionPartner != null)
{
reactionBuilder.AddEduct(reactionPartner);
}
}
if (productCompartmentMoleculeDictionary.ContainsKey(keyValuePair.Key))
{
usedProducts.Add(keyValuePair.Key);
var productsInThisCompartment = productCompartmentMoleculeDictionary[keyValuePair.Key];
foreach (var product in productsInThisCompartment)
{
var reactionPartner = CreateReactionPartner(product, model);
if (reactionPartner != null)
{
reactionBuilder.AddProduct(reactionPartner);
}
}
}
ReactionBuilderList.Add(reactionBuilder);
}
foreach (var keyValuePair in productCompartmentMoleculeDictionary)
{
if (usedProducts.Contains(keyValuePair.Key))
{
continue;
}
var reactionBuilder = ObjectBaseFactory.Create <IReactionBuilder>()
.WithName(sbmlReaction.getId() + "_" + keyValuePair.Key + "_ghostReaction")
.WithDescription(sbmlReaction.getNotesString());
CreateModifiers(sbmlReaction, reactionBuilder, keyValuePair.Key, model);
var parameters = CreateLocalParameters(sbmlReaction);
if (parameters != null)
{
parameters.ForEach(reactionBuilder.AddParameter);
}
CreateKineticLaw(sbmlReaction.getKineticLaw(), reactionBuilder, true);
var compartmentName = keyValuePair.Key;
if (!_sbmlInformation.DummyNameContainerDictionary.ContainsValue(compartmentName))
{
return;
}
var dummyMolecule = _sbmlInformation.DummyNameContainerDictionary.FirstOrDefault(x => x.Value == compartmentName).Key;
reactionBuilder.AddModifier(dummyMolecule);
foreach (var species in keyValuePair.Value)
{
var reactionPartner = CreateReactionPartner(species, model);
if (reactionPartner != null)
{
reactionBuilder.AddProduct(reactionPartner);
}
}
ReactionBuilderList.Add(reactionBuilder);
}
}
/// <summary>
/// Imports a SBML Reaction by creating a passive Transport.
/// </summary>
private void CreatePassiveTransport(Reaction sbmlReaction, Model model)
{
var reactant = sbmlReaction.getReactant(0).getSpecies();
var product = sbmlReaction.getProduct(0).getSpecies();
var reactantSpecies = GetSpeciesById(reactant, model);
var productSpecies = GetSpeciesById(product, model);
if (_sbmlInformation.MoleculeInformation.All(info => info.SpeciesIds.TrueForAll(s => s != reactant)))
{
return;
}
if (_sbmlInformation.MoleculeInformation.All(info => info.SpeciesIds.TrueForAll(s => s != product)))
{
return;
}
var molInfoReactant = _sbmlInformation.MoleculeInformation.FirstOrDefault(info => info.SpeciesIds.Contains(reactant));
var molInfoProduct = _sbmlInformation.MoleculeInformation.FirstOrDefault(info => info.SpeciesIds.Contains(product));
if (molInfoProduct == null)
{
return;
}
if (molInfoReactant == null)
{
return;
}
//must be the same Molecule
if (molInfoReactant.GetMoleculeBuilder() != molInfoProduct.GetMoleculeBuilder())
{
CreateErrorMessage();
}
var passiveTransport = ObjectBaseFactory.Create <ITransportBuilder>().WithName(sbmlReaction.getId());
passiveTransport.ForAll = false;
if (molInfoReactant.GetMoleculeBuilderName() == null)
{
return;
}
passiveTransport.MoleculeList.AddMoleculeName(molInfoReactant.GetMoleculeBuilderName());
var reactantCompartment = GetContainerFromCompartment_(molInfoReactant.GetCompartment(reactantSpecies));
var productCompartment = GetContainerFromCompartment_(molInfoProduct.GetCompartment(productSpecies));
if (reactantCompartment != null && productCompartment != null)
{
var reactantMatchTag = new MatchTagCondition(reactantCompartment.Name);
var productMatchTag = new MatchTagCondition(productCompartment.Name);
passiveTransport.SourceCriteria.Add(reactantMatchTag);
passiveTransport.TargetCriteria.Add(productMatchTag);
}
var parameters = CreateLocalParameters(sbmlReaction);
if (parameters != null)
{
parameters.ForEach(passiveTransport.AddParameter);
}
CreateKinetic(sbmlReaction, passiveTransport);
AddNeighbourhood(reactantCompartment, productCompartment, model);
_passiveTransportBuildingBlock.Add(passiveTransport);
}
/// <summary>
/// Creates the Molecule - and the Molecule Start Values Building Block.
/// </summary>
internal void CreateMoleculeBuildingBlock()
{
MoleculeBuildingBlock = ObjectBaseFactory.Create <IMoleculeBuildingBlock>()
.WithName(SBMLConstants.SBML_SPECIES_BB);
}
