/// <summary>
/// Called by the component carrying the data to input into the calculator.
/// </summary>
/// <param name="_calculator">Component carrying the calculation(s)</param>
/// <param name="_input_mapping">key = source parameter id, value = target parameter id</param>
private Mapping2Component CreateMappingTo(string _name, Component _calculator, Dictionary <long, long> _input_mapping, Dictionary <long, long> _output_mapping)
{
if (_calculator == null)
{
return(null);
}
if (_calculator.ID == this.ID)
{
return(null);
}
if (_input_mapping == null || _output_mapping == null)
{
return(null);
}
if (_input_mapping.Count == 0 || _output_mapping.Count == 0)
{
return(null);
}
_calculator.MappedToBy.Add(this);
Mapping2Component mapping = new Mapping2Component(_name, _calculator, _input_mapping, _output_mapping);
this.mappings_to_comps.Add(mapping);
return(mapping);
}
public void TranslateMapping(Mapping2Component _mapping, out Dictionary <Parameter.Parameter, Parameter.Parameter> input_mapping,
out Dictionary <Parameter.Parameter, Parameter.Parameter> output_mapping)
{
input_mapping = new Dictionary <Parameter.Parameter, Parameter.Parameter>();
output_mapping = new Dictionary <Parameter.Parameter, Parameter.Parameter>();
if (_mapping == null)
{
return;
}
List <Parameter.Parameter> input_source = this.GetByIds(_mapping.InputMapping.Keys.ToList());
List <Parameter.Parameter> input_target = _mapping.Calculator.GetByIds(_mapping.InputMapping.Values.ToList());
if (input_source.Count != input_target.Count)
{
return;
}
input_mapping = input_source.Zip(input_target, (x, y) => new KeyValuePair <Parameter.Parameter, Parameter.Parameter>(x, y)).ToDictionary(x => x.Key, x => x.Value);
List <Parameter.Parameter> output_source = this.GetByIds(_mapping.OutputMapping.Keys.ToList());
List <Parameter.Parameter> output_target = _mapping.Calculator.GetByIds(_mapping.OutputMapping.Values.ToList());
if (output_source.Count != output_target.Count)
{
return;
}
output_mapping = output_source.Zip(output_target, (x, y) => new KeyValuePair <Parameter.Parameter, Parameter.Parameter>(x, y)).ToDictionary(x => x.Key, x => x.Value);
}
public Comp2CompMappingErr MappingEditPreview(Mapping2Component _map, Dictionary <Parameter.Parameter, Parameter.Parameter> _new_input_mapping,
Dictionary <Parameter.Parameter, Parameter.Parameter> _new_output_mapping)
{
if (!(this.Mappings2Comps.Contains(_map)))
{
return(Comp2CompMappingErr.COULD_NOT_EVALUATE);
}
if (_new_input_mapping == null || _new_input_mapping.Count == 0)
{
return(Comp2CompMappingErr.NOT_ALL_INPUT_ASSIGNED);
}
if (_new_output_mapping == null || _new_output_mapping.Count == 0)
{
return(Comp2CompMappingErr.NOT_ALL_OUTPUT_ASSIGNED);
}
foreach (Parameter.Parameter p in _new_output_mapping.Values)
{
if (p.Propagation != InfoFlow.MIXED && p.Propagation != InfoFlow.OUPUT)
{
return(Comp2CompMappingErr.NOT_ALL_OUTPUT_ASSIGNED);
}
List <Parameter.Parameter> required_input_for_p = _map.Calculator.GetInputParamsInvolvedInTheCalculationOf(p);
if (required_input_for_p.Count == 0)
{
return(Comp2CompMappingErr.NO_CALCULATION_FOUND);
}
}
return(Comp2CompMappingErr.NONE);
}
public Comp2CompMappingErr MappingPreview(Component _calculator, Dictionary <Parameter.Parameter, Parameter.Parameter> _input_mapping,
Dictionary <Parameter.Parameter, Parameter.Parameter> _output_mapping)
{
if (_calculator == null)
{
return(Comp2CompMappingErr.COULD_NOT_EVALUATE);
}
if (_calculator.ID == this.ID)
{
return(Comp2CompMappingErr.SELF_REFERENCE);
}
Mapping2Component duplicate_mapping = this.mappings_to_comps.FirstOrDefault(x => x.Calculator.ID == _calculator.ID);
if (duplicate_mapping != null)
{
return(Comp2CompMappingErr.DUPLICATE_CALCULATOR);
}
if (_input_mapping == null || _input_mapping.Count == 0)
{
return(Comp2CompMappingErr.NOT_ALL_INPUT_ASSIGNED);
}
if (_output_mapping == null || _output_mapping.Count == 0)
{
return(Comp2CompMappingErr.NOT_ALL_OUTPUT_ASSIGNED);
}
foreach (Parameter.Parameter p in _output_mapping.Values)
{
if (p.Propagation != InfoFlow.MIXED && p.Propagation != InfoFlow.OUPUT)
{
return(Comp2CompMappingErr.NOT_ALL_OUTPUT_ASSIGNED);
}
List <Parameter.Parameter> required_input_for_p = _calculator.GetInputParamsInvolvedInTheCalculationOf(p);
if (required_input_for_p.Count == 0)
{
return(Comp2CompMappingErr.NO_CALCULATION_FOUND);
}
// partial input acceptable
//foreach (Parameter.Parameter ip in required_input_for_p)
//{
// if (!(_input_mapping.ContainsValue(ip)))
// return Comp2CompMappingErr.NOT_ALL_INPUT_ASSIGNED;
//}
}
return(Comp2CompMappingErr.NONE);
}
public bool RemoveMapping(Mapping2Component _mapping)
{
if (_mapping == null)
{
return(false);
}
if (_mapping.Calculator != null)
{
_mapping.Calculator.MappedToBy.Remove(this);
}
return(this.mappings_to_comps.Remove(_mapping));
}
public void EvaluateMapping(Mapping2Component _mapping)
{
if (_mapping == null)
{
return;
}
Dictionary <long, Parameter.Parameter> all_params = this.GetFlatParamsList();
// reset the calculator
_mapping.Calculator.ResetToDefaultValuesBeforeCalculation();
// gather the input values
Dictionary <long, double> input_values = new Dictionary <long, double>();
foreach (var entry in _mapping.InputMapping)
{
if (all_params.ContainsKey(entry.Key))
{
input_values.Add(entry.Value, all_params[entry.Key].ValueCurrent);
}
}
// gather the output values
Dictionary <long, double> output_values = new Dictionary <long, double>();
foreach (var entry in _mapping.OutputMapping)
{
if (all_params.ContainsKey(entry.Key))
{
output_values.Add(entry.Value, all_params[entry.Key].ValueCurrent);
}
else
{
output_values.Add(entry.Value, 0.0);
}
}
// pass the parameters to the calculator
_mapping.Calculator.CalculateAndMap(input_values, ref output_values);
// retrieve the result
foreach (var entry in _mapping.OutputMapping)
{
if (output_values.ContainsKey(entry.Value))
{
all_params[entry.Key].ValueCurrent = output_values[entry.Value];
}
}
}
public void EditMapping(Mapping2Component _map, Dictionary <Parameter.Parameter, Parameter.Parameter> _input_mapping,
Dictionary <Parameter.Parameter, Parameter.Parameter> _output_mapping, out Comp2CompMappingErr err)
{
err = this.MappingEditPreview(_map, _input_mapping, _output_mapping);
if (err != Comp2CompMappingErr.NONE)
{
return;
}
// apply changes
Dictionary <long, long> input_mapping = _input_mapping.Select(x => new KeyValuePair <long, long>(x.Key.ID, x.Value.ID)).ToDictionary(x => x.Key, x => x.Value);
Dictionary <long, long> output_mapping = _output_mapping.Select(x => new KeyValuePair <long, long>(x.Key.ID, x.Value.ID)).ToDictionary(x => x.Key, x => x.Value);
_map.Adjust(input_mapping, output_mapping);
}
internal bool RemoveMappingTo(Component _calc)
{
if (_calc == null)
{
return(false);
}
Mapping2Component to_remove = this.mappings_to_comps.FirstOrDefault(x => x.Calculator != null && x.Calculator.ID == _calc.ID);
if (to_remove != null)
{
return(this.RemoveMapping(to_remove));
}
else
{
return(false);
}
}
public bool MappingToCompExists(Component _calculator)
{
Mapping2Component duplicate_mapping = this.mappings_to_comps.FirstOrDefault(x => x.Calculator.ID == _calculator.ID);
return(duplicate_mapping != null);
}
