RestFrame.hh

Go to the documentation of this file.

//   RestFrames: particle physics event analysis library
//   --------------------------------------------------------------------
//   Copyright (c) 2014-2016, 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 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;

    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 GetVisibleShape(const vector<RFList<RestFrame> >& frames) 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