amplitudeSimplification.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/>.

#pragma once

#include <csl.h>

namespace color {
    class ColorSpace;
}
namespace mty {
    class QuantumField;
    class FeynOptions;
}

namespace mty::simpli {

    enum Mode {
        FeynmanRule,
        Amplitude,
        SquaredAmplitude,
        WilsonCoefficient
    };

    /*************************************************/
    // Main simplification routine using the other   //
    // routines below                                //
    /*************************************************/

    void simplify(
            csl::Expr                            &expr,
            std::vector<mty::QuantumField> const &insertions,
            std::vector<csl::Tensor>       const &momenta,
            mty::FeynOptions               const &options,
            Mode                                  mode
            );

    /*************************************************/
    // Simplification functions for color structures //
    /*************************************************/

    color::ColorSpace const *inColorSpace(csl::Index const& index);


    color::ColorSpace const *isColorStructure( 
            csl::IndexStructure const& structure
            );

    color::ColorSpace const *isColorStructure(csl::Expr const &expr);

    csl::IndexStructure colorStructure(
            csl::Expr const &node,
            color::ColorSpace const *color
            );

    bool factorIndicial(csl::Expr &res);

    csl::Expr colorAbbreviation(
            std::vector<csl::Expr> const &exprs,
            std::vector<color::ColorSpace const*> const &spaces
            );
    bool expandInProd(
            csl::Expr &prod,
            std::function<csl::IndexStructure(csl::Expr const&)> const &structureGetter
            );

    bool expandColorIndices(csl::Expr &res);

    bool simplifyColorWeights(csl::Expr &expr);

    bool findColorAbbreviation(csl::Expr& expr);

    /*************************************************/
    // Simplification functions for gamma / Minkowski//
    /*************************************************/

    bool expandMinkoStructures(csl::Expr &expr);

    bool expandMinkoMetric(csl::Expr &expr);

    bool expandMinkoEpsilon(csl::Expr &expr);

    bool simplifyEpsilonInProd(
            csl::Expr &prod,
            csl::IndexStructure &indices
            );

    bool simplifyEpsilon(csl::Expr &expr);

    bool expandGammaMatrices(csl::Expr &expr);

    bool simplifyFermionChains(csl::Expr &expr);

    void expandForFermionOrdering(csl::Expr &expr);

    /*************************************************/
    // Momenta and one-loop related simplifications  //
    /*************************************************/

    void expandMomentaExperimental(
            csl::Expr &res,
            std::vector<csl::Tensor> const &momenta
            );
    void reduceTensorIntegrals(csl::Expr &expr);

    struct FermionEOMData {
        csl::Tensor p;
        csl::Expr   m;
        csl::Index  alpha;
        bool        sign;
    };

    std::pair<csl::Expr, csl::Expr> getMomentumReplacement(
            std::vector<mty::QuantumField> const &insertions,
            std::vector<csl::Tensor>       const &momenta,
            size_t                                posReplaced
            );
    void replaceMomentum(
            csl::Expr                            &init,
            std::vector<mty::QuantumField> const &insertions,
            std::vector<csl::Tensor>       const &momenta,
            size_t                                posReplaced
            );

    void simplifyImpulsions(
            csl::Expr                            &init,
            std::vector<mty::QuantumField> const &insertions,
            std::vector<csl::Tensor>       const &momenta
            );

    void applyEOM(
        csl::Expr                   &ampl,
        std::vector<FermionEOMData> &onShellFermions
        );

    void applyEOM(
            csl::Expr                            &ampl,
            std::vector<mty::QuantumField> const &insertions,
            std::vector<csl::Tensor>       const &momenta
            );

    void addLocalTerms(csl::Expr &res);

    /*************************************************/
    // Miscellaneous routines                        //
    /*************************************************/
    
    bool maybeSimplified(csl::Expr const &expr);

    void findExternalAbbreviation(csl::Expr &expr);
    
    void abbreviateIntegral(csl::Expr &res);

    void abbreviateAll(csl::Expr &res);

    bool findAbbreviations(csl::Expr& res);

    void applyDerivativesInStructure(
            csl::Expr &expr
            );

    void suppressDiracDelta(
            csl::Expr       &expr,
            csl::Expr const &PSum
            );

} // namespace mty