10 |
|
|
11 |
#include "TrkNucleiZCut.h" |
#include "TrkNucleiZCut.h" |
12 |
|
|
13 |
const float TrkNucleiZCut::_sigmaZ[] = { 0.09, 0.1, 0.17, 0.34, 0.44, 0.59 }; // the charge-width in a layer for Z=1..6 |
const float TrkNucleiZCut::_meanRigMean[] = { .992, 1.99, 3., 4., 5., 6. }; // the charge distribution peak for Z=1..6 |
14 |
|
const float TrkNucleiZCut::_sigmaRigMean[] = { 0.06, 0.1, 0.17, 0.34, 0.44, 0.59 }; // the charge-width for Z=1..6 |
15 |
|
|
16 |
|
const float TrkNucleiZCut::_meanBetaMean[] = { 1., 2., 3., 4., 5., 6. }; // the charge distribution peak for Z=1..6 |
17 |
|
const float TrkNucleiZCut::_sigmaBetaMean[] = { 0.09, 0.1, 0.17, 0.34, 0.44, 0.59 }; // the charge-width for Z=1..6 |
18 |
|
|
19 |
|
|
20 |
int TrkNucleiZCut::Check(PamLevel2 *event) { |
int TrkNucleiZCut::Check(PamLevel2 *event) { |
21 |
|
|
22 |
if (_Z < 1 || _Z > 6) |
if (_lowZ < 1 || _lowZ > 6) { |
23 |
return TRKNUCLEIZ_ILLEGALZ; |
return TRKNUCLEIZ_ILLEGALLOWZ; |
24 |
|
} |
25 |
|
if ((_highZ < (int) _lowZ && _highZ != -1) || _highZ > 6) { |
26 |
|
return TRKNUCLEIZ_ILLEGALLOWZ; |
27 |
|
} |
28 |
|
|
29 |
|
/* Check if we must perform a range selection */ |
30 |
|
bool range = false; |
31 |
|
if (_highZ != -1) |
32 |
|
range = true; |
33 |
|
|
34 |
// ******** Check if TrkNuclei has already been initialized ******** |
// ******** Check if TrkNuclei has already been initialized ******** |
35 |
if (_trkNuclei == NULL) |
if (_trkNuclei == NULL) |
53 |
// ******** Check the mean charge value ******** |
// ******** Check the mean charge value ******** |
54 |
if (_howToCheck == TRKNUCLEIZ_CHECKMEAN) { |
if (_howToCheck == TRKNUCLEIZ_CHECKMEAN) { |
55 |
|
|
56 |
Float_t charge; |
Float_t charge = 0., meanLowZ = 0., sigmaLowZ = 0., meanHighZ = 0., sigmaHighZ = 0.; |
57 |
|
; |
58 |
switch (_method) { |
switch (_method) { |
59 |
case TRKNUCLEIZ_DEFL: |
case TRKNUCLEIZ_RIG: |
60 |
charge = _trkNuclei->GetZ_Rigidity(); |
charge = _trkNuclei->GetZ_Rigidity(); |
61 |
|
meanLowZ = _meanRigMean[_lowZ - 1]; |
62 |
|
sigmaLowZ = _sigmaRigMean[_lowZ - 1]; |
63 |
|
if (range) { |
64 |
|
meanHighZ = _meanRigMean[_highZ - 1]; |
65 |
|
sigmaHighZ = _sigmaRigMean[_highZ - 1]; |
66 |
|
} |
67 |
break; |
break; |
68 |
case TRKNUCLEIZ_BETA: |
case TRKNUCLEIZ_BETA: |
69 |
charge = _trkNuclei->GetZ_Beta(event->GetTrack(0)->GetToFTrack()->beta[12]); |
charge = _trkNuclei->GetZ_Beta(event->GetTrack(0)->GetToFTrack()->beta[12]); |
70 |
|
meanLowZ = _meanBetaMean[_lowZ - 1]; |
71 |
|
sigmaLowZ = _sigmaBetaMean[_lowZ - 1]; |
72 |
|
if (range) { |
73 |
|
meanHighZ = _meanBetaMean[_highZ - 1]; |
74 |
|
sigmaHighZ = _sigmaBetaMean[_highZ - 1]; |
75 |
|
} |
76 |
|
|
77 |
break; |
break; |
78 |
} |
} |
79 |
|
|
80 |
if ((charge > _Z + _upperLimit * _sigmaZ[_Z - 1]) || (charge < _Z - _lowerLimit * _sigmaZ[_Z - 1])) { |
if (!range) { |
81 |
return TRKNUCLEIZ_OUTOFBOUNDS; |
if ((charge > meanLowZ + _upperLimit * sigmaLowZ) || (charge < meanLowZ - _lowerLimit * sigmaLowZ)) { |
82 |
|
return TRKNUCLEIZ_OUTOFBOUNDS; |
83 |
|
} |
84 |
|
} |
85 |
|
else { |
86 |
|
if ((charge > meanHighZ + _upperLimit * sigmaHighZ) || (charge < meanLowZ - _lowerLimit * sigmaLowZ)) { |
87 |
|
return TRKNUCLEIZ_OUTOFBOUNDS; |
88 |
|
} |
89 |
} |
} |
|
|
|
90 |
} |
} |
91 |
// ******** Check the charge value from each plane ******** |
// ******** Check the charge value from each plane ******** |
92 |
// NB. In current implementation only 2 check methods (mean and single values) are used, so an "else" statement |
// NB. In current implementation only 2 check methods (mean and single values) are used, so an "else" statement |
96 |
Float_t charge[6] = { 0., 0., 0., 0., 0., 0. }; |
Float_t charge[6] = { 0., 0., 0., 0., 0., 0. }; |
97 |
nValid = 0; |
nValid = 0; |
98 |
switch (_method) { |
switch (_method) { |
99 |
case TRKNUCLEIZ_DEFL: |
case TRKNUCLEIZ_RIG: |
100 |
for (int ip = 0; ip < 6; ip++) { |
for (int ip = 0; ip < 6; ip++) { |
101 |
charge[ip] = _trkNuclei->GetZ_Rigidity(ip); |
charge[ip] = _trkNuclei->GetZ_Rigidity(ip); |
102 |
if (charge[ip] > 0.) { |
if (charge[ip] > 0.) { |
115 |
} |
} |
116 |
|
|
117 |
for (int ip = 0; ip < 6; ip++) { |
for (int ip = 0; ip < 6; ip++) { |
118 |
if (charge[ip] > 0.) // Check only good layers |
if (charge[ip] > 0.) { // Check only good layers |
119 |
if ((charge[ip] > _Z + _upperLimit * _sigmaZ[_Z - 1]) || (charge[ip] < _Z - _lowerLimit * _sigmaZ[_Z - 1])) { |
// Currently, no calibration for single layers is available. Z is used as a mean value, while for sigma |
120 |
return TRKNUCLEIZ_OUTOFBOUNDS; |
// we use the standard values use for mean dE/dx Vs. beta. |
121 |
|
if (!range) { |
122 |
|
if ((charge[ip] > _lowZ + _upperLimit * _sigmaBetaMean[_lowZ - 1]) || (charge[ip] < _lowZ - _lowerLimit |
123 |
|
* _sigmaBetaMean[_lowZ - 1])) { |
124 |
|
return TRKNUCLEIZ_OUTOFBOUNDS; |
125 |
|
} |
126 |
|
} |
127 |
|
else { |
128 |
|
if ((charge[ip] > _highZ + _upperLimit * _sigmaBetaMean[_highZ - 1]) || (charge[ip] < _lowZ - _lowerLimit |
129 |
|
* _sigmaBetaMean[_lowZ - 1])) { |
130 |
|
return TRKNUCLEIZ_OUTOFBOUNDS; |
131 |
|
} |
132 |
} |
} |
133 |
|
} |
134 |
} |
} |
135 |
} |
} |
136 |
|
|