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
 the likelihood function used for microtrack probablility estimation More...
 

Private Attributes

Float_t eBinTX
 
Float_t eBinTY
 
Float_t eBinX
 
Float_t eBinY
 bins [normalized to Sigma()] More...
 
Float_t eChi2Max
 
Int_t eChi2Mode
 mode of coupling chi2 calculation (default is 0) More...
 
Float_t eChi2PMax
 
Float_t eDegrad
 segment: More...
 
Float_t eOffX
 
Float_t eOffY
 
Float_t ePuls0 [2]
 puls height parametrizations: More...
 
Float_t ePuls04 [2]
 
Float_t eRadX0
 radiation length for ECC media [microns] More...
 
Float_t eSigmaTX0
 ["rad"] More...
 
Float_t eSigmaTY0
 ["rad"] More...
 
Float_t eSigmaX0
 [microns] Parameters at 0 angle More...
 
Float_t eSigmaXgr
 grain: More...
 
Float_t eSigmaY0
 [microns] SigmaX = S0*(1+eDegrad*Ax) More...
 
Float_t eSigmaYgr
 
Float_t eSigmaZ0
 z - uncertancy More...
 
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
bins [normalized to Sigma()]
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
mode of coupling chi2 calculation (default is 0)
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)

get polinomial function parameters

136{
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
the likelihood function used for microtrack probablility estimation
Definition: EdbScanCond.h:49

◆ Degrad()

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

◆ FillErrorsCov()

void EdbScanCond::FillErrorsCov ( float  tx,
float  ty,
TMatrixD &  cov 
)

Fill the non-diagonal covariance matrix of errors for the segment with angles tx,ty considering the input sigma being in the track plane (Y - is transversal axis)

tTODO: remove EdbSegP::SetErrorsCOV

162{
165
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}
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
t
TTree * t
Definition: check_shower.C:4

◆ 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]
puls height parametrizations:
Definition: EdbScanCond.h:32
EdbScanCond::eSigmaX0
Float_t eSigmaX0
[microns] Parameters at 0 angle
Definition: EdbScanCond.h:24
EdbScanCond::Chi2PMax
float Chi2PMax() const
Definition: EdbScanCond.h:86
EdbScanCond::eSigmaXgr
Float_t eSigmaXgr
grain:
Definition: EdbScanCond.h:17
EdbScanCond::eSigmaTY0
Float_t eSigmaTY0
["rad"]
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
["rad"]
Definition: EdbScanCond.h:27
EdbScanCond::eSigmaY0
Float_t eSigmaY0
[microns] SigmaX = S0*(1+eDegrad*Ax)
Definition: EdbScanCond.h:25

◆ ProbLL() [1/2]

float EdbScanCond::ProbLL ( float  t,
float  puls 
) const

use eLikelihoodMT function tTODO: to make this function statistically correct

152{
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

use linear puls ramp approximation

127{
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
radiation length for ECC media [microns]
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:25
EdbScanCond::eSigmaZ0
Float_t eSigmaZ0
z - uncertancy
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

bins [normalized to Sigma()]

◆ eChi2Max

Float_t EdbScanCond::eChi2Max
private

◆ eChi2Mode

Int_t EdbScanCond::eChi2Mode
private

mode of coupling chi2 calculation (default is 0)

◆ eChi2PMax

Float_t EdbScanCond::eChi2PMax
private

◆ eDegrad

Float_t EdbScanCond::eDegrad
private

segment:

angular degradation of parameters: S = S0*(1 + eDegrad*Ang)

◆ eLikelihoodMT

TF1* EdbScanCond::eLikelihoodMT

the likelihood function used for microtrack probablility estimation

◆ eOffX

Float_t EdbScanCond::eOffX
private

◆ eOffY

Float_t EdbScanCond::eOffY
private

maximal offsets in x and y - the accuracy of pattern itself in respect to the upper level RS

◆ ePuls0

Float_t EdbScanCond::ePuls0[2]
private

puls height parametrizations:

signal/all is parametrised as linear in range Pmin,Pmax

◆ ePuls04

Float_t EdbScanCond::ePuls04[2]
private
  • at angle .4 rad

◆ eRadX0

Float_t EdbScanCond::eRadX0
private

radiation length for ECC media [microns]

◆ eSigmaTX0

Float_t EdbScanCond::eSigmaTX0
private

["rad"]

◆ eSigmaTY0

Float_t EdbScanCond::eSigmaTY0
private

["rad"]

◆ eSigmaX0

Float_t EdbScanCond::eSigmaX0
private

[microns] Parameters at 0 angle

◆ eSigmaXgr

Float_t EdbScanCond::eSigmaXgr
private

grain:

Keep the accuracy parameters for 1 pattern/layer

◆ eSigmaY0

Float_t EdbScanCond::eSigmaY0
private

[microns] SigmaX = S0*(1+eDegrad*Ax)

◆ eSigmaYgr

Float_t EdbScanCond::eSigmaYgr
private

◆ eSigmaZ0

Float_t EdbScanCond::eSigmaZ0
private

z - uncertancy

◆ eSigmaZgr

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