StupidStripHandle.cxx

Go to the documentation of this file.

#include "MessageService/MsgService.h"
#include "StupidStripHandle.h"
#include "StupidGeomHandle.h"
#include "TMath.h"

ClassImp(StupidStripHandle)

CVSID("$Id: StupidStripHandle.cxx,v 1.7 2007/11/11 04:42:35 rhatcher Exp $");

Bool_t                                     StupidStripHandle::fVetoBuilt = false;
std::map<int,StupidStripHandle::stripData> StupidStripHandle::fVeto;

Float_t        
StupidStripHandle::GetHalfLength() const
{
  if(fSEId.GetDetector()==Detector::kCalDet)  return 0.5;
  else if(fSEId.GetDetector()==Detector::kFar) {
    if(fSEId.GetPlane()>528) { 
      return fVeto[fSEId.GetPlane()*100+fSEId.GetStrip()].length;
    }
    int strip = fSEId.GetStrip();
    if(strip<56) return 1.750 + (float)(strip)*(0.0406586);
    else if(strip>136)  return  9.55934 - (float)(strip)*(0.0406727);
    else return 4.0;
  } else if(fSEId.GetDetector()==Detector::kNear) {
    
    // Near detector.
    // Not very good measurements for strips at very start and very end.
    float strip = (float)fSEId.GetStrip();
    if(fSEId.GetPlaneCoverage()==PlaneCoverage::kNearPartial) {
      if(fSEId.GetPlaneView()==PlaneView::kU) {
        // Near Up
        if(strip<21)      return 0.99878 + 0.0205*strip;
        else if(strip<38) return 1.416;
        else              return 2.19381 - 0.0206525*strip;
      } else {
        // Near Vp
        if (strip<32)     return 0.769 + 0.020667*strip;
        else if(strip<49) return 1.416;
        else              return 2.413 - 0.0205*strip;
      }
    } else {
      if(fSEId.GetPlaneView()==PlaneView::kU) {
        // Near Uf
        if(strip<32)      return 1.33961 + 0.02058*strip;
        else if(strip<66) return 2.002;
        else              return 4.73129 - 0.0412069*strip;
      } else {
        // Near Vf
        if (strip<32)     return 0.69301 + 0.0412069*strip;
        else if(strip<66) return 2.002;
        else              return 3.3569  - 0.0205762*strip;
      }
    }
  }
  return 0; // Default.
}


TVector3       
StupidStripHandle::GlobalPos(const Float_t /*alongLength*/, 
                             const Bool_t onWLS) const
{
  if(onWLS) MSG("Stupid",Msg::kWarning) 
    << "Warning: StupidStripHandle::GlobalPos doesn't know anything about WLS."
    << endl;
  TVector3 retval; 
  if(fSEId.GetDetector()==Detector::kCalDet)  {

    retval.SetZ(0.05227 + 0.0594041*(float)(fSEId.GetPlane()));
    float l = -0.471625 + (float)(fSEId.GetStrip())*(0.041);

    if(fSEId.GetPlaneView()==PlaneView::kU) {
      retval.SetX(l);
      retval.SetY(0);
      return retval;
    };
    if(fSEId.GetPlaneView()==PlaneView::kV) {
      retval.SetX(0);
      retval.SetY(l);
      return retval;
    };  
    
    // Cosmic counters
    if(fSEId.GetPlaneView()==PlaneView::kB) {
      retval.SetY(-1.6);
      retval.SetX(-0.476625 + (float)(fSEId.GetStrip())*0.0410);
      switch(fSEId.GetPlane()) {
      case 61:
        retval.SetZ(0.5);
        return retval;
        break;
      case 62:
        retval.SetZ(1.5);
        return retval;
        break;
      case 63:
        retval.SetZ(2.0);
        return retval;
        break;
      case 64:
        retval.SetZ(3.0);
        return retval;
        break;
      };
    }
  }
  else if(fSEId.GetDetector()==Detector::kFar) {

    // Far Detector.

    if(fSEId.GetPlane()>528) { 
      // Veto planes.
      retval.SetXYZ(
                    fVeto[fSEId.GetPlane()*100+fSEId.GetStrip()].x,
                    fVeto[fSEId.GetPlane()*100+fSEId.GetStrip()].y,
                    fVeto[fSEId.GetPlane()*100+fSEId.GetStrip()].z );

      return retval;
    }
    
    // SM1:
    retval.SetZ(-0.0351982 + 0.0594*(float)(fSEId.GetPlane()));

    // SM2:
    if(fSEId.GetPlane()>249) retval.SetZ(1.4945 + 0.0594*(float)(fSEId.GetPlane()));
    
    // Coords.
    retval.SetY(- 2.7965 + 0.029130*(float)(fSEId.GetStrip()));
    if(fSEId.GetPlaneView()==PlaneView::kU) {
      retval.SetX( -2.7965 + 2.9130e-02*(float)(fSEId.GetStrip()));
      return retval;
    };
    if(fSEId.GetPlaneView()==PlaneView::kV) {
      retval.SetX(  2.7965 - 2.9130e-02*(float)(fSEId.GetStrip()));
      return retval;
    };                                    

  } else if(fSEId.GetDetector()==Detector::kNear) {

    // Near Detector.
    
    retval.SetZ(-0.0240 + 0.0592036*(float)(fSEId.GetPlane()) );
    
    float s = fSEId.GetStrip();
    
    if(fSEId.GetPlaneCoverage()==PlaneCoverage::kNearPartial) {
      if(fSEId.GetPlaneView()==PlaneView::kU) {
        // Near Up
        if(s<21)      { retval.SetX(1.162+0.01550*s); retval.SetY(-1.277+0.04265*s);}
        else if(s<38) { retval.SetX(0.876+0.02925*s); retval.SetY(-0.999+0.02925*s);}
        else          { retval.SetX(1.399+0.01514*s); retval.SetY(-1.518+0.04314*s);}
      } else {
        // Near Vp  
        if (s<32)    { retval.SetX(2.4445-0.01514*s); retval.SetY(-1.4583+0.04316*s);}     
        else if(s<49){ retval.SetX(2.8943-0.02924*s); retval.SetY(-1.0187+0.02925*s);}
        else         { retval.SetX(2.2321-0.01550*s); retval.SetY(-1.6654+0.04265*s);}
      }
    } else {
      if(fSEId.GetPlaneView()==PlaneView::kU) {
        // Near Uf
        if(s<32)      { retval.SetX(-0.847+0.04365*s); retval.SetY(-0.957+0.01455*s); }
        else if(s<66) { retval.SetX(-0.379+0.02911*s); retval.SetY(-1.425+0.02911*s); }
        else          { retval.SetX(-0.369+0.02915*s); retval.SetY(-1.438+0.02912*s); }
      } else {
        // Near Vf
        if (s<32)     { retval.SetX(2.487-0.02914*s); retval.SetY(-1.416+0.02914*s); }
        else if(s<66) { retval.SetX(2.475-0.02912*s); retval.SetY(-1.428+0.02912*s); }
        else          { retval.SetX(4.432-0.04367*s); retval.SetY(-4.682+0.01456*s); }
      }
    }

    return retval;
  }

  MSG("Stupid",Msg::kWarning) << "Warning: StupidGeometryHandle::GlobalPos doesn't know about plane " << fSEId.AsString() << endl;
  return TVector3(0,0,0);
}

Float_t StupidStripHandle::GetTPos() const
{
   // get the strip's tpos offset
   Float_t tpos = -999999;

   TVector3 center = GlobalPos(0.0,kFALSE);

   const Double_t rsqrt2 = 1.0/TMath::Sqrt(2.);

   switch (fSEId.GetPlaneView()) {
   case PlaneView::kX:
      tpos = center.Dot(TVector3(1.,0.,0.));
      break;
   case PlaneView::kY:
      tpos = center.Dot(TVector3(0.,1.,0.));
      break;
   case PlaneView::kU:
      if (fSEId.GetDetector() != Detector::kCalib) {
         tpos = center.Dot(TVector3(rsqrt2,rsqrt2,0.));
      } else {
         // CalDet funkiness
         tpos = center.Dot(TVector3(1.,0.,0.));
      }
      break;
   case PlaneView::kV:
      if (fSEId.GetDetector() != Detector::kCalib) {
         tpos = center.Dot(TVector3(-rsqrt2,rsqrt2,0.));
      } else {
         // CalDet funkiness
         tpos = center.Dot(TVector3(0.,1.,0.));
      }
      break;
   case PlaneView::kA:
      tpos = center.Dot(TVector3(0.,0.,1.));
      break;
   case PlaneView::kB:
      tpos = center.Dot(TVector3(1.,0.,0.));
      break;
   default:
     MSG("Stupid",Msg::kWarning)
       << "StupidStripNode::GetTPos unknown view "
       << PlaneView::AsString(fSEId.GetPlaneView()) << endl;
   }

   return tpos;
}

//_____________________________________________________________________________
Float_t StupidStripHandle::DistanceAlong(const PlexStripEndId& /* orthogonalStrip */) const
{ 
   // get the distance along a strip represented by orthogonal strip
   MSG("Stupid",Msg::kFatal)
      << "StupidStripNode::DistanceAlong not yet implemented" << endl;
   return 0;
}

//_____________________________________________________________________________
TVector3 StupidStripHandle::Intersection(const PlexStripEndId& /* orthogonalStrip */) const
{ 
   // get the 3-space "intersection" of two strips
   MSG("Stupid",Msg::kFatal)
      << "StupidStripNode::Intersection not yet implemented" << endl;
   return TVector3();
}


void StupidStripHandle::BuildVetoData()
{
  if(fVetoBuilt) return;
#include "StupidVetoCode.cinc"
  fVetoBuilt = true;
}

---