transducer-definitions.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_TRANSDUCER_DEFINITIONS_H
#define WOSS_TRANSDUCER_DEFINITIONS_H
 
 
#include <iostream>
#include <complex>
#include <map>
#include <cmath>
#include <cassert>
#include "custom-precision-double.h"
 
 
namespace woss {
   
  
  class CoordZ;
  
  
  #define BEAM_PATTERN_CUSTOM_BEAM_PRECISION (1.0)
  #define CONDUCTANCE_CUSTOM_FREQUENCY_PRECISION (1.0)
  #define TVR_CUSTOM_FREQUENCY_PRECISION (1.0)
  #define OCV_CUSTOM_FREQUENCY_PRECISION (1.0)
  #define TRANSDUCER_NOT_SET (-1000)
 
  
  class Transducer {
    
    
    protected:
      
      
    typedef ::std::map< PDouble, double > BeamPowerMap;
    typedef BeamPowerMap::iterator BPMIter;
    typedef BeamPowerMap::reverse_iterator BPMRIter;
    typedef BeamPowerMap::const_iterator BPMCIter;
    typedef BeamPowerMap::const_reverse_iterator BPMCRIter;
    
    
    typedef ::std::map< PDouble, double > ConductanceMap;
    typedef ConductanceMap::iterator CMIter;
    typedef ConductanceMap::reverse_iterator CMRIter;
    typedef ConductanceMap::const_iterator CMCIter;
    typedef ConductanceMap::const_reverse_iterator CMCRIter;    
    
  
    typedef ::std::map< PDouble, double > TVRMap;
    typedef TVRMap::iterator TVRMIter;
    typedef TVRMap::reverse_iterator TVRMRIter;
    typedef TVRMap::const_iterator TVRMCIter;
    typedef TVRMap::const_reverse_iterator TVRMCRIter;    
    
 
    typedef ::std::map< PDouble, double > OCVMap;
    typedef OCVMap::iterator OCVMIter;
    typedef OCVMap::reverse_iterator OCVMRIter;
    typedef OCVMap::const_iterator OCVMCIter;
    typedef OCVMap::const_reverse_iterator OCVMCRIter;        
  
    
    public:
    
 
    Transducer( long double beam_precision = BEAM_PATTERN_CUSTOM_BEAM_PRECISION, long double conduct_precison = CONDUCTANCE_CUSTOM_FREQUENCY_PRECISION, 
                long double tvr_precision = TVR_CUSTOM_FREQUENCY_PRECISION, long double ocv_precision = OCV_CUSTOM_FREQUENCY_PRECISION );
 
    Transducer( const Transducer& copy );
    
    Transducer( BeamPowerMap& beam_map, ConductanceMap& conductance_map, TVRMap& tvr_map, OCVMap& ocv_map );
      
    
    virtual ~Transducer() { }
  
  
    virtual Transducer* create( long double beam_precision = BEAM_PATTERN_CUSTOM_BEAM_PRECISION, long double conduct_precison = CONDUCTANCE_CUSTOM_FREQUENCY_PRECISION, 
                                long double tvr_precision = TVR_CUSTOM_FREQUENCY_PRECISION, long double ocv_precision = OCV_CUSTOM_FREQUENCY_PRECISION ) const;
 
  
    virtual Transducer* create( BeamPowerMap& beam_map, ConductanceMap& conductance_map, TVRMap& tvr_map, OCVMap& ocv_map ) const;
    
    virtual Transducer* create( const Transducer& copy ) const;
    
    virtual Transducer* clone() const;
    
    
    virtual bool isValid() const;
   
    
    Transducer& beampattern_rotate( double angle );
  
    Transducer& beampattern_sum( double value );
 
    Transducer& beampattern_multiply( double value );
   
    
    virtual double getSPL( double frequency, double power ) const;
 
    double getMaxSPL( double frequency ) const;
    
    virtual double getPowerFromSPL( double frequency, double spl ) const;
    
    bool beampattern_insert( double angle, double power );
 
    
    Transducer& beampattern_replace( double angle, double power );
    
    
    BPMCIter beampattern_find( double angle ) const;
 
    
    Transducer& beampattern_erase( double angle );
    
    
    int beampattern_size() const;
 
    bool beampattern_empty() const;
    
    
    Transducer& beampattern_clear();
    
    
    BPMCIter beampattern_begin() const;
    
    BPMCIter beampattern_end() const;
    
    BPMCRIter beampattern_rbegin() const;
    
    BPMCRIter beampattern_rend() const;    
    
    BPMCIter beampattern_lower_bound( double angle ) const;
    
    BPMCIter beampattern_upper_bound( double angle ) const;
    
              
    bool conductance_insert( double frequency, double conductance );
 
    bool conductance_insert( double frequency, const ::std::complex<double>& impedance );
 
    
    Transducer& conductance_replace( double frequency, double conductance );
    
    Transducer& conductance_replace( double frequency, const ::std::complex<double>& impedance );
    
    
    CMCIter conductance_find( double frequency ) const;
 
    
    Transducer& conductance_erase( double frequency );
    
    
    int conductance_size() const;
 
    bool conductance_empty() const;
    
    
    Transducer& conductance_clear();
    
    
    CMCIter conductance_begin() const;
    
    CMCIter conductance_end() const;
    
    CMCRIter conductance_rbegin() const;
    
    CMCRIter conductance_rend() const;    
    
    CMCIter conductance_lower_bound( double frequency ) const;
    
    CMCIter conductance_upper_bound( double frequency ) const;    
    
    
    bool tvr_insert( double frequency, double tvr );
    
    Transducer& tvr_replace( double frequency, double tvr );
    
    
    TVRMCIter tvr_find( double frequency ) const;
 
    
    Transducer& tvr_erase( double frequency );
    
    
    int tvr_size() const;
 
    bool tvr_empty() const;
    
    
    Transducer& tvr_clear();
    
    
    TVRMCIter tvr_begin() const;
    
    TVRMCIter tvr_end() const;
    
    TVRMCRIter tvr_rbegin() const;
    
    TVRMCRIter tvr_rend() const;    
    
    TVRMCIter tvr_lower_bound( double frequency ) const;
    
    TVRMCIter tvr_upper_bound( double frequency ) const;      
    
    
    bool ocv_insert( double frequency, double ocv );
    
    Transducer& ocv_replace( double frequency, double ocv );
    
    
    OCVMCIter ocv_find( double frequency ) const;
 
    
    Transducer& ocv_erase( double frequency );
    
    
    int ocv_size() const;
 
    bool ocv_empty() const;
    
    
    Transducer& ocv_clear();
    
    
    OCVMCIter ocv_begin() const;
    
    OCVMCIter ocv_end() const;
    
    OCVMCRIter ocv_rbegin() const;
    
    OCVMCRIter ocv_rend() const;    
    
    OCVMCIter ocv_lower_bound( double frequency ) const;
    
    OCVMCIter ocv_upper_bound( double frequency ) const;          
    
     
    Transducer& clearAll();
    
    
    virtual bool import( ::std::istream& stream_in );
    
    virtual bool importBinary( ::std::fstream& stream_in );
 
    
    bool writeVertBeamPattern( ::std::ostream& stream_out, const CoordZ& tx, const CoordZ& rx, double init_bearing, double vert_rot = 0, double horiz_rot = 0, double mult_costant = 1, double add_costant = 0 ) const;
 
    
    bool writeSPL( ::std::ostream& stream_out, double frequency_step, double power ) const;
 
    
    virtual bool write( ::std::ostream& stream_out ) const;
    
    virtual bool writeBinary( ::std::fstream& file_out ) const;
 
    
    Transducer& setMaxPower( double power );
    
    Transducer& setDutyCycle( double cycle );
    
    Transducer& setResonanceFrequency( double frequency );
    
    Transducer& setBandwith3dB( double frequency );
 
    Transducer& setTypeName( const ::std::string& name );
    
    
    virtual Transducer& setBeamPrecision( long double prec ); 
 
    virtual Transducer& setTVRPrecision( long double prec ); 
    
    virtual Transducer& setOCVPrecision( long double prec );     
    
    virtual Transducer& setConductancePrecision( long double prec ); 
    
    
    bool hasToroidalSymmetry() const;
    
    bool hasConicalSymmetry() const;
    
    
    double getMaxPower() const;
    
    double getDutyCycle() const;
    
    double getResonanceFrequency() const;    
    
    double getBandwith3dB() const;
 
    ::std::string getTypeName() const;
 
    
    long double getBeamPrecision() const;
    
    long double getTVRPrecision() const;   
 
    long double getOCVPrecision() const;
       
    long double getConductancePrecision() const;    
    
    
    Transducer& operator=( const Transducer& x ) ;
 
 
    friend bool operator==( const Transducer& left, const Transducer& right );
 
    friend bool operator!=( const Transducer& left, const Transducer& right );
 
    
    friend ::std::ostream& operator<<( ::std::ostream& os, const Transducer& instance );
    
    friend ::std::ostream& operator>>( ::std::istream& is, const Transducer& instance );
    
    
    static void setDebug( bool flag ) { debug = flag; }
            
    
    protected:
      
      
    static const ::std::string conical_string;
    
    static const ::std::string toroidal_string;
    
    
    static bool debug;
 
    
    bool has_conical_symmetry;
 
    
    double resonance_frequency;
 
    double bandwith_3db;
 
    double max_power;
 
    double duty_cycle;   
          
    
    long double beam_precision;
 
    long double conductance_precision;
    
    long double tvr_precision;
    
    long double ocv_precision;
    
    ::std::string type_name;
    
    
    BeamPowerMap beam_power_map;
 
    ConductanceMap conductance_map;
    
    TVRMap tvr_map;
    
    OCVMap ocv_map;
          
  
    virtual double normalizeAngle( double angle ) const;
  
    
    virtual double getValue( double frequency, const ::std::map< PDouble, double >& map, long double precision, bool use_linear = false, double costant = 20.0 ) const;
    
    
    virtual void beampattern_sum( double value, BeamPowerMap& map );
 
    virtual void beampattern_multiply( double value, BeamPowerMap& map );
 
    virtual void beampattern_rotate( double angle, BeamPowerMap& map );
    
    
    virtual bool import( ::std::istream& stream_in, ::std::map< PDouble, double >& map, long double precision, bool is_angle = false );
    
    virtual bool importBinary( ::std::fstream& file_in, ::std::map< PDouble, double >& map, long double precision, bool is_angle = false );
 
    
    virtual bool write( ::std::ostream& stream_out, const ::std::map< PDouble, double >& map ) const;
 
    virtual bool writeBinary( ::std::fstream& file_out, const ::std::map< PDouble, double >& map ) const;
    
    
    virtual const ::std::string& getSymmetryString() const;
    
    
  };
   
  
  //inline functions  
  inline Transducer& Transducer::setMaxPower( double power ) {
    max_power = power;
    return *this;
  }
  
  
  inline Transducer& Transducer::setDutyCycle( double cycle ) { 
    duty_cycle = cycle;
    return *this;   
  }
  
  
  inline Transducer& Transducer::setResonanceFrequency( double frequency ) {
    resonance_frequency = frequency;
    return *this;   
  }
   
   
  inline Transducer& Transducer::setBandwith3dB( double bw ) {
    bandwith_3db = bw;
    return *this;   
  }
 
 
  inline Transducer& Transducer::setTypeName( const ::std::string& name ) {
    type_name = name;
    return *this;
  }
  
  
  inline bool Transducer::hasToroidalSymmetry() const {
    return !has_conical_symmetry;
  }
    
  
  inline bool Transducer::hasConicalSymmetry() const {
    return has_conical_symmetry;
  }
  
    
  inline double Transducer::getMaxPower() const {
    return max_power;
  }
  
  
  inline double Transducer::getDutyCycle() const { 
    return duty_cycle;
  }
  
  
  inline double Transducer::getResonanceFrequency() const {
    return resonance_frequency;
  }
  
  
  inline double Transducer::getBandwith3dB() const {
    return bandwith_3db;
  }
  
  
  inline ::std::string Transducer::getTypeName() const {
    return type_name;
  }
  
  
  inline double Transducer::getMaxSPL( double frequency ) const {
    return getSPL( frequency, max_power );
  }
 
  
  inline Transducer& Transducer::beampattern_rotate( double angle ) {
    beampattern_rotate( angle, beam_power_map );
    return *this;
  }
  
  
  inline Transducer& Transducer::beampattern_sum( double value ) { 
    beampattern_sum( value, beam_power_map );
    return *this;    
  }
 
 
  inline Transducer& Transducer::beampattern_multiply( double value ) {
    beampattern_multiply( value, beam_power_map );
    return *this;  
  }
 
  
  inline bool Transducer::beampattern_insert( double angle, double power ) { 
    return beam_power_map.insert( ::std::make_pair( PDouble( normalizeAngle(angle), beam_precision), power ) ).second;
  }
 
 
  inline Transducer& Transducer::beampattern_replace( double angle, double power ) { 
    normalizeAngle(angle);
    beam_power_map[PDouble(angle, beam_precision)] = power;
    return *this;
  }
  
 
  inline Transducer::BPMCIter Transducer::beampattern_find( double angle ) const { 
    return beam_power_map.find(angle);
  }
  
 
  inline Transducer& Transducer::beampattern_erase( double angle ) { 
    beam_power_map.erase(angle);
    return *this;
  }
 
  inline int Transducer::beampattern_size() const { 
    return beam_power_map.size();  
  }
  
 
  inline bool Transducer::beampattern_empty() const { 
    return beam_power_map.empty();  
  }
  
 
  inline Transducer& Transducer::beampattern_clear() { 
    beam_power_map.clear();
    return *this;
  }
  
 
  inline Transducer::BPMCIter Transducer::beampattern_begin() const { 
    return beam_power_map.begin();  
  }
  
 
  inline Transducer::BPMCIter Transducer::beampattern_end() const { 
    return beam_power_map.end();  
  }
  
 
  inline Transducer::BPMCRIter Transducer::beampattern_rbegin() const  { 
    return beam_power_map.rbegin();  
  }
  
 
  inline Transducer::BPMCRIter Transducer::beampattern_rend() const  { 
    return beam_power_map.rend();  
  }
  
 
  inline Transducer::BPMCIter Transducer::beampattern_lower_bound( double angle ) const  { 
    return beam_power_map.lower_bound(PDouble(angle, beam_precision));  
  }
  
 
  inline Transducer::BPMCIter Transducer::beampattern_upper_bound( double angle ) const  { 
    return beam_power_map.upper_bound(PDouble(angle, beam_precision));  
  }
  
  
 
  inline bool Transducer::conductance_insert( double frequency, double conductance ) { 
    return conductance_map.insert( ::std::make_pair( PDouble( frequency, conductance_precision ), conductance ) ).second;
  }
  
  
  inline bool Transducer::conductance_insert( double frequency, const ::std::complex< double >& impedance ) { 
    return conductance_map.insert( ::std::make_pair( PDouble( frequency, conductance_precision ), impedance.real() 
                                                               / ( ::std::pow( ::std::abs(impedance), 2.0 ) ) ) ).second;
  }  
 
 
  inline Transducer& Transducer::conductance_replace( double frequency, double conductance ) { 
    conductance_map[PDouble(frequency, conductance_precision)] = conductance;
    return *this;
  }
  
  
  inline Transducer& Transducer::conductance_replace( double frequency, const ::std::complex< double >& impedance ) { 
    conductance_map[PDouble(frequency, conductance_precision)] = impedance.real() 
                                                               / ( ::std::pow( ::std::abs(impedance), 2.0 ) ) ;
    return *this;
  } 
  
 
  inline Transducer::CMCIter Transducer::conductance_find( double frequency ) const { 
    return conductance_map.find(frequency);
  }
  
 
  inline Transducer& Transducer::conductance_erase( double frequency ) { 
    conductance_map.erase(frequency);
    return *this;
  }
 
  inline int Transducer::conductance_size() const { 
    return conductance_map.size();  
  }
  
 
  inline bool Transducer::conductance_empty() const { 
    return conductance_map.empty();  
  }
  
 
  inline Transducer& Transducer::conductance_clear() { 
    conductance_map.clear();
    return *this;
  }
  
 
  inline Transducer::CMCIter Transducer::conductance_begin() const { 
    return conductance_map.begin();  
  }
  
 
  inline Transducer::CMCIter Transducer::conductance_end() const { 
    return conductance_map.end();  
  }
  
 
  inline Transducer::CMCRIter Transducer::conductance_rbegin() const  { 
    return conductance_map.rbegin();  
  }
  
 
  inline Transducer::CMCRIter Transducer::conductance_rend() const  { 
    return conductance_map.rend();  
  }
  
 
  inline Transducer::CMCIter Transducer::conductance_lower_bound( double frequency ) const  { 
    return conductance_map.lower_bound(PDouble(frequency, conductance_precision));  
  }
  
 
  inline Transducer::CMCIter Transducer::conductance_upper_bound( double frequency ) const  { 
    return conductance_map.upper_bound(PDouble(frequency, conductance_precision));  
  }
 
 
 
 
  inline bool Transducer::tvr_insert( double frequency, double tvr ) { 
    return tvr_map.insert( ::std::make_pair( PDouble( frequency, tvr_precision ), tvr ) ).second;
  }
 
 
  inline Transducer& Transducer::tvr_replace( double frequency, double tvr ) { 
    tvr_map[PDouble(frequency, tvr_precision)] = tvr;
    return *this;
  }
  
 
  inline Transducer::CMCIter Transducer::tvr_find( double frequency ) const { 
    return tvr_map.find(frequency);
  }
  
 
  inline Transducer& Transducer::tvr_erase( double frequency ) { 
    tvr_map.erase(frequency);
    return *this;
  }
 
  inline int Transducer::tvr_size() const { 
    return tvr_map.size();  
  }
  
 
  inline bool Transducer::tvr_empty() const { 
    return tvr_map.empty();  
  }
  
 
  inline Transducer& Transducer::tvr_clear() { 
    tvr_map.clear();
    return *this;
  }
  
 
  inline Transducer::CMCIter Transducer::tvr_begin() const { 
    return tvr_map.begin();  
  }
  
 
  inline Transducer::CMCIter Transducer::tvr_end() const { 
    return tvr_map.end();  
  }
  
 
  inline Transducer::CMCRIter Transducer::tvr_rbegin() const  { 
    return tvr_map.rbegin();  
  }
  
 
  inline Transducer::CMCRIter Transducer::tvr_rend() const  { 
    return tvr_map.rend();  
  }
  
 
  inline Transducer::CMCIter Transducer::tvr_lower_bound( double frequency ) const  { 
    return tvr_map.lower_bound(PDouble(frequency, tvr_precision));  
  }
  
 
  inline Transducer::CMCIter Transducer::tvr_upper_bound( double frequency ) const  { 
    return tvr_map.upper_bound(PDouble(frequency, tvr_precision));  
  }
 
 
 
  inline bool Transducer::ocv_insert( double frequency, double ocv ) { 
    return ocv_map.insert( ::std::make_pair( PDouble( frequency, ocv_precision ), ocv ) ).second;
  }
 
 
  inline Transducer& Transducer::ocv_replace( double frequency, double ocv ) { 
    ocv_map[PDouble(frequency, ocv_precision)] = ocv;
    return *this;
  }
  
 
  inline Transducer::CMCIter Transducer::ocv_find( double frequency ) const { 
    return ocv_map.find(frequency);
  }
  
 
  inline Transducer& Transducer::ocv_erase( double frequency ) { 
    ocv_map.erase(frequency);
    return *this;
  }
 
  inline int Transducer::ocv_size() const { 
    return ocv_map.size();  
  }
  
 
  inline bool Transducer::ocv_empty() const { 
    return ocv_map.empty();  
  }
  
 
  inline Transducer& Transducer::ocv_clear() { 
    ocv_map.clear();
    return *this;
  }
  
 
  inline Transducer::CMCIter Transducer::ocv_begin() const { 
    return ocv_map.begin();  
  }
  
 
  inline Transducer::CMCIter Transducer::ocv_end() const { 
    return ocv_map.end();  
  }
  
 
  inline Transducer::CMCRIter Transducer::ocv_rbegin() const  { 
    return ocv_map.rbegin();  
  }
  
 
  inline Transducer::CMCRIter Transducer::ocv_rend() const  { 
    return ocv_map.rend();  
  }
  
 
  inline Transducer::CMCIter Transducer::ocv_lower_bound( double frequency ) const  { 
    return ocv_map.lower_bound(PDouble(frequency, ocv_precision));  
  }
  
 
  inline Transducer::CMCIter Transducer::ocv_upper_bound( double frequency ) const  { 
    return ocv_map.upper_bound(PDouble(frequency, ocv_precision));  
  }
 
 
  inline Transducer& Transducer::clearAll() { 
    beam_power_map.clear();
    ocv_map.clear();
    tvr_map.clear();
    conductance_map.clear();
    return *this;
  }
  
  
  inline long double Transducer::getBeamPrecision() const { 
    return beam_precision;
  }
  
  
  inline long double Transducer::getConductancePrecision() const { 
    return conductance_precision;
  }
  
  
  inline long double Transducer::getTVRPrecision() const { 
    return tvr_precision;
  }
  
  
  inline long double Transducer::getOCVPrecision() const { 
    return ocv_precision;
  }  
    
  
  inline bool operator==( const Transducer& left, const Transducer& right ) {
    if ( &left == &right ) return true; 
    return( left.beam_power_map == right.beam_power_map && left.conductance_map == right.conductance_map
         && left.tvr_map == right.tvr_map && left.ocv_map == right.ocv_map );
  }
 
 
  inline bool operator!=( const Transducer& left, const Transducer& right ) {
    if ( &left == &right ) return false; 
    if ( &left == &right ) return true; 
    return( left.beam_power_map != right.beam_power_map || left.conductance_map != right.conductance_map
         || left.tvr_map != right.tvr_map || left.ocv_map != right.ocv_map );
  }
 
 
  inline ::std::ostream& operator<<( ::std::ostream& os, const Transducer& instance ) {
    if ( !instance.write( os ) ) os.setstate( ::std::ios_base::failbit );
    return os;
  }
 
 
  inline ::std::istream& operator>>( ::std::istream& is, Transducer& instance ) {
    if ( !instance.import( is ) ) is.setstate( ::std::ios_base::failbit );
    return is;
  }
    
 
}
 
 
#endif // WOSS_TRANSDUCER_DEFINITIONS_H