FairRoot/PandaRoot
PndFTSCAParam.cxx
Go to the documentation of this file.
1 // @(#) $Id: PndCAParam.cxx,v 1.5 2016/10/11 02:33:47 mpugach Exp $
2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project *
4 // ALICE Experiment at CERN, All rights reserved. *
5 // *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 // Ivan Kisel <kisel@kip.uni-heidelberg.de> *
8 // for The ALICE HLT Project. *
9 // *
10 // Developed by: Igor Kulakov <I.Kulakov@gsi.de> *
11 // Mykhailo Pugach <M.Pugach@gsi.de> *
12 // Maksym Zyzak <M.Zyzak@gsi.de> *
13 // *
14 // Permission to use, copy, modify and distribute this software and its *
15 // documentation strictly for non-commercial purposes is hereby granted *
16 // without fee, provided that the above copyright notice appears in all *
17 // copies and that both the copyright notice and this permission notice *
18 // appear in the supporting documentation. The authors make no claims *
19 // about the suitability of this software for any purpose. It is *
20 // provided "as is" without express or implied warranty. *
21 // *
22 //***************************************************************************
23 
24 
25 #include "PndFTSCAParam.h"
26 #include "PndFTSCAMath.h"
27 
28 #include <iostream>
29 #include "FairRunAna.h"
30 #include "FairField.h"
31 #include "debug.h"
32 
33 #include "TVector3.h"
34 #include "TVectorD.h"
35 #include "TMatrixD.h"
36 #include "TH2F.h"
37 
38 PndFTSCAParam::PndFTSCAParam()
39  : fNStations(0), fStations(0)
40 {
41 }
42 
43 void PndFTSCAParam::InitMagneticField()
44 {
45 // const int M=5; // polinom order
46 // const int N=21;//(M+1)*(M+2)/2;
47 
48  float xMax[48] = { 66, 66, 66, 66, 66, 66, 66, 66,
49  66, 66, 66, 66, 66, 66, 66, 66,
50  88, 88, 88, 88, 88, 88, 88, 88,
51  104,104,104,104,104,104,104,104,
52  160,160,160,160,160,160,160,160,
53  160,160,160,160,160,160,160,160 };
54 
55  float yMax[48] = { 32, 32, 32, 32, 32, 32, 32, 32,
56  32, 32, 32, 32, 32, 32, 32, 32,
57  37, 37, 37, 37, 37, 37, 37, 37,
58  41, 41, 41, 41, 41, 41, 41, 41,
59  60, 60, 60, 60, 60, 60, 60, 60,
60  60, 60, 60, 60, 60, 60, 60, 60 };
61 
62  for ( Int_t ist = 0; ist<fNStations; ist++ )
63  {
64  //std::cout << " Z " << fStations[ist].x0 << std::endl;
65  L1FieldSlice &fieldSlice = fStations[ist].fieldSlice;
66  if( ist == 32 || ist == 16)
67  {
68  vector<L1FieldSlice> &virtualSlices = fStations[ist].fieldVirtualSlice;
69  virtualSlices.resize(10);
70  float x0Virtual = fStations[ist].x0;
71  float xMaxVirtual = xMax[ist];
72  float yMaxVirtual = yMax[ist];
73  float dx = (xMax[ist] - xMax[ist-1])/11.f;
74  float dy = (yMax[ist] - yMax[ist-1])/11.f;
75  float dz = (fStations[ist].x0 - fStations[ist-1].x0)/11.f;
76  for( unsigned int iV = 0; iV < virtualSlices.size(); iV++ )
77  {
78  x0Virtual -= dz;
79  xMaxVirtual -= dx;
80  yMaxVirtual -= dy;
81  //std::cout << "Virt " << xMaxVirtual << " " << yMaxVirtual << " " << x0Virtual << std::endl;
82  CalculateFieldSlice(virtualSlices[iV], xMaxVirtual, yMaxVirtual, x0Virtual);
83  }
84  }
85  CalculateFieldSlice(fieldSlice, xMax[ist], yMax[ist], fStations[ist].x0);
86  }
87 
88  CheckFieldApproximation();
89 }
90 
91 void PndFTSCAParam::CalculateFieldSlice(L1FieldSlice& fieldSlice, const float xMax, const float yMax, const float z)
92 {
93  const int M=5; // polinom order
94  const int N=21;//(M+1)*(M+2)/2;
95 
96  double dx = 1.; // step for the field approximation
97  double dy = 1.;
98 
99  if( dx > xMax/N/2 ) dx = xMax/N/4.;
100  if( dy > yMax/N/2 ) dy = yMax/N/4.;
101 
102  TMatrixD A(N,N);
103  TVectorD b0(N), b1(N), b2(N);
104  for( int i=0; i<N; i++){
105  for( int j=0; j<N; j++) A(i,j) = 0.;
106  b0(i)=b1(i)=b2(i) = 0.;
107  }
108 
109  if(FairRunAna::Instance()->GetField())
110  {
111  for( double x=-xMax; x<=xMax; x+=dx )
112  for( double y=-yMax; y<=yMax; y+=dy )
113  {
114  double r = sqrt(fabs(x*x/xMax/xMax+y/yMax*y/yMax));
115 // if( r>1. ) continue;
116  Double_t w = 1./(r*r+1);
117  Double_t p[3] = { x, y, z};
118  Double_t B[3] = {0.,0.,0.};
119  FairRunAna::Instance()->GetField()->Field(p, B);
120  TVectorD m(N);
121  m(0)=1;
122  for( int i=1; i<=M; i++){
123  int k = (i-1)*(i)/2;
124  int l = i*(i+1)/2;
125  for( int j=0; j<i; j++ ) m(l+j) = x*m(k+j);
126  m(l+i) = y*m(k+i-1);
127  }
128 
129  TVectorD mt = m;
130  for( int i=0; i<N; i++){
131  for( int j=0; j<N;j++) A(i,j)+=w*m(i)*m(j);
132  b0(i)+=w*B[0]*m(i);
133  b1(i)+=w*B[1]*m(i);
134  b2(i)+=w*B[2]*m(i);
135  }
136  }
137  double det;
138  A.Invert(&det);
139  TVectorD c0 = A*b0, c1 = A*b1, c2 = A*b2;
140  for(int i=0; i<N; i++){
141  fieldSlice.cx[i] = c0(i);
142  fieldSlice.cy[i] = c1(i);
143  fieldSlice.cz[i] = c2(i);
144  }
145  }
146 }
147 
148 void PndFTSCAParam::GetStripInfo(FTSCAStripInfoVector& stripInfo, const int_v iStation, const float_m& mask) const
149 {
150  for(int iV=0; iV<int_v::Size; iV++)
151  {
152  if(!(mask[iV])) continue;
153 
154  stripInfo.sin[iV] = Station( iStation[iV] ).f.sin;
155  stripInfo.cos[iV] = Station( iStation[iV] ).f.cos;
156  }
157 }
158 
159 std::istream &operator>>( std::istream &in, PndFTSCAParam &p )
160 {
161  // Read settings from the file
162  in >> p.fNStations;
163  if(p.fStations) delete [] p.fStations;
164  p.fStations = new FTSCAStation[p.fNStations];
165  in >> p.fBz;
166 
167  for(int i=0; i<p.fNStations; i++)
168  {
169  float inttmp;
170  in >> inttmp;
171  if( inttmp != i ) {
172  cout << "ERROR: Settings.data format is wrong! Station: " << i-1 << endl;
173  exit(0);
174  }
175  in >> p.fStations[i].x0;
176 #ifdef PANDA_FTS
177  in >> p.fStations[i].materialInfo.RadThick;
178  p.fStations[i].materialInfo.RadThick *= 10.f; //TODO !!!!!!! put correct material
179  p.fStations[i].materialInfo.logRadThick = log( p.fStations[i].materialInfo.RadThick );
180  float xTimesRho;
181  in >> xTimesRho;
182  p.fStations[i].materialInfo.thick = xTimesRho/1.39; // ~54 mum mular
183  p.fStations[i].materialInfo.RL = p.fStations[i].materialInfo.thick/p.fStations[i].materialInfo.RadThick;
184 #else
185  in >> p.fStations[i].xOverX0;
186  in >> p.fStations[i].xTimesRho;
187 #endif
188 
189  float beta;
190  in >> beta;
191  p.fStations[i].f.sin = sin(beta);
192  p.fStations[i].f.cos = cos(beta);
193  //std::cout<<"p.fStations[i].f.sin "<<p.fStations[i].f.sin<<" p.fStations[i].f.cos "<<p.fStations[i].f.cos<<std::endl;
194  in >> inttmp;
195  p.fStations[i].NDF = inttmp;
196  in >> inttmp;
197  p.fStations[i].CellLength = inttmp;
198  }
199 
200 #ifdef STAR_HFT
201  p.fMaxZ = 35;
202  p.fMaxR = 25;
203  p.fMinR = 0;
204  p.fMinZ = -p.fMaxZ;
205 #elif ALICE_ITS
206  p.fMaxZ = 60;
207  p.fMaxR = 60;
208  p.fMinR = 0;
209  p.fMinZ = -p.fMaxZ;
210 #elif PANDA_STT
211  p.fMaxZ = 75+20;
212  p.fMaxR = 41;
213  p.fMinR = 0;
214  p.fMinZ = -75+20;
215 #elif PANDA_FTS
216  p.fMinX = -200; // more precisely 196
217  p.fMaxX = 200;
218  p.fMinY = -60;
219  p.fMaxY = 60;
220  p.fMinZ = 290;
221  p.fMaxZ = 660;
222 #endif
223 
224 #ifdef PANDA_FTS
225  // p.fVtxFieldValue[0].y = p.Bz();
226  // p.fVtxFieldValue[1].y = p.Bz();
227  // p.fZVtxFieldValue[0] = 0.f;
228  // p.fZVtxFieldValue[1] = 1.f;
229  // for(int i=0; i<p.fNStations; i++)
230  // p.fStations[i].fieldSlice.cy[0] = p.Bz();
231 // if(1){ // read field
232 // float tmp;
233 // for( int i = 0; i < 2; i++ ) {
234 // in >> tmp;
235 // p.fZVtxFieldValue[i] = tmp;
236 // in >> tmp;
237 // p.fVtxFieldValue[i].x = tmp;
238 // in >> tmp;
239 // p.fVtxFieldValue[i].y = tmp;
240 // in >> tmp;
241 // p.fVtxFieldValue[i].z = tmp;
242 // }
243 //
244 // in >> tmp >> tmp >> tmp >> tmp; // skip one point
245 //
246 // for(int iSta = 0; iSta < p.fNStations; iSta++) {
247 // #if 0
248 // int N;
249 // in >> N;
250 // for( int i = 0; i < N; i++ ) {
251 // in >> tmp;
252 // p.fStations[i].fieldSlice.cx[i] = tmp;
253 // }
254 // for( int i = 0; i < N; i++ ) {
255 // in >> tmp;
256 // p.fStations[i].fieldSlice.cy[i] = tmp;
257 // }
258 // for( int i = 0; i < N; i++ ) {
259 // in >> tmp;
260 // p.fStations[i].fieldSlice.cz[i] = tmp;
261 // }
262 // #else // 0
263 // L1FieldSlice &sl = p.fStations[iSta].fieldSlice;
264 // vector<L1FieldSlice> &vSls = p.fStations[iSta].fieldVirtualSlice;
265 // int itmp;
266 // in >> itmp; // station
267 // if ( itmp != iSta ) { cout << "Wrong field" << endl; exit(0); }
268 // ASSERT( itmp == iSta, itmp << " = " << iSta );
269 // in >> itmp >> p.fStations[iSta].dZVirtualStation; // n virtual stations & dz
270 // vSls.resize(itmp);
271 // in >> sl.xMin >> sl.dx >> sl.nXBins;
272 // in >> sl.yMin >> sl.dy >> sl.nYBins;
273 // const int NBins = sl.nXBins*sl.nYBins;
274 // for( unsigned int iV = 0; iV < vSls.size(); iV++ ) {
275 // L1FieldSlice &vSl = vSls[iV];
276 // vSl.xMin = sl.xMin;
277 // vSl.dx = sl.dx;
278 // vSl.nXBins = sl.nXBins;
279 // vSl.yMin = sl.yMin;
280 // vSl.dy = sl.dy;
281 // vSl.nYBins = sl.nYBins;
282 // vSl.AlocateMemory();
283 // for( int iB = 0; iB < NBins; iB++ ) {
284 // in >> vSl.bX[iB] >> vSl.bY[iB] >> vSl.bZ[iB];
285 // }
286 // }
287 //
288 // sl.AlocateMemory();
289 // for( int iB = 0; iB < NBins; iB++ ) {
290 // in >> sl.bX[iB] >> sl.bY[iB] >> sl.bZ[iB];
291 // }
292 // #endif // 0
293 // }
294 // }
295 #else // PANDA_FTS
296  p.fVtxFieldValue[0] = p.cBz();
297 #endif
298 
299  return in;
300 }
301 
302 #include "BinaryStoreHelper.h"
303 
304 void PndFTSCAParam::StoreToFile( FILE *f ) const
305 {
306  BinaryStoreWrite( *this, f );
307 }
308 
309 void PndFTSCAParam::RestoreFromFile( FILE *f )
310 {
311  BinaryStoreRead( *this, f );
312 }
313 
314 void PndFTSCAParam::CheckFieldApproximation()
315 {
316  TDirectory *curr = gDirectory;
317  TFile *currentFile = gFile;
318  TFile* fout = new TFile("FieldApprox.root","RECREATE");
319  fout->cd();
320 
321  float xMax[48] = { 66, 66, 66, 66, 66, 66, 66, 66,
322  66, 66, 66, 66, 66, 66, 66, 66,
323  88, 88, 88, 88, 88, 88, 88, 88,
324  104,104,104,104,104,104,104,104,
325  160,160,160,160,160,160,160,160,
326  160,160,160,160,160,160,160,160 };
327 
328  float yMax[48] = { 32, 32, 32, 32, 32, 32, 32, 32,
329  32, 32, 32, 32, 32, 32, 32, 32,
330  37, 37, 37, 37, 37, 37, 37, 37,
331  41, 41, 41, 41, 41, 41, 41, 41,
332  60, 60, 60, 60, 60, 60, 60, 60,
333  60, 60, 60, 60, 60, 60, 60, 60 };
334 
335  for ( int ist = 0; ist<fNStations; ist++ )
336  {
337  double z = fStations[ist].x0;
338  double Xmax=xMax[ist], Ymax=yMax[ist];
339 
340  Double_t r[3],B[3];
341  Double_t bbb, bbb_L1;
342 
343  L1FieldSlice &fieldSlice = fStations[ist].fieldSlice;
344  CAFieldValue B_L1;
345 
346  int NbinsX = 100; //static_cast<int>(2*Xmax/step);
347  int NbinsY = 100; //static_cast<int>(2*Ymax/step);
348  float ddx = 2*Xmax/NbinsX;
349  float ddy = 2*Ymax/NbinsY;
350 
351  TH2F *stB = new TH2F(Form("station %i, dB", ist+1) ,Form("station %i, dB, z = %0.f cm", ist+1,z) , static_cast<int>(NbinsX+1),-(Xmax+ddx/2.),(Xmax+ddx/2.), static_cast<int>(NbinsY+1),-(Ymax+ddy/2.),(Ymax+ddy/2.));
352  TH2F *stBx = new TH2F(Form("station %i, dBx", ist+1),Form("station %i, dBx, z = %0.f cm", ist+1,z), static_cast<int>(NbinsX+1),-(Xmax+ddx/2.),(Xmax+ddx/2.), static_cast<int>(NbinsY+1),-(Ymax+ddy/2.),(Ymax+ddy/2.));
353  TH2F *stBy = new TH2F(Form("station %i, dBy", ist+1),Form("station %i, dBy, z = %0.f cm", ist+1,z), static_cast<int>(NbinsX+1),-(Xmax+ddx/2.),(Xmax+ddx/2.), static_cast<int>(NbinsY+1),-(Ymax+ddy/2.),(Ymax+ddy/2.));
354  TH2F *stBz = new TH2F(Form("station %i, dBz", ist+1),Form("station %i, dBz, z = %0.f cm", ist+1,z), static_cast<int>(NbinsX+1),-(Xmax+ddx/2.),(Xmax+ddx/2.), static_cast<int>(NbinsY+1),-(Ymax+ddy/2.),(Ymax+ddy/2.));
355 
356 
357 
358  Int_t i=1,j=1;
359 
360  float x,y;
361  for(int ii = 1; ii <=NbinsX+1; ii++)
362  {
363  j=1;
364  x = -Xmax+(ii-1)*ddx;
365  for(int jj = 1; jj <=NbinsY+1; jj++)
366  {
367  y = -Ymax+(jj-1)*ddy;
368  //double rrr = sqrt(fabs(x*x/Xmax/Xmax+y/Ymax*y/Ymax));
369 // if(rrr>1. )
370 // {
371 // j++;
372 // continue;
373 // }
374  r[2] = z; r[0] = x; r[1] = y;
375  FairRunAna::Instance()->GetField()->Field(r, B);
376  bbb = sqrt(B[0]*B[0]+B[1]*B[1]+B[2]*B[2]);
377 
378  fieldSlice.GetFieldValue(x,y,B_L1);
379  bbb_L1 = sqrt(B_L1.x[0]*B_L1.x[0] + B_L1.y[0]*B_L1.y[0] + B_L1.z[0]*B_L1.z[0]);
380 
381  stB -> SetBinContent(ii,jj, fabs(bbb)>1.e-2 ? (bbb - bbb_L1)/bbb*100 : 0);
382  stBx -> SetBinContent(ii,jj, fabs(B[0])>1.e-2 ? (B[0] - B_L1.x[0])/B[0]*100 : 0);
383  stBy -> SetBinContent(ii,jj, fabs(B[1])>1.e-2 ? (B[1] - B_L1.y[0])/B[1]*100 : 0);
384  stBz -> SetBinContent(ii,jj, fabs(B[2])>1.e-2 ? (B[2] - B_L1.z[0])/B[2]*100 : 0);
385 
386 // stB -> SetBinContent(ii,jj, bbb_L1);
387 // stBx -> SetBinContent(ii,jj, B_L1.x[0]);
388 // stBy -> SetBinContent(ii,jj, B_L1.y[0]);
389 // stBz -> SetBinContent(ii,jj, B_L1.z[0]);
390 
391 // stB -> SetBinContent(ii,jj, (bbb - bbb_L1) );
392 // stBx -> SetBinContent(ii,jj, (B[0] - B_L1.x[0]));
393 // stBy -> SetBinContent(ii,jj, (B[1] - B_L1.y[0]));
394 // stBz -> SetBinContent(ii,jj, (B[2] - B_L1.z[0]));
395  j++;
396  }
397  i++;
398  }
399 
400  stB ->GetXaxis()->SetTitle("X, cm");
401  stB ->GetYaxis()->SetTitle("Y, cm");
402  stB ->GetXaxis()->SetTitleOffset(1);
403  stB ->GetYaxis()->SetTitleOffset(1);
404  stB ->GetZaxis()->SetTitle("B_map - B_L1, kGauss");
405  stB ->GetZaxis()->SetTitleOffset(1.3);
406 
407  stBx ->GetXaxis()->SetTitle("X, cm");
408  stBx ->GetYaxis()->SetTitle("Y, cm");
409  stBx ->GetXaxis()->SetTitleOffset(1);
410  stBx ->GetYaxis()->SetTitleOffset(1);
411  stBx ->GetZaxis()->SetTitle("Bx_map - Bx_L1, kGauss");
412  stBx ->GetZaxis()->SetTitleOffset(1.3);
413 
414  stBy ->GetXaxis()->SetTitle("X, cm");
415  stBy ->GetYaxis()->SetTitle("Y, cm");
416  stBy ->GetXaxis()->SetTitleOffset(1);
417  stBy ->GetYaxis()->SetTitleOffset(1);
418  stBy ->GetZaxis()->SetTitle("By_map - By_L1, kGauss");
419  stBy ->GetZaxis()->SetTitleOffset(1.3);
420 
421  stBz ->GetXaxis()->SetTitle("X, cm");
422  stBz ->GetYaxis()->SetTitle("Y, cm");
423  stBz ->GetXaxis()->SetTitleOffset(1);
424  stBz ->GetYaxis()->SetTitleOffset(1);
425  stBz ->GetZaxis()->SetTitle("Bz_map - Bz_L1, kGauss");
426  stBz ->GetZaxis()->SetTitleOffset(1.3);
427 
428  stB -> Write();
429  stBx -> Write();
430  stBy -> Write();
431  stBz -> Write();
432 
433  } // for ista
434 
435  fout->Close();
436  fout->Delete();
437  gFile = currentFile;
438  gDirectory = curr;
439 } // void CbmL1::FieldApproxCheck()
440 
x0
Double_t x0
Definition: checkhelixhit.C:70
p
Double_t p
Definition: anasim.C:58
b1
Double_t b1
Definition: createRootGeoFileBwEnd_FwEndCapGeo.C:21
cos
friend F32vec4 cos(const F32vec4 &a)
Definition: P4_F32vec4.h:112
std::basic_istream
Definition: PndFTSCATrackParamVector.h:1256
dy
double dy
Definition: runGeaneTestSimBox.cxx:45
r
double r
Definition: RiemannTest.C:14
PndFTSCAParam::Station
const FTSCAStation & Station(short i) const
Definition: PndFTSCAParam.h:45
PndFTSCAParam::GetStripInfo
void GetStripInfo(FTSCAStripInfoVector &stripInfo, const int_v iStation, const float_m &mask) const
Definition: PndFTSCAParam.cxx:148
i
Int_t i
Definition: run_full.C:25
FTSCAStation::f
FTSCAStripInfo f
Definition: FTSCAStation.h:32
m
__m128 m
Definition: P4_F32vec4.h:28
PndFTSCAParam::InitMagneticField
void InitMagneticField()
Definition: PndFTSCAParam.cxx:43
exit
exit(0)
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: P4_F32vec4.h:29
sin
friend F32vec4 sin(const F32vec4 &a)
Definition: P4_F32vec4.h:111
log
friend F32vec4 log(const F32vec4 &a)
Definition: P4_F32vec4.h:110
c2
c2
Definition: plot_dirc.C:39
dz
Double_t dz
Definition: createRootGeoFileBwEnd_FwEndCapGeo.C:24
jj
Int_t jj
Definition: createRootGeoFileBwEnd_FwEndCapGeo.C:434
Write
vTop Write()
b2
Double_t b2
Definition: createRootGeoFileBwEnd_FwEndCapGeo.C:22
L1FieldSlice::GetFieldValue
void GetFieldValue(const float_v &x, const float_v &y, CAFieldValue &B, const float_m &mask=float_m(true)) const
Definition: L1Field.h:74
BinaryStoreWrite
static void BinaryStoreWrite(const T *mem, int count, FILE *f)
Definition: BinaryStoreHelper.h:30
PndFTSCAParam::fVtxFieldValue
CAFieldValue fVtxFieldValue[2]
Definition: PndFTSCAParam.h:129
PndFTSCAParam::cBz
float cBz() const
Definition: PndFTSCAParam.h:49
PndFTSCAParam::fStations
FTSCAStation * fStations
Definition: PndFTSCAParam.h:126
FTSCAStation::xTimesRho
float xTimesRho
Definition: FTSCAStation.h:43
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
f
TFile * f
Definition: bump_analys.C:12
z
Double_t z
Definition: createRootFscGeometryFile.C:146
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
BinaryStoreRead
static void BinaryStoreRead(T *mem, int count, FILE *f)
Definition: BinaryStoreHelper.h:51
PndFTSCAParam::RestoreFromFile
void RestoreFromFile(FILE *f)
Definition: PndFTSCAParam.cxx:309
c1
c1
Definition: plot_dirc.C:35
L1FieldSlice::cy
float_v cy[21]
Definition: L1Field.h:67
PndFTSCAParam::CalculateFieldSlice
void CalculateFieldSlice(L1FieldSlice &fieldSlice, const float xMax, const float yMax, const float z)
Definition: PndFTSCAParam.cxx:91
dx
double dx
Definition: runGeaneTestSimBox.cxx:44
PndFTSCAParam::CheckFieldApproximation
void CheckFieldApproximation()
Definition: PndFTSCAParam.cxx:314
operator>>
TBuffer & operator>>(TBuffer &buf, PndAnaPidSelector *&obj)
Definition: PndAnaPidSelector.cxx:34
x
Double_t x
Definition: createRootFscGeometryFile.C:159
L1FieldSlice::cz
float_v cz[21]
Definition: L1Field.h:67
L1FieldSlice::cx
float_v cx[21]
Definition: L1Field.h:67
y
Double_t y
Definition: createRootFscGeometryFile.C:159
PndFTSCAParam::StoreToFile
void StoreToFile(FILE *f) const
Definition: PndFTSCAParam.cxx:304
TMatrixD
TMatrixT< double > TMatrixD
Definition: PndLmdDim.h:52
Generated on Wed Apr 3 2019 10:02:51 for FairRoot/PandaRoot by   doxygen 1.8.5