TOPRecoManager.h

/**************************************************************************
 * 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.                  *
 **************************************************************************/
 
#pragma once
 
#include <top/reconstruction_cpp/InverseRaytracer.h>
#include <top/reconstruction_cpp/FastRaytracer.h>
#include <top/reconstruction_cpp/YScanner.h>
#include <top/reconstruction_cpp/BackgroundPDF.h>
#include <top/dbobjects/TOPCalChannelMask.h>
#include <top/dbobjects/TOPCalChannelT0.h>
#include <top/dbobjects/TOPCalTimebase.h>
#include <framework/database/DBObjPtr.h>
#include <top/dataobjects/TOPAsicMask.h>
#include <top/geometry/TOPGeometryPar.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TOP {
 
    class TOPRecoManager {
 
    public:
 
      static TOPRecoManager& getInstance();
 
      static const InverseRaytracer* getInverseRaytracer(int moduleID);
 
      static const FastRaytracer* getFastRaytracer(int moduleID);
 
      static const YScanner* getYScanner(int moduleID);
 
      static const BackgroundPDF* getBackgroundPDF(int moduleID);
 
      static const std::vector<BackgroundPDF>& getBackgroundPDFs() {return getInstance().backgroundPDFs();}
 
      static double getMinTime()
      {
        if (getInstance().m_minTime < getInstance().m_maxTime) {
          return getInstance().m_minTime;
        }
        return TOPGeometryPar::Instance()->getGeometry()->getNominalTDC().getTimeMin();
      }
 
      static double getMaxTime()
      {
        if (getInstance().m_minTime < getInstance().m_maxTime) {
          return getInstance().m_maxTime;
        }
        return TOPGeometryPar::Instance()->getGeometry()->getNominalTDC().getTimeMax();
      }
 
      static double getTimeWindowSize() {return getMaxTime() - getMinTime();}
 
      static void setTimeWindow(double minTime, double maxTime)
      {
        getInstance().m_minTime = minTime;
        getInstance().m_maxTime = maxTime;
      }
 
      static void setDefaultTimeWindow()
      {
        getInstance().m_minTime = 0;
        getInstance().m_maxTime = 0;
      }
 
      static void setChannelMask(const DBObjPtr<TOPCalChannelMask>& mask,
                                 const TOPAsicMask& asicMask);
 
      static void setUncalibratedChannelsOff(const DBObjPtr<TOPCalChannelT0>& channelT0);
 
      static void setUncalibratedChannelsOff(const DBObjPtr<TOPCalTimebase>& timebase);
 
      static void setChannelEffi();
 
    private:
 
      TOPRecoManager() = default;
      TOPRecoManager(TOPRecoManager&) = delete;
      TOPRecoManager& operator=(const TOPRecoManager&) = delete;
      ~TOPRecoManager() = default;
 
      void set();
 
      std::vector<InverseRaytracer>& inverseRaytracers();
 
      std::vector<FastRaytracer>& fastRaytracers();
 
      std::vector<YScanner>& yScanners();
 
      std::vector<BackgroundPDF>& backgroundPDFs();
 
      std::vector<InverseRaytracer> m_inverseRaytracers; 
      std::vector<FastRaytracer> m_fastRaytracers; 
      std::vector<YScanner> m_yScanners; 
      std::vector<BackgroundPDF> m_backgroundPDFs; 
      double m_minTime = 0; 
      double m_maxTime = 0; 
      bool m_redoBkg = false; 
    };
 
    //--- inline functions ------------------------------------------------------------
 
    inline std::vector<InverseRaytracer>& TOPRecoManager::inverseRaytracers()
    {
      if (m_inverseRaytracers.empty()) set();
      return m_inverseRaytracers;
    }
 
    inline std::vector<FastRaytracer>& TOPRecoManager::fastRaytracers()
    {
      if (m_fastRaytracers.empty()) set();
      return m_fastRaytracers;
    }
 
    inline std::vector<YScanner>& TOPRecoManager::yScanners()
    {
      if (m_yScanners.empty()) set();
      return m_yScanners;
    }
 
    inline std::vector<BackgroundPDF>& TOPRecoManager::backgroundPDFs()
    {
      if (m_backgroundPDFs.empty()) set();
      if (m_redoBkg) {
        for (auto& pdf : m_backgroundPDFs) pdf.set();
        m_redoBkg = false;
      }
      return m_backgroundPDFs;
    }
 
  } // namespace TOP
} // namespace Belle2