CDCWireHitRequirements.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: CDC and tracking group                                                *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <TObject.h>
#include <framework/logging/Logger.h>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/json_parser.hpp>
 
namespace Belle2 {
  class CDCWireHitRequirements: public TObject {
 
    typedef std::pair<short, short> intRange_t;
    typedef std::pair<float, float> floatRange_t;
 
  public:
 
    CDCWireHitRequirements() = default;
 
    explicit CDCWireHitRequirements(boost::property_tree::ptree tree)
    {
 
      try {
 
        m_ADCRangeFirstSuperLayer  = std::make_pair(tree.get<short>("FirstSuperLayer.ADC.min"),
                                                    tree.get<short>("FirstSuperLayer.ADC.max"));
        m_ADCRangeOuterSuperLayers = std::make_pair(tree.get<short>("OuterSuperLayers.ADC.min"),
                                                    tree.get<short>("OuterSuperLayers.ADC.max"));
 
        m_TOTRangeFirstSuperLayer = std::make_pair(tree.get<short>("FirstSuperLayer.TOT.min"),
                                                   tree.get<short>("FirstSuperLayer.TOT.max"));
        m_TOTRangeOuterSuperLayers = std::make_pair(tree.get<short>("OuterSuperLayers.TOT.min"),
                                                    tree.get<short>("OuterSuperLayers.TOT.max"));
 
        m_ADCOverTOTRangeFirstSuperLayer = std::make_pair(tree.get<float>("FirstSuperLayer.ADCOverTOT.min"),
                                                          tree.get<float>("FirstSuperLayer.ADCOverTOT.max"));
        m_ADCOverTOTRangeOuterSuperLayers = std::make_pair(tree.get<float>("OuterSuperLayers.ADCOverTOT.min"),
                                                           tree.get<float>("OuterSuperLayers.ADCOverTOT.max"));
 
        for (boost::property_tree::ptree::value_type& row : tree.get_child("FirstSuperLayer.MaxADCGivenTOT")) {
          m_MaxADCGivenTOTFirstSuperLayer.insert(std::make_pair(row.second.get<short>("givenTOT"),
                                                                row.second.get<short>("maxADC")));
        }
        for (boost::property_tree::ptree::value_type& row : tree.get_child("OuterSuperLayers.MaxADCGivenTOT")) {
          m_MaxADCGivenTOTOuterSuperLayers.insert(std::make_pair(row.second.get<short>("givenTOT"),
                                                                 row.second.get<short>("maxADC")));
        }
 
      } catch (boost::property_tree::ptree_error& e) {
        // Any problem when parsing the tree?
        B2FATAL("Cannot parse CDCWireHit requirement information: " << e.what());
      }
 
    }
 
    ~CDCWireHitRequirements() = default;
 
    const intRange_t& getADCRangeFirstSuperLayer() const
    {
      return m_ADCRangeFirstSuperLayer;
    }
 
    void setADCRangeFirstSuperLayer(const intRange_t& ADCRangeFirstSuperLayer)
    {
      m_ADCRangeFirstSuperLayer =  ADCRangeFirstSuperLayer;
    }
 
    const intRange_t& getADCRangeOuterSuperLayers() const
    {
      return m_ADCRangeOuterSuperLayers;
    }
 
    void setADCRangeOuterSuperLayers(const intRange_t& ADCRangeOuterSuperLayers)
    {
      m_ADCRangeOuterSuperLayers =  ADCRangeOuterSuperLayers;
    }
 
    const intRange_t& getTOTRangeFirstSuperLayer() const
    {
      return m_TOTRangeFirstSuperLayer;
    }
 
    void setTOTRangeFirstSuperLayer(const intRange_t& TOTRangeFirstSuperLayer)
    {
      m_TOTRangeFirstSuperLayer =  TOTRangeFirstSuperLayer;
    }
 
    const intRange_t& getTOTRangeOuterSuperLayers() const
    {
      return m_TOTRangeOuterSuperLayers;
    }
 
    void setTOTRangeOuterSuperLayers(const intRange_t& TOTRangeOuterSuperLayers)
    {
      m_TOTRangeOuterSuperLayers =  TOTRangeOuterSuperLayers;
    }
 
    const floatRange_t& getADCOverTOTRangeFirstSuperLayer() const
    {
      return m_ADCOverTOTRangeFirstSuperLayer;
    }
 
    void setADCOverTOTRangeFirstSuperLayer(const floatRange_t& ADCOverTOTRangeFirstSuperLayer)
    {
      m_ADCOverTOTRangeFirstSuperLayer =  ADCOverTOTRangeFirstSuperLayer;
    }
 
    const floatRange_t& getADCOverTOTRangeOuterSuperLayers() const
    {
      return m_ADCOverTOTRangeOuterSuperLayers;
    }
 
    void setADCOverTOTRangeOuterSuperLayers(const floatRange_t& ADCOverTOTRangeOuterSuperLayers)
    {
      m_ADCOverTOTRangeOuterSuperLayers = ADCOverTOTRangeOuterSuperLayers;
    }
 
    const std::map<short, short> getMaxADCGivenTOTFirstSuperLayer() const
    {
      return m_MaxADCGivenTOTFirstSuperLayer;
    }
 
    short getMaxADCGivenTOTFirstSuperLayer(short tot) const
    {
      // Find maxADC given TOT
      const auto it = m_MaxADCGivenTOTFirstSuperLayer.find(tot);
 
      // Check if TOT exists in map or not
      if (it != m_MaxADCGivenTOTFirstSuperLayer.end()) {
        return it->second;
      } else {
        // By convention, -1 stands for unbounded
        return -1;
      }
    }
 
    void setMaxADCGivenTOTFirstSuperLayer(const std::map<short, short>& MaxADCGivenTOTFirstSuperLayer)
    {
      m_MaxADCGivenTOTFirstSuperLayer = MaxADCGivenTOTFirstSuperLayer;
    }
 
    const std::map<short, short> getMaxADCGivenTOTOuterSuperLayers() const
    {
      return m_MaxADCGivenTOTOuterSuperLayers;
    }
 
    short getMaxADCGivenTOTOuterSuperLayers(short tot) const
    {
      // Find maxADC given TOT
      const auto it = m_MaxADCGivenTOTOuterSuperLayers.find(tot);
 
      // Check if TOT exists in map or not
      if (it != m_MaxADCGivenTOTOuterSuperLayers.end()) {
        return it->second;
      } else {
        // By convention, -1 stands for unbounded
        return -1;
      }
    }
 
    void setMaxADCGivenTOTOuterSuperLayers(const std::map<short, short>& MaxADCGivenTOTOuterSuperLayers)
    {
      m_MaxADCGivenTOTOuterSuperLayers = MaxADCGivenTOTOuterSuperLayers;
    }
 
    void dump() const
    {
      std::string MaxADCGivenTOTFirstSuperLayer = "";
      for (auto& v : getMaxADCGivenTOTFirstSuperLayer()) {
        MaxADCGivenTOTFirstSuperLayer += "If TOT == " + std::to_string(v.first) +
                                         ", then ADC <= " + std::to_string(v.second) + "\n";
      }
 
      std::string MaxADCGivenTOTOuterSuperLayers = "";
      for (auto& v : getMaxADCGivenTOTOuterSuperLayers()) {
        MaxADCGivenTOTOuterSuperLayers += "If TOT == " + std::to_string(v.first) +
                                          ", then ADC <= " + std::to_string(v.second) + "\n";
      }
 
      B2INFO(" " << std::endl
             << "=======================================================" << std::endl
             << "CDCWireHit requirements (-1 values stand for unbounded)" << std::endl
             << "=======================================================" << std::endl
             << "First Super Layer: " << std::endl
             << getADCRangeFirstSuperLayer().first << " <= ADC <= " << getADCRangeFirstSuperLayer().second << std::endl
             << getTOTRangeFirstSuperLayer().first << " <= TOT <= " << getTOTRangeFirstSuperLayer().second << std::endl
             << getADCOverTOTRangeFirstSuperLayer().first << " <= ADC/TOT <= " << getADCOverTOTRangeFirstSuperLayer().second << std::endl
             << MaxADCGivenTOTFirstSuperLayer << std::endl
             << "Outer Super Layers: " << std::endl
             << getADCRangeOuterSuperLayers().first << " <= ADC <= " << getADCRangeOuterSuperLayers().second << std::endl
             << getTOTRangeOuterSuperLayers().first << " <= TOT <= " << getTOTRangeOuterSuperLayers().second << std::endl
             << getADCOverTOTRangeOuterSuperLayers().first << " <= ADC/TOT <= " << getADCOverTOTRangeOuterSuperLayers().second << std::endl
             << MaxADCGivenTOTOuterSuperLayers
             << "=======================================================" << std::endl);
 
    }
 
  private:
 
    intRange_t m_ADCRangeFirstSuperLayer  = {1, -1};
    intRange_t m_ADCRangeOuterSuperLayers = {1, -1};
 
    intRange_t m_TOTRangeFirstSuperLayer = {1, -1};
    intRange_t m_TOTRangeOuterSuperLayers = {1, -1};
 
    floatRange_t m_ADCOverTOTRangeFirstSuperLayer = {0.0, -1.0};
    floatRange_t m_ADCOverTOTRangeOuterSuperLayers = {0.0, -1.0};
 
    std::map<short, short> m_MaxADCGivenTOTFirstSuperLayer = {};
    std::map<short, short> m_MaxADCGivenTOTOuterSuperLayers = {};
 
    ClassDef(CDCWireHitRequirements, 2);
  };
 
} // end namespace Belle2