fermionFlow.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 FERMIONFLOW_H_INCLUDED
#define FERMIONFLOW_H_INCLUDED

#include <vector>
#include <csl.h>

namespace mty {

    class QuantumField;
    class ConjugationList;
    struct FermionLine;

    class ConjugationInfo {

    public:

        enum Type {

            Undefined,

            External,

            Internal
        };

        using FieldList = std::vector<mty::QuantumField const*>;

        constexpr static size_t maxFermionLines = 3;

        static ConjugationList resolveFermionLines(
                FieldList        init,
                FieldList const &ruleOrder,
                bool             ruleMode
                );

        static ConjugationList resolveFermionLines(
                FieldList                 const &init,
                std::vector<QuantumField> const &ruleOrder,
                bool                             ruleMode
                );

        static void simplify(
                ConjugationList &infoList,
                bool             ruleMode
                );

        static void applyConjugation(
                ConjugationList infoList,
                csl::Expr           &expr,
                bool            ruleMode
                );

    public:

        ConjugationInfo();

        explicit 
        ConjugationInfo(
                csl::Index const &t_A,
                bool              t_conjugated
                );

        ConjugationInfo(
                csl::Index const &t_A,
                csl::Index const &t_B,
                csl::Index const &t_preA,
                csl::Index const &t_postB
                );

        ~ConjugationInfo() = default;

        ConjugationInfo(ConjugationInfo const &) = default;
        ConjugationInfo(ConjugationInfo &&) = default;
        ConjugationInfo &operator=(ConjugationInfo const &) = default;
        ConjugationInfo &operator=(ConjugationInfo &&) = default;

        Type getType() const { return type; }

        csl::Index getA() const { return A; }

        csl::Index getB() const { return B; }

        csl::Index getPreA() const { return preA; }

        csl::Index getPostB() const { return postB; }

        bool getConjugated() const { return conjugated; }

        void setInfo(
                csl::Index const &t_A,
                bool              t_conjugated
                );

        void setInfo(
                csl::Index const &t_A,
                csl::Index const &t_B,
                csl::Index const &t_preA,
                csl::Index const &t_postB
                );

        void apply(
                csl::Expr &expr, 
                bool ruleMode, 
                std::vector<FermionLine> const &lines
                ) const;

    protected:

        void insertInChain(
                csl::Expr &expr
                ) const;

        void insertInChainForRule(
                csl::Expr &expr,
                std::vector<FermionLine> const &lines
                ) const;

        void insertExternal(
                csl::Expr &expr
                ) const;

    protected:

        Type       type;

        csl::Index A;

        csl::Index B;

        csl::Index preA;

        csl::Index postB;

        bool       conjugated;
    };

    struct FermionLine {

        ConjugationInfo::FieldList fields;
        std::vector<csl::Index> indices;
    };

    class ConjugationList: public std::vector<ConjugationInfo> {

        public:

        ConjugationList(
                std::vector<ConjugationInfo> const &info,
                int                                &t_sign,
                std::vector<FermionLine> const     &t_lines,
                std::vector<QuantumField const*> const &t_bosons
                )
            :std::vector<ConjugationInfo>(info),
            sign(t_sign),
            lines(t_lines),
            bosons(t_bosons)
        {}

        std::vector<QuantumField const *> getFinalOrder(
                size_t sizeHint = 10
                ) const {
            std::vector<QuantumField const *> finalOrder;
            finalOrder.reserve(sizeHint);
            for (const auto &b : bosons) 
                finalOrder.push_back(b);
            for (const auto &line : lines)
                for (const auto &f : line.fields)
                    finalOrder.push_back(f);

            return finalOrder;
        }

        int sign = 1;
        std::vector<FermionLine>         lines;
        std::vector<QuantumField const*> bosons;
    };

    std::ostream &operator<<(
            std::ostream          &out,
            ConjugationInfo::Type type
            );

    std::ostream &operator<<(
            std::ostream          &out,
            ConjugationInfo const &info
            );

    ConjugationInfo::FieldList::iterator getExternalBegin(
            ConjugationInfo::FieldList &fields
            );
    ConjugationInfo::FieldList::iterator getInternalBegin(
            ConjugationInfo::FieldList &fields
            );
    ConjugationInfo::FieldList::iterator getBegin(
            ConjugationInfo::FieldList &fields
            );

} // End of namespace mty

#endif