private void convertIndividual(Individual individual)
{
if (individual == null)
{
return;
}
_individualCalculationMethodsUpdater.AddMissingCalculationMethodsTo(individual);
if (!individual.IsHuman)
{
return;
}
if (individual.Organism.Parameter(CoreConstants.Parameter.BSA) != null)
{
return;
}
var defaultHuman = _defaultIndividualRetriever.DefaultHuman();
var bsa = defaultHuman.Organism.Parameter(CoreConstants.Parameter.BSA);
individual.Organism.Add(_cloner.Clone(bsa));
}
private void addSurfaceAreaParametersTo(Individual individual)
{
var templateIndividual = templateIndividualFor(individual);
var templateLumen = lumenIn(templateIndividual);
var currentLumen = lumenIn(individual);
var defaultFactor = effectiveSurfaceAreaVariabilityParameterIn(templateIndividual);
currentLumen.Add(_cloner.Clone(defaultFactor));
foreach (var segment in currentLumen.GetChildren <IContainer>())
{
var templateSegment = templateLumen.Container(segment.Name);
if (templateSegment == null)
{
continue;
}
var templateEffectiveSurfaceArea = templateSegment.Parameter(ConverterConstants.Parameter.EffectiveSurfaceArea);
if (templateEffectiveSurfaceArea == null)
{
continue;
}
//clone surface area parameter
segment.Add(_cloner.Clone(templateEffectiveSurfaceArea));
}
}
public Simulation CreateForVSS(Protocol protocol, Individual individual, Compound compound)
{
//we create a clone here to ensure that a name is set in the compound
var vssCompound = _cloner.Clone(compound).WithName("VSS COMPOUND");
var simulation = CreateFrom(individual, new[] { vssCompound }, _modelPropertiesTask.DefaultFor(individual.OriginData));
_simulationBuildingBlockUpdater.UpdateMultipleUsedBuildingBlockInSimulationFromTemplate(simulation, new[] { protocol }, PKSimBuildingBlockType.Protocol);
_simulationModelCreator.CreateModelFor(simulation);
return(simulation);
}
private void updatePartialProcessKineticAccordingToTemplate(Compound compound)
{
foreach (var partialProcess in compound.AllProcesses <PartialProcess>().ToList())
{
if (partialProcess.InternalName.Contains("Hill"))
{
continue;
}
//remove the old partial process that needs to be updated
compound.RemoveChild(partialProcess);
var templateProcess = _compoundProcessRepository.All <PartialProcess>().FindByName(partialProcess.InternalName);
bool wasInhibitionProcess = false;
//process does not exist anymore such as Inhibition. convert to non inhibition
if (templateProcess == null)
{
var processInternalName = partialProcess.InternalName.Replace("CompetitiveInhibition_", string.Empty);
templateProcess = _compoundProcessRepository.All <PartialProcess>().FindByName(processInternalName);
wasInhibitionProcess = true;
}
if (templateProcess == null)
{
continue;
}
//This updates all local properites from the parital process such as molecule name etc..
var cloneDbProcess = _cloner.Clone(templateProcess);
cloneDbProcess.UpdatePropertiesFrom(partialProcess, _cloner);
compound.Add(cloneDbProcess);
if (wasInhibitionProcess)
{
cloneDbProcess.Description = PKSimConstants.Warning.StaticInhibitionRemovedFromApplication(templateProcess.Description);
cloneDbProcess.InternalName = templateProcess.InternalName;
}
foreach (var parameter in partialProcess.AllParameters())
{
var newParameter = cloneDbProcess.Parameter(parameter.Name);
if (newParameter == null)
{
continue;
}
//make sure we have the same parameter id as before to ensure smooth update commit
newParameter.Id = parameter.Id;
_parameterSetUpdater.UpdateValue(parameter, newParameter);
//this needs to be done after udpdate value as the Update value also sets the origin
newParameter.Origin.ParameterId = parameter.Origin.ParameterId;
}
}
}
public void Visit(Individual individual)
{
_individualCalculationMethodsUpdater.AddMissingCalculationMethodsTo(individual);
performCommonConversion(individual);
Visit(individual.OriginData);
foreach (var transporter in individual.AllMolecules <IndividualTransporter>().SelectMany(x => x.AllExpressionsContainers()))
{
var oldProcessNames = transporter.ProcessNames.ToList();
transporter.ClearProcessNames();
foreach (var processName in oldProcessNames)
{
transporter.AddProcessName(processName.Replace("_MM", ""));
}
}
//change container type for molecules
foreach (var molecule in individual.AllMolecules())
{
molecule.ContainerType = ContainerType.Molecule;
updateOntogeny(molecule);
}
//special parameters that need conversion by hand
convertIndividualParameters(individual.Organism);
convertIndividualForTwoPore(individual);
var human = _defaultIndividualRetriever.DefaultHuman();
individual.Organism.Add(clone(human.Organism, CoreConstants.Parameters.ONTOGENY_FACTOR_ALBUMIN));
individual.Organism.Add(clone(human.Organism, CoreConstants.Parameters.ONTOGENY_FACTOR_AGP));
individual.Organism.Add(clone(human.Organism, CoreConstants.Parameters.PLASMA_PROTEIN_SCALE_FACTOR));
if (!individual.IsHuman)
{
individual.OriginData.AddCalculationMethod(_calculationMethodRepository.FindByName("MucosaVolume_Animals"));
}
else
{
individual.OriginData.AddCalculationMethod(_calculationMethodRepository.FindByName("MucosaVolume_Human"));
individual.OriginData.GestationalAge = CoreConstants.NOT_PRETERM_GESTATIONAL_AGE_IN_WEEKS;
individual.OriginData.GestationalAgeUnit = CoreConstants.Units.Weeks;
var gestationalAge = human.Organism.Parameter(Constants.Parameters.GESTATIONAL_AGE);
if (!individual.Organism.ContainsName(Constants.Parameters.GESTATIONAL_AGE))
{
individual.Organism.Add(_cloner.Clone(gestationalAge));
}
}
}
private IReactionBuilder createReactionFromProcess(IContainer rectionParameterContainer, IReactionBuilder templateReactionBuilder, string newReactionName, IReadOnlyCollection <string> forbiddenNames)
{
//retrieve process for the simulation and create a clone
var reaction = _cloner.Clone(templateReactionBuilder).WithName(newReactionName);
while (forbiddenNames.Contains(reaction.Name))
{
reaction.Name = string.Format("@{0}", reaction.Name);
}
_parameterSetUpdater.UpdateValuesByName(rectionParameterContainer.AllParameters(), reaction.Parameters);
return(reaction);
}
private void convertTransitTimeFor(IContainer individualToConvert)
{
if (!_defaultCache.Contains(_currentSpecies))
{
_defaultCache.Add(_defaultIndividualRetriever.DefaultIndividualFor(_currentSpecies));
}
var defaultIndividual = _defaultCache[_currentSpecies];
var defaultSITT = smallIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.SITT);
var defaultSITT_factor = smallIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.SITT_factor);
var defaultSITT_factor_slope = smallIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.SITT_factor_slope);
var defaultSITT_factor_intercept = smallIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.SITT_factor_intercept);
var defaultLITT = largeIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.LITT);
var defaultLITT_factor = largeIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.LITT_factor);
var defaultLITT_factor_slope = largeIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.LITT_factor_slope);
var defaultLITT_factor_intercept = largeIntestineIn(defaultIndividual).Parameter(ConverterConstants.Parameter.LITT_factor_intercept);
var defaultGET = gastricEmptyingTimeIn(defaultIndividual);
var currentGET = gastricEmptyingTimeIn(individualToConvert);
currentGET.Info.MaxValue = defaultGET.MaxValue;
var smallIntestine = smallIntestineIn(individualToConvert);
var largeIntestine = largeIntestineIn(individualToConvert);
smallIntestine.Add(_cloner.Clone(defaultSITT));
smallIntestine.Add(_cloner.Clone(defaultSITT_factor_slope));
smallIntestine.Add(_cloner.Clone(defaultSITT_factor_intercept));
largeIntestine.Add(_cloner.Clone(defaultLITT));
largeIntestine.Add(_cloner.Clone(defaultLITT_factor_slope));
largeIntestine.Add(_cloner.Clone(defaultLITT_factor_intercept));
var SITT = smallIntestine.Parameter(ConverterConstants.Parameter.SITT);
var SITT_fact_old = smallIntestine.Parameter(ConverterConstants.Parameter.SITT_factor).Value;
var P1_sin = smallIntestine.Parameter(ConverterConstants.Parameter.SITT_factor_slope).Value;
var P2_sin = smallIntestine.Parameter(ConverterConstants.Parameter.SITT_factor_intercept).Value;
var LITT = largeIntestine.Parameter(ConverterConstants.Parameter.LITT);
var LITT_fact_old = largeIntestine.Parameter(ConverterConstants.Parameter.LITT_factor).Value;
var P1_lin = largeIntestine.Parameter(ConverterConstants.Parameter.LITT_factor_slope).Value;
var P2_lin = largeIntestine.Parameter(ConverterConstants.Parameter.LITT_factor_intercept).Value;
SITT.Value = (SITT_fact_old - P2_sin) / P1_sin;
LITT.Value = (LITT_fact_old - P2_lin) / P1_lin;
//last but not least remove parameter to update formula
smallIntestine.RemoveChild(smallIntestine.Parameter(ConverterConstants.Parameter.SITT_factor));
largeIntestine.RemoveChild(largeIntestine.Parameter(ConverterConstants.Parameter.LITT_factor));
smallIntestine.Add(_cloner.Clone(defaultSITT_factor));
largeIntestine.Add(_cloner.Clone(defaultLITT_factor));
//removed unused parameters
smallIntestine.RemoveChild(smallIntestine.Parameter(ConverterConstants.Parameter.ColonArrivalTime));
largeIntestine.RemoveChild(largeIntestine.Parameter(ConverterConstants.Parameter.ExcretionTime));
_converted = true;
}
private void addIndividualParameters(IContainer individual, Species species, string replaceRootName = null)
{
if (!_defaultCache.Contains(species))
{
_defaultCache.Add(_defaultIndividualRetriever.DefaultIndividualFor(species));
}
var defaultIndividual = _defaultCache[species];
var stomach = lumenStomachIn(individual);
var defaultStomach = lumenStomachIn(defaultIndividual);
stomach.Add(_cloner.Clone(defaultStomach.Parameter(ConverterConstants.Parameter.GET_Alpha_variability_factor)));
stomach.Add(_cloner.Clone(defaultStomach.Parameter(ConverterConstants.Parameter.GET_Beta_variability_factor)));
}
protected override void Context()
{
_subPresenterManager = SubPresenterHelper.Create <IIndividualItemPresenter>();
_view = A.Fake <IScaleIndividualView>();
_propertiesMapper = A.Fake <IBuildingBlockPropertiesMapper>();
_workspace = A.Fake <IWorkspace>();
_individualExpressionsUpdater = A.Fake <IIndividualExpressionsUpdater>();
_cloner = A.Fake <ICloner>();
_sourceIndividual = A.Fake <Individual>();
_cloneIndividual = A.Fake <Individual>();
_scaledIndividual = A.Fake <Individual>();
_objectBaseDTOFactory = A.Fake <IObjectBaseDTOFactory>();
_settingPresenter = _subPresenterManager.CreateFake(ScaleIndividualItems.Settings);
_parameterPresenter = _subPresenterManager.CreateFake(ScaleIndividualItems.Parameters);
_scalingConfigurationPresenter = _subPresenterManager.CreateFake(ScaleIndividualItems.Scaling);
_moleculePresenter = _subPresenterManager.CreateFake(ScaleIndividualItems.Expressions);
ScaleIndividualItems.Expressions.Index = 3;
A.CallTo(() => _cloner.Clone(_sourceIndividual)).Returns(_cloneIndividual);
_individualSettingsDTO = new IndividualSettingsDTO();
_dialogCreator = A.Fake <IDialogCreator>();
A.CallTo(() => _settingPresenter.Individual).Returns(_scaledIndividual);
_scaleIndividualPropertiesDTO = new ObjectBaseDTO();
A.CallTo(() => _objectBaseDTOFactory.CreateFor <Individual>()).Returns(_scaleIndividualPropertiesDTO);
sut = new ScaleIndividualPresenter(_view, _subPresenterManager, _dialogCreator, _individualExpressionsUpdater,
_objectBaseDTOFactory, _propertiesMapper, _cloner);
sut.Initialize();
}
protected override Task Context()
{
_containerTask = A.Fake <IContainerTask>();
_progressManager = A.Fake <IProgressManager>();
_individualCacheImporter = A.Fake <IIndividualPropertiesCacheImporter>();
_cloner = A.Fake <ICloner>();
_objectBaseFactory = A.Fake <IObjectBaseFactory>();
_advancedParameterFactory = A.Fake <IAdvancedParameterFactory>();
_createdPopulation = A.Fake <ImportPopulation>();
_individual = new Individual();
_cloneIndividual = new Individual();
A.CallTo(() => _cloner.Clone(_individual)).Returns(_cloneIndividual);
A.CallTo(() => _objectBaseFactory.Create <ImportPopulation>()).Returns(_createdPopulation);
A.CallTo(() => _createdPopulation.IndividualPropertiesCache).Returns(A.Fake <IndividualPropertiesCache>());
sut = new ImportPopulationFactory(_objectBaseFactory, _progressManager, _individualCacheImporter, _cloner, _containerTask, _advancedParameterFactory);
A.CallTo(() => _containerTask.CacheAllChildren <IParameter>(_cloneIndividual)).Returns(_allParameters);
A.CallTo(() => _containerTask.CacheAllChildrenSatisfying(_cloneIndividual, A <Func <IParameter, bool> > ._)).Returns(_allCreateIndividualParameters);
_popFile1 = A.Fake <IndividualPropertiesCache>();
_popFile2 = A.Fake <IndividualPropertiesCache>();
A.CallTo(() => _individualCacheImporter.ImportFrom(_file1, _allParameters, A <IImportLogger> ._)).Returns(_popFile1);
A.CallTo(() => _individualCacheImporter.ImportFrom(_file2, _allParameters, A <IImportLogger> ._)).Returns(_popFile2);
return(_completed);
}
public Model.Formulation MapFrom(Formulation batchFormulation)
{
if (batchFormulation == null)
{
return(null);
}
var template = _formulationRepository.FormulationBy(batchFormulation.FormulationType);
var formulation = _cloner.Clone(template);
formulation.Name = batchFormulation.Name;
foreach (var parameterValue in batchFormulation.Parameters)
{
var parameter = formulation.Parameter(parameterValue.Key);
if (parameter == null)
{
_batchLogger.AddWarning($"Parameter '{parameterValue.Key}' not found in formulation '{formulation.Name}'");
continue;
}
parameter.Value = parameterValue.Value;
_batchLogger.AddParameterValueToDebug(parameter);
}
return(formulation);
}
public HomeController(ICloner<string> serializingCloner)
{
this.myStringCloner = serializingCloner;
var string1 = "Nijected Bitch!!";
var string2 = myStringCloner.Clone(string1);
}
protected override void Context()
{
_view = A.Fake <ITableParameterView>();
_parameterTask = A.Fake <IParameterTask>();
_formulaFactory = A.Fake <IFormulaFactory>();
_cloner = A.Fake <ICloner>();
_tableFormula = new TableFormula {
Id = "1"
};
_tableFormula.XDimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_tableFormula.XDisplayUnit = _tableFormula.XDimension.BaseUnit;
_tableFormula.Dimension = DomainHelperForSpecs.LengthDimensionForSpecs();
_tableFormula.YDisplayUnit = _tableFormula.Dimension.BaseUnit;
_editedFormula = new TableFormula {
Id = "2"
};
_editedFormula.XDimension = DomainHelperForSpecs.TimeDimensionForSpecs();
_editedFormula.XDisplayUnit = _editedFormula.XDimension.BaseUnit;
_editedFormula.Dimension = DomainHelperForSpecs.LengthDimensionForSpecs();
_editedFormula.YDisplayUnit = _editedFormula.Dimension.BaseUnit;
A.CallTo(() => _cloner.Clone(_tableFormula)).Returns(_editedFormula);
sut = new TableParametersForSpecs(_view, _parameterTask, _cloner, _formulaFactory);
sut.InitializeWith(A.Fake <ICommandCollector>());
_parameter = new PKSimParameter().WithFormula(_tableFormula);
}
public HomeController(ICloner <string> serializingCloner)
{
this.myStringCloner = serializingCloner;
var string1 = "Nijected Bitch!!";
var string2 = myStringCloner.Clone(string1);
}
private T RetrieveClone(Transact transaction)
{
if (ReferenceEquals(transaction, null))
{
return(base.Value);
}
object value;
Volatile.Write(ref _inUse, 1);
if (transaction._writeLog.TryGetValue(this, out value))
{
return((T)value);
}
if (transaction._readLog.TryGetValue(this, out value))
{
return((T)value);
}
var original = RetrieveValue(transaction._parentTransaction);
var clone = _cloner.Clone(original);
if (!_comparer.Equals(clone, original))
{
transaction._writeLog.Set(this, clone);
}
transaction._readLog.TryAdd(this, original);
return(clone);
}
public async Task <WorkflowDefinition?> GetDraftAsync(string workflowDefinitionId, CancellationToken cancellationToken = default)
{
var definition = await _workflowDefinitionStore.FindByDefinitionIdAsync(
workflowDefinitionId,
VersionOptions.Latest,
cancellationToken);
if (definition == null)
{
return(null);
}
if (!definition.IsPublished)
{
return(definition);
}
var draft = _cloner.Clone(definition);
draft.Id = _idGenerator.Generate();
draft.IsPublished = false;
draft.IsLatest = true;
draft.Version++;
return(draft);
}
public void CloneFiles()
{
if (ctx.VcsMode.Equals("git"))
{
cloner.SetContext(ctx);
cloner.Clone();
}
}
private void convertCompound(Compound compound)
{
var templateCompound = _templateCompound.Value;
var enableSupersaturation = _cloner.Clone(templateCompound.Parameter(Constants.Parameters.ENABLE_SUPERSATURATION));
compound.Add(enableSupersaturation);
_converted = true;
}
public void Update(Individual sourceIndividual, Individual targetIndividual)
{
foreach (var molecule in sourceIndividual.AllMolecules())
{
var newMolecule = _cloner.Clone(molecule);
targetIndividual.AddMolecule(newMolecule);
//we have to reset the new ontogeny for the molecule
_ontogenyTask.SetOntogenyForMolecule(newMolecule, newMolecule.Ontogeny, targetIndividual);
}
}
private ImportPopulation createPopulationFor(Individual individual)
{
var importPopulation = _objectBaseFactory.Create <ImportPopulation>();
importPopulation.Root = _objectBaseFactory.Create <IRootContainer>();
importPopulation.SetAdvancedParameters(_objectBaseFactory.Create <IAdvancedParameterCollection>());
importPopulation.Settings.BaseIndividual = _cloner.Clone(individual);
importPopulation.IsLoaded = true;
return(importPopulation);
}
public void Track <T>(string fullFileName, T item)
{
Ensure.NotNull(fullFileName, nameof(fullFileName));
var clone = _cloner.Clone(item);
lock (_gate)
{
_clones.AddOrUpdate(fullFileName, clone, (f, o) => clone);
}
}
private void convertCompound(Compound compound)
{
if (compound == null)
{
return;
}
var templateCompound = _compoundFactory.Create().WithName(compound.Name);
var solubilityTable = templateCompound.Parameter(CoreConstants.Parameters.SOLUBILITY_TABLE);
compound.Add(_cloner.Clone(solubilityTable));
var solubilityGroup = compound.ParameterAlternativeGroup(CoreConstants.Groups.COMPOUND_SOLUBILITY);
solubilityGroup.AllAlternatives.Each(x => x.Add(_cloner.Clone(solubilityTable)));
var templateParameterCache = _containerTask.CacheAllChildrenSatisfying <IParameter>(templateCompound, x => !x.IsDefault);
var compoundParameterCache = _containerTask.CacheAllChildren <IParameter>(compound);
foreach (var parameterPath in templateParameterCache.Keys)
{
setAsInput(compoundParameterCache[parameterPath]);
}
foreach (var templateAlternativeGroup in templateCompound.AllParameterAlternativeGroups())
{
var templateAlternative = templateAlternativeGroup.AllAlternatives.First();
var compoundGroup = compound.ParameterAlternativeGroup(templateAlternativeGroup.Name);
foreach (var alternative in compoundGroup.AllAlternatives)
{
updateIsInputStateByNameAndValue(alternative, templateAlternative);
}
}
foreach (var process in compound.AllProcesses())
{
var templateProcess = _compoundProcessRepository.ProcessByName(process.InternalName);
updateIsInputStateByNameAndValue(process, templateProcess);
}
_converted = true;
}
public override async Task <ModelFormulation> MapToModel(SnapshotFormulation snapshotFormulation, SnapshotContext snapshotContext)
{
var template = _formulationRepository.FormulationBy(snapshotFormulation.FormulationType);
var formulation = _cloner.Clone(template);
MapSnapshotPropertiesToModel(snapshotFormulation, formulation);
await UpdateParametersFromSnapshot(snapshotFormulation, formulation, snapshotContext);
formulation.UpdateParticleParametersVisibility();
return(formulation);
}
public void Visit(Formulation formulation)
{
if (!formulation.FormulationType.IsOneOf(CoreConstants.Formulation.Weibull, CoreConstants.Formulation.Lint80, CoreConstants.Formulation.Particles, CoreConstants.Formulation.Table))
{
return;
}
var templateFormulation = _formulationRepository.FormulationBy(formulation.FormulationType);
var useAsSuspension = _cloner.Clone(templateFormulation.Parameter(CoreConstants.Parameter.USE_AS_SUSPENSION));
useAsSuspension.Value = 0;
formulation.Add(useAsSuspension);
}
public void Visit(Formulation formulation)
{
if (!formulation.FormulationType.IsOneOf(CoreConstants.Formulation.WEIBULL, CoreConstants.Formulation.LINT80, CoreConstants.Formulation.TABLE))
{
return;
}
var templateFormulation = _formulationRepository.FormulationBy(formulation.FormulationType);
var useAsSuspension = _cloner.Clone(templateFormulation.Parameter(Constants.Parameters.USE_AS_SUSPENSION));
useAsSuspension.Value = 0;
formulation.Add(useAsSuspension);
_converted = true;
}
public void Edit(IParameter tableParameter)
{
_tableParameter = tableParameter;
_view.Editable = _tableParameter.Editable;
//do not edit the parameter formula itself as the user might cancel the edit
var tableFormula = tableParameter.Formula as TableFormula;
if (tableFormula != null)
{
tableFormula = _cloner.Clone(tableFormula);
}
editFormula(tableFormula);
}
public void Update(Individual sourceIndividual, Individual targetIndividual)
{
foreach (var molecule in sourceIndividual.AllMolecules())
{
var newMolecule = _cloner.Clone(molecule);
targetIndividual.AddMolecule(newMolecule);
//Make sure parameters that user defined parameters are reset to default to ensure proper scaling
resetMoleculeParametersToDefault(newMolecule);
//we have to reset the ontogeny for the molecule based on the target individual properties
_ontogenyTask.SetOntogenyForMolecule(newMolecule, newMolecule.Ontogeny, targetIndividual);
}
}
private void addFractionEndosomalParametersTo(Individual individual)
{
var defaultHuman = _defaultIndividualRetriever.DefaultHuman();
var allFractionEndosomalParameters =
defaultHuman.GetAllChildren <IParameter>(x => x.IsNamed(FRACTION_ENDOSOMAL));
allFractionEndosomalParameters.Each(x =>
{
//Find container in the individual to convert
var containerPath = new ObjectPath(x.ParentContainer.ConsolidatedPath());
var container = individual.Root.EntityAt <IContainer>(containerPath);
//add clone of parameter
container.Add(_cloner.Clone(x));
});
}
private void addEstimatedGFRParameterTo(Individual individual)
{
var kidney = individual.Organism.Organ(KIDNEY);
var gfr = kidney.Parameter(GFR);
var bsa = individual.Organism.Parameter(BSA);
//This is an old individual without GFR (v6.x) or BSA Return
if (gfr == null || bsa == null)
{
return;
}
var defaultHuman = _defaultIndividualRetriever.DefaultHuman();
var parameter = defaultHuman.Organism.EntityAt <IParameter>(KIDNEY, E_GFR);
kidney.Add(_cloner.Clone(parameter));
}
private PopulationAnalysisChart editAnalysis <TPresenter>(IPopulationDataCollector populationDataCollector, PopulationAnalysisChart populationAnalysisChart) where TPresenter : ICreatePopulationAnalysisPresenter
{
using (var presenter = _applicationController.Start <TPresenter>())
{
var clone = _cloner.Clone(populationAnalysisChart);
if (!presenter.Edit(populationDataCollector, clone))
{
return(populationAnalysisChart);
}
//swap out analysis with clone\
populationDataCollector.RemoveAnalysis(populationAnalysisChart);
populationDataCollector.AddAnalysis(clone);
return(clone);
}
}
public PKSimEvent Create(IEventGroupBuilder eventGroupBuilder)
{
if (eventGroupBuilder == null)
{
throw new ArgumentException(PKSimConstants.Error.EventTemplateNotDefined, nameof(eventGroupBuilder));
}
var newEvent = _objectBaseFactory.Create <PKSimEvent>();
newEvent.TemplateName = eventGroupBuilder.Name;
var clonedEvent = _cloner.Clone(eventGroupBuilder);
newEvent.AddChildren(clonedEvent.GetAllChildren <IParameter>());
newEvent.IsLoaded = true;
return(newEvent);
}
