KVGeoNavigator.h

 
 
#ifndef __KVGEONAVIGATOR_H
#define __KVGEONAVIGATOR_H
 
#include "KVBase.h"
#include "TVector3.h"
#include "TClonesArray.h"
#include "KVDetector.h"
#include <KVNameValueList.h>
#include <TGeoMatrix.h>
class KVNucleus;
class TGeoManager;
class TGeoVolume;
class TGeoNode;
class TEnv;
 
class KVGeoNavigator : public KVBase {
private:
    TGeoManager* fGeometry;
    TGeoVolume* fCurrentVolume;
    TGeoNode* fCurrentNode;
    TGeoNode* fCurrentDetectorNode;
    TGeoHMatrix fCurrentMatrix;
    TString fCurrentPath;
    TClonesArray fCurrentStructures;
    Int_t fCurStrucNumber;
    TGeoNode* fMotherNode;
    Double_t fStepSize;
    TVector3 fEntryPoint;
    TVector3 fExitPoint;
    Bool_t fStopPropagation;
    Int_t fTrackID;
    Bool_t fTracking;
protected:
    KVNameValueList fStrucNameFmt;
    KVString fDetNameFmt;
    TEnv* fDetStrucNameCorrespList;
   void FormatStructureName(const Char_t* type, Int_t number, KVString& name);
   void FormatDetectorName(const Char_t* basename, KVString& name);
 
public:
   class KVGeoDetectorPath : public TNamed {
      KVDetector* fDetector;
   public:
      KVGeoDetectorPath() : TNamed(), fDetector(nullptr) {}
      KVGeoDetectorPath(const Char_t* path, KVDetector* det) :
         TNamed(path, ""), fDetector(det) {}
      virtual ~KVGeoDetectorPath() {}
      KVDetector* GetDetector() const
      {
         return fDetector;
      }
      ClassDef(KVGeoDetectorPath, 1) //Link physical path to node in geometry with detector
   };
protected:
    KVUniqueNameList fDetectorPaths;
   KVDetector* GetDetectorFromPath(const Char_t* p)
   {
      KVGeoDetectorPath* gdp = (KVGeoDetectorPath*)fDetectorPaths.FindObject(p);
      return (KVDetector*)(gdp ? gdp->GetDetector() : nullptr);
   }
 
public:
   KVGeoNavigator(TGeoManager*);
   virtual ~KVGeoNavigator();
 
   void ResetTrackID(Int_t id = 0)
   {
      fTrackID = id;
   }
   Int_t GetTrackID() const
   {
      return fTrackID;
   }
   void IncrementTrackID()
   {
      ++fTrackID;
   }
   void SetTracking(Bool_t on = kTRUE)
   {
      fTracking = on;
   }
   Bool_t IsTracking() const
   {
      return fTracking;
   }
 
   void SetStructureNameFormat(const Char_t* type, const Char_t* fmt);
   void SetDetectorNameFormat(const Char_t* fmt)
   {
      fDetNameFmt = fmt;
   }
   const Char_t* GetDetectorNameFormat() const
   {
      return fDetNameFmt.Data();
   }
   void SetNameCorrespondanceList(const Char_t*);
   void SetNameCorrespondanceList(const TEnv*);
   Bool_t GetNameCorrespondance(const Char_t*, TString&);
 
   void PropagateEvent(KVEvent*, TVector3* TheOrigin = 0);
   virtual void PropagateParticle(KVNucleus*, TVector3* TheOrigin = 0);
   virtual void ParticleEntersNewVolume(KVNucleus*);
 
   TGeoManager* GetGeometry() const
   {
      return fGeometry;
   }
   TGeoVolume* GetCurrentVolume() const
   {
      return fCurrentVolume;
   }
   TGeoNode* GetCurrentNode() const
   {
      return fCurrentNode;
   }
   const TGeoHMatrix* GetCurrentMatrix() const;
   Double_t GetStepSize() const
   {
      return fStepSize;
   }
   const TVector3& GetEntryPoint() const
   {
      return fEntryPoint;
   }
   const TVector3& GetExitPoint() const
   {
      return fExitPoint;
   }
   TGeoVolume* GetCurrentDetectorNameAndVolume(KVString&, Bool_t&);
   TGeoNode* GetCurrentDetectorNode() const;
   TString GetCurrentPath() const
   {
      return fCurrentPath;
   }
 
   Bool_t StopPropagation() const
   {
      return fStopPropagation;
   }
   void SetStopPropagation(Bool_t stop = kTRUE)
   {
      fStopPropagation = stop;
   }
 
   void ExtractDetectorNameFromPath(KVString&);
   const TClonesArray& CurrentStructures() const
   {
      return fCurrentStructures;
   }
   virtual void AddPointToCurrentTrack(Double_t, Double_t, Double_t) {}
   void DrawTracks(KVNumberList* = nullptr);
 
   void AbsorbDetectorPaths(KVGeoNavigator* GN)
   {
 
      fDetectorPaths.AddAll(&GN->fDetectorPaths);
      GN->fDetectorPaths.SetOwner(kFALSE);
   }
   void PrintDetectorPaths()
   {
      TIter it(&fDetectorPaths);
      KVGeoDetectorPath* gdp;
      while ((gdp = (KVGeoDetectorPath*)it())) {
         std::cout << gdp->GetDetector()->GetName() << " : " << gdp->GetName() << std::endl;
      }
   }
 
   ClassDef(KVGeoNavigator, 0) //Propagate particles of an event through a TGeo geometry
};
 
#endif