/// <summary>
/// Le data du result contient l'élément de cablage ou null
/// </summary>
/// <param name="sens"></param>
/// <param name="contexteDonnee"></param>
/// <returns></returns>
public CResultAErreur GetElementCablage(
ESensAllerRetourLienReseau?sens,
CContexteDonnee contexteDonnee)
{
CResultAErreur result = CResultAErreur.True;
CNoeudDeGrapheReseauSite noeudSite = Composant as CNoeudDeGrapheReseauSite;
if (noeudSite == null || !noeudSite.IsCable)//Pas un site ou pas cablé
{
return(result);
}
CSchemaReseau schema = new CSchemaReseau(contexteDonnee);
if (!schema.ReadIfExists(Composant.IdSchemaReseau))
{
result.EmpileErreur(I.T("Can not find network diagram @1|20051", Composant.IdSchemaReseau.ToString()));
return(result);
}
CSchemaReseau schemaCablage = schema.GetSousSchemas().FirstOrDefault(s =>
s.SiteApparenance != null &&
s.SiteApparenance.Id == noeudSite.IdSite);
CGrapheReseau grapheCablage = new CGrapheReseau(null);
result = grapheCablage.CalculeGraphe(schemaCablage, sens);
if (!result)
{
return(result);
}
CArbreOperationnel arbreGraphe = new CArbreOperationnel();
result = arbreGraphe.CalculArbreRedondanceAuto(schemaCablage, grapheCablage);
if (result)
{
result.Data = arbreGraphe.ElementRacine;
}
return(result);
}
private void CalculeIsOperationnel()
{
bool bOldOperationnel = m_bIsOperationnel;
try
{
m_bIsOperationnel = true;
if (GraviteAlarme < EGraviteAlarme.Major)
{
return;
}
Dictionary <int, bool> dicSitesCoupes = new Dictionary <int, bool>();
Dictionary <int, bool> dicLiensCoupes = new Dictionary <int, bool>();
Dictionary <int, bool> dicEquipsCoupes = new Dictionary <int, bool>();
//FillDicsCoupes(m_listeFils.ToArray(), dicSitesCoupes, dicLiensCoupes, dicEquipsCoupes);
//Vérifie s'il y a des sites isolés en erreur, si oui, état opérationnel HS
foreach (CNoeudDeGrapheReseau noeud in m_dicNoeudsIsoles.Keys)
{
CNoeudDeGrapheReseauSite noeudSite = noeud as CNoeudDeGrapheReseauSite;
if (noeudSite != null && dicSitesCoupes.ContainsKey(noeudSite.IdSite))
{
m_bIsOperationnel = false;
return;
}
CNoeudDeGrapheReseauEquipement noeudEquip = noeud as CNoeudDeGrapheReseauEquipement;
if (noeudEquip != null && dicEquipsCoupes.ContainsKey(noeudEquip.IdEquipement))
{
m_bIsOperationnel = false;
return;
}
}
foreach (KeyValuePair <CPointAPointDeGraphe, List <CCheminDeGrapheReseau> > papToList in m_baseChemins)
{
CPointAPointDeGraphe pap = papToList.Key;
List <CCheminDeGrapheReseau> cheminsPourPap = papToList.Value;
bool bHasOkForThisPap = false;
foreach (CCheminDeGrapheReseau chemin in cheminsPourPap)
{
bool bIsOk = true;
foreach (CNoeudDeGrapheReseau noeud in chemin.NoeudsUtilises)
{
CNoeudDeGrapheReseauSite noeudSite = noeud as CNoeudDeGrapheReseauSite;
if (noeudSite != null && dicSitesCoupes.ContainsKey(noeudSite.IdSite))
{
bIsOk = false;
break;
}
CNoeudDeGrapheReseauEquipement noeudEquip = noeud as CNoeudDeGrapheReseauEquipement;
if (noeudEquip != null && dicEquipsCoupes.ContainsKey(noeudEquip.IdEquipement))
{
bIsOk = false;
break;
}
}
if (bIsOk)
{
foreach (CLienDeGrapheReseau lien in chemin.Liens)
{
if (dicLiensCoupes.ContainsKey(lien.IdLienReseau))
{
bIsOk = false;
break;
}
}
}
bHasOkForThisPap |= bIsOk;
}
if (!bHasOkForThisPap)
{
m_bIsOperationnel = false;
return;
}
}
}
finally
{
if (m_bIsOperationnel != bOldOperationnel)
{
m_base.OnChangementEtatSupervise(this);
}
}
}
//-------------------------------------------------
/// <summary>
/// Calcule l'arbre entre deux noeuds pour un schéma
/// </summary>
/// <param name="schema"></param>
/// <param name="graphe"></param>
/// <param name="noeudDepart"></param>
/// <param name="noeudArrivee"></param>
/// <returns></returns>
public CResultAErreur CalculArbreRedondanceAuto(
CSchemaReseau schema,
CGrapheReseau graphe,
CNoeudDeGrapheReseau noeudDepart,
CNoeudDeGrapheReseau noeudArrivee)
{
CResultAErreur result = CResultAErreur.True;
CNoeudDeGrapheReseau[] noeudsEntree;
if (noeudDepart != null)
{
noeudsEntree = new CNoeudDeGrapheReseau[] { noeudDepart }
}
;
else if (schema.LienReseau == null) //Ce n'est pas un schéma de lien
{
noeudsEntree = graphe.GetNoeudsEntreeNiveau0();
}
else
{
noeudsEntree = new CNoeudDeGrapheReseau[] {
graphe.GetNoeudForElement(schema.LienReseau.Element1, schema)
};
}
CNoeudDeGrapheReseau[] noeudsSortie;
if (noeudArrivee != null)
{
noeudsSortie = new CNoeudDeGrapheReseau[] { noeudArrivee }
}
;
else if (schema.LienReseau == null) //Ce n'est pas un schéma de lien
{
noeudsSortie = graphe.GetNoeudsSortieNiveau0();
}
else
{
noeudsSortie = new CNoeudDeGrapheReseau[] {
graphe.GetNoeudForElement(schema.LienReseau.Element2, schema)
};
}
CElementDeArbreOperationnelOperateurEt eltSource = new CElementDeArbreOperationnelOperateurEt(null);
m_elementRacine = eltSource;
//Ajoute les éléments seuls
foreach (CNoeudDeGrapheReseau noeud in graphe.GetNoeudsIsoles())
{
if (schema.LienReseau == null || noeud.Equals(noeudsEntree[0]) || noeud.Equals(noeudsSortie[0]))
//si c'est un schéma de lien n'ajoute que les noeuds isolé correspondant à l'entrée ou à la sortie
{
CElementDeArbreOperationnelEntite composant = new CElementDeArbreOperationnelEntite(eltSource, noeud);
eltSource.AddFils(composant);
result = composant.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
if (!result)
{
return(result);
}
CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
if (elementCablage != null)
{
eltSource.AddFils(elementCablage);
}
}
}
foreach (CNoeudDeGrapheReseau noeudEntree in noeudsEntree)
{
foreach (CNoeudDeGrapheReseau noeudSortie in noeudsSortie)
{
List <CCheminDeGrapheReseau> chemins = graphe.GetChemins(noeudEntree, noeudSortie);
if (chemins.Count() > 0)
{
CElementDeArbreOperationnelOperateurOu ouPourExtremites = new CElementDeArbreOperationnelOperateurOu(eltSource);
eltSource.AddFils(ouPourExtremites);
foreach (CCheminDeGrapheReseau chemin in chemins) //parcours tous les chemins en mettant un ou dessus
{
Stack <CRacineDeSchema> lstRacines = new Stack <CRacineDeSchema>();
CRacineDeSchema racine = new CRacineDeSchema(schema.Id, null, new CElementDeArbreOperationnelOperateurEt(ouPourExtremites));
ouPourExtremites.AddFils(racine.ElementRacine);
lstRacines.Push(racine);
int nLien = 0;
foreach (CLienDeGrapheReseau lien in chemin.Liens)
{
CRacineDeSchema racineEnCours = lstRacines.Peek();
if (lien.EtapesNoeudDepart != null)
{
int[] idsSchemas = lien.EtapesNoeudDepart.IdsSchemas;
//Dépile les sous schémas
for (int nEtape = idsSchemas.Count() - 1; nEtape >= 0; nEtape--)
{
int nIdSchema = idsSchemas[nEtape];
if (racineEnCours.IdSchema != nIdSchema)
{
result.EmpileErreur(I.T("Bad path for link @1 in graph for @2 diagram|20050",
lien.IdLienReseau.ToString(), lien.IdSchemaReseau.ToString()));
return(result);
}
if (racineEnCours.ElementSousSchema != null)
{
racineEnCours.ElementSousSchema.NoeudArrive = lien.NoeudDepart;
}
lstRacines.Pop();
racineEnCours = lstRacines.Peek();
}
}
//Si les extremités du lien sont cablées, le lien est dans un et, sinon,
//il est directement sous la racine en cours
CElementDeArbreOperationnelOperateur elementParentDeLien = racineEnCours.ElementRacine;
//Si ce n'est pas le dernier lien, on ajoute que les cablages des noeuds de départ,
//Puisque le cablage du noeud d'arrivé sera le cablage du noeud de départ du prochain lien
//Par contre, si c'est le dernier lien du chemin, il faut ajouter ce cablage
if ((lien.NoeudDepart is CNoeudDeGrapheReseauSite && ((CNoeudDeGrapheReseauSite)lien.NoeudDepart).IsCable) ||
(nLien == chemin.Liens.Count() - 1 && (lien.NoeudArrive is CNoeudDeGrapheReseauSite && ((CNoeudDeGrapheReseauSite)lien.NoeudArrive).IsCable)))
{
elementParentDeLien = new CElementDeArbreOperationnelOperateurEt(racineEnCours.ElementRacine);
racineEnCours.ElementRacine.AddFils(elementParentDeLien);
}
elementParentDeLien.AddFils(new CElementDeArbreOperationnelEntite(elementParentDeLien, lien));
//Cablage du site entrée
CNoeudDeGrapheReseauSite noeudSite = lien.NoeudDepart as CNoeudDeGrapheReseauSite;
if (noeudSite != null && noeudSite.IsCable)
{
//Le noeud correspondant à l'élément est déjà dans le schéma du lien
CElementDeArbreOperationnelEntite elementNoeud = new CElementDeArbreOperationnelEntite(null, noeudSite);
result = elementNoeud.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
if (!result)
{
return(result);
}
CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
if (elementCablage != null)
{
elementParentDeLien.AddFils(elementCablage);
}
}
//Cablage du site sortie
noeudSite = lien.NoeudArrive as CNoeudDeGrapheReseauSite;
if (noeudSite != null && noeudSite.IsCable && nLien == chemin.Liens.Count() - 1)
{
CElementDeArbreOperationnelEntite elementNoeud = new CElementDeArbreOperationnelEntite(null, noeudSite);
result = elementNoeud.GetElementCablage(graphe.SensDuGraphe, schema.ContexteDonnee);
if (!result)
{
return(result);
}
CElementDeArbreOperationnel elementCablage = result.Data as CElementDeArbreOperationnel;
if (elementCablage != null)
{
elementParentDeLien.AddFils(elementCablage);
}
}
if (lien.EtapesNoeudArrivee != null)
{
int[] idsSchemas = lien.EtapesNoeudArrivee.IdsSchemas;
foreach (int nIdSchema in idsSchemas)
{
CElementDeArbreOperationnelSousSchema eltSousSchema = new CElementDeArbreOperationnelSousSchema(racineEnCours.ElementRacine);
eltSousSchema.NoeudDepart = lien.NoeudArrive;
eltSousSchema.ElementDeArbre = new CElementDeArbreOperationnelOperateurEt(racine.ElementRacine);
eltSousSchema.IdSchema = nIdSchema;
CRacineDeSchema newRacine = new CRacineDeSchema(
nIdSchema,
eltSousSchema,
eltSousSchema.ElementDeArbre as CElementDeArbreOperationnelOperateur);
lstRacines.Push(newRacine);
racineEnCours.ElementRacine.AddFils(eltSousSchema);
racineEnCours = newRacine;
}
}
nLien++;
}
}
}
}
}
eltSource.Simplifier();
return(result);
}
