feynOptions.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 <functional>
#include "lagrangian.h"
#include "mrtOptions.h"
#include "topology.h"
#include "operatorBasis.h"

namespace mty {

    class InteractionTerm;
    class FeynmanDiagram;
    class FeynmanRule;

    class FeynOptions {

    public:

        using LagrangianFilter 
            = std::function<bool(mty::InteractionTerm const&)>;
        using DiagramFilter 
            = std::function<bool(mty::FeynmanDiagram const&)>;

        FeynOptions();

        bool getFeynRuleCalculation() const { return feynRuleCalculation; }

        int getLoopOrder()      const { return *loopOrder; }

        int getExpansionOrder() const { return expansionOrder; }

        int getTopology()       const { return topology; }

        std::vector<int> const &getFermionOrder() const { 
            return fermionOrder; 
        }

        std::vector<LagrangianFilter> const &getLagrangianFilters() const {
            return lfilters;
        }

        std::vector<DiagramFilter> const &getDiagramFilters() const {
            return dfilters;
        }

        csl::Expr getWilsonOperatorCoefficient() const {
            return wilsonOperatorCoefficient;
        }

        OperatorBasis getWilsonOperatorBasis() const {
            return wilsonOperatorBasis;
        }

        void setFeynmanRuleMode();

        void setLoopOrder(int t_nLoops, int nExternalLegs);

        void setTopology(int t_topology);

        void setFermionOrder(std::vector<int> const &order);

        void setWilsonOperatorCoefficient(csl::Expr const &factor);

        bool passFilters(FeynmanDiagram const &diagram) const;

        void applyFilters(
                std::vector<Lagrangian::TermType> &lagrangian
                ) const;

        std::vector<FeynmanRule const*> applyFilters(
                std::vector<FeynmanRule> const &lagrangian
                ) const;

        void applyFilters(
                std::vector<FeynmanDiagram> &diagrams,
                bool                         forceFilters = false
                ) const;

        template<class Filter>
        void addFilter(Filter &&filter) {
            if constexpr (std::is_constructible_v<LagrangianFilter, Filter>) 
            {
                addLagrangianFilter(std::forward<Filter>(filter));
            }
            else 
            {
                addDiagramFilter(std::forward<Filter>(filter));
            }
        }

        void addFilters() {}

        template<class First, class ...Next>
        void addFilters(First &&first, Next &&...next)
        {
            addFilter(std::forward<First>(first));
            addFilters(std::forward<Next>(next)...);
        }

        void resetFilters();

    protected:

        void addLagrangianFilter(LagrangianFilter const &filter) {
            addLagrangianFilters({filter});
        }
        void addDiagramFilter(DiagramFilter const &filter) {
            addDiagramFilters({filter});
        }
        void addLagrangianFilters(
                std::initializer_list<LagrangianFilter> filters
                );
        void addDiagramFilters(
                std::initializer_list<DiagramFilter> filters
                );

    private:

        template<class Container, class Predicate>
        void applyFilters(
                Container       &container,
                Predicate const &predicate
                ) const
        {
            auto last = std::remove_if(
                    begin(container), end(container), predicate);
            container.erase(last, end(container));
        }

        void initDefaultFilters();

        void setWilsonOperatorBasis(OperatorBasis basis);

    public:

        bool orderInsertions       { mty::option::applyInsertionOrdering };

        bool orderExternalFermions { mty::option::orderExternalFermions  };

        bool simplifyAmplitudes    { mty::option::simplifyAmplitudes     };

        bool discardLowerOrders    { mty::option::discardLowerOrders     };

        bool verboseAmplitude      { mty::option::verboseAmplitude       };

        bool partialCalculation { false };

    private:

        bool                          feynRuleCalculation { false };

        std::shared_ptr<int>          loopOrder;

        int                           expansionOrder;

        int                           topology = mty::Topology::Any;

        std::vector<int>              fermionOrder;

        std::vector<LagrangianFilter> lfilters;

        std::vector<DiagramFilter>    dfilters;

        csl::Expr wilsonOperatorCoefficient { CSL_1 };

        OperatorBasis wilsonOperatorBasis = OperatorBasis::Chiral;

        constexpr static size_t nDefaultDiagramFilters = 1;
    };

} // namespace mty