amplitude.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 "feynmanDiagram.h"
#include "kinematics.h"

namespace mty {

    class Amplitude {

    public:

        friend class AmplitudeInitializer;

        Amplitude(
                FeynOptions const &t_options,
                Kinematics  const &t_kinematics
                );

        Amplitude(
                FeynOptions                      const &t_options,
                std::vector<mty::FeynmanDiagram> const &t_diagrams,
                mty::Kinematics                  const &t_kinematics
                );

        Amplitude(
                FeynOptions                 const &t_options,
                std::vector<mty::FeynmanDiagram> &&t_diagrams,
                mty::Kinematics             const &t_kinematics
                );

        bool empty() const {
            return diagrams.empty();
        }

        size_t size() const {
            return diagrams.size();
        }

        csl::Expr       &expression(size_t pos);

        csl::Expr const &expression(size_t pos) const;

        FeynmanDiagram::diagram_t       &diagram(size_t pos);

        FeynmanDiagram::diagram_t const &diagram(size_t pos) const;

        std::vector<csl::Expr> obtainExpressions() const;

        std::vector<std::shared_ptr<mty::wick::Graph>> obtainGraphs() const;

        void add(std::vector<mty::FeynmanDiagram> const &t_diagrams);

        void add(std::vector<mty::FeynmanDiagram> &&t_diagrams);

        Amplitude filterOut(
                std::function<bool(mty::FeynmanDiagram const&)> filter
                ) const;

        template<class First, class ...Next,
            typename = std::enable_if_t<(sizeof...(Next) > 1)>
            >
        Amplitude filterOut(
                First &&first,
                Next  &&...next
                ) const
        {
            return filterOut(std::forward<First>(first)).filterOut(
                    std::forward<Next>(next)...
                    );
        }

        FeynOptions const &getOptions() const {
            return options;
        }

        std::vector<mty::FeynmanDiagram> const &getDiagrams() const {
            return diagrams;
        }

        std::vector<mty::FeynmanDiagram>       &getDiagrams()       {
            return diagrams;
        }

        mty::Kinematics const &getKinematics() const {
            return kinematics;
        }

        mty::Kinematics &getKinematics() {
            return kinematics;
        }

        csl::Expr getSum() const;

        Amplitude copy() const;

        void setKinematics(
                Kinematics const &t_kinematics,
                bool              replace = true);

    private:

        template<class Iterator>
        void add(Iterator first, Iterator last)
        {
            diagrams.insert(end(diagrams), first, last);
        }

    private:

        FeynOptions                      options;

        std::vector<mty::FeynmanDiagram> diagrams;

        mty::Kinematics                  kinematics;
    };

} // namespace mty