woss-test.h

Go to the documentation of this file.

/* WOSS - World Ocean Simulation System -
 * 
 * Copyright (C) 2020 2025 Federico Guerra
 * and regents of the SIGNET lab, University of Padova
 *
 * Author: Federico Guerra - WOSS@guerra-tlc.com
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */ 
 

 
 
#ifndef WOSS_TEST_H 
#define WOSS_TEST_H
 
 
#include <string>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <memory>
#include <ssp-definitions.h>
#include <sediment-definitions.h>
#include <altimetry-definitions.h>
#include <pressure-definitions.h>
#include <time-arrival-definitions.h>
#include <transducer-definitions.h>
#include <transducer-handler.h>
#include <res-pressure-bin-db-creator.h>
#include <res-pressure-txt-db-creator.h>
#include <res-time-arr-bin-db-creator.h>
#include <res-time-arr-txt-db-creator.h>
#if defined (WOSS_NETCDF_SUPPORT)
#include <bathymetry-gebco-db-creator.h>
#include <sediment-deck41-db-creator.h>
#include <ssp-woa2005-db-creator.h>
#endif // defined (WOSS_NETCDF_SUPPORT)
#include <bellhop-creator.h>
#include <woss-manager-simple.h>
#include <woss-controller.h>
 
 
namespace woss {

  enum class WossErrorType {
    WOSS_ERROR_NO_ERROR = 0,
    WOSS_ERROR_OUT_OF_MEMORY, 
    WOSS_ERROR_OUT_OF_RANGE_PARAM, 
    WOSS_ERROR_INVALID_PARAM, 
    WOSS_ERROR_TIMEOUT, 
    WOSS_ERROR_WRONG_STATE, 
    WOSS_ERROR_BAD_FORMAT, 
    WOSS_ERROR_INSUFFICIENT_PERMISSIONS, 
    WOSS_ERROR_IO_ERROR, 
    WOSS_ERROR_OUT_OF_HANDLES, 
    WOSS_ERROR_UNKNOWN,
    WOSS_ERROR_UNEXPECTED_EXCEPTION,
  };
 
  class WossException : public std::exception {
 
    public:

    static constexpr inline int CHAR_ARR_LENGTH = 250;

    WossException(WossErrorType error_type_, const char* file_, int line_, const char* func_, const char* info_);

    WossException(const WossException& copy) = default;

    virtual ~WossException() throw () override = default;

    WossException& operator=(const WossException& copy) = default;

    virtual const char* what() const throw();

    WossErrorType getErrorType() const { return error_type; }

    const char* getFile() const { return file; }

    int getLine() const { return line; }

    const char* getFunc() const { return func; }

    const char* getInfo() const { return info; }

    static void printAndExit(const std::exception* e);
 
 
    protected:

    WossErrorType error_type;

    char file[CHAR_ARR_LENGTH];

    int line;
    char func[CHAR_ARR_LENGTH];
    char info[CHAR_ARR_LENGTH];
    char what_str[4*CHAR_ARR_LENGTH];
 
  };
 
  #define WOSS_EXCEPTION_INFO(err_type, info) throw WossException(err_type, __FILE__, __LINE__, __FUNCTION__, info)
 
  #define WOSS_EXCEPTION(err_type) throw WossException(err_type, __FILE__, __LINE__, __FUNCTION__, "")

  class TestTimeReference: public TimeReference {
 
    public:

    TestTimeReference() 
    : TimeReference(),
      time_reference(0.0) { }
 
    TestTimeReference(const TestTimeReference& copy) = default;
 
    TestTimeReference(TestTimeReference&& tmp) = default;
 
    virtual ~TestTimeReference() override = default;

    virtual std::unique_ptr<TimeReference> clone() const override { return std::make_unique<TestTimeReference>(*this); }

    void setTimeReference(double time) { time_reference = time; }
    virtual double getTimeReference() const { return time_reference; }
 
    private:

    double time_reference;
 
  };

  class WossTest {
 
    public: 

    WossTest();
 
    virtual ~WossTest() = default;

     WossTest(const WossTest& copy) = delete;

     WossTest(WossTest&& tmp) = delete;

     WossTest& operator=(const WossTest& copy) = delete;

     WossTest& operator=(WossTest&& tmp) = delete;

    void run();

    WossTest& setWossTestDebug(bool flag) { debug = flag; return *this; }

    bool getWossTestDebug() const { return debug; }

    WossTest& setWossRandomGenStream(int stream) { woss_random_gen_stream = stream; return *this;}

    int getWossRandomGenStream() const { return woss_random_gen_stream; }

    WossTest& setResDbCreatorDebug(bool flag) { res_db_creator_debug = flag; return *this; }

    bool getResDbCreatorDebug() const { return res_db_creator_debug; }

    WossTest& setResDbDebug(bool flag) { res_db_debug = flag; return *this; }

    bool getResDbDebug() const { return res_db_debug; }

    WossTest& setResDbUseBinary(bool flag) { res_db_use_binary = flag; return *this; }

    bool getResDbUseBinary() const { return res_db_use_binary; }

    WossTest& setResDbUseTimeArr(bool flag) { res_db_use_time_arr = flag; return *this; }

    bool getResDbUseTimeArr() const { return res_db_use_time_arr; }

    WossTest& setResDbUsePressure(bool flag) { res_db_use_pressure = flag; return *this; }

    bool getResDbUsePressure() const { return res_db_use_pressure; }

    WossTest& setResDbSpaceSampling(double sampling) { res_db_space_sampling = sampling; return *this; }

    double getResDbSpaceSampling() const { return res_db_space_sampling; }

    WossTest& setResDbFilePath(const std::string& path) { res_db_file_path = path; return *this; }

    std::string getResDbFilePath() const { return res_db_file_path; }

    WossTest& setResDbFileName(const std::string& file_name) { res_db_file_name = file_name; return *this; }

    std::string getResDbFileName() const { return res_db_file_name; }
 
#if defined (WOSS_NETCDF_SUPPORT)
#if defined (WOSS_NETCDF4_SUPPORT)
    WossTest& setSedimDeck41DbType( DECK41DbType type) { sedim_deck41_db_type = type; return *this; }

    DECK41DbType getSedimDeck41DbType() const { return sedim_deck41_db_type; }
#endif // defined (WOSS_NETCDF4_SUPPORT)

    WossTest& setSedimDbCreatorDebug( bool flag ) { sedim_db_creator_debug = flag; return *this; }

    bool getSedimDbCreatorDebug() const { return sedim_db_creator_debug; }

    WossTest& setSedimDbDebug(bool flag) { sedim_db_debug = flag; return *this; }

    bool getSedimDbDebug() const { return sedim_db_debug; }

    WossTest& setSedimDbCoordFilePath(const std::string& path) { sedim_db_coord_file_path = path; return *this; }

    std::string getSedimDbCoordFilePath() const { return sedim_db_coord_file_path; }

    WossTest& setSedimDbMarsdenFilePath(const std::string& path) { sedim_db_marsden_file_path = path; return *this; }

    std::string getSedimDbMarsdenFilePath() const { return sedim_db_marsden_file_path; }

    WossTest& setSedimDbMarsdenOneFilePath(const std::string& path) { sedim_db_marsden_one_file_path = path; return *this; }

    std::string getSedimDbMarsdenOneFilePath() const { return sedim_db_marsden_one_file_path; }

    WossTest& setSspDbCreatorDebug( bool flag ) { ssp_db_creator_debug = flag; return *this; }

    bool getSspDbCreatorDebug() const { return ssp_db_creator_debug; }

    WossTest& setSspDbDebug( bool flag ) { ssp_db_debug = flag; return *this; }

    bool getSspDbDebug() const { return ssp_db_debug; }

    WossTest& setSspDbFilePath(const std::string& path) { ssp_db_file_path = path; return *this; }

    std::string getSspDbFilePath() const { return ssp_db_file_path; }
 
#if defined (WOSS_NETCDF4_SUPPORT)
    WossTest& setSspWoaDbType( WOADbType type) { ssp_woa_db_type = type; return *this; }

    WOADbType getSspWoaDbType() const { return ssp_woa_db_type; }
#endif // defined (WOSS_NETCDF_SUPPORT)

    WossTest& setBathyDbCreatorDebug( bool flag ) { bathy_db_creator_debug = flag; return *this; }

    bool getBathyDbCreatorDebug() const { return bathy_db_creator_debug; }

    WossTest& setBathyDbDebug( bool flag ) { bathy_db_debug = flag; return *this; }

    bool getBathyDbDebug() const { return bathy_db_debug; }

    WossTest& setBathyDbGebcoFormat(GEBCO_BATHY_TYPE type) { bathy_db_gebco_format = type; return *this; }

    GEBCO_BATHY_TYPE getBathyDbGebcoFormat() const { return bathy_db_gebco_format; }

    WossTest& setBathyDbFilePath(const std::string& path) { bathy_db_file_path = path; return *this; }

    std::string getBathyDbFilePath() const { return bathy_db_file_path; }
#endif // defined (WOSS_NETCDF_SUPPORT)

    WossTest& setWossDbManagerDebug(bool flag) { woss_db_manager_debug = flag; return *this; }

    bool getWossDbManagerDebug() const { return woss_db_manager_debug; }

    WossTest& setWossCreatorDebug(bool flag) { woss_creator_debug = flag; return *this; }

    bool getWossCreatorDebug() const { return woss_creator_debug; }

    WossTest& setWossDebug(bool flag) { woss_debug = flag; return *this; }

    bool getWossDebug() const { return woss_debug; }

    WossTest& setWossClearWorkDir(bool flag) { woss_clear_work_dir = flag; return *this; }

    bool getWossClearWorkDir() const { return woss_clear_work_dir; }

    WossTest& setWossEvolutionTimeQuantum(double time) { evolution_time_quantum = time; return *this; }

    double getWossEvolutionTimeQuantum() const { return evolution_time_quantum; }

    WossTest& setWossTotalRuns(int runs) { total_runs = runs; return *this; }

    int getWossTotalRuns() const { return total_runs; }

    WossTest& setWossFrequencyStep(double step) { frequency_step = step; return *this; }

    double getWossFrequencyStep() const { return frequency_step; }

    WossTest& setWossTotalRangeSteps(double step) { total_range_steps = step; return *this; }

    double getWossTotalRangeSteps() const { return total_range_steps; }

    WossTest& setWossTxMinDepthOffset(double offset) { tx_min_depth_offset = offset; return *this; }

    double getWossTxMinDepthOffset() const { return tx_min_depth_offset; }

    WossTest& setWossTxMaxDepthOffset(double offset) { tx_max_depth_offset = offset; return *this; }

    double getWossTxMaxDepthOffset() const { return tx_max_depth_offset; }

    WossTest& setWossTotalTransmitters(int transmitters) { total_transmitters = transmitters; return *this; }

    int getWossTotalTransmitters() const { return total_transmitters; }

    WossTest& setWossTotalRxDepths(int rx_depths) { total_rx_depths = rx_depths; return *this; }

    int getWossTotalRxDepths() const { return total_rx_depths; }

    WossTest& setWossRxMinDepthOffset(double offset) { rx_min_depth_offset = offset; return *this; }

    double getWossRxMinDepthOffset() const { return rx_min_depth_offset; }

    WossTest& setWossRxMaxDepthOffset(double offset) { rx_max_depth_offset = offset; return *this; }

    double getWossRxMaxDepthOffset() const { return rx_max_depth_offset; }

    WossTest& setWossTotalRxRanges(int rx_ranges) { total_rx_ranges = rx_ranges; return *this; }

    int getWossTotalRxRanges() const { return total_rx_ranges; }

    WossTest& setWossRxMinRangeOffset(double offset) { rx_min_range_offset = offset; return *this; }

    double getWossRxMinRangeOffset() const { return rx_min_range_offset; }

    WossTest& setWossRxMaxRangeOffset(double offset) { rx_max_range_offset = offset; return *this; }

    double getWossRxMaxRangeOffset() const { return rx_max_range_offset; }

    WossTest& setWossTotalRays(double rays) { total_rays = rays; return *this; }

    double getWossTotalRays() const { return total_rays; }

    WossTest& setWossMinAngle(double angle) { min_angle = angle; return *this; }

    double getWossMinAngle() const { return min_angle; }

    WossTest& setWossMaxAngle(double angle) { max_angle = angle; return *this; }

    double getWossMaxAngle() const { return max_angle; }

    WossTest& setWossUseThorpeAtt(bool flag) {use_thorpe_att = flag; return *this; }

    bool getWossUseThorpeAtt() const { return use_thorpe_att; }

    WossTest& setWossSspDepthPrecision(double precision) { ssp_depth_precision = precision; return *this; }

    double getWossSspDepthPrecision() const { return ssp_depth_precision; }

    WossTest& setWossNormalizedSspDepthSteps( double steps ) { normalized_ssp_depth_steps = steps; return *this; }

    double getWossNormalizedSspDepthSteps() const { return normalized_ssp_depth_steps; }

    WossTest& setWossWorkDirPath(const std::string& path) { work_dir_path = path; return *this; }

    std::string getWossWorkDirPath() const { return work_dir_path; }

    WossTest& setWossBellhopPath(const std::string& path) { bellhop_path = path; return *this; }

    std::string getWossBellhopPath() const { return bellhop_path; }

    WossTest& setWossBellhopBinName(const std::string& name) { bellhop_bin_name = name; return *this; }

    std::string getWossBellhopBinName() const { return bellhop_bin_name; }

    WossTest& setWossBellhopMode(const std::string& mode) { bellhop_mode = mode; return *this; }

    std::string getWossBellhopMode() const { return bellhop_mode; }

    WossTest& setWossBellhopBeamOptions(const std::string& options) { bellhop_beam_options = options; return *this; }

    std::string getWossBellhopBeamOptions() const { return bellhop_beam_options; }

    WossTest& setWossBellhopBathyType(const std::string& type) { bellhop_bathy_type = type; return *this; }

    std::string getWossBellhopBathyType() const { return bellhop_bathy_type; }
    
    WossTest& setWossBellhopBathyMethod(const std::string& type) { bellhop_bathy_method = type; return *this; }

    std::string getWossBellhopBathyMethod() const { return bellhop_bathy_method; }

    WossTest& setWossBellhopAltimType(const std::string& type) { bellhop_altim_type = type; return *this; }

    std::string getWossBellhopAltimType() const { return bellhop_altim_type; }

    WossTest& setWossBellhopArraySyntax(BellhopArrSyntax syntax) { bellhop_arr_syntax = syntax; return *this; }

    BellhopArrSyntax getWossBellhopArraySyntax() const { return bellhop_arr_syntax; }

    WossTest& setWossBellhopShdSyntax(BellhopShdSyntax syntax) { bellhop_shd_syntax = syntax; return *this; }

    BellhopShdSyntax getWossBellhopShdSyntax() const { return bellhop_shd_syntax; }

    WossTest& setWossSimTime(const SimTime& time) { sim_time = time; return *this; }

    SimTime getWossSimTime() const { return sim_time; }

    WossTest& setWossBoxDepth(double depth) { box_depth = depth; return *this; }

    double getWossBoxDepth() const { return box_depth; }

    WossTest& setWossBoxRange(double range) { box_range = range; return *this; }

    double getWossBoxRange() const { return box_range; }
 

    WossTest& setWossManagerDebug(bool flag) { woss_manager_debug = flag; return *this; }

    bool getWossManagerDebug() const { return woss_manager_debug; }

    WossTest& setWossManagerTimeEvoActive(bool flag) { time_evolution_active = flag; return *this; }

    bool getWossManagerTimeEvoActive() const { return time_evolution_active; }

    WossTest& setWossManagerThreads(unsigned int threads) { concurrent_threads = threads; return *this; }

    int getWossManagerThreads() const { return concurrent_threads; }

    WossTest& setWossManagerSpaceSampling(double sampling) { woss_manager_space_sampling = sampling; return *this; }

    double getWossManagerSpaceSampling() const { return woss_manager_space_sampling; }

    WossTest& setWossManagerUseMultiThread(bool flag) { woss_manager_use_multithread = flag; return *this; }

    bool getWossManagerUseMultiThread() const { return woss_manager_use_multithread; }

    WossTest& setWossManagerUseThreadPool(bool flag) { woss_manager_use_thread_pool = flag; return *this; }

    bool getWossManagerUseThreadPool() const { return woss_manager_use_thread_pool; }

    WossTest& setWossTransducerHandlerDebug(bool flag) { woss_transducer_handler_debug = flag; return *this; }

    bool getWossTransducerHandlerDebug() const { return woss_transducer_handler_debug; }

    WossTest& setWossControllerDebug(bool flag) { woss_controller_debug = flag; return *this; }

    bool getWossControllerDebug() const { return woss_controller_debug; }
 
    protected:
 
    bool debug; 
 
    std::unique_ptr<SSP> ssp_proto; 
    std::unique_ptr<Sediment> sediment_proto; 
    std::unique_ptr<Pressure> pressure_proto; 
    std::unique_ptr<TimeArr> time_arr_proto; 
    std::unique_ptr<Transducer> transducer_proto; 
    std::unique_ptr<AltimBretschneider> altim_bret_proto; 
    std::unique_ptr<Location> location_proto; 
    int woss_random_gen_stream; 
    std::unique_ptr<RandomGenerator> random_gen_proto; 
    std::unique_ptr<TimeReference> time_ref_proto; 
 
    DefHandler& def_handler; 
 
    bool res_db_creator_debug; 
    bool res_db_debug; 
    bool res_db_use_binary; 
    bool res_db_use_time_arr; 
    bool res_db_use_pressure; 
    double res_db_space_sampling; 
    std::string res_db_file_path; 
    std::string res_db_file_name; 
    std::shared_ptr<ResPressureBinDbCreator> res_db_creator_press_bin; 
    std::shared_ptr<ResPressureTxtDbCreator> res_db_creator_press_txt; 
    std::shared_ptr<ResTimeArrBinDbCreator> res_db_creator_time_arr_bin; 
    std::shared_ptr<ResTimeArrTxtDbCreator> res_db_creator_time_arr_txt; 
 
#if defined (WOSS_NETCDF_SUPPORT)
#if defined (WOSS_NETCDF4_SUPPORT)
    DECK41DbType sedim_deck41_db_type; 
#endif // defined (WOSS_NETCDF4_SUPPORT)
    bool sedim_db_creator_debug; 
    bool sedim_db_debug; 
    std::string sedim_db_coord_file_path; 
    std::string sedim_db_marsden_file_path; 
    std::string sedim_db_marsden_one_file_path; 
    std::shared_ptr<SedimDeck41DbCreator> sedim_db_creator; 
 
    bool ssp_db_creator_debug; 
    bool ssp_db_debug; 
    std::string ssp_db_file_path; 
#if defined (WOSS_NETCDF4_SUPPORT)
    WOADbType ssp_woa_db_type; 
#endif // defined (WOSS_NETCDF_SUPPORT)
    std::shared_ptr<SspWoa2005DbCreator> ssp_db_creator; 
 
    bool bathy_db_creator_debug; 
    bool bathy_db_debug; 
    GEBCO_BATHY_TYPE bathy_db_gebco_format; 
    std::string bathy_db_file_path; 
    std::shared_ptr<BathyGebcoDbCreator> bathy_db_creator; 
#endif // defined (WOSS_NETCDF_SUPPORT)
 
    bool woss_db_manager_debug; 
 
    std::shared_ptr<WossDbManager> woss_db_manager; 
 
    bool woss_creator_debug; 
    bool woss_debug; 
    bool woss_clear_work_dir; 
    double evolution_time_quantum;  
    int total_runs;  
    double frequency_step;  
    double total_range_steps;  
    double tx_min_depth_offset;  
    double tx_max_depth_offset;  
    int total_transmitters;  
    int total_rx_depths;  
    double rx_min_depth_offset;  
    double rx_max_depth_offset;  
    int total_rx_ranges;  
    double rx_min_range_offset;  
    double rx_max_range_offset;  
    double total_rays;  
    double min_angle;  
    double max_angle;  
    bool use_thorpe_att; 
    double ssp_depth_precision;  
    double normalized_ssp_depth_steps;  
    std::string work_dir_path;  
    std::string bellhop_path;  
    std::string bellhop_bin_name;  
    std::string bellhop_mode;  
    std::string bellhop_beam_options;  
    std::string bellhop_bathy_type;  
    std::string bellhop_bathy_method; 
    std::string bellhop_altim_type;  
    BellhopArrSyntax bellhop_arr_syntax; 
    BellhopShdSyntax bellhop_shd_syntax; 
    SimTime sim_time;  
    std::shared_ptr<BellhopCreator> bellhop_creator; 
    double box_depth; 
    double box_range; 
 
    bool woss_manager_debug; 
    bool time_evolution_active; 
    unsigned int concurrent_threads; 
    double woss_manager_space_sampling; 
    bool woss_manager_use_multithread; 
    bool woss_manager_use_thread_pool; 
    std::shared_ptr< WossManagerSimple<WossManagerResDb> > woss_manager_simple; 
    std::shared_ptr< WossManagerSimple<WossManagerResDbMT> > woss_manager_multi; 
 
    bool woss_transducer_handler_debug; 
    std::shared_ptr<TransducerHandler> woss_transducer_handler; 
 
    bool woss_controller_debug; 
    std::shared_ptr<WossController> woss_controller; 
 
    bool initialized; 

    void config();

    void init();

    virtual void doConfig() = 0;

    virtual void doInit() = 0;

    virtual void doRun() = 0;
 
  };
 
}
 
#endif /* WOSS_TEST_H */