TYProjet.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_PROJET__
#define __TY_PROJET__
 
#include "TYCalcul.h"
#include "Tympan/models/business/infrastructure/TYSiteNode.h"
#include "TYPointControl.h"
 
#include <iostream>
#include <vector>
// using namespace std;
 
class TYProjet : public TYElement
{
    OPROTODECL(TYProjet)
    TY_EXTENSION_DECL_ONLY(TYProjet)
    TY_EXT_GRAPHIC_DECL_ONLY(TYProjet)
 
    // Methodes
public:
    TYProjet();
 
    TYProjet(const TYProjet& other);
 
    virtual ~TYProjet();
 
    TYProjet& operator=(const TYProjet& other);
 
    bool operator==(const TYProjet& other) const;
 
    bool operator!=(const TYProjet& other) const;
 
    virtual std::string toString() const;
 
    virtual DOM_Element toXML(DOM_Element& domElement);
 
    virtual int fromXML(DOM_Element domElement);
 
    QString getAuteur() const
    {
        return _auteur;
    }
 
    void setAuteur(const 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;
    }
 
    LPTYSiteNode getSite()
    {
        return _pSite;
    }
 
    const LPTYSiteNode getSite() const
    {
        return _pSite;
    }
 
    void setSite(const LPTYSiteNode pSite);
 
    TYTabLPPointControl& getPointsControl()
    {
        return _pointsControl;
    }
    const TYTabLPPointControl& getPointsControl() const
    {
        return _pointsControl;
    }
    void setPointsControl(const TYTabLPPointControl& pointsControl)
    {
        _pointsControl = pointsControl;
        setIsGeometryModified(true);
    }
    bool addPointControl(LPTYPointControl pPointControl);
    bool remPointControl(LPTYPointControl pPointControl);
 
    LPTYPointControl duplicatePointControl(const LPTYPointControl& pPoint);
 
    LPTYPointControl getPointControl(int index)
    {
        return _pointsControl[index];
    }
    bool remAllPointControl();
 
    bool updateAltiRecepteurs();
 
    bool updateAltiRecepteurs(const TYAltimetrie* pAlti);
 
    bool updateAltiPointControle(TYPointControl* pPtControl, const TYAltimetrie* pAlti);
 
    // ++++ DEBUT MAILLAGES ++++
 
    TYTabMaillageGeoNode& getMaillages()
    {
        return _maillages;
    }
 
    const TYTabMaillageGeoNode& getMaillages() const
    {
        return _maillages;
    }
 
    void updateCalculsWithMaillage(TYMaillage* pMaillage);
 
    bool addMaillage(LPTYMaillageGeoNode pMaillageGeoNode);
    bool addMaillage(LPTYMaillage pMaillage);
 
    bool remMaillage(const LPTYMaillageGeoNode pMaillageGeoNode);
 
    bool remMaillage(const LPTYMaillage pMaillage);
 
    bool remMaillage(QString idMaillage);
 
    bool remAllMaillage();
 
    LPTYMaillage getMaillage(int index)
    {
        return TYMaillage::safeDownCast(_maillages.at(index)->getElement());
    }
 
    LPTYMaillageGeoNode findMaillage(const LPTYMaillage pMaillage);
 
    bool updateAltiMaillage(TYMaillageGeoNode* pMaillageGeoNode, const TYAltimetrie* pAlti);
 
    bool updateAltiMaillage(TYMaillageGeoNode* pMaillageGeoNode); // Remis pour compatibilite
 
    void selectActivePoint(const LPTYSiteNode pSite);
 
    virtual void updateGraphic();
 
protected:
    void updateGraphicMaillage();
 
    // ++++ FIN MAILLAGES ++++
 
public:
    TYTabLPCalcul& getListCalcul()
    {
        return _listCalcul;
    }
 
    const TYTabLPCalcul& getListCalcul() const
    {
        return _listCalcul;
    }
 
    void setListCalcul(const TYTabLPCalcul& list)
    {
        _listCalcul = list;
        setIsGeometryModified(true);
    }
 
    bool addCalcul(LPTYCalcul pCalcul);
 
    bool remCalcul(const LPTYCalcul pCalcul);
 
    bool remCalcul(QString idCalcul);
 
    void remAllCalcul();
 
    void unsetSite();
 
    LPTYCalcul getCurrentCalcul()
    {
        return _pCurrentCalcul;
    }
 
    const LPTYCalcul getCurrentCalcul() const
    {
        return _pCurrentCalcul;
    }
 
    void setCurrentCalcul(LPTYCalcul pCurCalcul);
 
    LPTYCalcul duplicateCalcul(const LPTYCalcul pCalcul);
 
    void duplicatePtCalcState(const TYCalcul* pCalculRef, TYCalcul* pCalculNew);
 
    void duplicateNoiseMapState(const TYCalcul* pCalculRef, TYCalcul* pCalculNew);
 
    void remElmtFromCalculs(TYElement* pElement);
 
    void remTabElmtFromCalculs(std::vector<LPTYGeometryNode> tabGeoNode);
 
    void setDelaunayTolerence(const double& val)
    {
        _delaunayTolerance = val;
    }
    double getDelaunayTolerence()
    {
        return _delaunayTolerance;
    }
    const double getDelaunayTolerence() const
    {
        return _delaunayTolerance;
    }
 
    void setDMax(const double& val);
    double getDMax()
    {
        return _maxDistBetweenPoints;
    }
    const double getDMax() const
    {
        return _maxDistBetweenPoints;
    }
 
    void setUseDefGeomVal(const bool& bVal)
    {
        _useDefaultGeomVal = bVal;
        verifGeometricParam();
    }
    bool getUseDefGeomVal()
    {
        return _useDefaultGeomVal;
    }
    const bool getUseDefGeomVal() const
    {
        return _useDefaultGeomVal;
    }
 
    void verifGeometricParam();
 
    void forceUseDefault();
 
    const double getDefaultDelaunayTolerence() const;
 
    const double getDefaultDMax() const;
 
    bool getStatusSolver()
    {
        return _bStatusSolver;
    }
    const bool getStatusSolver() const
    {
        return _bStatusSolver;
    }
    void setStatusSolver(const bool& bStatus)
    {
        _bStatusSolver = bStatus;
    }
 
    void cleanReceptorsStatus(TYCalcul* pCalcul);
 
    const bool displaySpectrumInOctaveForm();
 
    TYSpectreForm getSpectreForm() const
    {
        return _spectreForm;
    }
    void setSpectreForm(TYSpectreForm f)
    {
        _spectreForm = f;
    }
 
    QString getSpectrePond() const
    {
        return _spectrePond;
    }
    void setSpectrePond(QString& p)
    {
        _spectrePond = p;
    }
 
public:
    // CLM-NT33 : Sauvegarde sans resultats
    static bool gSaveValues;
 
    // Membres
protected:
    QString _auteur;
    QString _dateCreation;
    QString _dateModif;
    QString _comment;
 
    LPTYSiteNode _pSite;
 
    TYTabLPCalcul _listCalcul;
 
    TYTabLPPointControl _pointsControl;
 
    TYTabMaillageGeoNode _maillages;
 
    LPTYCalcul _pCurrentCalcul;
 
    double _delaunayTolerance;
    double _maxDistBetweenPoints;
    bool _useDefaultGeomVal;
 
    // Statut de disponibilite du solveur du calcul courant
    bool _bStatusSolver;
 
    // Default spectre form used for displaying spectrum for this project
    TYSpectreForm _spectreForm;
    // Default spectre weighting used for displaying spectrum for this project
    QString _spectrePond;
};
 
#endif // __TY_PROJET__