BadBoardADCDetector.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#include <tracking/trackFindingCDC/findlets/minimal/BadBoardADCDetector.h>
 
#include <tracking/trackingUtilities/rootification/StoreWrappedObjPtr.h>
#include <tracking/trackingUtilities/rootification/StoreWrapper.h>
#include <tracking/trackingUtilities/utilities/StringManipulation.h>
#include <framework/core/ModuleParamList.templateDetails.h>
#include <cdc/geometry/CDCGeometryPar.h>
#include <cdc/dataobjects/CDCHit.h>
 
#include <map>
 
using namespace Belle2;
using namespace TrackFindingCDC;
 
BadBoardADCDetector::BadBoardADCDetector()
{
}
 
void BadBoardADCDetector::initialize()
{
  Belle2::TrackingUtilities::StoreWrappedObjPtr< std::vector<unsigned int> > storeVector("CDCDeadBoardsVector");
  storeVector.registerInDataStore();
}
 
void BadBoardADCDetector::beginRun()
{
  // checking validity once per run should be sufficient
  if (not m_badBoardsFromDB.isValid()) B2FATAL("CDCBadBoards payload not found!");
}
 
std::string BadBoardADCDetector::getDescription()
{
  return "Detect boards with bad ADC values and mark hits accordingly";
}
 
void BadBoardADCDetector::exposeParameters(ModuleParamList* moduleParamList,
                                           const std::string& prefix)
{
  moduleParamList->addParameter(TrackingUtilities::prefixed(prefix, "badADCaverageMin"),
                                m_badADCaverageMin,
                                "Minimal value of average ADC to consider board bad",
                                m_badADCaverageMin);
  moduleParamList->addParameter(TrackingUtilities::prefixed(prefix, "badADCaverageMax"),
                                m_badADCaverageMax,
                                "Maximal value of average ADC to consider a board as bad",
                                m_badADCaverageMax);
  moduleParamList->addParameter(TrackingUtilities::prefixed(prefix, "badTOTaverageMin"),
                                m_badTOTaverageMin,
                                "Minimal value of average TOT to consider board bad",
                                m_badTOTaverageMin);
}
 
void BadBoardADCDetector::apply(std::vector<TrackingUtilities::CDCWireHit>& wireHits)
{
  CDC::CDCGeometryPar& geometryPar = CDC::CDCGeometryPar::Instance();
  // first loop: average ADC per board
  std::map <int, double> BoardADC;
  std::map <int, double> BoardTOT;
  std::map <int, int> BoardCount;
  for (auto& wireHit : wireHits) {
    auto board = geometryPar.getBoardID(wireHit.getWireID());
    BoardCount[board] += 1;
    BoardADC[board] += (*wireHit.getHit()).getADCCount();
    BoardTOT[board] += (*wireHit.getHit()).getTOT();
  };
  // now compute the averages:
  for (auto& pair  : BoardADC) {
    int board = pair.first;
    BoardADC[board] /= BoardCount[board];
    BoardTOT[board] /= BoardCount[board];
  }
 
  // second loop, set flag if board is problematic:
  for (auto& wireHit : wireHits) {
    auto board = geometryPar.getBoardID(wireHit.getWireID());
    if ((BoardADC[board] > m_badADCaverageMin) || (BoardADC[board] <= m_badADCaverageMax))
      wireHit->setBoardWithBadADCFlag();
    if (BoardTOT[board] > m_badTOTaverageMin)
      wireHit->setBoardWithBadTOTFlag();
  }
 
  // 3rd loop, over all boards, update list of them. Include boards with no hits at all
  Belle2::TrackingUtilities::StoreWrappedObjPtr< std::vector<unsigned int> > storeVector("CDCDeadBoardsVector");
 
  storeVector.create();
 
  // TODO: decide if need the dead boards from the payload. Should be not possible that this method fails to detect those!?
  double dummyEff = 0; // needed by isDeadBoard function else unused
  // Note that board 0 is absent, the loop starts from 1.
  for (unsigned int iBoard = 1; iBoard < c_nBoards; iBoard += 1) {
    if (BoardCount.find(iBoard) == BoardCount.end() || m_badBoardsFromDB->isDeadBoard(iBoard, dummyEff)) {
      storeVector->push_back(iBoard);
    }
  }
}