acoustic_problem_model.cpp

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/>.
 */
 
#include <iostream>
#include <iomanip>
 
#include "Tympan/models/common/cgal_tools.h"
#include "Tympan/models/common/triangle.h"
#include "acoustic_problem_model.hpp"
 
// using namespace std;
 
namespace tympan
{
 
std::deque<triangle_idx> scene_volume_intersection(const triangle_pool_t& triangle_soup,
                                                   const nodes_pool_t& nodes, float w, float h,
                                                   OPoint3D source, OPoint3D receptor)
{
    CGAL_Point3 _source = to_cgal(source);
    CGAL_Point3 _receptor = to_cgal(receptor);
    std::deque<CGAL_Point3> vertices = build_box(w, h, _source, _receptor);
    // we just want to apply rotation on mesh triangles and no translation --> center the box system
    // on (0, 0, 0)
    CGAL_Vector3 vx = normalize(CGAL_Vector3(vertices[0], vertices[1]));
    CGAL_Vector3 vy = normalize(CGAL_Vector3(vertices[0], vertices[2]));
    CGAL_Vector3 vz = normalize(CGAL_Vector3(vertices[0], vertices[3]));
    CGAL_Transform3 to_box_system(vx.x(), vx.y(), vx.z(), vy.x(), vy.y(), vy.z(), vz.x(), vz.y(), vz.z());
    // Move triangles from the triangle soup of the scene to the volume reference systeme and
    // build CGAL triangles out of them
    std::deque<CGAL_Point3> cgal_nodes;
    for (nodes_pool_t::const_iterator it = nodes.begin(); it != nodes.end(); it++)
    {
        cgal_nodes.push_back(CGAL_Point3(it->_x, it->_y, it->_z).transform(to_box_system));
    }
    CGAL_Triangles cgal_triangles;
    for (triangle_pool_t::const_iterator it = triangle_soup.begin(); it != triangle_soup.end(); it++)
    {
        cgal_triangles.push_back(
            CGAL_Triangle(cgal_nodes[it->n[0]], cgal_nodes[it->n[1]], cgal_nodes[it->n[2]]));
    }
    float l = (float)sqrt(CGAL_Vector3(_source, _receptor).squared_length());
    // these 3 points delimit the bounds of the fresnel box (in other terms, the bounding
    // box of this triangle should have the dimensions of the fresnel box). This will be checked
    // anyway by intersected_triangles() thanks to the expected dimensions passed: l, w and h
    std::deque<CGAL_Point3> box_triangle;
    box_triangle.push_back(vertices[1].transform(to_box_system));
    box_triangle.push_back(vertices[2].transform(to_box_system));
    box_triangle.push_back(vertices[3].transform(to_box_system));
    return intersected_triangles(cgal_triangles, box_triangle, l, w, h);
}
 
node_idx AcousticProblemModel::make_node(const Point& p)
{
    all_nodes.push_back(p);
    return all_nodes.size() - 1;
}
 
AcousticTriangle::AcousticTriangle(node_idx n1, node_idx n2, node_idx n3)
{
    n[0] = n1;
    n[1] = n2;
    n[2] = n3;
}
 
triangle_idx AcousticProblemModel::make_triangle(node_idx n1, node_idx n2, node_idx n3)
{
    all_triangles.push_back(AcousticTriangle(n1, n2, n3));
    return all_triangles.size() - 1;
}
 
material_ptr_t AcousticProblemModel::make_material(const string& name, double resistivity, double deviation,
                                                   double length, double factor_g)
{
    material_ptr_t p_mat = nullptr;
    shared_ptr<AcousticGroundMaterial> ptr = nullptr;
    bool found = false;
    // Search if an instance of AcousticGroundMaterial with same name and characteristics is already pushed
    for (auto iter = all_materials.begin(); iter != all_materials.end(); ++iter)
    {
        ptr = tympan::dynamic_pointer_cast<AcousticGroundMaterial>(*iter);
        // If it is not an AcousticGroundMaterial, continue
        if (ptr == nullptr)
            continue;
        if (ptr->compare(name, resistivity, deviation, length, factor_g))
        {
            found = true;
            break;
        }
    }
    if (found)
    {
        p_mat = ptr;
    }
    else
    {
        // If no equivalent AcousticGroundMaterial is found, then create it and push it
        p_mat = tympan::static_pointer_cast<AcousticMaterialBase>(
            tympan::make_shared<AcousticGroundMaterial>(name, resistivity, deviation, length, factor_g));
        all_materials.push_back(p_mat);
    }
    return p_mat;
}
 
material_ptr_t AcousticProblemModel::make_material(const string& name, const ComplexSpectrum& spectrum)
{
    material_ptr_t p_mat = tympan::static_pointer_cast<AcousticMaterialBase>(
        tympan::make_shared<AcousticBuildingMaterial>(name, spectrum));
    all_materials.push_back(p_mat);
    return p_mat;
}
 
boost::shared_ptr<AcousticFaceGeomData> AcousticProblemModel::makeFaceGeomData(double a, double h,
                                                                               const OVector3D& n)
{
    boost::shared_ptr<AcousticFaceGeomData> pFaceGeomData = boost::make_shared<AcousticFaceGeomData>();
    pFaceGeomData->a = a;
    pFaceGeomData->h = h;
    pFaceGeomData->n = n;
    return pFaceGeomData;
}
 
source_idx AcousticProblemModel::make_source(const Point& point, const Spectrum& spectrum,
                                             SourceDirectivityInterface* directivity)
{
 
    all_sources.push_back(AcousticSource(point, spectrum, directivity));
    return all_sources.size() - 1;
}
 
receptor_idx AcousticProblemModel::make_receptor(const Point& position_)
{
    all_receptors.push_back(AcousticReceptor(position_));
    return all_receptors.size() - 1;
}
 
std::unique_ptr<AcousticProblemModel> make_AcousticProblemModel()
{
    return std::unique_ptr<AcousticProblemModel>(new AcousticProblemModel());
}
 
} // namespace tympan