CoherentSum.h

Go to the documentation of this file.

#ifndef AMPGEN_COHERENTSUM_H
#define AMPGEN_COHERENTSUM_H
 
#include <memory.h>
#include <stddef.h>
#include <complex>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "AmpGen/AmplitudeRules.h"
#include "AmpGen/MatrixElement.h"
#include "AmpGen/CompiledExpression.h"
#include "AmpGen/EventList.h"
#include "AmpGen/EventListSIMD.h"
#include "AmpGen/EventType.h"
#include "AmpGen/Integrator.h"
#include "AmpGen/Types.h"
#include "AmpGen/Event.h"
#include "AmpGen/Projection.h"
#include "AmpGen/MinuitParameter.h"
#include "AmpGen/Store.h"
#include "AmpGen/KeyedFunctors.h"
#include "AmpGen/Property.h"
 
namespace AmpGen {
  class LinearErrorPropagator;
  class MinuitParameterSet;
  class FitFraction;
  class Particle;

  class CoherentSum : public Configurable<CoherentSum> {
  public:
#if ENABLE_AVX
    using EventList_type = EventListSIMD;
#else
    using EventList_type = EventList;
#endif
    CoherentSum();
    CoherentSum(const EventType &type, const AmpGen::MinuitParameterSet &mps, const std::string &prefix = "");
    virtual ~CoherentSum();
 
    std::string prefix() const { return m_prefix; }
 
    auto &operator[](const size_t &index) { return m_matrixElements[index]; }
    auto &operator[](const size_t &index) const { return m_matrixElements[index]; }
    size_t size() const { return m_matrixElements.size(); }
    real_t getWeight() const { return m_weight; }
    real_t norm(const Bilinears &norms) const;
    real_t norm() const;
    real_t getNorm(const Bilinears &normalisations);
 
    complex_t norm(const size_t &x, const size_t &y) const;
    complex_t getVal(const Event &evt) const;
    complex_t getValNoCache(const Event &evt) const;
 
    void transferParameters();
    void prepare();
    void printVal(const Event &evt);
    void updateNorms();
    void setWeight(MinuitProxy param) { m_weight = param; }
    void makeTotalExpression();
    void reset(bool resetEvents = false);
    void setEvents(const EventList_type &list);
    void setMC(const EventList_type &sim);
#if ENABLE_AVX
    void setEvents(const EventList &list) {
      WARNING("Setting events from a AoS container, will need to make a copy");
      m_ownEvents = true;
      setEvents(*(new EventListSIMD(list)));
    }
    void setMC(const EventList &list) {
      WARNING("Setting integration events from a AoS container, will need to make a copy");
      setMC(*(new EventListSIMD(list)));
    }
    // double operator()(const double*, const unsigned) const;
#endif
 
    real_v operator()(const real_v *, const unsigned) const;
    real_t operator()(const Event &evt) const { return m_weight * std::norm(getVal(evt)) / m_norm; }
 
    void debug(const Event &, const std::string & = "");
    void generateSourceCode(const std::string &, const double & = 1, bool = false);
 
    std::vector<FitFraction> fitFractions(const LinearErrorPropagator &, bool = false);
    auto matrixElements() const { return m_matrixElements; }
 
    std::map<std::string, std::vector<unsigned int>> getGroupedAmplitudes();
    Bilinears norms() const { return m_normalisations; }
 
    std::function<real_t(const Event &)> evaluator(const EventList_type * = nullptr) const;
    std::function<complex_t(const Event &)> amplitudeEvaluator(const EventList_type * = nullptr) const;
    KeyedFunctors<double(Event)> componentEvaluator(const EventList_type * = nullptr) const;
    EventType eventType() const { return m_eventType; }
    const auto &cache() const { return m_cache; }
 
  protected:
    //    Property<int> m_verbose{this, "CoherentSum::Verbose", 0, "Flag for verbose printing"};
 
    std::vector<MatrixElement> m_matrixElements;                      
    Bilinears m_normalisations;                                       
    Integrator m_integrator;                                          
    const EventList_type *m_events = {nullptr};                       
    FunctionCache<EventList_type, complex_v, Alignment::AoS> m_cache; 
 
    bool m_ownEvents = {false};          
    EventType m_eventType;               
    size_t m_prepareCalls = {0};         
    size_t m_lastPrint = {0};            
    MinuitProxy m_weight = {nullptr, 1}; 
    double m_norm = {1};                 
    bool m_isConstant = {false};         
    bool m_verbosity = {false};          
    std::string m_prefix = {""};         
    const MinuitParameterSet *m_mps = {nullptr};
    void addMatrixElement(std::pair<Particle, TotalCoupling> &particleWithCoupling, const MinuitParameterSet &mps);
  };
} // namespace AmpGen
 
#endif