internal override void ExecuteInternal(IBuildConfiguration config) { if (string.IsNullOrEmpty(ManifestPath)) { Log.LogWarning("No value was provided for the Manifest. Unable to process Manifest Tokens"); return; } if (!File.Exists(ManifestPath)) { Log.LogWarning($"Unable to process Manifest Tokens, no manifest was found at the path '{ManifestPath}'"); return; } IGenerator generator = null; switch (config.Platform) { case Platform.iOS: generator = new TemplatedPlistGenerator(config) { ManifestOutputPath = ManifestPath }; break; case Platform.Android: generator = new TemplatedAndroidAppManifestGenerator(config, ReferenceAssemblyPaths) { ManifestOutputPath = ManifestPath }; break; } generator?.Execute(); }
internal override void ExecuteInternal(IBuildConfiguration buildConfiguration) { if (!IsSupported(buildConfiguration.Platform)) { Log.LogMessage($"The current Platform '{buildConfiguration.Platform}' is not supported for Automatic Versioning"); } else if (buildConfiguration.Configuration.AutomaticVersioning.Behavior == VersionBehavior.Off) { Log.LogMessage("Automatic versioning has been disabled."); } else if (CIBuildEnvironmentUtils.IsBuildHost && buildConfiguration.Configuration.AutomaticVersioning.Environment == VersionEnvironment.Local) { Log.LogMessage("Your current settings are to only build on your local machine, however it appears you are building on a Build Host."); } else { Log.LogMessage("Executing Automatic Version Generator"); var generator = GetGenerator(buildConfiguration.Platform); if (generator is null) { Log.LogWarning($"We seem to be on a supported platform {buildConfiguration.Platform}, but we did not get a generator..."); } else { generator.Execute(); } } }
private CreationResult buildProcess(IModel model, IBuildConfiguration buildConfiguration, params Func <IModel, IBuildConfiguration, ValidationResult>[] steps) { var result = new CreationResult(model); IProgressUpdater progress = null; try { if (buildConfiguration.ShowProgress) { progress = _progressManager.Create(); progress.Initialize(steps.Length, Messages.CreatingModel); } foreach (var step in steps) { //call each build process with the model and the buildconfiguration result.Add(step(model, buildConfiguration)); progress?.IncrementProgress(); //if the result has become invalid, stop the build process if (result.IsInvalid) { break; } } } finally { progress?.Dispose(); } return(result); }
/// <inheritdoc /> public Type GetBuildType(IBuildConfiguration configuration, Type requestedType) { configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); requestedType = requestedType ?? throw new ArgumentNullException(nameof(requestedType)); var typeMappingRule = configuration.TypeMappingRules?.Where(x => x.SourceType == requestedType) .FirstOrDefault(); if (typeMappingRule != null) { return(typeMappingRule.TargetType); } // There is no type mapping for this type if (requestedType.IsInterface || requestedType.IsAbstract) { if (_typeCache.ContainsKey(requestedType)) { return(_typeCache[requestedType]); } var resolvedType = AutoResolveBuildType(requestedType); _typeCache[requestedType] = resolvedType; return(resolvedType); } return(requestedType); }
public void Configure(IBuildConfiguration configuration) { configuration .UpdateTypeCreator <EnumerableTypeCreator>(x => { x.MinCount = 1; x.MaxCount = 5; }) .AddIgnoreRule(x => x.PropertyType == typeof(EntityReference)) //.AddIgnoreRule(x => x.PropertyType == typeof(IEnumerable<>)) .AddIgnoreRule(x => x.GetCustomAttribute <AttributeLogicalNameAttribute>()?.LogicalName == "statecode") .AddIgnoreRule(x => x.GetCustomAttribute <AttributeLogicalNameAttribute>()?.LogicalName == "statuscode") //.AddIgnoreRule(x => x.Name == nameof(Entity.LogicalName)) .AddIgnoreRule <Entity>(x => x.LogicalName) .AddIgnoreRule(x => x.Name == nameof(Entity.EntityState)) .AddIgnoreRule(x => x.Name == nameof(Entity.KeyAttributes)) .AddIgnoreRule(x => x.Name == nameof(Entity.LazyFileAttributeKey)) .AddIgnoreRule(x => x.Name == nameof(Entity.LazyFileAttributeValue)) .AddIgnoreRule(x => x.Name == nameof(Entity.LazyFileSizeAttributeKey)) .AddIgnoreRule(x => x.Name == nameof(Entity.LazyFileSizeAttributeValue)) .AddIgnoreRule(x => x.Name == nameof(Entity.RowVersion)) .AddIgnoreRule(x => x.Name == nameof(Entity.ExtensionData)) //.AddIgnoreRule(x => x.Name == nameof(Entity.Attributes)) .AddIgnoreRule <Entity>(x => x.Attributes) .AddIgnoreRule(x => x.Name == nameof(Entity.LazyFileSizeAttributeValue)); }
public void MergeCalculationMethodInModel(IModel model, IBuildConfiguration buildConfiguration) { try { _buildConfiguration = buildConfiguration; _allContainers = model.Root.GetAllContainersAndSelf <IContainer>().ToList(); _allBlackBoxParameters = model.Root.GetAllChildren <IParameter>().Where(p => p.Formula.IsBlackBox()).ToList(); _model = model; foreach (var calculationMethod in buildConfiguration.AllCalculationMethods()) { var allMoleculesUsingMethod = allMoleculesUsing(calculationMethod, buildConfiguration.Molecules).ToList(); createFormulaForBlackBoxParameters(calculationMethod, allMoleculesUsingMethod); addHelpParametersFor(calculationMethod, allMoleculesUsingMethod); } } finally { _buildConfiguration = null; _allContainers.Clear(); _allBlackBoxParameters.Clear(); _model = null; } }
/// <summary> /// Returns whether this type creator can populate the specified type. /// </summary> /// <param name="configuration">The build configuration.</param> /// <param name="buildChain">The chain of instances built up to this point.</param> /// <param name="type">The type to evaluate.</param> /// <param name="referenceName">The property or parameter name to evaluate.</param> /// <returns><c>true</c> if this creator can populate the type; otherwise <c>false</c>.</returns> /// <exception cref="ArgumentNullException">The <paramref name="type" /> parameter is <c>null</c>.</exception> protected virtual bool CanPopulate(IBuildConfiguration configuration, IBuildChain buildChain, Type type, string?referenceName) { type = type ?? throw new ArgumentNullException(nameof(type)); return(true); }
protected override void Context() { _objectPathFactory = new ObjectPathFactory(new AliasCreator()); _buildConfiguration = A.Fake <IBuildConfiguration>(); _validFormula = new ExplicitFormula("5*PAR1"); _validFormula.AddObjectPath(_objectPathFactory.CreateFormulaUsablePathFrom("ROOT", "VALID", "PARA1").WithAlias("PAR1")); _invalidFormula = new ExplicitFormula("toto"); _invalidFormula.AddObjectPath(_objectPathFactory.CreateFormulaUsablePathFrom("ROOT", "INVALID", "PARA5").WithAlias("PAR1")); _rootContainer = new Container().WithName("ROOT"); _validContainer = new Container().WithName("VALID"); _validContainer.Add(new Parameter().WithName("PARA1").WithFormula(new ConstantFormula(1))); _validContainer.Add(new Parameter().WithName("PARA2").WithFormula(_validFormula)); _validContainer.Add(new Reaction().WithName("REACTION").WithFormula(_validFormula)); _validContainer.Add(new Transport().WithName("TRANSPORT").WithFormula(_validFormula)); _invalidContainer = new Container().WithName("INVALID"); _invalidContainer.Add(new Parameter().WithName("PARA1").WithFormula(new ConstantFormula(1))); _invalidContainer.Add(new Parameter().WithName("PARA2").WithFormula(_invalidFormula)); _invalidContainer.Add(new Reaction().WithName("REACTION").WithFormula(_invalidFormula)); _invalidContainer.Add(new Transport().WithName("TRANSPORT").WithFormula(_invalidFormula)); _rootContainer.Add(_validContainer); _rootContainer.Add(_invalidContainer); _objectTypeResolver = A.Fake <IObjectTypeResolver>(); }
public override void GlobalContext() { base.GlobalContext(); _simulation = LoadPKMLFile("simple_IV_53").Simulation; _simulationConfiguration = _simulation.BuildConfiguration; _dimensionFactory = IoC.Resolve <IDimensionFactory>(); }
private static void AddValueGenerators(IBuildConfiguration configuration) { configuration.AddValueGenerator <AddressValueGenerator>(); configuration.AddValueGenerator <AgeValueGenerator>(); configuration.AddValueGenerator <BooleanValueGenerator>(); configuration.AddValueGenerator <CityValueGenerator>(); configuration.AddValueGenerator <CompanyValueGenerator>(); configuration.AddValueGenerator <CountryValueGenerator>(); configuration.AddValueGenerator <CountValueGenerator>(); configuration.AddValueGenerator <CultureValueGenerator>(); configuration.AddValueGenerator <DateOfBirthValueGenerator>(); configuration.AddValueGenerator <DateTimeValueGenerator>(); configuration.AddValueGenerator <DomainNameValueGenerator>(); configuration.AddValueGenerator <EmailValueGenerator>(); configuration.AddValueGenerator <EnumValueGenerator>(); configuration.AddValueGenerator <FirstNameValueGenerator>(); configuration.AddValueGenerator <GenderValueGenerator>(); configuration.AddValueGenerator <GuidValueGenerator>(); configuration.AddValueGenerator <IPAddressValueGenerator>(); configuration.AddValueGenerator <LastNameValueGenerator>(); configuration.AddValueGenerator <MiddleNameValueGenerator>(); configuration.AddValueGenerator <NumericValueGenerator>(); configuration.AddValueGenerator <PhoneValueGenerator>(); configuration.AddValueGenerator <PostCodeValueGenerator>(); configuration.AddValueGenerator <StateValueGenerator>(); configuration.AddValueGenerator <StringValueGenerator>(); configuration.AddValueGenerator <SuburbValueGenerator>(); configuration.AddValueGenerator <TimeZoneValueGenerator>(); configuration.AddValueGenerator <TimeZoneInfoValueGenerator>(); configuration.AddValueGenerator <UriValueGenerator>(); }
/// <inheritdoc /> protected override bool CanCreate(IBuildConfiguration configuration, IBuildChain buildChain, Type type, string?referenceName) { var baseValue = base.CanCreate(configuration, buildChain, type, referenceName); if (baseValue == false) { return(baseValue); } // Resolve the type being created var typeToCreate = ResolveBuildType(configuration, type); // Use constructor detection to figure out how to create this instance var constructorResolver = configuration.ConstructorResolver; // Try to find a constructor to use var constructor = constructorResolver.Resolve(typeToCreate, null); if (constructor == null) { // This type does not have an available constructor return(false); } return(true); }
public void AddCalculationMethodsToBuildConfiguration(IBuildConfiguration buildConfiguration) { _calculationMethodRepository.All().Each( cm => buildConfiguration.AddCalculationMethod(_cloneManager.Clone(cm, new FormulaCache()))); correctPathsInCalculationMethods(buildConfiguration.AllCalculationMethods(), firstTopContainerName(buildConfiguration)); }
protected override void Context() { base.Context(); _amountDimension = A.Fake <IDimension>(); _targetContainer = new Container().WithName("TOTO"); A.CallTo(() => _amountDimension.Name).Returns(Constants.Dimension.MOLAR_AMOUNT); _moleculeBuilder = new MoleculeBuilder().WithName("tralala").WithDimension(_amountDimension); _parameterBuilder1 = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName("P1").WithMode(ParameterBuildMode.Local); _parameterBuilder2 = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName("P2").WithMode(ParameterBuildMode.Local); _parameterBuilder3 = DomainHelperForSpecs.ConstantParameterWithValue(1).WithName("P3").WithMode(ParameterBuildMode.Local); _parameterBuilder2.ContainerCriteria = Create.Criteria(x => x.With("TOTO")); _parameterBuilder3.ContainerCriteria = Create.Criteria(x => x.With("TATA")); _moleculeBuilder.AddParameter(_parameterBuilder1); _moleculeBuilder.AddParameter(_parameterBuilder2); _moleculeBuilder.AddParameter(_parameterBuilder3); _mappedFormula = A.Fake <IFormula>(); _buildConfiguration = A.Fake <IBuildConfiguration>(); _para1 = new Parameter().WithName("P1"); _para2 = new Parameter().WithName("P2"); _para3 = new Parameter().WithName("P3"); A.CallTo(() => _objectBaseFactory.Create <IMoleculeAmount>()).Returns(new MoleculeAmount()); A.CallTo(() => _dimensionFactory.Dimension(Constants.Dimension.MOLAR_AMOUNT)).Returns(_amountDimension); A.CallTo(() => _formulaMapper.MapFrom(_moleculeBuilder.DefaultStartFormula, _buildConfiguration)).Returns(_mappedFormula); A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder1, _buildConfiguration)).Returns(_para1); A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder2, _buildConfiguration)).Returns(_para2); A.CallTo(() => _parameterMapper.MapFrom(_parameterBuilder3, _buildConfiguration)).Returns(_para3); }
public IContainer MapFrom(IContainer containerBuilder, IBuildConfiguration buildConfiguration) { var container = _cloneManagerForModel.Clone(containerBuilder); addBuilderReference(container, containerBuilder, buildConfiguration); return(container); }
private void createSpatialStructureTableParameters(IBuildConfiguration buildConfiguration) { var spatialStructure = buildConfiguration.SpatialStructure; var allBaseIndividualDistributedParameters = new PathCache <IDistributedParameter>(_entityPathResolver).For(_baseIndividual.GetAllChildren <IDistributedParameter>(parameterShouldBeDefinedAsTable)); if (!allBaseIndividualDistributedParameters.Any()) { return; } var simulationPopulation = _simulation as PopulationSimulation; //Some special cache to optimize speed var allContainerParameters = new PathCache <IDistributedParameter>(_entityPathResolver).For(spatialStructure.TopContainers.SelectMany(x => x.GetAllChildren <IDistributedParameter>())); var allNeighborhoodParameters = new PathCache <IDistributedParameter>(_entityPathResolver).For(spatialStructure.Neighborhoods.SelectMany(x => x.GetAllChildren <IDistributedParameter>())); foreach (var baseIndividualParameter in allBaseIndividualDistributedParameters.KeyValues) { var structureParameter = allContainerParameters[baseIndividualParameter.Key] ?? allNeighborhoodParameters[baseIndividualParameter.Key]; if (structureParameter == null) { continue; } //cache all distributions for this parameter defined for the population and sub population. var allDistributionsForParameter = _parameterQuery.ParameterDistributionsFor(baseIndividualParameter.Value.ParentContainer, _baseOriginData.SpeciesPopulation, _baseOriginData.SubPopulation, baseIndividualParameter.Value.Name); var allDistributionsForMaleParameter = allDistributionsForParameter.Where(p => p.Gender == CoreConstants.Gender.Male).ToList(); var allDistributionsForFemaleParameter = allDistributionsForParameter.Where(p => p.Gender == CoreConstants.Gender.Female).ToList(); createSpatialStructureTableParameter(structureParameter, baseIndividualParameter.Value, allDistributionsForMaleParameter, allDistributionsForFemaleParameter, buildConfiguration); createPopulationTableParameter(baseIndividualParameter, simulationPopulation, allDistributionsForMaleParameter, allDistributionsForFemaleParameter); } }
public bool CreateReaction(IReactionBuilder reactionBuilder, IModel model, IBuildConfiguration buildConfiguration) { _reactionBuilder = reactionBuilder; _model = model; _buildConfiguration = buildConfiguration; try { //global container should be created before creating local reaction so that path replacement works var reactionGlobalContainer = createReactionPropertiesContainer(); _createdInstance = false; _model.Root.AcceptVisitor(this); //reaction was not created. No need to create a global container if (!_createdInstance) { _model.Root.RemoveChild(reactionGlobalContainer); } return(_createdInstance); } finally { _reactionBuilder = null; _model = null; _buildConfiguration = null; } }
private void updateMoleculeAmountFromMoleculeStartValues(IModel model, IBuildConfiguration buildConfiguration) { foreach (var moleculeStartValue in buildConfiguration.AllPresentMoleculeValues()) { //this can happen if the molecule start value contains entry for container that do not exist in the model var container = moleculeStartValue.ContainerPath.Resolve <IContainer>(model.Root); if (container == null || container.Mode != ContainerMode.Physical) { continue; } var molecule = container.EntityAt <IMoleculeAmount>(moleculeStartValue.MoleculeName); if (molecule == null) { throw new ArgumentException(Error.CouldNotFindMoleculeInContainer(moleculeStartValue.MoleculeName, moleculeStartValue.ContainerPath.PathAsString)); } if (moleculeStartValue.Formula != null) { //use a clone here because we want a different instance for each molecule updateMoleculeAmountFormula(molecule, _cloneManagerForModel.Clone(moleculeStartValue.Formula)); _keywordReplacerTask.ReplaceIn(molecule, model.Root); } else if (startValueShouldBeSetAsConstantFormula(moleculeStartValue, molecule)) { updateMoleculeAmountFormula(molecule, createConstantFormula(moleculeStartValue)); } molecule.ScaleDivisor = moleculeStartValue.ScaleDivisor; molecule.NegativeValuesAllowed = moleculeStartValue.NegativeValuesAllowed; } }
public IParameter MapFrom(IParameter parameterBuilder, IBuildConfiguration buildConfiguration) { var parameter = _cloneManagerForModel.Clone(parameterBuilder); buildConfiguration.AddBuilderReference(parameter, parameterBuilder); return(parameter); }
public void CreateObservers(IBuildConfiguration buildConfiguration, IModel model) { _allContainers = model.Root.GetAllChildren <IContainer>().ToList(); _buildConfiguration = buildConfiguration; var observers = buildConfiguration.Observers; var presentMolecules = buildConfiguration.AllPresentMolecules().ToList(); try { foreach (var observerBuilder in observers.AmountObserverBuilders) { createAmountObserver(observerBuilder, model, presentMolecules); } foreach (var observerBuilder in observers.ContainerObserverBuilders) { createContainerObserver(observerBuilder, model, presentMolecules); } } finally { _allContainers.Clear(); _buildConfiguration = null; } }
private static IOrderedEnumerable <ParameterInfo> CalculateOrderedParameters(IBuildConfiguration configuration, MethodBase method) { return(from x in method.GetParameters() orderby GetMaximumOrderPriority(configuration, x) descending select x); }
/// <inheritdoc /> protected override bool CanCreate(IBuildConfiguration configuration, IBuildChain buildChain, Type type, string?referenceName) { var buildType = ResolveBuildType(configuration, type); var baseValue = base.CanCreate(configuration, buildChain, buildType, referenceName); if (baseValue == false) { return(false); } // Check if there is no constructor to use var constructor = configuration.ConstructorResolver.Resolve(buildType); if (constructor != null) { // There is a valid constructor to use so we don't need to search for a singleton property return(false); } var propertyInfo = GetSingletonProperty(buildType); if (propertyInfo == null) { // There is no factory method that can be used return(false); } return(true); }
internal override void ExecuteInternal(IBuildConfiguration config) { if (!string.IsNullOrEmpty(JsonSecretsFilePath) && File.Exists(JsonSecretsFilePath) && File.GetAttributes(JsonSecretsFilePath).HasFlag(FileAttributes.Normal)) { return; } if (config.GetSecretsConfig().Disable || config.BuildingInsideVisualStudio) { return; } var secretsFile = Path.Combine(ProjectDirectory, "secrets.json"); if (File.Exists(secretsFile)) { Log.LogMessage("A secrets file already exists. Please delete the file to regenerate the secrets"); return; } Log.LogMessage($"Output Path: {secretsFile}"); IGenerator generator = new BuildHostSecretsGenerator(this) { SecretsJsonFilePath = secretsFile, }; generator.Execute(); }
/// <inheritdoc /> /// <exception cref="ArgumentNullException">The <paramref name="type" /> parameter is <c>null</c>.</exception> protected override bool CanCreate(IBuildConfiguration configuration, IBuildChain buildChain, Type type, string?referenceName) { type = type ?? throw new ArgumentNullException(nameof(type)); if (type.IsClass && type.IsAbstract) { // This is an abstract class so we can't create it return(false); } var typeToCreate = DetermineTypeToCreate(type); if (typeToCreate == null) { // We don't know how to create this type return(false); } if (typeToCreate.IsInterface) { // We couldn't identify that the type could be created as either List<> or Dictionary<,> return(false); } if (CanPopulate(configuration, buildChain, typeToCreate, referenceName) == false) { // There is no point trying to create something that we can't populate return(false); } return(true); }
public void UpdateBuildConfigurationForAging(IBuildConfiguration buildConfiguration, Simulation simulation, bool createAgingDataInPopulationSimulation) { if (!simulation.AllowAging) { return; } try { _simulation = simulation; _createAgingDataInPopulationSimulation = createAgingDataInPopulationSimulation; _baseIndividual = simulation.Individual; _baseOriginData = _baseIndividual.OriginData; var allHeightDistributionParameters = _parameterQuery.ParameterDistributionsFor(_baseIndividual.Organism, _baseOriginData.Population, _baseOriginData.SubPopulation, CoreConstants.Parameters.MEAN_HEIGHT); _allHeightDistributionMaleParameters = allHeightDistributionParameters.Where(p => p.Gender == CoreConstants.Gender.MALE).ToList(); _allHeightDistributionFemaleParameters = allHeightDistributionParameters.Where(p => p.Gender == CoreConstants.Gender.FEMALE).ToList(); createSpatialStructureTableParameters(buildConfiguration); createOntogenyTableParameters(buildConfiguration); updateAgeParameter(buildConfiguration); } finally { _simulation = null; _baseIndividual = null; _baseOriginData = null; } }
protected override void Context() { _reactionMapper = A.Fake <IReactionBuilderToReactionMapper>(); _keywordReplacerTask = A.Fake <IKeywordReplacerTask>(); _containerTask = A.Fake <IContainerTask>(); _parameterMapper = A.Fake <IParameterBuilderCollectionToParameterCollectionMapper>(); sut = new ReactionCreator(_reactionMapper, _keywordReplacerTask, _containerTask, _parameterMapper); _model = A.Fake <IModel>(); _reactionBuilder = A.Fake <IReactionBuilder>(); _reactionBuilder.ContainerCriteria = new DescriptorCriteria(); _reactionBuilder.Description = "A great description"; _reactionBuilder.Name = "Reaction"; _educt1 = A.Fake <IReactionPartnerBuilder>(); _educt1.MoleculeName = "sp1"; _educt2 = A.Fake <IReactionPartnerBuilder>(); _educt2.MoleculeName = "sp2"; _product1 = A.Fake <IReactionPartnerBuilder>(); _product1.MoleculeName = "sp3"; A.CallTo(() => _reactionBuilder.Educts).Returns(new[] { _educt1, _educt2 }); A.CallTo(() => _reactionBuilder.Products).Returns(new[] { _product1 }); A.CallTo(() => _reactionBuilder.ModifierNames).Returns(new[] { "modifier" }); _buildConfiguration = A.Fake <IBuildConfiguration>(); _rootContainer = new Container().WithMode(ContainerMode.Physical); _model.Root = _rootContainer; _globalContainer = new Container(); _reaction = A.Fake <IReaction>().WithName(_reactionBuilder.Name); A.CallTo(() => _reactionMapper.MapFromLocal(A <IReactionBuilder> ._, A <IContainer> ._, _buildConfiguration)).Returns(_reaction); A.CallTo(() => _containerTask.CreateOrRetrieveSubContainerByName(_rootContainer, _reactionBuilder.Name)).Returns(_globalContainer); }
private void createSpatialStructureTableParameter( IParameter structureParameter, IDistributedParameter baseIndividualParameter, IReadOnlyList <ParameterDistributionMetaData> distributionsForMale, IReadOnlyList <ParameterDistributionMetaData> distributionsForFemale, IBuildConfiguration buildConfiguration) { var allDistributionsForParameter = allDistributionsWithAgeStrictBiggerThanOriginData(distributionsForMale, distributionsForFemale, _baseIndividual.OriginData); if (!allDistributionsForParameter.Any()) { return; } //remove the parameter from the parent container and add a new one that will contain the table formula //retrieve the table formula corresponding to the individual values var newParameter = _parameterFactory.CreateFor(structureParameter.Name, structureParameter.BuildingBlockType); newParameter.UpdatePropertiesFrom(structureParameter, _cloneManager); var parentContainer = structureParameter.ParentContainer; parentContainer.RemoveChild(structureParameter); parentContainer.Add(newParameter); newParameter.Editable = false; var formula = createTableFormulaFrom(baseIndividualParameter, allDistributionsForParameter); updateConstantParameterToFormula(newParameter, formula, buildConfiguration); }
private void addNewParametersToParameterStartValues(IBuildConfiguration buildConfiguration, IParameter age0Parameter, IParameter minToYearFactorParameter) { var psv = buildConfiguration.ParameterStartValues; addParameterToParameterStartValues(psv, age0Parameter); addParameterToParameterStartValues(psv, minToYearFactorParameter); }
public IParameterStartValuesBuildingBlock CreateFor(IBuildConfiguration buildConfiguration, Simulation simulation) { try { //default default parameter start values matrix _spatialStructure = buildConfiguration.SpatialStructure; _defaultStartValues = _parameterStartValuesCreator.CreateFrom(_spatialStructure, buildConfiguration.Molecules); _formulaCache = _defaultStartValues.FormulaCache; var individual = simulation.Individual; //set the relative expression values for each protein defined in individual foreach (var protein in individual.AllMolecules <IndividualProtein>()) { updateProteinParametersValues(protein); } foreach (var transporter in individual.AllMolecules <IndividualTransporter>()) { updateTransporterParameterValues(transporter); } updateSimulationParameters(simulation); return(_defaultStartValues.WithName(simulation.Name)); } finally { _spatialStructure = null; _defaultStartValues = null; _formulaCache = null; } }
/** * Makes a list of {@link BuildAndCacheApplicationLayerStep} for dependencies, resources, and * classes layers. Optionally adds an extra layer if configured to do so. */ public static IAsyncStep <IReadOnlyList <ICachedLayer> > MakeList( IBuildConfiguration buildConfiguration, ProgressEventDispatcher.Factory progressEventDispatcherFactory) { buildConfiguration = buildConfiguration ?? throw new ArgumentNullException(nameof(buildConfiguration)); int layerCount = buildConfiguration.GetLayerConfigurations().Length; using (ProgressEventDispatcher progressEventDispatcher = progressEventDispatcherFactory.Create( "setting up to build application layers", layerCount)) using (TimerEventDispatcher ignored = new TimerEventDispatcher(buildConfiguration.GetEventHandlers(), Description)) { List <Task <ICachedLayer> > buildAndCacheApplicationLayerSteps = new List <Task <ICachedLayer> >(); foreach (LayerConfiguration layerConfiguration in buildConfiguration.GetLayerConfigurations()) { // Skips the layer if empty. if (layerConfiguration.LayerEntries.Length == 0) { continue; } buildAndCacheApplicationLayerSteps.Add( new BuildAndCacheApplicationLayerStep( buildConfiguration, progressEventDispatcher.NewChildProducer(), layerConfiguration.Name, layerConfiguration).GetFuture()); } return(AsyncSteps.FromTasks(buildAndCacheApplicationLayerSteps)); } }
public override void GlobalContext() { base.GlobalContext(); _compound.Parameter(CoreConstants.Parameter.IS_SMALL_MOLECULE).Value = 0; _simulation = DomainFactoryForSpecs.CreateSimulationWith(_individual, _compound, _protocol, CoreConstants.Model.TwoPores) as IndividualSimulation; var buildConfigurationTask = IoC.Resolve<IBuildConfigurationTask>(); _buildConfiguration = buildConfigurationTask.CreateFor(_simulation, shouldValidate: true, createAgingDataInSimulation: false); }
/// <inheritdoc /> /// <exception cref="ArgumentNullException">The <paramref name="configuration" /> parameter is null.</exception> /// <exception cref="ArgumentNullException">The <paramref name="buildLog" /> parameter is null.</exception> public void Initialize(IBuildConfiguration configuration, IBuildLog buildLog) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } if (buildLog == null) { throw new ArgumentNullException(nameof(buildLog)); } Configuration = configuration; Log = buildLog; }
public void Initialize(IBuildConfiguration configuration, IBuildLog buildLog) { }