marley::Weighter Class Reference

EventProcessor that assigns event weights. More...

#include <Weighter.hh>

Inheritance diagram for marley::Weighter:

Public Member Functions
	Weighter (const marley::JSON &config, marley::Generator &gen)
std::vector< double >	compute_weights (HepMC3::GenEvent &event, marley::Generator &gen) const
std::vector< std::shared_ptr< WeightCalculator > > &	get_weight_calculators ()
	Provides non-const access to the owned vector of weight calculators.
std::vector< std::string >	get_weight_names () const
	Returns the names of the weights associated with all configured weight calculators.
virtual void	process_event (HepMC3::GenEvent &event, marley::Generator &gen) override
	Processes an input GenEvent object.
void	set_use_cv_weight (bool use_it)
	Toggles inclusion of the central-value weight.

Protected Member Functions
std::shared_ptr< marley::WeightCalculator >	make_cv_weight_calc ()
	Helper function to create the weight calculator that handles the central-value weights during event generation.

Protected Attributes
std::vector< std::shared_ptr< WeightCalculator > >	calc_vec_
	Owned vector of weight calculators used to actually compute weights.

Static Protected Attributes
static const std::string	CV_WEIGHT_NAME = "CV"
	Reserved name for the central-value weights (required for compliance with the NuHepMC standard)

Detailed Description

EventProcessor that assigns event weights.

Definition at line 32 of file Weighter.hh.

Constructor & Destructor Documentation

Weighter()

marley::Weighter::Weighter	(	const marley::JSON &	config,
		marley::Generator &	gen )

Definition at line 36 of file Weighter.cc.

                         {
 
  // Always create a trivial weight calculator to handle the central-value
  // weights, and add it to the vector of owned calculators
  auto cv_wgt = make_cv_weight_calc();
  calc_vec_.push_back( cv_wgt );
 
  // Track all used weight names to detect duplicates
  std::unordered_set< std::string > used_names{ CV_WEIGHT_NAME };
 
  // Now parse the JSON configuration to instantiate any other requested
  // weight calculators
  if ( !config.is_array() ) {
    throw marley::Error( "Non-array JSON configuration passed to constructor"
      " of marley::Weighter" );
  }
 
  for ( const auto& obj : config.array_range() ) {
 
    if ( !obj.is_object() ) {
      throw marley::Error( "Each weight calculator configuration must be"
        " specified as a JSON object" );
    }
 
    if ( !obj.has_key("type") ) {
      throw marley::Error( "Missing \"type\" key in a weight calculator"
        " JSON configuration" );
    }
 
    // Based on the type key included with each weight calculator
    // configuration, build the appropriate kind of WeightCalculator object
    std::shared_ptr< WeightCalculator > wc;
    auto type = obj.at( "type" ).to_string();
    if ( type == "trivial" ) {
      auto twc = std::make_shared< marley::TrivialWeightCalculator >( obj );
      wc = std::static_pointer_cast< marley::WeightCalculator >( twc );
    }
    else if ( type == "optical_model" ) {
      auto omp_wc = std::make_shared< marley::OMPWeightCalculator >( obj );
      wc = std::static_pointer_cast< marley::WeightCalculator >( omp_wc );
    }
    else if ( type == "strength_variation" ) {
 
      // Delegate all config parsing to the static factory
      auto instances = marley::StrengthVariationWeightCalculator
        ::create_instances( obj, gen );
 
      for ( auto& svc : instances ) {
        if ( !used_names.insert( svc->name() ).second ) {
          throw marley::Error( "Duplicate weight calculator name \""
            + svc->name() + "\"" );
        }
        calc_vec_.push_back( svc );
      }
 
      // Skip the generic add at the bottom of the loop
      continue;
    }
    // TODO: add more weight calculator types here
    else {
      throw marley::Error( "Unrecognized weight calculator type"
        " specification \"" + type + '\"' );
    }
 
    // Check for duplicate weight names
    if ( !used_names.insert( wc->name() ).second ) {
      throw marley::Error( "Duplicate weight calculator name \""
        + wc->name() + "\"" );
    }
 
    // Add the completed WeightCalculator object to the owned vector
    calc_vec_.push_back( wc );
 
  } // loop over weight calculator configuration JSON objects
}

Member Function Documentation

compute_weights()

std::vector< double > marley::Weighter::compute_weights	(	HepMC3::GenEvent &	event,
		marley::Generator &	gen ) const

Definition at line 141 of file Weighter.cc.

{
  // Evaluate all configured weights and store the results in the output vector
  std::vector< double > weights;
  for ( const auto& weight_calc : calc_vec_ ) {
    double wgt = weight_calc->weight( event, gen );
    weights.push_back( wgt );
  }
  return weights;
}

get_weight_calculators()

std::vector< std::shared_ptr< WeightCalculator > > & marley::Weighter::get_weight_calculators ( )

inline

Provides non-const access to the owned vector of weight calculators.

Definition at line 57 of file Weighter.hh.

{ return calc_vec_; }

References calc_vec_.

Referenced by marley::CommandHandler::cmd_reweight().

get_weight_names()

std::vector< std::string > marley::Weighter::get_weight_names

(

)

const

Returns the names of the weights associated with all configured weight calculators.

Definition at line 153 of file Weighter.cc.

                                                              {
  // Look up the name of each owned weight calculator and store the results in
  // the output vector
  std::vector< std::string > names;
  for ( const auto& wgt_calc : calc_vec_ ) {
    names.push_back( wgt_calc->name() );
  }
  return names;
}

References calc_vec_.

Referenced by marley::CommandHandler::cmd_reweight().

make_cv_weight_calc()

std::shared_ptr< marley::WeightCalculator > marley::Weighter::make_cv_weight_calc ( )

protected

Helper function to create the weight calculator that handles the central-value weights during event generation.

Definition at line 192 of file Weighter.cc.

{
  marley::JSON temp_js;
  temp_js[ "name" ] = marley::Weighter::CV_WEIGHT_NAME;
  auto cv_wgt = std::make_shared< marley
    ::TrivialWeightCalculator >( temp_js );
  return std::static_pointer_cast< marley::WeightCalculator >( cv_wgt );
}

References CV_WEIGHT_NAME.

Referenced by set_use_cv_weight().

process_event()

void marley::Weighter::process_event ( HepMC3::GenEvent & ev, marley::Generator & gen )

overridevirtual

Processes an input GenEvent object.

Parameters

[in,out]	ev	The GenEvent object to be processed
[in]	gen	If needed, the Generator object to use during processing (e.g., for obtaining random numbers)

Implements marley::EventProcessor.

Definition at line 113 of file Weighter.cc.

{
  // Get non-const access to the vector of weights in the input event
  auto& weights_vec = event.weights();
  size_t num_weights = weights_vec.size();
 
  // Double-check that we have exactly the right number of weight
  // calculators configured
  if ( num_weights != calc_vec_.size() ) {
    throw marley::Error( "The number of configured weights is not the same"
      " as the number of configured weight calculators" );
  }
 
  // Evaluate all configured weights and store the results in the event
  auto temp_weights = compute_weights( event, gen );
 
  for ( size_t w = 0u; w < num_weights; ++w ) {
    double wgt = temp_weights.at( w );
 
    // Preserve any pre-existing event weights by multiplying the
    // current values in the event by the calculated result
    double& evw = weights_vec.at( w );
    evw *= wgt;
  }
 
}

References calc_vec_.

Referenced by marley::CommandHandler::cmd_reweight().

set_use_cv_weight()

void marley::Weighter::set_use_cv_weight

(

bool

use_it

)

Toggles inclusion of the central-value weight.

Definition at line 163 of file Weighter.cc.

                                                    {
  // Determine whether or not the CV weight is currently enabled by
  // checking the first element of the vector of weight calculators
  bool currently_using = false;
  if ( !calc_vec_.empty() ) {
    auto first_calc_name = calc_vec_.front()->name();
    currently_using = ( first_calc_name == marley::Weighter::CV_WEIGHT_NAME );
  }
 
  // If the requested setting matches the current state, return without
  // doing anything
  if ( currently_using == use_it ) return;
 
  // If we need to add it, then put a TrivialWeightCalculator with the
  // correct name at the start of the vector
  else if ( use_it ) {
    auto cv_wgt_calc = make_cv_weight_calc();
    calc_vec_.insert( calc_vec_.begin(), cv_wgt_calc );
    return;
  }
 
  // If we need to remove it, then do so
  else {
    calc_vec_.erase( calc_vec_.begin() );
  }
}

References calc_vec_, CV_WEIGHT_NAME, and make_cv_weight_calc().

Referenced by marley::CommandHandler::cmd_reweight().

Member Data Documentation

calc_vec_

std::vector< std::shared_ptr< WeightCalculator > > marley::Weighter::calc_vec_

protected

Owned vector of weight calculators used to actually compute weights.

Definition at line 67 of file Weighter.hh.

Referenced by get_weight_calculators(), get_weight_names(), process_event(), and set_use_cv_weight().

CV_WEIGHT_NAME

const std::string marley::Weighter::CV_WEIGHT_NAME = "CV"

staticprotected

Reserved name for the central-value weights (required for compliance with the NuHepMC standard)

Definition at line 63 of file Weighter.hh.

Referenced by make_cv_weight_calc(), and set_use_cv_weight().

---

The documentation for this class was generated from the following files:

• /home/sjg/Desktop/marley/include/marley/Weighter.hh
• /home/sjg/Desktop/marley/src/Weighter.cc