LauDPPartialIntegralInfo.hh

Go to the documentation of this file.

 
/*
Copyright 2014 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_DPPARTIALINTEGRAL_INFO
#define LAU_DPPARTIALINTEGRAL_INFO
 
#include "LauComplex.hh"
 
#include "TString.h"
 
#include <iosfwd>
 
class LauKinematics;
 
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,
                              const Bool_t squareDP           = kFALSE,
                              const LauKinematics* kinematics = 0 );
 
    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 Bool_t getSquareDP() const { return squareDP_; }
 
 
    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_;
 
    const Bool_t squareDP_;
 
    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