PlexPlaneId.cxx

Go to the documentation of this file.

// $Id: PlexPlaneId.cxx,v 1.42 2007/04/27 14:28:16 rhatcher Exp $
//
// PlexPlaneId
//
// PlexPlaneId encapsulates strip end encoding
//
// Author:  R. Hatcher 2000.11.28
//

#include "Plex/PlexPlaneId.h"

#include "Plex/PlexScintMdlId.h"
#include "Plex/PlexVetoShieldHack.h"

#include <iostream>
#include <iomanip>
#include <string>

#include <cassert>

#include "MessageService/MsgService.h"
CVSID("$Id: PlexPlaneId.cxx,v 1.42 2007/04/27 14:28:16 rhatcher Exp $");

ClassImp(PlexPlaneId)

//_____________________________________________________________________________

// define standard geometry values (declared static in header)
//Bool_t PlexPlaneId::fgFarIsUV = false;
//UInt_t PlexPlaneId::fgNumPlnsInFarSM[3] = { 249, 237, 0 };
Bool_t PlexPlaneId::fgCalDetCosmicsAView = false;  // in real life: kB   

//_____________________________________________________________________________
ostream& operator<<(ostream& os, const PlexPlaneId& p)
{
   os << p.AsString();

  return os;
}

//_____________________________________________________________________________
PlexPlaneId::PlexPlaneId(Detector::Detector_t detector,
                         UInt_t plane, Bool_t isSteel,
                         PlaneView::PlaneView_t view,
                         PlaneCoverage::PlaneCoverage_t coverage)

   : fEncoded(defaultPlexPlaneId)
{
   // Normal ctor

   SetDetector(detector);
   SetIsSteel(isSteel);
   SetPlane(plane,view,coverage);
}

//_____________________________________________________________________________
const char * PlexPlaneId::AsString(Option_t *option) const
{
   // Return unpacked StripEndId as a string
   // User should copy result because it points to a 
   // statically allocated string.
   // Internally uses a circular list of buffers to avoid problems
   // using AsString multiple times in a cout-like situation.

   const int nbuffers = 8;   // use a circular list of strings
   static char newstring[nbuffers][27]; // = "|123456789|1234 VX|123|SE|";
      //                                      12345678901234567890123456
   static int  ibuffer = nbuffers;
   ibuffer = (ibuffer+1)%nbuffers;  // each time move to next buffer

   Detector::Detector_t det = GetDetector();
   char detc                = Detector::AsString(det)[0];
   int  ipln                = GetPlane();
   char type                = (IsSteel() ? 'P' : 'A'); 
   char viewc               = PlaneView::AsString(GetPlaneView())[0];
   const char* cover        = PlaneCoverage::AsString(GetPlaneCoverage());

   switch (option[0]) {
   case 'b':
      // override P/A type with B 
      // b is for "box" containing steel+scint (or steel alone if no active)
      type = 'B';
   default:
      // compact rendering identifying only the plane info
      if ( Detector::kFar == det && IsVetoShield() ) {
        sprintf(newstring[ibuffer],"%c%3.3d%c%c%2.2s",
                detc, ipln, type, viewc, cover);
      }
      else {
        sprintf(newstring[ibuffer],"%c%3.3d%c%c%c",
                detc, ipln, type, viewc, cover[0]);
      }
      break;
   }
   
   return newstring[ibuffer];
}

//_____________________________________________________________________________
Bool_t PlexPlaneId::IsValid() const
{ 
  // test if plane # = all bits on as signal of invalid value
  // also fail if IsSteel=false but PlaneCoverage=NoActive
  if ( IsNull() ) return false;
  if ( ! IsSteel() && 
       GetPlaneCoverage() == PlaneCoverage::kNoActive ) return false;
  return true;
       
}

//_____________________________________________________________________________
UShort_t PlexPlaneId::NumberOfStrips() const
{
  // Expected number of strips for this plane 
  // Hard coded values depending on PlaneCoverage and Detector

  if ( IsSteel() ) return 0;  // steel planes have no strips

  switch (GetPlaneCoverage()) {
  case (PlaneCoverage::kNoActive):    return   0; // strip on pln w/ no active?
  case (PlaneCoverage::kNearPartial): return  68; // 28 + 20 + 20
  case (PlaneCoverage::kNearFull):    return  96; // 28 + 20 + 16 + 16 + 16
  case (PlaneCoverage::kTotal): {
    switch (GetDetector()) {
    case (Detector::kFar):        return 192; // 28+28+20+20+20+20+28+28
    case (Detector::kCalDet):     return  24;
    default:
      MSG("Plex",Msg::kWarning) 
        << "NumberOfStrips for PlaneCoverage::kTotal "
        << "on Detector::k" << Detector::AsString(GetDetector())
        << " is not defined" << endl;
      return 0;
    }
    break;
  }
  case (PlaneCoverage::kVScN):
  case (PlaneCoverage::kVSCN):
  case (PlaneCoverage::kVSeS):
  case (PlaneCoverage::kVSES):
  case (PlaneCoverage::kVScS):
  case (PlaneCoverage::kVSCS):
  case (PlaneCoverage::kVSeN):
  case (PlaneCoverage::kVSEN):
    return 20;  // all veto shield modules have 20 strips
  default:
      MSG("Plex",Msg::kWarning) 
        << "NumberOfStrips for PlaneCoverage::k" 
        << PlaneCoverage::AsString(GetPlaneCoverage())
        << " is not defined." << endl;
      return 0;
  }
}

//_____________________________________________________________________________
PlexPlaneId PlexPlaneId::GetNext(PlexPlaneId::EPlaneType ptype,
                                 PlaneView::PlaneView_t view,
                                 PlaneCoverage::PlaneCoverage_t cover) const
{
   // Find the next plane id (of type scint, steel or either).
   // If beyond end return an invalid id
   // Skip planes that don't exist (ie. scint on bookend plane, or
   // those in the near spectrometer.
   // If view or cover is other than kUnknown then look for that 
   // particular type.

   PlexPlaneId next(*this);
   while (true) {
   moveit:
      if (next.IsSteel()) {
         // steel means next should be scint of *NEXT* plane
         next.SetPlane(next.GetPlane()+1);
         next.SetIsSteel(false);
         // move along if there is no actual scintillator
         if (next.GetPlaneCoverage() == PlaneCoverage::kNoActive) goto moveit;
      }
      else {
         // scint means next should be steel of same plane
         next.SetIsSteel(true);
      }
      bool okview  = ( PlaneView::kUnknown == view ) || 
                     ( next.GetPlaneView() == view );
      bool okcover = ( PlaneCoverage::kUnknown == cover ) || 
                     ( next.GetPlaneCoverage() == cover );
      if ( okview && okcover ) {
        switch (ptype) {
        case PlexPlaneId::kScintOrSteel: 
          return next;
          break;
        case PlexPlaneId::kScint:        
          if (!next.IsSteel()) return next; 
          break;
        case PlexPlaneId::kSteel:
          if ( next.IsSteel()) return next;
          break;
        }
      }
      if (!next.IsValid()) return next; // beyond the end
   }
}
//_____________________________________________________________________________
PlexPlaneId PlexPlaneId::GetPrevious(PlexPlaneId::EPlaneType ptype,
                                     PlaneView::PlaneView_t view,
                                     PlaneCoverage::PlaneCoverage_t cover) const
{
   // Find the previous plane id (of type scint, steel or either).
   // If beyond end return an invalid id
   // Skip planes that don't exist (ie. scint on bookend plane, or
   // those in the near spectrometer.
   // If view or cover is other than kUnknown then look for that 
   // particular type.

   PlexPlaneId next(*this);
   while (true) {
   moveit:
      if (next.IsSteel()) {
         // steel means previous should be scint of same plane
         next.SetIsSteel(false);
         // move along if there is no actual scintillator
         if (next.GetPlaneCoverage() == PlaneCoverage::kNoActive) goto moveit;
      }
      else {
         // scint means next should be steel of *PREVIOUS* plane
         next.SetPlane(next.GetPlane()-1);
         next.SetIsSteel(true);
      }
      bool okview  = ( PlaneView::kUnknown == view ) || 
                     ( next.GetPlaneView() == view );
      bool okcover = ( PlaneCoverage::kUnknown == cover ) || 
                     ( next.GetPlaneCoverage() == cover );
      if ( okview && okcover ) {
        switch (ptype) {
        case PlexPlaneId::kScintOrSteel: 
          return next;
          break;
        case PlexPlaneId::kScint:
          if (!next.IsSteel()) return next;
          break;
        case PlexPlaneId::kSteel:
          if ( next.IsSteel()) return next;
          break;
        }
      }
      if (!next.IsValid()) return next; // beyond the end
   }
}

//_____________________________________________________________________________
UShort_t PlexPlaneId::GetNumStrips() const
{
  if (IsSteel() || GetPlaneCoverage()==PlaneCoverage::kNoActive) return 0;
  return PlexScintMdlId::GetNumStripsInPln(*this);
}

UShort_t PlexPlaneId::GetNumScintMdls() const
{
  if (IsSteel() || GetPlaneCoverage()==PlaneCoverage::kNoActive) return 0;
  return PlexScintMdlId::GetNumScintMdlsInPln(*this);
}
//_____________________________________________________________________________
void PlexPlaneId::Print(Option_t *option) const
{
   // Print the (decoded) value

   printf("%s\n",AsString(option));
}

//_____________________________________________________________________________

void PlexPlaneId::SetPlane(UInt_t plane,
                           PlaneView::PlaneView_t view,
                           PlaneCoverage::PlaneCoverage_t coverage)
{
   // Set the Plane # (and view, coverage)
   // if the view or coverage are unknown (default) then
   // use Default values based on detector+plane#
   // This is to protect the casual user who diddles with just
   // the plane#

   // set everything to invalid if one goes beyond the ends
   Detector::Detector_t detector = GetDetector();
   Bool_t out_of_range = false;
   Bool_t accept_out_of_range = false;
   switch (detector) {
   case Detector::kNear: 
      out_of_range = ( plane > LastPlaneNearSpect() );
      break;
   case Detector::kFar: {

      // for now simple allow "anything goes" for veto shield stuff
      // allow special 511 for UgliDbi*Struct hack
      if (plane>=511) { out_of_range = false; break; }

      out_of_range = ( plane > LastPlaneFarSM1() ); 
      // some sites might have older DB's that attempt to build
      // these non-existent planes ... leading to numerous
      // error messages from UgliGeometry.  For now accept them
      // but this will change eventually.
      // accept_out_of_range = ( plane >= 486 && plane <= 497 );

      break;
   }
   case Detector::kCalDet: 
      out_of_range = (plane > 5*12+4);
      break;
   default:
      out_of_range = false;
      break;
   }
   if (out_of_range) { 
     MAXMSG("Plex",Msg::kDebug,20)
       << "SetPlane() " << Detector::AsString(detector)
       << " plane " << plane << " is out-of-range."
       << endl;
     if ( ! accept_out_of_range ) {
       fEncoded = defaultPlexPlaneId;
       return; 
     }
   }

   // push the plane # into the field
   fEncoded = ( fEncoded & ~maskPlexIdPlane ) | 
     ( ( plane << shftPlexIdPlane ) & maskPlexIdPlane );   

   // set the view and coverage if they weren't supplied

   if (view == PlaneView::kUnknown) 
      view = DefaultPlaneView(detector,plane);
   SetPlaneView(view);

   if (coverage == PlaneCoverage::kUnknown) 
      coverage = DefaultPlaneCoverage(detector,plane);
   SetPlaneCoverage(coverage);

}

//_____________________________________________________________________________
PlaneView::PlaneView_t PlexPlaneId::DefaultPlaneView(
   Detector::Detector_t detector, UInt_t plane)
{
   // Determine plane view given just (detector,plane#)

   static Int_t warn_mask = 0;

   switch (detector) {
   case Detector::kNear:
      // 0=blank, 1=u, 2=v, 3=u, 4=v ...
      // planes 1,6,11... are full coverage
      // otherwise if plane<121 partial
      // otherwise uninstrumented
      if ( plane<1 ||  plane>LastPlaneNearSpect() ||
          ( plane>LastPlaneNearCalor() && (plane%5 !=1)) ) {
         return PlaneView::kUnknown;
      } 
      else if (plane%2 == 1) {
         return PlaneView::kU;
      } 
      else {
         return PlaneView::kV;
      }
      break;
   case Detector::kFar:
   {
      // veto shield stuff first
      if ( PlexVetoShieldHack::IsMuxPlnVetoShield(plane) ) {
        // ambiguous .. "mux" planes cover various views
        return PlaneView::kVSUnknown;
      }
      if ( PlexVetoShieldHack::IsMdlPlnVetoShield(plane) ) {
        // little to go on... use semi-bogus context
        const VldContext& vldc = PlexVetoShieldHack::GetDefaultContext();
        return PlexVetoShieldHack::GetMdlPlaneView(vldc,plane);
      }

      // first plane of each of the two SM is blank
      UInt_t far_blank[3];
      far_blank[0] = 0;
      far_blank[1] = LastPlaneFarSM0() + 1;
      far_blank[2] = LastPlaneFarSM1() + 1;  // beyond the end

      if ( plane <= far_blank[0] ) return PlaneView::kUnknown;
      if ( plane == far_blank[1] ) return PlaneView::kUnknown;
      if ( plane >= far_blank[2] ) return PlaneView::kUnknown;

      UInt_t insuper = plane;
      if ( plane < far_blank[1] ) {
         // nada
      }
      else {
         insuper = plane - far_blank[1];
      }

      if (insuper%2 == 1) return PlaneView::kV;
      else                return PlaneView::kU;

      break;
   }
   case Detector::kCalDet:
      // 5 supermodules of 12 planes + 4 on floor
      // plane 0 is legal, (plane 60 for was for older REROOT)
      if ( plane > 5*12+4 || plane == 60 ) {
         return PlaneView::kUnknown;
      } 
      else if ( plane > 5*12 ) {
         // floor or "cosmic" planes are 61,62,63,64
         return ((fgCalDetCosmicsAView) ? PlaneView::kA : PlaneView::kB ) ;
      }
      // plane 0 has strips running horizontal (kV)
      else if ( plane%2 == 0 ) {
         return PlaneView::kV;
      } 
      else {
         return PlaneView::kU;
      }
      break;
   default:
      if (! (warn_mask&detector) ) {
         MSG("Plex",Msg::kWarning) 
         << "PlexPlaneId::DefaultPlaneView "
         << "not unique for detector type "
         << Detector::AsString(detector) << endl
         << "    ... first and only warning " << endl;
         warn_mask |= detector;
      }
//      assert(0);
      break;
   }

   return PlaneView::kUnknown;

}

//_____________________________________________________________________________
PlaneCoverage::PlaneCoverage_t PlexPlaneId::DefaultPlaneCoverage(
   Detector::Detector_t detector, UInt_t plane)
{
   // Determine plane coverage given just (detector,plane#)

   static Int_t warn_mask = 0;

   switch (detector) {
   case Detector::kNear:
      // planes 1,6,11... are full coverage
      // otherwise if plane<121 partial
      // otherwise uninstrumented

      if ( plane<1 || plane>LastPlaneNearSpect() ) {
         return PlaneCoverage::kUninstrumented;
      }
      else if (plane%5 == 1) {
         return PlaneCoverage::kNearFull;
      }
      else if ( plane<=LastPlaneNearCalor() ) {
         return PlaneCoverage::kNearPartial;
      }
      else {
         return PlaneCoverage::kUninstrumented;
      }
      break;
   case Detector::kFar:
   {
      // veto shield stuff first
      if ( PlexVetoShieldHack::IsMuxPlnVetoShield(plane) ) {
        // ambiguous .. "mux" planes cover various views
        return PlaneCoverage::kUnknown;
      }
      if ( PlexVetoShieldHack::IsMdlPlnVetoShield(plane) ) {
        // little to go on... use semi-bogus context
        const VldContext& vldc = PlexVetoShieldHack::GetDefaultContext();
        return PlexVetoShieldHack::GetMdlPlaneCoverage(vldc,plane);
      }

      // first plane of each SM is blank
      UInt_t far_blank[3];
      far_blank[0] = 0;
      far_blank[1] = LastPlaneFarSM0() + 1;
      far_blank[2] = LastPlaneFarSM1() + 1; // beyond the end

      if ( plane <= far_blank[0] ) return PlaneCoverage::kUninstrumented;
      if ( plane == far_blank[1] ) return PlaneCoverage::kUninstrumented;
      if ( plane >= far_blank[2] ) return PlaneCoverage::kUninstrumented;
      return PlaneCoverage::kTotal;

      break;
   }
   case Detector::kCalDet:
      if ( plane > 5*12+4 ) return PlaneCoverage::kUninstrumented;
      if ( plane == 60    ) return PlaneCoverage::kUninstrumented;
      return PlaneCoverage::kTotal;
      break;
   default:
      if (! (warn_mask&detector) ) {
      MSG("Plex",Msg::kWarning) 
         << "PlexPlaneId::DefaultPlaneCoverage "
         << " not unique for detector type "
         << Detector::AsString(detector) << endl
         << "    ... first and only warning " << endl;
         
      warn_mask |= detector;
      }
//      assert(0);
      break;
   }

   return PlaneCoverage::kUnknown;

}

//_____________________________________________________________________________

---