CosmoBolognaLib
Free Software C++/Python libraries for cosmological calculations
Pair2D.h
Go to the documentation of this file.
1 /*******************************************************************
2  * Copyright (C) 2015 by Federico Marulli *
3  * federico.marulli3@unibo.it *
4  * *
5  * This program is free software; you can redistribute it and/or *
6  * modify it under the terms of the GNU General Public License as *
7  * published by the Free Software Foundation; either version 2 of *
8  * the License, or (at your option) any later version. *
9  * *
10  * This program is distributed in the hope that it will be useful,*
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13  * GNU General Public License for more details. *
14  * *
15  * You should have received a copy of the GNU General Public *
16  * License along with this program; if not, write to the Free *
17  * Software Foundation, Inc., *
18  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19  *******************************************************************/
20 
34 #ifndef __PAIR2D__
35 #define __PAIR2D__
36 
37 
38 #include "Pair.h"
39 
40 
41 // ===================================================================================================
42 
43 
44 namespace cbl {
45 
46  namespace pairs {
47 
56  class Pair2D : public virtual Pair {
57 
58  protected:
59 
64 
68  virtual void m_set_parameters_nbins () = 0;
69 
73  virtual void m_set_parameters_binSize () = 0;
74 
76 
77 
78  protected:
79 
81  std::vector<double> m_scale_D1;
82 
84  std::vector<double> m_scale_D2;
85 
87  std::vector<std::vector<double>> m_PP2D;
88 
90  std::vector<std::vector<double>> m_PP2D_weighted;
91 
96 
98  double m_binSize_inv_D1;
99 
101  int m_nbins_D1;
102 
104  double m_shift_D1;
105 
107  double m_binSize_inv_D2;
108 
110  int m_nbins_D2;
111 
113  double m_shift_D2;
114 
116 
117  public:
118 
123 
127  Pair2D ()
128  : m_binSize_inv_D1(1.), m_nbins_D1(50), m_shift_D1(0.5), m_binSize_inv_D2(1.), m_nbins_D2(50), m_shift_D2(0.5)
129  { m_pairDim = Dim::_2D_; m_angularUnits = CoordinateUnits::_radians_; m_angularWeight = nullptr; }
130 
144  Pair2D (const double binSize_D1, const int nbins_D1, const double shift_D1, const double binSize_D2, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
145  : m_binSize_inv_D1(1./binSize_D1), m_nbins_D1(nbins_D1), m_shift_D1(shift_D1), m_binSize_inv_D2(1./binSize_D2), m_nbins_D2(nbins_D2), m_shift_D2(shift_D2)
146  { m_pairDim = Dim::_2D_; m_angularUnits = angularUnits; m_angularWeight = angularWeight; }
147 
151  virtual ~Pair2D () = default;
152 
154 
155 
160 
166  double scale_D1 (const int i) const override { return m_scale_D1[i]; }
167 
172  std::vector<double> scale_D1 () const override { return m_scale_D1; }
173 
179  double scale_D2 (const int i) const override { return m_scale_D2[i]; }
180 
185  std::vector<double> scale_D2 () const override { return m_scale_D2; }
186 
193  double PP2D (const int i, const int j) const override { return m_PP2D[i][j]; }
194 
199  std::vector<std::vector<double>> PP2D () const override { return m_PP2D; }
200 
207  double PP2D_weighted (const int i, const int j) const override { return m_PP2D_weighted[i][j]; }
208 
214  std::vector<std::vector<double>> PP2D_weighted () const override { return m_PP2D_weighted; }
215 
220  double binSize_inv_D1 () const override { return m_binSize_inv_D1; }
221 
226  int nbins_D1 () const override { return m_nbins_D1; }
227 
233  double shift_D1 () const override { return m_shift_D1; }
234 
239  double binSize_inv_D2 () const override { return m_binSize_inv_D2; }
240 
245  int nbins_D2 () const override { return m_nbins_D2; }
246 
252  double shift_D2 () const override { return m_shift_D2; }
253 
255 
256 
261 
270  void reset () override;
271 
278  void set_scale_D1 (const int i, const double pp) { checkDim(m_scale_D1, i, "m_scale_D1"); m_scale_D1[i] = pp; }
279 
286  void set_scale_D2 (const int i, const double pp) { checkDim(m_scale_D2, i, "m_scale_D2"); m_scale_D2[i] = pp; }
287 
295  void set_PP2D (const int i, const int j, const double pp) { checkDim(m_PP2D, i, j, "m_PP2D"); m_PP2D[i][j] = pp; }
296 
304  void set_PP2D_weighted (const int i, const int j, const double pp) { checkDim(m_PP2D_weighted, i, j, "m_PP2D_weighted"); m_PP2D_weighted[i][j] = pp; }
305 
313  void add_data2D (const int i, const int j, const std::vector<double> data) override;
314 
323  void add_data2D (const int i, const int j, const std::shared_ptr<pairs::Pair> pair, const double ww=1.) override;
324 
326 
327 
332 
339  void Sum (const std::shared_ptr<Pair> pp, const double ww=1) override;
340 
342 
343  };
344 
345 
346  // ============================================================================================
347  // ============================================================================================
348 
349 
359  class Pair2D_comovingCartesian : public virtual Pair2D {
360 
361  protected:
362 
367 
371  virtual void m_set_parameters_nbins () = 0;
372 
376  virtual void m_set_parameters_binSize () = 0;
377 
379 
380 
381  protected:
382 
387 
389  double m_rpMin;
390 
392  double m_rpMax;
393 
395  double m_piMin;
396 
398  double m_piMax;
399 
401 
402 
403  public:
404 
409 
413  Pair2D_comovingCartesian () : m_rpMin(0.1), m_rpMax(50.), m_piMin(0.1), m_piMax(50.) {}
414 
432  Pair2D_comovingCartesian (const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
433  : Pair2D(1., nbins_rp, shift_rp, 1., nbins_pi, shift_pi, angularUnits, angularWeight), m_rpMin(rpMin), m_rpMax(rpMax), m_piMin(piMin), m_piMax(piMax) {}
434 
453  Pair2D_comovingCartesian (const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
454  : Pair2D(binSize_rp, 50, shift_rp, binSize_pi, 50, shift_pi, angularUnits, angularWeight), m_rpMin(rpMin), m_rpMax(rpMax), m_piMin(piMin), m_piMax(piMax) {}
455 
459  virtual ~Pair2D_comovingCartesian () = default;
460 
462 
463 
468 
474  double sMin_D1 () const override { return m_rpMin; }
475 
481  double sMax_D1 () const override { return m_rpMax; }
482 
488  double sMin_D2 () const override { return m_piMin; }
489 
495  double sMax_D2 () const override { return m_piMax; }
496 
498 
499  };
500 
501 
502  // ============================================================================================
503  // ============================================================================================
504 
505 
515  class Pair2D_comovingCartesian_linlin : public virtual Pair2D_comovingCartesian {
516 
517  protected:
518 
523 
528  void m_set_parameters_nbins () override;
529 
534  void m_set_parameters_binSize () override;
535 
537 
538  public:
539 
544 
548  Pair2D_comovingCartesian_linlin ()
549  {
550  m_pairType = PairType::_comovingCartesian_linlin_;
551  m_pairInfo = PairInfo::_standard_;
552  }
553 
571  Pair2D_comovingCartesian_linlin (const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
572  : Pair2D(1., nbins_rp, shift_rp, 1., nbins_pi, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, nbins_rp, shift_rp, piMin, piMax, nbins_pi, shift_pi, angularUnits, angularWeight)
573  {
574  m_pairType = PairType::_comovingCartesian_linlin_;
575  m_pairInfo = PairInfo::_standard_;
576  m_set_parameters_nbins();
577  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
578  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
579  }
580 
598  Pair2D_comovingCartesian_linlin (const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
599  : Pair2D(binSize_rp, 50, shift_rp, binSize_pi, 50, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, binSize_rp, shift_rp, piMin, piMax, binSize_pi, shift_pi, angularUnits, angularWeight)
600  {
601  m_pairType = PairType::_comovingCartesian_linlin_;
602  m_pairInfo = PairInfo::_standard_;
603  m_set_parameters_binSize();
604  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
605  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
606  }
607 
612  ~Pair2D_comovingCartesian_linlin () = default;
613 
615 
616 
621 
631  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
632 
641  void set (const int ir, const int jr, const double ww, const double weight=1) override;
642 
651  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
652 
654 
655  };
656 
657 
658  // ============================================================================================
659  // ============================================================================================
660 
661 
671  class Pair2D_comovingCartesian_loglin : public virtual Pair2D_comovingCartesian {
672 
673  protected:
674 
679 
684  void m_set_parameters_nbins () override;
685 
690  void m_set_parameters_binSize () override;
691 
693 
694  public:
695 
700 
704  Pair2D_comovingCartesian_loglin ()
705  {
706  m_pairType = PairType::_comovingCartesian_loglin_;
707  m_pairInfo = PairInfo::_standard_;
708  }
709 
727  Pair2D_comovingCartesian_loglin (const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
728  : Pair2D(1., nbins_rp, shift_rp, 1., nbins_pi, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, nbins_rp, shift_rp, piMin, piMax, nbins_pi, shift_pi, angularUnits, angularWeight)
729  {
730  m_pairType = PairType::_comovingCartesian_loglin_;
731  m_pairInfo = PairInfo::_standard_;
732  m_set_parameters_nbins();
733  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
734  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
735  }
736 
754  Pair2D_comovingCartesian_loglin (const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
755  : Pair2D(binSize_rp, 50, shift_rp, binSize_pi, 50, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, binSize_rp, shift_rp, piMin, piMax, binSize_pi, shift_pi, angularUnits, angularWeight)
756  {
757  m_pairType = PairType::_comovingCartesian_loglin_;
758  m_pairInfo = PairInfo::_standard_;
759  m_set_parameters_binSize();
760  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
761  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
762  }
763 
768  ~Pair2D_comovingCartesian_loglin () = default;
769 
771 
772 
777 
787  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
788 
797  void set (const int ir, const int jr, const double ww, const double weight=1) override;
798 
807  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
808 
810 
811  };
812 
813  // ============================================================================================
814  // ============================================================================================
815 
816 
826  class Pair2D_comovingCartesian_linlog : public virtual Pair2D_comovingCartesian {
827 
828  protected:
829 
834 
839  void m_set_parameters_nbins () override;
840 
845  void m_set_parameters_binSize () override;
846 
848 
849  public:
850 
855 
859  Pair2D_comovingCartesian_linlog ()
860  {
861  m_pairType = PairType::_comovingCartesian_linlog_;
862  m_pairInfo = PairInfo::_standard_;
863  }
864 
882  Pair2D_comovingCartesian_linlog (const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
883  : Pair2D(1., nbins_rp, shift_rp, 1., nbins_pi, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, nbins_rp, shift_rp, piMin, piMax, nbins_pi, shift_pi, angularUnits, angularWeight)
884  {
885  m_pairType = PairType::_comovingCartesian_linlog_;
886  m_pairInfo = PairInfo::_standard_;
887  m_set_parameters_nbins();
888  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
889  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
890  }
891 
909  Pair2D_comovingCartesian_linlog (const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
910  : Pair2D(binSize_rp, 50, shift_rp, binSize_pi, 50, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, binSize_rp, shift_rp, piMin, piMax, binSize_pi, shift_pi, angularUnits, angularWeight)
911  {
912  m_pairType = PairType::_comovingCartesian_linlog_;
913  m_pairInfo = PairInfo::_standard_;
914  m_set_parameters_binSize();
915  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
916  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
917  }
918 
923  ~Pair2D_comovingCartesian_linlog () = default;
924 
926 
927 
932 
942  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
943 
952  void set (const int ir, const int jr, const double ww, const double weight=1) override;
953 
962  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
963 
965 
966  };
967 
968  // ============================================================================================
969  // ============================================================================================
970 
971 
981  class Pair2D_comovingCartesian_loglog : public virtual Pair2D_comovingCartesian {
982 
983  protected:
984 
989 
994  void m_set_parameters_nbins () override;
995 
1000  void m_set_parameters_binSize () override;
1001 
1003 
1004  public:
1005 
1010 
1014  Pair2D_comovingCartesian_loglog ()
1015  {
1016  m_pairType = PairType::_comovingCartesian_loglog_;
1017  m_pairInfo = PairInfo::_standard_;
1018  }
1019 
1037  Pair2D_comovingCartesian_loglog (const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1038  : Pair2D(1., nbins_rp, shift_rp, 1., nbins_pi, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, nbins_rp, shift_rp, piMin, piMax, nbins_pi, shift_pi, angularUnits, angularWeight)
1039  {
1040  m_pairType = PairType::_comovingCartesian_loglog_;
1041  m_pairInfo = PairInfo::_standard_;
1042  m_set_parameters_nbins();
1043  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1044  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1045  }
1046 
1064  Pair2D_comovingCartesian_loglog (const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1065  : Pair2D(binSize_rp, 50, shift_rp, binSize_pi, 50, shift_pi, angularUnits, angularWeight), Pair2D_comovingCartesian(rpMin, rpMax, binSize_rp, shift_rp, piMin, piMax, binSize_pi, shift_pi, angularUnits, angularWeight)
1066  {
1067  m_pairType = PairType::_comovingCartesian_loglog_;
1068  m_pairInfo = PairInfo::_standard_;
1069  m_set_parameters_binSize();
1070  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1071  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1072  }
1073 
1078  ~Pair2D_comovingCartesian_loglog () = default;
1079 
1081 
1082 
1087 
1097  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
1098 
1107  void set (const int ir, const int jr, const double ww, const double weight=1) override;
1108 
1117  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
1118 
1120 
1121  };
1122 
1123 
1124  // ============================================================================================
1125  // ============================================================================================
1126 
1127 
1136  class Pair2D_comovingPolar : public virtual Pair2D {
1137 
1138  protected:
1139 
1144 
1148  virtual void m_set_parameters_nbins () = 0;
1149 
1153  virtual void m_set_parameters_binSize () = 0;
1154 
1156 
1157 
1158  protected:
1159 
1164 
1166  double m_rMin;
1167 
1169  double m_rMax;
1170 
1172  double m_muMin;
1173 
1175  double m_muMax;
1176 
1178 
1179 
1180  public:
1181 
1186 
1190  Pair2D_comovingPolar () = default;
1191 
1207  Pair2D_comovingPolar (const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1208  : Pair2D(1., nbins_D1, shift_D1, 1., nbins_D2, shift_D2, angularUnits, angularWeight), m_rMin(rMin), m_rMax(rMax), m_muMin(muMin), m_muMax(muMax) {}
1209 
1225  Pair2D_comovingPolar (const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1226  : Pair2D(binSize_D1, 50, shift_D1, binSize_D2, 50, shift_D2, angularUnits, angularWeight), m_rMin(rMin), m_rMax(rMax), m_muMin(muMin), m_muMax(muMax) {}
1227 
1232  virtual ~Pair2D_comovingPolar () = default;
1233 
1235 
1236 
1241 
1246  double sMin_D1 () const override { return m_rMin; }
1247 
1252  double sMax_D1 () const override { return m_rMax; }
1253 
1258  double sMin_D2 () const override { return m_muMin; }
1259 
1264  double sMax_D2 () const override { return m_muMax; }
1265 
1267 
1268  };
1269 
1270 
1271  // ============================================================================================
1272  // ============================================================================================
1273 
1274 
1284  class Pair2D_comovingPolar_linlin : public virtual Pair2D_comovingPolar {
1285 
1286  protected:
1287 
1292 
1297  void m_set_parameters_nbins () override;
1298 
1303  void m_set_parameters_binSize () override;
1304 
1306 
1307  public:
1308 
1313 
1317  Pair2D_comovingPolar_linlin ()
1318  {
1319  m_pairType = PairType::_comovingPolar_linlin_;
1320  m_pairInfo = PairInfo::_standard_;
1321  }
1322 
1338  Pair2D_comovingPolar_linlin (const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1339  : Pair2D(1., nbins_D1, shift_D1, 1., nbins_D2, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, nbins_D1, shift_D1, muMin, muMax, nbins_D2, shift_D2, angularUnits, angularWeight)
1340  {
1341  m_pairType = PairType::_comovingPolar_linlin_;
1342  m_pairInfo = PairInfo::_standard_;
1343  m_set_parameters_nbins();
1344  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1345  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1346  }
1347 
1363  Pair2D_comovingPolar_linlin (const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1364  : Pair2D(binSize_D1, 50, shift_D1, binSize_D2, 50, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, binSize_D1, shift_D1, muMin, muMax, binSize_D2, shift_D2, angularUnits, angularWeight)
1365  {
1366  m_pairType = PairType::_comovingPolar_linlin_;
1367  m_pairInfo = PairInfo::_standard_;
1368  m_set_parameters_binSize();
1369  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1370  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1371  }
1372 
1377  ~Pair2D_comovingPolar_linlin () = default;
1378 
1380 
1381 
1386 
1396  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
1397 
1406  void set (const int ir, const int jr, const double ww, const double weight=1) override;
1407 
1416  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
1417 
1419 
1420  };
1421 
1422 
1423  // ============================================================================================
1424  // ============================================================================================
1425 
1426 
1436  class Pair2D_comovingPolar_loglin : public virtual Pair2D_comovingPolar {
1437 
1438  protected:
1439 
1444 
1449  void m_set_parameters_nbins () override;
1450 
1455  void m_set_parameters_binSize () override;
1456 
1458 
1459  public:
1460 
1465 
1469  Pair2D_comovingPolar_loglin ()
1470  {
1471  m_pairType = PairType::_comovingPolar_loglin_;
1472  m_pairInfo = PairInfo::_standard_;
1473  }
1474 
1490  Pair2D_comovingPolar_loglin (const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1491  : Pair2D(1., nbins_D1, shift_D1, 1., nbins_D2, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, nbins_D1, shift_D1, muMin, muMax, nbins_D2, shift_D2, angularUnits, angularWeight)
1492  {
1493  m_pairType = PairType::_comovingPolar_loglin_;
1494  m_pairInfo = PairInfo::_standard_;
1495  m_set_parameters_nbins();
1496  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1497  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1498  }
1499 
1515  Pair2D_comovingPolar_loglin (const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1516  : Pair2D(binSize_D1, 50, shift_D1, binSize_D2, 50, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, binSize_D1, shift_D1, muMin, muMax, binSize_D2, shift_D2, angularUnits, angularWeight)
1517  {
1518  m_pairType = PairType::_comovingPolar_loglin_;
1519  m_pairInfo = PairInfo::_standard_;
1520  m_set_parameters_binSize();
1521  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1522  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1523  }
1524 
1529  ~Pair2D_comovingPolar_loglin () = default;
1530 
1532 
1533 
1538 
1548  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
1549 
1558  void set (const int ir, const int jr, const double ww, const double weight=1) override;
1559 
1568  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
1569 
1571 
1572  };
1573 
1574 
1575  // ============================================================================================
1576  // ============================================================================================
1577 
1578 
1588  class Pair2D_comovingPolar_linlog : public virtual Pair2D_comovingPolar {
1589 
1590  protected:
1591 
1596 
1601  void m_set_parameters_nbins () override;
1602 
1607  void m_set_parameters_binSize () override;
1608 
1610 
1611  public:
1612 
1617 
1621  Pair2D_comovingPolar_linlog ()
1622  {
1623  m_pairType = PairType::_comovingPolar_linlog_;
1624  m_pairInfo = PairInfo::_standard_;
1625  }
1626 
1642  Pair2D_comovingPolar_linlog (const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1643  : Pair2D(1., nbins_D1, shift_D1, 1., nbins_D2, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, nbins_D1, shift_D1, muMin, muMax, nbins_D2, shift_D2, angularUnits, angularWeight)
1644  {
1645  m_pairType = PairType::_comovingPolar_linlog_;
1646  m_pairInfo = PairInfo::_standard_;
1647  m_set_parameters_nbins();
1648  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1649  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1650  }
1651 
1667  Pair2D_comovingPolar_linlog (const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1668  : Pair2D(binSize_D1, 50, shift_D1, binSize_D2, 50, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, binSize_D1, shift_D1, muMin, muMax, binSize_D2, shift_D2, angularUnits, angularWeight)
1669  {
1670  m_pairType = PairType::_comovingPolar_linlog_;
1671  m_pairInfo = PairInfo::_standard_;
1672  m_set_parameters_binSize();
1673  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1674  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1675  }
1676 
1681  ~Pair2D_comovingPolar_linlog () = default;
1682 
1684 
1685 
1690 
1700  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
1701 
1710  void set (const int ir, const int jr, const double ww, const double weight=1) override;
1711 
1720  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
1721 
1723 
1724  };
1725 
1726  // ============================================================================================
1727  // ============================================================================================
1728 
1729 
1739  class Pair2D_comovingPolar_loglog : public virtual Pair2D_comovingPolar {
1740 
1741  protected:
1742 
1747 
1752  void m_set_parameters_nbins () override;
1753 
1758  void m_set_parameters_binSize () override;
1759 
1761 
1762  public:
1763 
1768 
1772  Pair2D_comovingPolar_loglog ()
1773  {
1774  m_pairType = PairType::_comovingPolar_loglog_;
1775  m_pairInfo = PairInfo::_standard_;
1776  }
1777 
1793  Pair2D_comovingPolar_loglog (const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1794  : Pair2D(1., nbins_D1, shift_D1, 1., nbins_D2, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, nbins_D1, shift_D1, muMin, muMax, nbins_D2, shift_D2, angularUnits, angularWeight)
1795  {
1796  m_pairType = PairType::_comovingPolar_loglog_;
1797  m_pairInfo = PairInfo::_standard_;
1798  m_set_parameters_nbins();
1799  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1800  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1801  }
1802 
1818  Pair2D_comovingPolar_loglog (const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function<double(double)> angularWeight=nullptr)
1819  : Pair2D(binSize_D1, 50, shift_D1, binSize_D2, 50, shift_D2, angularUnits, angularWeight), Pair2D_comovingPolar(rMin, rMax, binSize_D1, shift_D1, muMin, muMax, binSize_D2, shift_D2, angularUnits, angularWeight)
1820  {
1821  m_pairType = PairType::_comovingPolar_loglog_;
1822  m_pairInfo = PairInfo::_standard_;
1823  m_set_parameters_binSize();
1824  m_PP2D.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1825  m_PP2D_weighted.resize(m_nbins_D1+1, std::vector<double>(m_nbins_D2+1, 0.));
1826  }
1827 
1832  ~Pair2D_comovingPolar_loglog () = default;
1833 
1835 
1836 
1841 
1851  void get (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2, int &ir, int &jr, double &ww) override;
1852 
1861  void set (const int ir, const int jr, const double ww, const double weight=1) override;
1862 
1871  void put (const std::shared_ptr<catalogue::Object> obj1, const std::shared_ptr<catalogue::Object> obj2) override;
1872 
1874 
1875  };
1876  }
1877 }
1878 
1879 #endif
Pair.h
The class Pair.
cbl::pairs::Pair2D_comovingCartesian_linlin
The class Pair2D_comovingCartesian_linlin.
Definition: Pair2D.h:515
cbl::pairs::Pair2D_comovingCartesian_linlin::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:607
cbl::pairs::Pair2D_comovingCartesian_linlin::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:59
cbl::pairs::Pair2D_comovingCartesian_linlin::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:78
cbl::pairs::Pair2D_comovingCartesian_linlin::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:399
cbl::pairs::Pair2D_comovingCartesian_linlin::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:791
cbl::pairs::Pair2D_comovingCartesian_linlin::~Pair2D_comovingCartesian_linlin
~Pair2D_comovingCartesian_linlin()=default
default destructor
cbl::pairs::Pair2D_comovingCartesian_linlin::Pair2D_comovingCartesian_linlin
Pair2D_comovingCartesian_linlin(const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:571
cbl::pairs::Pair2D_comovingCartesian_linlin::Pair2D_comovingCartesian_linlin
Pair2D_comovingCartesian_linlin(const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:598
cbl::pairs::Pair2D_comovingCartesian_linlin::Pair2D_comovingCartesian_linlin
Pair2D_comovingCartesian_linlin()
default constructor
Definition: Pair2D.h:548
cbl::pairs::Pair2D_comovingCartesian_linlog
The class Pair2D_comovingCartesian_linlog.
Definition: Pair2D.h:826
cbl::pairs::Pair2D_comovingCartesian_linlog::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:803
cbl::pairs::Pair2D_comovingCartesian_linlog::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:630
cbl::pairs::Pair2D_comovingCartesian_linlog::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:425
cbl::pairs::Pair2D_comovingCartesian_linlog::Pair2D_comovingCartesian_linlog
Pair2D_comovingCartesian_linlog(const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:909
cbl::pairs::Pair2D_comovingCartesian_linlog::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:119
cbl::pairs::Pair2D_comovingCartesian_linlog::Pair2D_comovingCartesian_linlog
Pair2D_comovingCartesian_linlog()
default constructor
Definition: Pair2D.h:859
cbl::pairs::Pair2D_comovingCartesian_linlog::~Pair2D_comovingCartesian_linlog
~Pair2D_comovingCartesian_linlog()=default
default destructor
cbl::pairs::Pair2D_comovingCartesian_linlog::Pair2D_comovingCartesian_linlog
Pair2D_comovingCartesian_linlog(const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:882
cbl::pairs::Pair2D_comovingCartesian_linlog::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:97
cbl::pairs::Pair2D_comovingCartesian_loglin
The class Pair2D_comovingCartesian_loglin.
Definition: Pair2D.h:671
cbl::pairs::Pair2D_comovingCartesian_loglin::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:452
cbl::pairs::Pair2D_comovingCartesian_loglin::Pair2D_comovingCartesian_loglin
Pair2D_comovingCartesian_loglin(const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:727
cbl::pairs::Pair2D_comovingCartesian_loglin::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:653
cbl::pairs::Pair2D_comovingCartesian_loglin::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:163
cbl::pairs::Pair2D_comovingCartesian_loglin::~Pair2D_comovingCartesian_loglin
~Pair2D_comovingCartesian_loglin()=default
default destructor
cbl::pairs::Pair2D_comovingCartesian_loglin::Pair2D_comovingCartesian_loglin
Pair2D_comovingCartesian_loglin(const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:754
cbl::pairs::Pair2D_comovingCartesian_loglin::Pair2D_comovingCartesian_loglin
Pair2D_comovingCartesian_loglin()
default constructor
Definition: Pair2D.h:704
cbl::pairs::Pair2D_comovingCartesian_loglin::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:815
cbl::pairs::Pair2D_comovingCartesian_loglin::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:141
cbl::pairs::Pair2D_comovingCartesian_loglog
The class Pair2D_comovingCartesian_loglog.
Definition: Pair2D.h:981
cbl::pairs::Pair2D_comovingCartesian_loglog::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:207
cbl::pairs::Pair2D_comovingCartesian_loglog::Pair2D_comovingCartesian_loglog
Pair2D_comovingCartesian_loglog()
default constructor
Definition: Pair2D.h:1014
cbl::pairs::Pair2D_comovingCartesian_loglog::Pair2D_comovingCartesian_loglog
Pair2D_comovingCartesian_loglog(const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1064
cbl::pairs::Pair2D_comovingCartesian_loglog::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:185
cbl::pairs::Pair2D_comovingCartesian_loglog::~Pair2D_comovingCartesian_loglog
~Pair2D_comovingCartesian_loglog()=default
default destructor
cbl::pairs::Pair2D_comovingCartesian_loglog::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:827
cbl::pairs::Pair2D_comovingCartesian_loglog::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:676
cbl::pairs::Pair2D_comovingCartesian_loglog::Pair2D_comovingCartesian_loglog
Pair2D_comovingCartesian_loglog(const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1037
cbl::pairs::Pair2D_comovingCartesian_loglog::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:478
cbl::pairs::Pair2D_comovingCartesian
The class Pair2D_comovingCartesian.
Definition: Pair2D.h:359
cbl::pairs::Pair2D_comovingCartesian::sMin_D2
double sMin_D2() const override
get the protected member Pair2D::m_piMin
Definition: Pair2D.h:488
cbl::pairs::Pair2D_comovingCartesian::sMax_D2
double sMax_D2() const override
get the protected member Pair2D::m_piMax
Definition: Pair2D.h:495
cbl::pairs::Pair2D_comovingCartesian::m_rpMin
double m_rpMin
minimum perpendicular separation used to count the pairs
Definition: Pair2D.h:389
cbl::pairs::Pair2D_comovingCartesian::~Pair2D_comovingCartesian
virtual ~Pair2D_comovingCartesian()=default
default destructor
cbl::pairs::Pair2D_comovingCartesian::m_piMin
double m_piMin
minimum parallel separation used to count the pairs
Definition: Pair2D.h:395
cbl::pairs::Pair2D_comovingCartesian::Pair2D_comovingCartesian
Pair2D_comovingCartesian(const double rpMin, const double rpMax, const int nbins_rp, const double shift_rp, const double piMin, const double piMax, const int nbins_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:432
cbl::pairs::Pair2D_comovingCartesian::Pair2D_comovingCartesian
Pair2D_comovingCartesian(const double rpMin, const double rpMax, const double binSize_rp, const double shift_rp, const double piMin, const double piMax, const double binSize_pi, const double shift_pi, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:453
cbl::pairs::Pair2D_comovingCartesian::Pair2D_comovingCartesian
Pair2D_comovingCartesian()
default constructor
Definition: Pair2D.h:413
cbl::pairs::Pair2D_comovingCartesian::sMax_D1
double sMax_D1() const override
get the protected member Pair2D::m_rpMax
Definition: Pair2D.h:481
cbl::pairs::Pair2D_comovingCartesian::m_piMax
double m_piMax
maximum parallel separation used to count the pairs
Definition: Pair2D.h:398
cbl::pairs::Pair2D_comovingCartesian::sMin_D1
double sMin_D1() const override
get the protected member Pair2D::m_rpMin
Definition: Pair2D.h:474
cbl::pairs::Pair2D_comovingCartesian::m_rpMax
double m_rpMax
maximum perpendicular separation used to count the pairs
Definition: Pair2D.h:392
cbl::pairs::Pair2D_comovingCartesian::m_set_parameters_binSize
virtual void m_set_parameters_binSize()=0
set the binning parameters given the bin size
cbl::pairs::Pair2D_comovingCartesian::m_set_parameters_nbins
virtual void m_set_parameters_nbins()=0
set the binning parameters given the number of bins
cbl::pairs::Pair2D_comovingPolar_linlin
The class Pair2D_comovingPolar_linlin.
Definition: Pair2D.h:1284
cbl::pairs::Pair2D_comovingPolar_linlin::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:229
cbl::pairs::Pair2D_comovingPolar_linlin::Pair2D_comovingPolar_linlin
Pair2D_comovingPolar_linlin()
default constructor
Definition: Pair2D.h:1317
cbl::pairs::Pair2D_comovingPolar_linlin::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:839
cbl::pairs::Pair2D_comovingPolar_linlin::~Pair2D_comovingPolar_linlin
~Pair2D_comovingPolar_linlin()=default
default destructor
cbl::pairs::Pair2D_comovingPolar_linlin::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:699
cbl::pairs::Pair2D_comovingPolar_linlin::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:504
cbl::pairs::Pair2D_comovingPolar_linlin::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:248
cbl::pairs::Pair2D_comovingPolar_linlin::Pair2D_comovingPolar_linlin
Pair2D_comovingPolar_linlin(const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1363
cbl::pairs::Pair2D_comovingPolar_linlin::Pair2D_comovingPolar_linlin
Pair2D_comovingPolar_linlin(const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1338
cbl::pairs::Pair2D_comovingPolar_linlog
The class Pair2D_comovingPolar_linlog.
Definition: Pair2D.h:1588
cbl::pairs::Pair2D_comovingPolar_linlog::Pair2D_comovingPolar_linlog
Pair2D_comovingPolar_linlog(const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1642
cbl::pairs::Pair2D_comovingPolar_linlog::~Pair2D_comovingPolar_linlog
~Pair2D_comovingPolar_linlog()=default
default destructor
cbl::pairs::Pair2D_comovingPolar_linlog::Pair2D_comovingPolar_linlog
Pair2D_comovingPolar_linlog(const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1667
cbl::pairs::Pair2D_comovingPolar_linlog::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:722
cbl::pairs::Pair2D_comovingPolar_linlog::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:289
cbl::pairs::Pair2D_comovingPolar_linlog::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:530
cbl::pairs::Pair2D_comovingPolar_linlog::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:851
cbl::pairs::Pair2D_comovingPolar_linlog::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:267
cbl::pairs::Pair2D_comovingPolar_linlog::Pair2D_comovingPolar_linlog
Pair2D_comovingPolar_linlog()
default constructor
Definition: Pair2D.h:1621
cbl::pairs::Pair2D_comovingPolar_loglin
The class Pair2D_comovingPolar_loglin.
Definition: Pair2D.h:1436
cbl::pairs::Pair2D_comovingPolar_loglin::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:311
cbl::pairs::Pair2D_comovingPolar_loglin::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:333
cbl::pairs::Pair2D_comovingPolar_loglin::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:745
cbl::pairs::Pair2D_comovingPolar_loglin::Pair2D_comovingPolar_loglin
Pair2D_comovingPolar_loglin(const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1515
cbl::pairs::Pair2D_comovingPolar_loglin::Pair2D_comovingPolar_loglin
Pair2D_comovingPolar_loglin(const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1490
cbl::pairs::Pair2D_comovingPolar_loglin::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:863
cbl::pairs::Pair2D_comovingPolar_loglin::Pair2D_comovingPolar_loglin
Pair2D_comovingPolar_loglin()
default constructor
Definition: Pair2D.h:1469
cbl::pairs::Pair2D_comovingPolar_loglin::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:555
cbl::pairs::Pair2D_comovingPolar_loglin::~Pair2D_comovingPolar_loglin
~Pair2D_comovingPolar_loglin()=default
default destructor
cbl::pairs::Pair2D_comovingPolar_loglog
The class Pair2D_comovingPolar_loglog.
Definition: Pair2D.h:1739
cbl::pairs::Pair2D_comovingPolar_loglog::put
void put(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2) override
estimate the distance between two objects and update the pair vector accordingly
Definition: Pair2D.cpp:768
cbl::pairs::Pair2D_comovingPolar_loglog::set
void set(const int ir, const int jr, const double ww, const double weight=1) override
set the pair vector
Definition: Pair2D.cpp:875
cbl::pairs::Pair2D_comovingPolar_loglog::~Pair2D_comovingPolar_loglog
~Pair2D_comovingPolar_loglog()=default
default destructor
cbl::pairs::Pair2D_comovingPolar_loglog::m_set_parameters_binSize
void m_set_parameters_binSize() override
set the binning parameters given the bin size
Definition: Pair2D.cpp:377
cbl::pairs::Pair2D_comovingPolar_loglog::Pair2D_comovingPolar_loglog
Pair2D_comovingPolar_loglog(const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1793
cbl::pairs::Pair2D_comovingPolar_loglog::Pair2D_comovingPolar_loglog
Pair2D_comovingPolar_loglog(const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1818
cbl::pairs::Pair2D_comovingPolar_loglog::get
void get(const std::shared_ptr< catalogue::Object > obj1, const std::shared_ptr< catalogue::Object > obj2, int &ir, int &jr, double &ww) override
get the pair index and weight
Definition: Pair2D.cpp:581
cbl::pairs::Pair2D_comovingPolar_loglog::m_set_parameters_nbins
void m_set_parameters_nbins() override
set the binning parameters given the number of bins
Definition: Pair2D.cpp:355
cbl::pairs::Pair2D_comovingPolar_loglog::Pair2D_comovingPolar_loglog
Pair2D_comovingPolar_loglog()
default constructor
Definition: Pair2D.h:1772
cbl::pairs::Pair2D_comovingPolar
The class Pair2D_comovingPolar.
Definition: Pair2D.h:1136
cbl::pairs::Pair2D_comovingPolar::Pair2D_comovingPolar
Pair2D_comovingPolar(const double rMin, const double rMax, const int nbins_D1, const double shift_D1, const double muMin, const double muMax, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1207
cbl::pairs::Pair2D_comovingPolar::m_rMin
double m_rMin
minimum separation used to count the pairs
Definition: Pair2D.h:1166
cbl::pairs::Pair2D_comovingPolar::m_rMax
double m_rMax
maximum separation used to count the pairs
Definition: Pair2D.h:1169
cbl::pairs::Pair2D_comovingPolar::m_muMin
double m_muMin
minimum angle used to count the pairs
Definition: Pair2D.h:1172
cbl::pairs::Pair2D_comovingPolar::m_set_parameters_nbins
virtual void m_set_parameters_nbins()=0
set the binning parameters given the number of bins
cbl::pairs::Pair2D_comovingPolar::m_muMax
double m_muMax
maximum angle used to count the pairs
Definition: Pair2D.h:1175
cbl::pairs::Pair2D_comovingPolar::sMax_D2
double sMax_D2() const override
get the protected member Pair2D::m_muMax
Definition: Pair2D.h:1264
cbl::pairs::Pair2D_comovingPolar::m_set_parameters_binSize
virtual void m_set_parameters_binSize()=0
set the binning parameters given the bin size
cbl::pairs::Pair2D_comovingPolar::sMin_D1
double sMin_D1() const override
get the protected member Pair2D::m_rMin
Definition: Pair2D.h:1246
cbl::pairs::Pair2D_comovingPolar::Pair2D_comovingPolar
Pair2D_comovingPolar()=default
default constructor
cbl::pairs::Pair2D_comovingPolar::~Pair2D_comovingPolar
virtual ~Pair2D_comovingPolar()=default
default destructor
cbl::pairs::Pair2D_comovingPolar::sMin_D2
double sMin_D2() const override
get the protected member Pair2D::m_muMin
Definition: Pair2D.h:1258
cbl::pairs::Pair2D_comovingPolar::sMax_D1
double sMax_D1() const override
get the protected member Pair2D::m_rMax
Definition: Pair2D.h:1252
cbl::pairs::Pair2D_comovingPolar::Pair2D_comovingPolar
Pair2D_comovingPolar(const double rMin, const double rMax, const double binSize_D1, const double shift_D1, const double muMin, const double muMax, const double binSize_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:1225
cbl::pairs::Pair2D
The class Pair2D.
Definition: Pair2D.h:56
cbl::pairs::Pair2D::PP2D_weighted
double PP2D_weighted(const int i, const int j) const override
get the protected member m_PP2D_weighted[i]
Definition: Pair2D.h:207
cbl::pairs::Pair2D::scale_D1
std::vector< double > scale_D1() const override
get the protected member m_scale_D1
Definition: Pair2D.h:172
cbl::pairs::Pair2D::Sum
void Sum(const std::shared_ptr< Pair > pp, const double ww=1) override
sum the number of binned pairs
Definition: Pair2D.cpp:912
cbl::pairs::Pair2D::m_scale_D2
std::vector< double > m_scale_D2
the binned scales in the second dimension
Definition: Pair2D.h:84
cbl::pairs::Pair2D::Pair2D
Pair2D(const double binSize_D1, const int nbins_D1, const double shift_D1, const double binSize_D2, const int nbins_D2, const double shift_D2, const CoordinateUnits angularUnits=CoordinateUnits::_radians_, std::function< double(double)> angularWeight=nullptr)
constructor
Definition: Pair2D.h:144
cbl::pairs::Pair2D::PP2D_weighted
std::vector< std::vector< double > > PP2D_weighted() const override
get the protected member m_PP2D_weighted
Definition: Pair2D.h:214
cbl::pairs::Pair2D::shift_D1
double shift_D1() const override
get the protected member Pair2D::m_shift_D1
Definition: Pair2D.h:233
cbl::pairs::Pair2D::m_binSize_inv_D1
double m_binSize_inv_D1
the inverse of the bin size in the first dimension
Definition: Pair2D.h:98
cbl::pairs::Pair2D::binSize_inv_D2
double binSize_inv_D2() const override
get the protected member Pair2D::m_binSize_inv_D2
Definition: Pair2D.h:239
cbl::pairs::Pair2D::m_nbins_D2
int m_nbins_D2
number of bins in the second dimension
Definition: Pair2D.h:110
cbl::pairs::Pair2D::~Pair2D
virtual ~Pair2D()=default
default destructor
cbl::pairs::Pair2D::nbins_D2
int nbins_D2() const override
get the protected member Pair2D::m_nbins_D2
Definition: Pair2D.h:245
cbl::pairs::Pair2D::PP2D
std::vector< std::vector< double > > PP2D() const override
get the protected member m_PP2D
Definition: Pair2D.h:199
cbl::pairs::Pair2D::m_PP2D
std::vector< std::vector< double > > m_PP2D
the number of binned pairs
Definition: Pair2D.h:87
cbl::pairs::Pair2D::m_PP2D_weighted
std::vector< std::vector< double > > m_PP2D_weighted
the weighted number of binned pairs
Definition: Pair2D.h:90
cbl::pairs::Pair2D::reset
void reset() override
reset the pair counts
Definition: Pair2D.cpp:46
cbl::pairs::Pair2D::scale_D2
std::vector< double > scale_D2() const override
get the protected member m_scale_D2
Definition: Pair2D.h:185
cbl::pairs::Pair2D::set_PP2D
void set_PP2D(const int i, const int j, const double pp)
set the protected member Pair2D::m_PP2D[i][j]
Definition: Pair2D.h:295
cbl::pairs::Pair2D::m_set_parameters_binSize
virtual void m_set_parameters_binSize()=0
set the binning parameters given the bin size
cbl::pairs::Pair2D::m_nbins_D1
int m_nbins_D1
number of bins in the first dimension
Definition: Pair2D.h:101
cbl::pairs::Pair2D::binSize_inv_D1
double binSize_inv_D1() const override
get the protected member Pair2D::m_binSize_inv_D1
Definition: Pair2D.h:220
cbl::pairs::Pair2D::m_shift_D1
double m_shift_D1
radial shift used to centre the output bins in the first dimension
Definition: Pair2D.h:104
cbl::pairs::Pair2D::shift_D2
double shift_D2() const override
get the protected member Pair2D::m_shift_D2
Definition: Pair2D.h:252
cbl::pairs::Pair2D::set_scale_D2
void set_scale_D2(const int i, const double pp)
set the protected member Pair2D::m_scale_D2[i]
Definition: Pair2D.h:286
cbl::pairs::Pair2D::m_set_parameters_nbins
virtual void m_set_parameters_nbins()=0
set the binning parameters given the number of bins
cbl::pairs::Pair2D::scale_D2
double scale_D2(const int i) const override
get the protected member m_scale_D2[i]
Definition: Pair2D.h:179
cbl::pairs::Pair2D::m_binSize_inv_D2
double m_binSize_inv_D2
the inverse of the bin size in the second dimension
Definition: Pair2D.h:107
cbl::pairs::Pair2D::nbins_D1
int nbins_D1() const override
get the protected member Pair2D::m_nbins_D1
Definition: Pair2D.h:226
cbl::pairs::Pair2D::m_shift_D2
double m_shift_D2
radial shift used to centre the output bins in the second dimension
Definition: Pair2D.h:113
cbl::pairs::Pair2D::Pair2D
Pair2D()
default constructor
Definition: Pair2D.h:127
cbl::pairs::Pair2D::set_scale_D1
void set_scale_D1(const int i, const double pp)
set the protected member Pair2D::m_scale_D1[i]
Definition: Pair2D.h:278
cbl::pairs::Pair2D::add_data2D
void add_data2D(const int i, const int j, const std::vector< double > data) override
set the protected members by adding new data
Definition: Pair2D.cpp:887
cbl::pairs::Pair2D::scale_D1
double scale_D1(const int i) const override
get the protected member m_scale_D1[i]
Definition: Pair2D.h:166
cbl::pairs::Pair2D::m_scale_D1
std::vector< double > m_scale_D1
the binned scales in the first dimension
Definition: Pair2D.h:81
cbl::pairs::Pair2D::set_PP2D_weighted
void set_PP2D_weighted(const int i, const int j, const double pp)
set the protected member Pair2D::m_PP2D_weighted[i][j]
Definition: Pair2D.h:304
cbl::pairs::Pair2D::PP2D
double PP2D(const int i, const int j) const override
get the protected member m_PP2D[i]
Definition: Pair2D.h:193
cbl::pairs::Pair
The class Pair.
Definition: Pair.h:144
cbl::pairs::Pair::m_angularWeight
FunctionDoubleDouble m_angularWeight
angular weight function
Definition: Pair.h:181
cbl::pairs::Pair::m_pairInfo
PairInfo m_pairInfo
pair info
Definition: Pair.h:175
cbl::pairs::Pair::angularWeight
FunctionDoubleDouble angularWeight()
get the m_angularWeight function
Definition: Pair.h:354
cbl::pairs::Pair::angularUnits
CoordinateUnits angularUnits()
get the angular units
Definition: Pair.h:348
cbl::pairs::Pair::m_pairType
PairType m_pairType
pair type
Definition: Pair.h:172
cbl::pairs::Pair::m_angularUnits
CoordinateUnits m_angularUnits
angular units
Definition: Pair.h:178
cbl::pairs::Pair::m_pairDim
Dim m_pairDim
pair dimension
Definition: Pair.h:169
cbl::pairs::PairType::_comovingCartesian_linlin_
@ _comovingCartesian_linlin_
2D pair in comoving Cartesian coordinates (rp, π) in linear-linear bins
cbl::pairs::PairType::_comovingPolar_loglog_
@ _comovingPolar_loglog_
2D pair in comoving polar coordinates (r, μ) in logarithmic-logarithmic bins
cbl::pairs::PairType::_comovingCartesian_loglog_
@ _comovingCartesian_loglog_
2D pair in comoving Cartesian coordinates (rp, π) in logarithmic-logarithmic bins
cbl::pairs::PairType::_comovingPolar_loglin_
@ _comovingPolar_loglin_
2D pair in comoving polar coordinates (r, μ) in logarithmic-linear bins
cbl::pairs::PairType::_comovingCartesian_linlog_
@ _comovingCartesian_linlog_
2D pair in comoving Cartesian coordinates (rp, π) in linear-logarithmic bins
cbl::pairs::PairType::_comovingPolar_linlin_
@ _comovingPolar_linlin_
2D pair in comoving polar coordinates (r, μ) in linear-linear bins
cbl::pairs::PairType::_comovingCartesian_loglin_
@ _comovingCartesian_loglin_
2D pair in comoving Cartesian coordinates (rp, π) in logarithmic-linear bins
cbl::pairs::PairType::_comovingPolar_linlog_
@ _comovingPolar_linlog_
2D pair in comoving polar coordinates (r, μ) in linear-logarithmic bins
cbl::pairs::PairInfo::_standard_
@ _standard_
standard: the object contains only the number of pairs
cbl
The global namespace of the CosmoBolognaLib
Definition: CAMB.h:38
cbl::checkDim
void checkDim(const std::vector< T > vect, const int val, const std::string vector, bool equal=true)
check if the dimension of a std::vector is equal/lower than an input value
Definition: Kernel.h:1532
cbl::CoordinateUnits
CoordinateUnits
the coordinate units
Definition: Kernel.h:562
cbl::CoordinateUnits::_radians_
@ _radians_
angle in radians
cbl::Dim::_2D_
@ _2D_
2D pair, used e.g. for 2D pairs, in Cartesian or polar coordinates