mrtInterface.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 HEPINTERFACE_H_INCLUDED
#define HEPINTERFACE_H_INCLUDED

#include "model.h"
#include "insertion.h"

namespace mty {

template<class Type>
struct enable_model {
    using type = typename std::enable_if<
        std::is_same<
            mty::Model,
            std::remove_reference<std::remove_cv<Type>>>::value
        >::type;
};

template<class Type>
struct disable_model {
    using type = typename std::enable_if<
        not std::is_same<
            mty::Model,
            std::remove_reference<std::remove_cv<Type>>>::value
        >::type;
};

class Insertion;


/*************************************************/
// Expression utilities                          //
/*************************************************/

csl::Tensor MinkowskiVector(std::string const& name);

csl::Index MinkowskiIndex(std::string const& name = "");

std::vector<csl::Index> DiracIndices(size_t n, std::string const& name = "");

std::vector<csl::Index> MinkowskiIndices(size_t n, std::string const& name = "");

csl::Index DiracIndex(std::string const& name = "");

template<class GroupType, class FieldType>
csl::Index GaugeIndex(std::string const& nameIndex,
                      mty::Model  const& model,
                      GroupType       && group,
                      FieldType       && part)
{
    return model.generateIndex<GroupType, FieldType>(
            nameIndex,
            std::forward<GroupType>(group),
            std::forward<FieldType>(part)
            );
}

template<class GroupType>
csl::Index FlavorIndex(mty::Model  const& model,
                      GroupType       && group)
{
    return model.generateIndex(
            std::forward<GroupType>(group)
            );
}

template<class GroupType>
std::vector<csl::Index> FlavorIndices(
        size_t             nIndices,
        mty::Model  const& model,
        GroupType       && group)
{
    std::vector<csl::Index> indices(nIndices);
    for (size_t i = 0; i != nIndices; ++i) 
        indices[i] = FlavorIndex<GroupType>(
                model,
                std::forward<GroupType>(group)
                );

    return indices;
}


template<class GroupType, class FieldType>
csl::Index GaugeIndex(mty::Model  const& model,
                      GroupType       && group,
                      FieldType       && part)
{
    return model.generateIndex<GroupType, FieldType>(
            std::forward<GroupType>(group),
            std::forward<FieldType>(part)
            );
}

template<class GroupType, class FieldType>
std::vector<csl::Index> GaugeIndices(
        size_t             nIndices,
        mty::Model  const& model,
        GroupType       && group,
        FieldType       && part)
{
    std::vector<csl::Index> indices(nIndices);
    for (size_t i = 0; i != nIndices; ++i) 
        indices[i] = GaugeIndex<GroupType, FieldType>(
                model,
                std::forward<GroupType>(group),
                std::forward<FieldType>(part)
                );

    return indices;
}

const csl::Space* VectorSpace(
        mty::Model  const& model,
        std::string const& nameGroup,
        Particle    const& part
        );

csl::Index GenerateIndex(
        csl::Space  const *space,
        std::string const &name = ""
        );

csl::Tensor Delta(const csl::Space* space);

csl::Tensor Metric(const csl::Space* space);

csl::Tensor Epsilon(const csl::Space* space);

csl::Tensor DiracGamma();
csl::Tensor DiracGamma5();
csl::Tensor DiracSigma();
csl::Tensor DiracPL();
csl::Tensor DiracPR();

inline
csl::Tensor DiracProjector(Chirality chir)
{
    return (chir == Chirality::Left) ? DiracPL() : DiracPR();
}

csl::Tensor DiracCMatrix();

template<class GroupType, class FieldType>
mty::Generator GetGenerator(
        mty::Model &model,
        GroupType &&group,
        FieldType &&field
        ) 
{
    return model.getGenerator(
            std::forward<GroupType>(group),
            std::forward<FieldType>(field)
            );
}

template<class GroupType, class FieldType>
csl::Space const *GetVectorSpace(
        mty::Model &model,
        GroupType &&group,
        FieldType &&field
        ) 
{
    return model.getVectorSpace(
            std::forward<GroupType>(group),
            std::forward<FieldType>(field)
            );
}

/*************************************************/
// Computation utilities                         //
/*************************************************/

Amplitude SelfEnergy(
            mty::Order     order,
            mty::Particle &particle,
            mty::Model    &model);

Amplitude SelfEnergy(
            mty::Particle &particle,
            mty::Model    &model);

csl::Expr ComputeSquaredAmplitude(
        mty::Model      &model,
        Amplitude const &ampl
        );

std::vector<FeynmanRule> ComputeFeynmanRules(mty::Model& model);

void ContractIndices(csl::Expr &init);

void ContractIndices(std::vector<csl::Expr> &init);

void Display(std::vector<FeynmanRule> const& rules,
             std::ostream                  & out = std::cout);


void Display(std::vector<csl::Expr> const& amplitudes,
             std::ostream           & out = std::cout,
             bool                     simplify = false);
void Display(mty::Amplitude const& amplitudes,
             std::ostream        & out = std::cout,
             bool                  simplify = false);

void Display(WilsonSet const& wilsons,
             std::ostream             & out = std::cout);

void Show(std::vector<FeynmanRule> const& rules);
void Show(std::vector<std::shared_ptr<wick::Graph>> const& diagrams);
void Show(mty::Amplitude const& diagrams);
void Show(WilsonSet const &wilsons);

void Show(
        std::vector<FeynmanRule> const& rules,
        size_t first,
        size_t last
        );
void Show(
        std::vector<std::shared_ptr<wick::Graph>> const& diagrams,
        size_t first,
        size_t last
        );
void Show(
        mty::Amplitude const& diagrams,
        size_t first,
        size_t last
        );
void Show(
        WilsonSet const &wilsons,
        size_t first,
        size_t last
        );

template<class T>
void Display(T const& printable,
             std::ostream& out = std::cout)
{
    out << printable << std::endl;
}

void DisplayAbbreviations(std::ostream &out = std::cout);
void DisplayAbbreviations(std::string const &name,
                          std::ostream &out = std::cout);

void ExportPDF(std::string                 const& nameFiles,
               std::vector<std::shared_ptr<wick::Graph>> const& graphs);

void ExportPDF(std::string              const& nameFiles,
               std::vector<FeynmanRule> const& rules);

void ExportPNG(std::string                 const& nameFiles,
               std::vector<std::shared_ptr<wick::Graph>> const& graphs);

void ExportPNG(std::string              const& nameFiles,
               std::vector<FeynmanRule> const& rules);

/*************************************************/
// Model building utilities                      //
/*************************************************/

template<class ...Args>
void AddGaugedGroup(
        mty::Model &model,
        Args      &&...args
        )
{
    model.addGaugedGroup(std::forward<Args>(args)...);
}

template<class ...Args>
void AddFlavorGroup(
        mty::Model &model,
        Args      &&...args
        )
{
    model.addFlavorGroup(std::forward<Args>(args)...);
}

void AddParticle(mty::Model   & model,
              mty::Particle& particle,
              bool            initTerms = true);

void AddTerm(mty::Model& model,
             csl::Expr const& term,
             bool        addCC = false);

void AddTerm(mty::Model&              model,
             std::vector<csl::Expr> const& terms,
             bool                     addCC = false);

mty::Particle GetParticle(mty::Model  const& model,
                          std::string const& name);

csl::Expr GetMass(mty::Particle const& particle);

mty::Particle GenerateSimilarParticle(std::string   const& name,
                                      mty::Particle const& particle);

mty::Particle GetFieldStrength(Particle const& particle);

void PromoteGoldstone(mty::Model   & model,
                      mty::Particle& goldstone,
                      mty::Particle& gaugeBoson);

void PromoteGoldstone(mty::Model       & model,
                      char        const* goldstone,
                      char        const* gaugeBoson);

csl::Expr GetCoupling(mty::Model  const& model,
                 std::string const& nameCoupling);

csl::Tensor GetYukawa(mty::Model  const& model,
                       std::string const& nameCoupling);

void Rename(mty::Model       & model,
            std::string const& oldName,
            std::string const& newName);

template<class ...Args>
void SetMass(Particle & part,
             Args    && ...args)
{
    part->setMass(std::forward<Args>(args)...);
}

template<class ...Args>
void SetWidth(Particle & part,
             Args    && ...args)
{
    part->setWidth(std::forward<Args>(args)...);
}

void SetSelfConjugate(Particle & part,
                      bool       selfConjugate);

void SetGroupRep(mty::Particle         & part,
                 std::string      const& nameGroup,
                 std::vector<int> const& highestWeight);
void SetGroupRep(mty::Particle         & part,
                 std::string      const& nameGroup,
                 int charge);
void SetFlavorRep(mty::Particle         & part,
                  std::string      const& nameGroup);

void Init(mty::Model & model);

void Replaced(mty::Model& model,
             csl::Expr const& init,
             csl::Expr const& target);

void Replaced(mty::Model  & model,
             csl::Tensor& init,
             csl::Expr   const& target);

void Replaced(mty::Model  & model,
             csl::Tensor& init,
             csl::Tensor& target);

void Replaced(mty::Model      & model,
             Particle   const& particle,
             csl::Expr       const& newTerm);

void Rotate(mty::Model & model,
            std::vector<mty::Particle> const& fields,
            std::vector<mty::Particle> const& newFields,
            std::vector<std::vector<csl::Expr>> const& rotation,
            bool diagonalizeMasses = false);

void Rotate(mty::Model & model,
            std::vector<std::string> const& fields,
            std::vector<std::string> const& newFields,
            std::vector<std::vector<csl::Expr>> const& rotation,
            bool diagonalizeMasses = false);

void DiagonalizeMassMatrices(mty::Model& model);

void BreakGaugeSymmetry(
        mty::Model                                 & model,
        std::string                           const& brokenGroup,
        std::vector<Particle>                 const& brokenFields,
        std::vector<std::vector<std::string>> const& newNames
        );

void BreakGaugeSymmetry(
        mty::Model                                 & model,
        std::string                           const& brokenGroup,
        std::initializer_list<std::string>    const& brokenFields,
        std::vector<std::vector<std::string>> const& newNames
        );

void BreakFlavorSymmetry(
        mty::Model                                 & model,
        std::string                           const& brokenFlavor,
        std::initializer_list<std::string>    const& brokenFields,
        std::vector<std::vector<std::string>> const& newNames
        );

void BreakFlavorSymmetry(
        mty::Model                                 & model,
        std::string                           const& brokenFlavor,
        std::vector<mty::Particle>            const& brokenFields,
        std::vector<std::vector<std::string>> const& newNames
        );

template<class ...Args>
void BreakGaugeSymmetry(
        mty::Model &model,
        Args      &&...args
        )
{
    model.breakGaugeSymmetry(std::forward<Args>(args)...);
}

template<class ...Args>
void BreakFlavorSymmetry(
        mty::Model &model,
        Args      &&...args
        )
{
    model.breakFlavorSymmetry(std::forward<Args>(args)...);
}

void Refreshed(mty::Model & model);

void IntegrateOutParticle(
        mty::Particle & particle,
        bool            value = true);

/*************************************************/
// Group theory                                  //
/*************************************************/


std::unique_ptr<mty::SemiSimpleAlgebra> CreateAlgebra(
        algebra::Type type,
        int                  l = -1);

mty::Irrep GetIrrep(mty::SemiSimpleAlgebra const* algebra,
                    std::vector<int> const& labels);

mty::Irrep GetIrrep(std::unique_ptr<mty::SemiSimpleAlgebra> const& algebra,
                    std::vector<int> const& labels);

mty::Irrep GetConjugateRep(mty::Irrep const& rep);

mty::SemiSimpleAlgebra const* GetAlgebraOf(Irrep const& rep);

int GetDimension(mty::Irrep const& irrep);

bool ContainsIrrep(mty::SumIrrep const& decomposition,
                   mty::Irrep    const& irrep);

bool ContainsTrivialrep(mty::SumIrrep const& decomposition);

void SetGaugeChoice(mty::Model & model,
                    std::string const& nameParticle,
                    mty::gauge::Type choice);


void SetGaugeChoice(mty::Particle particle,
                    mty::gauge::Type choice);

std::string FindProcessName(
        std::string                 const &initName,
        std::vector<mty::Insertion> const &insertions
        );

}

#endif