LauKinematics.hh

Go to the documentation of this file.

/*
Copyright 2004 University of Warwick

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/*
Laura++ package authors:
John Back
Paul Harrison
Thomas Latham
*/

#ifndef LAU_KINEMATICS
#define LAU_KINEMATICS

#include <vector>

#include "TMath.h"


class LauKinematics {

        public:

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

                virtual ~LauKinematics();


                inline void squareDP( const Bool_t calcSquareDPCoords ) { squareDP_ = calcSquareDPCoords; }


                inline Bool_t squareDP() const { return squareDP_; }


                inline Bool_t gotSymmetricalDP() const { return (symmetricalDP_ && ! fullySymmetricDP_); }


                inline Bool_t gotFullySymmetricDP() const { return fullySymmetricDP_; }

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


                void updateKinematics(const Double_t m13Sq, const Double_t m23Sq);


                void updateSqDPKinematics(const Double_t mPrime, const Double_t thetaPrime);


                void updateKinematicsFrom23(const Double_t m23, const Double_t c23);


                void updateKinematicsFrom13(const Double_t m13, const Double_t c13);


                void updateKinematicsFrom12(const Double_t m12, const Double_t c12);


                Double_t calcSqDPJacobian(const Double_t mPrime, const Double_t thPrime) const;


                Double_t calcSqDPJacobian() const;


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


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


                Bool_t withinDPLimits(const Double_t m13Sq, const Double_t m23Sq) const;


                Bool_t withinDPLimits2(const Double_t m13Sq, const Double_t m23Sq) const;


                Bool_t withinSqDPLimits(const Double_t mPrime, const Double_t thetaPrime) const;


                Double_t calcThirdMassSq(const Double_t firstMassSq, const Double_t secondMassSq) const;


                Double_t distanceFromDPCentre() const;


                Double_t distanceFromDPCentre(const Double_t m13Sq, const 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(const Int_t orientation = 1323, const Int_t nbins = 100);


                inline Double_t getcov12() const {return (mParentSq_ + m12Sq_ - m3Sq_)/(2.*mParent_*m12_);}


                inline Double_t getcov13() const {return (mParentSq_ + m13Sq_ - m2Sq_)/(2.*mParent_*m13_);} 


                inline Double_t getcov23() const {return (mParentSq_ + m23Sq_ - m1Sq_)/(2.*mParent_*m23_);} 

        protected:

                void updateMassSq_m12(const Double_t m12, const Double_t c12);


                void updateMassSq_m23(const Double_t m23, const Double_t c23);


                void updateMassSq_m13(const Double_t m13, const Double_t c13);


                void updateMassSquares(const Double_t m13Sq, const Double_t m23Sq);


                void updateSqDPMassSquares(const Double_t mPrime, const Double_t thetaPrime);


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


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


                Double_t pCalc(const Double_t energy, const 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 Bool_t symmetricalDP_;
                const Bool_t fullySymmetricDP_;

                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