Inheritance diagram for evgen::Decay0Gen:

Public Types
using	ModuleType = EDProducer

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

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

	~Decay0Gen ()

void	produce (art::Event &evt)

void	beginRun (art::Run &run)

void	beginJob ()

void	endJob ()

virtual void	beginRun_radio (art::Run &)

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)

void	beginJob_radio ()

void	endJob_radio ()

Private Attributes
std::shared_ptr< clhep_random >	m_random_decay0

std::vector< std::unique_ptr< bxdecay0::decay0_generator > >	m_decay0_generator

TH1D *	m_timediff_TH1D

bool	m_single_isotope_mode

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 25 of file Decay0Gen_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::Decay0Gen::Decay0Gen ( fhicl::ParameterSet const & pset )

explicit

Definition at line 70 of file Decay0Gen_module.cc.

References fhicl::ParameterSet::get(), fhicl::ParameterSet::get_if_present(), evgen::BaseRadioGen::GetRandomEngine(), m_decay0_generator, evgen::BaseRadioGen::m_isotope, m_random_decay0, m_single_isotope_mode, and util::to_string().

                                                     : BaseRadioGen(pset)
   {
     std::string isotope = "";
     m_single_isotope_mode = pset.get_if_present<std::string>("isotope", isotope);
 
     if (not m_single_isotope_mode) {
       fhicl::ParameterSet decay_chain = pset.get<fhicl::ParameterSet>("decay_chain");
       int index = 0;
 
       while (
         decay_chain.get_if_present<std::string>("isotope_" + std::to_string(index++), isotope)) {
         m_isotope.push_back(isotope);
       }
     }
     else {
       m_isotope.push_back(isotope);
     }
 
     m_random_decay0 = std::make_shared<clhep_random>(GetRandomEngine());
 
     for (auto const& isotope : m_isotope) {
       auto generator = std::make_unique<bxdecay0::decay0_generator>();
       generator->reset();
 
       // Configure the Decay0 generator:
       generator->set_decay_category(bxdecay0::decay0_generator::DECAY_CATEGORY_BACKGROUND);
       generator->set_decay_isotope(isotope.c_str());
       try {
         generator->initialize(*m_random_decay0);
       }
       catch (...) {
         throw cet::exception("Decay0Gen") << "The inialisation of Decay0 failed. Maybe the isotope "
                                           << isotope << " doesn't exists?\n";
       }
       m_decay0_generator.push_back(std::move(generator));
     }
   }

evgen::Decay0Gen::~Decay0Gen ( )

inline

Definition at line 28 of file Decay0Gen_module.cc.

References beginJob_radio(), endJob_radio(), tca::evt, m_decay0_generator, and produce_radio().

     {
       for (auto& i : m_decay0_generator) {
         i->reset();
       }
     }

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;
   }

void evgen::Decay0Gen::beginJob_radio ( )

privatevirtual

Reimplemented from evgen::BaseRadioGen.

Definition at line 108 of file Decay0Gen_module.cc.

References evgen::BaseRadioGen::GetTs(), and m_timediff_TH1D.

Referenced by ~Decay0Gen().

   {
     art::ServiceHandle<art::TFileService> tfs;
     double T0 = 0, T1 = 0;
     GetTs(T0, T1);
     m_timediff_TH1D =
       tfs->make<TH1D>("TimeDiff", ";Time Diff[ns];n particles", (int)((T1) / 10000), 0, T1);
   }

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 evgen::SpectrumVolumeGen::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();
   }

void evgen::Decay0Gen::endJob_radio ( )

privatevirtual

Reimplemented from evgen::BaseRadioGen.

Definition at line 117 of file Decay0Gen_module.cc.

References evgen::BaseRadioGen::GetNEvents(), and m_timediff_TH1D.

Referenced by ~Decay0Gen().

   {
     if (GetNEvents()) m_timediff_TH1D->Scale(1. / GetNEvents());
   }

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

inlineprotectedinherited

Definition at line 788 of file BaseRadioGen.h.

Referenced by evgen::BaseRadioGen::endJob_radio(), evgen::SpectrumVolumeGen::produce_radio(), and 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(), evgen::SpectrumVolumeGen::produce_radio(), and 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(), evgen::SpectrumVolumeGen::produce_radio(), and 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 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 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 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::Decay0Gen::produce_radio ( art::Event & evt )

privatevirtual

Implements evgen::BaseRadioGen.

Definition at line 123 of file Decay0Gen_module.cc.

References util::abs(), simb::MCTruth::Add(), simb::MCParticle::AddTrajectoryPoint(), DEFINE_ART_MODULE, e, evgen::BaseRadioGen::FillHistos(), evgen::BaseRadioGen::GetGoodPositionTime(), evgen::BaseRadioGen::GetNDecays(), simb::kSingleParticle, m_decay0_generator, m_random_decay0, m_timediff_TH1D, MF_LOG_DEBUG, MF_LOG_ERROR, part, art::Event::put(), and simb::MCTruth::SetOrigin().

Referenced by ~Decay0Gen().

   {
     //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 bad_position = 0;
     int tentative_decay = 0;
     for (auto const& decay0_gen : m_decay0_generator) {
       int n_decay = GetNDecays();
 
       tentative_decay += n_decay;
       for (int iDecay = 0; iDecay < n_decay; ++iDecay) {
         TLorentzVector position;
         if (GetGoodPositionTime(position)) {
 
           bxdecay0::event gendecay;                      // Declare an empty decay event
           decay0_gen->shoot(*m_random_decay0, gendecay); // Randomize the decay event
           std::vector<bxdecay0::particle> part = gendecay.get_particles();
 
           double t_alpha = 0;
           double t_electron = 0;
           for (auto const& p : part) {
             // alpha particles need a little help since they're not in the TDatabasePDG table
             // so don't rely so heavily on default arguments to the MCParticle constructor
             simb::MCParticle part;
             if (not p.is_valid()) {
               p.print(std::cout);
               throw cet::exception("Decay0Gen") << "Invalid part generated by Decay0, printed "
                                                    "above (no clue what that means so throw)";
             }
 
             double mass = bxdecay0::particle_mass_MeV(p.get_code());
             int pdg = 0;
             //int simple_pdg=0; // simple_pdg is unused here
 
             if (p.is_alpha()) {
               pdg = 1000020040;
               part = simb::MCParticle(track_id, pdg, primary_str, -1, mass / 1000, 1);
             }
             else if (p.is_gamma()) {
               pdg = 22;
               part = simb::MCParticle(track_id, pdg, primary_str);
             }
             else if (p.is_positron()) {
               pdg = -11;
               part = simb::MCParticle(track_id, pdg, primary_str);
             }
             else if (p.is_electron()) {
               pdg = 11;
               part = simb::MCParticle(track_id, pdg, primary_str);
             }
             else if (p.is_neutron()) {
               pdg = 2112;
               part = simb::MCParticle(track_id, pdg, primary_str);
             }
             else if (p.is_proton()) {
               pdg = 2212;
               part = simb::MCParticle(track_id, pdg, primary_str);
             }
             else {
               p.print(std::cout);
               throw cet::exception("Decay0Gen") << "Particle above is weird, cannot recognise it.";
             }
 
             if ((p.is_positron() or p.is_electron()) and t_electron == 0) {
               t_electron = p.get_time();
             }
             if (p.is_alpha() and t_alpha == 0) { t_alpha = p.get_time(); }
             track_id--;
             TLorentzVector mom(p.get_px() / 1000.,
                                p.get_py() / 1000.,
                                p.get_pz() / 1000.,
                                sqrt(p.get_p() * p.get_p() + mass * mass) / 1000.);
 
             TLorentzVector this_part_position = position;
             double t = position.T();
             this_part_position.SetT(t + p.get_time() * 1e9);
 
             part.AddTrajectoryPoint(this_part_position, mom);
 
             truth.Add(part);
 
             FillHistos(part);
           }
           if (abs(t_alpha - t_electron) > 1.e-15) {
             m_timediff_TH1D->Fill(1e9 * abs(t_alpha - t_electron));
           }
           gendecay.reset();
         }
         else { // !GetGoodPosition
           ++bad_position;
         }
       } // idecay
     }   // m_decay_generators
 
     MF_LOG_DEBUG("Decay0Gen") << truth;
     if (bad_position > 0) {
       MF_LOG_ERROR("Decay0Gen")
         << "There were " << bad_position
         << " failed attempts to get a good position to generate a decay out of the target "
         << tentative_decay << " decays.\n"
         << "If these 2 numbers are close together, it means that the rate of your background is "
            "wrong (underestimated).\n"
         << "You can fix this by increasing the parameter \"max_tries_event\" to a bigger number "
            "(default is 1M) in your fhicl.\n"
         << "Another way is to change the \"volume_rand\" to a smaller one.\n";
     }
     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);
   }

Member Data Documentation

std::vector<std::unique_ptr<bxdecay0::decay0_generator> > evgen::Decay0Gen::m_decay0_generator

private

Definition at line 44 of file Decay0Gen_module.cc.

Referenced by Decay0Gen(), produce_radio(), and ~Decay0Gen().

std::vector<std::string> evgen::BaseRadioGen::m_isotope

protectedinherited

isotope to simulate. Example: "Ar39"

Definition at line 90 of file BaseRadioGen.h.

Referenced by Decay0Gen(), and evgen::SpectrumVolumeGen::SpectrumVolumeGen().

std::shared_ptr<clhep_random> evgen::Decay0Gen::m_random_decay0

private

Definition at line 41 of file Decay0Gen_module.cc.

Referenced by Decay0Gen(), and produce_radio().

bool evgen::Decay0Gen::m_single_isotope_mode

private

Definition at line 46 of file Decay0Gen_module.cc.

Referenced by Decay0Gen().

TH1D* evgen::Decay0Gen::m_timediff_TH1D

private

Definition at line 45 of file Decay0Gen_module.cc.

Referenced by beginJob_radio(), endJob_radio(), and produce_radio().

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

larsimrad/v09_09_05/source/larsimrad/BxDecay0/Decay0Gen_module.cc

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation