AmplitudeBasis.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_AmplitudeBasis_h
#define yap_AmplitudeBasis_h

#include "fwd/AmplitudeBasis.h"

#include "ComplexBasis.h"

#include "Exceptions.h"
#include "Matrix.h"
#include "Vector.h"

#include <complex>

namespace yap {

namespace amplitude_basis {

template <typename T>
using covariance_matrix = SquareMatrix<complex_basis::covariance_matrix<T>, 3>;

template <typename T>
class basis {

protected:
    basis(Vector<std::complex<T>, 3> c,
            covariance_matrix<T> cov = covariance_matrix<T>()) :
        Amplitudes_(c), Covariance_(cov)
    {}

    // conversion constructor
    explicit basis(const basis<T>& other, const SquareMatrix<T, 3>& jacobian) :
        Amplitudes_(jacobian * other.Amplitudes_),
        Covariance_(jacobian * other.Covariance_ * transpose(jacobian))
    {}

public:
    const Vector<std::complex<T>, 3>& coordinates() const
    { return Amplitudes_; }

    const covariance_matrix<T>& covariance() const
    { return Covariance_; }

private:
    Vector<std::complex<T>, 3> Amplitudes_;
    covariance_matrix<T> Covariance_;
};

template <typename T>
class canonical : public basis<T> {

public:
    explicit canonical(const std::complex<T>& c1, const std::complex<T>& c2, const std::complex<T>& c3,
            covariance_matrix<T> cov = covariance_matrix<T>()) :
        basis<T>(Vector<std::complex<T>, 3>({c1, c2, c3}), cov)
    {}

    explicit canonical(Vector<std::complex<T>, 3> c,
            covariance_matrix<T> cov = covariance_matrix<T>()) :
        basis<T>(c, cov)
    {}

    explicit canonical(const covariance_matrix<T>& cov) :
        basis<T>(Vector<std::complex<T>, 3>({0, 0, 0}), cov)
    {}

    canonical(const complex_basis::cartesian<T>& c1, const complex_basis::cartesian<T>& c2, const complex_basis::cartesian<T>& c3) :
        basis<T>(Vector<std::complex<T>, 3>({c1, c2, c3}),
                 diagonalMatrix<complex_basis::covariance_matrix<T>, 3>({c1.covariance(), c2.covariance(), c3.covariance()}))
    {}

    explicit constexpr canonical(const transversity<T>& t) :
        basis<T>(t, jacobian_from_transversity)
    {}

    explicit constexpr canonical(const helicity<T>& h) :
        basis<T>(h, jacobian_from_helicity)
    {}

    const std::complex<T> s() const
    { return basis<T>::coordinates()[0]; }

    const std::complex<T> p() const
    { return basis<T>::coordinates()[1]; }

    const std::complex<T> d() const
    { return basis<T>::coordinates()[2]; }

    const std::complex<T> operator[] (size_t l) const
    {
        switch (l) {
            case 0:
                return s();
            case 1:
                return p();
            case 2:
                return d();
            default :
                throw exceptions::Exception("l must be 0, 1, or 2", "canonical::operator[]");
        }
    }

private:

    // transformation matrix (jacobian) from transversity to canonical
    static const SquareMatrix<T, 3> jacobian_from_transversity;

    // transformation matrix (jacobian) from helicity to canonical
    static const SquareMatrix<T, 3> jacobian_from_helicity;
};

template <typename T>
class transversity : public basis<T> {

public:
    explicit transversity(const std::complex<T>& c1, const std::complex<T>& c2, const std::complex<T>& c3,
            covariance_matrix<T> cov = covariance_matrix<T>()) :
        basis<T>(Vector<std::complex<T>, 3>({c1, c2, c3}), cov)
    {}

    explicit transversity(Vector<std::complex<T>, 3> c,
            covariance_matrix<T> cov = covariance_matrix<T>()) :
        basis<T>(c, cov)
    {}

    explicit transversity(const covariance_matrix<T>& cov) :
        basis<T>(Vector<std::complex<T>, 3>({0, 0, 0}), cov)
    {}

    transversity(const complex_basis::cartesian<T>& c1, const complex_basis::cartesian<T>& c2, const complex_basis::cartesian<T>& c3) :
        basis<T>(Vector<std::complex<T>, 3>({c1, c2, c3}),
                 diagonalMatrix<complex_basis::covariance_matrix<T>, 3>({c1.covariance(), c2.covariance(), c3.covariance()}))
    {}

    explicit constexpr transversity(const canonical<T>& c) :
        basis<T>(c, jacobian_from_canonical)
    {}

    explicit constexpr transversity(const helicity<T>& h) :
        basis<T>(h, jacobian_from_helicity)
    {}

    const std::complex<T> longitudinal() const
    { return basis<T>::coordinates()[0]; }

    const std::complex<T> parallel() const
    { return basis<T>::coordinates()[1]; }

    const std::complex<T> perpendicular() const
    { return basis<T>::coordinates()[2]; }

private:

    // transformation matrix (jacobian) from canonical to transversity
    static const SquareMatrix<T, 3> jacobian_from_canonical;

    // transformation matrix (jacobian) from helicity to transversity
    static const SquareMatrix<T, 3> jacobian_from_helicity;
};


template <typename T>
class helicity : public basis<T> {

public:
    explicit helicity(const std::complex<T>& c1, const std::complex<T>& c2, const std::complex<T>& c3,
            covariance_matrix<T> cov = covariance_matrix<T>()) :
        basis<T>(Vector<std::complex<T>, 3>({c1, c2, c3}), cov)
    {}

    explicit helicity(Vector<std::complex<T>, 3> c,
            covariance_matrix<T> cov = covariance_matrix<T>()) :
        basis<T>(c, cov)
    {}

    explicit helicity(const covariance_matrix<T>& cov) :
        basis<T>(Vector<std::complex<T>, 3>({0, 0, 0}), cov)
    {}

    helicity(const complex_basis::cartesian<T>& c1, const complex_basis::cartesian<T>& c2, const complex_basis::cartesian<T>& c3) :
        basis<T>(Vector<std::complex<T>, 3>({c1, c2, c3}),
                 diagonalMatrix<complex_basis::covariance_matrix<T>, 3>({c1.covariance(), c2.covariance(), c3.covariance()}))
    {}

    explicit constexpr helicity(const canonical<T>& c) :
        basis<T>(c, jacobian_from_canonical)
    {}

    explicit constexpr helicity(const transversity<T>& t) :
        basis<T>(t, jacobian_from_transversity)
    {}

    const std::complex<T> zero() const
    { return basis<T>::coordinates()[0]; }

    const std::complex<T> plus() const
    { return basis<T>::coordinates()[1]; }

    const std::complex<T> minus() const
    { return basis<T>::coordinates()[2]; }

private:

    // transformation matrix (jacobian) from canonical to helicity
    static const SquareMatrix<T, 3> jacobian_from_canonical;

    // transformation matrix (jacobian) from transversity to helicity
    static const SquareMatrix<T, 3> jacobian_from_transversity;
};



template <typename T>
const SquareMatrix<T, 3> canonical<T>::jacobian_from_transversity(
      //  longitudinal parallel     perpendicular
        {-sqrt(1./3.), sqrt(2./3.), 0,     // S
          0,           0,           1,     // P
          sqrt(2./3.), sqrt(1./3.), 0});   // D

template <typename T>
const SquareMatrix<T, 3> canonical<T>::jacobian_from_helicity(
      //  zero         plus          minus
        {-sqrt(1./3.), sqrt(1./3.),  sqrt(1./3.),    // S
          0,           sqrt(0.5),   -sqrt(0.5)  ,    // P
          sqrt(2./3.), sqrt(1./6.),  sqrt(1./6.)});  // D

template <typename T>
const SquareMatrix<T, 3> transversity<T>::jacobian_from_canonical(
      //  S              P  D
        {-sqrt(1. / 3.), 0, sqrt(2. / 3.),   // longitudinal
          sqrt(2. / 3.), 0, sqrt(1. / 3.),   // parallel
          0,             1, 0            }); // perpendicular

template <typename T>
const SquareMatrix<T, 3> transversity<T>::jacobian_from_helicity(
      // zero plus        minus
        {1,   0,          0        ,    // longitudinal
         0,   sqrt(0.5),  sqrt(0.5),    // parallel
         0,   sqrt(0.5), -sqrt(0.5)});  // perpendicular

template <typename T>
const SquareMatrix<T, 3> helicity<T>::jacobian_from_canonical(
      //  S             P          D
        {-sqrt(1./3.),  0,         sqrt(2./3.),    // zero
          sqrt(1./3.),  sqrt(0.5), sqrt(1./6.),    // plus
          sqrt(1./3.), -sqrt(0.5), sqrt(1./6.)});  // minus

template <typename T>
const SquareMatrix<T, 3> helicity<T>::jacobian_from_transversity(
      // longitudinal parallel    perpendicular
        {1,           0,          0        ,    // zero
         0,           sqrt(0.5),  sqrt(0.5),    // plus
         0,           sqrt(0.5), -sqrt(0.5)});  // minus
}

}

#endif