public WorkflowGlobal(string name, string description, List <Data> modelDataInputs, List <Data> modelDataOutputs, List <WorkflowComponent> components,
List <WorkflowComponent> scheduledComponents, List <ISolver> solvers, bool isAuxiliary = true, string scheduleMode = "", string parentName = "")
: base(name, description, modelDataInputs, modelDataOutputs, components, scheduledComponents, isAuxiliary, scheduleMode, parentName)
{
List <Data> allData = ScheduledComponents.GetAllData();
ScheduledComponents.GetInputsOutputsStatus(allData, out List <Data> defaultInputs, out List <Data> defaultOutputs);
var outputsHash = new HashSet <string>(ModelDataOutputs.Select(d => d.Id));
foreach (Data dt in defaultInputs)
{
if (outputsHash.Contains(dt.Id))
{
ReversedInputs.Add(dt);
}
}
var inputsHash = new HashSet <string>(ModelDataInputs.Select(d => d.Id));
foreach (Data dt in defaultOutputs)
{
if (inputsHash.Contains(dt.Id))
{
ReversedOutputs.Add(dt);
}
}
Solvers = solvers;
}
public WorkflowReversedModel(string name, string description, List <Data> modelDataInputs, List <Data> modelDataOutputs, Model model, List <ISolver> solvers, string parentName = "")
: base(name, description, modelDataInputs, modelDataOutputs, new List <WorkflowComponent>() { model }, new List <WorkflowComponent>() { model }, true, parentName)
{
//this.Model = model;
var outputsHash = new HashSet <string>(ModelDataOutputs.Select(d => d.Id));
foreach (Data dt in model.ModelDataInputs)
{
if (outputsHash.Contains(dt.Id))
{
ReversedInputs.Add(dt);
}
}
var inputsHash = new HashSet <string>(ModelDataInputs.Select(d => d.Id));
foreach (Data dt in model.ModelDataOutputs)
{
if (inputsHash.Contains(dt.Id))
{
ReversedOutputs.Add(dt);
}
}
Solvers = solvers;
}
public string GetReversedName(List <Data> inputs, List <Data> outputs)
{
var reversedIN = inputs.GetNames().Except(ModelDataInputs.GetNames());
var reversedOUT = outputs.GetNames().Except(ModelDataOutputs.GetNames());
var reversed = new HashSet <string>(reversedIN.Union(reversedOUT));
string reversalID = ModelDataInputs.Aggregate(String.Empty, (t, d) => t += reversed.Contains(d.Name) ? '1' : '0', t => t += ':');
reversalID = ModelDataOutputs.Aggregate(reversalID, (t, d) => t += reversed.Contains(d.Name) ? '1' : '0');
return($"{Id}:Reversed:{reversalID}");
}
public override bool Execute()
{
var inputs = ModelDataInputs.ToDictionary(d => d.Name, d => d.Value);
IDictionary <string, object> outputs = model.Run(inputs);
for (int i = 0; i < ModelDataOutputs.Count; i++)
{
ModelDataOutputs[i].Value = outputs[ModelDataOutputs[i].Name];
}
return(true);
}
public override void RenameVariable(string oldName, string newName)
{
if (ModelDataInputs.Concat(ModelDataOutputs).FirstOrDefault(d => d.Name == newName) == null)
{
return;
}
var separators = new HashSet <char>(new char[] { '[', ']', '{', '}', ';', '.', ',', '(', ')', '"', '\'', '+', '-', '*', '/', '%', ' ', '\t', '\n' });
FunctionBody = Replace(FunctionBody);
Code = Signature + "\n{\n" + FunctionBody + "\n}";
Compiled = false;
string Replace(string text)
{
int index = -1;
do
{
index = text.IndexOf(oldName, index + 1);
if (index == -1)
{
continue;
}
if (index > 0 && !separators.Contains(text[index - 1]))
{
continue;
}
if (index < text.Length - 1 - oldName.Length && !separators.Contains(text[index + oldName.Length]))
{
continue;
}
text = text.Substring(0, index) + newName + text.Substring(index + oldName.Length);
} while (index != -1);
return(text);
}
}
public virtual Workflow Copy(string id, string name = null, string parentName = null)
{
return(new Workflow(id, Description, ModelDataInputs.ToList(), ModelDataOutputs.ToList(),
Components.ToList(), ScheduledComponents.ToList(), IsAuxiliary, ScheduleMode, parentName ?? parentName));
}
/// <summary>
/// Executes the cSubprocessUNCER object
/// </summary>
/// <returns></returns>
public override bool Execute()
{
var input_uncer_testpoints = new Dictionary <string, double[]>();
#region setting inputs to URQ
int NInput = ModelDataInputs.Count / 4;
string[,] RobVars = new string[NInput, 5];
int counter = 0;
var innerInputs = InnerWorkflow.ModelDataInputs.ToDictionary(d => d.Name);
var outerInputs = ModelDataInputs.ToDictionary(d => d.Name);
foreach (string name in mappings.Keys)
{
string[] mapped = mappings[name];
if (mapped.Length != 4)
{
continue;
}
innerInputs[name].ValueAsDouble = outerInputs[mapped[0]].ValueAsDouble;
RobVars[counter, 0] = name;
RobVars[counter, 1] = outerInputs[mapped[1]].ValueAsString;
RobVars[counter, 2] = outerInputs[mapped[2]].ValueAsString;
RobVars[counter, 3] = outerInputs[mapped[3]].ValueAsString;
RobVars[counter, 4] = 0.ToString();
counter++;
}
var input_options = new ArrayList {
RobVars
};
//cTreatment_InOut input_options_treat = new cTreatment_InOut(input_options);
var input_options_treat = new Treatment_InOut_OP_Input(input_options);
#endregion
string[,] temp_targs = new string[targetOutputs.Count, 7]; // get number of targets (i.e. from set the 'targetOutputs' in constructor)
counter = 0;
foreach (string outVar in targetOutputs)
{
temp_targs[counter, 0] = outVar;
temp_targs[counter, 1] = "1";
temp_targs[counter, 2] = "minimise";
temp_targs[counter, 3] = "";
temp_targs[counter, 4] = "";
temp_targs[counter, 5] = "Quantile";
temp_targs[counter, 6] = "+";
counter++;
}
string[,] temp_constraints = new string[0, 0];
string[,] temp_constants = new string[0, 0];
input_options.Add(temp_targs);
input_options.Add(temp_constraints);
input_options.Add(temp_constants);
input_options.Add("RobustAnalysis");
throw new Exception("This Workflow is deprecated");
//var output_to_set_treat = new Treatment_InOut_OP_Output("Study not executed yet.");
////cTreatment_ROP URQ = new cTreatment_ROP("UncerPropInnerWF", input_options_treat, output_to_set_treat);
//input_options_treat = new Treatment_InOut_OP_Input(input_options);
//var URQ = new Treatment_ROP("UncerPropInnerWF", input_options_treat, output_to_set_treat) { databaseFileName = "URQ" };
//URQ.ApplyOn(InnerWorkflow);
//string[,] temp_store_outputs = URQ.RobustData;
//var MeanAndSD = new List<string>();
//counter = 0;
//int NOut = temp_store_outputs.GetLength(1);
//for (int i = 0; i < NOut; i++)
//{
// switch (counter)
// {
// case 0:
// counter++;
// break;
// case 1:
// counter++;
// MeanAndSD.Add(temp_store_outputs[0, i]);
// break;
// case 2:
// MeanAndSD.Add(temp_store_outputs[0, i]);
// counter = 0;
// break;
// }
//}
//for (int i = 0; i < ModelDataOutputs.Count; i++)
//{
// if (i % 2 == 0)
// ModelDataOutputs[i].ValueAsDouble = Convert.ToDouble(MeanAndSD.ElementAt(i));
// else
// ModelDataOutputs[i].ValueAsDouble = Math.Sqrt(Convert.ToDouble(MeanAndSD.ElementAt(i)));
//}
//return true;
}
public List <Data> GetAllData() => ModelDataInputs.Concat(ModelDataOutputs).ToList();
public override Workflow Copy(string id, string name = null, string parentName = null)
{
return(new WorkflowUncertaintyParametrised(id, Description, InnerWorkflow, ModelDataInputs.ToList(), ModelDataOutputs.ToList(),
InputDistributions.ToList(), OutputDistributions.ToList(), UncertaintyPropagator, parentName ?? parentName));
}
public override Workflow Copy(string id, string name = null, string parentName = null)
{
return(new WorkflowReversedModel(id, Description, ModelDataInputs.ToList(), ModelDataOutputs.ToList(),
Model, Solvers.ToList(), parentName ?? parentName));
}
public override Workflow Copy(string id, string name = null, string parentName = null)
{
return(new WorkflowSCC(id, Description, ModelDataInputs.ToList(), ModelDataOutputs.ToList(),
Components.ToList(), ScheduledComponents.ToList(), Solvers.ToList(), parentName ?? parentName));
}
public override bool Execute()
{
int Ninputs = ModelDataInputs.Count;
int Nout = Math.Min(methodInfo.GetParameters().Where(p => p.IsOut).Count(), ModelDataOutputs.Count);
object[] parameters = ModelDataInputs.Concat(ModelDataOutputs.Take(Nout)).Select(i => i.Value).ToArray();
//for (int i = 0; i < Nout; i++)
// inputs.Add(ModelDataOutputs[i].Value);
//inputs.Add(Activator.CreateInstance(Type.GetType(param.ParameterType.FullName.TrimEnd('&'))));
try
{
//object[] parameters = inputs.ToArray();
object outputs = methodInfo.Invoke(classInstance, parameters);
Type outputType = outputs?.GetType() ?? typeof(void);
for (int i = 0; i < Nout; i++)
{
ModelDataOutputs[i].Value = parameters[Ninputs + i];
}
int idx = 0;
if (outputs is object[] arr)
{
int N = Math.Min(arr.Length, ModelDataOutputs.Count);
for (int i = 0; i < N; i++)
{
// Assign
ModelDataOutputs[Nout + i].Value = arr[i];
}
idx = N;
}
else if (outputType.IsSuported())
{
ModelDataOutputs.First().Value = outputs;
idx = 1;
}
else
{
PropertyInfo[] properties = outputType.GetProperties().Where(p => p.GetMethod.IsPublic && p.PropertyType.IsSuported()).ToArray();
FieldInfo[] fields = outputType.GetFields().Where(f => f.IsPublic && f.FieldType.IsSuported()).ToArray();
int N = Math.Min(properties.Length, ModelDataOutputs.Count);
int M = Math.Min(fields.Length, ModelDataOutputs.Count - N);
for (int i = 0; i < N; i++)
{
// Assign
ModelDataOutputs[Nout + i].Value = properties[i].GetValue(outputs);
}
for (int i = 0; i < M; i++)
{
// Assign
ModelDataOutputs[Nout + N + i].Value = fields[i].GetValue(outputs);
}
idx = N + M;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(false);
}
return(true);
}
