#include "BaseRadioGen.h"

Inheritance diagram for evgen::BaseRadioGen:

Public Types
using	ModuleType = EDProducer

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

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

void	produce (art::Event &evt)

void	beginRun (art::Run &run)

void	beginJob ()

void	endJob ()

virtual void	produce_radio (art::Event &evt)=0

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	CalculateActiveVolumeFromAllNodes ()

void	CalculateActiveVolumeFromXYZ ()

void	SimplePDG (int pdg, int &simple, std::string &name)

void	DeclareOutputHistos ()

void	FillAllNodes (const TGeoNode *curnode)

void	GetNodeXYZMinMax (const TGeoNode from, const TGeoNode to, double &x_min, double &x_max, double &y_min, double &y_max, double &z_min, double &z_max)

bool	IsDaughterNode (const TGeoNode daughter_node, const TGeoNode mother_node)

bool	findNode (const TGeoNode curnode, std::string &tgtnname, const TGeoNode &targetnode)
	Shamelessly stolen from here: https://cdcvs.fnal.gov/redmine/attachments/6719/calc_bbox.C. More...

bool	findMotherNode (const TGeoNode cur_node, std::string &daughter_name, const TGeoNode &mother_node)
	Adapted from above. More...

bool	NodeSupported (TGeoNode const *node) const

Private Attributes
std::set< const TGeoNode * >	m_all_nodes

std::string	m_material
	regex of materials in which to generate the decays. Example: "LAr" More...

std::string	m_volume_rand
	The volume in which to generate the decays. More...

std::string	m_volume_gen
	The volume in which to generate the decays. More...

std::regex	m_regex_material

std::regex	m_regex_volume

double	m_Bq {signaling_NaN}
	Radioactivity in Becquerels (decay per sec) per cubic cm. More...

double	m_rate
	Radioactivity in Becquerels (decay per sec) use either of this of Bq. More...

double	m_T0 {signaling_NaN}
	Beginning of time window to simulate in ns. More...

double	m_T1 {signaling_NaN}
	End of time window to simulate in ns. More...

double	m_X0 {signaling_NaN}
	Bottom corner x position (cm) in world coordinates. More...

double	m_Y0 {signaling_NaN}
	Bottom corner y position (cm) in world coordinates. More...

double	m_Z0 {signaling_NaN}
	Bottom corner z position (cm) in world coordinates. More...

double	m_X1 {signaling_NaN}
	Top corner x position (cm) in world coordinates. More...

double	m_Y1 {signaling_NaN}
	Top corner y position (cm) in world coordinates. More...

double	m_Z1 {signaling_NaN}
	Top corner z position (cm) in world coordinates. More...

double	m_volume_cc {signaling_NaN}

art::ServiceHandle< geo::Geometry const >	m_geo_service

TGeoManager *	m_geo_manager

CLHEP::HepRandomEngine &	m_engine

CLHEP::RandFlat	m_random_flat

CLHEP::RandPoisson	m_random_poisson

bool	m_geo_volume_mode {false}

bool	m_rate_mode

bool	m_volume_rand_present

size_t	m_max_tries_event

size_t	m_max_tries_rate_calculation

size_t	m_target_n_point_rate_calculation

std::map< const TGeoNode *, double >	m_good_nodes {}

std::vector< const TGeoVolume * >	m_good_volumes {}

std::vector< const TGeoMaterial * >	m_good_materials {}

TF1 *	m_distrib_xpos {nullptr}

TF1 *	m_distrib_ypos {nullptr}

TF1 *	m_distrib_zpos {nullptr}

int	m_nevent {0}

std::map< int, TH2D * >	m_pos_xy_TH2D {}

std::map< int, TH2D * >	m_pos_xz_TH2D {}

std::map< int, TH1D * >	m_dir_x_TH1D {}

std::map< int, TH1D * >	m_dir_y_TH1D {}

std::map< int, TH1D * >	m_dir_z_TH1D {}

std::map< int, TH1D * >	m_mom_TH1D {}

std::map< int, TH1D * >	m_ke_TH1D {}

std::map< int, TH1D * >	m_time_TH1D {}

TH1D *	m_pdg_TH1D {nullptr}

Static Private Attributes
static constexpr double	signaling_NaN = std::numeric_limits<double>::signaling_NaN()

Detailed Description

Definition at line 71 of file BaseRadioGen.h.

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::BaseRadioGen::BaseRadioGen ( fhicl::ParameterSet const & pset )

inlineexplicit

If we specified X, Y, Z we will throw with what the user provided This will throw an error if somebody specifies only one X0.

If we specified volume_rand we will throw with what the coordinates of the volume

Else we throw in the whole geometry but only in the nodes who have the specified volume/material

Definition at line 269 of file BaseRadioGen.h.

References art::detail::EngineCreator::createEngine(), m_engine, m_geo_manager, m_geo_service, m_material, m_max_tries_event, m_max_tries_rate_calculation, m_random_flat, m_random_poisson, m_rate_mode, m_regex_material, m_regex_volume, m_target_n_point_rate_calculation, m_volume_gen, m_volume_rand, m_volume_rand_present, and geo::GeometryCore::ROOTGeoManager().

     : EDProducer{pset}
     , m_material{pset.get<std::string>("material", ".*")}
     , m_volume_rand{""}
     , m_volume_gen{pset.get<std::string>("volume_gen", ".*")}
     , m_regex_material{(std::regex)m_material}
     , m_regex_volume{(std::regex)m_volume_gen}
     , m_geo_manager(m_geo_service->ROOTGeoManager())
     , m_engine(art::ServiceHandle<rndm::NuRandomService>()->registerAndSeedEngine(
         createEngine(0, "HepJamesRandom", "BaseRadioGen"),
         "HepJamesRandom",
         "BaseRadioGen",
         pset,
         "SeedBaseRadioGen"))
     , m_random_flat{m_engine}
     , m_random_poisson{m_engine}
     , m_rate_mode{pset.has_key("rate")}
     , m_volume_rand_present{pset.has_key("volume_rand")}
     , m_max_tries_event{pset.get<size_t>("max_tries_event", 1'000'000)}
     , m_max_tries_rate_calculation{pset.get<size_t>("max_tries_rate_calculation", 40'000'000)}
     , m_target_n_point_rate_calculation{
         pset.get<size_t>("target_n_point_rate_calculation", 100'000)}
   {
     produces<std::vector<simb::MCTruth>>();
     produces<sumdata::RunData, art::InRun>();
 
     m_rate_mode = pset.get_if_present<double>("rate", m_rate);
     if (not m_rate_mode) m_Bq = pset.get<double>("BqPercc");
 
     bool timed_mode = pset.get_if_present<double>("T0", m_T0);
     if (timed_mode) { m_T1 = pset.get<double>("T1"); }
     else {
       auto const clockData =
         art::ServiceHandle<detinfo::DetectorClocksService const>()->DataForJob();
       auto const detProp =
         art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataForJob(clockData);
       int nsample = detProp.NumberTimeSamples();
       m_T0 = -nsample * sampling_rate(clockData);
       m_T1 = -m_T0;
     }
 
     if (m_material != ".*" || m_volume_gen != ".*") {
       MF_LOG_INFO("BaseRadioGen") << "Calculating the volume of " << m_material
                                   << " and the volume " << m_volume_gen << " in the geometry.\n";
 
       TObjArray* volumes = m_geo_manager->GetListOfVolumes();
       TList* materials = m_geo_manager->GetListOfMaterials();
 
       for (int i = 0; i < volumes->GetEntries(); ++i) {
         TGeoVolume* volume = (TGeoVolume*)volumes->At(i);
         std::string volume_name = volume->GetName();
         bool good = std::regex_match(volume_name, m_regex_volume);
         if (good) {
 
           if (m_volume_gen != ".*") {
             MF_LOG_INFO("BaseRadioGen")
               << "  Volume " << volume_name << " is an accepted volume of "
               << volume->GetShape()->Capacity() << "cm^3.\n";
             if (volume->GetShape()->TestShapeBits(TGeoShape::kGeoBox)) {
               TGeoBBox* box = dynamic_cast<TGeoBBox*>(volume->GetShape());
               if (box)
                 MF_LOG_INFO("BaseRadioGen")
                   << "  It is a box of size " << 2. * box->GetDX() << " x " << 2. * box->GetDY()
                   << " x " << 2. * box->GetDZ() << " cm^3\n";
             }
           }
 
           m_good_volumes.push_back(volume);
         }
       }
 
       for (int i = 0; i < materials->GetEntries(); ++i) {
         TGeoMaterial* material = (TGeoMaterial*)materials->At(i);
         std::string material_name = material->GetName();
         bool good = std::regex_match(material_name, m_regex_material);
         if (good) m_good_materials.push_back(material);
       }
     }
     MF_LOG_INFO("BaseRadioGen") << m_good_volumes.size() << " volumes correspond to the regex \""
                                 << m_volume_gen << "\".\n";
     MF_LOG_INFO("BaseRadioGen") << m_good_materials.size()
                                 << " materials correspond to the regex \"" << m_material << "\".\n";
 
     if (pset.has_key("X0") or pset.has_key("X1") or pset.has_key("Y0") or pset.has_key("Y1") or
         pset.has_key("Z0") or pset.has_key("Z1")) {
 
       m_geo_volume_mode = false;
       m_volume_rand_present = false;
 
       m_X0 = pset.get<double>("X0");
       m_Y0 = pset.get<double>("Y0");
       m_Z0 = pset.get<double>("Z0");
       m_X1 = pset.get<double>("X1");
       m_Y1 = pset.get<double>("Y1");
       m_Z1 = pset.get<double>("Z1");
 
       CalculateActiveVolumeFromXYZ();
     }
     else {
       const TGeoNode* world = gGeoManager->GetNode(0);
 
       if (pset.get_if_present<std::string>("volume_rand", m_volume_rand)) {
         m_geo_volume_mode = false;
         m_volume_rand_present = true;
 
         const TGeoNode* node = nullptr;
         findNode(world, m_volume_rand, node);
         GetNodeXYZMinMax(node, world, m_X0, m_X1, m_Y0, m_Y1, m_Z0, m_Z1);
 
         CalculateActiveVolumeFromXYZ();
       }
       else {
         m_geo_volume_mode = true;
         m_volume_rand_present = false;
         CalculateActiveVolumeFromAllNodes();
       }
     }
 
     auto rand = CLHEP::RandFlat(m_engine);
     gRandom->SetSeed(rand.fireInt(std::numeric_limits<long>::max()));
 
     if (pset.has_key("distrib_x"))
       m_distrib_xpos = new TF1("distrib_x", pset.get<std::string>("distrib_x").c_str(), m_X0, m_X1);
     if (pset.has_key("distrib_y"))
       m_distrib_ypos = new TF1("distrib_y", pset.get<std::string>("distrib_y").c_str(), m_Y0, m_Y1);
     if (pset.has_key("distrib_z"))
       m_distrib_zpos = new TF1("distrib_z", pset.get<std::string>("distrib_z").c_str(), m_Z0, m_Z1);
   }

Member Function Documentation

void evgen::BaseRadioGen::beginJob ( )

inlinevirtual

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 ( )

inlinevirtual

Reimplemented in evgen::Decay0Gen.

Definition at line 81 of file BaseRadioGen.h.

81 {}

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

inlinevirtual

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 & )

inlinevirtual

Definition at line 80 of file BaseRadioGen.h.

80 {}

void evgen::BaseRadioGen::CalculateActiveVolumeFromAllNodes ( )

inlineprivate

Definition at line 402 of file BaseRadioGen.h.

Referenced by GetZs().

   {
     FillAllNodes(gGeoManager->GetTopNode());
     m_volume_cc = 0;
 
     for (auto const& node : m_all_nodes) {
       if (not NodeSupported(node)) continue;
 
       double capa = node->GetVolume()->GetShape()->Capacity();
       m_volume_cc += capa;
       m_good_nodes[node] = m_volume_cc;
     }
 
     MF_LOG_INFO("BaseRadioGen")
       << m_good_nodes.size() << " nodes (i.e. instance of the volumes) satisfy both the regexes.\n";
 
     if (empty(m_good_nodes))
       throw cet::exception("BaseRadioGen")
         << "Didn't find an instance of material " << m_material << " and the volume "
         << m_volume_gen << " in the geometry.\n";
   }

void evgen::BaseRadioGen::CalculateActiveVolumeFromXYZ ( )

inlineprivate

Definition at line 424 of file BaseRadioGen.h.

Referenced by GetZs().

   {
     m_volume_cc = (m_X1 - m_X0) * (m_Y1 - m_Y0) * (m_Z1 - m_Z0);
 
     if (m_material != ".*" || m_volume_gen != ".*") {
       MF_LOG_INFO("BaseRadioGen") << "Calculating the proportion of " << m_material
                                   << " and the volume " << m_volume_gen
                                   << " in the specified volume " << m_volume_rand << ".\n";
       size_t nfound = 0;
       size_t ntries = 0;
 
       double xyz[3];
       TGeoNode* node = nullptr;
 
       while (nfound < m_target_n_point_rate_calculation and ntries < m_max_tries_rate_calculation) {
         ntries++;
         node = nullptr;
         xyz[0] = m_X0 + (m_X1 - m_X0) * m_random_flat.fire(0, 1.);
         xyz[1] = m_Y0 + (m_Y1 - m_Y0) * m_random_flat.fire(0, 1.);
         xyz[2] = m_Z0 + (m_Z1 - m_Z0) * m_random_flat.fire(0, 1.);
         m_geo_manager->SetCurrentPoint(xyz);
         node = m_geo_manager->FindNode();
         if (!node) continue;
         if (node->IsOverlapping()) continue;
 
         if (!NodeSupported(node)) continue;
         nfound++;
       }
 
       if (nfound == 0) {
         throw cet::exception("BaseRadioGen")
           << "Didn't find the material " << m_material << " and the volume " << m_volume_gen
           << " in the specified volume " << m_volume_rand << ".\n"
           << "Position of the box:\n"
           << m_X0 << " " << m_X1 << "\n"
           << m_Y0 << " " << m_Y1 << "\n"
           << m_Z0 << " " << m_Z1 << "\n";
       }
 
       double proportion = (double)nfound / ntries;
       double proportion_error = proportion * sqrt(1. / nfound + 1. / ntries);
       m_volume_cc *= proportion;
 
       MF_LOG_INFO("BaseRadioGen")
         << "There is " << proportion * 100. << "% (+/- " << proportion_error * 100. << "%) of "
         << m_material << " and " << m_volume_gen << " in the specified volume ("
         << 100. * proportion_error / proportion << "% relat. uncert.).\n"
         << "If the uncertainty is too big, crank up the parameters \"max_tries_rate_calculation\" "
            "(default=40,000,000) and/or \"target_n_point_rate_calculation\" (default=100,000) in "
            "your fhicl.\n\n\n";
     }
   }

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

void evgen::BaseRadioGen::DeclareOutputHistos ( )

inlineprivate

Definition at line 724 of file BaseRadioGen.h.

Referenced by GetZs().

   {
     art::ServiceHandle<art::TFileService> tfs;
     auto pdgs = {1000020040, 11, -11, 22, 2112, 2212, 9999};
     m_pdg_TH1D = tfs->make<TH1D>("PDG", ";PDG;n particles/event", pdgs.size(), 0, pdgs.size());
 
     for (auto pdg : pdgs) {
 
       std::string part = "";
       int simple_pdg;
       SimplePDG(pdg, simple_pdg, part);
       art::TFileDirectory dir = tfs->mkdir(part.c_str());
 
       m_pos_xy_TH2D[simple_pdg] =
         dir.make<TH2D>("posXY", ";X [cm];Y [cm]", 100, m_X0, m_X1, 100, m_Y0, m_Y1);
       m_pos_xz_TH2D[simple_pdg] =
         dir.make<TH2D>("posXZ", ";X [cm];Z [cm]", 100, m_X0, m_X1, 100, m_Z0, m_Z1);
       m_dir_x_TH1D[simple_pdg] = dir.make<TH1D>("dirX", ";X momentum projection", 100, -1, 1);
       m_dir_y_TH1D[simple_pdg] = dir.make<TH1D>("dirY", ";Y momentum projection", 100, -1, 1);
       m_dir_z_TH1D[simple_pdg] = dir.make<TH1D>("dirZ", ";Z momentum projection", 100, -1, 1);
       m_mom_TH1D[simple_pdg] =
         dir.make<TH1D>("Momentum", ";Momentum [MeV];n particles/event", 5000, 0, 500);
       m_ke_TH1D[simple_pdg] = dir.make<TH1D>("KE", ";KE [MeV];n particles/event", 5000, 0, 500);
       m_time_TH1D[simple_pdg] =
         dir.make<TH1D>("Time", ";Time[ns];n particles/event", 100, m_T0, m_T1);
 
       m_pdg_TH1D->GetXaxis()->SetBinLabel(simple_pdg + 1, part.c_str());
     }
   }

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

inlineprotected

Definition at line 810 of file BaseRadioGen.h.

Referenced by 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 ( )

inlinevirtual

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 ( )

inlinevirtual

Reimplemented in evgen::Decay0Gen.

Definition at line 82 of file BaseRadioGen.h.

References dirCalc(), FillHistos(), GetGoodPositionTime(), GetNDecays(), and part.

82 {}

void evgen::BaseRadioGen::FillAllNodes ( const TGeoNode * curnode )

inlineprivate

Definition at line 658 of file BaseRadioGen.h.

   {
     if (!curnode) return;
     TObjArray* daunodes = curnode->GetNodes();
     if (!daunodes) return;
 
     TIter next(daunodes);
 
     const TGeoNode* anode = 0;
     while ((anode = (const TGeoNode*)next())) {
       m_all_nodes.insert(anode);
       FillAllNodes(anode);
     }
   }

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

inlineprotected

Definition at line 788 of file BaseRadioGen.h.

Referenced by endJob_radio(), evgen::SpectrumVolumeGen::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());
   }

bool evgen::BaseRadioGen::findMotherNode	(	const TGeoNode *	cur_node,
		std::string &	daughter_name,
		const TGeoNode *&	mother_node
	)

inlineprivate

Adapted from above.

Definition at line 697 of file BaseRadioGen.h.

Referenced by GetNodeXYZMinMax().

   {
     TObjArray* daunodes = cur_node->GetNodes();
 
     if (!daunodes) return false;
 
     TIter next(daunodes);
 
     const TGeoNode* anode = 0;
     bool found = 0;
     while ((anode = (const TGeoNode*)next())) {
       std::string nname = anode->GetName();
       std::string vname = anode->GetVolume()->GetName();
 
       if (nname == daughter_name || vname == daughter_name) {
         mother_node = cur_node;
         return true;
       }
       found = findMotherNode(anode, daughter_name, mother_node);
     }
 
     return found;
   }

bool evgen::BaseRadioGen::findNode	(	const TGeoNode *	curnode,
		std::string &	tgtnname,
		const TGeoNode *&	targetnode
	)

inlineprivate

Shamelessly stolen from here: https://cdcvs.fnal.gov/redmine/attachments/6719/calc_bbox.C.

Definition at line 673 of file BaseRadioGen.h.

   {
     std::string nname = curnode->GetName();
     std::string vname = curnode->GetVolume()->GetName();
     if (nname == tgtnname || vname == tgtnname) {
       targetnode = curnode;
       return true;
     }
 
     TObjArray* daunodes = curnode->GetNodes();
     if (!daunodes) return false;
     TIter next(daunodes);
     const TGeoNode* anode = 0;
     while ((anode = (const TGeoNode*)next())) {
       bool found = findNode(anode, tgtnname, targetnode);
       if (found) return true;
     }
 
     return false;
   }

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 )

inlineprotected

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 endJob_radio(), evgen::SpectrumVolumeGen::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 ( )

inlineprotected

Definition at line 629 of file BaseRadioGen.h.

Referenced by endJob_radio(), evgen::SpectrumVolumeGen::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 ( )

inlineprotected

Definition at line 93 of file BaseRadioGen.h.

References m_nevent.

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

93 { return m_nevent; }

evgen::BaseRadioGen::m_nevent

int m_nevent

Definition: BaseRadioGen.h:180

void evgen::BaseRadioGen::GetNodeXYZMinMax	(	const TGeoNode *	from,
		const TGeoNode *	to,
		double &	x_min,
		double &	x_max,
		double &	y_min,
		double &	y_max,
		double &	z_min,
		double &	z_max
	)

inlineprivate

Definition at line 199 of file BaseRadioGen.h.

References findMotherNode(), and geo::origin().

   {
     std::vector<const TGeoNode*> mother_nodes;
     const TGeoNode* current_node = from;
     std::string daughter_name = from->GetName();
     int nmax = 20;
     int iter = 0;
     while (current_node != to and iter++ < nmax) {
       const TGeoNode* mother_node = nullptr;
       daughter_name = current_node->GetName();
       bool found_mum = findMotherNode(to, daughter_name, mother_node);
       if (not found_mum) {
         throw cet::exception("BaseRadioGen")
           << "Didn't find the mum of the following node: " << daughter_name;
       }
       mother_nodes.push_back(mother_node);
       current_node = mother_node;
     }
 
     TGeoVolume* vol = from->GetVolume();
     TGeoShape* shape = vol->GetShape();
     TGeoBBox* bbox = (TGeoBBox*)shape;
 
     double dx = bbox->GetDX();
     double dy = bbox->GetDY();
     double dz = bbox->GetDZ();
 
     double halfs[3] = {dx, dy, dz};
     double posmin[3] = {1.0e30, 1.0e30, 1.0e30};
     double posmax[3] = {-1.0e30, -1.0e30, -1.0e30};
 
     const double* origin = bbox->GetOrigin();
     for (int ix = -1; ix <= 1; ix += 2) {
       for (int iy = -1; iy <= 1; iy += 2) {
         for (int iz = -1; iz <= 1; iz += 2) {
           double local[3];
           local[0] = origin[0] + (double)ix * halfs[0];
           local[1] = origin[1] + (double)iy * halfs[1];
           local[2] = origin[2] + (double)iz * halfs[2];
           double master[3];
           from->LocalToMaster(local, master);
           for (auto const& mum : mother_nodes) {
             local[0] = master[0];
             local[1] = master[1];
             local[2] = master[2];
             mum->LocalToMaster(local, master);
           }
           for (int j = 0; j < 3; ++j) {
             posmin[j] = TMath::Min(posmin[j], master[j]);
             posmax[j] = TMath::Max(posmax[j], master[j]);
           }
         }
       }
     }
 
     x_min = posmin[0];
     y_min = posmin[1];
     z_min = posmin[2];
     x_max = posmax[0];
     y_max = posmax[1];
     z_max = posmax[2];
   }

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

inlineprotected

Definition at line 92 of file BaseRadioGen.h.

References 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
	)

inlineprotected

Definition at line 94 of file BaseRadioGen.h.

References m_T0, and m_T1.

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

     {
       T0 = m_T0;
       T1 = m_T1;
     }

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

inlineprotected

Definition at line 99 of file BaseRadioGen.h.

References m_X0, and m_X1.

     {
       X0 = m_X0;
       X1 = m_X1;
     }

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

inlineprotected

Definition at line 104 of file BaseRadioGen.h.

References m_Y0, and m_Y1.

     {
       Y0 = m_Y0;
       Y1 = m_Y1;
     }

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

inlineprotected

Definition at line 109 of file BaseRadioGen.h.

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

     {
       Z0 = m_Z0;
       Z1 = m_Z1;
     }

bool evgen::BaseRadioGen::IsDaughterNode	(	const TGeoNode *	daughter_node,
		const TGeoNode *	mother_node
	)

inlineprivate

Definition at line 639 of file BaseRadioGen.h.

   {
     if (mother_node == daughter_node) return true;
 
     TObjArray* daunodes = mother_node->GetNodes();
     if (!daunodes) return false;
 
     TIter next(daunodes);
     const TGeoNode* anode = 0;
 
     while ((anode = (const TGeoNode*)next())) {
       bool found = IsDaughterNode(daughter_node, anode);
       if (found) return true;
     }
 
     return false;
   }

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

bool evgen::BaseRadioGen::NodeSupported ( TGeoNode const * node ) const

inlineprivate

Definition at line 192 of file BaseRadioGen.h.

References m_good_materials, and m_good_volumes.

   {
     assert(node != nullptr);
     return cet::search_all(m_good_volumes, node->GetVolume()) and
            cet::search_all(m_good_materials, node->GetMedium()->GetMaterial());
   }

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

inlinevirtual

Implements art::EDProducer.

Definition at line 477 of file BaseRadioGen.h.

   {
     m_nevent++;
     produce_radio(evt);
   }

virtual void evgen::BaseRadioGen::produce_radio ( art::Event & evt )

pure virtual

Implemented in evgen::Decay0Gen, and evgen::SpectrumVolumeGen.

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 evgen::BaseRadioGen::SimplePDG	(	int	pdg,
		int &	simple,
		std::string &	name
	)

inlineprivate

Definition at line 754 of file BaseRadioGen.h.

Referenced by GetZs().

   {
     switch (pdg) {
     case 1000020040:
       name = "alpha";
       simple = 0;
       return;
     case 22:
       name = "gamma";
       simple = 1;
       return;
     case -11:
       name = "positron";
       simple = 2;
       return;
     case 11:
       name = "electron";
       simple = 3;
       return;
     case 2112:
       name = "neutron";
       simple = 4;
       return;
     case 2212:
       name = "proton";
       simple = 5;
       return;
     default:
       name = "other";
       simple = 6;
       return;
     }
   }

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::set<const TGeoNode*> evgen::BaseRadioGen::m_all_nodes

private

Definition at line 120 of file BaseRadioGen.h.

double evgen::BaseRadioGen::m_Bq {signaling_NaN}

private

Radioactivity in Becquerels (decay per sec) per cubic cm.

Definition at line 144 of file BaseRadioGen.h.

std::map<int, TH1D*> evgen::BaseRadioGen::m_dir_x_TH1D {}

private

Definition at line 183 of file BaseRadioGen.h.

std::map<int, TH1D*> evgen::BaseRadioGen::m_dir_y_TH1D {}

private

Definition at line 184 of file BaseRadioGen.h.

std::map<int, TH1D*> evgen::BaseRadioGen::m_dir_z_TH1D {}

private

Definition at line 185 of file BaseRadioGen.h.

TF1* evgen::BaseRadioGen::m_distrib_xpos {nullptr}

private

Definition at line 176 of file BaseRadioGen.h.

TF1* evgen::BaseRadioGen::m_distrib_ypos {nullptr}

private

Definition at line 177 of file BaseRadioGen.h.

TF1* evgen::BaseRadioGen::m_distrib_zpos {nullptr}

private

Definition at line 178 of file BaseRadioGen.h.

CLHEP::HepRandomEngine& evgen::BaseRadioGen::m_engine

private

Definition at line 160 of file BaseRadioGen.h.

Referenced by BaseRadioGen(), and GetRandomEngine().

TGeoManager* evgen::BaseRadioGen::m_geo_manager

private

Definition at line 158 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

art::ServiceHandle<geo::Geometry const> evgen::BaseRadioGen::m_geo_service

private

Definition at line 157 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

bool evgen::BaseRadioGen::m_geo_volume_mode {false}

private

Definition at line 164 of file BaseRadioGen.h.

std::vector<const TGeoMaterial*> evgen::BaseRadioGen::m_good_materials {}

private

Definition at line 174 of file BaseRadioGen.h.

Referenced by NodeSupported().

std::map<const TGeoNode*, double> evgen::BaseRadioGen::m_good_nodes {}

private

Definition at line 172 of file BaseRadioGen.h.

std::vector<const TGeoVolume*> evgen::BaseRadioGen::m_good_volumes {}

private

Definition at line 173 of file BaseRadioGen.h.

Referenced by NodeSupported().

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

protected

isotope to simulate. Example: "Ar39"

Definition at line 90 of file BaseRadioGen.h.

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

std::map<int, TH1D*> evgen::BaseRadioGen::m_ke_TH1D {}

private

Definition at line 187 of file BaseRadioGen.h.

std::string evgen::BaseRadioGen::m_material

private

regex of materials in which to generate the decays. Example: "LAr"

Definition at line 137 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

size_t evgen::BaseRadioGen::m_max_tries_event

private

Definition at line 168 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

size_t evgen::BaseRadioGen::m_max_tries_rate_calculation

private

Definition at line 169 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

std::map<int, TH1D*> evgen::BaseRadioGen::m_mom_TH1D {}

private

Definition at line 186 of file BaseRadioGen.h.

int evgen::BaseRadioGen::m_nevent {0}

private

Definition at line 180 of file BaseRadioGen.h.

Referenced by GetNEvents().

TH1D* evgen::BaseRadioGen::m_pdg_TH1D {nullptr}

private

Definition at line 189 of file BaseRadioGen.h.

std::map<int, TH2D*> evgen::BaseRadioGen::m_pos_xy_TH2D {}

private

Definition at line 181 of file BaseRadioGen.h.

std::map<int, TH2D*> evgen::BaseRadioGen::m_pos_xz_TH2D {}

private

Definition at line 182 of file BaseRadioGen.h.

CLHEP::RandFlat evgen::BaseRadioGen::m_random_flat

private

Definition at line 161 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

CLHEP::RandPoisson evgen::BaseRadioGen::m_random_poisson

private

Definition at line 162 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

double evgen::BaseRadioGen::m_rate

private

Initial value:

{

signaling_NaN}

Radioactivity in Becquerels (decay per sec) use either of this of Bq.

Definition at line 145 of file BaseRadioGen.h.

bool evgen::BaseRadioGen::m_rate_mode

private

Definition at line 165 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

std::regex evgen::BaseRadioGen::m_regex_material

private

Definition at line 140 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

std::regex evgen::BaseRadioGen::m_regex_volume

private

Definition at line 141 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

double evgen::BaseRadioGen::m_T0 {signaling_NaN}

private

Beginning of time window to simulate in ns.

Definition at line 147 of file BaseRadioGen.h.

Referenced by GetTs().

double evgen::BaseRadioGen::m_T1 {signaling_NaN}

private

End of time window to simulate in ns.

Definition at line 148 of file BaseRadioGen.h.

Referenced by GetTs().

size_t evgen::BaseRadioGen::m_target_n_point_rate_calculation

private

Definition at line 170 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

std::map<int, TH1D*> evgen::BaseRadioGen::m_time_TH1D {}

private

Definition at line 188 of file BaseRadioGen.h.

double evgen::BaseRadioGen::m_volume_cc {signaling_NaN}

private

Definition at line 155 of file BaseRadioGen.h.

std::string evgen::BaseRadioGen::m_volume_gen

private

The volume in which to generate the decays.

Definition at line 139 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

std::string evgen::BaseRadioGen::m_volume_rand

private

The volume in which to generate the decays.

Definition at line 138 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

bool evgen::BaseRadioGen::m_volume_rand_present

private

Definition at line 166 of file BaseRadioGen.h.

Referenced by BaseRadioGen().

double evgen::BaseRadioGen::m_X0 {signaling_NaN}

private

Bottom corner x position (cm) in world coordinates.

Definition at line 149 of file BaseRadioGen.h.

Referenced by GetXs().

double evgen::BaseRadioGen::m_X1 {signaling_NaN}

private

Top corner x position (cm) in world coordinates.

Definition at line 152 of file BaseRadioGen.h.

Referenced by GetXs().

double evgen::BaseRadioGen::m_Y0 {signaling_NaN}

private

Bottom corner y position (cm) in world coordinates.

Definition at line 150 of file BaseRadioGen.h.

Referenced by GetYs().

double evgen::BaseRadioGen::m_Y1 {signaling_NaN}

private

Top corner y position (cm) in world coordinates.

Definition at line 153 of file BaseRadioGen.h.

Referenced by GetYs().

double evgen::BaseRadioGen::m_Z0 {signaling_NaN}

private

Bottom corner z position (cm) in world coordinates.

Definition at line 151 of file BaseRadioGen.h.

Referenced by GetZs().

double evgen::BaseRadioGen::m_Z1 {signaling_NaN}

private

Top corner z position (cm) in world coordinates.

Definition at line 154 of file BaseRadioGen.h.

Referenced by GetZs().

constexpr double evgen::BaseRadioGen::signaling_NaN = std::numeric_limits<double>::signaling_NaN()

staticprivate

Definition at line 143 of file BaseRadioGen.h.

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

larsimrad/v09_09_05/source/larsimrad/BxDecay0/BaseRadioGen.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation