modelData.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 MODEL_DATA_H_INCLUDED
#define MODEL_DATA_H_INCLUDED 

#include <type_traits>
#include <csl.h>
#include "quantumField.h"
#include "lagrangian.h"

namespace mty {

class ModelData {

public:

    // Public (static) data members

    inline static size_t            nMomentums           = 10;
    inline static csl::Space const *defaultSpaceTime     = &csl::Minkowski;
    inline static int               defaultQuantumNumber = 1;

public:

    // Constructors

    ModelData();
    explicit ModelData(std::unique_ptr<Gauge> &&t_gauge);
    ModelData(
            std::unique_ptr<Gauge>  &&t_gauge,
            std::unique_ptr<Flavor> &&t_flavor
            );
    ModelData(
            std::unique_ptr<Gauge>  &&t_gauge,
            std::unique_ptr<Flavor> &&t_flavor,
            std::vector<Particle>    &t_particles);
    ModelData(std::string const& nameFile);

    virtual ~ModelData();

    ModelData(ModelData &&other) = default;
    ModelData &operator=(ModelData &&other) = default;
    ModelData(ModelData const &other) = delete;
    ModelData &operator=(ModelData const &other) = delete;

    // Initialization function

    void init(bool initGaugeTerms = true);

    // Check functions

    void checkHermiticity();

    // Write function

    virtual void saveModel(
            std::ostream    &out,
            int              indent = 4
            );

    void saveModelFunction(
            std::string_view name,
            std::ostream    &out,
            int              indent = 0
            );

    void saveModelFunctionWithRef(
            std::string_view name,
            std::ostream    &out,
            int              indent = 0
            );

    void saveModelFile(
            std::string_view   name,
            std::string const &fileName
            );

    // Getters

    Lagrangian const &getLagrangian() const;

    bool isEnableChecks() const {
        return enableChecks;
    }

    void setEnableChecks(bool t_enable) {
        enableChecks = t_enable;
    }

    csl::Space const *getSpaceTime() const;

    mty::Gauge *getGauge() const;

    mty::Flavor *getFlavor() const;

    std::vector<mty::Particle> const &getParticles() const;

    std::vector<mty::Particle> getPhysicalParticles(
            std::function<bool(mty::Particle)> const &predicate
                = [](mty::Particle) { return true; }
            ) const;

    std::vector<mty::QuantumNumber> const &getQuantumNumbers() const;
    std::vector<mty::QuantumNumber> &getQuantumNumbers();

    std::vector<csl::Expr> const &getScalarCouplings() const;

    std::vector<csl::Tensor> const &getTensorCouplings() const;

    // Setters

    void setSpaceTime(csl::Space const *t_spaceTime);

    void setGauge(std::unique_ptr<mty::Gauge> &&t_gauge);


    void addGaugedGroup(
            group::Type      type,
            std::string_view name,
            int              dim,
            csl::Expr      const& coupling = nullptr);

    void addGaugedGroup(
            group::Type      type,
            std::string_view name,
            csl::Expr      const& coupling = nullptr);
    
    void addFlavorGroup(
            std::string_view name,
            int              nFlavor,
            bool             complexFields = true);

    void setFlavor(std::unique_ptr<mty::Flavor> &&t_flavor);

    void addParticle(
            mty::Particle const &part,
            bool                 initializeTerms = true);
    void addParticles(
            std::vector<mty::Particle> const &parts,
            bool                              initializeTerms = true);

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

    void removeParticle(mty::Particle const &part);

    void removeParticles(std::vector<mty::Particle> const &parts);

    void removeParticle(std::string const &part);

    void removeParticles(std::vector<std::string> const &parts);

    void addScalarCoupling(std::string_view t_name);
    void addScalarCoupling(csl::Expr const &coupling);

    void addTensorCoupling(csl::Parent const &tensorCoupling);

    void addQuantumNumber(
            std::string_view                  name,
            std::vector<mty::Particle> const& fields,
            std::vector<int>           const& values,
            bool                              conserved = true
            );
    template<class FieldType>
        void addQuantumNumber(
                std::string_view              name,
                std::vector<FieldType> const& fields,
                std::vector<int>       const& values,
                bool                          conserved = true
                );
    template<class FieldType>
        void addQuantumNumber(
                std::string_view                 name,
                std::initializer_list<FieldType> fields,
                std::vector<int>          const &values,
                bool                             conserved = true
                );

    void setQuantumNumbers(
            std::vector<mty::QuantumNumber> const &numbers
            );
        

    // Content

    bool findParticle(std::string_view t_name) const;
    bool findParticle(mty::Particle const &part) const;
    bool findParticle(mty::QuantumFieldParent const *part) const;

    bool findScalarCoupling(std::string_view t_name) const;
    bool findScalarCoupling(csl::Expr const &coupling) const;

    bool findTensorCoupling(std::string_view t_name) const;
    bool findTensorCoupling(csl::Parent const &coupling) const;
    bool findTensorCoupling(csl::AbstractParent const *coupling) const;

    // Finders

    mty::Group const *getGroup(std::string_view t_name) const;
    mty::Group *getGroup(std::string_view t_name);

    mty::Group const *getGroup(mty::FlavorGroup const *flavGroup) const;
    mty::Group *getGroup(mty::FlavorGroup const *flavGroup);
    mty::GaugedGroup const *getGaugedGroup(std::string_view t_name) const;
    mty::GaugedGroup *getGaugedGroup(std::string_view t_name);

    mty::FlavorGroup const *getFlavorGroup(std::string_view t_name) const;
    mty::FlavorGroup *getFlavorGroup(std::string_view t_name);

    std::vector<mty::Particle> getParticles(
            std::initializer_list<std::string_view> names
            ) const;
    mty::Particle getParticle(std::string_view t_name) const;
    mty::Particle getParticle(mty::QuantumFieldParent const *field) const;
    mty::Particle getParticle(mty::QuantumFieldParent const &field) const;
    mty::Particle getParticle(mty::QuantumField const &field) const;
    mty::Particle getParticle(csl::Expr const &field) const;

    csl::Expr getScalarCoupling(std::string_view t_name) const;

    csl::Tensor getTensorCoupling(std::string_view t_name) const;
    csl::Tensor getTensorCoupling(csl::Parent const &t_coupling) const;

    template<class FieldType>
        mty::GaugeIrrep getGaugeIrrep(FieldType &&field) const;

    template< class GroupType, class FieldType >
        mty::Irrep getGroupIrrep(
                FieldType &&field,
                GroupType &&group
                ) const;

    template< class GroupType, class FieldType >
        csl::Expr getCharge(
                FieldType &&field,
                GroupType &&group
                ) const;

    template<class FieldType>
        mty::FlavorIrrep getFlavorIrrep(FieldType &&field) const ;

    template< class FlavorType, class FieldType >
        mty::Irrep getFlavorIrrep(
                FieldType  &&field,
                FlavorType &&flavor
                ) const;

    template< class GroupType, class FieldType >
        csl::Space const *getVectorSpace(
                GroupType &&group,
                FieldType &&field
                ) const;
        

    template< class GroupType, class FieldType >
        csl::Index generateIndex(
                GroupType &&group,
                FieldType &&field
                ) const;

    template< class GroupType >
        csl::Index generateIndex(
                GroupType &&group
                ) const;

    template< class GroupType, class FieldType >
        std::vector<csl::Index> generateIndices(
                size_t      nIndices,
                GroupType &&group,
                FieldType &&field
                ) const;

    template< class GroupType >
        std::vector<csl::Index> generateIndices(
                size_t      nIndices,
                GroupType &&group
                ) const;

        
    template< class GroupType, class FieldType >
        csl::Index generateIndex(
                std::string_view nameIndex,
                GroupType      &&group,
                FieldType      &&field
                ) const;
        
    template< class GroupType, class FieldType >
        mty::Generator getGenerator(
                GroupType &&group,
                FieldType &&field
                ) const;
    
    mty::QuantumNumber const &getQuantumNumber(std::string_view name) const;
    mty::QuantumNumber &getQuantumNumber(std::string_view name);

    // Model building

    void checkValidity(mty::Particle const &part) const;

    void checkValidity(mty::Lagrangian::TermType const &term) const;

    void addLagrangianTerm(
            csl::Expr const &term,
            bool        addHermitic = false);
    void addLagrangianTerm(
            mty::Lagrangian::TermType const &term,
            bool                             addHermitic = false);

    template<class FieldType>
        void addBosonicMass(
                FieldType      &&field,
                std::string_view mass
                );
    template<class FieldType>
        void addBosonicMass(
                FieldType      &&field,
                csl::Expr      const &mass
                );

    template<class FieldType1, class FieldType2>
        void addFermionicMass(
                FieldType1     &&left,
                FieldType2     &&right,
                std::string_view mass
                );
    template<class FieldType1, class FieldType2>
        void addFermionicMass(
                FieldType1 &&left,
                FieldType2 &&right,
                csl::Expr const &mass
                );
    template<class FieldType>
        void addFermionicMass(
                FieldType      &&diracFermion,
                std::string_view mass
                );
    template<class FieldType>
        void addFermionicMass(
                FieldType &&diracFermion,
                csl::Expr const &mass
                );

    template<class FieldType>
    void renameParticle(
            FieldType      &&field,
            std::string_view newName
            );

    void renameCoupling(
            std::string_view name,
            std::string_view newName
            );

    // Display

    void printSubPart(
            std::vector<std::string> const &particles,
            std::ostream &out = std::cout
            ) const;
    void printSubPart(
            std::initializer_list<std::string> particles,
            std::ostream &out = std::cout
            ) const;
    void printSubPart(
            std::string const &particle,
            std::ostream &out = std::cout
            ) const;

    friend std::ostream &operator<<(
            std::ostream    &out,
            ModelData const &model);

protected:

    // Protected member functions

    // Init functions

    void initGaugedGroups(bool initGaugeTerms = true);

    // Write functions

    void writeHeader(
            std::ostream &out,
            int           indentSize,
            std::vector<csl::Parent> &defined
            );
    void writeGauge(
            std::ostream &out,
            int           indentSize,
            std::vector<csl::Parent> &defined
            );
    void writeFlavor(
            std::ostream &out,
            int           indentSize,
            std::vector<csl::Parent> &defined
            );
    void writeMassAndWidth(
            std::ostream &out,
            int           indentSize,
            std::vector<csl::Parent> &defined
            );
    void writeParticles(
            std::ostream &out,
            int           indentSize,
            std::vector<csl::Parent> &defined
            );
    void writeDependencies(
            std::ostream &out,
            int           indentSize,
            std::vector<csl::Parent> &defined,
            std::vector<csl::Expr> &kinetic,
            std::vector<csl::Expr> &mass,
            std::vector<csl::Expr> &interac
            );
    void writeLagrangian(
            std::ostream &out,
            int           indentSize,
            std::vector<csl::Expr> const &kinetic,
            std::vector<csl::Expr> const &mass,
            std::vector<csl::Expr> const &interac
            );

    // Helper functions for template overloads

    mty::GaugeIrrep doGetGaugeIrrep(mty::Particle const &part) const;
    mty::Irrep doGetGroupIrrep(
            mty::Particle   const &part,
            mty::Group      const *group
            ) const;
    csl::Expr doGetCharge(
            mty::Particle const &particle,
            mty::Group    const *group
            ) const;

    mty::FlavorIrrep doGetFlavorIrrep(mty::Particle const &part) const;
    mty::Irrep doGetFlavorIrrep(
            mty::Particle    const &part,
            mty::Group       const *flavor
            ) const;

    csl::Space const *doGetVectorSpace(
            mty::Group    const *group,
            mty::Particle const &irrep
            ) const; 

    csl::Space const *doGetVectorSpace(
            mty::FlavorGroup const *group,
            mty::Particle    const &irrep
            ) const; 

    csl::Index doGenerateIndex(
            mty::Group    const *group,
            mty::Particle const &fieldRep
            ) const;

    csl::Index doGenerateIndex(
            mty::Group    const *group
            ) const;
    csl::Index doGenerateIndex(
            std::string_view     nameIndex,
            mty::Group    const *group,
            mty::Particle const &fieldRep
            ) const;

    mty::Generator doGetGenerator(
            mty::Group    const *group,
            mty::Particle const &fieldRep
            ) const;

    /*
     * @brief Actually adds a bosonic mass term to the Lagrangian.
     *
     * @param particle Particle in the mass term.
     * @param mass     Name of the mass for the particle.
     *
     * @sa addBosonicMass()
     */
    void doAddBosonicMass(
            mty::Particle const &particle,
            std::string_view     mass
            );
    /*
     * @brief Actually adds a bosonic mass term to the Lagrangian.
     *
     * @param particle Particle in the mass term.
     * @param mass     Mass of the particle.
     *
     * @sa addBosonicMass()
     */
    void doAddBosonicMass(
            mty::Particle const &particle,
            csl::Expr          const &mass
            );

    /*
     * @brief Actually adds a fermionic mass term to the Lagrangian.
     *
     * @param left  Left-handed Weyl fermion.
     * @param right Right-handed Weyl fermion.
     * @param mass  Name of the mass for the particle.
     *
     * @sa addFermionicMass()
     */
    void doAddFermionicMass(
            mty::Particle const &left,
            mty::Particle const &right,
            std::string_view     mass
            );
    /*
     * @brief Actually adds a fermionic mass term to the Lagrangian.
     *
     * @param left  Left-handed Weyl fermion.
     * @param right Right-handed Weyl fermion.
     * @param mass  Mass of the particle.
     *
     * @sa addFermionicMass()
     */
    void doAddFermionicMass(
            mty::Particle const &left,
            mty::Particle const &right,
            csl::Expr          const &mass
            );
    /*
     * @brief Actually adds a fermionic mass term to the Lagrangian.
     *
     * @param diracFermion Dirac fermion.
     * @param mass         Name of the mass for the particle.
     *
     * @sa addFermionicMass()
     */
    void doAddFermionicMass(
            mty::Particle const &diracFermion,
            std::string_view     mass
            );
    /*
     * @brief Actually adds a fermionic mass term to the Lagrangian.
     *
     * @param diracFermion Dirac fermion.
     * @param mass         Mass of the particle.
     *
     * @sa addFermionicMass()
     */
    void doAddFermionicMass(
            mty::Particle const &diracFermion,
            csl::Expr          const &mass
            );

    void doRenameParticle(
            mty::Particle const &part,
            std::string_view     newName
            );
   
protected:

    mty::Lagrangian                 L;

    csl::Space const               *spaceTime;

    std::unique_ptr<mty::Gauge>     gauge;

    std::unique_ptr<mty::Flavor>    flavor;

    std::vector<mty::Particle>      particles;

    std::vector<mty::QuantumNumber> quantumNumbers;

    std::vector<csl::Expr>               scalarCouplings;

    std::vector<csl::Tensor>        tensorCouplings;

    bool gaugeLocked = false;

    bool enableChecks = true;
};


// Template functions for ModelData setters

template<class FieldType>
    void ModelData::addQuantumNumber(
            std::string_view              name,
            std::vector<FieldType> const& fields,
            std::vector<int>       const& values,
            bool                          conserved
            )
    {
        std::vector<mty::Particle> parts;
        parts.reserve(fields.size());
        for (FieldType const &f : fields)
            parts.push_back(getParticle(f));
        addQuantumNumber(name, parts, values, conserved);
    }
template<class FieldType>
    void ModelData::addQuantumNumber(
            std::string_view                 name,
            std::initializer_list<FieldType> fields,
            std::vector<int>          const &values,
            bool                             conserved
            )
    {
        addQuantumNumber(
                name, 
                std::vector<FieldType>(fields),
                values, 
                conserved);
    }

// Template functions for ModelData finders


template<class FieldType>
    mty::GaugeIrrep ModelData::getGaugeIrrep(FieldType &&field) const 
    {
        constexpr bool field_valid =
            std::is_convertible<FieldType, mty::Particle const&>::value;

        if constexpr(field_valid)
            return doGetGaugeIrrep(field);
        else
            return getGaugeIrrep(
                    getParticle(std::forward<FieldType>(field)));
    }

template< class GroupType, class FieldType >
    csl::Expr ModelData::getCharge(
            FieldType &&field,
            GroupType &&group
            ) const
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        constexpr bool group_valid = 
            std::is_convertible<
                GroupType, 
                mty::Group const*>::value;

        if constexpr(group_valid) {
            if constexpr(field_valid) 
                return doGetCharge(field, group);
            else
                return getCharge(
                        getParticle(std::forward<FieldType>(field)), 
                        group);
        }
        else if constexpr (field_valid)
            return getCharge(
                    field, 
                    getGroup(std::forward<GroupType>(group)));
        else 
            return getCharge(
                    getParticle(std::forward<FieldType>(field)), 
                    getGroup(std::forward<GroupType>(group)));
    }

template< class GroupType, class FieldType >
    mty::Irrep ModelData::getGroupIrrep(
            FieldType &&field,
            GroupType &&group
            ) const
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        constexpr bool group_valid = 
            std::is_convertible<
                GroupType, 
                mty::Group const*>::value;

        if constexpr(group_valid) {
            if constexpr(field_valid) 
                return doGetGroupIrrep(field, group);
            else
                return getGroupIrrep(
                        getParticle(std::forward<FieldType>(field)), 
                        group);
        }
        else if constexpr (field_valid)
            return getGroupIrrep(
                    field, 
                    getGroup(std::forward<GroupType>(group)));
        else 
            return getGroupIrrep(
                    getParticle(std::forward<FieldType>(field)), 
                    getGroup(std::forward<GroupType>(group)));
    }

template<class FieldType>
    mty::FlavorIrrep ModelData::getFlavorIrrep(FieldType &&field) const 
    {
        constexpr bool field_valid =
            std::is_convertible<FieldType, mty::Particle const&>::value;

        if constexpr(field_valid)
            return doGetFlavorIrrep(field);
        else
            return getFlavorIrrep(
                    getParticle(std::forward<FieldType>(field)));
    }

template< class FlavorType, class FieldType >
    mty::Irrep ModelData::getFlavorIrrep(
            FieldType  &&field,
            FlavorType &&flavor
            ) const
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        constexpr bool flavor_valid = 
            std::is_convertible<
                FlavorType, 
                mty::Group const*>::value;

        if constexpr(flavor_valid) {
            if constexpr(field_valid) 
                return doGetFlavorIrrep(field, flavor);
            else
                return getFlavorIrrep(
                        getParticle(std::forward<FieldType>(field)), 
                        flavor);
        }
        else if constexpr (field_valid)
            return getFlavorIrrep(
                    field, 
                    getGroup(std::forward<FlavorType>(flavor))
                    );
        else 
            return getFlavorIrrep(
                    getParticle(std::forward<FieldType>(field)), 
                    getGroup(std::forward<FlavorType>(flavor)));
    }

template< class GroupType, class FieldType >
    csl::Space const *ModelData::getVectorSpace(
            GroupType &&group,
            FieldType &&field
            ) const
    {
        constexpr bool group_valid = 
            std::is_convertible<
                GroupType, 
                mty::Group const*>::value;

        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr(group_valid) {
            if constexpr(field_valid) 
                return doGetVectorSpace(group, field);
            else
                return getVectorSpace(group, 
                        getParticle(std::forward<FieldType>(field)));
        }
        else if constexpr (field_valid)
            return getVectorSpace(
                    getGroup(std::forward<GroupType>(group)), 
                    field);
        else
            return getVectorSpace(
                    getGroup(std::forward<GroupType>(group)), 
                    getParticle(std::forward<FieldType>(field)));
    }

template< class GroupType, class FieldType >
    csl::Index ModelData::generateIndex(
            GroupType &&group,
            FieldType &&field
            ) const
    {
        constexpr bool group_valid = 
            std::is_convertible<
                GroupType, 
                mty::Group const*>::value;

        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr(group_valid) {
            if constexpr(field_valid) 
                return doGenerateIndex(group, field);
            else
                return generateIndex(
                        group, 
                        getParticle(std::forward<FieldType>(field)));
        }
        else if constexpr (field_valid)
            return generateIndex(
                    getGroup(std::forward<GroupType>(group)), 
                    field);
        else 
            return generateIndex(
                    getGroup(std::forward<GroupType>(group)), 
                    getParticle(std::forward<FieldType>(field)));
    }

template< class GroupType >
    csl::Index ModelData::generateIndex(
            GroupType &&group
            ) const
    {
        constexpr bool group_valid = 
            std::is_convertible<
                GroupType, 
                mty::Group const*>::value;

        if constexpr(group_valid) {
            return doGenerateIndex(group);
        }
        else 
            return generateIndex(
                    getGroup(std::forward<GroupType>(group))
                    );
    }

    template< class GroupType, class FieldType >
    std::vector<csl::Index> ModelData::generateIndices(
            size_t      nIndices,
            GroupType &&group,
            FieldType &&field
            ) const
    {
        std::vector<csl::Index> indices(nIndices);
        for (size_t i = 0; i != nIndices; ++i) 
            indices[i] = generateIndex<GroupType, FieldType>(
                    std::forward<GroupType>(group),
                    std::forward<FieldType>(field)
                    );

        return indices;
    }

    template< class GroupType >
    std::vector<csl::Index> ModelData::generateIndices(
            size_t      nIndices,
            GroupType &&group
            ) const
    {
        std::vector<csl::Index> indices(nIndices);
        for (size_t i = 0; i != nIndices; ++i) 
            indices[i] = generateIndex<GroupType>(
                    std::forward<GroupType>(group)
                    );

        return indices;
    }

template< class GroupType, class FieldType >
    csl::Index ModelData::generateIndex(
            std::string_view nameIndex,
            GroupType      &&group,
            FieldType      &&field
            ) const
    {
        constexpr bool group_valid = 
            std::is_convertible<
                GroupType, 
                mty::Group const*>::value;

        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr(group_valid) {
            if constexpr(field_valid) 
                return doGenerateIndex(nameIndex, group, field);
            else
                return generateIndex(
                        nameIndex, 
                        group, 
                        getParticle(std::forward<FieldType>(field)));
        }
        else if constexpr (field_valid)
            return generateIndex(
                    nameIndex, 
                    getGroup(std::forward<GroupType>(group)), 
                    field);
        else 
            return generateIndex(
                    nameIndex, 
                    getGroup(std::forward<GroupType>(group)), 
                    getParticle(std::forward<FieldType>(field)));
    }

template< class GroupType, class FieldType >
    mty::Generator ModelData::getGenerator(
            GroupType &&group,
            FieldType &&field
            ) const
    {
        constexpr bool group_valid = 
            std::is_convertible<
                GroupType, 
                mty::Group const*>::value;

        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr(group_valid) {
            if constexpr(field_valid) 
                return doGetGenerator(group, field);
            else
                return getGenerator(
                        group, 
                        getParticle(std::forward<FieldType>(field)));
        }
        else if constexpr (field_valid)
            return getGenerator(
                    getGroup(std::forward<GroupType>(group)), 
                    field);
        else 
            return getGenerator(
                    getGroup(std::forward<GroupType>(group)), 
                    getParticle(std::forward<FieldType>(field)));
    }

template<class FieldType>
    void ModelData::addBosonicMass(
            FieldType      &&field,
            std::string_view mass
            )
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr (field_valid)
            doAddBosonicMass(field, mass);
        else
            addBosonicMass(
                    getParticle(std::forward<FieldType>(field)),
                    mass
                    );
    }
template<class FieldType>
    void ModelData::addBosonicMass(
            FieldType      &&field,
            csl::Expr      const &mass
            )
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr (field_valid)
            doAddBosonicMass(field, mass);
        else
            addBosonicMass(
                    getParticle(std::forward<FieldType>(field)),
                    mass
                    );
    }

template<class FieldType1, class FieldType2>
    void ModelData::addFermionicMass(
            FieldType1     &&left,
            FieldType2     &&right,
            std::string_view mass
            )
    {
        constexpr bool field1_valid = 
            std::is_convertible<
                FieldType1, 
                mty::Particle const&>::value;
        constexpr bool field2_valid = 
            std::is_convertible<
                FieldType2, 
                mty::Particle const&>::value;

        if constexpr(field1_valid) {
            if constexpr(field2_valid) 
                return doAddFermionicMass(left, right, mass);
            else
                return addFermionicMass(
                        left,
                        getParticle(std::forward<FieldType2>(right)),
                        mass
                        );
        }
        else if constexpr (field2_valid)
                return addFermionicMass(
                        getParticle(std::forward<FieldType1>(left)),
                        right,
                        mass
                        );
        else 
                return addFermionicMass(
                        getParticle(std::forward<FieldType1>(left)),
                        getParticle(std::forward<FieldType2>(right)),
                        mass
                        );
    }
template<class FieldType1, class FieldType2>
    void ModelData::addFermionicMass(
            FieldType1 &&left,
            FieldType2 &&right,
            csl::Expr  const &mass
            )
    {
        constexpr bool field1_valid = 
            std::is_convertible<
                FieldType1, 
                mty::Particle const&>::value;
        constexpr bool field2_valid = 
            std::is_convertible<
                FieldType2, 
                mty::Particle const&>::value;

        if constexpr(field1_valid) {
            if constexpr(field2_valid) 
                return doAddFermionicMass(left, right, mass);
            else
                return addFermionicMass(
                        left,
                        getParticle(std::forward<FieldType2>(right)),
                        mass
                        );
        }
        else if constexpr (field2_valid)
                return addFermionicMass(
                        getParticle(std::forward<FieldType1>(left)),
                        right,
                        mass
                        );
        else 
                return addFermionicMass(
                        getParticle(std::forward<FieldType1>(left)),
                        getParticle(std::forward<FieldType2>(right)),
                        mass
                        );
    }
template<class FieldType>
    void ModelData::addFermionicMass(
            FieldType      &&diracFermion,
            std::string_view mass
            )
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr (field_valid)
            doAddFermionicMass(diracFermion, mass);
        else
            addFermionicMass(
                    getParticle(std::forward<FieldType>(diracFermion)),
                    mass
                    );
    }
template<class FieldType>
    void ModelData::addFermionicMass(
            FieldType &&diracFermion,
            csl::Expr const &mass
            )
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr (field_valid)
            doAddFermionicMass(diracFermion, mass);
        else
            addFermionicMass(
                    getParticle(std::forward<FieldType>(diracFermion)),
                    mass
                    );
    }


template<class FieldType>
    void ModelData::renameParticle(
            FieldType      &&field,
            std::string_view newName
            )
    {
        constexpr bool field_valid = 
            std::is_convertible<
                FieldType, 
                mty::Particle const&>::value;

        if constexpr(field_valid)
            return doRenameParticle(field, newName);
        else
            return renameParticle(
                    getParticle(std::forward<FieldType>(field)), 
                    newName);
    }

} // End of namespace mty

#endif