LauKinematics.hh

Go to the documentation of this file.

// Copyright University of Warwick 2004 - 2013.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

// Authors:
// Thomas Latham
// John Back
// Paul Harrison

#ifndef LAU_KINEMATICS
#define LAU_KINEMATICS

#include <vector>

#include "TMath.h"


class LauKinematics {

        public:

                LauKinematics(Double_t m1, Double_t m2, Double_t m3, Double_t mParent, Bool_t calcSquareDPCoords = kFALSE);

                virtual ~LauKinematics();


                inline Bool_t squareDP() const { return squareDP_; }

                inline void warningMessages(Bool_t boolean) { warnings_ = boolean; }


                void updateKinematics(Double_t m13Sq, Double_t m23Sq);


                void updateSqDPKinematics(Double_t mPrime, Double_t thetaPrime);


                Double_t calcSqDPJacobian();


                void genFlatPhaseSpace(Double_t& m13Sq, Double_t& m23Sq) const;


                void genFlatSqDP(Double_t& mPrime, Double_t& thetaPrime) const;


                Bool_t withinDPLimits(Double_t m13Sq, Double_t m23Sq) const;


                Bool_t withinDPLimits2(Double_t m13Sq, Double_t m23Sq) const;


                Bool_t withinDPLimits() const;


                Bool_t withinSqDPLimits(Double_t mPrime, Double_t thetaPrime) const;


                Double_t calcThirdMassSq(Double_t firstMassSq, Double_t secondMassSq) const;


                Double_t distanceFromDPCentre() const;


                Double_t distanceFromDPCentre(Double_t m13Sq, Double_t m23Sq) const;


                inline Double_t getm12() const {return m12_;}

                inline Double_t getm23() const {return m23_;}

                inline Double_t getm13() const {return m13_;}


                inline Double_t getm12Sq() const {return m12Sq_;}

                inline Double_t getm23Sq() const {return m23Sq_;}

                inline Double_t getm13Sq() const {return m13Sq_;}


                inline Double_t getc12() const {return c12_;}

                inline Double_t getc23() const {return c23_;}

                inline Double_t getc13() const {return c13_;}


                inline Double_t getmPrime() const {return mPrime_;}

                inline Double_t getThetaPrime() const {return thetaPrime_;}


                inline Double_t getmParent() const {return mParent_;}

                inline Double_t getmParentSq() const {return mParentSq_;}


                inline Double_t getDPBoxArea() const {return (mSqMax_[1] - mSqMin_[1])*(mSqMax_[0] - mSqMin_[0]);}


                void flipAndUpdateKinematics();


                void rotateAndUpdateKinematics();


                inline Double_t getm1() const {return m1_;}

                inline Double_t getm2() const {return m2_;}

                inline Double_t getm3() const {return m3_;}


                inline Double_t getm23Min() const {return TMath::Sqrt(mSqMin_[0]);}

                inline Double_t getm13Min() const {return TMath::Sqrt(mSqMin_[1]);}

                inline Double_t getm12Min() const {return TMath::Sqrt(mSqMin_[2]);}


                inline Double_t getm23Max() const {return TMath::Sqrt(mSqMax_[0]);}

                inline Double_t getm13Max() const {return TMath::Sqrt(mSqMax_[1]);}

                inline Double_t getm12Max() const {return TMath::Sqrt(mSqMax_[2]);}


                inline Double_t getm23SqMin() const {return mSqMin_[0];}

                inline Double_t getm13SqMin() const {return mSqMin_[1];}

                inline Double_t getm12SqMin() const {return mSqMin_[2];}


                inline Double_t getm23SqMax() const {return mSqMax_[0];}

                inline Double_t getm13SqMax() const {return mSqMax_[1];}

                inline Double_t getm12SqMax() const {return mSqMax_[2];}


                inline Double_t getp1_12() const {return p1_12_;}

                inline Double_t getp3_12() const {return p3_12_;}

                inline Double_t getp2_23() const {return p2_23_;}

                inline Double_t getp1_23() const {return p1_23_;}

                inline Double_t getp1_13() const {return p1_13_;}

                inline Double_t getp2_13() const {return p2_13_;}


                inline Double_t getp1_Parent() const {return p1_Parent_;}

                inline Double_t getp2_Parent() const {return p2_Parent_;}

                inline Double_t getp3_Parent() const {return p3_Parent_;}


                void drawDPContour(Int_t orientation = 1323, Int_t nbins = 100);

        protected:

                void updateMassSq_m12(Double_t m12, Double_t c12);

                void updateMassSq_m23(Double_t m23, Double_t c23);

                void updateMassSq_m13(Double_t m13, Double_t c13);


                void updateMassSquares(Double_t m13Sq, Double_t m23Sq);


                void updateSqDPMassSquares(Double_t mPrime, Double_t thetaPrime);


                Double_t cFromM(Double_t mijSq, Double_t mikSq, Double_t mij, Int_t i, Int_t j, Int_t k) const;


                Double_t mFromC(Double_t mijSq, Double_t cij, Double_t mij, Int_t i, Int_t j, Int_t k) const;


                Double_t pCalc(Double_t energy, Double_t massSq) const;


                Double_t genm13Sq() const;

                Double_t genm23Sq() const;

                Double_t genm12Sq() const;

                void calcm12Sq();

                void calcHelicities();

                void calcSqDPVars();

                void calcParentFrameMomenta();

        private:
                LauKinematics(const LauKinematics& rhs);

                LauKinematics& operator=(const LauKinematics& rhs);

                const Double_t m1_;
                const Double_t m2_;
                const Double_t m3_;
                const Double_t mParent_;

                const Double_t m1Sq_;
                const Double_t m2Sq_;
                const Double_t m3Sq_;
                const Double_t mParentSq_;

                std::vector<Double_t> mass_;
                std::vector<Double_t> mMin_;
                std::vector<Double_t> mMax_;
                std::vector<Double_t> mDiff_;

                std::vector<Double_t> mSq_;
                std::vector<Double_t> mSqMin_;
                std::vector<Double_t> mSqMax_;
                std::vector<Double_t> mSqDiff_;

                const Double_t mDTot_;
                const Double_t massInt_;
                const Double_t mSqDTot_;

                Double_t m12_;
                Double_t m23_;
                Double_t m13_;

                Double_t m12Sq_;
                Double_t m23Sq_;
                Double_t m13Sq_;

                Double_t c12_;
                Double_t c23_;
                Double_t c13_;

                Double_t mPrime_;
                Double_t thetaPrime_;

                mutable Double_t qi_;
                mutable Double_t qk_;

                Double_t p1_12_;
                Double_t p3_12_;
                Double_t p2_23_;
                Double_t p1_23_;
                Double_t p1_13_;
                Double_t p2_13_;

                Double_t p1_Parent_;
                Double_t p2_Parent_;
                Double_t p3_Parent_;

                Bool_t squareDP_;
                Bool_t warnings_;

                ClassDef(LauKinematics,0)
};

Double_t dal(Double_t* x, Double_t* par);

#endif