CMap.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \brief   cmap::CMap class source code
/// \author  jpaley@fnal.gov
/// \date    Sept. 2016
////////////////////////////////////////////////////////////////////////
#include "CMap/CMap.h"

// NOvA includes
#include "RawData/RawDigit.h"
#include "RecoBase/CellHit.h"

#include <messagefacility/MessageLogger/MessageLogger.h> 

// ART includes
#include "art/Framework/Services/Registry/ServiceHandle.h"

namespace cmap {
  namespace dataprov {

    //----------------------------------------------------------------------
    CMap::CMap() 
    {
      fVerbosity = 0;
      fCurrentRun = 0;
      fUseExceptions = false;
      fExceptionsMap.clear();
      fStdMap = 0;
    }
    
    //----------------------------------------------------------------------
    CMap::CMap(const daqchannelmap::DAQChannelMap* map) 
    {
      fVerbosity = 0;
      fCurrentRun = 0;
      fUseExceptions = false;
      fExceptionsMap.clear();
      fStdMap = map;
    }
    
    //----------------------------------------------------------------------  
    CMap::~CMap() 
    { 
      
    }
    
    //----------------------------------------------------------------------
    void CMap::AddException(int idet, std::string chan1, std::string chan2)
    {
      LOG_INFO("CMap") << "Adding exception " << chan1 << "->" << chan2;
      
      int ndashes1=0;
      int ndashes2=0;
      
      for (size_t i=0; i<chan1.length(); ++i) {
        if (chan1[i] == '-') ndashes1++;
      }
      for (size_t i=0; i<chan2.length(); ++i) {
        if (chan2[i] == '-') ndashes2++;
      }

      if ((ndashes1 != ndashes2) || ndashes1==0) {
        LOG_ERROR("CMap") << "Mismatch in string formats for the two channels!  Please use either [diblock]-[dcm]-[feb], [diblock]-[dcm]-[feb]-[pixel], or [plane]-[cell].";
        return;
      }
      
      int plane, cell;
      int db, dcm, feb, pixel;
      
      if (ndashes1 == 1) {
        sscanf(chan1.c_str(),"%d-%d",&plane,&cell);
        daqchannelmap::lchan logChan = this->Map()->encodeLChan(idet,plane,cell);
        daqchannelmap::dchan daqChan1 = this->Map()->encodeDChan(logChan);
        sscanf(chan2.c_str(),"%d-%d",&plane,&cell);
        logChan = this->Map()->encodeLChan(idet,plane,cell);
        daqchannelmap::dchan daqChan2 = this->Map()->encodeDChan(logChan);
        this->AddException(daqChan1,daqChan2);
      }
      else if (ndashes1==3) {
        sscanf(chan1.c_str(),"%d-%d-%d-%d",&db,&dcm,&feb,&pixel);    
        daqchannelmap::dchan daqChan1 = this->Map()->encodeDChan(idet,db,dcm,feb,pixel);
        sscanf(chan2.c_str(),"%d-%d-%d-%d",&db,&dcm,&feb,&pixel);    
        daqchannelmap::dchan daqChan2 = this->Map()->encodeDChan(idet,db,dcm,feb,pixel);
        this->AddException(daqChan1,daqChan2);
      }
      else if (ndashes1==2) { // handle case for an entire FEB
        sscanf(chan1.c_str(),"%d-%d-%d",&db,&dcm,&feb);    
        daqchannelmap::dchan daqChan1 = this->Map()->encodeDChan(idet,db,dcm,feb,0);
        sscanf(chan2.c_str(),"%d-%d-%d",&db,&dcm,&feb);    
        daqchannelmap::dchan daqChan2 = this->Map()->encodeDChan(idet,db,dcm,feb,0);
        for (int i=0; i<32; ++i) {
          this->AddException(daqChan1+i,daqChan2+i);
        }
      }
      else {
        LOG_ERROR("CMap") << "Channel string format unsupported.  Please use either [diblock]-[dcm]-[feb], [diblock]-[dcm]-[feb]-[pixel], or [plane]-[cell].";
        return;
      }
      
    }
    
    //----------------------------------------------------------------------
    void CMap::AddException(int idet, geo::OfflineChan chan1, geo::OfflineChan chan2)
    {
      daqchannelmap::lchan logChan = this->Map()->encodeLChan(idet,chan1.Plane(),chan1.Cell());
      daqchannelmap::dchan daqChan1 = this->Map()->encodeDChan(logChan);
      logChan = this->Map()->encodeLChan(idet,chan2.Plane(),chan2.Cell());
      daqchannelmap::dchan daqChan2 = this->Map()->encodeDChan(logChan);
        this->AddException(daqChan1,daqChan2);
      
    }
    
    //----------------------------------------------------------------------
    daqchannelmap::lchan CMap::encodeLChan(int detId, int plane, int cell)
    {
      daqchannelmap::lchan lc = this->Map()->encodeLChan(detId,plane,cell);
      if (fUseExceptions) {
        if (fVerbosity)
          LOG_DEBUG("CMap") << "Exceptions enabled.";
        daqchannelmap::dchan dchan = this->Map()->encodeDChan(lc);
        if (fExceptionsMap.find(dchan) != fExceptionsMap.end()) {
          dchan = fExceptionsMap[dchan];
          lc = this->Map()->encodeLChan(dchan);
        }
      }
      
      return lc;
    }
    
    //----------------------------------------------------------------------
    daqchannelmap::dchan CMap::encodeDChan(daqchannelmap::lchan lchan)
    {
      daqchannelmap::dchan dc = this->Map()->encodeDChan(lchan);
      if (fUseExceptions) {
        if (fVerbosity)
          LOG_DEBUG("CMap") << "Exceptions enabled.";
        if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
          dc = fExceptionsMap[dc];
        }
      }
      
      return dc;
    }
    
  //----------------------------------------------------------------------
  int CMap::computeBlock(daqchannelmap::lchan lchan)
  {
    int block = this->Map()->computeBlock(lchan);
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      daqchannelmap::dchan dc = this->Map()->encodeDChan(lchan);
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        block = this->Map()->computeBlock(this->Map()->encodeLChan(dc));
      }
    }
    return block;
  }

  //----------------------------------------------------------------------
  int CMap::getDetector(daqchannelmap::dchan dc)
  {
    int det = this->Map()->getDetector(dc);
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        det = this->Map()->getDetector(dc);
      }
    }
    return det;
  }

  //----------------------------------------------------------------------
  int CMap::getDiBlock(daqchannelmap::dchan dc)
  {
    int block = this->Map()->getDiBlock(dc);
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        block = this->Map()->getDiBlock(dc);
      }
    }
    return block;
  }

  //----------------------------------------------------------------------
  int CMap::getDCM(daqchannelmap::dchan dc)
  {
    int dcm = this->Map()->getDCM(dc);
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        dcm = this->Map()->getDCM(dc);
      }
    }
    return dcm;
  }
  
  //----------------------------------------------------------------------
  int CMap::getFEB(daqchannelmap::dchan dc)
  {
    int feb = this->Map()->getFEB(dc);
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        feb = this->Map()->getFEB(dc);
      }
    }
    return feb;
  }
  
  //----------------------------------------------------------------------
  int CMap::getPixel(daqchannelmap::dchan dc)
  {
    int pixel = this->Map()->getPixel(dc);

    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        pixel = this->Map()->getPixel(dc);
      }
    }
    return pixel;
  }

  //----------------------------------------------------------------------
  int CMap::getView(daqchannelmap::dchan dc)
  {
    int view = this->Map()->getView(dc);
    
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        view = this->Map()->getView(dc);
      }      
    }
    return view;
  }

  //----------------------------------------------------------------------
  int CMap::getPlane(daqchannelmap::lchan lc)
  {
    int plane = this->Map()->getPlane(lc);
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      daqchannelmap::dchan dc = this->Map()->encodeDChan(lc);
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        plane = this->Map()->getPlane(this->Map()->encodeLChan(dc));
      }
    }
    return plane;
  }

  //----------------------------------------------------------------------
  int CMap::getCell(daqchannelmap::lchan lc)
  {
    int cell = this->Map()->getCell(lc);
    if (fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      daqchannelmap::dchan dc = this->Map()->encodeDChan(lc);
      if (fExceptionsMap.find(dc) != fExceptionsMap.end()) {
        dc = fExceptionsMap[dc];
        cell = this->Map()->getCell(this->Map()->encodeLChan(dc));
      }
    }
    return cell;
  }
  
  //----------------------------------------------------------------------
  unsigned short CMap::GetPlane(const rawdata::RawDigit* dig)
  {
    if (!dig) return 30000;

    daqchannelmap::lchan local_channel  = dig->Channel();
    
    if (dig->IsRealData() && fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      daqchannelmap::dchan dchan = dig->DaqChannel();
      if (fExceptionsMap.find(dchan) != fExceptionsMap.end()) {
        dchan = fExceptionsMap[dchan];
        local_channel = this->Map()->encodeLChan(dchan);
      }
    }
    
    return this->Map()->getPlane(local_channel);
    
  }
  
  //----------------------------------------------------------------------
  unsigned short CMap::GetPlane(const rb::CellHit* dig)
  {
    if (!dig) return 30000;

    daqchannelmap::lchan local_channel  = dig->Channel();
    
    if (dig->IsRealData() && fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      daqchannelmap::dchan dchan = dig->DaqChannel();
      if (fExceptionsMap.find(dchan) != fExceptionsMap.end()) {
        dchan = fExceptionsMap[dchan];
        local_channel = this->Map()->encodeLChan(dchan);
      }
    }
    
    return this->Map()->getPlane(local_channel);
    
  }
  
  //----------------------------------------------------------------------
  unsigned short CMap::GetCell(const rawdata::RawDigit* dig) 
  {
    if (!dig) return 30000;
    
    //    const
    daqchannelmap::lchan local_channel = dig->Channel();

    if (dig->IsRealData() && fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      daqchannelmap::dchan dchan = dig->DaqChannel();
      if (fExceptionsMap.find(dchan) != fExceptionsMap.end()) {
        dchan = fExceptionsMap[dchan];
        local_channel = this->Map()->encodeLChan(dchan);
      }
    }
    
    return this->Map()->getCell(local_channel);
  }
  
  //----------------------------------------------------------------------
  unsigned short CMap::GetCell(const rb::CellHit* dig) 
  {
    if (!dig) return 30000;
    
    //    const
    daqchannelmap::lchan local_channel = dig->Channel();

    if (dig->IsRealData() && fUseExceptions) {
      if (fVerbosity)
        LOG_DEBUG("CMap") << "Exceptions enabled.";
      daqchannelmap::dchan dchan = dig->DaqChannel();
      if (fExceptionsMap.find(dchan) != fExceptionsMap.end()) {
        dchan = fExceptionsMap[dchan];
        local_channel = this->Map()->encodeLChan(dchan);
      }
    }
    
    return this->Map()->getCell(local_channel);
  }

  }
} // end namespace cmap
////////////////////////////////////////////////////////////////////////