KVDetectorStack.cpp

#include "KVDetectorStack.h"
#include "KVDetector.h"
 
ClassImp(KVDetectorStack)
 
 
 
void KVDetectorStack::Add(KVDetector* D)
{
   fDetectors.Add(D);
}
 
 
 
 
void KVDetectorStack::Add(KVDetector& D)
{
   Add(&D);
}
 
 
 
 
Double_t KVDetectorStack::GetDeltaE(Int_t Z, Int_t A, Double_t Einc)
{
   // \return total energy loss in stack for given incident energy
 
   auto E0 = Einc;
   for (auto d : fDetectors) {
      E0 -= dynamic_cast<KVDetector*>(d)->GetTotalDeltaE(Z, A, E0);
      if (E0 <= 0)
         return Einc;
   }
   return Einc - E0;
}
 
 
 
 
Double_t KVDetectorStack::GetERes(Int_t Z, Int_t A, Double_t Einc)
{
   // \return residual energy after all detectors in stack
 
   return Einc - GetDeltaE(Z, A, Einc);
}
 
 
 
 
Double_t KVDetectorStack::GetDeltaEFromERes(Int_t Z, Int_t A, Double_t Eres)
{
   // \return total energy loss in stack given residual energy
 
   return GetIncidentEnergyFromERes(Z, A, Eres) - Eres;
}
 
 
 
 
Double_t KVDetectorStack::GetIncidentEnergyFromERes(Int_t Z, Int_t A, Double_t Eres, std::optional<int> layers)
{
   // \return incident energy for particle having residual energy after stack
   //
   // \param layers optional:
   //                 + layers<0 - ignore last abs(layers) detectors
   //                 + layers>0 - ignore first layers detectors
 
   auto ndets = fDetectors.GetEntries();
   bool ignore_some = layers.has_value();
   auto ignore_first = (ignore_some && layers.value() > 0) ? ndets - layers.value() : ndets;
   auto ignore_last = (ignore_some && layers.value() < 0) ? -layers.value() : 0;
 
   double Einc;
   TIter it(&fDetectors, kIterBackward);
   KVDetector* d;
   while ((d = (KVDetector*)it())) {
      if (ignore_last) {
         --ignore_last;
         continue;
      }
      if (!ignore_first)
         continue;
      --ignore_first;
      Einc = d->GetIncidentEnergyFromERes(Z, A, Eres);
      Eres = Einc;
   }
   return Einc;
}
 
 
 
 
Double_t KVDetectorStack::GetPunchThroughEnergy(Int_t Z, Int_t A)
{
   // \return punch through energy for particle
   //
   // This is the incident energy required to arrive just before the last detector
   // with the punch through energy for *that* detector, i.e. having that as residual
   // energy after passing all but the last layer of the stack
 
   auto eres = dynamic_cast<KVDetector*>(fDetectors.Last())->GetPunchThroughEnergy(Z, A);
   return GetIncidentEnergyFromERes(Z, A, eres, -1);
}
 
 
 
 
void KVDetectorStack::DetectParticle(KVNucleus& N, TVector3* norm)
{
   // Simulate passage of charged particle through the detector stack.
   //
   // Particle energy will decrease according to energy losses in detectors.
   //
   //If the optional argument 'norm' is given, it is supposed to be a vector
   //normal to the detectors in the stack, oriented from the origin towards the detectors.
   //In this case the effective thicknesses of the detector's absorbers 'seen' by the particle
   //depending on its direction of motion is used for the calculation.
 
   for (auto d : fDetectors) {
      dynamic_cast<KVDetector*>(d)->DetectParticle(&N, norm);
   }
}
 
 
 
 
void KVDetectorStack::Clear(Option_t* opt)
{
   // Calls KVDetector::Clear() for each detector in stack.
   for (auto d : fDetectors) {
      d->Clear(opt);
   }
}