ThreePointCorrelation.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2010 by Federico Marulli, Michele Moresco         *
 *  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 __THREEPOINT__
#define __THREEPOINT__ 
 
 
#include "Measure.h"
#include "ChainMesh_Catalogue.h"
#include "Triplet1D.h"
#include "Triplet2D.h"
 
 
// ===================================================================================================
 
 
namespace cbl {
  
  namespace measure {
 
    namespace threept {
 
      enum class ThreePType { 
 
    _angular_connected_,
 
    _angular_reduced_,
      
    _comoving_connected_,
 
    _comoving_reduced_
      
      };
 
      inline std::vector<std::string> ThreePTypeNames () {return {"angular_connected", "angular_reduced", "comoving_connected", "comoving_reduced"}; }
 
      inline ThreePType ThreePTypeCast (const int threePTypeIndex) {return castFromValue<ThreePType>(threePTypeIndex);}
 
      inline ThreePType ThreePTypeCast (const std::string threePTypeName) {return castFromName<ThreePType>(threePTypeName, ThreePTypeNames());}
 
      inline std::vector<ThreePType> ThreePTypeCast (const std::vector<int> threePTypeIndeces) {return castFromValues<ThreePType>(threePTypeIndeces);} 
 
      inline std::vector<ThreePType> ThreePTypeCast (const std::vector<std::string> threePTypeNames) {return castFromNames<ThreePType>(threePTypeNames, ThreePTypeNames());}
 
      class ThreePointCorrelation : public Measure {
    
      protected :
 
      
    ThreePType m_threePType;
 
    
    
    std::shared_ptr<catalogue::Catalogue> m_data;
 
    std::shared_ptr<catalogue::Catalogue> m_random;
    
 
 
 
    std::shared_ptr<triplets::Triplet> m_ddd;
 
    std::shared_ptr<triplets::Triplet> m_rrr;
 
    std::shared_ptr<triplets::Triplet> m_ddr;
    
    std::shared_ptr<triplets::Triplet> m_drr;
 
 
    std::vector<std::shared_ptr<triplets::Triplet>> m_ddd_regions;
 
    std::vector<std::shared_ptr<triplets::Triplet>> m_rrr_regions;
 
    std::vector<std::shared_ptr<triplets::Triplet>> m_ddr_regions;
    
    std::vector<std::shared_ptr<triplets::Triplet>> m_drr_regions;
 
 
 
      
    void count_triplets (const std::shared_ptr<catalogue::Catalogue> cat1, const chainmesh::ChainMesh_Catalogue &ChainMesh_rMAX1, const chainmesh::ChainMesh_Catalogue &ChainMesh_rMAX2, std::shared_ptr<triplets::Triplet> tt, const bool tcount=false);
 
    void count_allTriplets (const std::string dir_output_triplets=par::defaultString, const std::vector<std::string> dir_input_triplets={}, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1);
            
    void count_triplets_region (const std::shared_ptr<catalogue::Catalogue> cat1, const chainmesh::ChainMesh_Catalogue &ChainMesh_rMAX1, const chainmesh::ChainMesh_Catalogue &ChainMesh_rMAX2, std::shared_ptr<triplets::Triplet> tt, std::vector<std::shared_ptr<triplets::Triplet>> tt_regions, const std::vector<std::vector<double>> weight, const bool tcount=false);
 
    void count_allTriplets_region (const std::vector<std::vector<double>> weight, const std::string dir_output_triplets=par::defaultString, const std::vector<std::string> dir_input_triplets={}, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1);
 
    
    void write_triplets (const std::shared_ptr<triplets::Triplet> TT, const std::string dir, const std::string file) const;
 
    void read_triplets (std::shared_ptr<triplets::Triplet> TT, const std::vector<std::string> dir, const std::string file);
    
 
 
      
      public:
 
 
    ThreePointCorrelation () = default;
 
    ThreePointCorrelation (const catalogue::Catalogue data, const catalogue::Catalogue random) 
      : m_data(std::make_shared<catalogue::Catalogue>(catalogue::Catalogue(std::move(data)))), m_random(std::make_shared<catalogue::Catalogue>(catalogue::Catalogue(std::move(random)))) {}
 
    virtual ~ThreePointCorrelation () = default;
      
    static std::shared_ptr<ThreePointCorrelation> Create (const ThreePType type, const catalogue::Catalogue data, const catalogue::Catalogue random, const triplets::TripletType tripletType, const double side_s, const double side_u, const double perc_increase, const int nbins);
      
    static std::shared_ptr<ThreePointCorrelation> Create (const ThreePType type, const catalogue::Catalogue data, const catalogue::Catalogue random, const triplets::TripletType tripletType, const double r12, const double r12_binSize, const double r13, const double r13_binSize, const int nbins);
 
    static std::shared_ptr<ThreePointCorrelation> Create (const catalogue::Catalogue data, const catalogue::Catalogue random, const double r12Min, const double r12Max, const double r13Min, const double r13Max, const int nOrders, const double split=-1, const int seed=234);
 
    static std::shared_ptr<ThreePointCorrelation> Create (const catalogue::Catalogue data, const catalogue::Catalogue random, const double rMin, const double rMax, const double binSize, const int nOrders, const double split=-1, const int seed=234);
      
      
 
 
    ThreePType threePType () const { return m_threePType; }
    
    std::shared_ptr<catalogue::Catalogue> data () const { return m_data; }
   
    std::shared_ptr<catalogue::Catalogue> random () const { return m_random; }
 
    std::shared_ptr<triplets::Triplet> ddd () const { return m_ddd; }
 
    std::shared_ptr<triplets::Triplet> rrr () const { return m_rrr; }
 
    std::shared_ptr<triplets::Triplet> ddr () const { return m_ddr; }
 
    std::shared_ptr<triplets::Triplet> drr () const { return m_drr; }
 
    virtual std::vector<double> scale () const
    { cbl::ErrorCBL("", "scale", "ThreePointCorrelation.h"); std::vector<double> vv; return vv; }
      
    virtual std::vector<double> zeta () const  
    { cbl::ErrorCBL("", "zeta", "ThreePointCorrelation.h"); std::vector<double> vv; return vv; }
 
    virtual std::vector<double> QQ () const  
    { cbl::ErrorCBL("", "QQ", "ThreePointCorrelation.h"); std::vector<double> vv; return vv; }
 
    virtual std::vector<double> error () const  
    { cbl::ErrorCBL("", "error", "ThreePointCorrelation.h"); std::vector<double> vv; return vv; }
 
      
 
      
    
    void set_data (const catalogue::Catalogue data) { m_data = std::make_shared<catalogue::Catalogue>(catalogue::Catalogue(std::move(data))); }
 
    void set_random (const catalogue::Catalogue random) { m_random = std::make_shared<catalogue::Catalogue>(catalogue::Catalogue(std::move(random))); }
 
 
 
    virtual void measure (const std::string dir_output_triplets, const std::vector<std::string> dir_input_triplets={}, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1, const int seed=3213)
    { (void)dir_output_triplets; (void)dir_input_triplets; (void)count_ddd; (void)count_rrr; (void)count_ddr; (void)count_drr; (void)tcount; (void)fact; (void)seed; cbl::ErrorCBL("", "measure", "ThreePointCorrelation.h"); }
 
    virtual void measure (const std::vector<std::vector<double>> weight, const bool doJK, const std::string dir_output_triplets=par::defaultString, const std::vector<std::string> dir_input_triplets={}, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1, const int seed=3213)
    { (void)weight; (void)doJK; (void)dir_output_triplets; (void)dir_input_triplets; (void)count_ddd; (void)count_rrr; (void)count_ddr; (void)count_drr; (void)tcount; (void)fact; (void)seed; cbl::ErrorCBL("", "measure", "ThreePointCorrelation.h"); }
 
    virtual void measure (const ErrorType errorType, const std::string dir_output_triplets, const std::vector<std::string> dir_input_triplets={}, const int nResamplings=100, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1, const int seed=3213)
    { (void)errorType; (void)dir_output_triplets; (void)dir_input_triplets; (void)nResamplings; (void)count_ddd; (void)count_rrr; (void)count_ddr; (void)count_drr; (void)tcount; (void)fact; (void)seed; cbl::ErrorCBL("", "measure", "ThreePointCorrelation.h"); }
 
    virtual void measure (const std::string dir_output_triplets, const std::string dir_output_2pt, const std::vector<std::string> dir_input_triplets={}, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1, const int seed=3213)
    { (void)dir_output_triplets; (void)dir_output_2pt; (void)dir_input_triplets; (void)count_ddd; (void)count_rrr; (void)count_ddr; (void)count_drr; (void)tcount; (void)fact; (void)seed; cbl::ErrorCBL("", "measure", "ThreePointCorrelation.h!"); }
                
    virtual void measure (const std::vector<std::vector<double>> weight, const bool doJK, const std::string dir_output_triplets, const std::string dir_output_2pt, const std::vector<std::string> dir_input_triplets={}, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1, const int seed=3213)
    { (void)weight; (void)doJK; (void)dir_output_triplets; (void)dir_output_2pt; (void)dir_input_triplets; (void)count_ddd; (void)count_rrr; (void)count_ddr; (void)count_drr; (void)tcount; (void)fact; (void)seed; cbl::ErrorCBL("", "measure", "ThreePointCorrelation.h"); }
 
    virtual void measure (const ErrorType errorType, const std::string dir_output_triplets, const std::string dir_output_2pt, const std::vector<std::string> dir_input_triplets={}, const int nResamplings=100, const bool count_ddd=true, const bool count_rrr=true, const bool count_ddr=true, const bool count_drr=true, const bool tcount=false, const double fact=0.1, const int seed=3213)
    { (void)errorType; (void)dir_output_triplets; (void)dir_output_2pt; (void)dir_input_triplets; (void)nResamplings; (void)count_ddd; (void)count_rrr; (void)count_ddr; (void)count_drr; (void)tcount; (void)fact; (void)seed; cbl::ErrorCBL("", "measure", "ThreePointCorrelation.h"); }
 
    
    virtual void measure (const ErrorType errorType, const std::string dir_output_triplets, const std::vector<std::string> dir_input_triplets, const int nResamplings, const bool count_triplets, const bool tcount, const double fact, const int seed=3213)
    { (void)errorType; (void)dir_output_triplets; (void)dir_input_triplets; (void)nResamplings; (void)count_triplets; (void)tcount; (void)fact; (void)seed; cbl::ErrorCBL("", "measure", "ThreePointCorrelation.h"); }
    
    
      
    
    
    virtual void write (const std::string dir, const std::string file) const = 0;
      
    virtual void write (const std::string dir, const std::string file, const bool connected) const
    { (void)dir; (void)file; (void)connected; cbl::ErrorCBL("", "write", "ThreePointCorrelation.h"); }
 
    virtual void write_covariance (const std::string dir, const std::string file) const
    { (void)dir; (void)file; cbl::ErrorCBL("", "write_covariance", "ThreePointCorrelation.h"); }
    
      
      };
    }
  }
}
 
#endif