public IMoleculeAmount MapFrom(IMoleculeBuilder moleculeBuilder, IContainer targetContainer, IBuildConfiguration buildConfiguration)
{
//molecule amount always in amount
var moleculeAmount = _objectBaseFactory.Create <IMoleculeAmount>()
.WithName(moleculeBuilder.Name)
.WithDescription(moleculeBuilder.Description)
.WithContainerType(ContainerType.Molecule)
.WithIcon(moleculeBuilder.Icon)
.WithQuantityType(moleculeBuilder.QuantityType)
.WithDimension(_amountDimension)
.WithDisplayUnit(_amountDimension.UnitOrDefault(_amountDimension.DefaultUnit.Name));
buildConfiguration.AddBuilderReference(moleculeAmount, moleculeBuilder);
createMoleculeAmountDefaultFormula(moleculeBuilder, buildConfiguration, moleculeAmount);
//map parameters. Only parameters having BuildMode="Local" will
//be added to the molecule amount. Global/Property-Parameters
//will be filled in elsewhere (by the GlobalProperties-Mapper)
var allLocalParameters = moleculeBuilder.Parameters
.Where(x => x.BuildMode == ParameterBuildMode.Local)
.Where(x => x.ContainerCriteria?.IsSatisfiedBy(targetContainer) ?? true);
allLocalParameters.Each(x => moleculeAmount.Add(_parameterMapper.MapFrom(x, buildConfiguration)));
_keywordReplacerTask.ReplaceIn(moleculeAmount);
return(moleculeAmount);
}
public IParameter MapFrom(IParameter parameterBuilder, IBuildConfiguration buildConfiguration)
{
var parameter = _cloneManagerForModel.Clone(parameterBuilder);
buildConfiguration.AddBuilderReference(parameter, parameterBuilder);
return(parameter);
}
public IParameter MapFrom(IParameter parameterBuilder, IBuildConfiguration buildConfiguration)
{
var parameter = _cloneManagerForModel.Clone(parameterBuilder);
//We reset the container criteria explicitly in the model instance
parameter.ContainerCriteria = null;
buildConfiguration.AddBuilderReference(parameter, parameterBuilder);
return(parameter);
}
private IContainer addContainerUnder(IContainer parentContainer, IContainer templateContainer, string newContainerName, IBuildConfiguration buildConfiguration)
{
var instanceContainer = _containerTask.CreateOrRetrieveSubContainerByName(parentContainer, newContainerName);
buildConfiguration.AddBuilderReference(instanceContainer, templateContainer);
instanceContainer.Icon = templateContainer.Icon;
instanceContainer.Description = templateContainer.Description;
return(instanceContainer);
}
public IEventGroup MapFrom(IEventGroupBuilder eventGroupBuilder, IBuildConfiguration buildConfiguration)
{
var eventGroup = _objectBaseFactory.Create <IEventGroup>();
buildConfiguration.AddBuilderReference(eventGroup, eventGroupBuilder);
eventGroup.UpdatePropertiesFrom(eventGroupBuilder, _cloneManagerForModel);
eventGroup.EventGroupType = eventGroupBuilder.EventGroupType;
createEventGroupStructure(eventGroupBuilder, eventGroup, buildConfiguration);
return(eventGroup);
}
private void addActiveTransportToModel(IModel model, ITransportBuilder activeTransportBuilder, IEnumerable <INeighborhood> allNeighborhoods, IMoleculeBuilder molecule, TransporterMoleculeContainer transporterMolecule, IBuildConfiguration buildConfiguration)
{
var neighborhoods = getNeigborhoodsForActiveTransport(activeTransportBuilder, allNeighborhoods, molecule.Name, transporterMolecule.Name);
foreach (var neighborhood in neighborhoods)
{
var activeTransport = mapFrom(activeTransportBuilder, neighborhood, molecule.Name, buildConfiguration);
var activeTransportInMolecule = addActiveTransportToNeighborhood(neighborhood, activeTransport, transporterMolecule, molecule.Name, buildConfiguration);
buildConfiguration.AddBuilderReference(activeTransportInMolecule, activeTransportBuilder);
_keywordReplacerTask.ReplaceIn(activeTransport, model.Root, molecule.Name, neighborhood, transporterMolecule.TransportName, transporterMolecule.Name);
}
}
public IObserver MapFrom(IObserverBuilder observerBuilder, IBuildConfiguration buildConfiguration)
{
var observer = _objectBaseFactory.Create <IObserver>()
.WithName(observerBuilder.Name)
.WithIcon(observerBuilder.Icon)
.WithDescription(observerBuilder.Description)
.WithDimension(observerBuilder.Dimension)
.WithFormula(_formulaMapper.MapFrom(observerBuilder.Formula, buildConfiguration));
buildConfiguration.AddBuilderReference(observer, observerBuilder);
return(observer);
}
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);
}
private void addBuilderReference(IContainer container, IContainer containerBuilder, IBuildConfiguration buildConfiguration)
{
if (container == null || containerBuilder == null)
{
return;
}
buildConfiguration.AddBuilderReference(container, containerBuilder);
foreach (var childBuilder in containerBuilder.Children)
{
var child = container.GetSingleChildByName(childBuilder.Name);
if (child.IsAnImplementationOf <IContainer>())
{
addBuilderReference(child.DowncastTo <IContainer>(), childBuilder as IContainer, buildConfiguration);
}
else
{
buildConfiguration.AddBuilderReference(child, childBuilder);
}
}
}
private IContainer createReactionPropertiesContainer()
{
var globalReactionContainer = _containerTask.CreateOrRetrieveSubContainerByName(_model.Root, _reactionBuilder.Name)
.WithContainerType(ContainerType.Reaction)
.WithIcon(_reactionBuilder.Icon)
.WithDescription(_reactionBuilder.Description);
_buildConfiguration.AddBuilderReference(globalReactionContainer, _reactionBuilder);
//"Local"-Parameters will be filled in elsewhere (by the Reaction-Mapper)
_parameterMapper.MapGlobalOrPropertyFrom(_reactionBuilder, _buildConfiguration).Each(globalReactionContainer.Add);
_keywordReplacerTask.ReplaceIn(globalReactionContainer, _model.Root, _reactionBuilder.Name);
return(globalReactionContainer);
}
public ITransport MapFrom(ITransportBuilder transportBuilder, IBuildConfiguration buildConfiguration)
{
var transport = _objectBaseFactory.Create <ITransport>()
.WithName(transportBuilder.Name)
.WithIcon(transportBuilder.Icon)
.WithDimension(transportBuilder.Dimension)
.WithFormula(_formulaMapper.MapFrom(transportBuilder.Formula, buildConfiguration));
buildConfiguration.AddBuilderReference(transport, transportBuilder);
addLocalParameters(transport, transportBuilder, buildConfiguration);
//lastly, add parameter rate transporter if required
if (transportBuilder.CreateProcessRateParameter)
{
transport.Add(processRateParameterFor(transportBuilder, buildConfiguration));
}
return(transport);
}
public INeighborhood MapFrom(INeighborhoodBuilder neighborhoodBuilder, IModel model,
IBuildConfiguration buildConfiguration,
IEnumerable <string> moleculeNames,
IEnumerable <string> moleculeNamesWithCopyPropertiesRequired)
{
var neighborhood = _objectBaseFactory.Create <INeighborhood>();
neighborhood.UpdatePropertiesFrom(neighborhoodBuilder, _cloneManagerForModel);
buildConfiguration.AddBuilderReference(neighborhood, neighborhoodBuilder);
neighborhood.FirstNeighbor = resolveReference(model, neighborhoodBuilder.FirstNeighbor);
neighborhood.SecondNeighbor = resolveReference(model, neighborhoodBuilder.SecondNeighbor);
if (neighborhoodBuilder.MoleculeProperties != null)
{
moleculeNames.Each(moleculeName => neighborhood.Add(
createMoleculePropertiesFor(neighborhoodBuilder, moleculeName, model.Root, buildConfiguration, moleculeNamesWithCopyPropertiesRequired)));
}
//Add neighorhood parameter to the neighborhood (clone the existing parmeter)
neighborhoodBuilder.Parameters.Each(param => neighborhood.Add(_parameterMapper.MapFrom(param, buildConfiguration)));
return(neighborhood);
}
/// <summary>
/// Creates (molecule-specific) observers, stored under
/// molecule container of the corresponding molecule in the spatial structure
/// of the model.
/// Typical example is average drug concentration in an organ
/// </summary>
private void createContainerObserver(IContainerObserverBuilder observerBuilder, IModel model, IEnumerable <IMoleculeBuilder> presentMolecules)
{
var moleculeBuildersForObserver = moleculeBuildersValidFor(observerBuilder.MoleculeList, presentMolecules).ToList();
//retrieve a list here to avoid endless loop if observers criteria is not well defined
foreach (var container in _allContainers.Where(observerBuilder.ContainerCriteria.IsSatisfiedBy).ToList())
{
foreach (var moleculeBuilder in moleculeBuildersForObserver)
{
//get the molecule container defined for the molecule name
var moleculeContainer = container.GetSingleChildByName <IContainer>(moleculeBuilder.Name);
if (moleculeContainer == null)
{
//should only happen for a logical container.
moleculeContainer = _containerTask.CreateOrRetrieveSubContainerByName(container, moleculeBuilder.Name).WithContainerType(ContainerType.Molecule);
_buildConfiguration.AddBuilderReference(moleculeContainer, observerBuilder);
}
var observer = addObserverInContainer(observerBuilder, moleculeContainer, moleculeBuilder.QuantityType);
_keywordReplacerTask.ReplaceIn(observer, model.Root, moleculeBuilder.Name);
}
}
}
private void createMoleculeAmountDefaultFormula(IMoleculeBuilder moleculeBuilder, IBuildConfiguration buildConfiguration, IMoleculeAmount moleculeAmount)
{
//set start value formula to the default. If user has specified
//a new start value in MoleculesStartValueCollection-BB, default formula
//will be overwritten during setting of molecule start values
var modelFormula = _formulaMapper.MapFrom(moleculeBuilder.DefaultStartFormula, buildConfiguration);
//amount based, we can just the formula as is
if (moleculeBuilder.IsAmountBased())
{
moleculeAmount.Formula = modelFormula;
return;
}
//create a start value parameter that will be referenced in the molecule formula
var startValueParameter = _parameterFactory.CreateStartValueParameter(moleculeAmount, modelFormula, moleculeBuilder.DisplayUnit);
buildConfiguration.AddBuilderReference(startValueParameter, moleculeBuilder);
moleculeAmount.Add(startValueParameter);
moleculeAmount.Formula = _formulaFactory.CreateMoleculeAmountReferenceToStartValue(startValueParameter);
}
public IReaction MapFromLocal(IReactionBuilder reactionBuilder, IContainer container, IBuildConfiguration buildConfiguration)
{
var reaction = _objectBaseFactory.Create <IReaction>()
.WithName(reactionBuilder.Name)
.WithDescription(reactionBuilder.Description)
.WithIcon(reactionBuilder.Icon)
.WithDimension(reactionBuilder.Dimension)
.WithFormula(createReactionKinetic(reactionBuilder, buildConfiguration));
reactionBuilder.Educts.Each(reactionPartnerBuilder => reaction.AddEduct(_reactionPartnerMapper.MapFromLocal(reactionPartnerBuilder, container, buildConfiguration)));
reactionBuilder.Products.Each(reactionPartnerBuilder => reaction.AddProduct(_reactionPartnerMapper.MapFromLocal(reactionPartnerBuilder, container, buildConfiguration)));
reactionBuilder.ModifierNames.Each(reaction.AddModifier);
reaction.AddChildren(_parameterMapper.MapLocalFrom(reactionBuilder, buildConfiguration));
if (reactionBuilder.CreateProcessRateParameter)
{
reaction.Add(processRateParameterFor(reactionBuilder, buildConfiguration));
}
buildConfiguration.AddBuilderReference(reaction, reactionBuilder);
return(reaction);
}
public IEvent MapFrom(IEventBuilder eventBuilder, IBuildConfiguration buildConfiguration)
{
var modelEvent = _objectBaseFactory.Create <IEvent>()
.WithName(eventBuilder.Name)
.WithDimension(eventBuilder.Dimension)
.WithDescription(eventBuilder.Description)
.WithFormula(_formulaMapper.MapFrom(eventBuilder.Formula, buildConfiguration));
buildConfiguration.AddBuilderReference(modelEvent, eventBuilder);
eventBuilder.Assignments
.SelectMany(x => _assignmentMapper.MapFrom(x, buildConfiguration))
.Each(modelEvent.AddAssignment);
foreach (var param in eventBuilder.Parameters)
{
modelEvent.Add(_parameterMapper.MapFrom(param, buildConfiguration));
}
modelEvent.OneTime = eventBuilder.OneTime;
return(modelEvent);
}
public IParameter CreateProcessRateParameterFor(IProcessBuilder processBuilder, IBuildConfiguration buildConfiguration)
{
var parameter = _objectBaseFactory
.Create<IParameter>()
.WithName(Constants.Parameters.PROCESS_RATE)
.WithDimension(processBuilder.Dimension)
.WithFormula(_formulaMapper.MapFrom(processBuilder.Formula, buildConfiguration));
parameter.Visible = false;
parameter.Editable = false;
parameter.IsDefault = true;
addAdditionalParentReference(parameter.Formula);
buildConfiguration.AddBuilderReference(parameter, processBuilder);
if (processBuilder.ProcessRateParameterPersistable)
parameter.Persistable = true;
parameter.AddTag(processBuilder.Name);
parameter.AddTag(Constants.Parameters.PROCESS_RATE);
return parameter;
}
public void should_have_referenced_the_parameter_with_the_parmaeter_builder()
{
A.CallTo(() => _buildConfiguration.AddBuilderReference(_clonedParameter, _parameterBuilder)).MustHaveHappened();
}
public void should_have_added_a_reference_to_the_observer_builder_for_the_created_observer()
{
A.CallTo(() => _buildConfiguration.AddBuilderReference(_observer, _observerBuilder)).MustHaveHappened();
}
public void should_add_the_builder_to_the_build_configuration_cache()
{
A.CallTo(() => _buildConfiguration.AddBuilderReference(_moleculeAmount, _moleculeBuilder)).MustHaveHappened();
}