Triplet.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2015 by Michele Moresco, Federico Marulli         *
 *  and Alfonso Veropalumbo                                         *
 *                                                                  *
 *  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 __TRIPLET__
#define __TRIPLET__
 
 
#include "Catalogue.h"
 
 
// ===================================================================================================
 
 
namespace cbl {
  
  namespace triplets {
    
    enum class TripletType {
 
      _comoving_theta_,
 
      _comoving_side_,
 
      _comoving_costheta_,
 
      _multipoles_direct_,
 
    };
 
    inline std::vector<std::string> TripletTypeNames ()
    { return {"comoving_theta", "comoving_side", "comoving_costheta", "multipoles_direct"}; }
 
    inline TripletType TripletTypeCast (const int tripletPTypeIndex)
    { return castFromValue<TripletType>(tripletPTypeIndex); }
 
    inline TripletType TripletTypeCast (const std::string tripletPTypeName)
    { return castFromName<TripletType>(tripletPTypeName, TripletTypeNames()); }
 
    inline std::vector<TripletType> TripletTypeCast (const std::vector<int> tripletPTypeIndeces)
    { return castFromValues<TripletType>(tripletPTypeIndeces); } 
 
    inline std::vector<TripletType> TripletTypeCast (const std::vector<std::string> tripletPTypeNames)
    { return castFromNames<TripletType>(tripletPTypeNames, TripletTypeNames()); }
 
 
    class Triplet {
 
    private:
      
  
      virtual void set_parameters () = 0;
  
 
      
    protected:
      
      Dim m_tripletDim;
     
      TripletType m_tripletType;
      
      
    public:
    
 
      virtual ~Triplet () {}
 
      static std::shared_ptr<Triplet> Create (const TripletType type, const double r12, const double r12_binSize, const double r13, const double r13_binSize, const int nbins);
 
    
 
      
      Dim tripletDim () const
      { return m_tripletDim; }
 
      TripletType tripletType () const
      { return m_tripletType; }
 
      virtual double scale (const int i) const
      { (void)i; cbl::ErrorCBL("", "scale", "Triplet.h"); return 0; }
 
      virtual std::vector<double> scale () const
      { cbl::ErrorCBL("", "scale", "Triplet.h"); std::vector<double> vv; return vv; }
      
      virtual double TT1D (const int i) const { (void)i; cbl::ErrorCBL("", "TT1D", "Triplet.h"); return 0; }
      
      virtual std::vector<double> TT1D () const { cbl::ErrorCBL("", "TT1D", "Triplet.h"); std::vector<double> vv; return vv; }
 
      virtual double scale_D1 (const int i) const { (void)i; cbl::ErrorCBL("", "scale_D1", "Triplet.h"); return 0; }
 
      virtual std::vector<double> scale_D1 () const { cbl::ErrorCBL("", "scale_D1", "Triplet.h"); std::vector<double> vv; return vv; }
 
      virtual double scale_D2 (const int i) const { (void)i; cbl::ErrorCBL("", "scale_D2", "Triplet.h"); return 0; }
 
      virtual std::vector<double> scale_D2 () const { cbl::ErrorCBL("", "scale_D2", "Triplet.h"); std::vector<double> vv; return vv; }
 
      virtual double TT2D (const int i, const int j) const { (void)i; (void)j; cbl::ErrorCBL("", "TT2D", "Triplet.h"); return 0; }
 
      virtual std::vector<std::vector<double> > TT2D () const { cbl::ErrorCBL("", "TT2D", "Triplet.h"); std::vector<std::vector<double> > vv; return vv; }
      
      virtual double r12 () const { cbl::ErrorCBL("", "r12", "Triplet.h"); return 0; }
      
      virtual double r12_binSize () const { cbl::ErrorCBL("", "r12_binSize", "Triplet.h"); return 0; }
 
      virtual double r13 () const { cbl::ErrorCBL("", "r13", "Triplet.h"); return 0; }
 
      virtual double r13_binSize () const { cbl::ErrorCBL("", "r13_binSize", "Triplet.h"); return 0; }
 
      virtual int nbins () const { cbl::ErrorCBL("", "nbins", "Triplet.h"); return 0; }
 
      virtual double binSize () const { cbl::ErrorCBL("", "binSize", "Triplet.h"); return 0; }
 
      virtual double r12_D1 () const { cbl::ErrorCBL("", "r12_D1", "Triplet.h"); return 0; }
 
      virtual double r12_binSize_D1 () const { cbl::ErrorCBL("", "r12_binSize_D1", "Triplet.h"); return 0; }
 
      virtual double r13_D1 () const { cbl::ErrorCBL("", "r13_D1", "Triplet.h"); return 0; }
 
      virtual double r13_binSize_D1 () const { cbl::ErrorCBL("", "r13_binSize_D1", "Triplet.h"); return 0; }
 
      virtual int nbins_D1 () const { cbl::ErrorCBL("", "nbins_D1", "Triplet.h"); return 0; }
      
      virtual double binSize_D1 () const { cbl::ErrorCBL("", "binSize_D1", "Triplet.h"); return 0; }
 
      virtual double r12_D2 () const { cbl::ErrorCBL("", "r12_D2", "Triplet.h"); return 0; }
 
      virtual double r12_binSize_D2 () const { cbl::ErrorCBL("", "r12_binSize_D2", "Triplet.h"); return 0; }
 
      virtual double r13_D2 () const { cbl::ErrorCBL("", "r13_D2", "Triplet.h"); return 0; }
 
      virtual double r13_binSize_D2 () const { cbl::ErrorCBL("", "r13_binSize_D2", "Triplet.h"); return 0; }
 
      virtual int nbins_D2 () const { cbl::ErrorCBL("", "nbins_D2", "Triplet.h"); return 0; }
      
      virtual double binSize_D2 () const { cbl::ErrorCBL("", "binSize_D2", "Triplet.h"); return 0; }
 
      
      
 
      virtual void set_TT1D (const int i, const double tt)
      { (void)i; (void)tt; cbl::ErrorCBL("", "set_TT1D", "Triplet.h"); }
 
      virtual void add_TT1D (const int i, const double tt)
      { (void)i; (void)tt; cbl::ErrorCBL("", "add_TT1D", "Triplet.h"); }
 
 
      
     
      virtual void get_triplet (const double r12, const double r13, const double r23, int &klin) = 0;   
 
      virtual void set_triplet (const int klin, const double ww=1.) = 0;   
 
      virtual void put (const double r12, const double r13, const double r23, const double ww=1.) = 0;
 
      virtual void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, const std::shared_ptr<catalogue::Object> obj3) = 0;
    
      virtual void Sum (const std::shared_ptr<Triplet> tt, const double ww=1.) = 0;
 
 
    }; 
  }
}
 
#endif