spectre.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef TY_MC_SPECTRE
#define TY_MC_SPECTRE
 
#include <vector>
#include <map>
#include <ostream>
 
#include "Tympan/core/macros.h"
 
enum TYSpectreType
{
    SPECTRE_TYPE_ATT,
    SPECTRE_TYPE_ABSO,
    SPECTRE_TYPE_LW,
    SPECTRE_TYPE_LP,
    SPECTRE_TYPE_AUTRE
};
enum TYSpectreForm
{
    SPECTRE_FORM_TIERS,
    SPECTRE_FORM_OCT,
    SPECTRE_FORM_CST_DF,
    SPECTRE_FORM_UNSHAPED
};
enum TYSpectreEtat
{
    SPECTRE_ETAT_DB,
    SPECTRE_ETAT_LIN
};
 
static const unsigned int TY_SPECTRE_DEFAULT_NB_ELMT = 31;
 
static const unsigned int TY_SPECTRE_OCT_NB_ELMT = 9;
 
static const double TY_SPECTRE_DEFAULT_VALUE = -100.0;
static const double TY_SPECTRE_OCT_DEFAULT_VALUE = -95.23;
 
typedef std::vector<double> OTabFreq;
 
#define CHECK_FORM_AND_GET_CONCRETE_INSTANCE                                                                 \
                                                                                                             \
    if (this->getForm() != spectre.getForm())                                                                \
    {                                                                                                        \
        throw tympan::invalid_data("Spectrums must be same form") << tympan_source_loc;                      \
    }                                                                                                        \
    OSpectreAbstract* sp = getConcreteInstance();                                                            \
    OSpectreAbstract& s = *sp;
 
class OSpectreAbstract
{
public:
    explicit OSpectreAbstract();
    explicit OSpectreAbstract(TYSpectreForm form);
 
    explicit OSpectreAbstract(bool isValid, TYSpectreType type, TYSpectreEtat etat, TYSpectreForm form);
    virtual OSpectreAbstract& operator=(const OSpectreAbstract& other);
    virtual bool operator==(const OSpectreAbstract& other) const;
    virtual bool operator!=(const OSpectreAbstract& other) const;
 
    OSpectreAbstract& operator+(const double& valeur) const;
 
    OSpectreAbstract& operator+(const OSpectreAbstract& spectre) const;
 
    OSpectreAbstract& operator-(const OSpectreAbstract& spectre) const;
 
    OSpectreAbstract& operator*(const OSpectreAbstract& spectre) const;
    OSpectreAbstract& operator*(const double& coefficient) const;
 
    OSpectreAbstract& sumdB(const OSpectreAbstract& spectre) const;
 
    virtual double* getTabValReel() = 0;
    virtual const double* getTabValReel() const = 0;
 
    virtual OSpectreAbstract* getConcreteInstance() const = 0;
 
    void setDefaultValue(const double& valeur = TY_SPECTRE_DEFAULT_VALUE);
 
    bool isValid() const
    {
        return _valid;
    }
 
    void setValid(const bool& valid = true)
    {
        _valid = valid;
    }
 
    TYSpectreType getType() const
    {
        return _type;
    }
    void setType(TYSpectreType type)
    {
        _type = type;
    }
 
    TYSpectreEtat getEtat() const
    {
        return _etat;
    };
    const TYSpectreEtat getEtat()
    {
        return _etat;
    };
 
    void setEtat(TYSpectreEtat etat)
    {
        _etat = etat;
    }
 
    TYSpectreForm getForm() const
    {
        return _form;
    };
 
    void setForm(TYSpectreForm form)
    {
        _form = form;
    }
 
    unsigned int getNbValues() const;
 
    void setDefaultValue(double module[], const unsigned int spectreNbElmt = TY_SPECTRE_DEFAULT_NB_ELMT,
                         const double& valeur = TY_SPECTRE_DEFAULT_VALUE);
 
    void getRangeValueReal(double* valeurs, const short& nbVal, const short& decalage);
 
    OSpectreAbstract& sum(const OSpectreAbstract& spectre) const;
 
    OSpectreAbstract& sum(const double& value) const;
 
    OSpectreAbstract& mult(const OSpectreAbstract& spectre) const;
 
    OSpectreAbstract& mult(const double& coefficient) const;
 
    OSpectreAbstract& div(const OSpectreAbstract& spectre) const;
 
    OSpectreAbstract& div(const double& coefficient) const;
 
    OSpectreAbstract& subst(const OSpectreAbstract& spectre) const;
 
    OSpectreAbstract& subst(const double& valeur) const;
 
    OSpectreAbstract& invMult(const double& coefficient = 1.0) const;
 
    OSpectreAbstract& inv() const;
 
    OSpectreAbstract& power(const double& puissance) const;
 
    OSpectreAbstract& log(const double& base = 10.0) const;
 
    OSpectreAbstract& racine() const;
 
    OSpectreAbstract& exp(const double coef = 1.0);
 
    OSpectreAbstract& sin() const;
 
    OSpectreAbstract& cos() const;
 
    OSpectreAbstract& abs() const;
 
    OSpectreAbstract& sqrt() const;
 
    double valMax();
 
    OSpectreAbstract& seuillage(const double& min = -200.0, const double max = 200.0);
 
    double sigma();
    const double sigma() const;
 
    OSpectreAbstract& toDB() const;
 
    OSpectreAbstract& toGPhy() const;
 
    double valGlobDBLin() const;
 
    double valGlobDBA() const;
 
    OSpectreAbstract& toTOct() const;
 
    OSpectreAbstract& toOct() const;
 
    OSpectreAbstract& round();
 
    virtual void printme() const;
 
    // === STATIC FUNCTIONS
 
    static OSpectreAbstract& makeOctSpect();
 
    // Members
public:
protected:
    // ==== Static members
    static double _defaultValue;
 
    // ==== Other members
 
    bool _valid;
 
    TYSpectreType _type;
 
    TYSpectreEtat _etat;
 
    TYSpectreForm _form;
};
 
class OSpectre : public OSpectreAbstract
{
    // Methods
public:
    OSpectre();
    OSpectre(double defaultValue);
    OSpectre(const OSpectre& other);
    OSpectre(const OSpectreAbstract& other);
 
    OSpectre(const double* valeurs, unsigned nbVal, unsigned decalage);
    virtual ~OSpectre();
    OSpectre& operator=(const OSpectre& other);
    OSpectreAbstract& operator=(const OSpectreAbstract& other) override;
    virtual bool operator==(const OSpectre& other) const;
    virtual bool operator!=(const OSpectre& other) const;
 
    double* getTabValReel() override
    {
        return _module;
    }
    const double* getTabValReel() const override
    {
        return _module;
    }
 
    OSpectreAbstract* getConcreteInstance() const override;
 
    void setValue(const double& freq, const double& reel = 0.0);
 
    double getValueReal(double freq);
 
    bool isTonalite() const;
 
    // === STATIC FUNCTIONS
 
    static OSpectre getEmptyLinSpectre(const double& valInit = 1.0E-20);
 
    static OSpectre makeOctSpect();
 
    static int getIndice(const double& freq)
    {
        return _mapFreqIndice[freq];
    }
 
    static void setFMin(const double& fMin)
    {
        _fMin = fMin;
    }
    static void setFMax(const double& fMax)
    {
        _fMax = fMax;
    }
 
    static OTabFreq getTabFreqExact(); // XXX These are the frequencies to use in solver
 
    static OSpectre getOSpectreFreqExact();
 
    static std::map<double, int> setMapFreqIndice();
 
    static OSpectre pondA();
 
    static OSpectre pondB();
 
    static OSpectre pondC();
 
    static OSpectre getLambda(const double& c);
 
    // Members
public:
protected:
    // ==== Static members
    // CAUTION Check how those static members behave in shared libraries
 
    static const double _freqNorm[];
 
    static double _fMin;
 
    static double _fMax;
 
    static std::map<double, int> _mapFreqIndice;
 
    double _module[TY_SPECTRE_DEFAULT_NB_ELMT];
};
 
::std::ostream& operator<<(::std::ostream& os, const OSpectre& s);
 
typedef std::vector<OSpectre> OTabSpectre;                
typedef std::vector<std::vector<OSpectre>> OTab2DSpectre; 
 
class OSpectreComplex : public OSpectre
{
    // Methods
public:
    OSpectreComplex();
    OSpectreComplex(const TYComplex& defaultValue);
    OSpectreComplex(const OSpectreComplex& other);
    OSpectreComplex(const OSpectre& other);
    OSpectreComplex(const OSpectre& spectre1, const OSpectre& spectre2);
 
    virtual ~OSpectreComplex();
    OSpectreComplex& operator=(const OSpectreComplex& other);
    OSpectreAbstract& operator=(const OSpectreAbstract& other) override;
 
    bool operator==(const OSpectreComplex& other) const;
    bool operator!=(const OSpectreComplex& other) const;
    OSpectreComplex operator+(const OSpectreComplex& spectre) const;
    OSpectreComplex operator*(const OSpectreComplex& spectre) const;
    OSpectreComplex operator*(const OSpectre& spectre) const;
    OSpectreComplex operator*(const double& coefficient) const;
    OSpectreComplex operator/(const OSpectreComplex& spectre) const;
 
    double* getTabValImag()
    {
        return _phase;
    }
    const double* getTabValImag() const
    {
        return _phase;
    }
 
    void setValue(const double& freq, const double& reel, const double& imag = 0.0);
    void setValue(const double& freq, const TYComplex& cplx);
    double getValueImag(double freq, bool* pValid = 0);
    void setPhase(const OSpectre& spectre);
    void setPhase(const double& valeur = 0.0);
    OSpectre getPhase() const;
    OSpectre getModule() const;
 
    OSpectreComplex toModulePhase() const;
 
    // === STATIC FUNCTIONS
 
    static OSpectreComplex getCplxSpectre(const double& valInit = 1.0E-20);
    // Members
public:
protected:
    double _phase[TY_SPECTRE_DEFAULT_NB_ELMT];
};
 
typedef std::vector<OSpectreComplex> OTabSpectreComplex;                
typedef std::vector<std::vector<OSpectreComplex>> OTab2DSpectreComplex; 
 
class OSpectreOctave : public OSpectreAbstract
{
    // Methods
public:
    OSpectreOctave();
    OSpectreOctave(bool isValid, TYSpectreType type, TYSpectreEtat etat);
    OSpectreOctave(double defaultValue);
    OSpectreOctave(const double* valeurs, unsigned nbVal, unsigned decalage);
    OSpectreOctave(const OSpectreOctave& other);
    OSpectreOctave(const OSpectreAbstract& other);
 
    OSpectreOctave(const OSpectre& other);
 
    virtual ~OSpectreOctave();
 
    OSpectreOctave& operator=(const OSpectreOctave& other);
    OSpectreAbstract& operator=(const OSpectreAbstract& other) override;
    bool operator==(const OSpectreOctave& other) const;
    bool operator!=(const OSpectreOctave& other) const;
 
    double* getTabValReel() override
    {
        return _module;
    }
 
    const double* getTabValReel() const override
    {
        return _module;
    }
 
    OSpectreAbstract* getConcreteInstance() const override;
 
    void setValue(const double& freq, const double& reel = 0.0);
 
    // === STATIC FUNCTIONS
 
    static OSpectreOctave getEmptyLinSpectre(const double& valInit = 1.0E-20);
 
    static OTabFreq getTabFreqExact(); // XXX These are the frequencies to use in solver
 
    static OSpectreOctave pondA();
 
    static OSpectreOctave getLambda(const double& c);
 
    static std::map<double, int> setMapFreqIndice();
 
    // Members
public:
protected:
    // ==== Static members
    static std::map<double, int> _mapFreqIndice;
 
    static const double _freqNorm[TY_SPECTRE_OCT_NB_ELMT];
 
    static const double _AWeighting[TY_SPECTRE_OCT_NB_ELMT];
 
    // ==== Other members
 
    double _module[TY_SPECTRE_OCT_NB_ELMT];
};
 
#endif // TY_MC_SPECTRE