ParticleSubset Class Reference

Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists. More...

#include <ParticleSubset.h>

Inheritance diagram for ParticleSubset:

Collaboration diagram for ParticleSubset:

Public Member Functions
void	removeParticlesNotInLists (const std::vector< std::string > &listNames)
	Removes all Particles that are not in one of the given ParticleLists (or daughters of Particles in the lists).
void	select (std::function< bool(const Particle *)> f)
	select Particles for which f returns true, discard others
void	registerSubset (const StoreArray< Particle > &set, DataStore::EStoreFlags storeFlags=DataStore::c_ErrorIfAlreadyRegistered)
	Remove all non-selected objects from set.
void	registerSubset (const StoreArray< Particle > &set, const std::string &subsetName, DataStore::EStoreFlags storeFlags=DataStore::c_ErrorIfAlreadyRegistered)
	Register the StoreArray<StoredClass> that will contain the subset of selected elements.
void	inheritRelationsFrom (const StoreArray< T > &array, MoreArguments... moreArgs)
	Inherit relations pointing from Other to objects selected into this subset.
void	inheritRelationsTo (const StoreArray< T > &array, MoreArguments... moreArgs)
	Inherit relations pointing from objects selected into this subset to Other.
void	inheritAllRelations ()
	Automatically inherit all relations to or from the original set (if registered when calling this function).
void	select (const std::function< bool(const Particle *)> &f)
	This method is the actual worker.
StoreAccessorBase *	getSet () override
	Get accessor for original set.
StoreAccessorBase *	getSubSet () override
	Get accessor for reduced set.
std::vector< std::string >	getInheritFromArrays () const
	Get list of arrays we inherit relations from.
std::vector< std::string >	getInheritToArrays () const
	Get list of arrays we inherit relations to.
bool	getInheritToSelf () const
	Do we inherit relations from original set to itself?
void	swapSetsAndDestroyOriginal ()
	Swap set and subset (+relations), and keep only the reduced set.

Protected Member Functions
void	fixParticles (const std::map< int, int > &oldToNewMap)
	fix daughter indices, reset m_arrayPointer
void	fixParticleLists (const std::map< int, int > &oldToNewMap)
	fix contents of particlelists by updating indices or removing entries.
void	inheritRelationsFrom ()
	Empty method to stop the recursion of the variadic template.
void	inheritRelationsTo ()
	Empty method to stop the recursion of the variadic template.
std::map< int, int >	copySetWithRelations (std::function< bool(const Particle *)> f)
	Selects the elements, fill the subset and copies all the relations in which the set is involved.
void	copyRelationsToSelf ()
	Copy any set -> set relations between selected objects.

Static Protected Member Functions
static void	fixVector (std::vector< int > &vec, const std::map< int, int > &oldToNewMap)
	replace entries in vec via oldToNewMap, removing those not found.

Protected Attributes
StoreArray< Particle > *	m_set
	The array we use as input.
StoreArray< Particle > *	m_subset
	The array we create.
DataStore::EStoreFlags	m_subsetFlags
	Flags used for m_subset.
std::vector< std::string >	m_inheritFromArrays
	array names we inherit relations from.
std::vector< std::string >	m_inheritToArrays
	array names we inherit relations to.
bool	m_inheritToSelf = false
	If true, relations from set objects to set objects are copied.
bool	m_reduceExistingSet = false
	If true, non-selected candidates are removed from m_set, m_subset only exists temporarily.

Detailed Description

Specialised SelectSubset<Particle> that also fixes daughter indices and all ParticleLists.

Relations are already handled in SelectSubset.

Can be used like SelectSubset via select(), or by calling removeParticlesNotInLists() instead.

Definition at line 22 of file ParticleSubset.h.

Member Function Documentation

copyRelationsToSelf()

void copyRelationsToSelf

protectedinherited

Copy any set -> set relations between selected objects.

Definition at line 334 of file SelectSubset.h.

  {
    for (const StoredClass& subsetObject1 : *m_subset) {
      //TODO: change relation direction to set -> subset?
      const StoredClass* setObject1 = subsetObject1.template getRelatedFrom<StoredClass>(m_set->getName());
 
      if (setObject1 != nullptr) {
        //get all objects in original set related to setObject1
        const RelationVector<StoredClass>& relations = setObject1->template getRelationsTo<StoredClass>(m_set->getName());
        for (unsigned int iRel = 0; iRel < relations.size(); iRel++) {
          const StoredClass* setObject2 = relations.object(iRel);
          const double weight = relations.weight(iRel);
          //if setObject2 was selected into subset, inherit relation
          const StoredClass* subsetObject2 = setObject2->template getRelatedTo<StoredClass>(m_subset->getName());
          if (subsetObject2) {
            subsetObject1.addRelationTo(subsetObject2, weight);
          }
        }
      }
    }
  }

copySetWithRelations()

std::map< int, int > copySetWithRelations ( std::function< bool(const Particle *)>  f )

protectedinherited

Selects the elements, fill the subset and copies all the relations in which the set is involved.

Definition at line 331 of file SelectSubset.h.

  {
    std::map<int, int> oldToNew;
    for (const StoredClass& setObject : *m_set) {
      if (!f(&setObject))
        continue;
 
      oldToNew[setObject.getArrayIndex()] = m_subset->getEntries();
      const StoredClass* subsetObject = m_subset->appendNew(setObject);
      if (!m_reduceExistingSet)
        setObject.addRelationTo(subsetObject);
    }
 
 
    //TODO this is the slow bit, can probably be improved by directly dealing with indices
    for (const auto& oldToNewPair : oldToNew) {
      const StoredClass* setObject = (*m_set)[oldToNewPair.first];
      const StoredClass* subsetObject = (*m_subset)[oldToNewPair.second];
 
      for (std::string fromArray : m_inheritFromArrays) {
        const RelationVector<RelationsObject>& relations = setObject->template getRelationsFrom<RelationsObject>(fromArray);
        for (unsigned int iRel = 0; iRel < relations.size(); iRel++) {
          relations.object(iRel)->addRelationTo(subsetObject, relations.weight(iRel));
        }
      }
      for (std::string toArray : m_inheritToArrays) {
        const RelationVector<RelationsObject>& relations = setObject->template getRelationsTo<RelationsObject>(toArray);
        for (unsigned int iRel = 0; iRel < relations.size(); iRel++) {
          subsetObject->addRelationTo(relations.object(iRel), relations.weight(iRel));
        }
      }
    }
 
    return oldToNew;
  }

fixParticleLists()

void fixParticleLists ( const std::map< int, int > &  oldToNewMap )

protected

fix contents of particlelists by updating indices or removing entries.

Definition at line 69 of file ParticleSubset.cc.

{
  const auto& entryMap = DataStore::Instance().getStoreEntryMap(DataStore::c_Event);
  for (const auto& entry : entryMap) {
    if (!entry.second.ptr or !entry.second.object->InheritsFrom(ParticleList::Class()))
      continue;
 
    auto* list = static_cast<ParticleList*>(entry.second.ptr);
    if (list->getParticleCollectionName() == m_set->getName()) {
      fixVector(list->m_scList, oldToNewMap);
      fixVector(list->m_fsList, oldToNewMap);
    }
  }
}

fixParticles()

void fixParticles ( const std::map< int, int > &  oldToNewMap )

protected

fix daughter indices, reset m_arrayPointer

Definition at line 56 of file ParticleSubset.cc.

{
  TClonesArray* arrayPtr = m_set->getPtr();
  for (Particle& p : *m_set) {
    unsigned int n = p.m_daughterIndices.size();
    for (unsigned int i = 0; i < n; i++) {
      p.m_daughterIndices[i] = oldToNewMap.at(p.m_daughterIndices[i]);
    }
 
    p.m_arrayPointer = arrayPtr;
  }
}

fixVector()

void fixVector ( std::vector< int > &  vec, const std::map< int, int > &  oldToNewMap  )

staticprotected

replace entries in vec via oldToNewMap, removing those not found.

Definition at line 84 of file ParticleSubset.cc.

{
  const std::vector<int> oldList(vec);
  vec.clear();
  for (const int idx : oldList) {
    const auto& it = oldToNewMap.find(idx);
    if (it != oldToNewMap.end())
      vec.push_back(it->second);
  }
}

getInheritFromArrays()

std::vector< std::string > getInheritFromArrays ( ) const

inlineinherited

Get list of arrays we inherit relations from.

Definition at line 32 of file SelectSubset.h.

{ return m_inheritFromArrays; }

getInheritToArrays()

std::vector< std::string > getInheritToArrays ( ) const

inlineinherited

Get list of arrays we inherit relations to.

Definition at line 34 of file SelectSubset.h.

{ return m_inheritToArrays; }

getInheritToSelf()

bool getInheritToSelf ( ) const

inlineinherited

Do we inherit relations from original set to itself?

Definition at line 36 of file SelectSubset.h.

{ return m_inheritToSelf; }

getSet()

StoreAccessorBase * getSet ( )

inlineoverridevirtualinherited

Get accessor for original set.

Implements SelectSubsetBase.

Definition at line 325 of file SelectSubset.h.

{ return m_set; }

getSubSet()

StoreAccessorBase * getSubSet ( )

inlineoverridevirtualinherited

Get accessor for reduced set.

Implements SelectSubsetBase.

Definition at line 327 of file SelectSubset.h.

{ return m_subset; }

inheritAllRelations()

void inheritAllRelations ( )

inlineinherited

Automatically inherit all relations to or from the original set (if registered when calling this function).

Equivalent to calling inheritRelationsFrom()/To() for all related arrays.

Note: Do not combine with inheritRelationsFrom() and inheritRelationsTo().

Definition at line 301 of file SelectSubset.h.

    {
      auto arrays = DataStore::Instance().getListOfRelatedArrays(*m_set);
 
      for (std::string arrayName : arrays) {
        StoreArray<TObject> array(arrayName, m_set->getDurability());
        if (array == *m_subset)
          continue; // from registerSubset(), ignore
 
        if (array.optionalRelationTo(*m_set, m_set->getDurability()))
          inheritRelationsFrom(array);
        if (m_set->optionalRelationTo(array, m_set->getDurability()))
          inheritRelationsTo(array);
      }
    }

inheritRelationsFrom() [1/2]

void inheritRelationsFrom ( )

inlineprotectedinherited

Empty method to stop the recursion of the variadic template.

Definition at line 337 of file SelectSubset.h.

{ }

inheritRelationsFrom() [2/2]

void inheritRelationsFrom ( const StoreArray< T > &  array, MoreArguments...  moreArgs  )

inlineinherited

Inherit relations pointing from Other to objects selected into this subset.

You can specify an unlimited number of arrays as arguments to this function.

Definition at line 250 of file SelectSubset.h.

    {
      if (array.getName() == m_set->getName()) {
        m_inheritToSelf = true;
        inheritRelationsFrom(*m_subset, moreArgs...);
      } else {
        const_cast<StoreArray<T>&>(array).isRequired();
 
        DataStore::EStoreFlags flags = m_subsetFlags;
        if (m_subset->notWrittenOut() or array.notWrittenOut())
          flags |= DataStore::c_DontWriteOut;
        array.registerRelationTo(*m_subset, m_subset->getDurability(), flags);
 
        if (array.getName() != m_subset->getName())
          m_inheritFromArrays.push_back(array.getName());
 
        inheritRelationsFrom(moreArgs ...);
      }
    }

inheritRelationsTo() [1/2]

void inheritRelationsTo ( )

inlineprotectedinherited

Empty method to stop the recursion of the variadic template.

Definition at line 339 of file SelectSubset.h.

{ }

inheritRelationsTo() [2/2]

void inheritRelationsTo ( const StoreArray< T > &  array, MoreArguments...  moreArgs  )

inlineinherited

Inherit relations pointing from objects selected into this subset to Other.

You can specify an unlimited number of arrays as arguments to this function.

Definition at line 275 of file SelectSubset.h.

    {
      if (array.getName() == m_set->getName()) {
        m_inheritToSelf = true;
        inheritRelationsTo(*m_subset, moreArgs...);
      } else {
        const_cast<StoreArray<T>&>(array).isRequired();
 
        DataStore::EStoreFlags flags = m_subsetFlags;
        if (m_subset->notWrittenOut() or array.notWrittenOut())
          flags |= DataStore::c_DontWriteOut;
        m_subset->registerRelationTo(array, m_subset->getDurability(), flags);
 
        if (array.getName() != m_subset->getName())
          m_inheritToArrays.push_back(array.getName());
 
        inheritRelationsTo(moreArgs ...);
      }
    }

registerSubset() [1/2]

void registerSubset ( const StoreArray< Particle > &  set, const std::string &  subsetName, DataStore::EStoreFlags  storeFlags = DataStore::c_ErrorIfAlreadyRegistered  )

inlineinherited

Register the StoreArray<StoredClass> that will contain the subset of selected elements.

Parameters

set	The StoreArray<StoredClass> from which the elements will be selected
subsetName	The name of the StoreArray<StoredClass> that will contain the selected elements
storeFlags	ORed combination of DataStore::EStoreFlags.

Definition at line 229 of file SelectSubset.h.

    {
      if (m_set or m_subset) {
        B2FATAL("SelectSubset::registerSubset() can only be called once!");
      }
 
      m_set = new StoreArray<StoredClass>(set);
 
      m_subset = new StoreArray<StoredClass>(subsetName, m_set->getDurability());
      m_subset->registerInDataStore(storeFlags);
      m_subsetFlags = storeFlags;
 
      set.registerRelationTo(*m_subset, m_subset->getDurability(), storeFlags);
    }

registerSubset() [2/2]

void registerSubset ( const StoreArray< Particle > &  set, DataStore::EStoreFlags  storeFlags = DataStore::c_ErrorIfAlreadyRegistered  )

inlineinherited

Remove all non-selected objects from set.

All relations registered so far are retained. TODO: consider moving this into StoreArray itself

Parameters

set	The StoreArray<StoredClass> from which to retain only selected elements
storeFlags	flags used for temporary arrays and relations. Should be changed from the default if you want multiple instances. c_DontWriteOut is always used.

Definition at line 215 of file SelectSubset.h.

    {
      m_reduceExistingSet = true;
      registerSubset(set, set.getName() + "_tmpSubset", storeFlags | DataStore::c_DontWriteOut);
 
      inheritAllRelations();
    }

removeParticlesNotInLists()

void removeParticlesNotInLists

(

const std::vector< std::string > &

listNames

)

Removes all Particles that are not in one of the given ParticleLists (or daughters of Particles in the lists).

Removal is done immediately, there is no need to call select() afterwards.

Definition at line 28 of file ParticleSubset.cc.

{
  std::unordered_set<int> indicesToKeep;
  for (const auto& l : listNames) {
    StoreObjPtr<ParticleList> list(l);
    if (!list)
      continue;
 
    if (list->getParticleCollectionName() == m_set->getName()) {
      const int n = list->getListSize();
      for (int i = 0; i < n; i++) {
        const Particle* p = list->getParticle(i);
        keepParticle(p, &indicesToKeep);
      }
    } else {
      B2ERROR("ParticleList " << l << " uses Particle array '" << list->getParticleCollectionName() <<
              "', but ParticleSubset uses different array '" << m_set->getName() << "'!");
    }
  }
 
  //remove everything not in indicesToKeep
  auto selector = [indicesToKeep](const Particle * p) -> bool {
    int idx = p->getArrayIndex();
    return indicesToKeep.count(idx) == 1;
  };
  select(selector);
}

select() [1/2]

void select ( const std::function< bool(const Particle *)> &  f )

inherited

This method is the actual worker.

It selects the elements, fill the subset and all the relations in which the subset is involved.

Parameters

f	the pointer to the function (or a nameless lambda expression) returning true for the elements to be selected and false for the others.

Definition at line 322 of file SelectSubset.h.

  {
    copySetWithRelations(f);
 
    if (m_inheritToSelf) {
      copyRelationsToSelf();
    }
 
    if (m_reduceExistingSet) {
      swapSetsAndDestroyOriginal();
    }
  }

select() [2/2]

void select ( std::function< bool(const Particle *)>  f )

inline

select Particles for which f returns true, discard others

Definition at line 31 of file ParticleSubset.h.

    {
      const std::map<int, int>& oldToNewMap = copySetWithRelations(f);
 
      if (m_inheritToSelf) {
        copyRelationsToSelf();
      }
 
      if (m_reduceExistingSet) {
        swapSetsAndDestroyOriginal();
      }
 
      fixParticles(oldToNewMap);
 
      fixParticleLists(oldToNewMap);
    }

swapSetsAndDestroyOriginal()

void swapSetsAndDestroyOriginal ( )

inherited

Swap set and subset (+relations), and keep only the reduced set.

Subset and associated relations will be empty afterwards.

Definition at line 14 of file SelectSubset.cc.

{
  StoreAccessorBase* set = getSet();
  StoreAccessorBase* subset = getSubSet();
 
  //replace set with subset
  DataStore::Instance().replaceData(*subset, *set);
 
  //swap relations
  for (const std::string& fromArray : m_inheritFromArrays) {
    RelationArray setRel(DataStore::relationName(fromArray, set->getName()));
    RelationArray subsetRel(DataStore::relationName(fromArray, subset->getName()));
    DataStore::Instance().replaceData(subsetRel, setRel);
  }
  for (const std::string& toArray : m_inheritToArrays) {
    RelationArray setRel(DataStore::relationName(set->getName(), toArray));
    RelationArray subsetRel(DataStore::relationName(subset->getName(), toArray));
    DataStore::Instance().replaceData(subsetRel, setRel);
  }
}

Member Data Documentation

m_inheritFromArrays

std::vector<std::string> m_inheritFromArrays

protectedinherited

array names we inherit relations from.

Definition at line 54 of file SelectSubset.h.

m_inheritToArrays

std::vector<std::string> m_inheritToArrays

protectedinherited

array names we inherit relations to.

Definition at line 56 of file SelectSubset.h.

m_inheritToSelf

bool m_inheritToSelf = false

protectedinherited

If true, relations from set objects to set objects are copied.

(if both objects are selected!).

Definition at line 58 of file SelectSubset.h.

m_reduceExistingSet

bool m_reduceExistingSet = false

protectedinherited

If true, non-selected candidates are removed from m_set, m_subset only exists temporarily.

Definition at line 60 of file SelectSubset.h.

m_set

StoreArray<Particle >* m_set

protectedinherited

The array we use as input.

Definition at line 342 of file SelectSubset.h.

m_subset

StoreArray<Particle >* m_subset

protectedinherited

The array we create.

Definition at line 344 of file SelectSubset.h.

m_subsetFlags

DataStore::EStoreFlags m_subsetFlags

protectedinherited

Flags used for m_subset.

Definition at line 346 of file SelectSubset.h.

---

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

• analysis/utility/include/ParticleSubset.h
• analysis/utility/src/ParticleSubset.cc