UgliGeomHandle.h

Go to the documentation of this file.

// $Id: UgliGeomHandle.h,v 1.30 2007/06/14 14:49:06 rhatcher Exp $
//
// UgliGeomHandle
//
// UgliGeomHandle is single geometry
//
// Author:  R. Hatcher 2000.04.25
//

#ifndef UGLIGEOMHANDLE_H
#define UGLIGEOMHANDLE_H
class UgliGeomHandle;

#include "Plex/PlexStripEndId.h"

#include "UgliGeometry/Ugli.h"
#include "UgliGeometry/UgliGeometry.h"
#include "GeoGeometry/GeoGeometry.h"

#include "UgliGeometry/UgliStripNode.h"
#include "UgliGeometry/UgliScintMdlNode.h"
#include "UgliGeometry/UgliScintPlnNode.h"
#include "UgliGeometry/UgliSteelPlnNode.h"

#include "UgliGeometry/UgliStripHandle.h"
#include "UgliGeometry/UgliScintMdlHandle.h"
#include "UgliGeometry/UgliScintPlnHandle.h"
#include "UgliGeometry/UgliSteelPlnHandle.h"

#include <vector>
#include "TVector3.h"

class UgliGeomHandle : public UgliGeomABC {

 public:

   UgliGeomHandle(const VldContext& vldc, 
                  Ugli::EModifyMode mmode = Ugli::kUseGlobal,
                  Geo::EAppType apptype = Geo::kRecons);
   UgliGeomHandle(const UgliGeomHandle& that); // must have copy ctor
                                               // return by value not pointer
   UgliGeomHandle& operator=(const UgliGeomHandle& ugh);

   // One should avoid creating UgliGeomHandle without a reference
   // (be sure to test IsValid() if you do this)
   UgliGeomHandle();   

   virtual ~UgliGeomHandle();

   virtual void ResetVldContext(const VldContext& vldc);

   virtual Bool_t        IsGeo() const { return (fGeoGeometry != 0 ); }
   virtual Bool_t        IsValid() const;
   virtual Bool_t        IsFrozen() const;
   virtual Bool_t        IsAlgorithmic() const;

   virtual UgliScintPlnHandle    GetScintPlnHandle(PlexPlaneId planeid);
   virtual UgliSteelPlnHandle    GetSteelPlnHandle(PlexPlaneId planeid);
   virtual UgliStripHandle       GetStripHandle(PlexStripEndId seid);

   std::vector<UgliScintPlnHandle>    GetScintPlnHandleVector();
   std::vector<UgliSteelPlnHandle>    GetSteelPlnHandleVector();
   std::vector<UgliPlnHandle>         GetPlnHandleVector();

   virtual PlexPlaneId           GetPlaneIdFromZ(Double_t z) const
      { if ( !IsGeo() ) return fUgliGeometry->GetPlaneIdFromZ(z);
        else            return fGeoGeometry->GetPlaneIdFromZ(z/Munits::cm); }

   virtual UgliSteelPlnHandle    GetNearestSteelPlnHandle(Double_t z) 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;

   virtual const VldRange&       GetVldRange() const
      { if ( !IsGeo() ) return fUgliGeometry->GetVldRange();
        else            return fGeoGeometry->GetVldRange();  }
   virtual Detector::Detector_t  GetDetector() const
      { return (Detector::Detector_t)GetVldRange().GetDetectorMask(); }

   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 mat, shapes, nodes

   virtual void uv2xy(Float_t  u, Float_t  v, Float_t  &x, Float_t  &y) const;
   virtual void uv2xy(Double_t u, Double_t v, Double_t &x, Double_t &y) const;
   virtual void xy2uv(Float_t  x, Float_t  y, Float_t  &u, Float_t  &v) const;
   virtual void xy2uv(Double_t x, Double_t y, Double_t &u, Double_t &v) const;

   virtual TVector3 uvz2xyz(const TVector3& uvz) const;
   virtual TVector3 xyz2uvz(const TVector3& xyz) const;

   virtual void UpdateGlobalManager() const { 
     if ( !IsGeo() ) gGeoManager = 0;
     else fGeoGeometry->UpdateGlobalManager(); }
   
   static bool DoesValidGeomExist(const VldContext& vldc,
                                  Ugli::EModifyMode mmode = Ugli::kUseGlobal);
      
   void SwitchMedia(bool toswim);
   
 protected:

   UgliGeometry *fUgliGeometry;
   GeoGeometry*  fGeoGeometry; // pointer to alternate geometry GeoGeometry
   
 private:

   // Avoid copying
   void Copy(TObject &that) const;

   ClassDef(UgliGeomHandle,2)
};

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

inline Bool_t UgliGeomHandle::IsValid() const
{ 
  if ( ( fUgliGeometry || fGeoGeometry ) &&
       ( GetVldRange().GetDetectorMask() != Detector::kUnknown ) ) 
    return kTRUE; // geometry constructed and valid detector type
  return kFALSE;
}

inline Bool_t UgliGeomHandle::IsFrozen() const
{ if ( !IsGeo() ) return fUgliGeometry->IsFrozen();
  else            return fGeoGeometry->IsFrozen(); }

inline Bool_t UgliGeomHandle::IsAlgorithmic() const
{ if ( !IsGeo() ) return fUgliGeometry->IsAlgorithmic(); 
  else            return fGeoGeometry->IsAlgorithmic(); }

inline UgliSteelPlnHandle UgliGeomHandle::GetSteelPlnHandle(PlexPlaneId planeid)
{ if ( !IsGeo() ) 
    return UgliSteelPlnHandle(fUgliGeometry->GetSteelPlnNode(planeid));
  else return UgliSteelPlnHandle(fGeoGeometry->GetSteelPlnNode(planeid)); }

inline void UgliGeomHandle::GetTransverseExtent(PlaneView::PlaneView_t view,
                                                Float_t& tmin, 
                                                Float_t& tmax) const
{ if ( !IsGeo() ) fUgliGeometry->GetTransverseExtent(view,tmin,tmax); 
  else          { fGeoGeometry->GetTransverseExtent(view,tmin, tmax); 
                  tmin *= Munits::cm; tmax *= Munits::cm; }               
}

inline void UgliGeomHandle::GetTransverseExtent(PlaneView::PlaneView_t view,
                                                Double_t& tmin, 
                                                Double_t& tmax) const
{ if ( !IsGeo() ) fUgliGeometry->GetTransverseExtent(view,tmin,tmax);
  else          { fGeoGeometry->GetTransverseExtent(view,tmin,tmax); 
                  tmin *= Munits::cm; tmax *= Munits::cm; }               
}



inline void UgliGeomHandle::GetZExtent(Float_t& zmin, Float_t& zmax, 
                                       Int_t isuper) const { 
  if ( !IsGeo() ) fUgliGeometry->GetZExtent(zmin,zmax,isuper); 
  else { 
    fGeoGeometry->GetZExtent(zmin,zmax,isuper); 
    zmin *= Munits::cm; zmax *= Munits::cm; 
  }
}

inline void UgliGeomHandle::GetZExtent(Double_t& zmin, Double_t& zmax, 
                                       Int_t isuper) const { 
  if ( !IsGeo() ) fUgliGeometry->GetZExtent(zmin,zmax,isuper); 
  else { 
    fGeoGeometry->GetZExtent(zmin,zmax,isuper); 
    zmin *= Munits::cm; zmax *= Munits::cm; 
  }
  
}
  

inline TVector3 UgliGeomHandle::GetHallExtentMin() const
{ if ( !IsGeo() ) return fUgliGeometry->GetHallExtentMin(); 
  else            return (fGeoGeometry->GetHallExtentMin())*Munits::cm; }

inline TVector3 UgliGeomHandle::GetHallExtentMax() const
{ if ( !IsGeo() ) return fUgliGeometry->GetHallExtentMax(); 
  else            return (fGeoGeometry->GetHallExtentMax())*Munits::cm; }

inline UgliSteelPlnHandle 
UgliGeomHandle::GetNearestSteelPlnHandle(Double_t z) const
{
  if ( !IsGeo() ) 
    return UgliSteelPlnHandle(fUgliGeometry->GetNearestSteelPlnNode(z));
  else 
    return UgliSteelPlnHandle(fGeoGeometry->
                              GetNearestSteelPlnNode(z/Munits::cm));
  
}

inline void UgliGeomHandle::Draw(Option_t *option)
{ if ( !IsGeo() ) fUgliGeometry->Draw(option); 
  else            fGeoGeometry->Draw(option); }

inline void UgliGeomHandle::Print(Option_t *option) const
{ if ( !IsGeo() ) fUgliGeometry->Print(option); 
  else            fGeoGeometry->Print(option); }

inline void UgliGeomHandle::ls(Option_t *option) const
{ if ( !IsGeo() ) fUgliGeometry->ls(option); 
  else            fGeoGeometry->ls(option); }

inline void UgliGeomHandle::uv2xy(Float_t   u, Float_t   v, 
                                  Float_t&  x, Float_t&  y) const
{ Ugli::uv2xy(GetDetector(),u,v,x,y); }
inline void UgliGeomHandle::uv2xy(Double_t  u, Double_t  v, 
                                  Double_t& x, Double_t& y) const
{ Ugli::uv2xy(GetDetector(),u,v,x,y); }
inline void UgliGeomHandle::xy2uv(Float_t   x, Float_t   y, 
                                  Float_t&  u, Float_t&  v) const
{ Ugli::xy2uv(GetDetector(),x,y,u,v); }
inline void UgliGeomHandle::xy2uv(Double_t  x, Double_t  y, 
                                  Double_t& u, Double_t& v) const
{ Ugli::xy2uv(GetDetector(),x,y,u,v); }
inline TVector3 UgliGeomHandle::uvz2xyz(const TVector3& uvz) const
{ return Ugli::uvz2xyz(GetDetector(),uvz); }
inline TVector3 UgliGeomHandle::xyz2uvz(const TVector3& xyz) const
{ return Ugli::xyz2uvz(GetDetector(),xyz); }

#endif /* __CINT__ */
#endif // UGLIGEOMHANDLE_H

---