public FullFactorialDOEStudy(string name, string description, WorkflowComponent workflow, List <Data> factors, List <decimal> startingValues, List <decimal> stepSizes, List <int> noOfLevels, List <Data> responses)
: base(name, description, workflow, factors, responses)
{
base.StudiedComponent = workflow;
this.startingValues = startingValues;
this.stepSizes = stepSizes;
this.noOfLevels = noOfLevels;
ColumnNames.Add("ID");
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
ColumnUnits.Add("");
for (int i = 0; i < factors.Count; i++)
{
string columnHeader = factors[i].Name;
ColumnNames.Add(columnHeader);
if (factors[i] is IntegerData)
{
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
ColumnUnits.Add(((IntegerData)factors[i]).Unit);
}
else if (factors[i] is DoubleData)
{
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(((DoubleData)factors[i]).DecimalPlaces);
ColumnUnits.Add(((DoubleData)factors[i]).Unit);
}
}
for (int i = 0; i < responses.Count; i++)
{
string columnHeader = responses[i].Name;
ColumnNames.Add(columnHeader);
if (responses[i] is IntegerData)
{
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
ColumnUnits.Add(((IntegerData)responses[i]).Unit);
}
else if (responses[i] is DoubleData)
{
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(((DoubleData)responses[i]).DecimalPlaces);
ColumnUnits.Add(((DoubleData)responses[i]).Unit);
}
}
TableNames.Add(Name);
Treatment = new FullFactorial("testFF", "", Project.ProjectPath + "\\DOE.sdf", workflow as Workflow, factors, startingValues, stepSizes, noOfLevels, responses);
Treatment.CreateFolder();
}
private void FindNumericOrSymbolic()
{
var testData = TestData.AsEnumerable();
foreach (DataColumn column in TestData.Columns)
{
bool isNumeric = true;
var temp = testData.Select(t => t.Field <string>(column)).ToList();
if (column.ColumnName != "ID")
{
foreach (var item in temp)
{
if (!float.TryParse(item, out float result))
{
isNumeric = false;
ColumnTypes.Add(column.ColumnName, ColumnType.SYMBOLIC);
break;
}
}
if (isNumeric)
{
ColumnTypes.Add(column.ColumnName, ColumnType.NUMERIC);
}
}
}
}
private void FindNumericOrSymbolic(DataTable dataSet)
{
var testData = dataSet.AsEnumerable();
foreach (DataColumn column in dataSet.Columns)
{
bool isNumeric = true;
var temp = testData.Select(t => t.Field <string>(column)).ToList();
if (column.Ordinal == dataSet.Columns.Count - 2)
{
continue;
}
if (column.ColumnName != "ID")
{
foreach (var item in temp)
{
if (item == "?" || item == "*")
{
continue;
}
if (!float.TryParse(item, out float result))
{
isNumeric = false;
ColumnTypes.Add(column.ColumnName, ColumnType.SYMBOLIC);
break;
}
}
if (isNumeric)
{
ColumnTypes.Add(column.ColumnName, ColumnType.NUMERIC);
}
}
}
}
public PrintGridItem(ExDataGridView dgv, bool isFit, PrintPageEventArgs e)
{
_grid = dgv;
_newPage = true;
_fitToPageWidth = true;
_pageNo = 1;
_headerTitle = String.Empty;
_headerPrinter = String.Empty;
_rowPos = 0;
_rowsPerPage = 0;
_totalWidth = 0;
int CellWidth = 0;
int PageLeft = e.MarginBounds.Left;
foreach (DataGridViewColumn GridCol in dgv.Columns)
{
if (!GridCol.Visible)
{
continue;
}
_totalWidth += GridCol.Width;
}
foreach (DataGridViewColumn GridCol in dgv.Columns)
{
if (!GridCol.Visible)
{
continue;
}
if (isFit)
{
CellWidth = (int)(Math.Floor((double)((double)GridCol.Width / (double)TotalWidth * (double)TotalWidth * ((double)e.MarginBounds.Width / (double)TotalWidth))));
}
else
{
CellWidth = GridCol.Width;
}
HeaderHeight = (int)(e.Graphics.MeasureString(GridCol.HeaderText, GridCol.InheritedStyle.Font, CellWidth).Height) + 11;
ColumnLefts.Add(PageLeft);
ColumnWidths.Add(CellWidth);
ColumnTypes.Add(GridCol.GetType());
PageLeft += CellWidth;
}
}
private Dictionary <string, ShineTable> ParseShineTable(string file)
{
if (!File.Exists(file))
{
throw new Exception("FFFFFFFFF");
}
Dictionary <string, ShineTable> ret = new Dictionary <string, ShineTable>();
using (var files = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var sr = new StreamReader(files, Encoding.Default))
{
bool definingStruct = false, definingTable = false;
int lineNR = 0;
ShineTable curTable = null;
List <string> ColumnTypes = null;
string comment = "";
char? ignore = null;
KeyValuePair <string, string>?replaceThis = null;
while (!sr.EndOfStream)
{
lineNR++;
string line = sr.ReadLine().TrimStart();
if (line.Contains(Comment))
{
// Remove everything after it.
int index = line.IndexOf(Comment);
comment = line.Substring(index + 1);
//Console.WriteLine("Comment @ {0}: {1}", lineNR, comment);
line = line.Remove(index);
}
if (ignore.HasValue)
{
line = line.Replace(ignore.Value.ToString(), "");
}
if (line == string.Empty)
{
continue;
}
string lineLower = line.ToLower();
string[] lineSplit = line.Split('\t');
if (lineLower.StartsWith(Replace))
{
// ...
replaceThis = new KeyValuePair <string, string>(ConvertShitToString(lineSplit[1]), ConvertShitToString(lineSplit[2])); // take risks :D
//continue;
}
if (lineLower.StartsWith(Ignore))
{
ignore = ConvertShitToString(lineSplit[1])[0];
//continue;
}
if (lineLower.StartsWith(StartDefine))
{
if (definingStruct || definingTable)
{
throw new Exception("Already defining.");
}
// Get the name..
string name = line.Substring(StartDefine.Length + 1);
curTable = new ShineTable(name);
definingStruct = true;
continue;
}
else if (lineLower.StartsWith(Table))
{
if (definingStruct)
{
throw new Exception("Already defining.");
}
// Get the name..
string name = lineSplit[1].Trim(); // I hope this works D;
curTable = new ShineTable(name);
ColumnTypes = new List <string>();
ret.Add(name, curTable);
definingTable = true;
continue;
}
if (lineLower.StartsWith(EndDefine))
{
if (!definingStruct)
{
throw new Exception("Not started defining.");
}
definingStruct = false;
ret.Add(curTable.TableName, curTable);
continue;
}
line = line.Trim();
lineLower = lineLower.Trim();
if (definingStruct)
{
string columnName = comment.Trim();
if (columnName == string.Empty)
{
continue;
}
curTable.AddColumn(columnName, lineLower);
Console.WriteLine("Added column {0} to table {1}", columnName, curTable.TableName);
}
else if (definingTable)
{
// Lets search for columns..
if (lineLower.StartsWith(ColumnType))
{
for (int i = 1; i < lineSplit.Length; i++)
{
string l = lineSplit[i].Trim();
if (l == string.Empty)
{
continue;
}
ColumnTypes.Add(l);
}
}
else if (lineLower.StartsWith(ColumnName))
{
int j = 0;
for (int i = 1; i < lineSplit.Length; i++)
{
string l = lineSplit[i].Trim();
if (l == string.Empty)
{
continue;
}
var coltype = ColumnTypes[j++];
//curTable.AddColumn(l + "(" + coltype + ")", coltype);
curTable.AddColumn(l, coltype);
}
}
else if (lineLower.StartsWith(RecordLine))
{
// Next column is tablename
string tablename = lineSplit[1].Trim();
if (ret.ContainsKey(tablename))
{
curTable = ret[tablename];
// Lets start.
object[] data = new object[curTable.Columns.Count];
int j = 0;
for (int i = 2; i < lineSplit.Length; i++)
{
string l = lineSplit[i].Trim();
if (l == string.Empty)
{
continue;
}
data[j++] = Check(replaceThis, l.TrimEnd(','));
}
curTable.AddRow(data);
}
}
else if (lineLower.StartsWith(Record))
{
// Right under the table
object[] data = new object[curTable.Columns.Count];
int j = 0;
for (int i = 1; i < lineSplit.Length; i++)
{
string l = lineSplit[i].Trim();
if (l == string.Empty)
{
continue;
}
data[j++] = Check(replaceThis, l.TrimEnd(','));
}
curTable.AddRow(data);
}
}
else
{
if (ret.ContainsKey(lineSplit[0].Trim()))
{
// Should be a struct I guess D:
var table = ret[lineSplit[0].Trim()];
int columnsInStruct = table.Columns.Count;
int readColumns = 0;
object[] data = new object[columnsInStruct];
for (int i = 1; ; i++)
{
if (readColumns == columnsInStruct)
{
break;
}
else if (lineSplit.Length < i)
{
throw new Exception(string.Format("Could not read all columns of line {0}", lineNR));
}
// Cannot count on the tabs ...
string columnText = lineSplit[i].Trim();
if (columnText == string.Empty)
{
continue;
}
// Well, lets see if we can put it into the list
columnText = columnText.TrimEnd(',').Trim('"');
data[readColumns++] = columnText;
}
table.AddRow(data);
}
}
}
}
}
return(ret);
}
public RobustOptimisationStudy(string name, Treatment treatment, ExecutableComponent ec, OptimisationTemplate template, string parentName = "")
: base(name, null, null, name, parentName)
{
Treatment = treatment;
StudiedComponent = ec;
var DesignVariables = template.DesignVariables.Select(v => new RobOptDesignVariable {
Name = v.Name
}).ToList();
var Objectives = template.Objectives.Select(o => new RobOptObjective {
Name = o.Name, Type = o.Type
}).ToList();
var Constraints = template.Constraints.Select(c => new RobOptConstraint {
Name = c.Name, Type = c.Type, Value = c.Value
}).ToList();
robOptTemplate = new RobOptTemplate()
{
DesignVariables = DesignVariables, Objectives = Objectives, Constraints = Constraints
};
ColumnNames.Add("ID");
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
ColumnUnits.Add("");
for (int i = 0; i < robOptTemplate.DesignVariables.Count(); i++)
{
string columnHeader = robOptTemplate.DesignVariables[i].Name;
ColumnNames.Add(columnHeader);
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
}
for (int i = 0; i < robOptTemplate.Objectives.Count(); i++)
{
string columnHeader = robOptTemplate.Objectives[i].Name;
// Loss Function
ColumnNames.Add(columnHeader + "LF");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Mean
ColumnNames.Add(columnHeader + "mean");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Variance
ColumnNames.Add(columnHeader + "var");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
}
for (int i = 0; i < robOptTemplate.Constraints.Count(); i++)
{
string columnHeader = robOptTemplate.Constraints[i].Name;
// Loss Function
ColumnNames.Add(columnHeader + "LF");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Mean
ColumnNames.Add(columnHeader + "mean");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Variance
ColumnNames.Add(columnHeader + "var");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
}
TableNames.Add("RobOptimAllResults");
TableNames.Add("RobOptimGenResults");
Template = template;
}
} //NormalizeCsv()
#endregion PUBLIC METHODS
#region PRIVATE METHODS
private bool ReadCsv(TextReader reader, TextWriter errorStream)
{
Records = new List<string[]>();
using (CsvParser csvParser = new CsvParser(reader))
{
csvParser.Configuration.Delimiter = Delimiter;
Headers = csvParser.Read();
if (Headers == null)
{
errorStream.WriteLine("Error: No input to process.");
return false;
}
// Read current line fields, pointer moves to the next line.
string[] record;
//Read until the parser returns null (EOF)
// Note: CsvParser converts the input using .toString(), which implements the
// built-in type converter based on the specified character encoding of inStream
// (This will correct any invalid characters, then load into a UTF-16 string)
while ((record = csvParser.Read()) != null)
{
string[] parsedRecord = new string[record.Length];
//Before parsing fields, be sure we know (or have tried to guess) the type of each field
//This will normally run at most once, on line #2 (first line of data), unless later records have more columns
if (ColumnTypes.Count < Headers.Length)
{
errorStream.WriteLine("Warning: Some or all column data types were not specified");
for (int i = ColumnTypes.Count; i < Headers.Length; i++)
{
ColumnTypes.Add(GuessDataType(record[i], Headers[i]));
}
}
try
{
for (int i = 0; i < record.Length; i++)
{
switch (ColumnTypes[i])
{
case DataType.Timestamp:
parsedRecord[i] = ProcessTimestamp(record[i]);
break;
case DataType.ZipCode:
parsedRecord[i] = ProcessZipCode(record[i]);
break;
case DataType.FullName:
parsedRecord[i] = ProcessFullName(record[i]);
break;
case DataType.Duration:
parsedRecord[i] = ProcessDuration(record[i]);
break;
case DataType.TotalDuration:
//Build a list of all fields of DataType 'Duration' preceding this one
List<string> durations = new List<string>();
for (int j = 0; j < i; j++)
{
if (ColumnTypes[j] == DataType.Duration)
{
durations.Add(parsedRecord[j]);
}
}
parsedRecord[i] = ProcessTotalDuration(durations);
break;
case DataType.UnmodifiedString:
//Validation already done, no conversion necessary
parsedRecord[i] = record[i];
break;
default:
//In theory, this line will only be called if a new datatype is added to the enum and
// passed to the function, but not handled in the Switch statement
throw (new MissingMethodException("DataType not handled"));
//break; //Commenting out to eliminate VSCode warning, leaving in to show it was not forgotten
} //switch
} //for
//Now that all fields are validated, add them to the list
Records.Add(parsedRecord);
} //try
catch (Exception e)
{
//Output error, including original data and Exception message
errorStream.WriteLine("Record discarded due to Critical Error: <" +
string.Join(",", record) + "> (Error message: " +
e.Message + ")");
//If exception is thrown because a DataType is not handled, every line will
// fail. No need to spit out the same error over and over.
if (e is MissingMethodException)
{
throw;
}
} //catch
} //while
} //using
return true;
} //ReadCsv()
public DetOptStudy(string name, string description, string parentName = "")
: base(name, null, null, description, parentName)
{
// Create SQL statements to create tables, sqlStatement1 for OptimAllResults and sqlStatement2 for OptimGenResults
sqlStatement1 = "create table OptimAllResults (";
sqlStatement2 = "create table OptimGenResults (";
sqlStatement1 += "ID int, ";
sqlStatement2 += "ID int, Category int, ";
#region Atif
// Prepare results database
foreach (var designVariable in OptimisationTemplate.DesignVariables)
{
string columnHeader = designVariable.Name;
ColumnNames.Add(columnHeader);
sqlStatement1 += columnHeader + " ";
sqlStatement2 += columnHeader + " ";
if (designVariable.Data is IntegerData)
{
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
sqlStatement1 += "int, ";
sqlStatement2 += "int, ";
}
else if (designVariable.Data is DoubleData)
{
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(((DoubleData)(designVariable.Data)).DecimalPlaces);
sqlStatement1 += "float, ";
sqlStatement2 += "float, ";
}
ColumnUnits.Add(designVariable.Data.Unit);
MinValues.Add(designVariable.LowerBound);
MaxValues.Add(designVariable.UpperBound);
}
foreach (Objective objective in OptimisationTemplate.Objectives)
{
string columnHeader = objective.Name;
ColumnNames.Add(columnHeader);
sqlStatement1 += columnHeader + " ";
sqlStatement2 += columnHeader + " ";
if (objective.Data is IntegerData)
{
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
sqlStatement1 += "int, ";
sqlStatement2 += "int, ";
}
else if (objective.Data is DoubleData)
{
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(((DoubleData)(objective.Data)).DecimalPlaces);
sqlStatement1 += "float, ";
sqlStatement2 += "float, ";
}
ColumnUnits.Add(objective.Data.Unit);
MinValues.Add(Double.NaN);
MaxValues.Add(Double.NaN);
}
foreach (Aircadia.ObjectModel.Treatments.Optimisers.Formulation.Constraint constraint in OptimisationTemplate.Constraints)
{
string columnHeader = constraint.Name;
ColumnNames.Add(columnHeader);
sqlStatement1 += columnHeader + " ";
sqlStatement2 += columnHeader + " ";
if (constraint.Data is IntegerData)
{
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
sqlStatement1 += "int, ";
sqlStatement2 += "int, ";
}
else if (constraint.Data is DoubleData)
{
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(((DoubleData)(constraint.Data)).DecimalPlaces);
sqlStatement1 += "float, ";
sqlStatement2 += "float, ";
}
ColumnUnits.Add(constraint.Data.Unit);
MinValues.Add(Double.NaN);
MaxValues.Add(Double.NaN);
}
TableNames.Add("OptimAllResults");
TableNames.Add("OptimGenResults");
if (OptimisationTemplate.DesignVariables.Count() + OptimisationTemplate.Objectives.Count() + OptimisationTemplate.Constraints.Count() > 0)
{
sqlStatement1 = sqlStatement1.Remove(sqlStatement1.Length - 2);
sqlStatement2 = sqlStatement2.Remove(sqlStatement2.Length - 2);
}
sqlStatement1 += ")";
sqlStatement2 += ")";
#endregion Atif
}
//public DOEplusURQStudy(string name, string description, Model worflow, List<Data> factors, List<Data> responses)
public DOEplusURQStudy(string name, string description, List <string> names, Treatment treatment, FullFactorial fullFactorialDOE, WorkflowComponent worflow)
: base(name, description)
{
TreatmentURQ = treatment;
this.names = names; //DOE factors
Treatment = treatment;
StudiedComponent = worflow;
FullFactorialDOE = fullFactorialDOE;
var DesignVariables = new List <RobOptDesignVariable>();
for (int i = 0; i < ((string[, ])(Treatment.input_options.setuplist[0])).GetLength(0); i++)
{
var designVariable = new RobOptDesignVariable
{
Name = ((string[, ])(Treatment.input_options.setuplist[0]))[i, 0]
};
//designVariable.LowerBound = ;
//designVariable.UpperBound = ;
DesignVariables.Add(designVariable);
}
var Objectives = new List <RobOptObjective>();
for (int i = 0; i < ((string[, ])(Treatment.input_options.setuplist[1])).GetLength(0); i++)
{
var objective = new RobOptObjective
{
Name = ((string[, ])(Treatment.input_options.setuplist[1]))[i, 0]
};
if (((string[, ])(Treatment.input_options.setuplist[1]))[i, 2] == "minimise")
{
objective.Type = ObjectiveType.Minimise;
}
else if (((string[, ])(Treatment.input_options.setuplist[1]))[i, 2] == "maximise")
{
objective.Type = ObjectiveType.Maximise;
}
Objectives.Add(objective);
}
var Constraints = new List <RobOptConstraint>();
for (int i = 0; i < ((string[, ])(Treatment.input_options.setuplist[2])).GetLength(0); i++)
{
var constraint = new RobOptConstraint
{
Name = ((string[, ])(Treatment.input_options.setuplist[2]))[i, 0]
};
if (((string[, ])(Treatment.input_options.setuplist[2]))[i, 2] == "<=")
{
constraint.Type = ConstraintType.LessThanOrEqual;
}
else if (((string[, ])(Treatment.input_options.setuplist[2]))[i, 2] == ">=")
{
constraint.Type = ConstraintType.GreatorThanOrEqual;
}
constraint.Value = Convert.ToDouble(((string[, ])(Treatment.input_options.setuplist[2]))[i, 3]);
Constraints.Add(constraint);
}
robOptTemplate = new RobOptTemplate()
{
DesignVariables = DesignVariables, Objectives = Objectives, Constraints = Constraints
};
ColumnNames.Add("ID");
ColumnTypes.Add(DataTypes.INTEGER);
ColumnFormats.Add(0);
ColumnUnits.Add("");
for (int i = 0; i < this.names.Count; i++)
{
string columnHeader = this.names[i];
ColumnNames.Add(columnHeader);
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
}
for (int i = 0; i < robOptTemplate.DesignVariables.Count(); i++)
{
if (!this.names.Contains(robOptTemplate.DesignVariables[i].Name))
{
string columnHeader = robOptTemplate.DesignVariables[i].Name;
ColumnNames.Add(columnHeader);
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
}
}
for (int i = 0; i < robOptTemplate.Objectives.Count(); i++)
{
string columnHeader = robOptTemplate.Objectives[i].Name;
// Loss Function
ColumnNames.Add(columnHeader + "LF");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Mean
ColumnNames.Add(columnHeader + "mean");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Variance
ColumnNames.Add(columnHeader + "var");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
}
for (int i = 0; i < robOptTemplate.Constraints.Count(); i++)
{
string columnHeader = robOptTemplate.Constraints[i].Name;
// Loss Function
ColumnNames.Add(columnHeader + "LF");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Mean
ColumnNames.Add(columnHeader + "mean");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
// Variance
ColumnNames.Add(columnHeader + "var");
ColumnTypes.Add(DataTypes.DOUBLE);
ColumnFormats.Add(4);
ColumnUnits.Add("");
}
TableNames.Add("DOE");
}
