Triplet2D.h

Go to the documentation of this file.

/********************************************************************
 *  Copyright (C) 2015 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 __TRIPLET2D__
#define __TRIPLET2D__
 
 
#include "Triplet.h"
 
 
// ===================================================================================================
 
 
namespace cbl {
  
  namespace triplets {
    
    class Triplet2D : public Triplet {
 
    private:
      
  
      virtual void set_parameters () = 0;
  
      
      
    protected:
      
      std::vector<double> m_scale_D1;
      
      std::vector<double> m_scale_D2;
      
      std::vector<std::vector<double> > m_TT2D;
 
 
 
      double m_r12_D1;
 
      double m_r12_binSize_D1; 
 
      double m_r13_D1;
 
      double m_r13_binSize_D1; 
 
      int m_nbins_D1;
      
      double m_binSize_D1;
 
      double m_r12_D2;
 
      double m_r12_binSize_D2; 
 
      double m_r13_D2;
 
      double m_r13_binSize_D2; 
 
      int m_nbins_D2;
      
      double m_binSize_D2;
      
 
  
    public:
    
 
      Triplet2D () 
    : m_r12_D1(-1), m_r12_binSize_D1(-1), m_r13_D1(-1), m_r13_binSize_D1(-1), m_nbins_D1(-1), m_binSize_D1(-1), m_r12_D2(-1), m_r12_binSize_D2(-1), m_r13_D2(-1), m_r13_binSize_D2(-1), m_nbins_D2(-1), m_binSize_D2(-1)
    { m_tripletDim = Dim::_2D_; }
                                                                
      Triplet2D (const double r12_D1, const double r12_binSize_D1, const double r13_D1, const double r13_binSize_D1, const int nbins_D1, const double r12_D2, const double r12_binSize_D2, const double r13_D2, const double r13_binSize_D2, const int nbins_D2) 
    : m_r12_D1(r12_D1), m_r12_binSize_D1(r12_binSize_D1), m_r13_D1(r13_D1), m_r13_binSize_D1(r13_binSize_D1), m_nbins_D1(nbins_D1), m_r12_D2(r12_D2), m_r12_binSize_D2(r12_binSize_D2), m_r13_D2(r13_D2), m_r13_binSize_D2(r13_binSize_D2), m_nbins_D2(nbins_D2)
      { m_tripletDim = Dim::_2D_; m_TT2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.)); }
 
      ~Triplet2D () = default;
      
 
      
 
      double scale_D1 (const int i) const override { (void)i; return m_scale_D1[i]; }
 
      std::vector<double> scale_D1 () const override { return m_scale_D1; }
 
      double scale_D2 (const int i) const override { (void)i; return m_scale_D2[i]; }
 
      std::vector<double> scale_D2 () const override { return m_scale_D2; }
 
      double TT2D (const int i, const int j) const override { (void)i; (void)j; return m_TT2D[i][j]; }
 
      std::vector<std::vector<double> > TT2D () const override { return m_TT2D; }
      
      double r12_D1 () const override { return m_r12_D1; }
 
      double r12_binSize_D1 () const override { return m_r12_binSize_D1; }
 
      double r13_D1 () const override { return m_r13_D1; }
 
      double r13_binSize_D1 () const override { return m_r13_binSize_D1; }
 
      double binSize_D1 () const override { return m_binSize_D1; }
 
      double r12_D2 () const override { return m_r12_D2; }
 
      double r12_binSize_D2 () const override { return m_r12_binSize_D2; }
 
      double r13_D2 () const override { return m_r13_D2; }
 
      double r13_binSize_D2 () const override { return m_r13_binSize_D2; }
 
      double binSize_D2 () const override { return m_binSize_D2; }
      
      
    
    
      void Sum (const std::shared_ptr<Triplet> tt, const double ww=1) override
      { (void)tt; (void)ww; ErrorCBL("", "Sum", "Triple2D.h", cbl::glob::ExitCode::_workInProgress_); }
     
      virtual void get_triplet (const double r12, const double r13, const double r23, int &klin) override
      { (void)r12; (void)r13; (void)r23; (void)klin; ErrorCBL("", "get_triplet", "Triple2D.h", cbl::glob::ExitCode::_workInProgress_); }
 
      virtual void set_triplet (const int klin, const double ww=1.) override   
      { (void)klin; (void)ww; ErrorCBL("", "set_triplet", "Triple2D.h", cbl::glob::ExitCode::_workInProgress_); }
 
      void put (const double r12, const double r13, const double r23, const double ww=1.) override
      { (void)r12; (void)r13; (void)r23; (void)ww; ErrorCBL("", "put", "Triple2D.h", cbl::glob::ExitCode::_workInProgress_); }
    
      void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, const std::shared_ptr<catalogue::Object> obj3) override
      { (void)obj1; (void)obj2; (void)obj3; ErrorCBL("", "put", "Triple2D.h", cbl::glob::ExitCode::_workInProgress_); }
      
    
    };
  }
}
 
#endif