KVGeoDNTrajectory.h

#ifndef __KVGEODNTRAJECTORY_H
#define __KVGEODNTRAJECTORY_H
 
#include "KVBase.h"
#include "KVUniqueNameList.h"
#include "TObjArray.h"
#include "KVGeoDetectorNode.h"
 
 
 
class KVGeoDNTrajectory : public KVBase {
 
   friend class KVGroup;
 
   static KVGeoDNTrajectory* Factory(const char* plugin, const KVGeoDNTrajectory*, const KVGeoDetectorNode*);
 
   void init();
 
    TObjArray fNodes;
   static Int_t fGDNTrajNumber;
    mutable Int_t fIter_idx;
    mutable Int_t fIter_limit;
    mutable Int_t fIter_delta;
    mutable Int_t fIter_idx_sav;
    mutable Int_t fIter_limit_sav;
    mutable Int_t fIter_delta_sav;
    KVUniqueNameList fIDTelescopes;
    Bool_t fPathInTitle;
 
   void rebuild_title();
 
   void increment_identified_particle_counters(int identified, int unidentified) const;
 
protected:
    Bool_t fAddToNodes;
 
public:
   KVGeoDNTrajectory();
   KVGeoDNTrajectory(KVGeoDetectorNode*);
   KVGeoDNTrajectory(const KVGeoDNTrajectory&);
   virtual ~KVGeoDNTrajectory();
   void Copy(TObject& obj) const;
   KVGeoDNTrajectory& operator=(const KVGeoDNTrajectory&);
 
   void Clear(Option_t* = "");
 
   void SetAddToNodes(Bool_t yes = kTRUE)
   {
      fAddToNodes = yes;
   }
 
   KVGeoDetectorNode* GetNode(const Char_t* name) const
   {
      return (KVGeoDetectorNode*)fNodes.FindObject(name);
   }
   KVGeoDetectorNode* GetNodeInFront(const KVGeoDetectorNode* n) const
   {
      if (Contains(n) && !EndsAt(n)) {
         return GetNodeAt(Index(n) + 1);
      }
      return nullptr;
   }
   Bool_t Contains(const Char_t* name) const
   {
      return GetNode(name) != nullptr;
   }
 
   Int_t GetN() const
   {
      return fNodes.GetEntries();
   }
   Int_t Index(const TObject* node) const
   {
      return fNodes.IndexOf(node);
   }
 
   void AddLast(KVGeoDetectorNode* n)
   {
      fNodes.AddLast(n);
      if (fAddToNodes) n->AddTrajectory(this);
      rebuild_title();
   }
 
   void ReverseOrder();
   void AddToNodes();
 
   void ls(Option_t* = "") const
   {
      std::cout << GetTrajectoryName() << " : " << GetPathString() << std::endl;
   }
 
   Bool_t EndsAt(const Char_t* node_name) const
   {
 
      return !strcmp(node_name, fNodes.Last()->GetName());
   }
 
   Bool_t BeginsAt(const Char_t* node_name) const
   {
 
      return !strcmp(node_name, fNodes.First()->GetName());
   }
 
   Bool_t EndsAt(const KVGeoDetectorNode* d) const
   {
 
      return (d == (KVGeoDetectorNode*)fNodes.Last());
   }
 
   Bool_t BeginsAt(const KVGeoDetectorNode* d) const
   {
 
      return (d == (KVGeoDetectorNode*)fNodes.First());
   }
 
   Bool_t Contains(const KVGeoDetectorNode* n) const
   {
      return (fNodes.FindObject(n) != NULL);
   }
   Bool_t ContainsAll(const TCollection* l) const
   {
      TIter next(l);
      TObject* o;
      while ((o = next())) {
         if (!Contains(o->GetName())) return kFALSE;
      }
      return kTRUE;
   }
   Bool_t ContainsAny(const TCollection* l) const
   {
      TIter next(l);
      TObject* o;
      while ((o = next())) {
         if (Contains(o->GetName())) return kTRUE;
      }
      return kFALSE;
   }
 
   KVGeoDetectorNode* GetNodeAt(Int_t i) const
   {
 
      return (KVGeoDetectorNode*)fNodes[i];
   }
 
   void SaveIterationState() const
   {
      fIter_idx_sav = fIter_idx;
      fIter_delta_sav = fIter_delta;
      fIter_limit_sav = fIter_limit;
   }
   void RestoreIterationState() const
   {
 
      fIter_idx = fIter_idx_sav;
      fIter_delta = fIter_delta_sav;
      fIter_limit = fIter_limit_sav;
   }
   void IterateFrom(const KVGeoDetectorNode* node0 = nullptr) const
   {
 
      fIter_idx = (node0 == nullptr ? 0 : Index(node0));
      fIter_delta = 1;
      fIter_limit = GetN() - 1;
   }
   void IterateBackFrom(const KVGeoDetectorNode* node0 = nullptr) const
   {
 
      fIter_idx = (node0 == nullptr ? GetN() - 1 : Index(node0));
      fIter_delta = -1;
      fIter_limit = 0;
   }
 
   KVGeoDetectorNode* GetNextNode() const
   {
 
      if (fIter_idx > -1) {
         if (fIter_delta * (fIter_limit - fIter_idx) > 0) {
            Int_t idx = fIter_idx;
            fIter_idx += fIter_delta;
            return GetNodeAt(idx);
         }
         else {
            fIter_idx = -1;
            return GetNodeAt(fIter_limit);
         }
      }
      return nullptr;
   }
 
   const KVSeqCollection* GetIDTelescopes() const
   {
      return &fIDTelescopes;
   }
   KVSeqCollection* AccessIDTelescopeList()
   {
      return &fIDTelescopes;
   }
   Int_t GetNumberOfIdentifications() const
   {
      return fIDTelescopes.GetEntries();
   }
   Bool_t ContainsPath(KVGeoDNTrajectory* other)
   {
      return GetPathString().Contains(other->GetPathString());
   }
   TString GetPathString() const
   {
      if (fPathInTitle) return GetTitle();
      return GetName();
   }
   const Char_t* GetTrajectoryName() const
   {
      if (fPathInTitle) return GetName();
      return GetTitle();
   }
   void SetPathInTitle(Bool_t intitle = kTRUE)
   {
 
      if (intitle != fPathInTitle) {
         TString s = GetName();
         SetName(GetTitle());
         SetTitle(s);
         fPathInTitle = intitle;
      }
   }
   Bool_t IsPathInTitle() const
   {
      return fPathInTitle;
   }
   void AddIdentifiedParticle(int modify_unidentified = -1) const
   {
      increment_identified_particle_counters(1, modify_unidentified);
   }
   void AddUnidentifiedParticle(int modify_identified = -1) const
   {
      increment_identified_particle_counters(modify_identified, 1);
   }
 
   ClassDef(KVGeoDNTrajectory, 1) //Path taken by particles through multidetector geometry
};
 
#endif