/// <summary>
/// Ajoute un Point de performances de vol à une Serie de la layer
/// Si la Serie n'existe pas, une Serie est créée pour accueillir le Point
/// </summary>
/// <param name="newPerfPoint">Nouveau Point de performances de vol</param>
/// <param name="serieFactorValue">Facteur de la Serie dans laquelle inscrire le Point</param>
/// <returns>True si l'ajout est réussi, False dans le cas contaire</returns>
public bool add(PerfPoint newPerfPoint, double serieFactorValue)
{
bool foundIt = false;
bool success = false;
// Recherche de la Serie ayant un facteur identique
for (int count = 0; count < perfSerieList.Count; count++)
{
if (serieFactorValue == SerieAt(count).factorValue)
{
success = SerieAt(count).add(newPerfPoint);
foundIt = true;
break;
}
}
// Pas de Serie qui convienne, on la crée
if (!foundIt)
{
PerfSerie ps = new PerfSerie(serieFactorValue);
success = ps.add(newPerfPoint);
if (success)
{
success = add(ps);
}
}
return(success);
}
/// <summary>
/// Formate un élément XML pour refléter un objet PerfSerie
/// </summary>
/// <param name="pp">Objet PerfSerie</param>
/// <returns>Un élément XML</returns>
private XElement xmlPerfSerie(PerfSerie pf)
{
XElement xElem = new XElement("Serie", new XAttribute("Key", pf.dataBaseKey),
new XAttribute("Factor", pf.factorValue));
XElement xColElem = new XElement("Points");
// Ajout de chaque point de la série
for (int count = 0; count < pf.count; count++)
{
xColElem.Add(xmlPerfPoint(pf.pointAt(count)));
}
xElem.Add(xColElem);
return(xElem);
}
/// <summary>
/// Calcule une prédiction pour deux facteurs
/// </summary>
/// <param name="pointFactorValue">Facteur lié aux layers de performance</param>
/// <param name="serieFactorValue">Facteur lié aux séries de layers de performance</param>
/// <returns></returns>
public double predict(double pointFactorValue, double serieFactorValue)
{
PerfSerie ps = new PerfSerie();
double output = double.NaN;
double serieOutput = double.NaN;
try {
if (this.count == 1)
{
// Il n'y a qu'une série dans la layer, donc serieFactorValue n'est pas utile
output = SerieAt(0).predict(pointFactorValue);
}
else
{
// Si le domaine de calcul n'a pas été défini au préalable, il est réduit à l'étendue
// de la layer
if (!ranged)
{
setRange();
}
// Test du domaine de calcul
if (!isInRange(serieFactorValue))
{
throw new ModelException(AeroCalc.E_SERIE_VALUE_OUT_OF_RANGE,
this.outputName, "", serieFactorValue);
}
// Sélection des séries
selectSubLayer(serieFactorValue, 3);
// Calcul de la prédiction pour chaque série sélectionnée
for (int count = 0; count < this.count; count++)
{
if (SerieAt(count).selected)
{
serieOutput = SerieAt(count).predict(pointFactorValue);
ps.add(new PerfPoint(SerieAt(count).factorValue, serieOutput, false));
}
}
if (ps.count >= 1)
{
output = ps.predict(serieFactorValue);
}
}
} catch (ModelException e) {
throw e;
}
return(output);
}
// Services /////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Ajoute une Serie de performances à la Layer
/// </summary>
/// <param name="newPerfSerie">Nouvelle Serie à ajouter dans la Layer</param>
/// <returns>True si l'ajout est réussi, False dans le cas contaire</returns>
public bool add(PerfSerie newPerfSerie)
{
foreach (PerfSerie p in perfSerieList)
{
if (p.Compare(p, newPerfSerie) == 0)
{
return(false);
}
}
// newPerfSerie est bien une nouvelle série de layers de performance de vol
perfSerieList.Add(newPerfSerie);
perfSerieList.Sort(newPerfSerie);
// TODO Lors de l'ajout de la première Serie, on récupère les infos de la dimension inférieure
/// pointFactorName = newPerfSerie.getPrimaryDimension();
/// pointFactorUnitCode = newPerfSerie.getPrimaryDimensionUnitCode();
/// -->
// Le domaine de calcul n'est plus valable
ranged = false;
return(true);
}
/// <summary>
/// Calcule une prédiction tridimensionnelle
/// </summary>
/// <param name="pointFactorValue">Facteur des Point de performances</param>
/// <param name="serieFactorValue">Facteur des Serie de performances</param>
/// <param name="layerFactorValue">Facteur des Layer de performances</param>
/// <returns>Double, valeur prédite pour les facteurs passés en arguments</returns>
/// <remarks>
/// TODO Cette fonction doit générer les différentes exceptions qui caractérisent les cas de calculs
/// impossibles, mais ce n'est pas à la Pile d'intervenir dans le traitement des exceptions
/// y compris pour stocker les informations liées à ces exceptions.
/// Il reste à revoir la structure des blocs try, une imbrication n'est pas judicieuse
/// Le bloc try primaire est visiblement trop étendu
/// </remarks>
public double predict(double pointFactorValue, double serieFactorValue, double layerFactorValue)
{
// Serie locale permettant une interpolation polynomiale sur 3 Layer en proximité avec layerFactorValue
PerfSerie ps = new PerfSerie();
double output = double.NaN;
double layerOutput = double.NaN;
try {
if (this.count == 1)
{
// Une seule layer, donc layerFactorValue est inutile
output = layerAt(0).predict(pointFactorValue, serieFactorValue);
}
else
{
// Plusieurs Layer à traiter
// Définition du domaine de calcul, si non défini au préalable
if (!ranged)
{
setRange();
}
// Test du domaine de calcul
if (!isInRange(layerFactorValue))
{
throw new ModelException(AeroCalc.E_LAYER_VALUE_OUT_OF_RANGE,
this.outputName, this.layerFactorName, layerFactorValue);
}
// Sélection des layers
selectLayers(layerFactorValue, 3);
// Calcul de la prédiction pour chaque layer sélectionnée
for (int count = 0; count < this.count; count++)
{
if (layerAt(count).selected)
{
layerOutput = layerAt(count).predict(pointFactorValue, serieFactorValue);
// Abonde la Serie locale
ps.add(new PerfPoint(layerAt(count).factorValue, layerOutput, false));
}
}
if (ps.count >= 1)
{
//
// TODO, Attention, la fonction predict va travailler sur une création de données
// nécessaires à une interpolation sur plusieurs Layer. En cas d'exception, ce ne sont pas
// des données originales des modèles de performances.
// REVOIR l'imbrication des blocs try pour simplifier la structure du code
//
try {
output = ps.predict(layerFactorValue);
} catch (ModelException ee) {
ee.setFactor(layerFactorName, layerFactorValue);
}
}
else
{
throw new ModelException(AeroCalc.E_VOID_SYSTEM,
this.outputName, this.layerFactorName, layerFactorValue);
}
}
}
catch (ModelException e) {
output = double.NaN;
if (e.modelName.Equals(""))
{
e.setModelName(this.outputName);
}
switch (e.nature)
{
case AeroCalc.E_POINT_VALUE_OUT_OF_RANGE: e.setFactor(pointFactorName, pointFactorValue);
break;
case AeroCalc.E_SERIE_VALUE_OUT_OF_RANGE: e.setFactor(serieFactorName, serieFactorValue);
break;
case AeroCalc.E_LAYER_VALUE_OUT_OF_RANGE: e.setFactor(layerFactorName, layerFactorValue);
break;
}
throw;
}
return(output);
}
// CONSTRUCTEUR(S)
/// <summary>
/// Construit un objet destiné à réaliser des interpolations polynomiales
/// </summary>
/// <param name="ps">
/// Série de layers de performance de vol
/// </param>
public PolInter(PerfSerie ps)
{
this.perfSerie = ps;
}
