UgliPlnHandle.h

Go to the documentation of this file.

// $Id: UgliPlnHandle.h,v 1.6 2005/07/17 23:54:45 schubert Exp $
//
// UgliPlnHandle
//
// UgliPlnHandle is the handle to a single plane
//
// Author:  R. Hatcher 2000.11.15
//

#ifndef UGLIPLNHANDLE_H
#define UGLIPLNHANDLE_H

#include "GeoGeometry/GeoPlnNode.h"
#include "UgliGeometry/UgliPlnNode.h"
#include "UgliGeometry/UgliGeometry.h"


class UgliPlnHandle : public UgliPlnABC {

 public:

   // Create handles from the actual node object, copy and assignment
   UgliPlnHandle(UgliPlnNode* plnNode);
   UgliPlnHandle(GeoPlnNode* plnNode);
   UgliPlnHandle(const UgliPlnHandle& that);
   UgliPlnHandle& operator=(const UgliPlnHandle& that);

   // One should avoid creating UgliPlnHandle without a reference 
   // (be sure to test IsValid())
   UgliPlnHandle();

   virtual ~UgliPlnHandle();

   virtual Bool_t         IsValid() const;
   virtual Bool_t         IsGeo() const { return (fGeoPlnNode != 0); }
     
   virtual PlexPlaneId                    GetPlexPlaneId() const;
   virtual Int_t                          GetPlaneNumber() const;
   virtual PlaneView::PlaneView_t         GetPlaneView() const;
   virtual PlaneCoverage::PlaneCoverage_t GetPlaneCoverage() const;

   virtual Float_t        GetHalfThickness() const;
   virtual TVector3       GetCenter() const;
   virtual Float_t        GetX0() const;
   virtual Float_t        GetY0() const;
   virtual Float_t        GetZ0() const;

 protected:

   // The actual node being referenced
   UgliPlnNode* fUgliPlnNode;
   GeoPlnNode* fGeoPlnNode;
   
 private:

ClassDef(UgliPlnHandle,3)

};

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

inline Bool_t UgliPlnHandle::IsValid() const
{ if ( !IsGeo() ) return (fUgliPlnNode) ? kTRUE : kFALSE;
  else return (fGeoPlnNode) ? kTRUE : kFALSE;  
}

inline PlexPlaneId UgliPlnHandle::GetPlexPlaneId() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetPlexPlaneId(); 
  else return fGeoPlnNode->GetPlexPlaneId(); 
}

inline Int_t UgliPlnHandle::GetPlaneNumber() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetPlexPlaneId().GetPlane(); 
 else return fGeoPlnNode->GetPlexPlaneId().GetPlane(); 
}

inline PlaneView::PlaneView_t UgliPlnHandle::GetPlaneView() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetPlexPlaneId().GetPlaneView(); 
 else return fGeoPlnNode->GetPlexPlaneId().GetPlaneView(); 
}

inline PlaneCoverage::PlaneCoverage_t 
         UgliPlnHandle::GetPlaneCoverage() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetPlexPlaneId().GetPlaneCoverage(); 
  else return fGeoPlnNode->GetPlexPlaneId().GetPlaneCoverage();
}

inline Float_t UgliPlnHandle::GetHalfThickness() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetHalfThickness();
  else return (fGeoPlnNode->GetHalfThickness())*Munits::cm;
}

inline TVector3 UgliPlnHandle::GetCenter() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetCenter();
  else return (fGeoPlnNode->GetCenter())*Munits::cm;
}

inline Float_t UgliPlnHandle::GetX0() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetX0(); 
  else return (fGeoPlnNode->GetX0())*Munits::cm; 
}

inline Float_t UgliPlnHandle::GetY0() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetY0(); 
  else return (fGeoPlnNode->GetY0())*Munits::cm;
}

inline Float_t UgliPlnHandle::GetZ0() const
{ if ( !IsGeo() ) return fUgliPlnNode->GetZ0(); 
  else return (fGeoPlnNode->GetZ0())*Munits::cm;
}

#endif /* __CINT__ */
#endif // UGLIPLNHANDLE_H

---