bellhop-woss.h

Go to the documentation of this file.

/* WOSS - World Ocean Simulation System -
 * 
 * Copyright (C) 2009 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_BELLHOP_H
#define WOSS_BELLHOP_H
 
 
#include <iomanip>
#include <memory>
#include <map>
#include <definitions.h>
#include <coordinates-definitions.h>
#include <sediment-definitions.h>
#include <transducer-definitions.h>
#include <ssp-definitions.h>
#include "ac-toolbox-arr-asc-reader.h"
#include "ac-toolbox-arr-bin-reader.h"
#include "ac-toolbox-shd-reader.h"
#include "ac-toolbox-woss.h"
 
 
namespace woss {
 
  using NormSSPMap = std::map< double, std::unique_ptr<SSP> >;
  using NSMIter = NormSSPMap::iterator;
  using NSMCIter = NormSSPMap::const_iterator;
  using NSMRIter = NormSSPMap::reverse_iterator;
  using NSMCRIter = NormSSPMap::const_reverse_iterator;
 
  /*
   * .arr file syntax to be used during parsing
   */
  enum class BellhopArrSyntax {
    BELLHOP_CREATOR_ARR_FILE_SYNTAX_0 = 0, 
    BELLHOP_CREATOR_ARR_FILE_SYNTAX_1, 
    BELLHOP_CREATOR_ARR_FILE_SYNTAX_2, 
    BELLHOP_CREATOR_ARR_FILE_INVALID 
  };
 
  /*
   * .shd file syntax to be used during parsing
   */
  enum class BellhopShdSyntax {
    BELLHOP_CREATOR_SHD_FILE_SYNTAX_0 = 0,
    BELLHOP_CREATOR_SHD_FILE_SYNTAX_1,
    BELLHOP_CREATOR_SHD_FILE_INVALID 
  };
 
  class BellhopWoss : public ACToolboxWoss { 
 
    public:
 
    static constexpr inline const char* WOSS_BELLHOP_BIN_NAME = "bellhop.exe"; 
    static constexpr inline const char* WOSS_BELLHOPCXX_BIN_NAME = "bellhopcxx"; 
    static constexpr inline const char* WOSS_BELLHOPCUDA_BIN_PATH = "bellhopcuda"; 
    BellhopWoss();
 
    BellhopWoss(const CoordZ& tx, const CoordZ& rx, const Time& start_t, const Time& end_t, double start_freq, double end_freq, double freq_step ) ;
 
    BellhopWoss(const BellhopWoss& copy) = default;
 
    BellhopWoss(BellhopWoss&& tmp) = default;
 
    virtual ~BellhopWoss() override = default;
 
    BellhopWoss& operator=(const BellhopWoss& copy) = default;
 
    BellhopWoss& operator=(BellhopWoss&& tmp) = default;
 
    virtual bool initialize() override;
 
    virtual bool initPressResReader( double curr_frequency );
 
    virtual bool initTimeArrResReader( double curr_frequency ); 
 
    virtual bool run() override;
 
    virtual bool timeEvolve( const Time& time_value ) override;
 
    virtual bool isValid() const override;
 
    virtual std::unique_ptr<Pressure> getAvgPressure( double frequency, double tx_depth, double start_rx_depth = WOSS_MIN_DEPTH, double start_rx_range = WOSS_MIN_RANGE, double end_rx_depth = WOSS_MAX_DEPTH , double end_rx_range = WOSS_MAX_RANGE ) const;
 
    virtual std::unique_ptr<Pressure> getPressure( double frequency, double tx_depth, double rx_depth, double rx_range ) const;
 
    virtual std::unique_ptr<TimeArr> getTimeArr( double frequency, double tx_depth, double rx_depth, double rx_range ) const;
 
    BellhopWoss& setThorpeAttFlag( bool flag ) { use_thorpe_att = flag; return *this; }
 
    BellhopWoss& setTxMinDepthOffset( double offset ) { tx_min_depth_offset = offset; return *this; }
 
    BellhopWoss& setTxMaxDepthOffset( double offset ) { tx_max_depth_offset = offset; return *this; }
 
    BellhopWoss& setTotalTransmitters( int sources ) { total_transmitters = sources; return *this; }
 
    BellhopWoss& setRxMinDepthOffset( double offset ) { rx_min_depth_offset = offset; return *this; }
 
    BellhopWoss& setRxMaxDepthOffset( double offset ) { rx_max_depth_offset = offset; return *this; }
    
    BellhopWoss& setRxMinRangeOffset( double offset ) { rx_min_range_offset = offset; return *this; }
    
    BellhopWoss& setRxMaxRangeOffset( double offset ) { rx_max_range_offset = offset; return *this; }
 
    BellhopWoss& setRxTotalDepths( int number ) { total_rx_depths = number; return *this; }
 
    BellhopWoss& setRxTotalRanges( int number ) { total_rx_ranges = number; return *this; }
 
    BellhopWoss& setRaysNumber( int number ) { total_rays = number; return *this; }
 
    BellhopWoss& setMinAngle( double angle ) { min_angle = angle; return *this; }
 
    BellhopWoss& setMaxAngle( double angle ) { max_angle = angle; return *this; }
 
    BellhopWoss& setBoxDepth( double depth ) { box_depth = depth; return *this; }
 
    BellhopWoss& setBoxRange( double range ) { box_range = range; return *this; }
 
    BellhopWoss& setBellhopPath( const std::string& path ) { bellhop_path = path; return *this; }
 
    BellhopWoss& setBellhopBinName( const std::string& name ) { bellhop_bin_name = name; return *this; }
 
    BellhopWoss& setBellhopArrSyntax( BellhopArrSyntax syntax ) { bellhop_arr_syntax = syntax; return *this; }
    
    BellhopWoss& setBellhopShdSyntax( BellhopShdSyntax syntax ) { bellhop_shd_syntax = syntax; return *this; }
    
    BellhopWoss& setBeamOptions( const std::string& options ) { beam_options = options; return *this; }
 
    BellhopWoss& setBhMode( const std::string& mode );
 
    BellhopWoss& setBathymetryType( const std::string& type ) { bathymetry_type = type; return *this; }
 
    BellhopWoss& setBathymetryMethod( const std::string& type ) { bathymetry_method = type; return *this; }
 
    BellhopWoss& setAltimetryType( const std::string& type ) { altimetry_type = type; return *this; }
 
    BellhopWoss& setTransducer( std::unique_ptr<Transducer> ptr ) { transducer = std::move(ptr); return *this; }
 
    BellhopWoss& setTransformSSPDepthSteps( int depth_steps ) { transform_ssp_depth_steps = depth_steps; return *this; }
 
    BellhopWoss& setBeamPatternParam( double init_bearing, double vert_rot = 0.0, double horiz_rot = 0.0, double mult = 1.0, double add = 0.0 ) {
      bp_initial_bearing = init_bearing; bp_vertical_rotation = vert_rot; bp_horizontal_rotation = horiz_rot;
      bp_mult_costant = mult; bp_add_costant = add; return *this; }
 
    bool getThorpeAttFlag() const { return use_thorpe_att; }
 
    double getTxMinDepthOffset() const { return tx_min_depth_offset; }
 
    double getTxMaxDepthOffset() const { return tx_max_depth_offset; }
 
    int getTotalTransmitters() const { return total_transmitters; }
 
    double getRxMinDepthOffset() const { return rx_min_depth_offset; }
 
    double getRxMaxDepthOffset() const { return rx_max_depth_offset; }
 
    double getRxMinRangeOffset() const { return rx_min_range_offset; }
 
    double getRxMaxRangeOffset() const { return rx_max_range_offset; }
 
    int getRxTotalDepths() const { return total_rx_depths; }
 
    int getRxTotalRanges() const { return total_rx_ranges; }
 
    int getRaysNumber() const { return total_rays; }
 
    double getMinAngle() const { return min_angle; }
 
    double getMaxAngle() const { return max_angle; }
 
    double getBoxDepth() const { return box_depth; }
    
    double getBoxRange() const { return box_range; }
 
    int getTransformSSPDepthSteps() const  { return transform_ssp_depth_steps; }
 
    std::string getBellhopPath() const { return bellhop_path; }
 
    std::string getBellhopBinName() const { return bellhop_bin_name; }
 
    BellhopArrSyntax getBellhopArrSyntax() const { return bellhop_arr_syntax; }
 
    BellhopShdSyntax getBellhopShdSyntax() const { return bellhop_shd_syntax; }
 
    std::string getBeamOptions() const { return beam_options; }
 
    std::string getBathymetryType() const { return bathymetry_type; }
 
    std::string getBathymetryMethod() const { return bathymetry_method; }
 
    std::string getAltimetryType() const { return altimetry_type; }
 
    std::unique_ptr<Transducer> getTransducer() const { return transducer->clone(); }
 
    bool isValidBhMode( const std::string& ) const ;
 
    bool usingPressMode() const { return using_press_mode; }
 
    bool usingTimeArrMode() const { return using_time_arrival_mode; }
 
    bool usingSSPFile() const { return using_ssp_file; }
 
    protected:
 
    bool use_thorpe_att;
    
    std::string beam_options;
    
    std::string bathymetry_type;
 
    std::string bathymetry_method;
 
    std::string altimetry_type;    
    
    std::string bellhop_op_mode;
 
    std::string bellhop_env_file;
 
    std::string bathymetry_file;
    
    std::string altimetry_file;
    
    std::string beam_pattern_file;
 
    std::string ssp_file;
 
    std::string shd_file;
 
    std::string arr_file;
 
    std::string bellhop_path;
 
    std::string bellhop_bin_name;
    
    BellhopArrSyntax bellhop_arr_syntax;
 
    BellhopShdSyntax bellhop_shd_syntax;
 
    std::string curr_path;
    
    std::string transducer_type;
 
    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;
 
    int total_rays;
 
    double min_angle;
 
    double max_angle;
 
    double min_normalized_ssp_depth;
 
    double max_normalized_ssp_depth;
 
    int curr_norm_ssp_depth_steps;
 
    int transform_ssp_depth_steps;
 
    std::unique_ptr<Transducer> transducer;
    
    double bp_initial_bearing;
    
    double bp_vertical_rotation;
    
    double bp_horizontal_rotation;
    
    double bp_mult_costant;
    
    double bp_add_costant;
 
    bool using_ssp_file;
 
    bool using_press_mode;
 
    bool using_time_arrival_mode;
 
    NormSSPMap normalized_ssp_map;
 
    NormSSPMap randomized_ssp_map;
 
    double box_depth;
 
    double box_range;
 
    std::ofstream f_out;
 
    virtual void normalizeDbSSP();
 
    virtual void resetNormalizedDbSSP();
 
    bool initResReader( double curr_frequency );
 
    void initBox( double depth, double range );
 
    void initCfgFiles( double curr_frequency, int curr_run );
 
    void writeCfgFiles( double curr_frequency, int curr_run ); 
 
    void writeAllCfgFiles(); 
 
    void writeNormalizedSSP( int curr_run );
 
    void writeSediment();
 
    void writeHeader( double curr_frequency, int curr_run );
 
    void writeTransmitter();
 
    void writeReceiver(); 
 
    void writeRayOptions();
 
    void writeBox();
 
    void writeBeamBlock(); 
 
    void writeBathymetryFile();    
  
    void writeBeamPatternFile(); 
    
    void writeAltimetryFile( int curr_run );
 
    void removeAllCfgFiles();
 
    void removeCfgFiles( double curr_frequency, int curr_run );
 
    void checkBoundaries( double& frequency, double& tx_depth, double& rx_start_depth, double& rx_start_range, double& rx_end_depth, double& rx_end_range ) const;
 
    void checkDepthOffsets();
 
    void checkDepthOffsets( const CoordZ& coords, double& min_offset, double& max_offset, double min_depth_value, double max_depth_value );
 
    void checkAngles();
 
    void checkRangeOffsets();
 
  };
 
  //inline functions
  inline bool BellhopWoss::isValidBhMode( const std::string& mode ) const {
    return (  mode == "a" || mode == "A" || mode == "C" || mode == "I" || mode == "S" );
  }
 
  inline void BellhopWoss::initBox( double depth, double range ) {
    if(box_depth < 0) //box depth not set by user - default to depth + 10%
      box_depth = depth + depth / 10.0;
 
    if(box_range < 0) //box range not set by user - default to range + 10%
      box_range = range + range / 10.0;
  }
 
  inline void BellhopWoss::writeSediment() {
    f_out << "\'A*\' 0.0" << std::setw(30) << "! BOTTOM TYPE" << std::endl
          << max_normalized_ssp_depth << " " << sediment_map.begin()->second->getStringValues() <<  "  /  ! " 
          << sediment_map.begin()->second->getType() << " BOTTOM TYPE " << std::endl;
  }
 
  inline void BellhopWoss::writeHeader( double curr_frequency, int curr_run ) {
    f_out.precision(WOSS_DECIMAL_PRECISION);
    f_out << "\'BELLHOP - woss id = " << woss_id << "; run = " << curr_run 
          << "; tx(" << tx_coordz.getLatitude() << "," << tx_coordz.getLongitude() << "," << tx_coordz.getDepth() << ")"
          << "; rx(" << rx_coordz.getLatitude() << "," << rx_coordz.getLongitude() << "," << rx_coordz.getDepth() << ")"
          << "\'" << std::endl
          << curr_frequency << std::setw(30) << "! FREQUENCY [HZ]" << std::endl
          << 1 << std::setw(30) << "! NMEDIA" << std::endl;
  }
 
  inline void BellhopWoss::writeTransmitter() {
    f_out << total_transmitters << std::setw(30) << "! NUMBER OF SOURCES" << std::endl;
    if (total_transmitters == 1) 
      f_out << tx_coordz.getDepth() + tx_min_depth_offset << "  " << "/" << std::setw(30) << "! SOURCE'S DEPTH" << std::endl;
    else 
      f_out << tx_coordz.getDepth() + tx_min_depth_offset << "  " << tx_coordz.getDepth() + tx_max_depth_offset 
            << "  " << "/" << std::setw(30) << "! SOURCES' DEPTHS" << std::endl;
  }
 
  inline void BellhopWoss::writeReceiver() {
    f_out << total_rx_depths << std::setw(30) << "! NUMBER OF RX DEPTH(S)" << std::endl;
    if (total_rx_depths == 1) 
      f_out << rx_coordz.getDepth() + rx_min_depth_offset << "  " << "/" << std::setw(30) << "! RX'S DEPTH" << std::endl;
    else 
      f_out << rx_coordz.getDepth() + rx_min_depth_offset << "  " << rx_coordz.getDepth() + rx_max_depth_offset << "  " << "/" 
            << std::setw(30) << "! RX'S DEPTHS" << std::endl;
 
    f_out << total_rx_ranges << std::setw(30) << "!NUMBER OF RX RANGE(S)" << std::endl;
    if (total_rx_ranges == 1) 
      f_out << ((total_great_circle_distance + rx_min_range_offset) / 1000.0) << "  " << "/" << std::setw(30) << "! RX'S RANGE" << std::endl;
    else 
      f_out << ((total_great_circle_distance + rx_min_range_offset) / 1000.0) << "  " << ((total_great_circle_distance + rx_max_range_offset)/1000.0) << "  " << "/" 
            << std::setw(30) << "! RX'S RANGES" << std::endl;
  }
 
  inline void BellhopWoss::writeRayOptions() {
    f_out << "\'"<< bellhop_op_mode << beam_options; 
    
    if ( transducer->isValid() ) 
      f_out << "*";   
    
    f_out << "\'" << std::setw(30) << "! RAY OPTIONS" << std::endl 
          << total_rays << std::setw(30) << "! NUMBER OF RAYS" << std::endl
          << min_angle << "  " << max_angle << "  " << "/" << std::setw(30) << "! START, END ANGLES" << std::endl;   
  }
 
  inline void BellhopWoss::writeBox() {
    f_out << "0.0" << " " << box_depth << " " << (box_range/1000.0)  << " ,  "
                   << "! RAY-STEP , BOX DEPTH, BOX RANGE" << std::endl;
  }
 
  inline void BellhopWoss::writeBeamBlock() {  
    f_out << "\'MS\' 1.0 100.0 0," << std::endl << "3 5" << std::endl;
  }
 
}
 
#endif /* WOSS_BELLHOP_H */