feynmanDiagram.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>
#include "model.h"
#include "topology.h"

namespace mty {

    namespace wick {
        class Graph;
    }

    class Model;
    class Particle;

    class FeynmanDiagram {

    public:

        using diagram_t = std::shared_ptr<mty::wick::Graph>;

        template<typename T>
        using isNotParticle_t = typename std::enable_if_t<
                !std::is_same_v<mty::Particle, std::decay_t<T>>
                >;

        enum DiagramParticleType {

            External, 
            Mediator, 
            Loop,     
            Any       
        };

        FeynmanDiagram(
                mty::Model const &t_model
                );

        FeynmanDiagram(
                mty::Model const &t_model,
                csl::Expr  const &t_expression,
                diagram_t  const &t_diagram
                );

        bool isZero() const {
            return CSL_0 == expression;
        }

        csl::Expr const &getExpression() const { return expression; }

        csl::Expr       &getExpression()       { return expression; }

        diagram_t &getDiagram() { return diagram; }

        diagram_t const &getDiagram() const { return diagram; }

        std::vector<mty::Particle> const &getParticles(
                DiagramParticleType type = Any
                ) const;

        bool contains(
                mty::Particle const &part,
                DiagramParticleType  type = Any
                ) const;

        bool isExternal(mty::Particle const &particle) const {
            return contains(particle, External);
        }
        bool isMediator(mty::Particle const &particle) const {
            return contains(particle, Mediator);
        }
        bool isInLoop(mty::Particle const &particle) const {
            return contains(particle, Loop);
        }
        bool isInternal(mty::Particle const &particle) const {
            return isMediator(particle) || isInLoop(particle);
        }

        bool isTreeLevel() const {
            return getNLoops() == 0;
        }

        bool isLoop() const {
            return !isTreeLevel();
        }

        int getNLoops() const;

        bool isTopology(int topology) const;

        template<typename T, typename = isNotParticle_t<T>>
        bool contains(
                T                 &&part,
                DiagramParticleType type = Any
                ) const {
            return contains(
                    model->getParticle(std::forward<T>(part)),
                    type
                    );
        }

        template<typename T, typename = isNotParticle_t<T>>
        bool isExternal(T &&particle) const {
            return isExternal(model->getParticle(std::forward<T>(particle)));
        }
        template<typename T, typename = isNotParticle_t<T>>
        bool isMediator(T &&particle) const {
            return isMediator(model->getParticle(std::forward<T>(particle)));
        }
        template<typename T, typename = isNotParticle_t<T>>
        bool isInLoop(T &&particle) const {
            return isInLoop(model->getParticle(std::forward<T>(particle)));
        }
        template<typename T, typename = isNotParticle_t<T>>
        bool isInternal(T &&particle) const {
            return isInternal(model->getParticle(std::forward<T>(particle)));
        }

        FeynmanDiagram copy() const;

        static FeynmanDiagram combine(
                FeynmanDiagram const &A,
                FeynmanDiagram const &B,
                Particle       const &mediator
                );

    private:

        std::vector<mty::Particle> &getParticles(
                DiagramParticleType type = Any
                );

        void addParticle(
                mty::Particle const &part, 
                DiagramParticleType  type
                );

        template<typename T, typename = isNotParticle_t<T>>
        void addParticle(
                T                 &&part, 
                DiagramParticleType type
                )
        {
            addParticle(
                    model->getParticle(std::forward<T>(part)),
                    type
                    );
        }

        void loadParticlesFromVertices(
                std::vector<mty::wick::Vertex> const &vertices
                );

        void updateParticleData();

        void updateParticleData(std::vector<mty::wick::Vertex> const &vertices);

        void mergeParticles();

    private:

        Model const *model;

        csl::Expr    expression;

        diagram_t    diagram;

        int cycleLength;

        int nLoops;

        std::vector<mty::Particle> allParticles;

        std::vector<mty::Particle> externalParticles;

        std::vector<mty::Particle> mediatorParticles;

        std::vector<mty::Particle> loopParticles;
    };

}