pressure-definitions.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 PRESSURE_DEFINITIONS_H
#define PRESSURE_DEFINITIONS_H 
 
 
#include <complex>
#include <memory>
#include <ostream>
 
namespace woss {
 
  class TimeArr;
 
  class Pressure {
 
    public:
 
    Pressure( double real = 0.0, double imag = 0.0 );
 
    Pressure( const std::complex<double>& complex_press );
 
    explicit Pressure( const TimeArr& time_arr );
 
    Pressure( const Pressure& copy ) = default;
 
    Pressure( Pressure&& tmp ) = default;
 
    virtual ~Pressure() = default;
 
    virtual std::unique_ptr<Pressure> create( double real = 0.0, double imag = 0.0 ) const { return std::make_unique<Pressure>( real, imag ); }
 
    virtual std::unique_ptr<Pressure> create( const std::complex<double>& complex_press ) const { return std::make_unique<Pressure>( complex_press ); }
 
    virtual std::unique_ptr<Pressure> create( const TimeArr& time_arr ) const { return std::make_unique<Pressure>( time_arr ); }
 
    virtual std::unique_ptr<Pressure> clone() const { return std::make_unique<Pressure>(*this); }
 
    virtual std::unique_ptr<Pressure[]> createArray( unsigned int array_size ) const { return std::make_unique<Pressure[]>(array_size); }
 
    operator std::complex<double>() const { return complex_pressure; }
 
    static constexpr std::complex<double> createNotValid() { return( std::complex<double>( HUGE_VAL, HUGE_VAL ) ); } 
 
    void clear() { complex_pressure = {0.0, 0.0}; };
 
    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 constexpr 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& copy ) = default;
 
    Pressure& operator=( Pressure&& tmp ) = default;
    
    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 ) const;
 
    constexpr double getThorpAtt( double frequency ) const;
    
  };
 
  //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 */