amplitudeInitializer.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 <variant>
#include "feynOptions.h"
#include "lagrangian.h"
#include "amplitude.h"

namespace mty {

    class Model;
    class Kinematics;

    class AmplitudeInitializer {

    public:

        AmplitudeInitializer(
                mty::Model                       const *t_model,
                mty::FeynOptions                 const &t_options,
                Kinematics                       const &t_kinematics,
                std::vector<mty::QuantumField>   const &t_insertions,
                std::vector<mty::Lagrangian::TermType> &t_lagrangian
                );

        AmplitudeInitializer(
                mty::Model                       const *t_model,
                mty::FeynOptions                 const &t_options,
                Kinematics                       const &t_kinematics,
                std::vector<mty::QuantumField>   const &t_insertions,
                std::vector<mty::FeynmanRule const*>   &t_lagrangian
                );

        template<class ...Args>
        static Amplitude getAmplitude(
                std::vector<std::vector<size_t>> const &terms,
                Args &&...args
                )
        {
            AmplitudeInitializer ampl (std::forward<Args>(args)... );
            return ampl.getAmplitude(terms);
        }

        Amplitude getAmplitude(
                std::vector<std::vector<size_t>> const &terms
                );

        void initMomentumVertices(
                std::vector<FeynmanRule>       &localRules,
                std::map<csl::Tensor, size_t>  &vertexIds,
                std::vector<csl::Tensor> const &vertices,
                std::vector<csl::Tensor>       &witnessVertices,
                csl::PseudoIntegral            &integral,
                std::vector<csl::Expr>         &fieldVertices
                );

        std::vector<std::vector<size_t>> getExternalSymmetries(
            csl::Expr &fieldProd
            ) const;

        std::vector<csl::Expr> applyExternalSymmetries(
                csl::Expr    const& res,
                std::vector<size_t> perm
                ) const;

        std::vector<csl::Expr> applyAllExternalSymmetries(
                std::vector<csl::Expr>              const& init,
                std::vector<std::vector<size_t>>::iterator first,
                std::vector<std::vector<size_t>>::iterator last
                ) const;

        void simplifyFullQuantumCalculation(
                mty::FeynmanDiagram            &diagram,
                csl::PseudoIntegral      const &integral,
                std::vector<size_t>      const &posTerms,
                std::vector<std::vector<size_t>> &externalSym
                );

        void simplifyRuledCalculation(
                mty::FeynmanDiagram            &diagram,
                csl::PseudoIntegral      const &integral,
                std::vector<csl::Tensor> const &witnessVericesx,
                FeynruleMomentum               &momentumMapping
                );

        static void removeZeroDiagrams(
                std::vector<FeynmanDiagram> &diagrams
                );

        static csl::Expr getLSZInsertions(
                std::vector<mty::QuantumField> const &fields,
                std::vector<csl::Tensor>       const &momenta,
                bool                                  feynRuleCalculation
                );

        static std::vector<csl::Tensor> getVertices(size_t N);

        static void orderInsertions(
                std::vector<mty::QuantumField> &insertions,
                Kinematics                     &kinematics,
                FeynOptions                    &options
                );

        static void applyMomentumVertices(
                std::vector<csl::Tensor> const &witnessVertices,
                FeynruleMomentum               &momentumMapping,
                csl::Expr                           &amplitude
                );

    private:

        Amplitude fullQuantumCalculation(
                std::vector<std::vector<size_t>> const &terms
                );

        Amplitude ruledCalculation(
                std::vector<std::vector<size_t>> const &terms
                );

    private:

        inline static std::vector<mty::Lagrangian::TermType> defaultL{};
        inline static std::vector<mty::FeynmanRule const*>   defaultFR{};

        mty::Model                  const *model;
        mty::FeynOptions                   options;
        std::vector<mty::QuantumField>     insertions;
        Kinematics                         kinematics;

        bool feynRuleMode;

        std::vector<mty::Lagrangian::TermType> &lagrangian;

        std::vector<mty::FeynmanRule const*> &feynmanRules;
    };

} // namespace mty