ComplexLgAmpPhase.h

Go to the documentation of this file.

#ifndef _utl_ComplexLgAmpPhase_h_
#define _utl_ComplexLgAmpPhase_h_

#include <cmath>
#include <complex>
#include <iostream>
#include <utl/AugerException.h>

namespace utl {

  class ComplexLgAmpPhase {

  public:
    ComplexLgAmpPhase() : fLgAmplitude(0), fPhase(0) { }

    ComplexLgAmpPhase(const double lgamp, const double phase = 0)
      : fLgAmplitude(lgamp), fPhase(phase) { }

    double GetLgAmplitude() const
    { return fLgAmplitude; }

    double GetAmplitude() const
    { return std::pow(10.0,fLgAmplitude); }

    double GetPhase() const
    { return fPhase; }

    std::complex<double> GetComplex() const
    { return std::pow(10.0,fLgAmplitude) * std::exp(std::complex<double>(0, 1) * fPhase); }

    double GetReal() const
    { return GetComplex().real(); }

    double GetImag() const
    { return GetComplex().imag(); }

    // careful, it is not possible to implement addition or subtraction without losing the extra phase information!

    ComplexLgAmpPhase
    operator*(const ComplexLgAmpPhase& rhs) const
    {
      double newLgAmplitude = this->fLgAmplitude + rhs.fLgAmplitude;
      double newPhase = this->fPhase + rhs.fPhase; 
      return ComplexLgAmpPhase(newLgAmplitude,newPhase);
    }
    
    ComplexLgAmpPhase
    operator/(const ComplexLgAmpPhase& rhs) const
    {
      double newLgAmplitude = this->fLgAmplitude - rhs.fLgAmplitude;
      double newPhase = this->fPhase - rhs.fPhase;
      return ComplexLgAmpPhase(newLgAmplitude,newPhase);
    }

    ComplexLgAmpPhase&
    operator*=(const ComplexLgAmpPhase& rhs)
    {
      fLgAmplitude += rhs.fLgAmplitude;
      fPhase += rhs.fPhase;
      return *this;
    }

    ComplexLgAmpPhase&
    operator/=(const ComplexLgAmpPhase& rhs)
    {
      fLgAmplitude -= rhs.fLgAmplitude;
      fPhase -= rhs.fPhase;
      return *this;
    }

    // should this operator use Test<CloseTo> instead of operator==?
    bool operator==(const ComplexLgAmpPhase& rhs) const
    { return fLgAmplitude == rhs.fLgAmplitude && fPhase == rhs.fPhase; }

    ComplexLgAmpPhase&
    Pow(double power)
    {
      fLgAmplitude *= power;
      fPhase *= power;
      return *this;
    }

  private:
    double fLgAmplitude;
    double fPhase;

  };

  inline
  ComplexLgAmpPhase
  Interpolate(double x1, const ComplexLgAmpPhase& y1,
              double x2, const ComplexLgAmpPhase& y2,
              double x)
  {
    const double a1 = y1.GetLgAmplitude();
    const double p1 = y1.GetPhase();
    const double a2 = y2.GetLgAmplitude();
    const double p2 = y2.GetPhase();
    const double frac = (x - x1) / (x2 - x1);
    const double anew = a1 + frac * (a2 - a1);
    const double pnew = p1 + frac * (p2 - p1);
    return ComplexLgAmpPhase(anew, pnew);
  }

} // utl

#endif