FEDRA emulsion software from the OPERA Collaboration
Public Member Functions | Public Attributes | Private Attributes | List of all members
EdbScanCond Class Reference

#include <EdbScanCond.h>

Inheritance diagram for EdbScanCond:
Inheritance graph
[legend]
Collaboration diagram for EdbScanCond:
Collaboration graph
[legend]

Public Member Functions

float BinTX () const
 
float BinTY () const
 
float BinX () const
 
float BinY () const
 
float Chi2Max () const
 
int Chi2Mode () const
 
float Chi2PMax () const
 
void DefineLLFunction (const char *str)
 
float Degrad () const
 
 EdbScanCond ()
 ============================================================================== More...
 
void FillErrorsCov (float tx, float ty, TMatrixD &cov)
 
float OffX () const
 
float OffY () const
 
void Print () const
 
float ProbLL (float t, float puls) const
 
float ProbLL (float tx, float ty, float puls) const
 
float ProbSeg (float t, float puls) const
 
float ProbSeg (float tx, float ty, float puls) const
 
float RadX0 () const
 
float Ramp (float x, float x1, float x2) const
 
void SetBins (float bx, float by, float btx, float bty)
 
void SetChi2Max (float chi2)
 
void SetChi2Mode (int mode)
 
void SetChi2PMax (float chi2)
 
void SetDefault ()
 
void SetDegrad (float d)
 
void SetOffset (float x, float y)
 
void SetPulsRamp0 (const char *str)
 
void SetPulsRamp0 (float p1, float p2)
 
void SetPulsRamp04 (const char *str)
 
void SetPulsRamp04 (float p1, float p2)
 
void SetRadX0 (float x0)
 
void SetSigma0 (const char *str)
 
void SetSigma0 (float x, float y, float tx, float ty)
 
void SetSigmaGR (float sx, float sy, float sz)
 
void SetSigmaZ0 (float z)
 
float SigmaTX (float ax) const
 
float SigmaTXf (float ax) const
 full functions for sigmaTX(TX) - use them for simulation More...
 
float SigmaTY (float ay) const
 
float SigmaTYf (float ay) const
 
float SigmaX (float ax) const
 
float SigmaXgr () const
 
float SigmaY (float ay) const
 
float SigmaYgr () const
 
float SigmaZ (float ax, float ay) const
 
float SigmaZgr () const
 
float StepTX (float tx) const
 
float StepTY (float ty) const
 
float StepX (float dz) const
 
float StepY (float dz) const
 
virtual ~EdbScanCond ()
 

Public Attributes

TF1 * eLikelihoodMT
 

Private Attributes

Float_t eBinTX
 
Float_t eBinTY
 
Float_t eBinX
 
Float_t eBinY
 
Float_t eChi2Max
 
Int_t eChi2Mode
 
Float_t eChi2PMax
 
Float_t eDegrad
 
Float_t eOffX
 
Float_t eOffY
 
Float_t ePuls0 [2]
 
Float_t ePuls04 [2]
 
Float_t eRadX0
 
Float_t eSigmaTX0
 
Float_t eSigmaTY0
 
Float_t eSigmaX0
 
Float_t eSigmaXgr
 
Float_t eSigmaY0
 
Float_t eSigmaYgr
 
Float_t eSigmaZ0
 
Float_t eSigmaZgr
 

Constructor & Destructor Documentation

◆ EdbScanCond()

EdbScanCond::EdbScanCond ( )

==============================================================================

11 {
12  SetDefault();
13 }
EdbScanCond::SetDefault
void SetDefault()
Definition: EdbScanCond.cxx:16

◆ ~EdbScanCond()

virtual EdbScanCond::~EdbScanCond ( )
inlinevirtual
53 {}

Member Function Documentation

◆ BinTX()

float EdbScanCond::BinTX ( ) const
inline
80 {return eBinTX;}
EdbScanCond::eBinTX
Float_t eBinTX
Definition: EdbScanCond.h:36

◆ BinTY()

float EdbScanCond::BinTY ( ) const
inline
81 {return eBinTY;}
EdbScanCond::eBinTY
Float_t eBinTY
Definition: EdbScanCond.h:36

◆ BinX()

float EdbScanCond::BinX ( ) const
inline
78 {return eBinX;}
EdbScanCond::eBinX
Float_t eBinX
Definition: EdbScanCond.h:35

◆ BinY()

float EdbScanCond::BinY ( ) const
inline
79 {return eBinY;}
EdbScanCond::eBinY
Float_t eBinY
Definition: EdbScanCond.h:35

◆ Chi2Max()

float EdbScanCond::Chi2Max ( ) const
inline
85 {return eChi2Max;}
EdbScanCond::eChi2Max
Float_t eChi2Max
Definition: EdbScanCond.h:38

◆ Chi2Mode()

int EdbScanCond::Chi2Mode ( ) const
inline
89 {return eChi2Mode;}
EdbScanCond::eChi2Mode
Int_t eChi2Mode
Definition: EdbScanCond.h:40

◆ Chi2PMax()

float EdbScanCond::Chi2PMax ( ) const
inline
86 {return eChi2PMax;}
EdbScanCond::eChi2PMax
Float_t eChi2PMax
Definition: EdbScanCond.h:39

◆ DefineLLFunction()

void EdbScanCond::DefineLLFunction ( const char *  str)
136 {
137  //get polinomial function parameters
138  if(!str) return;
139  SafeDelete(eLikelihoodMT);
140  eLikelihoodMT = new TF1("LikelihoodMT",str,0,2);
141  Log(2,"EdbScanCond::DefineLLFunction",str);
142 }
Log
bool Log(int level, const char *location, const char *fmt,...)
Definition: EdbLog.cxx:75
EdbScanCond::eLikelihoodMT
TF1 * eLikelihoodMT
Definition: EdbScanCond.h:49

◆ Degrad()

float EdbScanCond::Degrad ( ) const
inline
100 { return eDegrad; }
EdbScanCond::eDegrad
Float_t eDegrad
Definition: EdbScanCond.h:22

◆ FillErrorsCov()

void EdbScanCond::FillErrorsCov ( float  tx,
float  ty,
TMatrixD &  cov 
)
162 {
163  // Fill the non-diagonal covariance matrix of errors for the segment with angles tx,ty
164  // considering the input sigma being in the track plane (Y - is transversal axis)
165 
166  //TODO: remove EdbSegP::SetErrorsCOV
167 
168  float theta = Sqrt( tx*tx + ty*ty );
169  float sx = SigmaX(theta); //TODO the coord error can have different dependance on ang
170  float sy = SigmaY(0);
171  float stx = SigmaTX(theta);
172  float sty = SigmaTY(0);
173 
174  cov(0,0) = (double)(sx*sx);
175  cov(1,1) = (double)(sy*sy);
176  cov(2,2) = (double)(stx*stx);
177  cov(3,3) = (double)(sty*sty);
178  cov(4,4) = 1L; //TODO sp
179 
180  //double Phi = -ATan2(ty,tx); // "-" seems to be a bug
181  double Phi = ATan2(ty,tx);
182  TMatrixD t(5,5);
183  TMatrixD tt(5,5);
184  t(0,0) = Cos(Phi);
185  t(0,1) = -Sin(Phi);
186  t(1,0) = Sin(Phi);
187  t(1,1) = Cos(Phi);
188  t(2,2) = Cos(Phi);
189  t(2,3) = -Sin(Phi);
190  t(3,2) = Sin(Phi);
191  t(3,3) = Cos(Phi);
192  t(4,4) = 1.;
193  tt(0,0) = t(0,0);
194  tt(1,0) = t(0,1);
195  tt(0,1) = t(1,0);
196  tt(1,1) = t(1,1);
197  tt(2,2) = t(2,2);
198  tt(3,2) = t(2,3);
199  tt(2,3) = t(3,2);
200  tt(3,3) = t(3,3);
201  tt(4,4) = t(4,4);
202  cov = t*(cov*tt);
203 }
t
TTree * t
Definition: check_shower.C:4
EdbScanCond::SigmaTX
float SigmaTX(float ax) const
Definition: EdbScanCond.h:106
EdbScanCond::SigmaTY
float SigmaTY(float ay) const
Definition: EdbScanCond.h:107
EdbScanCond::SigmaX
float SigmaX(float ax) const
Definition: EdbScanCond.h:102
EdbScanCond::SigmaY
float SigmaY(float ay) const
Definition: EdbScanCond.h:103

◆ OffX()

float EdbScanCond::OffX ( ) const
inline
69 {return eOffX;}
EdbScanCond::eOffX
Float_t eOffX
Definition: EdbScanCond.h:42

◆ OffY()

float EdbScanCond::OffY ( ) const
inline
70 {return eOffY;}
EdbScanCond::eOffY
Float_t eOffY
Definition: EdbScanCond.h:42

◆ Print()

void EdbScanCond::Print ( ) const
51 {
52  printf( "******************************************************\n");
53  printf( "Scanning Conditions Parametres: %s\n", GetName() );
54  printf( "Sigma Grain: \t%f \t%f \t%f \n",
55  eSigmaXgr,eSigmaYgr,eSigmaZgr);
56  printf( "Sigma0 x,y,tx,ty: \t%f \t%f \t%f \t%f \n",
57  eSigmaX0,eSigmaY0,eSigmaTX0,eSigmaTY0);
58  printf( "Angular degradation: \t%f \n", eDegrad);
59  printf( "Acceptance bins: \t%f \t%f \t%f \t%f\n",BinX(),BinY(),BinTX(),BinTY());
60  printf( "Puls ramp at 0 angle: \t%f \t%f \n", ePuls0[0], ePuls0[1] );
61  printf( "Puls ramp at 0.4 angle: \t%f \t%f \n", ePuls04[0], ePuls04[1] );
62  printf( "Chi2Max: \t %f\n",Chi2Max());
63  printf( "Chi2PMax:\t %f\n",Chi2PMax());
64  printf( "eOffX = %f eOffY = %f\n",eOffX,eOffY);
65  printf( "******************************************************\n");
66 }
EdbScanCond::BinTX
float BinTX() const
Definition: EdbScanCond.h:80
EdbScanCond::eSigmaZgr
Float_t eSigmaZgr
Definition: EdbScanCond.h:19
EdbScanCond::ePuls0
Float_t ePuls0[2]
Definition: EdbScanCond.h:32
EdbScanCond::eSigmaX0
Float_t eSigmaX0
Definition: EdbScanCond.h:24
EdbScanCond::Chi2PMax
float Chi2PMax() const
Definition: EdbScanCond.h:86
EdbScanCond::eSigmaXgr
Float_t eSigmaXgr
Definition: EdbScanCond.h:17
EdbScanCond::eSigmaTY0
Float_t eSigmaTY0
Definition: EdbScanCond.h:28
EdbScanCond::Chi2Max
float Chi2Max() const
Definition: EdbScanCond.h:85
EdbScanCond::eSigmaYgr
Float_t eSigmaYgr
Definition: EdbScanCond.h:18
EdbScanCond::ePuls04
Float_t ePuls04[2]
Definition: EdbScanCond.h:33
EdbScanCond::BinTY
float BinTY() const
Definition: EdbScanCond.h:81
EdbScanCond::BinX
float BinX() const
Definition: EdbScanCond.h:78
EdbScanCond::BinY
float BinY() const
Definition: EdbScanCond.h:79
EdbScanCond::eSigmaTX0
Float_t eSigmaTX0
Definition: EdbScanCond.h:27
EdbScanCond::eSigmaY0
Float_t eSigmaY0
Definition: EdbScanCond.h:25

◆ ProbLL() [1/2]

float EdbScanCond::ProbLL ( float  t,
float  puls 
) const
152 {
153  // use eLikelihoodMT function
154  // TODO: to make this function statistically correct
155  if(!eLikelihoodMT) return 1;
156  Double_t ell = eLikelihoodMT->Eval( ATan(t) );
157  return 1./Exp( Abs(ell-ll) );
158 }

◆ ProbLL() [2/2]

float EdbScanCond::ProbLL ( float  tx,
float  ty,
float  puls 
) const
146 {
147  return ProbLL( Sqrt(tx*tx + ty*ty), ll);
148 }
EdbScanCond::ProbLL
float ProbLL(float tx, float ty, float puls) const
Definition: EdbScanCond.cxx:145

◆ ProbSeg() [1/2]

float EdbScanCond::ProbSeg ( float  t,
float  puls 
) const
127 {
128  // use linear puls ramp approximation
129  float pa1 = ePuls0[0] - t/.4*(ePuls0[0]-ePuls04[0]);
130  float pa2 = ePuls0[1] - t/.4*(ePuls0[1]-ePuls04[1]);
131  return Ramp(puls,pa1,pa2);
132 }
EdbScanCond::Ramp
float Ramp(float x, float x1, float x2) const
Definition: EdbScanCond.cxx:104

◆ ProbSeg() [2/2]

float EdbScanCond::ProbSeg ( float  tx,
float  ty,
float  puls 
) const
120 {
121  float t = Sqrt(tx*tx + ty*ty);
122  return ProbSeg(t, puls);
123 }
EdbScanCond::ProbSeg
float ProbSeg(float tx, float ty, float puls) const
Definition: EdbScanCond.cxx:119

◆ RadX0()

float EdbScanCond::RadX0 ( ) const
inline
58 {return eRadX0;}
EdbScanCond::eRadX0
Float_t eRadX0
Definition: EdbScanCond.h:45

◆ Ramp()

float EdbScanCond::Ramp ( float  x,
float  x1,
float  x2 
) const
105 {
106  //printf("%f %f %f\n",x,x1,x2);
107  float pmin=.01;
108  float pmax=1.;
109  if(x2<=x1) return 1.; //error value
110  if(x<x1) return pmin;
111  if(x>x2) return pmax;
112  float p = (x-x1)/(x2-x1);
113  if(p<pmin) return pmin;
114  if(p>pmax) return pmax;
115  return p;
116 }
p
p
Definition: testBGReduction_AllMethods.C:8

◆ SetBins()

void EdbScanCond::SetBins ( float  bx,
float  by,
float  btx,
float  bty 
)
inline
66  { eBinX=bx; eBinY=by; eBinTX=btx; eBinTY=bty; }

◆ SetChi2Max()

void EdbScanCond::SetChi2Max ( float  chi2)
inline
83 {eChi2Max=chi2;}
chi2
Float_t chi2
Definition: testBGReduction_By_ANN.C:14

◆ SetChi2Mode()

void EdbScanCond::SetChi2Mode ( int  mode)
inline
88 {eChi2Mode=mode;}

◆ SetChi2PMax()

void EdbScanCond::SetChi2PMax ( float  chi2)
inline
84 {eChi2PMax=chi2;}

◆ SetDefault()

void EdbScanCond::SetDefault ( )
17 {
18  eSigmaXgr= .1;
19  eSigmaYgr= .1;
20  eSigmaZgr= 3.;
21 
22  eDegrad = .6; // means that at .4 mrad degradation is 24 % in respect to 0 angle
23 
24  eSigmaX0 = 8.; // [microns]
25  eSigmaY0 = 8.; // [microns]
26  eSigmaZ0 = 3.; // [microns]
27  eSigmaTX0 = .008; // [mrad]
28  eSigmaTY0 = .008; // [mrad]
29 
30 
31  ePuls0[0] = 8; // microtrack puls height (grains)
32  ePuls0[1] = 10; // at 0 angle
33  ePuls04[0] = 5; // microtrack puls height (grains)
34  ePuls04[1] = 9; // at 0.4 rad angle
35  eBinX=eBinY = 3;
36  eBinTX=eBinTY = 3;
37 
38  eChi2Max = 3.5;
39  eChi2PMax = 3.5;
40  eChi2Mode = 0;
41  eOffX=0;
42  eOffY=0;
43 
44  eRadX0 = EdbPhysics::kX0_Cell();
45 
46  eLikelihoodMT=0;
47 }
EdbPhysics::kX0_Cell
static float kX0_Cell()
Definition: EdbPhys.h:24
EdbScanCond::eSigmaZ0
Float_t eSigmaZ0
Definition: EdbScanCond.h:26

◆ SetDegrad()

void EdbScanCond::SetDegrad ( float  d)
inline
71 {eDegrad=d;}
d
void d()
Definition: RecDispEX.C:381

◆ SetOffset()

void EdbScanCond::SetOffset ( float  x,
float  y 
)
inline
68 {eOffX=x; eOffY=y;}

◆ SetPulsRamp0() [1/2]

void EdbScanCond::SetPulsRamp0 ( const char *  str)
70 {
71  float p1,p2;
72  if(str) if( sscanf(str,"%f %f",&p1,&p2) == 2 ) {ePuls0[0]=p1; ePuls0[1]=p2;}
73 }

◆ SetPulsRamp0() [2/2]

void EdbScanCond::SetPulsRamp0 ( float  p1,
float  p2 
)
inline
74 {ePuls0[0]=p1; ePuls0[1]=p2;}

◆ SetPulsRamp04() [1/2]

void EdbScanCond::SetPulsRamp04 ( const char *  str)
76 {
77  float p1,p2;
78  if(str) if( sscanf(str,"%f %f",&p1,&p2) == 2 ) {ePuls04[0]=p1; ePuls04[1]=p2;}
79 }

◆ SetPulsRamp04() [2/2]

void EdbScanCond::SetPulsRamp04 ( float  p1,
float  p2 
)
inline
75 {ePuls04[0]=p1; ePuls04[1]=p2;}

◆ SetRadX0()

void EdbScanCond::SetRadX0 ( float  x0)
inline
57 {eRadX0=x0;}

◆ SetSigma0() [1/2]

void EdbScanCond::SetSigma0 ( const char *  str)
83 {
84  float x,y,tx,ty;
85  if( sscanf(str,"%f %f %f %f",&x,&y,&tx,&ty) == 4 )
86  {eSigmaX0=x; eSigmaY0=y; eSigmaTX0=tx; eSigmaTY0=ty;}
87 }

◆ SetSigma0() [2/2]

void EdbScanCond::SetSigma0 ( float  x,
float  y,
float  tx,
float  ty 
)
inline
63  { eSigmaX0=x; eSigmaY0=y; eSigmaTX0=tx; eSigmaTY0=ty; }

◆ SetSigmaGR()

void EdbScanCond::SetSigmaGR ( float  sx,
float  sy,
float  sz 
)
inline
61  { eSigmaXgr=sx; eSigmaYgr=sy; eSigmaZgr=sz; }

◆ SetSigmaZ0()

void EdbScanCond::SetSigmaZ0 ( float  z)
inline
72 {eSigmaZ0=z;}

◆ SigmaTX()

float EdbScanCond::SigmaTX ( float  ax) const
inline
106 { return eSigmaTX0*(1. + TMath::Abs(ax)*eDegrad); }

◆ SigmaTXf()

float EdbScanCond::SigmaTXf ( float  ax) const
inline

full functions for sigmaTX(TX) - use them for simulation

109 { return eSigmaTX0*TMath::Sqrt(1. + ax*ax*eDegrad*eDegrad); }

◆ SigmaTY()

float EdbScanCond::SigmaTY ( float  ay) const
inline
107 { return eSigmaTY0*(1. + TMath::Abs(ay)*eDegrad); }

◆ SigmaTYf()

float EdbScanCond::SigmaTYf ( float  ay) const
inline
110 { return eSigmaTY0*TMath::Sqrt(1. + ay*ay*eDegrad*eDegrad); }

◆ SigmaX()

float EdbScanCond::SigmaX ( float  ax) const
inline
102 { return eSigmaX0*(1. + TMath::Abs(ax)*eDegrad); }

◆ SigmaXgr()

float EdbScanCond::SigmaXgr ( ) const
inline
96 { return eSigmaXgr; }

◆ SigmaY()

float EdbScanCond::SigmaY ( float  ay) const
inline
103 { return eSigmaY0*(1. + TMath::Abs(ay)*eDegrad); }

◆ SigmaYgr()

float EdbScanCond::SigmaYgr ( ) const
inline
97 { return eSigmaYgr; }

◆ SigmaZ()

float EdbScanCond::SigmaZ ( float  ax,
float  ay 
) const
inline
105  { return eSigmaZ0; } // TODO

◆ SigmaZgr()

float EdbScanCond::SigmaZgr ( ) const
inline
98 { return eSigmaZgr; }

◆ StepTX()

float EdbScanCond::StepTX ( float  tx) const
inline
93 { return BinTX()*SigmaTX(tx); }

◆ StepTY()

float EdbScanCond::StepTY ( float  ty) const
inline
94 { return BinTY()*SigmaTY(ty); }

◆ StepX()

float EdbScanCond::StepX ( float  dz) const
91 {
92  float sigma = Sqrt( eSigmaX0*eSigmaX0 + eSigmaTX0*dz*eSigmaTX0*dz );
93  return eBinX*sigma;
94 }
dz
brick dz
Definition: RecDispMC.C:107

◆ StepY()

float EdbScanCond::StepY ( float  dz) const
98 {
99  float sigma = Sqrt( eSigmaY0*eSigmaY0 + eSigmaTY0*dz*eSigmaTY0*dz );
100  return eBinY*sigma;
101 }

Member Data Documentation

◆ eBinTX

Float_t EdbScanCond::eBinTX
private

◆ eBinTY

Float_t EdbScanCond::eBinTY
private

◆ eBinX

Float_t EdbScanCond::eBinX
private

◆ eBinY

Float_t EdbScanCond::eBinY
private

◆ eChi2Max

Float_t EdbScanCond::eChi2Max
private

◆ eChi2Mode

Int_t EdbScanCond::eChi2Mode
private

◆ eChi2PMax

Float_t EdbScanCond::eChi2PMax
private

◆ eDegrad

Float_t EdbScanCond::eDegrad
private

◆ eLikelihoodMT

TF1* EdbScanCond::eLikelihoodMT

◆ eOffX

Float_t EdbScanCond::eOffX
private

◆ eOffY

Float_t EdbScanCond::eOffY
private

◆ ePuls0

Float_t EdbScanCond::ePuls0[2]
private

◆ ePuls04

Float_t EdbScanCond::ePuls04[2]
private

◆ eRadX0

Float_t EdbScanCond::eRadX0
private

◆ eSigmaTX0

Float_t EdbScanCond::eSigmaTX0
private

◆ eSigmaTY0

Float_t EdbScanCond::eSigmaTY0
private

◆ eSigmaX0

Float_t EdbScanCond::eSigmaX0
private

◆ eSigmaXgr

Float_t EdbScanCond::eSigmaXgr
private

◆ eSigmaY0

Float_t EdbScanCond::eSigmaY0
private

◆ eSigmaYgr

Float_t EdbScanCond::eSigmaYgr
private

◆ eSigmaZ0

Float_t EdbScanCond::eSigmaZ0
private

◆ eSigmaZgr

Float_t EdbScanCond::eSigmaZgr
private
The documentation for this class was generated from the following files: