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"
namespace AmpGen
{
  class LinearErrorPropagator;
  class MinuitParameterSet;
  class FitFraction;
  class Particle;

  class 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& evt, const std::string& nameMustContain="");
    void generateSourceCode( const std::string& fname, const double& normalisation = 1, bool add_mt = false );
 
    std::vector<FitFraction> fitFractions( const LinearErrorPropagator& linProp );
    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:
    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};                    
    size_t           m_printFreq    = {0};                    
    MinuitProxy      m_weight       = {nullptr, 1};           
    double           m_norm         = {1};                    
    bool             m_isConstant   = {false};                
    bool             m_dbThis       = {false};                
    bool             m_verbosity    = {false};                
    std::string      m_objCache     = {""};                   
    std::string      m_prefix       = {""};                   
    const MinuitParameterSet* m_mps = {nullptr};
    void addMatrixElement( std::pair<Particle, TotalCoupling>& particleWithCoupling, const MinuitParameterSet& mps );
  };
} // namespace AmpGen
 
#endif