ParticleList Class Reference

ParticleList is a container class that stores a collection of Particle objects. More...

#include <ParticleList.h>

Inheritance diagram for ParticleList:

Public Types
enum	EParticleType {   c_FlavorSpecificParticle = 0 ,   c_SelfConjugatedParticle }
	Type of Particle (determines in which of the two internal lists the particle is stored). More...
typedef ArrayIterator< ParticleList, Particle >	iterator
	STL-like iterator over the particles (not Particle*).
typedef ArrayIterator< ParticleList, const Particle >	const_iterator
	STL-like const_iterator over the particles (not Particle*).

Public Member Functions
	ParticleList ()
	Default constructor.
void	initialize (int pdg, const std::string &name, const std::string &particleStoreName="Particles")
	Sets the PDG code and name of this ParticleList.
void	bindAntiParticleList (ParticleList &antiList, bool includingAntiList=true)
	Binds particle and anti-particle ParticleLists.
void	setParticleCollectionName (const std::string &name, bool forAntiParticle=true)
	Sets Particle store array name to which particle list refers.
void	addParticle (const Particle *particle)
	Adds a new particle to the list (safe method)
void	addParticle (unsigned iparticle, int pdg, Particle::EFlavorType flavorType, bool includingAntiList=true)
	Adds a new particle to the list (almost safe method)
void	removeParticles (const std::vector< unsigned int > &toRemove, bool removeFromAntiList=true)
	Remove given elements from list.
void	clear (bool includingAntiList=true)
	Remove all elements from list, afterwards getListSize() will be 0.
std::string	getParticleCollectionName () const
	Returns Particle store array name to which particle list refers.
int	getPDGCode () const
	Returns PDG code.
int	getAntiParticlePDGCode () const
	Returns PDG code of anti-particle.
const std::vector< int > &	getList (EParticleType K, bool forAntiParticle=false) const
	Returns list of StoreArray<Particle> indices.
std::string	getAntiParticleListName () const
	Returns the name the anti-particle ParticleList.
std::string	getParticleListName () const
	Returns the name this ParticleList.
unsigned	getListSize (bool includingAntiList=true) const
	Returns total number of particles in this list and anti list if requested.
Particle *	getParticle (unsigned i, bool includingAntiList=true) const
	Returns i-th particle from the list and anti list if requested.
Particle *	getParticleWithMdstIdx (unsigned int mdstIdx, bool includingAntiList=true) const
	Returns the particle from the list matching the given mdst array index, if any is found.
unsigned	getNParticlesOfType (EParticleType K, bool forAntiParticle=false) const
	Returns the number of flavor-specific particles or self-conjugated particles in this list or its anti-particle list.
bool	contains (const Particle *p, bool includingAntiList=true) const
	Returns true if and only if 'p' is already in this list.
int	getIndex (const Particle *p, bool includingAntiList=true) const
	Returns index of the given particle 'p' in this list.
void	print () const
	Prints the list.
void	setEditable (bool editable, bool includingAntiList=true)
	Sets m_isReserved so that the reserved list can be edited.
bool	getIsReserved () const
	Returns m_isReserved.
std::string	getInfoHTML () const
	Return a short summary of this object's contents in HTML format.
iterator	begin ()
	Return iterator to first entry.
iterator	end ()
	Return iterator to last entry +1.
const_iterator	begin () const
	Return const_iterator to first entry.
const_iterator	end () const
	Return const_iterator to last entry +1.
Particle *	operator[] (int index) const
	Convenience function to get particle with index.

Private Member Functions
ParticleList &	getAntiParticleList () const
	Returns bound anti-particle list.
	ClassDef (ParticleList, 4)
	Class to hold a list of particles, anti-particles and self-conjugated particles.

Private Attributes
int	m_pdg
	PDG code of Particle.
int	m_pdgbar
	PDG code of antiparticle.
std::vector< int >	m_fsList
	list of 0-based indices of flavor-specific Particles (particles that have an anti-particle)
std::vector< int >	m_scList
	list of 0-based indices of self-conjugated Particles (particles that do not have an anti-particle)
std::string	m_particleStore
	name of Particle store array
std::string	m_thisListName
	name of this ParticleList
std::string	m_antiListName
	name of ParticleList for anti-particles
StoreObjPtr< ParticleList > *	m_antiList
	keep anti-list around for performance.
bool	m_isReserved = false
	transient

Friends
class	ParticleSubset

Detailed Description

ParticleList is a container class that stores a collection of Particle objects.

The particles are internally stored in two std::vector<int> holding the indices of particles in StoreArray<Particle>: o) flavor specific particles (particles that have an anti-particle, e.g. pi-, K-, D+, D0) o) self-conjugated particles (particles that do not have an anti-particle, e.g. pi0, phi, or particles that have an anti-particle but are reconstructed in self-conjugated decay mode, e.g. K*0 -> K0s pi0, or D0 -> K- K+, ...) ParticleList can store only particles with same PDG code (which however can be reconstructed in different decay modes).

Each ParticleList can and should be bound with its anti-ParticleList at the time of creation of the lists. This bond for example enables automatic reconstruction of charged conjugated decays in ParticleCombiner module for example.

The unique identifier of the ParticleList is its name. According to the naming convention the ParticleList's name has to be of the form:

listName = particle_name:label,

where particle_name is the name of the particle as given in the evt.pdl and the label can be any string indicating the selection criteria or decay mode (or anything else) used to reconstruct the particles. Examples are: o) pi+:loose - pi+ candidates passing loose PID requirements o) D0:kpi - D0 candidates reconstructed in D0->Kpi decays

Creating new ParticleList

Particles and their anti-particles are stored in their own ParticleLists. Creation and connection of particle and anti-particle lists is performed in the following way (example for K- and K+ lists):

\\ create ParticleList for particles (K+)
StoreObjPtr<ParticleList> pList("K+:all");
pList.create();
pList->initialize( 321, pList.getName());
 
\\ create ParticleList for anti-particles (K-)
StoreObjPtr<ParticleList> antipList("K-:all");
antipList.create();
antipList->initialize(-321, antipList.getName());
 
\\ bind the two lists together
pList->bindAntiParticleList(*antipList);

Adding Particle to ParticleList

The following rules apply: o) ParticleList can contain only particles with same absolute value of the PDG code (e.g. only charged kaons, neutral D mesons, ...) o) All particles have to be stored in the same StoreArray<Particle>

Example:

pList->addParticle(particle);

where particle is a pointer to a Particle object. Note, if one adds anti-particle to ParticleLists for particles the particle will be actually added to the ParticleList for anti-particles. The following two lines of code give same result

// adding anti-particle Particle object to ParticleList for particles
pList->addParticle(antiParticle);
 
// is the same as if the anti-particle Particle object is added to the ParticleList for anti-particles
antiPlist->addParticle(antiParticle);

Accessing elements of ParticleList

To loop over all particles (as well as their anti-particles) do the following

const unsigned int n = pList->getListSize();
for (unsigned i = 0; i < n; i++) {
 const Particle* particle = pList->getParticle(i);
 
 // do something with the particle
 particle->....
}

If you would like to loop over the particles stored in a particular ParticleList without including the anti-particles as well, do the following (set the boolean parameter in the relevant functions to false)

const unsigned int n = pList->getListSize(false);
for (unsigned i = 0; i < n; i++) {
 const Particle* particle = pList->getParticle(i, false);
 
 // do something with the particle
 particle->....
}

You can also use C++11 range-based for loops to loop over all particles (and anti-particles):

for(const Particle& particle : *pList) {
   // do something with the particle
}
 
Remember to dereference the StoreObjPtr<ParticleList> before you can use it in the range based for loop.
 
<h1>Remove Particles from ParticleList</h1>
 
Particles can be removed in the following way (as above, this action will by default be applied to list of
particles as well as to list for anti-particles):
 
\code
 std::vector<unsigned int> toRemove;
 const unsigned int n = pList->getListSize();
 for (unsigned i = 0; i < n; i++) {
   const Particle* part = pList->getParticle(i);
   if (...particle should be removed...) toRemove.push_back(part->getArrayIndex());
 }
 
 pList->removeParticles(toRemove);

Definition at line 140 of file ParticleList.h.

Member Typedef Documentation

const_iterator

typedef ArrayIterator<ParticleList, const Particle> const_iterator

STL-like const_iterator over the particles (not Particle*).

Definition at line 146 of file ParticleList.h.

iterator

typedef ArrayIterator<ParticleList, Particle> iterator

STL-like iterator over the particles (not Particle*).

Definition at line 144 of file ParticleList.h.

Member Enumeration Documentation

EParticleType

enum EParticleType

Type of Particle (determines in which of the two internal lists the particle is stored).

Definition at line 149 of file ParticleList.h.

                       {
      c_FlavorSpecificParticle = 0,
      c_SelfConjugatedParticle
    };

Constructor & Destructor Documentation

ParticleList()

ParticleList ( )

inline

Default constructor.

Definition at line 157 of file ParticleList.h.

                  :
      m_pdg(0),
      m_pdgbar(0),
      m_particleStore("Particles"),
      m_thisListName(),
      m_antiListName(),
      m_antiList(nullptr),
      m_isReserved(false)
    {
    }

~ParticleList()

~ParticleList

(

)

Definition at line 25 of file ParticleList.cc.

{
  delete m_antiList;
}

Member Function Documentation

addParticle() [1/2]

void addParticle

(

const Particle *

particle

)

Adds a new particle to the list (safe method)

The method determines based on the particle's properties (PDGcode, flavorType) to which particular list this particle belongs (flavor-specific or self-conjugated particle or anti-particle list)

Parameters

particle

pointer to particle in the StoreArray<Particle>

Definition at line 52 of file ParticleList.cc.

{
  if (m_isReserved)
    B2FATAL("ParticleList::addParticle The ParticleList " << m_thisListName <<
            " is reserved and forbidden to be manipulated.");
 
  if (particle->getArrayName() != m_particleStore) {
    B2ERROR("ParticleList::addParticle particle is from different store array, not added");
    return;
  }
 
  int iparticle = particle->getArrayIndex();
  if (iparticle < 0) {
    B2ERROR("ParticleList::addParticle particle is not in a store array, not added");
    return;
  }
 
  int pdg = particle->getPDGCode();
  Particle::EFlavorType type = particle->getFlavorType();
  addParticle((unsigned) iparticle, pdg, type, true);
}

addParticle() [2/2]

void addParticle	(	unsigned	iparticle,
		int	pdg,
		Particle::EFlavorType	flavorType,
		bool	includingAntiList = true
	)

Adds a new particle to the list (almost safe method)

Parameters

iparticle	index of the particle in the StoreArray<Particle>
pdg	particle PDG code
flavorType	particle flavor type
includingAntiList	include anti-particle list?

Definition at line 86 of file ParticleList.cc.

{
  if (m_isReserved)
    B2FATAL("ParticleList::addParticle The ParticleList " << m_thisListName <<
            " is reserved and forbidden to be manipulated.");
 
  if (abs(pdg) != abs(getPDGCode())) {
    B2ERROR("ParticleList::addParticle PDG codes do not match, not added");
    return;
  }
 
  if (type == Particle::c_Unflavored) {
    // this is self-conjugated particle
    // add it to the self-conjugated list of this (and anti-particle list if exists)
 
    // check if the particle is already in this list
    if (std::find(m_scList.begin(), m_scList.end(), iparticle) == m_scList.end()) {
      m_scList.push_back(iparticle);
    } else {
      B2WARNING("ParticleList::addParticle Trying to add Particle with index=" << iparticle
                << " to the ParticleList=" << m_thisListName << " that is already included!");
      return;
    }
 
    // add it to the self-conjugated list
    if (includingAntiList and !m_antiListName.empty())
      getAntiParticleList().addParticle(iparticle, pdg, type, false);
  } else if (type == Particle::c_Flavored) {
    unsigned antiParticle = (pdg == getPDGCode()) ? 0 : 1;
 
    if (antiParticle)
      getAntiParticleList().addParticle(iparticle, pdg, type, false);
    else {
      if (std::find(m_fsList.begin(), m_fsList.end(), iparticle) == m_fsList.end()) {
        m_fsList.push_back(iparticle);
      } else {
        B2WARNING("ParticleList::addParticle Trying to add Particle with index=" << iparticle
                  << " to the ParticleList=" << m_thisListName << "that is already included! Particle not added");
      }
    }
  } else {
    B2ERROR("ParticleList::addParticle invalid flavor type, not added");
  }
}

begin() [1/2]

iterator begin ( )

inline

Return iterator to first entry.

Definition at line 353 of file ParticleList.h.

{ return iterator(this, 0); }

begin() [2/2]

const_iterator begin ( ) const

inline

Return const_iterator to first entry.

Definition at line 358 of file ParticleList.h.

{ return const_iterator(this, 0); }

bindAntiParticleList()

void bindAntiParticleList	(	ParticleList &	antiList,
		bool	includingAntiList = true
	)

Binds particle and anti-particle ParticleLists.

After the lists are bound any action performed on ParticleList for particles will be performed by default also on ParticleList for anti-particles.

Parameters

antiList	- anti-particle ParticleList of this ParticleList
includingAntiList	- the "anti"-anti-particle list has to be set also for the anti-particle list

Definition at line 74 of file ParticleList.cc.

{
  m_pdgbar       = antiList.getPDGCode();
  m_antiListName = antiList.getParticleListName();
 
  if (abs(m_pdgbar) != abs(m_pdg))
    B2ERROR("ParticleList::bindAntiParticleList invalid (inconsistent) PDG codes!");
 
  if (includingAntiList)
    antiList.bindAntiParticleList(*this, false);
}

clear()

void clear

(

bool

includingAntiList = true

)

Remove all elements from list, afterwards getListSize() will be 0.

Definition at line 158 of file ParticleList.cc.

{
  if (m_isReserved)
    B2FATAL("ParticleList::clear The ParticleList " << m_thisListName <<
            " is reserved and forbidden to be manipulated.");
 
  m_fsList.clear();
  m_scList.clear();
 
  if (includingAntiList and !m_antiListName.empty()) {
    getAntiParticleList().clear(false);
  }
}

contains()

bool contains	(	const Particle *	p,
		bool	includingAntiList = true
	)		const

Returns true if and only if 'p' is already in this list.

Will check flavour-specific and self-conjugated list, and optionally (with includingAntiList=true) also the anti-particle list.

Definition at line 236 of file ParticleList.cc.

{
  const int index = p->getArrayIndex();
  for (int i = 0; i < 3; i++) {
    if (i == 1 && !includingAntiList)
      continue;
 
    const std::vector<int>& currentList = getList((i < 2) ? c_FlavorSpecificParticle : c_SelfConjugatedParticle, i == 1);
    if (std::find(currentList.begin(), currentList.end(), index) != currentList.end())
      return true;
  }
  return false;
}

end() [1/2]

iterator end ( )

inline

Return iterator to last entry +1.

Definition at line 355 of file ParticleList.h.

{ return iterator(this, getListSize()); }

end() [2/2]

const_iterator end ( ) const

inline

Return const_iterator to last entry +1.

Definition at line 360 of file ParticleList.h.

{ return const_iterator(this, getListSize()); }

getAntiParticleList()

ParticleList & getAntiParticleList ( ) const

private

Returns bound anti-particle list.

Aborts if no list is present (might occur with I/O problems). Please check m_antiListName is not empty() before calling this.

Definition at line 295 of file ParticleList.cc.

{
  if (!m_antiList) {
    m_antiList = new StoreObjPtr<ParticleList>(m_antiListName);
    if (!m_antiList->isValid()) {
      B2FATAL("Anti-particle list " << m_antiListName << " for " << m_thisListName <<
              " not found, even though one was set via bindAntiParticleList(). Maybe you only saved one list into a .root file?");
    }
  }
  return **m_antiList;
}

getAntiParticleListName()

std::string getAntiParticleListName ( ) const

inline

Returns the name the anti-particle ParticleList.

Definition at line 272 of file ParticleList.h.

{ return m_antiListName; }

getAntiParticlePDGCode()

int getAntiParticlePDGCode ( ) const

inline

Returns PDG code of anti-particle.

Definition at line 244 of file ParticleList.h.

{ return m_pdgbar; }

getIndex()

int getIndex	(	const Particle *	p,
		bool	includingAntiList = true
	)		const

Returns index of the given particle 'p' in this list.

If 'p' is not in this list, return -1. Will check flavour-specific and self-conjugated list, and optionally (with includingAntiList=true) also the anti-particle list.

Definition at line 250 of file ParticleList.cc.

{
  const int index = p->getArrayIndex();
 
  auto it_fs = std::find(m_fsList.begin(), m_fsList.end(), index);
  if (it_fs != m_fsList.end()) {
    return std::distance(m_fsList.begin(), it_fs);
  }
 
  auto it_sc = std::find(m_scList.begin(), m_scList.end(), index);
  if (it_sc != m_scList.end()) {
    return std::distance(m_scList.begin(), it_sc) + m_fsList.size();
  }
 
  if (includingAntiList and !m_antiListName.empty()) {
    int indexAnti = getAntiParticleList().getIndex(p, false);
    if (indexAnti != -1)
      return indexAnti + m_fsList.size() + m_scList.size();
  }
 
  return -1;
}

getInfoHTML()

std::string getInfoHTML

(

)

const

Return a short summary of this object's contents in HTML format.

Definition at line 278 of file ParticleList.cc.

{
  std::stringstream stream;
  unsigned thisFSCount = getNParticlesOfType(c_FlavorSpecificParticle);
  unsigned thisSCCount = getNParticlesOfType(c_SelfConjugatedParticle);
  unsigned antiFSCount = getNParticlesOfType(c_FlavorSpecificParticle, true);
  unsigned antiSCCount = getNParticlesOfType(c_SelfConjugatedParticle, true);
 
  if (!m_antiListName.empty()) {
    stream << " ParticleLists: " << m_thisListName << " (" << thisFSCount << "+" << thisSCCount << ")"
           << " + " << m_antiListName << " (" << antiFSCount << "+" << antiSCCount << ")";
  } else {
    stream << " ParticleList : " << m_thisListName << " (" << thisFSCount << "+" << thisSCCount << ")";
  }
  return HTML::escape(stream.str());
}

getIsReserved()

bool getIsReserved ( ) const

inline

Returns m_isReserved.

Definition at line 346 of file ParticleList.h.

{ return m_isReserved; };

getList()

const std::vector< int > & getList	(	EParticleType	K,
		bool	forAntiParticle = false
	)		const

Returns list of StoreArray<Particle> indices.

Possible options are:

o) getList(ParticleList::c_FlavorSpecificParticle)

• returns the vector of flavor-specific particles stored in this list

o) getList(ParticleList::c_SelfConjugatedParticle)

• returns the vector of self-conjugated particles stored in this list

o) getList(ParticleList::c_FlavorSpecificParticle, true)

• returns the vector of flavor-specific anti-particles stored in the anti-particle ParticleList of this list

o) getList(ParticleList::c_SelfConjugatedParticle, true)

• this is equivalent to getList(ParticleList::c_SelfConjugatedParticle)

Parameters

K	ParticleType - Particle, SelfConjugatedParticle
forAntiParticle	- whether the Particle or SelfConjugatedParticle should be returned for this (false) or anti-particle list (true)

Returns

const reference to vector of indices

Definition at line 220 of file ParticleList.cc.

{
  if (!forAntiParticle) {
    if (K == c_FlavorSpecificParticle)
      return m_fsList;
    else
      return m_scList;
  } else {
    const static std::vector<int> emptyList;
    if (m_antiListName.empty())
      return emptyList;
 
    return getAntiParticleList().getList(K);
  }
}

getListSize()

unsigned getListSize

(

bool

includingAntiList = true

)

const

Returns total number of particles in this list and anti list if requested.

Parameters

includingAntiList

Returns

size of the this (+ anti-particle) list

Definition at line 203 of file ParticleList.cc.

{
  unsigned size = 0;
 
  // FlavorSpecific particles of this list
  size += m_fsList.size();
  // SelfConjugated particles of this list = SelfConjugated particles of anti-particle list
  size += m_scList.size();
 
  if (includingAntiList) {
    // FlavorSpecific particles of anti-particle list
    size += getNParticlesOfType(EParticleType::c_FlavorSpecificParticle, true);
  }
 
  return size;
}

getNParticlesOfType()

unsigned getNParticlesOfType ( EParticleType  K, bool  forAntiParticle = false  ) const

inline

Returns the number of flavor-specific particles or self-conjugated particles in this list or its anti-particle list.

Parameters

K	ParticleType - Particle or SelfConjugatedParticle
forAntiParticle	- whether the Particle or SelfConjugatedParticle should be returned for this (false) or anti-particle list (true)

Returns

number of particles or self-conjugated particles in the list or anti-particle list

Definition at line 310 of file ParticleList.h.

    {
      return getList(K, forAntiParticle).size();
    }

getParticle()

Particle * getParticle	(	unsigned	i,
		bool	includingAntiList = true
	)		const

Returns i-th particle from the list and anti list if requested.

Parameters

i	list index (i < getListSize())
includingAntiList	consider anti-particle list as well?

Returns

pointer to Particle or NULL

Definition at line 172 of file ParticleList.cc.

{
  StoreArray<Particle> Particles(m_particleStore);
 
  if (i < m_fsList.size()) {
    return Particles[m_fsList[i]];
  } else if (i < m_fsList.size() + m_scList.size()) {
    i -= m_fsList.size();
    return Particles[m_scList[i]];
  }
 
  if (includingAntiList and !m_antiListName.empty())
    return getAntiParticleList().getParticle(i - m_fsList.size() - m_scList.size(), false);
 
  return nullptr;
}

getParticleCollectionName()

std::string getParticleCollectionName ( ) const

inline

Returns Particle store array name to which particle list refers.

Definition at line 234 of file ParticleList.h.

{return m_particleStore;}

getParticleListName()

std::string getParticleListName ( ) const

inline

Returns the name this ParticleList.

Definition at line 277 of file ParticleList.h.

{ return m_thisListName; }

getParticleWithMdstIdx()

Particle * getParticleWithMdstIdx	(	unsigned int	mdstIdx,
		bool	includingAntiList = true
	)		const

Returns the particle from the list matching the given mdst array index, if any is found.

Parameters

mdstIdx	mdst array index
includingAntiList	consider anti-particle list as well?

Returns

pointer to Particle or NULL if no match is found.

Definition at line 189 of file ParticleList.cc.

{
  const unsigned int n = this->getListSize(includingAntiList);
  for (unsigned i = 0; i < n; i++) {
 
    auto particle = this->getParticle(i, includingAntiList);
 
    if (particle->getMdstArrayIndex() == mdstIdx) {
      return particle;
    }
  }
  return nullptr;
}

getPDGCode()

int getPDGCode ( ) const

inline

Returns PDG code.

Definition at line 239 of file ParticleList.h.

{return m_pdg; }

initialize()

void initialize	(	int	pdg,
		const std::string &	name,
		const std::string &	particleStoreName = "Particles"
	)

Sets the PDG code and name of this ParticleList.

At this point it is assumed that this is self-conjugated list (PDG code = anti-PDG code). To bind the particle and anti-particle ParticleLists use bindAntiParticleList(ParticleList &antiList) method.

Parameters

pdg	PDG code of particles to be hold in this list
name	of the particle list
particleStoreName	name of the Particle StoreArray

Definition at line 30 of file ParticleList.cc.

{
  m_pdg    = pdg;
  m_pdgbar = pdg;
  m_particleStore = particleStoreName;
 
  m_thisListName = name;
  m_antiListName.clear();
 
  std::string label = m_thisListName.substr(m_thisListName.find_first_of(':') + 1);
  if ((Const::finalStateParticlesSet.contains(Const::ParticleType(abs(m_pdg))) and label == "all") or label == "V0")
    m_isReserved = true;
}

operator[]()

Particle * operator[] ( int  index ) const

inline

Convenience function to get particle with index.

Definition at line 363 of file ParticleList.h.

{return getParticle(index);}

print()

void print

(

)

const

Prints the list.

Definition at line 273 of file ParticleList.cc.

{
  B2INFO(HTML::htmlToPlainText(getInfoHTML()));
}

removeParticles()

void removeParticles	(	const std::vector< unsigned int > &	toRemove,
		bool	removeFromAntiList = true
	)

Remove given elements from list.

Parameters

toRemove	vector of Particle array indices to be removed
removeFromAntiList	flag indicating whether to remove particle also from anti-particle list (default is true)

Definition at line 131 of file ParticleList.cc.

{
  if (m_isReserved)
    B2FATAL("ParticleList::removeParticles The ParticleList " << m_thisListName <<
            " is reserved and forbidden to be manipulated.");
 
  std::vector<int> newList;
  // remove Particles from flavor-specific list of this Particle List
  for (int i : m_fsList) {
    if (std::find(toRemove.begin(), toRemove.end(), i) == toRemove.end())
      newList.push_back(i);
  }
  m_fsList = newList;
 
  // remove Particles from self-conjugated list of this Particle List
  newList.clear();
  for (int i : m_scList) {
    if (std::find(toRemove.begin(), toRemove.end(), i) == toRemove.end())
      newList.push_back(i);
  }
  m_scList = newList;
 
  if (removeFromAntiList and !m_antiListName.empty()) {
    getAntiParticleList().removeParticles(toRemove, false);
  }
}

setEditable()

void setEditable ( bool  editable, bool  includingAntiList = true  )

inline

Sets m_isReserved so that the reserved list can be edited.

Definition at line 336 of file ParticleList.h.

    {
      m_isReserved = !editable;
      if (includingAntiList and !m_antiListName.empty())
        getAntiParticleList().setEditable(editable, false);
    };

setParticleCollectionName()

void setParticleCollectionName	(	const std::string &	name,
		bool	forAntiParticle = true
	)

Sets Particle store array name to which particle list refers.

By default this parameter is set to "Particles".

Parameters

name	name of the Particle store array
forAntiParticle	if true the name is set also for the anti-particle list

Definition at line 44 of file ParticleList.cc.

{
  m_particleStore = name;
 
  if (forAntiParticle and !m_antiListName.empty())
    getAntiParticleList().setParticleCollectionName(name, false);
}

Friends And Related Function Documentation

ParticleSubset

friend class ParticleSubset

friend

Definition at line 391 of file ParticleList.h.

Member Data Documentation

m_antiList

StoreObjPtr<ParticleList>* m_antiList

mutableprivate

keep anti-list around for performance.

Definition at line 385 of file ParticleList.h.

m_antiListName

std::string m_antiListName

private

name of ParticleList for anti-particles

Definition at line 382 of file ParticleList.h.

m_fsList

std::vector<int> m_fsList

private

list of 0-based indices of flavor-specific Particles (particles that have an anti-particle)

Definition at line 375 of file ParticleList.h.

m_isReserved

bool m_isReserved = false

private

transient

True if the list name is reserved

Definition at line 387 of file ParticleList.h.

m_particleStore

std::string m_particleStore

private

name of Particle store array

Definition at line 379 of file ParticleList.h.

m_pdg

int m_pdg

private

PDG code of Particle.

Definition at line 373 of file ParticleList.h.

m_pdgbar

int m_pdgbar

private

PDG code of antiparticle.

Definition at line 374 of file ParticleList.h.

m_scList

std::vector<int> m_scList

private

list of 0-based indices of self-conjugated Particles (particles that do not have an anti-particle)

Definition at line 377 of file ParticleList.h.

m_thisListName

std::string m_thisListName

private

name of this ParticleList

Definition at line 381 of file ParticleList.h.

---

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

• analysis/dataobjects/include/ParticleList.h
• analysis/dataobjects/src/ParticleList.cc