KaliVeda
Toolkit for HIC analysis
KVINDRAForwardGroupReconstructor.cpp
1 //Created by KVClassFactory on Tue Feb 27 11:35:10 2018
2 //Author: John Frankland,,,
3 
4 #include "KVINDRAForwardGroupReconstructor.h"
5 #include "KVINDRACodeMask.h"
6 #include "KVIDGChIoSi.h"
7 #include "KVIDGCsI.h"
8 
9 #include <KVCsI.h>
10 #include <KVSilicon.h>
11 
13 
14 
15 
19 {
20  // Coherency analysis for forward rings 1-9 of INDRA
21 
22  bool ok = false;
23  if (PART.GetStoppingDetector()->IsType("CSI")) {
24  // particles stopping in CsI detectors
25  // check coherency of CsI-R/L and Si-CsI identifications
26  ok = CoherencySiCsI(PART);
27  // we check that the ChIo contribution is sane:
28  // if no other particles hit this group, the Z given by the ChIoSi
29  // must be <= the Z found from Si-CsI or CsI-RL identification
30  PART.SetParameter("UseFullChIoEnergyForCalib", CoherencyChIoSiCsI(PART));
31  }
32  else {
33  // particle stopped in Si (=> ChIo-Si) or ChIo (=> Zmin)
34  ok = PART.IsIdentified() && identifying_telescope;
35  PART.SetParameter("UseFullChIoEnergyForCalib", !(theChio && theChio->GetNHits() > 1));
36  }
37 
38  return ok;
39 }
40 
41 
42 
80 
82 {
83  // Special calibration for particles in rings 1 to 9
84  // We set the energy calibration code for the particle here:
85  //
86  //~~~{.cpp}
87  // KVINDRA::ECodes::NO_CALIBRATION_ATTEMPTED = 0, ///< particle stopped in detectors with no available calibration
88  // KVINDRA::ECodes::NORMAL_CALIBRATION = 1, ///< normal well-calibrated particle with no problems
89  // KVINDRA::ECodes::SOME_ENERGY_LOSSES_CALCULATED = 2, ///< particle calibration OK, with some detector energies calculated
90  // KVINDRA::ECodes::WARNING_CSI_MAX_ENERGY = 3, ///< particle calibration OK, although apparent energy would mean punching through the CsI
91  // KVINDRA::ECodes::BAD_CALIBRATION = 15 ///< calibration attempted but bad result (negative energies etc.)
92  //~~~
93  //
94  // The contributions from ChIo, Si, and CsI are stored in particle parameters
95  // INDRA.ECHIO, INDRA.ESI and INDRA.ECSI
96  // If the contribution is calculated rather than measured (see below), it is stored as a negative value.
97  // NOTE: in no case do we ever calculate an energy for uncalibrated detector using measured energy
98  // loss in the detector placed in front (i.e. calculate ECsI from deSi, or calculate ESi
99  // from deChIo) as this gives wildly varying (mostly false) results.
100  //
101  // For neutrons (IDCODE=1): if CsI is calibrated, we use the CsI light response to calculate
102  // the equivalent energy for a proton.
103  // For particles stopping in the CsI detector (IDCODE=2 or 3):
104  // - for "8Be" we use half the CsI light output to calculate 4He kinetic energy which is then doubled
105  // (we assume two 4He of identical energy), and ECODE=kECode2 (calculated)
106  // - if calibrated CsI energy is bizarre (<=0), we cannot calibrate the particle (ECODE=kECode15)
107  // - if the Silicon detector is not calibrated, or if coherency analysis indicates a pile-up
108  // in the silicon or other inconsistency, the Silicon energy is calculated from the calibrated
109  // CsI energy (ECODE=kECode2)
110  // - if the Ionisation Chamber is not calibrated, or if coherency analysis indicates a pile-up
111  // in the ChIo or other inconsistency, this contribution is calculated using the total
112  // cumulated energy measured in the CsI and/or Silicon detectors (ECODE=kECode2)
113  //
114  // For particles stopping in the Silicon detector (IDCODE=3, 4 or 5):
115  // - if no calibration exists for the Silicon, we cannot calibrate the particle (ECODE=kECode0)
116  // - if the Ionisation Chamber is not calibrated, or if coherency analysis indicates a pile-up
117  // in the ChIo or other inconsistency, this contribution is calculated using the total
118  // cumulated energy measured in the CsI and/or Silicon detectors (ECODE=kECode2)
119 
120  bool fUseFullChIoEnergyForCalib = PART->GetParameters()->GetBoolValue("UseFullChIoEnergyForCalib");
121  bool fPileup = PART->GetParameters()->GetBoolValue("Pileup");
122  bool fCoherent = PART->GetParameters()->GetBoolValue("Coherent");
123 
124  if (PART->GetIDCode() == KVINDRA::IDCodes::ID_NEUTRON) { // neutrons
125  DoNeutronCalibration(PART);
126  return;
127  }
128 
129  Bool_t stopped_in_silicon = kTRUE;
130 
131  auto si = GetSi(PART);
132  auto csi = GetCsI(PART);
133  if (csi) {
134  stopped_in_silicon = kFALSE;
135  if (csi->IsCalibrated() && csi->GetDetectorSignalValue("TotLight") > 0) {
136  /* CSI ENERGY CALIBRATION */
137  if (PART->GetIDCode() == KVINDRA::IDCodes::ID_CSI_PSA && PART->IsIsotope(4, 8)) {
139  }
140  else
141  fECsI = csi->GetCorrectedEnergy(PART, -1., kFALSE);
142  }
143  else if (si && !fPileup && fCoherent && si->IsCalibrated()) {
144  // use silicon energy to calculate CsI energy
145  fESi = si->GetCorrectedEnergy(PART);
146  if (fESi <= 0) {
147  // problem with silicon calibration
149  return;
150  }
151  fECsI = si->GetEResFromDeltaE(PART->GetZ(), PART->GetA());
152  // sanity check: very small DE can give very large Eres
153  auto de_max = csi->GetMaxDeltaE(PART->GetZ(), PART->GetA());
154  if (fECsI > de_max)
156  else
158  fECsI = -fECsI;
159  }
160  else {
161  SetNoCalibrationStatus(PART);// no CsI calibration - no calibration performed
162  return;
163  }
164  if (fECsI <= 0 && (PART->GetECode() != KVINDRA::ECodes::SOME_ENERGY_LOSSES_CALCULATED)) { // DoBeryllium8Calibration returns fECsI<0 with ECode=SOME_ENERGY_LOSSES_CALCULATED if OK
165  SetBadCalibrationStatus(PART);// problem with CsI energy - no calibration
166  return;
167  }
168  }
169  if (si) {
170  /* SILICIUM ENERGY CONTRIBUTION */
171  // if fPileup = kTRUE, the Silicon energy appears to include a contribution from another particle
172  // therefore we have to estimate the silicon energy for this particle using the CsI energy
173  // if fCoherent = kFALSE, the Silicon energy is too small to be consistent with the CsI identification,
174  // therefore we have to estimate the silicon energy for this particle using the CsI energy
175 
176  if (PART->GetIDCode() == KVINDRA::IDCodes::ID_STOPPED_IN_FIRST_STAGE && stopped_in_silicon) {
177  // particles stopped in Silicon detectors with no identification except estimation of Zmin (case of INDRA without Ionization Chambers):
178  // if silicon is calibrated, give measured energy in silicon as particle energy
179  if (si->IsCalibrated())
180  PART->SetEnergy(si->GetEnergy());
181  else
183  return;
184  }
185 
186  if (!fPileup && fCoherent && si->IsCalibrated()) {
187  // all is apparently well. use full energy deposited in silicon.
188  Bool_t si_transmission = kTRUE;
189  if (stopped_in_silicon) {
190  si_transmission = kFALSE;
191  }
192  else {
193  si->SetEResAfterDetector(TMath::Abs(fECsI));
194  }
195  fESi = si->GetCorrectedEnergy(PART, -1., si_transmission);
196  if (fESi <= 0) {
197  // problem with silicon calibration
198  print_part = true;
199  if (!stopped_in_silicon && (TMath::Abs(fECsI) > 0.0)) {
200  if (!CalculateSiliconDEFromResidualEnergy(PART, si)) return;
201  }
202  else {
203  // stopped in Si with bad Si calibration - no good
205  return;
206  }
207  }
208  }
209  else {
210  if (!stopped_in_silicon && (TMath::Abs(fECsI) > 0.0)) {
211  if (!CalculateSiliconDEFromResidualEnergy(PART, si)) return;
212  }
213  else {
214  // cannot calibrate particle stopping in silicon in this case
216  return;
217  }
218  }
219 
220  }
221  if (theChio) {
222  /* CHIO ENERGY CONTRIBUTION */
223  // if fUseFullChIoEnergyForCalib = kFALSE, we have to estimate the ChIo energy for this particle
225  if (fUseFullChIoEnergyForCalib && theChio->IsCalibrated()) {
226  // all is apparently well
227  if (!PART->GetStoppingDetector()->IsType("CI")) {
228  theChio->SetEResAfterDetector(ERES);
229  fEChIo = theChio->GetCorrectedEnergy(PART);
230  }
231  else {
232  // particle stopped in chio, not in transmission
233  fEChIo = theChio->GetCorrectedEnergy(PART, -1., kFALSE);
234  }
235  if (fEChIo < 0.) {
236  // bad chio calibration
237  if (!PART->GetStoppingDetector()->IsType("CI") && (ERES > 0.0)) {
238  if (!CalculateChIoDEFromResidualEnergy(PART, ERES)) return;
239  }
240  }
241  }
242  else {
243  if (!PART->GetStoppingDetector()->IsType("CI") && (ERES > 0.0)) {
244  if (!CalculateChIoDEFromResidualEnergy(PART, ERES)) return;
245  }
246  else {
247  // particle stopped in ChIo, no calibration available
249  return;
250  }
251  }
252  }
254 }
255 
256 
257 
258 
262 
264 {
265  // use energy of CsI calculated using the Z & A of the CsI identification
266  // to calculate the energy deposited by the neutron
268  KVNucleus tmp(IDcsi->Z, IDcsi->A);
269  auto csi = GetCsI(PART);
270  if (csi && csi->IsCalibrated()) {
271  fECsI = csi->GetCorrectedEnergy(&tmp, -1., kFALSE);
272  PART->SetEnergy(fECsI);
273  SetCalibrationStatus(*PART, KVINDRA::ECodes::SOME_ENERGY_LOSSES_CALCULATED); // not a real energy measure
274  }
275  else
277 }
278 
279 
280 
281 
293 
295 {
296  // Called by DoCoherency() for particles stopping in CsI detectors on rings 2-9,
297  // which have a ChIo in front of them.
298  //
299  // we check that the ChIo contribution is sane:
300  // if no other particles hit this group, the Z given by the ChIoSi
301  // must be <= the Z found from Si-CsI or CsI-RL identification
302  //
303  // in this case the measured energy loss of the ChIo can be solely attributed to this particle
304  // and we return kTRUE;
305 
306  // ChIo was hit by more than one particle in group
307  if (theChio && theChio->GetNHits() > 1) {
308  return kFALSE;
309  }
310 
312  if (!IDchiosi->IDattempted) {
313  // no ChIo-Si identification ? assume coherency ?
314  return kTRUE;
315  }
316 
317  // if we have a successful ChIo-Si id with a Z > Z given by CsI or Si-CsI id,
318  // then we consider that there is a pile-up in the ChIo
319  // note that we consider Z_ChIoSi = 1 to mean the ChIo is in the pedestal i.e. nothing seen
320  // we also require the chio-si identification to be above the punch-through line
321  if (IDchiosi->IDOK && IDchiosi->Z > 1 && IDchiosi->IDquality != KVIDGChIoSi::k_BelowPunchThrough && IDchiosi->Z > partID.Z) {
322  return kFALSE;
323  }
324 
325  return kTRUE;
326 }
327 
328 
329 
342 
344 {
345  // Called by DoCoherency() for particles stopping in CsI detectors on rings 1-9,
346  // which have a Silicon detector just in front of them.
347  //
348  // coherent = kFALSE if CsI-R/L and Si-CsI identifications are not coherent.
349  // this is a warning, the CsI identification is kept, either the Si signal
350  // was not good (particle hitting dead zone), or it actually corresponds
351  // to two particles reaching the CsI at the same time
352  // pileup = kTRUE means that the particle identified in CsI-R/L is correct,
353  // and there is probably a second particle which stopped in the silicon
354  // detector at the same time, to be identified in ChIo-Si after
355  // subtraction of the Silicon contribution
356 
361  bool fCoherent = kTRUE;
362  bool fPileup = kFALSE;
363 
364  // Unsuccessful/no CsI id attempt with successful Si-CsI id ?
365  // Then use Si-CsI identification result
366  if (IDsicsi->IDOK && !IDcsi->IDOK) {
367  partID = *IDsicsi;
368  identifying_telescope = idt_sicsi;
369  PART.SetParameter("Coherent", fCoherent);
370  PART.SetParameter("Pileup", fPileup);
371  return kTRUE;
372  }
373 
374  // check coherency of CsI-R/L and Si-CsI identifications
375  if (IDcsi->IDOK) {
376  partID = *IDcsi;
377  identifying_telescope = idt_csi;
378 
379  // Neutrons have no energy loss in Si detector (pedestal), have a reaction in the CsI and create a Z=1
380  // or Z=2 which is identified in CsI R-L, while they show up in Si-CsI maps as a horizontal
381  // band around the Si pedestal for low energies (energies where proton dE is significantly larger than
382  // the pedestal).
383  if ((IDcsi->Z == 1 || IDcsi->Z == 2) && IDsicsi->IDattempted) {
385  // explicit treatment of 'neutron-like' particles with a cut in Si-CsI id grid
386  partID = *IDsicsi;
387  identifying_telescope = idt_sicsi;
388  partID.IDOK = kTRUE;
389  partID.Zident = kTRUE;
390  partID.Aident = kTRUE;
391  partID.Z = 0;
392  partID.A = 1;
393  partID.IDcode = KVINDRA::IDCodes::ID_NEUTRON; // general code for neutrons
394  PART.SetParameter("Coherent", fCoherent);
395  PART.SetParameter("Pileup", fPileup);
396  return kTRUE;
397  }
398  }
399 
400  // We check the coherency of the mass and charge identifications
401  // If a successful Si-CsI identification is available we check:
402  // if Si-CsI gives A & Z - must have same Z, A within +/-1 unit
403  // if Z or A smaller => incoherency : pile-up of two particles in CsI ?
404  // or bad signal from Si detector (dead zones) ?
405  // if Z or A larger, CsI identification is good,
406  // assume another particle stopped in Si (identify in ChIo-Si)
407  // if Si-CsI gives just Z - must have same Z
408  // if Z smaller => incoherency : pile-up of two particles in CsI ?
409  // or bad signal from Si detector (dead zones) ?
410  // if Z larger => CsI identification is good,
411  // assume another particle stopped in Si (identify in ChIo-Si)
412  //
413  // If CsI identification gives code KVIDGCsI::kICode1 ou KVIDGCsI::kICode3 and the
414  // Si-CsI gives the same Z but A = Acsi + 1, we use the Si-CsI identification.
415  //
416  // If CsI identification gives code KVIDGCsI::kICode2 ou KVIDGCsI::kICode3 and the
417  // Si-CsI gives the same Z but A = Acsi - 1, we use the Si-CsI identification.
418  //
419  // N.B. if CsI-R/L identification gives "8Be" (2 alpha particles) then there are two correct possibilities:
420  // 1) Si-CsI identification gives 7Li => CsI identification is correct ("8Be")
421  // 2) Si-CsI identification gives 8He => the particle is 8He (falls on same R/L line as 2*alpha)
422  // Seeing the very low statistics for 8He compared to 8Be/2alpha, we assume that if Si-CsI id
423  // gives something above 8He it is either incoherent (below 7Li) or 8Be + something else in ChIo-Si
424  // (above 7Li).
425  Int_t Zref = IDcsi->Z;
426  Int_t Aref = IDcsi->A;
427  if (IDsicsi->IDOK) {
428  if (IDsicsi->Aident) { // Si-CsI provides mass identification
429 
430  if (IDcsi->Z == 4 && IDcsi->A == 8) {
431  // traitement special 8Be
432  // if sicsi => 7Li, it is 8Be (2alpha)
433  // if sicsi => 8He, it is 8He
434  if (IDsicsi->Z < 2 || (IDsicsi->Z == 2 && IDsicsi->A < 7)) {
435  fCoherent = kFALSE;
436  IDsicsi->SetComment("CsI-R/L & Si-CsI identifications not coherent");
437  PART.SetParameter("Coherent", fCoherent);
438  PART.SetParameter("Pileup", fPileup);
439  return kTRUE;
440  }
441  else if (IDsicsi->Z == 2 && IDsicsi->A > 6 && IDsicsi->A < 10) {
442  // accept helium-7,8,9 as 8He
443  partID = *IDsicsi;
444  identifying_telescope = idt_sicsi;
445  PART.SetParameter("Coherent", fCoherent);
446  PART.SetParameter("Pileup", fPileup);
447  return kTRUE;
448  }
449  else if ((IDsicsi->Z == 2 && IDsicsi->A > 9) || (IDsicsi->Z == 3 && IDsicsi->A < 6)) {
450  fCoherent = kFALSE;
451  IDsicsi->SetComment("CsI-R/L & Si-CsI identifications not coherent");
452  PART.SetParameter("Coherent", fCoherent);
453  PART.SetParameter("Pileup", fPileup);
454  return kTRUE;
455  }
456  else if (IDsicsi->Z == 3 && IDsicsi->A > 5 && IDsicsi->A < 9) {
457  // accept lithium-6,7,8 as 7Li
458  PART.SetParameter("Coherent", fCoherent);
459  PART.SetParameter("Pileup", fPileup);
460  return kTRUE;
461  }
462  else if ((IDsicsi->Z == 3 && IDsicsi->A > 8) || IDsicsi->Z > 3) {
463  fPileup = kTRUE;
464  IDsicsi->SetComment("Second particle stopping in Si, identification ChIo-Si required");
465  PART.SetParameter("Coherent", fCoherent);
466  PART.SetParameter("Pileup", fPileup);
467  return kTRUE;
468  }
469  }
470  // if CsI says A could be bigger and Si-CsI gives same Z and A+1, use Si-CsI
471  if ((IDsicsi->Z == Zref) && (IDsicsi->A == (Aref + 1))
472  && (IDcsi->IDquality == KVIDGCsI::kICODE1 || IDcsi->IDquality == KVIDGCsI::kICODE3)) {
473  partID = *IDsicsi;
474  identifying_telescope = idt_sicsi;
475  PART.SetParameter("Coherent", fCoherent);
476  PART.SetParameter("Pileup", fPileup);
477  return kTRUE;
478  }
479  // if CsI says A could be smaller and Si-CsI gives same Z and A-1, use Si-CsI
480  if ((IDsicsi->Z == Zref) && (IDsicsi->A == (Aref - 1))
481  && (IDcsi->IDquality == KVIDGCsI::kICODE2 || IDcsi->IDquality == KVIDGCsI::kICODE3)) {
482  partID = *IDsicsi;
483  identifying_telescope = idt_sicsi;
484  PART.SetParameter("Coherent", fCoherent);
485  PART.SetParameter("Pileup", fPileup);
486  return kTRUE;
487  }
488  // everything else - Z must be same, A +/- 1 unit
489  if (IDsicsi->Z == Zref && TMath::Abs(IDsicsi->A - Aref) < 2) {
490  PART.SetParameter("Coherent", fCoherent);
491  PART.SetParameter("Pileup", fPileup);
492  return kTRUE;
493  }
494  else if (IDsicsi->Z < Zref || (IDsicsi->Z == Zref && IDsicsi->A < (Aref - 1))) {
495  fCoherent = kFALSE;
496  IDsicsi->SetComment("CsI-R/L & Si-CsI identifications not coherent");
497  PART.SetParameter("Coherent", fCoherent);
498  PART.SetParameter("Pileup", fPileup);
499  return kTRUE;
500  }
501  else if (IDsicsi->Z > Zref || (IDsicsi->Z == Zref && IDsicsi->A > (Aref + 1))) {
502  fPileup = kTRUE;
503  IDsicsi->SetComment("Second particle stopping in Si, identification ChIo-Si required");
504  PART.SetParameter("Coherent", fCoherent);
505  PART.SetParameter("Pileup", fPileup);
506  return kTRUE;
507  }
508  }
509  else { // only Z identification from Si-CsI
510  if (IDcsi->Z == 4 && IDcsi->A == 8) {
511  // traitement special 8Be
512  // we ask for Z to be equal 3 in SiCsI, but with no mass identification
513  // we do not try for 8He identification
514  if (IDsicsi->Z < 3) {
515  fCoherent = kFALSE;
516  IDsicsi->SetComment("CsI-R/L & Si-CsI identifications not coherent");
517  PART.SetParameter("Coherent", fCoherent);
518  PART.SetParameter("Pileup", fPileup);
519  return kTRUE;
520  }
521  else if (IDsicsi->Z == 3) {
522  PART.SetParameter("Coherent", fCoherent);
523  PART.SetParameter("Pileup", fPileup);
524  return kTRUE;
525  }
526  else {
527  fPileup = kTRUE;
528  IDsicsi->SetComment("Second particle stopping in Si, identification ChIo-Si required");
529  PART.SetParameter("Coherent", fCoherent);
530  PART.SetParameter("Pileup", fPileup);
531  return kTRUE;
532  }
533  }
534  // everything else
535  if (IDsicsi->Z == Zref) {
536  PART.SetParameter("Coherent", fCoherent);
537  PART.SetParameter("Pileup", fPileup);
538  return kTRUE;
539  }
540  else if (IDsicsi->Z < Zref) {
541  fCoherent = kFALSE;
542  IDsicsi->SetComment("CsI-R/L & Si-CsI identifications not coherent");
543  PART.SetParameter("Coherent", fCoherent);
544  PART.SetParameter("Pileup", fPileup);
545  return kTRUE;
546  }
547  else {
548  fPileup = kTRUE;
549 
550  IDsicsi->SetComment("Second particle stopping in Si, identification ChIo-Si required");
551  PART.SetParameter("Coherent", fCoherent);
552  PART.SetParameter("Pileup", fPileup);
553  return kTRUE;
554  }
555  }
556  }
557  else if (IDsicsi->IDattempted && (IDsicsi->IDquality == 4 || IDsicsi->IDquality == 5)) {
558  // "noise" in between Si-CsI identification lines => pile-up with good particle
559  // in CsI plus another particle stopped in the Silicon
560  if (IDsicsi->Z < Zref) fCoherent = kFALSE;
561  else fPileup = kTRUE;
562  }
563  else if (IDsicsi->IDattempted && IDsicsi->IDquality == 7) {
564  // Point to identify in Si-CsI matrix is above the last line in the grid
565  // Z given to identification result is Zmin = lastZ + 1
566  // if this is > Z from CsI identification, pileup in Si
567  if (IDsicsi->Z > Zref) fPileup = kTRUE;
568  }
569  PART.SetParameter("Coherent", fCoherent);
570  PART.SetParameter("Pileup", fPileup);
571  return kTRUE;
572  }
573  PART.SetParameter("Coherent", fCoherent);
574  PART.SetParameter("Pileup", fPileup);
575  return kFALSE;
576 }
577 
578 
579 
589 
591 {
592  // calculate fESi from fECsI
593  // returns kTRUE if OK
594  //
595  // this sets directly the value of fESi
596  //
597  // if result is not good, bad calibration status is set for particle and we return false: in this case fESi=0
598  //
599  // if result is good, particle calibration status set to SOME_ENERGY_LOSSES_CALCULATED and fESi<0
600 
601  Double_t e0 = si->GetDeltaEFromERes(n->GetZ(), n->GetA(), TMath::Abs(fECsI));
602  si->SetEResAfterDetector(TMath::Abs(fECsI));
603  fESi = si->GetCorrectedEnergy(n, e0);
604  if (fESi <= 0) {
605  // can't calculate fESi from CsI energy - bad
607  fESi = 0;
608  return kFALSE;
609  }
610  else {
611  // calculated energy: negative
612  fESi = -TMath::Abs(fESi);
613  SetCalibrationStatus(*n, KVINDRA::ECodes::SOME_ENERGY_LOSSES_CALCULATED);
614  }
615  return kTRUE;
616 }
617 
618 
619 
int Int_t
bool Bool_t
constexpr Bool_t kFALSE
double Double_t
constexpr Bool_t kTRUE
virtual const Char_t * GetType() const
Definition: KVBase.h:176
const KVSeqCollection * GetIDTelescopes() const
KVIDTelescope * identifying_telescope
telescope which identified current particle
void SetCalibrationStatus(KVReconstructedNucleus &PART, UShort_t code)
KVIdentificationResult partID
identification to be applied to current particle
@ k_BelowPunchThrough
Definition: KVIDGChIoSi.h:77
Base class for all detectors or associations of detectors in array which can identify charged particl...
Definition: KVIDTelescope.h:84
Reconstruct data in rings 1-9 of INDRA.
Bool_t CalculateSiliconDEFromResidualEnergy(KVReconstructedNucleus *n, KVDetector *si)
void DoNeutronCalibration(KVReconstructedNucleus *PART)
Bool_t CoherencyChIoSiCsI(KVReconstructedNucleus &PART)
void DoCalibration(KVReconstructedNucleus *PART) override
KVDetector * GetSi(KVReconstructedNucleus *n)
Bool_t CoherencySiCsI(KVReconstructedNucleus &PART)
void SetNoCalibrationStatus(KVReconstructedNucleus *n)
Bool_t CalculateChIoDEFromResidualEnergy(KVReconstructedNucleus *n, Double_t ERES)
double DoBeryllium8Calibration(KVReconstructedNucleus *n)
KVDetector * GetCsI(KVReconstructedNucleus *n)
void SetBadCalibrationStatus(KVReconstructedNucleus *n)
KVDetector * theChio
the ChIo of the group
@ WARNING_CSI_MAX_ENERGY
particle calibration OK, although apparent energy would mean punching through the CsI
Definition: KVINDRA.h:176
@ SOME_ENERGY_LOSSES_CALCULATED
particle calibration OK, with some detector energies calculated
Definition: KVINDRA.h:175
Full result of one attempted particle identification.
Bool_t IDattempted
=kTRUE if identification was attempted
Bool_t IDOK
general quality of identification, =kTRUE if acceptable identification made
void SetComment(const Char_t *c)
Bool_t Aident
= kTRUE if A of particle established
Int_t deltaEpedestal
special code for handling particles which give no signal in deltaE
Int_t A
A of particle found (if Aident==kTRUE)
Int_t Z
Z of particle found (if Zident==kTRUE)
Int_t IDquality
specific quality code returned by identification procedure
Int_t IDcode
a general identification code for this type of identification
Bool_t Zident
=kTRUE if Z of particle established
Bool_t GetBoolValue(const Char_t *name) const
Description of properties and kinematics of atomic nuclei.
Definition: KVNucleus.h:123
Int_t GetA() const
Definition: KVNucleus.cpp:792
Bool_t IsIsotope(Int_t Z, Int_t A) const
Definition: KVNucleus.h:330
Int_t GetZ() const
Return the number of proton / atomic number.
Definition: KVNucleus.cpp:763
KVNameValueList * GetParameters() const
Definition: KVParticle.h:818
void SetParameter(const Char_t *name, ValType value) const
Definition: KVParticle.h:822
void SetEnergy(Double_t e)
Definition: KVParticle.h:602
Nuclei reconstructed from data measured by a detector array .
virtual Int_t GetECode() const
KVIdentificationResult * GetIdentificationResult(Int_t i)
const KVReconNucTrajectory * GetReconstructionTrajectory() const
virtual Int_t GetIDCode() const
KVDetector * GetStoppingDetector() const
void SetDetector(int i, KVDetector *);
virtual TObject * FindObjectByType(const Char_t *) const
const Int_t n
Double_t Abs(Double_t d)
ClassImp(TPyArg)