acoustic_problem_model.hpp

Go to the documentation of this file.

 
#ifndef TYMPAN__ACOUSTIC_PROBLEM_MODEL_H__INCLUDED
#define TYMPAN__ACOUSTIC_PROBLEM_MODEL_H__INCLUDED
 
#include <string>
#include <memory>
 
#include "data_model_common.hpp"
#include "entities.hpp"
 
namespace tympan
{
std::deque<triangle_idx> scene_volume_intersection(const triangle_pool_t& triangles,
                                                   const nodes_pool_t& nodes, float l, float h,
                                                   OPoint3D source, OPoint3D receptor); // L
class AcousticProblemModel
{
public:
    AcousticProblemModel(){};          
    virtual ~AcousticProblemModel(){}; 
 
    node_idx make_node(const Point& point);
    node_idx make_node(double x, double y, double z)
    {
        return make_node(Point(x, y, z));
    }
 
    triangle_idx make_triangle(node_idx n1, node_idx n2, node_idx n3);
 
    size_t npoints() const // TODO move to implementation file
    {
        return all_nodes.size();
    } 
 
    size_t ntriangles() const // TODO move to implementation file
    {
        return all_triangles.size();
    } 
 
    size_t nsources() const // TODO move to implementation file
    {
        return all_sources.size();
    } 
 
    size_t nreceptors() const // TODO move to implementation file
    {
        return all_receptors.size();
    } 
 
    AcousticTriangle& triangle(triangle_idx tri_idx)
    {
        return all_triangles.at(tri_idx);
    } 
 
    const AcousticTriangle& triangle(triangle_idx tri_idx) const
    {
        return all_triangles.at(tri_idx);
    } 
 
    Point& node(node_idx idx)
    {
        return all_nodes.at(idx);
    } 
 
    const Point& node(node_idx idx) const
    {
        return all_nodes.at(idx);
    } 
 
    AcousticSource& source(source_idx idx)
    {
        return all_sources.at(idx);
    } 
 
    const AcousticSource& source(source_idx idx) const
    {
        return all_sources.at(idx);
    } 
 
    AcousticReceptor& receptor(receptor_idx idx)
    {
        return all_receptors.at(idx);
    } 
 
    const AcousticReceptor& receptor(receptor_idx idx) const
    {
        return all_receptors.at(idx);
    } 
 
    size_t nmaterials() const // TODO move to implementation file
    {
        return all_materials.size();
    } 
 
    const AcousticMaterialBase& material(size_t mat_idx) const
    {
        return *all_materials.at(mat_idx);
    } 
 
    AcousticMaterialBase& material(size_t mat_idx)
    {
        return *all_materials.at(mat_idx);
    } 
 
    material_ptr_t make_material(const string& name, double resistivity, double deviation, double length,
                                 double factor_g);
 
    material_ptr_t make_material(const string& name, const ComplexSpectrum& spectrum);
 
    source_idx make_source(const Point& point_, const Spectrum& spectrum_,
                           SourceDirectivityInterface* directivity);
 
    receptor_idx make_receptor(const Point& position_);
 
    const nodes_pool_t& nodes() const
    {
        return all_nodes;
    } 
    const triangle_pool_t& triangles() const
    {
        return all_triangles;
    } 
    const material_pool_t& materials() const
    {
        return all_materials;
    } 
    const source_pool_t& sources() const
    {
        return all_sources;
    } 
    const receptor_pool_t& receptors() const
    {
        return all_receptors;
    } 
 
public: // XXX Could / should be protected but this complicates testing
    /*
        // Comparison utilities
        static bool equal_to (const node_idx & lhs, const node_idx & rhs)
        { return *lhs == *rhs; };
        static bool equal_to (const Point& point, const node_idx & pnode)
        { return point == *pnode; }
        static bool equal_to (const node_idx & pnode, const Point& point)
        { return equal_to(point, pnode); };
 
        static bool less_than (const node_idx & lhs, const node_idx & rhs);
        static bool less_than (const Point& lhs, const Point& rhs);
    */
 
protected:                         // data members
    nodes_pool_t all_nodes;        
    triangle_pool_t all_triangles; 
    material_pool_t all_materials; 
    source_pool_t all_sources;     
    receptor_pool_t all_receptors; 
};                                 // class AcousticProblemModel
 
std::unique_ptr<AcousticProblemModel> make_AcousticProblemModel();
 
} // namespace tympan
 
#endif // TYMPAN__ACOUSTIC_PROBLEM_MODEL_H__INCLUDED