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); }