LauCacheData.hh

Go to the documentation of this file.

 
/*
Copyright 2005 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_CACHE_DATA
#define LAU_CACHE_DATA
 
#include <vector>
 
#include <Rtypes.h>
 
class LauCacheData {
 
  public:
    LauCacheData();
 
    virtual ~LauCacheData();
 
 
    LauCacheData( const LauCacheData& rhs );
 
 
    LauCacheData& operator=( const LauCacheData& rhs );
 
 
    inline void storem13Sq( Double_t m13Sq ) { m13Sq_ = m13Sq; }
 
 
    inline void storem23Sq( Double_t m23Sq ) { m23Sq_ = m23Sq; }
 
 
    inline void storemPrime( Double_t mPrime ) { mPrime_ = mPrime; }
 
 
    inline void storethPrime( Double_t thPrime ) { thPrime_ = thPrime; }
 
 
    inline void storeTagCat( Int_t tagCat ) { tagCat_ = tagCat; }
 
 
    inline void storeEff( Double_t eff ) { eff_ = eff; }
 
 
    inline void storeScfFraction( Double_t scfFraction ) { scfFraction_ = scfFraction; }
 
 
    inline void storeJacobian( Double_t jacobian ) { jacobian_ = jacobian; }
 
 
    inline void storeRealAmp( const std::vector<Double_t>& realAmp ) { realAmp_ = realAmp; }
 
 
    inline void storeImagAmp( const std::vector<Double_t>& imagAmp ) { imagAmp_ = imagAmp; }
 
 
    inline void storeIncohIntensities( const std::vector<Double_t>& incohIntensities )
    {
        incohIntensities_ = incohIntensities;
    }
 
 
    inline Double_t retrievem13Sq() const { return m13Sq_; }
 
 
    inline Double_t retrievem23Sq() const { return m23Sq_; }
 
 
    inline Double_t retrievemPrime() const { return mPrime_; }
 
 
    inline Double_t retrievethPrime() const { return thPrime_; }
 
 
    inline Int_t retrieveTagCat() const { return tagCat_; }
 
 
    inline Double_t retrieveEff() const { return eff_; }
 
 
    inline Double_t retrieveScfFraction() const { return scfFraction_; }
 
 
    inline Double_t retrieveJacobian() const { return jacobian_; }
 
 
    inline const std::vector<Double_t>& retrieveRealAmp() const { return realAmp_; }
 
 
    inline const std::vector<Double_t>& retrieveImagAmp() const { return imagAmp_; }
 
 
    inline const std::vector<Double_t>& retrieveIncohIntensities() const
    {
        return incohIntensities_;
    }
 
 
    inline std::vector<Double_t>& retrieveRealAmp() { return realAmp_; }
 
 
    inline std::vector<Double_t>& retrieveImagAmp() { return imagAmp_; }
 
 
    inline std::vector<Double_t>& retrieveIncohIntensities() { return incohIntensities_; }
 
  protected:
 
  private:
    Double_t m13Sq_;
 
    Double_t m23Sq_;
 
    Double_t mPrime_;
 
    Double_t thPrime_;
 
    Int_t tagCat_;
 
    Double_t eff_;
 
    Double_t scfFraction_;
 
    Double_t jacobian_;
 
    std::vector<Double_t> realAmp_;
 
    std::vector<Double_t> imagAmp_;
 
    std::vector<Double_t> incohIntensities_;
 
    ClassDef( LauCacheData, 0 )    // Cached Data Class
};
 
#endif