/// <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>
/// Parses the JObject into an SimulationModel and returns the new created SimulationModel
/// </summary>
/// <param name="json"></param>
/// <param name="name"></param>
/// <returns></returns>
public static SimulationModel Parse(JObject json, String name)
{
if (json == null)
{
return(new SimulationModel());
}
SimulationModel simulation = new SimulationModel();
simulation.Name = name;
simulation.AsJson = json;
simulation.setFmu(json);
simulation.setSemanticId();
return(simulation);
}
/// <summary>
/// Returns the SimulationModel as Entity
/// </summary>
/// <param name="simulationModel"></param>
/// <param name="nameSubmodel"></param>
/// <returns></returns>
public AdminShellNS.AdminShell.Entity GetSimModelAsEntity(SimulationModel simulationModel, string nameSubmodel)
{
AdminShellNS.AdminShell.Entity entity = new AdminShellNS.AdminShell.Entity();
entity.idShort = simulationModel.Name;
entity.entityType = "CoManagedEntity";
entity.semanticId = simulationModel.SemanticId;
// make new parent
var newpar = new AdminShellNS.AdminShell.Referable();
newpar.idShort = nameSubmodel;
entity.parent = newpar;
// to be processed further
return(entity);
}
/// <summary>
/// Creates a node, represented as a Simulationmodel, for all physical ports which are connected.
/// </summary>
public void CreateNodesForPhysicalPorts()
{
int nodeCount = 0;
List <SimulationModel> newSimMod = new List <SimulationModel>();
AdminShellNS.AdminShell.SemanticId semanticId = new AdminShellNS.AdminShell.SemanticId();
AdminShellNS.AdminShell.Key key = new AdminShellNS.AdminShell.Key();
key.value = "www.tedz.itsowl.com/ids/cd/1132_9030_2102_4033";
key.type = "ConceptDescription";
key.local = true;
key.index = 0;
key.idType = "IRI";
semanticId.Keys.Add(key);
List <List <IOput> > nodeLists = new List <List <IOput> >();
foreach (var simmod in SimulationsModels.Values)
{
foreach (var port in simmod.PhysicalPorts)
{
if (!nodeLists.Contains(port.ConnectedTo) && port.ConnectedTo.Count > 1)
{
nodeLists.Add(port.ConnectedTo);
}
}
}
foreach (var list in nodeLists)
{
SimulationModel nodeModel = createNode(nodeCount, semanticId, list);
if (nodeModel.PhysicalPorts.Count > 0)
{
newSimMod.Add(nodeModel);
nodeCount++;
}
}
foreach (var simmod in newSimMod)
{
SimulationsModels.Add(simmod.Name, simmod);
}
}
/// <summary>
/// Returns the SimulationModel port Information as a Property
/// </summary>
/// <param name="simulationModel"></param>
/// <returns></returns>
private List <AdminShellNS.AdminShell.Property> GetPortsAsProp(SimulationModel simulationModel)
{
List <AdminShellNS.AdminShell.Property> ioputs = new List <AdminShellNS.AdminShell.Property>();
foreach (var input in simulationModel.Inputs)
{
ioputs.Add(GetPortAsProperty(input, "in"));
}
foreach (var output in simulationModel.Outputs)
{
ioputs.Add(GetPortAsProperty(output, "out"));
}
foreach (var output in simulationModel.PhysicalPorts)
{
ioputs.Add(GetPortAsProperty(output, "physical"));
}
return(ioputs);
}
/// <summary>
/// Creates a node between the given ports
/// </summary>
/// <param name="nodeCount"></param>
/// <param name="semanticId"></param>
/// <param name="list"></param>
/// <returns></returns>
private static SimulationModel createNode(int nodeCount,
AdminShellNS.AdminShell.SemanticId semanticId,
List <IOput> list)
{
SimulationModel nodeModel = new SimulationModel();
nodeModel.IsNode = true;
string name = "node_" + nodeCount;
nodeModel.Name = name;
nodeModel.SemanticId = semanticId;
int portnumber = 0;
foreach (var port in list)
{
IOput newport = new IOput(port.IdShort + "_" + portnumber++, name);
newport.IsPhysical = true;
newport.ConnectedTo.Add(port);
nodeModel.PhysicalPorts.Add(newport);
}
return(nodeModel);
}
/// <summary>
/// Creates multiplication points in case there is a connection where the ports to not share the same unit
/// but were connected because of a mapping. The mapping conatains a value which is used here as the factor
/// for the multiplication. The existing output port of the existing connection gets connected to the multports
/// input port and the input port of the connection gets connected to the multports output port.
/// The old connection is removed.
/// </summary>
/// <returns></returns>
public bool CreateMultPoints()
{
int multCount = 0;
List <SimulationModel> newSimMod = new List <SimulationModel>();
AdminShellNS.AdminShell.SemanticId semanticId = new AdminShellNS.AdminShell.SemanticId();
AdminShellNS.AdminShell.Key key = new AdminShellNS.AdminShell.Key();
key.value = SemanticPort.GetInstance().GetSemanticForPort("BoM_SmdComp_Mult");
key.type = "ConceptDescription";
key.local = true;
key.index = 0;
key.idType = "IRI";
semanticId.Keys.Add(key);
foreach (var simmod in SimulationsModels.Values)
{
foreach (var input in simmod.Inputs)
{
if (input.EclassID != null && simmod.Mappings.ContainsKey(input.EclassID))
{
foreach (var connected in input.ConnectedTo.ToList())
{
string name = "mult_" + multCount++;
SimulationModel multPort = new SimulationModel();
multPort.SemanticId = semanticId;
multPort.Multfactor = simmod.Mappings[input.EclassID].Value;
IOput iput = new IOput("in", name);
iput.SemanticId = input.SemanticId;
IOput oput = new IOput("out", name);
oput.SemanticId = input.SemanticId;
input.RemoveConnection(connected);
oput.AddConnection(input);
iput.AddConnection(connected);
multPort.Outputs.Add(oput);
multPort.Inputs.Add(iput);
multPort.Name = name;
newSimMod.Add(multPort);
}
}
}
foreach (var output in simmod.Outputs)
{
if (output.EclassID != null && simmod.Mappings.ContainsKey(output.EclassID))
{
foreach (var connected in output.ConnectedTo.ToList())
{
string name = "mult_" + multCount++;
SimulationModel multPort = new SimulationModel();
multPort.SemanticId = semanticId;
multPort.Multfactor = simmod.Mappings[output.EclassID].Value;
IOput iput = new IOput("in", name);
iput.SemanticId = output.SemanticId;
IOput oput = new IOput("out", name);
oput.SemanticId = output.SemanticId;
output.RemoveConnection(connected);
iput.AddConnection(output);
oput.AddConnection(connected);
multPort.Outputs.Add(oput);
multPort.Inputs.Add(iput);
multPort.Name = name;
newSimMod.Add(multPort);
}
}
}
}
foreach (var simMod in newSimMod)
{
SimulationsModels.Add(simMod.Name, simMod);
}
return(true);
}
