GeoGeometry.h

Go to the documentation of this file.

//
// GeoGeometry
//
// GeoGeometry is single geometry built from ROOT's TGeoManager
//
// Author:  S. Kasahara 11/03
//
// Based on R. Hatcher's UgliGeometry/UgliGeometry class

#ifndef GEOGEOMETRY_H
#define GEOGEOMETRY_H

#include <map>
#include <vector>
#include <TVector3.h>
#include <TGeoManager.h>

#include "GeoGeometry/Geo.h"
#include "GeoGeometry/GeoRefCnt.h"   // base class
#include "GeoGeometry/GeoShield.h"  
#include "Validity/VldRange.h"
#include "Validity/VldContext.h"
#include "Plex/PlexPlaneId.h"

class PlexScintMdlId;
class PlexStripEndId;
class UgliDbiTables;
class UgliDbiGeometry;
class DbiValidityRec;

class TGeoManager;
class TGeoNode;
class TGeoVolume;
class GeoStripNode;
class GeoPlnNode;
class GeoScintPlnNode;
class GeoSteelPlnNode;
class GeoScintMdlNode;
class GeoScintMdlVolume;
class GeoNode;
class GeoMediumMap;

class TGeoRotation;

class GeoGeometry : public TObject, public GeoRefCnt {

 public:

  // Typedefs and enumerations
  typedef  std::map<PlexPlaneId,GeoPlnNode*>::iterator PlaneMapItr; 
  typedef  std::map<PlexPlaneId,GeoPlnNode*>::const_iterator PlaneMapConstItr; 
  typedef  std::map<PlexPlaneId,GeoPlnNode*>::reverse_iterator PlaneMapRevItr; 
  typedef  std::map<PlexPlaneId,GeoPlnNode*>::const_reverse_iterator 
                                                        PlaneMapConstRevItr; 

  // Constructors/Destructors
  GeoGeometry(); // def ctor
  GeoGeometry(const VldContext &vldc, 
              Geo::EAppType apptype = Geo::kRecons);  // normal ctor
  virtual ~GeoGeometry();
  virtual void UpdateGlobalManager() const { gGeoManager = fGeoManager; }
      
  // State testing methods
  bool IsAlgorithmic() const { return false; }
  bool IsFrozen() const { return true; }
  Geo::EAppType GetAppType() const { return fAppType; }
  virtual PlexPlaneId  GetPlaneIdFromZ(Double_t z) const;
  virtual GeoStripNode* GetStripNode(const PlexStripEndId& seid) const;
  virtual TVector3 GetHallExtentMin() const { return fHallMin; }
  virtual TVector3 GetHallExtentMax() const { return fHallMax; }
  virtual GeoScintPlnNode* GetScintPlnNode(PlexPlaneId planeId) const;
  virtual GeoSteelPlnNode* GetNearestSteelPlnNode(Double_t z) const;
  virtual const GeoMediumMap& GetMediumMap() const { return *fMediumMap; }
      
  static std::string GetGeoCompatibleName(std::string name);

  const std::vector<GeoScintPlnNode*>& GetScintPlnNodePtrVector() const;
  const std::vector<GeoSteelPlnNode*>& GetSteelPlnNodePtrVector() const;
  const std::vector<GeoPlnNode*>& GetPlnNodePtrVector() const;
  const std::map<Float_t,GeoSteelPlnNode*>& GetSteelPlnNodeMap() const;

  virtual GeoSteelPlnNode* GetSteelPlnNode(PlexPlaneId planeId) const;
  virtual void GetTransverseExtent(PlaneView::PlaneView_t view,
                                   Float_t& tmin, Float_t& tmax) const;
  virtual void GetTransverseExtent(PlaneView::PlaneView_t view,
                                   Double_t& tmin, Double_t& tmax) const;
  virtual void GetZExtent(Float_t& zmin, Float_t& zmax, Int_t isup = -1) 
                                                                   const;
  virtual void GetZExtent(Double_t& zmin, Double_t& zmax, Int_t isup = -1) 
                                                                   const;
  virtual const VldRange& GetVldRange() const { return fVldRange; }
  bool IsCompatible(const VldContext& vldc, Geo::EAppType apptype) const;
  TGeoMedium* GetMedium(const char* name) const;
  
  virtual void Draw(Option_t* volname="");
  virtual void ls(Option_t *option="") const;
  virtual void Print(Option_t *option="") const;  
  virtual void PrintHeader(Option_t *option="") const;  
  virtual void DumpVolume(std::string volname,std::string preface="") const;
  virtual void SwitchMedia(bool toswim);
   
  // methods used during build
  TGeoRotation* GetRot45() const { return fRot45; } 
  TGeoRotation* GetRot315() const { return fRot315; }
      
 private:

  // Private state changing methods
  virtual void BuildAll(const VldContext& vldc);
  virtual void BuildVldRange(const VldContext& vldc);
  virtual void TrimVldRange(const char* tblName="",
                            const DbiValidityRec* dbivrec=0);
  virtual void BuildRotations();
  virtual void BuildGeometry(const VldContext& vldc);
  virtual void BuildDetector(const VldContext& vldc, TGeoVolume* hallVol); 
  virtual void BuildStrips(const UgliDbiTables& tbl, GeoScintMdlNode* node);
  virtual void BuildHallExtent();
  virtual TGeoVolume* BuildFarMARS();
  virtual TGeoVolume* BuildNearMARS();
  virtual void BuildFarCoil(TGeoVolume* hallVol);
  virtual void BuildFarLeadStacks(TGeoVolume* hallVol);
  virtual void BuildNearCoil(TGeoVolume* hallVol);
  virtual TGeoVolume* BuildCoilAirGapVolume(const VldContext& vldc) const;
  virtual TGeoVolume* BuildFarCoilAirGapVolume() const;
  virtual TGeoVolume* BuildNearCoilAirGapVolume() const;
  virtual void BuildPlanePairVolumes(const VldContext& vldc); 
  virtual void BuildStripVolumes(const VldContext& vldc);
  virtual void BuildModules(const UgliDbiTables& tbl, GeoScintPlnNode* node);
  virtual void UpdateNodeMatrices(TGeoVolume* volume);
  Int_t GetSMPlaneLimits(const VldContext& vldc, Int_t* plnMin, Int_t* plnMax);
  
  VldRange      fVldRange;  // vld context of this geometry
  Geo::EAppType fAppType;   // Application type (Recons or VMC)
  Float_t       fSMZMin[2]; // supermodule zmin (global coord)
  Float_t       fSMZMax[2]; // supermodule zmax (global coord)
  Float_t       fScale;     // Scale factor to build geom in appropriate units
  std::string   fHallPath;  // global path to hall
  TVector3      fHallMin;   // hall xyz min
  TVector3      fHallMax;   // hall xyz max

  TGeoManager*  fGeoManager;  // pointer to manager of this geometry
  mutable std::map<PlexPlaneId,GeoPlnNode*> fPlaneMap;  // Map of plane id vs nodes
  mutable std::vector<GeoScintPlnNode*> fScintPlnNodes;
  mutable std::vector<GeoSteelPlnNode*> fSteelPlnNodes;
  mutable std::vector<GeoPlnNode*> fPlnNodes;
  mutable std::map<Float_t, GeoSteelPlnNode*> fSteelPlnNodeMap; // Map of z0 vs nodes

  GeoShield     fGeoShield; // helper to manage shield planes
  Bool_t        fIsSwimMedia; // media is in swimmer mode
  GeoMediumMap* fMediumMap; // build media and associate to det components

  TGeoRotation* fRot45; // reference to common rotation, not owned
  TGeoRotation* fRot315; // reference to common rotation, not owned
  
  ClassDef(GeoGeometry,4)
};

#endif // GEOGEOMETRY_H

---