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 <source_location>
#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) WossException(err_type, __FILE__, __LINE__, __FUNCTION__, info)
 
  #define WOSS_EXCEPTION(err_type) 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& 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_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 */