TYCalcul.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program 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 2 of the License, or
 * (at your option) any later version.
 * This program 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 this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
/*
 *
 */
 
/* ==============================================================================
    TO DO :
            1. Save _geomPrecision in XML
    ============================================================================= */
 
#ifndef __TY_CALCUL__
#define __TY_CALCUL__
 
#include <memory>
 
#include "Tympan/models/business/infrastructure/TYSiteNode.h"
#include "Tympan/models/business/TYRay.h"
#include "Tympan/models/business/TYMaillage.h"
#include "Tympan/models/business/TYPointControl.h"
#include "Tympan/models/business/TYResultat.h"
 
class TYProjet;
 
class TYCalcul : public TYElement
{
    OPROTODECL(TYCalcul)
    TY_EXTENSION_DECL_ONLY(TYCalcul)
    TY_EXT_GRAPHIC_DECL_ONLY(TYCalcul)
 
public:
    enum CalculState
    {
        Locked, 
        Actif,  
    };
 
    TYCalcul();
 
    // * \brief build a calcul giving his parent.
    // *  Constructor of the TYCalcul class.
    // *  \param LPTYProjet  pParent=Nulle
    // */
    // TYCalcul(LPTYProjet pParent);
 
    TYCalcul(const TYCalcul& other);
 
    virtual ~TYCalcul();
 
    TYCalcul& operator=(const TYCalcul& other);
    bool operator==(const TYCalcul& other) const;
    bool operator!=(const TYCalcul& other) const;
 
    virtual bool deepCopy(const TYElement* pOther, bool copyId = true, bool pUseCopyTag = false);
 
    virtual std::string toString() const;
 
    virtual DOM_Element toXML(DOM_Element& domElement);
    virtual int fromXML(DOM_Element domElement);
 
    bool getPtCtrlStatus(const TYUUID& id_pt);
 
    void setPtCtrlStatus(const TYUUID& id_pt, bool bStatus);
 
    void purge();
 
    void clearResult();
 
    TYProjet* getProjet();
 
    int getNumero() const
    {
        return _numero;
    }
 
    void setNumero(int num)
    {
        _numero = num;
    }
 
    QString getAuteur() const
    {
        return _auteur;
    }
 
    void setAuteur(QString auteur)
    {
        _auteur = auteur;
    }
 
    QString getDateCreation() const
    {
        return _dateCreation;
    }
    void setDateCreation(const QString& date)
    {
        _dateCreation = date;
    }
 
    QString getDateModif() const
    {
        return _dateModif;
    }
 
    void setDateModif(const QString& date)
    {
        _dateModif = date;
    }
 
    QString getComment() const
    {
        return _comment;
    }
 
    void setComment(const QString& comment)
    {
        _comment = comment;
    }
 
    bool getIsUpTodate() const
    {
        return _upTodate;
    }
 
    void setIsUpTodate(bool upTodate)
    {
        _upTodate = upTodate;
    }
 
    TYListID getElementSelection() const
    {
        return _elementSelection;
    }
 
    bool addToSelection(TYUUID id);
    void addToSelection(TYElement* pElt, bool recursif = true);
 
    bool remToSelection(TYUUID id);
    bool remToSelection(TYElement* pElt, bool recursif = true);
 
    bool isInSelection(TYUUID id);
 
    bool isInSelection(LPTYElement pElt)
    {
        assert(pElt);
        return isInSelection(pElt->getID().toString());
    }
 
    TYMapPtrElementBool& getEmitAcVolNode()
    {
        return _emitAcVolNode;
    }
    const TYMapPtrElementBool& getEmitAcVolNode() const
    {
        return _emitAcVolNode;
    }
 
    TYMapPtrElementInt& getMapElementRegime()
    {
        return _mapElementRegime;
    }
 
    const TYMapPtrElementInt& getMapElementRegime() const
    {
        return _mapElementRegime;
    }
 
    bool addPtCtrlToResult(LPTYPointControl pPoint);
 
    bool remPtCtrlFromResult(LPTYPointControl pPoint);
 
    LPTYSpectre getSpectre(const TYUUID& id_pt);
    LPTYSpectre getSpectre(const TYPointControl* pPoint);
 
    void setSpectre(const TYUUID& id_pt, TYSpectre* pSpectre);
    void setSpectre(TYPointCalcul* pPoint, TYSpectre* pSpectre);
 
    const LPTYResultat getResultat() const
    {
        return _pResultat;
    }
 
    LPTYResultat getResultat()
    {
        return _pResultat;
    }
 
    void getCalculElements(LPTYSiteNode pSite);
 
    void setSite(LPTYSiteNode pSite);
 
    LPTYSiteNode getSite();
 
    void setState(int state)
    {
        _state = state;
    }
 
    int getState()
    {
        return _state;
    }
 
    const int getState() const
    {
        return _state;
    }
 
    bool getStatusPartialResult() const
    {
        return _pResultat->getPartialState();
    }
 
    void setStatusPartialResult(const bool& status)
    {
        _pResultat->setPartialState(status);
    }
 
    void setSolverId(const OGenID& iD)
    {
        _solverId = iD;
    }
 
    const OGenID getSolverId() const
    {
        return _solverId;
    }
 
    OGenID getSolverId()
    {
        return _solverId;
    }
 
    void goPostprocessing();
    // Solver parameters for this computation
    QString solverParams;
 
    TYTabRay& getTabRays()
    {
        return _tabRays;
    }
 
    std::vector<LPTYSpectre>* getSpectrumDatas(const TYUUID& id);
 
    std::vector<LPTYSpectre>* getSpectrumDatas(TYMaillage* pMaillage);
 
    bool addMaillage(TYMaillage* pMaillage);
 
    bool remMaillage(TYMaillage* pMaillage);
 
    bool updateMaillage(TYMaillage* pMaillage);
 
    void setNoiseMapSpectrums(const TYMaillage* pMaillage, TYTabLPSpectre& tabSpectrum);
 
    void setNoiseMapSpectrums(const TYUUID& id, TYTabLPSpectre& tabSpectrum);
 
    TYMapIdSpectre getMapPointCtrlSpectre();
 
    bool hasResuCtrlPoints()
    {
        return _hasResuCtrlPnts;
    }
 
private:
    void clearCtrlPointsSpectrums();
    void clearNoiseMapsSpectrums();
    void copyNoiseMapSpectrums(TYMapIdTabSpectre& otherNoiseMap);
 
    // Members
protected:
    // solver to be used to solve this "calcul"
    OGenID _solverId;
 
    int _numero;
    QString _auteur;
    QString _dateCreation;
    QString _dateModif;
    QString _comment;
 
    bool _upTodate;
    int _state;
 
    LPTYSiteNode _pSiteCalcul;
 
    TYListID _elementSelection;
 
    TYMapPtrElementBool _emitAcVolNode;
 
    TYMapPtrElementInt _mapElementRegime;
 
    // Map control point with spectrum
    TYMapIdSpectre _mapPointCtrlSpectre;
 
    // Map NoiseMap Id with spectrum list
    TYMapIdTabSpectre _noiseMapsSpectrums;
 
    LPTYResultat _pResultat;
 
    // Valid rays produced by ray tracing
    TYTabRay _tabRays;
 
    // Indicator used for migrating T310 project
    // True if ResuCtrlPnts exists in xml project else false
    bool _hasResuCtrlPnts;
};
 
#endif // __TY_CALCUL__