SelectionUtility.h

Go to the documentation of this file.

//
// Created by Adam Lister on 06/02/20.
//
// Functions to help with selection configurations
//

#ifndef CMF_UTILITIES_CMFSELECTIONUTILITIES_H
#define CMF_UTILITIES_CMFSELECTIONUTILITIES_H

// Framework includes
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "cetlib_except/exception.h"
#include "fhiclcpp/ParameterSet.h"

// ROOT includes
#include "TRandom3.h"
#include "TH2.h"

// CMF includes
#include "CovarianceMatrixFit/core/Event.h"
#include "CovarianceMatrixFit/dataProducts/Constants.h"
#include "CovarianceMatrixFit/dataProducts/StaticFuncs.h"
#include "CovarianceMatrixFit/dataProducts/Structs.h"

namespace cmf{

  class SelectionUtility {

  public:

    /// associates each detector-beam pair to a set of selections
    struct DetBeamSels
    {
      cmf::DetType_t                 det;
      cmf::BeamType_t                beam;
      std::set<cmf::SelectionType_t> sels;

      DetBeamSels()
      : det(cmf::kUnknownDet)
      , beam(cmf::BeamType_t::kUnknownBeam)
      , sels({})
      {}

      DetBeamSels(cmf::DetType_t                 const& d,
                  cmf::BeamType_t                const& b,
                  std::set<cmf::SelectionType_t> const& s = std::set<cmf::SelectionType_t>())
      : det(d)
      , beam(b)
      , sels(s)
      {}

      std::set<cmf::SelectionType_t> const& Selections() const { return sels; }
      cmf::DetType_t                 const& Detector()   const { return det;  }
      cmf::BeamType_t                const& BeamType()   const { return beam; }
      std::set<long>                        Keys()       const;

      bool operator==(DetBeamSels const& rhs)  const;

      bool operator<(DetBeamSels const& rhs)  const;

    };

    typedef std::set<cmf::SelectionUtility::DetBeamSels> DetBeamSelSet;

    static SelectionUtility *Instance();

    void Initialize(fhicl::ParameterSet const& pset);

    void PrintSelections(DetBeamSelSet dbs);

    DetBeamSelSet const& AllAvailSelections();

    DetBeamSelSet const&       SelectionsToUse();
    std::vector<cmf::MetaData> SelectionsToUseAsMetaData(bool isMC=true) const;
    std::vector<long>          SelectionsToUseAsKeys() const;

    DetBeamSelSet const& SelectionsNotUsed();

    std::set<cmf::DetType_t> const& DetectorsToUse();

    void  SelectionsUsedOfType(cmf::SelectionType_t const& sel,
                               DetBeamSelSet             & sels);

    bool UsesDetAndBeam   (cmf::MetaData const& md) const;
    bool UsesDetAndBeam   (cmf::DetType_t const& d,
                           cmf::BeamType_t const& b) const;
    bool UsesDetBeamAndSel(cmf::MetaData const& md) const;
    bool UsesDetBeamAndSel(cmf::DetType_t  const& d,
                           cmf::BeamType_t      const& b,
                           cmf::SelectionType_t const& s) const;
    bool UsesSelection    (cmf::SelectionType_t const& s) const;
    bool UsesDetector     (cmf::DetType_t       const& d) const;

  private:

    SelectionUtility();

    ~SelectionUtility();

    void DetermineUnusedSelections();

    DetBeamSelSet fAllAvailSelections; ///< all available selections
    DetBeamSelSet fSelectionsToUse;    ///< selections which are configured
    DetBeamSelSet fSelectionsNotUsed;  ///< selections which are not configured

    std::set<cmf::DetType_t> fDetectorsToUse;

  };

  //---------------------------------------------------------------------------
  inline cmf::SelectionUtility::DetBeamSelSet const& SelectionUtility::AllAvailSelections() 
  { 
    if (fAllAvailSelections.size() == 0)
    {
      throw cet::exception("SelectionUtility")
        << "fAllAvailSelections has size 0, which can't be right.";
    }
    return fAllAvailSelections; 
  }

  //---------------------------------------------------------------------------
  inline cmf::SelectionUtility::DetBeamSelSet const& SelectionUtility::SelectionsToUse()
  { 
    if (fSelectionsToUse.size() == 0)
    {
      throw cet::exception("SelectionUtility")
        << "fSelectionsToUse has size 0. Have you correctly configured SelectionsToUse in fhicl?";
    }

    return fSelectionsToUse;
  }

  //---------------------------------------------------------------------------
  inline std::vector<cmf::MetaData> SelectionUtility::SelectionsToUseAsMetaData(bool isMC) const
  {
    std::vector<cmf::MetaData> mds;
    for(auto const& itr : fSelectionsToUse){
      for(auto const& sel : itr.Selections())
        mds.emplace_back(isMC,
                         itr.Detector(),
                         cmf::kUnknownFileType,
                         sel,
                         cmf::kUnknownInteraction,
                         cmf::BeamToPeriod(itr.BeamType()));
    }
    return std::move(mds);
  }

  //---------------------------------------------------------------------------
  inline std::vector<long> SelectionUtility::SelectionsToUseAsKeys() const
  {
    std::vector<long> keys;
    for(auto const& itr : fSelectionsToUse){
      for(auto const& sel : itr.Selections())
       keys.emplace_back(cmf::DetectorBeamSelectionTypesToKey(itr.Detector(), itr.BeamType(), sel));
    }
    return std::move(keys);
  }

  //---------------------------------------------------------------------------
  inline void SelectionUtility::SelectionsUsedOfType(cmf::SelectionType_t const& sel,
                                                     DetBeamSelSet             & sels)
  {
    if (fSelectionsToUse.size() == 0)
    {
      throw cet::exception("SelectionUtility")
          << "fSelectionsToUse has size 0, cannot find any of any type";
    }

    // loop over the selections used and return those of the requested type
    sels.clear();
    std::set<cmf::SelectionType_t> subSetOfSels;
    for(auto const& itr : fSelectionsToUse){
      subSetOfSels.clear();
      for(auto const& selItr : itr.Selections()){
        if(cmf::IsNuMuSelected(selItr) && cmf::IsNuMuSelected(sel))
          subSetOfSels.insert(selItr);
        else if(cmf::IsNuESelected(selItr) && cmf::IsNuESelected(sel))
          subSetOfSels.insert(selItr);
        else if(sel == selItr)
          subSetOfSels.insert(selItr);
      }
      sels.emplace(itr.Detector(), itr.BeamType(), subSetOfSels);
    }
  }

  //---------------------------------------------------------------------------
  inline const cmf::SelectionUtility::DetBeamSelSet& SelectionUtility::SelectionsNotUsed() 
  { return fSelectionsNotUsed; }

  //---------------------------------------------------------------------------
  inline std::set<long> SelectionUtility::DetBeamSels::Keys() const
  {
    std::set<long> keys;
    for(auto const& itr : sels)
      keys.insert(cmf::DetectorBeamSelectionTypesToKey(det,
                                                       beam,
                                                       itr));

    return keys;
  }

  //---------------------------------------------------------------------------
  inline bool SelectionUtility::DetBeamSels::operator==(const DetBeamSels& rhs) const 
  {
    return (rhs.det  == this->det && 
            rhs.beam == this->beam);
  }

  //---------------------------------------------------------------------------
  inline bool SelectionUtility::DetBeamSels::operator<(const DetBeamSels& rhs) const    
  {
    if(this->beam < rhs.beam) return true;
    else if(this->beam == rhs.beam){
      if(this->det < rhs.det) return true;
    }
    return false;
  }

}

#endif //CMF_UTILITIES_CMFSELECTIONUTILITIES_H