Algorithm.h

#pragma once
 
#include "iguana/algorithms/Algorithm.h"
#include "iguana/algorithms/TypeDefs.h"
#include "iguana/services/ConcurrentParam.h"
 
namespace iguana::physics {

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

      bool Run(
          hipo::bank const& particle_bank,
          hipo::bank const& config_bank,
          hipo::bank& result_bank) const;

      concurrent_key_t PrepareEvent(int const runnum) const;

      InclusiveKinematicsVars ComputeFromLepton(
          vector_element_t const lepton_px,
          vector_element_t const lepton_py,
          vector_element_t const lepton_pz,
          concurrent_key_t const key) const;
 
    private:

      std::optional<int> const FindScatteredLepton(hipo::bank const& particle_bank, concurrent_key_t const key) const; // FIXME: this could be changed to a vector action function
 
      // banklist indices
      hipo::banklist::size_type b_particle;
      hipo::banklist::size_type b_config;
      hipo::banklist::size_type b_result;
 
      // `b_result` bank item indices
      int i_pindex;
      int i_Q2;
      int i_x;
      int i_y;
      int i_W;
      int i_nu;
      int i_qx;
      int i_qy;
      int i_qz;
      int i_qE;
      int i_beamPx;
      int i_beamPy;
      int i_beamPz;
      int i_beamM;
      int i_targetPx;
      int i_targetPy;
      int i_targetPz;
      int i_targetM;
 
      // enums
      enum method_reconstruction {
        scattered_lepton
      };
      enum method_lepton_finder {
        highest_energy_FD_trigger,
        lund_beam_daughter,
      };
 
      // config options
      mutable std::unique_ptr<ConcurrentParam<int>> o_runnum;
      mutable std::unique_ptr<ConcurrentParam<int>> o_beam_pdg;
      mutable std::unique_ptr<ConcurrentParam<int>> o_target_pdg;
      mutable std::unique_ptr<ConcurrentParam<double>> o_beam_mass;
      mutable std::unique_ptr<ConcurrentParam<double>> o_target_mass;
      mutable std::unique_ptr<ConcurrentParam<std::vector<double>>> o_beam_PxPyPzM;
      mutable std::unique_ptr<ConcurrentParam<std::vector<double>>> o_target_PxPyPzM;
      std::string o_particle_bank;
      double o_theta_between_FD_and_FT;
      method_reconstruction o_method_reconstruction;
      method_lepton_finder o_method_lepton_finder;
 
      // keysmith
      std::unique_ptr<Keysmith<int>> m_keysmith;
 
      // ==================================================================================
 
      // initial state class, for representing the beam or the target
      class InitialState
      {
        public:
 
          // constructor
          InitialState(
              std::string const id,
              std::unique_ptr<Logger> const& log,
              std::string const name,
              std::vector<double> const direction,
              double const energy)
              : id(id)
              , m_log(log)
              , name(name)
              , direction(direction)
              , energy(energy)
          {}
 
          // determine the 4-momentum
          void SetMomentum();
 
          // constant members
          std::string const id;
          std::unique_ptr<Logger> const& m_log;
          std::string const name;
          std::vector<double> const direction{};
 
          // variable members
          double energy = -1.0;
          int pdg       = 0;
          double mass   = 0.0;
          double px     = 0.0;
          double py     = 0.0;
          double pz     = 0.0;
      };
  };
 
 
}