private void m_btnGraphe_Click(object sender, EventArgs e)
{
if (m_schemaReseau == null)
{
return;
}
CGrapheReseau graphe = new CGrapheReseau();
CResultAErreur result = graphe.CalculeGraphe(m_schemaReseau, ESensAllerRetourLienReseau.Forward);
if (!result)
{
CFormAlerte.Afficher(result.Erreur);
return;
}
CArbreOperationnel arbre = new CArbreOperationnel();
result = arbre.CalculArbreRedondanceAuto(m_schemaReseau, graphe);
string strTexte = "";
if (result)
{
strTexte = arbre.ElementRacine.ToString();
Clipboard.SetText(strTexte);
CFormTesteArbreElementDeGraphe.AfficheArbre(arbre);
}
}
private void CalculArbreOperationnel()
{
// Calcul les graphes
CResultAErreur result = CResultAErreur.True;
CGrapheReseau grapheAller = new CGrapheReseau();
result = grapheAller.CalculeGraphe(m_schema, ESensAllerRetourLienReseau.Forward);
if (result)
{
result = m_arbreAller.CalculArbreRedondanceAuto(m_schema, grapheAller);
}
CGrapheReseau grapheRetour = new CGrapheReseau();
result = grapheRetour.CalculeGraphe(m_schema, ESensAllerRetourLienReseau.Backward);
if (result)
{
result = m_arbreRetour.CalculArbreRedondanceAuto(m_schema, grapheAller);
}
foreach (CInfoElementDeSchemaSupervise info in this.ListeFils)
{
CInfoSchemaDeSchemaSupervise infoSchema = info as CInfoSchemaDeSchemaSupervise;
if (infoSchema != null)
{
infoSchema.CalculArbreOperationnel();
}
}
}
public CResultAErreur CalculArbreTousNecessaires(
CSchemaReseau schema,
CGrapheReseau graphe)
{
CResultAErreur result = CResultAErreur.True;
return(result);
}
//-------------------------------------------------
/// <summary>
/// Calcule un arbre en mode redondance auto pour
/// un schéma
/// </summary>
/// <param name="schema"></param>
/// <param name="graphe"></param>
/// <returns></returns>
public CResultAErreur CalculArbreRedondanceAuto(
CSchemaReseau schema,
CGrapheReseau graphe)
{
return(CalculArbreRedondanceAuto(
schema,
graphe,
null,
null));
}
public CResultAErreur CalculeArbre(
CSchemaReseau schema,
ESensAllerRetourLienReseau sens,
CBaseGraphesReseau baseGraphes)
{
CResultAErreur result = CResultAErreur.True;
if (baseGraphes == null)
{
baseGraphes = new CBaseGraphesReseau();
}
CGrapheReseau graphe = baseGraphes.GetGrapheExistant(schema, sens);
if (graphe == null)
{
graphe = new CGrapheReseau(baseGraphes);
result = graphe.CalculeGraphe(schema, sens);
if (!result)
{
return(result);
}
baseGraphes.AddGrapheReseau(schema.Id, sens, graphe);
}
switch (schema.ModeOperationnel.Code)
{
case EModeOperationnelSchema.AllMandatory:
return(CalculArbreTousNecessaires(schema, graphe));
case EModeOperationnelSchema.AutomaticRedundancy:
return(CalculArbreRedondanceAuto(schema, graphe));
case EModeOperationnelSchema.Custom:
result.EmpileErreur("For future use");
return(result);
default:
break;
}
return(result);
}
/// <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);
}
protected void PrepareSupervisionEtatOperationnel(CSchemaReseau schema)
{
m_listeGraphes.Clear();
List <ESensAllerRetourLienReseau?> lstToCalcul = new List <ESensAllerRetourLienReseau?>();
if (schema.LienReseau != null)
{
lstToCalcul.Add(null);
}
else
{
lstToCalcul.Add(ESensAllerRetourLienReseau.Forward);
lstToCalcul.Add(ESensAllerRetourLienReseau.Backward);
}
foreach (ESensAllerRetourLienReseau?sens in lstToCalcul)
{
CGrapheReseau graphe = m_base.BaseGraphes.GetGrapheExistant(schema, sens);
if (graphe == null)
{
graphe = new CGrapheReseau(m_base.BaseGraphes);
graphe.IntegreLiaison = IntegreLienInGraphe;
if (graphe.CalculeGraphe(schema, sens))
{
m_listeGraphes.Add(graphe);
}
}
else
{
m_listeGraphes.Add(graphe);
}
}
if (m_listeGraphes.Count == 2)
{
//Si l'un des graphes a des liens et pas l'autre, supprime ce graphe
int nNbLiens1 = m_listeGraphes[0].GetLiensNiveau0().Length;
int nNbLiens2 = m_listeGraphes[1].GetLiensNiveau0().Length;
if (nNbLiens1 == 0 && nNbLiens2 != 0)
{
m_listeGraphes.RemoveAt(0);
}
else if (nNbLiens2 == 0)
{
m_listeGraphes.RemoveAt(1);
}
}
//Calcule tous les chemins de point d'entrée à point de sortie.
m_baseChemins.Clear();
m_dicNoeudsIsoles = new Dictionary <CNoeudDeGrapheReseau, bool>();
if (m_listeGraphes.Count > 0)
{
foreach (CNoeudDeGrapheReseau noeud in m_listeGraphes[0].GetNoeudsIsoles())
{
m_dicNoeudsIsoles[noeud] = true;
}
}
int nIndex = 0;
foreach (CGrapheReseau graphe in m_listeGraphes)
{
List <CNoeudDeGrapheReseau> noeudsDepart = new List <CNoeudDeGrapheReseau>(graphe.GetNoeudsEntreeNiveau0());
List <CNoeudDeGrapheReseau> noeudsArrive = new List <CNoeudDeGrapheReseau>(graphe.GetNoeudsSortieNiveau0());
foreach (CNoeudDeGrapheReseau noeudDepart in noeudsDepart)
{
if (m_dicNoeudsIsoles.ContainsKey(noeudDepart))
{
m_dicNoeudsIsoles.Remove(noeudDepart);
}
foreach (CNoeudDeGrapheReseau noeudArrivee in noeudsArrive)
{
if (m_dicNoeudsIsoles.ContainsKey(noeudArrivee))
{
m_dicNoeudsIsoles.Remove(noeudArrivee);
}
CPointAPointDeGraphe pap = new CPointAPointDeGraphe(noeudDepart, noeudArrivee);
m_baseChemins.Add(pap, graphe.GetChemins(noeudDepart, noeudArrivee));
}
}
}
}
//-----------------------------------------------------------------
/// <summary>
/// recalcule l'arbre opérationnel
/// </summary>
/// <param name="baseGraphes"></param>
/// <returns></returns>
public CResultAErreur RecalculeArbreOperationnelInContexte(CBaseGraphesReseau baseGraphes)
{
if (baseGraphes == null)
{
baseGraphes = new CBaseGraphesReseau();
}
CResultAErreur result = CResultAErreur.True;
CSchemaReseau schema = ObjetTimosAssocie;
//Supprime toutes les dépendances à des elements de graphe
result = CObjetDonneeAIdNumerique.Delete(ElementsDeGraphe, true);
if (!result)
{
return(result);
}
foreach (ESensAllerRetourLienReseau sens in Enum.GetValues(typeof(ESensAllerRetourLienReseau)))
{
ESensAllerRetourLienReseau?sensRetenu = null;
if (schema.LienReseau == null)
{
sensRetenu = sens;
}
//Calcule le graphe
CGrapheReseau graphe = baseGraphes.GetGrapheExistant(schema, sensRetenu);
if (graphe == null)
{
graphe = new CGrapheReseau(baseGraphes);
result = graphe.CalculeGraphe(schema, sensRetenu);
if (!result)
{
return(result);
}
}
CArbreOperationnel arbre = new CArbreOperationnel();
result = arbre.CalculArbreRedondanceAuto(schema, graphe);
if (!result)
{
return(result);
}
result = CSpvElementDeGraphe.CreateFromElementDeArbreOperationnel(this, arbre.ElementRacine, sensRetenu);
if (!result)
{
return(result);
}
if (schema.LienReseau != null)
{
break;
}
}
//Recalcule les éléments de graphe qui utilisent ce schéma
CListeObjetsDonnees lstEltsUtilisantLeSchema = new CListeObjetsDonnees(ContexteDonnee, typeof(CSpvElementDeGraphe));
lstEltsUtilisantLeSchema.Filtre = new CFiltreData(CSpvElementDeGraphe.c_champIdSchemaSmt + "=@1",
schema.Id);
foreach (CSpvElementDeGraphe elt in lstEltsUtilisantLeSchema.ToArrayList())
{
CSpvElementDeGrapheSousSchema eltSpvSousSchema = elt.GetElementDuBonType() as CSpvElementDeGrapheSousSchema;
if (eltSpvSousSchema != null)
{
CNoeudDeGrapheReseau noeudDepart = eltSpvSousSchema.NoeudDepart;
CNoeudDeGrapheReseau noeudArrive = eltSpvSousSchema.NoeudArrive;
CArbreOperationnel arbre = new CArbreOperationnel();
CGrapheReseau graphe = baseGraphes.GetGrapheExistant(schema, eltSpvSousSchema.SensGraphe);
if (graphe == null)
{
graphe = new CGrapheReseau(baseGraphes);
result = graphe.CalculeGraphe(schema, eltSpvSousSchema.SensGraphe);
if (!result)
{
return(result);
}
}
result = arbre.CalculArbreRedondanceAuto(schema, graphe, noeudDepart, noeudArrive);
if (!result)
{
return(result);
}
CElementDeArbreOperationnelSousSchema eltOp = new CElementDeArbreOperationnelSousSchema(null);
eltOp.ElementDeArbre = arbre.ElementRacine;
eltOp.IdSchema = schema.Id;
eltOp.NoeudArrive = noeudArrive;
eltOp.NoeudDepart = noeudDepart;
result = CObjetDonneeAIdNumerique.Delete(eltSpvSousSchema.ElementsFils, true);
if (!result)
{
return(result);
}
result = eltSpvSousSchema.FillFromElementDeGraphe(eltOp);
if (!result)
{
return(result);
}
}
}
return(result);
}
//-------------------------------------------------
/// <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);
}
