public ExperimentBase ToExperiment()
{
Component environment = EnvironmentRegistry
.GetEnvironments()
.Single(t => t.FullName.Equals(this.EnvironmentTypeName))
.InstantiateWithDefaultConstructor <Component>();
Component presentationEnvironment = environment.Clone();
Component agent = AgentRegistry
.GetAgents(environment.ComponentType)
.Single(t => t.FullName.Equals(this.AgentTypeName))
.InstantiateWithDefaultConstructor <Component>();
ExperimentBase result = ExperimentBase.Instantiate(environment, presentationEnvironment, agent);
result.SetParametersFromSnapshot(this.ExperimentParameters);
environment.SetParametersFromSnapshotWithInnerObjects(this.EnvironmentParameters);
presentationEnvironment.SetParametersFromSnapshotWithInnerObjects(this.EnvironmentParameters);
agent.SetParametersFromSnapshotWithInnerObjects(this.AgentParameters);
result.Reporter = this.ReporterTemplate.ToReporter(
ReportTrigger.GetReportTriggers().ToArray(),
DataSource.GetDataSources(result).ToArray(),
DataAccumulator.GetDataAccumulators().ToArray());
return(result);
}
public ReportElement CloneFor(ExperimentBase experiment)
{
return(new ReportElement(this.DataProvider.CloneFor(experiment), this.DataAccumulator.Clone())
{
ColumnHeaderText = this.ColumnHeaderText
});
}
public override ReportWriter CloneFor(ExperimentBase experiment)
{
ReportFileWriter result = new ReportFileWriter(this.ReportTrigger.Clone(), this.FileName);
result.AddReportElements(this.ReportElements.Select(re => re.CloneFor(experiment)));
return(result);
}
public Reporter CloneFor(ExperimentBase experiment)
{
Reporter result = new Reporter();
result.ReportWriters.AddRange(this.ReportWriters.Select(rw => rw.CloneFor(experiment)));
return(result);
}
public static DataSource[] GetDataSources(ExperimentBase experiment)
{
return(new object[] { experiment, experiment.Agent, experiment.Environment, new ConstantValueDataSource() }
.Select(o => new DataSource()
{
Object = o, ReportingFields = GetReportingFields(o)
})
.Where(ds => ds.ReportingFields.Any())
.ToArray());
}
public static ExperimentTemplate Create(ExperimentBase experiment)
{
ExperimentTemplate result = new ExperimentTemplate()
{
ExperimentTypeName = experiment.GetType().FullName
};
result.ExperimentParameters = experiment.GetParametersSnapshot();
return(result
.WithAgent(experiment.Agent)
.WithEnvironment(experiment.Environment)
.WithReporter(experiment.Reporter));
}
public override void ExperimentStarted(ExperimentBase experiment)
{
string fileName = Path.GetFileNameWithoutExtension(this.FileName);
string extension = Path.GetExtension(this.FileName);
string directory = Path.GetDirectoryName(this.FileName);
if (this.BatchModeIndex.HasValue)
{
fileName += "-" + (this.BatchModeIndex.Value + 1);
}
this.streamWriter = new StreamWriter(Path.Combine(directory, fileName + extension));
base.ExperimentStarted(experiment);
}
public virtual void ExperimentStarted(ExperimentBase experiment)
{
ProcessReportElements(reportElement => reportElement.ExperimentStarted(experiment));
foreach (ReportElement reportElement in this.reportElements)
{
this.Write(reportElement.ColumnHeaderText);
if (reportElement != this.reportElements.Last())
{
this.Write(this.Separator);
}
}
this.WriteLine();
}
// TODO: deal with error states if conditions not met
public void LaunchExperiment()
{
// launch scene with exp,
// instantiate experiment,
// call start function
// Check if settings are loaded
if (experimentConfig != null)
{
Cursor.visible = false;
Application.runInBackground = true;
// Make the game run as fast as possible
QualitySettings.vSyncCount = (int)GetSetting("vSync");
Application.targetFrameRate = (int)GetSetting("frameRate");
// create path for current participant/session
fileManager.CreateSession();
Do(new EventBase <string>(SceneManager.LoadScene, (string)GetSetting("experimentScene")));
Do(new EventBase(() => {
// Start syncbox
syncBox.Do(new EventBase(syncBox.StartPulse));
if ((bool)GetSetting("elemem"))
{
hostPC = new ElememInterface(this);
}
LogExperimentInfo();
Type t = Type.GetType((string)GetSetting("experimentClass"));
exp = (ExperimentBase)Activator.CreateInstance(t, new object[] { this });
}));
}
else
{
throw new Exception("No experiment configuration loaded");
}
}
public ReportWriterConfigurationControl(
Type[] reportTriggers,
Type[] dataAccumulators,
ExperimentBase experiment,
bool editable)
{
InitializeComponent();
this.Editable = editable;
this.reportTriggers = reportTriggers;
this.experiment = experiment;
this.dataAccumulators = dataAccumulators;
this.inhibitParameterWindow = true;
this.inhibitValueChangedEvent = false;
this.inhibitUpdatePreview = false;
this.inhibitCheckBoxEvent = false;
this.dataSources = DataSource.GetDataSources(experiment);
this.reportTriggerComboBox.Items.AddRange(this.reportTriggers.Select(t => t.GetDisplayName()).ToArray());
this.reportTriggerComboBox.SelectedItem = typeof(EpisodeCountReportTrigger).GetDisplayName();
int rowIndex = this.reportGridView.Rows.Add();
this.dataProviderObjectRow = this.reportGridView.Rows[rowIndex];
rowIndex = this.reportGridView.Rows.Add();
this.dataProviderFieldRow = this.reportGridView.Rows[rowIndex];
rowIndex = this.reportGridView.Rows.Add();
this.dataAccumulatorRow = this.reportGridView.Rows[rowIndex];
this.reportGridView.ReadOnly = !this.Editable;
this.dataProviderObjectRow.HeaderCell.Value = "Object";
this.dataProviderFieldRow.HeaderCell.Value = "Field";
this.dataAccumulatorRow.HeaderCell.Value = "Data accumulator";
AddReportElement(this.dataSources.First(), "EpisodeCount", typeof(CurrentValueDataAccumulator));
AddReportElement(this.dataSources.First(), "CurrentReinforcement", typeof(AverageSinceTriggerDataAccumulator));
this.inhibitParameterWindow = false;
}
/// <summary>
/// Start a new experiment
/// </summary>
void Start()
{
if (IsRunning)
{
return;
}
//create experimental class
ExperimentBase exp = null;
if (ExperimentViewModel != null)
{
exp = ExperimentViewModel.CreateExperiment(ExperimentName, FishName);
}
else
{
System.Diagnostics.Debug.WriteLine("No experiment view model was active. Exiting.");
return;
}
if (exp == null)
{
MessageBox.Show("Could not create experiment. Check parameters.", "Failure to launch", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
exp.Comment = Comment;
exp.DOB = DOB;
exp.DishCenter = DishCenter;
exp.Radius = MaskRadius;
exp.WriteExperimentInformation();
//dispose previewthread
if (_acquisitionThread != null)
{
_acquisitionThread.Dispose();
}
//start experimental threads
FrameIndex = 0;
_acquisitionThread = new WorkerT <IExperiment>(TrackThreadRun, exp, true, 3000);
IsRunning = true;
}
public override bool StepDone(ExperimentBase experiment)
{
return(experiment.TotalStepCount % this.StepCountInterval == 0);
}
internal DatasetWriter(ExperimentBase experiment)
{
SourceDir = experiment.ExperimentUserPath;
}
public abstract ReportWriter CloneFor(ExperimentBase experiment);
public void EpisodeEnded(ExperimentBase experiment)
{
ProcessReportWriters(reportFile => reportFile.EpisodeEnded(experiment));
}
public override ReportWriter CloneFor(ExperimentBase experiment)
{
return(new ReportTextBoxWriter(this.ReportTrigger, this.textBox));
}
public void EpisodeEnded(ExperimentBase experiment)
{
this.DataAccumulator.EpisodeEnded(this.DataProvider);
}
public void ReportTriggered(ExperimentBase experiment)
{
this.DataAccumulator.ReportTriggered(this.DataProvider);
}
public void StepDone(ExperimentBase experiment)
{
ProcessReportElements(reportElement => reportElement.StepDone(experiment));
ProcessReportTrigger(reportTrigger => reportTrigger.StepDone(experiment), experiment);
}
public void EpisodeEnded(ExperimentBase experiment)
{
ProcessReportElements(reportElement => reportElement.EpisodeEnded(experiment));
ProcessReportTrigger(reportTrigger => reportTrigger.EpisodeEnded(experiment), experiment);
}
public ReportingConfigurationWindow(ExperimentBase experiment)
{
InitializeComponent();
this.reportingConfigurationControl1.Experiment = experiment;
}
public DataProvider CloneFor(ExperimentBase experiment)
{
return(DataSource
.FindDataSource(experiment, [email protected]().GetDisplayName())
.ToDataProvider(this.field.Name));
}
public static DataSource FindDataSource(ExperimentBase experiment, string dataSourceObjectTypeDisplayName)
{
return(DataSource.FindDataSource(GetDataSources(experiment), dataSourceObjectTypeDisplayName));
}
private void ProcessReportTrigger(Func <ReportTrigger, bool> reportTriggerAction, ExperimentBase experiment)
{
if (reportTriggerAction(this.ReportTrigger))
{
string line = string.Join(
this.Separator,
this.reportElements.Where(eo => eo != null).Select(reportElement => reportElement.GetReportToken()));
this.WriteLine(line);
ProcessReportElements(reportElement => reportElement.ReportTriggered(experiment));
}
}
public void ExperimentStarted(ExperimentBase experiment)
{
this.DataAccumulator.ExperimentStarted(this.DataProvider);
}
public override bool EpisodeEnded(ExperimentBase experiment)
{
return(experiment.EpisodeCount % this.EpisodeCountInterval == 0);
}
public void StepDone(ExperimentBase experiment)
{
this.DataAccumulator.StepDone(this.DataProvider);
}
public void ExperimentStarted(ExperimentBase experiment)
{
ProcessReportWriters(reportFile => reportFile.ExperimentStarted(experiment));
}
public void StepDone(ExperimentBase experiment)
{
ProcessReportWriters(reportFile => reportFile.StepDone(experiment));
}
public void EpisodeEnded(ExperimentBase experiment)
{
ProcessObservers(experimentObserver => experimentObserver.EpisodeEnded(experiment));
ProcessTraceLines(traceTrigger => traceTrigger.EpisodeEnded(experiment));
}
