acoustic_path.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_MC_ACOUSTIC_PATH
#define TY_MC_ACOUSTIC_PATH
 
#include "Tympan/models/common/3d.h"
 
enum ACOUSTIC_EVENT_TYPES
{
    TY_NO_TYPE = 0,
    TYDIFFRACTION = 1,
    TYREFLEXION = 2,
    TYREFLEXIONSOL = 4,
    TYREFRACTION = 8,
    TYSOURCE = 16,
    TYRECEPTEUR = 32,
    TY_ALL_TYPE = TYDIFFRACTION | TYREFLEXION | TYREFLEXIONSOL | TYREFRACTION | TYSOURCE | TYRECEPTEUR
};
 
class Event;
 
class acoustic_event
{
public:
    acoustic_event();
    acoustic_event(const OPoint3D& pt);
    acoustic_event(const acoustic_event& ev);
    ~acoustic_event();
 
    acoustic_event& operator=(const acoustic_event& other);
 
    OPoint3D pos;              
    double distNextEvent;      
    double distEndEvent;       
    double distPrevNext;       
    double angle;              
    double angletheta;         
    ACOUSTIC_EVENT_TYPES type; 
    int idFace1;               
    int idFace2;               
    acoustic_event* previous;  
    acoustic_event* next;      
    acoustic_event* endEvent;  
};
 
typedef std::vector<acoustic_event*> tab_acoustic_events;
 
class Ray;
class IGeometryModifier;
 
class acoustic_path
{
public:
    acoustic_path();
    virtual ~acoustic_path();
 
    acoustic_path(unsigned int source_idx, unsigned int receptor_idx, tab_acoustic_events& _events);
 
    acoustic_path(const acoustic_path& ray);
 
    virtual void cleanEventsTab();
 
    virtual acoustic_path& operator=(const acoustic_path& other);
 
    virtual bool deepCopy(acoustic_path* pOther);
 
    virtual void setSource(unsigned int source_idx_, OPoint3D& globalPosition);
 
    virtual void setSource(unsigned int source_idx_)
    {
        source_idx = source_idx_;
    }
 
    virtual unsigned int getSource_idx()
    {
        return source_idx;
    }
 
    virtual void setRecepteur(unsigned int receptor_idx_, OPoint3D& globalPosition);
 
    virtual void setRecepteur(unsigned int receptor_idx_)
    {
        receptor_idx = receptor_idx_;
    }
 
    virtual unsigned int getRecepteur_idx()
    {
        return receptor_idx;
    }
 
    virtual void setIdentifiant(unsigned int id)
    {
        _identifiant = id;
    }
 
    virtual unsigned int getIdentifiant() const
    {
        return _identifiant;
    }
 
    virtual void addEvent(acoustic_event* TYEvent)
    {
        _events.push_back(TYEvent);
    }
 
    virtual tab_acoustic_events& getEvents()
    {
        return _events;
    }
    virtual const tab_acoustic_events& getEvents() const
    {
        return _events;
    }
 
    virtual void setEvents(tab_acoustic_events& tabEvents)
    {
        _events = tabEvents;
    }
 
    virtual std::vector<int> getIndexOfEvents(const int& eventType) const;
 
    virtual size_t getNbEventType(const ACOUSTIC_EVENT_TYPES& eventType)
    {
        return getIndexOfEvents(eventType).size();
    }
 
    virtual void copyEvents(const acoustic_path* tyRay, ACOUSTIC_EVENT_TYPES eventType);
 
    virtual void setNextDistance(ACOUSTIC_EVENT_TYPES eventType);
 
    virtual void setAngles(ACOUSTIC_EVENT_TYPES eventType);
 
    virtual double getLength();
 
    virtual size_t getnbEvents()
    {
        return _events.size();
    }
 
    virtual void setPosSourceGlobal(const OPoint3D& pos)
    {
        _posSourceGlobal = pos;
    }
 
    virtual OPoint3D& getPosSourceGlobal()
    {
        return _posSourceGlobal;
    }
 
    virtual void setPosReceptGlobal(const OPoint3D& pos)
    {
        _posReceptGlobal = pos;
    }
 
    virtual OPoint3D& getPosReceptGlobal()
    {
        return _posReceptGlobal;
    }
 
    static void set_sampler_step(double sampler_step_)
    {
        sampler_step = sampler_step_;
    }
 
    void build_links_between_events();
 
    void compute_shot_angle();
 
protected:
    static double sampler_step; 
    unsigned int _identifiant;  
    unsigned int source_idx;    
    unsigned int receptor_idx;  
    OPoint3D _posSourceGlobal;  
    OPoint3D _posReceptGlobal;  
 
    tab_acoustic_events
        _events; 
};
 
typedef std::vector<acoustic_path*> tab_acoustic_path;
 
#endif // TY_MC_ACOUSTIC_PATH