sim::ParticleList Class Reference

#include <ParticleList.h>

Classes
struct	archived_info_type

Public Types
typedef std::map< int, simb::MCParticle * >	list_type
typedef list_type::key_type	key_type
typedef list_type::mapped_type	mapped_type
typedef list_type::value_type	value_type
typedef list_type::iterator	iterator
typedef list_type::const_iterator	const_iterator
typedef list_type::reverse_iterator	reverse_iterator
typedef list_type::const_reverse_iterator	const_reverse_iterator
typedef list_type::size_type	size_type
typedef list_type::difference_type	difference_type
typedef list_type::key_compare	key_compare
typedef list_type::allocator_type	allocator_type

Public Member Functions
	ParticleList ()
virtual	~ParticleList ()
	ParticleList (const ParticleList &rhs)=delete
ParticleList &	operator= (const ParticleList &rhs)=delete
	ParticleList (ParticleList &&rhs)=default
ParticleList &	operator= (ParticleList &&rhs)=default
ParticleList	MakeCopy () const
	Returns a copy of this object. More...
void	Cut (const double &)
const key_type &	TrackId (const size_type) const
mapped_type const &	Particle (const size_type) const
mapped_type	Particle (const size_type)
bool	HasParticle (int trackID) const
	Returns whether we have this particle, live (with full information) More...
bool	KnownParticle (int trackID) const
	Returns whether we have had this particle, archived or live. More...
bool	IsPrimary (int trackID) const
int	NumberOfPrimaries () const
std::vector< const simb::MCParticle * >	GetPrimaries () const
const simb::MCParticle *	Primary (const int) const
simb::MCParticle *	Primary (const int)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
reverse_iterator	rbegin ()
const_reverse_iterator	rbegin () const
reverse_iterator	rend ()
const_reverse_iterator	rend () const
size_type	size () const
bool	empty () const
void	swap (ParticleList &other)
iterator	find (const key_type &key)
const_iterator	find (const key_type &key) const
iterator	upper_bound (const key_type &key)
const_iterator	upper_bound (const key_type &key) const
iterator	lower_bound (const key_type &key)
const_iterator	lower_bound (const key_type &key) const
mapped_type const &	operator[] (const key_type &key) const
mapped_type	operator[] (const key_type &key)
mapped_type	at (const key_type &key)
mapped_type const &	at (const key_type &key) const
key_type	key (mapped_type const &part) const
	Extracts the key from the specified value. More...
void	insert (simb::MCParticle *value)
void	Add (simb::MCParticle *value)
void	Archive (const key_type &key)
	Removes the particle from the list, keeping minimal info of it. More...
void	Archive (const mapped_type &key)
int	GetMotherOf (const key_type &key) const
	This function seeks for the exact key, not its absolute value. More...
void	clear ()
size_type	erase (const key_type &key)
iterator	erase (iterator key)
int	EveId (const int trackID) const

Static Public Member Functions
static void	AdoptEveIdCalculator (EveIdCalculator *)

Private Types
typedef std::set< int >	primaries_type
typedef std::map< int, archived_info_type >	archive_type
typedef primaries_type::iterator	primaries_iterator
typedef primaries_type::const_iterator	primaries_const_iterator

Private Attributes
list_type	m_particleList
	Sorted list of particles in the event. More...
primaries_type	m_primaries
archive_type	m_archive
	archive of the particles no longer among us More...

Friends
std::ostream &	operator<< (std::ostream &output, const ParticleList &)
std::ostream &	operator<< (std::ostream &output, const ParticleList::archived_info_type &)

Detailed Description

Definition at line 122 of file ParticleList.h.

Member Typedef Documentation

typedef list_type::allocator_type sim::ParticleList::allocator_type

Definition at line 138 of file ParticleList.h.

typedef std::map<int, archived_info_type> sim::ParticleList::archive_type

private

Definition at line 166 of file ParticleList.h.

typedef list_type::const_iterator sim::ParticleList::const_iterator

Definition at line 132 of file ParticleList.h.

typedef list_type::const_reverse_iterator sim::ParticleList::const_reverse_iterator

Definition at line 134 of file ParticleList.h.

typedef list_type::difference_type sim::ParticleList::difference_type

Definition at line 136 of file ParticleList.h.

typedef list_type::iterator sim::ParticleList::iterator

Definition at line 131 of file ParticleList.h.

typedef list_type::key_compare sim::ParticleList::key_compare

Definition at line 137 of file ParticleList.h.

typedef list_type::key_type sim::ParticleList::key_type

Definition at line 128 of file ParticleList.h.

typedef std::map<int,simb::MCParticle*> sim::ParticleList::list_type

Definition at line 127 of file ParticleList.h.

typedef list_type::mapped_type sim::ParticleList::mapped_type

Definition at line 129 of file ParticleList.h.

typedef primaries_type::const_iterator sim::ParticleList::primaries_const_iterator

private

Definition at line 168 of file ParticleList.h.

typedef primaries_type::iterator sim::ParticleList::primaries_iterator

private

Definition at line 167 of file ParticleList.h.

typedef std::set< int > sim::ParticleList::primaries_type

private

Definition at line 165 of file ParticleList.h.

typedef list_type::reverse_iterator sim::ParticleList::reverse_iterator

Definition at line 133 of file ParticleList.h.

typedef list_type::size_type sim::ParticleList::size_type

Definition at line 135 of file ParticleList.h.

typedef list_type::value_type sim::ParticleList::value_type

Definition at line 130 of file ParticleList.h.

Constructor & Destructor Documentation

sim::ParticleList::ParticleList

(

)

Definition at line 30 of file ParticleList.cxx.

  {
  }  

sim::ParticleList::~ParticleList ( )

virtual

Definition at line 36 of file ParticleList.cxx.

  {
    this->clear();
  }

sim::ParticleList::ParticleList ( const ParticleList &  rhs )

delete

sim::ParticleList::ParticleList ( ParticleList &&  rhs )

default

Member Function Documentation

void sim::ParticleList::Add ( simb::MCParticle *  value )

inline

Definition at line 315 of file ParticleList.h.

{ insert(value);                  }

void sim::ParticleList::AdoptEveIdCalculator ( EveIdCalculator *  calc )

static

Definition at line 418 of file ParticleList.cxx.

  {
    eveIdCalculator.reset(calc);
  }

void sim::ParticleList::Archive

(

const key_type &

key

)

Removes the particle from the list, keeping minimal info of it.

Definition at line 295 of file ParticleList.cxx.

  {
     auto& part = m_particleList.at(key);
     if (part == nullptr) return; // already archived, nothing to do
     
     // create a new archive item with the particle;
     m_archive[key] = archived_info_type(*part);
     
     // dispose of the particle in the list (the cell will still be there
     delete part;
     part = nullptr;
  } // ParticleList::Archive()

void sim::ParticleList::Archive

(

const mapped_type &

key

)

Definition at line 310 of file ParticleList.cxx.

                                                         {
    Archive(key(part));
  }

sim::ParticleList::mapped_type sim::ParticleList::at ( const key_type &  key )

inline

Definition at line 330 of file ParticleList.h.

{ return m_particleList.at(std::abs(key)); }

sim::ParticleList::mapped_type const & sim::ParticleList::at ( const key_type &  key ) const

inline

Definition at line 332 of file ParticleList.h.

{ return m_particleList.at(std::abs(key)); }

sim::ParticleList::iterator sim::ParticleList::begin ( )

inline

Definition at line 305 of file ParticleList.h.

{ return m_particleList.begin();  }

sim::ParticleList::const_iterator sim::ParticleList::begin ( ) const

inline

Definition at line 306 of file ParticleList.h.

{ return m_particleList.begin();  }

void sim::ParticleList::clear

(

void

)

Definition at line 323 of file ParticleList.cxx.

  {
    for ( iterator i = m_particleList.begin(); i != m_particleList.end(); ++i ){
      delete (*i).second;
    }

    m_particleList.clear();
    m_archive.clear();
    m_primaries.clear();
  }

void sim::ParticleList::Cut

(

const double &

cut

)

Definition at line 59 of file ParticleList.cxx.

  {
    // The safest way to do this is to create a list of track IDs that
    // fail the cut, then delete those IDs.

    // Define a list of IDs.
    typedef std::set< key_type > keyList_type;
    keyList_type keyList;

    // Add each ID that fails the cut to the list.
    for ( const_iterator i = m_particleList.begin(); i != m_particleList.end(); ++i ){
      const simb::MCParticle* particle = (*i).second;
      if (!particle) continue;
      Double_t totalInitialEnergy = particle->E();
      if ( totalInitialEnergy < cut ) { 
        keyList.insert( (*i).first ); 
      }
    }
    
    // Go through the list, deleting the particles that are on the list.
    for ( keyList_type::const_iterator i = keyList.begin(); i != keyList.end(); ++i ){
      this->erase( *i );
    }
  }

bool sim::ParticleList::empty ( void  ) const

inline

Definition at line 314 of file ParticleList.h.

{ return m_particleList.empty();  }

sim::ParticleList::iterator sim::ParticleList::end ( void  )

inline

Definition at line 307 of file ParticleList.h.

{ return m_particleList.end();    }

sim::ParticleList::const_iterator sim::ParticleList::end ( void  ) const

inline

Definition at line 308 of file ParticleList.h.

{ return m_particleList.end();    }

ParticleList::size_type sim::ParticleList::erase

(

const key_type &

key

)

Definition at line 342 of file ParticleList.cxx.

  {
    iterator entry = m_particleList.find( abs(key) );
    if (entry == m_particleList.end()) return 0;
    erase(entry);
    return 1;
  }

ParticleList::iterator sim::ParticleList::erase

(

iterator

key

)

Definition at line 336 of file ParticleList.cxx.

  {
    delete position->second;
    return m_particleList.erase( position );
  }

int sim::ParticleList::EveId

(

const int

trackID

)

const

Definition at line 392 of file ParticleList.cxx.

  {
    // If the eve ID calculator has never been initialized, use the
    // default method.
    if ( eveIdCalculator.get() == 0 ){
      AdoptEveIdCalculator( new EveIdCalculator );
    }

    // If the eve ID calculator has changed, or we're looking at a
    // different ParticleList, initialize the calculator.
    static EveIdCalculator* saveEveIdCalculator = 0;
    if ( saveEveIdCalculator != eveIdCalculator.get() ) {
      saveEveIdCalculator = eveIdCalculator.get();
      eveIdCalculator->Init( this );
    }
    if ( eveIdCalculator->ParticleList() != this ){
      eveIdCalculator->Init( this );
    }
    
    // After the "bookkeeping" tests, here's where we actually do the
    // calculation.
    return eveIdCalculator->CalculateEveId( trackID );
  }

sim::ParticleList::iterator sim::ParticleList::find ( const key_type &  key )

inline

Definition at line 318 of file ParticleList.h.

{ return m_particleList.find(abs(key));        }

sim::ParticleList::const_iterator sim::ParticleList::find ( const key_type &  key ) const

inline

Definition at line 320 of file ParticleList.h.

{ return m_particleList.find(abs(key));        }

int sim::ParticleList::GetMotherOf

(

const key_type &

key

)

const

This function seeks for the exact key, not its absolute value.

Definition at line 315 of file ParticleList.cxx.

  {
     auto part = m_particleList.at(key);
     return part? part->Mother(): m_archive.at(key).Mother();
  } // ParticleList::GetMotherOf()

std::vector< const simb::MCParticle * > sim::ParticleList::GetPrimaries

(

)

const

Definition at line 156 of file ParticleList.cxx.

  {
    std::vector<const simb::MCParticle*> primaries;
    primaries.reserve(m_primaries.size());
    // for each particle, check if its track ID is in the primaries list
    // iPartPair is std::pair<const int, simb::MCParticle*>
    for (auto& iPartPair: m_particleList) {
      if (m_primaries.count(iPartPair.first))
        primaries.push_back(iPartPair.second);
    } // for
    if (primaries.size() != m_primaries.size()) {
      throw cet::exception("ParticleList")
        << "sim::ParticleList::GetPrimaries() collected " << primaries.size()
        << " primaries, not " << m_primaries.size() << " as expected\n";
    }
    return primaries;
  } // ParticleList::GetPrimaries()

bool sim::ParticleList::HasParticle ( int  trackID ) const

inline

Returns whether we have this particle, live (with full information)

Definition at line 208 of file ParticleList.h.

      {
        auto iParticle = find(trackID);
        return (iParticle != end()) && (iParticle->second != nullptr);
      }

void sim::ParticleList::insert

(

simb::MCParticle *

value

)

Definition at line 267 of file ParticleList.cxx.

  { 
    int trackID = key(particle);
    iterator insertion = m_particleList.lower_bound( trackID );
    if ( insertion == m_particleList.end() ){
      // The best "hint" we can give is that the particle will go at
      // the end of the list.
      m_particleList.insert( insertion, value_type( trackID, particle ) );
    }
    else if ( (*insertion).first == trackID ){
      throw cet::exception("ParticleList") << "sim::ParticleList::insert - ERROR - "
                                   << "track ID=" << trackID 
                                   << " is already in the list\n";
    }
    else{
      // It turns out that the best hint we can give is one more
      // than the result of lower_bound.
      m_particleList.insert( ++insertion, value_type( trackID, particle ) );
    }

    // If this is a primary particle, add it to the list.  use 
    // rimary as the process string to look for as the P may or may not
    // be capitalized
    if ( particle->Process().find("rimary") != std::string::npos )
      m_primaries.insert( trackID );
  }

bool sim::ParticleList::IsPrimary

(

int

trackID

)

const

Definition at line 109 of file ParticleList.cxx.

  {
    return m_primaries.find( trackID )  !=  m_primaries.end();
  }

sim::ParticleList::key_type sim::ParticleList::key ( mapped_type const &  part ) const

inline

Extracts the key from the specified value.

Definition at line 338 of file ParticleList.h.

{ return part->TrackId(); }

bool sim::ParticleList::KnownParticle ( int  trackID ) const

inline

Returns whether we have had this particle, archived or live.

Definition at line 215 of file ParticleList.h.

      { return find(trackID) != end(); }

sim::ParticleList::iterator sim::ParticleList::lower_bound ( const key_type &  key )

inline

Definition at line 326 of file ParticleList.h.

{ return m_particleList.lower_bound(abs(key)); }

sim::ParticleList::const_iterator sim::ParticleList::lower_bound ( const key_type &  key ) const

inline

Definition at line 328 of file ParticleList.h.

{ return m_particleList.lower_bound(abs(key)); }

ParticleList sim::ParticleList::MakeCopy

(

)

const

Returns a copy of this object.

Definition at line 44 of file ParticleList.cxx.

  {
    ParticleList list;

    // Copy each entry in the other ParticleList.
    for (std::pair<int, simb::MCParticle*> const& partInfo: m_particleList)
      list.insert(partInfo.second? new simb::MCParticle(*(partInfo.second)): nullptr);
    
    list.m_archive = m_archive;
    
    return list;
  } // ParticleList::MakeCopy()

int sim::ParticleList::NumberOfPrimaries

(

)

const

Definition at line 115 of file ParticleList.cxx.

  {
    return m_primaries.size();
  }

ParticleList& sim::ParticleList::operator= ( const ParticleList &  rhs )

delete

ParticleList& sim::ParticleList::operator= ( ParticleList &&  rhs )

default

sim::ParticleList::mapped_type const & sim::ParticleList::operator[] ( const key_type &  key ) const

inline

Definition at line 336 of file ParticleList.h.

{ return at(key); }

sim::ParticleList::mapped_type sim::ParticleList::operator[] ( const key_type &  key )

inline

Definition at line 334 of file ParticleList.h.

{ return at(key); }

ParticleList::mapped_type const & sim::ParticleList::Particle

(

const size_type

index

)

const

Definition at line 93 of file ParticleList.cxx.

  {
    const_iterator i = m_particleList.begin();
    std::advance(i,index);
    return (*i).second;
  }

ParticleList::mapped_type sim::ParticleList::Particle

(

const size_type

index

)

Definition at line 101 of file ParticleList.cxx.

  {
    iterator i = m_particleList.begin();
    std::advance(i,index);
    return (*i).second;
  }

const simb::MCParticle * sim::ParticleList::Primary

(

const int

index

)

const

Definition at line 121 of file ParticleList.cxx.

  {
    // Advance "index" entries from the beginning of the primary list.
    primaries_const_iterator primary = m_primaries.begin();
    std::advance( primary, index );

    // Get the track ID from that entry in the list.
    int trackID = *primary;

    // Find the entry in the particle list with that track ID.
    const_iterator entry = m_particleList.find(trackID);

    // Return the Particle object in that entry.
    return (*entry).second;
  }

simb::MCParticle * sim::ParticleList::Primary

(

const int

index

)

Definition at line 138 of file ParticleList.cxx.

  {
    // Advance "index" entries from the beginning of the primary list.
    primaries_const_iterator primary = m_primaries.begin();
    std::advance( primary, index );

    // Get the track ID from that entry in the list.
    int trackID = *primary;

    // Find the entry in the particle list with that track ID.
    iterator entry = m_particleList.find(trackID);

    // Return the Particle object in that entry.
    return (*entry).second;
  }

sim::ParticleList::reverse_iterator sim::ParticleList::rbegin ( )

inline

Definition at line 309 of file ParticleList.h.

{ return m_particleList.rbegin(); }

sim::ParticleList::const_reverse_iterator sim::ParticleList::rbegin ( ) const

inline

Definition at line 310 of file ParticleList.h.

{ return m_particleList.rbegin(); }

sim::ParticleList::reverse_iterator sim::ParticleList::rend ( )

inline

Definition at line 311 of file ParticleList.h.

{ return m_particleList.rend();   }

sim::ParticleList::const_reverse_iterator sim::ParticleList::rend ( ) const

inline

Definition at line 312 of file ParticleList.h.

{ return m_particleList.rend();   }

sim::ParticleList::size_type sim::ParticleList::size ( void  ) const

inline

Definition at line 313 of file ParticleList.h.

{ return m_particleList.size();   }

void sim::ParticleList::swap ( sim::ParticleList &  other )

inline

Definition at line 316 of file ParticleList.h.

{ m_particleList.swap( other.m_particleList ); m_archive.swap( other.m_archive ); m_primaries.swap( other.m_primaries); }

const ParticleList::key_type & sim::ParticleList::TrackId

(

const size_type

index

)

const

Definition at line 86 of file ParticleList.cxx.

  {
    const_iterator i = m_particleList.begin();
    std::advance(i,index);
    return (*i).first;
  }

sim::ParticleList::iterator sim::ParticleList::upper_bound ( const key_type &  key )

inline

Definition at line 322 of file ParticleList.h.

{ return m_particleList.upper_bound(abs(key)); }

sim::ParticleList::const_iterator sim::ParticleList::upper_bound ( const key_type &  key ) const

inline

Definition at line 324 of file ParticleList.h.

{ return m_particleList.upper_bound(abs(key)); }

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  output, const ParticleList &  list  )

friend

Definition at line 352 of file ParticleList.cxx.

  {
    // Determine a field width for the particle number.
    ParticleList::size_type numberOfParticles = list.size();
    int numberOfDigits = (int) std::log10( (double) numberOfParticles ) + 1;

    // A simple header.
    output.width( numberOfDigits );
    output << "#" << ": < ID, particle >" << std::endl; 

    // Write each particle on a separate line.
    ParticleList::size_type nParticle = 0;
    for ( ParticleList::const_iterator particle = list.begin(); 
          particle != list.end(); ++particle, ++nParticle ){
      output.width( numberOfDigits );
      output << nParticle << ": " 
             << "<" << (*particle).first << ",";
      if (particle->second)
             output << *(particle->second);
      else {
        auto iArch = list.m_archive.find(particle->first);
        if (iArch == list.m_archive.end())
          output << "lost [INTERNAL ERROR!]";
        else
          output << "(archived) " << iArch->second;
      }
      output << ">" << std::endl;
    }

    return output;
  }

std::ostream& operator<< ( std::ostream &  output, const ParticleList::archived_info_type &  info  )

friend

Definition at line 425 of file ParticleList.cxx.

  {
    output << "Mother ID=" << info.Mother() << std::endl;
    return output;
  }

Member Data Documentation

archive_type sim::ParticleList::m_archive

private

archive of the particles no longer among us

Definition at line 173 of file ParticleList.h.

list_type sim::ParticleList::m_particleList

private

Sorted list of particles in the event.

Definition at line 170 of file ParticleList.h.

primaries_type sim::ParticleList::m_primaries

private

Sorted list of the track IDs of primary particles.

Definition at line 171 of file ParticleList.h.

---

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

• nutools/old/ParticleNavigation/ParticleList.h
• nutools/old/ParticleNavigation/ParticleList.cxx