TYSolver.cpp

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.
 */
 
#include "Tympan/core/logging.h"
#include "Tympan/models/common/spectrum_matrix.h"
#include "Tympan/models/solver/config.h"
#include "Tympan/solvers/DefaultSolver/threading.h"
#include "Tympan/solvers/DefaultSolver/TYTrajet.h"
#include "Tympan/models/common/mathlib.h"
#include "Tympan/geometric_methods/AcousticRaytracer/Geometry/Triangle.h"
#include "Tympan/geometric_methods/AcousticRaytracer/Geometry/Scene.h"
#include "Tympan/geometric_methods/AcousticRaytracer/Acoustic/Material.h"
#include "TYSolver.h"
#include "TYAcousticModel.h"
#include "TYAcousticPathFinder.h"
#include "TYFaceSelector.h"
#include "TYTask.h"
 
TYSolver::TYSolver()
{
    // Creation du face selector
    _faceSelector = make_face_selector();
 
    // Creation du path finder
    _acousticPathFinder = make_path_finder();
 
    // Creation du acoustic model
    _acousticModel = make_acoustic_model();
 
    _tabPolygon.clear();
 
    _scene = std::unique_ptr<Scene>(new Scene());
 
    // Creation de la collection de thread
    _pool = NULL;
}
 
TYSolver::~TYSolver()
{
    if (_pool)
    {
        delete _pool;
    }
    _pool = NULL;
 
    if (_tabTrajets.size() > 0)
    {
        _tabTrajets.clear();
    }
}
 
bool TYSolver::solve(const tympan::AcousticProblemModel& aproblem, tympan::AcousticResultModel& aresult,
                     tympan::LPSolverConfiguration configuration)
{
    int nbTrajectsForOneSource = 0;
    int nbTrajectsTotal = 0;
    tympan::SolverConfiguration::set(configuration);
    // Use grid accelerating structure instead of KDTree (default value)
    OMessageManager::get()->warning(
        "Overwriting Acccelerator solver parameter to 1 (grid accelerating structure)");
    tympan::SolverConfiguration::get()->Accelerator = 1;
    // Creation de la collection de thread
    _pool = new OThreadPool(tympan::SolverConfiguration::get()->NbThreads);
 
    // Creation du face selector
    if (!_faceSelector)
    {
        _faceSelector = make_face_selector();
    }
 
    // Creation du path finder
    if (!_acousticPathFinder)
    {
        _acousticPathFinder = make_path_finder();
    }
 
    // Creation du acoustic model
    if (!_acousticModel)
    {
        _acousticModel = make_acoustic_model();
    }
 
    // On calcule la structure
    if (buildCalcStruct(aproblem))
    {
        appendTriangleToScene();
    }
    else
    {
        return false;
    }
 
    // Initialisation du path finder
    _acousticPathFinder->init();
 
    // Initialisation du acoustic model
    _acousticModel->init();
 
    tympan::SpectrumMatrix& matrix = aresult.get_data();
    matrix.resize(aproblem.nreceptors(), aproblem.nsources());
    tab_acoustic_path& tabRays = aresult.get_path_data();
    tabRays.clear();
 
    // construction trajets et ajout des taches associees
    for (unsigned int i = 0; i < aproblem.nsources(); i++)
    {
        // On reset la thread pool
        _pool->begin(static_cast<unsigned int>(aproblem.nreceptors()));
        // reset deque and liberate memory
        _tabTrajets.clear();
        nbTrajectsForOneSource = 0;
 
        for (unsigned int j = 0; j < aproblem.nreceptors(); j++)
        {
            TYTrajet* trajet = new TYTrajet(const_cast<tympan::AcousticProblemModel&>(aproblem).source(i),
                                            const_cast<tympan::AcousticProblemModel&>(aproblem).receptor(j));
            trajet->asrc_idx = i;
            trajet->arcpt_idx = j;
            _tabTrajets.push_back(trajet);
 
            _pool->push(new TYTask(*this, aproblem.nodes(), aproblem.triangles(), aproblem.materials(),
                                   *_tabTrajets.at(nbTrajectsForOneSource), nbTrajectsTotal + 1));
            nbTrajectsTotal++;
            nbTrajectsForOneSource++;
        }
 
        // launch threads
        _pool->startPool();
 
        if (!_pool->end())
        {
            return false;
        }
 
        // Displaying rays in the GUI
        bool keepRays = tympan::SolverConfiguration::get()->KeepRays;
        if (keepRays == true)
        {
            for (unsigned int i = 0; i < _tabTrajets.size(); i++)
            {
                for (size_t j = 0; j < _tabTrajets.at(i)->get_tab_rays().size(); j++)
                {
                    tabRays.push_back(_tabTrajets.at(i)->get_tab_rays()[j]);
                }
            }
        }
 
        for (int i = 0; i < nbTrajectsForOneSource; i++)
        {
            tympan::source_idx sidx = _tabTrajets.at(i)->asrc_idx;
            tympan::receptor_idx ridx = _tabTrajets.at(i)->arcpt_idx;
 
            matrix(ridx, sidx) = _tabTrajets.at(i)->getSpectre();
        }
 
        for (unsigned int cnt = 0; cnt < _tabTrajets.size(); cnt++)
        {
            delete _tabTrajets.at(cnt);
        }
    }
 
    return true;
}
 
std::unique_ptr<TYFaceSelector> TYSolver::make_face_selector()
{
    return std::unique_ptr<TYFaceSelector>(new TYFaceSelector(*this));
}
 
std::unique_ptr<TYAcousticPathFinder> TYSolver::make_path_finder()
{
    return std::unique_ptr<TYAcousticPathFinder>(new TYAcousticPathFinder(*this));
}
 
std::unique_ptr<TYAcousticModel> TYSolver::make_acoustic_model()
{
    return std::unique_ptr<TYAcousticModel>(new TYAcousticModel(*this));
}
 
bool TYSolver::buildCalcStruct(const tympan::AcousticProblemModel& aproblem)
{
    _tabPolygon.clear();
    const tympan::nodes_pool_t& nodes = aproblem.nodes();
    const tympan::triangle_pool_t& triangles = aproblem.triangles();
 
    _tabPolygon.reserve(triangles.size());
 
    OPoint3D pts[3];
    for (unsigned int i = 0; i < triangles.size(); i++)
    {
        pts[0] = nodes[triangles[i].n[0]];
        pts[1] = nodes[triangles[i].n[1]];
        pts[2] = nodes[triangles[i].n[2]];
 
        TYStructSurfIntersect SI;
        OGeometrie::computeNormal(pts, 3, SI.normal);
 
        SI.volume_id = triangles[i].volume_id;
        SI.tabPoint.push_back(pts[0]);
        SI.tabPoint.push_back(pts[1]);
        SI.tabPoint.push_back(pts[2]);
        SI.material = triangles[i].made_of.get();
 
        _tabPolygon.push_back(SI);
    }
 
    return true;
}
 
bool TYSolver::appendTriangleToScene()
{
    if (_tabPolygon.empty())
    {
        return false;
    }
 
    _scene->clean();
 
    Material* m = new Material(); // Only for compatibility, may be suppressed;
 
    vec3 pos;
 
    for (unsigned int i = 0; i < _tabPolygon.size(); i++)
    {
        // Recuperation et convertion de la normale de la surface
 
        unsigned int a, b, c;
 
        pos = OPoint3Dtovec3(_tabPolygon[i].tabPoint[0]);
        _scene->addVertex(pos, a);
 
        pos = OPoint3Dtovec3(_tabPolygon[i].tabPoint[1]);
        _scene->addVertex(pos, b);
 
        pos = OPoint3Dtovec3(_tabPolygon[i].tabPoint[2]);
        _scene->addVertex(pos, c);
 
        if (dynamic_cast<tympan::AcousticGroundMaterial*>(_tabPolygon[i].material))
        {
            // Set last parameter true means triangle is part of the ground
            (Triangle*)_scene->addTriangle(a, b, c, m, true);
        }
        else
        {
            (Triangle*)_scene->addTriangle(a, b, c, m);
        }
    }
 
    _scene->finish(); // Build accelerating structure
 
    return true;
}