RestFrame.hh

Go to the documentation of this file.

//   RestFrames: particle physics event analysis library
//   --------------------------------------------------------------------
//   Copyright (c) 2014-2018, 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 RestFrame_HH
#define RestFrame_HH
 
#include "RestFrames/RFBase.hh"
#include "RestFrames/RFCharge.hh"
 
namespace RestFrames {
 
  enum FrameType { kVanillaFrame, kVisibleFrame, kInvisibleFrame,
           kDecayFrame,   kLabFrame};
 
  enum AnaType { kRecoFrame, kGenFrame };
 
  class RestFrame : public RFBase {
  public:
    
    RestFrame(const std::string& sname, const std::string& stitle);
    
    RestFrame();
    
    virtual ~RestFrame();
 
    static void SetAxis(const TVector3& axis);
 
    static TVector3 const& GetAxis();
 
    virtual void Clear();
 
    
    FrameType GetType() const;
    
    bool IsVisibleFrame() const;
    
    bool IsInvisibleFrame() const;
    
    bool IsDecayFrame() const;
    
    bool IsLabFrame() const; 
    
    bool IsRecoFrame() const;
    
    bool IsGenFrame() const;
 
    virtual std::string PrintString(LogType type) const;
    
 
    
    virtual void AddChildFrame(RestFrame& frame);
 
    void AddChildFrames(const RestFrameList& frames);
 
    virtual void SetParentFrame(RestFrame& frame = 
                RestFrame::Empty());
 
    void RemoveChildFrame(RestFrame& frame);
 
    void RemoveChildFrames();
  
 
    int GetNChildren() const;
 
    int GetNDescendants() const;
 
    virtual RestFrame const& GetParentFrame() const;
 
    virtual RestFrame& GetChildFrame(int i = 0) const;
 
    RestFrameList const& GetChildFrames() const;
 
    virtual RestFrame const& GetLabFrame() const;
 
    virtual RestFrame const& GetProductionFrame() const;
 
    virtual RestFrame const& GetSiblingFrame() const;
 
    int GetFrameDepth(const RestFrame& frame) const;
 
    virtual RestFrame const& GetFrameAtDepth(int depth, const RestFrame& frame) const;
    
    virtual RestFrameList GetListFrames(FrameType type = kLabFrame) const;
 
    virtual RestFrameList GetListVisibleFrames() const;
 
    virtual RestFrameList GetListInvisibleFrames() const;
    
 
 
    RestFrameList operator + (RestFrame& frame); 
 
    RestFrameList operator + (const RestFrameList& frames); 
 
    virtual RFCharge GetCharge() const;
 
    virtual double GetMass() const;
 
    TLorentzVector GetFourVector(const RestFrame& frame = 
                 RestFrame::Empty()) const;
 
    TLorentzVector GetTransverseFourVector(const RestFrame& frame = 
                       RestFrame::Empty(),
                       const TVector3& axis = 
                       RestFrame::GetAxis(), 
                       const RestFrame& axis_frame = 
                       RestFrame::Empty()) const;
   
    TLorentzVector GetVisibleFourVector(const RestFrame& frame = 
                    RestFrame::Empty()) const; 
    
    TLorentzVector GetInvisibleFourVector(const RestFrame& frame = 
                      RestFrame::Empty()) const; 
    
    double GetEnergy(const RestFrame& frame) const;
 
    double GetMomentum(const RestFrame& frame) const;
 
    TLorentzVector GetFourVector(const TLorentzVector& P,
                 const RestFrame& def_frame = 
                 RestFrame::Empty()) const;
 
    TLorentzVector GetTransverseFourVector(const TLorentzVector& P,
                       const TVector3& axis = 
                       RestFrame::GetAxis(), 
                       const RestFrame& axis_frame = 
                       RestFrame::Empty()) const;
 
    double GetTransverseMomentum(const RestFrame& frame = 
                 RestFrame::Empty(),
                 const TVector3& axis = 
                 RestFrame::GetAxis(), 
                 const RestFrame& axis_frame = 
                 RestFrame::Empty()) const;
 
    double GetTransverseMomentum(const TLorentzVector& P,
                 const TVector3& axis = 
                 RestFrame::GetAxis(), 
                 const RestFrame& axis_frame = 
                 RestFrame::Empty()) const;
 
    double GetVisibleShape() const;
 
    double GetSumVisibleMomentum() const;
 
    double GetSumInvisibleMomentum() const;
 
    TVector3 GetBoostInParentFrame() const;
 
    double GetGammaInParentFrame() const;
 
    TVector3 GetDecayPlaneNormalVector(const RestFrame& frame = 
                       RestFrame::Empty()) const;
 
    double GetDeltaPhiDecayPlanes(const RestFrame& frame) const;
 
    double GetCosDecayAngle(const RestFrame& frame = 
                RestFrame::Empty()) const;
 
    double GetDeltaPhiDecayAngle(const TVector3& axis = 
                 RestFrame::GetAxis(), 
                 const RestFrame& frame = 
                 RestFrame::Empty()) const;
 
    double GetDeltaPhiBoostVisible(const TVector3& axis = 
                   RestFrame::GetAxis(), 
                   const RestFrame& frame = 
                   RestFrame::Empty()) const;
 
    double GetDeltaPhiDecayVisible(const TVector3& axis = 
                   RestFrame::GetAxis(), 
                   const RestFrame& frame = 
                   RestFrame::Empty()) const;
 
    double GetDeltaPhiVisible(const TVector3& axis = 
                  RestFrame::GetAxis(), 
                  const RestFrame& frame = 
                  RestFrame::Empty()) const;
 
    static RestFrame& Empty();
 
    static ConstRestFrameList const& EmptyList();
 
  protected:   
    FrameType m_Type;
    AnaType m_Ana;
 
    virtual bool IsSoundBody() const;
 
    TVector3 const& GetChildBoostVector(RestFrame& frame) const;
    TVector3 const& GetParentBoostVector() const;
 
    virtual bool InitializeTreeRecursive();
 
    virtual bool InitializeAnalysisRecursive() = 0;
 
    virtual bool AnalyzeEventRecursive() = 0;
 
    virtual bool ClearEventRecursive() = 0;
 
    bool IsCircularTree(std::vector<RFKey>& keys) const;
 
  private:
    static int m_class_key;
 
    static TVector3 m_Axis;
 
    // 4-vector of this state in the frame it's initialized
    TLorentzVector m_P;
    
    // the reference frame where this four-vector is initialized
    const RestFrame* m_ProdFramePtr;
 
    // list of child frames and boosts
    RestFrameList m_ChildFrames;
    mutable std::map<const RestFrame*, TVector3> m_ChildBoosts;
 
    // parent frame and boost
    RestFrame* m_ParentFramePtr;
    TVector3 m_ParentBoost;
 
    void SetFourVector(const TLorentzVector& V, const RestFrame& frame);
    void SetChildBoostVector(RestFrame& frame, const TVector3& boost);
    void SetParentBoostVector(const TVector3& boost);
 
    // Recursively get lists of frames
    void FillListFramesRecursive(RestFrameList& frames,
                 FrameType type = kLabFrame) const;
 
    bool FindPathToFrame(const RestFrame& dest_frame,
             const RestFrame& prev_frame, 
             std::vector<const TVector3*>& boosts) const;
 
    static const ConstRestFrameList m_EmptyList;
    
    friend class ReconstructionFrame;
    friend class GeneratorFrame;
 
  };
 
}
 
#endif