private void BindExperimentalRun(ExperimentalRun experimentalRun)
{
var newThread = new Thread(CreateRunView);
newThread.SetApartmentState(ApartmentState.STA);
newThread.Start(experimentalRun);
}
private void CreateZoomTab(int cultureIndex, ExperimentalRun selectedExperimentalRun)
{
var displayItems = new List <int> {
cultureIndex
};
CreateTab(displayItems, selectedExperimentalRun);
}
private static bool GetExperimentalRun(string fileFullPath, out ExperimentalRun expRun)
{
try
{
expRun = BioScreenHelper.ImportBioscreenFile(fileFullPath);
}
catch (Exception ex)
{
MessageBox.Show("Could not import the file: " + fileFullPath + "\r\nReason: " + ex.Message, "Import Errror", MessageBoxButton.OK, MessageBoxImage.Error);
expRun = null;
return(true);
}
return(false);
}
private static string GetSampelsName(List <int> displayItems, ExperimentalRun selectedExperimentalRun)
{
var wells = new StringBuilder();
foreach (var displayItem in displayItems)
{
var culture = selectedExperimentalRun.Run[displayItem];
BuildWellString(culture, ref wells);
}
wells.Remove(wells.Length - 1, 1);
wells.Append(")");
string sampelsName = "(" + wells.ToString();
return(sampelsName);
}
private static ExperimentalRun CloneExperimentalRun(ExperimentalRun run)
{
var newExp = new ExperimentalRun(run.ImportFileName)
{
Name = run.Name,
CreationDate = run.CreationDate,
ExperimentType = run.ExperimentType,
FileType = run.FileType,
ReferenceCultureIndex = run.ReferenceCultureIndex,
ReplicateBehaviour = run.ReplicateBehaviour,
RunODRange = run.RunODRange,
RunTimeRange = run.RunTimeRange
};
foreach (var culture in run.Run)
{
newExp.Run.Add(culture);
}
return(newExp);
}
public static ImageSource CreateChartImage(ExperimentalRun experimentalRun, int cultureIndex, List <DataType> validTypes, int height, int width, int padding, bool logged)
{
GrowthGraph growthGraph;
var fd = false;
if (validTypes.Contains(DataType.FirstDerivative))
{
var culture = experimentalRun.Run.FirstOrDefault(exp => exp.ContainerIndex == cultureIndex);
var referenceCulture = experimentalRun.Run.FirstOrDefault(exp => exp.ContainerIndex == experimentalRun.ReferenceCultureIndex);
growthGraph = AsGrowthGraph(culture, referenceCulture, validTypes);
logged = false;
fd = true;
}
else
{
growthGraph = AsGrowthGraph(experimentalRun, cultureIndex, validTypes);
}
return(CreateChartImage(growthGraph, height, width, padding, logged, fd));
}
public static GrowthGraph AsGrowthGraph(ExperimentalRun experimentalRun, int cultureIndex, List <DataType> validTypes)
{
Culture culture = experimentalRun.Run.Where(exp => exp.ContainerIndex == cultureIndex).FirstOrDefault();
Culture referenceCulture = null;
if (experimentalRun.ReferenceCultureIndex != -1)
{
referenceCulture = experimentalRun.Run.Where(exp => exp.ContainerIndex == experimentalRun.ReferenceCultureIndex).FirstOrDefault();
}
if (culture != null)
{
var graph = new GrowthGraph(culture.Container);
if (culture.GetType() == typeof(MergedCulture))
{
CreateSeriesFromMergedCulture(((MergedCulture)culture), validTypes, ref graph);
if (referenceCulture != null)
{
CreateSeriesFromMergedCulture(((MergedCulture)culture), validTypes, ref graph);
}
}
else if (culture.GetType() == typeof(Culture))
{
string serieName = GetSeriesName(culture.IsFaulty, culture.Container);
CreateSeriesFromCulture(culture.GrowthMeasurements, serieName, validTypes, ref graph);
if (referenceCulture != null)
{
CreateSeriesFromCulture(referenceCulture.GrowthMeasurements, serieName, validTypes, ref graph);
}
}
graph.ODRange = new DoubleRange(experimentalRun.RunODRange.Min, experimentalRun.RunODRange.Max);
graph.TimeRange = new DoubleRange(experimentalRun.RunTimeRange.Min, experimentalRun.RunTimeRange.Max);
return(graph);
}
return(null);
}
public void AddJobs(ExperimentalRun run, RunMode? forcemode=null)
{
QJobs.Enqueue(run.ToDAQThread(forcemode));
PropertyChanged(this, new PropertyChangedEventArgs("JobLeft"));
}
private void CreateTab(List <int> displayItems, ExperimentalRun selectedExperimentalRun)
{
var itemsTab = (TabControl)FindName("ViewTab");
ResetHaveFocusOnAllTabs(itemsTab);
var cultureIndex = displayItems.First();
string container = displayItems.Count == 1 ? selectedExperimentalRun.Run[cultureIndex].Container : GetSampelsName(displayItems, selectedExperimentalRun);
var runName = selectedExperimentalRun.ImportFileName;
var newTab = new TabItem {
Header = container + " @ " + runName
};
newTab.MouseUp += new MouseButtonEventHandler(TabItem_Click);
var neuralParameters = new Macro.NeuralParameters
{
Iterations = ProcessDataControl.iterations,
LearningRate = ProcessDataControl.learningRate,
NeuronsInFirstLayer = ProcessDataControl.neuronsInFirstLayer,
SigmoidAlphaValue = ProcessDataControl.sigmoidAlphaValue
};
var graph = new zoomGraph
{
ExperimentalRun = selectedExperimentalRun,
NeuralParameters = neuralParameters
};
var zgcv = new ZoomGraphControlValues
{
DisplayRaw = false,
DisplayFD = false,
DisplayMetaLagData = false,
DisplayMetaRateData = false,
DisplayMetaYieldData = false,
LogYAxis = true,
ChartBehaviour = ChartBehaviour.Zoom,
FitData = false,
EnableFit = false,
SkipPointsNumber = 0
};
ZoomGraphControlsControl.ControlValues = zgcv;
graph.ZoomGraphControlValues = zgcv;
SetZoomGraphBindings(graph);
graph.DisplayFirstDervivative = false;
graph.HasFocus = true;
graph.DisplayItems = displayItems;
graph.SeriesCreated += new RoutedEventHandler(GraphSeries_Created);
graph.NameChanged += new RoutedEventHandler(NameChanged_Executed);
var grid = new Grid();
grid.RowDefinitions.Add(new RowDefinition {
Height = GridLength.Auto
});
grid.RowDefinitions.Add(new RowDefinition());
Grid.SetRow(graph, 1);
grid.Children.Add(graph);
newTab.Content = grid;
if (itemsTab != null)
{
itemsTab.Items.Add(newTab);
itemsTab.SelectedItem = newTab;
}
ActionsExpander.IsExpanded = true;
GraphControlsExpander.IsExpanded = true;
}
private void CreateZoomTab(List <int> displayItems, ExperimentalRun selectedExperimentalRun)
{
CreateTab(displayItems, selectedExperimentalRun);
}
private void ExperimentalRunList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
_selectedRun = (ExperimentalRun)ExperimentalRunList.SelectedItem;
ckDisplayRaw.IsChecked = true;
ProccessReplicates();
}
public void StartTestRun()
{
if (CurrentSetting != null)
{
ExperimentalRun run = new ExperimentalRun(mca, motor, thermometer, RunMode.Calibrate);
//use our thing as data collector
run.Log.Setting = CurrentSetting;
run.Log.MCAData = this.MCAData;
run.Log.MotorPosition = TargetPosition;
run.Timeout = Timeout;
run.MaxSample = MaxSample;
App.ExperimentServer.AddJobs(run);
}
else
{
MessageBox.Show("Setting Not Selected.", "Setting Not Selected", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void StartSimulationRun()
{
ExperimentalRun run = new ExperimentalRun(mca, motor, thermometer, RunMode.Simulated);
run.Log.MCAData = this.MCAData;
App.ExperimentServer.AddJobs(run);
}
public static ExperimentalRun ImportBioscreenFile(string fileFullPath)
{
var reader = ReadAsLines(fileFullPath);
var experimenRun = new ExperimentalRun(Path.GetFileName(fileFullPath));
if (reader == null)
{
throw new Exception("No Data");
}
var fileType = GetFileType(reader, fileFullPath);
experimenRun.FileType = fileType;
if (fileType == BioscreenFileType.Other)
{
throw new Exception("Invalid file extension");
}
experimenRun.Name = GetRunName(reader, fileType);
experimenRun.CreationDate = File.GetCreationTime(fileFullPath);
var headers = GetHeaders(reader, fileType);
var records = GetRecords(reader, fileType);
var wells = GetWellQueue(headers, fileType);
int counter = 0;
foreach (var record in records)
{
counter += 1;
if (string.IsNullOrEmpty(record.Trim()))
{
continue;
}
var rowWellMeasurement = GetRowWellMeasurements(record, fileType);
int time = GetTimeInSeconds(rowWellMeasurement[0], fileType);
var rowToSkip = GetRowsToSkip(fileType);
foreach (string item in rowWellMeasurement.Skip(rowToSkip))
{
var well = wells.Dequeue();
if (item == string.Empty)
{
wells.Enqueue(well);
continue;
}
float od = GetOD(item);
if (od == 0)
{
wells.Enqueue(well);
continue;
}
if (experimenRun.Run.ElementAtOrDefault(well.Index - 1) != null)
{
var measurement = new GrowthMeasurement {
OD = od, Time = time
};
experimenRun.Run[well.Index - 1].GrowthMeasurements.GetMeasurements(DataType.Raw).Add(measurement);
}
else
{
var measurements = new List <GrowthMeasurement>();
var measurement = new GrowthMeasurement {
OD = od, Time = time
};
measurements.Add(measurement);
experimenRun.Run.Add(new Culture(well.Index, well.Name, measurements));
}
wells.Enqueue(well);
}
}
return(experimenRun);
}
public void FillExperimentalRuns(FillExperimentArgument arg = null)
{
if (arg == null) arg = new FillExperimentArgument();
double[] positions = NP.Linspace(arg.StartPosition, arg.EndPosition, arg.NumPosition);
foreach (double position in positions)
{
ExperimentalRun run = new ExperimentalRun(MCA, LinearMotor, Thermometer, RunMode.Experiment);
run.Log.Setting = arg.Setting;
run.Log.MotorPosition = position;
run.MaxSample = arg.MaxSample;
run.Timeout = arg.Timeout;
//Debug.WriteLine(arg.Setting.Name);
ExperimentalRuns.Add(run);
}
}
