StaticSector.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 <tracking/dataobjects/FullSecID.h>
#include <tracking/trackFindingVXD/filterMap/map/CompactSecIDs.h>
#include <tracking/trackFindingVXD/filterMap/filterFramework/TBranchLeafType.h>
 
#include <TF1.h>
 
#include <unordered_map>
#include <tuple>
#include <utility>
 
namespace Belle2 {
  template < class HitType,
             class Filter2sp, class Filter3sp, class Filter4sp >
  class StaticSector {
 
    // allows VXDTFFilters to modify private members and use private functions, which is kind of dangerous
    // maybe better to make the one function needed to modify the filters public
    template<class T>
    friend class VXDTFFilters;
 
  public:
 
 
    StaticSector() :
      m_secID(FullSecID()), m_compactSecIDsMap(nullptr)
    {}
 
    explicit StaticSector(FullSecID secID) :
      m_secID(secID), m_compactSecIDsMap(nullptr)
    {}
 
 
    // ACCESSOR FUNCTIONS
 
    const Filter2sp* getFilter2sp(FullSecID innerSector) const
    {
      auto filter = m_2spFilters.find(m_compactSecIDsMap->getCompactID(innerSector));
      if (filter == m_2spFilters.end()) {
        return nullptr;
      }
      return &(filter->second);
    }
 
    const Filter3sp* getFilter3sp(const FullSecID& centerID, const  FullSecID& innerID) const
    {
      auto filter = m_3spFilters.find(m_compactSecIDsMap->getCompactID(centerID, innerID));
      if (filter == m_3spFilters.end()) {
        return nullptr;
      }
      return &(filter->second);
    }
 
 
    const Filter4sp* getFilter4sp(const FullSecID& /*outerCenterID*/, const FullSecID& /*innerCenterID*/,
                                  const FullSecID& /*innerID*/) const
    {
      B2WARNING("StaticSector:getFilter4sp  4 hit, all 4 hits are yet ignored in here! TODO: implement!");
      return nullptr;
    }
 
 
 
    const std::unordered_map<CompactSecIDs::sectorID_t, Filter2sp >&
    getAllFilters2sp() const
    {return m_2spFilters;}
 
    const std::unordered_map<CompactSecIDs::secPairID_t, Filter3sp >&
    getAllFilters3sp() const
    {return m_3spFilters;}
 
    const std::unordered_map<CompactSecIDs::secTripletID_t, Filter4sp >&
    getAllFilters4sp() const
    {return m_4spFilters;}
 
 
    void assignCompactSecIDsMap(const CompactSecIDs& compactSecIDsMap)
    {
      m_compactSecIDsMap = & compactSecIDsMap;
    }
 
 
    void assign2spFilter(FullSecID inner, const Filter2sp  filter)
    {
      m_2spFilters[ m_compactSecIDsMap->getCompactID(inner) ] = filter;
      m_inner2spSecIDs.push_back(inner);
    }
 
    void assign3spFilter(FullSecID center, FullSecID inner,
                         const Filter3sp  filter)
    {
      m_3spFilters[ m_compactSecIDsMap->getCompactID(center, inner) ] = filter;
      m_inner3spSecIDs.push_back({center, inner});
    }
 
    void assign4spFilter(FullSecID outerCenter, FullSecID innerCenter, FullSecID inner,
                         const Filter3sp  filter)
    {
      m_4spFilters[ m_compactSecIDsMap->getCompactID(outerCenter, innerCenter, inner) ] =
        filter;
      m_inner4spSecIDs.push_back({outerCenter, innerCenter, inner});
    }
 
 
    // @param sublayer : the new SubLayerID will be 0 if sublayer==0, and will be 1 else
    void setSubLayerID(int sublayer)
    {
      m_secID = FullSecID(m_secID.getVxdID(), (bool)sublayer, m_secID.getSecID());
    }
 
 
    const std::vector< FullSecID >& getInner2spSecIDs() const
    {
      return m_inner2spSecIDs;
    }
 
 
    const std::vector< std::pair<FullSecID, FullSecID> >& getInner3spSecIDs() const
    {
      return m_inner3spSecIDs;
    }
 
    const std::vector< std::tuple<FullSecID, FullSecID, FullSecID> >& getInner4spSecIDs() const
    {
      return m_inner4spSecIDs;
    }
 
    FullSecID getFullSecID() const { return m_secID; }
 
 
 
    inline bool operator == (const StaticSector& b) const
    {
      return (getFullSecID() == b.getFullSecID());
    }
 
    inline bool operator == (const FullSecID& b) const
    {
      return (getFullSecID() == b);
    }
 
 
  private:
 
    void modify2SPFilters(const std::vector< std::tuple<int, std::string> >& adjustFunctions)
    {
      // loop over all 2SP-filters
      for (auto& filter : m_2spFilters) modifySingleFilter<Filter2sp>(filter.second, adjustFunctions);
    }
 
    void modify3SPFilters(const std::vector< std::tuple<int, std::string > >& adjustFunctions)
    {
      // loop over all 3SP-filters
      for (auto& filter : m_3spFilters) modifySingleFilter<Filter3sp>(filter.second, adjustFunctions);
    }
 
    template<class FilterType>
    void modifySingleFilter(FilterType& filter, const std::vector< std::tuple<int, std::string > >& adjustFunctions)
    {
      // get the "map" to the cut values, the char in the pair codes the type, and the pointer points to the value
      std::vector< std::pair<char, void*> > accessor = {};
      filter.getNameAndReference(&accessor);
 
      // this will produce lots of output
      B2DEBUG(20, std::endl << "BEFORE: " << filter.getNameAndReference() << std::endl);
 
      // loop over all adjustfunctions
      for (const std::tuple<int, std::string >& entry : adjustFunctions) {
        // first is the index
        int index = std::get<0>(entry);
 
        if (index < 0 || index >= (int)accessor.size()) {
          B2FATAL("Provided index is out of range! index = " << index << " number of entries = " << accessor.size());
        }
 
        // now do some casting magic
        double x = 0;
        // the secID will be treated as 0th parameter of the TF1 ([0]) if specified.
        double y = m_secID;
 
        char typeID = accessor[index].first;
        void* valuePtr = accessor[index].second;
        if (typeID == TBranchLeafType(double())) x = *((double*)valuePtr);
        else if (typeID == TBranchLeafType(int())) x = (double)(*((int*)valuePtr));
        else if (typeID == TBranchLeafType(float())) x = (double)(*((float*)valuePtr));
        else if (typeID == TBranchLeafType(bool())) x = (double)(*((bool*)valuePtr));
        else {
          B2FATAL("Unrecognized type : " << typeID);
        } // end else if
 
        // create function
        TF1 f("function", std::get<1>(entry).c_str());
        if (!f.IsValid() || f.GetNpar() > 1) {
          B2FATAL("No valid function provided! The provided string has to be able to be converted by TF1. Also max. 1 parameter is allowed!"
                  << " The provided string is: \"" << std::get<1>(entry).c_str() << "\"");
        }
 
        double result = f.EvalPar(&x, &y);
 
        // now cast back to original type and set the value
        if (typeID == TBranchLeafType(double())) *((double*)valuePtr) = result;
        else if (typeID == TBranchLeafType(int())) *((int*)valuePtr) = result;
        else if (typeID == TBranchLeafType(float())) *((float*)valuePtr) = result;
        else if (typeID == TBranchLeafType(bool())) *((bool*)valuePtr) = result;
        else {
          B2FATAL("Unrecognized type : " << typeID);
        } // end else if
 
      }// end loop over the functions
 
      B2DEBUG(20, "AFTER: " << filter.getNameAndReference() << std::endl);
    }
 
    FullSecID m_secID;
 
    const CompactSecIDs* m_compactSecIDsMap;
 
    std::vector< FullSecID                        > m_inner2spSecIDs;
    std::vector< std::pair< FullSecID, FullSecID> > m_inner3spSecIDs;
    std::vector< std::tuple< FullSecID, FullSecID, FullSecID > > m_inner4spSecIDs;
 
    std::unordered_map<CompactSecIDs::sectorID_t, Filter2sp > m_2spFilters;
    std::unordered_map<CompactSecIDs::secPairID_t, Filter3sp > m_3spFilters;
    std::unordered_map<CompactSecIDs::secTripletID_t, Filter4sp > m_4spFilters;
 
  };
 
 
} //Belle2 namespace