Simulation.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 SIMULATION_H
#define SIMULATION_H
 
#include "Base.h"
#include "Geometry/Scene.h"
#include "Acoustic/Solver.h"
#include "Acoustic/Source.h"
#include "Acoustic/Recepteur.h"
#include "Acoustic/Material.h"
#include "Tools/Logger.h"
#include "AcousticRaytracerConfiguration.h"
#include "DefaultEngine.h"
#include "ParallelDefaultEngine.h"
 
enum engineChoice
{
    DEFAULT = 0,
    PARALLELDEFAULT,
    GPU
};
 
class Simulation : public Base
{
 
public:
    Simulation() : solver(NULL), materialManager(NULL), engine(NULL), engineC(DEFAULT)
    {
        compteurSource = 0;
        compteurRecepteur = 0;
        configuration = AcousticRaytracerConfiguration::get();
    }
    Simulation(const Simulation& other)
    {
        solver = new Solver(other.solver);
        engine = NULL;
        engineC = other.engineC;
        compteurSource = other.compteurSource;
        compteurRecepteur = other.compteurRecepteur;
        materialManager = new MaterialManager(*(other.materialManager));
        *configuration = *other.configuration;
    }
    virtual ~Simulation() {}
 
    Scene* getScene()
    {
        return &scene;
    }
 
#ifdef TEST_ACCELERATION_RECEPTORS
    Scene* get_receptors_landscape()
    {
        return &receptors_landscape;
    }
#endif
 
    void setSolver(Solver* _solver)
    {
        solver = _solver;
    }
 
    Solver* getSolver()
    {
        return solver;
    }
 
    Engine* getEngine()
    {
        return engine;
    }
 
    void clean();
 
    bool launchSimulation();
 
    void addSource(const Source& s)
    {
        sources.push_back(s);
        sources.back().setId(compteurSource);
        compteurSource++;
    }
    std::vector<Source>& getSources()
    {
        return sources;
    }
 
    void addRecepteur(Recepteur& r)
    {
        recepteurs.push_back(r);
        recepteurs.back().setId(compteurRecepteur);
#ifdef TEST_ACCELERATION_RECEPTORS
        Recepteur* rcpt = new Recepteur(r);
        rcpt->setId(compteurRecepteur);
        receptors_landscape.addShape(rcpt);
#endif
        compteurRecepteur++;
    }
    std::vector<Recepteur>& getRecepteurs()
    {
        return recepteurs;
    }
 
    void setMaterialManager(MaterialManager* _materialManager)
    {
        materialManager = _materialManager;
    }
    MaterialManager* getMaterialManager()
    {
        return materialManager;
    }
 
    void setEngine(engineChoice engine = DEFAULT)
    {
        engineC = engine;
    }
 
    AcousticRaytracerConfiguration* getConfiguration()
    {
        return configuration;
    }
 
    //    void runBenchmark() { engine = new DefaultEngine(&scene, &sources, solver, &recepteurs);
    //    engine->runStructureBenchmark(); }
 
protected:
    Scene scene; 
#ifdef TEST_ACCELERATION_RECEPTORS
    Scene receptors_landscape; 
#endif
 
    Solver* solver;                   
    MaterialManager* materialManager; 
 
    std::vector<Source> sources;       
    std::vector<Recepteur> recepteurs; 
 
    Engine* engine;       
    engineChoice engineC; 
 
    unsigned int compteurSource;    
    unsigned int compteurRecepteur; 
 
    AcousticRaytracerConfiguration* configuration; 
};
#endif