bellhop-creator.h

Go to the documentation of this file.

/* WOSS - World Ocean Simulation System -
 * 
 * Copyright (C) 2009 Federico Guerra
 * and regents of the SIGNET lab, University of Padova
 *
 * Author: Federico Guerra - federico@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
 */ 
 
/*
 * This software has been developed by Federico Guerra and SIGNET lab,
 * University of Padova, in collaboration with the NATO Centre for 
 * Maritime Research and Experimentation (http://www.cmre.nato.int ; 
 * E-mail: pao@cmre.nato.int), whose support is gratefully acknowledged.
 */
 
 
#ifndef WOSS_BELLHOP_CREATOR_DEFINITIONS_H
#define WOSS_BELLHOP_CREATOR_DEFINITIONS_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() { }
    
 
    virtual BellhopWoss* const createWoss( const CoordZ& tx, const CoordZ& rx, double start_frequency, double end_frequency ) const;
    
    
    BellhopCreator& setThorpeAttFlag( bool flag ) { use_thorpe_att = flag; return *this; }
    
    bool getThorpeAttFlag() { 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, Location* const tx = CCInt::ALL_LOCATIONS, Location* const 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( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_range_steps.erase(tx, rx); return *this; }
 
    double getTotalRangeSteps( const CoordZ& tx, const CoordZ& rx ) { 
      return cctotal_range_steps.get(tx, rx); }
 
    double getTotalRangeSteps( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      cctx_min_depth_offset.erase(tx, rx); return *this; }
 
    double getTxMinDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      return cctx_min_depth_offset.get(tx, rx); }
 
    double getTxMinDepthOffset( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      cctx_max_depth_offset.erase(tx, rx); return *this; }
 
    double getTxMaxDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      return cctx_max_depth_offset.get(tx, rx); }
 
    double getTxMaxDepthOffset( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      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, Location* const tx = CCInt::ALL_LOCATIONS, Location* const 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( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_transmitters.erase(tx, rx); return *this; }
 
    int getTotalTransmitters( const CoordZ& tx, const CoordZ& rx ) { 
      return cctotal_transmitters.get(tx, rx); }
 
    int getTotalTransmitters( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_min_depth_offset.erase(tx, rx); return *this; }
 
    double getRxMinDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      return ccrx_min_depth_offset.get(tx, rx); }
 
    double getRxMinDepthOffset( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_max_depth_offset.erase(tx, rx); return *this; }
 
    double getRxMaxDepthOffset( const CoordZ& tx, const CoordZ& rx ) { 
      return ccrx_max_depth_offset.get(tx, rx); }
 
    double getRxMaxDepthOffset( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_min_range_offset.erase(tx, rx); return *this; }
 
    double getRxMinRangeOffset( const CoordZ& tx, const CoordZ& rx ) { 
      return ccrx_min_range_offset.get(tx, rx); }
 
    double getRxMinRangeOffset( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      ccrx_max_range_offset.erase(tx, rx); return *this; }
 
    double getRxMaxRangeOffset( const CoordZ& tx, const CoordZ& rx ) { 
      return ccrx_max_range_offset.get(tx, rx); }
 
    double getRxMaxRangeOffset( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      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, Location* const tx = CCInt::ALL_LOCATIONS, Location* const 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( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rx_depths.erase(tx, rx); return *this; }
 
    int getRxTotalDepths( const CoordZ& tx, const CoordZ& rx ) { 
      return cctotal_rx_depths.get(tx, rx); }
 
    int getRxTotalDepths( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      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, Location* const tx = CCInt::ALL_LOCATIONS, Location* const 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( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rx_ranges.erase(tx, rx); return *this; }
 
    int getRxTotalRanges( const CoordZ& tx, const CoordZ& rx ) { 
      return cctotal_rx_ranges.get(tx, rx); }
 
    int getRxTotalRanges( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      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, Location* const tx = CCInt::ALL_LOCATIONS, Location* const 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( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      cctotal_rays.erase(tx, rx); return *this; }
 
    int getRaysNumber( const CoordZ& tx, const CoordZ& rx ) { 
      return cctotal_rays.get(tx, rx); }
 
    int getRaysNumber( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      return cctotal_rays.get(tx, rx); }  
 
 
    BellhopCreator& setBellhopPath( const ::std::string& path ) { bellhop_path = path; return *this; }
 
    ::std::string getBellhopPath() { return bellhop_path; }
 
    BellhopCreator& setBellhopArrSyntax( BellhopArrSyntax syntax ) { 
      bellhop_arr_syntax = syntax; return *this; }
 
    BellhopArrSyntax getBellhopArrSyntax() { return bellhop_arr_syntax; }
 
    BellhopCreator& setBellhopShdSyntax( BellhopShdSyntax syntax ) { 
      bellhop_shd_syntax = syntax; return *this; }
 
    BellhopShdSyntax getBellhopShdSyntax() { 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, Location* const tx = CCString::ALL_LOCATIONS, Location* const 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( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      ccbeam_options.erase(tx, rx); return *this; }
 
    ::std::string getBeamOptions( const CoordZ& tx, const CoordZ& rx ) { 
      return ccbeam_options.get(tx, rx); }
 
    ::std::string getBeamOptions( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      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, Location* const tx = CCString::ALL_LOCATIONS, Location* const 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( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      ccbellhop_mode.erase(tx, rx); return *this; }
 
    ::std::string getBhMode( const CoordZ& tx, const CoordZ& rx ) { 
      return ccbellhop_mode.get(tx, rx); }
 
    ::std::string getBhMode( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      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, Location* const tx = CCString::ALL_LOCATIONS, Location* const 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( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      ccbathymetry_type.erase(tx, rx); return *this; }
 
    ::std::string getBathymetryType( const CoordZ& tx, const CoordZ& rx ) { 
      return ccbathymetry_type.get(tx, rx); }
 
    ::std::string getBathymetryType( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      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, Location* const tx = CCString::ALL_LOCATIONS, Location* const 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( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      ccbathymetry_method.erase(tx, rx); return *this; }
 
    ::std::string getBathymetryMethod( const CoordZ& tx, const CoordZ& rx ) { 
      return ccbathymetry_method.get(tx, rx); }
 
    ::std::string getBathymetryMethod( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      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, Location* const tx = CCString::ALL_LOCATIONS, Location* const 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( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      ccaltimetry_type.erase(tx, rx); return *this; }
        
    ::std::string getAltimetryType( const CoordZ& tx, const CoordZ& rx ) { 
      return ccaltimetry_type.get(tx, rx); }
      
    ::std::string getAltimetryType( Location* const tx = CCString::ALL_LOCATIONS, Location* const rx = CCString::ALL_LOCATIONS ) { 
      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, Location* const tx = CCAngles::ALL_LOCATIONS, Location* const 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( Location* const tx = CCAngles::ALL_LOCATIONS, Location* const 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( Location* const tx = CCAngles::ALL_LOCATIONS, Location* const 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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) {
                ccbox_depth.erase(tx, rx); return *this; }
 
      double getBoxDepth( const CoordZ& tx, const CoordZ& rx ) {
        return ccbox_depth.get(tx, rx); }
 
      double getBoxDepth( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) {
        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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) {
                ccbox_range.erase(tx, rx); return *this; }
 
                double getBoxRange( const CoordZ& tx, const CoordZ& rx ) {
                  return ccbox_range.get(tx, rx); }
 
                double getBoxRange( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) {
                  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, Location* const tx = CCDouble::ALL_LOCATIONS, Location* const 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( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      ccssp_depth_precision.erase(tx, rx); return *this; }
 
    double getSspDepthPrecision( const CoordZ& tx, const CoordZ& rx ) { 
      return ccssp_depth_precision.get(tx, rx); }
 
    double getSspDepthPrecision( Location* const tx = CCDouble::ALL_LOCATIONS, Location* const rx = CCDouble::ALL_LOCATIONS ) { 
      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, Location* const tx = CCInt::ALL_LOCATIONS, Location* const 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( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      ccnormalized_ssp_depth_steps.erase(tx, rx); return *this; }
 
    int getSspDepthSteps( const CoordZ& tx, const CoordZ& rx ) { 
      return ccnormalized_ssp_depth_steps.get(tx, rx); }
 
    int getSspDepthSteps( Location* const tx = CCInt::ALL_LOCATIONS, Location* const rx = CCInt::ALL_LOCATIONS ) { 
      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, Location* const tx = CCTransducer::ALL_LOCATIONS, Location* const 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( Location* const tx = CCTransducer::ALL_LOCATIONS, Location* const 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( Location* const tx = CCTransducer::ALL_LOCATIONS, Location* const rx = CCTransducer::ALL_LOCATIONS ) {
      cctransducer.erase(tx, rx); return *this;
    }      
    
 
    typedef WossCreatorContainer< CustomAngles > CCAngles;
    
    typedef WossCreatorContainer< CustomTransducer > CCTransducer;
 
    typedef WossCreatorContainer< ::std::string > CCString;
        
                
    protected:
    
    bool use_thorpe_att;
    
      
    ::std::string bellhop_path;
    
    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* const woss_ptr ) const ;
 
    bool initializeBhWoss( BellhopWoss* const woss_ptr ) const ;
        
 
    virtual const BellhopWoss* createNotValidWoss() const;
 
    virtual void updateDebugFlag();
    
  };
 
  
}
 
 
#endif /* WOSS_BELLHOP_CREATOR_DEFINITIONS_H */