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