Creates some dummy hits. More...

Inheritance diagram for lar::test::TrackProxyTrackMaker:

Classes
struct	Config

Public Types
using	Parameters = art::EDProducer::Table< Config >

Public Types inherited from art::EDProducer
using	ModuleType = EDProducer

using	WorkerType = WorkerT< EDProducer >

Public Types inherited from art::detail::Producer
template<typename UserConfig , typename KeysToIgnore = void>
using	Table = Modifier::Table< UserConfig, KeysToIgnore >

Public Types inherited from art::Modifier
template<typename UserConfig , typename UserKeysToIgnore = void>
using	Table = ProducerTable< UserConfig, detail::ModuleConfig, UserKeysToIgnore >

Public Member Functions
	TrackProxyTrackMaker (Parameters const &config)

virtual void	produce (art::Event &event) override

Public Member Functions inherited from art::EDProducer
	EDProducer (fhicl::ParameterSet const &pset)

template<typename Config >
	EDProducer (Table< Config > const &config)

std::string	workerType () const

Public Member Functions inherited from art::detail::Producer
virtual	~Producer () noexcept

	Producer (fhicl::ParameterSet const &)

	Producer (Producer const &)=delete

	Producer (Producer &&)=delete

Producer &	operator= (Producer const &)=delete

Producer &	operator= (Producer &&)=delete

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)

Public Member Functions inherited from art::Modifier
	~Modifier () noexcept

	Modifier ()

	Modifier (Modifier const &)=delete

	Modifier (Modifier &&)=delete

Modifier &	operator= (Modifier const &)=delete

Modifier &	operator= (Modifier &&)=delete

Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept

	ModuleBase ()

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)

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

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

Private Attributes
art::InputTag	hitsTag
	Input hit collection label. More...

std::vector< unsigned int >	hitsPerTrack
	Hits per produced track. More...

Additional Inherited Members
Static Public Member Functions inherited from art::EDProducer
static void	commitEvent (EventPrincipal &ep, Event &e)

Protected Member Functions inherited from art::ModuleBase
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 ()

Detailed Description

Creates some dummy hits.

The produced tracks have completely dummy content.

Configuration parameters

hits (input tag, mandatory): the data product to read the hits from
hitsPerTrack (list of unsigned integers, mandatory): number of hits for each produced track. If there are hits left after all the tracks specified here have been created, an additional track with all those hits is created. If there are not enough hits, an exception is thrown.

Definition at line 58 of file TrackProxyTrackMaker_module.cc.

Member Typedef Documentation

using lar::test::TrackProxyTrackMaker::Parameters = art::EDProducer::Table<Config>

Definition at line 77 of file TrackProxyTrackMaker_module.cc.

Constructor & Destructor Documentation

lar::test::TrackProxyTrackMaker::TrackProxyTrackMaker ( Parameters const & config )

inlineexplicit

Definition at line 79 of file TrackProxyTrackMaker_module.cc.

         : EDProducer{config}
         , hitsTag(config().hitsTag())
         , hitsPerTrack(config().hitsPerTrack())
         {
           produces<std::vector<recob::TrackTrajectory>>();
           produces<art::Assns<recob::TrackTrajectory, recob::Hit>>();
           produces<std::vector<recob::Track>>();
           produces<std::vector<std::vector<recob::TrackFitHitInfo>>>();
           produces<art::Assns<recob::Track, recob::Hit, recob::TrackHitMeta>>();
           produces<art::Assns<recob::Track, recob::TrackTrajectory>>();
         }

Member Function Documentation

void lar::test::TrackProxyTrackMaker::produce ( art::Event & event )

overridevirtual

Implements art::EDProducer.

Definition at line 108 of file TrackProxyTrackMaker_module.cc.

                                                          {
 
   auto trajectories = std::make_unique<std::vector<recob::TrackTrajectory>>();
   auto tracks = std::make_unique<std::vector<recob::Track>>();
   auto trackFitInfo
     = std::make_unique<std::vector<std::vector<recob::TrackFitHitInfo>>>();
   auto hitTrackAssn
     = std::make_unique<art::Assns<recob::Track, recob::Hit, recob::TrackHitMeta>>();
   auto hitTrajectoryAssn
     = std::make_unique<art::Assns<recob::TrackTrajectory, recob::Hit>>();
   auto trackTrajectoryAssn
     = std::make_unique<art::Assns<recob::Track, recob::TrackTrajectory>>();
 
   auto hitHandle = event.getValidHandle<std::vector<recob::Hit>>(hitsTag);
   auto const& hits = *hitHandle;
 
   art::PtrMaker<recob::TrackTrajectory> trajectoryPtrMaker(event);
   art::PtrMaker<recob::Track> trackPtrMaker(event);
   unsigned int iTrack = 0;
   unsigned int usedHits = 0;
   while (usedHits < hits.size()) {
 
     // how many hits for this track:
     unsigned int const nTrackHits = (iTrack < hitsPerTrack.size())
       ? std::min(hitsPerTrack[iTrack], (unsigned int)(hits.size() - usedHits))
       : (hits.size() - usedHits)
       ;
 
     //
     // create the track trajectory and fit information
     //
     std::size_t const firstHit = usedHits;
     recob::TrackTrajectory::Positions_t pos;
     recob::TrackTrajectory::Momenta_t mom;
     recob::TrackTrajectory::Flags_t flags;
     std::vector<recob::TrackFitHitInfo> fitInfo;
     for (unsigned int iPoint = 0; iPoint < nTrackHits; ++iPoint) {
       //
       // fill base track information
       //
       using Mask_t = recob::TrajectoryPointFlags::flag::Mask_t;
       Mask_t pointFlags {
         - recob::TrajectoryPointFlags::flag::NoPoint
         - recob::TrajectoryPointFlags::flag::HitIgnored
         - recob::TrajectoryPointFlags::flag::Suspicious
         - recob::TrajectoryPointFlags::flag::DetectorIssue
         };
 
       // one point out of seven has no valid position at all
       if (iPoint % 7 == 2) // make sure there are at least two valid points
         pointFlags.set(recob::TrajectoryPointFlags::flag::NoPoint);
       // one point out of five was made ignoring the hit
       if (iPoint % 5)
         pointFlags.set(recob::TrajectoryPointFlags::flag::HitIgnored);
       // one point out of three is suspicious
       if (iPoint % 3)
         pointFlags.set(recob::TrajectoryPointFlags::flag::Suspicious);
       // every other point has issues
       if (iPoint % 2)
         pointFlags.set(recob::TrajectoryPointFlags::flag::DetectorIssue);
 
       pos.emplace_back(iPoint, iPoint, iPoint);
       mom.emplace_back(2.0, 1.0, 0.0);
       flags.emplace_back(usedHits++, pointFlags);
       //
       // fill optional information
       //
       fitInfo.push_back({
         double(iPoint) * 2.5,              // aHitMeas
         double(iPoint) * 1.5,              // aHitMeasErr2
         {},                                // aTrackStatePar
         { ROOT::Math::SMatrixIdentity{} }, // aTrackStateCov
         hits[usedHits + iPoint].WireID()   // aWireId
         });
     } // for
 
     // produce some "additional" trajectory (pretty much invalid)
     trajectories->emplace_back();
 
     trajectories->emplace_back
       (std::move(pos), std::move(mom), std::move(flags), true);
 
     //
     // create the trajectory-hit associations
     // (no hits for the invalid trajectory)
     //
     auto const trajPtr = trajectoryPtrMaker(trajectories->size() - 1U);
     for (std::size_t iHit = firstHit; iHit < usedHits; ++iHit)
       hitTrajectoryAssn->addSingle(trajPtr, { hitHandle, iHit });
 
     //
     // create the track
     //
     recob::Track track
       (trajectories->back(), 2112, 1.0, nTrackHits, {}, {}, iTrack);
     tracks->push_back(std::move(track));
 
     //
     // and the additional objects
     //
     trackFitInfo->push_back(std::move(fitInfo));
 
     //
     // create the track-hit associations
     //
     auto const trackPtr = trackPtrMaker(iTrack);
     for (std::size_t iHit = firstHit; iHit < usedHits; ++iHit) {
 
       auto const hitIndex = iHit - firstHit;
       recob::TrackHitMeta const hitInfo(hitIndex, 2.0 * hitIndex);
       hitTrackAssn->addSingle(trackPtr, { hitHandle, iHit }, hitInfo);
 
     } // for
 
     //
     // create the track-trajectory associations
     //
     trackTrajectoryAssn->addSingle(trackPtr, trajPtr);
 
     mf::LogVerbatim("TrackProxyTrackMaker")
       << "New track #" << tracks->back().ID()
       << " with " << nTrackHits << " hits";
 
     //
     // prepare for the next track
     //
     ++iTrack;
 
   } // while
 
   mf::LogInfo("TrackProxyTrackMaker")
     << "Produced " << tracks->size() << " tracks from " << usedHits << " hits.";
 
   event.put(std::move(trajectories));
   event.put(std::move(hitTrajectoryAssn));
   event.put(std::move(tracks));
   event.put(std::move(trackFitInfo));
   event.put(std::move(hitTrackAssn));
   event.put(std::move(trackTrajectoryAssn));
 
 } // lar::test::TrackProxyTrackMaker::produce()