ScalarTo3ScalarDalitz.h

// -*- C++ -*-
#ifndef Herwig_ScalarTo3ScalarDalitz_H
#define Herwig_ScalarTo3ScalarDalitz_H
//
// This is the declaration of the ScalarTo3ScalarDalitz class.
//
 
#include "DalitzBase.h"
 
namespace Herwig {
using namespace ThePEG;
  
  
class ScalarTo3ScalarDalitz: public DalitzBase {
  
public:
 
  ScalarTo3ScalarDalitz() : useResonanceMass_(false)
  {}
 
  virtual double me2(const int ichan,const Particle & part,
                     const tPDVector & outgoing,
                     const vector<Lorentz5Momentum> & momenta,
                     MEOption meopt) const;
 
  virtual void constructSpinInfo(const Particle & part,
                                 ParticleVector outgoing) const;
 
  virtual void dataBaseOutput(ofstream & os,bool header) const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
protected:
  
  virtual Complex amplitude(int ichan) const {
    Complex amp(0.);
    int iloc=-1;
    for(int ix=0;ix<int(resonances().size());++ix) {
      ++iloc;
      if(channel1()>=0) {
        if(ix!=channel1() && ix!=channel2()) continue;
      }
      if(ichan>=0&&ichan!=iloc) continue;
      amp += resAmp(ix);
    }
    return amp;
  }
 
  Complex resAmp(unsigned int i) const;
 
  const Energy & mInv(unsigned int i,unsigned int j) const {
    return m2_[i][j];
  }
 
  const Energy & mOut(unsigned int i) const {
    return mOut_[i];
  }
 
private:
 
  ScalarTo3ScalarDalitz & operator=(const ScalarTo3ScalarDalitz &) = delete;
 
private:
 
  bool useResonanceMass_;
  
private :
 
  mutable Energy mD_;
 
  mutable Energy mOut_[3];
 
  mutable Energy m2_[3][3];
 
  mutable RhoDMatrix rho_;
};
 
}
 
#endif /* Herwig_ScalarTo3ScalarDalitz_H */