CosmoBolognaLib
Free Software C++/Python libraries for cosmological calculations
Pair2D.cpp
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 #include "Pair2D.h"
35 
36 using namespace std;
37 
38 using namespace cbl;
39 using namespace catalogue;
40 using namespace pairs;
41 
42 
43 // ============================================================================================
44 
45 
46 void cbl::pairs::Pair2D::reset ()
47 {
48  for (int i=0; i<m_nbins_D1; i++) {
49  for (int j=0; j<m_nbins_D2; j++) {
50  m_PP2D[i][j] = 0.;
51  m_PP2D_weighted[i][j] = 0;
52  }
53  }
54 }
55 
56 // ============================================================================================
57 
58 
59 void cbl::pairs::Pair2D_comovingCartesian_linlin::m_set_parameters_nbins ()
60 {
61  const double binSize_D1 = ((m_rpMax-m_rpMin)/m_nbins_D1);
62  m_binSize_inv_D1 = 1./binSize_D1;
63 
64  const double binSize_D2 = ((m_piMax-m_piMin)/m_nbins_D2);
65  m_binSize_inv_D2 = 1./binSize_D2;
66 
67  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
68  for (int i=0; i<m_nbins_D1; i++)
69  m_scale_D1[i] = (i+m_shift_D1)*binSize_D1+m_rpMin;
70  for (int i=0; i<m_nbins_D2; i++)
71  m_scale_D2[i] = (i+m_shift_D2)*binSize_D2+m_piMin;
72 }
73 
74 
75 // ============================================================================================
76 
77 
78 void cbl::pairs::Pair2D_comovingCartesian_linlin::m_set_parameters_binSize ()
79 {
80  m_nbins_D1 = nint((m_rpMax-m_rpMin)*m_binSize_inv_D1);
81  m_rpMax = m_nbins_D1/m_binSize_inv_D1+m_rpMin;
82 
83  m_nbins_D2 = nint((m_piMax-m_piMin)*m_binSize_inv_D2);
84  m_piMax = m_nbins_D2/m_binSize_inv_D2+m_piMin;
85 
86  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
87  for (int i=0; i<m_nbins_D1; i++)
88  m_scale_D1[i] = (i+m_shift_D1)/m_binSize_inv_D1+m_rpMin;
89  for (int i=0; i<m_nbins_D2; i++)
90  m_scale_D2[i] = (i+m_shift_D2)/m_binSize_inv_D2+m_piMin;
91 }
92 
93 
94 // ============================================================================================
95 
96 
97 void cbl::pairs::Pair2D_comovingCartesian_linlog::m_set_parameters_nbins ()
98 {
99  if (m_piMin<1.e-30)
100  ErrorCBL("m_piMin must be >0!", "m_set_parameters_nbins", "Pair2D.cpp");
101 
102  const double binSize_D1 = ((m_rpMax-m_rpMin)/m_nbins_D1);
103  m_binSize_inv_D1 = 1./binSize_D1;
104 
105  const double binSize_D2 = ((log10(m_piMax)-log10(m_piMin))/m_nbins_D2);
106  m_binSize_inv_D2 = 1./binSize_D2;
107 
108  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
109  for (int i=0; i<m_nbins_D1; i++)
110  m_scale_D1[i] = (i+m_shift_D1)*binSize_D1+m_rpMin;
111  for (int i=0; i<m_nbins_D2; i++)
112  m_scale_D2[i] = pow(10.,(i+m_shift_D2)*binSize_D2+log10(m_piMin));
113 }
114 
115 
116 // ============================================================================================
117 
118 
119 void cbl::pairs::Pair2D_comovingCartesian_linlog::m_set_parameters_binSize ()
120 {
121  if (m_piMin<1.e-30)
122  ErrorCBL("m_piMin must be >0!", "m_set_parameters_binSize", "Pair2D.cpp");
123 
124  m_nbins_D1 = nint((m_rpMax-m_rpMin)*m_binSize_inv_D1);
125  m_rpMax = m_nbins_D1/m_binSize_inv_D1+m_rpMin;
126 
127  m_nbins_D2 = nint((log10(m_piMax)-log10(m_piMin))*m_binSize_inv_D2);
128  m_piMax = pow(10.,m_nbins_D2/m_binSize_inv_D2+log10(m_piMin));
129 
130  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
131  for (int i=0; i<m_nbins_D1; i++)
132  m_scale_D1[i] = (i+m_shift_D1)/m_binSize_inv_D1+m_rpMin;
133  for (int i=0; i<m_nbins_D2; i++)
134  m_scale_D2[i] = pow(10.,(i+m_shift_D2)/m_binSize_inv_D2+log10(m_piMin));
135 }
136 
137 
138 // ============================================================================================
139 
140 
141 void cbl::pairs::Pair2D_comovingCartesian_loglin::m_set_parameters_nbins ()
142 {
143  if (m_rpMin<1.e-30)
144  ErrorCBL("m_rpMin must be >0!", "m_set_parameters_nbins", "Pair2D.cpp");
145 
146  const double binSize_D1 = ((log10(m_rpMax)-log10(m_rpMin))/m_nbins_D1);
147  m_binSize_inv_D1 = 1./binSize_D1;
148 
149  const double binSize_D2 = ((m_piMax-m_piMin)/m_nbins_D2);
150  m_binSize_inv_D2 = 1./binSize_D2;
151 
152  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
153  for (int i=0; i<m_nbins_D1; i++)
154  m_scale_D1[i] = pow(10.,(i+m_shift_D1)*binSize_D1+log10(m_rpMin));
155  for (int i=0; i<m_nbins_D2; i++)
156  m_scale_D2[i] = (i+m_shift_D2)*binSize_D2+m_piMin;
157 }
158 
159 
160 // ============================================================================================
161 
162 
163 void cbl::pairs::Pair2D_comovingCartesian_loglin::m_set_parameters_binSize ()
164 {
165  if (m_rpMin<1.e-30)
166  ErrorCBL("m_rpMin must be >0!", "m_set_parameters_binSize", "Pair2D.cpp");
167 
168  m_nbins_D1 = nint((log10(m_rpMax)-log10(m_rpMin))*m_binSize_inv_D1);
169  m_rpMax = pow(10.,m_nbins_D1/m_binSize_inv_D1+log10(m_rpMin));
170 
171  m_nbins_D2 = nint((m_piMax-m_piMin)*m_binSize_inv_D2);
172  m_piMax = m_nbins_D2/m_binSize_inv_D2+m_piMin;
173 
174  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
175  for (int i=0; i<m_nbins_D1; i++)
176  m_scale_D1[i] = pow(10.,(i+m_shift_D1)/m_binSize_inv_D1+log10(m_rpMin));
177  for (int i=0; i<m_nbins_D2; i++)
178  m_scale_D2[i] = (i+m_shift_D2)/m_binSize_inv_D2+m_piMin;
179 }
180 
181 
182 // ============================================================================================
183 
184 
185 void cbl::pairs::Pair2D_comovingCartesian_loglog::m_set_parameters_nbins ()
186 {
187  if (m_rpMin<1.e-30 || m_piMin<1.e-30)
188  ErrorCBL("m_rpMin and m_piMin must be >0!", "m_set_parameters_nbins", "Pair2D.cpp");
189 
190  const double binSize_D1 = ((log10(m_rpMax)-log10(m_rpMin))/m_nbins_D1);
191  m_binSize_inv_D1 = 1./binSize_D1;
192 
193  const double binSize_D2 = ((log10(m_piMax)-log10(m_piMin))/m_nbins_D2);
194  m_binSize_inv_D2 = 1./binSize_D2;
195 
196  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
197  for (int i=0; i<m_nbins_D1; i++)
198  m_scale_D1[i] = pow(10.,(i+m_shift_D1)*binSize_D1+log10(m_rpMin));
199  for (int i=0; i<m_nbins_D2; i++)
200  m_scale_D2[i] = pow(10.,(i+m_shift_D2)*binSize_D2+log10(m_piMin));
201 }
202 
203 
204 // ============================================================================================
205 
206 
207 void cbl::pairs::Pair2D_comovingCartesian_loglog::m_set_parameters_binSize ()
208 {
209  if (m_rpMin<1.e-30 || m_piMin<1.e-30)
210  ErrorCBL("m_rpMin and m_piMin must be >0!", "m_set_parameters_binSize", "Pair2D.cpp");
211 
212  m_nbins_D1 = nint((log10(m_rpMax)-log10(m_rpMin))*m_binSize_inv_D1);
213  m_rpMax = pow(10.,m_nbins_D1/m_binSize_inv_D1+log10(m_rpMin));
214 
215  m_nbins_D2 = nint((log10(m_piMax)-log10(m_piMin))*m_binSize_inv_D2);
216  m_piMax = pow(10.,m_nbins_D2/m_binSize_inv_D2+log10(m_piMin));
217 
218  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
219  for (int i=0; i<m_nbins_D1; i++)
220  m_scale_D1[i] = pow(10.,(i+m_shift_D1)/m_binSize_inv_D1+log10(m_rpMin));
221  for (int i=0; i<m_nbins_D2; i++)
222  m_scale_D2[i] = pow(10.,(i+m_shift_D2)/m_binSize_inv_D2+log10(m_piMin));
223 }
224 
225 
226 // ============================================================================================
227 
228 
229 void cbl::pairs::Pair2D_comovingPolar_linlin::m_set_parameters_nbins ()
230 {
231  const double binSize_D1 = ((m_rMax-m_rMin)/m_nbins_D1);
232  m_binSize_inv_D1 = 1./binSize_D1;
233 
234  const double binSize_D2 = ((m_muMax-m_muMin)/m_nbins_D2);
235  m_binSize_inv_D2 = 1./binSize_D2;
236 
237  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
238  for (int i=0; i<m_nbins_D1; i++)
239  m_scale_D1[i] = (i+m_shift_D1)*binSize_D1+m_rMin;
240  for (int i=0; i<m_nbins_D2; i++)
241  m_scale_D2[i] = (i+m_shift_D2)*binSize_D2+m_muMin;
242 }
243 
244 
245 // ============================================================================================
246 
247 
248 void cbl::pairs::Pair2D_comovingPolar_linlin::m_set_parameters_binSize ()
249 {
250  m_nbins_D1 = nint((m_rMax-m_rMin)*m_binSize_inv_D1);
251  m_rMax = m_nbins_D1/m_binSize_inv_D1+m_rMin;
252 
253  m_nbins_D2 = nint((m_muMax-m_muMin)*m_binSize_inv_D2);
254  m_muMax = m_nbins_D2/m_binSize_inv_D2+m_muMin;
255 
256  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
257  for (int i=0; i<m_nbins_D1; i++)
258  m_scale_D1[i] = (i+m_shift_D1)/m_binSize_inv_D1+m_rMin;
259  for (int i=0; i<m_nbins_D2; i++)
260  m_scale_D2[i] = (i+m_shift_D2)/m_binSize_inv_D2+m_muMin;
261 }
262 
263 
264 // ============================================================================================
265 
266 
267 void cbl::pairs::Pair2D_comovingPolar_linlog::m_set_parameters_nbins ()
268 {
269  if (m_muMin<1.e-30)
270  ErrorCBL("m_muMin must be >0!", "m_set_parameters_nbins", "Pair2D.cpp");
271 
272  const double binSize_D1 = ((m_rMax-m_rMin)/m_nbins_D1);
273  m_binSize_inv_D1 = 1./binSize_D1;
274 
275  const double binSize_D2 = ((log10(m_muMax)-log10(m_muMin))/m_nbins_D2);
276  m_binSize_inv_D2 = 1./binSize_D2;
277 
278  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
279  for (int i=0; i<m_nbins_D1; i++)
280  m_scale_D1[i] = (i+m_shift_D1)*binSize_D1+m_rMin;
281  for (int i=0; i<m_nbins_D2; i++)
282  m_scale_D2[i] = pow(10.,(i+m_shift_D2)*binSize_D2+log10(m_muMin));
283 }
284 
285 
286 // ============================================================================================
287 
288 
289 void cbl::pairs::Pair2D_comovingPolar_linlog::m_set_parameters_binSize ()
290 {
291  if (m_muMin<1.e-30)
292  ErrorCBL("m_muMin must be >0!", "m_set_parameters_binSize", "Pair2D.cpp");
293 
294  m_nbins_D1 = nint((m_rMax-m_rMin)*m_binSize_inv_D1);
295  m_rMax = m_nbins_D1/m_binSize_inv_D1+m_rMin;
296 
297  m_nbins_D2 = nint((log10(m_muMax)-log10(m_muMin))*m_binSize_inv_D2);
298  m_muMax = pow(10.,(m_nbins_D2-m_shift_D2)/m_binSize_inv_D2+log10(m_muMin));
299 
300  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
301  for (int i=0; i<m_nbins_D1; i++)
302  m_scale_D1[i] = (i+m_shift_D1)/m_binSize_inv_D1+m_rMin;
303  for (int i=0; i<m_nbins_D2; i++)
304  m_scale_D2[i] = pow(10.,(i+m_shift_D2)/m_binSize_inv_D2+log10(m_muMin));
305 }
306 
307 
308 // ============================================================================================
309 
310 
311 void cbl::pairs::Pair2D_comovingPolar_loglin::m_set_parameters_nbins ()
312 {
313  if (m_rMin<1.e-30)
314  ErrorCBL("m_rMin must be >0!", "m_set_parameters_nbins", "Pair2D.cpp");
315 
316  const double binSize_D1 = ((log10(m_rMax)-log10(m_rMin))/m_nbins_D1);
317  m_binSize_inv_D1 = 1./binSize_D1;
318 
319  const double binSize_D2 = ((m_muMax-m_muMin)/m_nbins_D2);
320  m_binSize_inv_D2 = 1./binSize_D2;
321 
322  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
323  for (int i=0; i<m_nbins_D1; i++)
324  m_scale_D1[i] = pow(10.,(i+m_shift_D1)*binSize_D1+log10(m_rMin));
325  for (int i=0; i<m_nbins_D2; i++)
326  m_scale_D2[i] = (i+m_shift_D2)*binSize_D2+m_muMin;
327 }
328 
329 
330 // ============================================================================================
331 
332 
333 void cbl::pairs::Pair2D_comovingPolar_loglin::m_set_parameters_binSize ()
334 {
335  if (m_rMin<1.e-30)
336  ErrorCBL("m_rMin must be >0!", "m_set_parameters_binSize", "Pair2D.cpp");
337 
338  m_nbins_D1 = nint((log10(m_rMax)-log10(m_rMin))*m_binSize_inv_D1);
339  m_rMax = pow(10.,m_nbins_D1/m_binSize_inv_D1+log10(m_rMin));
340 
341  m_nbins_D2 = nint((m_muMax-m_muMin)*m_binSize_inv_D2);
342  m_muMax = m_nbins_D2/m_binSize_inv_D2+m_muMin;
343 
344  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
345  for (int i=0; i<m_nbins_D1; i++)
346  m_scale_D1[i] = pow(10.,(i+m_shift_D1)/m_binSize_inv_D1+log10(m_rMin));
347  for (int i=0; i<m_nbins_D2; i++)
348  m_scale_D2[i] = (i+m_shift_D2)/m_binSize_inv_D2+m_muMin;
349 }
350 
351 
352 // ============================================================================================
353 
354 
355 void cbl::pairs::Pair2D_comovingPolar_loglog::m_set_parameters_nbins ()
356 {
357  if (m_rMin<1.e-30 || m_muMin<1.e-30)
358  ErrorCBL("m_rMin and m_muMin must be >0!", "m_set_parameters_nbins", "Pair2D.cpp");
359 
360  const double binSize_D1 = ((log10(m_rMax)-log10(m_rMin))/m_nbins_D1);
361  m_binSize_inv_D1 = 1./binSize_D1;
362 
363  const double binSize_D2 = ((log10(m_muMax)-log10(m_muMin))/m_nbins_D2);
364  m_binSize_inv_D2 = 1./binSize_D2;
365 
366  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
367  for (int i=0; i<m_nbins_D1; i++)
368  m_scale_D1[i] = pow(10.,(i+m_shift_D1)*binSize_D1+log10(m_rMin));
369  for (int i=0; i<m_nbins_D2; i++)
370  m_scale_D2[i] = pow(10.,(i+m_shift_D2)*binSize_D2+log10(m_muMin));
371 }
372 
373 
374 // ============================================================================================
375 
376 
377 void cbl::pairs::Pair2D_comovingPolar_loglog::m_set_parameters_binSize ()
378 {
379  if (m_rMin<1.e-30 || m_muMin<1.e-30)
380  ErrorCBL("m_rMin and m_muMin must be >0!", "m_set_parameters_binSize", "Pair2D.cpp");
381 
382  m_nbins_D1 = nint((log10(m_rMax)-log10(m_rMin))*m_binSize_inv_D1);
383  m_rMax = pow(10.,m_nbins_D1/m_binSize_inv_D1+log10(m_rMin));
384 
385  m_nbins_D2 = nint((log10(m_muMax)-log10(m_muMin))*m_binSize_inv_D2);
386  m_muMax = pow(10.,m_nbins_D2/m_binSize_inv_D2+log10(m_muMin));
387 
388  m_scale_D1.resize(m_nbins_D1); m_scale_D2.resize(m_nbins_D2);
389  for (int i=0; i<m_nbins_D1; i++)
390  m_scale_D1[i] = pow(10.,(i+m_shift_D1)/m_binSize_inv_D1+log10(m_rMin));
391  for (int i=0; i<m_nbins_D2; i++)
392  m_scale_D2[i] = pow(10.,(i+m_shift_D2)/m_binSize_inv_D2+log10(m_muMin));
393 }
394 
395 
396 // ============================================================================================
397 
398 
399 void cbl::pairs::Pair2D_comovingCartesian_linlin::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
400 {
401  ir = -1;
402  ir = -1;
403  ww = 0;
404 
405  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
406  const double pi = fabs(obj1->dc()-obj2->dc());
407 
408  if (m_rpMin<rp && rp<m_rpMax && m_piMin<=pi && pi<m_piMax) {
409 
410  ir = max(0, min(int((rp-m_rpMin)*m_binSize_inv_D1), m_nbins_D1));
411  jr = max(0, min(int((pi-m_piMin)*m_binSize_inv_D2), m_nbins_D2));
412 
413  const double angWeight = (m_angularWeight==nullptr) ? 1.
414  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
415 
416  ww = obj1->weight()*obj2->weight()*angWeight;
417 
418  }
419 }
420 
421 
422 // ============================================================================================
423 
424 
425 void cbl::pairs::Pair2D_comovingCartesian_linlog::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
426 {
427  ir = -1;
428  ir = -1;
429  ww = 0;
430 
431 
432  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
433  const double pi = fabs(obj1->dc()-obj2->dc());
434 
435  if (m_rpMin<rp && rp<m_rpMax && m_piMin<pi && pi<m_piMax) {
436 
437  ir = max(0, min(int((rp-m_rpMin)*m_binSize_inv_D1), m_nbins_D1));
438  jr = max(0, min(int((log10(pi)-log10(m_piMin))*m_binSize_inv_D2), m_nbins_D2));
439 
440  const double angWeight = (m_angularWeight==nullptr) ? 1.
441  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
442 
443  ww = obj1->weight()*obj2->weight()*angWeight;
444 
445  }
446 }
447 
448 
449 // ============================================================================================
450 
451 
452 void cbl::pairs::Pair2D_comovingCartesian_loglin::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
453 {
454  ir = -1;
455  ir = -1;
456  ww = 0;
457 
458  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
459  const double pi = fabs(obj1->dc()-obj2->dc());
460 
461  if (m_rpMin<rp && rp<m_rpMax && m_piMin<=pi && pi<m_piMax) {
462 
463  ir = max(0, min(int((log10(rp)-log10(m_rpMin))*m_binSize_inv_D1), m_nbins_D1));
464  jr = max(0, min(int((pi-m_piMin)*m_binSize_inv_D2), m_nbins_D2));
465 
466  const double angWeight = (m_angularWeight==nullptr) ? 1.
467  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
468 
469  ww = obj1->weight()*obj2->weight()*angWeight;
470 
471  }
472 }
473 
474 
475 // ============================================================================================
476 
477 
478 void cbl::pairs::Pair2D_comovingCartesian_loglog::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
479 {
480  ir = -1;
481  ir = -1;
482  ww = 0;
483 
484  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
485  const double pi = fabs(obj1->dc()-obj2->dc());
486 
487  if (m_rpMin<rp && rp<m_rpMax && m_piMin<pi && pi<m_piMax) {
488 
489  ir = max(0, min(int((log10(rp)-log10(m_rpMin))*m_binSize_inv_D1), m_nbins_D1));
490  jr = max(0, min(int((log10(pi)-log10(m_piMin))*m_binSize_inv_D2), m_nbins_D2));
491 
492  const double angWeight = (m_angularWeight==nullptr) ? 1.
493  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
494 
495  ww = obj1->weight()*obj2->weight()*angWeight;
496 
497  }
498 }
499 
500 
501 // ============================================================================================
502 
503 
504 void cbl::pairs::Pair2D_comovingPolar_linlin::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
505 {
506  ir = -1;
507  ir = -1;
508  ww = 0;
509 
510  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
511  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
512 
513  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
514 
515  ir = max(0, min(int((rr-m_rMin)*m_binSize_inv_D1), m_nbins_D1));
516  jr = max(0, min(int((mu-m_muMin)*m_binSize_inv_D2), m_nbins_D2));
517 
518  const double angWeight = (m_angularWeight==nullptr) ? 1.
519  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
520 
521  ww = obj1->weight()*obj2->weight()*angWeight;
522 
523  }
524 }
525 
526 
527 // ============================================================================================
528 
529 
530 void cbl::pairs::Pair2D_comovingPolar_linlog::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
531 {
532  ir = -1;
533  ir = -1;
534  ww = 0;
535 
536  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
537  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
538 
539  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
540 
541  ir = max(0, min(int((rr-m_rMin)*m_binSize_inv_D1), m_nbins_D1));
542  jr = max(0, min(int((log10(mu)-log10(m_muMin))*m_binSize_inv_D2), m_nbins_D2));
543 
544  const double angWeight = (m_angularWeight==nullptr) ? 1.
545  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
546 
547  ww = obj1->weight()*obj2->weight()*angWeight;
548  }
549 }
550 
551 
552 // ============================================================================================
553 
554 
555 void cbl::pairs::Pair2D_comovingPolar_loglin::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
556 {
557  ir = -1;
558  ir = -1;
559  ww = 0;
560 
561  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
562  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
563 
564  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
565 
566  ir = max(0, min(int((log10(rr)-log10(m_rMin))*m_binSize_inv_D1), m_nbins_D1));
567  jr = max(0, min(int((mu-m_muMin)*m_binSize_inv_D2), m_nbins_D2));
568 
569  const double angWeight = (m_angularWeight==nullptr) ? 1.
570  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
571 
572  ww = obj1->weight()*obj2->weight()*angWeight;
573 
574  }
575 }
576 
577 
578 // ============================================================================================
579 
580 
581 void cbl::pairs::Pair2D_comovingPolar_loglog::get (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2, int &ir, int &jr, double &ww)
582 {
583  ir = -1;
584  ir = -1;
585  ww = 0;
586 
587  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
588  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
589 
590  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
591 
592  ir = max(0, min(int((log10(rr)-log10(m_rMin))*m_binSize_inv_D1), m_nbins_D1));
593  jr = max(0, min(int((log10(mu)-log10(m_muMin))*m_binSize_inv_D2), m_nbins_D2));
594 
595  const double angWeight = (m_angularWeight==nullptr) ? 1.
596  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
597 
598  ww = obj1->weight()*obj2->weight()*angWeight;
599 
600  }
601 }
602 
603 
604 // ============================================================================================
605 
606 
607 void cbl::pairs::Pair2D_comovingCartesian_linlin::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
608 {
609  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
610  const double pi = fabs(obj1->dc()-obj2->dc());
611 
612  if (m_rpMin<rp && rp<m_rpMax && m_piMin<=pi && pi<m_piMax) {
613 
614  const int ir = max(0, min(int((rp-m_rpMin)*m_binSize_inv_D1), m_nbins_D1));
615  const int jr = max(0, min(int((pi-m_piMin)*m_binSize_inv_D2), m_nbins_D2));
616 
617  const double angWeight = (m_angularWeight==nullptr) ? 1.
618  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
619 
620  m_PP2D[ir][jr] ++;
621  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
622 
623  }
624 }
625 
626 
627 // ============================================================================================
628 
629 
630 void cbl::pairs::Pair2D_comovingCartesian_linlog::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
631 {
632  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
633  const double pi = fabs(obj1->dc()-obj2->dc());
634 
635  if (m_rpMin<rp && rp<m_rpMax && m_piMin<pi && pi<m_piMax) {
636 
637  const int ir = max(0, min(int((rp-m_rpMin)*m_binSize_inv_D1), m_nbins_D1));
638  const int jr = max(0, min(int((log10(pi)-log10(m_piMin))*m_binSize_inv_D2), m_nbins_D2));
639 
640  const double angWeight = (m_angularWeight==nullptr) ? 1.
641  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
642 
643  m_PP2D[ir][jr] ++;
644  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
645 
646  }
647 }
648 
649 
650 // ============================================================================================
651 
652 
653 void cbl::pairs::Pair2D_comovingCartesian_loglin::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
654 {
655  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
656  const double pi = fabs(obj1->dc()-obj2->dc());
657 
658  if (m_rpMin<rp && rp<m_rpMax && m_piMin<=pi && pi<m_piMax) {
659 
660  const int ir = max(0, min(int((log10(rp)-log10(m_rpMin))*m_binSize_inv_D1), m_nbins_D1));
661  const int jr = max(0, min(int((pi-m_piMin)*m_binSize_inv_D2), m_nbins_D2));
662 
663  const double angWeight = (m_angularWeight==nullptr) ? 1.
664  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
665 
666  m_PP2D[ir][jr] ++;
667  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
668 
669  }
670 }
671 
672 
673 // ============================================================================================
674 
675 
676 void cbl::pairs::Pair2D_comovingCartesian_loglog::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
677 {
678  const double rp = perpendicular_distance(obj1->ra(), obj2->ra(), obj1->dec(), obj2->dec(), obj1->dc(), obj2->dc());
679  const double pi = fabs(obj1->dc()-obj2->dc());
680 
681  if (m_rpMin<rp && rp<m_rpMax && m_piMin<pi && pi<m_piMax) {
682 
683  const int ir = max(0, min(int((log10(rp)-log10(m_rpMin))*m_binSize_inv_D1), m_nbins_D1));
684  const int jr = max(0, min(int((log10(pi)-log10(m_piMin))*m_binSize_inv_D2), m_nbins_D2));
685 
686  const double angWeight = (m_angularWeight==nullptr) ? 1.
687  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
688 
689  m_PP2D[ir][jr] ++;
690  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
691 
692  }
693 }
694 
695 
696 // ============================================================================================
697 
698 
699 void cbl::pairs::Pair2D_comovingPolar_linlin::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
700 {
701  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
702  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
703 
704  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
705 
706  const int ir = max(0, min(int((rr-m_rMin)*m_binSize_inv_D1), m_nbins_D1));
707  const int jr = max(0, min(int((mu-m_muMin)*m_binSize_inv_D2), m_nbins_D2));
708 
709  const double angWeight = (m_angularWeight==nullptr) ? 1.
710  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
711 
712  m_PP2D[ir][jr] ++;
713  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
714 
715  }
716 }
717 
718 
719 // ============================================================================================
720 
721 
722 void cbl::pairs::Pair2D_comovingPolar_linlog::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
723 {
724  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
725  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
726 
727  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
728 
729  const int ir = max(0, min(int((rr-m_rMin)*m_binSize_inv_D1), m_nbins_D1));
730  const int jr = max(0, min(int((log10(mu)-log10(m_muMin))*m_binSize_inv_D2), m_nbins_D2));
731 
732  const double angWeight = (m_angularWeight==nullptr) ? 1.
733  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
734 
735  m_PP2D[ir][jr] ++;
736  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
737 
738  }
739 }
740 
741 
742 // ============================================================================================
743 
744 
745 void cbl::pairs::Pair2D_comovingPolar_loglin::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
746 {
747  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
748  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
749 
750  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
751 
752  const int ir = max(0, min(int((log10(rr)-log10(m_rMin))*m_binSize_inv_D1), m_nbins_D1));
753  const int jr = max(0, min(int((mu-m_muMin)*m_binSize_inv_D2), m_nbins_D2));
754 
755  const double angWeight = (m_angularWeight==nullptr) ? 1.
756  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
757 
758  m_PP2D[ir][jr] ++;
759  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
760 
761  }
762 }
763 
764 
765 // ============================================================================================
766 
767 
768 void cbl::pairs::Pair2D_comovingPolar_loglog::put (const shared_ptr<Object> obj1, const shared_ptr<Object> obj2)
769 {
770  const double rr = Euclidean_distance(obj1->xx(), obj2->xx(), obj1->yy(), obj2->yy(), obj1->zz(), obj2->zz());
771  const double mu = fabs(obj1->dc()-obj2->dc())/rr;
772 
773  if (m_rMin<rr && rr<m_rMax && m_muMin<mu && mu<m_muMax) {
774 
775  const int ir = max(0, min(int((log10(rr)-log10(m_rMin))*m_binSize_inv_D1), m_nbins_D1));
776  const int jr = max(0, min(int((log10(mu)-log10(m_muMin))*m_binSize_inv_D2), m_nbins_D2));
777 
778  const double angWeight = (m_angularWeight==nullptr) ? 1.
779  : max(0., m_angularWeight(converted_angle(angular_distance(obj1->xx()/obj1->dc(), obj2->xx()/obj2->dc(), obj1->yy()/obj1->dc(), obj2->yy()/obj2->dc(), obj1->zz()/obj1->dc(), obj2->zz()/obj2->dc()), CoordinateUnits::_radians_, m_angularUnits)));
780 
781  m_PP2D[ir][jr] ++;
782  m_PP2D_weighted[ir][jr] += obj1->weight()*obj2->weight()*angWeight;
783 
784  }
785 }
786 
787 
788 // ============================================================================================
789 
790 
791 void cbl::pairs::Pair2D_comovingCartesian_linlin::set (const int ir, const int jr, const double ww, const double weight)
792 {
793  if (ir>-1 && jr>-1){
794  m_PP2D[ir][jr] += weight;
795  m_PP2D_weighted[ir][jr] += ww*weight;
796  }
797 }
798 
799 
800 // ============================================================================================
801 
802 
803 void cbl::pairs::Pair2D_comovingCartesian_linlog::set (const int ir, const int jr, const double ww, const double weight)
804 {
805  if (ir>-1 && jr>-1){
806  m_PP2D[ir][jr] += weight;
807  m_PP2D_weighted[ir][jr] += ww*weight;
808  }
809 }
810 
811 
812 // ============================================================================================
813 
814 
815 void cbl::pairs::Pair2D_comovingCartesian_loglin::set (const int ir, const int jr, const double ww, const double weight)
816 {
817  if (ir>-1 && jr>-1){
818  m_PP2D[ir][jr] += weight;
819  m_PP2D_weighted[ir][jr] += ww*weight;
820  }
821 }
822 
823 
824 // ============================================================================================
825 
826 
827 void cbl::pairs::Pair2D_comovingCartesian_loglog::set (const int ir, const int jr, const double ww, const double weight)
828 {
829  if (ir>-1 && jr>-1){
830  m_PP2D[ir][jr] += weight;
831  m_PP2D_weighted[ir][jr] += ww*weight;
832  }
833 }
834 
835 
836 // ============================================================================================
837 
838 
839 void cbl::pairs::Pair2D_comovingPolar_linlin::set (const int ir, const int jr, const double ww, const double weight)
840 {
841  if (ir>-1 && jr>-1){
842  m_PP2D[ir][jr] += weight;
843  m_PP2D_weighted[ir][jr] += ww*weight;
844  }
845 }
846 
847 
848 // ============================================================================================
849 
850 
851 void cbl::pairs::Pair2D_comovingPolar_linlog::set (const int ir, const int jr, const double ww, const double weight)
852 {
853  if (ir>-1 && jr>-1){
854  m_PP2D[ir][jr] += weight;
855  m_PP2D_weighted[ir][jr] += ww*weight;
856  }
857 }
858 
859 
860 // ============================================================================================
861 
862 
863 void cbl::pairs::Pair2D_comovingPolar_loglin::set (const int ir, const int jr, const double ww, const double weight)
864 {
865  if (ir>-1 && jr>-1){
866  m_PP2D[ir][jr] += weight;
867  m_PP2D_weighted[ir][jr] += ww*weight;
868  }
869 }
870 
871 
872 // ============================================================================================
873 
874 
875 void cbl::pairs::Pair2D_comovingPolar_loglog::set (const int ir, const int jr, const double ww, const double weight)
876 {
877  if (ir>-1 && jr>-1){
878  m_PP2D[ir][jr] += weight;
879  m_PP2D_weighted[ir][jr] += ww*weight;
880  }
881 }
882 
883 
884 // ============================================================================================
885 
886 
887 void cbl::pairs::Pair2D::add_data2D (const int i, const int j, const std::vector<double> data)
888 {
889  /*
890  checkDim(m_PP2D, i, j, "m_PP2D", false);
891  checkDim(m_PP2D_weighted, i, j, "m_PP2D_weighted", false);
892  checkDim(data, 1, "data");
893  */
894 
895  m_PP2D[i][j] += data[0];
896  m_PP2D_weighted[i][j] += data[1];
897 }
898 
899 
900 // ============================================================================================
901 
902 
903 void cbl::pairs::Pair2D::add_data2D (const int i, const int j, const std::shared_ptr<pairs::Pair> pair, const double ww)
904 {
905  add_data2D(i, j, {ww*pair->PP2D(i, j), ww*pair->PP2D_weighted(i, j)});
906 }
907 
908 
909 // ============================================================================================
910 
911 
912 void cbl::pairs::Pair2D::Sum (const std::shared_ptr<Pair> pair, const double ww)
913 {
914  if (m_nbins_D1 != pair->nbins_D1() || m_nbins_D2 != pair->nbins_D2())
915  ErrorCBL("dimension problems!", "Sum", "Pair2D.cpp");
916 
917  for (int i=0; i<m_nbins_D1; i++)
918  for (int j=0; j<m_nbins_D2; j++)
919  add_data2D(i, j, pair, ww);
920 }
921 
Pair2D.h
The classes Pair2D*.
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_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::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::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::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::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::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::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::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::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::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_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::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::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_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_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::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::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_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::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::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::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::reset
void reset() override
reset the pair counts
Definition: Pair2D.cpp:46
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::par::pi
static const double pi
: the ratio of a circle's circumference to its diameter
Definition: Constants.h:199
cbl
The global namespace of the CosmoBolognaLib
Definition: CAMB.h:38
cbl::Euclidean_distance
double Euclidean_distance(const double x1, const double x2, const double y1, const double y2, const double z1, const double z2)
the Euclidean distance in 3D relative to the origin (0,0,0), i.e. the Euclidean norm
Definition: Func.cpp:250
cbl::converted_angle
double converted_angle(const double angle, const CoordinateUnits inputUnits=CoordinateUnits::_radians_, const CoordinateUnits outputUnits=CoordinateUnits::_degrees_)
conversion to angle units
Definition: Func.cpp:192
cbl::angular_distance
double angular_distance(const double x1, const double x2, const double y1, const double y2, const double z1, const double z2)
the angular separation in 3D
Definition: Func.cpp:277
cbl::ErrorCBL
int ErrorCBL(const std::string msg, const std::string functionCBL, const std::string fileCBL, const cbl::glob::ExitCode exitCode=cbl::glob::ExitCode::_error_)
throw an exception: it is used for handling exceptions inside the CosmoBolognaLib
Definition: Kernel.h:780
cbl::nint
int nint(const T val)
the nearest integer
Definition: Kernel.h:915
cbl::perpendicular_distance
double perpendicular_distance(const double ra1, const double ra2, const double dec1, const double dec2, const double d1, const double d2)
the perpendicular separation, rp
Definition: Func.cpp:259