PlexusReroot.cxx

Go to the documentation of this file.

// $Id: PlexusReroot.cxx,v 1.15 2006/12/03 01:52:59 gmieg Exp $
//
// PlexusReroot
//
// PlexusReroot is an actual connection map
//   that derives its information from the connected REROOT file
//
// Author:  R. Hatcher 2000.05.03
//

#include "RerootExodus/PlexusReroot.h"
#include "Validity/VldContext.h"

#include "MessageService/MsgService.h"
CVSID("$Id: PlexusReroot.cxx,v 1.15 2006/12/03 01:52:59 gmieg Exp $");

#include <iomanip>

#include "RerootExodus/RerootExodus.h"

ClassImp(PlexusReroot)

//_____________________________________________________________________________
PlexusReroot::PlexusReroot()
   : Plexus(), fNStrips(0), fStripToPixelModulo(0), fStripToPixelPermute(0)
{
   // Default constructor

   MSG("Plex",Msg::kVerbose) << "default ctor" << endl;

   fVldRange = RerootExodus::BuildVldRange();
}

//_____________________________________________________________________________
PlexusReroot::PlexusReroot(const VldContext& /* vldc */)
   : Plexus(), fNStrips(0), fStripToPixelModulo(0), fStripToPixelPermute(0)
{
   // normal constructor

   MSG("Plex",Msg::kInfo) << " PlexusReroot vldc ctor " << endl;

   fVldRange = RerootExodus::BuildVldRange();
}

//_____________________________________________________________________________
PlexusReroot::~PlexusReroot()
{
   // delete all the owned sub-objects

   delete [] fStripToPixelModulo;
   delete [] fStripToPixelPermute;

}

//_____________________________________________________________________________
RawChannelId PlexusReroot::GetRawChannelId(const PlexStripEndId& pseid) const
{
   // Convert PlexStripEndId into RawChannelId (m:1 mapping)

   // Choose a particular mapping
   // Assume that the "modulo" side is always on the West
   // and the permute side is on the East
   // (this keeps one-sided near spectrometer as "modulo")

   BuildPermute(pseid.GetPlane());

   ElecType::Elec_t elec = ElecType::kReroot;
   Int_t crate = -1;
   Int_t chadd = -1;

   Int_t plane = pseid.GetPlane();
   Int_t strip = pseid.GetStrip();
   StripEnd::StripEnd_t end = pseid.GetEnd();
   Int_t pixel;

   // map strip to pixel depending on the side
   switch (end) {
   case StripEnd::kEast:
      pixel = fStripToPixelPermute[strip];
      break;
   case StripEnd::kWest:
      pixel = fStripToPixelModulo[strip];
      break;
   default:
      pixel = -1;
      // dump out message
      MSG("Plex",Msg::kFatal) 
         << "PlexusExodus::GetRawChannelId(seid) illegal side " 
         << StripEnd::AsString(pseid.GetEnd()) << endl;
   }

   // special cases

   Detector::Detector_t detector = pseid.GetDetector();

   // near detector calorimeter has no MUX
   if (Detector::kNear == detector) {
      if ( pseid.GetPlane() <= 120 ) {
         pixel = strip;
      }
   }

   // calibration detector (CalDet) has no MUX
   if (Detector::kCalDet == detector) {
      pixel = strip;
   }

   // illegal strip
   if ( strip >= fNStrips ) {
      pixel = -1;
      // dump out message
      MSG("Plex",Msg::kFatal) 
         << "PlexusExodus::GetRawChannelId(seid) illegal strip # "
         << pseid.AsString() << " in " << fActvNameStrip2Pixel 
         << " which has " << fNStrips << " strips " << endl;
   }

   MangleFakeCrate(plane,pixel,end,crate,chadd);
   
   return RawChannelId(detector,elec,crate,chadd);
   
}

//_____________________________________________________________________________
RawChannelId PlexusReroot::GetRawChannelId(const PlexPixelSpotId& psid) const
{
   // Convert PlexPixelSpotId into a RawChannelId
   // not supported under Reroot
   MSG("Exodus",Msg::kError)
     << "GetRawChannelId(PlexPixelSpotId) not supported: "
     << psid << endl;
   return RawChannelId();
}

//_____________________________________________________________________________
RawChannelId PlexusReroot::GetRawChannelId(const PlexPinDiodeId& diodeid) const
{
   // Convert PlexPinDiodeId into a RawChannelId
   // not supported under Reroot
   MSG("Exodus",Msg::kError)
     << "GetRawChannelId(PlexPinDiodeId) not supported: "
     << diodeid << endl;
   return RawChannelId();
}

//_____________________________________________________________________________
PlexPinDiodeId PlexusReroot::GetPinDiodeId(const RawChannelId& rcid) const
{
   // Convert RawChannelId into PlexPinDiodeId (if possible)
   // not supported under Reroot
   MSG("Exodus",Msg::kError)
     << "GetPinDiodeId(RawChannelId) not supported: "
     << rcid << endl;
   return PlexPinDiodeId();
}

//_____________________________________________________________________________
PlexSEIdAltL PlexusReroot::GetSEIdAltL(const RawChannelId& rcid,
                                       const PlexCalib* calib,
                                       Int_t adc, Double_t time) const
{
   // Convert RawChannelId into PlexStripEndId Alternative List (1:m mapping)

   Int_t plane = -1;
   StripEnd::StripEnd_t end = StripEnd::kUnknown;
   Int_t pixel = -1;

   DemangleFakeCrate(rcid.GetCrate(),rcid.GetChAdd(),plane,pixel,end);

   // build a base SEId that has view&coverage correctly set
   // but just setting plane # (detector determined from Reroot event)
   Int_t rpln = RerootExodus::SteelToRerootPlane(plane,kTRUE);
   PlexStripEndId pseid_base = RerootExodus::PECAB2SEId(rpln,0,0,0);
   Detector::Detector_t detector = pseid_base.GetDetector();

   // Build the permutation lists
   BuildPermute(plane);

   PlexSEIdAltL   altlist;
   
   // special cases

   // near detector calorimeter has no MUX
   if ( Detector::kNear == detector && plane < 121 ) {
      Int_t strip = pixel;
      pseid_base.SetStrip(strip);
      pseid_base.SetEnd(end);
      PlexPixelSpotId spotid;
      altlist.AddStripEndId(pseid_base,spotid,0,calib,adc,time);
      return altlist;
   }

   // calibration detector (CalDet) has no MUX
   if ( Detector::kCalDet == detector ) {
      Int_t strip = pixel;
      pseid_base.SetStrip(strip);
      pseid_base.SetEnd(end);
      PlexPixelSpotId spotid;
      altlist.AddStripEndId(pseid_base,spotid,0,calib,adc,time);
      return altlist;
   }

   for (Int_t strip = 0; strip < fNStrips; strip++) {
      Bool_t test = kFALSE;
      switch ( end ) {
      case StripEnd::kWest:  
         if ( pixel == fStripToPixelModulo[strip] )  test = kTRUE;
         break;
      case StripEnd::kEast:
         if ( pixel == fStripToPixelPermute[strip] ) test = kTRUE;
         break;
      default:
         break;
      }
      if (test) {
         pseid_base.SetStrip(strip);
         pseid_base.SetEnd(end);
         PlexPixelSpotId spotid;
         altlist.AddStripEndId(pseid_base,spotid,0,calib,adc,time);
      }
   }

   return altlist;


}

//_____________________________________________________________________________
ReadoutType::Readout_t PlexusReroot::GetReadoutType(const RawChannelId& rcid) const
{ 
   // Determine what (eg. scint strip, pin diode, cerenkov, tof) 
   // is attached to raw channel

   MSG("Exodus",Msg::kVerbose)
     << "GetReadoutType(RawChannelId) always returns kScintStrip " 
     << rcid
     << endl;
   return ReadoutType::kScintStrip;  // for now there isn't anything but
}

//_____________________________________________________________________________
void PlexusReroot::BuildPermute(const Int_t steelpln) const
{
   // Build the permutation scheme for a given plane

   Int_t rpln = RerootExodus::SteelToRerootPlane(steelpln);
   TString reqtype = RerootExodus::ActvPlaneName(rpln);

   // if this map is already there simply return
   if (reqtype == fActvNameStrip2Pixel) return;

   // clear what exists
   delete [] fStripToPixelModulo;
   delete [] fStripToPixelPermute;

   // build the map
   fActvNameStrip2Pixel = reqtype;
   fNStrips = RerootExodus::NStripsNonZero(rpln);
   
   fStripToPixelModulo  = new Int_t [fNStrips];
   fStripToPixelPermute = new Int_t [fNStrips];

   // far detector has 192 strips, near has 64 or 96 strips per plane

   Int_t nstrip_swath = 1;
   Detector::Detector_t detector = RerootExodus::GetDetector();
   switch (detector) {
   case Detector::kNear:  nstrip_swath = 24; break;
   case Detector::kFar:   nstrip_swath = 24; break;
   default: nstrip_swath = 1;
   }
      
   Int_t ioff1 = 1;
   for (Int_t strip = 0; strip < fNStrips; strip++) {
      Int_t swath   = strip/nstrip_swath;
      Int_t inswath = strip%nstrip_swath;
      Int_t ioff    = swath*ioff1;
      Int_t permute = (strip+ioff)%nstrip_swath;

      fStripToPixelModulo[strip]  = inswath;
      fStripToPixelPermute[strip] = permute;
      
      //      MSG("Plex",Msg::kInfo) << 
      //         " strip "   << setw(3) << strip   <<
      //         " modulo "  << setw(3) << inswath << 
      //         " permute " << setw(3) << permute << endl;

      //      MSG("Plex",Msg::kInfo) << 
      //         " strip "   << strip   <<
      //         " modulo "  << inswath << 
      //         " permute " << permute << endl;
   }

}

//_____________________________________________________________________________
void PlexusReroot::MangleFakeCrate(const Int_t plane, const Int_t pixel,
                                   const StripEnd::StripEnd_t end, 
                                   Int_t &crate, Int_t &chadd)
{
   // chadd can only be 13 bits for raw block packing
   // crate can only be  6 bits for RawChannelId

   // mangle the bits (plane#,end#,pixel#) around some more 
   // to form (crate,chadd)
   // allow 10 bits for plane #  0:1023
   //        1 bits for end #    0:1  (map 1->1, 2->0)
   //        8 bits for pixel #  0:255
   // then take apart into (crate,chadd) of (8,13) bits

   // avoid bit 4 as this gets eaten by QIE electronics

   const Int_t mask13 = 0x1fff;
   const Int_t mask10 = 0x03ff;
   //const Int_t mask2  = 0x0003;
   const Int_t mask1  = 0x0001;
   const Int_t mask8  = 0x00ff;
   const Int_t mask6  = 0x003f;
   
   Int_t bits = ((plane    & mask10) <<  9) |
                ((end      & mask1)  <<  8) | 
                 (pixel    & mask8);

   // create a hole for bit 4
   const Int_t low4   = 0x0000f;
   const Int_t high16 = 0xffff0;
   Int_t bitstmp = ((bits & high16) << 1) | ( bits & low4 );
   //cout << " create hole: 0x" << hex << bits << " -> 0x" << bitstmp << dec 
   //     << ((bitstmp>0x7ffff)?" too big":" ") 
   //     << (((bitstmp>>13)>mask6)?" crate overflow":" ")
   //     << endl ;
   bits = bitstmp;

   crate =    (bits >> 13) & mask6;
   chadd =     bits        & mask13;

}
void PlexusReroot::DemangleFakeCrate(const Int_t crate, Int_t chadd,
                                     Int_t &plane, Int_t &pixel,
                                     StripEnd::StripEnd_t &end)
{

   const Int_t mask13 = 0x1fff;
   const Int_t mask10 = 0x03ff;
   //const Int_t mask2  = 0x0003;
   const Int_t mask1  = 0x0001;
   const Int_t mask8  = 0x00ff;
   const Int_t mask6  = 0x003f;

   Int_t bits = ((crate & mask6) << 13 ) | (chadd & mask13);

   // remove hole from bit 4
   const Int_t low4   = 0x0000f;
   const Int_t high16 = 0xffff0 << 1;
   Int_t bitstmp = ((bits & high16) >> 1) | ( bits & low4 );
   //cout << " remove hole: 0x" << hex << bits << " -> 0x" << bitstmp << dec 
   //     << endl;
   bits = bitstmp;

   plane =    (bits >>  9) & mask10;
   //Int_t tmp   =    (bits >>  8) & mask1;
   //end   = (StripEnd::StripEnd_t)tmp;
   end = ((bits>>8)&mask1) ? StripEnd::kNegative : StripEnd::kPositive;
   pixel =     bits        & mask8;
}

//_____________________________________________________________________________
void PlexusReroot::BuildPixelMaps(const VldContext& /* vldc */) const
{ 
   // build the basic maps   RawChannel <--> PixeSpot <--> StripEnd

   MSG("Plex",Msg::kInfo) << "PlexusReroot::BuildPixelMaps " << endl;
   fVldRange.Print();
   return;
}

//_____________________________________________________________________________
void PlexusReroot::BuildReadoutMap(const VldContext& /* vldc */) const
{ 
   // build the basic map   RawChannel --> ReadoutType

   MSG("Plex",Msg::kInfo) << "PlexusReroot::BuildReadoutMap " << endl;
   fVldRange.Print();
   return;
}

//_____________________________________________________________________________
void PlexusReroot::BuildPinDiodeMap(const VldContext& /* vldc */) const
{ 
   // build the basic maps   RawChannel --> PinDiode

   MSG("Plex",Msg::kInfo) << "PlexusReroot::BuildPinDiodeMap " << endl;
   fVldRange.Print();
   return;
}

//_____________________________________________________________________________

---