Inheritance diagram for evgen::SpectrumVolumeGen:

Public Types
using	ModuleType = EDProducer

template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Member Functions
	SpectrumVolumeGen (fhicl::ParameterSet const &pset)

void	produce (art::Event &evt)

void	beginRun (art::Run &run)

void	beginJob ()

void	endJob ()

virtual void	beginRun_radio (art::Run &)

virtual void	beginJob_radio ()

virtual void	endJob_radio ()

void	doBeginJob (SharedResources const &resources)

void	doEndJob ()

void	doRespondToOpenInputFile (FileBlock const &fb)

void	doRespondToCloseInputFile (FileBlock const &fb)

void	doRespondToOpenOutputFiles (FileBlock const &fb)

void	doRespondToCloseOutputFiles (FileBlock const &fb)

bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)

bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)

bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)

void	fillProductDescriptions ()

void	registerProducts (ProductDescriptions &productsToRegister)

ModuleDescription const &	moduleDescription () const

void	setModuleDescription (ModuleDescription const &)

std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const

void	sortConsumables (std::string const &current_process_name)

std::unique_ptr< Worker >	makeWorker (WorkerParams const &wp)

template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)

template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Protected Member Functions
int	GetNDecays ()

bool	GetGoodPositionTime (TLorentzVector &position)

TLorentzVector	dirCalc (double p, double m)

void	FillHistos (simb::MCParticle &part)

CLHEP::HepRandomEngine &	GetRandomEngine ()

int	GetNEvents ()

void	GetTs (double &T0, double &T1)

void	GetXs (double &X0, double &X1)

void	GetYs (double &Y0, double &Y1)

void	GetZs (double &Z0, double &Z1)

ConsumesCollector &	consumesCollector ()

template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)

template<typename T , BranchType = InEvent>
void	consumesMany ()

template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)

template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)

template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Protected Attributes
std::vector< std::string >	m_isotope
	isotope to simulate. Example: "Ar39" More...

Private Member Functions
void	produce_radio (art::Event &evt)

Private Attributes
int	m_pdg

double	m_mass

TH1D *	m_spectrum

Detailed Description

Module to generate particles created by radiological decay, patterend off of SingleGen Currently it generates only in rectangular prisms oriented along the x,y,z axes

Definition at line 16 of file SpectrumVolumeGen_module.cc.

Member Typedef Documentation

using art::EDProducer::ModuleType = EDProducer

inherited

Definition at line 17 of file EDProducer.h.

template<typename UserConfig , typename KeysToIgnore = void>

using art::detail::Producer::Table = Modifier::Table<UserConfig, KeysToIgnore>

inherited

Definition at line 26 of file Producer.h.

Constructor & Destructor Documentation

evgen::SpectrumVolumeGen::SpectrumVolumeGen ( fhicl::ParameterSet const & pset )

explicit

Definition at line 32 of file SpectrumVolumeGen_module.cc.

References fhicl::ParameterSet::get(), fhicl::ParameterSet::get_if_present(), evgen::BaseRadioGen::m_isotope, m_mass, m_pdg, m_spectrum, MF_LOG_WARNING, x, and y.

                                                                     : BaseRadioGen(pset)
   {
     std::string isotope = "";
     isotope = pset.get<std::string>("isotope");
     m_pdg = pset.get<int>("isotope");
 
     bool mass_specified = pset.get_if_present<double>("mass", m_mass);
     if (not mass_specified) {
       const TDatabasePDG* databasePDG = TDatabasePDG::Instance();
       const TParticlePDG* definition = databasePDG->GetParticle(m_pdg);
       // Check that the particle is known to ROOT.  If not, this is
       // not a major error; Geant4 has an internal particle coding
       // scheme for nuclei that ROOT doesn't recognize.
       if (definition != 0) { m_mass = definition->Mass(); }
       else {
         throw cet::exception("SpectrumVolumeGen") << "Cannot find the particle pdg " << m_pdg;
       }
     }
 
     m_isotope.push_back(isotope);
 
     double min_p = 0, max_p = 0;
     std::vector<double> bins;
     bool minmax_mode = pset.get_if_present<double>("spectrum_p_min", min_p);
     if (minmax_mode) { max_p = pset.get<double>("spectrum_p_max"); }
     else {
       bins = pset.get<std::vector<double>>("bins");
     }
 
     std::string function;
     std::vector<double> parameters;
     bool have_params;
     std::vector<double> spectrum;
     bool func_mode = pset.get_if_present<std::string>("function", function);
 
     if (func_mode) {
       have_params = pset.get_if_present<std::vector<double>>("parameters", parameters);
     }
     else {
       spectrum = pset.get<std::vector<double>>("spectrum");
     }
 
     if (func_mode and minmax_mode) {
       int nbins = pset.get<int>("nbins");
       TF1 the_func("spect_func", function.c_str(), min_p, max_p);
       if (have_params) the_func.SetParameters(parameters.data());
 
       m_spectrum = new TH1D("spectrum", ";p [GeV];PDF", nbins, min_p, max_p);
 
       for (int ibin = 1; ibin < nbins + 1; ++ibin) {
         double x = m_spectrum->GetBinCenter(ibin);
         double y = the_func.Eval(x);
         if (y < 0) y = 0;
         m_spectrum->SetBinContent(ibin, y);
       }
     }
     else if (func_mode and not minmax_mode) {
       if (bins.size() <= 1) {
         throw cet::exception("SpectrumVolumeGen")
           << "You need to specify more than 1 bin edge to use the \"bins\" option.";
       }
       MF_LOG_WARNING("SpectrumVolumeGen")
         << "\033[31mYou are using a function and non constant binning...\n"
         << "Please please please check spectrum and momentum distribution are what you actually "
            "want!\033[0m\n";
       int nbins = bins.size() - 1;
 
       TF1 the_func("spect_func", function.c_str(), *bins.begin(), *bins.rbegin());
       if (have_params) the_func.SetParameters(parameters.data());
 
       m_spectrum = new TH1D("spectrum", ";p [GeV];PDF", nbins, bins.data());
 
       for (int ibin = 1; ibin < nbins + 1; ++ibin) {
         double x = m_spectrum->GetBinCenter(ibin);
         double y = the_func.Eval(x);
         if (y < 0) y = 0;
         m_spectrum->SetBinContent(ibin, y);
       }
     }
     else if (not func_mode and minmax_mode) {
       int nbins = spectrum.size();
 
       m_spectrum = new TH1D("spectrum", ";p [GeV];PDF", nbins, min_p, max_p);
       for (int ibin = 1; ibin < nbins + 1; ++ibin) {
         m_spectrum->SetBinContent(ibin, spectrum.at(ibin - 1));
       }
     }
     else {
       int nbins = spectrum.size();
       if ((unsigned)nbins != spectrum.size())
         throw cet::exception("SpectrumVolumeGen") << "spectrum and bins don't have coherent size!";
 
       m_spectrum = new TH1D("spectrum", ";p [GeV];PDF", nbins, bins.data());
 
       for (int ibin = 1; ibin < nbins + 1; ++ibin) {
         m_spectrum->SetBinContent(ibin, spectrum.at(ibin - 1));
       }
     }
 
     m_spectrum->Scale(1. / m_spectrum->Integral());
 
     art::ServiceHandle<art::TFileService> tfs;
     TH1D* sp = tfs->make<TH1D>(*m_spectrum);
     (void)sp;
   }

Member Function Documentation

void evgen::BaseRadioGen::beginJob ( )

inlinevirtualinherited

Reimplemented from art::EDProducer.

Definition at line 490 of file BaseRadioGen.h.

   {
     if (m_isotope.empty()) {
       throw cet::exception("BaseRadioGen")
         << "m_isotope is empty, you need to fill it yourself in the constructor of your module\n";
     }
 
     DeclareOutputHistos();
     beginJob_radio();
     m_nevent = 0;
   }

virtual void evgen::BaseRadioGen::beginJob_radio ( )

inlinevirtualinherited

Reimplemented in evgen::Decay0Gen.

Definition at line 81 of file BaseRadioGen.h.

81 {}

void evgen::BaseRadioGen::beginRun ( art::Run & run )

inlinevirtualinherited

Reimplemented from art::EDProducer.

Definition at line 483 of file BaseRadioGen.h.

   {
     art::ServiceHandle<geo::Geometry const> geo;
     run.put(std::make_unique<sumdata::RunData>(m_geo_service->DetectorName()), art::fullRun());
     beginRun_radio(run);
   }

virtual void evgen::BaseRadioGen::beginRun_radio ( art::Run & )

inlinevirtualinherited

Definition at line 80 of file BaseRadioGen.h.

80 {}

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::consumes ( InputTag const & tag )

protectedinherited

Definition at line 61 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumes().

   {
     return collector_.consumes<T, BT>(tag);
   }

ConsumesCollector & art::ModuleBase::consumesCollector ( )

protectedinherited

Definition at line 57 of file ModuleBase.cc.

References art::ModuleBase::collector_.

   {
     return collector_;
   }

template<typename T , BranchType BT>

void art::ModuleBase::consumesMany ( )

protectedinherited

Definition at line 75 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesMany().

   {
     collector_.consumesMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::consumesView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::consumesView ( InputTag const & tag )

inherited

Definition at line 68 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::consumesView().

   {
     return collector_.consumesView<T, BT>(tag);
   }

TLorentzVector evgen::BaseRadioGen::dirCalc	(	double	p,
		double	m
	)

inlineprotectedinherited

Definition at line 810 of file BaseRadioGen.h.

Referenced by evgen::BaseRadioGen::endJob_radio(), and produce_radio().

   {
     // isotropic production angle for the decay product
     double costheta = (2.0 * m_random_flat.fire() - 1.0);
 
     if (costheta < -1.0) costheta = -1.0;
     if (costheta > 1.0) costheta = 1.0;
 
     double const sintheta = sqrt(1.0 - costheta * costheta);
     double const phi = 2.0 * M_PI * m_random_flat.fire();
 
     return TLorentzVector{p * sintheta * std::cos(phi),
                           p * sintheta * std::sin(phi),
                           p * costheta,
                           std::sqrt(p * p + m * m)};
   }

void art::detail::Producer::doBeginJob ( SharedResources const & resources )

inherited

Definition at line 22 of file Producer.cc.

References art::detail::Producer::beginJobWithFrame(), and art::detail::Producer::setupQueues().

   {
     setupQueues(resources);
     ProcessingFrame const frame{ScheduleID{}};
     beginJobWithFrame(frame);
   }

bool art::detail::Producer::doBeginRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 65 of file Producer.cc.

References art::detail::Producer::beginRunWithFrame(), art::RangeSet::forRun(), art::RunPrincipal::makeRun(), r, art::RunPrincipal::runID(), and art::ModuleContext::scheduleID().

   {
     auto r = rp.makeRun(mc, RangeSet::forRun(rp.runID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doBeginSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 85 of file Producer.cc.

References art::detail::Producer::beginSubRunWithFrame(), art::RangeSet::forSubRun(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::SubRunPrincipal::subRunID().

   {
     auto sr = srp.makeSubRun(mc, RangeSet::forSubRun(srp.subRunID()));
     ProcessingFrame const frame{mc.scheduleID()};
     beginSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

void art::detail::Producer::doEndJob ( )

inherited

Definition at line 30 of file Producer.cc.

References art::detail::Producer::endJobWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     endJobWithFrame(frame);
   }

bool art::detail::Producer::doEndRun	(	RunPrincipal &	rp,
		ModuleContext const &	mc
	)

inherited

Definition at line 75 of file Producer.cc.

References art::detail::Producer::endRunWithFrame(), art::RunPrincipal::makeRun(), r, art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto r = rp.makeRun(mc, rp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endRunWithFrame(r, frame);
     r.commitProducts();
     return true;
   }

bool art::detail::Producer::doEndSubRun	(	SubRunPrincipal &	srp,
		ModuleContext const &	mc
	)

inherited

Definition at line 95 of file Producer.cc.

References art::detail::Producer::endSubRunWithFrame(), art::SubRunPrincipal::makeSubRun(), art::ModuleContext::scheduleID(), and art::Principal::seenRanges().

   {
     auto sr = srp.makeSubRun(mc, srp.seenRanges());
     ProcessingFrame const frame{mc.scheduleID()};
     endSubRunWithFrame(sr, frame);
     sr.commitProducts();
     return true;
   }

bool art::detail::Producer::doEvent	(	EventPrincipal &	ep,
		ModuleContext const &	mc,
		std::atomic< std::size_t > &	counts_run,
		std::atomic< std::size_t > &	counts_passed,
		std::atomic< std::size_t > &	counts_failed
	)

inherited

Definition at line 105 of file Producer.cc.

References art::detail::Producer::checkPutProducts_, e, art::EventPrincipal::makeEvent(), art::detail::Producer::produceWithFrame(), and art::ModuleContext::scheduleID().

   {
     auto e = ep.makeEvent(mc);
     ++counts_run;
     ProcessingFrame const frame{mc.scheduleID()};
     produceWithFrame(e, frame);
     e.commitProducts(checkPutProducts_, &expectedProducts<InEvent>());
     ++counts_passed;
     return true;
   }

void art::detail::Producer::doRespondToCloseInputFile ( FileBlock const & fb )

inherited

Definition at line 44 of file Producer.cc.

References art::detail::Producer::respondToCloseInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToCloseOutputFiles ( FileBlock const & fb )

inherited

Definition at line 58 of file Producer.cc.

References art::detail::Producer::respondToCloseOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToCloseOutputFilesWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenInputFile ( FileBlock const & fb )

inherited

Definition at line 37 of file Producer.cc.

References art::detail::Producer::respondToOpenInputFileWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenInputFileWithFrame(fb, frame);
   }

void art::detail::Producer::doRespondToOpenOutputFiles ( FileBlock const & fb )

inherited

Definition at line 51 of file Producer.cc.

References art::detail::Producer::respondToOpenOutputFilesWithFrame().

   {
     ProcessingFrame const frame{ScheduleID{}};
     respondToOpenOutputFilesWithFrame(fb, frame);
   }

void evgen::BaseRadioGen::endJob ( )

inlinevirtualinherited

Reimplemented from art::EDProducer.

Definition at line 502 of file BaseRadioGen.h.

   {
     if (m_nevent) {
       m_pdg_TH1D->Scale(1. / m_nevent);
 
       for (auto histo : m_pos_xy_TH2D) {
         m_pos_xy_TH2D[histo.first]->Scale(1. / m_nevent);
         m_pos_xz_TH2D[histo.first]->Scale(1. / m_nevent);
         m_dir_x_TH1D[histo.first]->Scale(1. / m_nevent);
         m_dir_y_TH1D[histo.first]->Scale(1. / m_nevent);
         m_dir_z_TH1D[histo.first]->Scale(1. / m_nevent);
         m_mom_TH1D[histo.first]->Scale(1. / m_nevent);
         m_ke_TH1D[histo.first]->Scale(1. / m_nevent);
         m_time_TH1D[histo.first]->Scale(1. / m_nevent);
       }
     }
     endJob_radio();
   }

virtual void evgen::BaseRadioGen::endJob_radio ( )

inlinevirtualinherited

Reimplemented in evgen::Decay0Gen.

Definition at line 82 of file BaseRadioGen.h.

References evgen::BaseRadioGen::dirCalc(), evgen::BaseRadioGen::FillHistos(), evgen::BaseRadioGen::GetGoodPositionTime(), evgen::BaseRadioGen::GetNDecays(), and part.

82 {}

void evgen::BaseRadioGen::FillHistos ( simb::MCParticle & part )

inlineprotectedinherited

Definition at line 788 of file BaseRadioGen.h.

Referenced by evgen::BaseRadioGen::endJob_radio(), produce_radio(), and evgen::Decay0Gen::produce_radio().

   {
     int pdg = part.PdgCode();
     int simple_pdg = 0;
     std::string dummy = "";
     SimplePDG(pdg, simple_pdg, dummy);
 
     TLorentzVector position = part.Position();
     TLorentzVector mom = part.Momentum();
     double mass = mom.M();
     m_pos_xy_TH2D[simple_pdg]->Fill(position.X(), position.Y());
     m_pos_xz_TH2D[simple_pdg]->Fill(position.X(), position.Z());
     m_dir_x_TH1D[simple_pdg]->Fill(mom.Px() / mom.P());
     m_dir_y_TH1D[simple_pdg]->Fill(mom.Py() / mom.P());
     m_dir_z_TH1D[simple_pdg]->Fill(mom.Pz() / mom.P());
     double ke = (sqrt(mom.P() * mom.P() + mass * mass) - mass) * 1000.;
     m_ke_TH1D[simple_pdg]->Fill(ke);
     m_mom_TH1D[simple_pdg]->Fill(mom.P() * 1000.);
     m_time_TH1D[simple_pdg]->Fill(position.T());
     m_pdg_TH1D->Fill(simple_pdg);
   }

void art::Modifier::fillProductDescriptions ( )

inherited

Definition at line 10 of file Modifier.cc.

References art::ProductRegistryHelper::fillDescriptions(), and art::ModuleBase::moduleDescription().

   {
     ProductRegistryHelper::fillDescriptions(moduleDescription());
   }

std::array< std::vector< ProductInfo >, NumBranchTypes > const & art::ModuleBase::getConsumables ( ) const

inherited

Definition at line 43 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::getConsumables().

   {
     return collector_.getConsumables();
   }

bool evgen::BaseRadioGen::GetGoodPositionTime ( TLorentzVector & position )

inlineprotectedinherited

Deal with the time first

We use all the XYZ that have been set earlier, until we find the correct volume and material

We use the list of nodes

Definition at line 521 of file BaseRadioGen.h.

Referenced by evgen::BaseRadioGen::endJob_radio(), produce_radio(), and evgen::Decay0Gen::produce_radio().

   {
 
     double time = m_T0 + m_random_flat.fire() * (m_T1 - m_T0);
 
     if (not m_geo_volume_mode) {
 
       size_t n_tries = 0;
 
       double xpos = std::numeric_limits<double>::signaling_NaN();
       double ypos = std::numeric_limits<double>::signaling_NaN();
       double zpos = std::numeric_limits<double>::signaling_NaN();
 
       while (n_tries++ < m_max_tries_event) {
 
         if (m_distrib_xpos)
           xpos = m_distrib_xpos->GetRandom(m_X0, m_X1);
         else
           xpos = m_X0 + m_random_flat.fire() * (m_X1 - m_X0);
 
         if (m_distrib_ypos)
           ypos = m_distrib_ypos->GetRandom(m_Y0, m_Y1);
         else
           ypos = m_Y0 + m_random_flat.fire() * (m_Y1 - m_Y0);
 
         if (m_distrib_zpos)
           zpos = m_distrib_zpos->GetRandom(m_Z0, m_Z1);
         else
           zpos = m_Z0 + m_random_flat.fire() * (m_Z1 - m_Z0);
 
         auto node = gGeoManager->FindNode(xpos, ypos, zpos);
 
         if (NodeSupported(node)) break;
       }
 
       if (std::isnan(xpos) or std::isnan(ypos) or std::isnan(zpos)) {
         MF_LOG_ERROR("BaseRadioGen") << "Error in generation of random position!";
       }
 
       position.SetXYZT(xpos, ypos, zpos, time);
       return true;
     }
     else {
 
       if (m_good_nodes.empty() or m_volume_cc == 0)
         MF_LOG_ERROR("BaseRadioGen") << "There is no node to throw events in!";
 
       double which_vol = m_random_flat.fire() * m_volume_cc;
 
       const TGeoNode* node = nullptr;
       size_t i = 0;
 
       for (auto const& nd : m_good_nodes) {
         if (which_vol < nd.second) {
           node = nd.first;
           break;
         }
         i++;
       }
 
       const TGeoNode* world = gGeoManager->GetNode(0);
       double x_min, x_max;
       double y_min, y_max;
       double z_min, z_max;
       GetNodeXYZMinMax(node, world, x_min, x_max, y_min, y_max, z_min, z_max);
 
       size_t n_tries = 0;
 
       while (n_tries++ < m_max_tries_event) {
         double xpos = std::numeric_limits<double>::signaling_NaN();
         double ypos = std::numeric_limits<double>::signaling_NaN();
         double zpos = std::numeric_limits<double>::signaling_NaN();
 
         if (m_distrib_xpos)
           xpos = m_distrib_xpos->GetRandom(x_min, x_max);
         else
           xpos = x_min + m_random_flat.fire() * (x_max - x_min);
 
         if (m_distrib_ypos)
           ypos = m_distrib_ypos->GetRandom(y_min, y_max);
         else
           ypos = y_min + m_random_flat.fire() * (y_max - y_min);
 
         if (m_distrib_zpos)
           zpos = m_distrib_zpos->GetRandom(z_min, z_max);
         else
           zpos = z_min + m_random_flat.fire() * (z_max - z_min);
 
         if (std::isnan(xpos) or std::isnan(ypos) or std::isnan(zpos)) {
           MF_LOG_ERROR("BaseRadioGen") << "Error in generation of random position!";
         }
         position.SetXYZT(xpos, ypos, zpos, time);
 
         const TGeoNode* node_generated = gGeoManager->FindNode(xpos, ypos, zpos);
         if (node_generated == node) return true;
 
         if (node->GetNdaughters() and IsDaughterNode(node_generated, node)) return true;
       }
     }
 
     return false;
   }

int evgen::BaseRadioGen::GetNDecays ( )

inlineprotectedinherited

Definition at line 629 of file BaseRadioGen.h.

Referenced by evgen::BaseRadioGen::endJob_radio(), produce_radio(), and evgen::Decay0Gen::produce_radio().

   {
 
     if (m_rate_mode) { return m_random_poisson.fire(m_rate); }
     else {
       double rate = abs(m_Bq * (m_T1 - m_T0) * m_volume_cc / 1.0E9);
       return m_random_poisson.fire(rate);
     }
   }

int evgen::BaseRadioGen::GetNEvents ( )

inlineprotectedinherited

Definition at line 93 of file BaseRadioGen.h.

References evgen::BaseRadioGen::m_nevent.

Referenced by evgen::Decay0Gen::endJob_radio().

93 { return m_nevent; }

evgen::BaseRadioGen::m_nevent

int m_nevent

Definition: BaseRadioGen.h:180

CLHEP::HepRandomEngine& evgen::BaseRadioGen::GetRandomEngine ( )

inlineprotectedinherited

Definition at line 92 of file BaseRadioGen.h.

References evgen::BaseRadioGen::m_engine.

Referenced by evgen::Decay0Gen::Decay0Gen().

92 { return m_engine; }

evgen::BaseRadioGen::m_engine

CLHEP::HepRandomEngine & m_engine

Definition: BaseRadioGen.h:160

void evgen::BaseRadioGen::GetTs	(	double &	T0,
		double &	T1
	)

inlineprotectedinherited

Definition at line 94 of file BaseRadioGen.h.

References evgen::BaseRadioGen::m_T0, and evgen::BaseRadioGen::m_T1.

Referenced by evgen::Decay0Gen::beginJob_radio().

     {
       T0 = m_T0;
       T1 = m_T1;
     }

void evgen::BaseRadioGen::GetXs	(	double &	X0,
		double &	X1
	)

inlineprotectedinherited

Definition at line 99 of file BaseRadioGen.h.

References evgen::BaseRadioGen::m_X0, and evgen::BaseRadioGen::m_X1.

     {
       X0 = m_X0;
       X1 = m_X1;
     }

void evgen::BaseRadioGen::GetYs	(	double &	Y0,
		double &	Y1
	)

inlineprotectedinherited

Definition at line 104 of file BaseRadioGen.h.

References evgen::BaseRadioGen::m_Y0, and evgen::BaseRadioGen::m_Y1.

     {
       Y0 = m_Y0;
       Y1 = m_Y1;
     }

void evgen::BaseRadioGen::GetZs	(	double &	Z0,
		double &	Z1
	)

inlineprotectedinherited

Definition at line 109 of file BaseRadioGen.h.

References evgen::BaseRadioGen::CalculateActiveVolumeFromAllNodes(), evgen::BaseRadioGen::CalculateActiveVolumeFromXYZ(), evgen::BaseRadioGen::DeclareOutputHistos(), evgen::BaseRadioGen::m_Z0, evgen::BaseRadioGen::m_Z1, and evgen::BaseRadioGen::SimplePDG().

     {
       Z0 = m_Z0;
       Z1 = m_Z1;
     }

std::unique_ptr< Worker > art::ModuleBase::makeWorker ( WorkerParams const & wp )

inherited

Definition at line 37 of file ModuleBase.cc.

References art::ModuleBase::doMakeWorker(), and art::NumBranchTypes.

   {
     return doMakeWorker(wp);
   }

template<typename T , BranchType BT>

ProductToken< T > art::ModuleBase::mayConsume ( InputTag const & tag )

protectedinherited

Definition at line 82 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsume().

   {
     return collector_.mayConsume<T, BT>(tag);
   }

template<typename T , BranchType BT>

void art::ModuleBase::mayConsumeMany ( )

protectedinherited

Definition at line 96 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeMany().

   {
     collector_.mayConsumeMany<T, BT>();
   }

template<typename Element , BranchType = InEvent>

ViewToken<Element> art::ModuleBase::mayConsumeView ( InputTag const & )

protectedinherited

template<typename T , BranchType BT>

ViewToken<T> art::ModuleBase::mayConsumeView ( InputTag const & tag )

inherited

Definition at line 89 of file ModuleBase.h.

References art::ModuleBase::collector_, and art::ConsumesCollector::mayConsumeView().

   {
     return collector_.mayConsumeView<T, BT>(tag);
   }

ModuleDescription const & art::ModuleBase::moduleDescription ( ) const

inherited

Definition at line 13 of file ModuleBase.cc.

References art::errors::LogicError.

Referenced by art::OutputModule::doRespondToOpenInputFile(), art::OutputModule::doWriteEvent(), art::Modifier::fillProductDescriptions(), art::OutputModule::makePlugins_(), art::OutputWorker::OutputWorker(), reco::shower::LArPandoraModularShowerCreation::produce(), art::Modifier::registerProducts(), and art::OutputModule::registerProducts().

   {
     if (md_.has_value()) {
       return *md_;
     }
 
     throw Exception{errors::LogicError,
                     "There was an error while calling moduleDescription().\n"}
       << "The moduleDescription() base-class member function cannot be called\n"
          "during module construction.  To determine which module is "
          "responsible\n"
          "for calling it, find the '<module type>:<module "
          "label>@Construction'\n"
          "tag in the message prefix above.  Please contact artists@fnal.gov\n"
          "for guidance.\n";
   }

void evgen::BaseRadioGen::produce ( art::Event & evt )

inlinevirtualinherited

Implements art::EDProducer.

Definition at line 477 of file BaseRadioGen.h.

   {
     m_nevent++;
     produce_radio(evt);
   }

void evgen::SpectrumVolumeGen::produce_radio ( art::Event & evt )

privatevirtual

Implements evgen::BaseRadioGen.

Definition at line 139 of file SpectrumVolumeGen_module.cc.

References simb::MCTruth::Add(), simb::MCParticle::AddTrajectoryPoint(), DEFINE_ART_MODULE, evgen::BaseRadioGen::dirCalc(), evgen::BaseRadioGen::FillHistos(), evgen::BaseRadioGen::GetGoodPositionTime(), evgen::BaseRadioGen::GetNDecays(), simb::kSingleParticle, m_mass, m_pdg, m_spectrum, MF_LOG_DEBUG, part, art::Event::put(), and simb::MCTruth::SetOrigin().

   {
 
     //unique_ptr allows ownership to be transferred to the art::Event after the put statement
     std::unique_ptr<std::vector<simb::MCTruth>> truthcol(new std::vector<simb::MCTruth>);
 
     simb::MCTruth truth;
     truth.SetOrigin(simb::kSingleParticle);
     int track_id = -1;
     const std::string primary_str("primary");
 
     int n_decay = GetNDecays();
 
     for (int iDecay = 0; iDecay < n_decay; ++iDecay) {
       TLorentzVector position;
 
       if (GetGoodPositionTime(position)) {
         simb::MCParticle part(track_id, m_pdg, primary_str);
 
         TLorentzVector momentum = dirCalc(m_spectrum->GetRandom(), m_mass);
         part.AddTrajectoryPoint(position, momentum);
 
         truth.Add(part);
         FillHistos(part);
 
         track_id--;
       } // GetGoodPosition
     }   // idecay
 
     MF_LOG_DEBUG("SpectrumVolumeGen") << truth;
     truthcol->push_back(truth);
     evt.put(std::move(truthcol));
   }

void art::Modifier::registerProducts ( ProductDescriptions & productsToRegister )

inherited

Definition at line 16 of file Modifier.cc.

References art::ModuleBase::moduleDescription(), and art::ProductRegistryHelper::registerProducts().

   {
     ProductRegistryHelper::registerProducts(productsToRegister,
                                             moduleDescription());
   }

void art::ModuleBase::setModuleDescription ( ModuleDescription const & md )

inherited

Definition at line 31 of file ModuleBase.cc.

References art::ModuleBase::md_.

   {
     md_ = md;
   }

void art::ModuleBase::sortConsumables ( std::string const & current_process_name )

inherited

Definition at line 49 of file ModuleBase.cc.

References art::ModuleBase::collector_, and art::ConsumesCollector::sortConsumables().

   {
     // Now that we know we have seen all the consumes declarations,
     // sort the results for fast lookup later.
     collector_.sortConsumables(current_process_name);
   }