private static void setMoleculeStartValue(IMoleculeBuilder moleculeBuilder, IMoleculeStartValue moleculeStartValue)
{
moleculeStartValue.StartValue = moleculeBuilder.GetDefaultMoleculeStartValue();
}
private IMenuBarItem createRenameItemFor(IMoleculeBuilder moleculeBuilder)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Rename)
.WithCommandFor <RenameObjectCommand <IMoleculeBuilder>, IMoleculeBuilder>(moleculeBuilder)
.WithIcon(ApplicationIcons.Rename));
}
private IMenuBarItem createAddExistingFromTemplateTransporterFor(IMoleculeBuilder moleculeBuilder)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.AddExistingFromTemplate(ObjectTypes.TransporterMoleculeContainer))
.WithCommandFor <AddExistingFromTemplateCommandFor <IMoleculeBuilder, TransporterMoleculeContainer>, IMoleculeBuilder>(moleculeBuilder)
.WithIcon(ApplicationIcons.LoadFromTemplate));
}
private void addInduction(IMoleculeBuilder molecule, InteractionProcess inductionProcess)
{
var inductionReaction = _processBuilderMapper.InductionReactionFrom(inductionProcess, molecule, _allMoleculeNames, _reactionBuildingBlock.FormulaCache);
_reactionBuildingBlock.Add(inductionReaction);
}
public override void RestoreExecutionData(IMoBiContext context)
{
base.RestoreExecutionData(context);
_moleculeBuilder = context.Get <IMoleculeBuilder>(_moleculeBuilderId);
}
private void convert(IMoleculeBuilder moleculeBuilder, IMoleculeBuildingBlock moleculeBuildingBlock, IPassiveTransportBuildingBlock passiveTransportBuildingBlock)
{
convert(moleculeBuilder, moleculeBuildingBlock, new[] { passiveTransportBuildingBlock });
}
protected override void Because()
{
_result = sut.Create(_moleculeType, _formulaCache);
}
private ApplicationIcon getMoleculeBuilderIconFor(IMoleculeBuilder objectBase)
{
var iconName = Enum.GetName(typeof(QuantityType), objectBase.QuantityType);
return(iconByName(iconName) ?? ApplicationIcons.Drug);
}
private IEnumerable <ParameterDTO> allTemplateParametersFor(IMoleculeBuilder molecule)
{
var templateParameter = molecule.Parameters.Where(isTemplateParameter).ToList();
return(templateParameter.MapAllUsing(_parameterDTOMapper).Cast <ParameterDTO>());
}
public void AddMoleculeParametersTo(IMoleculeBuilder molecule, IFormulaCache formulaCache)
{
addParametersTo(molecule, null, CoreConstants.CalculationMethod.ForCompounds, x => true, formulaCache);
}
protected override void Context()
{
base.Context();
_returnedBuildingBlocks = new List <IBuildingBlock>();
_childReactionBuilder = new ReactionBuilder().WithName("Test").WithId("FindME");
_reactionBuildingBlock = new MoBiReactionBuildingBlock()
{
_childReactionBuilder
};
_allBuildingBlocks.Add(_reactionBuildingBlock);
_moleculeBuilder = new MoleculeBuilder();
_moleculeBuildingBlock = new MoleculeBuildingBlock()
{
_moleculeBuilder
};
_allBuildingBlocks.Add(_moleculeBuildingBlock);
_obseverBuilder = new ObserverBuilder();
_observerBuildingBlock = new ObserverBuildingBlock()
{
_obseverBuilder
};
_allBuildingBlocks.Add(_observerBuildingBlock);
_passiveTranportBuilder = new TransportBuilder();
_passiveTranportBuildingBlock = new PassiveTransportBuildingBlock()
{
_passiveTranportBuilder
};
_allBuildingBlocks.Add(_passiveTranportBuildingBlock);
_applicationBuilder = new ApplicationBuilder();
_eventGroupBuildingBlock = new EventGroupBuildingBlock()
{
_applicationBuilder
};
_allBuildingBlocks.Add(_eventGroupBuildingBlock);
_parameter = new Parameter().WithName("Para");
var container = new Container().WithName("Cont");
container.Add(_parameter);
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_parmaeterFactory = A.Fake <IParameterFactory>();
A.CallTo(() => _objectBaseFactory.Create <IContainer>()).Returns(A.Fake <IContainer>());
A.CallTo(() => _objectBaseFactory.Create <IMoBiSpatialStructure>()).Returns(new MoBiSpatialStructure());
var diagramManagerFactory = A.Fake <IDiagramManagerFactory>();
_spatialStructure = new MoBiSpatialStructureFactory(_objectBaseFactory, _parmaeterFactory, A.Fake <IconRepository>(), diagramManagerFactory).Create().DowncastTo <IMoBiSpatialStructure>();
_spatialStructure.AddTopContainer(container);
_allBuildingBlocks.Add(_spatialStructure);
_formula = new ExplicitFormula();
_moleculeBuildingBlock.AddFormula(_formula);
_parameterStartValue = new ParameterStartValue {
Path = new ObjectPath {
"test"
}, StartValue = 1, Dimension = A.Fake <IDimension>()
};
_parameterStartValueBuildingBlock = new ParameterStartValuesBuildingBlock()
{
_parameterStartValue
};
_allBuildingBlocks.Add(_parameterStartValueBuildingBlock);
_moleculeStartValue = new MoleculeStartValue {
ContainerPath = new ObjectPath {
"test"
}, Name = "drug"
};
_moleculeStartValuesBuildingBlock = new MoleculeStartValuesBuildingBlock()
{
_moleculeStartValue
};
_allBuildingBlocks.Add(_moleculeStartValuesBuildingBlock);
}
public void Visit(IMoleculeBuilder moleculeBuilder)
{
updateDefaultStartFormulaDimension(moleculeBuilder);
updateIconIfNotSet(moleculeBuilder);
_converted = true;
}
private static bool dimensionIsAmountOrMolarConcentration(IMoleculeBuilder moleculeBuilder)
{
var dimension = moleculeBuilder.DefaultStartFormula.Dimension;
return(dimension != null && dimension.Name.IsOneOf(Constants.Dimension.AMOUNT, Constants.Dimension.MOLAR_CONCENTRATION));
}
public void Visit(IMoleculeBuilder moleculeBuilder)
{
checkObjectBase(moleculeBuilder);
// Formula is not checked here, only checked in Chache cause double will cause errors in undo
}
private void createReceptorOccupancyObserver(IObserverBuildingBlock observerBuildingBlock, IMoleculeBuilder protein, IMoleculeBuilder complex)
{
var observerName = CoreConstants.Observer.ObserverNameFrom(CoreConstants.Observer.RECEPTOR_OCCUPANCY, complex.Name);
var observer = createAmountFractionObserver(observerName, observerBuildingBlock, () => getReceptorOccupancyFormula(observerBuildingBlock, protein, complex));
observer.AddMoleculeName(complex.Name);
}
private void updateAlternativeParameters(Compound compound, CompoundProperties compoundProperties, IMoleculeBuilder drug)
{
selectedAlternativesFor(compound, compoundProperties).Each(alternative => updateAlternativeParameters(alternative, drug));
}
private IFormula getReceptorOccupancyFormula(IObserverBuildingBlock observerBuildingBlock, IMoleculeBuilder protein, IMoleculeBuilder complex)
{
var receptorOccupancyObserver = $"ReceptorOccupancyObserver_{complex.Name}";
if (observerBuildingBlock.FormulaCache.Contains(receptorOccupancyObserver))
{
return(observerBuildingBlock.FormulaCache[receptorOccupancyObserver]);
}
var receptorOccupancy = _objectBaseFactory.Create <ExplicitFormula>()
.WithName(receptorOccupancyObserver)
.WithFormulaString("Protein + Complex > 0 ? Complex/(Protein + Complex) : 0")
.WithDimension(_dimensionRepository.Fraction);
receptorOccupancy.AddObjectPath(_objectPathFactory.CreateFormulaUsablePathFrom(ObjectPath.PARENT_CONTAINER)
.WithAlias("Complex")
.WithDimension(_dimensionRepository.Amount));
receptorOccupancy.AddObjectPath(_objectPathFactory.CreateFormulaUsablePathFrom(ObjectPath.PARENT_CONTAINER, ObjectPath.PARENT_CONTAINER, protein.Name)
.WithAlias("Protein")
.WithDimension(_dimensionRepository.Amount));
observerBuildingBlock.FormulaCache.Add(receptorOccupancy);
//reference to protein concentration has to be added for each receptor
return(receptorOccupancy);
}
private void addConcentrationParmeterTo(IMoleculeBuilder moleculeBuilder, IFormulaCache formulaCache)
{
var parameter = _parameterFactory.CreateConcentrationParameterIn(formulaCache);
moleculeBuilder.AddParameter(parameter);
}
protected override void Because()
{
_molecule = sut.Create(_compound, _compoundProperties, _interactionProperties, _formulaCache);
}
private void setDefaultParameterValues(IMoleculeBuilder molecule)
{
var parameters = molecule.AllParameters().Where(parameter => CoreConstants.Parameter.CompoundMustInputParameters.Contains(parameter.Name));
parameters.Each(p => p.Value = double.NaN);
}
protected override void Because()
{
_result = sut.Create(QuantityType.Transporter, new FormulaCache());
}
public void Edit(IMoleculeBuilder moleculeBuilder)
{
Edit(moleculeBuilder, moleculeBuilder.ParentContainer);
}
protected override void ClearReferences()
{
base.ClearReferences();
_moleculeBuilder = null;
}
public void EditMolecule(IMoleculeBuildingBlock buildingBlock, IMoleculeBuilder moleculeBuilder)
{
_editTasksForMoleculeBuildingBlock.Edit(buildingBlock, moleculeBuilder);
}
private IMenuBarItem createEditItemFor(IMoleculeBuilder moleculeBuilder)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Edit)
.WithCommandFor <EditCommandFor <IMoleculeBuilder>, IMoleculeBuilder>(moleculeBuilder)
.WithIcon(ApplicationIcons.Edit));
}
public ChangedCalculationMethodEvent(IMoleculeBuilder moleculeBuilder)
{
MoleculeBuilder = moleculeBuilder;
}
private IMenuBarItem createRemoveItemFor(IMoleculeBuildingBlock moleculeBuildingBlock, IMoleculeBuilder moleculeBuilder)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.Delete)
.WithRemoveCommand(moleculeBuildingBlock, moleculeBuilder)
.WithIcon(ApplicationIcons.Delete));
}
private bool concentrationIsNeeded(IMoleculeBuilder moleculeBuilder)
{
//concentration for all dynamic species but metabolite
return(moleculeBuilder.QuantityType.Is(QuantityType.Protein) ||
moleculeBuilder.QuantityType.Is(QuantityType.Complex));
}
private IMenuBarItem createSaveItemFor(IMoleculeBuilder selectedObject)
{
return(CreateMenuButton.WithCaption(AppConstants.MenuNames.SaveAsPKML)
.WithCommandFor <SaveUICommandFor <IMoleculeBuilder>, IMoleculeBuilder>(selectedObject)
.WithIcon(ApplicationIcons.SaveMolecule));
}
protected override void Because()
{
sut.AddNew(_moleculeBuilderBuildingBlock, _moleculeBuilderBuildingBlock);
_moleculeBuilder = _moleculeBuilderBuildingBlock.First();
}
