NBodyDecayConstructorBase.h

// -*- C++ -*-
//
// NBodyDecayConstructorBase.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_NBodyDecayConstructorBase_H
#define HERWIG_NBodyDecayConstructorBase_H
//
// This is the declaration of the NBodyDecayConstructorBase class.
//
 
#include "ThePEG/Interface/Interfaced.h"
#include "ThePEG/Utilities/Exception.h"
#include "ThePEG/PDT/ParticleData.h"
#include "NBodyDecayConstructorBase.fh"
#include "PrototypeVertex.h"
#include "DecayConstructor.fh"
 
namespace Herwig {
 
using namespace ThePEG;
 
class NBodyDecayConstructorBase: public Interfaced {
 
public:
 
  struct MassOrdering {
    bool operator()(PDPtr p1, PDPtr p2) const {
      return p1->mass() < p2->mass() || (p1->mass()==p2->mass() && p1->id()>p2->id());
    }
  };
  
public:
 
  NBodyDecayConstructorBase() : 
    init_(true),iteration_(1), points_(1000), info_(false), 
    createModes_(true), removeOnShell_(1), excludeEffective_(true), 
    minReleaseFraction_(1e-3), maxBoson_(1), maxList_(1),
    includeTopOnShell_(false ), removeFlavourChangingVertices_(false),
    removeSmallVertices_(false), minVertexNorm_(1e-8) 
  {}
 
  virtual void DecayList(const set<PDPtr,MassOrdering> & particles);
 
  virtual unsigned int numBodies() const = 0;
 
  void decayConstructor(tDecayConstructorPtr d) { 
    decayConstructor_ = d;
  }
 
  bool removeFlavourChangingVertices() const {
    return removeFlavourChangingVertices_;
  }
 
  bool removeSmallVertices() const {
    return removeSmallVertices_;
  }
 
  double minVertexNorm() const {
    return minVertexNorm_;
  }
 
protected:
  
  virtual void createDecayMode(vector<NBDiagram> & mode,
                               bool possibleOnShell,
                               double symfac);
  
 
  void setBranchingRatio(tDMPtr dm, Energy pwidth);
 
  void setDecayerInterfaces(string name) const;
 
  bool initialize() const { return init_; }
  
  int iteration() const { return iteration_; }
 
  int points() const { return points_; }
 
  bool info() const { return info_; }
 
  bool createDecayModes() const { return createModes_; }
 
  unsigned int maximumGaugeBosons() const { return maxBoson_;}
 
  unsigned int maximumList() const { return maxList_;}
 
  double minimumReleaseFraction() const {return minReleaseFraction_;}
 
  tDecayConstructorPtr decayConstructor() const { 
    return decayConstructor_;
  }
 
  unsigned int removeOnShell() const { return removeOnShell_; }
 
  bool excluded(VertexBasePtr vertex) const {
    // skip an effective vertex
    if( excludeEffective_ &&
        vertex->orderInAllCouplings() != int(vertex->getNpoint())-2)
      return true;
    // check if explicitly forbidden
    return excludedVerticesSet_.find(vertex)!=excludedVerticesSet_.end();
  }
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual void doinit();
 
private:
 
  NBodyDecayConstructorBase & operator=(const NBodyDecayConstructorBase &) = delete;
 
private:
 
  bool init_;
  
  int iteration_;
 
  int points_;
 
  bool info_;
 
  bool createModes_;
 
  unsigned int removeOnShell_;
 
  vector<VertexBasePtr> excludedVerticesVector_;
 
  set<VertexBasePtr> excludedVerticesSet_;
 
  vector<PDPtr> excludedParticlesVector_;
 
  set<PDPtr> excludedParticlesSet_;
 
  bool excludeEffective_;
  
  tDecayConstructorPtr decayConstructor_;
 
  double minReleaseFraction_;
 
  unsigned int maxBoson_;
 
  unsigned int maxList_;
 
  bool includeTopOnShell_;
 
  bool removeFlavourChangingVertices_;
 
  bool removeSmallVertices_;
 
  double minVertexNorm_;
};
 
  class NBodyDecayConstructorError : public Exception {
 
  public:
 
    NBodyDecayConstructorError() : Exception() {}
    
    NBodyDecayConstructorError(const string & str,
                               Severity sev) : Exception(str,sev)
    {}
  };
 
}
 
#endif /* HERWIG_NBodyDecayConstructorBase_H */