SpinAmplitude.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_SpinAmplitude_h
#define yap_SpinAmplitude_h

#include "fwd/SpinAmplitude.h"

#include "fwd/Model.h"
#include "fwd/ParticleCombination.h"
#include "fwd/Spin.h"
#include "fwd/StatusManager.h"

#include "CachedValue.h"
#include "MathUtilities.h"
#include "StaticDataAccessor.h"

#include <array>
#include <complex>
#include <iostream>
#include <memory>

namespace yap {

class SpinAmplitude : public StaticDataAccessor
{
protected:

    SpinAmplitude(Model& m, unsigned two_J, const SpinVector& two_j, unsigned l, unsigned two_s,
                  const ParticleCombinationEqualTo& equal);

public:

    using AmplitudeSubmap = std::map<SpinProjectionVector, std::shared_ptr<ComplexCachedValue> >;

    using AmplitudeMap = std::map<int, AmplitudeSubmap>;

    virtual operator std::string() const;


    const unsigned initialTwoJ() const
    { return InitialTwoJ_; }

    const SpinVector& finalTwoJ() const
    { return FinalTwoJ_; }

    const unsigned L() const
    { return L_; }

    const unsigned twoS() const
    { return TwoS_; }

    const std::set<int> twoM() const;

    const std::set<SpinProjectionVector> twoM(int two_M) const;


    virtual const std::complex<double> calc(int two_M, const SpinProjectionVector& two_m,
                                            const DataPoint& d, const std::shared_ptr<ParticleCombination>& pc) const = 0;

    virtual void calculate(DataPoint& d, StatusManager& sm) const override;

    virtual const std::complex<double> amplitude(const DataPoint& d, const std::shared_ptr<ParticleCombination>& pc,
                                         int two_M, const SpinProjectionVector& two_m) const
    { return Amplitudes_.at(two_M).at(two_m)->value(d, symmetrizationIndex(pc)); }

    bool equalTo(const SpinAmplitude& other) const;

    virtual bool equals(const SpinAmplitude& other) const;

    virtual std::string formalism() const = 0;

    friend class DecayChannel;

protected:

    void addAmplitude(int two_M, const SpinProjectionVector& two_m, bool store_null = false);

private:

    unsigned InitialTwoJ_;

    SpinVector FinalTwoJ_;

    unsigned L_;

    unsigned TwoS_;

    AmplitudeMap Amplitudes_;

    friend bool operator==(const SpinAmplitude& A, const SpinAmplitude& B)
    { return typeid(A) == typeid(B) and A.equals(B); }

};

inline std::string to_string(const SpinAmplitude& sa)
{ return (std::string)sa; }

inline std::ostream& operator<< (std::ostream& os, const SpinAmplitude& sa)
{ os << to_string(sa); return os; }

std::string to_string(const SpinAmplitudeVector& saV);

}

#endif