/// <summary>
/// Connects the ports of the inputs list with the ports of the outputs list in case the domains are the same.
/// Returns true in case at least one connection is found.
/// </summary>
/// <param name="inputs"></param>
/// <param name="outputs"></param>
/// <returns></returns>
private bool connectInputsAndOutputsByDomain(List <IOput> inputs, List <IOput> outputs)
{
bool foundConnection = false;
foreach (var input in inputs)
{
foreach (var output in outputs)
{
if (input.Domain.Equals(output.Domain))
{
if (output.IsPhysical)
{
if (EClass.CheckEClassConnection(output.EclassID, input.EclassID) ||
EClass.CheckEClassConnection(input.EclassID, output.EclassID))
{
output.AddPhysicalConnection(input);
foundConnection = true;
}
}
else
{
input.AddConnection(output);
foundConnection = true;
}
}
}
}
return(foundConnection);
}
/// <summary>
/// Checks for mappings for the in or output port and returns true in case there is a mapping.
/// </summary>
/// <param name="input"></param>
/// <param name="output"></param>
/// <param name="eClass"></param>
/// <returns></returns>
private bool checkForMapping(IOput input, IOput output, EClass eClass)
{
SimulationModel simulationModel = SimulationsModels[input.Owner];
bool result = simulationModel.Mappings.ContainsKey(input.EclassID) &&
EClass.CheckEClassConnection(simulationModel.Mappings[input.EclassID].BasicId, output.EclassID);
// Check output ports only if mapping was not already found in input ports
if (result == false)
{
simulationModel = SimulationsModels[output.Owner];
result = simulationModel.Mappings.ContainsKey(output.EclassID) &&
EClass.CheckEClassConnection(input.EclassID, simulationModel.Mappings[output.EclassID].BasicId);
}
return(result);
}
/// <summary>
/// Checks the EClass ids of all connected in and output ports
/// If they are not compatible the connection gets removed
/// Returns a list of strings with the name, eclass id and
/// unit of the in and output ports of all removed connections
/// </summary>
/// <param name="relationshipElement"></param>
/// <param name="firstEle"></param>
/// <param name="secondEle"></param>
/// <returns></returns>
public List <string> CheckeClassConnectionAndRemoveIncompatible(RelationshipElement relationshipElement,
string firstEle,
string secondEle)
{
EClass eClass = new EClass();
List <string> changed = new List <string>();
if (SimulationsModels.ContainsKey(firstEle) && SimulationsModels.ContainsKey(secondEle))
{
foreach (var input in SimulationsModels[firstEle].Inputs.Concat(SimulationsModels[secondEle].Inputs))
{
for (int i = input.ConnectedTo.Count - 1; i >= 0; i--)
{
var connection = input.ConnectedTo[i];
if (SimulationsModels[input.Owner].Mappings.Count != 0)
{
Console.WriteLine("---Mappings of " + input.Owner);
foreach (var map in SimulationsModels[input.Owner].Mappings.Values)
{
Console.WriteLine(map.BasicId + " " + map.UnknownId);
}
}
// Search for compatible Eclass IDs
if (EClass.CheckEClassConnection(input.EclassID, connection.EclassID) ||
checkForMapping(input, connection, eClass))
{
}
// Not Compatible Eclass ids and connection gets removed.
else
{
input.RemoveConnection(connection);
changed.Add(input.IdShort + $"({input.EclassID})({input.Unit}) and " +
connection.IdShort +
$"({connection.EclassID})({connection.Unit})" +
$"are connected but do not have compatible Eclass ID");
}
}
}
}
return(changed);
}
