LauDPPartialIntegralInfo.hh

Go to the documentation of this file.

// Copyright University of Warwick 2014.
// 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_DPPARTIALINTEGRAL_INFO
#define LAU_DPPARTIALINTEGRAL_INFO

#include <iosfwd>

#include "TString.h"

#include "LauComplex.hh"


class LauDPPartialIntegralInfo {

        public:

                LauDPPartialIntegralInfo(const Double_t minm13, const Double_t maxm13,
                                         const Double_t minm23, const Double_t maxm23,
                                         const Double_t m13BinWidth, const Double_t m23BinWidth,
                                         const Double_t precision,
                                         const UInt_t nAmp,
                                         const UInt_t nIncohAmp);

                virtual ~LauDPPartialIntegralInfo();


                inline Double_t getMinm13() const {return minm13_;}


                inline Double_t getMaxm13() const {return maxm13_;}


                inline Double_t getMinm23() const {return minm23_;}


                inline Double_t getMaxm23() const {return maxm23_;}


                inline Double_t getM13BinWidth() const {return m13BinWidth_;}


                inline Double_t getM23BinWidth() const {return m23BinWidth_;}


                inline UInt_t getnm13Points() const {return nm13Points_;}


                inline UInt_t getnm23Points() const {return nm23Points_;}


                inline Double_t getWeight(const UInt_t m13Point, const UInt_t m23Point) const {return weights_[m13Point][m23Point];}


                inline Double_t getM13Value(const UInt_t m13Point) const {return m13Points_[m13Point];}


                inline Double_t getM23Value(const UInt_t m23Point) const {return m23Points_[m23Point];}


                inline Double_t getEfficiency(const UInt_t m13Point, const UInt_t m23Point) const { return efficiencies_[m13Point][m23Point]; }


                inline void storeEfficiency(const UInt_t m13Point, const UInt_t m23Point, const Double_t efficiency) { efficiencies_[m13Point][m23Point] = efficiency; }


                inline const LauComplex& getAmplitude(const UInt_t m13Point, const UInt_t m23Point, const UInt_t iAmp) const { return amplitudes_[m13Point][m23Point][iAmp]; }


                inline void storeAmplitude(const UInt_t m13Point, const UInt_t m23Point, const UInt_t iAmp, const LauComplex& amplitude) { amplitudes_[m13Point][m23Point][iAmp] = amplitude; }


                inline Double_t getIntensity(const UInt_t m13Point, const UInt_t m23Point, const UInt_t iAmp) const { return incohIntensities_[m13Point][m23Point][iAmp]; }


                inline void storeIntensity(const UInt_t m13Point, const UInt_t m23Point, const UInt_t iAmp, const Double_t intensity) { incohIntensities_[m13Point][m23Point][iAmp] = intensity; }

        private:
                LauDPPartialIntegralInfo( const LauDPPartialIntegralInfo& other );

                LauDPPartialIntegralInfo& operator=( const LauDPPartialIntegralInfo& other );

                const Double_t minm13_;

                const Double_t maxm13_;

                const Double_t minm23_;

                const Double_t maxm23_;

                const Double_t m13BinWidth_;

                const Double_t m23BinWidth_;

                const UInt_t nm13Points_;

                const UInt_t nm23Points_;

                const UInt_t nAmp_;

                const UInt_t nIncohAmp_;

                std::vector<Double_t> m13Points_;

                std::vector<Double_t> m23Points_;

                std::vector<Double_t> m13Weights_;

                std::vector<Double_t> m23Weights_;

                std::vector< std::vector<Double_t> > weights_;

                std::vector< std::vector<Double_t> > efficiencies_;

                std::vector< std::vector< std::vector<LauComplex> > > amplitudes_;

                std::vector< std::vector< std::vector<Double_t> > > incohIntensities_;

                ClassDef(LauDPPartialIntegralInfo, 0)
};

std::ostream& operator<<( std::ostream& stream, const LauDPPartialIntegralInfo& infoRecord );

#endif