Public Member Functions
	GenieReweightProducer (const std::string &name, framework::Process &process)

virtual void	configure (framework::config::Parameters &)
	Callback for the EventProcessor to configure itself from the given set of parameters.

virtual void	onNewRun (const ldmx::RunHeader &runHeader)
	Callback for the EventProcessor to take any necessary action when the run being processed changes.

virtual void	produce (framework::Event &event)
	Process the event and put new data products into it.

Public Member Functions inherited from framework::Producer
	Producer (const std::string &name, Process &process)
	Class constructor.

virtual void	process (Event &event) final
	Processing an event for a Producer is calling produce.

Public Member Functions inherited from framework::EventProcessor
	DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
	declare that we have a factory for this class

	EventProcessor (const std::string &name, Process &process)
	Class constructor.

virtual	~EventProcessor ()=default
	Class destructor.

virtual void	beforeNewRun (ldmx::RunHeader &run_header)
	Callback for Producers to add parameters to the run header before conditions are initialized.

virtual void	onFileOpen (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.

virtual void	onFileClose (EventFile &event_file)
	Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.

virtual void	onProcessStart ()
	Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

virtual void	onProcessEnd ()
	Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

template<class T >
const T &	getCondition (const std::string &condition_name)
	Access a conditions object for the current event.

TDirectory *	getHistoDirectory ()
	Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.

void	setStorageHint (framework::StorageControl::Hint hint)
	Mark the current event as having the given storage control hint from this module_.

void	setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
	Mark the current event as having the given storage control hint from this module and the given purpose string.

int	getLogFrequency () const
	Get the current logging frequency from the process.

int	getRunNumber () const
	Get the run number from the process.

std::string	getName () const
	Get the processor name.

void	createHistograms (const std::vector< framework::config::Parameters > &histos)
	Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.

Private Member Functions
void	reinitializeGenieReweight ()

void	reconfigureGenieReweight (size_t)

Static Private Member Functions
static genie::rew::EGSyst	variationTypeToGenieDial (const ldmx::EventWeights::VariationType &vtype)

Private Attributes
std::string	hepmc3_coll_name_

std::string	hepmc3_pass_name_

std::string	event_weights_coll_name_

int	seed_

size_t	n_weights_

std::string	message_threshold_file_

std::string	tune_

std::map< ldmx::EventWeights::VariationType, std::vector< double > >	variation_map_

std::unique_ptr< genie::HepMC3Converter >	hep_mc3_converter_

std::unique_ptr< genie::rew::GReWeight >	genie_rw_

Additional Inherited Members
Protected Member Functions inherited from framework::EventProcessor
void	abortEvent ()
	Abort the event immediately.

Protected Attributes inherited from framework::EventProcessor
HistogramPool	histograms_
	helper object for making and filling histograms

NtupleManager &	ntuple_ {NtupleManager::getInstance()}
	Manager for any ntuples.

logging::logger	the_log_
	The logger for this EventProcessor.

Detailed Description

Definition at line 27 of file GenieReweightProducer.h.

Constructor & Destructor Documentation

◆ GenieReweightProducer()

simcore::GenieReweightProducer::GenieReweightProducer	(	const std::string &	name,
		framework::Process &	process )

Definition at line 47 of file GenieReweightProducer.cxx.

    : Producer(name, process) {
  hep_mc3_converter_ = std::make_unique<genie::HepMC3Converter>();
  genie_rw_ = std::make_unique<genie::rew::GReWeight>();
}

Member Function Documentation

◆ configure()

void simcore::GenieReweightProducer::configure ( framework::config::Parameters & parameters )

virtual

Callback for the EventProcessor to configure itself from the given set of parameters.

The parameters a processor has access to are the member variables of the python class in the sequence that has className equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters

parameters Parameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 54 of file GenieReweightProducer.cxx.

                                                                   {
  hepmc3_coll_name_ = ps.get<std::string>("hepmc3CollName");
  hepmc3_pass_name_ = ps.get<std::string>("hepmc3PassName");
  event_weights_coll_name_ = ps.get<std::string>("eventWeightsCollName");
  seed_ = ps.get<int>("seed");
  n_weights_ = static_cast<size_t>(ps.get<int>("n_weights"));
  auto var_types_strings = ps.get<std::vector<std::string> >("var_types");
 
  message_threshold_file_ = ps.get<std::string>("message_threshold_file");
 
  std::default_random_engine generator(seed_);
  std::normal_distribution<double> normal_distribution;
 
  for (auto const& vt_str : var_types_strings) {
    auto vtype = ldmx::EventWeights::stringToVariationType(vt_str);
    for (size_t i_w = 0; i_w < n_weights_; ++i_w)
      variation_map_[vtype].push_back(normal_distribution(generator));
  }
}

References framework::config::Parameters::get().

◆ onNewRun()

void simcore::GenieReweightProducer::onNewRun ( const ldmx::RunHeader & run_header )

virtual

Callback for the EventProcessor to take any necessary action when the run being processed changes.

Parameters

run_header The RunHeader containing run information.

Reimplemented from framework::EventProcessor.

Definition at line 94 of file GenieReweightProducer.cxx.

                                                                   {
  const std::string genie_tune_par = "GenieTune";
  std::string new_tune;
  for (auto par : runHeader.getStringParameters())
    if (par.first.size() >= genie_tune_par.size() &&
        par.first.compare(par.first.size() - genie_tune_par.size(),
                          genie_tune_par.size(), genie_tune_par) == 0) {
      new_tune = par.second;
      break;
    }
 
  if (tune_ != new_tune) {
    ldmx_log(debug) << "Found new tune " << new_tune << " (used to be " << tune_
                    << ")" << std::endl;
    tune_ = new_tune;
    reinitializeGenieReweight();
  }
}

References ldmx::RunHeader::getStringParameters().

◆ produce()

void simcore::GenieReweightProducer::produce ( framework::Event & event )

virtual

Process the event and put new data products into it.

Parameters

event The Event to process.

Implements framework::Producer.

Definition at line 153 of file GenieReweightProducer.cxx.

                                                         {
  // grab the input hepmc3 event collection
  auto hepmc3_col = event.getObject<std::vector<ldmx::HepMC3GenEvent> >(
      hepmc3_coll_name_, hepmc3_pass_name_);
 
  // create an output weights
  ldmx::EventWeights ev_weights(variation_map_);
 
  for (size_t i_w = 0; i_w < n_weights_; ++i_w) {
    double running_weight = 1;
 
    reconfigureGenieReweight(i_w);
 
    // setup a loop here ... but we're going to force only looping over one
    // interaction if it exists for now.
    for (size_t i_ev = 0; i_ev < 1; ++i_ev) {
      auto const& hepmc3_ev = hepmc3_col.at(i_ev);
      // fill our event data into a HepMC3GenEvent
      HepMC3::GenEvent hepmc3_genev;
      hepmc3_genev.read_data(hepmc3_ev);
 
      // print it out to check it ...
      if (i_w == 0) ldmx_log(debug) << hepmc3_genev;
 
      // now convert to genie event record
      auto genie_ev_record_ptr = hep_mc3_converter_->RetrieveGHEP(hepmc3_genev);
 
      // print that out too ...
      if (i_w == 0) ldmx_log(debug) << *genie_ev_record_ptr;
 
      // auto this_weight = 1.0 + var_value*0.05;
      auto this_weight = genie_rw_->CalcWeight(*genie_ev_record_ptr);
 
      running_weight = running_weight * this_weight;
 
    }  // end loop over interactions in event
 
    ev_weights.addWeight(running_weight);
 
  }  // end loop over weights
 
  ldmx_log(trace) << ev_weights;
 
  event.add(event_weights_coll_name_, ev_weights);
}

◆ reconfigureGenieReweight()

void simcore::GenieReweightProducer::reconfigureGenieReweight ( size_t i_w )

private

Definition at line 113 of file GenieReweightProducer.cxx.

                                                               {
  auto& syst = genie_rw_->Systematics();
  for (auto var : variation_map_) {
    if (var.first ==
        ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_MFP_pi)
      syst.Set(genie::rew::GSyst::FromString("MFP_pi"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_MFP_N)
      syst.Set(genie::rew::GSyst::FromString("MFP_N"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrCEx_pi)
      syst.Set(genie::rew::GSyst::FromString("FrCEx_pi"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrInel_pi)
      syst.Set(genie::rew::GSyst::FromString("FrInel_pi"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrAbs_pi)
      syst.Set(genie::rew::GSyst::FromString("FrAbs_pi"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrPiProd_pi)
      syst.Set(genie::rew::GSyst::FromString("FrPiProd_pi"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrCEx_N)
      syst.Set(genie::rew::GSyst::FromString("FrCEx_N"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrInel_N)
      syst.Set(genie::rew::GSyst::FromString("FrInel_N"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrAbs_N)
      syst.Set(genie::rew::GSyst::FromString("FrAbs_N"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrPiProd_N)
      syst.Set(genie::rew::GSyst::FromString("FrPiProd_N"), var.second[i_w]);
    else if (var.first ==
             ldmx::EventWeights::VariationType::kGENIE_HadrNuclTwkDial_FormZone)
      syst.Set(genie::rew::GSyst::FromString("FormZone"), var.second[i_w]);
  }
  genie_rw_->Reconfigure();
}

◆ reinitializeGenieReweight()

void simcore::GenieReweightProducer::reinitializeGenieReweight ( )

private

Definition at line 74 of file GenieReweightProducer.cxx.

                                                      {
  genie_rw_ = std::make_unique<genie::rew::GReWeight>();
 
  // set message thresholds
  genie::utils::app_init::MesgThresholds(message_threshold_file_);
 
  genie::RunOpt::Instance()->SetTuneName(tune_);
  if (!genie::RunOpt::Instance()->Tune()) {
    EXCEPTION_RAISE("ConfigurationException", "No TuneId in RunOption.");
  }
  genie::RunOpt::Instance()->BuildTune();
 
  genie_rw_->AdoptWghtCalc("hadro_fzone", new genie::rew::GReWeightFZone);
  genie_rw_->AdoptWghtCalc("hadro_intranuke", new genie::rew::GReWeightINuke);
 
  auto& syst = genie_rw_->Systematics();
  for (auto var : variation_map_)
    syst.Init(variationTypeToGenieDial(var.first));
}

◆ variationTypeToGenieDial()

static genie::rew::EGSyst simcore::GenieReweightProducer::variationTypeToGenieDial ( const ldmx::EventWeights::VariationType & vtype )

inlinestaticprivate

Definition at line 78 of file GenieReweightProducer.h.

                                                  {
    switch (vtype) {
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_MFP_pi:
        return genie::rew::EGSyst::kINukeTwkDial_MFP_pi;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_MFP_N:
        return genie::rew::EGSyst::kINukeTwkDial_MFP_N;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrCEx_pi:
        return genie::rew::EGSyst::kINukeTwkDial_FrCEx_pi;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrInel_pi:
        return genie::rew::EGSyst::kINukeTwkDial_FrInel_pi;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrAbs_pi:
        return genie::rew::EGSyst::kINukeTwkDial_FrAbs_pi;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrPiProd_pi:
        return genie::rew::EGSyst::kINukeTwkDial_FrPiProd_pi;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrCEx_N:
        return genie::rew::EGSyst::kINukeTwkDial_FrCEx_N;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrInel_N:
        return genie::rew::EGSyst::kINukeTwkDial_FrInel_N;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrAbs_N:
        return genie::rew::EGSyst::kINukeTwkDial_FrAbs_N;
      case ldmx::EventWeights::VariationType::kGENIE_INukeTwkDial_FrPiProd_N:
        return genie::rew::EGSyst::kINukeTwkDial_FrPiProd_N;
      case ldmx::EventWeights::VariationType ::kGENIE_HadrNuclTwkDial_FormZone:
        return genie::rew::EGSyst::kHadrNuclTwkDial_FormZone;
      default:
        return genie::rew::EGSyst::kNullSystematic;
    }
    return genie::rew::EGSyst::kNullSystematic;
  }

Member Data Documentation

◆ event_weights_coll_name_

std::string simcore::GenieReweightProducer::event_weights_coll_name_

private

Definition at line 52 of file GenieReweightProducer.h.

◆ genie_rw_

std::unique_ptr<genie::rew::GReWeight> simcore::GenieReweightProducer::genie_rw_

private

Definition at line 73 of file GenieReweightProducer.h.

◆ hep_mc3_converter_

std::unique_ptr<genie::HepMC3Converter> simcore::GenieReweightProducer::hep_mc3_converter_

private

Definition at line 71 of file GenieReweightProducer.h.

◆ hepmc3_coll_name_

std::string simcore::GenieReweightProducer::hepmc3_coll_name_

private

Definition at line 46 of file GenieReweightProducer.h.

◆ hepmc3_pass_name_

std::string simcore::GenieReweightProducer::hepmc3_pass_name_

private

Definition at line 49 of file GenieReweightProducer.h.

◆ message_threshold_file_

std::string simcore::GenieReweightProducer::message_threshold_file_

private

Definition at line 61 of file GenieReweightProducer.h.

◆ n_weights_

size_t simcore::GenieReweightProducer::n_weights_

private

Definition at line 58 of file GenieReweightProducer.h.

◆ seed_

int simcore::GenieReweightProducer::seed_

private

Definition at line 55 of file GenieReweightProducer.h.

◆ tune_

std::string simcore::GenieReweightProducer::tune_

private

Definition at line 64 of file GenieReweightProducer.h.

◆ variation_map_

std::map<ldmx::EventWeights::VariationType, std::vector<double> > simcore::GenieReweightProducer::variation_map_

private

Definition at line 68 of file GenieReweightProducer.h.

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

SimCore/include/SimCore/Reweight/GenieReweightProducer.h
SimCore/src/SimCore/Reweight/GenieReweightProducer.cxx

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GenieReweightProducer()

Member Function Documentation

◆ configure()

◆ onNewRun()

◆ produce()

◆ reconfigureGenieReweight()

◆ reinitializeGenieReweight()

◆ variationTypeToGenieDial()

Member Data Documentation

◆ event_weights_coll_name_

◆ genie_rw_

◆ hep_mc3_converter_

◆ hepmc3_coll_name_

◆ hepmc3_pass_name_

◆ message_threshold_file_

◆ n_weights_

◆ seed_

◆ tune_

◆ variation_map_