FilterValueDataSet.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 <framework/logging/Logger.h>
#include <string>
#include <vector>
#include <map>
#include <limits>       // std::numeric_limits
 
 
namespace Belle2 {
  class SecIDPair {
  public:
    unsigned outer; 
    unsigned inner; 
    SecIDPair() { reset(); }
 
    void reset()
    {
      outer = std::numeric_limits<unsigned>::max();
      inner = std::numeric_limits<unsigned>::max();
    }
 
    bool isValid()
    {
      return ((outer == std::numeric_limits<unsigned>::max())
              or (inner == std::numeric_limits<unsigned>::max()))
             ? false : true;
    }
  };
 
 
 
  class SecIDTriplet {
  public:
    unsigned outer; 
    unsigned center; 
    unsigned inner; 
    SecIDTriplet() { reset(); }
 
    void reset()
    {
      outer = std::numeric_limits<unsigned>::max();
      center = std::numeric_limits<unsigned>::max();
      inner = std::numeric_limits<unsigned>::max();
    }
 
    bool isValid()
    {
      return ((outer == std::numeric_limits<unsigned>::max())
              or (center == std::numeric_limits<unsigned>::max())
              or (inner == std::numeric_limits<unsigned>::max()))
             ? false : true;
    }
  };
 
 
 
  class SecIDQuadruplet {
  public:
    unsigned outer; 
    unsigned outerCenter; 
    unsigned innerCenter; 
    unsigned inner; 
    SecIDQuadruplet() { reset(); }
 
    void reset()
    {
      outer = std::numeric_limits<unsigned>::max();
      outerCenter = std::numeric_limits<unsigned>::max();
      innerCenter = std::numeric_limits<unsigned>::max();
      inner = std::numeric_limits<unsigned>::max();
    }
 
    bool isValid()
    {
      return ((outer == std::numeric_limits<unsigned>::max())
              or (outerCenter == std::numeric_limits<unsigned>::max())
              or (innerCenter == std::numeric_limits<unsigned>::max())
              or (inner == std::numeric_limits<unsigned>::max()))
             ? false : true;
    }
  };
 
 
 
  template <class SecIDSetType>
  class FilterValueDataSet {
  protected:
    std::map<std::string, double> m_values;
 
  public:
 
    unsigned expNo;
 
    unsigned runNo;
 
    unsigned evtNo;
 
    unsigned trackNo;
 
    int pdg;
 
    SecIDSetType secIDs;
 
 
 
    explicit FilterValueDataSet(std::vector<std::string> filterNames) :
      expNo(std::numeric_limits<unsigned>::max()),
      runNo(std::numeric_limits<unsigned>::max()),
      evtNo(std::numeric_limits<unsigned>::max()),
      trackNo(std::numeric_limits<unsigned>::max()),
      pdg(std::numeric_limits<int>::max())
    {
      for (auto name : filterNames) {
        m_values.insert({name, std::numeric_limits<double>::max()});
        B2DEBUG(26, "FilterValueDataSet::constructor: filterName " << name << " has been added.");
      }
      B2DEBUG(25, "FilterValueDataSet::constructor: " << m_values.size() << " filters have been added.");
    }
 
    void setValueOfFilter(std::string filterName, double value)
    {
      auto it = m_values.find(filterName);
      if (it == m_values.end()) {
        B2ERROR("FilterValueDataSet::setValueOfFilter: filterName " << filterName
                << "is not known, value " << value
                << " will NOT be added!");
        return;
      }
      it->second = value;
    }
 
    double* getValuePtr(std::string filterName)
    {
      double* valuePtr = nullptr;
      auto it = m_values.find(filterName);
      if (it != m_values.end()) {
        valuePtr = &it->second;
      } else { B2WARNING("filter could not be found, returning nullptr instead!"); }
      return valuePtr;
    }
 
    void reset()
    {
      expNo = std::numeric_limits<unsigned>::max();
      runNo = std::numeric_limits<unsigned>::max();
      evtNo = std::numeric_limits<unsigned>::max();
      trackNo = std::numeric_limits<unsigned>::max();
      pdg = std::numeric_limits<int>::max();
      secIDs.reset();
      for (auto& entry : m_values) {
        entry.second = std::numeric_limits<double>::max();
      }
    }
 
    bool isValid()
    {
      if (expNo == std::numeric_limits<unsigned>::max()) return false;
      if (runNo == std::numeric_limits<unsigned>::max()) return false;
      if (evtNo == std::numeric_limits<unsigned>::max()) return false;
      if (trackNo == std::numeric_limits<unsigned>::max()) return false;
      if (pdg == std::numeric_limits<int>::max()) return false;
      for (auto& entry : m_values) {
        if (entry.second == std::numeric_limits<double>::max()) return false;
      }
      return secIDs.isValid();
    }
  };
 
}