TYRoute.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.
 */
 
/*
 *
 *
 *
 *
 */
 
#ifndef __TY_ROUTE__
#define __TY_ROUTE__
 
#include "gtest/gtest_prod.h"
#include "Tympan/models/business/geoacoustic/TYAcousticLine.h"
#include "Tympan/models/business/acoustic/TYTrafic.h"
 
#include "RoadEmissionNMPB08.h"
 
typedef TYGeometryNode TYRouteGeoNode;
typedef SmartPtr<TYRouteGeoNode> LPTYRouteGeoNode;
typedef std::vector<LPTYRouteGeoNode> TYTabRouteGeoNode;
 
class TYRoute : public TYAcousticLine
{
 
    FRIEND_TEST(TestRoads, xml_roundtrip);
 
    OPROTODECL(TYRoute)
    TY_EXTENSION_DECL_ONLY(TYRoute)
    TY_EXT_GRAPHIC_DECL_ONLY(TYRoute)
 
    // Methods
public:
    static const double undefined_declivity;
 
    enum TrafficRegimes
    {
        Day,
        Evening,
        Night,
        NB_TRAFFIC_REGIMES
    };
 
    TYRoute();
    TYRoute(const TYRoute& other);
    virtual ~TYRoute();
 
    TYRoute& operator=(const TYRoute& other);
    bool operator==(const TYRoute& other) const;
    bool operator!=(const TYRoute& 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);
 
    // TODO/WIP The speed is modelised at the RoadTrafficComponent in NMPB08
    double getVitMoy() const
    {
        return getTraficJour().lv.trafficSpeed;
    }
 
    // TODO/WIP The speed is modelised at the RoadTrafficComponent in NMPB08
    void setVitMoy(double vit)
    {
        getTraficJour().lv.trafficSpeed = vit;
        getTraficNuit().hgv.trafficSpeed = vit;
    }
 
    const TYTrafic& getTraficJour() const
    {
        return traffic_regimes[Day];
    }
    TYTrafic& getTraficJour()
    {
        return traffic_regimes[Day];
    }
 
    //  void setTraficJour(const LPTYTrafic pTrafic);
 
    const TYTrafic& getTraficNuit() const
    {
        return traffic_regimes[Night];
    }
    TYTrafic& getTraficNuit()
    {
        return traffic_regimes[Night];
    }
 
    //  void setTraficNuit(const LPTYTrafic pTrafic);
 
    enum RoadType
    {
        Motorway,
        Intercity
    };
    enum RoadFunction
    {
        LongDistance,
        Regional
    };
 
    bool setFromAADT(double aadt_hgv, double aadt_lv, RoadType road_type, RoadFunction road_function,
                     QString* out_msg = NULL);
 
    // TODO in NMPB08 `mode calcul` is obsoleted.
    //      Is now represented by the RoadFlowType at RoadTrafficComponent level.
 
    TYSpectre computeSpectre(enum TrafficRegimes regime);
 
    virtual bool updateAcoustic(const bool& force = false);
 
    virtual bool updateAltitudes(const TYAltimetrie& alti, LPTYRouteGeoNode pGeoNode, OMatrix globalMatrix);
 
    const RoadTrafficComponent& getNMPB08RoadTrafficComponent(enum TrafficRegimes regime,
                                                              enum TYTrafic::VehicleTypes vehic_type) const;
 
    // NB : can not be const qualified because it is required to switch regime
    const RoadTraffic& getNMBP08RoadTraffic(enum TrafficRegimes regime);
 
    RoadSurfaceType surfaceType() const
    {
        return road_traffic.surfaceType;
    };
    double surfaceAge() const
    {
        return road_traffic.surfaceAge;
    };
 
    double ramp() const
    {
        return road_traffic.ramp;
    };
 
    void setSurfaceType(RoadSurfaceType type);
    void setSurfaceAge(double age);
    void setRamp(double ramp);
 
    void setRoadTrafficComponent(enum TrafficRegimes regime, enum TYTrafic::VehicleTypes vehic_type,
                                 double flow, double speed, RoadFlowType type = FlowType_CONST);
 
    bool computed_declivity;
 
    static bool note77_check_validity(double aadt_hgv, double aadt_lv, RoadType road_type,
                                      RoadFunction road_function, QString* out_msg = NULL);
 
private:
    virtual void distriSrcs()
    {
        assert(false && "You must use distriSrcs(const TYAltimetrie&) for roads");
    }
 
    void setRoadTrafficArrayForRegime(enum TrafficRegimes regime);
 
protected:
    RoadTrafficComponent& accessRoadTrafficComponent(enum TrafficRegimes regime,
                                                     enum TYTrafic::VehicleTypes vehic_type);
 
    double calculPenteMoyenne();
 
    static bool is_valid_declivity(double decli);
 
    void updateComputedDeclivity();
 
    virtual void distriSrcs(const TYAltimetrie& alti, LPTYRouteGeoNode pGeoNode, OMatrix globalMatrix);
 
    double getOffSet()
    {
        return _offSet;
    }
    void setOffSet(const double& offSet)
    {
        _offSet = offSet;
    }
 
    // Members
protected:
    RoadTraffic road_traffic;
    TYTrafic traffic_regimes[NB_TRAFFIC_REGIMES];
 
    double _offSet;
 
private:
    class TrafficHalfer
    {
    public:
        TrafficHalfer(TYRoute& road);
        ~TrafficHalfer();
 
    private:
        TYRoute& road;
    };
 
    typedef double note77_tables[2][2][3];
    static const note77_tables note77_lower_bounds;     // table C1
    static const note77_tables note77_upper_bounds;     // table C1
    static const note77_tables note77_hourly_HGV_coeff; // table C2
    static const note77_tables note77_hourly_LV_coeff;  // table C2
};
 
#endif // __TY_ROUTE__