sim_fdm_simulator_iso.hpp

/* sim_fdm_simulator_iso.hpp */
/* $Id$ */
#ifndef __sim_fdm_simulator_iso_hpp
#define __sim_fdm_simulator_iso_hpp

#include <vector>
#include <s2proc/sim_service.hpp>
#include <s2proc/sim_fdm_source.hpp>
#include <s2proc/sim_fdm_snapshot.hpp>
#include <s2proc/sim_fdm_scheme_iso_it.hpp>

class WaveField;

namespace sim
{
  class VmParamsIso;
  template <typename T> class VelModel;
  
  namespace fdm
  {
    class SimulatorIso
    {
    public:

      SimulatorIso();
      
      virtual ~SimulatorIso() {/* nothing to do. */}
      
      sim::ErrCode init(const Snapshot::Area &snapshot_area,
            const VelModel<sim::VmParamsIso> &vm);
      
      
      sim::ErrCode init(const Snapshot::Area &snapshot_area,
            const VelModel<sim::VmParamsIso> &vm,
            const Source &source);
      
      void addSource(const Source &source);
      
      void clearSources();
      
      sim::ErrCode operator()(const TimeT &dt, WaveField &wf) const;
      
      void setExecutionFlag(const bool flag);
      
      
      virtual void snapshotCallback(const TimeT &t,
                    const TimeT &tmax,
                    const Snapshot &snapshot) const;
      
    protected:
      
      Snapshot::Area m_snapshot_area;    
      std::vector<Source> m_sources_vec; 
      GridIso m_grid;                    
      bool m_execution_flag;             
      void time_grid_step(Snapshot &fp, Snapshot &f, const Snapshot &fn) const; 
      
      void modelling(SchemeIsoIt &scheme_it) const;
      
      AmplT interpol_ampl(const TimeT &t1, const AmplT &a1,
              const TimeT &t2, const AmplT &a2,
              const TimeT &t) const;
      
    private:
      
      CoordT m_max_vel;        
      CoordT m_min_coord_step; 
    };
    
  }; // finite differences modeling namespace
  
}; // simulation namespace

#endif /* sim_fdm_simulator_iso.hpp */