bellhop-creator.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_CREATOR_DEFINITIONS_H
#define WOSS_BELLHOP_CREATOR_DEFINITIONS_H
 
 
#include <memory>
#include <ostream>
#include "woss-creator-container.h"
#include "woss-creator.h"
#include "bellhop-woss.h"
 
 
namespace woss {
 
  struct CustomAngles {
 
    CustomAngles( double min = double(), double max = double() ) : min_angle(min), max_angle(max) { }
 
    friend std::ostream& operator<<( std::ostream& os, const CustomAngles& instance ) {
      os << "min angle = " << instance.min_angle << "; max_angle = " << instance.max_angle;
      return os;
    }
 
    double min_angle;
 
    double max_angle;
 
  };
 
  class BellhopCreator : public WossCreator {
 
    public:
 
    BellhopCreator();
    
    virtual ~BellhopCreator() override = default;
 
    virtual std::unique_ptr<Woss> const createWoss( const CoordZ& tx, const CoordZ& rx, double start_frequency, double end_frequency ) const override;
 
    BellhopCreator& setThorpeAttFlag( bool flag ) { use_thorpe_att = flag; return *this; }
 
    bool getThorpeAttFlag() const { return use_thorpe_att; }
 
    BellhopCreator& setTotalRangeSteps( int steps, const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_range_steps.replace(steps, tx, rx); return *this; }
 
    BellhopCreator& setTotalRangeSteps( int steps, const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_range_steps.replace(steps, tx, rx); return *this; }
 
    BellhopCreator& eraseTotalRangeSteps( const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_range_steps.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseTotalRangeSteps( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_range_steps.erase(tx, rx); return *this; }
 
    double getTotalRangeSteps( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctotal_range_steps.get(tx, rx); }
 
    double getTotalRangeSteps( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) const { 
      return cctotal_range_steps.get(tx, rx); }
 
    BellhopCreator& setTxMinDepthOffset( double offset, const CoordZ& tx, const CoordZ& rx ) { 
      cctx_min_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& setTxMinDepthOffset( double offset, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      cctx_min_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& eraseTxMinDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      cctx_min_depth_offset.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseTxMinDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      cctx_min_depth_offset.erase(tx, rx); return *this; }
 
    double getTxMinDepthOffset( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctx_min_depth_offset.get(tx, rx); }
 
    double getTxMinDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const { 
      return cctx_min_depth_offset.get(tx, rx); }
 
    BellhopCreator& setTxMaxDepthOffset( double offset, const CoordZ& tx, const CoordZ& rx ) { 
      cctx_max_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& setTxMaxDepthOffset( double offset, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      cctx_max_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& eraseTxMaxDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      cctx_max_depth_offset.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseTxMaxDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      cctx_max_depth_offset.erase(tx, rx); return *this; }
 
    double getTxMaxDepthOffset( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctx_max_depth_offset.get(tx, rx); }
 
    double getTxMaxDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const { 
      return cctx_max_depth_offset.get(tx, rx); }
 
    BellhopCreator& setTotalTransmitters( int sources, const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_transmitters.replace(sources, tx, rx); return *this; }
 
    BellhopCreator& setTotalTransmitters( int sources, const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_transmitters.replace(sources, tx, rx); return *this; }
 
    BellhopCreator& eraseTotalTransmitters( const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_transmitters.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseTotalTransmitters( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_transmitters.erase(tx, rx); return *this; }
 
    int getTotalTransmitters( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctotal_transmitters.get(tx, rx); }
 
    int getTotalTransmitters( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) const { 
      return cctotal_transmitters.get(tx, rx); }
 
 
    BellhopCreator& setRxMinDepthOffset( double offset, const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_min_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& setRxMinDepthOffset( double offset, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_min_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& eraseRxMinDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_min_depth_offset.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseRxMinDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_min_depth_offset.erase(tx, rx); return *this; }
 
    double getRxMinDepthOffset( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccrx_min_depth_offset.get(tx, rx); }
 
    double getRxMinDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const { 
      return ccrx_min_depth_offset.get(tx, rx); }
 
 
    BellhopCreator& setRxMaxDepthOffset( double offset, const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_max_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& setRxMaxDepthOffset( double offset, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_max_depth_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& eraseRxMaxDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_max_depth_offset.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseRxMaxDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_max_depth_offset.erase(tx, rx); return *this; }
 
    double getRxMaxDepthOffset( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccrx_max_depth_offset.get(tx, rx); }
 
    double getRxMaxDepthOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const { 
      return ccrx_max_depth_offset.get(tx, rx); }
 
    BellhopCreator& setRxMinRangeOffset( double offset, const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_min_range_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& setRxMinRangeOffset( double offset, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_min_range_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& eraseRxMinRangeOffset( const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_min_range_offset.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseRxMinRangeOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_min_range_offset.erase(tx, rx); return *this; }
 
    double getRxMinRangeOffset( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccrx_min_range_offset.get(tx, rx); }
 
    double getRxMinRangeOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const { 
      return ccrx_min_range_offset.get(tx, rx); }       
 
    BellhopCreator& setRxMaxRangeOffset( double offset, const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_max_range_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& setRxMaxRangeOffset( double offset, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_max_range_offset.replace(offset, tx, rx); return *this; }
 
    BellhopCreator& eraseRxMaxRangeOffset( const CoordZ& tx, const CoordZ& rx ) { 
      ccrx_max_range_offset.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseRxMaxRangeOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_max_range_offset.erase(tx, rx); return *this; }
 
    double getRxMaxRangeOffset( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccrx_max_range_offset.get(tx, rx); }
 
    double getRxMaxRangeOffset( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const { 
      return ccrx_max_range_offset.get(tx, rx); }       
 
    BellhopCreator& setRxTotalDepths( int number, const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_rx_depths.replace(number, tx, rx); return *this; }
 
    BellhopCreator& setRxTotalDepths( int number, const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rx_depths.replace(number, tx, rx); return *this; }
 
    BellhopCreator& eraseRxTotalDepths( const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_rx_depths.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseRxTotalDepths( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rx_depths.erase(tx, rx); return *this; }
 
    int getRxTotalDepths( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctotal_rx_depths.get(tx, rx); }
 
    int getRxTotalDepths( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) const { 
      return cctotal_rx_depths.get(tx, rx); }   
 
    BellhopCreator& setRxTotalRanges( int number, const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_rx_ranges.replace(number, tx, rx); return *this; }
 
    BellhopCreator& setRxTotalRanges( int number, const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rx_ranges.replace(number, tx, rx); return *this; }
 
    BellhopCreator& eraseRxTotalRanges( const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_rx_ranges.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseRxTotalRanges( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rx_ranges.erase(tx, rx); return *this; }
 
    int getRxTotalRanges( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctotal_rx_ranges.get(tx, rx); }
 
    int getRxTotalRanges( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) const { 
      return cctotal_rx_ranges.get(tx, rx); }  
 
    BellhopCreator& setRaysNumber( int number, const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_rays.replace(number, tx, rx); return *this; }
 
    BellhopCreator& setRaysNumber( int number, const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rays.replace(number, tx, rx); return *this; }
 
    BellhopCreator& eraseRaysNumber( const CoordZ& tx, const CoordZ& rx ) { 
      cctotal_rays.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseRaysNumber( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rays.erase(tx, rx); return *this; }
 
    int getRaysNumber( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctotal_rays.get(tx, rx); }
 
    int getRaysNumber( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) const { 
      return cctotal_rays.get(tx, rx); }  
 
    BellhopCreator& setBellhopPath( const std::string& path ) { bellhop_path = path; return *this; }
 
    BellhopCreator& setBellhopBinName( const std::string& name ) { bellhop_bin_name = name; return *this; }
 
    std::string getBellhopPath() const { return bellhop_path; }
 
    std::string getBellhopBinName() const { return bellhop_bin_name; }
 
    BellhopCreator& setBellhopArrSyntax( BellhopArrSyntax syntax ) { 
      bellhop_arr_syntax = syntax; return *this; }
 
    BellhopArrSyntax getBellhopArrSyntax() const { return bellhop_arr_syntax; }
 
    BellhopCreator& setBellhopShdSyntax( BellhopShdSyntax syntax ) { 
      bellhop_shd_syntax = syntax; return *this; }
 
    BellhopShdSyntax getBellhopShdSyntax() const { return bellhop_shd_syntax; }
 
    BellhopCreator& setBeamOptions( const std::string& options, const CoordZ& tx, const CoordZ& rx ) { 
      ccbeam_options.replace(options, tx, rx); return *this; }
 
    BellhopCreator& setBeamOptions( const std::string& options, const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbeam_options.replace(options, tx, rx); return *this; }
 
    BellhopCreator& eraseBeamOptions( const CoordZ& tx, const CoordZ& rx ) { 
      ccbeam_options.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseBeamOptions( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbeam_options.erase(tx, rx); return *this; }
 
    std::string getBeamOptions( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccbeam_options.get(tx, rx); }
 
    std::string getBeamOptions( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) const { 
      return ccbeam_options.get(tx, rx); }  
 
    BellhopCreator& setBhMode( const std::string& options, const CoordZ& tx, const CoordZ& rx ) { 
      ccbellhop_mode.replace(options, tx, rx); return *this; }
 
    BellhopCreator& setBhMode( const std::string& options, const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbellhop_mode.replace(options, tx, rx); return *this; }
 
    BellhopCreator& eraseBhMode( const CoordZ& tx, const CoordZ& rx ) { 
      ccbellhop_mode.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseBhMode( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbellhop_mode.erase(tx, rx); return *this; }
 
    std::string getBhMode( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccbellhop_mode.get(tx, rx); }
 
    std::string getBhMode( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) const { 
      return ccbellhop_mode.get(tx, rx); } 
 
    BellhopCreator& setBathymetryType( const std::string& options, const CoordZ& tx, const CoordZ& rx ) { 
      ccbathymetry_type.replace(options, tx, rx); return *this; }
 
    BellhopCreator& setBathymetryType( const std::string& options, const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbathymetry_type.replace(options, tx, rx); return *this; }
 
    BellhopCreator& eraseBathymetryType( const CoordZ& tx, const CoordZ& rx ) { 
      ccbathymetry_type.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseBathymetryType( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbathymetry_type.erase(tx, rx); return *this; }
 
    std::string getBathymetryType( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccbathymetry_type.get(tx, rx); }
 
    std::string getBathymetryType( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) const { 
      return ccbathymetry_type.get(tx, rx); }    
 
    BellhopCreator& setBathymetryMethod( const std::string& options, const CoordZ& tx, const CoordZ& rx ) { 
      ccbathymetry_method.replace(options, tx, rx); return *this; }
 
    BellhopCreator& setBathymetryMethod( const std::string& options, const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbathymetry_method.replace(options, tx, rx); return *this; }
 
    BellhopCreator& eraseBathymetryMethod( const CoordZ& tx, const CoordZ& rx ) { 
      ccbathymetry_method.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseBathymetryMethod( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccbathymetry_method.erase(tx, rx); return *this; }
 
    std::string getBathymetryMethod( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccbathymetry_method.get(tx, rx); }
 
    std::string getBathymetryMethod( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) const { 
      return ccbathymetry_method.get(tx, rx); }   
 
    BellhopCreator& setAltimetryType( const std::string& options, const CoordZ& tx, const CoordZ& rx ) { 
      ccaltimetry_type.replace(options, tx, rx); return *this; }
    
    BellhopCreator& setAltimetryType( const std::string& options, const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccaltimetry_type.replace(options, tx, rx); return *this; }
      
    BellhopCreator& eraseAltimetryType( const CoordZ& tx, const CoordZ& rx ) { 
      ccaltimetry_type.erase(tx, rx); return *this; }
      
    BellhopCreator& eraseAltimetryType( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) { 
      ccaltimetry_type.erase(tx, rx); return *this; }
        
    std::string getAltimetryType( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccaltimetry_type.get(tx, rx); }
 
    std::string getAltimetryType( const std::shared_ptr<Location>& tx = CCString::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCString::ALL_LOCATIONS ) const { 
      return ccaltimetry_type.get(tx, rx); }    
 
    BellhopCreator& setAngles( const CustomAngles& angles, const CoordZ& tx, const CoordZ& rx ) { 
      ccangles_map.replace(angles, tx, rx); return *this; }
 
    BellhopCreator& setAngles( const CustomAngles& angles, const std::shared_ptr<Location>& tx = CCAngles::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCAngles::ALL_LOCATIONS ) { 
      ccangles_map.replace(angles, tx, rx); return *this; }    
 
    CustomAngles getAngles( const CoordZ& tx, const CoordZ& rx ) const { return ccangles_map.get(tx, rx); }
 
    CustomAngles getAngles( const std::shared_ptr<Location>& tx = CCAngles::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCAngles::ALL_LOCATIONS ) const { 
      return ccangles_map.get(tx, rx); }
 
    BellhopCreator& eraseAngles( const CoordZ& tx, const CoordZ& rx ) { ccangles_map.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseAngles( const std::shared_ptr<Location>& tx = CCAngles::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCAngles::ALL_LOCATIONS ) {
      ccangles_map.erase(tx, rx); return *this;
    }
 
    BellhopCreator& setBoxDepth( double box_depth, const CoordZ& tx, const CoordZ& rx ) {
      ccbox_depth.replace(box_depth, tx, rx); return *this; }
 
    BellhopCreator& setBoxDepth( double box_depth, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) {
      ccbox_depth.replace(box_depth, tx, rx); return *this; }
 
    BellhopCreator& eraseBoxDepth( const CoordZ& tx, const CoordZ& rx ) {
      ccbox_depth.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseBoxDepth( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) {
      ccbox_depth.erase(tx, rx); return *this; }
 
    double getBoxDepth( const CoordZ& tx, const CoordZ& rx ) const {
      return ccbox_depth.get(tx, rx); }
 
    double getBoxDepth( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const {
      return ccbox_depth.get(tx, rx); }
 
    BellhopCreator& setBoxRange( double box_range, const CoordZ& tx, const CoordZ& rx ) {
      ccbox_range.replace(box_range, tx, rx); return *this; }
 
    BellhopCreator& setBoxRange( double box_range, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) {
      ccbox_range.replace(box_range, tx, rx); return *this; }
 
    BellhopCreator& eraseBoxRange( const CoordZ& tx, const CoordZ& rx ) {
      ccbox_range.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseBoxRange( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) {
    ccbox_range.erase(tx, rx); return *this; }
 
    double getBoxRange( const CoordZ& tx, const CoordZ& rx ) const {
      return ccbox_range.get(tx, rx); }
 
    double getBoxRange( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const {
      return ccbox_range.get(tx, rx); }
 
    BellhopCreator& setSspDepthPrecision( double ssp_precision, const CoordZ& tx, const CoordZ& rx ) { 
      ccssp_depth_precision.replace(ssp_precision, tx, rx); return *this; }
 
    BellhopCreator& setSspDepthPrecision( double ssp_precision, const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccssp_depth_precision.replace(ssp_precision, tx, rx); return *this; }
 
    BellhopCreator& eraseSspDepthPrecision( const CoordZ& tx, const CoordZ& rx ) { 
      ccssp_depth_precision.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseSspDepthPrecision( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) { 
      ccssp_depth_precision.erase(tx, rx); return *this; }
 
    double getSspDepthPrecision( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccssp_depth_precision.get(tx, rx); }
 
    double getSspDepthPrecision( const std::shared_ptr<Location>& tx = CCDouble::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCDouble::ALL_LOCATIONS ) const { 
      return ccssp_depth_precision.get(tx, rx); }       
 
    BellhopCreator& setSspDepthSteps( int ssp_depth_steps, const CoordZ& tx, const CoordZ& rx ) { 
      ccnormalized_ssp_depth_steps.replace(ssp_depth_steps, tx, rx); return *this; }
 
    BellhopCreator& setSspDepthSteps( int ssp_depth_steps, const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      ccnormalized_ssp_depth_steps.replace(ssp_depth_steps, tx, rx); return *this; }
 
    BellhopCreator& eraseSspDepthSteps( const CoordZ& tx, const CoordZ& rx ) { 
      ccnormalized_ssp_depth_steps.erase(tx, rx); return *this; }
 
    BellhopCreator& eraseSspDepthSteps( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) { 
      ccnormalized_ssp_depth_steps.erase(tx, rx); return *this; }
 
    int getSspDepthSteps( const CoordZ& tx, const CoordZ& rx ) const { 
      return ccnormalized_ssp_depth_steps.get(tx, rx); }
 
    int getSspDepthSteps( const std::shared_ptr<Location>& tx = CCInt::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCInt::ALL_LOCATIONS ) const { 
      return ccnormalized_ssp_depth_steps.get(tx, rx); }      
 
    BellhopCreator& setCustomTransducer( const CustomTransducer& type, const CoordZ& tx, const CoordZ& rx ) { 
      cctransducer.replace(type, tx, rx); return *this; }
 
    BellhopCreator& setCustomTransducer( const CustomTransducer& type, const std::shared_ptr<Location>& tx = CCTransducer::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCTransducer::ALL_LOCATIONS ) { 
      cctransducer.replace(type, tx, rx); return *this; }    
   
    CustomTransducer getCustomTransducer( const CoordZ& tx, const CoordZ& rx ) const { 
      return cctransducer.get(tx, rx); }
 
    CustomTransducer getCustomTransducer( const std::shared_ptr<Location>& tx = CCTransducer::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCTransducer::ALL_LOCATIONS ) const { 
      return cctransducer.get(tx, rx); }
 
    BellhopCreator& eraseCustomTransducer( const CoordZ& tx, const CoordZ& rx ) { ccangles_map.erase(tx, rx); return *this; }
    
    BellhopCreator& eraseCustomTransducer( const std::shared_ptr<Location>& tx = CCTransducer::ALL_LOCATIONS, const std::shared_ptr<Location>& rx = CCTransducer::ALL_LOCATIONS ) {
      cctransducer.erase(tx, rx); return *this;
    }
 
    using CCAngles = WossCreatorContainer< CustomAngles >;
    
    using CCTransducer = WossCreatorContainer< CustomTransducer >;
 
    using CCString = WossCreatorContainer< std::string >;
 
    protected:
 
    bool use_thorpe_att;
 
    std::string bellhop_path;
 
    std::string bellhop_bin_name;
 
    BellhopArrSyntax bellhop_arr_syntax;
 
    BellhopShdSyntax bellhop_shd_syntax;
 
    CCString ccbellhop_mode;
 
    CCString ccbeam_options; 
 
    CCString ccbathymetry_type;
    
    CCString ccbathymetry_method;
       
    CCString ccaltimetry_type;
 
    CCAngles ccangles_map;
 
    CCInt cctotal_range_steps;
 
    CCInt cctotal_transmitters;
  
    CCDouble cctx_min_depth_offset;
 
    CCDouble cctx_max_depth_offset;
 
    CCInt cctotal_rx_depths;
 
    CCDouble ccrx_min_depth_offset;
 
    CCDouble ccrx_max_depth_offset;
 
    CCInt cctotal_rx_ranges;
 
    CCDouble ccrx_min_range_offset;
 
    CCDouble ccrx_max_range_offset;
 
    CCInt cctotal_rays;
 
    CCDouble ccssp_depth_precision;
 
    CCInt ccnormalized_ssp_depth_steps;
 
    CCTransducer cctransducer;
 
    CCDouble ccbox_depth;
 
    CCDouble ccbox_range;
 
    virtual bool initializeWoss( Woss& woss_ref ) const override;
 
    bool initializeBhWoss( BellhopWoss& woss_ref ) const;
 
    virtual void updateDebugFlag() override;
 
  };
 
}
 
#endif /* WOSS_BELLHOP_CREATOR_DEFINITIONS_H */