PlexVetoShieldHack.cxx

Go to the documentation of this file.

// $Id: PlexVetoShieldHack.cxx,v 1.10 2005/08/26 18:47:04 rhatcher Exp $
//
// PlexVetoShieldHack
//
// PlexVetoShieldHack is for renumbering Veto Shield modules
//
// Author:  R. Hatcher 2002.09.04
//

#include "Plex/PlexVetoShieldHack.h"

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

#include <cassert>

#include "DatabaseInterface/DbiResultPtr.h"
#include "Plex/PlexVetoShieldMuxToMdl.h"
#include "MessageService/MsgService.h"
CVSID("$Id: PlexVetoShieldHack.cxx,v 1.10 2005/08/26 18:47:04 rhatcher Exp $");

// a default context 
VldContext PlexVetoShieldHack::fgDefaultContext =
  VldContext(Detector::kFar,SimFlag::kData,VldTimeStamp());

ClassImp(PlexVetoShieldHack)

//_____________________________________________________________________________
VldContext PlexVetoShieldHack::SetDefaultContext(const VldContext& vldc)
{
  // return old context, set default to passed value

  MSG("Plex",Msg::kDebug) 
    << "PlexVetoShieldHack::SetDefaultContext " << vldc << endl;

  VldContext old = fgDefaultContext;
  fgDefaultContext = vldc;
  return old;
}

//_____________________________________________________________________________
PlexStripEndId PlexVetoShieldHack::RenumberMuxToMdl(const VldContext& vldc,
                                                    PlexStripEndId& seid)
{

  if (!seid.IsVetoShield()) return seid;

  unsigned int mux_pln   = seid.GetPlane();

  if ( PlexVetoShieldHack::IsMdlPlnVetoShield(mux_pln) ) {
    // already what we want, quietly do nothing
    return seid;
  }
  else if ( ! PlexVetoShieldHack::IsMuxPlnVetoShield(mux_pln) ) {
    // not something we know  about, loudly do nothing
    MSG("Plex",Msg::kWarning)
      << " MuxToMdl unknown plane= " << mux_pln << endl;
    return seid;
  }

  unsigned int mux_strip = seid.GetStrip();
  unsigned int mux_mdl   = mux_strip/20;  // all veto shield modules have 20

  const PlexVetoShieldMuxToMdl *the_muxtomdl = 
    LookForMuxMdl(vldc,mux_pln,mux_mdl);
  if (!the_muxtomdl) {
    MSG("Plex",Msg::kInfo)
      << "RenumberMuxToMdl no match for Mux #'ed plane= " 
      << seid.GetPlane() << " strip=" << setw(3) << seid.GetStrip() << endl;
    return seid;
  }

  unsigned int strip_in_mdl = mux_strip%20;
  // if reverse 0-->19  and 19-->0
  if (the_muxtomdl->GetCountDir() < 0) strip_in_mdl = 19 - strip_in_mdl;

  PlexStripEndId new_seid(the_muxtomdl->GetSingleMdlPlaneId(),
                          strip_in_mdl,
                          seid.GetEnd(),seid.GetSubPart());
  return new_seid;
}

//_____________________________________________________________________________
PlexStripEndId PlexVetoShieldHack::RenumberMdlToMux(const VldContext& vldc,
                                                    PlexStripEndId& seid)
{

  if (!seid.IsVetoShield()) return seid;

  unsigned int mdl_pln   = seid.GetPlane();

  if ( PlexVetoShieldHack::IsMuxPlnVetoShield(mdl_pln) ) {
    // already what we want, quietly do nothing
    return seid;
  }
  else if ( ! PlexVetoShieldHack::IsMdlPlnVetoShield(mdl_pln) ) {
    // not something we know  about, loudly do nothing
    MSG("Plex",Msg::kWarning)
      << " MdlToMux unknown plane= " << mdl_pln << endl;
    return seid;
  }

  const PlexVetoShieldMuxToMdl *the_muxtomdl = LookForSingleMdl(vldc,mdl_pln);
  if (!the_muxtomdl) {
    MSG("Plex",Msg::kInfo)
      << "RenumberMdlToMux no match for Mdl #'ed plane= " 
      << seid.GetPlane() << " strip=" << setw(3) << seid.GetStrip() << endl;
    return seid;
  }

  unsigned int mdl_strip = seid.GetStrip();
  unsigned int muxmdl = the_muxtomdl->GetMuxMdl();
  unsigned int mux_strip = 
    (the_muxtomdl->GetCountDir() > 0) ?
    20*(muxmdl+0) + mdl_strip + 0:
    20*(muxmdl+1) - mdl_strip - 1;
  
  PlexStripEndId new_seid(the_muxtomdl->GetMuxPlaneId(),
                          mux_strip,
                          seid.GetEnd(),seid.GetSubPart());
  return new_seid;
}

//_____________________________________________________________________________
PlexScintMdlId PlexVetoShieldHack::RenumberMuxToMdl(const VldContext& vldc,
                                                    PlexScintMdlId& mdlid)
{
  if (!mdlid.IsVetoShield()) return mdlid;

  unsigned int mux_pln   = mdlid.GetPlane();

  if ( PlexVetoShieldHack::IsMdlPlnVetoShield(mux_pln) ) {
    // already what we want, quietly do nothing
    return mdlid;
  }
  else if ( ! PlexVetoShieldHack::IsMuxPlnVetoShield(mux_pln) ) {
    // not something we know  about, loudly do nothing
    MSG("Plex",Msg::kWarning)
      << " MuxToMdl unknown plane= " << mux_pln << endl;
    return mdlid;
  }

  unsigned int mux_mdl   = mdlid.GetModule();

  const PlexVetoShieldMuxToMdl *the_muxtomdl = 
    LookForMuxMdl(vldc,mux_pln,mux_mdl);
  if (!the_muxtomdl) {
    MSG("Plex",Msg::kInfo)
      << "RenumberMuxToMdl no match for Mux #'ed plane= " << mdlid.GetPlane() 
      << " module=" << mdlid.GetModule() << endl;
    return mdlid;
  }
  
  return the_muxtomdl->GetSingleMdlScintMdlId();
}

//_____________________________________________________________________________
PlexScintMdlId PlexVetoShieldHack::RenumberMdlToMux(const VldContext& vldc,
                                                    PlexScintMdlId& mdlid)
{
  if (!mdlid.IsVetoShield()) return mdlid;

  unsigned int mdl_pln = mdlid.GetPlane();

  if ( PlexVetoShieldHack::IsMuxPlnVetoShield(mdl_pln) ) {
    // already what we want, quietly do nothing
    return mdlid;
  }
  else if ( ! PlexVetoShieldHack::IsMdlPlnVetoShield(mdl_pln) ) {
    // not something we know  about, loudly do nothing
    MSG("Plex",Msg::kWarning)
      << " MdlToMux unknown plane= " << mdl_pln << endl;
    return mdlid;
  }

  unsigned int mdl_mdl = mdlid.GetModule();

  DbiResultPtr<PlexVetoShieldMuxToMdl> mapping(vldc);
  for (unsigned int i=0; i<mapping.GetNumRows(); ++i) {
    const PlexVetoShieldMuxToMdl *the_muxtomdl = mapping.GetRow(i);
    if (the_muxtomdl->GetMdlPln() == mdl_pln) {

      const unsigned int kMdlMdl = 0;
      if (mdl_mdl != kMdlMdl) {
        MSG("Plex",Msg::kInfo)
          << "RenumberMdlToMux no match for Mdl #'ed plane= " 
          << mdlid.GetPlane() 
          << " module=" << mdlid.GetModule() 
          << " > 0 " << endl;
      }

      return the_muxtomdl->GetMuxScintMdlId();
    }
  }
  MSG("Plex",Msg::kInfo)
    << "RenumberMdlToMux no match for Mdl #'ed plane= " << mdlid.GetPlane() 
    << " module=" << mdlid.GetModule() << endl;
  return mdlid;
}

//_____________________________________________________________________________
PlexPlaneId PlexVetoShieldHack::RenumberMuxToMdl(const VldContext& vldc,
                                                 PlexPlaneId& plnid)
{
  if (!plnid.IsVetoShield()) return plnid;

  unsigned int mux_pln   = plnid.GetPlane();

  if ( PlexVetoShieldHack::IsMdlPlnVetoShield(mux_pln) ) {
    // already what we want, quietly do nothing
    return plnid;
  }
  else if ( ! PlexVetoShieldHack::IsMuxPlnVetoShield(mux_pln) ) {
    // not something we know  about, loudly do nothing
    MSG("Plex",Msg::kWarning)
      << " MuxToMdl unknown plane= " << mux_pln << endl;
    return plnid;
  }

  // arbitrarily take first module in mux numbering scheme
  unsigned int mux_mdl   = 0;

  DbiResultPtr<PlexVetoShieldMuxToMdl> mapping(vldc);
  for (unsigned int i=0; i<mapping.GetNumRows(); ++i) {
    const PlexVetoShieldMuxToMdl *the_muxtomdl = mapping.GetRow(i);
    if (the_muxtomdl->GetMuxPln() == mux_pln && 
        the_muxtomdl->GetMuxMdl() == mux_mdl ) {

      MSG("Plex",Msg::kInfo)
        << " no unique match for mapping MuxToMdl for plane "
        << mux_pln << endl;
      return the_muxtomdl->GetSingleMdlPlaneId();
    }
  }
  MSG("Plex",Msg::kInfo)
    << "RenumberMuxToMdl no match for Mux #'ed plane= "
    << plnid.GetPlane() << endl;
  return plnid;

}

//_____________________________________________________________________________
PlexPlaneId PlexVetoShieldHack::RenumberMdlToMux(const VldContext& vldc,
                                                 PlexPlaneId& plnid)
{
  if (!plnid.IsVetoShield()) return plnid;

  unsigned int mdl_pln = plnid.GetPlane();

  if ( PlexVetoShieldHack::IsMuxPlnVetoShield(mdl_pln) ) {
    // already what we want, quietly do nothing
    return plnid;
  }
  else if ( ! PlexVetoShieldHack::IsMdlPlnVetoShield(mdl_pln) ) {
    // not something we know  about, loudly do nothing
    MSG("Plex",Msg::kWarning)
      << " MdlToMux unknown plane= " << mdl_pln << endl;
    return plnid;
  }

  DbiResultPtr<PlexVetoShieldMuxToMdl> mapping(vldc);
  for (unsigned int i=0; i<mapping.GetNumRows(); ++i) {
    const PlexVetoShieldMuxToMdl *the_muxtomdl = mapping.GetRow(i);
    if (the_muxtomdl->GetMdlPln() == mdl_pln) {
           
      return the_muxtomdl->GetMuxPlaneId();
    }
  }
  MSG("Plex",Msg::kInfo)
    << "RenumberMdlToMux no match for Mdl #'ed plane= "
    << plnid.GetPlane() << endl;
  return plnid;
}

//_____________________________________________________________________________

Bool_t PlexVetoShieldHack::IsMuxPlnVetoShield(UInt_t plane)
{
  // mux planes are [ 513 ... 524 ] (12 pseudo-planes in section 0)
  return ( ( 513 <= plane ) && ( plane <= 524 ) );
}

Bool_t PlexVetoShieldHack::IsMdlPlnVetoShield(UInt_t plane)
{
  // mdl planes are:
  // [ 528 .. 575 ] for section 0 (48 module incl. phantoms)
  // [ 576 .. 607 ] (single layer) or [ 592 .. 639] (double layer) section 1
  // other sections are [ 528 .. 575 ] + isection*64.
  return ( ( 528 <= plane ) && ( plane <= 575 ) ) ||  // section 0
         ( ( 576 <= plane ) && ( plane <= 639 ) ) ||  // section 1
         ( ( 656 <= plane ) && ( plane <= 703 ) ) ||  // section 2
         ( ( 720 <= plane ) && ( plane <= 767 ) ) ;   // section 3
}

//_____________________________________________________________________________
VldContext PlexVetoShieldHack::ConvertRangeToContext(const VldRange& vldr)
{
  Detector::Detector_t detector = 
    (Detector::Detector_t)(vldr.GetDetectorMask());
  SimFlag::SimFlag_t simflag =
    (vldr.GetSimMask() & SimFlag::kData) ? SimFlag::kData : SimFlag::kMC;
  VldTimeStamp ts = vldr.GetTimeStart();
  return VldContext(detector,simflag,ts);
}

//_____________________________________________________________________________
PlaneView::PlaneView_t 
PlexVetoShieldHack::GetMdlPlaneView(const VldContext& vldc, UInt_t mdl_pln)
{
  DbiResultPtr<PlexVetoShieldMuxToMdl> mapping(vldc);
  for (unsigned int i=0; i<mapping.GetNumRows(); ++i) {
    const PlexVetoShieldMuxToMdl *the_muxtomdl = mapping.GetRow(i);
    if (the_muxtomdl->GetMdlPln() == mdl_pln) {
      return the_muxtomdl->GetSingleMdlPlaneId().GetPlaneView();
    }
  }
  return PlaneView::kVSUnknown;
}

//_____________________________________________________________________________
PlaneCoverage::PlaneCoverage_t 
PlexVetoShieldHack::GetMdlPlaneCoverage(const VldContext& vldc, UInt_t mdl_pln)
{

  DbiResultPtr<PlexVetoShieldMuxToMdl> mapping(vldc);
  for (unsigned int i=0; i<mapping.GetNumRows(); ++i) {
    const PlexVetoShieldMuxToMdl *the_muxtomdl = mapping.GetRow(i);
    if (the_muxtomdl->GetMdlPln() == mdl_pln) {
      return the_muxtomdl->GetSingleMdlPlaneId().GetPlaneCoverage();
    }
  }
  return PlaneCoverage::kUnknown;
}

//_____________________________________________________________________________
const PlexVetoShieldMuxToMdl*
PlexVetoShieldHack::LookForMuxMdl(const VldContext& vldc, 
                                  UInt_t mux_pln, UInt_t mux_mdl)
{

  DbiResultPtr<PlexVetoShieldMuxToMdl> mapping(vldc);
  for (unsigned int i=0; i<mapping.GetNumRows(); ++i) {
    const PlexVetoShieldMuxToMdl *the_muxtomdl = mapping.GetRow(i);
    if (the_muxtomdl->GetMuxPln() == mux_pln && 
        the_muxtomdl->GetMuxMdl() == mux_mdl    ) {
      return the_muxtomdl;
    }
  }
  return 0;  // found no match
}

//_____________________________________________________________________________
const PlexVetoShieldMuxToMdl*
PlexVetoShieldHack::LookForSingleMdl(const VldContext& vldc, 
                                     UInt_t mdl_pln)
{

  DbiResultPtr<PlexVetoShieldMuxToMdl> mapping(vldc);
  for (unsigned int i=0; i<mapping.GetNumRows(); ++i) {
    const PlexVetoShieldMuxToMdl *the_muxtomdl = mapping.GetRow(i);
    if (the_muxtomdl->GetMdlPln() == mdl_pln ) {
      return the_muxtomdl;
    }
  }
  return 0;  // found no match
}

//_____________________________________________________________________________

---