spectrum.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY 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.
// 
// MARTY 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 MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef SPECTRUM_H_INCLUDED
#define SPECTRUM_H_INCLUDED

#include "csl.h"
#include "lagrangian.h"
#include "matrix.h"

namespace mty {

class Particle;
struct MassBlock;

class Spectrum {

public:

    template<class T>
        using matrix    = boost::numeric::ublas::matrix<T>;

    template<class T>
        using id_matrix = boost::numeric::ublas::identity_matrix<T>;
    using FloatType = double;

    struct MatrixEl {
        size_t i;
        size_t j;
        csl::Expr   term;
    };

    Spectrum(
            std::vector<mty::Particle>     const &t_particles,
            std::vector<mty::Particle>     const &t_newParticles,
            std::vector<csl::Expr>              const &terms,
            std::vector<std::vector<csl::Expr>> const &t_mixing
            );

    Spectrum(
            std::vector<mty::Particle>     const &t_newParticles,
            std::vector<std::vector<csl::Expr>> const &t_mass,
            std::vector<std::vector<csl::Expr>> const &t_mixing,
            std::vector<std::vector<csl::Expr>> const &t_mixing2
                = std::vector<std::vector<csl::Expr>>()
            );

    Spectrum(
            std::vector<mty::Particle> const &partA,
            std::vector<mty::Particle> const &partB,
            std::vector<mty::Particle> const &newPartA,
            std::vector<mty::Particle> const &newPartB,
            std::vector<csl::Expr>          const &terms,
            std::vector<std::vector<csl::Expr>> const &mixingA,
            std::vector<std::vector<csl::Expr>> const &mixingB
            );

    Spectrum()  = default;
    ~Spectrum() = default;

    Spectrum(Spectrum const &) = default;
    Spectrum(Spectrum &&)      = default;
    Spectrum &operator=(Spectrum const &) = default;
    Spectrum &operator=(Spectrum &&)      = default;

    std::vector<mty::Particle> const &getParticles() const {
        return newFields;
    }

    matrix<csl::Expr> const &getMassTerms() const {
        return mass;
    }

    matrix<csl::Expr> const &getMixings() const {
        return mixing;
    }

    matrix<csl::Expr> const &getMixings2() const {
        return mixing2;
    }

    bool getReplaceMasses() const {
        return replaceMasses;
    }
    bool getReplaceMixings() const {
        return replaceMixings;
    }

    void setReplaceMasses(bool t_replaceMasses) {
        replaceMasses = t_replaceMasses;
    }
    void setReplaceMixings(bool t_replaceMixings) {
        replaceMasses = t_replaceMixings;
    }

    bool isDiagonalized() const;

    void setBlock(
            std::vector<csl::Expr>              const &terms,
            std::vector<std::vector<csl::Expr>> const &t_mixing
            );

    void setBlock(
            std::vector<csl::Expr>              const &terms,
            std::vector<std::vector<csl::Expr>> const &mixingA,
            std::vector<std::vector<csl::Expr>> const &mixingB
            );
    void updateData();
    void applyOn(csl::Expr &expr) const;
    void applyOn(std::vector<csl::Expr> &expr) const;

protected:

    size_t getFieldPos(QuantumField const &field) const;

    MatrixEl getMassFromTerm(
            csl::Expr const &term
            ) const;

    static
    void replace(
            csl::Expr                    &expr, 
            std::vector<csl::Expr> const &oldExpr,
            std::vector<csl::Expr> const &newExpr
            );

    void addMassTerm(MatrixEl &&matrixEl);

    void diagonalize();

    void bidiagonalize();

    void applyDiagonalizationOn(csl::Expr &expr) const;

    void applyBidiagonalizationOn(csl::Expr &expr) const;

protected:

    bool bidiagonalization;
    bool replaceMasses;
    bool replaceMixings;
    std::vector<mty::Particle> fields;
    std::vector<mty::Particle> newFields;
    matrix<csl::Expr>               mass;
    matrix<csl::Expr>               mixing;
    matrix<csl::Expr>               mixing2;
    csl::Expr                       massData;
    csl::Expr                       diagonal = nullptr;
    csl::Expr                       transfer = nullptr;
    csl::Expr                       transfer2 = nullptr;
};

} // End of namespace mty

#endif