Ray.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 RAY_H
#define RAY_H
 
#include <memory>
#include <boost/shared_ptr.hpp>
 
#include "Base.h"
#include "Geometry/mathlib.h"
#include "Acoustic/Source.h"
#include "Acoustic/Event.h"
#include "Acoustic/Diffraction.h"
 
// using namespace std;
 
typedef std::pair<bitSet, bitSet> signature;
class Ray : public Base
{
 
public:
    Ray()
        : Base(), position(), direction(), mint(0), maxt(100000), source(NULL), recepteur(NULL),
          nbReflexion(0), nbDiffraction(0), cumulDistance(0.), cumulDelta(0.)
    {
        name = "unknow ray";
    }
 
    Ray(const vec3& _position, const vec3& _direction)
        : Base(), position(_position), direction(_direction), mint(0), maxt(100000), source(NULL),
          recepteur(NULL), nbReflexion(0), nbDiffraction(0), cumulDistance(0.), cumulDelta(0.)
    {
        name = "unknow ray";
        this->direction.normalize();
    }
    Ray(const Ray& other) : Base(other)
    {
        position = vec3(other.position);
        direction = vec3(other.direction);
        mint = other.mint;
        maxt = other.maxt;
        source = other.source;
        recepteur = other.recepteur;
        constructId = other.constructId;
        for (unsigned int i = 0; i < other.events.size(); i++)
        {
            events.push_back(other.events.at(i));
        }
 
        nbDiffraction = other.nbDiffraction;
        nbReflexion = other.nbReflexion;
        cumulDistance = other.cumulDistance;
        cumulDelta = other.cumulDelta;
    }
 
    Ray(Ray* other)
    {
        position = vec3(other->position);
        direction = vec3(other->direction);
        mint = other->mint;
        maxt = other->maxt;
        source = other->source;
        recepteur = other->recepteur;
        constructId = other->constructId;
        for (unsigned int i = 0; i < other->events.size(); i++)
        {
            events.push_back(other->events.at(i));
        }
 
        nbDiffraction = other->nbDiffraction;
        nbReflexion = other->nbReflexion;
        cumulDistance = other->cumulDistance;
        cumulDelta = other->cumulDelta;
    }
    virtual ~Ray() {}
 
    decimal computeEventsSequenceLength();
 
    void computeLongueur();
 
    decimal computeTrueLength(const vec3& ref, const vec3& lastPos, vec3& closestPoint);
 
    decimal computePertinentLength(const vec3& ref, const vec3& lastPos, vec3& closestPoint);
 
    Base* getLastPertinentEventOrSource(typeevent evType = DIFFRACTION);
 
    inline vec3 computeLocalOrigin(Base* ev)
    {
        if (dynamic_cast<Source*>(ev))
        {
            // if ev is the source
            return dynamic_cast<Source*>(ev)->getPosition();
        }
        else
        {
            // if ev is a standard event
            return dynamic_cast<Event*>(ev)->getPosition();
        }
    }
 
    double getLongueur() const
    {
        return longueur;
    }
 
    unsigned int getDiff() const
    {
        return nbDiffraction;
    }
 
    unsigned int getReflex() const
    {
        return nbReflexion;
    }
 
    unsigned int getNbEvents() const
    {
        return nbDiffraction + nbReflexion;
    }
 
    std::vector<boost::shared_ptr<Event>>* getEvents()
    {
        return &events;
    }
 
    const std::vector<boost::shared_ptr<Event>>* getEvents() const
    {
        return &events;
    }
 
    std::vector<unsigned int> getFaceHistory();
 
    std::vector<unsigned int> getPrimitiveHistory();
 
    Source* getSource()
    {
        return source;
    }
 
    void* getRecepteur()
    {
        return recepteur;
    }
 
    signature getSignature(const typeevent& typeEv = SPECULARREFLEXION);
 
    decimal getThickness(const decimal& distance, bool diffraction);
 
    decimal getSolidAngle(bool& diffraction);
 
    inline bitSet getSRBitSet(const unsigned int& source_id, const unsigned int& receptor_id)
    {
        // The source id is stored in 12 bits, receptor is stored in 20 bits
        assert((source_id < 4096) && (receptor_id < 1048576));
        bitSet SR = source_id;
        SR = SR << 20;
        return SR += receptor_id;
    }
 
    bitSet getEventsBitSet(const typeevent& typeEv);
 
    decimal getCumulDelta() const
    {
        return cumulDelta;
    }
 
    decimal getCumulDistance() const
    {
        return cumulDistance;
    }
 
    unsigned long long int getConstructId() const
    {
        return constructId;
    }
 
    decimal getMint() const
    {
        return mint;
    }
 
    decimal getMaxt() const
    {
        return maxt;
    }
 
    vec3 getFinalPosition() const
    {
        return finalPosition;
    }
 
    vec3 getDirection() const
    {
        return direction;
    }
 
    vec3 getPosition() const
    {
        return position;
    }
 
    void setPosition(vec3 _position)
    {
        position = _position;
    }
 
    void setDirection(vec3 _direction)
    {
        direction = _direction;
        direction.normalize();
    }
 
    void setFinalPosition(vec3 _finalPosition)
    {
        finalPosition = _finalPosition;
    }
 
    void setMint(decimal _mint)
    {
        mint = _mint;
    }
 
    void setMaxt(decimal _maxt)
    {
        maxt = _maxt;
    }
 
    void setSource(Source* _source)
    {
        source = _source;
    }
 
    void setRecepteur(void* _recepteur)
    {
        recepteur = _recepteur;
    }
 
    void setLongueur(decimal _longueur)
    {
        longueur = _longueur;
    }
 
    void setConstructId(unsigned long long int _constructId)
    {
        constructId = _constructId;
    }
 
    void setNbReflexion(unsigned int _nbReflexion)
    {
        nbReflexion = _nbReflexion;
    }
 
    void setNbDiffraction(unsigned int _nbDiffraction)
    {
        nbDiffraction = _nbDiffraction;
    }
 
    void setCumulDistance(decimal _cumulDistance)
    {
        cumulDistance = _cumulDistance;
    }
 
    void setCumulDelta(decimal _cumulDelta)
    {
        cumulDelta = _cumulDelta;
    }
 
    void addEvent(boost::shared_ptr<Event> _event)
    {
        events.push_back(_event);
    }
 
    std::vector<unsigned int> getEventSignature();
 
protected:
    vec3 position;      
    vec3 direction;     
    vec3 finalPosition; 
    decimal mint;
    decimal maxt;
    Source* source;                               
    void* recepteur;                              
    decimal longueur;                             
    unsigned long long int constructId;           
    unsigned int nbReflexion;                     
    unsigned int nbDiffraction;                   
    decimal cumulDistance;                        
    decimal cumulDelta;                           
    std::vector<boost::shared_ptr<Event>> events; 
};
 
#endif