DalitzBase.h

// -*- C++ -*-
#ifndef Herwig_DalitzBase_H
#define Herwig_DalitzBase_H
//
// This is the declaration of the DalitzBase class.
//
 
#include "Herwig/Decay/DecayIntegrator.h"
#include "Herwig/Decay/FormFactors/KMatrix.h"
#include "DalitzResonance.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class DalitzBase: public DecayIntegrator {
 
public:
 
  DalitzBase() : rParent_(5./GeV), useAllK0_(false),
                 maxWgt_(1.), channel1_(-1), channel2_(-1),
                 incoming_(0), outgoing_({0,0,0}) {
    // intermediates
    generateIntermediates(true);
  }
 
  virtual int modeNumber(bool & cc, tcPDPtr parent, 
                         const tPDVector & children) const;
 
  virtual void dataBaseOutput(ofstream & os,bool header) const;
 
  string addChannel(string arg);
 
  string setExternal(string arg);
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  void addResonance(const DalitzResonancePtr & R) {resonances_.push_back(R);}
 
  void createMode(tPDPtr in, tPDVector out);
 
  const vector<DalitzResonancePtr> & resonances() const {return resonances_;}
 
  const int & channel1() const {
    return channel1_;
  }
    
  const int & channel2() const {
    return channel2_;
  }
 
  const InvEnergy & parentRadius() const {
    return rParent_;
  }
 
  const vector<double> & weights() const {return weights_;}
      
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
private:
 
  DalitzBase & operator=(const DalitzBase &) = delete;
 
private:
 
  InvEnergy rParent_;
 
  bool useAllK0_;
 
  vector<DalitzResonancePtr> resonances_;
  
  vector<KMatrixPtr> kMatrix_;
  
  double maxWgt_;
 
  vector<double> weights_;
  
private:
 
  int channel1_, channel2_;
 
  long incoming_;
 
  array<long,3> outgoing_;
 
};
 
}
 
#endif /* Herwig_DalitzBase_H */