private List <ExperimentInstance> DuplicateExperimentInstances(List <ExperimentInstance> instances,
int repetitions)
{
var copies = new List <ExperimentInstance>();
for (var i = 0; i < repetitions; i++)
{
foreach (var instance in instances)
{
var instanceCopy = new ExperimentInstance
{
ParameterValues = new List <ExperimentParameterAssignment>()
};
foreach (var valueAssignment in instance.ParameterValues)
{
instanceCopy.ParameterValues.Add(new ExperimentParameterAssignment
{
ParameterValue = valueAssignment.ParameterValue,
ExperimentInstance = instanceCopy
});
}
copies.Add(instanceCopy);
}
}
return(copies);
}
public IDictionary <string, object> Resolve(ExperimentInstance source, ExperimentInstanceDto destination,
IDictionary <string, object> destMember,
ResolutionContext context)
{
return(source.ParameterValues.Select(v => v.ParameterValue)
.ToDictionary(parameterValue => parameterValue.Parameter.Name,
parameterValue => ParseUtils.ParseToClosestPossibleValueType(parameterValue.Value)));
}
internal Result(ExperimentInstance <T, TClean> experiment, IEnumerable <Observation <T, TClean> > observations, Observation <T, TClean> control, Dictionary <string, dynamic> contexts)
{
Candidates = observations.Where(o => o != control).ToList();
Control = control;
ExperimentName = experiment.Name;
Observations = observations.ToList();
Contexts = contexts;
var mismatchedObservations = Candidates.Where(o => !o.EquivalentTo(Control, experiment.Comparator)).ToList();
IgnoredObservations = mismatchedObservations.Where(m => experiment.IgnoreMismatchedObservation(control, m).Result).ToList();
MismatchedObservations = mismatchedObservations.Except(IgnoredObservations).ToList();
}
public override void OnActionExecuting(ActionExecutingContext context)
{
var simId = int.Parse((string)context.RouteData.Values["simid"]);
var instanceId = int.Parse((string)context.RouteData.Values["instanceid"]);
var instance = _context.ExperimentInstances
.Include(si => si.Experiment)
.SingleOrDefault(i => (i.Id == instanceId) && (i.ExperimentId == simId));
if (instance == null)
{
context.Result = NotFound();
return;
}
_currentExperimentInstance = instance;
base.OnActionExecuting(context);
}
private void FindAllInstancePermutations_Recursion(
IList <ExperimentInstance> experimentInstances,
IList <Parameter> parameters,
IList <ParameterValue> selectedParams)
{
// If there are no parameters left in the list, we have selected a value for each parameter.
if (!parameters.Any())
{
var experimentInstance = new ExperimentInstance
{
ParameterValues = new List <ExperimentParameterAssignment>(),
Status = ExperimentStatus.Pending
};
experimentInstances.Add(experimentInstance);
foreach (var selectedParam in selectedParams)
{
experimentInstance.ParameterValues.Add(new ExperimentParameterAssignment
{
ExperimentInstance = experimentInstance,
ParameterValue = selectedParam
});
}
}
else
{
// Pop the first parameter from the list.
var parameter = parameters.First();
parameters.Remove(parameter);
// Select each possible value once.
foreach (var paramInstance in parameter.Values)
{
selectedParams.Add(paramInstance);
FindAllInstancePermutations_Recursion(experimentInstances, parameters, selectedParams);
selectedParams.Remove(paramInstance);
}
parameters.Insert(0, parameter);
}
}
public IActionResult AddCombination(int id, [FromBody] List <ParameterValueAddDto> parameterValueAddDto)
{
/*
* This method does not ensure a full cartesian product.
*/
var performanceTracking = false;
Stopwatch sw = performanceTracking ? new Stopwatch() : null;
if (sw != null)
{
sw.Start();
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (sw != null)
{
TimeSpan ts = sw.Elapsed;
Console.WriteLine("Model state validated after " + String.Format("{0:00}:{1:00}:{2:00}:{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds));
}
Experiment sim;
if (!_cache.TryGetValue(id, out sim))
{
sim = _context.Experiments
.Include(s => s.Parameters).ThenInclude(p => p.Values)
.SingleOrDefault(s => s.Id == id);
_cache.Set(id, sim, TimeSpan.FromMinutes(1));
}
if (sim == null)
{
Console.WriteLine("Server did not find experiment " + id.ToString());
return(NotFound());
}
if (sw != null)
{
TimeSpan ts = sw.Elapsed;
Console.WriteLine("Loaded data after " + String.Format("{0:00}:{1:00}:{2:00}:{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds));
}
if (!parameterValueAddDto.TrueForAll(para => sim.Parameters.Single(p => p.Name == para.ParameterName) != null))
{
Console.WriteLine("Invalid parameter name " + parameterValueAddDto.Where(para => sim.Parameters.Single(p => p.Name == para.ParameterName) == null).First().ParameterName + ".");
return(BadRequest("Invalid parameter name " + parameterValueAddDto.Where(para => sim.Parameters.Single(p => p.Name == para.ParameterName) == null).First().ParameterName + "."));
}
/*if (sim.Parameters.Where(para => parameterValueAddDto.Exists(p => p.ParameterName != para.Name)).Count() > 0)
* {
* Console.WriteLine("Missing parameter " + sim.Parameters.Where(para => parameterValueAddDto.Exists(p => p.ParameterName != para.Name)).First().Name + ".");
* return BadRequest("Missing parameter " + sim.Parameters.Where(para => parameterValueAddDto.Exists(p => p.ParameterName != para.Name)).First().Name + ".");
* }*/
if (!parameterValueAddDto.TrueForAll(para => ParameterValidator.IsValid(sim.Parameters.Single(p => p.Name == para.ParameterName).Type, para.Value)))
{
Console.WriteLine("Parameter value " +
parameterValueAddDto.Where(para => !ParameterValidator.IsValid(sim.Parameters.Single(p => p.Name == para.ParameterName).Type, para.Value)).First().Value +
" is invalid.");
return(BadRequest("Parameter value " +
parameterValueAddDto.Where(para => !ParameterValidator.IsValid(sim.Parameters.Single(p => p.Name == para.ParameterName).Type, para.Value)).First().Value +
" is invalid."));
}
var experimentInstance = new ExperimentInstance();
experimentInstance.ParameterValues = parameterValueAddDto.
Select(para => new ExperimentParameterAssignment
{
ParameterValue = new ParameterValue
{
Parameter = sim.Parameters.SingleOrDefault(p => p.Name == para.ParameterName),
Value = para.Value
},
ExperimentInstance = experimentInstance
}).ToList();
experimentInstance.ExperimentId = sim.Id;
experimentInstance.Experiment = sim;
/*
* The whole caching is kind of nasty.
* We might got sim from the cache, so make
* sure to not add it without tracking.
*/
if (sw != null)
{
TimeSpan ts = sw.Elapsed;
Console.WriteLine("Prepared data for storage after " + String.Format("{0:00}:{1:00}:{2:00}:{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds));
}
_context.Attach(sim);
_context.Add(experimentInstance);
_context.SaveChanges();
if (sw != null)
{
TimeSpan ts = sw.Elapsed;
Console.WriteLine("Stored data after " + String.Format("{0:00}:{1:00}:{2:00}:{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds));
}
//_scalingService.Scale(sim);
if (sw != null)
{
TimeSpan ts = sw.Elapsed;
Console.WriteLine("Finished scaling after " + String.Format("{0:00}:{1:00}:{2:00}:{3:00}",
ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds));
}
return(new ObjectResult(new
{
ExperimentInstanceId = experimentInstance.Id
}));
}
