pressure-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 PRESSURE_DEFINITIONS_H
#define PRESSURE_DEFINITIONS_H 
 
 
#include <complex>
 
 
namespace woss {
  
    
  class TimeArr;
 
  class Pressure {
 
    
    public:
      
      
    Pressure( double real = 0.0, double imag = 0.0 );
 
    Pressure( const ::std::complex<double>& complex_press );
 
    Pressure( const TimeArr& time_arr );
    
    Pressure( const Pressure& copy );
 
    
    virtual Pressure* create( double real = 0.0, double imag = 0.0 ) const { return new Pressure( real, imag ); }
 
    virtual Pressure* create( const ::std::complex<double>& complex_press ) const { return new Pressure( complex_press ); }
 
    virtual Pressure* create( const TimeArr& time_arr ) const { return new Pressure( time_arr ); }
    
    virtual Pressure* create( const Pressure& copy ) const { return new Pressure( copy ); }
    
    virtual Pressure* clone() const { return new Pressure(*this); }
    
    virtual Pressure* createArray( unsigned int array_size ) const { return new Pressure[array_size]; }
    
    
    virtual ~Pressure() { }
 
 
    operator ::std::complex<double>() const { return complex_pressure; }
 
 
    static const ::std::complex<double> createNotValid() { return( ::std::complex<double>( HUGE_VAL, HUGE_VAL ) ); } 
    
    
    double real() const { return complex_pressure.real(); }
 
    double imag() const { return complex_pressure.imag(); }
    
    
    double abs() const { return ::std::abs( complex_pressure ); }
 
    double phase() const { return ::std::arg( complex_pressure ); }
 
    Pressure sqrt() const { return ::std::sqrt( complex_pressure ); }
 
 
    virtual bool isValid() const { return( complex_pressure != ::std::complex<double>( HUGE_VAL, HUGE_VAL ) ); }
    
 
    static double getTxLossDb( const ::std::complex<double>& val ) { if ( val == ::std::complex<double>( HUGE_VAL, HUGE_VAL ) ) return -HUGE_VAL;
                                else if( val == ::std::complex<double>( 0.0, 0.0 ) ) return HUGE_VAL; 
                                else return( -20.0 * log10( ::std::abs(val) ) ); }
 
    double getTxLossDb() const { 
      if (isValid() == false) return -HUGE_VAL;
      else if ( complex_pressure == ::std::complex<double>( 0.0, 0.0 ) ) return HUGE_VAL;
      else return ( -20.0 * log10( abs() ));
    }
 
    virtual bool checkAttenuation( double distance, double frequency );
 
    
    static void setDebug( bool flag ) { debug = flag; } 
    
    
    Pressure& operator=( const Pressure& x );
    
    
    friend const Pressure operator+( const Pressure& left, const Pressure& right );
 
    friend const Pressure operator-( const Pressure& left, const Pressure& right );
 
    friend const Pressure operator/( const Pressure& left, const Pressure& right );
    
    friend const Pressure operator*( const Pressure& left, const Pressure& right );
 
 
    friend Pressure& operator+=( Pressure& left, const Pressure& right );
 
    friend Pressure& operator-=( Pressure& left, const Pressure& right );
 
    friend Pressure& operator/=( Pressure& left, const Pressure& right );
 
    friend Pressure& operator*=( Pressure& left, const Pressure& right );
    
    
    friend bool operator==( const Pressure& left, const Pressure& right );
 
    friend bool operator!=( const Pressure& left, const Pressure& right );
    
    
    friend ::std::ostream& operator<<( ::std::ostream& os, const Pressure& instance );
    
      
    protected:
    
      
    static bool debug;
    
    
    ::std::complex< double > complex_pressure;
 
    virtual double getAttenuation( double dist, double freq );
 
    double getThorpAtt( double frequency );
    
  };
 
  
  //inline functions 
  inline bool operator==( const Pressure& left, const Pressure& right ) { 
    if ( &left == &right ) return true; 
    return( left.complex_pressure == right.complex_pressure );
  }
 
 
  inline bool operator!=( const Pressure& left, const Pressure& right ) { 
    if ( &left == &right ) return false; 
    return( left.complex_pressure != right.complex_pressure );
  }
 
 
  inline const Pressure operator+( const Pressure& left, const Pressure& right ) { 
    return( Pressure( left.complex_pressure + right.complex_pressure ) );
  }
    
    
  inline const Pressure operator-( const Pressure& left, const Pressure& right ) { 
    return( Pressure( left.complex_pressure - right.complex_pressure ) );
  }
    
    
  inline const Pressure operator/( const Pressure& left, const Pressure& right ) { 
    return( Pressure( left.complex_pressure / right.complex_pressure ) );
  }
    
    
  inline const Pressure operator*( const Pressure& left, const Pressure& right ) { 
    return( Pressure( left.complex_pressure * right.complex_pressure ) );
  }
 
    
  inline Pressure& operator+=( Pressure& left, const Pressure& right ) { 
    left.complex_pressure += right.complex_pressure;
    return left;
  }
    
    
  inline Pressure& operator-=( Pressure& left, const Pressure& right ) { 
    left.complex_pressure -= right.complex_pressure;
    return left;
  }
    
    
  inline Pressure& operator/=( Pressure& left, const Pressure& right ) { 
    left.complex_pressure /= right.complex_pressure;
    return left;
  }
    
    
  inline Pressure& operator*=( Pressure& left, const Pressure& right ) { 
    left.complex_pressure *= right.complex_pressure;
    return left;
  }
    
 
  inline ::std::ostream& operator<<( ::std::ostream& os, const Pressure& instance ) { 
    os << instance.complex_pressure << " TL = " << instance.getTxLossDb() << " dB";
    return os; 
  }
 
 
}
 
 
#endif /* PRESSURE_DEFINITIONS_H */