LArVoxelData.h

Go to the documentation of this file.

#ifndef Simulation_LArVoxelData_h_
#define Simulation_LArVoxelData_h_

#include "lardataobj/Utilities/VectorMap.h"
#include "lardataobj/Utilities/SumSecondFunction.h"
#include "larsim/Simulation/LArVoxelID.h"

#include <numeric>
#include <iostream>

namespace sim {

  class LArVoxelData 
  {
  public:
    // Some type definitions to make life easier, and to help "hide"
    // the implementation details.  (If you're not familiar with STL,
    // you can ignore these definitions.)
    typedef util::VectorMap<int, double>       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;

    // Standard constructor and destructor.
    LArVoxelData();
    virtual ~LArVoxelData();

  private:
    // This is the sum of all the voxel energy that is not assigned
    // to a particular particle track.
    mapped_type fenergy;     // Energy not assigned to a particular track in a voxel.

    // If we're able to maintain a track<->energy relationship for
    // this voxel, this map contains the amount of energy deposited
    // in this voxel for the given tracks.
    list_type ftrackEnergy;  // Energy assigned to individual particle tracks in a voxel.

    sim::LArVoxelID fVoxelID; //id for the voxel represented by these data

#ifndef __GCCXML__

  public:
    // The energy routines described above.  (std::accumulate is
    // defined in <numeric>, and is a standard STL algorithm.)
    mapped_type AssignedEnergy() const;
    mapped_type UnassignedEnergy() const;
    mapped_type Energy() const;

    size_type NumberParticles() const;

    const key_type&    TrackID( const size_type ) const;
    const mapped_type& Energy ( const size_type ) const;

    // Add the energy to the entry with the key; if the key doesn't
    // exist, create it.
    void Add( const mapped_type& energy, const key_type& trackID );

    // If there's no key, it must be "unassigned" energy.
    void Add( const mapped_type& energy );

    sim::LArVoxelID VoxelID()  const;
    void            SetVoxelID(sim::LArVoxelID voxID);

    // Arithmetic methods to support the arithmetic that can be
    // performed by LArVoxelList.
    void Add( const LArVoxelData& );
    LArVoxelData& operator+=( const LArVoxelData& other );
    const LArVoxelData operator+(const LArVoxelData& other) const; 

    LArVoxelData& operator*=( const double& value );
    const LArVoxelData operator*(const double& value) const;

    // Just in case: define the result of "scalar * LArVoxelData" to be
    // the same as "LArVoxelData * scalar".
    friend const LArVoxelData operator*(const double& value, const LArVoxelData& list);

    // RemoveTrack any particle with this track ID and move its energy to
    // the "unassigned" energy; it returns the number of entries
    // removed.  This method is inlined because we need to do this
    // fast; it's probably being called in a loop over all the
    // members of a LArVoxelList.
    size_type RemoveTrack( const int& track );

    // Remove all particles and move their energies to "unassigned."
    void RemoveAllTracks();

    friend std::ostream& operator<< ( std::ostream& output, const LArVoxelData& );

    // Standard STL methods, to make this class look like an STL map.
    // Again, if you don't know STL, you can just ignore these
    // methods. Remember, the "map" portion of this class doesn't
    // always tell the whole story; you also need to look at the
    // "unasigned" energy separately.
    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( LArVoxelData& other );
    void      clear();
                                                                                                   
    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; 
    size_type      erase( const key_type& key );           
                                                                                                   
    mapped_type&       operator[](const key_type& key);
    // My own little addition: operator[] in a const context.                                      
    const mapped_type& operator[]( const key_type& key) const;     
    mapped_type&       at(const key_type& key);                    
    const mapped_type& at(const key_type& key)          const;
                                                                                                   
    // In addition to operator[], include one insert() method.  Note                               
    // that, as with operator[], there's no check against overwriting                              
    // an existing item.                                                                           
    void insert( const key_type& key, const mapped_type& value );

#endif

  };

} // namespace sim

#ifndef __GCCXML__

inline void                  sim::LArVoxelData::SetVoxelID(sim::LArVoxelID voxID) { fVoxelID = voxID; }
inline sim::LArVoxelID                sim::LArVoxelData::VoxelID()          const { return fVoxelID;  }
inline sim::LArVoxelData::size_type   sim::LArVoxelData::NumberParticles()  const { return size();    }
inline sim::LArVoxelData::mapped_type sim::LArVoxelData::UnassignedEnergy() const { return fenergy;   }
inline sim::LArVoxelData::mapped_type sim::LArVoxelData::AssignedEnergy()   const
{
  return std::accumulate( ftrackEnergy.begin(), ftrackEnergy.end(), 0.0,
                          util::SumSecondFunction<key_type,mapped_type>() );
}
inline sim::LArVoxelData::mapped_type sim::LArVoxelData::Energy()           const
{
  return std::accumulate( ftrackEnergy.begin(), ftrackEnergy.end(), fenergy,
                          util::SumSecondFunction<key_type,mapped_type>() );
}
inline sim::LArVoxelData::size_type   sim::LArVoxelData::RemoveTrack( const int& track )
{
  iterator search = ftrackEnergy.find( track );
  if ( search != ftrackEnergy.end() )
    {
      fenergy += (*search).second;
      ftrackEnergy.erase( search );
      return 1;
    }
  else return 0;
}
inline void sim::LArVoxelData::RemoveAllTracks()
{
  fenergy = this->Energy();
  ftrackEnergy.clear();
}
inline void sim::LArVoxelData::Add( const sim::LArVoxelData::mapped_type& energy, 
                                    const sim::LArVoxelData::key_type& trackID ) 
{ ftrackEnergy[trackID] += energy; }
inline void sim::LArVoxelData::Add( const sim::LArVoxelData::mapped_type& energy)
{ fenergy += energy; } 
inline sim::LArVoxelData& sim::LArVoxelData::operator+=( const sim::LArVoxelData& other)
{ 
  this->Add(other); 
  return *this; 
}
inline const sim::LArVoxelData sim::LArVoxelData::operator+(const sim::LArVoxelData& other) const
{
  return LArVoxelData(*this) += other;
}
inline const sim::LArVoxelData sim::LArVoxelData::operator*(const double& value) const 
{
  return LArVoxelData(*this) *= value;
}
inline sim::LArVoxelData::iterator               sim::LArVoxelData::begin()        { return ftrackEnergy.begin();  }
inline sim::LArVoxelData::const_iterator         sim::LArVoxelData::begin()  const { return ftrackEnergy.begin();  }                       
inline sim::LArVoxelData::iterator               sim::LArVoxelData::end()          { return ftrackEnergy.end();    }                       
inline sim::LArVoxelData::const_iterator         sim::LArVoxelData::end()    const { return ftrackEnergy.end();    }                       
inline sim::LArVoxelData::reverse_iterator       sim::LArVoxelData::rbegin()       { return ftrackEnergy.rbegin(); }                       
inline sim::LArVoxelData::const_reverse_iterator sim::LArVoxelData::rbegin() const { return ftrackEnergy.rbegin(); }                       
inline sim::LArVoxelData::reverse_iterator       sim::LArVoxelData::rend()         { return ftrackEnergy.rend();   }                       
inline sim::LArVoxelData::const_reverse_iterator sim::LArVoxelData::rend()   const { return ftrackEnergy.rend();   }                       
                                                                                                   
inline sim::LArVoxelData::size_type              sim::LArVoxelData::size()   const { return ftrackEnergy.size();   }                       
inline bool                                      sim::LArVoxelData::empty()  const { return ftrackEnergy.empty();  }                       
inline void sim::LArVoxelData::swap( LArVoxelData& other ) 
{                                                                                                  
  ftrackEnergy.swap( other.ftrackEnergy );                                                         
  double temp = fenergy;                                                                           
  fenergy = other.fenergy;                                                                         
  other.fenergy = temp;                                                                    
}                                                                                                  
inline void sim::LArVoxelData::clear() { fenergy = 0.; ftrackEnergy.clear(); }  
inline sim::LArVoxelData::iterator       sim::LArVoxelData::find(const sim::LArVoxelData::key_type& key)
{ return ftrackEnergy.find(key);        }
inline sim::LArVoxelData::const_iterator sim::LArVoxelData::find(const sim::LArVoxelData::key_type& key) const 
{ return ftrackEnergy.find(key);        }
inline sim::LArVoxelData::iterator       sim::LArVoxelData::upper_bound(const sim::LArVoxelData::key_type& key)       
{ return ftrackEnergy.upper_bound(key); }
inline sim::LArVoxelData::const_iterator sim::LArVoxelData::upper_bound(const sim::LArVoxelData::key_type& key) const 
{ return ftrackEnergy.upper_bound(key); }
inline sim::LArVoxelData::iterator       sim::LArVoxelData::lower_bound(const sim::LArVoxelData::key_type& key)       
{ return ftrackEnergy.lower_bound(key); }
inline sim::LArVoxelData::const_iterator sim::LArVoxelData::lower_bound(const sim::LArVoxelData::key_type& key) const 
{ return ftrackEnergy.lower_bound(key); }
inline sim::LArVoxelData::size_type      sim::LArVoxelData::erase( const sim::LArVoxelData::key_type& key )           
{ return this->RemoveTrack(key);        }
                                                                                                   
inline sim::LArVoxelData::mapped_type&   sim::LArVoxelData::operator[](const sim::LArVoxelData::key_type& key)        
{ return ftrackEnergy[key];    }           
inline const sim::LArVoxelData::mapped_type& sim::LArVoxelData::operator[]( const sim::LArVoxelData::key_type& key) const 
{ return ftrackEnergy.at(key); }           
inline sim::LArVoxelData::mapped_type&       sim::LArVoxelData::at(const sim::LArVoxelData::key_type& key)                
{ return ftrackEnergy.at(key); }           
inline const sim::LArVoxelData::mapped_type& sim::LArVoxelData::at(const sim::LArVoxelData::key_type& key) const 
{ return ftrackEnergy.at(key); }           
inline void sim::LArVoxelData::insert( const sim::LArVoxelData::key_type& key, const sim::LArVoxelData::mapped_type& value )
{ ftrackEnergy[key] = value; }    

#endif

#endif // Simulation_LArVoxelData_h_