filters.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 "model.h"
#include "feynmanRule.h"
#include "feynmanDiagram.h"
#include <algorithm>

namespace mty::filter {

    template<class ParticleIterator>
    auto disableParticles(
            ParticleIterator first,
            ParticleIterator last
            )
    {
        return [particles = std::vector<mty::Particle>(first, last)]
            (InteractionTerm const &rule) {
                return std::all_of(begin(particles), end(particles),
                [&](Particle const &p) {
                    return !rule.containsWeakly(p);
                });
            };
    }

    inline auto disableParticles(std::vector<mty::Particle> const &particles)
    {
        return disableParticles(begin(particles), end(particles));
    }

    inline auto disableParticles(std::initializer_list<mty::Particle> particles)
    {
        return disableParticles(begin(particles), end(particles));
    }

    inline auto disableParticles(
            std::initializer_list<std::string_view> names,
            mty::Model                       const &model = *Model::current
            )
    {
        return disableParticles(model.getParticles(names));
    }

    inline auto disableParticle(mty::Particle const &particle)
    {
        return disableParticles({particle});
    }

    inline auto disableParticle(
            std::string_view  name,
            mty::Model const &model = *Model::current
            )
    {
        return disableParticle(model.getParticle(name));
    }

    template<class ParticleIterator>
    auto disableParticleCombination(
            ParticleIterator first,
            ParticleIterator last
            )
    {
        return [particles = std::vector<mty::Particle>(first, last)]
            (FeynmanDiagram const &rule) {
                return std::any_of(begin(particles), end(particles),
                [&](Particle const &p) {
                    return !rule.contains(p);
                });
            };
    }

    inline auto disableParticleCombination(
            std::vector<mty::Particle> const &particles
            )
    {
        return disableParticleCombination(begin(particles), end(particles));
    }

    inline auto disableParticleCombination(
            std::initializer_list<mty::Particle> particles
            )
    {
        return disableParticleCombination(begin(particles), end(particles));
    }

    inline auto disableParticleCombination(
            std::initializer_list<std::string_view> names,
            mty::Model                       const &model = *Model::current
            )
    {
        return disableParticleCombination(model.getParticles(names));
    }


    template<class ParticleIterator>
    auto forceParticleCombination(
            ParticleIterator first,
            ParticleIterator last
            )
    {
        return [particles = std::vector<mty::Particle>(first, last)]
            (FeynmanDiagram const &diagram) {
                return std::all_of(begin(particles), end(particles), 
                [&](Particle const &p) {
                    return diagram.contains(p);
                });
            };
    }

    inline auto forceParticleCombination(
            std::vector<mty::Particle> const &particles
            )
    {
        return forceParticleCombination(begin(particles), end(particles));
    }

    inline auto forceParticleCombination(
            std::initializer_list<mty::Particle> particles
            )
    {
        return forceParticleCombination(begin(particles), end(particles));
    }

    inline auto forceParticleCombination(
            std::initializer_list<std::string_view> names,
            mty::Model                       const &model = *Model::current
            )
    {
        return forceParticleCombination(model.getParticles(names));
    }

    inline auto forceParticle(mty::Particle const &particle)
    {
        return forceParticleCombination({particle});
    }

    inline auto forceParticle(
            std::string_view  name,
            mty::Model const &model = *Model::current
            )
    {
        return forceParticle(model.getParticle(name));
    }

    template<class ParticleIterator>
    auto forceParticles(
            ParticleIterator first,
            ParticleIterator last
            )
    {
        return [particles = std::vector<mty::Particle>(first, last)]
            (FeynmanDiagram const &diagram) {
                return std::any_of(begin(particles), end(particles), 
                [&](Particle const &p) {
                    return diagram.contains(p);
                });
            };
    }

    inline auto forceParticles(std::vector<mty::Particle> const &particles)
    {
        return forceParticles(begin(particles), end(particles));
    }

    inline auto forceParticles(std::initializer_list<mty::Particle> particles)
    {
        return forceParticles(begin(particles), end(particles));
    }

    inline auto forceParticles(
            std::initializer_list<std::string_view> names,
            mty::Model                       const &model = *Model::current
            )
    {
        return forceParticles(model.getParticles(names));
    }

}