FourPionCzyzCurrent.h

// -*- C++ -*-
//
// FourPionCzyzCurrent.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
#ifndef Herwig_FourPionCzyzCurrent_H
#define Herwig_FourPionCzyzCurrent_H
//
// This is the declaration of the FourPionCzyzCurrent class.
//
 
#include "WeakCurrent.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
 
class FourPionCzyzCurrent: public WeakCurrent {
 
public:
 
  FourPionCzyzCurrent();
 
  virtual bool createMode(int icharge, tcPDPtr resonance,
                          FlavourInfo flavour,
                          unsigned int imode,PhaseSpaceModePtr mode,
                          unsigned int iloc,int ires,
                          PhaseSpaceChannel phase, Energy upp );
 
  virtual tPDVector particles(int icharge, unsigned int imode, int iq, int ia);
 
  virtual vector<LorentzPolarizationVectorE> 
  current(tcPDPtr resonance, FlavourInfo flavour,
          const int imode, const int ichan,Energy & scale,
          const tPDVector & outgoing,
          const vector<Lorentz5Momentum> & momenta,
          DecayIntegrator::MEOption meopt) const;
 
  virtual bool accept(vector<int> id);
 
  virtual unsigned int decayMode(vector<int> id);
 
  virtual void dataBaseOutput(ofstream & os,bool header,bool create) const;
  
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  void createChannels(unsigned int imode,
                      int icharge,  tcPDPtr resonance,
                      unsigned int iloc,int ires,
                      tPDVector outgoing, PhaseSpaceModePtr mode,
                      PhaseSpaceChannel channel,
                      unsigned int j1, unsigned int j2,
                      unsigned int j3, unsigned int j4,
                      int & nchan);
  
  LorentzVector<complex<InvEnergy> > baseCurrent(Energy2 Q2,
                                                 tcPDPtr resonance,
                                                 const int ichan,
                                                 const Lorentz5Momentum & Q,
                                                 const Lorentz5Momentum & q1,
                                                 const Lorentz5Momentum & q2,
                                                 const Lorentz5Momentum & q3,
                                                 const Lorentz5Momentum & q4) const;
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
 
 
  virtual void doinit();
 
private:
 
  FourPionCzyzCurrent & operator=(const FourPionCzyzCurrent &) = delete;
 
private:
 
  vector<Energy> rhoMasses_;
  vector<Energy> rhoWidths_;
  
  vector<Energy> rhoMasses_Frho_;
  vector<Energy> rhoWidths_Frho_;
  
  Energy omegaMass_;
  Energy omegaWidth_;
  
  Energy f0Mass_;
  Energy f0Width_;
  
  Energy a1Mass_;
  Energy a1Width_;
 
  vector<double> beta_a1_;
  
  vector<double> beta_f0_;
  
  vector<double> beta_omega_;
  
  vector<double> beta_B_;
  
  vector<double> beta_bar_;
 
  InvEnergy2 c_a1_;
 
  InvEnergy2 c_f0_;
 
  InvEnergy c_omega_;
 
  double c_rho_;
 
  double g_rho_pi_pi_;
 
  ThePEG::Qty<std::ratio<0,1>, std::ratio<-5,1>, std::ratio<0,1> > g_omega_pi_rho_;
 
  Energy2 g_rho_gamma_;
 
  Energy mpip_, mpi0_;
 
  vector<vector<int> > channelMap_;
};
 
}
 
#endif /* Herwig_FourPionCzyzCurrent_H */