public IPKSimMacroCommand UpdateValues(PathCache <IParameter> sourceParameters, IContainer targetContainer)
{
var allTargetParameters = new PathCache <IParameter>(_entityPathResolver).For(targetContainer.GetAllChildren <IParameter>());
return(UpdateValues(sourceParameters, allTargetParameters));
}
private void updateReferenceToIndividualParametersForStandardContainer(Individual individual, IndividualMolecule molecule, MoleculeExpressionContainer expressionContainer, IList <IContainer> allOrganismContainers, PathCache <IMoleculeAmount> moleculeAmountPath)
{
var allContainers = _expressionContainersRetriever.AllContainersFor(individual.Organism, allOrganismContainers, molecule, expressionContainer);
foreach (var container in allContainers)
{
var amount = amountFor(container, molecule, moleculeAmountPath);
if (amount == null)
{
continue;
}
updateFromIndividualParameter(amount.Parameter(CoreConstants.Parameters.REL_EXP), expressionContainer.RelativeExpressionParameter, individual, molecule);
updateFromIndividualParameter(amount.Parameter(CoreConstants.Parameters.REL_EXP_NORM), expressionContainer.RelativeExpressionNormParameter, individual, molecule);
}
}
protected override void Context()
{
var entityPathFactory = new EntityPathResolverForSpecs();
_objectPathFactory = new ObjectPathFactory(new AliasCreator());
_simulation = A.Fake <IModelCoreSimulation>().WithName("Sim");
_simModelManager = A.Fake <ISimModelManager>();
_containerTask = A.Fake <IContainerTask>();
_options = new ScaleDivisorOptions();
_moleculeAmountCache = new PathCache <IMoleculeAmount>(entityPathFactory);
var rootContainer = new ARootContainer().WithName(_simulation.Name)
.WithContainerType(ContainerType.Simulation);
_simulation.Model.Root = rootContainer;
_moleculeAmount1 = new MoleculeAmount().WithName("M1");
_moleculeAmount2 = new MoleculeAmount().WithName("M2");
rootContainer.Add(_moleculeAmount1);
rootContainer.Add(_moleculeAmount2);
_moleculeAmountCache.Add(_moleculeAmount1);
_moleculeAmountCache.Add(_moleculeAmount2);
_molecule1Path = entityPathFactory.PathFor(_moleculeAmount1);
_molecule2Path = entityPathFactory.PathFor(_moleculeAmount2);
_originalResults = new DataRepository();
_simulation.Results = _originalResults;
var baseGrid = new BaseGrid("Time", Constants.Dimension.NO_DIMENSION)
{
Values = new[] { 0f, 1f, 2f, 3f }
};
_originalDataColumn = new DataColumn("M1", Constants.Dimension.NO_DIMENSION, baseGrid)
{
Values = new[] { 0f, 10f, 20f, 30f }
};
_originalDataColumn.QuantityInfo.Path = _objectPathFactory.CreateAbsoluteObjectPath(_moleculeAmount1);
_originalResults.Add(_originalDataColumn);
A.CallTo(_containerTask).WithReturnType <PathCache <IMoleculeAmount> >().Returns(_moleculeAmountCache);
var simResults = new DataRepository();
var baseGrid2 = new BaseGrid("Time", Constants.Dimension.NO_DIMENSION)
{
Values = new[] { 0f, 1f, 2f, 3f }
};
var res1 = new DataColumn("M1", Constants.Dimension.NO_DIMENSION, baseGrid2)
{
Values = new[] { 0f, 10f, 20f, 30f }
};
res1.QuantityInfo.Path = _objectPathFactory.CreateAbsoluteObjectPath(_moleculeAmount1);
simResults.Add(res1);
var res2 = new DataColumn("M2", Constants.Dimension.NO_DIMENSION, baseGrid2)
{
Values = new[] { 0f, 11f, 12f, 13f }
};
res2.QuantityInfo.Path = _objectPathFactory.CreateAbsoluteObjectPath(_moleculeAmount2);
simResults.Add(res2);
var simulationRunResults = new SimulationRunResults(true, Enumerable.Empty <ISolverWarning>(), simResults);
A.CallTo(() => _simModelManager.RunSimulation(_simulation)).Returns(simulationRunResults);
sut = new ScaleDivisorCalculator(_simModelManager, _containerTask, _objectPathFactory);
}
public CloseInstruction(PathCache pathCache)
{
_pathCache = pathCache;
}
private void updateAllParametersFor(Simulation simulation, Individual individual, IList <IContainer> allOrganismContainers, IndividualMolecule molecule, PathCache <IMoleculeAmount> moleculeAmountPath)
{
var globalMoleculeContainer = simulation.Model.Root
.GetSingleChildByName <IContainer>(molecule.Name);
hideGlobalParametersForUndefinedMolecule(globalMoleculeContainer);
hideInterstialParametersForIntracellularLocalizationInTissue(individual, molecule, allOrganismContainers, moleculeAmountPath);
foreach (var expressionContainer in molecule.AllExpressionsContainers())
{
if (expressionContainer.IsSurrogate())
{
updateReferenceToIndividualParametersForSurrogateContainer(individual, molecule, expressionContainer, globalMoleculeContainer);
}
else
{
updateReferenceToIndividualParametersForStandardContainer(individual, molecule, expressionContainer, allOrganismContainers, moleculeAmountPath);
}
}
}
public void UpdateParametersAndSpeciesValuesForIndividual(int individualId, IReadOnlyList <ParameterProperties> parameterProperties,
IReadOnlyList <SpeciesProperties> speciesProperties, PathCache <IParameter> parameterCache)
{
fillParameterAndSpeciesInitialValuesFor(individualId, parameterProperties, speciesProperties, parameterCache);
}
private ICommand updateParameterValues(PathCache <IParameter> sourceParameters, PathCache <IParameter> targetParameters)
{
return(_parameterSetUpdater.UpdateValues(sourceParameters, targetParameters));
}
public async Task <IReadOnlyCollection <ScaleDivisor> > CalculateScaleDivisorsAsync(IModelCoreSimulation simulation, ScaleDivisorOptions scaleDivisorOptions, PathCache <IMoleculeAmount> allMoleculeAmounts)
{
_simulationName = simulation.Name;
var previousResults = simulation.Results;
var previousSelections = outputSelectionsFor(simulation);
_allMoleculeAmounts = allMoleculeAmounts;
_scaleDivisorOptions = scaleDivisorOptions;
var previousScaleDivisor = retrievePreviousScaleDivisor();
try
{
resetScaleDivisor();
settingsFor(simulation).OutputSelections = createOutputSelectionWithAllMoleculeAmountSelected();
updateSelectedMoleculeAmount(simulation);
var results = await runSimulation(simulation);
return(computerScaleDivisorBasedOn(results));
}
finally
{
simulation.Results = previousResults;
settingsFor(simulation).OutputSelections = previousSelections;
updateSelectedMoleculeAmount(simulation);
setPreviousScaleDivisor(previousScaleDivisor);
_allMoleculeAmounts = null;
_scaleDivisorOptions = null;
}
}
public void UpdateDistributedParameter(PathCache <IDistributedParameter> allDistributedParameter, PathCache <IDistributedParameter> allBaseDistributedParameters, OriginData originData)
{
foreach (var distributionsForOneContainer in _parameterQuery.AllParameterDistributionsFor(originData).GroupBy(dist => dist.ParentContainerPath))
{
foreach (var distributions in distributionsForOneContainer.GroupBy(x => x.ParameterName))
{
var parameterPath = distributionsForOneContainer.Key + ObjectPath.PATH_DELIMITER + distributions.Key;
var currentParameter = allDistributedParameter[parameterPath];
var baseParameter = allBaseDistributedParameters[parameterPath];
if (currentParameter == null || baseParameter == null)
{
continue;
}
_distributionFactory.UpdateDistributionBasedOn(distributions, currentParameter, baseParameter, originData);
}
}
}
private IPKSimCommand updateParameterValues(PathCache <IParameter> sourceParameters, PathCache <IParameter> targetParameters)
{
return(_parameterSetUpdater.UpdateValues(sourceParameters, targetParameters).DowncastTo <IPKSimCommand>());
}
private void ConnectCallback()
{
_doContentScanOn.Clear();
Initialize();
SetFavorites();
var defaultPath = string.IsNullOrEmpty(Connection.Model.DefaultPath)
? GetDefaultDrive()
: Connection.Model.DefaultPath;
var drive = GetDriveFromPath(defaultPath);
if (drive != null && FileManager.FolderExists(defaultPath))
{
PathCache.Add(drive, defaultPath);
}
Drive = drive ?? Drives.First();
if (!IsContentScanTriggerAvailable)
{
return;
}
//HACK: for testing purposes only
if (FileManager.ServerType == FtpServerType.IIS)
{
ScanFolders = new Dictionary <int, FsdScanPath>()
{
{ 1, new FsdScanPath
{
PathId = 1,
Path = "/Hdd1/Content/0000000000000000/",
ScanDepth = 2,
Drive = "Hdd1"
} }
};
return;
}
var credentials = GetHttpLogin();
var username = credentials.UserName;
var password = credentials.Password;
switch (GetScanFolders(username, password))
{
case HttpStatusCode.OK:
if (!UserSettingsProvider.DisableFsdStatusPolling)
{
_statusUpdateTimer.Elapsed += StatusUpdateTimerOnElapsed;
_statusUpdateTimer.Start();
}
return;
case HttpStatusCode.Unauthorized:
bool result;
do
{
var loginViewModel = Container.Resolve <ILoginViewModel>();
loginViewModel.Title = Resx.Login;
loginViewModel.Message = Resx.LoginToFreestyleDashHttpServer;
loginViewModel.Username = username;
loginViewModel.Password = password;
loginViewModel.IsRememberPasswordEnabled = true;
var login = WindowManager.ShowLoginDialog(loginViewModel);
if (login == null)
{
var answer = (DisableOption)WindowManager.ShowListInputDialog(Resx.DisableFsdContentScanTriggerTitle, Resx.DisableFsdContentScanTriggerMessage, DisableOption.None, GetDisableOptionList());
switch (answer)
{
case DisableOption.All:
UserSettingsProvider.FsdContentScanTrigger = FsdContentScanTrigger.Disabled;
break;
case DisableOption.Single:
Connection.IsHttpAccessDisabled = true;
break;
}
result = true;
}
else
{
username = login.Username;
password = login.Password;
var status = GetScanFolders(username, password);
if (status != HttpStatusCode.OK && status != HttpStatusCode.Unauthorized)
{
//TODO: handle different result then the previous one
result = true;
}
else
{
result = status != HttpStatusCode.Unauthorized;
if (result && login.RememberPassword == true)
{
Connection.HttpUsername = username;
Connection.HttpPassword = password;
EventAggregator.GetEvent <ConnectionDetailsChangedEvent>().Publish(new ConnectionDetailsChangedEventArgs(Connection));
}
}
}
} while (!result);
break;
case HttpStatusCode.RequestTimeout:
{
var answer = (DisableOption)WindowManager.ShowListInputDialog(Resx.DisableFsdContentScanTriggerTitle, Resx.DisableFsdContentScanTriggerMessage, DisableOption.None, GetDisableOptionList());
switch (answer)
{
case DisableOption.All:
UserSettingsProvider.FsdContentScanTrigger = FsdContentScanTrigger.Disabled;
break;
case DisableOption.Single:
Connection.IsHttpAccessDisabled = true;
break;
}
}
break;
}
}
public LineToInstruction(Vector2D <float> position, PathCache pathCache)
{
_position = position;
_pathCache = pathCache;
}
void _http_download(System.Net.HttpListenerContext req)
{
string path = req.Request.Url.AbsolutePath.Substring(1);
string[] subpath = path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (subpath.Length == 1)
{//return the list;
string downstr = "<html>";
foreach (var p in _http_downcache)
{
downstr += p.Key + ",locked=" + p.Value.locked + "<br/>";
}
downstr += "</html>";
_http_response_html(req, downstr);
return;
}
string path2 = subpath[1];
if (System.IO.File.Exists(path) == false)
{
req.Response.StatusCode = 404;
req.Response.Close();
}
else
{
if (_http_downcache.ContainsKey(path2) == false)
{
_http_downcache[path2] = new PathCache("/publish/" + path2);
}
byte[] filebuf = _http_downcache[path2].GetBytes(path);
//byte[] filebuf = System.IO.File.ReadAllBytes(path);
string range = req.Request.Headers.Get("range");
int from = 0;
int len = filebuf.Length;
if (string.IsNullOrWhiteSpace(range) == false)
{
string[] ss = range.Split(new char[] { '-', '=' });
from = int.Parse(ss[1]);
len = filebuf.Length - from;
if (string.IsNullOrWhiteSpace(ss[2]) == false)
{
int end = int.Parse(ss[2]);
len = end - from;
}
}
req.Response.AddHeader("Content-Range", "bytes " + from + "-");
req.Response.ContentEncoding = System.Text.Encoding.UTF8;
req.Response.ContentLength64 = filebuf.Length;
req.Response.ContentType = "application/octet-stream";
AsyncCallback onResponse = onResponse = (rhr) =>
{
try
{
req.Response.OutputStream.EndWrite(rhr);
req.Response.Close();
}
catch
{
try
{
req.Response.Close();
}catch
{
}
}
};
req.Response.OutputStream.BeginWrite(filebuf, from, len, onResponse, null);
}
}
public IPKSimMacroCommand UpdateValues(PathCache <IParameter> sourceParameters, PathCache <IParameter> targetParameters, bool updateParameterOriginId = true)
{
var updateCommands = new PKSimMacroCommand {
CommandType = PKSimConstants.Command.CommandTypeEdit, ObjectType = PKSimConstants.ObjectTypes.Parameter
};
//should update non distributed parameters first and then distributed parameter
foreach (var sourceParameter in sourceParameters.KeyValues.OrderBy(x => x.Value.IsDistributed()))
{
var targetParameter = targetParameters[sourceParameter.Key];
if (targetParameter == null)
{
continue;
}
updateCommands.Add(UpdateValue(sourceParameter.Value, targetParameter, updateParameterOriginId));
}
return(updateCommands);
}
public void Edit(IEnumerable <IParameter> parameters)
{
_allParameterCache = _parameterTask.PathCacheFor(parameters);
updateParameters();
}
private ICommand <IMoBiContext> updateSimulation(IMoBiSimulation simulationToUpdate, IBuildingBlock templateBuildingBlock, IMoBiBuildConfiguration buildConfigurationReferencingTemplates, IMoBiCommand configurationCommands, PathCache <IQuantity> fixedValueQuantities)
{
//create model using referencing templates
var model = createModelAndValidate(simulationToUpdate.Model.Name, buildConfigurationReferencingTemplates);
var simulationBuildConfiguration = createBuildConfigurationToUseInSimulation(buildConfigurationReferencingTemplates);
var updateSimulationCommand = new UpdateSimulationCommand(simulationToUpdate, model, simulationBuildConfiguration, templateBuildingBlock).Run(_context);
synchronizeFixedParameterValues(simulationToUpdate, fixedValueQuantities, templateBuildingBlock);
var macro = new MoBiMacroCommand
{
Description = updateSimulationCommand.Description,
CommandType = updateSimulationCommand.CommandType,
ObjectType = updateSimulationCommand.ObjectType
};
macro.Add(configurationCommands);
macro.Add(updateSimulationCommand);
return(macro);
}
private void fillParameterAndSpeciesInitialValuesFor(int individualId, IReadOnlyList <ParameterProperties> parameters,
IReadOnlyList <SpeciesProperties> speciesProperties, PathCache <IParameter> parameterCache)
{
var nonTableParameterValues = parameterDataRowFromIndividualId(individualId);
foreach (var parameter in parameters)
{
// first, assign all table points for the parameter from the aging data (if any)
fillTableParameterValuesFor(parameter, individualId);
// if no aging data found, parameter value is stored in the population data table
// (single value)
if (parameter.TablePoints.Any())
{
continue;
}
var parameterValue = nonTableParameterValues[parameter.Path].ConvertedTo <double>();
//reset the parameter to its default value if the value in the table is NaN
parameter.Value = double.IsNaN(parameterValue) ? parameterCache[parameter.Path].Value : parameterValue;
}
var initialValues = initialValuesDataRowFromIndividualId(individualId);
if (initialValues == null)
{
return;
}
foreach (var species in speciesProperties)
{
species.InitialValue = initialValues[species.Path].ConvertedTo <double>();
}
}
public MisDummyPath(float lightArea, int numLightPaths, Vector3[] positions, Vector3[] normals)
{
this.lightArea = lightArea;
this.numLightPaths = numLightPaths;
this.positions = positions;
this.normals = normals;
// Create the light path
pathCache = new PathCache(1, 10);
var emitterVertex = new PathVertex {
Point = new SurfacePoint {
Position = positions[0],
Normal = normals[0],
},
PdfFromAncestor = -10000.0f,
PdfReverseAncestor = -10000.0f, // Guard value: this is unused!
AncestorId = -1,
Depth = 0
};
int emVertexId = pathCache.AddVertex(emitterVertex, 0);
// Add all intermediate surface vertices
var prevLightVertex = emitterVertex;
int prevLightVertexIdx = emVertexId;
float lastReverse = 0.0f;
float lastNee = 0.0f;
for (int idx = 1; idx < normals.Length; ++idx)
{
// Add the vertex on the first surface
var surfaceVertex = new PathVertex {
Point = new SurfacePoint {
Position = positions[idx],
Normal = normals[idx],
},
AncestorId = prevLightVertexIdx,
Depth = (byte)idx
};
// Compute the geometry terms
Vector3 dirToLight = prevLightVertex.Point.Position - surfaceVertex.Point.Position;
float distSqr = dirToLight.LengthSquared();
dirToLight = Vector3.Normalize(dirToLight);
float cosSurfToLight = Vector3.Dot(dirToLight, surfaceVertex.Point.Normal);
float cosLightToSurf = Vector3.Dot(-dirToLight, prevLightVertex.Point.Normal);
// pdf for diffuse sampling of the emission direction
surfaceVertex.PdfFromAncestor = (cosLightToSurf / MathF.PI) * (cosSurfToLight / distSqr);
surfaceVertex.PdfReverseAncestor = lastReverse;
surfaceVertex.PdfNextEventAncestor = lastNee;
lastReverse = (cosSurfToLight / MathF.PI) * (cosLightToSurf / distSqr);
if (idx == 1)
{
surfaceVertex.PdfFromAncestor *= 1.0f / lightArea; // emission surface sampling pdf
lastNee = 1.0f / lightArea; // Next event
}
else
{
lastNee = 0.0f;
}
int lightVertexIndex = pathCache.AddVertex(surfaceVertex, 0);
prevLightVertex = surfaceVertex;
prevLightVertexIdx = lightVertexIndex;
}
lightEndpointIdx = prevLightVertexIdx;
// Create the camera path
cameraVertices = new PathPdfPair[positions.Length];
// sampling the camera itself / a point on the lens
cameraVertices[0] = new PathPdfPair {
PdfFromAncestor = 1.0f, // lens / sensor sampling is deterministic
PdfToAncestor = 0.0f
};
// primary surface vertex
cameraVertices[1] = new PathPdfPair {
PdfFromAncestor = numLightPaths * 0.8f, // surface area pdf of sampling this vertex from the camera
PdfToAncestor = 1.0f
};
// All other surface vertices
float nextReverse = lastReverse;
int lightVertIdx = lightEndpointIdx;
for (int idx = 2; idx < positions.Length; ++idx)
{
var lightVert = pathCache[0, lightVertIdx];
cameraVertices[idx] = new PathPdfPair {
PdfFromAncestor = nextReverse,
PdfToAncestor = lightVert.PdfFromAncestor
};
nextReverse = lightVert.PdfReverseAncestor;
lightVertIdx = lightVert.AncestorId;
}
// The last camera path vertex is special: it should not already contain the NEE pdf
var dir = pathCache[0, 0].Point.Position - pathCache[0, 1].Point.Position;
var cossurf = Vector3.Dot(Vector3.Normalize(dir), pathCache[0, 1].Point.Normal);
var coslight = Vector3.Dot(Vector3.Normalize(-dir), pathCache[0, 0].Point.Normal);
var distsqr = dir.LengthSquared();
cameraVertices[^ 1].PdfFromAncestor = cossurf * coslight / distsqr / MathF.PI;
public BidirPathPdfs(PathCache cache, Span <float> lightToCam, Span <float> camToLight)
{
PdfsCameraToLight = camToLight;
PdfsLightToCamera = lightToCam;
LightPathCache = cache;
}
public override void StartAnalysis(IPopulationDataCollector populationDataCollector, PopulationAnalysis populationAnalysis)
{
_allQuantities = _entitiesInContainerRetriever.QuantitiesFrom(populationDataCollector);
base.StartAnalysis(populationDataCollector, populationAnalysis);
}
private void synchronizeFixedParameterValues(IMoBiSimulation simulationToUpdate, IBuildingBlock templateBuildingBlock, PathCache <IQuantity> fixedValueQuantities)
{
if (fixedValueQuantities == null)
{
return;
}
var currentQuantities = new PathCache <IQuantity>(_entityPathResolver);
currentQuantities.AddRange(simulationToUpdate.Model.Root.GetAllChildren <IQuantity>());
foreach (var fixedValueQuantity in fixedValueQuantities.KeyValues)
{
//quantity does not exist anymore after update. Nothing to do
var simulationQuantity = currentQuantities[fixedValueQuantity.Key];
if (simulationQuantity == null)
{
continue;
}
//building block corresponding to quantity could not be found. That should never happen
var affectedBuildingBlock = _affectedBuildingBlockRetriever.RetrieveFor(simulationQuantity, simulationToUpdate);
if (affectedBuildingBlock?.UntypedTemplateBuildingBlock == null)
{
continue;
}
//The quantity previously fixed is part of the template building block. We should not reset the changes
if (Equals(affectedBuildingBlock.UntypedTemplateBuildingBlock, templateBuildingBlock))
{
continue;
}
synchronizeQuantities(fixedValueQuantity.Value, simulationQuantity);
}
}
public IndividualValuesCache ImportFrom(string populationFileFullPath, IImportLogger logger, PathCache <IParameter> allParameters = null)
{
try
{
foreach (var delimiter in ALLOWED_DELIMITERS)
{
var individualValuesCache = individualValuesCacheFrom(populationFileFullPath, delimiter);
//we found at least one individual, this is a valid file for the delimiter and we can exit
if (individualValuesCache?.Count > 0)
{
return(withPathsContainingUnitsUpdated(individualValuesCache, allParameters, logger));
}
}
//no match. Log
logger.AddError(Warning.PopulationFileFormatIsNotSupported);
return(new IndividualValuesCache());
}
catch (Exception e)
{
logger.AddError(e.FullMessage());
return(new IndividualValuesCache());
}
}
public virtual void Merge(IndividualPropertiesCache individualPropertiesCache, PathCache <IParameter> parameterCache)
{
AllCovariates.AddRange(individualPropertiesCache.AllCovariates);
ParameterValuesCache.Merge(individualPropertiesCache.ParameterValuesCache, parameterCache);
}
private IndividualValuesCache withPathsContainingUnitsUpdated(IndividualValuesCache individualValuesCache, PathCache <IParameter> allParameters, IImportLogger logger)
{
// No parameters to check from, return as IS
if (allParameters == null)
{
return(individualValuesCache);
}
//Use TO LIST here because collection might be modified
foreach (var parameterValue in individualValuesCache.AllParameterValues.ToList())
{
var parameterPath = parameterValue.ParameterPath;
if (allParameters.Contains(parameterPath))
{
continue;
}
var pathWithUnitsRemoved = parameterPath.StripUnit();
if (allParameters.Contains(pathWithUnitsRemoved))
{
individualValuesCache.RenamePath(parameterPath, pathWithUnitsRemoved);
parameterValue.ParameterPath = pathWithUnitsRemoved;
continue;
}
logger.AddWarning(Warning.ParameterWithPathNotFoundInBaseIndividual(parameterPath));
individualValuesCache.Remove(parameterPath);
}
return(individualValuesCache);
}
private void hideInterstialParametersForIntracellularLocalizationInTissue(Individual individual, IndividualMolecule molecule, IList <IContainer> allOrganismContainers, PathCache <IMoleculeAmount> moleculeAmountPath)
{
var protein = molecule as IndividualProtein;
if (protein?.TissueLocation != TissueLocation.Intracellular || protein.IntracellularVascularEndoLocation != IntracellularVascularEndoLocation.Interstitial)
{
return;
}
var vascularEndothelium = protein.ExpressionContainer(CoreConstants.Compartment.VascularEndothelium);
if (vascularEndothelium == null)
{
return;
}
var allInterstitialContainer = _expressionContainersRetriever.AllContainersFor(individual.Organism, allOrganismContainers, protein, vascularEndothelium);
foreach (var interstitial in allInterstitialContainer)
{
var amount = amountFor(interstitial, molecule, moleculeAmountPath);
if (amount == null)
{
continue;
}
hideParameter(amount.Parameter(CoreConstants.Parameters.REL_EXP));
hideParameter(amount.Parameter(CoreConstants.Parameters.REL_EXP_NORM));
}
}
private void updateParameterValue(Population population, int individualId, IParameter parameter, PathCache <IParameter> extractedIndividualParameterCache)
{
var parameterPath = _entityPathResolver.PathFor(parameter);
var parameterValues = population.AllValuesFor(parameterPath);
var extractedParameter = extractedIndividualParameterCache[parameterPath];
var value = parameterValues[individualId];
if (!shouldUpdateParameter(extractedParameter, value))
{
return;
}
extractedParameter.Value = value;
}
private IMoleculeAmount amountFor(IContainer container, IndividualMolecule molecule, PathCache <IMoleculeAmount> moleculeAmountPath)
{
var amount = moleculeAmountPath[_entityPathResolver.ObjectPathFor(container).AndAdd(molecule.Name).ToString()];
return(amount);
}
public virtual void Edit(IEnumerable <IParameter> parameters)
{
_visibleParameters = parameters.Where(x => x.Visible).ToList();
_pathCache = _parameterTask.PathCacheFor(_visibleParameters);
}
public TreeBrowserModel(BrowserController controller, PathCache cache, ListProgressListener listener)
{
_controller = controller;
_cache = cache;
}
public IndividualValuesCache ImportFrom(string fileFullPath, PathCache <IParameter> allParameters, IImportLogger logger)
{
var individualValuesCache = _individualValuesCacheImporter.ImportFrom(fileFullPath, logger, allParameters);
return(withUpdatedGenderAndRace(individualValuesCache));
}
