ParticleCombination.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_ParticleCombination_h
#define yap_ParticleCombination_h

#include "fwd/ParticleCombination.h"

#include "fwd/Model.h"

#include <algorithm>
#include <functional>
#include <memory>
#include <ostream>
#include <string>
#include <vector>

namespace yap {

class ParticleCombination : public std::enable_shared_from_this<ParticleCombination>
{
private:

    ParticleCombination() = default;

    ParticleCombination(unsigned index) : Indices_(1, index) {}

    ParticleCombination(const ParticleCombination&) = delete;

    ParticleCombination(ParticleCombination&&) = delete;

    ParticleCombination& operator=(const ParticleCombination&) = delete;

    ParticleCombination& operator=(ParticleCombination&&) = delete;

public:


    const std::vector<unsigned>& indices() const
    { return Indices_; }

    const ParticleCombinationVector& daughters() const
    { return Daughters_; }

    std::shared_ptr<ParticleCombination> parent() const
    { return Parent_.lock(); }


    bool consistent() const;

    friend class ParticleCombinationCache;

protected:

    void addDaughter(std::shared_ptr<ParticleCombination> daughter);

private:

    std::weak_ptr<ParticleCombination> Parent_;

    ParticleCombinationVector Daughters_;

    std::vector<unsigned> Indices_;

};


constexpr bool equal_always(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B)
{ return true; }

inline bool equal_by_shared_pointer(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B)
{ return A == B; }

bool equal_by_ordered_content(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B);

bool equal_by_orderless_content(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B);

bool equal_down(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B);

bool equal_up(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B);

bool equal_up_and_down(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B);

bool equal_down_by_orderless_content(const std::shared_ptr<const ParticleCombination>& A, const std::shared_ptr<const ParticleCombination>& B);


bool disjoint(const ParticleCombinationVector& pcv);

inline const bool is_final_state_particle_combination(const ParticleCombination& pc)
{ return pc.daughters().empty() and pc.indices().size() == 1; }

inline const ParticleCombination& origin(const ParticleCombination& pc)
{ return pc.parent() ? origin(*pc.parent()) : pc; }

const bool is_initial_state_particle_combination(const ParticleCombination& pc, const Model& m);

inline const bool is_from_initial_state_particle_combination(const ParticleCombination& pc, const Model& m)
{ return is_initial_state_particle_combination(origin(pc), m); }

void prune_particle_combinations(ParticleCombinationSet& PCs);

std::string indices_string(const ParticleCombination& pc, std::string before = "(", std::string after = ")");

std::string to_string(const ParticleCombination& pc);

std::string to_string_with_parent(const ParticleCombination& pc);

inline std::ostream& operator<<(std::ostream& os, const ParticleCombination& PC)
{ os << to_string(PC); return os; }

}

#endif