ROOT   Reference Guide
THelix.cxx
Go to the documentation of this file.
1// @(#)root/g3d:$Id$
2// Author: Ping Yeh 19/12/97
3
4/*************************************************************************
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. * 9 * For the list of contributors see$ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12/** \class THelix
13\ingroup g3d
14THelix has two different constructors.
15
16If a particle with charge q passes through a point (x,y,z)
17with momentum (px,py,pz) with magnetic field B along an axis (nx,ny,nz),
18this helix can be constructed like:
19
20~~~ {.cpp}
21 THelix p(x,y,z, px,py,pz, q*B, nx,ny,nz);
22 (nx,ny,nz) defaults to (0,0,1).
23~~~
24
25A helix in its own frame can be defined with a pivotal point
26(x0,y0,z0), the velocity at that point (vx0,vy0,vz0), and
27an angular frequency w. Combining vx0 and vy0 to a transverse
28velocity vt0 one can parametrize the helix as:
29
30~~~ {.cpp}
31 x(t) = x0 - vt0 / w * sin(-w * t + phi0)
32 y(t) = y0 + vt0 / w * cos(-w * t + phi0)
33 z(t) = z0 + vz0 * t
34~~~
35
36The second constructor has 6 parameters,
37
38Example:
39
40~~~ {.cpp}
41 THelix pl1(xyz, v, w, range, rtype, axis);
42~~~
43
44where:
45
46 - xyz : array of initial position
47 - v : array of initial velocity
48 - w : angular frequency
49 - range: helix range
50 - rtype: kHelixZ specifies allowed drawing range in helix Z direction, i.e., along B field.
51 kLabZ specifies drawing range in lab frame.
52 kHelixX, kHelixY, kLabX, kLabY, kUnchanged ... etc can also be specified
53 - axis : helix axis
54
55Example constructing a helix with several default values and drawing it:
56
57Begin_Macro(source)
58{
59 TCanvas* helix_example_c1 = new TCanvas("helix_example_c1");
60 TView *view = TView::CreateView(1);
61 view->SetRange(-1,-1,-1,1,1,1);
62 THelix *helix = new THelix(0., 0., 0., 1., 0., 0.3, 10.);
63 helix->Draw();
64}
65End_Macro
66
67This initializes a helix with its axis in Z direction (rtype=kHelixZ).
68*/
69
70#include "Riostream.h"
71#include "TROOT.h"
73#include "THelix.h"
74#include "TClass.h"
75#include "TMath.h"
76
77Int_t THelix::fgMinNSeg=5; // at least 5 line segments in TPolyLine3D
78
80
81////////////////////////////////////////////////////////////////////////////////
82/// Set all helix parameters.
83
85 Double_t *range, EHelixRangeType rType,
86 Double_t *axis )
87{
88 // Define the helix frame by setting the helix axis and rotation matrix
89 SetAxis(axis);
90
91 // Calculate initial position and velocity in helix frame
92 fW = w;
94 Double_t vx0, vy0, vz0;
95 vx0 = v[0] * m[0] + v[1] * m[1] + v[2] * m[2];
96 vy0 = v[0] * m[3] + v[1] * m[4] + v[2] * m[5];
97 vz0 = v[0] * m[6] + v[1] * m[7] + v[2] * m[8];
98 fVt = TMath::Sqrt(vx0*vx0 + vy0*vy0);
99 fPhi0 = TMath::ATan2(vy0,vx0);
100 fVz = vz0;
101 fX0 = p[0] * m[0] + p[1] * m[1] + p[2] * m[2];
102 fY0 = p[0] * m[3] + p[1] * m[4] + p[2] * m[5];
103 fZ0 = p[0] * m[6] + p[1] * m[7] + p[2] * m[8];
104 if (fW != 0) {
105 fX0 += fVt / fW * TMath::Sin(fPhi0);
106 fY0 -= fVt / fW * TMath::Cos(fPhi0);
107 }
108
109 // Then calculate the range in t and set the polyline representation
110 Double_t r1 = 0;
111 Double_t r2 = 1;
112 if (range) {r1 = range[0]; r2 = range[1];}
113 if (rType != kUnchanged) {
114 fRange[0] = 0.0; fRange[1] = TMath::Pi(); // initialize to half round
115 SetRange(r1,r2,rType);
116 }
117}
118
119////////////////////////////////////////////////////////////////////////////////
120/// Helix default constructor.
121
123{
124 fX0 = fY0 = fZ0 = fVt = fPhi0 = fVz = fAxis[0] = fAxis[1] = 0.0;
125 fAxis[2] = 1.0;
126 fW = 1.5E7; // roughly the cyclon frequency of proton in AMS
127 fRange[0] = 0.0;
128 fRange[1] = 1.0;
129 fRotMat = 0;
130}
131
132////////////////////////////////////////////////////////////////////////////////
133/// Helix normal constructor.
134
136 Double_t vx, Double_t vy, Double_t vz,
137 Double_t w)
138 : TPolyLine3D()
139{
140 Double_t p[3], v[3];
141 p[0] = x;
142 p[1] = y;
143 p[2] = z;
144 v[0] = vx;
145 v[1] = vy;
146 v[2] = vz;
147 Double_t *range = 0;
148 fRotMat = 0;
149
150 SetHelix(p, v, w, range, kHelixZ);
151 fOption = "";
152}
153
154////////////////////////////////////////////////////////////////////////////////
155/// Helix normal constructor.
156
158 Double_t * range, EHelixRangeType rType, Double_t * axis)
159 : TPolyLine3D()
160{
161 Double_t r[2];
162 if ( range ) {
163 r[0] = range[0]; r[1] = range[1];
164 } else {
165 r[0] = 0.0; r[1] = 1.0;
166 }
167
168 fRotMat = 0;
169 if ( axis ) { // specify axis
170 SetHelix(p, v, w, r, rType, axis);
171 } else { // default axis
172 SetHelix(p, v, w, r, rType);
173 }
174
175 fOption = "";
176}
177
178
179#if 0
180////////////////////////////////////////////////////////////////////////////////
181/// Helix copy constructor.
182
184{
185 fX0 = h.fX0;
186 fY0 = h.fY0;
187 fZ0 = h.fZ0;
188 fVt = h.fVt;
189 fPhi0 = h.fPhi0;
190 fVz = h.fVz;
191 fW = h.fW;
192 for (Int_t i=0; i<3; i++) fAxis[i] = h.fAxis[i];
193 fRotMat = new TRotMatrix(*(h.fRotMat));
194 fRange[0] = h.fRange[0];
195 fRange[1] = h.fRange[1];
196
197 fOption = h.fOption;
198}
199#endif
200
201////////////////////////////////////////////////////////////////////////////////
202/// assignment operator
203
205{
206 if(this!=&hx) {
208 fX0=hx.fX0;
209 fY0=hx.fY0;
210 fZ0=hx.fZ0;
211 fVt=hx.fVt;
212 fPhi0=hx.fPhi0;
213 fVz=hx.fVz;
214 fW=hx.fW;
215 for(Int_t i=0; i<3; i++)
216 fAxis[i]=hx.fAxis[i];
217 fRotMat=hx.fRotMat;
218 for(Int_t i=0; i<2; i++)
219 fRange[i]=hx.fRange[i];
220 }
221 return *this;
222}
223
224////////////////////////////////////////////////////////////////////////////////
225/// Helix destructor.
226
228{
229 if (fRotMat) delete fRotMat;
230}
231
232
233////////////////////////////////////////////////////////////////////////////////
234/// Helix copy constructor.
235
236THelix::THelix(const THelix &helix) : TPolyLine3D(helix)
237{
238 fRotMat=0;
239 ((THelix&)helix).THelix::Copy(*this);
240}
241
242
243////////////////////////////////////////////////////////////////////////////////
244/// Copy this helix to obj.
245
246void THelix::Copy(TObject &obj) const
247{
248 TObject::Copy(obj);
249 TAttLine::Copy(((THelix&)obj));
250
251 ((THelix&)obj).fX0 = fX0;
252 ((THelix&)obj).fY0 = fY0;
253 ((THelix&)obj).fZ0 = fZ0;
254 ((THelix&)obj).fVt = fVt;
255 ((THelix&)obj).fPhi0 = fPhi0;
256 ((THelix&)obj).fVz = fVz;
257 ((THelix&)obj).fW = fW;
258 for (Int_t i=0; i<3; i++)
259 ((THelix&)obj).fAxis[i] = fAxis[i];
260
261 if (((THelix&)obj).fRotMat)
262 delete ((THelix&)obj).fRotMat;
263 ((THelix&)obj).fRotMat = new TRotMatrix(*fRotMat);
264
265 ((THelix&)obj).fRange[0] = fRange[0];
266 ((THelix&)obj).fRange[1] = fRange[1];
267
268 ((THelix&)obj).fOption = fOption;
269
270 //
271 // Set range and make the graphic representation
272 //
273 ((THelix&)obj).SetRange(fRange[0], fRange[1], kHelixT);
274}
275
276
277////////////////////////////////////////////////////////////////////////////////
278/// Draw this helix with its current attributes.
279
281{
283}
284
285
286////////////////////////////////////////////////////////////////////////////////
287/// Dump this helix with its attributes.
288
289void THelix::Print(Option_t *option) const
290{
291 std::cout <<" THelix Printing N=" <<fN<<" Option="<<option<<std::endl;
292}
293
294
295////////////////////////////////////////////////////////////////////////////////
296/// Save primitive as a C++ statement(s) on output stream out.
297
298void THelix::SavePrimitive(std::ostream &out, Option_t * /*= ""*/)
299{
300 char quote = '"';
301 out<<" "<<std::endl;
302 if (gROOT->ClassSaved(THelix::Class())) {
303 out<<" ";
304 } else {
305 out<<" THelix *";
306 }
307 out<<"helix = new THelix("<<fX0<<","<<fY0<<","<<fZ0<<","
308 <<fVt*TMath::Cos(fPhi0)<<","<<fVt*TMath::Sin(fPhi0)<<","<<fVz<<","
309 <<fW<<","<<fRange[0]<<","<<fRange[1]<<","<<(Int_t)kHelixT<<","
310 <<fAxis[0]<<","<<fAxis[1]<<","<<fAxis[2]<<","
311 <<quote<<fOption<<quote<<");"<<std::endl;
312
313 SaveLineAttributes(out,"helix",1,1,1);
314
315 out<<" helix->Draw();"<<std::endl;
316}
317
318
319////////////////////////////////////////////////////////////////////////////////
320/// Set a new axis for the helix. This will make a new rotation matrix.
321
323{
324 if (axis) {
325 Double_t len = TMath::Sqrt(axis[0]*axis[0] + axis[1]*axis[1] + axis[2]*axis[2]);
326 if (len <= 0) {
327 Error("SetAxis()", "Impossible! axis length %lf <= 0!", len);
328 return;
329 }
330 fAxis[0] = axis[0]/len;
331 fAxis[1] = axis[1]/len;
332 fAxis[2] = axis[2]/len;
333 } else {
334 fAxis[0] = 0;
335 fAxis[1] = 0;
336 fAxis[2] = 1;
337 }
338
339 // Construct the rotational matrix from the axis
340 SetRotMatrix();
341}
342
343
344////////////////////////////////////////////////////////////////////////////////
345/// Set axis.
346
348{
349 Double_t axis[3]; axis[0] = x; axis[1] = y; axis[2] = z;
350 SetAxis(axis);
351}
352
353
354////////////////////////////////////////////////////////////////////////////////
355/// Set a new range for the helix. This will remake the polyline.
356
358{
359 Double_t a[2];
360 Double_t halfpi = TMath::Pi()/2.0;
361 Int_t i;
364 Double_t phase;
365
366 if ( fW != 0 && fVz != 0 ) { // general case
367 switch ( rType ) {
368 case kHelixT :
369 fRange[0] = range[0]; fRange[1] = range[1]; break;
370
371 case kHelixX :
372 for (i=0; i<2; i++ ) {
373 a[i] = fW / fVt * (range[i] - fX0);
374 if ( a[i] < -1 || a[i] > 1 ) {
375 Error("SetRange()",
376 "range out of bound (%lf:%lf): %lf. Default used: %lf",
377 fX0-fVt/fW, fX0+fVt/fW, range[i], fRange[i]);
378 return;
379 }
380 phase = FindClosestPhase(fPhi0+halfpi, a[i]);
381 fRange[i] = ( fPhi0 + halfpi - phase ) / fW;
382 }
383 break;
384
385 case kHelixY :
386 for (i=0; i<2; i++ ) {
387 a[i] = fW / fVt * (range[i] - fY0);
388 if ( a[i] < -1 || a[i] > 1 ) {
389 Error("SetRange()",
390 "range out of bound (%lf:%lf): %lf. Default used: %lf",
391 fY0-fVt/fW, fY0+fVt/fW, range[i], fRange[i]);
392 return;
393 }
394 phase = FindClosestPhase(fPhi0, a[i]);
395 fRange[i] = ( fPhi0 - phase ) / fW;
396 }
397 break;
398
399 case kHelixZ :
400 if ( fVz != 0 ) {
401 for (i=0; i<2; i++ ) {
402 fRange[i] = (range[i] - fZ0) / fVz;
403 }
404 } else { // fVz = 0, z = constant = fZ0
405 Error("SetRange()",
406 "Vz = 0 and attempts to set range along helix axis!");
407 return;
408 }
409 break;
410
411 case kLabX :
412 case kLabY :
413 case kLabZ :
414 printf("setting range in lab axes is not implemented yet\n");
415 break;
416 default:
417 Error("SetRange()","unknown range type %d", rType);
418 break;
419 }
420 } else if ( fW == 0 ) { // straight line: x = x0 + vx * t
421 switch ( rType ) {
422 case kHelixT :
423 fRange[0] = range[0]; fRange[1] = range[1];
424 break;
425 case kHelixX :
426 if ( vx != 0 ) {
427 fRange[0] = (range[0] - fX0) / vx;
428 fRange[1] = (range[1] - fX0) / vx;
429 } else {
430 Error("SetRange()",
431 "Vx = 0 and attempts to set range on helix x axis!");
432 return;
433 }
434 break;
435 case kHelixY :
436 if ( vy != 0 ) {
437 fRange[0] = (range[0] - fY0) / vy;
438 fRange[1] = (range[1] - fY0) / vy;
439 } else {
440 Error("SetRange()",
441 "Vy = 0 and attempts to set range on helix y axis!");
442 return;
443 }
444 break;
445 case kHelixZ :
446 if ( fVz != 0 ) {
447 fRange[0] = (range[0] - fZ0) / fVz;
448 fRange[1] = (range[1] - fZ0) / fVz;
449 } else {
450 Error("SetRange()",
451 "Vz = 0 and attempts to set range on helix z axis!");
452 return;
453 }
454 break;
455 case kLabX :
456 case kLabY :
457 case kLabZ :
458 printf("setting range in lab axes is not implemented yet\n");
459 break;
460 default :
461 Error("SetRange()","unknown range type %d", rType);
462 break;
463 }
464 } else if ( fVz == 0 ) { // a circle, not fully implemented yet
465 switch ( rType ) {
466 case kHelixT :
467 fRange[0] = range[0]; fRange[1] = range[1]; break;
468 case kHelixX :
469 if ( vx != 0 ) {
470 fRange[0] = (range[0] - fX0) / vx;
471 fRange[1] = (range[1] - fX0) / vx;
472 } else {
473 Error("SetRange()",
474 "Vx = 0 and attempts to set range on helix x axis!");
475 return;
476 }
477 break;
478 case kHelixY :
479 if ( vy != 0 ) {
480 fRange[0] = (range[0] - fY0) / vy;
481 fRange[1] = (range[1] - fY0) / vy;
482 } else {
483 Error("SetRange()",
484 "Vy = 0 and attempts to set range on helix y axis!");
485 return;
486 }
487 break;
488 case kHelixZ :
489 Error("SetRange()",
490 "Vz = 0 and attempts to set range on helix z axis!");
491 return;
492 case kLabX :
493 case kLabY :
494 case kLabZ :
495 printf("setting range in lab axes is not implemented yet\n");
496 break;
497 default :
498 Error("SetRange()","unknown range type %d", rType);
499 break;
500 }
501 }
502
503 if ( fRange[0] > fRange[1] ) {
504 Double_t temp = fRange[1]; fRange[1] = fRange[0]; fRange[0] = temp;
505 }
506
507 // Set the polylines in global coordinates
508 Double_t degrad = TMath::Pi() / 180.0;
509 Double_t segment = 5.0 * degrad; // 5 degree segments
510 Double_t dt = segment / TMath::Abs(fW); // parameter span on each segm.
511
512 Int_t nSeg = Int_t((fRange[1]-fRange[0]) / dt) + 1;
513 if (nSeg < THelix::fgMinNSeg) {
514 nSeg = THelix::fgMinNSeg;
515 dt = (fRange[1]-fRange[0])/nSeg;
516 }
517
518 Double_t * xl = new Double_t[nSeg+1]; // polyline in local coordinates
519 Double_t * yl = new Double_t[nSeg+1];
520 Double_t * zl = new Double_t[nSeg+1];
521
522 for (i=0; i<=nSeg; i++) { // calculate xl[], yl[], zl[];
523 Double_t t, phase2;
524 if (i==nSeg) t = fRange[1]; // the last point
525 else t = fRange[0] + dt * i;
526 phase2 = -fW * t + fPhi0;
527 xl[i] = fX0 - fVt/fW * TMath::Sin(phase2);
528 yl[i] = fY0 + fVt/fW * TMath::Cos(phase2);
529 zl[i] = fZ0 + fVz * t;
530 }
531
532 Float_t xg, yg,zg; // global coordinates
533 // must be Float_t to call TPolyLine3D::SetPoint()
536 for (i=0; i<=nSeg; i++) { // m^{-1} = transpose of m
537 xg = xl[i] * m[0] + yl[i] * m[3] + zl[i] * m[6] ;
538 yg = xl[i] * m[1] + yl[i] * m[4] + zl[i] * m[7] ;
539 zg = xl[i] * m[2] + yl[i] * m[5] + zl[i] * m[8] ;
540 TPolyLine3D::SetPoint(i,xg,yg,zg);
541 }
542
543 delete[] xl; delete[] yl; delete[] zl;
544}
545
546
547////////////////////////////////////////////////////////////////////////////////
548/// Set range.
549
551{
552 Double_t range[2];
553 range[0] = r1; range[1] = r2;
554 SetRange(range, rType);
555}
556
557
558////////////////////////////////////////////////////////////////////////////////
559// //
560// Protected Member Functions //
561// //
562////////////////////////////////////////////////////////////////////////////////
563
564
565////////////////////////////////////////////////////////////////////////////////
566/// Set the rotational matrix according to the helix axis.
567
569{
570 // Calculate all 6 angles.
571 // Note that TRotMatrix::TRotMatrix() expects angles in degrees.
572 Double_t raddeg = 180.0 / TMath::Pi();
573 Double_t halfpi = TMath::Pi()/2.0 * raddeg;
574 // (theta3,phi3) is the helix axis
575 Double_t theta3 = TMath::ACos(fAxis[2]) * raddeg;
576 Double_t phi3 = TMath::ATan2(fAxis[1], fAxis[0]) * raddeg;
577 // (theta1,phi1) is the x-axis in helix frame
578 Double_t theta1 = theta3 + halfpi;
579 Double_t phi1 = phi3;
580 // (theta2,phi2) is the y-axis in helix frame
581 Double_t theta2 = halfpi;
582 Double_t phi2 = phi1 + halfpi;
583
584 // Delete the old rotation matrix
585 if (fRotMat) delete fRotMat;
586
587 // Make a new rotation matrix
588 fRotMat = new TRotMatrix("HelixRotMat", "Master frame -> Helix frame",
589 theta1, phi1, theta2, phi2, theta3, phi3 );
590 return;
591}
592
593
594////////////////////////////////////////////////////////////////////////////////
595/// Finds the closest phase to phi0 that gives cos(phase) = cosine
596
598{
599 const Double_t pi = TMath::Pi();
600 const Double_t twopi = TMath::Pi() * 2.0;
601 Double_t phi1 = TMath::ACos(cosine);
602 Double_t phi2 = - phi1;
603
604 while ( phi1 - phi0 > pi ) phi1 -= twopi;
605 while ( phi1 - phi0 < -pi ) phi1 += twopi;
606
607 while ( phi2 - phi0 > pi ) phi2 -= twopi;
608 while ( phi2 - phi0 < -pi ) phi2 += twopi;
609
610 // Now phi1, phi2 and phi0 are within the same 2pi range
611 // and cos(phi1) = cos(phi2) = cosine
612 if ( TMath::Abs(phi1-phi0) < TMath::Abs(phi2-phi0) ) return phi1;
613 else return phi2;
614}
615
616
617////////////////////////////////////////////////////////////////////////////////
618/// Stream an object of class THelix.
619
620void THelix::Streamer(TBuffer &R__b)
621{
623 UInt_t R__s, R__c;
624 Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
625 if (R__v > 1) {
626 R__b.ReadClassBuffer(THelix::Class(), this, R__v, R__s, R__c);
627 return;
628 }
629 //====process old versions before automatic schema evolution
630 TPolyLine3D::Streamer(R__b);
631 R__b >> fX0;
632 R__b >> fY0;
633 R__b >> fZ0;
634 R__b >> fVt;
635 R__b >> fPhi0;
636 R__b >> fVz;
637 R__b >> fW;
639 R__b >> fRotMat;
641 R__b.CheckByteCount(R__s, R__c, THelix::IsA());
642 //====end of old versions
643
644 } else {
645 R__b.WriteClassBuffer(THelix::Class(),this);
646 }
647}
void Class()
Definition: Class.C:29
ROOT::R::TRInterface & r
Definition: Object.C:4
#define h(i)
Definition: RSha256.hxx:106
int Int_t
Definition: RtypesCore.h:41
short Version_t
Definition: RtypesCore.h:61
unsigned int UInt_t
Definition: RtypesCore.h:42
double Double_t
Definition: RtypesCore.h:55
float Float_t
Definition: RtypesCore.h:53
const char Option_t
Definition: RtypesCore.h:62
#define ClassImp(name)
Definition: Rtypes.h:365
EHelixRangeType
Definition: THelix.h:31
@ kHelixY
Definition: THelix.h:32
@ kHelixX
Definition: THelix.h:32
@ kLabZ
Definition: THelix.h:32
@ kHelixT
Definition: THelix.h:32
@ kLabX
Definition: THelix.h:32
@ kHelixZ
Definition: THelix.h:32
@ kLabY
Definition: THelix.h:32
@ kUnchanged
Definition: THelix.h:32
#define gROOT
Definition: TROOT.h:415
void Copy(TAttLine &attline) const
Copy this line attributes to a new TAttLine.
Definition: TAttLine.cxx:172
virtual void SaveLineAttributes(std::ostream &out, const char *name, Int_t coldef=1, Int_t stydef=1, Int_t widdef=1)
Save line attributes as C++ statement(s) on output stream out.
Definition: TAttLine.cxx:270
Buffer base class used for serializing objects.
Definition: TBuffer.h:42
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
Definition: TBuffer.h:85
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
THelix has two different constructors.
Definition: THelix.h:36
Double_t fRange[2]
Definition: THelix.h:48
Double_t fZ0
Definition: THelix.h:41
virtual void Draw(Option_t *option="")
Draw this helix with its current attributes.
Definition: THelix.cxx:280
void SetHelix(Double_t *xyz, Double_t *v, Double_t w, Double_t *range=0, EHelixRangeType type=kUnchanged, Double_t *axis=0)
Set all helix parameters.
Definition: THelix.cxx:84
THelix & operator=(const THelix &)
assignment operator
Definition: THelix.cxx:204
virtual void Copy(TObject &helix) const
Copy this helix to obj.
Definition: THelix.cxx:246
Double_t fPhi0
Definition: THelix.h:43
virtual void SetRange(Double_t *range, EHelixRangeType rtype=kHelixZ)
Set a new range for the helix. This will remake the polyline.
Definition: THelix.cxx:357
THelix()
Helix default constructor.
Definition: THelix.cxx:122
Double_t fVz
Definition: THelix.h:44
Double_t fAxis[3]
Definition: THelix.h:46
Double_t fX0
Definition: THelix.h:39
virtual void SavePrimitive(std::ostream &out, Option_t *option="")
Save primitive as a C++ statement(s) on output stream out.
Definition: THelix.cxx:298
virtual ~THelix()
Helix destructor.
Definition: THelix.cxx:227
Double_t FindClosestPhase(Double_t phi0, Double_t cosine)
Finds the closest phase to phi0 that gives cos(phase) = cosine.
Definition: THelix.cxx:597
void SetRotMatrix()
Set the rotational matrix according to the helix axis.
Definition: THelix.cxx:568
Double_t fY0
Definition: THelix.h:40
Double_t fVt
Definition: THelix.h:42
virtual void Print(Option_t *option="") const
Dump this helix with its attributes.
Definition: THelix.cxx:289
TRotMatrix * fRotMat
Definition: THelix.h:47
Double_t fW
Definition: THelix.h:45
virtual void SetAxis(Double_t *axis)
Set a new axis for the helix. This will make a new rotation matrix.
Definition: THelix.cxx:322
static Int_t fgMinNSeg
Definition: THelix.h:55
Mother of all ROOT objects.
Definition: TObject.h:37
Append graphics object to current pad.
Definition: TObject.cxx:105
virtual void Copy(TObject &object) const
Copy this to obj.
Definition: TObject.cxx:61
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:880
A 3-dimensional polyline.
Definition: TPolyLine3D.h:32
TPolyLine3D & operator=(const TPolyLine3D &polylin)
assignment operator
virtual void SetPoint(Int_t point, Double_t x, Double_t y, Double_t z)
Set point n to x, y, z.
Int_t fN
Number of points.
Definition: TPolyLine3D.h:34
TString fOption
options
Definition: TPolyLine3D.h:36
virtual void SetPolyLine(Int_t n, Option_t *option="")
Re-initialize polyline with n points (0,0,0).
Manages a detector rotation matrix.
Definition: TRotMatrix.h:28
virtual Double_t * GetMatrix()
Definition: TRotMatrix.h:54
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
static constexpr double halfpi
static constexpr double pi
static constexpr double twopi
Double_t ACos(Double_t)
Definition: TMath.h:658
Double_t ATan2(Double_t y, Double_t x)
Definition: TMath.h:669
Double_t Sqrt(Double_t x)
Definition: TMath.h:681
Double_t Cos(Double_t)
Definition: TMath.h:631
constexpr Double_t Pi()
Definition: TMath.h:38
Double_t Sin(Double_t)
Definition: TMath.h:627
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
auto * m
Definition: textangle.C:8
auto * a
Definition: textangle.C:12