UgliGeometry.h

Go to the documentation of this file.

// $Id: UgliGeometry.h,v 1.27 2005/02/11 09:15:10 rhatcher Exp $
//
// UgliGeometry
//
// UgliGeometry is single geometry
//
// Author:  R. Hatcher 2000.04.25
//

#ifndef UGLIGEOMETRY_H
#define UGLIGEOMETRY_H
class UgliGeometry;

#include "Plex/PlexStripEndId.h"
#include "UgliGeometry/TNodeX.h"
class UgliPlnNode;
class UgliSteelPlnNode;
class UgliScintPlnNode;
class UgliScintMdlNode;
class UgliStripNode;

#include "UgliGeometry/UgliGeomABC.h"
#include "UgliGeometry/UgliRefCnt.h"

// need full header here for streamer purposes
#include "TGeometryX.h"
#include "TString.h"
class TObjArray;

#include <map>
#include <vector>

class UgliGeometry;
class DbiValidityRec;

class UgliGeometry : public UgliGeomABC, public UgliRefCnt {

   // only the loan pool can create/delete UgliGeometry
   // and upon reading from a cache file it might need to RestorePlaneTable()
   friend class UgliLoanPool; 

 public:

   Bool_t                    IsCompatible(const VldContext& vldc);
   Bool_t                    IsCompatible(const VldContext* vldc);

   virtual UgliScintPlnNode* GetScintPlnNode(PlexPlaneId planeid) const;
   virtual UgliSteelPlnNode* GetSteelPlnNode(PlexPlaneId planeid) const;
   virtual UgliStripNode*    GetStripNode(PlexStripEndId seid) const;
   virtual PlexPlaneId       GetPlaneIdFromZ(Double_t z) const;
   virtual UgliSteelPlnNode* GetNearestSteelPlnNode(Double_t z) const;

   const std::vector<UgliScintPlnNode*>& GetScintPlnNodePtrVector() const;
   const std::vector<UgliSteelPlnNode*>& GetSteelPlnNodePtrVector() const;
   const std::vector<UgliPlnNode*>&      GetPlnNodePtrVector() 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 isuper=-1) const;
   virtual void  GetZExtent(Double_t& zmin, Double_t& zmax, Int_t isuper=-1) const;
   virtual TVector3 GetHallExtentMin() const;
   virtual TVector3 GetHallExtentMax() const;

   const  VldRange&          GetVldRange() const { return fVldRange; }
   Bool_t                    IsFrozen() const { return fFrozen; }
   Bool_t                    IsAlgorithmic() const { return fAlgorithmic; }

   virtual void Draw(Option_t *option="");
   virtual void Print(Option_t *option="") const;  // print name + ref counts
   virtual void ls(Option_t *option="rsn5") const; // list rot mats, shapes, nodes

   virtual TGeometryX*       GetTGeometryX() const;
   virtual TRotMatrix*       GetRotMatrix(const char *name) const;
   virtual TShape*           GetShape(const char *name) const;
   virtual TNode*            GetNode(const char *name) const;
   virtual TNodeX*           GetTNodeX(const char *name) const;

 public:

   UgliGeometry();  // should be protected, but needed for i/o

 protected:

   UgliGeometry(const VldContext &vldc, Bool_t frozen=kTRUE);
   virtual ~UgliGeometry();

   void SetFrozen(Bool_t frozen);
   
   enum EMINFStatus {
      kNotNeeded,  // gMINFast is not needed
      kOkay,       // gMINFast is needed, has non-zero value
      kNotThere    // gMINFast is needed, but isn't initialized
   };
   virtual UgliGeometry::EMINFStatus GetMINFStatus() const;

   void TrimVldRange(const char* tblName="", const DbiValidityRec* dbivrec=0);

   Bool_t         fFrozen;      // frozen copies can't be modified
   Bool_t         fAlgorithmic; // build from algorithm values not DBI
   VldRange       fVldRange;
   TGeometryX    *fRootGeom;

   mutable std::map<PlexPlaneId,UgliPlnNode*> fPlaneTable; 

   mutable PlexPlaneId       fCachedSteelPlnId;             
   mutable UgliSteelPlnNode* fCachedSteelPlnNode;           
   mutable PlexPlaneId       fCachedScintPlnId;             
   mutable UgliScintPlnNode* fCachedScintPlnNode;           

   // these vectors are used as caches
   mutable std::vector<UgliScintPlnNode*> fScintPlnNodes;     
   mutable std::vector<UgliSteelPlnNode*> fNormalSteelNodes;  
   mutable std::vector<UgliPlnNode*>      fAllPlnNodes;       
   mutable std::vector<Double_t>          fZSteelPlnMidPoint; 

   virtual void BuildAll(const VldContext& vldc);
   virtual void BuildVldRange(const VldContext& vldc);
   virtual void BuildMaterials(const VldContext& vldc);
   virtual void BuildRotMatrices(const VldContext& vldc);
   virtual void BuildShapes(const VldContext& vldc);
   virtual void BuildNodes(const VldContext& vldc);
   virtual void BuildStripShapes(const VldContext& vldc);
   
   virtual void ClearDbiCache(const VldContext& vldc);

   virtual void RestorePlaneTable(bool onlyIfEmpty=true) const; // refills mutable fPlaneTable

 private:

   // avoid copy constructor
   UgliGeometry(const UgliGeometry &so);
   //   void Copy(TObject &obj);

   ClassDef(UgliGeometry,4)
};

#ifndef __CINT__
//=============================================================================
// Implementation details -- inlines need to be hidden from CINT
//=============================================================================

inline TGeometryX* UgliGeometry::GetTGeometryX() const
{ return fRootGeom; }

inline TRotMatrix* UgliGeometry::GetRotMatrix(const char *name) const
{ return fRootGeom->GetRotMatrix(name); }

inline TShape* UgliGeometry::GetShape(const char *name) const
{ return fRootGeom->GetShape(name); }

inline TNode* UgliGeometry::GetNode(const char *name) const
{ return fRootGeom->GetNode(name); }

inline TNodeX* UgliGeometry::GetTNodeX(const char* name) const
{ return dynamic_cast<TNodeX*>(fRootGeom->GetNode(name)); }

#endif /* __CINT__ */
#endif // UGLIGEOMETRY_H

---