KVReconstructedNucleus.h

#ifndef KVRECONSTRUCTEDNUCLEUS_H
#define KVRECONSTRUCTEDNUCLEUS_H
 
#include "KVNucleus.h"
#include "KVHashList.h"
#include "KVList.h"
#include "KVDetector.h"
#include "KVIDTelescope.h"
#include "KVIdentificationResult.h"
#include "KVGroup.h"
#include "TClonesArray.h"
#include "KVReconNucTrajectory.h"
 
class KVReconstructedNucleus: public KVNucleus {
 
protected:
    const KVReconNucTrajectory* fReconTraj;
    KVString fDetNames;
    KVHashList fDetList;
    KVString fIDTelName;
    KVIDTelescope* fIDTelescope;
 
   enum {
      kIsIdentified = BIT(18),  //flag set when identification of particle is complete
      kIsCalibrated = BIT(19),   //flag set when energy calibration of particle is complete
      kCoherency = BIT(20),   //particle created and/or identified by analysis of energy losses of other particles
      kZMeasured = BIT(21),   //the Z attributed to this nucleus was measured
      kAMeasured = BIT(22)   //the A attributed to this nucleus was measured
   };
 
    Int_t fNSegDet;
    Int_t fAnalStatus;
    Float_t fRealZ;
    Float_t fRealA;
    Double_t fTargetEnergyLoss;
 
    TClonesArray fIDResults;
 
   void MakeDetectorList();
public:
   void RebuildReconTraj(bool in_streamer = true);
   void ReplaceReconTraj(const TString& traj_name);
 
   enum {
      kStatusOK,           // = 0 :   identification is, in principle at least, possible straight away
      kStatusOKafterSub,   // = 1 :   identification is, in principle, possible after identification and subtraction
      kStatusOKafterShare, // = 2 :   the energy loss in the shared detector of the group must be shared
      kStatusStopFirstStage,//= 3 :   the particle has stopped in the first member of an identification
      kStatusPileupDE,     // = 4 :   only for filtered simulations: undetectable pile-up in DE detector
      kStatusPileupGhost   // = 5 :   only for filtered simulations: undetectable particle
   };
 
   KVReconstructedNucleus();
   KVReconstructedNucleus(const KVReconstructedNucleus&);
   void init();
   virtual ~KVReconstructedNucleus() {}
   virtual void Print(Option_t* option = "") const;
   virtual void Clear(Option_t* option = "");
   virtual void Reconstruct(KVDetector* kvd);
 
   void SetIdentification(KVIdentificationResult*, KVIDTelescope*);
   void SetIdentifyingTelescope(KVIDTelescope* i)
   {
      if (i) {
         fIDTelescope = i;
         fIDTelName = i->GetName();
      }
      else fIDTelName = "";
   };
 
   const KVSeqCollection* GetDetectorList() const
   {
 
      if (fReconTraj) {
         Obsolete("GetDetectorList", "1.10", "1.12");
         return nullptr;
      }
      if (fDetList.IsEmpty()) {
         const_cast<KVReconstructedNucleus*>(this)->MakeDetectorList();
      }
      return &fDetList;
   }
   KVDetector* GetDetector(const TString& label) const
   {
      if (fReconTraj) return fReconTraj->GetDetector(label);
      if (GetDetectorList()) return (KVDetector*)GetDetectorList()->FindObjectByLabel(label);
      return nullptr;
   }
   KVDetector* GetDetector(int i) const
   {
 
      if (fReconTraj) return fReconTraj->GetNodeAt(i)->GetDetector();
      if (i >= GetDetectorList()->GetEntries()) return 0;
      return (KVDetector*) GetDetectorList()->At(i);
   }
 
   const Char_t* GetDetectorNames() const
   {
      return fDetNames.Data();
   }
   const Char_t* GetIDtelNames() const
   {
      return fIDTelName.Data();
   }
 
   KVDetector* GetStoppingDetector() const
   {
      return GetDetector(0);
   };
   Int_t GetNumDet() const
   {
      if (fReconTraj) return fReconTraj->GetN();
      return GetDetectorList()->GetEntries();
   }
   Int_t GetNSegDet() const
   {
      return fNSegDet;
   }
   void SetNSegDet(Int_t seg)
   {
      fNSegDet = seg;
   }
   void ResetNSegDet()
   {
 
      if (fReconTraj) fNSegDet = fReconTraj->GetNumberOfIndependentIdentifications();
      fNSegDet = 0;
      KVDetector* det;
      TIter nxt(&fDetList);
      while ((det = (KVDetector*)nxt())) fNSegDet += det->GetSegment();
   }
   inline Int_t GetStatus() const
   {
      return fAnalStatus;
   };
 
   inline void SetStatus(Int_t a)
   {
      fAnalStatus = a;
   }
 
   virtual void GetAnglesFromReconstructionTrajectory(Option_t* opt = "random");
   KVGroup* GetGroup() const
   {
      return (GetStoppingDetector() ?  GetStoppingDetector()->GetGroup() : 0);
   };
 
 
   void AddDetector(KVDetector*);
 
   virtual void Copy(TObject&) const;
 
   const KVSeqCollection* GetIDTelescopes() const
   {
 
      if (fReconTraj) return fReconTraj->GetIDTelescopes();
      return (GetStoppingDetector() ? GetStoppingDetector()->GetAlignedIDTelescopes() : 0);
   }
   virtual void Identify();
   virtual void Calibrate();
 
   KVIDTelescope* GetIdentifyingTelescope() const
   {
      return fIDTelescope;
   }
 
   virtual void SetIDCode(UShort_t s)
   {
      GetParameters()->SetValue("IDCODE", (Int_t)s);
   }
   virtual Int_t GetIDCode() const
   {
      return GetParameters()->GetIntValue("IDCODE");
   }
   virtual void SetECode(UChar_t s)
   {
      GetParameters()->SetValue("ECODE", (Int_t)s);
   }
   virtual Int_t GetECode() const
   {
      return GetParameters()->GetIntValue("ECODE");
   }
 
   void SetIsIdentified()
   {
      SetBit(kIsIdentified);
      if (fReconTraj) {
         fReconTraj->AddIdentifiedParticle();
         return;
      }
      const_cast<KVSeqCollection*>(GetDetectorList())->R__FOR_EACH(KVDetector, IncrementIdentifiedParticles)(1);
      const_cast<KVSeqCollection*>(GetDetectorList())->R__FOR_EACH(KVDetector, IncrementUnidentifiedParticles)(-1);
   }
   void SetIsCalibrated()
   {
      SetBit(kIsCalibrated);
   }
   void SetIsUnidentified()
   {
      if (fReconTraj) {
         fReconTraj->AddUnidentifiedParticle();
         return;
      }
      ResetBit(kIsIdentified);
      const_cast<KVSeqCollection*>(GetDetectorList())->R__FOR_EACH(KVDetector, IncrementIdentifiedParticles)(-1);
      const_cast<KVSeqCollection*>(GetDetectorList())->R__FOR_EACH(KVDetector, IncrementUnidentifiedParticles)(1);
   }
   void SetIsUncalibrated()
   {
      ResetBit(kIsCalibrated);
   }
   Bool_t IsIdentified() const
   {
      return TestBit(kIsIdentified);
   }
   Bool_t IsCalibrated() const
   {
      return TestBit(kIsCalibrated);
   }
 
   void SetRealZ(Float_t zz)
   {
      fRealZ = zz;
   }
   void SetRealA(Float_t A)
   {
      fRealA = A;
   }
   Float_t GetRealZ() const
   {
      if (fRealZ > 0) {
         return fRealZ;
      }
      else {
         return (Float_t) GetZ();
      }
   }
   Float_t GetRealA() const
   {
      if (fRealA > 0)
         return fRealA;
      else
         return (Float_t) GetA();
   }
   virtual Float_t GetPID() const
   {
      if (IsAMeasured())
         return (GetRealZ() + 0.1 * (GetRealA() - 2. * GetRealZ()));
      return GetRealZ();
   };
   virtual void SetTargetEnergyLoss(Double_t e)
   {
      fTargetEnergyLoss = e;
   };
   virtual Double_t GetTargetEnergyLoss() const
   {
      return fTargetEnergyLoss;
   };
 
   virtual void SetZMeasured(Bool_t yes = kTRUE)
   {
      SetBit(kZMeasured, yes);
   };
   virtual void SetAMeasured(Bool_t yes = kTRUE)
   {
      SetBit(kAMeasured, yes);
   };
   virtual Bool_t IsZMeasured() const
   {
      return TestBit(kZMeasured);
   };
   virtual Bool_t IsAMeasured() const
   {
      return TestBit(kAMeasured);
   };
   KVIdentificationResult* GetIdentificationResult(Int_t i)
   {
 
      KVIdentificationResult* id = nullptr;
      if (i) id = (KVIdentificationResult*)fIDResults.ConstructedAt(i - 1);
      id->SetNumber(i);
      return id;
   }
   Int_t GetNumberOfIdentificationResults() const
   {
      return fIDResults.GetEntries();
   }
 
   KVIdentificationResult* GetIdentificationResult(const Char_t* idtype)
   {
 
      Int_t n = GetNumberOfIdentificationResults();
      for (int i = 1; i <= n; i++) {
         KVIdentificationResult* id = GetIdentificationResult(i);
         if (!strcmp(id->GetIDType(), idtype)) {
            return id;
         }
      }
      return nullptr;
   }
 
   KVIdentificationResult* GetIdentificationResult(KVIDTelescope* idt)
   {
 
      if (!idt) return nullptr;
      return GetIdentificationResult(idt->GetType());
   }
   KVIdentificationResult* GetIdentificationResult(Int_t i) const
   {
      return const_cast<KVReconstructedNucleus*>(this)->GetIdentificationResult(i);
   }
   KVIdentificationResult* GetIdentificationResult(const Char_t* idtype) const
   {
      return const_cast<KVReconstructedNucleus*>(this)->GetIdentificationResult(idtype);
   }
   KVIdentificationResult* GetIdentificationResult(KVIDTelescope* idt) const
   {
      return const_cast<KVReconstructedNucleus*>(this)->GetIdentificationResult(idt);
   }
 
   virtual void SubtractEnergyFromAllDetectors();
   static UInt_t GetNIdentifiedInGroup(KVGroup* grp)
   {
      UInt_t n = 0;
      if (grp->GetHits()) {
         TIter next(grp->GetParticles());
         KVReconstructedNucleus* nuc = 0;
         while ((nuc = (KVReconstructedNucleus*) next()))
            n += (UInt_t) nuc->IsIdentified();
      }
      return n;
   }
   static UInt_t GetNUnidentifiedInGroup(KVGroup* grp)
   {
      return (grp->GetHits() - GetNIdentifiedInGroup(grp));
   }
   static void AnalyseParticlesInGroup(KVGroup* grp);
 
   const KVReconNucTrajectory* GetReconstructionTrajectory() const
   {
      return fReconTraj;
   }
   void SetReconstructionTrajectory(const KVReconNucTrajectory* t);
   void ModifyReconstructionTrajectory(const KVReconNucTrajectory* t);
   void CopyAndMoveReferences(const KVReconstructedNucleus*);
   void PrintStatusString() const;
 
   Bool_t InArray(const TString&) const;
   TString GetArrayName() const;
   void ls(Option_t* = "") const;
 
   ClassDef(KVReconstructedNucleus, 17)  //Nucleus detected by multidetector array
};
 
 
#endif