CachedValue.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef yap_CachedValue_h
#define yap_CachedValue_h

#include "fwd/CachedValue.h"
#include "fwd/CalculationStatus.h"
#include "fwd/FourVector.h"
#include "fwd/Parameter.h"
#include "fwd/ParticleCombination.h"
#include "fwd/StatusManager.h"
#include "fwd/VariableStatus.h"

#include "DataAccessor.h"
#include "DataPoint.h"

#include <complex>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>

namespace yap {

class CachedValue : public std::enable_shared_from_this<CachedValue>
{

protected:

    CachedValue(unsigned size, DataAccessor& da);

public:

    struct Status {

        Status();

        CalculationStatus Calculation;

        VariableStatus Variable;

        Status& operator=(const CalculationStatus& s)
        { Calculation = s; return *this; }

        Status& operator=(const VariableStatus& s);
    };


    DataAccessor* owner() const
    { return Owner_; }

    const int index() const
    { return Index_; }

    inline const double value(unsigned index, const DataPoint& d, unsigned sym_index) const
    { return d.Data_[Owner_->index()][sym_index][Position_ + index]; }

    virtual const unsigned size() const
    { return Size_; }



    void setValue(unsigned index, double val, DataPoint& d, unsigned sym_index) const
    { d.Data_[Owner_->index()][sym_index][Position_ + index] = val; }


    friend class DataAccessor;

protected:

    void addToDataAccessor();

    void setIndex(int i)
    { Index_ = i; }

    void setPosition(int p)
    { Position_ = p; }

private:

    DataAccessor* Owner_;

    int Index_;

    int Position_;

    unsigned Size_;

};

inline bool operator==(const CachedValue::Status& S, const CalculationStatus& s)
{ return S.Calculation == s; }

inline bool operator!=(const CachedValue::Status& S, const CalculationStatus& s)
{ return S.Calculation != s; }

inline bool operator==(const CachedValue::Status& S, const VariableStatus& s)
{ return S.Variable == s; }

inline bool operator!=(const CachedValue::Status& S, const VariableStatus& s)
{ return S.Variable != s; }

std::string to_string(const CachedValue::Status& S);

class RealCachedValue : public CachedValue
{
private:

    RealCachedValue(DataAccessor& da) : CachedValue(1, da) {}

public:

    static std::shared_ptr<RealCachedValue> create(DataAccessor& da);

    void setValue(double val, DataPoint& d, unsigned sym_index, StatusManager& sm) const;

    void setValue(double val, DataPoint& d, unsigned sym_index) const
    { CachedValue::setValue(0, val, d, sym_index); }

    const double value(const DataPoint& d, unsigned sym_index) const
    { return CachedValue::value(0, d, sym_index); }

};

class ComplexCachedValue : public CachedValue
{
private:

    ComplexCachedValue(DataAccessor& da) : CachedValue(2, da) {}

public:

    static std::shared_ptr<ComplexCachedValue> create(DataAccessor& da);

    void setValue(const std::complex<double>& val, DataPoint& d, unsigned sym_index, StatusManager& sm) const
    { setValue(real(val), imag(val), d, sym_index, sm); }

    void setValue(double val_re, double val_im, DataPoint& d, unsigned sym_index, StatusManager& sm) const;

    void setValue(const std::complex<double>& val, DataPoint& d, unsigned sym_index) const
    { setValue(real(val), imag(val), d, sym_index); }

    void setValue(double val_re, double val_im, DataPoint& d, unsigned sym_index) const
    { CachedValue::setValue(0, val_re, d, sym_index); CachedValue::setValue(1, val_im, d, sym_index); }

    const std::complex<double> value(const DataPoint& d, unsigned  sym_index) const
    { return std::complex<double>(CachedValue::value(0, d, sym_index), CachedValue::value(1, d, sym_index)); }

};

class FourVectorCachedValue : public CachedValue
{
private:

    FourVectorCachedValue(DataAccessor& da) : CachedValue(4, da) {}

public:

    static std::shared_ptr<FourVectorCachedValue> create(DataAccessor& da);

    void setValue(const FourVector<double>& val, DataPoint& d, unsigned sym_index, StatusManager& sm) const;

    void setValue(const FourVector<double>& val, DataPoint& d, unsigned sym_index) const;

    const FourVector<double> value(const DataPoint& d, unsigned  sym_index) const;

};

}

#endif