UgliScintPlnHandle.cxx

Go to the documentation of this file.

// $Id: UgliScintPlnHandle.cxx,v 1.19 2008/03/28 00:43:53 schubert Exp $
//
// UgliScintPlnHandle
//
// UgliScintPlnHandle is handle to a single scint plane
//
// Author:  R. Hatcher 2000.11.15
//

#include "GeoGeometry/GeoScintPlnNode.h"
#include "UgliGeometry/UgliScintPlnHandle.h"

#include "MessageService/MsgService.h"
CVSID("$Id: UgliScintPlnHandle.cxx,v 1.19 2008/03/28 00:43:53 schubert Exp $");

#include <cassert>

ClassImp(UgliScintPlnHandle)

//_____________________________________________________________________________
UgliScintPlnHandle::UgliScintPlnHandle()
  : UgliPlnHandle((UgliPlnNode*)0), fUgliScintPlnNode(0), fGeoScintPlnNode(0)
{
   // Default constructor

   MSG("Ugli",Msg::kDebug) 
     << "UgliScintPlnHandle created by default ctor" << endl;
//   assert(0);
}

//_____________________________________________________________________________
UgliScintPlnHandle::~UgliScintPlnHandle()
{
   // handle deletion updates reference count
   // done by super-class UgliPlnHandle
   // don't do it here or we'll get two counts for every handle

   // if (fUgliScintPlnNode) fUgliScintPlnNode->DecrementRef();
   // if (fGeoScintPlnNode) fGeoScintPlnNode->DecrementRef();
}

//_____________________________________________________________________________
UgliScintPlnHandle::UgliScintPlnHandle(UgliScintPlnNode* node)
  : UgliPlnHandle(node), fUgliScintPlnNode(node), fGeoScintPlnNode(0)
{
   // ctor keeps reference count up-to-date
   // done by super-class UgliPlnHandle
   // don't do it here or we'll get two counts for every handle

   // if (fUgliScintPlnNode) fUgliScintPlnNode->IncrementRef();
}

//_____________________________________________________________________________
UgliScintPlnHandle::UgliScintPlnHandle(GeoScintPlnNode* node)
  : UgliPlnHandle(node), fUgliScintPlnNode(0), fGeoScintPlnNode(node)
{
   // ctor keeps reference count up-to-date
   // done by super-class UgliPlnHandle
   // don't do it here or we'll get two counts for every handle

   // if (fGeoScintPlnNode) fGeoScintPlnNode->IncrementRef();
}

//_____________________________________________________________________________
UgliScintPlnHandle::UgliScintPlnHandle(const UgliScintPlnHandle &that)
   : UgliPlnHandle(that),
     UgliScintPlnABC(),
     fUgliScintPlnNode(that.fUgliScintPlnNode),
     fGeoScintPlnNode(that.fGeoScintPlnNode)
{
   // copy constructor keeps reference counts up-to-date
   // done by super-class UgliPlnHandle
   // don't do it here or we'll get two counts for every handle

   // if (fUgliScintPlnNode) fUgliScintPlnNode->IncrementRef();
   // if (fGeoScintPlnNode) fGeoScintPlnNode->IncrementRef();
}

//_____________________________________________________________________________
UgliScintPlnHandle&  UgliScintPlnHandle::operator=(const UgliScintPlnHandle& that)
{
   // assignment keeps reference counts up-to-date
   // done by super-class UgliPlnHandle
   // don't do it here or we'll get two counts for every handle

   // if (fUgliScintPlnNode) fUgliScintPlnNode->DecrementRef();
   // fUgliScintPlnNode = that.fUgliScintPlnNode;
   // if (fUgliScintPlnNode) fUgliScintPlnNode->IncrementRef();
  
   if ( this != &that ) {
     UgliPlnHandle::operator=(that);
     fUgliScintPlnNode = that.fUgliScintPlnNode;
     fGeoScintPlnNode = that.fGeoScintPlnNode;
   }
   return *this;
}

//_____________________________________________________________________________
// inlining these causes a circular dependency

//inline 
UgliStripHandle UgliScintPlnHandle::GetStripHandle(PlexStripEndId seid)
{ if (!IsGeo()) return UgliStripHandle(fUgliScintPlnNode->GetStripNode(seid)); 
       else return UgliStripHandle(fGeoScintPlnNode->GetStripNode(seid));
}

//inline 
vector<UgliStripHandle> UgliScintPlnHandle::GetStripHandleVector()
{
//{ return fUgliScintPlnNode->GetStripHandleVector(); }
  vector<UgliStripHandle> stripHandles;
  if ( !IsGeo() ) {
    vector<UgliStripNode*>  stripNodes = 
      fUgliScintPlnNode->GetStripNodePtrVector();
    for (unsigned int i=0; i<stripNodes.size(); ++i)
      stripHandles.push_back(UgliStripHandle(stripNodes[i]));
  }
  else {
    vector<GeoStripNode*>  stripNodes = 
      fGeoScintPlnNode->GetStripNodePtrVector();
    for (unsigned int i=0; i<stripNodes.size(); ++i)
      stripHandles.push_back(UgliStripHandle(stripNodes[i]));
  }
  
  return stripHandles;
}

//inline 
vector<UgliScintMdlHandle> UgliScintPlnHandle::GetScintMdlHandleVector()
{
//{ return fUgliScintPlnNode->GetScintMdlHandleVector(); }
  vector<UgliScintMdlHandle> scintMdlHandles;
  if ( !IsGeo() ) {
    vector<UgliScintMdlNode*>  scintMdlNodes =
      fUgliScintPlnNode->GetScintMdlNodePtrVector();
    for (unsigned int i=0; i<scintMdlNodes.size(); ++i)
      scintMdlHandles.push_back(UgliScintMdlHandle(scintMdlNodes[i]));
  }
  else {
    vector<GeoScintMdlNode*>  scintMdlNodes =
      fGeoScintPlnNode->GetScintMdlNodePtrVector();
    for (unsigned int i=0; i<scintMdlNodes.size(); ++i)
      scintMdlHandles.push_back(UgliScintMdlHandle(scintMdlNodes[i]));
  }
  
  return scintMdlHandles;
}

//_____________________________________________________________________________
UgliStripHandle UgliScintPlnHandle::GetClosestStrip(Float_t tpos, Float_t orthCoord)
{
  // return the handle to the strip in the plane with a position
  // closest to "tpos", orthCoord is position in orthogonal coordinate

  if ( !IsGeo() ) {
    vector<UgliStripNode*>  stripNodes = 
      fUgliScintPlnNode->GetStripNodePtrVector();

    UgliStripNode* closestNode  = 0;
    Float_t        closestDtpos = 999999.;

    // very dumb approach ... 
    // strips are ordered? when delta start getting larger we could possibly quit
    // (is this guaranteed in the vector?)
    // and/or a binary search might be better
    for (unsigned int i=0; i<stripNodes.size(); ++i) {
      Float_t strip_tpos = stripNodes[i]->GetTPos(orthCoord);
      Float_t dtpos = TMath::Abs(strip_tpos-tpos);
      if ( dtpos < closestDtpos ) {
        closestNode  = stripNodes[i];
        closestDtpos = dtpos;
      }
    }
    return UgliStripHandle(closestNode);
  }
  else { 
    return UgliStripHandle(fGeoScintPlnNode -> GetClosestStrip(
                                    tpos/Munits::cm,orthCoord/Munits::cm));
  }
  
}

//_____________________________________________________________________________
Bool_t UgliScintPlnHandle::AttemptSet(const char* what) const
{
  if (!IsFrozen()) return true;

  MSG("Ugli",Msg::kError) 
    << "AttemptSet " << what << " on Frozen " 
    << GetPlexPlaneId() << " twarted!" << endl;
  return false;
}

void UgliScintPlnHandle::SetZRotRelSteelRad(Float_t radians)
{
  if (!AttemptSet("ZRotRelSteelRad")) return;
  if ( !IsGeo() ) fUgliScintPlnNode->SetZRotRelSteelRad(radians);
  else fGeoScintPlnNode->SetZRotRelSteelRad(radians);
  
}

void UgliScintPlnHandle::SetXY0RelSteel(Float_t x0, Float_t y0)
{
  if (!AttemptSet("XY0RelPln")) return;
  if ( !IsGeo() ) fUgliScintPlnNode->SetPosition(x0,y0);
  else fGeoScintPlnNode->SetXY0RelSteel(x0/Munits::cm,y0/Munits::cm);
  
}

//_____________________________________________________________________________
TVector3 UgliScintPlnHandle::GlobalToLocal(const TVector3& global,
                                           const Bool_t globalInXYZ) const
{ 

  if ( !IsValid() ) {
    MSG("Ugli",Msg::kWarning) << "UgliScintPlnHandle::GlobalToLocal "
                              << "called for InValid scint pln." << endl;
    TVector3 dummy;
    return dummy;
  }
  
  // convert a global position into a local (volume) one
  // globalInXYZ determines whether result is in XYZ or UVZ
  TVector3 globalXYZ = (globalInXYZ) ? 
      global : Ugli::uvz2xyz(GetPlexPlaneId().GetDetector(),global);

  if ( !IsGeo() ) 
      return fUgliScintPlnNode->GlobalToLocal(global);
  else { 
      TVector3 scaledglobal(global); scaledglobal *= 1./Munits::cm;
      return (fGeoScintPlnNode->GlobalToLocal(scaledglobal) *= Munits::cm); 
  }
}

//_____________________________________________________________________________
TVector3 UgliScintPlnHandle::LocalToGlobal(const TVector3& local,
                                           const Bool_t globalInXYZ) const
{ 

  if ( !IsValid() ) {
    MSG("Ugli",Msg::kWarning) << "UgliScintPlnHandle::LocalToGlobal "
                              << "called for InValid scint pln." << endl;
    TVector3 dummy;
    return dummy;
  }

  // convert a global position into a local (volume) one
  // globalInXYZ determines whether result is in XYZ or UVZ
  TVector3 globalXYZ;
  if ( !IsGeo() ) 
      globalXYZ = fUgliScintPlnNode->LocalToGlobal(local);
  else { 
      TVector3 scaledlocal(local); scaledlocal *= 1./Munits::cm;
      globalXYZ = (fGeoScintPlnNode->LocalToGlobal(scaledlocal) *= Munits::cm); 
  }

  if (globalInXYZ ) return globalXYZ;
  else              return Ugli::xyz2uvz(GetPlexPlaneId().GetDetector(),
                                         globalXYZ);
}

//_____________________________________________________________________________

---