Belle II Software development
B2Vector3.h
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#pragma once
10
11
12#include <framework/logging/Logger.h>
13
14#include <TVector3.h>
15#include <Math/Vector3D.h>
16#include <string>
17#include <iostream> // std::cout, std::fixed
18#include <iomanip> // std::setprecision
19#include <typeinfo>
20#include <cmath>
21
22
23namespace Belle2 {
41 template<typename DataType>
42 class B2Vector3 {
43 protected:
45 static_assert(std::is_floating_point<DataType>::value, "B2Vector3 only works with floating point types");
47 DataType m_coordinates[3];
48 public:
50 typedef DataType value_type;
51
53 B2Vector3(void) : m_coordinates {static_cast<DataType>(0), static_cast<DataType>(0), static_cast<DataType>(0)} {};
55 B2Vector3(const DataType xVal, const DataType yVal, const DataType zVal): m_coordinates {xVal, yVal, zVal} {};
57 explicit B2Vector3(const DataType(& coords)[3]): m_coordinates {coords[0], coords[1], coords[2]} {};
59 explicit B2Vector3(const DataType(* coords)[3]): m_coordinates {(*coords)[0], (*coords)[1], (*coords)[2]} {};
61 // cppcheck-suppress noExplicitConstructor
62 B2Vector3(const TVector3& tVec3): m_coordinates {static_cast<DataType>(tVec3.X()), static_cast<DataType>(tVec3.Y()), static_cast<DataType>(tVec3.Z())} {};
64 // cppcheck-suppress noExplicitConstructor
65 B2Vector3(const TVector3* tVec3): m_coordinates {static_cast<DataType>(tVec3->X()), static_cast<DataType>(tVec3->Y()), static_cast<DataType>(tVec3->Z())} {};
67 explicit B2Vector3(const B2Vector3<DataType>& b2Vec3): m_coordinates {b2Vec3.X(), b2Vec3.Y(), b2Vec3.Z()} {};
69 explicit B2Vector3(const B2Vector3<DataType>* b2Vec3): m_coordinates {b2Vec3->X(), b2Vec3->Y(), b2Vec3->Z()} {};
71 // cppcheck-suppress noExplicitConstructor
72 template <typename OtherType> B2Vector3(const B2Vector3<OtherType>& b2Vec3):
73 m_coordinates {static_cast<DataType>(b2Vec3.X()), static_cast<DataType>(b2Vec3.Y()), static_cast<DataType>(b2Vec3.Z())} {};
75 template <typename OtherType> explicit B2Vector3(const B2Vector3<OtherType>* b2Vec3):
76 m_coordinates {static_cast<DataType>(b2Vec3->X()), static_cast<DataType>(b2Vec3->Y()), static_cast<DataType>(b2Vec3->Z())} {};
78 // cppcheck-suppress noExplicitConstructor
79 B2Vector3(const ROOT::Math::XYZVector& xyzVec): m_coordinates {static_cast<DataType>(xyzVec.X()), static_cast<DataType>(xyzVec.Y()), static_cast<DataType>(xyzVec.Z())} {};
81 // cppcheck-suppress noExplicitConstructor
82 B2Vector3(const ROOT::Math::XYZVector* xyzVec): m_coordinates {static_cast<DataType>(xyzVec->X()), static_cast<DataType>(xyzVec->Y()), static_cast<DataType>(xyzVec->Z())} {};
83
85 DataType operator()(unsigned i) const { return m_coordinates[i]; }
87 DataType operator[](unsigned i) const { return m_coordinates[i]; }
89 DataType& operator()(unsigned i) { return m_coordinates[i]; }
91 DataType& operator[](unsigned i) { return m_coordinates[i]; }
92
94 B2Vector3<DataType>& operator = (const B2Vector3<DataType>& b);
96 B2Vector3<DataType>& operator = (const TVector3& b);
98 B2Vector3<DataType>& operator = (const ROOT::Math::XYZVector& b);
99
101 operator TVector3() const { return GetTVector3(); }
103 operator ROOT::Math::XYZVector() const { return GetXYZVector(); }
104
106 bool operator == (const B2Vector3<DataType>& b) const { return X() == b.X() && Y() == b.Y() && Z() == b.Z(); }
108 bool operator == (const TVector3& b) const { return X() == b.X() && Y() == b.Y() && Z() == b.Z(); }
110 bool operator == (const ROOT::Math::XYZVector& b) const { return X() == b.X() && Y() == b.Y() && Z() == b.Z(); }
112 bool operator != (const B2Vector3<DataType>& b) const { return !(*this == b); }
114 bool operator != (const TVector3& b) const { return !(*this == b); }
116 bool operator != (const ROOT::Math::XYZVector& b) const { return !(*this == b); }
117
119 B2Vector3<DataType>& operator += (const B2Vector3<DataType>& b);
121 B2Vector3<DataType>& operator -= (const B2Vector3<DataType>& b);
123 B2Vector3<DataType>& operator *= (DataType a);
125 B2Vector3<DataType> operator - () const { return B2Vector3<DataType>(-X(), -Y(), -Z()); }
127 B2Vector3<DataType> operator + (const B2Vector3<DataType>& b) const
128 {
129 return B2Vector3<DataType>(X() + b.X(), Y() + b.Y(), Z() + b.Z());
130 }
132 B2Vector3<DataType> operator - (const B2Vector3<DataType>& b) const
133 {
134 return B2Vector3<DataType>(X() - b.X(), Y() - b.Y(), Z() - b.Z());
135 }
137 B2Vector3<DataType> operator * (DataType a) const
138 {
139 return B2Vector3<DataType>(a * X(), a * Y(), a * Z());
140 }
142 B2Vector3<DataType> operator / (DataType a) const
143 {
144 return B2Vector3<DataType>(X() / a, Y() / a, Z() / a);
145 }
147 DataType operator * (const B2Vector3<DataType>& b) const { return Dot(b); }
148
149
151 DataType Phi() const { return X() == 0 && Y() == 0 ? 0 : atan2(Y(), X()); }
153 DataType Theta() const { return X() == 0 && Y() == 0 && Z() == 0 ? 0 : atan2(Perp(), Z()); }
155 DataType CosTheta() const { const double pTot = Mag(); return pTot == 0 ? 1 : Z() / pTot; }
157 DataType Mag2() const { return X() * X() + Y() * Y() + Z() * Z(); }
159 DataType Mag() const { return std::hypot((double)Perp(), (double)Z()); }
160
162 void SetPhi(DataType phi)
163 {
164 const double perp = Perp();
165 SetX(perp * cos((double)phi));
166 SetY(perp * sin((double)phi));
167 }
168
170 void SetTheta(DataType theta)
171 {
172 const double ma = Mag();
173 const double ph = Phi();
174 const double ctheta = std::cos((double) theta);
175 const double stheta = std::sin((double) theta);
176 SetX(ma * stheta * std::cos(ph));
177 SetY(ma * stheta * std::cos(ph));
178 SetZ(ma * ctheta);
179 }
180
182 void SetMag(DataType mag)
183 {
184 double factor = Mag();
185 if (factor == 0) {
186 B2WARNING(name() << "::SetMag: zero vector can't be stretched");
187 } else {
188 factor = mag / factor;
189 SetX(X()*factor);
190 SetY(Y()*factor);
191 SetZ(Z()*factor);
192 }
193 }
194
196 DataType Perp2() const { return X() * X() + Y() * Y(); }
198 DataType Pt() const { return Perp(); }
200 DataType Perp() const { return std::hypot((double)X(), (double)Y()); }
201
203 void SetPerp(DataType r)
204 {
205 const double p = Perp();
206 if (p != 0.0) {
207 m_coordinates[0] *= r / p;
208 m_coordinates[1] *= r / p;
209 }
210 }
211
213 DataType Perp2(const B2Vector3<DataType>& axis) const
214 {
215 const double tot = axis.Mag2();
216 const double ss = Dot(axis);
217 double per = Mag2();
218 if (tot > 0.0) per -= ss * ss / tot;
219 if (per < 0) per = 0;
220 return per;
221 }
222
224 DataType Pt(const B2Vector3<DataType>& axis) const { return Perp(axis); }
226 DataType Perp(const B2Vector3<DataType>& axis) const { return std::sqrt(Perp2(axis)); }
228 DataType DeltaPhi(const B2Vector3<DataType>& v) const { return Mpi_pi(Phi() - v.Phi()); }
229
230
232 static DataType Mpi_pi(DataType angle)
233 {
234 if (std::isnan(angle)) {
235 B2ERROR(name() << "::Mpi_pi: function called with NaN");
236 return angle;
237 }
238 angle = std::remainder(angle, 2 * M_PI);
239 //for compatibility with ROOT we flip the sign for exactly pi
240 if (angle == M_PI) angle = -M_PI;
241 return angle;
242 }
243
245 DataType DeltaR(const B2Vector3<DataType>& v) const
246 {
247 const double deta = Eta() - v.Eta();
248 const double dphi = DeltaPhi(v);
249 return std::hypot(deta, dphi);
250 }
251
253 DataType DrEtaPhi(const B2Vector3<DataType>& v) const
254 {
255 return DeltaR(v);
256 }
257
259 void SetMagThetaPhi(DataType mag, DataType theta, DataType phi)
260 {
261 const double amag = std::abs(mag);
262 const double sinTheta = std::sin((double)theta);
263 m_coordinates[0] = amag * sinTheta * std::cos((double)phi);
264 m_coordinates[1] = amag * sinTheta * std::sin((double)phi);
265 m_coordinates[2] = amag * std::cos((double)theta);
266 }
267
269 B2Vector3<DataType> Unit() const
270 {
271 const double tot = Mag2();
272 B2Vector3<DataType> p(X(), Y(), Z());
273 return tot > 0.0 ? p *= (1.0 / std::sqrt(tot)) : p;
274 }
275
277 B2Vector3<DataType> Orthogonal() const
278 {
279 const double xVal = std::abs((double)X());
280 const double yVal = std::abs((double)Y());
281 const double zVal = std::abs((double)Z());
282 if (xVal < yVal) {
283 return xVal < zVal ? B2Vector3<DataType>(0, Z(), -Y()) : B2Vector3<DataType>(Y(), -X(), 0);
284 } else {
285 return yVal < zVal ? B2Vector3<DataType>(-Z(), 0, X()) : B2Vector3<DataType>(Y(), -X(), 0);
286 }
287 }
288
290 DataType Dot(const B2Vector3<DataType>& p) const
291 {
292 return X() * p.X() + Y() * p.Y() + Z() * p.Z();
293 }
294
296 B2Vector3<DataType> Cross(const B2Vector3<DataType>& p) const
297 {
298 return B2Vector3<DataType>(Y() * p.Z() - p.Y() * Z(), Z() * p.X() - p.Z() * X(), X() * p.Y() - p.X() * Y());
299 }
300
302 DataType Angle(const B2Vector3<DataType>& q) const
303 {
304 const double ptot2 = Mag2() * q.Mag2();
305 if (ptot2 <= 0) {
306 return 0.0;
307 } else {
308 double arg = Dot(q) / std::sqrt(ptot2);
309 if (arg > 1.0) arg = 1.0;
310 if (arg < -1.0) arg = -1.0;
311 return std::acos(arg);
312 }
313 }
314
319 DataType PseudoRapidity() const
320 {
321 const double cosTheta = CosTheta();
322 if (std::abs(cosTheta) < 1) return -0.5 * std::log((1.0 - cosTheta) / (1.0 + cosTheta));
323 if (Z() == 0) return 0;
324 //B2WARNING(name() << "::PseudoRapidity: transverse momentum = 0! return +/- 10e10");
325 if (Z() > 0) return 10e10;
326 else return -10e10;
327 }
328
329
331 DataType Eta() const { return PseudoRapidity(); }
332
333
335 void RotateX(DataType angle)
336 {
337 //rotate vector around X
338 const double s = std::sin((double)angle);
339 const double c = std::cos((double)angle);
340 const double yOld = Y();
341 m_coordinates[1] = c * yOld - s * Z();
342 m_coordinates[2] = s * yOld + c * Z();
343 }
344
345
347 void RotateY(DataType angle)
348 {
349 //rotate vector around Y
350 const double s = std::sin((double)angle);
351 const double c = std::cos((double)angle);
352 const double zOld = Z();
353 m_coordinates[0] = s * zOld + c * X();
354 m_coordinates[2] = c * zOld - s * X();
355 }
356
357
359 void RotateZ(DataType angle)
360 {
361 //rotate vector around Z
362 const double s = std::sin((double)angle);
363 const double c = std::cos((double)angle);
364 const double xOld = X();
365 m_coordinates[0] = c * xOld - s * Y();
366 m_coordinates[1] = s * xOld + c * Y();
367 }
368
370 void RotateUz(const B2Vector3<DataType>& NewUzVector)
371 {
372 // NewUzVector must be normalized !
373
374 const double u1 = NewUzVector.X();
375 const double u2 = NewUzVector.Y();
376 const double u3 = NewUzVector.Z();
377 double up = u1 * u1 + u2 * u2;
378
379 if (up) {
380 up = std::sqrt(up);
381 DataType px = X(), py = Y(), pz = Z();
382 m_coordinates[0] = (u1 * u3 * px - u2 * py + u1 * up * pz) / up;
383 m_coordinates[1] = (u2 * u3 * px + u1 * py + u2 * up * pz) / up;
384 m_coordinates[2] = (u3 * u3 * px - px + u3 * up * pz) / up;
385 } else if (u3 < 0.) {
386 m_coordinates[0] = -m_coordinates[0];
387 m_coordinates[2] = -m_coordinates[2];
388 }
389 }
390
399 void Rotate(DataType alpha, const B2Vector3<DataType>& v)
400 {
401 B2Vector3<DataType> n = v.Unit();
402 *this = (n * (n.Dot(*this)) + cos(alpha) * ((n.Cross(*this)).Cross(n)) + sin(alpha) * (n.Cross(*this)));
403 }
404
406 void Abs()
407 {
408 m_coordinates[0] = std::abs(m_coordinates[0]);
409 m_coordinates[1] = std::abs(m_coordinates[1]);
410 m_coordinates[2] = std::abs(m_coordinates[2]);
411 }
412
414 void Sqrt()
415 {
416 Abs();
417 m_coordinates[0] = std::sqrt(m_coordinates[0]);
418 m_coordinates[1] = std::sqrt(m_coordinates[1]);
419 m_coordinates[2] = std::sqrt(m_coordinates[2]);
420 }
421
423 DataType at(unsigned i) const;
425 DataType x() const { return m_coordinates[0]; }
427 DataType y() const { return m_coordinates[1]; }
429 DataType z() const { return m_coordinates[2]; }
431 DataType X() const { return x(); }
433 DataType Y() const { return y(); }
435 DataType Z() const { return z(); }
437 DataType Px() const { return x(); }
439 DataType Py() const { return y(); }
441 DataType Pz() const { return z(); }
442
444 void GetXYZ(Double_t* carray) const;
446 void GetXYZ(Float_t* carray) const;
448 void GetXYZ(TVector3* tVec) const;
450 void GetXYZ(ROOT::Math::XYZVector* xyzVec) const;
452 TVector3 GetTVector3() const;
454 ROOT::Math::XYZVector GetXYZVector() const;
455
457 void SetX(DataType x) { m_coordinates[0] = x; }
459 void SetY(DataType y) { m_coordinates[1] = y; }
461 void SetZ(DataType z) { m_coordinates[2] = z; }
462
464 void SetXYZ(DataType x, DataType y, DataType z)
465 {
466 SetX(x); SetY(y); SetZ(z);
467 }
469 void SetXYZ(const TVector3& tVec);
471 void SetXYZ(const TVector3* tVec);
473 void SetXYZ(const ROOT::Math::XYZVector& xyzVec);
475 void SetXYZ(const ROOT::Math::XYZVector* xyzVec);
476
478 static std::string name();
479
481 std::string PrintString(unsigned precision = 4) const
482 {
483 return name() + " " + PrintStringXYZ(precision) + " " + PrintStringCyl(precision);
484 }
485
487 std::string PrintStringXYZ(unsigned precision = 4) const
488 {
489 std::ostringstream output;
490 output << "(x,y,z)=("
491 << std::fixed << std::setprecision(precision)
492 << X() << "," << Y() << "," << Z() << ")";
493 return output.str();
494 }
495
497 std::string PrintStringCyl(unsigned precision = 4) const
498 {
499 std::ostringstream output;
500 output << "(rho, theta, phi)=("
501 << std::fixed << std::setprecision(precision)
502 << Mag() << "," << Theta() * 180. / M_PI << "," << Phi() * 180. / M_PI << ")";
503 return output.str();
504 }
505
507 void Print()
508 {
509 //print vector parameters
510 Print(PrintString().c_str());
511 }
512
513 };
514
516 typedef B2Vector3<double> B2Vector3D;
517
519 typedef B2Vector3<float> B2Vector3F;
520
522 template <typename DataType>
523 Bool_t operator == (const TVector3& a, const B2Vector3<DataType>& b)
524 {
525 return (a.X() == b.X() && a.Y() == b.Y() && a.Z() == b.Z());
526 }
527
529 template < typename DataType>
530 Bool_t operator != (const TVector3& a, const B2Vector3<DataType>& b)
531 {
532 return !(a == b);
533 }
534
536 template < typename DataType>
537 B2Vector3<DataType> operator * (DataType a, const B2Vector3<DataType>& p)
538 {
539 return B2Vector3<DataType>(a * p.X(), a * p.Y(), a * p.Z());
540 }
541
543 template < typename DataType>
544 B2Vector3<DataType> operator + (const TVector3& a, const B2Vector3<DataType>& b)
545 {
546 return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
547 }
548
550 template < typename DataType>
551 B2Vector3<DataType> operator - (const TVector3& a, const B2Vector3<DataType>& b)
552 {
553 return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
554 }
555
557 template < typename DataType>
558 B2Vector3<DataType> operator + (const B2Vector3<DataType>& a, const TVector3& b)
559 {
560 return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
561 }
562
564 template < typename DataType>
565 B2Vector3<DataType> operator - (const B2Vector3<DataType>& a, const TVector3& b)
566 {
567 return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
568 }
569
571 template < typename DataType>
572 B2Vector3<DataType> operator + (const ROOT::Math::XYZVector& a, const B2Vector3<DataType>& b)
573 {
574 return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
575 }
576
578 template < typename DataType>
579 B2Vector3<DataType> operator - (const ROOT::Math::XYZVector& a, const B2Vector3<DataType>& b)
580 {
581 return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
582 }
583
585 template < typename DataType>
586 B2Vector3<DataType> operator + (const B2Vector3<DataType>& a, const ROOT::Math::XYZVector& b)
587 {
588 return B2Vector3<DataType>(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
589 }
590
592 template < typename DataType>
593 B2Vector3<DataType> operator - (const B2Vector3<DataType>& a, const ROOT::Math::XYZVector& b)
594 {
595 return B2Vector3<DataType>(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
596 }
597
598
600 template< typename DataType >
601 B2Vector3<DataType>& B2Vector3<DataType>::operator = (const B2Vector3<DataType>& b)
602 {
603 m_coordinates[0] = b.X();
604 m_coordinates[1] = b.Y();
605 m_coordinates[2] = b.Z();
606 return *this;
607 }
608
610 template< typename DataType >
611 B2Vector3<DataType>& B2Vector3<DataType>::operator = (const TVector3& b)
612 {
613 m_coordinates[0] = b.X();
614 m_coordinates[1] = b.Y();
615 m_coordinates[2] = b.Z();
616 return *this;
617 }
618
620 template< typename DataType >
621 B2Vector3<DataType>& B2Vector3<DataType>::operator = (const ROOT::Math::XYZVector& b)
622 {
623 m_coordinates[0] = b.X();
624 m_coordinates[1] = b.Y();
625 m_coordinates[2] = b.Z();
626 return *this;
627 }
628
630 template< typename DataType >
631 B2Vector3<DataType>& B2Vector3<DataType>::operator += (const B2Vector3<DataType>& b)
632 {
633 m_coordinates[0] += b.X();
634 m_coordinates[1] += b.Y();
635 m_coordinates[2] += b.Z();
636 return *this;
637 }
638
639
641 template< typename DataType >
642 B2Vector3<DataType>& B2Vector3<DataType>::operator -= (const B2Vector3<DataType>& b)
643 {
644 m_coordinates[0] -= b.X();
645 m_coordinates[1] -= b.Y();
646 m_coordinates[2] -= b.Z();
647 return *this;
648 }
649
651 template< typename DataType >
652 B2Vector3<DataType>& B2Vector3<DataType>::operator *= (DataType a)
653 {
654 m_coordinates[0] *= a;
655 m_coordinates[1] *= a;
656 m_coordinates[2] *= a;
657 return *this;
658 }
659
661 template< typename DataType >
662 void B2Vector3<DataType>::SetXYZ(const TVector3& tVec)
663 {
664 m_coordinates[0] = static_cast<Double_t>(tVec.X());
665 m_coordinates[1] = static_cast<Double_t>(tVec.Y());
666 m_coordinates[2] = static_cast<Double_t>(tVec.Z());
667 }
668
670 template< typename DataType >
671 void B2Vector3<DataType>::SetXYZ(const TVector3* tVec)
672 {
673 m_coordinates[0] = static_cast<Double_t>(tVec->X());
674 m_coordinates[1] = static_cast<Double_t>(tVec->Y());
675 m_coordinates[2] = static_cast<Double_t>(tVec->Z());
676 }
677
679 template< typename DataType >
680 void B2Vector3<DataType>::SetXYZ(const ROOT::Math::XYZVector& xyzVec)
681 {
682 m_coordinates[0] = static_cast<Double_t>(xyzVec.X());
683 m_coordinates[1] = static_cast<Double_t>(xyzVec.Y());
684 m_coordinates[2] = static_cast<Double_t>(xyzVec.Z());
685 }
686
688 template< typename DataType >
689 void B2Vector3<DataType>::SetXYZ(const ROOT::Math::XYZVector* xyzVec)
690 {
691 m_coordinates[0] = static_cast<Double_t>(xyzVec->X());
692 m_coordinates[1] = static_cast<Double_t>(xyzVec->Y());
693 m_coordinates[2] = static_cast<Double_t>(xyzVec->Z());
694 }
695
696 template< typename DataType >
697 void B2Vector3<DataType>::GetXYZ(double* carray) const
698 {
699 carray[0] = X();
700 carray[1] = Y();
701 carray[2] = Z();
702 }
703
705 template< typename DataType >
706 void B2Vector3<DataType>::GetXYZ(TVector3* tVec) const
707 {
708 tVec->SetXYZ(static_cast<Double_t>(X()),
709 static_cast<Double_t>(Y()),
710 static_cast<Double_t>(Z()));
711 }
712
714 template< typename DataType >
715 void B2Vector3<DataType>::GetXYZ(ROOT::Math::XYZVector* xyzVec) const
716 {
717 xyzVec->SetXYZ(static_cast<Double_t>(X()),
718 static_cast<Double_t>(Y()),
719 static_cast<Double_t>(Z()));
720 }
721
722
724 template< typename DataType >
725 TVector3 B2Vector3<DataType>::GetTVector3() const
726 {
727 return
728 TVector3(
729 static_cast<Double_t>(X()),
730 static_cast<Double_t>(Y()),
731 static_cast<Double_t>(Z())
732 );
733 }
734
735
737 template< typename DataType >
738 ROOT::Math::XYZVector B2Vector3<DataType>::GetXYZVector() const
739 {
740 return
741 ROOT::Math::XYZVector(
742 static_cast<Double_t>(X()),
743 static_cast<Double_t>(Y()),
744 static_cast<Double_t>(Z())
745 );
746 }
747
748
750 template < typename DataType>
751 DataType B2Vector3<DataType>::at(unsigned i) const
752 {
753 switch (i) {
754 case 0:
755 return B2Vector3<DataType>::m_coordinates[0];
756 case 1:
757 return B2Vector3<DataType>::m_coordinates[1];
758 case 2:
759 return B2Vector3<DataType>::m_coordinates[2];
760 }
761 B2FATAL(this->name() << "::access operator: given index (i=" << i << ") is out of bounds!");
762 return 0.;
763 }
764
766 template < typename DataType>
767 std::string B2Vector3<DataType>::name()
768 {
769 return std::string("B2Vector3<") + typeid(DataType).name() + std::string(">");
770 }
771
773} // end namespace Belle2
Belle2::B2Vector3
A fast and root compatible alternative to TVector3.
Definition: B2Vector3.h:42
Belle2::B2Vector3::Phi
DataType Phi() const
The azimuth angle.
Definition: B2Vector3.h:151
Belle2::B2Vector3::SetMag
void SetMag(DataType mag)
Set magnitude keeping theta and phi constant.
Definition: B2Vector3.h:182
Belle2::B2Vector3::operator-
B2Vector3< DataType > operator-() const
unary minus
Definition: B2Vector3.h:125
Belle2::B2Vector3::Pz
DataType Pz() const
access variable Z (= .at(2) without boundary check)
Definition: B2Vector3.h:441
Belle2::B2Vector3::m_coordinates
DataType m_coordinates[3]
Make sure that we only have floating point vectors.
Definition: B2Vector3.h:47
Belle2::B2Vector3::B2Vector3
B2Vector3(const B2Vector3< DataType > &b2Vec3)
Constructor expecting a B2Vector3 of same type.
Definition: B2Vector3.h:67
Belle2::B2Vector3::operator()
DataType operator()(unsigned i) const
member access without boundary check
Definition: B2Vector3.h:85
Belle2::B2Vector3::Z
DataType Z() const
access variable Z (= .at(2) without boundary check)
Definition: B2Vector3.h:435
Belle2::B2Vector3::Perp2
DataType Perp2() const
The transverse component squared (R^2 in cylindrical coordinate system).
Definition: B2Vector3.h:196
Belle2::B2Vector3::SetPerp
void SetPerp(DataType r)
Set the transverse component keeping phi and z constant.
Definition: B2Vector3.h:203
Belle2::B2Vector3::y
DataType y() const
access variable Y (= .at(1) without boundary check)
Definition: B2Vector3.h:427
Belle2::B2Vector3::SetX
void SetX(DataType x)
set X/1st-coordinate
Definition: B2Vector3.h:457
Belle2::B2Vector3::Theta
DataType Theta() const
The polar angle.
Definition: B2Vector3.h:153
Belle2::B2Vector3::CosTheta
DataType CosTheta() const
Cosine of the polar angle.
Definition: B2Vector3.h:155
Belle2::B2Vector3::Cross
B2Vector3< DataType > Cross(const B2Vector3< DataType > &p) const
Cross product.
Definition: B2Vector3.h:296
Belle2::B2Vector3::GetXYZ
void GetXYZ(Float_t *carray) const
directly copies coordinates to an array of float
Belle2::B2Vector3::z
DataType z() const
access variable Z (= .at(2) without boundary check)
Definition: B2Vector3.h:429
Belle2::B2Vector3::B2Vector3
B2Vector3(const B2Vector3< DataType > *b2Vec3)
Constructor expecting a pointer to a B2Vector3.
Definition: B2Vector3.h:69
Belle2::B2Vector3::SetMagThetaPhi
void SetMagThetaPhi(DataType mag, DataType theta, DataType phi)
setter with mag, theta, phi
Definition: B2Vector3.h:259
Belle2::B2Vector3::X
DataType X() const
access variable X (= .at(0) without boundary check)
Definition: B2Vector3.h:431
Belle2::B2Vector3::PrintStringXYZ
std::string PrintStringXYZ(unsigned precision=4) const
create a string containing vector in cartesian coordinates
Definition: B2Vector3.h:487
Belle2::B2Vector3::Orthogonal
B2Vector3< DataType > Orthogonal() const
Vector orthogonal to this one.
Definition: B2Vector3.h:277
Belle2::B2Vector3::Eta
DataType Eta() const
Returns the pseudo-rapidity.
Definition: B2Vector3.h:331
Belle2::B2Vector3::operator*
B2Vector3< DataType > operator*(DataType a) const
Scaling of 3-vectors with a real number.
Definition: B2Vector3.h:137
Belle2::B2Vector3::DeltaPhi
DataType DeltaPhi(const B2Vector3< DataType > &v) const
returns phi in the interval [-PI,PI)
Definition: B2Vector3.h:228
Belle2::B2Vector3::RotateY
void RotateY(DataType angle)
Rotates the B2Vector3 around the y-axis.
Definition: B2Vector3.h:347
Belle2::B2Vector3::Y
DataType Y() const
access variable Y (= .at(1) without boundary check)
Definition: B2Vector3.h:433
Belle2::B2Vector3::operator[]
DataType operator[](unsigned i) const
member access without boundary check
Definition: B2Vector3.h:87
Belle2::B2Vector3::PrintString
std::string PrintString(unsigned precision=4) const
create a string containing vector in cartesian and spherical coordinates
Definition: B2Vector3.h:481
Belle2::B2Vector3::Mag
DataType Mag() const
The magnitude (rho in spherical coordinate system).
Definition: B2Vector3.h:159
Belle2::B2Vector3::value_type
DataType value_type
storage type of the vector
Definition: B2Vector3.h:50
Belle2::B2Vector3::B2Vector3
B2Vector3(const ROOT::Math::XYZVector &xyzVec)
Constructor expecting a XYZVector.
Definition: B2Vector3.h:79
Belle2::B2Vector3::operator==
bool operator==(const B2Vector3< DataType > &b) const
Comparison for equality with a B2Vector3.
Definition: B2Vector3.h:106
Belle2::B2Vector3::x
DataType x() const
access variable X (= .at(0) without boundary check)
Definition: B2Vector3.h:425
Belle2::B2Vector3::B2Vector3
B2Vector3(const DataType(*coords)[3])
Constructor using a pointer.
Definition: B2Vector3.h:59
Belle2::B2Vector3::DeltaR
DataType DeltaR(const B2Vector3< DataType > &v) const
return deltaR with respect to input-vector
Definition: B2Vector3.h:245
Belle2::B2Vector3::Perp
DataType Perp(const B2Vector3< DataType > &axis) const
The transverse component w.r.t.
Definition: B2Vector3.h:226
Belle2::B2Vector3::operator()
DataType & operator()(unsigned i)
member access without boundary check
Definition: B2Vector3.h:89
Belle2::B2Vector3::RotateX
void RotateX(DataType angle)
Rotates the B2Vector3 around the x-axis.
Definition: B2Vector3.h:335
Belle2::B2Vector3::Abs
void Abs()
calculates the absolute value of the coordinates element-wise
Definition: B2Vector3.h:406
Belle2::B2Vector3::B2Vector3
B2Vector3(const DataType(&coords)[3])
Constructor using a reference.
Definition: B2Vector3.h:57
Belle2::B2Vector3::B2Vector3
B2Vector3(const ROOT::Math::XYZVector *xyzVec)
Constructor expecting a pointer to a XYZVector.
Definition: B2Vector3.h:82
Belle2::B2Vector3::Pt
DataType Pt(const B2Vector3< DataType > &axis) const
The transverse component w.r.t.
Definition: B2Vector3.h:224
Belle2::B2Vector3::Mag2
DataType Mag2() const
The magnitude squared (rho^2 in spherical coordinate system).
Definition: B2Vector3.h:157
Belle2::B2Vector3::SetTheta
void SetTheta(DataType theta)
Set theta keeping mag and phi constant.
Definition: B2Vector3.h:170
Belle2::B2Vector3::operator+
B2Vector3< DataType > operator+(const B2Vector3< DataType > &b) const
Addition of 3-vectors.
Definition: B2Vector3.h:127
Belle2::B2Vector3::B2Vector3
B2Vector3(const TVector3 &tVec3)
Constructor expecting a TVector3.
Definition: B2Vector3.h:62
Belle2::B2Vector3::RotateZ
void RotateZ(DataType angle)
Rotates the B2Vector3 around the z-axis.
Definition: B2Vector3.h:359
Belle2::B2Vector3::Print
void Print()
just for backward compatibility, should not be used with new code
Definition: B2Vector3.h:507
Belle2::B2Vector3::Sqrt
void Sqrt()
calculates the square root of the absolute values of the coordinates element-wise
Definition: B2Vector3.h:414
Belle2::B2Vector3::SetZ
void SetZ(DataType z)
set Z/3rd-coordinate
Definition: B2Vector3.h:461
Belle2::B2Vector3::Dot
DataType Dot(const B2Vector3< DataType > &p) const
Scalar product.
Definition: B2Vector3.h:290
Belle2::B2Vector3::SetY
void SetY(DataType y)
set Y/2nd-coordinate
Definition: B2Vector3.h:459
Belle2::B2Vector3::B2Vector3
B2Vector3(const B2Vector3< OtherType > *b2Vec3)
Constructor expecting a pointer to a B2Vector3 of different type.
Definition: B2Vector3.h:75
Belle2::B2Vector3::PseudoRapidity
DataType PseudoRapidity() const
Returns the pseudo-rapidity, i.e.
Definition: B2Vector3.h:319
Belle2::B2Vector3::DrEtaPhi
DataType DrEtaPhi(const B2Vector3< DataType > &v) const
return DrEtaPhi with respect to input-vector
Definition: B2Vector3.h:253
Belle2::B2Vector3::operator!=
bool operator!=(const B2Vector3< DataType > &b) const
Comparison != with a B2Vector3.
Definition: B2Vector3.h:112
Belle2::B2Vector3::Perp
DataType Perp() const
The transverse component (R in cylindrical coordinate system).
Definition: B2Vector3.h:200
Belle2::B2Vector3::B2Vector3
B2Vector3(void)
empty Constructor sets everything to 0
Definition: B2Vector3.h:53
Belle2::B2Vector3::Perp2
DataType Perp2(const B2Vector3< DataType > &axis) const
The transverse component w.r.t.
Definition: B2Vector3.h:213
Belle2::B2Vector3::B2Vector3
B2Vector3(const B2Vector3< OtherType > &b2Vec3)
Constructor expecting a B2Vector3 of different type.
Definition: B2Vector3.h:72
Belle2::B2Vector3::GetXYZ
void GetXYZ(Double_t *carray) const
directly copies coordinates to an array of double
Belle2::B2Vector3::RotateUz
void RotateUz(const B2Vector3< DataType > &NewUzVector)
Rotates reference frame from Uz to newUz (unit vector).
Definition: B2Vector3.h:370
Belle2::B2Vector3::Py
DataType Py() const
access variable Y (= .at(1) without boundary check)
Definition: B2Vector3.h:439
Belle2::B2Vector3::Mpi_pi
static DataType Mpi_pi(DataType angle)
returns given angle in the interval [-PI,PI)
Definition: B2Vector3.h:232
Belle2::B2Vector3::Unit
B2Vector3< DataType > Unit() const
Unit vector parallel to this.
Definition: B2Vector3.h:269
Belle2::B2Vector3::Pt
DataType Pt() const
The transverse component (R in cylindrical coordinate system).
Definition: B2Vector3.h:198
Belle2::B2Vector3::B2Vector3
B2Vector3(const TVector3 *tVec3)
Constructor expecting a pointer to a TVector3.
Definition: B2Vector3.h:65
Belle2::B2Vector3::Px
DataType Px() const
access variable X (= .at(0) without boundary check)
Definition: B2Vector3.h:437
Belle2::B2Vector3::SetXYZ
void SetXYZ(DataType x, DataType y, DataType z)
set all coordinates using data type
Definition: B2Vector3.h:464
Belle2::B2Vector3::Angle
DataType Angle(const B2Vector3< DataType > &q) const
The angle w.r.t.
Definition: B2Vector3.h:302
Belle2::B2Vector3::operator[]
DataType & operator[](unsigned i)
member access without boundary check
Definition: B2Vector3.h:91
Belle2::B2Vector3::PrintStringCyl
std::string PrintStringCyl(unsigned precision=4) const
create a string containing vector in spherical coordinates
Definition: B2Vector3.h:497
Belle2::B2Vector3::operator/
B2Vector3< DataType > operator/(DataType a) const
Scaling of 3-vectors with a real number.
Definition: B2Vector3.h:142
Belle2::B2Vector3::Rotate
void Rotate(DataType alpha, const B2Vector3< DataType > &v)
Rotation around an arbitrary axis v with angle alpha.
Definition: B2Vector3.h:399
Belle2::B2Vector3::SetPhi
void SetPhi(DataType phi)
Set phi keeping mag and theta constant.
Definition: B2Vector3.h:162
Belle2::B2Vector3::B2Vector3
B2Vector3(const DataType xVal, const DataType yVal, const DataType zVal)
Constructor expecting 3 coordinates.
Definition: B2Vector3.h:55
Belle2::operator==
bool operator==(const DecayNode &node1, const DecayNode &node2)
Compare two Decay Nodes: They are equal if All daughter decay nodes are equal or one of the daughter ...
Definition: DecayNode.cc:48
Belle2::operator!=
bool operator!=(const DecayNode &node1, const DecayNode &node2)
Not equal: See operator==.
Definition: DecayNode.cc:65
Belle2::B2Vector3::SetXYZ
void SetXYZ(const ROOT::Math::XYZVector *xyzVec)
set all coordinates using a pointer to XYZVector
Definition: B2Vector3.h:689
Belle2::B2Vector3::GetXYZ
void GetXYZ(ROOT::Math::XYZVector *xyzVec) const
directly copies coordinates to a XYZVector
Definition: B2Vector3.h:715
Belle2::B2Vector3::SetXYZ
void SetXYZ(const TVector3 &tVec)
set all coordinates using a reference to TVector3
Definition: B2Vector3.h:662
Belle2::B2Vector3::operator-=
B2Vector3< DataType > & operator-=(const B2Vector3< DataType > &b)
subtraction
Definition: B2Vector3.h:642
Belle2::B2Vector3::GetTVector3
TVector3 GetTVector3() const
returns a TVector3 containing the same coordinates
Definition: B2Vector3.h:725
Belle2::B2Vector3F
B2Vector3< float > B2Vector3F
typedef for common usage with float
Definition: B2Vector3.h:519
Belle2::B2Vector3::GetXYZ
void GetXYZ(TVector3 *tVec) const
directly copies coordinates to a TVector3
Definition: B2Vector3.h:706
Belle2::B2Vector3::SetXYZ
void SetXYZ(const TVector3 *tVec)
set all coordinates using a pointer to TVector3
Definition: B2Vector3.h:671
Belle2::B2Vector3::GetXYZVector
ROOT::Math::XYZVector GetXYZVector() const
returns a XYZVector containing the same coordinates
Definition: B2Vector3.h:738
Belle2::B2Vector3::operator+=
B2Vector3< DataType > & operator+=(const B2Vector3< DataType > &b)
addition
Definition: B2Vector3.h:631
Belle2::operator*
B2Vector3< DataType > operator*(DataType a, const B2Vector3< DataType > &p)
non-memberfunction Scaling of 3-vectors with a real number
Definition: B2Vector3.h:537
Belle2::operator-
B2Vector3< DataType > operator-(const TVector3 &a, const B2Vector3< DataType > &b)
non-memberfunction for substracting a TVector3 from a B2Vector3
Definition: B2Vector3.h:551
Belle2::B2Vector3::operator*=
B2Vector3< DataType > & operator*=(DataType a)
scaling with real numbers
Definition: B2Vector3.h:652
Belle2::operator+
B2Vector3< DataType > operator+(const TVector3 &a, const B2Vector3< DataType > &b)
non-memberfunction for adding a TVector3 to a B2Vector3
Definition: B2Vector3.h:544
Belle2::B2Vector3::SetXYZ
void SetXYZ(const ROOT::Math::XYZVector &xyzVec)
set all coordinates using a reference to XYZVector
Definition: B2Vector3.h:680
Belle2::B2Vector3::operator=
B2Vector3< DataType > & operator=(const B2Vector3< DataType > &b)
Assignment via B2Vector3.
Definition: B2Vector3.h:601
Belle2::B2Vector3D
B2Vector3< double > B2Vector3D
typedef for common usage with double
Definition: B2Vector3.h:516
Belle2::B2Vector3::at
DataType at(unsigned i) const
safe member access (with boundary check!)
Definition: B2Vector3.h:751
Belle2::B2Vector3::name
static std::string name()
Returns the name of the B2Vector.
Definition: B2Vector3.h:767
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17