Algorithm.h

#pragma once
 
#include "iguana/algorithms/Algorithm.h"
#include "iguana/algorithms/TypeDefs.h"
 
namespace iguana::clas12 {

  class SectorFinder : public Algorithm
  {
 
      DEFINE_IGUANA_ALGORITHM(SectorFinder, clas12::SectorFinder)
 
    private: // hooks
      void ConfigHook() override;
      void StartHook(hipo::banklist& banks) override;
      bool RunHook(hipo::banklist& banks) const override;
 
    public:

      static int const UNKNOWN_SECTOR = -1;

      bool Run(
          hipo::bank const& particleBank,
          hipo::bank const& trackBank,
          hipo::bank const& calBank,
          hipo::bank const& scintBank,
          hipo::bank& resultBank) const
      {
        return RunImpl(&particleBank, &trackBank, &calBank, &scintBank, nullptr, nullptr, &resultBank);
      }

      bool RunWithCustomChargedBank(
          hipo::bank const& particleBank,
          hipo::bank const& trackBank,
          hipo::bank const& calBank,
          hipo::bank const& scintBank,
          hipo::bank const& userChargedBank,
          hipo::bank& resultBank) const
      {
        return RunImpl(&particleBank, &trackBank, &calBank, &scintBank, &userChargedBank, nullptr, &resultBank);
      }

      bool RunWithCustomNeutralBank(
          hipo::bank const& particleBank,
          hipo::bank const& trackBank,
          hipo::bank const& calBank,
          hipo::bank const& scintBank,
          hipo::bank const& userNeutralBank,
          hipo::bank& resultBank) const
      {
        return RunImpl(&particleBank, &trackBank, &calBank, &scintBank, nullptr, &userNeutralBank, &resultBank);
      }

      bool RunWithCustomBanks(
          hipo::bank const& particleBank,
          hipo::bank const& userChargedBank,
          hipo::bank const& userNeutralBank,
          hipo::bank& resultBank) const
      {
        return RunImpl(&particleBank, nullptr, nullptr, nullptr, &userChargedBank, &userNeutralBank, &resultBank);
      }

      int GetSector(
          std::vector<int> const& sectors,
          std::vector<int> const& pindices,
          int const& pindex_particle) const;

      int GetStandardSector(
          std::vector<int> const& sectors_track,
          std::vector<int> const& pindices_track,
          std::vector<int> const& sectors_cal,
          std::vector<int> const& pindices_cal,
          std::vector<int> const& sectors_scint,
          std::vector<int> const& pindices_scint,
          int const& pindex_particle) const;

      std::vector<int> GetStandardSector(
          std::vector<int> const& sectors_track,
          std::vector<int> const& pindices_track,
          std::vector<int> const& sectors_cal,
          std::vector<int> const& pindices_cal,
          std::vector<int> const& sectors_scint,
          std::vector<int> const& pindices_scint,
          std::vector<int> const& pindices_particle) const;

      void GetListsSectorPindex(hipo::bank const& bank, std::vector<int>& sectors, std::vector<int>& pindices) const;
 
    private:

      bool RunImpl(
          hipo::bank const* particleBank,
          hipo::bank const* trackBank,
          hipo::bank const* calBank,
          hipo::bank const* scintBank,
          hipo::bank const* userChargedBank,
          hipo::bank const* userNeutralBank,
          hipo::bank* resultBank) const;

      hipo::banklist::size_type b_particle;
      hipo::banklist::size_type b_track;
      hipo::banklist::size_type b_calorimeter;
      hipo::banklist::size_type b_scint;
      hipo::banklist::size_type b_user_charged;
      hipo::banklist::size_type b_user_neutral;
      hipo::banklist::size_type b_result;
      bool userSpecifiedBank_charged{false};
      bool userSpecifiedBank_neutral{false};
 
      // `b_result` bank item indices
      int i_sector;
      int i_pindex;

      std::string o_bankname_charged;
      std::string o_bankname_neutral;
 
      // only want sectors from FD detectors
      std::set<int> const listFDDets{
          DetectorType::DC,
          DetectorType::ECAL,
          DetectorType::FTOF,
          DetectorType::HTCC,
          DetectorType::LTCC,
          DetectorType::RICH};
  };
 
}