PolarisedSum.h

Go to the documentation of this file.

#ifndef AMPGEN_POLARISEDAMPLITUDE_H
#define AMPGEN_POLARISEDAMPLITUDE_H
 
#include <stddef.h>
#include <complex>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <array>
 
#include "AmpGen/Types.h"
#include "AmpGen/AmplitudeRules.h"
#include "AmpGen/CompiledExpression.h"
#include "AmpGen/EventList.h"
#include "AmpGen/EventType.h"
#include "AmpGen/Integrator.h"
#include "AmpGen/CoherentSum.h"
#include "AmpGen/Expression.h"
#include "AmpGen/Tensor.h"
#include "AmpGen/MinuitParameter.h"
#include "AmpGen/enum.h"
#include "AmpGen/Configurable.h"
 
namespace AmpGen {
  class LinearErrorPropagator;
  class MinuitParameterSet;
  class FitFraction;
  class MinuitProxy;
  make_enum(spaceType, spin, flavour);
 
  class PolarisedSum : public Configurable<PolarisedSum> {
  public:
#if ENABLE_AVX
    using EventList_type = EventListSIMD;
#else
    using EventList_type = EventList;
#endif
 
    PolarisedSum() = default;
    virtual ~PolarisedSum();
    PolarisedSum(const EventType &, MinuitParameterSet &, const std::vector<MinuitProxy> & = {});
    void prepare();
    void setEvents(EventList_type &);
    void setMC(EventList_type &);
#if ENABLE_AVX
    void setEvents(EventList &evts) {
      m_ownEvents = true;
      setEvents(*new EventList_type(evts));
    };
    void setMC(EventList &evts) { setMC(*new EventList_type(evts)); };
    double operator()(const double *, const unsigned) const;
#endif
    real_v operator()(const real_v *, const unsigned) const;
    real_t operator()(const Event &evt) const;
    void reset(const bool & = false);
    void debug(const Event &);
    void debug_norm();
    void setWeight(MinuitProxy);
    double getWeight() const;
    void updateNorms();
    void generateSourceCode(const std::string &, const double & = 1, bool = false);
    Expression probExpression(const Tensor &, const std::vector<Expression> &, const std::vector<Expression> &, DebugSymbols * = nullptr) const;
    size_t size() const;
    real_t norm() const;
    complex_t norm(const size_t &, const size_t &, Integrator * = nullptr);
    real_t getValNoCache(const Event &) const;
    std::vector<FitFraction> fitFractions(const LinearErrorPropagator &, bool = false, bool = false);
    std::vector<MatrixElement> matrixElements() const;
    void transferParameters();
    Tensor transitionMatrix() const;
    const MatrixElement &operator[](const size_t &i) const { return m_matrixElements[i]; }
    std::function<real_t(const Event &)> evaluator(const EventList_type * = nullptr) const;
    KeyedFunctors<double(Event)> componentEvaluator(const EventList_type * = nullptr) const;
    EventType eventType() const { return m_eventType; }
    auto cache() { return m_cache; }
 
  private:
    size_t m_nCalls = {0};
    real_t m_norm = {1};
    EventList_type *m_events = {nullptr};
    FunctionCache<EventList_type, complex_v, Alignment::AoS> m_cache = {};
    FunctionCache<FunctionCache<EventList_type, complex_v, Alignment::AoS>, real_v, Alignment::AoS> m_pdfCache = {};
    bool m_ownEvents = {false};
    MinuitParameterSet *m_mps = {nullptr};
    MinuitProxy m_weight = {nullptr, 1};
    MinuitProxy m_polParam = {nullptr};
    std::vector<MinuitProxy> m_pVector = {};
    std::vector<MinuitProxy> m_pfVector = {};
    Integrator m_integrator;
    std::vector<Bilinears> m_norms;
    EventType m_eventType;
    std::string m_prefix = "";
    std::vector<complex_t> m_rho;
    std::vector<size_t> m_integIndex;
    std::pair<unsigned, unsigned> m_dim;
    std::vector<MatrixElement> m_matrixElements;
    CompiledExpression<real_v(const real_t *, const complex_v *)> m_probExpression;
 
    Property<spaceType> m_spaceType{this, "PolarisedSum::SpaceType", spaceType::spin};
  };
} // namespace AmpGen
 
#endif