UgliStripHandle.h

Go to the documentation of this file.

// $Id: UgliStripHandle.h,v 1.14 2006/04/07 18:03:14 kordosky Exp $
//
// UgliStripHandle
//
// UgliStripHandle is the handle to a single strip
//
// Author:  R. Hatcher 2000.11.15
//

#ifndef UGLISTRIPHANDLE_H
#define UGLISTRIPHANDLE_H
class UgliStripHandle;
class UgliStripABC;

#include "GeoGeometry/GeoStripNode.h"
#include "GeoGeometry/GeoGeometry.h"
#include "UgliGeometry/UgliStripABC.h"
#include "UgliGeometry/UgliGeomHandle.h"
#include "UgliGeometry/UgliStripNode.h"
#include "UgliGeometry/UgliScintMdlHandle.h"
#include "UgliGeometry/UgliScintPlnHandle.h"

class UgliStripHandle : public UgliStripABC {

 public:

   // Create handles from the actual node object, copy and assignment
   UgliStripHandle(UgliStripNode* stripNode);
   UgliStripHandle(GeoStripNode* stripNode);
   UgliStripHandle(const UgliStripHandle& that);
   UgliStripHandle& operator=(const UgliStripHandle& that);

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

   virtual ~UgliStripHandle();

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

   virtual PlexStripEndId GetSEId() const;

   virtual Float_t        GetHalfLength() const;
   virtual Float_t        GetHalfThickness() const;
   virtual Float_t        GetHalfWidth() const;

   virtual Float_t        GetTPos(Float_t orthCoord=9999.) const;

   virtual Float_t        PartialLength(const StripEnd::StripEnd_t end) const;
   virtual Bool_t         IsMirrored(const StripEnd::StripEnd_t end) const;
   virtual Float_t        WlsPigtail(const StripEnd::StripEnd_t end) const;
   virtual Float_t        WlsBypass() const;
   virtual Float_t        ClearFiber(const StripEnd::StripEnd_t end) const;
   virtual Float_t        TotalAttenuation(const StripEnd::StripEnd_t end,
                                           const Float_t alongLength) const;
   
   // world coordinate for point along centerline or WLS fiber
   virtual TVector3       GlobalPos(const Float_t alongLength, 
                                    const Bool_t onWLS=false,
                                    const Bool_t globalInXYZ=true) const;
   // convert between world and nominal cell (box) 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;

   // use position of orthogonal strip to calculate an intersection point
   virtual Float_t        DistanceAlong(const PlexStripEndId& orthogonalStrip) const;
   virtual TVector3       Intersection(const PlexStripEndId& orthogonalStrip) const;

   // return the Scint. Module/Plane in which this strip is located.
   UgliScintMdlHandle     GetScintMdlHandle() const;
   UgliScintPlnHandle     GetScintPlnHandle() const;

   Float_t         GetZRotRelMdlRad() const;
   Float_t         GetLPosRelMdl() const;
   Float_t         GetTPosRelMdl() const;

   // these are only allowed if the copy is modifiable
   Bool_t          AttemptSet(const char* what="?") const;
   void            SetZRotRelMdlRad(Float_t radians);
   void            SetLTPosRelMdl(Float_t lpos, Float_t tpos);
   void            RotateRelMdlBy(Float_t deltaRadians);
   void            ShiftLTPosRelMdlBy(Float_t dlpos, Float_t dtpos);

 protected:

   // The actual node being referenced
   UgliStripNode* fUgliStripNode;
   GeoStripNode*  fGeoStripNode;
   
 private:

   ClassDef(UgliStripHandle,2)

};

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

inline Bool_t UgliStripHandle::IsValid() const
{ if ( !IsGeo() ) return (fUgliStripNode) ? kTRUE : kFALSE;
 else             return (fGeoStripNode)  ? kTRUE : kFALSE; }

inline Bool_t UgliStripHandle::IsFrozen() const
{ if ( !IsGeo() ) return fUgliStripNode->GetUgliGeometry()->IsFrozen();
  else            return fGeoStripNode->GetGeoGeometry()->IsFrozen();}

inline PlexStripEndId UgliStripHandle::GetSEId() const
{ if ( !IsGeo() ) return fUgliStripNode->GetSEId();
  else            return fGeoStripNode->GetSEId(); }

inline Float_t  UgliStripHandle::GetHalfLength() const
{ if ( !IsGeo() ) return fUgliStripNode->GetHalfLength();
  else            return (fGeoStripNode->GetHalfLength())*Munits::cm; } 

inline Float_t  UgliStripHandle::GetHalfThickness() const
{ if ( !IsGeo() ) return fUgliStripNode->GetHalfThickness(); 
  else            return (fGeoStripNode->GetHalfThickness())*Munits::cm; } 

inline Float_t  UgliStripHandle::GetHalfWidth() const
{ if ( !IsGeo() ) return fUgliStripNode->GetHalfWidth(); 
  else            return (fGeoStripNode->GetHalfWidth())*Munits::cm; } 

inline Float_t  UgliStripHandle::GetTPos(Float_t orthCoord) const
{ if ( !IsGeo() ) return fUgliStripNode->GetTPos(orthCoord); 
  else return (fGeoStripNode->GetTPos(orthCoord/Munits::cm))*Munits::cm; } 

inline Float_t  UgliStripHandle::PartialLength(const StripEnd::StripEnd_t end) const
{ if ( !IsGeo() ) return fUgliStripNode->PartialLength(end);
 else             return (fGeoStripNode->PartialLength(end))*Munits::cm; }

inline Bool_t   UgliStripHandle::IsMirrored(const StripEnd::StripEnd_t end) const
{ if ( !IsGeo() ) return fUgliStripNode->IsMirrored(end);
  else            return fGeoStripNode->IsMirrored(end); } 

inline Float_t  UgliStripHandle::WlsPigtail(const StripEnd::StripEnd_t end) const
{ if ( !IsGeo() ) return fUgliStripNode->WlsPigtail(end); 
  else            return (fGeoStripNode->WlsPigtail(end))*Munits::cm; } 

inline Float_t  UgliStripHandle::WlsBypass() const
{ if ( !IsGeo() ) return fUgliStripNode->WlsBypass();
  else            return (fGeoStripNode->WlsBypass())*Munits::cm;  } 

inline Float_t  UgliStripHandle::ClearFiber(const StripEnd::StripEnd_t end) const
{ if ( !IsGeo() ) return fUgliStripNode->ClearFiber(end);
 else             return (fGeoStripNode->ClearFiber(end))*Munits::cm; } 

inline Float_t  UgliStripHandle::TotalAttenuation(const StripEnd::StripEnd_t end, const Float_t alongLength) const
{ if ( !IsGeo() ) return fUgliStripNode->TotalAttenuation(end,alongLength);
  else            return fGeoStripNode->TotalAttenuation(end,
                                         alongLength/Munits::cm);  } 

inline Float_t  UgliStripHandle::DistanceAlong(const PlexStripEndId& orthogonalStrip) const
{ if ( !IsGeo() ) return fUgliStripNode->DistanceAlong(orthogonalStrip);
  else   return (fGeoStripNode->DistanceAlong(orthogonalStrip)*Munits::cm); }

inline TVector3 UgliStripHandle::Intersection(const PlexStripEndId& orthogonalStrip) const
{ if ( !IsGeo() ) return fUgliStripNode->Intersection(orthogonalStrip);
  else {
    return (fGeoStripNode->Intersection(orthogonalStrip) *= Munits::cm); 
  }
}

inline Float_t UgliStripHandle::GetZRotRelMdlRad() const
{ if ( !IsGeo() ) return fUgliStripNode->GetZRotRelMdlRad();
  else            return fGeoStripNode->GetZRotRelMdlRad(); }

inline Float_t UgliStripHandle::GetLPosRelMdl() const
{ if ( !IsGeo() ) return fUgliStripNode->GetLPosRelMdl();
 else             return (fGeoStripNode->GetLPosRelMdl())*Munits::cm; }

inline Float_t UgliStripHandle::GetTPosRelMdl() const
{ if ( !IsGeo() ) return fUgliStripNode->GetTPosRelMdl(); 
  else            return (fGeoStripNode->GetTPosRelMdl())*Munits::cm; }

inline void UgliStripHandle::RotateRelMdlBy(Float_t deltaRadians) 
{ SetZRotRelMdlRad(GetZRotRelMdlRad()+deltaRadians); }

inline void UgliStripHandle::ShiftLTPosRelMdlBy(Float_t dlpos, Float_t dtpos)
{ SetLTPosRelMdl((GetLPosRelMdl()+dlpos)/Munits::cm,
                 (GetTPosRelMdl()+dtpos)/Munits::cm); }

#endif /* __CINT__ */
#endif // UGLISTRIPHANDLE_H

---