UgliScintPlnHandle.h

Go to the documentation of this file.

// $Id: UgliScintPlnHandle.h,v 1.17 2005/09/01 08:07:08 rhatcher Exp $
//
// UgliScintPlnHandle
//
// UgliScintPlnHandle is the handle to a single scint plane
//
// Author:  R. Hatcher 2000.11.15
//

#ifndef UGLISCINTPLNHANDLE_H
#define UGLISCINTPLNHANDLE_H
class UgliScintPlnHandle;
class UgliPlnHandle;
class UgliScintPlnABC;

#include "GeoGeometry/GeoGeometry.h" // IsFrozen
#include "GeoGeometry/GeoScintPlnNode.h"

#include "UgliGeometry/UgliScintPlnABC.h"
#include "UgliGeometry/UgliPlnHandle.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliScintPlnNode.h"
#include "UgliGeometry/UgliStripHandle.h"
#include "UgliGeometry/UgliScintMdlHandle.h"

class GeoScintPlnNode;

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

class UgliScintPlnHandle : public UgliPlnHandle, public UgliScintPlnABC {

 public:

   // Create handles from the actual node object, copy and assignment
   UgliScintPlnHandle(UgliScintPlnNode* scintNode);
   UgliScintPlnHandle(GeoScintPlnNode* scintNode);
   UgliScintPlnHandle(const UgliScintPlnHandle& that);
   UgliScintPlnHandle& operator=(const UgliScintPlnHandle& that);

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

   virtual ~UgliScintPlnHandle();

   virtual Bool_t                  IsValid() const;
   virtual Bool_t                  IsFrozen() const;

   virtual Int_t                   NumberOfStrips() const;

   virtual UgliStripHandle         GetStripHandle(PlexStripEndId seid);

   std::vector<UgliStripHandle>    GetStripHandleVector();
   std::vector<UgliScintMdlHandle> GetScintMdlHandleVector();

   UgliStripHandle                 GetClosestStrip(Float_t tpos, 
                                                   Float_t orthCoord=9999.);

   // convert between world and scint plane coordinates
   virtual TVector3       GlobalToLocal(const TVector3& global,
                                        const Bool_t globalInXYZ=true) const;
   virtual TVector3       LocalToGlobal(const TVector3& local,
                                        const Bool_t globalInXYZ=true) const;

   Float_t                         GetZRotRelSteelRad() const;
   Float_t                         GetX0RelSteel() const;
   Float_t                         GetY0RelSteel() const;

   // these are only allowed if the copy is modifiable
   Bool_t          AttemptSet(const char* what="?") const;
   void            SetZRotRelSteelRad(Float_t radians);
   void            SetXY0RelSteel(Float_t x0, Float_t y0);
   void            RotateRelSteelBy(Float_t deltaRadians);
   void            ShiftXY0RelSteelBy(Float_t dx, Float_t dy);

 protected:

   // The actual node being referenced
   // duplicates UgliPlnNode* in UgliPlnHandle but avoids recasting
   UgliScintPlnNode* fUgliScintPlnNode;
   GeoScintPlnNode* fGeoScintPlnNode;
   
 private:

   ClassDef(UgliScintPlnHandle,2)

};

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

inline Bool_t UgliScintPlnHandle::IsValid() const
{ if ( !IsGeo() ) return (fUgliScintPlnNode) ? kTRUE : kFALSE;
  else return (fGeoScintPlnNode) ? kTRUE : kFALSE; }

inline Bool_t UgliScintPlnHandle::IsFrozen() const
{ if ( !IsGeo() ) return fUgliScintPlnNode->GetUgliGeometry()->IsFrozen();
  else return fGeoScintPlnNode->GetGeoGeometry()->IsFrozen(); }

inline Int_t UgliScintPlnHandle::NumberOfStrips() const
{ if ( !IsGeo() ) return fUgliScintPlnNode->NumberOfStrips();
  else return fGeoScintPlnNode->NumberOfStrips(); }

inline Float_t UgliScintPlnHandle::GetZRotRelSteelRad() const
{ if ( !IsGeo() ) return fUgliScintPlnNode->GetZRotRelSteelRad();
  else return fGeoScintPlnNode->GetZRotRelSteelRad(); }

inline Float_t UgliScintPlnHandle::GetX0RelSteel() const
{ if ( !IsGeo() ) return fUgliScintPlnNode->GetX0RelSteel();
  else return (fGeoScintPlnNode->GetX0RelSteel())*Munits::cm; }

inline Float_t UgliScintPlnHandle::GetY0RelSteel() const
{ if ( !IsGeo() ) return fUgliScintPlnNode->GetY0RelSteel();
  else return (fGeoScintPlnNode->GetY0RelSteel())*Munits::cm; }

inline void UgliScintPlnHandle::RotateRelSteelBy(Float_t deltaRadians) 
{ SetZRotRelSteelRad(GetZRotRelSteelRad()+deltaRadians); }

inline void UgliScintPlnHandle::ShiftXY0RelSteelBy(Float_t dx, Float_t dy)
{ SetXY0RelSteel((GetX0RelSteel()+dx)/Munits::cm,
                 (GetY0RelSteel()+dy)/Munits::cm); }

#endif /* __CINT__ */
#endif // UGLISCINTPLNHANDLE_H

---