Filters.h

Go to the documentation of this file.

/*  YAP - Yet another PWA toolkit
    Copyright 2015, Technische Universitaet Muenchen,
    Authors: Daniel Greenwald, Johannes Rauch

    This program 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.

    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef yap__Filters_h
#define yap__Filters_h

#include "fwd/Filters.h"

#include "fwd/DecayChannel.h"
#include "fwd/DecayingParticle.h"
#include "fwd/DecayTree.h"
#include "fwd/FinalStateParticle.h"
#include "fwd/FreeAmplitude.h"
#include "fwd/MassShape.h"
#include "fwd/MassShapeWithNominalMass.h"
#include "fwd/Particle.h"
#include "fwd/Resonance.h"
#include "fwd/SpinAmplitude.h"

#include "Exceptions.h"

#include <algorithm>
#include <memory>
#include <set>

namespace yap {


template <typename container>
typename container::value_type lone_elt(container& C)
{
    if (C.size() != 1)
        throw yap::exceptions::Exception("Container size not 1 (" + std::to_string(C.size()) + ")", "lone_elt");
    return *C.begin();
}

template <typename container>
typename container::value_type lone_elt(container&& C)
{
    if (C.size() != 1)
        throw yap::exceptions::Exception("Container size not 1 (" + std::to_string(C.size()) + ")", "lone_elt");
    return *C.begin();
}

template <typename T, typename Last, typename ... UnaryPredicates>
std::set<std::shared_ptr<T> > filter(const std::set<std::shared_ptr<T> >& S, Last p, UnaryPredicates ... P)
{
    auto s = filter<T, UnaryPredicates...>(S, P...);
    for (auto it = s.begin(); it != s.end(); ) {
        if (p(**it))
            ++it;
        else
            it = s.erase(it);
    }
    return s;
}

// does nothing, needed to terminate above variadic template
template <typename T>
const std::set<std::shared_ptr<T> >& filter(const std::set<std::shared_ptr<T> >& S)
{ return S; }

struct filter_decay_tree {
    virtual const bool operator()(const DecayTree& dt) const = 0;
};

struct filter_free_amplitude : public filter_decay_tree {
    using filter_decay_tree::operator();

    virtual const bool operator()(const DecayTree& dt) const override;

    virtual const bool operator()(const FreeAmplitude& fa) const = 0;
};

struct filter_decay_channel : public filter_free_amplitude {
    using filter_free_amplitude::operator();

    virtual const bool operator()(const FreeAmplitude& fa) const override;

    virtual const bool operator()(const DecayChannel& dc) const = 0;
};

struct filter_spin_amplitude : public filter_free_amplitude {
    using filter_free_amplitude::operator();

    virtual const bool operator()(const FreeAmplitude& fa) const override;

    virtual const bool operator()(const SpinAmplitude& dc) const = 0;
};

struct filter_particle {
    virtual const bool operator()(const Particle& p) const = 0;
};

struct filter_decaying_particle : public filter_particle {
    using filter_particle::operator();

    virtual const bool operator()(const Particle& p) const override;

    virtual const bool operator()(const DecayingParticle& dp) const = 0;
};

struct filter_resonance : public filter_decaying_particle {
    using filter_decaying_particle::operator();

    virtual const bool operator()(const DecayingParticle& dp) const override;

    virtual const bool operator()(const Resonance& dp) const = 0;
};

struct filter_mass_shape : public filter_resonance {
    using filter_resonance::operator();

    virtual const bool operator()(const Resonance& dp) const override;

    virtual const bool operator()(const MassShape& dp) const = 0;

};

template <class F, typename T>
const bool by_ptr(const F& f, const std::shared_ptr<T>& ptr)
{ return ptr and f(*ptr); }

template <class F, typename T>
const bool by_ptr(const F& f, const T* ptr)
{ return ptr and f(*ptr); }

class has_decay_channel : public filter_decay_channel, public filter_decaying_particle
{
public:
    has_decay_channel(const DecayChannel* dc)
        : filter_decay_channel(), filter_decaying_particle(), DecayChannel_(dc) {}

    using filter_decay_channel::operator();
    using filter_decaying_particle::operator();

    const bool operator()(const FreeAmplitude& fa) const override;

    const bool operator()(const DecayChannel& dc) const override
    { return operator()(&dc); }

    const bool operator()(const std::shared_ptr<DecayChannel> dc) const
    { return operator()(dc.get()); }

    const bool operator()(const DecayChannel* dc) const
    { return dc == DecayChannel_; }

    const bool operator()(const DecayingParticle& dp) const override;

private:
    const DecayChannel* DecayChannel_;
};

class has_spin_amplitude : public filter_spin_amplitude
{
public:
    has_spin_amplitude(const SpinAmplitude* sa)
        : filter_spin_amplitude(), SpinAmplitude_(sa) {}

    using filter_spin_amplitude::operator();

    const bool operator()(const FreeAmplitude& fa) const override;

    const bool operator()(const SpinAmplitude& sa) const override
    { return operator()(&sa); }

    const bool operator()(const std::shared_ptr<SpinAmplitude>& sa) const
    { return operator()(sa.get()); }

    const bool operator()(const SpinAmplitude* sa) const
    { return sa == SpinAmplitude_; }

private:
    const SpinAmplitude* SpinAmplitude_;
};

class to : public filter_decay_channel, public filter_decaying_particle
{
public:

    to(const ParticleVector& daughters)
        : filter_decay_channel(), filter_decaying_particle(), Daughters_(daughters)
    {
        if (std::any_of(Daughters_.begin(), Daughters_.end(), std::logical_not<ParticleVector::value_type>()))
            throw exceptions::Exception("nullptr daughter provided", "to::to");
    }

    template <typename ... Others>
    to(std::shared_ptr<Particle> A, Others ... others)
        : filter_decay_channel(), filter_decaying_particle()
    {
        Daughters_ = {A, others...};
        if (std::any_of(Daughters_.begin(), Daughters_.end(), std::logical_not<ParticleVector::value_type>()))
            throw exceptions::Exception("nullptr daughter provided", "to::to");
    }

    using filter_decay_channel::operator();
    using filter_decaying_particle::operator();

    virtual const bool operator()(const DecayChannel& dc) const override;

    virtual const bool operator()(const DecayingParticle& dp) const override;

protected:

    ParticleVector Daughters_;

};

class exactly_to : public to
{
public:
    exactly_to(const ParticleVector& daughters) : to(daughters) {}

    template <typename ... Others>
    exactly_to(const ParticleVector::value_type& A, Others ... others)
        : to(A, others...) {}

    using to::operator();

    virtual const bool operator()(const DecayChannel& dc) const override;
};

class l_equals : public filter_spin_amplitude
{
public:

    l_equals(unsigned l) : filter_spin_amplitude(), L_(l) {}

    using filter_spin_amplitude::operator();

    virtual const bool operator()(const SpinAmplitude& sa) const override;

private:

    unsigned L_;

};

class m_equals : filter_free_amplitude
{
public:

    m_equals(int two_m) : filter_free_amplitude(), TwoM_(two_m) {}

    using filter_free_amplitude::operator();

    virtual const bool operator()(const FreeAmplitude& fa) const override;

private:

    int TwoM_;

};

class is_named
{
public:
    is_named(std::string name) : Name_(name) {}

    template <typename T>
    const bool operator()(const T& t) const
    { return t.name() == Name_; }

private:
    std::string Name_;
};

class has_decay_tree : public filter_decaying_particle, public filter_decay_tree
{
public:
    has_decay_tree(const DecayTree* dt)
        : filter_decaying_particle(), filter_decay_tree(), DecayTree_(dt) {}

    using filter_decaying_particle::operator();
    using filter_decay_tree::operator();

    const bool operator()(const DecayTree& dt) const
    { return operator()(&dt); }

    const bool operator()(const std::shared_ptr<DecayTree>& dt) const
    { return operator()(dt.get()); }

    const bool operator()(const DecayTree* dt) const
    { return dt == DecayTree_; }

    const bool operator()(const DecayingParticle& dp) const;

private:
    const DecayTree* DecayTree_;
};

class has_free_amplitude : public filter_decaying_particle, public filter_free_amplitude
{
public:
    has_free_amplitude(const FreeAmplitude* fa)
        : filter_decaying_particle(), filter_free_amplitude(), FreeAmplitude_(fa) {}

    using filter_decaying_particle::operator();
    using filter_free_amplitude::operator();

    const bool operator()(const DecayTree& dt) const override;

    const bool operator()(const DecayingParticle& dp) const override;

    const bool operator()(const FreeAmplitude& fa) const override
    { return operator()(&fa); }

    const bool operator()(const std::shared_ptr<FreeAmplitude>& fa) const
    { return operator()(fa.get()); }

    const bool operator()(const FreeAmplitude* fa) const
    { return fa == FreeAmplitude_; }

private:
    const FreeAmplitude* FreeAmplitude_;
};

class from : public filter_decay_channel, public filter_particle
{
public:
    from(const DecayingParticle& dp)
        : filter_decay_channel(), filter_particle(), DecayingParticle_(&dp) {}

    from(const std::shared_ptr<DecayingParticle>& dp)
        : filter_decay_channel(), filter_particle(), DecayingParticle_(dp.get()) {}

    using filter_decay_channel::operator();
    using filter_particle::operator();

    const bool operator()(const DecayTree& dt) const override
    { return has_decay_tree(&dt)(*DecayingParticle_); }

    const bool operator()(const FreeAmplitude& fa) const override
    { return has_free_amplitude(&fa)(*DecayingParticle_); }

    const bool operator()(const DecayChannel& dc) const override
    { return has_decay_channel(&dc)(*DecayingParticle_); }

    const bool operator()(const Particle& p) const override;

private:
    const DecayingParticle* DecayingParticle_;
};


class has_mass : public filter_mass_shape
{
public:
    has_mass() : filter_mass_shape() {}

    using filter_mass_shape::operator();

    virtual const bool operator()(const Particle& p) const override;

    const bool operator()(const FinalStateParticle& p) const
    { return true; }

    virtual const bool operator()(const MassShape& m) const override;

    const bool operator()(const MassShapeWithNominalMass& m) const
    { return true; }

};

// end of defgroup filters

}

#endif