klmtrgLayerCounter.cc

/**************************************************************************
 * 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.                  *
 **************************************************************************/
 
 
#include "trg/klm/modules/klmtrigger/ntuples_full.h"
 
 
#include "trg/klm/modules/klmtrigger/klmtrgLayerCounter.h"
#include "trg/klm/modules/klmtrigger/IO_csv.h"
#include "trg/klm/modules/klmtrigger/bit_operations.h"
 
 
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <vector>
#include <tuple>
#include <iostream>
#include <bitset>
 
using namespace Belle2::KLM_TRG_definitions;
 
 
 
 
 
 
namespace Belle2 {
 
  void klmtrgLayerCounter::clear_layersUsed()
  {
    m_layersUsed.clear();
  }
 
  void klmtrgLayerCounter::add_layersUsed(int layersUsed)
  {
    m_layersUsed.emplace_back(layersUsed);
  }
 
  void klmtrgLayerCounter::set_NLayerTrigger(int NLayerTrigger)
  {
    m_NLayerTrigger = NLayerTrigger;
  }
 
  void klmtrgLayerCounter::set_NPlaneTrigger(int NPlaneTrigger)
  {
    m_NPlaneTrigger = NPlaneTrigger;
  }
 
  void klmtrgLayerCounter::set_countPlanes(int countPlanes)
  {
    m_countPlanes = countPlanes;
  }
 
  KLM_Digit_compact_ts klmtrgLayerCounter::set_joiningAlgorithm(const KLM_Digit_compact_ts& hits, const int count_planes)
  {
    if (count_planes == 1) {
      auto hits1 = nt::algorithms::join_vectors(
                     hits,
                     m_layersUsed,
                     nt::comparators::on_common_args,
      [&](auto e1, const auto&) {
        e1.layer = e1.layer * 2 + e1.plane;
        return e1;
      });
      return hits1;
    } else {
      auto hits1 = nt::algorithms::join_vectors(
                     hits,
                     m_layersUsed,
                     nt::comparators::on_common_args,
      [&](auto e1, const auto&) {
        e1.layer = e1.layer;
        return e1;
      });
      return hits1;
    }
  }
 
  void klmtrgLayerCounter::run(const KLM_Digit_compact_ts& hits)
  {
 
 
    m_sections_trig.clear();
    m_summary1.clear();
 
    auto hits1 = set_joiningAlgorithm(hits, m_countPlanes);
 
    __CSV__WRITE__(hits1);
 
 
    auto grouped = nt_group(
                     hits1[0].subdetector,
                     hits1[0].section,
                     hits1[0].sector
                   ).apply_append(
                     hits1,
    [](const auto & e1) {
      auto bit_mask = to_bit_mask(nt_span(e1, layer));
      return nt::ntuple(
               ax_maker(plane_count) = countBits(bit_mask),
               ax_maker(plane_mask) = bit_mask
             );
    });
 
 
    __CSV__WRITE__(grouped);
    int threshold = (m_countPlanes == 1) ? m_NPlaneTrigger : m_NLayerTrigger;
    nt::algorithms::filter(grouped, [&](const auto & e) { return e.plane_count >= threshold;  });
 
 
 
 
 
    m_sections_trig = nt_group(
                        grouped[0].subdetector,
                        grouped[0].section
                      ).apply_append(
                        grouped,
    [&](const auto & e1) {
 
      auto bit_mask = to_bit_mask(nt_span(e1, sector));
      n_sections_trig  nsector = countBits(bit_mask);
      return  nt::ntuple(
                sector_mask(bit_mask),
                nsector
              );
    }
                      );
 
    __CSV__WRITE__(m_sections_trig);
 
 
 
    m_summary1 = nt_group(
                   m_sections_trig[0].subdetector
                 ).apply_append(
                   m_sections_trig,
    [](const auto & e1) {
      auto bit_mask = countBits(to_bit_mask(nt_span(e1, section)));
      n_sections_trig  nsector = nt::algorithms::sum(e1, [](auto&& e) {return e.n_sections_trig; });
 
      return  nt::ntuple(
                nsector,
                back2back(bit_mask == 2)
 
              );
    }
                 );
 
    __CSV__WRITE__(m_summary1);
 
 
  }
 
  int klmtrgLayerCounter::get_n_sections_trig(int subdetector)
  {
    for (const auto& e : m_summary1) {
      if (e.subdetector == subdetector) {
        return e.n_sections_trig;
      }
    }
    return 0;
  }
 
  int klmtrgLayerCounter::get_triggermask(int subdetector, int section)
  {
    for (const auto& e : m_sections_trig) {
      if (e.subdetector == subdetector && e.section == section) {
        return e.sector_mask;
      }
    }
    return 0;
  }
 
  int klmtrgLayerCounter::get_BKLM_back_to_back_flag(int subdetector)
  {
    for (const auto& e : m_summary1) {
      if (e.subdetector == subdetector) {
        return e.back2back;
      }
    }
    return 0;
  }
 

}