SurfYZLine.cxx
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////
2 ///
3 /// \file SurfYZLine.cxx
4 ///
5 /// \brief Line surface perpendicular to x-axis.
6 ///
7 /// \author H. Greenlee
8 ///
9 ////////////////////////////////////////////////////////////////////////
10 
11 #include <cmath>
13 #include "cetlib_except/exception.h"
14 #include "TVector2.h"
15 #include "TMath.h"
16 
17 namespace trkf {
18 
19  // Static attributes.
20 
21  double SurfYZLine::fPhiTolerance = 1.e-10;
22  double SurfYZLine::fSepTolerance = 1.e-6;
23 
24  /// Default constructor.
26  fX0(0.),
27  fY0(0.),
28  fZ0(0.),
29  fPhi(0.)
30  {}
31 
32  /// Initializing constructor.
33  ///
34  /// Arguments:
35  ///
36  /// x0, y0, z0 - Global coordinates of local origin.
37  /// phi - Rotation angle about x-axis.
38  ///
39  SurfYZLine::SurfYZLine(double x0, double y0, double z0, double phi) :
40  fX0(x0),
41  fY0(y0),
42  fZ0(z0),
43  fPhi(phi)
44  {}
45 
46  /// Destructor.
48  {}
49 
50  /// Clone method.
52  {
53  return new SurfYZLine(*this);
54  }
55 
56  /// Surface-specific tests of validity of track parameters.
57  bool SurfYZLine::isTrackValid(const TrackVector& vec) const
58  {
59  // Limit allowed range of eta parameter.
60 
61  return std::abs(vec(3)) < 10.;
62  }
63 
64  /// Transform global to local coordinates.
65  ///
66  /// Arguments:
67  ///
68  /// xyz - Cartesian coordinates in global coordinate system.
69  /// uvw - Cartesian coordinates in local coordinate system.
70  ///
71  void SurfYZLine::toLocal(const double xyz[3], double uvw[3]) const
72  {
73  double sinphi = std::sin(fPhi);
74  double cosphi = std::cos(fPhi);
75 
76  // u = x-x0
77  uvw[0] = xyz[0] - fX0;
78 
79  // v = (y-y0)*cos(phi) + (z-z0)*sin(phi)
80  uvw[1] = (xyz[1] - fY0) * cosphi + (xyz[2] - fZ0) * sinphi;
81 
82  // w = -(y-y0)*sin(phi) + (z-z0)*cos(phi)
83  uvw[2] = -(xyz[1] - fY0) * sinphi + (xyz[2] - fZ0) * cosphi;
84  }
85 
86  /// Transform local to global coordinates.
87  ///
88  /// Arguments:
89  ///
90  /// uvw - Cartesian coordinates in local coordinate system.
91  /// xyz - Cartesian coordinates in global coordinate system.
92  ///
93  void SurfYZLine::toGlobal(const double uvw[3], double xyz[3]) const
94  {
95  double sinphi = std::sin(fPhi);
96  double cosphi = std::cos(fPhi);
97 
98  // x = x0 + u
99  xyz[0] = fX0 + uvw[0];
100 
101  // y = y0 + v*cos(phi) - w*sin(phi)
102  xyz[1] = fY0 + uvw[1] * cosphi - uvw[2] * sinphi;
103 
104  // z = z0 + v*sin(phi) + w*cos(phi)
105  xyz[2] = fZ0 + uvw[1] * sinphi + uvw[2] * cosphi;
106  }
107 
108  /// Calculate difference of two track parameter vectors, taking into account phi wrap.
109  ///
110  /// Arguments:
111  ///
112  /// vec1 - First vector.
113  /// vec2 - Second vector.
114  ///
115  /// Returns: vec1 - vec2
116  ///
117  TrackVector SurfYZLine::getDiff(const TrackVector& vec1, const TrackVector& vec2) const
118  {
119  TrackVector result = vec1 - vec2;
120  while(result(2) <= -TMath::Pi())
121  result(2) += TMath::TwoPi();
122  while(result(2) > TMath::Pi())
123  result(2) -= TMath::TwoPi();
124  return result;
125  }
126 
127  /// Get position of track.
128  ///
129  /// Arguments:
130  ///
131  /// vec - Track state vector.
132  /// xyz - Position in global coordinate system.
133  ///
134  void SurfYZLine::getPosition(const TrackVector& vec, double xyz[3]) const
135  {
136  // Get position in local coordinate system.
137 
138  double phi = vec(2);
139  double sinphi = std::sin(phi);
140  double cosphi = std::cos(phi);
141 
142  double uvw[3];
143  uvw[0] = -vec(0) * sinphi;
144  uvw[1] = vec(1);
145  uvw[2] = vec(0) * cosphi;
146 
147  // Transform to global coordinate system.
148 
149  toGlobal(uvw, xyz);
150  return;
151  }
152 
153  /// Get momentum vector of track.
154  ///
155  /// Arguments:
156  ///
157  /// vec - Track state vector.
158  /// mom - Momentum vector in global coordinate system.
159  /// dir - Track direction (ignored).
160  ///
161  void SurfYZLine::getMomentum(const TrackVector& vec, double mom[3],
162  TrackDirection dir) const
163  {
164 
165  // Get momentum.
166 
167  double invp = std::abs(vec(4));
168  double p = 1. / std::max(invp, 1.e-3); // Capped at 1000. GeV/c.
169 
170  // Get track direction parameters.
171 
172  double phi = vec(2);
173  double eta = vec(3);
174 
175  double sinphi = std::sin(phi);
176  double cosphi = std::cos(phi);
177  double sh = 1./std::cosh(eta); // sech(eta)
178  double th = std::tanh(eta);
179 
180  // Calculate momentum vector in local coordinate system.
181 
182  double pu = p * cosphi * sh;
183  double pv = p * th;
184  double pw = p * sinphi * sh;
185 
186  // Rotate momentum to global coordinte system.
187 
188  double sinfphi = std::sin(fPhi);
189  double cosfphi = std::cos(fPhi);
190 
191  mom[0] = pu;
192  mom[1] = pv * cosfphi - pw * sinfphi;
193  mom[2] = pv * sinfphi + pw * cosfphi;
194 
195  return;
196  }
197 
198  /// Test whether two surfaces are parallel, within tolerance.
199  /// This method will only return true if the other surface
200  /// is a SurfYZLine.
201  ///
202  /// Arguments:
203  ///
204  /// surf - Other surface.
205  ///
206  /// Returned value: true if parallel.
207  ///
208  bool SurfYZLine::isParallel(const Surface& surf) const
209  {
210  bool result = false;
211 
212  // Test if the other surface is a SurfYZLine.
213 
214  const SurfYZLine* psurf = dynamic_cast<const SurfYZLine*>(&surf);
215  if(psurf != 0) {
216 
217  // Test whether surface angle parameters are the same
218  // within tolerance.
219 
220  double delta_phi = TVector2::Phi_mpi_pi(fPhi - psurf->phi());
221  if(std::abs(delta_phi) <= fPhiTolerance)
222  result = true;
223  }
224  return result;
225  }
226 
227  /// Find perpendicular distance to a parallel surface.
228  ///
229  /// Throw an exception if the other surface is not parallel.
230  ///
231  /// Arguments:
232  ///
233  /// surf - Other surface.
234  ///
235  /// Returned value: Distance.
236  ///
237  double SurfYZLine::distanceTo(const Surface& surf) const
238  {
239  // Check if the other surface is parallel to this one.
240 
241  bool parallel = isParallel(surf);
242  if(!parallel)
243  throw cet::exception("SurfYZLine") << "Attempt to find distance to non-parallel surface.\n";
244 
245  // Find the origin of the other surface in global coordinates,
246  // then convert to our local coordinates.
247 
248  double otheruvw[3] = {0., 0., 0.};
249  double xyz[3];
250  double myuvw[3];
251  surf.toGlobal(otheruvw, xyz);
252  toLocal(xyz, myuvw);
253 
254  // Distance of v-axis to other surface origin.
255 
256  return std::hypot(myuvw[0], myuvw[2]);
257  }
258 
259  /// Test two surfaces for equality, within tolerance.
260  /// Here equal is defined as having all surface parameters the same,
261  /// not just having the surfaces coincide spatially, so that the
262  /// local coordinate systems are the same between the two surfaces.
263  ///
264  /// Arguments:
265  ///
266  /// surf - Other surface.
267  ///
268  /// Returned values: true if equal.
269  ///
270  bool SurfYZLine::isEqual(const Surface& surf) const
271  {
272  bool result = false;
273 
274  // Test if the other surface is a SurfYZLine.
275 
276  const SurfYZLine* psurf = dynamic_cast<const SurfYZLine*>(&surf);
277  if(psurf != 0) {
278 
279  // Test whether surface parameters are the same within tolerance.
280 
281  double delta_phi = TVector2::Phi_mpi_pi(fPhi - psurf->phi());
282  double dx = fX0 - psurf->x0();
283  double dy = fY0 - psurf->y0();
284  double dz = fZ0 - psurf->z0();
285  if(std::abs(delta_phi) <= fPhiTolerance &&
286  std::abs(dx) <= fSepTolerance &&
287  std::abs(dy) <= fSepTolerance &&
288  std::abs(dz) <= fSepTolerance)
289  result = true;
290  }
291  return result;
292  }
293 
294  /// Printout
295  std::ostream& SurfYZLine::Print(std::ostream& out) const
296  {
297  out << "SurfYZLine{ x0=" << fX0 << ", y0=" << fY0 << ", z0=" << fZ0 << ", phi=" << fPhi << "}";
298  return out;
299  }
300 
301 } // end namespace trkf
TrackDirection
Track direction enum.
Definition: Surface.h:56
static QCString result
virtual void toGlobal(const double uvw[3], double xyz[3]) const
Transform local to global coordinates.
Definition: SurfYZLine.cxx:93
virtual bool isEqual(const Surface &surf) const
Test two surfaces for equality, within tolerance.
Definition: SurfYZLine.cxx:270
string dir
virtual void toLocal(const double xyz[3], double uvw[3]) const
Transform global to local coordinates.
Definition: SurfYZLine.cxx:71
virtual bool isTrackValid(const TrackVector &vec) const
Surface-specific tests of validity of track parameters.
Definition: SurfYZLine.cxx:57
std::enable_if_t< std::is_arithmetic_v< T >, T > hypot(T x, T y)
Definition: hypot.h:60
virtual void getMomentum(const TrackVector &vec, double mom[3], TrackDirection dir=UNKNOWN) const
Get momentum vector of track.
Definition: SurfYZLine.cxx:161
virtual bool isParallel(const Surface &surf) const
Test whether two surfaces are parallel, within tolerance.
Definition: SurfYZLine.cxx:208
T abs(T value)
double fX0
X origin.
Definition: SurfYZLine.h:140
virtual double distanceTo(const Surface &surf) const
Find perpendicular distance to a parallel surface.
Definition: SurfYZLine.cxx:237
const double e
virtual ~SurfYZLine()
Destructor.
Definition: SurfYZLine.cxx:47
static double fPhiTolerance
Phi tolerance for parallel.
Definition: SurfYZLine.h:135
p
Definition: test.py:223
virtual std::ostream & Print(std::ostream &out) const
Printout.
Definition: SurfYZLine.cxx:295
KVector< 5 >::type TrackVector
Track state vector, dimension 5.
static int max(int a, int b)
double z0() const
Z origin.
Definition: SurfYZLine.h:94
static double fSepTolerance
Separation tolerance for equal.
Definition: SurfYZLine.h:136
double x0() const
X origin.
Definition: SurfYZLine.h:92
double fZ0
Z origin.
Definition: SurfYZLine.h:142
double fY0
Y origin.
Definition: SurfYZLine.h:141
virtual TrackVector getDiff(const TrackVector &vec1, const TrackVector &vec2) const
Calculate difference of two track parameter vectors.
Definition: SurfYZLine.cxx:117
double phi() const
Rotation angle about x-axis.
Definition: SurfYZLine.h:95
double y0() const
Y origin.
Definition: SurfYZLine.h:93
Line surface perpendicular to x-axis.
double fPhi
Rotation angle about x-axis.
Definition: SurfYZLine.h:143
virtual Surface * clone() const
Clone method.
Definition: SurfYZLine.cxx:51
virtual void getPosition(const TrackVector &vec, double xyz[3]) const
Get position of track.
Definition: SurfYZLine.cxx:134
virtual void toGlobal(const double uvw[3], double xyz[3]) const =0
Transform local to global coordinates.
cet::coded_exception< error, detail::translate > exception
Definition: exception.h:33
SurfYZLine()
Default constructor.
Definition: SurfYZLine.cxx:25