FairRoot/PandaRoot
Public Member Functions | List of all members
PndTrkCTGeometryCalculations Class Reference

#include <PndTrkCTGeometryCalculations.h>

Inheritance diagram for PndTrkCTGeometryCalculations:

Public Member Functions

 PndTrkCTGeometryCalculations ()
 
 ~PndTrkCTGeometryCalculations ()
 
Double_t CalculateArcLength (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t *Xcross, Double_t *Ycross)
 
bool CalculateCircleThru3Points (Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3, Double_t *o_x, Double_t *o_y, Double_t *r_r)
 
void calculateintersections (Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t C0x, Double_t C0y, Double_t C0z, Double_t r, Double_t vx, Double_t vy, Double_t vz, Int_t *STATUS, Double_t *POINTS)
 
void CalculateSandZ (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t skewnum, Double_t info[][7], Double_t *WDX, Double_t *WDY, Double_t *WDZ, Double_t S[2], Double_t Z[2], Double_t Zdrift[2], Double_t Zerror[2])
 
void CalculateSandZ2 (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t skewnum, Double_t info[][7], Double_t *WDX, Double_t *WDY, Double_t *WDZ, Double_t S[2], Double_t Sdrift[2], Double_t Z[2], Double_t Zdrift[2], Double_t Zerror[2])
 
void ChooseEntranceExitbis (Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t Xcross[2], Double_t Ycross[2])
 
void ChooseEntranceExit3 (Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t *FiOrderedList)
 
Double_t Dist_SZ (Double_t Rr, Double_t KAPPA, Double_t FI0, Double_t ZED, Double_t S, Int_t *nrounds)
 
Double_t Dist_SZ_bis (Double_t Rr, Double_t KAPPA, Double_t FI0, Double_t ZED, Double_t S, Short_t n_allowed_rounds, Double_t signPz, Double_t &chosenS)
 
Double_t FindDistance (Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t tanlow, Double_t tanmid, Double_t tanup, Double_t alfa, Double_t beta, Double_t gamma)
 
void FindingParallelTrackAngularRange (Double_t oX, Double_t oY, Double_t Rr, Short_t Charge, Double_t *Fi_low_limit, Double_t *Fi_up_limit, Short_t *status, Double_t Rmin, Double_t Rmax)
 
void FindingParallelTrackAngularRange2 (Double_t oX, Double_t oY, Double_t Rma, Double_t Rmi, Double_t Rr, Double_t *Fi_low_limit, Double_t *Fi_up_limit, Short_t *status)
 
Short_t FindIntersectionsOuterCircle (Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t RMax, Double_t Xcross[2], Double_t Ycross[2])
 
Short_t FindTrackEntranceExitbiHexagonLeft (Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t Xcross[2], Double_t Ycross[2])
 
Short_t FindTrackEntranceExitbiHexagonLeft2 (Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t XintersectionList[16], Double_t YintersectionList[16], Double_t FiOrderedList[16])
 
Short_t FindTrackEntranceExitbiHexagonRight (Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t Xcross[2], Double_t Ycross[2])
 
Short_t FindTrackEntranceExitbiHexagonRight2 (Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t XintersectionList[16], Double_t YintersectionList[16], Double_t FiOrderedList[16])
 
Short_t FindTrackEntranceExitHexagonCircleLeft (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t GAP, Double_t Xcross[2], Double_t Ycross[2])
 
Short_t FindTrackEntranceExitHexagonCircleLeft2 (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t GAP, Double_t XintersectionList[12], Double_t YintersectionList[12], Double_t FiOrderedList[12])
 
Short_t FindTrackEntranceExitHexagonCircleRight (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t GAP, Double_t Xcross[2], Double_t Ycross[2])
 
Short_t FindTrackEntranceExitHexagonCircleRight2 (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t GAP, Double_t XintersectionList[12], Double_t YintersectionList[12], Double_t FiOrderedList[12])
 
bool IntersectionCircle_Segment (Double_t a, Double_t b, Double_t c, Double_t P1x, Double_t P2x, Double_t P1y, Double_t P2y, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2], Double_t *distance)
 
bool IntersectionCircle_Segment_forScitil (Double_t a, Double_t b, Double_t c, Double_t P1x, Double_t P2x, Double_t P1y, Double_t P2y, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t factor, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2], Double_t *distance)
 
bool IntersectionSciTil_Circle (Double_t posizSciTilx, Double_t posizSciTily, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2])
 
Short_t IntersectionsWithClosedbiHexagonLeft (Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t Ami, Double_t Ama, Short_t *nIntersections, Double_t *XintersectionList, Double_t *YintersectionList)
 
Short_t IntersectionsWithClosedbiHexagonRight (Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t Ami, Double_t Ama, Short_t *nIntersections, Double_t *XintersectionList, Double_t *YintersectionList)
 
Short_t IntersectionsWithClosedPolygon (Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t Rmi, Double_t Rma, Short_t nIntersections[2], Double_t XintersectionList[][2], Double_t YintersectionList[][2])
 
Short_t IntersectionsWithGapSemicircle (Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t gap, bool left, Double_t Rma, Double_t *XintersectionList, Double_t *YintersectionList)
 
Short_t IntersectionsWithOpenPolygon (Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t nSides, Double_t *a, Double_t *b, Double_t *c, Double_t *side_x, Double_t *side_y, Double_t *XintersectionList, Double_t *YintersectionList)
 
bool IsInsideArc (Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t Xcross[2], Double_t Ycross[2], Double_t Spoint)
 
bool IsInMvdMiniDisk1_97to1_99 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk1_97to1_99withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk2_41to2_43 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk2_41to2_43withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk3_97to3_99 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk3_97to3_99withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk4_41to4_43 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk4_41to4_43withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk6_97to6_99 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk6_97to6_99withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk7_41to7_43 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk7_41to7_43withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk9_97to9_99 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk9_97to9_99withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk10_41to10_43 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk10_41to10_43withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk14_77to14_79 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk14_77to14_79withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk15_21to15_23 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk15_21to15_23withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk21_77to21_79 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk21_77to21_79withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInMvdMiniDisk22_21to22_23 (Double_t X, Double_t Y)
 
bool IsInMvdMiniDisk22_21to22_23withMargin (Double_t X, Double_t Y, Double_t xmargin, Double_t ymargin)
 
bool IsInTargetPipe (Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t fi0, Double_t kappa, Short_t charge, Double_t gap)
 
bool IsInternal (Double_t Px, Double_t Py, Double_t Xtraslation, Double_t Ytraslation, Double_t Theta)
 
void ListAxialSectorsCrossedbyTrack_and_Hits (Double_t Ox, Double_t Oy, Double_t R, Double_t Charge, Short_t nHits, Short_t *ListHits, Double_t info[][7], Short_t &nArcs_populated, Short_t nHitsInArc[56], Short_t(*ListHitsInArc)[56])
 
 ClassDef (PndTrkCTGeometryCalculations, 1)
 

Detailed Description

Definition at line 8 of file PndTrkCTGeometryCalculations.h.

Constructor & Destructor Documentation

PndTrkCTGeometryCalculations::PndTrkCTGeometryCalculations ( )
inline

Default constructor

Definition at line 14 of file PndTrkCTGeometryCalculations.h.

14 {};
PndTrkCTGeometryCalculations::~PndTrkCTGeometryCalculations ( )
inline

Destructor

Definition at line 18 of file PndTrkCTGeometryCalculations.h.

18 {};

Member Function Documentation

Double_t PndTrkCTGeometryCalculations::CalculateArcLength ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t *  Xcross,
Double_t *  Ycross 
)

Definition at line 15 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, and TWO_PI.

Referenced by PndTrkCleanup::BadTrack_ParStt(), and PndTrkCleanup::SttSkewCleanup().

23 {
24  Double_t dis,
25  theta1,
26  theta2;
27 
28  theta1 = atan2(Ycross[0]-Oyy, Xcross[0]- Oxx);
29  theta2 = atan2(Ycross[1]-Oyy, Xcross[1]- Oxx);
30 
31 
32  if(charge>0){ // the rotation was clockwise.
33  dis = theta1-theta2;
34  } else { // the rotation was counterclockwise.
35  dis = theta2-theta1;
36  }
37 
38  if(dis<0.) dis += TWO_PI;
39  if(dis<0.) dis =0.;
40 
41  dis *= Rr;
42 
43  return dis;
44 }
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
bool PndTrkCTGeometryCalculations::CalculateCircleThru3Points ( Double_t  x1,
Double_t  y1,
Double_t  x2,
Double_t  y2,
Double_t  x3,
Double_t  y3,
Double_t *  o_x,
Double_t *  o_y,
Double_t *  r_r 
)

Definition at line 52 of file PndTrkCTGeometryCalculations.cxx.

References a, d, Double_t, fabs(), and sqrt().

63 {
64  // inspiration from http://mathworld.wolfram.com/Circle.html
65 
66  Double_t a,
67  d,
68  e,
69  q1,
70  q2,
71  q3;
72 
73  a = x1*y2 + y1*x3 + x2*y3 - x3*y2 - x2*y1 - x1*y3;
74 
75  if( fabs(a)<1.e-10 ) return false;
76 
77  q1 = x1*x1 + y1*y1;
78  q2 = x2*x2 + y2*y2;
79  q3 = x3*x3 + y3*y3;
80 
81  d = -(q1*y2 + y1*q3 + q2*y3 - q3*y2 - q2*y1 - q1*y3);
82 
83  e = -(x1*q2 + q1*x3 + x2*q3 - x3*q2 - x2*q1 - x1*q3);
84 
85  *o_x = -0.5*d/a;
86  *o_y = -0.5*e/a;
87  *r_r = sqrt( (x1-*o_x)*(x1-*o_x) + (y1-*o_y)*(y1-*o_y) );
88 
89 
90  return true;
91 }
d
TObjArray * d
Definition: Pnd_Hc_etaee7G.C:78
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
void PndTrkCTGeometryCalculations::calculateintersections ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  C0x,
Double_t  C0y,
Double_t  C0z,
Double_t  r,
Double_t  vx,
Double_t  vy,
Double_t  vz,
Int_t *  STATUS,
Double_t *  POINTS 
)

Definition at line 99 of file PndTrkCTGeometryCalculations.cxx.

References Double_t, and sqrt().

Referenced by PndTrkPlotMacros::WriteMacroSkewAssociatedHitswithMC().

112 {
113 
114 
115 //-------------------------------------------
116 
117 
118  //Double_t P1x, P1y, P1z, P2x, P2y, P2z; //[R.K. 01/2017] unused variable?
119 
120  Double_t AAA, DELTA, ax, ay; //, aaa; //[R.K. 01/2017] unused variable?
121 
122 
123 
124 
125 /*
126  INPUTS :
127 
128  Oxx, Oyy = abscissa and ordinate of the center of the circular trajectory of
129  the particle;
130  Rr = radius of such trajectory;
131  C0x, C0y, C0z = x, y, z coordinates of a point belonging to the axis of the
132  skewed straw;
133  r = radius of equidrift of such skewed straw;
134  vx, vy, vz = versor of the direction along which the skewed straw lies.
135 
136 
137  OUTPUTS :
138 
139  P1x, P1y, P1z = x, y, z coordinates of the point intersection between the
140  particle trajectory circle and the equidrift cylinder of
141  the skewed straw calculated as a function of theta (first
142  solution);
143  P2x, P2y, P2z = x, y, z coordinates of the point intersection between the
144  particle trajectory circle and the equidrift cylinder of
145  the skewed straw calculated as a function of theta (second
146  solution);
147 
148  P1x, P1y, .... , P2z are stored in the array POINTS[0-5]; the status is stored
149  in *STATUS.
150 
151 */
152 
153 
154 
155 
156 //--------------------------------------------------------------------------
157 
158 
159 // from the resolving formula on page 23 of Gianluigi's notes, setting r=0.
160 
161 
162  ax = C0x - Oxx;
163  ay = C0y - Oyy;
164  DELTA = Rr*Rr*(vx*vx+vy*vy) - (vx*ay - vy*ax)*(vx*ay - vy*ax);
165  AAA = vx*vx+vy*vy;
166 
167 
168  if ( DELTA < 0. ) {
169  *STATUS=-2;
170  } else if (AAA == 0.){
171  *STATUS=-3;
172  } else if (DELTA == 0.){
173  *STATUS=1;
174  POINTS[0] = C0x - vx*(vx*ax + vy*ay)/AAA;
175  POINTS[1] = C0y - vy*(vx*ax + vy*ay)/AAA;
176  POINTS[2] = C0z - vz*(vx*ax + vy*ay)/AAA;
177  }else {
178  *STATUS=0;
179  DELTA = sqrt(DELTA);
180  POINTS[0] = C0x - vx*(vx*ax + vy*ay - DELTA)/AAA;
181  POINTS[1] = C0y - vy*(vx*ax + vy*ay - DELTA)/AAA;
182  POINTS[2] = C0z - vz*(vx*ax + vy*ay - DELTA)/AAA;
183  POINTS[3] = C0x - vx*(vx*ax + vy*ay + DELTA)/AAA;
184  POINTS[4] = C0y - vy*(vx*ax + vy*ay + DELTA)/AAA;
185  POINTS[5] = C0z - vz*(vx*ax + vy*ay + DELTA)/AAA;
186  }
187 
188  return;
189 
190 
191 }
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
void PndTrkCTGeometryCalculations::CalculateSandZ ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  skewnum,
Double_t  info[][7],
Double_t *  WDX,
Double_t *  WDY,
Double_t *  WDZ,
Double_t  S[2],
Double_t  Z[2],
Double_t  Zdrift[2],
Double_t  Zerror[2] 
)

Definition at line 201 of file PndTrkCTGeometryCalculations.cxx.

References Double_t.

Referenced by PndTrkTracking2::AssociateSkewHitsToXYTrack().

215 {
216 
217  // this method is the same as CalculateSandZ2 only it does NOT return the Sdrift[2] array;
218 
219 
220  Double_t Sdrift[2];
221 
222  CalculateSandZ2(
223  Oxx, // input;
224  Oyy, // input;
225  Rr, // input;
226  skewnum, // input;
227  info, // input;
228  WDX, // input;
229  WDY, // input;
230  WDZ, // input;
231  S, // output;
232  Sdrift, // output; drift radius projected onto the Helix S direction.
233  Z, // output; Zcoordinate of the central wire.
234  Zdrift,// output; drift radius projected onto the Helix Z direction.
235  Zerror // output; 150 micron projected onto the Helix.
236  );
237 
238 }
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndTrkCTGeometryCalculations::CalculateSandZ2
void CalculateSandZ2(Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t skewnum, Double_t info[][7], Double_t *WDX, Double_t *WDY, Double_t *WDZ, Double_t S[2], Double_t Sdrift[2], Double_t Z[2], Double_t Zdrift[2], Double_t Zerror[2])
Definition: PndTrkCTGeometryCalculations.cxx:248
Z
double Z
Definition: anaLmdDigi.C:68
void PndTrkCTGeometryCalculations::CalculateSandZ2 ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  skewnum,
Double_t  info[][7],
Double_t *  WDX,
Double_t *  WDY,
Double_t *  WDZ,
Double_t  S[2],
Double_t  Sdrift[2],
Double_t  Z[2],
Double_t  Zdrift[2],
Double_t  Zerror[2] 
)

Definition at line 248 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, i, sqrt(), STRAWRESOLUTION, and TWO_PI.

Referenced by PndTrkPlotMacros2::WriteMacroSkewAssociatedHitswithMC(), and PndTrkPlotMacros2::WriteMacroSkewAssociatedHitswithMC_Degree().

263 {
264 
265 
266  Int_t STATUS;
267  Short_t i,
268  j,
269  ii;
270 
271  Double_t
272  aaa,
273  bbb,
274  Bmax,
275  distance,
276  Aellipsis1,
277  Bellipsis1,
278  Rx,
279  Ry,
280  sinDelta,
281  sinTheta,
282  vx1,
283  vy1,
284  vz1,
285  C0x1,
286  C0y1,
287  C0z1,
288  POINTS1[6];
289 
290 
291  // necessary initialization of the intersection position;
292  Z[0]= 999999.;
293  Z[1]= 999999.;
294  i = skewnum ;
295 
296  aaa = sqrt(WDX[i]*WDX[i]+WDY[i]*WDY[i]+ WDZ[i]*WDZ[i]);
297  vx1 = WDX[i]/aaa;
298  vy1 = WDY[i]/aaa;
299  vz1 = WDZ[i]/aaa;
300  C0x1 = info[i][0];
301  C0y1 = info[i][1];
302  C0z1 = info[i][2];
303 
304 
305  calculateintersections(Oxx,Oyy,Rr,C0x1,C0y1,C0z1,info[i][3],
306  vx1,vy1,vz1,
307  &STATUS,POINTS1);
308 
309 
310  if(STATUS < 0 ) return;
311 
312 
313  // loop on the two possible intersections of the middle wire the straw with the
314  // trajectory circle; if that is unphysical then the intersection
315  // remains 999999.
316  for( ii=0; ii<2; ii++){
317  j=3*ii;
318  distance = sqrt(
319  (POINTS1[j]-C0x1)*(POINTS1[j]-C0x1) +
320  (POINTS1[1+j]-C0y1)*(POINTS1[1+j]-C0y1) +
321  (POINTS1[2+j]-C0z1)*(POINTS1[2+j]-C0z1)
322  );
323 
324 
325  Rx = POINTS1[j]-Oxx ; // x component Radial vector of cylinder of trajectory
326  Ry = POINTS1[1+j]-Oyy ; // y direction Radial vector of cylinder of trajectory
327 
328 
329  // the tilt direction of this ellipse is (1,0) when major axis along Z direction
330 
331  sinTheta = vx1*vx1 + vy1*vy1;
332  if( sinTheta < 1.e-10) continue;
333  sinTheta = sqrt(sinTheta);
334  Aellipsis1 = info[i][3]/sinTheta;
335 
336 
337  // Bellipsis1 must be in radians;
338  sinDelta = 1. - (-Ry*vx1 + Rx*vy1)*(-Ry*vx1 + Rx*vy1)/(Rx*Rx+Ry*Ry);
339  // for the derivation of the maximum Bellipsis1 possible see Logbook Panda II on page 109;
340  bbb = info[i][3]*(2.*Rr-info[i][3]);
341  if(bbb< 1.e-10) continue;
342  Bmax = 2.*info[i][3]/sqrt(bbb);
343  if( sinDelta < 1.e-10) Bellipsis1=Bmax;
344  sinDelta = sqrt(sinDelta);
345  Bellipsis1 = info[i][3]/(Rr*sinDelta);
346  if(Bmax<Bellipsis1) Bellipsis1=Bmax;
347 
348  // if the intersection point is unphysical, out of the straw length, quit but set Z[ii] to 1000000.+distance ;
349  if( distance >= info[i][4] + Aellipsis1) {
350  Z[ii] = 1000000.+distance;
351  continue;
352  }
353 
354 //--------------------------
355  S[ii] = atan2(POINTS1[j+1]-Oyy, POINTS1[j]-Oxx) ; // atan2 returns radians in (-pi and +pi]
356  if( S[ii] < 0.) S[ii] += TWO_PI;
357 
358  Sdrift[ii]=Bellipsis1;
359 
360  Z[ii] = POINTS1[j+2];
361  Zdrift[ii] = Aellipsis1;
362  Zerror[ii] = STRAWRESOLUTION/sinTheta;
363 
364 
365 
366 // Double_t rotation1 = 180.*atan2(Tiltdirection1[1],Tiltdirection1[0])/PI;
367 
368 
369  } // end of for( ii=0; ii<2; ii++)
370 
371  return;
372 }
STRAWRESOLUTION
const Double_t STRAWRESOLUTION
Definition: PndTrkConstants.h:243
i
Int_t i
Definition: run_full.C:25
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
Z
double Z
Definition: anaLmdDigi.C:68
PndTrkCTGeometryCalculations::calculateintersections
void calculateintersections(Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t C0x, Double_t C0y, Double_t C0z, Double_t r, Double_t vx, Double_t vy, Double_t vz, Int_t *STATUS, Double_t *POINTS)
Definition: PndTrkCTGeometryCalculations.cxx:99
void PndTrkCTGeometryCalculations::ChooseEntranceExit3 ( Double_t  Oxx,
Double_t  Oyy,
Short_t  Charge,
Double_t  FiStart,
Short_t  nIntersections,
Double_t *  XintersectionList,
Double_t *  YintersectionList,
Double_t *  FiOrderedList 
)

Definition at line 452 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, fi, i, PndTrkMergeSort::Merge_Sort(), and TWO_PI.

Referenced by PndTrkCleanup::Track_Crosses_MvdBarrelFullAzimuthalCoverage(), PndTrkCleanup::Track_Crosses_MvdBarrelPartialAzimuthalCoverage(), and PndTrkCleanup::XYCleanup().

463 {
464 
465  Short_t
466  i;
467  //j; //[R.K. 01/2017] unused variable?
468 
469  Int_t auxIndex[nIntersections];
470 
471  Double_t auxX[nIntersections], auxY[nIntersections], fi[nIntersections];
472 
473  PndTrkMergeSort MergeSort;
474 
475 // this method works under the hypothesis that there are at least 2 intersections.
476 // It is the same as ChooseEntranceExitbis but it gives in output the values of the ordered
477 // Fi ( in FiOrderedLis);
478 
479  if (nIntersections<2) return;
480 
481  if(Charge > 0) { // charge positive, particle rotates clockwise when looking into the beam;
482  for( i=0;i<nIntersections;i++){
483  fi[i] = atan2(YintersectionList[i]-Oyy,
484  XintersectionList[i]-Oxx);
485  if( fi[i] < 0.) fi[i] += TWO_PI;
486  if( fi[i] > FiStart) fi[i] -= TWO_PI;
487  if( fi[i] > FiStart) fi[i] = FiStart;
488  auxIndex[i]=i;
489  } // end of for( i=0;i<nIntersections;i++)
490  MergeSort.Merge_Sort( nIntersections, fi, auxIndex);
491  for( i=0;i<nIntersections;i++){
492  auxX[i] = XintersectionList[ auxIndex[nIntersections-i-1] ];
493  auxY[i] = YintersectionList[ auxIndex[nIntersections-i-1] ];
494  FiOrderedList[i] = fi[nIntersections-i-1];
495  } // end of for( i=0;i<nIntersections;i++)
496 
497  } else { // case in which charge is negative; particle rotates counterclockwise when looking into the beam;
498  for( i=0;i<nIntersections;i++){
499  fi[i] = atan2(YintersectionList[i]-Oyy,
500  XintersectionList[i]-Oxx);
501  if( fi[i] < 0.) fi[i] += TWO_PI;
502  if( fi[i] < FiStart) fi[i] += TWO_PI;
503  if( fi[i] < FiStart) fi[i] += FiStart;
504  auxIndex[i]=i;
505 
506 
507  } // end of for( i=0;i<nIntersections;i++)
508  MergeSort.Merge_Sort( nIntersections, fi, auxIndex);
509 
510  for( i=0;i<nIntersections;i++){
511  auxX[i] = XintersectionList[ auxIndex[i] ];
512  auxY[i] = YintersectionList[ auxIndex[i] ];
513  FiOrderedList[i] = fi[i] ;
514  } // end of for( i=0;i<nIntersections;i++)
515 
516  } // end of if(Charge > 0)
517 
518 
519  for( i=0;i<nIntersections;i++){
520  XintersectionList[i] = auxX[i];
521  YintersectionList[i] = auxY[i];
522  } // end of for( i=0;i<nIntersections;i++)
523 
524 
525 }
i
Int_t i
Definition: run_full.C:25
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
fi
TFile * fi
Definition: createRootGeoFile.C:238
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndTrkMergeSort::Merge_Sort
void Merge_Sort(Short_t n_ele, Double_t *array, Int_t *ind)
Definition: PndTrkMergeSort.cxx:166
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
void PndTrkCTGeometryCalculations::ChooseEntranceExitbis ( Double_t  Oxx,
Double_t  Oyy,
Short_t  Charge,
Double_t  FiStart,
Short_t  nIntersections,
Double_t *  XintersectionList,
Double_t *  YintersectionList,
Double_t  Xcross[2],
Double_t  Ycross[2] 
)

Definition at line 381 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, fi, i, PndTrkMergeSort::Merge_Sort(), and TWO_PI.

Referenced by PndTrkCleanup::SttParalCleanup(), and PndTrkCleanup::SttSkewCleanup().

392 {
393 
394  Short_t
395  i;
396 
397  PndTrkMergeSort MergeSort;
398 
399 // this method works under the hypothesis that there are at least 2 intersections.
400 // It orders the nIntersections intersections using as order parameter the azimuthal
401 // angle fi (in the reference frame of the trajectory helix); then it returns the FIRST
402 // TWO INTERSECTIONS assuming that the track was originated from (0,0,0) and taking into
403 // account its charge;
404 
405  if (nIntersections<2) return;
406 
407  if(Charge > 0) {
408  Int_t auxIndex[100];
409  Double_t fi[100];
410  for( i=0;i<nIntersections;i++){
411  fi[i] = atan2(YintersectionList[i]-Oyy,
412  XintersectionList[i]-Oxx);
413  if( fi[i] < 0.) fi[i] += TWO_PI;
414  if( fi[i] > FiStart) fi[i] -= TWO_PI;
415  if( fi[i] > FiStart) fi[i] = FiStart;
416  auxIndex[i]=i;
417  } // end of for( i=0;i<nIntersections;i++)
418  MergeSort.Merge_Sort( nIntersections, fi, auxIndex);
419  Xcross[0] = XintersectionList[ auxIndex[nIntersections-1] ];
420  Ycross[0] = YintersectionList[ auxIndex[nIntersections-1] ];
421  Xcross[1] = XintersectionList[ auxIndex[nIntersections-2] ];
422  Ycross[1] = YintersectionList[ auxIndex[nIntersections-2] ];
423 
424  } else { // case in which Charge is negative.
425  Int_t auxIndex[nIntersections];
426  Double_t fi[nIntersections];
427  for( i=0;i<nIntersections;i++){
428  fi[i] = atan2(YintersectionList[i]-Oyy,
429  XintersectionList[i]-Oxx);
430  if( fi[i] < 0.) fi[i] += TWO_PI;
431  if( fi[i] < FiStart) fi[i] += TWO_PI;
432  if( fi[i] < FiStart) fi[i] += FiStart;
433  auxIndex[i]=i;
434  } // end of for( i=0;i<nIntersections;i++)
435  MergeSort.Merge_Sort( nIntersections, fi, auxIndex);
436  Xcross[0] = XintersectionList[ auxIndex[0] ];
437  Ycross[0] = YintersectionList[ auxIndex[0] ];
438  Xcross[1] = XintersectionList[ auxIndex[1] ];
439  Ycross[1] = YintersectionList[ auxIndex[1] ];
440  }
441 
442 
443 
444 
445 }
i
Int_t i
Definition: run_full.C:25
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
fi
TFile * fi
Definition: createRootGeoFile.C:238
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndTrkMergeSort::Merge_Sort
void Merge_Sort(Short_t n_ele, Double_t *array, Int_t *ind)
Definition: PndTrkMergeSort.cxx:166
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
PndTrkCTGeometryCalculations::ClassDef ( PndTrkCTGeometryCalculations  ,
1   
)
Double_t PndTrkCTGeometryCalculations::Dist_SZ ( Double_t  Rr,
Double_t  KAPPA,
Double_t  FI0,
Double_t  ZED,
Double_t  S,
Int_t *  nrounds 
)

Definition at line 533 of file PndTrkCTGeometryCalculations.cxx.

References Double_t, fabs(), sqrt(), and TWO_PI.

541 {
542 
543 // Defining : ZZ = (S-FI0)/KAPPA
544 // this method returns the distance (WITH ITS SIGN ) : ZZ - ZED. Therefore this number
545 // can be negative.
546 // Care is taken to calculate this distance properly taking into
547 // account that we are dealing with the function FI = mod(KAPPA*Z + FI0, 2*3.14).
548 
549 // the limits of an Int_t are : -2147483648 <= n <= 2147483647
550 
551  Double_t aaa,
552  //ABSdis1, //[R.K. 01/2017] unused variable?
553  dis1,
554  dis2,
555  dis_segments;
556  //gap; //[R.K. 01/2017] unused variable?
557 
558  if(fabs(KAPPA) < 1.e-10){
559  return -999999999.;
560  } else if (fabs(KAPPA)>1.e10) {
561  return -ZED;
562  }
563 
564 // gap = fabs(TWO_PI/KAPPA);
565 
566  aaa = (KAPPA*ZED)/TWO_PI;
567  if( aaa<-2147483648.) {
568  *nrounds = -2147483647;
569  } else if (aaa > 2147483647.) {
570  *nrounds = 2147483647;
571  } else {
572  *nrounds = (Int_t) aaa;
573  }
574 
575  dis_segments = TWO_PI*Rr/sqrt(1.+KAPPA*KAPPA*Rr*Rr); // distance between
576  // two consecutive segments
577  // of trajectory.
578 
579  dis1 = fabs( Rr*S -Rr*KAPPA*ZED - Rr*FI0)/sqrt( 1.+KAPPA*KAPPA*Rr*Rr);
580  dis1 = fmod(dis1,dis_segments);
581  dis2 = dis_segments-dis1; if(dis2<0.)dis2=0.;
582 
583 
584  if( dis1 < dis2 )
585  {
586  return dis1;
587  } else {
588  return dis2;
589  }
590 
591 }
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
Double_t PndTrkCTGeometryCalculations::Dist_SZ_bis ( Double_t  Rr,
Double_t  KAPPA,
Double_t  FI0,
Double_t  ZED,
Double_t  S,
Short_t  n_allowed_rounds,
Double_t  signPz,
Double_t &  chosenS 
)

Definition at line 597 of file PndTrkCTGeometryCalculations.cxx.

References Double_t, fabs(), i, SEMILENGTH_STRAIGHT, TWO_PI, and ZCENTER_STRAIGHT.

Referenced by PndTrkTracking2::EliminateSpuriousSZ_bis(), and PndTrkTracking2::EliminateSpuriousSZ_ter().

609 {
610 
611 
612 
613  Short_t i;
614  //nMax, //[R.K. 01/2017] unused variable?
615  //nMin //[R.K. 01/2017] unused variable?
616 
617 
618  Double_t
619  boundaries[n_allowed_rounds+3],
620  chosenZ,
621  deltaz,
622  dis,
623  dis_new,
624  z_on_trajectory,
625  z2pi;
626 
627  // check that KAPPA is not zero;
628  if( fabs(KAPPA)<1.e-10) {
629  cout<<"PdnTrkCTGeometryCalculations::Dist_SZ_bis KAPPA < 1.e-10, returning dist=999999.\t";
630  return 999999.;
631  }
632 
633  // calculate z2pi, see logbook on page 140 for meaning;
634 
635  // calculate deltaz, see logbook on page 140 for meaning; the following formula is valid for any combination
636  // of KAPPA and signPz;
637  deltaz = TWO_PI/fabs(KAPPA);
638 
639 
640  // all the calculations are shown in Gianluigi's logbook on page 140;
641  // case with Pz > 0, the particle is moving forward;
642 
643  // for the LITTLE SKEW straws the following is not true, the calculation
644  // should be much more conservative; leave it the same as for the long Skew straw for the moment;
645  boundaries[0] = 0.;
646  if(signPz>0){
647  // particle moving forward;
648 
649 
650  // calculate z2pi, see logbook on page 140 for meaning;
651  if(KAPPA>0.) { z2pi = (TWO_PI-FI0)/KAPPA; if(z2pi<0.) z2pi=0.;} else { z2pi = -FI0/KAPPA;}
652 
653  // the intervals relevant for the trajectory in SZ are n_allowed_rounds+2 (logbook page 141);
654  // loading first the limits of the boundaries;
655 
656 // boundaries[n_allowed_rounds+2] = (n_allowed_rounds+1)*deltaz;
657 
658  // the last boundary is the maximum length of the Skew Straw IN Z (NOT the physical length)
659  // and therefore :
660  boundaries[n_allowed_rounds+2] = ZCENTER_STRAIGHT+SEMILENGTH_STRAIGHT;
661  for(i=1; i<n_allowed_rounds+2;i++){
662  boundaries[i]=z2pi+(i-1)*deltaz;
663  } // end of for (i=1; i<n_allowed_rounds+2;i++)
664 
665  dis = 99999999999.;
666  for(i=0; i< n_allowed_rounds+2; i++){
667  z_on_trajectory = (S-FI0+i*TWO_PI)/KAPPA;
668  // don't accept this solution if it is out of the Z range of this
669  // piece of trajectory in SZ; see logbook on page 141;
670  if( z_on_trajectory < boundaries[i] || z_on_trajectory > boundaries[i+1] ) continue;
671  dis_new = fabs(ZED- z_on_trajectory);
672  if(dis_new < dis) {
673  dis = dis_new;
674  chosenZ = z_on_trajectory; // used later to calculate chosenS;
675  }
676  } // end of for(i=0; i< n_allowed_rounds+2; i++)
677 
678  } else { // in this case Pz <0;
679  // particle moving backward;
680 
681  // calculate z2pi, see logbook on page 140 for meaning;
682  if(KAPPA>0.) { z2pi = FI0/KAPPA;} else { z2pi = -(TWO_PI-FI0)/KAPPA; if(z2pi<0.) z2pi=0.;}
683 
684  // the intervals relevant for the trajectory in SZ are n_allowed_rounds+2 (logbook page 143);
685  // loading first the limits of the boundaries;
686 
687 // boundaries[n_allowed_rounds+2] = -(n_allowed_rounds+1)*deltaz;
688 
689  // the last boundary is the minimum length of the Skew Straw IN Z (NOT the physical length)
690  // and therefore :
691  boundaries[n_allowed_rounds+2] = ZCENTER_STRAIGHT-SEMILENGTH_STRAIGHT;
692  for(i=1; i<n_allowed_rounds+2;i++){
693  boundaries[i]=-z2pi-(i-1)*deltaz;
694  } // end of for (i=1; i<n_allowed_rounds+2;i++)
695 
696  dis = 99999999999.;
697  for(i=0; i< n_allowed_rounds+2; i++){
698  z_on_trajectory = (S-FI0+i*TWO_PI)/KAPPA;
699  // don't accept this solution if it is out of the Z range of this
700  // piece of trajectory in SZ; see logbook on page 143;
701  // since here we are with Z < 0, the boundaries are exchanged compared to the
702  // case whe Pz > 0;
703  if( z_on_trajectory > boundaries[i] || z_on_trajectory < boundaries[i+1] ) continue;
704  dis_new = fabs(ZED - z_on_trajectory);
705  if(dis_new < dis) {
706  dis = dis_new;
707  chosenZ = z_on_trajectory; // used later to calculate chosenS;
708  }
709  } // end of for(i=0; i< n_allowed_rounds+2; i++)
710 
711  } // end of if(signPz>0)
712 
713 
714  // calculate the S corresponding to this hit; this S can be < 0. or > 2PI; so it coincides
715  // with the input S only when the number of rounds of this hit are 0;
716  chosenS = FI0 + KAPPA* chosenZ;
717 
718  return dis;
719 }
i
Int_t i
Definition: run_full.C:25
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
SEMILENGTH_STRAIGHT
const Double_t SEMILENGTH_STRAIGHT
Definition: PndTrkConstants.h:241
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
ZCENTER_STRAIGHT
const Double_t ZCENTER_STRAIGHT
Definition: PndTrkConstants.h:247
Double_t PndTrkCTGeometryCalculations::FindDistance ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  tanlow,
Double_t  tanmid,
Double_t  tanup,
Double_t  alfa,
Double_t  beta,
Double_t  gamma 
)

Definition at line 727 of file PndTrkCTGeometryCalculations.cxx.

References Double_t, fabs(), i, m, n, and sqrt().

738 {
739 
740 
741  Short_t i,
742  n;
743 
744  Double_t Delta,
745  m[3],
746  q,
747  dist,
748  dist1,
749  dist2,
750  //distlow, //[R.K. 01/2017] unused variable?
751  //distmid, //[R.K. 01/2017] unused variable?
752  //distup, //[R.K. 01/2017] unused variable?
753  totaldist,
754  x1,
755  x2,
756  y1,
757  y2;
758 
759 //int nevento=1; //[R.K. 01/2017] unused variable?
760 
761 
762 
763 
764 
765  m[0] = tanlow;
766  m[1] = tanmid;
767  m[2] = tanup;
768 
769  n=0;
770  totaldist=0.;
771 
772 
773  for(i=0;i<3;i++){
774 
775  if( tanlow<999998.) {
776  q = Oyy-m[i]*Oxx;
777  Delta = alfa*alfa + beta*beta*m[i]*m[i] - 4.*gamma*m[i]*m[i] - 4.*q*q + 4.*m[i]*q*alfa +
778  + 2.*alfa*beta*m[i] - 4.*beta*q - 4.*gamma;
779  if( Delta < 0.){
780  dist = -1.;
781  } else if (Delta==0.){
782  x1 = 0.5*(-alfa - 2.*m[i]*q - beta*m[i] )/(1.+m[i]*m[i]);
783  y1 = m[i]*x1+q;
784  dist = fabs( sqrt( (Oxx-x1)*(Oxx-x1) + (Oyy-y1)*(Oyy-y1) ) - Rr);
785  } else {
786  Delta = sqrt(Delta);
787  x1 = 0.5*(-alfa - 2.*m[i]*q - beta*m[i] - Delta)/(1.+m[i]*m[i]);
788  x2 = 0.5*(-alfa - 2.*m[i]*q - beta*m[i] + Delta)/(1.+m[i]*m[i]);
789  y1 = m[i]*x1+q;
790  y2 = m[i]*x2+q;
791  dist1 = fabs( sqrt( (Oxx-x1)*(Oxx-x1) + (Oyy-y1)*(Oyy-y1) ) - Rr);
792  dist2 = fabs( sqrt( (Oxx-x2)*(Oxx-x2) + (Oyy-y2)*(Oyy-y2) ) - Rr);
793  if(dist1<dist2){
794  dist = dist1;
795  } else{
796  dist = dist2;
797  }
798  }
799  } else {
800  Delta = beta*beta - 4.*Oxx*Oxx - 4.*Oxx*alfa - 4.*gamma;
801 
802  if( Delta < 0.){
803  dist = -1.;
804  } else if (Delta==0.){
805  dist = fabs( fabs(Oyy+0.5*beta) - Rr);
806  } else {
807  Delta = sqrt(Delta);
808  y1 = -0.5*beta + Delta/2.;
809  y2 = -0.5*beta - Delta/2.;
810  dist1 = fabs( fabs(Oyy+0.5*beta + Delta/2.) - Rr);
811  dist2 = fabs( fabs(Oyy+0.5*beta - Delta/2.) - Rr);
812  if(dist1<dist2) dist = dist1;
813  else dist = dist2;
814  }
815  }
816 
817  if( dist>-0.5) {
818  totaldist+=dist;
819  n++;
820  }
821 
822 
823  } // end of for(i=0;i<3;i++)
824 
825 
826  if(n!=3) totaldist = -1.;
827  else totaldist = totaldist / n;
828 
829  return totaldist;
830 
831 }
i
Int_t i
Definition: run_full.C:25
m
__m128 m
Definition: P4_F32vec4.h:28
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
n
int n
Definition: HypStatDecay.cxx:21
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
void PndTrkCTGeometryCalculations::FindingParallelTrackAngularRange ( Double_t  oX,
Double_t  oY,
Double_t  Rr,
Short_t  Charge,
Double_t *  Fi_low_limit,
Double_t *  Fi_up_limit,
Short_t *  status,
Double_t  Rmin,
Double_t  Rmax 
)

Definition at line 841 of file PndTrkCTGeometryCalculations.cxx.

References a, acos(), atan2(), Double_t, fi, sqrt(), and TWO_PI.

852 {
853 // -------------- calculate the maximum fi and minimum fi spanned by this track,
854 
855 // see logbook pag.270; by using the Rmin and Rmax of the straw detector.
856 // this function works also when circular trajectory in XY doesn't pass through (0,0).
857 
858  bool intersection_inner,
859  intersection_outer;
860  Double_t //teta1, //[R.K. 01/2017] unused variable?
861  //teta2, //[R.K. 01/2017] unused variable?
862  //tetavertex, //[R.K. 01/2017] unused variable?
863  a,
864  //cosT, //[R.K. 01/2017] unused variable?
865  //cost, //[R.K. 01/2017] unused variable?
866  cosFi,
867  cosfi,
868  Fi,
869  fi,
870  FI0;
871  //Px, //[R.K. 01/2017] unused variable?
872  //Py, //[R.K. 01/2017] unused variable?
873  //tmp; //[R.K. 01/2017] unused variable?
874 
875 
876  Rma += 1. ; // add a safety margin.
877  Rmi -= 1. ; // add a safety margin.
878 
879 
880 
881 
882  a = sqrt(oX*oX+oY*oY);
883 
884  // preliminary condition
885  if(a + Rr <= Rmi ) // in this case there might be hits at radius < Rmi.
886  { *status = -1 ;return;}
887  if( a >= Rr + Rma || Rr >= a + Rma) // in this case there can be no hits with radius < Rma.
888  { *status = -2;return;}
889 
890  if( a - Rr >= Rmi ) intersection_inner = false; else intersection_inner = true;
891 
892  if( a + Rr <= Rma || a - Rr >= Rma )
893  intersection_outer = false; else intersection_outer = true;
894 
895  if( (! intersection_inner) && (! intersection_outer) ){
896  *Fi_low_limit = 0.;
897  *Fi_up_limit = TWO_PI;
898  *status = 1;
899  return;
900  }
901 
902 // now the calculation
903 
904  FI0 = atan2(-oY,-oX);
905  if( intersection_outer ){
906  cosFi = (a*a + Rr*Rr - Rma*Rma)/(2.*Rr*a);
907  if(cosFi<-1.) cosFi=-1.; else if(cosFi>1.) cosFi=1.;
908  Fi = acos(cosFi);
909  }
910 
911  if( intersection_inner ){
912  cosfi = (a*a + Rr*Rr - Rmi*Rmi)/(2.*Rr*a);
913  if(cosfi<-1.) cosfi=-1.; else if(cosfi>1.) cosfi=1.;
914  fi = acos(cosfi);
915  }
916 
917  if( Charge < 0){ // this particle rotates counterclockwise when looking into the beam
918  if( intersection_outer && intersection_inner){
919  *Fi_low_limit=FI0 + fi;
920  *Fi_up_limit= FI0 +Fi;
921 
922  } else if (intersection_inner) {
923  *Fi_low_limit=FI0 + fi;
924  *Fi_up_limit= FI0 - fi;
925  } else { // case with intersection_outer=true; intersection_inner=false;
926  *Fi_low_limit=FI0 - Fi;
927  *Fi_up_limit= FI0 + Fi;
928  } // end of if( intersection_outer && intersection_inner
929 
930 
931 
932  } else { // continuation of if( Charge < 0.)
933 
934  if( intersection_outer && intersection_inner){
935  *Fi_low_limit=FI0 - Fi;
936  *Fi_up_limit= FI0 - fi;
937 
938  } else if (intersection_inner) {
939  *Fi_low_limit=FI0 + fi; // must invert because low limit must be < up limit
940  *Fi_up_limit= FI0 - fi;
941  } else { // case with intersection_outer=true; intersection_inner=false;
942  *Fi_low_limit=FI0 - Fi;
943  *Fi_up_limit= FI0 + Fi;
944  } // end of if( intersection_outer && intersection_inner
945 
946 
947  } // end of if( Charge < 0.)
948 
949 
950  if(*Fi_low_limit<0.) {
951  *Fi_low_limit=fmod(*Fi_low_limit,TWO_PI);
952  *Fi_low_limit += TWO_PI;
953  } else if (*Fi_low_limit>=TWO_PI){
954  *Fi_low_limit=fmod(*Fi_low_limit,TWO_PI);
955  }
956  if(*Fi_up_limit<0.) {
957  *Fi_up_limit=fmod(*Fi_up_limit,TWO_PI);
958  *Fi_up_limit += TWO_PI;
959  } else if (*Fi_up_limit>=TWO_PI){
960  *Fi_up_limit=fmod(*Fi_up_limit,TWO_PI);
961  }
962 
963  // Modify *Fi_up_limit by adding
964  // 2PI if it is the case, in order to make *Fi_up_limit > *Fi_low_limit.
965  if( *Fi_up_limit < *Fi_low_limit ) *Fi_up_limit += TWO_PI;
966  if( *Fi_up_limit < *Fi_low_limit ) *Fi_up_limit = *Fi_low_limit;
967 
968 
969 
970  return;
971 }
acos
friend F32vec4 acos(const F32vec4 &a)
Definition: P4_F32vec4.h:113
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
a
Int_t a
Definition: anaLmdDigi.C:126
fi
TFile * fi
Definition: createRootGeoFile.C:238
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
status
int status[10]
Definition: f_Init.h:28
void PndTrkCTGeometryCalculations::FindingParallelTrackAngularRange2 ( Double_t  oX,
Double_t  oY,
Double_t  Rma,
Double_t  Rmi,
Double_t  Rr,
Double_t *  Fi_low_limit,
Double_t *  Fi_up_limit,
Short_t *  status 
)

Definition at line 981 of file PndTrkCTGeometryCalculations.cxx.

References a, acos(), atan2(), Double_t, fi, i, sqrt(), and TWO_PI.

996 {
997 // -------------- calculate the maximum fi and minimum fi spanned by this track,
998 
999 // see logbook pag.270; by using the Rmin and Rmax of the straw detector.
1000 // this function works also when circular trajectory in XY doesn't pass through (0,0).
1001 
1002  bool intersection_inner,
1003  intersection_outer;
1004  Double_t //teta1, //[R.K. 01/2017] unused variable?
1005  //teta2, //[R.K. 01/2017] unused variable?
1006  //tetavertex, //[R.K. 01/2017] unused variable?
1007  a,
1008  //cosT, //[R.K. 01/2017] unused variable?
1009  //cost, //[R.K. 01/2017] unused variable?
1010  cosFi,
1011  cosfi,
1012  Fi,
1013  fi,
1014  FI0;
1015  //Px, //[R.K. 01/2017] unused variable?
1016  //Py, //[R.K. 01/2017] unused variable?
1017  //tmp; //[R.K. 01/2017] unused variable?
1018 
1019 
1020  // Fi_low_limit is an array of dimensionality 2;
1021  // Fi_up_limit is an array of dimensionality 2;
1022  // Fi_low_limit[0], Fi_up_limit[0] is the solution (radians) corresponding to the intersection
1023  // on the RIGHT side, in the XY projection of the trajectory [looking into the beam] with respect
1024  // to the segment joining the Center of the Helix with the origin (0,0);
1025  // Fi_low_limit[1], Fi_up_limit[1] is the solution corresponding to the LEFT intersection; in case
1026  // there is no second solution it is set at -100.;
1027  // the charge is not considered here; the two solution are just determined by the intersection of the trajectory
1028  // circle with the inner and outer boundary of the STT detector system;
1029 
1030  // the trajectory NEEDS NOT to come from the origin ;
1031 
1032  // Fi_low_limit is ALWAY between 0 and 2PI radians;
1033  // Fi_up_limit is ALWAYS bigger than Fi_low_limit (not necessarily < 2PI), in radians;
1034 
1035  Rma += 1. ; // add a safety margin.
1036  Rmi -= 1. ; // add a safety margin.
1037 
1038  a = sqrt(oX*oX+oY*oY);
1039 
1040  // preliminary condition
1041  if(a + Rr <= Rmi ) // in this case there might be hits at radius < Rmi.
1042  { *status = -1 ;return;}
1043  if( a >= Rr + Rma || Rr >= a + Rma) // in this case there can be no hits with radius < Rma.
1044  { *status = -2;return;}
1045 
1046  if( a - Rr >= Rmi ) intersection_inner = false; else intersection_inner = true;
1047 
1048  if( a + Rr <= Rma || a - Rr >= Rma )
1049  intersection_outer = false; else intersection_outer = true;
1050 
1051  if( (! intersection_inner) && (! intersection_outer) ){
1052  // in this case the trajectory is contained completely between the inner
1053  // and outer regions of the STT;
1054  Fi_low_limit[0] = 0.;
1055  Fi_up_limit[0] = TWO_PI;
1056  *status = 1;
1057  return;
1058  }
1059 
1060 // now the calculation
1061 
1062  FI0 = atan2(-oY,-oX);
1063  if( intersection_outer ){
1064  cosFi = (a*a + Rr*Rr - Rma*Rma)/(2.*Rr*a);
1065  if(cosFi<-1.) cosFi=-1.; else if(cosFi>1.) cosFi=1.;
1066  Fi = acos(cosFi);
1067  }
1068 
1069  if( intersection_inner ){
1070  cosfi = (a*a + Rr*Rr - Rmi*Rmi)/(2.*Rr*a);
1071  if(cosfi<-1.) cosfi=-1.; else if(cosfi>1.) cosfi=1.;
1072  fi = acos(cosfi);
1073  }
1074 
1075  if( intersection_outer && intersection_inner){
1076 
1077  Fi_low_limit[1] = FI0 - Fi;
1078  Fi_up_limit[1] = FI0 - fi;
1079 
1080  Fi_low_limit[0] = FI0 + fi;
1081  Fi_up_limit[0] = FI0 + Fi;
1082 
1083  } else if (intersection_inner) {
1084  Fi_low_limit[0] = FI0 + fi;
1085  Fi_up_limit[0] = FI0 - fi;
1086 
1087  Fi_low_limit[1] = -100.;
1088  Fi_up_limit[1] = -100.;
1089  } else { // case with intersection_outer=true; intersection_inner=false;
1090  Fi_low_limit[0]=FI0 - Fi;
1091  Fi_up_limit[0]= FI0 + Fi;
1092 
1093  Fi_low_limit[1] = -100.;
1094  Fi_up_limit[1] = -100.;
1095  } // end of if( intersection_outer && intersection_inner
1096 
1097  for(int i=0; i<2; i++){
1098  if( Fi_low_limit[i]<-99.) continue;
1099  if(Fi_low_limit[i]<0.) {
1100  Fi_low_limit[i]=fmod(Fi_low_limit[i],TWO_PI);
1101  Fi_low_limit[i] += TWO_PI;
1102  } else if (Fi_low_limit[i]>=TWO_PI){
1103  Fi_low_limit[i]=fmod(Fi_low_limit[i],TWO_PI);
1104  }
1105  if(Fi_up_limit[i]<0.) {
1106  Fi_up_limit[i]=fmod(Fi_up_limit[i],TWO_PI);
1107  Fi_up_limit[i] += TWO_PI;
1108  } else if (Fi_up_limit[i]>=TWO_PI){
1109  Fi_up_limit[i]=fmod(Fi_up_limit[i],TWO_PI);
1110  }
1111 
1112  // Modify *Fi_up_limit by adding
1113  // 2PI if it is the case, in order to make *Fi_up_limit > *Fi_low_limit.
1114  if( Fi_up_limit[i] < Fi_low_limit[i] ) Fi_up_limit[i] += TWO_PI;
1115  if( Fi_up_limit[i] < Fi_low_limit[i] ) Fi_up_limit[i] = Fi_low_limit[i];
1116  } // end of for(int i=0; i<2; i++)
1117  *status = 0;
1118 
1119 
1120 
1121 
1122  return;
1123 }
acos
friend F32vec4 acos(const F32vec4 &a)
Definition: P4_F32vec4.h:113
i
Int_t i
Definition: run_full.C:25
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
a
Int_t a
Definition: anaLmdDigi.C:126
fi
TFile * fi
Definition: createRootGeoFile.C:238
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
status
int status[10]
Definition: f_Init.h:28
Short_t PndTrkCTGeometryCalculations::FindIntersectionsOuterCircle ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  RMax,
Double_t  Xcross[2],
Double_t  Ycross[2] 
)

Definition at line 1131 of file PndTrkCTGeometryCalculations.cxx.

References a, acos(), atan2(), cos(), Double_t, sin(), and sqrt().

Referenced by PndTrkCleanup::SttParalCleanup(), PndTrkCleanup::SttSkewCleanup(), PndTrkCleanup::Track_Crosses_MvdBarrelFullAzimuthalCoverage(), PndTrkCleanup::Track_Crosses_MvdBarrelPartialAzimuthalCoverage(), and PndTrkCleanup::XYCleanup().

1140 {
1141 
1142  // return -1 --> non-intersection;
1143  // return 0 --> 2 intersections.
1144 
1145  Double_t a,
1146  cosFi,
1147  Fi,
1148  FI0;
1149  a = sqrt(oX*oX+oY*oY);
1150 
1151  // case with no intersections or just 1 intersection;
1152  if( a >= Rr + Rma || Rr >= a + Rma || a + Rr <= Rma) return -1;
1153 
1154 
1155  FI0 = atan2(-oY,-oX);
1156  cosFi = (a*a + Rr*Rr - Rma*Rma)/(2.*Rr*a);
1157  if(cosFi<-1.) cosFi=-1.; else if(cosFi>1.) cosFi=1.;
1158  Fi = acos(cosFi);
1159 
1160  Xcross[0] = oX + Rr*cos(FI0+Fi);
1161  Ycross[0] = oY + Rr*sin(FI0+Fi);
1162  Xcross[1] = oX + Rr*cos(FI0-Fi);
1163  Ycross[1] = oY + Rr*sin(FI0-Fi);
1164 
1165  return 0;
1166 }
acos
friend F32vec4 acos(const F32vec4 &a)
Definition: P4_F32vec4.h:113
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: P4_F32vec4.h:112
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: P4_F32vec4.h:111
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitbiHexagonLeft ( Double_t  vgap,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  Xcross[2],
Double_t  Ycross[2] 
)

Definition at line 1172 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, and TWO_PI.

Referenced by PndTrkCleanup::SttParalCleanup(), and PndTrkCleanup::SttSkewCleanup().

1184 {
1185  Short_t flag;
1186  Short_t nIntersections;
1187  Double_t FiStart,
1188  XintersectionList[16], // all the possible intersections
1189  YintersectionList[16]; // (up to 16 intersections).
1190 
1191 // The following is the form of the Left (looking from downstream into the beam) biHexagon
1192 // geometrical shape considered in this method :
1193 //
1194 /*
1195 
1196  /|
1197  / |
1198  / |
1199  / /
1200  / /
1201  / /
1202  / /
1203  | |
1204  | |
1205  | |
1206  | |
1207  \ \
1208  \ \
1209  \ \
1210  \ \
1211  \ |
1212  \ |
1213  \|
1214 
1215 */
1216 // finding all possible intersections with inner parallel straw region.
1217 // The inner parallel straw region is delimited by two hexagons.
1218 
1219  // flag meaning :
1220  // -1 --> track outside outer perimeter;
1221  // 0 --> at least 1 intersection with polygon, therefore a possible entry and an exit;
1222  // 1 --> track contained completely between the two polygons;
1223 
1224 
1225  flag=IntersectionsWithClosedbiHexagonLeft(
1226  vgap,
1227  Oxx,
1228  Oyy,
1229  Rr,
1230  ApotemaMin, // Apotema of the inner Hexagon,
1231  ApotemaMax,// Apotema of the outer Hexagon.
1232  &nIntersections,
1233  XintersectionList, // XintersectionList[..][0] --> inner polygon,
1234  // XintersectionList[..][1] --> outer polygon.
1235  YintersectionList
1236  );
1237 
1238  // IMPORTANT :
1239  // this is true because here it is assumed that the track comes from (0,0,0)
1240  // otherwise the code must be changed!
1241 
1242  if (!(flag == 0)) return flag;
1243  if( nIntersections<2) return -1;
1244 
1245 //------- among all possible intersection find the entrance point (Xcross[0], Ycross[0])
1246 // and the exit point (Xcross[1], Ycross[1]) of this track.
1247 
1248 //-------- the starting point of the track.
1249  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
1250  if(FiStart<0.) FiStart+= TWO_PI;
1251  if(FiStart<0.) FiStart =0.;
1252 
1253  // this method selects the entrance and exit points of the trajectory among all
1254  // geometrical intersections of the circular trajectory with the straw particular
1255  // volume.
1256 
1257  // so at this point, the intersections are at least 2.
1258 
1259  ChooseEntranceExitbis(
1260  Oxx,
1261  Oyy,
1262  Charge,
1263  FiStart,
1264  nIntersections,
1265  XintersectionList,
1266  YintersectionList,
1267  Xcross, // output
1268  Ycross // output
1269  );
1270 
1271 
1272 //----------------------
1273 
1274  return flag;
1275 
1276 }
PndTrkCTGeometryCalculations::IntersectionsWithClosedbiHexagonLeft
Short_t IntersectionsWithClosedbiHexagonLeft(Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t Ami, Double_t Ama, Short_t *nIntersections, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2328
Start
timer Start()
PndTrkCTGeometryCalculations::ChooseEntranceExitbis
void ChooseEntranceExitbis(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t Xcross[2], Double_t Ycross[2])
Definition: PndTrkCTGeometryCalculations.cxx:381
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitbiHexagonLeft2 ( Double_t  vgap,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  XintersectionList[16],
Double_t  YintersectionList[16],
Double_t  FiOrderedList[16] 
)

Definition at line 1285 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, and TWO_PI.

1298 {
1299  Short_t flag,
1300  nIntersections;
1301  Double_t FiStart;
1302 
1303 // The following is the form of the Left (looking from downstream into the beam) biHexagon
1304 // geometrical shape considered in this method :
1305 //
1306 
1307 
1308 // /| //
1309 // / | //
1310 // / | //
1311 // / / //
1312 // / / //
1313 // / / //
1314 // / / //
1315 // | | //
1316 // | | //
1317 // | | //
1318 // | | //
1319 // \ \ //
1320 // \ \ //
1321 // \ \ //
1322 // \ \ //
1323 // \ | //
1324 // \ | //
1325 // \| //
1326 
1327 
1328 // finding all possible intersections with inner parallel straw region.
1329 // The inner parallel straw region is delimited by two hexagons.
1330 
1331  // flag meaning :
1332  // -1 --> track outside outer perimeter;
1333  // 0 --> at least 1 intersection with polygon, therefore a possible entry and an exit;
1334  // 1 --> track contained completely between the two polygons;
1335 
1336  // nIntersections is the number of intersections found;
1337 
1338 // This method return nIntersections (it can be 0);
1339 
1340 
1341 
1342  flag=IntersectionsWithClosedbiHexagonLeft(
1343  vgap,
1344  Oxx,
1345  Oyy,
1346  Rr,
1347  ApotemaMin, // Apotema of the inner Hexagon,
1348  ApotemaMax,// Apotema of the outer Hexagon.
1349  &nIntersections,
1350  XintersectionList, // XintersectionList[..][0] --> inner polygon,
1351  // XintersectionList[..][1] --> outer polygon.
1352  YintersectionList
1353  );
1354 
1355  // IMPORTANT :
1356  // this is true because here it is assumed that the track comes from (0,0,0)
1357  // otherwise the code must be changed!
1358 
1359  if (!(flag == 0)) return 0;
1360 
1361 //------- among all possible intersection find the entrance point (Xcross[0], Ycross[0])
1362 // and the exit point (Xcross[1], Ycross[1]) of this track.
1363 
1364 //-------- the starting point of the track.
1365  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
1366  if(FiStart<0.) FiStart+= TWO_PI;
1367  if(FiStart<0.) FiStart =0.;
1368 
1369  // this method selects the entrance and exit points of the trajectory among all
1370  // geometrical intersections of the circular trajectory with the straw particular
1371  // volume.
1372 
1373  // so at this point, the intersections are at least 2.
1374 
1375 
1376  // XintersectionList and YintersectionList are ordered clockwise or counterclockwise
1377  // according to the charge;
1378  ChooseEntranceExit3(
1379  Oxx,
1380  Oyy,
1381  Charge,
1382  FiStart,
1383  nIntersections,
1384  XintersectionList, // input and output;
1385  YintersectionList, // input and output;
1386  FiOrderedList
1387  );
1388 
1389 
1390 //----------------------
1391 
1392  return nIntersections;
1393 
1394 }
PndTrkCTGeometryCalculations::IntersectionsWithClosedbiHexagonLeft
Short_t IntersectionsWithClosedbiHexagonLeft(Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t Ami, Double_t Ama, Short_t *nIntersections, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2328
PndTrkCTGeometryCalculations::ChooseEntranceExit3
void ChooseEntranceExit3(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t *FiOrderedList)
Definition: PndTrkCTGeometryCalculations.cxx:452
Start
timer Start()
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitbiHexagonRight ( Double_t  vgap,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  Xcross[2],
Double_t  Ycross[2] 
)

Definition at line 1401 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, and TWO_PI.

Referenced by PndTrkCleanup::SttParalCleanup(), and PndTrkCleanup::SttSkewCleanup().

1413 {
1414  Short_t flag;
1415  Short_t nIntersections;
1416  Double_t FiStart,
1417  XintersectionList[16], // all the possible intersections
1418  YintersectionList[16]; // (up to 16 intersections).
1419 
1420 // The following is the form of the Left (looking from downstream into the beam) biHexagon
1421 // geometrical shape considered in this method :
1422 //
1423 //
1424 // |\ //
1425 // | \ //
1426 // | \ //
1427 // \ \ //
1428 // \ \ //
1429 // | | //
1430 // | | //
1431 // / / //
1432 // / / //
1433 // / / //
1434 // | / //
1435 // | / //
1436 // |/ //
1437 //
1438 
1439 // finding all possible intersections with inner parallel straw region.
1440 // The inner parallel straw region is delimited by two hexagons.
1441 
1442  // flag meaning :
1443  // -1 --> track outside outer perimeter;
1444  // 0 --> at least 1 intersection with polygon, therefore a possible entry and an exit;
1445  // 1 --> track contained completely between the two polygons;
1446 
1447 
1448  flag=IntersectionsWithClosedbiHexagonRight(
1449  vgap,
1450  Oxx,
1451  Oyy,
1452  Rr,
1453  ApotemaMin, // Apotema of the inner Hexagon,
1454  ApotemaMax,// Apotema of the outer Hexagon.
1455  &nIntersections,
1456  XintersectionList,
1457  YintersectionList
1458  );
1459 
1460 
1461 
1462 
1463  // IMPORTANT :
1464  // this is true because here it is assumed that the track comes from (0,0,0)
1465  // otherwise the code must be changed!
1466 
1467  if (!(flag == 0)) return flag;
1468  if( nIntersections<2) return -1;
1469 
1470 //------- among all possible intersection find the entrance point (Xcross[0], Ycross[0])
1471 // and the exit point (Xcross[1], Ycross[1]) of this track.
1472 
1473 //-------- the starting point of the track.
1474  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
1475  if(FiStart<0.) FiStart+= TWO_PI;
1476  if(FiStart<0.) FiStart =0.;
1477 
1478  // this method selects the entrance and exit points of the trajectory among all
1479  // geometrical intersections of the circular trajectory with the straw particular
1480  // volume.
1481 
1482  // so at this point, the intersections are at least 2.
1483 
1484  ChooseEntranceExitbis(
1485  Oxx,
1486  Oyy,
1487  Charge,
1488  FiStart,
1489  nIntersections,
1490  XintersectionList,
1491  YintersectionList,
1492  Xcross, // output
1493  Ycross // output
1494  );
1495 
1496 
1497 //----------------------
1498 
1499  return flag;
1500 
1501 }
PndTrkCTGeometryCalculations::IntersectionsWithClosedbiHexagonRight
Short_t IntersectionsWithClosedbiHexagonRight(Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t Ami, Double_t Ama, Short_t *nIntersections, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2470
Start
timer Start()
PndTrkCTGeometryCalculations::ChooseEntranceExitbis
void ChooseEntranceExitbis(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t Xcross[2], Double_t Ycross[2])
Definition: PndTrkCTGeometryCalculations.cxx:381
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitbiHexagonRight2 ( Double_t  vgap,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  XintersectionList[16],
Double_t  YintersectionList[16],
Double_t  FiOrderedList[16] 
)

Definition at line 1510 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, and TWO_PI.

1523 {
1524  Short_t flag,
1525  nIntersections;
1526 
1527  Double_t FiStart;
1528 
1529 // The following is the form of the Left (looking from downstream into the beam) biHexagon
1530 // geometrical shape considered in this method :
1531 //
1532 //
1533 // |\ //
1534 // | \ //
1535 // | \ //
1536 // \ \ //
1537 // \ \ //
1538 // | | //
1539 // | | //
1540 // / / //
1541 // / / //
1542 // / / //
1543 // | / //
1544 // | / //
1545 // |/ //
1546 //
1547 
1548 // finding all possible intersections with inner parallel straw region.
1549 // The inner parallel straw region is delimited by two hexagons.
1550 
1551  // flag meaning :
1552  // -1 --> track outside outer perimeter;
1553  // 0 --> at least 1 intersection with polygon, therefore a possible entry and an exit;
1554  // 1 --> track contained completely between the two polygons;
1555 
1556 
1557 // This method returns the number of intersections (it can be 0);
1558 
1559 
1560 
1561  flag=IntersectionsWithClosedbiHexagonRight(
1562  vgap,
1563  Oxx,
1564  Oyy,
1565  Rr,
1566  ApotemaMin, // Apotema of the inner Hexagon,
1567  ApotemaMax,// Apotema of the outer Hexagon.
1568  &nIntersections,
1569  XintersectionList,
1570  YintersectionList
1571  );
1572 
1573 
1574  // IMPORTANT :
1575  // this is true because here it is assumed that the track comes from (0,0,0)
1576  // otherwise the code must be changed!
1577 
1578  if (!(flag == 0)) return 0;
1579 
1580 //------- among all possible intersection find the entrance point (Xcross[0], Ycross[0])
1581 // and the exit point (Xcross[1], Ycross[1]) of this track.
1582 
1583 //-------- the starting point of the track.
1584  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
1585  if(FiStart<0.) FiStart+= TWO_PI;
1586  if(FiStart<0.) FiStart =0.;
1587 
1588  // this method selects the entrance and exit points of the trajectory among all
1589  // geometrical intersections of the circular trajectory with the straw particular
1590  // volume.
1591 
1592  // so at this point, the intersections are at least 2.
1593 
1594  // XintersectionList and YintersectionList are ordered clockwise or counterclockwise
1595  // according to the charge;
1596  ChooseEntranceExit3(
1597  Oxx,
1598  Oyy,
1599  Charge,
1600  FiStart,
1601  nIntersections,
1602  XintersectionList, // input and output;
1603  YintersectionList, // input and output;
1604  FiOrderedList // output;
1605  );
1606 
1607 
1608 //----------------------
1609 
1610  return nIntersections;
1611 
1612 }
PndTrkCTGeometryCalculations::IntersectionsWithClosedbiHexagonRight
Short_t IntersectionsWithClosedbiHexagonRight(Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t Ami, Double_t Ama, Short_t *nIntersections, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2470
PndTrkCTGeometryCalculations::ChooseEntranceExit3
void ChooseEntranceExit3(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t *FiOrderedList)
Definition: PndTrkCTGeometryCalculations.cxx:452
Start
timer Start()
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitHexagonCircleLeft ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  GAP,
Double_t  Xcross[2],
Double_t  Ycross[2] 
)

Definition at line 1620 of file PndTrkCTGeometryCalculations.cxx.

References a, atan2(), b, c, Double_t, sqrt(), and TWO_PI.

Referenced by PndTrkCleanup::SttParalCleanup().

1632 {
1633 
1634 // This methods finds the intersections between a trajectory coming from (0,0) and
1635 // parameters Oxx, Oyy, Rr with the closed geometrical figure (in XY) formed by the STT
1636 // external Left semicircle and the Outer STT parallel Left straw semi-Hexagon + Gap for
1637 // the pellet target target.
1638 // It returns -1 if there are 0 or 1 intersections, or it returns 0
1639 // if they are at least 2.
1640 
1641 
1642 //------------------
1643 
1644  Short_t nIntersectionsCircle,
1645  nIntersections;
1646  Double_t FiStart,
1647  XintersectionList[12],
1648  YintersectionList[12]; // all the possible intersections (up to 12 intersections).
1649 
1650 // finding all possible intersections with inner parallel straw region.
1651 
1652 
1653  Double_t Side_x[] = { -GAP/2., -GAP/2. , -ApotemaMin, -ApotemaMin, -GAP/2., -GAP/2. },
1654  Side_y[] = { sqrt(Rma*Rma-GAP*GAP/4.), (2.*ApotemaMin-GAP/2.)/sqrt(3.),
1655  ApotemaMin/sqrt(3.),
1656  -ApotemaMin/sqrt(3.),
1657  -(2.*ApotemaMin-GAP/2.)/sqrt(3.), -sqrt(Rma*Rma-GAP*GAP/4.)},
1658  a[] = {1., -1./sqrt(3.), 1., 1./sqrt(3.), 1.},
1659  b[] = {0., 1., 0., 1., 0.},
1660  c[] = {GAP/2., -2.*ApotemaMin/sqrt(3.),ApotemaMin, 2.*ApotemaMin/sqrt(3.), GAP/2.};
1661 
1662  nIntersections=IntersectionsWithOpenPolygon(
1663  Oxx,
1664  Oyy,
1665  Rr,
1666  5, // n. Sides of open Polygon.
1667  a, // coefficient of formula : aX + bY + c = 0 defining the Polygon sides.
1668  b,
1669  c,
1670  Side_x, // X,Y coordinate of the Sides vertices (in sequence, following
1671  Side_y, // the Polygon along.
1672  XintersectionList, // XintersectionList
1673  YintersectionList // YintersectionList.
1674  );
1675 
1676 
1677 
1678 
1679 //-------------------------------------------------------------------------
1680 // finding intersections of trajectory [assumed to originate from (0,0) ]
1681 // with outer semicircle, the Left part.
1682 
1683  nIntersectionsCircle=IntersectionsWithGapSemicircle(
1684  Oxx, // input from trajectory
1685  Oyy, // input from trajectory
1686  Rr, // input from trajectory
1687  GAP, // input, vertical gap in XY plane of STT detector.
1688  true, // true --> Left semicircle, false --> Right semicircle.
1689  Rma, // radius of external Stt containment.
1690  &XintersectionList[nIntersections], // output, X list of intersections (maximal 2).
1691  &YintersectionList[nIntersections]
1692  );
1693  nIntersections += nIntersectionsCircle;
1694 
1695 //-------- the starting point of the track.
1696 
1697  if(nIntersections<2) return -1;
1698 
1699  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
1700  if(FiStart<0.) FiStart+= TWO_PI;
1701  if(FiStart<0.) FiStart =0.;
1702 
1703  // this method selects the entrance and exit points of the trajectory among all
1704  // geometrical intersections of the circular trajectory with the straw particular
1705  // volume.
1706 
1707 
1708  ChooseEntranceExitbis(
1709  Oxx,
1710  Oyy,
1711  Charge,
1712  FiStart,
1713  nIntersections,
1714  XintersectionList,
1715  YintersectionList,
1716  Xcross, // output
1717  Ycross // output
1718  );
1719 
1720 
1721  return 0;
1722 
1723 }
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
Start
timer Start()
PndTrkCTGeometryCalculations::ChooseEntranceExitbis
void ChooseEntranceExitbis(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t Xcross[2], Double_t Ycross[2])
Definition: PndTrkCTGeometryCalculations.cxx:381
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndTrkCTGeometryCalculations::IntersectionsWithOpenPolygon
Short_t IntersectionsWithOpenPolygon(Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t nSides, Double_t *a, Double_t *b, Double_t *c, Double_t *side_x, Double_t *side_y, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2846
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
PndTrkCTGeometryCalculations::IntersectionsWithGapSemicircle
Short_t IntersectionsWithGapSemicircle(Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t gap, bool left, Double_t Rma, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2749
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitHexagonCircleLeft2 ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  GAP,
Double_t  XintersectionList[12],
Double_t  YintersectionList[12],
Double_t  FiOrderedList[12] 
)

Definition at line 1731 of file PndTrkCTGeometryCalculations.cxx.

References a, atan2(), b, c, Double_t, sqrt(), and TWO_PI.

1744 {
1745 
1746 // THIS METHOD IS THE SAME AS FindTrackEntranceExitHexagonCircleLeft BUT IT PROVIDES ALL THE
1747 // INTERSECTIONS ORDERED FROM CENTER TO PERIFERY;
1748 // This methods finds the intersections between a trajectory coming from (0,0) and
1749 // parameters Oxx, Oyy, Rr with the closed geometrical figure (in XY) formed by the STT
1750 // external Left semicircle and the Outer STT parallel Left straw semi-Hexagon + Gap for
1751 // the pellet target target.
1752 // It returns the number of intersections (0 in case).
1753 
1754 // At the most the number of such intersection is 12, that's why XintersectionList[12];
1755 // also the intersections are ordered from center to perifery according to the charge of the
1756 // track that dictates the sense of rotation;
1757 
1758  Short_t nIntersections;
1759 
1760 //------------------
1761 
1762  Short_t nIntersectionsCircle;
1763 
1764  Double_t FiStart;
1765 
1766 
1767 
1768 // This method returns the number of intersections (it can be 0);
1769 
1770 
1771 
1772 
1773 // finding all possible intersections with inner parallel straw region.
1774 
1775 
1776  Double_t Side_x[] = { -GAP/2., -GAP/2. , -ApotemaMin, -ApotemaMin, -GAP/2., -GAP/2. },
1777  Side_y[] = { sqrt(Rma*Rma-GAP*GAP/4.), (2.*ApotemaMin-GAP/2.)/sqrt(3.),
1778  ApotemaMin/sqrt(3.),
1779  -ApotemaMin/sqrt(3.),
1780  -(2.*ApotemaMin-GAP/2.)/sqrt(3.), -sqrt(Rma*Rma-GAP*GAP/4.)},
1781  a[] = {1., -1./sqrt(3.), 1., 1./sqrt(3.), 1.},
1782  b[] = {0., 1., 0., 1., 0.},
1783  c[] = {GAP/2., -2.*ApotemaMin/sqrt(3.),ApotemaMin, 2.*ApotemaMin/sqrt(3.), GAP/2.};
1784 
1785  nIntersections=IntersectionsWithOpenPolygon(
1786  Oxx,
1787  Oyy,
1788  Rr,
1789  5, // n. Sides of open Polygon.
1790  a, // coefficient of formula : aX + bY + c = 0 defining the Polygon sides.
1791  b,
1792  c,
1793  Side_x, // X,Y coordinate of the Sides vertices (in sequence, following
1794  Side_y, // the Polygon along.
1795  XintersectionList, // XintersectionList
1796  YintersectionList // YintersectionList.
1797  );
1798 
1799 
1800 
1801 //-------------------------------------------------------------------------
1802 // finding intersections of trajectory [assumed to originate from (0,0) ]
1803 // with outer semicircle, the Left part.
1804 
1805  nIntersectionsCircle=IntersectionsWithGapSemicircle(
1806  Oxx, // input from trajectory
1807  Oyy, // input from trajectory
1808  Rr, // input from trajectory
1809  GAP, // input, vertical gap in XY plane of STT detector.
1810  true, // true --> Left semicircle, false --> Right semicircle.
1811  Rma, // radius of external Stt containment.
1812  &XintersectionList[nIntersections], // output, X list of intersections (maximal 2).
1813  &YintersectionList[nIntersections]
1814  );
1815  nIntersections += nIntersectionsCircle;
1816 
1817 //-------- the starting point of the track.
1818 
1819  if(nIntersections==0) return 0;
1820 
1821  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
1822  if(FiStart<0.) FiStart+= TWO_PI;
1823  if(FiStart<0.) FiStart =0.;
1824 
1825  // this method selects the entrance and exit points of the trajectory among all
1826  // geometrical intersections of the circular trajectory with the straw particular
1827  // volume; IT RETURNS all the intersections ordered from center to perifery according to the sense of
1828  // rotation dictated by the charge of the track;
1829  // the methods requires at least 2 intersection;
1830 
1831  ChooseEntranceExit3(
1832  Oxx,
1833  Oyy,
1834  Charge,
1835  FiStart,
1836  nIntersections,
1837  XintersectionList, // input and output;
1838  YintersectionList, // input and output;
1839  FiOrderedList // output;
1840  );
1841 
1842 
1843  return nIntersections;
1844 
1845 }
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
PndTrkCTGeometryCalculations::ChooseEntranceExit3
void ChooseEntranceExit3(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t *FiOrderedList)
Definition: PndTrkCTGeometryCalculations.cxx:452
Start
timer Start()
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndTrkCTGeometryCalculations::IntersectionsWithOpenPolygon
Short_t IntersectionsWithOpenPolygon(Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t nSides, Double_t *a, Double_t *b, Double_t *c, Double_t *side_x, Double_t *side_y, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2846
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
PndTrkCTGeometryCalculations::IntersectionsWithGapSemicircle
Short_t IntersectionsWithGapSemicircle(Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t gap, bool left, Double_t Rma, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2749
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitHexagonCircleRight ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  GAP,
Double_t  Xcross[2],
Double_t  Ycross[2] 
)

Definition at line 1854 of file PndTrkCTGeometryCalculations.cxx.

References a, atan2(), b, c, Double_t, sqrt(), and TWO_PI.

Referenced by PndTrkCleanup::SttParalCleanup().

1866 {
1867 
1868 // This methods finds the intersections between a trajectory coming from (0,0) and
1869 // parameters Oxx, Oyy, Rr with the closed geometrical figure (in XY) formed by the STT
1870 // external Left semicircle and the Outer STT parallel Left straw semi-Hexagon + Gap for
1871 // the pellet target target.
1872 // It returns -1 if there are 0 or 1 intersections, or it returns 0
1873 // if they are at least 2.
1874 
1875 
1876 //------------------
1877 
1878  Short_t nIntersectionsCircle,
1879  nIntersections;
1880  Double_t FiStart,
1881  XintersectionList[12],
1882  YintersectionList[12]; // all the possible intersections (up to 10 intersections).
1883 
1884 // finding all possible intersections with inner parallel straw region.
1885 
1886 
1887  Double_t Side_x[] = { GAP/2., GAP/2. , ApotemaMin, ApotemaMin, GAP/2., GAP/2. },
1888  Side_y[] = { sqrt(Rma*Rma-GAP*GAP/4.), (2.*ApotemaMin-GAP/2.)/sqrt(3.),
1889  ApotemaMin/sqrt(3.),
1890  -ApotemaMin/sqrt(3.),
1891  -(2.*ApotemaMin-GAP/2.)/sqrt(3.), -sqrt(Rma*Rma-GAP*GAP/4.)},
1892  a[] = {1., 1./sqrt(3.), 1., -1./sqrt(3.), 1.},
1893  b[] = {0., 1., 0., 1., 0.},
1894  c[] = {-GAP/2.,-2.*ApotemaMin/sqrt(3.),-ApotemaMin, 2.*ApotemaMin/sqrt(3.), -GAP/2.};
1895 
1896  nIntersections=IntersectionsWithOpenPolygon(
1897  Oxx,
1898  Oyy,
1899  Rr,
1900  5, // n. Sides of open Polygon.
1901  a, // coefficient of formula : aX + bY + c = 0 defining the Polygon sides.
1902  b,
1903  c,
1904  Side_x, // X,Y coordinate of the Sides vertices (in sequence, following
1905  Side_y, // the Polygon along.
1906  XintersectionList, // XintersectionList
1907  YintersectionList // YintersectionList.
1908  );
1909 
1910 
1911 
1912 //-------------------------------------------------------------------------
1913 // finding intersections of trajectory [assumed to originate from (0,0) ]
1914 // with outer semicircle, the Left part.
1915 
1916  nIntersectionsCircle=IntersectionsWithGapSemicircle(
1917  Oxx, // input from trajectory
1918  Oyy, // input from trajectory
1919  Rr, // input from trajectory
1920  GAP, // input, vertical gap in XY plane of STT detector.
1921  false, // true --> Left semicircle, false --> Right semicircle.
1922  Rma, // radius of external Stt containment.
1923  &XintersectionList[nIntersections], // output, X list of intersections (maximal 2).
1924  &YintersectionList[nIntersections]
1925  );
1926 
1927 
1928  nIntersections += nIntersectionsCircle;
1929 
1930 //-------- the starting point of the track.
1931 
1932  if(nIntersections<2) return -1;
1933 
1934  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
1935  if(FiStart<0.) FiStart+= TWO_PI;
1936  if(FiStart<0.) FiStart =0.;
1937 
1938  // this method selects the entrance and exit points of the trajectory among all
1939  // geometrical intersections of the circular trajectory with the straw particular
1940  // volume.
1941 
1942  ChooseEntranceExitbis(
1943  Oxx,
1944  Oyy,
1945  Charge,
1946  FiStart,
1947  nIntersections,
1948  XintersectionList,
1949  YintersectionList,
1950  Xcross, // output
1951  Ycross // output
1952  );
1953 
1954 
1955  return 0;
1956 
1957 }
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
Start
timer Start()
PndTrkCTGeometryCalculations::ChooseEntranceExitbis
void ChooseEntranceExitbis(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t Xcross[2], Double_t Ycross[2])
Definition: PndTrkCTGeometryCalculations.cxx:381
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndTrkCTGeometryCalculations::IntersectionsWithOpenPolygon
Short_t IntersectionsWithOpenPolygon(Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t nSides, Double_t *a, Double_t *b, Double_t *c, Double_t *side_x, Double_t *side_y, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2846
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
PndTrkCTGeometryCalculations::IntersectionsWithGapSemicircle
Short_t IntersectionsWithGapSemicircle(Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t gap, bool left, Double_t Rma, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2749
Short_t PndTrkCTGeometryCalculations::FindTrackEntranceExitHexagonCircleRight2 ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  Charge,
Double_t  Start[3],
Double_t  ApotemaMin,
Double_t  ApotemaMax,
Double_t  GAP,
Double_t  XintersectionList[12],
Double_t  YintersectionList[12],
Double_t  FiOrderedList[12] 
)

Definition at line 1967 of file PndTrkCTGeometryCalculations.cxx.

References a, atan2(), b, c, Double_t, sqrt(), and TWO_PI.

1980 {
1981 
1982 // THIS METHOD IS ALMOST THE SAME AS FindTrackEntranceExitHexagonCircleLeft BUT IT PROVIDES ALL THE
1983 // INTERSECTIONS ORDERED FROM CENTER TO PERIFERY;
1984 // This methods finds the intersections between a trajectory coming from (0,0) and
1985 // parameters Oxx, Oyy, Rr with the closed geometrical figure (in XY) formed by the STT
1986 // external Left semicircle and the Outer STT parallel Left straw semi-Hexagon + Gap for
1987 // the pellet target target.
1988 // It returns the number of intersections (0 if there are no intersections);
1989 
1990 // At the most the number of such intersection is 12, that's why XintersectionList[12];
1991 // also the intersections are ordered from center to perifery according to the charge of the
1992 // track that dictates the sense of rotation;
1993 
1994  Short_t nIntersections;
1995 
1996  //Double_t cosFi, //[R.K. 01/2017] unused variable?
1997  //theta1, //[R.K. 01/2017] unused variable?
1998  //theta2, //[R.K. 01/2017] unused variable?
1999  //Theta1, //[R.K. 01/2017] unused variable?
2000  //Theta2, //[R.K. 01/2017] unused variable?
2001  //aaa, //[R.K. 01/2017] unused variable?
2002  //Fi, //[R.K. 01/2017] unused variable?
2003  //FI0, //[R.K. 01/2017] unused variable?
2004  //x1, //[R.K. 01/2017] unused variable?
2005  //x2, //[R.K. 01/2017] unused variable?
2006  //y1, //[R.K. 01/2017] unused variable?
2007  //y2; //[R.K. 01/2017] unused variable?
2008 //------------------
2009 
2010  Short_t nIntersectionsCircle;
2011  Double_t FiStart;
2012 
2013 // finding all possible intersections with inner parallel straw region.
2014 
2015 
2016  Double_t Side_x[] = { GAP/2., GAP/2. , ApotemaMin, ApotemaMin, GAP/2., GAP/2. },
2017  Side_y[] = { sqrt(Rma*Rma-GAP*GAP/4.), (2.*ApotemaMin-GAP/2.)/sqrt(3.),
2018  ApotemaMin/sqrt(3.),
2019  -ApotemaMin/sqrt(3.),
2020  -(2.*ApotemaMin-GAP/2.)/sqrt(3.), -sqrt(Rma*Rma-GAP*GAP/4.)},
2021  a[] = {1., 1./sqrt(3.), 1., -1./sqrt(3.), 1.},
2022  b[] = {0., 1., 0., 1., 0.},
2023  c[] = {-GAP/2.,-2.*ApotemaMin/sqrt(3.),-ApotemaMin, 2.*ApotemaMin/sqrt(3.), -GAP/2.};
2024 
2025  nIntersections=IntersectionsWithOpenPolygon(
2026  Oxx,
2027  Oyy,
2028  Rr,
2029  5, // n. Sides of open Polygon.
2030  a, // coefficient of formula : aX + bY + c = 0 defining the Polygon sides.
2031  b,
2032  c,
2033  Side_x, // X,Y coordinate of the Sides vertices (in sequence, following
2034  Side_y, // the Polygon along.
2035  XintersectionList, // XintersectionList
2036  YintersectionList // YintersectionList.
2037  );
2038 
2039 
2040 //-------------------------------------------------------------------------
2041 // finding intersections of trajectory [assumed to originate from (0,0) ]
2042 // with outer semicircle, the Left part.
2043 
2044  nIntersectionsCircle=IntersectionsWithGapSemicircle(
2045  Oxx, // input from trajectory
2046  Oyy, // input from trajectory
2047  Rr, // input from trajectory
2048  GAP, // input, vertical gap in XY plane of STT detector.
2049  false, // true --> Left semicircle, false --> Right semicircle.
2050  Rma, // radius of external Stt containment.
2051  &XintersectionList[nIntersections], // output, X list of intersections (maximal 2).
2052  &YintersectionList[nIntersections]
2053  );
2054 
2055  nIntersections += nIntersectionsCircle;
2056 
2057 //-------- the starting point of the track.
2058 
2059  if(nIntersections == 0) return 0;
2060 
2061  FiStart = atan2( Start[1]-Oyy,Start[0]-Oxx);
2062  if(FiStart<0.) FiStart+= TWO_PI;
2063  if(FiStart<0.) FiStart =0.;
2064 
2065  // this method selects the entrance and exit points of the trajectory among all
2066  // geometrical intersections of the circular trajectory with the straw particular
2067  // volume; IT RETURNS all the intersections ordered from center to perifery according to the sense of
2068  // rotation dictated by the charge of the track;
2069  // the methods requires at least 2 intersection;
2070 
2071  ChooseEntranceExit3(
2072  Oxx,
2073  Oyy,
2074  Charge,
2075  FiStart,
2076  nIntersections,
2077  XintersectionList, // input and output;
2078  YintersectionList, // input and output;
2079  FiOrderedList // output;
2080  );
2081 
2082 
2083  return nIntersections;
2084 
2085 }
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
PndTrkCTGeometryCalculations::ChooseEntranceExit3
void ChooseEntranceExit3(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t *FiOrderedList)
Definition: PndTrkCTGeometryCalculations.cxx:452
Start
timer Start()
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndTrkCTGeometryCalculations::IntersectionsWithOpenPolygon
Short_t IntersectionsWithOpenPolygon(Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t nSides, Double_t *a, Double_t *b, Double_t *c, Double_t *side_x, Double_t *side_y, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2846
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
PndTrkCTGeometryCalculations::IntersectionsWithGapSemicircle
Short_t IntersectionsWithGapSemicircle(Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t gap, bool left, Double_t Rma, Double_t *XintersectionList, Double_t *YintersectionList)
Definition: PndTrkCTGeometryCalculations.cxx:2749
bool PndTrkCTGeometryCalculations::IntersectionCircle_Segment ( Double_t  a,
Double_t  b,
Double_t  c,
Double_t  P1x,
Double_t  P2x,
Double_t  P1y,
Double_t  P2y,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t *  Nintersections,
Double_t  XintersectionList[2],
Double_t  YintersectionList[2],
Double_t *  distance 
)

Definition at line 2092 of file PndTrkCTGeometryCalculations.cxx.

References a, b, c, Double_t, sqrt(), status, x, and y.

2108 {
2109 // this method finds the intersection of a circle with a segment. If the circle
2110 // passes through an endpoint of the segment, that is considered an intersection also.
2111 
2112  bool status;
2113 
2114  Short_t ipossibility;
2115 
2116  Double_t aperp,
2117  bperp,
2118  cperp,
2119  det,
2120  distq,
2121  //dist1, //[R.K. 01/2017] unused variable?
2122  //dist2, //[R.K. 01/2017] unused variable?
2123  length,
2124  length_segmentq,
2125  Rq,
2126  x,
2127  y,
2128  Xintersection,
2129  Yintersection;
2130 
2131  *Nintersections=0;
2132  det = a*a+b*b ;
2133  if(det < 1.e-20){
2134  cout<<"from PndTrkCTGeometryCalculations::IntersectionCircle_Segment :"
2135  <<" this is not the equation of a segment; a = "<<a<<", b = "
2136  <<b<<", return false!\n";
2137  return false;
2138  }
2139  // find if intersection circle - segment is possible.
2140  // check if there is an intersection (with the squares, it's the same!).
2141  distq = ( a*Oxx+ b*Oyy + c )*( a*Oxx+ b*Oyy + c )/det;
2142  *distance = sqrt(distq);
2143  Rq=Rr*Rr;
2144  length = Rq - distq;
2145  if(length <= 0. ) return false; // no intersection between trajectory and this
2146  // segment.
2147  length = sqrt(length);
2148  // coefficients of line perpendicular to input segment and passing for (Oxx, Oyy).
2149  aperp = -b;
2150  bperp = a;
2151  cperp = - aperp*Oxx - bperp*Oyy;
2152 
2153  // find intersection of segment with perpendicular : no need to check if
2154  // det is different from 0.
2155  Xintersection = (-bperp*c + b*cperp)/det;
2156  Yintersection = (-a*cperp + aperp*c)/det;
2157  det = sqrt(det);
2158  length_segmentq = (P1x-P2x)*(P1x-P2x) + (P1y-P2y)*(P1y-P2y);
2159  status = false;
2160  for(ipossibility=-1;ipossibility<2;ipossibility +=2){
2161  x = Xintersection + ipossibility*length*b/det ;
2162  y = Yintersection - ipossibility*length*a/det ;
2163  if ( (x-P1x)*(x-P1x)+(y-P1y)*(y-P1y) > length_segmentq // factor to take
2164  // (grossly) errors in trajectory into account;
2165  ||
2166  (x-P2x)*(x-P2x)+(y-P2y)*(y-P2y) > length_segmentq
2167  ) continue;
2168  status = true;
2169  XintersectionList[*Nintersections] = x;
2170  YintersectionList[*Nintersections] = y;
2171  (*Nintersections)++;
2172  } // end of for(ipossibility=-1; ...
2173 
2174  return status;
2175 }
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
x
Double_t x
Definition: createRootFscGeometryFile.C:159
y
Double_t y
Definition: createRootFscGeometryFile.C:159
status
int status[10]
Definition: f_Init.h:28
bool PndTrkCTGeometryCalculations::IntersectionCircle_Segment_forScitil ( Double_t  a,
Double_t  b,
Double_t  c,
Double_t  P1x,
Double_t  P2x,
Double_t  P1y,
Double_t  P2y,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  factor,
Short_t *  Nintersections,
Double_t  XintersectionList[2],
Double_t  YintersectionList[2],
Double_t *  distance 
)

Definition at line 2183 of file PndTrkCTGeometryCalculations.cxx.

References a, b, c, Double_t, sqrt(), status, x, and y.

2200 {
2201 // this method finds the intersection of a circle with a segment. If the circle
2202 // passes through an endpoint of the segment, that is considered an intersection also.
2203 
2204  bool status;
2205 
2206  Short_t ipossibility;
2207 
2208  Double_t aperp,
2209  bperp,
2210  cperp,
2211  det,
2212  distq,
2213  //dist1, //[R.K. 01/2017] unused variable?
2214  //dist2, //[R.K. 01/2017] unused variable?
2215  length,
2216  length_segmentq,
2217  Rq,
2218  x,
2219  y,
2220  Xintersection,
2221  Yintersection;
2222 
2223  *Nintersections=0;
2224  det = a*a+b*b ;
2225  if(det < 1.e-20){
2226  cout<<"from PndTrkCTGeometryCalculations::IntersectionCircle_Segment :"
2227  <<" this is not the equation of a segment; a = "<<a<<", b = "
2228  <<b<<", return false!\n";
2229  return false;
2230  }
2231  // find if intersection circle - segment is possible.
2232  // check if there is an intersection (with the squares, it's the same!).
2233  distq = ( a*Oxx+ b*Oyy + c )*( a*Oxx+ b*Oyy + c )/det;
2234  *distance = sqrt(distq);
2235  Rq=Rr*Rr;
2236  length = Rq - distq;
2237  if(length <= 0. ) return false; // no intersection between trajectory and this
2238  // segment.
2239  length = sqrt(length);
2240  // coefficients of line perpendicular to input segment and passing for (Oxx, Oyy).
2241  aperp = -b;
2242  bperp = a;
2243  cperp = - aperp*Oxx - bperp*Oyy;
2244 
2245  // find intersection of segment with perpendicular : no need to check if
2246  // det is different from 0.
2247  Xintersection = (-bperp*c + b*cperp)/det;
2248  Yintersection = (-a*cperp + aperp*c)/det;
2249  det = sqrt(det);
2250  length_segmentq = (P1x-P2x)*(P1x-P2x) + (P1y-P2y)*(P1y-P2y);
2251  status = false;
2252  for(ipossibility=-1;ipossibility<2;ipossibility +=2){
2253  x = Xintersection + ipossibility*length*b/det ;
2254  y = Yintersection - ipossibility*length*a/det ;
2255  if ( (x-P1x)*(x-P1x)+(y-P1y)*(y-P1y) > factor*length_segmentq // factor to take
2256  // (grossly) errors in trajectory into account;
2257  ||
2258  (x-P2x)*(x-P2x)+(y-P2y)*(y-P2y) > factor*length_segmentq
2259  ) continue;
2260  status = true;
2261  XintersectionList[*Nintersections] = x;
2262  YintersectionList[*Nintersections] = y;
2263  (*Nintersections)++;
2264  } // end of for(ipossibility=-1; ...
2265 
2266  return status;
2267 }
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
x
Double_t x
Definition: createRootFscGeometryFile.C:159
y
Double_t y
Definition: createRootFscGeometryFile.C:159
status
int status[10]
Definition: f_Init.h:28
bool PndTrkCTGeometryCalculations::IntersectionSciTil_Circle ( Double_t  posizSciTilx,
Double_t  posizSciTily,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t *  Nintersections,
Double_t  XintersectionList[2],
Double_t  YintersectionList[2] 
)

Definition at line 2272 of file PndTrkCTGeometryCalculations.cxx.

References DIMENSIONSCITIL, Double_t, and sqrt().

Referenced by PndTrkCTFindTrackInXY::AssociateSciTilHit(), PndTrkCTFindTrackInXY2::AssociateSciTilHit(), PndTrkPlotMacros::WriteAllMacros(), and PndTrkPlotMacros2::WriteAllMacros().

2283 {
2284 
2285  bool intersect;
2286 
2287  Double_t
2288  distance,
2289  QQ,
2290  sqrtRR,
2291  SIGN;
2292 
2293 
2294  QQ = posizSciTilx*posizSciTilx+posizSciTily*posizSciTily;
2295  sqrtRR=sqrt(QQ);
2296 
2297  if( posizSciTily<0.) SIGN=-1.;
2298  else SIGN=1.;
2299 
2300 
2301  intersect = IntersectionCircle_Segment_forScitil(
2302  posizSciTilx,
2303  posizSciTily,
2304  -QQ,
2305  posizSciTilx-SIGN*0.5*DIMENSIONSCITIL*posizSciTily/sqrtRR,
2306  posizSciTilx+SIGN*0.5*DIMENSIONSCITIL*posizSciTily/sqrtRR,
2307  posizSciTily+SIGN*posizSciTilx*0.5*DIMENSIONSCITIL/sqrtRR,
2308  posizSciTily-SIGN*posizSciTilx*0.5*DIMENSIONSCITIL/sqrtRR,
2309  Oxx,
2310  Oyy,
2311  Rr,
2312  2.25, // factor to take into account errors in the determination of the trajectory circle;
2313  Nintersections, // output
2314  XintersectionList, // output
2315  YintersectionList, // output
2316  &distance // output
2317  );
2318 
2319  return intersect;
2320 }
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
PndTrkCTGeometryCalculations::IntersectionCircle_Segment_forScitil
bool IntersectionCircle_Segment_forScitil(Double_t a, Double_t b, Double_t c, Double_t P1x, Double_t P2x, Double_t P1y, Double_t P2y, Double_t Oxx, Double_t Oyy, Double_t Rr, Double_t factor, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2], Double_t *distance)
Definition: PndTrkCTGeometryCalculations.cxx:2183
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
DIMENSIONSCITIL
const Double_t DIMENSIONSCITIL
Definition: PndTrkConstants.h:208
Short_t PndTrkCTGeometryCalculations::IntersectionsWithClosedbiHexagonLeft ( Double_t  vgap,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  Ami,
Double_t  Ama,
Short_t *  nIntersections,
Double_t *  XintersectionList,
Double_t *  YintersectionList 
)

Definition at line 2328 of file PndTrkCTGeometryCalculations.cxx.

References a, b, c, Double_t, is, and sqrt().

2341 {
2342 
2343 
2344  // return integer convention :
2345  // -1 --> track outside outer perimeter;
2346  // 0 --> at least 1 intersection with polygon;
2347  // 1 --> track contained completely between the two polygons;
2348 
2349 
2350  // inner Hexagon --> 0
2351  // outer Hexagon --> 1
2352 
2353  bool internal,
2354  AtLeast1;
2355 
2356  Short_t is,
2357  j,
2358  Nintersections;
2359 
2360  Double_t aaa,
2361  maxdistq,
2362  distance,
2363  //-------------------
2364  // a,b,c == coefficients of the implicit equations of the 3 sides of the half inner Hexagon
2365  // plus 3 sides of the half outer Hexagon plus 2 vertical sides corresponding to the Gap :
2366  // a*x + b*y +c =0; the numbering of these 8 sides follows the convention of Gianluigi's
2367  // logbook on page 286.
2368 a[] = {-1./sqrt(3.) , 1., 1./sqrt(3.), 1., 1./sqrt(3.), 1., -1./sqrt(3.), 1.},
2369 b[] = {1., 0., 1., 0., 1., 0., 1., 0.},
2370 c[] = {-2.*Ama/sqrt(3.),Ama, 2.*Ama/sqrt(3.),vgap/2.,2.*Ami/sqrt(3.),Ami, -2.*Ami/sqrt(3.),vgap/2.},
2371  //----------------------
2372 
2373  tempX[2],
2374  tempY[2];
2375 
2376  // side_x and side_y are ordered as side1, side2, ..... in Gianluigi's logbook on page 286.
2377  Double_t
2378  side_x[] = { -vgap/2., -Ama , -Ama, -vgap/2., -vgap/2., -Ami,
2379  -Ami, -vgap/2., -vgap/2.},
2380  side_y[] = {(-0.5*vgap+2.*Ama)/sqrt(3.), Ama/sqrt(3.), -Ama/sqrt(3.),
2381  -(-0.5*vgap+2.*Ama)/sqrt(3.), -(-0.5*vgap+2.*Ami)/sqrt(3.),
2382  -Ami/sqrt(3.), Ami/sqrt(3.), (-0.5*vgap+2.*Ami)/sqrt(3.),
2383  (-0.5*vgap+2.*Ama)/sqrt(3.) };
2384 
2385 
2386 
2387 //-----------------------
2388 
2389 // find intersections (maximum 16) with the 8 sides.
2390 
2391 
2392 
2393  AtLeast1 = false;
2394  *nIntersections =0;
2395  internal = true;
2396  maxdistq=-9999.;
2397  for(is=0; is<8; is++){
2398  aaa = (side_x[is]-Oxx)*(side_x[is]-Oxx)+(side_y[is]-Oyy)*(side_y[is]-Oyy);
2399  if(aaa>maxdistq) maxdistq=aaa;
2400  aaa = (side_x[is+1]-Oxx)*(side_x[is+1]-Oxx)+(side_y[is+1]-Oyy)*(side_y[is+1]-Oyy);
2401  if(aaa>maxdistq) maxdistq=aaa;
2402  if ( IntersectionCircle_Segment(
2403  a[is],
2404  b[is],
2405  c[is],
2406  side_x[is],
2407  side_x[is+1],
2408  side_y[is],
2409  side_y[is+1],
2410  Oxx,
2411  Oyy,
2412  Rr,
2413  &Nintersections,
2414  tempX,
2415  tempY,
2416  &distance // distance of (Oxx,Oyy) from line
2417  // defined by a*x+b*y+c=0.
2418  )
2419  ){
2420  AtLeast1=true;
2421  for(j=0;j<Nintersections;j++){
2422  XintersectionList[ *nIntersections ] =tempX[j];
2423  YintersectionList[ *nIntersections ] =tempY[j];
2424  (*nIntersections)++;
2425  }
2426  } // end of if ( IntersectionCircle_Segment( .....
2427 
2428 
2429  // the definition of 'internal' here is when the given Point
2430  // stays at the same side of the origin (0,0) with respect to
2431  // the given line of equation a*x+b*y+c=0.
2432  if(is<3) {
2433  internal = internal && IsInternal(Oxx,
2434  Oyy,
2435  a[is],
2436  b[is],
2437  c[is]
2438  );
2439  } else {
2440  internal = internal && (!IsInternal(Oxx,
2441  Oyy,
2442  a[is],
2443  b[is],
2444  c[is]
2445  ) );
2446  }
2447 
2448  } // end of for(is=0; is<8; is++)
2449 
2450 
2451  if( !AtLeast1){
2452  if (!internal) return -1;// trajectory outside polygon.
2453  if( maxdistq < Rr*Rr ) return -1;// trajectory outside polygon.
2454  return 1; // trajectory completely contained inside this Polygon.
2455  }
2456  return 0;
2457 
2458 }
PndTrkCTGeometryCalculations::IsInternal
bool IsInternal(Double_t Px, Double_t Py, Double_t Xtraslation, Double_t Ytraslation, Double_t Theta)
Definition: PndTrkCTGeometryCalculations.cxx:3909
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
is
static int is
Definition: ranlxd.cxx:374
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
PndTrkCTGeometryCalculations::IntersectionCircle_Segment
bool IntersectionCircle_Segment(Double_t a, Double_t b, Double_t c, Double_t P1x, Double_t P2x, Double_t P1y, Double_t P2y, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2], Double_t *distance)
Definition: PndTrkCTGeometryCalculations.cxx:2092
Short_t PndTrkCTGeometryCalculations::IntersectionsWithClosedbiHexagonRight ( Double_t  vgap,
Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  Ami,
Double_t  Ama,
Short_t *  nIntersections,
Double_t *  XintersectionList,
Double_t *  YintersectionList 
)

Definition at line 2470 of file PndTrkCTGeometryCalculations.cxx.

References a, b, c, Double_t, is, and sqrt().

2483 {
2484 
2485 
2486  // return integer convention :
2487  // -1 --> track outside outer perimeter;
2488  // 0 --> at least 1 intersection with polygon;
2489  // 1 --> track contained completely between the two polygons;
2490 
2491 
2492  // inner Hexagon --> 0
2493  // outer Hexagon --> 1
2494 
2495  bool internal,
2496  AtLeast1;
2497 
2498  Short_t //i, //[R.K. 01/2017] unused variable?
2499  is,
2500  j,
2501  Nintersections;
2502 
2503  Double_t aaa,
2504  maxdistq,
2505  distance,
2506  //-------------------
2507  // a,b,c == coefficients of the implicit equations of the 3 sides of the half inner Hexagon
2508  // plus 3 sides of the half outer Hexagon plus 2 vertical sides corresponding to the Gap :
2509  // a*x + b*y +c =0; the numbering of these 8 sides foolows the convention of Gianluigi's
2510  // logbook on page 286.
2511 a[] = {1./sqrt(3.) , 1., -1./sqrt(3.), 1., -1./sqrt(3.), 1., 1./sqrt(3.), 1.},
2512 b[] = {1., 0., 1., 0., 1., 0., 1., 0.},
2513 c[] = {-2.*Ama/sqrt(3.),-Ama, 2.*Ama/sqrt(3.),-vgap/2.,2.*Ami/sqrt(3.),-Ami, -2.*Ami/sqrt(3.),-vgap/2.},
2514  //----------------------
2515 
2516  tempX[2],
2517  tempY[2];
2518 
2519  // side_x and side_y are ordered as side1, side2, ..... in Gianluigi's logbook on page 286.
2520  Double_t
2521  side_x[] = { vgap/2., Ama , Ama, vgap/2., vgap/2., Ami,
2522  Ami, vgap/2., vgap/2.},
2523  side_y[] = {(-0.5*vgap+2.*Ama)/sqrt(3.), Ama/sqrt(3.), -Ama/sqrt(3.),
2524  -(-0.5*vgap+2.*Ama)/sqrt(3.), -(-0.5*vgap+2.*Ami)/sqrt(3.),
2525  -Ami/sqrt(3.), Ami/sqrt(3.), (-0.5*vgap+2.*Ami)/sqrt(3.),
2526  (-0.5*vgap+2.*Ama)/sqrt(3.) };
2527 
2528 
2529 
2530 //-----------------------
2531 
2532 // find intersections (maximum 16) with the 8 sides.
2533 
2534  AtLeast1 = false;
2535  *nIntersections =0;
2536  internal = true;
2537  maxdistq=-9999.;
2538  for(is=0; is<8; is++){
2539  aaa = (side_x[is]-Oxx)*(side_x[is]-Oxx)+(side_y[is]-Oyy)*(side_y[is]-Oyy);
2540  if(aaa>maxdistq) maxdistq=aaa;
2541  aaa = (side_x[is+1]-Oxx)*(side_x[is+1]-Oxx)+(side_y[is+1]-Oyy)*(side_y[is+1]-Oyy);
2542  if(aaa>maxdistq) maxdistq=aaa;
2543  if ( IntersectionCircle_Segment(
2544  a[is],
2545  b[is],
2546  c[is],
2547  side_x[is],
2548  side_x[is+1],
2549  side_y[is],
2550  side_y[is+1],
2551  Oxx,
2552  Oyy,
2553  Rr,
2554  &Nintersections,
2555  tempX,
2556  tempY,
2557  &distance // distance of (Oxx,Oyy) from line
2558  // defined by a*x+b*y+c=0.
2559  )
2560  )
2561  {
2562  AtLeast1=true;
2563  for(j=0;j<Nintersections;j++){
2564  XintersectionList[ *nIntersections ] =tempX[j];
2565  YintersectionList[ *nIntersections ] =tempY[j];
2566  (*nIntersections)++;
2567  }
2568  } // end of if ( IntersectionCircle_Segment( .....
2569 
2570 
2571  // the definition of 'internal' here is when the given Point
2572  // stays at the same side of the origin (0,0) with respect to
2573  // the given line of equation a*x+b*y+c=0.
2574  if(is<3) {
2575  internal = internal && IsInternal(Oxx,
2576  Oyy,
2577  a[is],
2578  b[is],
2579  c[is]
2580  );
2581  } else {
2582  internal = internal && (!IsInternal(Oxx,
2583  Oyy,
2584  a[is],
2585  b[is],
2586  c[is]
2587  ) );
2588  }
2589 
2590  } // end of for(is=0; is<8; is++)
2591 
2592 
2593  if( !AtLeast1){
2594  if (!internal) return -1;// trajectory outside polygon.
2595  if( maxdistq < Rr*Rr ) return -1;// trajectory outside polygon.
2596  return 1; // trajectory completely contained inside this Polygon.
2597  }
2598  return 0;
2599 
2600 }
PndTrkCTGeometryCalculations::IsInternal
bool IsInternal(Double_t Px, Double_t Py, Double_t Xtraslation, Double_t Ytraslation, Double_t Theta)
Definition: PndTrkCTGeometryCalculations.cxx:3909
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
is
static int is
Definition: ranlxd.cxx:374
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
PndTrkCTGeometryCalculations::IntersectionCircle_Segment
bool IntersectionCircle_Segment(Double_t a, Double_t b, Double_t c, Double_t P1x, Double_t P2x, Double_t P1y, Double_t P2y, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2], Double_t *distance)
Definition: PndTrkCTGeometryCalculations.cxx:2092
Short_t PndTrkCTGeometryCalculations::IntersectionsWithClosedPolygon ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  Rmi,
Double_t  Rma,
Short_t  nIntersections[2],
Double_t  XintersectionList[][2],
Double_t  YintersectionList[][2] 
)

Definition at line 2608 of file PndTrkCTGeometryCalculations.cxx.

References a, b, c, Double_t, i, is, and sqrt().

2620 {
2621 
2622 
2623  // return integer convention :
2624  // -2 --> track outside outer polygon;
2625  // -1 --> track contained completely within inner polygon;
2626  // 0 --> at least 1 intersection with inner polygon, at least 1 with outer polygon;
2627  // 1 --> track contained completely between the two polygons;
2628  // 2 --> track contained completely by larger polygons, with intersections in the smaller;
2629  // 3 --> track completely outsiede the small polygon with intersections in the bigger.
2630 
2631 
2632  // inner Hexagon --> 0
2633  // outer Hexagon --> 1
2634 
2635  bool internal[2],
2636  AtLeast1[2];
2637 
2638  Short_t i,
2639  is,
2640  j,
2641  Nintersections;
2642 
2643  Double_t mindist[2],
2644  distance,
2645  //-------------------
2646  // a,b,c == coefficients of the implicit equations of the six sides of the Hexagon
2647  // centered at 0 : a*x + b*y +c =0; see Gianluigi's logbook on page 277;
2648  // the coefficient c has to be multiplied by Erre.
2649  // The first side is
2650  a[] = { 1./sqrt(3.) , 1., -1./sqrt(3.), 1./sqrt(3.) , 1. , -1./sqrt(3.) } ,
2651  b[] = { 1., 0. , 1., 1., 0. , 1. },
2652  c[] = { -2./sqrt(3.) , -1., 2./sqrt(3.), 2./sqrt(3.), 1., -2./sqrt(3.)},
2653  //----------------------
2654 
2655  Erre[] = {Rmi, Rma}, // this is the distance from (0,0)
2656  // of the SIDES of the Hexagon delimiting the Skew area
2657  tempX[2],
2658  tempY[2];
2659 
2660  // both hexagon_side_xlow and hexagon_side_xup must be multiplied by appropriate Erre;
2661  // sides of Hexagon ordered as a, b, c ..... in Gianluigi's logbook on page 280.
2662  Double_t
2663  hexagon_side_x[] = { 0., 1. , 1., 0., -1., -1., 0. },
2664  hexagon_side_y[] = { 2./sqrt(3.),1./sqrt(3.),-1./sqrt(3.),
2665  -2./sqrt(3.),-1./sqrt(3.), 1./sqrt(3.), 2./sqrt(3.)};
2666 
2667 
2668 
2669 //-----------------------
2670 
2671 // find intersection with the 6 sides of the small exhagon delimiting the skew straws zone
2672 // see on page 277 of Gianluigi's logbook.
2673 
2674  // status =0, at least 1 intersection with inner Hexagon, at least 1 intersection
2675  // with the outer Hexagon; =1, track contained completely between the
2676  // two Hexagons; = -1 track contained within inner Hexagon;
2677  // =-2 track outside outer Hexagon.
2678 
2679 
2680  for(i=0;i<2;i++){ // i=0 --> inner Hexagon, i= 1 --> outer Hexagon.
2681  AtLeast1[i] = false;
2682  nIntersections[i]=0;
2683  internal[i] = true;
2684  mindist[i]=999999.;
2685  for(is=0; is<6; is++){
2686  if ( IntersectionCircle_Segment(a[is],
2687  b[is],
2688  c[is]*Erre[i],
2689  hexagon_side_x[is]*Erre[i],
2690  hexagon_side_x[is+1]*Erre[i],
2691  hexagon_side_y[is]*Erre[i],
2692  hexagon_side_y[is+1]*Erre[i],
2693  Oxx,
2694  Oyy,
2695  Rr,
2696  &Nintersections,
2697  tempX,
2698  tempY,
2699  &distance // distance of (Oxx,Oyy) from line
2700  // defined by a*x+b*y+c=0.
2701  )
2702  )
2703  {
2704  AtLeast1[i]=true;
2705  for(j=0;j<Nintersections;j++){
2706  XintersectionList[ nIntersections[i] ][i] =tempX[j];
2707  YintersectionList[ nIntersections[i] ][i] =tempY[j];
2708  nIntersections[i]++;
2709  }
2710  } // end of if ( IntersectionCircle_Segment( .....
2711 
2712  if(mindist[i]>distance) mindist[i]=distance;
2713 
2714  // the definition of 'internal' here is when the given Point
2715  // stays at the same side of the origin (0,0) with respect to
2716  // the given line of equation a*x+b*y+c=0.
2717  internal[i] = internal[i] && IsInternal(Oxx,
2718  Oyy,
2719  a[is],
2720  b[is],
2721  c[is]*Erre[i]
2722  );
2723 
2724  } // end of for(is=0; is<6; is++)
2725  } // end of for(i=0;i<2;i++)
2726 
2727 
2728  if( (!AtLeast1[0]) && (!AtLeast1[1]) ){
2729  if (!internal[1]) return -2; // trajectory outside outer Hexagon.
2730  if( Rr > mindist[1]) return -2;
2731  if( !internal[0]) return 1; // trajectory contained between inner and outer Hexagon.
2732  if( mindist[0] >= Rr) return -1; // trajectory contained in inner Hexagon.
2733  return 1; // trajectory contained between inner and outer Hexagon.
2734  } else if (AtLeast1[0] && AtLeast1[1] ){ // continuation of if( (!AtLeast1[0]) && ...
2735  return 0;
2736  } else if (AtLeast1[0]){
2737  return 2;
2738  }
2739 
2740  return 3;
2741 }
PndTrkCTGeometryCalculations::IsInternal
bool IsInternal(Double_t Px, Double_t Py, Double_t Xtraslation, Double_t Ytraslation, Double_t Theta)
Definition: PndTrkCTGeometryCalculations.cxx:3909
i
Int_t i
Definition: run_full.C:25
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
is
static int is
Definition: ranlxd.cxx:374
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
PndTrkCTGeometryCalculations::IntersectionCircle_Segment
bool IntersectionCircle_Segment(Double_t a, Double_t b, Double_t c, Double_t P1x, Double_t P2x, Double_t P1y, Double_t P2y, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2], Double_t *distance)
Definition: PndTrkCTGeometryCalculations.cxx:2092
Short_t PndTrkCTGeometryCalculations::IntersectionsWithGapSemicircle ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  gap,
bool  left,
Double_t  Rma,
Double_t *  XintersectionList,
Double_t *  YintersectionList 
)

Definition at line 2749 of file PndTrkCTGeometryCalculations.cxx.

References acos(), atan2(), cos(), Double_t, sin(), and sqrt().

2759 {
2760 
2761  Short_t nIntersectionsCircle;
2762 
2763  Double_t cosFi,
2764  theta1,
2765  theta2,
2766  Theta1,
2767  Theta2,
2768  aaa,
2769  Fi,
2770  FI0,
2771  x1,
2772  x2,
2773  y1,
2774  y2;
2775 
2776 
2777 
2778  nIntersectionsCircle=0;
2779  aaa = sqrt(Oxx*Oxx+Oyy*Oyy);
2780 
2781  // preliminary condition for having intersections between trajectory and Circle.
2782 
2783  if( !( aaa >= Rr + Rma || Rr >= aaa + Rma) &&
2784  !( aaa + Rr <= Rma || aaa - Rr >= Rma ) ) {
2785 
2786 // now the calculation
2787 
2788  FI0 = atan2(-Oyy,-Oxx);
2789  cosFi = (aaa*aaa + Rr*Rr - Rma*Rma)/(2.*Rr*aaa);
2790  if(cosFi<-1.) cosFi=-1.; else if(cosFi>1.) cosFi=1.;
2791  Fi = acos(cosFi);
2792 
2793 
2794  // (x1, y1) and (x2,y2) are the intersections between the trajectory
2795  // and the circle, in the laboratory reference frame.
2796  x1 = Oxx+Rr*cos(FI0 - Fi);
2797  y1 = Oyy+Rr*sin(FI0 - Fi);
2798  theta1 = atan2(y1,x1); // in this way theta1 is between -PI and PI.
2799  x2 = Oxx+Rr*cos(FI0 + Fi);
2800  y2 = Oyy+Rr*sin(FI0 + Fi);
2801  theta2 = atan2(y2,x2); // in this way theta2 is between -PI and PI.
2802  // Theta1, Theta2 = angle of the edges of the outer circle + Gap in the laboratory frame.
2803  // Theta1, Theta2 are angles between -PI/2 and +PI/2.
2804  if(!left){ // Right (looking into the beam) Semicircle.
2805  Theta2 = atan2( sqrt(Rma*Rma-GAP*GAP/4.),GAP/2.);
2806  Theta1 = atan2( -sqrt(Rma*Rma-GAP*GAP/4.),GAP/2.);
2807  if( Theta1<= theta1 && theta1 <= Theta2 ){
2808  XintersectionList[nIntersectionsCircle]=x1;
2809  YintersectionList[nIntersectionsCircle]=y1;
2810  nIntersectionsCircle++;
2811  }
2812  if( Theta1<= theta2 && theta2 <= Theta2 ){
2813  XintersectionList[nIntersectionsCircle]=x2;
2814  YintersectionList[nIntersectionsCircle]=y2;
2815  nIntersectionsCircle++;
2816  }
2817  } else { // Left (looking into the beam) Semicircle.
2818  Theta2 = atan2( -sqrt(Rma*Rma-GAP*GAP/4.),-GAP/2.);
2819  Theta1 = atan2( sqrt(Rma*Rma-GAP*GAP/4.),-GAP/2.);
2820  if( Theta1<= theta1 || theta1 <= Theta2 ){
2821  XintersectionList[nIntersectionsCircle]=x1;
2822  YintersectionList[nIntersectionsCircle]=y1;
2823  nIntersectionsCircle++;
2824  }
2825  if( Theta1<= theta2 || theta2 <= Theta2 ){
2826  XintersectionList[nIntersectionsCircle]=x2;
2827  YintersectionList[nIntersectionsCircle]=y2;
2828  nIntersectionsCircle++;
2829  }
2830  }
2831 
2832  } // end of if (!( a >= Rr + Rma || .....
2833 
2834 //---------------------------- end of calculation intersection with outer circle.
2835 
2836  return nIntersectionsCircle;
2837 
2838 
2839 }
acos
friend F32vec4 acos(const F32vec4 &a)
Definition: P4_F32vec4.h:113
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: P4_F32vec4.h:112
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: P4_F32vec4.h:111
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
Short_t PndTrkCTGeometryCalculations::IntersectionsWithOpenPolygon ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Short_t  nSides,
Double_t *  a,
Double_t *  b,
Double_t *  c,
Double_t *  side_x,
Double_t *  side_y,
Double_t *  XintersectionList,
Double_t *  YintersectionList 
)

Definition at line 2846 of file PndTrkCTGeometryCalculations.cxx.

References Double_t, and is.

2861 {
2862 
2863  // this methods returns the n. of intersections.
2864 
2865  Short_t //i, //[R.K. 01/2017] unused variable?
2866  is,
2867  j,
2868  nIntersections,
2869  Nintersections;
2870 
2871  Double_t //mindist, //[R.K. 01/2017] unused variable?
2872  distance,
2873  //-------------------
2874  // a,b,c == coefficients of the implicit equations of the six sides of the Hexagon
2875  // centered at 0 : a*x + b*y +c =0; see Gianluigi's logbook on page 277;
2876  // the coefficient c has to be multiplied by Erre.
2877 
2878  tempX[2],
2879  tempY[2];
2880 
2881 
2882 
2883 
2884 //-----------------------
2885 
2886  nIntersections=0;
2887  for(is=0; is<nSides; is++){
2888  if ( IntersectionCircle_Segment(a[is],
2889  b[is],
2890  c[is],
2891  Side_x[is],
2892  Side_x[is+1],
2893  Side_y[is],
2894  Side_y[is+1],
2895  Oxx,
2896  Oyy,
2897  Rr,
2898  &Nintersections,
2899  tempX,
2900  tempY,
2901  &distance // distance of (Oxx,Oyy) from line
2902  // defined by a*x+b*y+c=0.
2903  )
2904  ){
2905 
2906 
2907  for(j=0;j<Nintersections;j++){
2908  XintersectionList[ nIntersections ] =tempX[j];
2909  YintersectionList[ nIntersections ] =tempY[j];
2910  nIntersections ++;
2911  }
2912  } // end of if ( IntersectionCircle_Segment( .....
2913 
2914 
2915  } // end of for(is=0; is<nSides; is++)
2916 // } // end of for(i=0;i<2;i++)
2917 
2918 
2919 
2920  return nIntersections;
2921 }
b
TTree * b
Definition: GammaSpectraAnalysis.C:24
a
Int_t a
Definition: anaLmdDigi.C:126
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
is
static int is
Definition: ranlxd.cxx:374
c
GeV c
Definition: ReadMesDecCorrRes_PiT.C:28
PndTrkCTGeometryCalculations::IntersectionCircle_Segment
bool IntersectionCircle_Segment(Double_t a, Double_t b, Double_t c, Double_t P1x, Double_t P2x, Double_t P1y, Double_t P2y, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t *Nintersections, Double_t XintersectionList[2], Double_t YintersectionList[2], Double_t *distance)
Definition: PndTrkCTGeometryCalculations.cxx:2092
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk10_41to10_43 ( Double_t  X,
Double_t  Y 
)

Definition at line 3443 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3447 {
3448 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3449 // they are placed between 10.41 and 10.43 in Z;
3450 // look at Gianluigi's logbook on page 197 for the geometry detail;
3451 
3452 // this geometry is the same as the Z=6.97_6.99 geometry;
3453 
3454  if(
3455  (X > -6.96 && X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3456  ||
3457  (X > -4.64 && X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3458  ||
3459  (X > -2.33 && X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3460  ||
3461  (X > 0. && X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3462  ||
3463  (X > 2.3 && X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3464  ||
3465  (X > 4.64 && X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3466  ) return true;
3467 
3468 
3469  return false;
3470 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk10_41to10_43withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3478 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3484 {
3485 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3486 // they are placed between 10.41 and 10.43 in Z;
3487 // look at Gianluigi's logbook on page 197 for the geometry detail;
3488 
3489 // this geometry is the same as the Z=6.97_6.99 geometry;
3490 
3491  if(
3492  (X > -6.96 + xmargin && X < -5.8 - xmargin && fabs(Y) < 2.31 - ymargin && fabs(Y) > 0.07 + ymargin)
3493  ||
3494  (X > -4.64 + xmargin && X < -3.48 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3495  ||
3496  (X > -2.33 + xmargin && X < -1.17 - xmargin && fabs(Y) < 6.87 - ymargin && fabs(Y) > 0.07 + ymargin)
3497  ||
3498  (X > 0. + xmargin && X < 1.16 - xmargin && fabs(Y) < 6.85 - ymargin && fabs(Y) > 1.19 + ymargin)
3499  ||
3500  (X > 2.3 + xmargin && X < 3.46 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3501  ||
3502  (X > 4.64 + xmargin && X < 5.8 - xmargin && fabs(Y) < 4.59 - ymargin && fabs(Y) > 0.07 + ymargin)
3503  ) return true;
3504 
3505 
3506  return false;
3507 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk14_77to14_79 ( Double_t  X,
Double_t  Y 
)

Definition at line 3518 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3522 {
3523 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3524 // they are placed between 14.77 and 14.79 in Z;
3525 // look at Gianluigi's logbook on page 198 for the geometry detail;
3526 
3527 // this geometry is the same as the Z=6.97_6.99 geometry;
3528 
3529  if(
3530  (X > -6.96 && X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3531  ||
3532  (X > -4.64 && X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3533  ||
3534  (X > -2.33 && X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3535  ||
3536  (X > 0. && X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3537  ||
3538  (X > 2.3 && X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3539  ||
3540  (X > 4.64 && X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3541  ) return true;
3542 
3543 
3544 
3545  return false;
3546 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk14_77to14_79withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3554 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3560 {
3561 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3562 // they are placed between 14.77 and 14.79 in Z;
3563 // look at Gianluigi's logbook on page 198 for the geometry detail;
3564 
3565 // this geometry is the same as the Z=6.97_6.99 geometry;
3566 
3567  if(
3568  (X > -6.96 + xmargin && X < -5.8 - xmargin && fabs(Y) < 2.31 - ymargin && fabs(Y) > 0.07 + ymargin)
3569  ||
3570  (X > -4.64 + xmargin && X < -3.48 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3571  ||
3572  (X > -2.33 + xmargin && X < -1.17 - xmargin && fabs(Y) < 6.87 - ymargin && fabs(Y) > 0.07 + ymargin)
3573  ||
3574  (X > 0. + xmargin && X < 1.16 - xmargin && fabs(Y) < 6.85 - ymargin && fabs(Y) > 1.19 + ymargin)
3575  ||
3576  (X > 2.3 + xmargin && X < 3.46 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3577  ||
3578  (X > 4.64 + xmargin && X < 5.8 - xmargin && fabs(Y) < 4.59 - ymargin && fabs(Y) > 0.07 + ymargin)
3579  ) return true;
3580 
3581 
3582 
3583  return false;
3584 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk15_21to15_23 ( Double_t  X,
Double_t  Y 
)

Definition at line 3595 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3599 {
3600 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3601 // they are placed between 15.21 and 15.23 in Z;
3602 // look at Gianluigi's logbook on page 198 for the geometry detail;
3603 
3604 // this geometry is the same as the Z=7.41_7.43 geometry;
3605 
3606  if(
3607  (-X > -6.96 && -X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3608  ||
3609  (-X > -4.64 && -X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3610  ||
3611  (-X > -2.33 && -X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3612  ||
3613  (-X > 0. && -X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3614  ||
3615  (-X > 2.3 && -X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3616  ||
3617  (-X > 4.64 && -X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3618  ) return true;
3619 
3620 
3621 
3622  return false;
3623 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk15_21to15_23withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3631 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3637 {
3638 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3639 // they are placed between 15.21 and 15.23 in Z;
3640 // look at Gianluigi's logbook on page 198 for the geometry detail;
3641 
3642 // this geometry is the same as the Z=7.41_7.43 geometry;
3643 
3644  if(
3645  (-X > -6.96 + xmargin && -X < -5.8 - xmargin && fabs(Y) < 2.31 - ymargin && fabs(Y) > 0.07 + ymargin)
3646  ||
3647  (-X > -4.64 + xmargin && -X < -3.48 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3648  ||
3649  (-X > -2.33 + xmargin && -X < -1.17 - xmargin && fabs(Y) < 6.87 - ymargin && fabs(Y) > 0.07 + ymargin)
3650  ||
3651  (-X > 0. + xmargin && -X < 1.16 - xmargin && fabs(Y) < 6.85 - ymargin && fabs(Y) > 1.19 + ymargin)
3652  ||
3653  (-X > 2.3 + xmargin && -X < 3.46 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3654  ||
3655  (-X > 4.64 + xmargin && -X < 5.8 - xmargin && fabs(Y) < 4.59 - ymargin && fabs(Y) > 0.07 + ymargin)
3656  ) return true;
3657 
3658 
3659 
3660  return false;
3661 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk1_97to1_99 ( Double_t  X,
Double_t  Y 
)

Definition at line 2990 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

2994 {
2995 // this is a set of sensors placed vertically perpendicularly to the Z direction;
2996 // they are placed between 1.97 and 1.99 in Z;
2997 // look at Gianluigi's logbook on page 193 for the geometry detail;
2998 
2999  if(
3000  (X > -2.33 && X < -1.17 && Y > -2.26 && Y < 2.26 )
3001  ||
3002  (X > 0. && X < 1.21 && fabs(Y) < 3.43 && fabs(Y) > 1.19)
3003  ||
3004  (X > 2.32 && X < 3.48 && fabs(Y) < 1.12)
3005  ) return true;
3006 
3007  return false;
3008 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk1_97to1_99withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3016 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3022 {
3023 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3024 // they are placed between 1.97 and 1.99 in Z;
3025 // look at Gianluigi's logbook on page 193 for the geometry detail;
3026 
3027  if(
3028  (X > -2.33 + xmargin && X < -1.17 - xmargin && Y > -2.26 + ymargin && Y < 2.26 - ymargin )
3029  ||
3030  (X > 0. + xmargin && X < 1.21 - xmargin && fabs(Y) < 3.43 && fabs(Y) > 1.19)
3031  ||
3032  (X > 2.32 + xmargin && X < 3.48 - xmargin && fabs(Y) < 1.12 - ymargin)
3033  ) return true;
3034 
3035  return false;
3036 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk21_77to21_79 ( Double_t  X,
Double_t  Y 
)

Definition at line 3672 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3676 {
3677 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3678 // they are placed between 21.77 and 21.79 in Z;
3679 // look at Gianluigi's logbook on page 198 for the geometry detail;
3680 
3681 // this geometry is the same as the Z=7.41_7.43 geometry;
3682 
3683 
3684  if(
3685  (-X > -6.96 && -X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3686  ||
3687  (-X > -4.64 && -X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3688  ||
3689  (-X > -2.33 && -X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3690  ||
3691  (-X > 0. && -X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3692  ||
3693  (-X > 2.3 && -X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3694  ||
3695  (-X > 4.64 && -X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3696  ) return true;
3697 
3698 
3699 
3700 
3701  return false;
3702 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk21_77to21_79withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3710 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3716 {
3717 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3718 // they are placed between 21.77 and 21.79 in Z;
3719 // look at Gianluigi's logbook on page 198 for the geometry detail;
3720 
3721 
3722 // this geometry is the same as the Z=7.41_7.43 geometry;
3723 
3724 
3725  if(
3726  (-X > -6.96 && -X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3727  ||
3728  (-X > -4.64 && -X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3729  ||
3730  (-X > -2.33 && -X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3731  ||
3732  (-X > 0. && -X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3733  ||
3734  (-X > 2.3 && -X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3735  ||
3736  (-X > 4.64 && -X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3737  ) return true;
3738 
3739 
3740  return false;
3741 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk22_21to22_23 ( Double_t  X,
Double_t  Y 
)

Definition at line 3752 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3756 {
3757 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3758 // they are placed between 22.21 and 22.23 in Z;
3759 // look at Gianluigi's logbook on page 193 for the geometry detail;
3760 
3761 
3762  if(
3763  (X > -6.96 && X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3764  ||
3765  (X > -4.64 && X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3766  ||
3767  (X > -2.33 && X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3768  ||
3769  (X > 0. && X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3770  ||
3771  (X > 2.3 && X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3772  ||
3773  (X > 4.64 && X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3774  ) return true;
3775 
3776 
3777 
3778 
3779  return false;
3780 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk22_21to22_23withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3788 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3794 {
3795 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3796 // they are placed between 22.21 and 22.23 in Z;
3797 // look at Gianluigi's logbook on page 193 for the geometry detail;
3798 
3799 
3800  if(
3801  (X > -6.96 + xmargin && X < -5.8 - xmargin && fabs(Y) < 2.31 - ymargin && fabs(Y) > 0.07 + ymargin)
3802  ||
3803  (X > -4.64 + xmargin && X < -3.48 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3804  ||
3805  (X > -2.33 + xmargin && X < -1.17 - xmargin && fabs(Y) < 6.87 - ymargin && fabs(Y) > 0.07 + ymargin)
3806  ||
3807  (X > 0. + xmargin && X < 1.16 - xmargin && fabs(Y) < 6.85 - ymargin && fabs(Y) > 1.19 + ymargin)
3808  ||
3809  (X > 2.3 + xmargin && X < 3.46 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3810  ||
3811  (X > 4.64 + xmargin && X < 5.8 - xmargin && fabs(Y) < 4.59 - ymargin && fabs(Y) > 0.07 + ymargin)
3812  ) return true;
3813 
3814 
3815 
3816 
3817  return false;
3818 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk2_41to2_43 ( Double_t  X,
Double_t  Y 
)

Definition at line 3044 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3048 {
3049 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3050 // they are placed between 2.41 and 2.43 in Z;
3051 // look at Gianluigi's logbook on page 194 for the geometry detail;
3052 
3053 
3054  if(
3055  ( X > 1.17 && X < 2.33 && Y > -2.26 && Y < 2.26 )
3056  ||
3057  ( X < 0. && X > -1.21 && fabs(Y) < 3.43 && fabs(Y) > 1.19)
3058  ||
3059  ( X < -2.32 && X > -3.48 && fabs(Y) < 1.12)
3060  ) return true;
3061 
3062  return false;
3063 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk2_41to2_43withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3071 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3077 {
3078 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3079 // they are placed between 2.41 and 2.43 in Z;
3080 // look at Gianluigi's logbook on page 194 for the geometry detail;
3081 
3082  if(
3083  ( X > 1.17 + xmargin && X < 2.33 - xmargin && Y > -2.26 + ymargin && Y < 2.26 - ymargin )
3084  ||
3085  ( X < 0. - xmargin && X > -1.21 + xmargin && fabs(Y) < 3.43 - ymargin && fabs(Y) > 1.19 + ymargin )
3086  ||
3087  ( X < -2.32 - xmargin && X > -3.48 + xmargin && fabs(Y) < 1.12 - ymargin )
3088  ) return true;
3089 
3090 
3091  return false;
3092 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk3_97to3_99 ( Double_t  X,
Double_t  Y 
)

Definition at line 3103 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3107 {
3108 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3109 // they are placed between 3.97 and 3.99 in Z;
3110 // look at Gianluigi's logbook on page 195 for the geometry detail;
3111 
3112 
3113  if(
3114  ( X > 1.17 && X < 2.33 && Y > -2.26 && Y < 2.26 )
3115  ||
3116  ( X < 0. && X > -1.21 && fabs(Y) < 3.43 && fabs(Y) > 1.19)
3117  ||
3118  ( X < -2.32 && X > -3.48 && fabs(Y) < 1.12)
3119  ) return true;
3120 
3121 
3122  return false;
3123 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk3_97to3_99withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3131 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3137 {
3138 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3139 // they are placed between 3.97 and 3.99 in Z;
3140 // look at Gianluigi's logbook on page 193 for the geometry detail;
3141 
3142  if(
3143  ( X > 1.17 + xmargin && X < 2.33 - xmargin && Y > -2.26 + ymargin && Y < 2.26 - ymargin )
3144  ||
3145  ( X < 0. - xmargin && X > -1.21 + xmargin && fabs(Y) < 3.43 - ymargin && fabs(Y) > 1.19 + ymargin )
3146  ||
3147  ( X < -2.32 - xmargin && X > -3.48 + xmargin && fabs(Y) < 1.12 - ymargin )
3148  ) return true;
3149 
3150  return false;
3151 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk4_41to4_43 ( Double_t  X,
Double_t  Y 
)

Definition at line 3162 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3166 {
3167 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3168 // they are placed between 4.41 and 4.43 in Z;
3169 // look at Gianluigi's logbook on page 195 for the geometry detail;
3170 
3171  if(
3172  (X > -2.33 && X < -1.17 && Y > -2.26 && Y < 2.26 )
3173  ||
3174  (X > 0. && X < 1.21 && fabs(Y) < 3.43 && fabs(Y) > 1.19)
3175  ||
3176  (X > 2.32 && X < 3.48 && fabs(Y) < 1.12)
3177  ) return true;
3178 
3179  return false;
3180 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk4_41to4_43withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3188 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3194 {
3195 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3196 // they are placed between 4.41 and 4.43 in Z;
3197 // look at Gianluigi's logbook on page 195 for the geometry detail;
3198 
3199  if(
3200  (X > -2.33 + xmargin && X < -1.17 - xmargin && Y > -2.26 + ymargin && Y < 2.26 - ymargin )
3201  ||
3202  (X > 0. + xmargin && X < 1.21 - xmargin && fabs(Y) < 3.43 && fabs(Y) > 1.19)
3203  ||
3204  (X > 2.32 + xmargin && X < 3.48 - xmargin && fabs(Y) < 1.12 - ymargin)
3205  ) return true;
3206 
3207  return false;
3208 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk6_97to6_99 ( Double_t  X,
Double_t  Y 
)

Definition at line 3219 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3223 {
3224 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3225 // they are placed between 6.97 and 6.99 in Z;
3226 // look at Gianluigi's logbook on page 195 for the geometry detail;
3227 
3228  if(
3229  (X > -6.96 && X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3230  ||
3231  (X > -4.64 && X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3232  ||
3233  (X > -2.33 && X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3234  ||
3235  (X > 0. && X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3236  ||
3237  (X > 2.3 && X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3238  ||
3239  (X > 4.64 && X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3240  ) return true;
3241 
3242  return false;
3243 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk6_97to6_99withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3251 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3257 {
3258 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3259 // they are placed between 6.97 and 6.99 in Z;
3260 // look at Gianluigi's logbook on page 195 for the geometry detail;
3261 
3262 
3263  if(
3264  (X > -6.96 + xmargin && X < -5.8 - xmargin && fabs(Y) < 2.31 - ymargin && fabs(Y) > 0.07 + ymargin)
3265  ||
3266  (X > -4.64 + xmargin && X < -3.48 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3267  ||
3268  (X > -2.33 + xmargin && X < -1.17 - xmargin && fabs(Y) < 6.87 - ymargin && fabs(Y) > 0.07 + ymargin)
3269  ||
3270  (X > 0. + xmargin && X < 1.16 - xmargin && fabs(Y) < 6.85 - ymargin && fabs(Y) > 1.19 + ymargin)
3271  ||
3272  (X > 2.3 + xmargin && X < 3.46 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3273  ||
3274  (X > 4.64 + xmargin && X < 5.8 - xmargin && fabs(Y) < 4.59 - ymargin && fabs(Y) > 0.07 + ymargin)
3275  ) return true;
3276 
3277 
3278 
3279  return false;
3280 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk7_41to7_43 ( Double_t  X,
Double_t  Y 
)

Definition at line 3291 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3295 {
3296 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3297 // they are placed between 7.41 and 7.43 in Z;
3298 // look at Gianluigi's logbook on page 196 for the geometry detail;
3299 
3300 // this geometry is the mirror-reflected with respect of Y axis of the Z=6.97_6.99 geometry;
3301 
3302  if(
3303  (-X > -6.96 && -X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3304  ||
3305  (-X > -4.64 && -X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3306  ||
3307  (-X > -2.33 && -X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3308  ||
3309  (-X > 0. && -X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3310  ||
3311  (-X > 2.3 && -X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3312  ||
3313  (-X > 4.64 && -X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3314  ) return true;
3315 
3316 
3317 
3318  return false;
3319 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk7_41to7_43withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3327 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3333 {
3334 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3335 // they are placed between 7.41 and 7.43 in Z;
3336 // look at Gianluigi's logbook on page 196 for the geometry detail;
3337 
3338 // this geometry is the mirror-reflected with respect of Y axis of the Z=6.97_6.99 geometry;
3339 
3340 
3341  if(
3342  (-X > -6.96 + xmargin && -X < -5.8 - xmargin && fabs(Y) < 2.31 - ymargin && fabs(Y) > 0.07 + ymargin)
3343  ||
3344  (-X > -4.64 + xmargin && -X < -3.48 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3345  ||
3346  (-X > -2.33 + xmargin && -X < -1.17 - xmargin && fabs(Y) < 6.87 - ymargin && fabs(Y) > 0.07 + ymargin)
3347  ||
3348  (-X > 0. + xmargin && -X < 1.16 - xmargin && fabs(Y) < 6.85 - ymargin && fabs(Y) > 1.19 + ymargin)
3349  ||
3350  (-X > 2.3 + xmargin && -X < 3.46 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3351  ||
3352  (-X > 4.64 + xmargin && -X < 5.8 - xmargin && fabs(Y) < 4.59 - ymargin && fabs(Y) > 0.07 + ymargin)
3353  ) return true;
3354 
3355 
3356 
3357 
3358  return false;
3359 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk9_97to9_99 ( Double_t  X,
Double_t  Y 
)

Definition at line 3366 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::IsThereHitInMvdMiniDisk().

3370 {
3371 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3372 // they are placed between 9.97 and 9.99 in Z;
3373 // look at Gianluigi's logbook on page 197 for the geometry detail;
3374 
3375 // this geometry is the mirror-reflected with respect of Y axis of the Z=6.97_6.99 geometry;
3376 
3377  if(
3378  (-X > -6.96 && -X < -5.8 && fabs(Y) < 2.31 && fabs(Y) > 0.07)
3379  ||
3380  (-X > -4.64 && -X < -3.48 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3381  ||
3382  (-X > -2.33 && -X < -1.17 && fabs(Y) < 6.87 && fabs(Y) > 0.07)
3383  ||
3384  (-X > 0. && -X < 1.16 && fabs(Y) < 6.85 && fabs(Y) > 1.19)
3385  ||
3386  (-X > 2.3 && -X < 3.46 && fabs(Y) < 5.73 && fabs(Y) > 0.07)
3387  ||
3388  (-X > 4.64 && -X < 5.8 && fabs(Y) < 4.59 && fabs(Y) > 0.07)
3389  ) return true;
3390 
3391 
3392 
3393  return false;
3394 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInMvdMiniDisk9_97to9_99withMargin ( Double_t  X,
Double_t  Y,
Double_t  xmargin,
Double_t  ymargin 
)

Definition at line 3402 of file PndTrkCTGeometryCalculations.cxx.

References fabs().

Referenced by PndTrkCleanup::Track_Crosses_MvdMiniDisk_withMargin().

3408 {
3409 // this is a set of sensors placed vertically perpendicularly to the Z direction;
3410 // they are placed between 9.97 and 9.99 in Z;
3411 // look at Gianluigi's logbook on page 197 for the geometry detail;
3412 
3413 // this geometry is the mirror-reflected with respect of Y axis of the Z=6.97_6.99 geometry;
3414 
3415 
3416  if(
3417  (-X > -6.96 + xmargin && -X < -5.8 - xmargin && fabs(Y) < 2.31 - ymargin && fabs(Y) > 0.07 + ymargin)
3418  ||
3419  (-X > -4.64 + xmargin && -X < -3.48 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3420  ||
3421  (-X > -2.33 + xmargin && -X < -1.17 - xmargin && fabs(Y) < 6.87 - ymargin && fabs(Y) > 0.07 + ymargin)
3422  ||
3423  (-X > 0. + xmargin && -X < 1.16 - xmargin && fabs(Y) < 6.85 - ymargin && fabs(Y) > 1.19 + ymargin)
3424  ||
3425  (-X > 2.3 + xmargin && -X < 3.46 - xmargin && fabs(Y) < 5.73 - ymargin && fabs(Y) > 0.07 + ymargin)
3426  ||
3427  (-X > 4.64 + xmargin && -X < 5.8 - xmargin && fabs(Y) < 4.59 - ymargin && fabs(Y) > 0.07 + ymargin)
3428  ) return true;
3429 
3430 
3431 
3432 
3433  return false;
3434 }
Y
double Y
Definition: anaLmdDigi.C:68
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
X
double X
Definition: anaLmdDigi.C:68
bool PndTrkCTGeometryCalculations::IsInsideArc ( Double_t  Oxx,
Double_t  Oyy,
Short_t  Charge,
Double_t  Xcross[2],
Double_t  Ycross[2],
Double_t  Spoint 
)

Definition at line 2929 of file PndTrkCTGeometryCalculations.cxx.

References atan2(), Double_t, f1, f2, and TWO_PI.

Referenced by PndTrkCleanup::BadTrack_ParStt(), PndTrkCleanup::GoodTrack(), and PndTrkCleanup::SttSkewCleanup().

2937 {
2938 
2939  Double_t f1,
2940  f2;
2941 
2942 
2943  // Xcross[0],Ycross[0] is the point of entrance.
2944 
2945 
2946  f1 = atan2(Ycross[0]-Oyy, Xcross[0]-Oxx);
2947  if(f1<0.) f1+= TWO_PI;
2948  if(f1<0.) f1= 0.;
2949  f2 = atan2(Ycross[1]-Oyy, Xcross[1]-Oxx);
2950  if(f2<0.) f2+= TWO_PI;
2951  if(f2<0.) f2= 0.;
2952 
2953 
2954 
2955  if(Charge<0){
2956  if(f1 > f2 ) f2 +=TWO_PI;
2957  if(f1 > f2 ) f2 = f1;
2958  if( f>f1){
2959  if(f<f2) return true; else return false;
2960  } else {
2961  f +=TWO_PI;
2962  if(f<f1) f= f1;
2963  if(f<f2) return true; else return false;
2964  }
2965  } else { // Charge > 0.
2966  if(f1 < f2 ) f1 +=TWO_PI;
2967  if(f1 < f2 ) f1 = f2;
2968  if( f>f2){
2969  if(f<f1) return true; else return false;
2970  } else {
2971  f +=TWO_PI;
2972  if(f<f2) f= f2;
2973  if(f<f1) return true; else return false;
2974  }
2975  } // end of if(Charge<0)
2976 }
f1
TF1 * f1
Definition: reco_analys2.C:50
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
f
TFile * f
Definition: bump_analys.C:12
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
f2
TFile * f2
Definition: ReadMesDecCorrRes.C:5
bool PndTrkCTGeometryCalculations::IsInTargetPipe ( Double_t  Oxx,
Double_t  Oyy,
Double_t  Rr,
Double_t  fi0,
Double_t  kappa,
Short_t  charge,
Double_t  gap 
)

Definition at line 3827 of file PndTrkCTGeometryCalculations.cxx.

References cos(), Double_t, fabs(), sin(), and sqrt().

Referenced by PndTrkCleanup::MvdCleanup_prova().

3836 {
3837  Short_t nintersections;
3838 
3839  Double_t delta,
3840  XintersectionList[8],
3841  YintersectionList[8],
3842  Xcross[2],
3843  Ycross[2];
3844 
3845  // find if this track lays in the target pipe volume
3846  // for distances < 15 (supposidly the maximum radius of the Mvd system)
3847  // and consequently it cannot have Mvd hits.
3848 
3849  nintersections=0;
3850 
3851  // intersections of trajectory with plane X = gap;
3852  delta = Rr*Rr - (gap-Oxx)*(gap-Oxx);
3853  if(delta>0.) {
3854  XintersectionList[0] = gap;
3855  YintersectionList[0] = sqrt(delta) + Oyy;
3856  XintersectionList[1] = gap;
3857  YintersectionList[1] = -sqrt(delta) + Oyy;
3858  nintersections+=2;
3859  }
3860 
3861  // intersections of trajectory with plane X = -gap;
3862  delta = Rr*Rr - (-gap-Oxx)*(-gap-Oxx);
3863  if(delta>0.) {
3864  XintersectionList[nintersections] = -gap;
3865  YintersectionList[nintersections] = sqrt(delta) + Oyy;
3866  XintersectionList[nintersections+1] = -gap;
3867  YintersectionList[nintersections+1] = -sqrt(delta) + Oyy;
3868  nintersections+=2;
3869  }
3870 
3871 
3872  // intersections of trajectory with plane Z = gap;
3873  XintersectionList[nintersections] = Oxx + Rr*cos(fi0+kappa*gap);
3874  YintersectionList[nintersections] = Oyy + Rr*sin(fi0+kappa*gap);
3875  nintersections++;
3876 
3877  // intersections of trajectory with plane Z = -gap;
3878  XintersectionList[nintersections] = Oxx + Rr*cos(fi0-kappa*gap);
3879  YintersectionList[nintersections] = Oyy + Rr*sin(fi0-kappa*gap);
3880  nintersections++;
3881 
3882  // order the found intersection point by increasing/decreasing FI
3883  // depending if the Charge is negative or positive.
3884  ChooseEntranceExitbis(
3885  Oxx,
3886  Oyy,
3887  Charge,
3888  fi0,
3889  nintersections,// n. intersection in input.
3890  XintersectionList,
3891  YintersectionList,
3892  Xcross, // output
3893  Ycross // output
3894  );
3895 
3896  // here I suppose that the Mvd system CONSERVATIVELY ends at Rmax=5 cm.
3897 //---------------
3898 for(int ic=0;ic<nintersections;ic++){
3899 }
3900 //-------------
3901  if( fabs(Ycross[0]) > 4. ) return true;
3902  else return false;
3903 }
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: P4_F32vec4.h:112
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: P4_F32vec4.h:111
PndTrkCTGeometryCalculations::ChooseEntranceExitbis
void ChooseEntranceExitbis(Double_t Oxx, Double_t Oyy, Short_t Charge, Double_t FiStart, Short_t nIntersections, Double_t *XintersectionList, Double_t *YintersectionList, Double_t Xcross[2], Double_t Ycross[2])
Definition: PndTrkCTGeometryCalculations.cxx:381
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
bool PndTrkCTGeometryCalculations::IsInternal ( Double_t  Px,
Double_t  Py,
Double_t  Xtraslation,
Double_t  Ytraslation,
Double_t  Theta 
)

Definition at line 3909 of file PndTrkCTGeometryCalculations.cxx.

References cos(), and sin().

3916 {
3917 
3918 
3919  // for explanations see Gianluigi's logbook on page 278-280.
3920 
3921  if( (Xtraslation-Px)*sin(Theta) + (Py-Ytraslation)*cos(Theta) >= 0. ) return true;
3922  else return false;
3923 
3924 
3925 }
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: P4_F32vec4.h:112
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: P4_F32vec4.h:111
void PndTrkCTGeometryCalculations::ListAxialSectorsCrossedbyTrack_and_Hits ( Double_t  Ox,
Double_t  Oy,
Double_t  R,
Double_t  Charge,
Short_t  nHits,
Short_t *  ListHits,
Double_t  info[][7],
Short_t &  nArcs_populated,
Short_t  nHitsInArc[56],
Short_t(*)  ListHitsInArc[56] 
)

Definition at line 3936 of file PndTrkCTGeometryCalculations.cxx.

References APOTEMAMAXINNERPARSTRAW, APOTEMAMINOUTERPARSTRAW, APOTEMASTRAWDETECTORMIN, atan2(), Double_t, fi, i, n, nHits, RSTRAWDETECTORMAX, Start(), TWO_PI, and VERTICALGAP.

Referenced by PndTrkCleanup::XYCleanup().

3952 {
3953 
3954 
3955  // nIntersection = number of sectors (entrance/exit) crossed by TRAJECTORY, namely by the entire
3956  // circle projection of the helix on XY;
3957  // nArcs = nIntersection/2 --> this is the number of Arcs in which the circle is segmented by the various
3958  // sectors of the axial straws;
3959  // nArcs_populated = the same as nArcs, but only those Arcs in which axial STT hits are actually present;
3960 
3961 
3962  Short_t
3963  half,
3964  i,
3965  //ihit, //[R.K. 01/2017] unused variable?
3966  //j, //[R.K. 01/2017] unused variable?
3967  jArc,
3968  n,
3969  nArcs,
3970  nIntersections,
3971  oldArc,
3972  remainder;
3973 
3974  Double_t
3975  AllFiOrderedList[56],
3976  AllXOrderedList[56],
3977  AllYOrderedList[56],
3978  fi,
3979  FiStart,
3980  Start[3];
3981  //FiOrderedList12[12], //[R.K. 01/2017] unused variable? // at most 12 intersections; ordered according to charge of the track
3982  // assuming it originated from (0,0,0);
3983  //FiOrderedList16[16]; //[R.K. 01/2017] unused variable? // at most 16 intersections; ordered according to charge of the track
3984  // assuming it originated from (0,0,0);
3985 
3986 
3987 
3988 //Double_t
3989  //XintersectionList12[12], // at most 12 intersections; //[R.K. 01/2017] unused variable?
3990  //XintersectionList16[16], // at most 16 intersections; //[R.K. 01/2017] unused variable?
3991  //YintersectionList12[12], // at most 12 intersections; //[R.K. 01/2017] unused variable?
3992  //YintersectionList16[16]; // at most 16 intersections; //[R.K. 01/2017] unused variable?
3993 
3994 
3995 
3996 
3997  // origin of the track assumed in (0,0,0);
3998  Start[0]=Start[1]=Start[2]= 0.;
3999 
4000 
4001 
4002  // Sector number convention:
4003  // 1 --> Right Axial Outer;
4004  // 2 --> Right Axial Inner;
4005  // 3 --> Left Axial Inner;
4006  // 4 --> Left Axial Outer;
4007 
4008 
4009  nArcs=0;
4010 
4011  // Sector 1;
4012  nIntersections = FindTrackEntranceExitHexagonCircleRight2(
4013  Ox,
4014  Oy,
4015  R,
4016  Charge,
4017  Start,
4018  APOTEMAMINOUTERPARSTRAW,
4019  RSTRAWDETECTORMAX,
4020  VERTICALGAP,
4021  &AllXOrderedList[0],
4022  &AllYOrderedList[0],
4023 // AllXOrderedList,
4024 // AllYOrderedList,
4025  AllFiOrderedList
4026  );
4027 
4028  // nIntersections must be multiple of 2 (entrance/exit);
4029  // each pair entrance/exit defines an arc of the trajectory; each arc will be later analyzed for continuity;
4030  half = nIntersections/2;
4031  remainder = nIntersections - 2 * half; // this is like fmod, only for integer arguments;
4032  //------
4033 
4034  if( remainder != 0 ){
4035  cout<<"PndTrkCTGeometryCalculations::ListAxialSectorsCrossedbyTrack_and_Hits,after FindTrackEntranceExitHexagonCircleRight2;"
4036  <<"\n\todd number of intersections : "<<nIntersections<<", cannot be, return with nArcs_populated=0!\n";
4037  nArcs_populated=0;
4038  return;
4039  }
4040  //------
4041 
4042 
4043 
4044  nArcs += half;
4045 
4046 /*
4047  for(i=0;i<nIntersections;i++){
4048  cout<<"from PndTrkCTGeometryCalculations, 1; Inters. so far "<<nIntersections<<", X inter "<<AllXOrderedList[i]<<", Y inter "
4049  <<AllYOrderedList[i]<<endl;
4050  };
4051 */
4052 
4053  // Sector 2;
4054  n = FindTrackEntranceExitbiHexagonRight2(
4055  VERTICALGAP,
4056  Ox,
4057  Oy,
4058  R,
4059  Charge,
4060  Start,
4061  APOTEMASTRAWDETECTORMIN,
4062  APOTEMAMAXINNERPARSTRAW,
4063  &AllXOrderedList[nIntersections],
4064  &AllYOrderedList[nIntersections],
4065  &AllFiOrderedList[nIntersections]
4066  );
4067 
4068  // n must be multiple of 2 (entrance/exit);
4069  // each pair entrance/exit defines an arc of the trajectory; each arc will be later analyzed for continuity;
4070  half = n/2;
4071  remainder = n - 2 * half; // this is like fmod, only for integer arguments;
4072  //------
4073  if( remainder != 0 ){
4074  cout<<"PndTrkCTGeometryCalculations::ListAxialSectorsCrossedbyTrack_and_Hits,after FindTrackEntranceExitbiHexagonRight2;"
4075  <<"\n\todd number of intersections : "<<n<<", cannot be, return with nArcs_populated=0!\n";
4076  nArcs_populated=0;
4077  return;
4078  }
4079  //------
4080 
4081  nIntersections += n;
4082 
4083  nArcs += half;
4084 
4085 /* for(i=0;i<nIntersections;i++){ cout<<"from PndTrkCTGeometryCalculations, 2; Inters. so far "<<
4086 nIntersections<<", X inter "<<AllXOrderedList[i]<<", Y inter "
4087  <<AllYOrderedList[i]<<endl;};
4088 */
4089 
4090  // Sector 3;
4091  n = FindTrackEntranceExitbiHexagonLeft2(
4092  VERTICALGAP,
4093  Ox,
4094  Oy,
4095  R,
4096  Charge,
4097  Start,
4098  APOTEMASTRAWDETECTORMIN,
4099  APOTEMAMAXINNERPARSTRAW,
4100  &AllXOrderedList[nIntersections],
4101  &AllYOrderedList[nIntersections],
4102  &AllFiOrderedList[nIntersections]
4103  );
4104  // n must be multiple of 2 (entrance/exit);
4105  // each pair entrance/exit defines an arc of the trajectory; each arc will be later analyzed for continuity;
4106  half = n/2;
4107  remainder = n - 2 * half; // this is like fmod, only for integer arguments;
4108  //------
4109  if( remainder != 0 ){
4110  cout<<"PndTrkCTGeometryCalculations::ListAxialSectorsCrossedbyTrack_and_Hits,after FindTrackEntranceExitbiHexagonLeft2;"
4111  <<"\n\todd number of intersections : "<<n<<", cannot be, return with nArcs_populated=0!\n";
4112  nArcs_populated=0;
4113  return;
4114  }
4115  //------
4116 
4117  nArcs += half;
4118 
4119 
4120 
4121 // for(i=nIntersections;i<nIntersections+n;i++){ IntersectedSector[i]=3;};
4122  nIntersections += n;
4123 
4124 /* for(i=0;i<nIntersections;i++){ cout<<"from PndTrkCTGeometryCalculations, 3, Inters. so far "<<
4125 nIntersections<<", X inter "<<AllXOrderedList[i]<<", Y inter "
4126  <<AllYOrderedList[i]<<endl;};
4127 */
4128 
4129  // Sector 4;
4130  n = FindTrackEntranceExitHexagonCircleLeft2(
4131  Ox,
4132  Oy,
4133  R,
4134  Charge,
4135  Start,
4136  APOTEMAMINOUTERPARSTRAW,
4137  RSTRAWDETECTORMAX,
4138  VERTICALGAP,
4139  &AllXOrderedList[nIntersections],
4140  &AllYOrderedList[nIntersections],
4141  &AllFiOrderedList[nIntersections]
4142  );
4143  // n must be multiple of 2 (entrance/exit);
4144  // each pair entrance/exit defines an arc of the trajectory; each arc will be later analyzed for continuity;
4145  half = n/2;
4146  remainder = n - 2 * half; // this is like fmod, only for integer arguments;
4147  //------
4148  if( remainder != 0 ){
4149  cout<<"PndTrkCTGeometryCalculations::ListAxialSectorsCrossedbyTrack_and_Hits,after FindTrackEntranceExitHexagonCircleLeft2;"
4150  <<"\n\todd number of intersections : "<<n<<", cannot be, return with nArcs_populated=0!\n";
4151  nArcs_populated=0;
4152  return;
4153  }
4154  //------
4155 
4156  nArcs += half;
4157 
4158 
4159  nIntersections += n;
4160 
4161 /* for(i=0;i<nIntersections;i++){ cout<<"from PndTrkCTGeometryCalculations, 4, Inters. so far "<<nIntersections<<
4162 ", X inter "<<AllXOrderedList[i]<<", Y inter "
4163  <<AllYOrderedList[i]<<endl;};
4164 */
4165 
4166  // now subdivide the hit list in many lists, on for each sector crossed by track;
4167  // since the List of Hits in a track should already be ordered from inside
4168  // outwards, the various ListHitsInArc[*][jArc] should be automatically
4169  // ordered from inside outwards; also the various Arcs shoud be already in the right sequence
4170  // from inside towards outside;
4171 
4172  FiStart = atan2( Start[1]-Oy,Start[0]-Ox);
4173  if(FiStart<0.) FiStart+= TWO_PI;
4174  if(FiStart<0.) FiStart =0.;
4175 
4176  oldArc = -1;
4177  nArcs_populated=0;
4178 
4179  if(Charge > 0.) { // particle runs clockwise;
4180  // loop over the hits in track;
4181  for(i=0;i<nHits;i++){
4182  fi = atan2(info[ListHits[i]][1]-Oy, info[ListHits[i]][0]-Ox);
4183  if(fi<0.) fi+= TWO_PI;
4184  if(fi<0.) fi =0.;
4185  if( fi > FiStart) fi -= TWO_PI;
4186  if( fi > FiStart) fi = FiStart;
4187  // find to which Arc this hit belongs;
4188  for(jArc=0;jArc<nArcs;jArc++){
4189  if(fi < AllFiOrderedList[2*jArc] && fi>AllFiOrderedList[2*jArc+1])
4190  {
4191  if( jArc != oldArc ){ // new Arc;
4192  oldArc=jArc;
4193  nHitsInArc[nArcs_populated] = 1;
4194  ListHitsInArc[0][nArcs_populated ] = ListHits[i];
4195  nArcs_populated++;
4196  } else {
4197  ListHitsInArc[ nHitsInArc[nArcs_populated-1] ][ nArcs_populated-1 ] = ListHits[i];
4198  nHitsInArc[ nArcs_populated-1 ] ++;
4199  } // end of if( jArc != oldArc )
4200 
4201  break;
4202  } // end of if(fi < AllFiOrderedList[2*jArc] && fi>AllFiOrderedList[2*jArc+1])
4203  } // end of for(j=0;j<nIntersections;j++)
4204  } // end of for(i=0;i<nHits;i++)
4205 
4206  } else { // continuation of if(charge > 0.) // negative particle run anticlockwise;
4207 
4208 
4209  // loop over the hits in track;
4210  for(i=0;i<nHits;i++){
4211  fi = atan2(info[ListHits[i]][1]-Oy, info[ListHits[i]][0]-Ox);
4212  if(fi<0.) fi+= TWO_PI;
4213  if(fi<0.) fi =0.;
4214  if( fi < FiStart) fi += TWO_PI;
4215  if( fi < FiStart) fi = FiStart;
4216  // find to which Arc this hit belongs;
4217  for(jArc=0;jArc<nArcs;jArc++){
4218  if(fi > AllFiOrderedList[2*jArc] && fi < AllFiOrderedList[2*jArc+1])
4219  {
4220  if( jArc != oldArc ){ // new Arc;
4221  oldArc=jArc;
4222  nHitsInArc[nArcs_populated] = 1;
4223  ListHitsInArc[0][nArcs_populated ] = ListHits[i];
4224  nArcs_populated++;
4225  } else {
4226  ListHitsInArc[ nHitsInArc[nArcs_populated-1] ][ nArcs_populated-1 ] = ListHits[i];
4227  nHitsInArc[ nArcs_populated-1 ] ++;
4228  } // end of if( jArc != oldArc )
4229 
4230  break;
4231  } // end of if(fi < AllFiOrderedList[2*jArc] && fi>AllFiOrderedList[2*jArc+1])
4232  } // end of for(j=0;j<nIntersections;j++)
4233  } // end of for(i=0;i<nHits;i++)
4234 
4235 
4236  } // end of if(charge > 0.)
4237 
4238 
4239  return;
4240 }
RSTRAWDETECTORMAX
const Double_t RSTRAWDETECTORMAX
Definition: PndTrkConstants.h:215
PndTrkCTGeometryCalculations::FindTrackEntranceExitHexagonCircleLeft2
Short_t FindTrackEntranceExitHexagonCircleLeft2(Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t GAP, Double_t XintersectionList[12], Double_t YintersectionList[12], Double_t FiOrderedList[12])
Definition: PndTrkCTGeometryCalculations.cxx:1731
i
Int_t i
Definition: run_full.C:25
n
int n
Definition: HypStatDecay.cxx:21
Start
timer Start()
TWO_PI
const Double_t TWO_PI
Definition: PndTrkConstants.h:254
nHits
int nHits
Definition: RiemannTest.C:16
fi
TFile * fi
Definition: createRootGeoFile.C:238
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
APOTEMAMINOUTERPARSTRAW
const Double_t APOTEMAMINOUTERPARSTRAW
Definition: PndTrkConstants.h:220
VERTICALGAP
const Double_t VERTICALGAP
Definition: PndTrkConstants.h:23
PndTrkCTGeometryCalculations::FindTrackEntranceExitbiHexagonRight2
Short_t FindTrackEntranceExitbiHexagonRight2(Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t XintersectionList[16], Double_t YintersectionList[16], Double_t FiOrderedList[16])
Definition: PndTrkCTGeometryCalculations.cxx:1510
atan2
friend F32vec4 atan2(const F32vec4 &y, const F32vec4 &x)
Definition: P4_F32vec4.h:117
APOTEMAMAXINNERPARSTRAW
const Double_t APOTEMAMAXINNERPARSTRAW
Definition: PndTrkConstants.h:218
PndTrkCTGeometryCalculations::FindTrackEntranceExitbiHexagonLeft2
Short_t FindTrackEntranceExitbiHexagonLeft2(Double_t vgap, Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t XintersectionList[16], Double_t YintersectionList[16], Double_t FiOrderedList[16])
Definition: PndTrkCTGeometryCalculations.cxx:1285
PndTrkCTGeometryCalculations::FindTrackEntranceExitHexagonCircleRight2
Short_t FindTrackEntranceExitHexagonCircleRight2(Double_t Oxx, Double_t Oyy, Double_t Rr, Short_t Charge, Double_t Start[3], Double_t ApotemaMin, Double_t ApotemaMax, Double_t GAP, Double_t XintersectionList[12], Double_t YintersectionList[12], Double_t FiOrderedList[12])
Definition: PndTrkCTGeometryCalculations.cxx:1967
APOTEMASTRAWDETECTORMIN
const Double_t APOTEMASTRAWDETECTORMIN
Definition: PndTrkConstants.h:222
R
Double_t R
Definition: checkhelixhit.C:61
The documentation for this class was generated from the following files:
Generated on Sun Aug 18 2019 03:04:20 for FairRoot/PandaRoot by   doxygen 1.8.8