Pair1D.h

Go to the documentation of this file.

/*******************************************************************
 *  Copyright (C) 2015 by Federico Marulli                         *
 *  federico.marulli3@unibo.it                                     *
 *                                                                 *
 *  This program is free software; you can redistribute it and/or  *
 *  modify it under the terms of the GNU General Public License as *
 *  published by the Free Software Foundation; either version 2 of *
 *  the License, or (at your option) any later version.            *
 *                                                                 *
 *  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 __PAIR1D__
#define __PAIR1D__
 
 
#include "Pair.h"
 
 
// ===================================================================================================
 
 
namespace cbl {
  
  namespace pairs {
 
    class Pair1D : public virtual Pair {
      
    protected:
      
  
      virtual void m_set_parameters_nbins () = 0;
  
      virtual void m_set_parameters_binSize () = 0;
  
 
 
    protected:
      
      std::vector<double> m_scale;
      
      std::vector<double> m_PP1D;
      
      std::vector<double> m_PP1D_weighted;
 
  
      double m_binSize_inv;
  
      int m_nbins;
  
      double m_shift;
  
 
  
    public:
      
 
      Pair1D () : m_binSize_inv(1.), m_nbins(50), m_shift(0.5)
    { m_pairDim = Dim::_1D_; m_angularUnits = CoordinateUnits::_radians_; m_angularWeight = nullptr; }
 
      Pair1D (const double binSize, const int nbins, const double shift, const CoordinateUnits angularUnits, std::function<double(double)> angularWeight=nullptr)
    : m_binSize_inv(1./binSize), m_nbins(nbins), m_shift(shift)
      {
    m_pairDim = Dim::_1D_;
    m_PP1D.resize(m_nbins+1, 0.);
    m_PP1D_weighted.resize(m_nbins+1, 0.);
    m_angularUnits = angularUnits;
    m_angularWeight = angularWeight;
      }
    
      virtual ~Pair1D () = default;
 
 
  
      
      double scale (const int i) const override { return m_scale[i]; }
 
      std::vector<double> scale () const override { return m_scale; }
      
      double PP1D (const int i) const override { return m_PP1D[i]; }
 
      std::vector<double> PP1D () const override { return m_PP1D; }
 
      double PP1D_weighted (const int i) const override { return m_PP1D_weighted[i]; }
 
      std::vector<double> PP1D_weighted () const override { return m_PP1D_weighted; }
    
      double binSize_inv () const override { return m_binSize_inv; }
 
      int nbins () const override { return m_nbins; }
    
      double shift () const override { return m_shift; }
 
 
  
 
      void reset () override;
      
      void set_scale (const int i, const double ss) { checkDim(m_scale, i, "m_scale", false); m_scale[i] = ss; }
      
      void set_PP1D (const int i, const double pp) { checkDim(m_PP1D, i, "m_PP1D", false); m_PP1D[i] = pp; }
 
      void set_PP1D_weighted (const int i, const double pp) { checkDim(m_PP1D_weighted, i, "m_PP1D_weighted", false); m_PP1D_weighted[i] = pp; }
      
      void add_data1D (const int i, const std::vector<double> data) override;
 
      void add_data1D (const int i, const std::shared_ptr<pairs::Pair> pair, const double ww=1.) override;
      
 
    
    
      virtual void Sum (const std::shared_ptr<Pair> pair, const double ww=1) override;
 
    
    };
 
 
    // ============================================================================================
    // ============================================================================================
 
  
    class Pair1D_angular : public virtual Pair1D {
 
    protected:
      
  
      virtual void m_set_parameters_nbins () = 0;
  
      virtual void m_set_parameters_binSize () = 0;
  
 
      
    protected:
  
 
      double m_thetaMin; 
  
      double m_thetaMax;
  
 
  
    public:
 
 
      Pair1D_angular () : m_thetaMin(0.1), m_thetaMax(50.) {} 
 
      Pair1D_angular (const double thetaMin, const double thetaMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), m_thetaMin(thetaMin), m_thetaMax(thetaMax) {}
  
      Pair1D_angular (const double thetaMin, const double thetaMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), m_thetaMin(thetaMin), m_thetaMax(thetaMax) {}
  
      virtual ~Pair1D_angular () = default;
 
  
  
 
      double sMin () const override { return m_thetaMin; }
 
      double sMax () const override { return m_thetaMax; }
 
    
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
    class Pair1D_angular_lin : public virtual Pair1D_angular {
 
    protected:
    
  
      void m_set_parameters_nbins () override;
    
      void m_set_parameters_binSize () override;
 
  
    public:
 
 
      Pair1D_angular_lin ()
    {
      m_pairType = PairType::_angular_lin_;
      m_pairInfo = PairInfo::_standard_;
    } 
 
      Pair1D_angular_lin (const double thetaMin, const double thetaMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), Pair1D_angular(thetaMin, thetaMax, nbins, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_angular_lin_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_nbins();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    }
  
      Pair1D_angular_lin (const double thetaMin, const double thetaMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), Pair1D_angular(thetaMin, thetaMax, binSize, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_angular_lin_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_binSize();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    } 
  
      ~Pair1D_angular_lin () = default;
      
  
  
  
      void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &kk, double &wkk) override;
 
      void set (const int kk, const double wkk, const double weight=1) override;
 
      void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
 
    
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
 
    class Pair1D_angular_log : public virtual Pair1D_angular {
 
    protected:
    
  
      void m_set_parameters_nbins () override;
    
      void m_set_parameters_binSize () override;
 
  
    public:
 
 
      Pair1D_angular_log ()
    {
      m_pairType = PairType::_angular_log_;
      m_pairInfo = PairInfo::_standard_;
    } 
 
      Pair1D_angular_log (const double thetaMin, const double thetaMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), Pair1D_angular(thetaMin, thetaMax, nbins, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_angular_log_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_nbins();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    }
  
      Pair1D_angular_log (const double thetaMin, const double thetaMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), Pair1D_angular(thetaMin, thetaMax, binSize, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_angular_log_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_binSize();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    } 
  
      ~Pair1D_angular_log () = default;
 
  
  
    
      void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &kk, double &wkk) override;
 
      void set (const int kk, const double wkk, const double weight=1) override;
 
      void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
 
    
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
 
    class Pair1D_comoving : public virtual Pair1D {
 
    protected:
      
  
      virtual void m_set_parameters_nbins () = 0;
  
      virtual void m_set_parameters_binSize () = 0;
  
      
      
    protected:
  
 
      double m_rMin;
  
      double m_rMax;
 
 
  
    public:
  
 
      Pair1D_comoving () : m_rMin(0.1), m_rMax(50.) {} 
    
      Pair1D_comoving (const double rMin, const double rMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), m_rMin(rMin), m_rMax(rMax) {} 
  
      Pair1D_comoving (const double rMin, const double rMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), m_rMin(rMin), m_rMax(rMax) {} 
  
      virtual ~Pair1D_comoving () = default;
 
 
  
 
      double sMin () const override { return m_rMin; }
 
      double sMax () const override { return m_rMax; }
 
    
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
  
    class Pair1D_comoving_lin : public virtual Pair1D_comoving {
 
    protected:
    
  
      void m_set_parameters_nbins () override;
    
      void m_set_parameters_binSize () override;
 
  
    public:
 
 
      Pair1D_comoving_lin ()
    {
      m_pairType = PairType::_comoving_lin_;
      m_pairInfo = PairInfo::_standard_;
    } 
 
      Pair1D_comoving_lin (const double rMin, const double rMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), Pair1D_comoving(rMin, rMax, nbins, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_comoving_lin_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_nbins();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    }
  
      Pair1D_comoving_lin (const double rMin, const double rMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), Pair1D_comoving(rMin, rMax, binSize, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_comoving_lin_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_binSize();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    } 
  
      ~Pair1D_comoving_lin () = default;
 
  
  
      
      void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &kk, double &wkk) override;
 
      void set (const int kk, const double wkk, const double weight=1) override;
  
      void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
  
    
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
  
    class Pair1D_comoving_log : public virtual Pair1D_comoving {
 
    protected:
      
  
      void m_set_parameters_nbins () override;
    
      void m_set_parameters_binSize () override;
 
  
    public:
 
 
      Pair1D_comoving_log ()
    {
      m_pairType = PairType::_comoving_log_;
      m_pairInfo = PairInfo::_standard_; 
    }
      
      Pair1D_comoving_log (const double rMin, const double rMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), Pair1D_comoving(rMin, rMax, nbins, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_comoving_log_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_nbins();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    }
  
      Pair1D_comoving_log (const double rMin, const double rMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), Pair1D_comoving(rMin, rMax, binSize, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_comoving_log_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_binSize();
      m_PP1D.resize(m_nbins+1, 0.);
      m_PP1D_weighted.resize(m_nbins+1, 0.);
    } 
  
      ~Pair1D_comoving_log () = default;
 
  
  
        
      void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &kk, double &wkk) override;
 
      void set (const int kk, const double wkk, const double weight=1) override;
 
      void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
 
    
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
    class Pair1D_comoving_multipoles : public virtual Pair1D {
 
    protected:
      
  
      virtual void m_set_parameters_nbins () = 0;
  
      virtual void m_set_parameters_binSize () = 0;
  
      
      
    protected:
  
 
      double m_rMin;
  
      double m_rMax;
 
 
  
    public:
  
 
      Pair1D_comoving_multipoles () : m_rMin(0.1), m_rMax(50.) {} 
    
      Pair1D_comoving_multipoles (const double rMin, const double rMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), m_rMin(rMin), m_rMax(rMax) 
      {
    m_PP1D.resize(3*(m_nbins+1), 0.);
    m_PP1D_weighted.resize(3*(m_nbins+1), 0.);
      }
 
      Pair1D_comoving_multipoles (const double rMin, const double rMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), m_rMin(rMin), m_rMax(rMax)
      {
    m_PP1D.resize(3*(m_nbins+1), 0.);
    m_PP1D_weighted.resize(3*(m_nbins+1), 0.);
      }
 
      virtual ~Pair1D_comoving_multipoles () = default;
 
 
  
 
      double sMin () const override { return m_rMin; }
 
      double sMax () const override { return m_rMax; }
 
    
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
    class Pair1D_comoving_multipoles_lin : public virtual Pair1D_comoving_multipoles {
 
    protected:
    
  
      void m_set_parameters_nbins () override;
    
      void m_set_parameters_binSize () override;
 
  
    public:
 
 
      Pair1D_comoving_multipoles_lin ()
    {
      m_pairType = PairType::_comoving_lin_;
      m_pairInfo = PairInfo::_standard_;
    } 
 
      Pair1D_comoving_multipoles_lin (const double rMin, const double rMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), Pair1D_comoving_multipoles(rMin, rMax, nbins, shift, angularUnits, angularWeight)
    {
      m_pairType = PairType::_comoving_multipoles_lin_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_nbins();
      m_PP1D.resize(3*(m_nbins+1), 0.);
      m_PP1D_weighted.resize(3*(m_nbins+1), 0.);
    }
  
      Pair1D_comoving_multipoles_lin (const double rMin, const double rMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), Pair1D_comoving_multipoles(rMin, rMax, binSize, shift, angularUnits, angularWeight) 
    {
      m_pairType = PairType::_comoving_multipoles_lin_;
      m_pairInfo = PairInfo::_standard_; 
      m_set_parameters_binSize();
      m_PP1D.resize(3*(m_nbins+1), 0.);
      m_PP1D_weighted.resize(3*(m_nbins+1), 0.);
    } 
  
      ~Pair1D_comoving_multipoles_lin () = default;
 
  
  
      
      void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &kk, double &cosmu, double &wkk) override;
 
      void set (const double cosmu, const int kk, const double wkk, const double weight=1) override;
  
      void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
  
    
 
      virtual void Sum (const std::shared_ptr<Pair> pair, const double ww=1) override;
 
    };
 
  
    // ============================================================================================
    // ============================================================================================
 
  
    class Pair1D_comoving_multipoles_log : public virtual Pair1D_comoving_multipoles {
 
    protected:
      
  
      void m_set_parameters_nbins () override;
    
      void m_set_parameters_binSize () override;
 
  
    public:
 
 
      Pair1D_comoving_multipoles_log ()
    {
      m_pairType = PairType::_comoving_log_;
      m_pairInfo = PairInfo::_standard_; 
    }
 
      
      Pair1D_comoving_multipoles_log (const double rMin, const double rMax, const int nbins, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(1., nbins, shift, angularUnits, angularWeight), Pair1D_comoving_multipoles (rMin, rMax, nbins, shift, angularUnits, angularWeight) 
      {
    m_pairType = PairType::_comoving_multipoles_log_;
    m_pairInfo = PairInfo::_standard_; 
    m_set_parameters_nbins();
    m_PP1D.resize(3*(m_nbins+1), 0.);
    m_PP1D_weighted.resize(3*(m_nbins+1), 0.);
      } 
 
      Pair1D_comoving_multipoles_log (const double rMin, const double rMax, const double binSize, const double shift, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
    : Pair1D(binSize, 50, shift, angularUnits, angularWeight), Pair1D_comoving_multipoles(rMin, rMax, binSize, shift, angularUnits, angularWeight) 
      {
    m_pairType = PairType::_comoving_multipoles_log_;
    m_pairInfo = PairInfo::_standard_; 
    m_set_parameters_binSize();
    m_PP1D.resize(3*(m_nbins+1), 0.);
    m_PP1D_weighted.resize(3*(m_nbins+1), 0.);
      } 
  
      ~Pair1D_comoving_multipoles_log () = default;
 
  
  
        
      void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &kk, double &cosmu, double &wkk) override;
 
      void set (const double cosmu, const int kk, const double wkk, const double weight=1) override;
 
      void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
 
 
 
      virtual void Sum (const std::shared_ptr<Pair> pair, const double ww=1) override;
 
 
    };
 
  }
}
 
#endif