StrengthVariationWeightCalculator.hh

//
// This file is part of MARLEY (Model of Argon Reaction Low Energy Yields)
//
// MARLEY is free software: you can redistribute it and/or modify it under the
// terms of version 3 of the GNU General Public License as published by the
// Free Software Foundation.
//
// For the full text of the license please see COPYING or
// visit http://opensource.org/licenses/GPL-3.0
//
// Please respect the MCnet academic usage guidelines. See GUIDELINES
// or visit https://www.montecarlonet.org/GUIDELINES for details.
 
#pragma once
 
// Standard library includes
#include <memory>
#include <random>
#include <string>
#include <vector>
 
// MARLEY includes
#include "marley/Reaction.hh"
#include "marley/WeightCalculator.hh"
 
namespace HepMC3 {
  class GenEvent;
}
 
namespace marley {
 
  class DiscreteNuclearReaction;
  class Generator;
  class JSON;

  class StrengthVariationWeightCalculator : public WeightCalculator {
 
    public:

      enum class VariationMode { multisim, shift, unisim };

      static std::vector< std::shared_ptr<
        StrengthVariationWeightCalculator > >
        create_instances( const marley::JSON& config,
          marley::Generator& gen );
 
      virtual ~StrengthVariationWeightCalculator() = default;
 
      virtual double weight( HepMC3::GenEvent& event,
        marley::Generator& gen ) const override;
 
    private:

      StrengthVariationWeightCalculator( const std::string& name,
        std::shared_ptr< std::mt19937_64 > rng,
        const std::string& resolved_reaction_file );

      StrengthVariationWeightCalculator( const std::string& name,
        double sigma_factor,
        const std::string& resolved_reaction_file );

      StrengthVariationWeightCalculator( const std::string& name,
        double sigma_factor,
        size_t matrix_element_index,
        const std::string& resolved_reaction_file );
 
    protected:

      void ensure_initialized( marley::Generator& gen ) const;

      std::shared_ptr< std::mt19937_64 > rng_;

      std::string resolved_reaction_file_;

      VariationMode mode_;

      double sigma_factor_ = 0.;

      size_t me_idx_ = 0;

      mutable bool initialized_ = false;

      mutable const DiscreteNuclearReaction* dnr_ = nullptr;

      mutable Reaction::ProcessType process_type_
        = Reaction::ProcessType::Unknown;

      mutable int target_pdg_ = 0;

      mutable std::vector< double > varied_;
  };
 
}