RFList.hh

Go to the documentation of this file.

//   RestFrames: particle physics event analysis library
//   --------------------------------------------------------------------
//   Copyright (c) 2014-2019, Christopher Rogan
//   This file is part of RestFrames.
//
//   RestFrames is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
// 
//   RestFrames is distributed in the hope that it will be useful,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//   GNU General Public License for more details.
// 
//   You should have received a copy of the GNU General Public License
//   along with RestFrames. If not, see <http://www.gnu.org/licenses/>.
 
#ifndef RFList_HH
#define RFList_HH
 
#include <vector>
 
class TLorentzVector;
class TVector3;
 
namespace RestFrames {
  
  class RFKey;
  
  template <class T>
  class RFList;
  
  // RFListBase class
  template <class T, class Derived>
  class RFListBase {
  public:
    RFListBase() {}
 
    virtual ~RFListBase() {}
    
    void Clear();
 
    bool Add(T& obj);
 
    template <class U>
    bool Add(const RFList<U>& objs){
      int N = objs.GetN();
      double ret = true;
      for(int i = 0; i < N; i++) 
    if(!Add((T&)objs[i])) ret = false;
      return ret;
    }
 
    int Remove(const T& obj);
    
    template <class U>
    void Remove(const RFList<U>& objs){
      int N = objs.GetN();
      for(int i = 0; i < N; i++) 
    Remove(objs[i]);
    }
 
    int GetN() const { return m_Objs.size(); }
 
    T& Get(int i) const;
 
    T& Get(const RFKey& key) const;
 
    int GetIndex(const RFKey& key) const;
 
    int GetIndex(const T& obj) const;
 
    template <class U>
    bool Contains(const U& obj) const{
      int N = GetN();
      for(int i = 0; i < N; i++)
    if(*m_Objs[i] == obj) return true;
      return false;
    }
 
    template <class U>
    bool Contains(const RFList<U>& objs) const {
      int N = objs.GetN();
      for(int i = 0; i < N; i++)
    if(!Contains(objs[i]))
      return false;
      return true;
    }
    
    template <class U>
    bool IsSame(const RFList<U>& objs) const {
      return Union(objs).GetN() == Intersection(objs).GetN();
    }
 
    template <class U>
    Derived Union(const RFList<U>& objs) const {
      Derived objs_this = static_cast<const Derived&>(*this);
      objs_this.Add(objs);
      return objs_this;
    }
 
    template <class U>
    Derived Intersection(const RFList<U>& objs) const {
      Derived inter; 
      int N = objs.GetN();
      for(int i = 0; i < N; i++)
    if(Contains(objs[i])) inter.Add(objs[i]);
      return inter;
    }
 
    template <class U>
    Derived Complement(const RFList<U>& objs) const {
      Derived comp = static_cast<Derived&>(*this);
      int N = objs.GetN();
      for(int i = 0; i < N; i++)
    if(comp.Contains(objs.Get(i))) 
      comp.Remove(objs.Get(i));
      return comp;
    }
 
    Derived& operator = (T& obj){
      Clear();
      Add(obj);
      return static_cast<Derived&>(*this);
    }
 
    template <class U>
    Derived& operator = (const RFList<U>& objs){
      Clear();
      Add(objs);
      return static_cast<Derived&>(*this);
    }
 
    T& operator [] (int i) const;
 
    T& operator [] (const RFKey& key) const;
 
    bool operator == (const T& obj) const;
 
    template <class U>
    bool operator == (const RFList<U>& objs) const {
      return IsSame(objs);
    }
 
    bool operator != (const T& obj) const;
 
    template <class U>
    bool operator != (const RFList<U>& objs) const {
      return !IsSame(objs);
    }
 
    Derived operator + (T& obj) const;
 
    template <class U>
    Derived operator + (const RFList<U>& objs) const {
      Derived list = static_cast<const Derived&>(*this);
      list.Add(objs);
      return list;
    }
 
    Derived operator - (const T& obj) const;
 
    template <class U>
    Derived operator - (const RFList<U>& objs) const;
 
    Derived& operator += (T& obj);
 
    template <class U>
    Derived& operator += (const RFList<U>& objs){
      Add(objs);
      return static_cast<Derived&>(*this);
    }
 
    Derived& operator -= (const T& obj);
 
    template <class U>
    Derived& operator -= (const RFList<U>& objs){
      Remove(objs);
      return static_cast<Derived&>(*this);
    }
    
  protected:
    std::vector<T*> m_Objs;
  
  };
    
  // RFList class
  template <class T>
  class RFList : public RestFrames::RFListBase<T,RFList<T> > {
  public:
    RFList() : RFListBase<T,RFList<T> >() { }
    
    template <class U>
    RFList(const RFList<U>& objs) : RFListBase<T,RFList<T> >() {
      RFListBase<T,RFList<T> >::Add(objs);
    }
 
    virtual ~RFList() { }
  };
 
  class RFCharge;
  class RestFrame;
  class State;
  
  template <>
  class RFList<RestFrames::State>
    : public RFListBase<State,RFList<RestFrames::State> > {
  public:
    RFList() : RFListBase<State,RFList<State> >() { }
 
    template <class U>
    RFList(const RFList<U>& objs) : RFListBase<State,RFList<State> >() {
      Add(objs);
    }
 
    virtual ~RFList(){ }
 
    State& GetFrame(const RestFrame& frame) const;
    TLorentzVector GetFourVector() const;
    RFCharge GetCharge() const;
    void Boost(const TVector3& B) const;
  };
 
  template <> 
  class RFList<RestFrames::RestFrame>
    : public RFListBase<RestFrame,RFList<RestFrames::RestFrame> > {
  public:
    RFList() : RFListBase<RestFrame,RFList<RestFrame> >() {}
 
    template <class U>
    RFList(const RFList<U>& objs) : RFListBase<RestFrame,RFList<RestFrame> >() {
      Add(objs);
    }
 
    virtual ~RFList(){ }
 
    double GetMass() const;
  
    TLorentzVector GetFourVector() const;
    TLorentzVector GetFourVector(const RestFrame& frame) const;
    TLorentzVector GetVisibleFourVector() const;
    TLorentzVector GetVisibleFourVector(const RestFrame& frame) const;
    TLorentzVector GetInvisibleFourVector() const;
    TLorentzVector GetInvisibleFourVector(const RestFrame& frame) const;
    double GetEnergy(const RestFrame& frame) const;
    double GetMomentum(const RestFrame& frame) const;
    RFCharge GetCharge() const;
  };
 
  class RFBase;
  class Jigsaw;
  class Group;
  class VisibleState;
  class HistPlotVar;
  class HistPlotCategory;
  class RFDataVar;
  class RFPDF;
  
  typedef RestFrames::RFList<RFBase>            RFBaseList;
  typedef RestFrames::RFList<RestFrame>         RestFrameList;
  typedef RestFrames::RFList<const RestFrame>   ConstRestFrameList;
  typedef RestFrames::RFList<Group>             GroupList;
  typedef RestFrames::RFList<const Group>       ConstGroupList;
  typedef RestFrames::RFList<Jigsaw>            JigsawList;
  typedef RestFrames::RFList<const Jigsaw>      ConstJigsawList;
  typedef RestFrames::RFList<State>             StateList;
  typedef RestFrames::RFList<VisibleState>      VisibleStateList;
  typedef RestFrames::RFList<HistPlotVar>       HistPlotVarList;
  typedef RestFrames::RFList<HistPlotCategory>  HistPlotCatList;
  typedef RestFrames::RFList<RFDataVar>         RFDataVarList;
  typedef RestFrames::RFList<const RFDataVar>   ConstRFDataVarList;
  typedef RestFrames::RFList<RFPDF>             RFPDFList;
 
  typedef std::vector<RestFrames::RFList<RestFrame> >       RestFrameListList;
  typedef std::vector<RestFrames::RFList<State> >           StateListList;
  
}
 
#endif