recob::ChargedSpacePointCollectionCreator Class Reference

Creates a collection of space points with associated charge. More...

#include <ChargedSpacePointCreator.h>

Public Member Functions
void	put ()
	Puts all data products into the event, leaving the creator empty(). More...
Insertion and finish operations
void	add (recob::SpacePoint const &spacePoint, recob::PointCharge const &charge)
	Inserts the specified space point and associated data into the collection. More...
void	add (recob::SpacePoint &&spacePoint, recob::PointCharge &&charge)
void	addAll (std::vector< recob::SpacePoint > &&spacePoints, std::vector< recob::PointCharge > &&charges)
	Inserts all the space points and associated data from the vectors into the collection. More...
void	addAll (std::vector< recob::SpacePoint > const &spacePoints, std::vector< recob::PointCharge > const &charges)
Queries and operations
bool	empty () const
	Returns whether there are currently no space points in the collection. More...
std::size_t	size () const
	Returns the number of space points currently in the collection. More...
void	clear ()
	Removes all data from the collection, making it empty(). More...
bool	spent () const
	Returns whether put() has already been called. More...
bool	canMakePointers () const
	Returns whether art pointer making is enabled. More...
Complimentary unchecked element access
recob::SpacePoint const &	spacePoint (std::size_t i) const
	Returns the specified space point; undefined behaviour if not there. More...
recob::SpacePoint const &	lastSpacePoint () const
	Returns the last inserted space point; undefined behaviour if empty(). More...
art::Ptr< recob::SpacePoint >	spacePointPtr (std::size_t i) const
	Returns an art pointer to the specified space point (no check done!). More...
art::Ptr< recob::SpacePoint >	lastSpacePointPtr () const
	Returns an art pointer to the last inserted space point (no check!). More...
recob::PointCharge const &	charge (std::size_t i) const
	Returns the last inserted charge; undefined behaviour if empty(). More...
recob::PointCharge const &	lastCharge () const
	Returns the last inserted charge; undefined behaviour if empty(). More...
art::Ptr< recob::PointCharge >	chargePtr (std::size_t i) const
	Returns an art pointer to the specified charge (no check done!). More...
art::Ptr< recob::PointCharge >	lastChargePtr () const
	Returns an art pointer to the inserted charge (no check!). More...

Static Public Member Functions
Static constructor interface
These methods take care of initialization that needs to take place on construction of the module.
static void	produces (art::ProducesCollector &producesCollector, std::string const &instanceName={})
	Declares the data products being produced. More...

Private Member Functions
std::size_t	lastIndex () const
	Returns the index of the last element (undefined if empty). More...

Private Attributes
art::Event &	fEvent
	The event this object is bound to. More...
std::string	fInstanceName
	Instance name of all the data products. More...
std::unique_ptr< std::vector< recob::SpacePoint > >	fSpacePoints
	Space point data. More...
std::unique_ptr< art::PtrMaker< recob::SpacePoint > >	fSpacePointPtrMaker
	Space point pointer maker. More...
std::unique_ptr< std::vector< recob::PointCharge > >	fCharges
	Charge data. More...
std::unique_ptr< art::PtrMaker< recob::PointCharge > >	fChargePtrMaker
	Charge pointer maker. More...

Constructors
	ChargedSpacePointCollectionCreator (art::Event &event, std::string const &instanceName={})
	Constructor binding this object to a specific art event. More...
static ChargedSpacePointCollectionCreator	forPtrs (art::Event &event, std::string const &instanceName={})
	Static function binding a new object to a specific art event. More...

Detailed Description

Creates a collection of space points with associated charge.

This class facilitates the creation of data products satisfying the requirements the proxy::ChargedSpacePoints proxy relies on. It will keep track of space points and reconstructed charge, and will put them into the event at the end.

Requirements of the data products

The requirements guaranteed by the output of this collection creator satisfy the proxy::ChargedSpacePoints proxy requirements. They are:

• space points and charges stored in two separate data products
• space points and charge in the same order, so that charge at position i is associated to space point at the same position i
• one-to-one correspondence between each space point and its charge
• association is implicit in the requirements above: no art::Assns data product is produced

Usage

The usage pattern is made of two main parts:

declaration of the data products, at producer construction time

production of the data products, event by event

The second part happens within the context of the producer's produce() (or filter(), or equivalent) method, and it can be split into three stages:

construction of the collection creator, binding it to the current event

filling of the creator, usually in a loop

explicit transfer of the data products into the event

Declaration of the data products

In the same fashion as data products must be declared to art with a produces() call, the collection creator will have to perform an equivalent step. This is achieved by calling the staticproduces()` method from your module's constructor (see its documentation for an example).

Construction of a collection creator object

Collection creator objects are bound to a specific event and therefore can't be data members of the producer class. In the produces() method, we'll have:

void MyProducer::produce(art::Event& event) {

  recob::ChargedSpacePointCollectionCreator spacePoints(event);

  // ...

} // MyProducer::produce()

If art pointers to the data products are needed (e.g. to create associations), then the named-constructor idiom should be followed:

void MyProducer::produce(art::Event& event) {

  auto spacePoints = recob::ChargedSpacePointCollectionCreator::forPtrs(event);

  // ...

} // MyProducer::produce()

In both cases, an instance name can be specified which will be used for all the managed data products (space points and reconstructed charge).

Populating the collections

The core of the usage of this object is feeding the objects to the data product collections. This is done using the add() member function. If the data objects already exist, they can be moved in instead of being copied. For example:

void MyProducer::produce(art::Event& event) {

  recob::ChargedSpacePointCollectionCreator spacePoints(event);

  auto hitAssns
    = std::make_unique<art::Assns<recob::SpacePoint, recob::Hit>>();

  // some processing

  for (auto const& hitSet: hitSets) {

    recob::SpacePoint spacePoint;
    recob::PointCharge charge;

    fSpacePointChargeAlgo->run(hitSet, spacePoint, charge);

    // add the new space point and charge to the collection
    spacePoints.add(std::move(spacePoint), std::move(charge));

    // associate this space point with all the hits in the source set
    auto const& spacePointPtr = spacePoints.lastSpacePointPtr();
    for (art::Ptr<recob::Hit> const& hitPtr: hitSet)
      hitAssns.addSingle(spacePointPtr, hitPtr);

  } // for

  // ...

} // MyProducer::produce()

If your algorithm is creating a subcollection of space points and charges which are in the same order, a shortcut to a loop of add() is addAll():

void MyProducer::produce(art::Event& event) {

  recob::ChargedSpacePointCollectionCreator spacePoints(event);

  // some processing

  for (auto const& track: tracks) {

    std::vector<recob::SpacePoint> trackSpacePoints;
    std::vector<recob::PointCharge> trackCharges;

    fSpacePointChargeAlgo->run(track, trackSpacePoints, trackCharges);

    spacePoints.addAll
      (std::move(trackSpacePoints), std::move(trackCharges));

  } // for

  // ...

} // MyProducer::produce()

Operations on the collection

While the collection creator object is designed to be just a single-use, single-pattern helper, there are a few operations that it allows:

• query: the current number of space points (size()), whether there are any (empty()), and whether put() has been already called (spent(); see below)
• deletion: it is possible to remove all the data so far collected; this may be useful in case of error, where the data product should be set in as default-constructed (which unfortunately in the case of space points might be, albeit unlikely, a legal outcome)
• if art::Ptr-creation has been enabled (by calling the static 'forPtrs(...)' function), art pointers can be created with lastSpacePointPtr(), lastChargePtr(), spacePointPtr() and chargePtr() to the elements of the future data products

Insertion of the data products into the event

Again as in the standard producer pattern, where Event::put() needs to be called to finally move the data into art, the collection creator will need to be told to do the same:

void MyProducer::produce(art::Event& event) {

  recob::ChargedSpacePointCollectionCreator spacePoints(event);

  auto hitAssns
    = std::make_unique<art::Assns<recob::SpacePoint, recob::Hit>>();

  // ... filling here ...

  spacePoints.put();
  event.put(std::move(hitAssns)); // other data products go the usual way

} // MyProducer::produce()

The instance name used in put() had been set at construction time.

After put() is called, the object has served its purpose and can't be used any further. In this state, spent() method will return true.

Definition at line 225 of file ChargedSpacePointCreator.h.

Constructor & Destructor Documentation

recob::ChargedSpacePointCollectionCreator::ChargedSpacePointCollectionCreator	(	art::Event &	event,
		std::string const &	instanceName = {}
	)

Constructor binding this object to a specific art event.

Parameters

event	the art event to bind to
instanceName	_(default: empty)_ instance name for all data products

When the object is constructed with this constructor, the creation of art pointers will not be enabled (canMakePointers() will return false).

Definition at line 26 of file ChargedSpacePointCreator.cpp.

  : fEvent(event)
  , fInstanceName(instanceName)
  , fSpacePoints(std::make_unique<std::vector<recob::SpacePoint>>())
  , fCharges(std::make_unique<std::vector<recob::PointCharge>>())
  {}

Member Function Documentation

void recob::ChargedSpacePointCollectionCreator::add	(	recob::SpacePoint const &	spacePoint,
		recob::PointCharge const &	charge
	)

Inserts the specified space point and associated data into the collection.

Parameters

spacePoint	the space point to be copied into the collection
charge	the charge to be copied into the collection

The data is pushed as the new last element of the collection.

Data is copied or moved depending on which variant of this method is used.

Definition at line 51 of file ChargedSpacePointCreator.cpp.

{
  // if these assertion fail, add() is being called after put()
  assert(fSpacePoints);
  assert(fCharges);

  fSpacePoints->push_back(spacePoint);
  fCharges->push_back(charge);

  assert(fSpacePoints->size() == fCharges->size());

} // recob::ChargedSpacePointCollectionCreator::add(copy)

void recob::ChargedSpacePointCollectionCreator::add	(	recob::SpacePoint &&	spacePoint,
		recob::PointCharge &&	charge
	)

Definition at line 67 of file ChargedSpacePointCreator.cpp.

{
  // if these assertion fail, add() is being called after put()
  assert(fSpacePoints);
  assert(fCharges);

  fSpacePoints->push_back(std::move(spacePoint));
  fCharges->push_back(std::move(charge));

  assert(fSpacePoints->size() == fCharges->size());

} // recob::ChargedSpacePointCollectionCreator::add()

void recob::ChargedSpacePointCollectionCreator::addAll	(	std::vector< recob::SpacePoint > &&	spacePoints,
		std::vector< recob::PointCharge > &&	charges
	)

Inserts all the space points and associated data from the vectors into the collection.

Parameters

spacePoints	the space point to be copied into the collection
charges	the charges to be copied into the collection

Exceptions

cet::exception

(category ChargedSpacePointCollectionCreator) if the input collections are inconsistent

The data is pushed as the new last element of the collection.

Data is copied or moved depending on which variant of this method is used.

No exception safety is offered here.

Definition at line 82 of file ChargedSpacePointCreator.cpp.

{
  // if these assertion fail, addAll() is being called after put()
  assert(fSpacePoints);
  assert(fCharges);

  if (spacePoints.size() != charges.size()) {
    throw cet::exception("ChargedSpacePointCollectionCreator")
      << "Input collections of inconsistent size:"
      << " " << spacePoints.size() << " (space points)"
      << "and " << charges.size() << " (charges)"
      << "\n";
  }
  if (empty()) {
    *fSpacePoints = std::move(spacePoints);
    *fCharges = std::move(charges);
  }
  else {
    fSpacePoints->reserve(fSpacePoints->size() + spacePoints.size());
    for (auto&& obj: spacePoints) fSpacePoints->push_back(std::move(obj));
    spacePoints.clear();

    fCharges->reserve(fCharges->size() + charges.size());
    for (auto&& obj: charges) fCharges->push_back(std::move(obj));
    charges.clear();
  }

  assert(fSpacePoints->size() == fCharges->size());

} // recob::ChargedSpacePointCollectionCreator::addAll()

void recob::ChargedSpacePointCollectionCreator::addAll	(	std::vector< recob::SpacePoint > const &	spacePoints,
		std::vector< recob::PointCharge > const &	charges
	)

Definition at line 118 of file ChargedSpacePointCreator.cpp.

{
  // if these assertion fail, addAll() is being called after put()
  assert(fSpacePoints);
  assert(fCharges);


  if (spacePoints.size() != charges.size()) {
    throw cet::exception("ChargedSpacePointCollectionCreator")
      << "Input collections of inconsistent size:"
      << " " << spacePoints.size() << " (space points)"
      << "and " << charges.size() << " (charges)"
      << "\n";
  }
  fSpacePoints->reserve(fSpacePoints->size() + spacePoints.size());
  std::copy
    (spacePoints.begin(), spacePoints.end(), std::back_inserter(*fSpacePoints));

  fCharges->reserve(fCharges->size() + charges.size());
  std::copy(charges.begin(), charges.end(), std::back_inserter(*fCharges));

  assert(fSpacePoints->size() == fCharges->size());

} // recob::ChargedSpacePointCollectionCreator::addAll()

bool recob::ChargedSpacePointCollectionCreator::canMakePointers ( ) const

inline

Returns whether art pointer making is enabled.

Definition at line 343 of file ChargedSpacePointCreator.h.

{ return bool(fSpacePointPtrMaker); }

recob::PointCharge const& recob::ChargedSpacePointCollectionCreator::charge ( std::size_t  i ) const

inline

Returns the last inserted charge; undefined behaviour if empty().

Definition at line 370 of file ChargedSpacePointCreator.h.

      { return fCharges->operator[](i); }

art::Ptr< recob::PointCharge > recob::ChargedSpacePointCollectionCreator::chargePtr

(

std::size_t

i

)

const

Returns an art pointer to the specified charge (no check done!).

Definition at line 183 of file ChargedSpacePointCreator.cpp.

{
  return fChargePtrMaker? (*fChargePtrMaker)(i): art::Ptr<recob::PointCharge>{};
} // recob::ChargedSpacePointCollectionCreator::chargePtr()

void recob::ChargedSpacePointCollectionCreator::clear

(

)

Removes all data from the collection, making it empty().

Definition at line 160 of file ChargedSpacePointCreator.cpp.

                                                    {

  if (fSpacePoints) fSpacePoints->clear();
  if (fCharges) fCharges->clear();

  assert(empty());

} // recob::ChargedSpacePointCollectionCreator::clear()

bool recob::ChargedSpacePointCollectionCreator::empty ( ) const

inline

Returns whether there are currently no space points in the collection.

Definition at line 331 of file ChargedSpacePointCreator.h.

{ return spent() || fSpacePoints->empty(); }

recob::ChargedSpacePointCollectionCreator recob::ChargedSpacePointCollectionCreator::forPtrs ( art::Event &  event, std::string const &  instanceName = {}  )

static

Static function binding a new object to a specific art event.

Parameters

event	the art event to bind to
instanceName	_(default: empty)_ instance name for all data products

This static function follows the named-constructor idiom, enabling the creation of art pointers.

Definition at line 37 of file ChargedSpacePointCreator.cpp.

{
  ChargedSpacePointCollectionCreator creator(event, instanceName);
  creator.fSpacePointPtrMaker = std::make_unique<art::PtrMaker<recob::SpacePoint>>
    (event, instanceName);
  creator.fChargePtrMaker = std::make_unique<art::PtrMaker<recob::PointCharge>>
    (event, instanceName);
  return creator;
} // ChargedSpacePointCollectionCreator(ProducesCollector)

recob::PointCharge const& recob::ChargedSpacePointCollectionCreator::lastCharge ( ) const

inline

Returns the last inserted charge; undefined behaviour if empty().

Definition at line 374 of file ChargedSpacePointCreator.h.

      { return charge(lastIndex()); }

art::Ptr<recob::PointCharge> recob::ChargedSpacePointCollectionCreator::lastChargePtr ( ) const

inline

Returns an art pointer to the inserted charge (no check!).

Definition at line 381 of file ChargedSpacePointCreator.h.

      { return chargePtr(lastIndex()); }

std::size_t recob::ChargedSpacePointCollectionCreator::lastIndex ( ) const

inlineprivate

Returns the index of the last element (undefined if empty).

Definition at line 434 of file ChargedSpacePointCreator.h.

{ return size() - 1U; }

recob::SpacePoint const& recob::ChargedSpacePointCollectionCreator::lastSpacePoint ( ) const

inline

Returns the last inserted space point; undefined behaviour if empty().

Definition at line 358 of file ChargedSpacePointCreator.h.

      { return spacePoint(lastIndex()); }

art::Ptr<recob::SpacePoint> recob::ChargedSpacePointCollectionCreator::lastSpacePointPtr ( ) const

inline

Returns an art pointer to the last inserted space point (no check!).

Definition at line 365 of file ChargedSpacePointCreator.h.

      { return spacePointPtr(lastIndex()); }

void recob::ChargedSpacePointCollectionCreator::produces ( art::ProducesCollector &  producesCollector, std::string const &  instanceName = {}  )

static

Declares the data products being produced.

Parameters

producer	the module producing the data products
instanceName	_(default: empty)_ name of instance of all data products

Call this method in the constructor of producer, e.g.:

MyProducer::MyProducer(Parameters const& config) {

  recob::ChargedSpacePointCollectionCreator::produces
    (producesCollector(), config().instanceName());

} // MyProducer::MyProducer()

Definition at line 191 of file ChargedSpacePointCreator.cpp.

{

  producesCollector.produces<std::vector<recob::SpacePoint>>(instanceName);
  producesCollector.produces<std::vector<recob::PointCharge>>(instanceName);

} // recob::ChargedSpacePointCollectionCreator::produces()

void recob::ChargedSpacePointCollectionCreator::put

(

)

Puts all data products into the event, leaving the creator empty().

The accumulated data is moved into the event.

This is the last valid action of the object. After this, only empty(), spent() and the art pointer makers (if enabled) are guaranteed to work.

Definition at line 149 of file ChargedSpacePointCreator.cpp.

                                                  {

  fEvent.put(std::move(fSpacePoints), fInstanceName);
  fEvent.put(std::move(fCharges), fInstanceName);

  assert(spent());
  assert(empty());
} // recob::ChargedSpacePointCollectionCreator::put()

std::size_t recob::ChargedSpacePointCollectionCreator::size ( void  ) const

inline

Returns the number of space points currently in the collection.

Definition at line 334 of file ChargedSpacePointCreator.h.

{ return spent()? 0U: fSpacePoints->size(); }

recob::SpacePoint const& recob::ChargedSpacePointCollectionCreator::spacePoint ( std::size_t  i ) const

inline

Returns the specified space point; undefined behaviour if not there.

Definition at line 354 of file ChargedSpacePointCreator.h.

      { return fSpacePoints->operator[](i); }

art::Ptr< recob::SpacePoint > recob::ChargedSpacePointCollectionCreator::spacePointPtr

(

std::size_t

i

)

const

Returns an art pointer to the specified space point (no check done!).

Definition at line 173 of file ChargedSpacePointCreator.cpp.

{
  return fSpacePointPtrMaker
    ? (*fSpacePointPtrMaker)(i): art::Ptr<recob::SpacePoint>{};
} // recob::ChargedSpacePointCollectionCreator::spacePointPtr()

bool recob::ChargedSpacePointCollectionCreator::spent ( ) const

inline

Returns whether put() has already been called.

Definition at line 340 of file ChargedSpacePointCreator.h.

{ return !fSpacePoints; }

Member Data Documentation

std::unique_ptr<art::PtrMaker<recob::PointCharge> > recob::ChargedSpacePointCollectionCreator::fChargePtrMaker

private

Charge pointer maker.

Definition at line 431 of file ChargedSpacePointCreator.h.

std::unique_ptr<std::vector<recob::PointCharge> > recob::ChargedSpacePointCollectionCreator::fCharges

private

Charge data.

Definition at line 429 of file ChargedSpacePointCreator.h.

art::Event& recob::ChargedSpacePointCollectionCreator::fEvent

private

The event this object is bound to.

Definition at line 420 of file ChargedSpacePointCreator.h.

std::string recob::ChargedSpacePointCollectionCreator::fInstanceName

private

Instance name of all the data products.

Definition at line 422 of file ChargedSpacePointCreator.h.

std::unique_ptr<art::PtrMaker<recob::SpacePoint> > recob::ChargedSpacePointCollectionCreator::fSpacePointPtrMaker

private

Space point pointer maker.

Definition at line 427 of file ChargedSpacePointCreator.h.

std::unique_ptr<std::vector<recob::SpacePoint> > recob::ChargedSpacePointCollectionCreator::fSpacePoints

private

Space point data.

Definition at line 425 of file ChargedSpacePointCreator.h.

---

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

• lardata/lardata/ArtDataHelper/ChargedSpacePointCreator.h
• lardata/lardata/ArtDataHelper/ChargedSpacePointCreator.cpp