/*
* METHODES
*/
/// <summary>
/// Retourne une string contenant la signature du modèle de calcul
/// </summary>
/// <param name="outputName"></param>
/// <returns>
/// </returns>
private string modelSignature(string outputName)
{
// Recherche du nom du modèle dans la liste dataModels
PerfPile p = this.dataModels.Find(x => x.outputName.Equals(outputName));
if (p != null)
{
List <String> factorList = new List <string>();
string factors = "";
foreach (string word in factorsSignature(outputName).Split(AeroCalcCommand.CMD_SEPARATOR))
{
if (!string.IsNullOrEmpty(word) && factorList.Find(x => x.Equals(word)) == null)
{
// On ajoute que les noms distincts des différents facteurs
factorList.Add(word);
}
}
foreach (string word in factorList)
{
factors += word + " ";
}
return(p.outputName + " " + factors);
}
else
{
// Aucun modèle de donnée ne correspond à ce nom
return("");
}
// Suppression des doublons dans les facteurs
}
/*
* SERVICES
*/
/// <summary>
/// Sauvegarde un objet PerfPile dans un fichier XML
/// </summary>
/// <param name="pp">Objet PerfPile à sauvegarder</param>
/// <param name="xmlFileAbsolutePath">Chemin complet vers le fichier XML à créer</param>
/// <returns>Entier signalant la réussite ou l'échec de l'opération
/// XMLConnector.FILEOP_SUCCESSFUL : réussite
/// XMLConnector.FILEOP_UNABLE_TO_CREATE_OUTPUT_FILE : Impossible de créer le fichier XML
/// XMLConnector.FILEOP_UNKNOWN_ERROR : Erreur non identifiable
/// </returns>
/// <remarks>
/// TODO: A DEVELOPPER
/// </remarks>
public int savePerfPileToXML(PerfPile pp, string xmlFileAbsolutePath)
{
XDocument xmlPerfDoc = new XDocument();
xmlPerfDoc.AddFirst(xmlPerfPile(pp));
xmlPerfDoc.Save(xmlFileAbsolutePath);
return(XMLFile.FILEOP_SUCCESSFUL);
}
/// <summary>
/// Retourne une string contenant les noms des facteurs d'un modèle de calcul
/// </summary>
/// <param name="outputName">Nom du modèle de calcul</param>
/// <returns>
/// </returns>
private string factorsSignature(string outputName)
{
PerfPile p = this.dataModels.Find(x => x.outputName == outputName);
string signature;
if (p != null)
{
// Le modèle existe
signature = factorsSignature(p.discretName) + " ";
signature += factorsSignature(p.layerFactorName) + " ";
signature += factorsSignature(p.serieFactorName) + " ";
signature += factorsSignature(p.pointFactorName) + " ";
return(signature);
}
else
{
return(outputName);
}
}
/// <summary>
/// Formate un élément XML pour refléter un objet PerfPile
/// </summary>
/// <param name="pp">Objet PerfPile</param>
/// <returns>Un élément XML</returns>
private XElement xmlPerfPile(PerfPile pp)
{
XElement xElem = new XElement("Pile", new XAttribute("Name", pp.outputName),
new XAttribute("Key", pp.dataBaseKey),
new XAttribute("Hidden", (pp.hidden == true ? "1" : "0")),
new XAttribute("Factor", pp.factorValue),
new XAttribute("DiscretName", pp.discretName),
new XAttribute("DiscretValue", pp.discretValue),
new XAttribute("PointFactorName", pp.pointFactorName),
new XAttribute("PointFactorUnitCode", pp.pointFactorUnitCode),
new XAttribute("SerieFactorName", pp.serieFactorName),
new XAttribute("SerieFactorUnitCode", pp.serieFactorUnitCode),
new XAttribute("LayerFactorName", pp.layerFactorName),
new XAttribute("LayerFactorUnitCode", pp.layerFactorUnitCode));
XElement xColElem = new XElement("Layers");
// Ajout de chaque layer de la pile
for (int count = 0; count < pp.count; count++)
{
xColElem.Add(xmlPerfLayer(pp.layerAt(count)));
}
xElem.Add(xColElem);
return(xElem);
}
/*
* /// <summary>
* /// Retourne le dictionnaire des unités
* /// </summary>
* /// <returns>UnitDictionnary, le dictionnaire des unités</returns>
* ///
* public UnitDictionary unitDictionary() {
* return dataUnits;
* }
*/
/// <summary>
/// Retourne le résultat d'un calcul multi-dimensionnel
/// </summary>
/// <param name="dataModelName">Nom du modèle à utiliser</param>
/// <param name="factors">Liste des facteurs passés en argument</param>
/// <returns>
/// double, résultat du calcul
/// </returns>
/// <remarks>
/// Fontion récursive
/// </remarks>
public double compute(string dataModelName, List <CommandFactor> factors)
{
// Recherche du modèle de performances permettant le traitement (nom + discret)
//PerfPile Pile = dataModels.ElementAt(dataModelIndex(dataModelName, factors));
PerfPile Pile = dataModels.Find(x => x.outputName == dataModelName);
double result = double.NaN;
//int commandIndex = container.dataModelIndex(Cmd.subs[0], Cmd.Factors);
if (Pile == null)
{
// Aucun modèle ne répond aux critères de sélection
return(double.NaN);
}
// Recherche de la valeur des différents facteurs nécessaires aux calculs
if (Pile != null)
{
// Le modèle est identifié
//pp = container.dataModelByIndex(commandIndex);
// Analyse des facteurs, paramètres et options de la commande
//double pointFactorValue = factors.Find(x => x.name.Equals(Pile.pointFactorName)).value;
double pointFactorValue = valueFromFactor(factors, Pile.pointFactorName);
if (double.IsNaN(pointFactorValue))
{
// serieFactorValue n'est pas disponible dans les facteurs, on tente de le calculer
pointFactorValue = compute(Pile.pointFactorName, factors);
if (double.IsNaN(pointFactorValue))
{
// Echec de la tentative du calcul
return(double.NaN);
}
}
//double serieFactorValue = factors.Find(x => x.name.Equals(Pile.serieFactorName)).value;
double serieFactorValue = valueFromFactor(factors, Pile.serieFactorName);
if (double.IsNaN(serieFactorValue))
{
// serieFactorValue n'est pas disponible dans les facteurs, on tente de le calculer
serieFactorValue = compute(Pile.serieFactorName, factors);
if (double.IsNaN(serieFactorValue))
{
// Echec de la tentative du calcul
return(double.NaN);
}
}
//double layerFactorValue = factors.Find(x => x.name.Equals(Pile.layerFactorName)).value;
double layerFactorValue = valueFromFactor(factors, Pile.layerFactorName);
if (double.IsNaN(layerFactorValue))
{
// layerFactorValue n'est pas disponible dans les facteurs, on tente de le calculer
serieFactorValue = compute(Pile.layerFactorName, factors);
if (double.IsNaN(layerFactorValue))
{
// Echec de la tentative du calcul
return(double.NaN);
}
}
try
{
result = Pile.predict(pointFactorValue, serieFactorValue, layerFactorValue);
}
catch (ModelException e)
{
// On récupère d'une exception ou un paramètre est hors du range ou il peut être utilisé
// TODO les infos de l'exception sont générées directement dans predict()
throw e;
}
}
return(result);
}