Interfaces to create instances of LArSoft data proxies. More...

Modules
	LArSoft data proxy infrastructure
	Classes for implementation and customization of LArsoft proxies.

Functions
template<typename CollProxy , typename Event , typename... OptionalArgs>
auto	proxy::getCollection (Event const &event, OptionalArgs &&...optionalArgs)
	Creates a proxy to a data product collection. More...

One-to-many sequential associations
These functions allow to merge into a data collection proxy auxiliary data via an art association fulfilling the one-to-many sequential association requirement. Two categories of functions are available depending on the data source: `proxy::withAssociated()` reads the relevant association from an event `proxy::wrapAssociated()` uses an existing association objects Variants of `proxy::withAssociated()` called `proxy::withAssociatedMeta()` allow merging the metadata of an association too. The `proxy::wrapAssociated()` functions always merge the metadata if the wrapped association has it. Also, variants are available to customize the tag class. The implementation of this feature is documented in its own doxygen module.
template<typename Aux , typename Metadata , typename AuxTag , typename... Args>
auto	proxy::withAssociatedMetaAs (Args &&...args)
	Helper function to merge associated data with metadata. More...

template<typename Aux , typename AuxTag , typename... Args>
auto	proxy::withAssociatedAs (Args &&...args)
	Helper function to merge associated data with no metadata. More...

template<typename Aux , typename Metadata , typename... Args>
auto	proxy::withAssociatedMeta (Args &&...args)
	Helper function to merge associated data. More...

template<typename Aux , typename... Args>
auto	proxy::withAssociated (Args &&...args)
	Helper function to merge associated data with no metadata. More...

template<typename AuxTag , typename Assns >
auto	proxy::wrapAssociatedAs (Assns const &assns)
	Helper function to merge associated data from a given association. More...

template<typename Assns >
auto	proxy::wrapAssociated (Assns const &assns)
	Helper function to merge associated data from a given association. More...

template<typename AuxTag , typename Assns >
auto	proxy::wrapAssociated (Assns const &assns)
	Helper function to merge associated data from a given association. More...

Parallel data collections
These functions allow to merge into a data collection proxy some auxiliary data from other collections fulfilling the parallel data product requirement. Two categories of functions are available depending on the data source: `proxy::withParallelData()` reads the relevant data product from an event `proxy::wrapParallelData()` uses an existing collection Also, variants are available to customize the tag class. The implementation of this feature is documented in its own doxygen module.
template<typename Aux , typename AuxTag , typename... Args>
auto	proxy::withParallelDataAs (Args &&...args)
	Helper function to merge an auxiliary data product into the proxy. More...

template<typename Aux , typename... Args>
auto	proxy::withParallelData (Args &&...args)
	Helper function to merge an auxiliary data product into the proxy. More...

template<typename AuxTag , typename AuxColl >
auto	proxy::wrapParallelDataAs (AuxColl const &auxColl)
	Uses a collection as auxiliary data for a collection proxy. More...

template<typename AuxColl >
auto	proxy::wrapParallelData (AuxColl const &auxColl)
	Uses a collection as auxiliary data for a collection proxy. More...

One-to-one (optional) associations
These functions allow to merge into a data collection proxy some auxiliary data via an art association fulfilling the one-to-(zero-or-one) sequential association requirement. One category of functions is currently available: `proxy::withZeroOrOne()` reads the relevant association from an event Variants of `proxy::withZeroOrOne()` called `proxy::withZeroOrOneMeta()` will allow merging the metadata of an association too. This feature is not supported yet, though. Also, variants are available to customize the tag class. The implementation of this feature is documented in its own doxygen module.
template<typename Aux , typename Metadata , typename AuxTag , typename... Args>
auto	proxy::withZeroOrOneMetaAs (Args &&...args)

template<typename Aux , typename AuxTag , typename... Args>
auto	proxy::withZeroOrOneAs (Args &&...args)

template<typename Aux , typename Metadata , typename... Args>
auto	proxy::withZeroOrOneMeta (Args &&...args)
	Helper function to merge one-to-(zero-or-one) associated data. More...

template<typename Aux , typename... Args>
auto	proxy::withZeroOrOne (Args &&...args)

Detailed Description

Interfaces to create instances of LArSoft data proxies.

This section contains documentation about the main tools to instantiate a data collection proxy in LArSoft. Some prepackaged data proxies are provided by LArSoft and documented in the recostructed object data proxy section.

The starting point is the documentation of proxy::getCollection(). That function is the way to create a proxy object in your code. Auxiliary data can me merged to that proxy on creation, and only then. Different functions help with merging different auxiliary data:

data from one-to-many associations stored following the one-to-many sequential association requirement can be fetched and merged with the proxy::withAssociated() class of functions, or just merged, is already fetched, with proxy::wrapAssociated() functions
data from a one-to-one optional associations (according to this requirement) can be merged with the proxy::withZeroOrOne() class of functions
data from another collection with a one-to-one implicit relation (according to this requirement) can be read and merged with the proxy::withParallelData() class of functions, or directly used with proxy::wrapParallelData() functions

Each auxiliary data is identified by a "tag", which is for example used when asking for that auxiliary data with get<Tag>() member of the proxy. Most of the withXxx() functions have a variant, usually withXxxAs(), that allows that tag to be explicitly chosen.

For the supported associated data, a variant withXxxMeta() (and withXxxMetaAs()) is offered which allows to access also the metadata of the association.

Function Documentation

template<typename CollProxy , typename Event , typename... OptionalArgs>

auto proxy::getCollection	(	Event const &	event,
		OptionalArgs &&...	optionalArgs
	)

Creates a proxy to a data product collection.

Template Parameters

CollProxy	type of target main collection proxy
Event	type of event to read data from
OptionalArgs	type of optional arguments

Parameters

event	event to read data from
optionalArgs	optional arguments for construction of the proxy

Returns: a collection proxy object

See also: ways to merge more data into a proxy

This function delivers a collection proxy related to CollProxy.

The type of proxy delivered is arbitrary and usually not CollProxy. The type of the collection proxy must be explicitly specified, e.g.:

auto tracks = proxy::getCollection<proxy::Tracks>

(event, tag, withAssociated<recob::Hits>());

In this case, two optional arguments are passed: the input tag to the main collection, and then withAssociated<recob::Hits>(). The meaning of both is decided depending on the collection proxy being created, but it's common to have the first argument be the input tag to the main collection, as in this example. withAssociated() is one of the ways for a proxy to have auxiliary data "merged" into. The options to merge this data are collected in the proxy interface documentation.

The collection proxy name is arbitrary, but it's custom to have it live in proxy namespace and have the same name as the base object, made plural: a proxy to a recob::Track collection data product will have a proxy called proxy::Tracks.

Note that a proxy need to be explicitly supported in order to be available. Nevertheless, a generic implementation is supported to create a proxy of a data product which is a C++ vector, so that:

auto tracks = proxy::getCollection<std::vector<recob::Track>>

(event, tag, withAssociated<recob::Hits>());

will have an outcome similar to the previous example. In this case, though, all the specific track interface that went into proxy::Tracks proxy will not be available.

The implementation of this feature is documented in its own doxygen module.

Customization

To control which type of collection proxy is produced for the type CollProxy, the class CollectionProxyMaker may be specialised.

Definition at line 81 of file getCollection.h.

References proxy::CollectionProxyMakerBase< CollProxy >::make().

   {
     return CollectionProxyMaker<CollProxy>::make(event,
                                                  std::forward<OptionalArgs>(optionalArgs)...);
   }

template<typename Aux , typename... Args>

auto proxy::withAssociated ( Args &&... args )

Helper function to merge associated data with no metadata.

Template Parameters

Aux	type of associated data requested
Args	types of constructor arguments for associated data collection

Parameters

args	constructor arguments for the associated data collection

Returns: a temporary object that getCollection() knows to handle

See also: withAssociatedMeta(), withAssociatedMetaAs(), wrapAssociated()

This function is equivalent to withAssociatedMeta() but with the request of no associated metadata (Metadata be void). Example of usage:

auto tracks = proxy::getCollection<proxy::Tracks>

(event, trackTag, withAssociated<recob::Cluster>(clusterTag));

The cluster association ("clusterTag") will be accessed by using the type recob::Cluster as tag:

for (auto const& track: tracks) {
  auto const& clusters = track.get<recob::Cluster>();
  for (art::Ptr<recob::Cluster> const& cluster: clusters) {
    // ...
  } // for clusters
} // for tracks

The interface of clusters is documented in lar::CollectionView. The interface of cluster is documented in proxy::details::AssnsNode.

For more extensive information, see proxy::withAssociatedMeta().

Definition at line 367 of file withAssociated.h.

   {
     return withAssociatedMeta<Aux, void>(std::forward<Args>(args)...);
   }

template<typename Aux , typename AuxTag , typename... Args>

auto proxy::withAssociatedAs ( Args &&... args )

Helper function to merge associated data with no metadata.

Template Parameters

Aux	type of associated data requested
AuxTag	tag to access the associated data within the proxy
Args	types of constructor arguments for associated data collection

Parameters

args	constructor arguments for the associated data collection

Returns: a temporary object that getCollection() knows to handle

See also: withAssociatedMeta(), withAssociatedAs(), wrapAssociatedAs()

This function is similar to withAssociated(), but it defines a tag for the data. In this example we fetch from event an association between recob::Track (which is the main type of the collection proxy proxy::Tracks) and recob::Cluster objects:

struct MyClusters {};
void analyze(art::Event const& event) {
  // ...
  auto tracks = proxy::getCollection<proxy::Tracks>
    (event, trackTag, withAssociatedAs<MyCluster>(clusterTag));
  // ...
  for (auto const& track: tracks) {
    auto const& clusters = track.get<MyCluster>();
    for (auto const& clusterInfo: clusters) {
      // implicit conversion:
      art::Ptr<recob::Cluster> const& clusterPtr = clusterInfo;
      // access to the cluster itself
      recob::Cluster const& cluster = *clusterInfo;
    } // for clusters
} // for tracks

The interface of clusters is documented in lar::CollectionView. The interface of clusterInfo is documented in proxy::details::AssnsNode.

For more extensive information, see proxy::withAssociatedMeta().

Definition at line 199 of file withAssociated.h.

   {
     return withAssociatedMetaAs<Aux, void, AuxTag>(std::forward<Args>(args)...);
   }

template<typename Aux , typename Metadata , typename... Args>

auto proxy::withAssociatedMeta ( Args &&... args )

Helper function to merge associated data.

Template Parameters

Aux	type of associated data requested
Metadata	type of associated metadata requested
Args	types of constructor arguments for associated data collection

Parameters

args	constructor arguments for the associated data collection

Returns: a temporary object that getCollection() knows to handle

See also: withAssociated(), withAssociatedAs(), withAssociatedMetaAs()

This function is meant to convey to getCollection() function the request for the delivered collection proxy to carry data from an association. This association must fulfil the one-to-many sequential association requirement. The associated data is normally extracted from an art association art::Assns<Main, Aux, Metadata>, where Main is the main type of the proxy collection. If no metadata is required, Metadata can be set to void, or withAssociated() can be used instead.

The function also transfers the information required to create a proxy to that auxiliary data.

This data will be tagged with the type Aux. To use a different type as tag, use withAssociatedAs() or withAssociatedMetaAs() instead, specifying the tag as second template argument, e.g.:

struct DubiousClusters {};
auto tracks = proxy::getCollection<proxy::Tracks>(event, trackTag,
  withAssociatedMeta<recob::Cluster, void>(defaultClusterTag),
  withAssociatedMetaAs<recob::Cluster, void, DubiousClusters>
    (maybeClusterTag)
  );

or, equivalently (because we asked for no metadata):

struct DubiousClusters {};
auto tracks = proxy::getCollection<proxy::Tracks>(event, trackTag,
  withAssociated<recob::Cluster>(defaultClusterTag),
  withAssociatedAs<recob::Cluster, DubiousClusters>(maybeClusterTag)
  );

The first cluster association ("defaultClusterTag") will be accessed by using the type recob::Cluster as tag, while the second one will be accessed by the DubiousClusters tag (which is better not be defined in a local scope):

for (auto const& track: tracks) {
  auto const& clusters = track.get<recob::Clusters>();
  auto const& maybeClusters = track.get<DubiousClusters>();
  // ...
}

The full interface of track is documented in lar::CollectionView. The interface of clusters and maybeClusters is documented in proxy::details::AssnsNode.

Customization of the association proxy

To have a call like:

auto tracks = getCollection<SpecialTracks>

(event, tag, withAssociatedMeta<recob::Hit, void>(hitAssnTag, "special"));

create something different than the standard association proxy, specialize proxy::AssociatedDataProxyMaker, e.g.:

namespace proxy {
  template <>
  struct AssociatedDataProxyMaker
    <recob::Track, recob::Hit, void, SpecialTracks>
    : public AssociatedDataProxyMakerBase
      <recob::Track, recob::Hit, void, SpecialTracks>
  {
    template<typename Event, typename MainArgs>
    static auto make(
      Event const& event,
      MainArgs const&,
      art::InputTag assnTag,
      std::string quality
      )
      {
        ::SpecialTrackHitsProxy myAuxProxy;
        // ... make it, and make it right
        return myAuxProxy;
      }
  }; // struct AssociatedDataProxyMaker<..., SpecialTracks>
} // namespace proxy

(the void template type signifies the association has no metadata).

Technical details

The main purpose of this function and the related WithAssociatedStruct class is to save the user from specifying the main type the auxiliary data is associated with, when using it as getCollection() argument:

auto tracks = getCollection<proxy::Tracks>

(event, tag, withAssociated<recob::Hit>(hitAssnTag));

While parsing the withAssociated() argument (or any argument), the information of which is the proxy collection type (proxy::Tracks in the example) is not known. In principle, to fully define the association, two template arguments are needed, e.g. withAssociated<recob::Track, recob::Hit>(hitAssnTag). The class WithAssociatedStruct holds the information of which associated type is requested (recob::Hit) and the information needed to create a proxy to such association (all arguments, here just hitAssnTag). The function getCollection() will have this object as argument, and when executing will be able to supply the missing information, that recob::Track is the main data product element we are associating to.

Definition at line 326 of file withAssociated.h.

   {
     return withAssociatedMetaAs<Aux, Metadata, Aux>(std::forward<Args>(args)...);
   }

template<typename Aux , typename Metadata , typename AuxTag , typename... Args>

auto proxy::withAssociatedMetaAs ( Args &&... args )

Helper function to merge associated data with metadata.

Template Parameters

Aux	type of associated data requested
Metadata	type of associated metadata requested
AuxTag	tag to access the associated data within the proxy
Args	types of constructor arguments for associated data collection

Parameters

args	constructor arguments for the associated data collection

Returns: a temporary object that getCollection() knows to handle

See also: withAssociatedMeta(), withAssociatedMetaAs(), wrapAssociated()

This function is similar to withAssociated(), but it also merges the specified metadata and defines a tag for the data. In this example we fetch from event an association between recob::Track (which is the main type of the collection proxy proxy::Tracks) and recob::Cluster objects, each one with an index as metadata:

struct MyClusters {};
void analyze(art::Event const& event) {
  // ...
  auto tracks = proxy::getCollection<proxy::Tracks>
    (event, trackTag, withAssociatedMetaAs<int, MyCluster>(clusterTag));
  // ...
  for (auto const& track: tracks) {
    auto const& clusters = track.get<MyCluster>();
    for (auto const& clusterInfo: clusters) {
      // implicit conversion:
      art::Ptr<recob::Cluster> const& clusterPtr = clusterInfo;
      // access to the cluster itself
      recob::Cluster const& cluster = *clusterInfo;
      // access to the metadata
      int index = clusterInfo.data();
    } // for clusters
} // for tracks

The interface of clusters is documented in lar::CollectionView. The interface of clusterInfo is documented in proxy::details::AssnsNode.

For more extensive information, see proxy::withAssociatedMeta().

Definition at line 143 of file withAssociated.h.

   {
     using ArgTuple_t = std::tuple<Args&&...>;
     ArgTuple_t argsTuple(std::forward<Args>(args)...);
     return details::WithAssociatedStruct<Aux, Metadata, ArgTuple_t, AuxTag>(std::move(argsTuple));
   } // withAssociatedMetaAs()

template<typename Aux , typename... Args>

auto proxy::withParallelData ( Args &&... args )

Helper function to merge an auxiliary data product into the proxy.

Template Parameters

Aux	type of parallel data product requested
Args	types of constructor arguments for parallel data proxy

Parameters

args	constructor arguments for the parallel data collection proxy

Returns: a temporary object that getCollection() knows to handle

This function is meant to convey to getCollection() function the request to merge auxiliary data structured as a collection parallel into the collection proxy.

This data will be tagged with the type Aux. To use a different type as tag, use withParallelDataAs() instead, specifying the tag as second template argument, e.g.:

struct MCS {};
auto tracks = proxy::getCollection<proxy::Tracks>(event, trackTag,
  withParallelData<recob::TrackMomentum>(defaultMomTag),
  withParallelDataAs<recob::TrackMomentum, MCS>(MCSmomTag)
  );

The first momentum association ("defaultMomTag") will be accessed by using the type recob::TrackMomentum as tag, while the second one will be accessed by the MCS tag (which is better not be defined in a local scope):

for (auto&& track: tracks) {
  decltype(auto) trackMom = track.get<recob::TrackMomentum>();
  decltype(auto) trackMCSmom = track.get<MCS>();
  // ...
}

The default implementation of parallel data proxy returns for each element query an object with the same interface as the element of the parallel data collection. In the previous examples, that would be a constant reference to an object with recob::TrackMomentum interface.

Customization of the parallel data proxy

To have a call like:

auto tracks = getCollection<SpecialTracks>

(event, tag, withParallelData<recob::TrackMomentum>(momTag, "special"));

to create something different than the standard parallel data proxy, one needs to specialize proxy::ParallelDataProxyMaker, e.g.:

namespace proxy {
  template <>
  struct ParallelDataProxyMaker<recob::Track, recob::TrackMomentum, SpecialTracks>
    : public ParallelDataProxyMakerBase<recob::Track, std::vector<recob::TrackMomentum>, recob::TrackMomentum>
  {
    template<typename Event, typename MainArgs>
    static auto make(
      Event const& event,
      MainArgs const&,
      art::InputTag assnTag,
      std::string quality = "default"
      )
      {
        ::SpecialTrackHitsProxy myAuxProxy;
        // ... make it, and make it right
        return myAuxProxy;
      }
  }; // struct ParallelDataProxyMaker<recob::Track, recob::TrackMomentum, SpecialTracks>
} // namespace proxy

Definition at line 175 of file withParallelData.h.

Referenced by NuGraphAnalyzer::analyze().

   {
     return withParallelDataAs<Aux, Aux>(std::forward<Args>(args)...);
   }

template<typename Aux , typename AuxTag , typename... Args>

auto proxy::withParallelDataAs ( Args &&... args )

Helper function to merge an auxiliary data product into the proxy.

Template Parameters

Aux	type of parallel data product requested
AuxTag	the tag type to refer this auxiliary data as
Args	types of constructor arguments for parallel data proxy

Parameters

args	constructor arguments for the parallel data collection proxy

Returns: a temporary object that getCollection() knows to handle

See also: proxy::withParallelData()

This function is meant to convey to getCollection() function the request for merging a auxiliary data structured as a collection parallel into the collection proxy.

It is functionally equivalent to withParallelData(), with the difference that here the auxiliary data tag must be specified. withParallelData() documentation also contains examples on how to use this function and the proxy resulting from that.

Definition at line 89 of file withParallelData.h.

   {
     using ArgTuple_t = std::tuple<Args&&...>;
     ArgTuple_t argsTuple(std::forward<Args>(args)...);
     return details::WithParallelCollectionStruct<Aux, ArgTuple_t, AuxTag>(std::move(argsTuple));
   } // withParallelDataAs()

template<typename Aux , typename... Args>

auto proxy::withZeroOrOne ( Args &&... args )

Works like withZeroOrOneMeta(), but for associations with no metadata.

See also: withZeroOrOneAs(), withZeroOrOneMeta()

Definition at line 153 of file withZeroOrOne.h.

   {
     return withZeroOrOneMeta<Aux, void>(std::forward<Args>(args)...);
   }

template<typename Aux , typename AuxTag , typename... Args>

auto proxy::withZeroOrOneAs ( Args &&... args )

The same as withZeroOrOne(), but it also specified a tag for the data.

Definition at line 75 of file withZeroOrOne.h.

   {
     return withZeroOrOneMetaAs<Aux, void, AuxTag>(std::forward<Args>(args)...);
   }

template<typename Aux , typename Metadata , typename... Args>

auto proxy::withZeroOrOneMeta ( Args &&... args )

Helper function to merge one-to-(zero-or-one) associated data.

Template Parameters

Aux	type of associated data requested
Metadata	type of metadata coming with the associated data
Args	types of constructor arguments for associated data collection

Parameters

args	constructor arguments for the associated data collection

Returns: a temporary object that getCollection() knows to handle

See also: withZeroOrOneMetaAs(), withZeroOrOne()

This function is meant to convey to getCollection() function the request for the delivered collection proxy to carry auxiliary data from an association fulfilling the one-to-many sequential association requirements.

This data will be tagged with the type Aux. To use a different type as tag, use withZeroOrOneAs() instead, specifying the tag as second template argument, e.g.:

struct QuestionableVertex {};
auto tracks = proxy::getCollection<proxy::Tracks>(event, trackTag,
  withZeroOrOneMeta<recob::Vertex, void>(defaultVertexTag),
  withZeroOrOneMetaAs<recob::Vertex, void, QuestionableVertex>
    (stinkyVertexTag)
  );

and, since we are not requesting any metadata, this is equivalent to

struct QuestionableVertex {};
auto tracks = proxy::getCollection<proxy::Tracks>(event, trackTag,
  withZeroOrOne<recob::Vertex>(defaultVertexTag),
  withZeroOrOneAs<recob::Vertex, QuestionableVertex>(stinkyVertexTag)
  );

The first vertex association ("defaultVertexTag") will be accessed by using the type recob::Vertex as tag, while the second one will be accessed by the QuestionableVertex tag (which is better not be defined in a local scope):

for (auto&& track: tracks) {
  decltype(auto) vertex = track.get<recob::Vertex>();
  decltype(auto) maybeVertex = track.get<QuestionableVertex>();
  // ...
}

Customization of the association proxy

See the technical details about withAssociated(), which hold for this function and related classes too.

Technical details

See the technical details about withAssociated(), which hold for this function and related classes too.

Todo:: Metadata is not supported yet (the interface is apparently there though).

Definition at line 144 of file withZeroOrOne.h.

   {
     return withZeroOrOneMetaAs<Aux, Metadata, Aux>(std::forward<Args>(args)...);
   }

template<typename Aux , typename Metadata , typename AuxTag , typename... Args>

auto proxy::withZeroOrOneMetaAs ( Args &&... args )

The same as withZeroOrOneMeta(), but it also specified a tag.

Todo:: Metadata is not supported yet.

Definition at line 64 of file withZeroOrOne.h.

   {
     using ArgTuple_t = std::tuple<Args&&...>;
     ArgTuple_t argsTuple(std::forward<Args>(args)...);
     return details::WithOneTo01AssociatedStruct<Aux, Metadata, ArgTuple_t, AuxTag>(
       std::move(argsTuple));
   } // withZeroOrOneAs()

template<typename Assns >

auto proxy::wrapAssociated ( Assns const & assns )

Helper function to merge associated data from a given association.

Template Parameters

Assns type of the association being merged; needs art::Assns interface

Parameters

assns the association being merged

Returns: a temporary object that getCollection() knows to handle

See also: withAssociatedMeta(), wrapAssociatedAs()

This function instructs the proxy to use the specified association assns directly. The specified association assns must remain valid for all the lifetime of the proxy.

The difference with wrapAssociated() is only that the tag is implicitly assigned to be the one of the associated data.

If Assns contains metadata, that is also merged into the proxy.

Usage example:

void checkClusters
  (art::Assns<recob::Track, recob::Cluster> const& clusters)
{
  auto tracks = proxy::getCollection<proxy::Tracks>
    (event, trackTag, wrapAssociated(clusters));
  for (auto const& track: tracks) {
    auto const& clusters = track.get<recob::Cluster>();
    for (art::Ptr<recob::Cluster> const& cluster: clusters) {
      // ...
    } // for clusters
  } // for tracks
} // checkClusters()

For more extensive information, see proxy::withAssociatedMeta().

Definition at line 466 of file withAssociated.h.

   {
     return wrapAssociatedAs<typename Assns::right_t>(assns);
   }

template<typename AuxTag , typename Assns >

auto proxy::wrapAssociated ( Assns const & assns )

Helper function to merge associated data from a given association.

Template Parameters

AuxTag	tag to access the associated data within the proxy
Assns	type of the association being merged; needs `art::Assns` interface

Parameters

assns the association being merged

Returns: a temporary object that getCollection() knows to handle

See also: withAssociatedMeta(), wrapAssociatedAs()

This function instructs the proxy to use the specified association assns directly. It is fully equivalent to proxy::wrapAssociatedAs().

Definition at line 485 of file withAssociated.h.

   {
     return wrapAssociatedAs<AuxTag>(assns);
   }

template<typename AuxTag , typename Assns >

auto proxy::wrapAssociatedAs ( Assns const & assns )

Helper function to merge associated data from a given association.

Template Parameters

AuxTag	tag to access the associated data within the proxy
Assns	type of the association being merged; needs `art::Assns` interface

Parameters

assns the association being merged

Returns: a temporary object that getCollection() knows to handle

See also: withAssociatedMeta(), withAssociatedMetaAs(), wrapAssociated()

This function instructs the proxy to use the specified association assns directly. The specified association assns must remain valid for all the lifetime of the proxy.

If Assns contains metadata, that is also merged into the proxy.

Usage example:

struct Clusters {};
void checkClusters
  (art::Assns<recob::Track, recob::Cluster> const& clusters)
{
  auto tracks = proxy::getCollection<proxy::Tracks>
    (event, trackTag, wrapAssociatedAs<::Clusters>(clusters));
  for (auto const& track: tracks) {
    auto const& clusters = track.get<::Clusters>();
    for (art::Ptr<recob::Cluster> const& cluster: clusters) {
      // ...
    } // for clusters
  } // for tracks
} // checkClusters()

For more extensive information, see proxy::withAssociatedMeta().

Definition at line 416 of file withAssociated.h.

   {
     using Aux_t = typename Assns::right_t;
     using Metadata_t = lar::util::assns_metadata_t<Assns>;
     return details::WithAssociatedStruct<Aux_t, Metadata_t, std::tuple<>, AuxTag>({});
   } // wrapAssociatedAs()

template<typename AuxColl >

auto proxy::wrapParallelData ( AuxColl const & auxColl )

Uses a collection as auxiliary data for a collection proxy.

Template Parameters

AuxColl type of the auxiliary data collection

Parameters

auxColl the data collection to be used as auxiliary data

Returns: an object making getCollection() add such auxiliary data

See also: proxy::withParallelData(), proxy::wrapParallelDataAs()

This function is meant to convey to getCollection() function the request for merging an existing auxiliary data collection structured as a collection parallel into the collection proxy.

It is functionally equivalent to wrapParallelDataAs(), with the difference that here the auxiliary data tag is automatically defined after the type of the data in the container. withParallelDataAs() documentation also contains examples on how to use this function and the proxy resulting from that.

Definition at line 256 of file withParallelData.h.

   {
     return wrapParallelDataAs<util::collection_value_t<AuxColl>>(auxColl);
   }

template<typename AuxTag , typename AuxColl >

auto proxy::wrapParallelDataAs ( AuxColl const & auxColl )

Uses a collection as auxiliary data for a collection proxy.

Template Parameters

AuxTag	the tag type to refer this auxiliary data as
AuxColl	type of the auxiliary data collection

Parameters

auxColl the data collection to be used as auxiliary data

Returns: an object making getCollection() add such auxiliary data

See also: withParallelDataAs(), wrapParallelData()

The specified collection is used directly as auxiliary data in a collection proxy. It is required to fulfil the parallel data product requirements, but it does not have to actually be a data product (that is, it does not have to be a collection read from art).

The usage of the resulting proxy is the same as the ones created using proxy::withParallelDataAs(), but the object auxColl must remain valid as long as that proxy is being used. Example of usage:

struct MCS {};
void checkMomenta(
  std::vector<recob::TrackMomentum> const& mom,
  std::vector<recob::TrackMomentum> const& MCSmom
) {
  auto tracks = proxy::getCollection<proxy::Tracks>(event, trackTag,
    wrapParallelData<recob::TrackMomentum>(defaultMomTag),
    wrapParallelDataAs<recob::TrackMomentum, MCS>(MCSmomTag)
    );
  for (auto const& track: tracks) {
    auto const& trackMom = track.get<recob::TrackMomentum>();
    auto const& trackMCSmom = track.get<MCS>();
    // ...
  } // for tracks
} // checkMomenta()

The first momentum (mom) will be accessed by using the type recob::TrackMomentum as tag, while the second one (MCSmom) will be accessed by the MCS tag (which is better not be defined in a local scope).

Definition at line 227 of file withParallelData.h.

   {
     std::tuple<AuxColl const&> args = {auxColl};
     return details::WithWrappedParallelCollectionStruct<util::collection_value_t<AuxColl>,
                                                         decltype(args),
                                                         AuxColl,
                                                         AuxTag>(std::move(args));
   } // wrapParallelDataAs()

Modules

Functions

One-to-many sequential associations

Parallel data collections

One-to-one (optional) associations

Detailed Description

Function Documentation

Customization

Customization of the association proxy

Technical details

Customization of the parallel data proxy

Customization of the association proxy

Technical details