private void addLiverZoneCompartmentObserver(IObserverBuilder observerBuilder, string compartment, IObserverBuildingBlock observerBuildingBlock, Compound compound)
{
var observerName = CoreConstants.CompositeNameFor(observerBuilder.Name, CoreConstants.Organ.Liver, compartment);
if (observerBuildingBlock.ExistsByName(observerName))
{
return;
}
var observer = _objectBaseFactory.Create <IContainerObserverBuilder>()
.WithName(observerName)
.WithDimension(_dimensionRepository.Fraction);
observer.ForAll = false;
observerBuilder.MoleculeNames().Each(observer.AddMoleculeName);
observer.ContainerCriteria = Create.Criteria(x => x.With(CoreConstants.Organ.Liver)
.And.With(compartment)
.And.Not(CoreConstants.Compartment.Pericentral)
.And.Not(CoreConstants.Compartment.Periportal));
var formula = _objectBaseFactory.Create <ExplicitFormula>()
.WithName(observerName)
.WithFormulaString("(M_periportal + M_pericentral)/" + TOTAL_DRUG_MASS_ALIAS)
.WithDimension(_dimensionRepository.Fraction);
formula.AddObjectPath(createZoneAmoutPath(compartment, CoreConstants.Compartment.Periportal, "M_periportal"));
formula.AddObjectPath(createZoneAmoutPath(compartment, CoreConstants.Compartment.Pericentral, "M_pericentral"));
formula.AddObjectPath(createTotalDrugMassObjectPath(compound.Name));
observer.Formula = formula;
observerBuildingBlock.Add(observer);
observerBuildingBlock.AddFormula(formula);
}
protected override void Context()
{
_context = A.Fake <IMoBiContext>();
_buildingBlock = A.Fake <IBuildingBlock>();
_observerBuilder = new ContainerObserverBuilder();
sut = new TagTask(_context);
}
protected override void Context()
{
base.Context();
_observer = new ObserverBuilder().WithName("NNNNNN");
_observer.ContainerCriteria.Add(new MatchTagCondition(_changedName));
_observerBuildingBlock = new ObserverBuildingBlock().WithName("Observer").WithId("Observer");
_observerBuildingBlock.Add(_observer);
}
private IObserver addObserverInContainer(IObserverBuilder observerBuilder, IContainer observerContainer, QuantityType moleculeType)
{
var observer = _observerMapper.MapFrom(observerBuilder, _buildConfiguration);
observer.QuantityType = QuantityType.Observer | moleculeType;
observerContainer.Add(observer);
return(observer);
}
protected override void Context()
{
base.Context();
_simulationFactory = IoC.Resolve <ISimulationFactory>();
_buildConfigurationFactory = IoC.Resolve <IBuildConfigurationFactory>();
_modelConstructor = IoC.Resolve <IModelConstructor>();
_simulationSettingsFactory = IoC.Resolve <ISimulationSettingsFactory>();
_observerBuilder = IoC.Resolve <IObserverBuilder>();
_fileName = Helper.TestFileFullPath("tiny_example_12.xml");
}
protected override void Context()
{
base.Context();
_buildConfiguration = A.Fake <IBuildConfiguration>();
_observerBuilder = A.Fake <IObserverBuilder>().WithName("toto").WithDimension(A.Fake <IDimension>());
_observerBuilder.Formula = A.Fake <IFormula>();
_mappedFormula = A.Fake <IFormula>();
A.CallTo(() => _objectBaseFactory.Create <IObserver>()).Returns(A.Fake <IObserver>());
A.CallTo(() => _formulaMapper.MapFrom(_observerBuilder.Formula, _buildConfiguration)).Returns(_mappedFormula);
}
protected override void SelectObserver(IObserverBuilder selectedObserver)
{
var containerObserver = selectedObserver as ContainerObserverBuilder;
if (containerObserver == null)
{
return;
}
Select(_containerObserverBuilderToDTOContainerObserverBuilderMapper.MapFrom(containerObserver));
}
protected override void SelectObserver(IObserverBuilder selectedObserver)
{
var amountObserver = (IAmountObserverBuilder)selectedObserver;
if (amountObserver == null)
{
return;
}
Select(_amountObserverBuilderToDTOAmountObserverBuilderMapper.MapFrom(amountObserver));
}
public UpdateDimensionInObserverBuilderCommand(IObserverBuilder observerBuilder, IDimension newDimension, IBuildingBlock observerBuildingBlock)
: base(observerBuildingBlock)
{
_newDimension = newDimension;
_oldDimension = observerBuilder.Dimension;
_observerBuilder = observerBuilder;
_observerBuilderId = observerBuilder.Id;
ObjectType = ObjectTypes.ObserverBuilder;
CommandType = AppConstants.Commands.EditCommand;
Description = AppConstants.Commands.UpdateDimensions(observerBuilder.Name, ObjectType, _oldDimension, newDimension, observerBuildingBlock.Name);
}
public void Edit(IObserverBuilder observer)
{
if (observer == null)
{
_view.Clear();
}
else
{
_view.BindTo(_observerMapper.MapFrom(observer));
}
}
protected T MapObserverBuilder <T>(T dto, IObserverBuilder observerBuilder) where T : ObserverBuilderDTO, new()
{
MapProperties(observerBuilder, dto);
dto.Dimension = observerBuilder.Dimension;
if (observerBuilder.Formula != null)
{
dto.Monitor = _formulaToDTOFormulaMapper.MapFrom(observerBuilder.Formula);
dto.MonitorString = observerBuilder.Formula.ToString();
}
return(dto);
}
protected override void Context()
{
_observerLoader = A.Fake <IObserverLoader>();
_executionContext = A.Fake <IExecutionContext>();
_objectIdResetter = A.Fake <IObjectIdResetter>();
sut = new ObserverTask(_executionContext, _observerLoader, _objectIdResetter);
_observer1 = new AmountObserverBuilder().WithName("OBS1");
_observer2 = new AmountObserverBuilder().WithName("OBS2");
_observerSet = new ObserverSet();
}
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 ObjectBaseSummaryDTO MapFrom(IObserverBuilder observerBuilder)
{
var dto = new ObjectBaseSummaryDTO
{
ApplicationIcon = ApplicationIcons.Observer,
EntityName = observerBuilder.Name
};
dto.AddToDictionary(AppConstants.Captions.Type, _objectTypeResolver.TypeFor(observerBuilder));
return(dto);
}
public void TestSerializationObserverBuilderWithoutFormula()
{
ContainerObserverBuilder x1 = CreateObject <ContainerObserverBuilder>().WithName("Oberon.Builder");
x1.MoleculeList.ForAll = true;
x1.AddMoleculeName("H2O");
x1.AddMoleculeName("CO2");
x1.AddMoleculeNameToExclude("NO2");
IObserverBuilder x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualObserverBuilder(x2, x1);
}
protected override void Context()
{
_context = A.Fake <IMoBiContext>();
_buildingBlock = A.Fake <IBuildingBlock>();
_observerBuilder = new ContainerObserverBuilder();
sut = new TagTask(_context);
_commandParameters = new TagConditionCommandParameters <IObserverBuilder>
{
BuildingBlock = _buildingBlock,
DescriptorCriteriaRetriever = x => x.ContainerCriteria,
TaggedObject = _observerBuilder
};
}
protected override async Task Context()
{
await base.Context();
_snapshot = await sut.MapToSnapshot(_observerSet);
A.CallTo(() => _observerSetFactory.Create()).Returns(new ObserverSet());
_snapshot.Name = "New Observer Set";
_snapshot.Description = "The description that will be deserialized";
_newObserverBuilder = new ContainerObserverBuilder();
A.CallTo(() => _observerMapper.MapToModel(_observerSnapshot)).Returns(_newObserverBuilder);
}
protected override Task Context()
{
_descriptorConditionMapper = A.Fake <DescriptorConditionMapper>();
_explicitFormulaMapper = A.Fake <ExplicitFormulaMapper>();
_moleculeListMapper = A.Fake <MoleculeListMapper>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_dimensionRepository = A.Fake <IDimensionRepository>();
_logger = A.Fake <ILogger>();
_dimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_amountObserver = new AmountObserverBuilder {
Dimension = _dimension
};
_containerObserver = new ContainerObserverBuilder {
Dimension = _dimension
};
_formula = new OSPSuite.Core.Domain.Formulas.ExplicitFormula("1+2");
_amountObserver.Formula = _formula;
_containerObserver.Formula = _formula;
_moleculeListSnapshot = new MoleculeList();
_snapshotFormula = new ExplicitFormula();
_newMoleculeList = new OSPSuite.Core.Domain.Builder.MoleculeList();
_newMoleculeList.AddMoleculeNameToExclude("A");
_newMoleculeList.AddMoleculeName("B");
_newMoleculeList.ForAll = false;
_newFormula = new OSPSuite.Core.Domain.Formulas.ExplicitFormula("New");
sut = new ObserverMapper(
_descriptorConditionMapper,
_explicitFormulaMapper,
_moleculeListMapper,
_objectBaseFactory,
_dimensionRepository,
_logger);
A.CallTo(() => _explicitFormulaMapper.MapToSnapshot(_formula)).Returns(_snapshotFormula);
A.CallTo(() => _explicitFormulaMapper.MapToModel(_snapshotFormula)).Returns(_newFormula);
A.CallTo(() => _moleculeListMapper.MapToSnapshot(_amountObserver.MoleculeList)).Returns(_moleculeListSnapshot);
A.CallTo(() => _moleculeListMapper.MapToSnapshot(_containerObserver.MoleculeList)).Returns(_moleculeListSnapshot);
A.CallTo(() => _moleculeListMapper.MapToModel(_moleculeListSnapshot)).Returns(_newMoleculeList);
A.CallTo(() => _dimensionRepository.DimensionByName(_dimension.Name)).Returns(_dimension);
A.CallTo(() => _objectBaseFactory.Create <AmountObserverBuilder>()).Returns(new AmountObserverBuilder());
A.CallTo(() => _objectBaseFactory.Create <ContainerObserverBuilder>()).Returns(new ContainerObserverBuilder());
return(_completed);
}
protected override Task Context()
{
_observerMapper = A.Fake <ObserverMapper>();
_observerSetFactory = A.Fake <IObserverSetFactory>();
_observer = new AmountObserverBuilder();
_observerSet = new ObserverSet {
_observer
};
_observerSet.Name = "OBS_SET";
_observerSet.Description = "OBS_SET_DESCRIPTION";
sut = new ObserverSetMapper(_observerMapper, _observerSetFactory);
_observerSnapshot = new Observer();
A.CallTo(() => _observerMapper.MapToSnapshot(_observer)).Returns(_observerSnapshot);
return(_completed);
}
public void TestSerializationObserverBuilderWithConstantFormula()
{
ContainerObserverBuilder x1 = CreateObject <ContainerObserverBuilder>()
.WithName("Obasi.Builder").WithDimension(DimensionLength);
x1.MoleculeList.ForAll = false;
x1.AddMoleculeName("H2O");
x1.AddMoleculeName("CO2");
x1.Formula = CreateObject <ConstantFormula>().WithDimension(DimensionLength).WithValue(23.4);
IObserverBuilder x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualObserverBuilder(x2, x1);
}
protected override void Context()
{
_buildingBlock = new ObserverBuildingBlock();
_context = A.Fake <IMoBiContext>();
_newDimension = DimensionFactoryForSpecs.Factory.Dimension(DimensionFactoryForSpecs.DimensionNames.Mass);
_oldDimension = DimensionFactoryForSpecs.Factory.Dimension(DimensionFactoryForSpecs.DimensionNames.Concentration);
_observedBuilder = new ObserverBuilder
{
Dimension = _oldDimension,
Formula = new ConstantFormula(5).WithDimension(_oldDimension)
}.WithId("5");
sut = new UpdateDimensionInObserverBuilderCommand(_observedBuilder, _newDimension, _buildingBlock);
}
public override void GlobalContext()
{
base.GlobalContext();
_simulation = DomainFactoryForSpecs.CreateDefaultSimulation();
_moleculeBuildingBlock = new MoleculeBuildingBlock();
var compoundProperties = _simulation.CompoundPropertiesList.First();
_compoundName = compoundProperties.Compound.Name;
_moleculeBuildingBlock.Add(new MoleculeBuilder {
Name = _compoundName, QuantityType = QuantityType.Drug
});
_moleculeBuildingBlock.Add(new MoleculeBuilder {
Name = "Enzyme", QuantityType = QuantityType.Enzyme
});
_moleculeBuildingBlock.Add(new MoleculeBuilder {
Name = "Metabolite", QuantityType = QuantityType.Metabolite
});
_moleculeBuildingBlock.Add(new MoleculeBuilder {
Name = "Protein", QuantityType = QuantityType.OtherProtein
});
var specificBindingSelection = new ProcessSelection {
CompoundName = _compoundName, MoleculeName = "Protein", ProcessName = "Specific Binding"
};
var metabolizationSelection = new EnzymaticProcessSelection {
CompoundName = _compoundName, MoleculeName = "Protein", ProcessName = "Metabolism"
};
_complexProductName = specificBindingSelection.ProductName(CoreConstants.Molecule.Complex);
_metaboliteProductName = metabolizationSelection.ProductName(CoreConstants.Molecule.Metabolite);
_moleculeBuildingBlock.Add(new MoleculeBuilder {
Name = _complexProductName, QuantityType = QuantityType.Complex
});
compoundProperties.Processes.SpecificBindingSelection.AddPartialProcessSelection(specificBindingSelection);
compoundProperties.Processes.MetabolizationSelection.AddPartialProcessSelection(metabolizationSelection);
var observerSet = new ObserverSet();
var observerSetBuildingBlock = new UsedBuildingBlock("OBS_ID", PKSimBuildingBlockType.ObserverSet)
{
BuildingBlock = observerSet
};
_observer = new AmountObserverBuilder().WithName("Test");
observerSet.Add(_observer);
_simulation.AddUsedBuildingBlock(observerSetBuildingBlock);
}
protected override void Context()
{
_view = A.Fake <IImportObserverSetView>();
_observerInfoPresenter = A.Fake <IObserverInfoPresenter>();
_dialogCreator = A.Fake <IDialogCreator>();
_observerTask = A.Fake <IObserverTask>();
_commandCollector = A.Fake <ICommandCollector>();
_observer1 = new ContainerObserverBuilder().WithName("OBS1");
_observer2 = new ContainerObserverBuilder().WithName("OBS2");
_observerSet = new ObserverSet {
_observer1, _observer2
};
_entityTask = A.Fake <IEntityTask>();
A.CallTo(() => _view.BindTo(A <IReadOnlyList <ImportObserverDTO> > ._))
.Invokes(x => _allImportObserverDTO = x.GetArgument <IReadOnlyList <ImportObserverDTO> >(0));
sut = new ImportObserverSetPresenter(_view, _observerInfoPresenter, _dialogCreator, _observerTask, _entityTask);
sut.InitializeWith(_commandCollector);
}
public void TestSerializationObserverBuilderWithExplicitFormula()
{
ContainerObserverBuilder x1 = CreateObject <ContainerObserverBuilder>().WithName("Oberon.Builder");
x1.ForAll = false;
x1.AddMoleculeName("H2O");
x1.AddMoleculeName("CO2");
ExplicitFormula f1 = CreateObject <ExplicitFormula>().WithName("Fortunato").WithDimension(DimensionLength);
IFormulaUsablePath fup = new FormulaUsablePath(new string[] { "aa", "bb" }).WithAlias("b").WithDimension(DimensionLength);
f1.AddObjectPath(fup);
IFormulaCache formulaCache = new FormulaCache();
formulaCache.Add(f1);
x1.Formula = formulaCache[f1.Id];
//SerializeAndDeserializeGeneral(formulaCache);
IObserverBuilder x2 = SerializeAndDeserialize(x1);
AssertForSpecs.AreEqualObserverBuilder(x2, x1);
}
public IPKSimCommand RemoveObserver(IObserverBuilder observer, ObserverSet observerSet)
{
return(new RemoveObserverFromObserverSetCommand(observer, observerSet, _executionContext).Run(_executionContext));
}
public IPKSimCommand AddObserver(IObserverBuilder observer, ObserverSet observerSet)
{
return(new AddObserverToObserverSetCommand(observer, observerSet, _executionContext).Run(_executionContext));
}
public void Visit(IObserverBuilder observerBuilder)
{
checkMoleculeDependentBuilder(observerBuilder, ObjectTypes.ObserverBuilder);
checkDescriptorCriteria(observerBuilder, x => x.ContainerCriteria);
}
public static bool IsConcentration(this IObserverBuilder observerBuilder)
{
return(string.Equals(observerBuilder.Name, CoreConstants.Observer.CONCENTRATION_IN_CONTAINER));
}
private void addLiverZoneObserversBasedOn(IObserverBuilder observerBuilder, IObserverBuildingBlock observerBuildingBlock, Compound compound)
{
CoreConstants.Compartment.LiverCompartments.Each(compartment => addLiverZoneCompartmentObserver(observerBuilder, compartment, observerBuildingBlock, compound));
}
protected override async Task Because()
{
_result = await sut.MapToModel(_snapshot);
}
