MCTrajectory.h

Go to the documentation of this file.

#ifndef SIMB_MCTRAJECTORY_H
#define SIMB_MCTRAJECTORY_H

#include <vector>
#include <iostream>

#include <TLorentzVector.h>

namespace simb {

  class MCTrajectory {
  public:
    typedef std::vector< std::pair<TLorentzVector, TLorentzVector> >  list_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 std::vector< std::pair<size_t, unsigned char> >           ProcessMap;
    MCTrajectory();

  private:
    list_type  ftrajectory;        
    ProcessMap fTrajectoryProcess; 

  public:

    MCTrajectory( const TLorentzVector& vertex,
                  const TLorentzVector& momentum );

    const TLorentzVector& Position( const size_type ) const;
    const TLorentzVector& Momentum( const size_type ) const;
    double  X( const size_type i ) const;
    double  Y( const size_type i ) const;
    double  Z( const size_type i ) const;
    double  T( const size_type i ) const;
    double Px( const size_type i ) const;
    double Py( const size_type i ) const;
    double Pz( const size_type i ) const;
    double  E( const size_type i ) const;

    double TotalLength() const;

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

    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(simb::MCTrajectory& other);
    void      clear();

    // Note that there's no non-const version of operator[] or at() here; once
    // you've added a point to a trajectory, you can't modify it.
    const value_type& operator[](const size_type i) const;
    const value_type& at(const size_type i)         const;

    void push_back(value_type const& v );
    void push_back(TLorentzVector const& p,
                   TLorentzVector const& m );
    void Add(TLorentzVector const& p,
             TLorentzVector const& m );
    void Add(TLorentzVector const& p,
             TLorentzVector const& m,
             std::string    const& process,
             bool keepTransportation = false);

    unsigned char        ProcessToKey(std::string   const& process) const;
    std::string          KeyToProcess(unsigned char const& key)     const;
    ProcessMap    const& TrajectoryProcesses()                      const;

    void Sparsify(double margin = .1, bool keep_second_to_last = false);

  };

} // namespace simb

inline double           simb::MCTrajectory::X ( const size_type i ) const { return Position(i).X();      }
inline double           simb::MCTrajectory::Y ( const size_type i ) const { return Position(i).Y();      }
inline double           simb::MCTrajectory::Z ( const size_type i ) const { return Position(i).Z();      }
inline double           simb::MCTrajectory::T ( const size_type i ) const { return Position(i).T();      }
inline double           simb::MCTrajectory::Px( const size_type i ) const { return Momentum(i).Px();     }
inline double           simb::MCTrajectory::Py( const size_type i ) const { return Momentum(i).Py();     }
inline double           simb::MCTrajectory::Pz( const size_type i ) const { return Momentum(i).Pz();     }
inline double           simb::MCTrajectory::E ( const size_type i ) const { return Momentum(i).E();      }

inline simb::MCTrajectory::iterator               simb::MCTrajectory::begin()             { return ftrajectory.begin();  }
inline simb::MCTrajectory::const_iterator         simb::MCTrajectory::begin()       const { return ftrajectory.begin();  }
inline simb::MCTrajectory::iterator               simb::MCTrajectory::end()               { return ftrajectory.end();    }
inline simb::MCTrajectory::const_iterator         simb::MCTrajectory::end()         const { return ftrajectory.end();    }
inline simb::MCTrajectory::reverse_iterator       simb::MCTrajectory::rbegin()            { return ftrajectory.rbegin(); }
inline simb::MCTrajectory::const_reverse_iterator simb::MCTrajectory::rbegin()      const { return ftrajectory.rbegin(); }
inline simb::MCTrajectory::reverse_iterator       simb::MCTrajectory::rend()              { return ftrajectory.rend();   }
inline simb::MCTrajectory::const_reverse_iterator simb::MCTrajectory::rend()        const { return ftrajectory.rend();   }
inline simb::MCTrajectory::size_type              simb::MCTrajectory::size()        const { return ftrajectory.size();   }
inline bool                                       simb::MCTrajectory::empty()       const { return ftrajectory.empty();  }
inline void                                       simb::MCTrajectory::clear()             { ftrajectory.clear();         }
inline void                                       simb::MCTrajectory::swap(simb::MCTrajectory& other)
                                                                                { ftrajectory.swap( other.ftrajectory ); }

inline const simb::MCTrajectory::value_type&      simb::MCTrajectory::operator[](const simb::MCTrajectory::size_type i) const
                                                                                                { return ftrajectory[i]; }

inline const simb::MCTrajectory::value_type&      simb::MCTrajectory::at(const simb::MCTrajectory::size_type i)         const
                                                                                             { return ftrajectory.at(i); }

inline void                                       simb::MCTrajectory::push_back(const simb::MCTrajectory::value_type& v )
                                                                                             { ftrajectory.push_back(v); }

inline void                                       simb::MCTrajectory::push_back(const TLorentzVector& p,
                                                                                const TLorentzVector& m )
                                                         { ftrajectory.push_back( simb::MCTrajectory::value_type(p,m) ); }

inline void                                       simb::MCTrajectory::Add(const TLorentzVector& p,
                                                                          const TLorentzVector& m )    { push_back(p,m); }

inline simb::MCTrajectory::ProcessMap    const&   simb::MCTrajectory::TrajectoryProcesses() const { return fTrajectoryProcess; }

#endif // SIMB_MCTRAJECTORY_H