HardBranching.h

// -*- C++ -*-
#ifndef HERWIG_HardBranching_H
#define HERWIG_HardBranching_H
//
// This is the declaration of the HardBranching class.
//
 
#include "ThePEG/Config/ThePEG.h"
#include "Herwig/Shower/QTilde/Base/ShowerProgenitor.h"
#include "Herwig/Shower/QTilde/Base/ShowerTree.h"
#include "Herwig/Shower/QTilde/SplittingFunctions/SudakovFormFactor.h"
#include "HardBranching.fh"
#include "HardTree.fh"
 
namespace Herwig {
 
using namespace ThePEG;
 
class HardBranching : public Base {
 
  friend class HardTree;
 
public:
 
  enum Status {Outgoing=0,Incoming,Decay};
 
public:
 
  HardBranching(ShowerParticlePtr particle, SudakovPtr sudakov,
                tHardBranchingPtr parent,Status status);
 
  void addChild(HardBranchingPtr child) {_children.push_back(child);} 
 
  void clearChildren() { _children.clear(); }
 
  void setMomenta(LorentzRotation R, double alpha, Lorentz5Momentum pt,
                  bool setMomentum=true);
 
  tShowerParticlePtr branchingParticle() const {return _particle;}
 
  void branchingParticle(ShowerParticlePtr in) {_particle=in;}
 
  const Lorentz5Momentum & original() const {return _original;}
 
  void original(const Lorentz5Momentum & in) {_original=in;}
 
  const Lorentz5Momentum & pVector() const {return _p;}
 
  void pVector(const Lorentz5Momentum & in) {_p=in;}
 
  const Lorentz5Momentum & nVector() const {return _n;}
 
  void nVector(const Lorentz5Momentum & in) {_n=in;}
 
  const Lorentz5Momentum & qPerp() const {return _qt;}
 
  void qPerp(const Lorentz5Momentum & in) {_qt=in;}
 
  const Lorentz5Momentum & showerMomentum() const {return _shower;}
 
  void showerMomentum(const Lorentz5Momentum & in ) {_shower=in;}
 
  Energy pT() const {return _pt;}
 
  void pT(Energy in) { _pt=in;}
 
  double x_frac() const {return _x_frac;}
 
  void x_frac( double x ) { _x_frac = x; }
 
  Status status() const {return _status;}
 
  void status(Status in) {_status=in;}
 
  tHardBranchingPtr parent() const {return _parent;}
 
  void parent(tHardBranchingPtr in) {_parent=in;}
 
  SudakovPtr sudakov() const {return _sudakov;}
 
  void sudakov(SudakovPtr in) {_sudakov=in;}
 
  PPtr beam() const {return _beam;}
 
  void beam(PPtr in) {_beam=in;}
 
  vector<HardBranchingPtr> & children() {return _children;}
 
  Energy scale() const {return _scale;}
 
  void scale(Energy in) {_scale=in;}
 
  double z() const {return _z;}
 
  void z(double in) {_z=in;}
 
  double phi() const {return _phi;}
 
  void phi(double in) {_phi=in;}
 
  tHardBranchingPtr colourPartner() const {return _partner;}
 
  void colourPartner(tHardBranchingPtr in) {_partner=in;}
 
 
  ShowerPartnerType type() const {
    assert(type_!=ShowerPartnerType::Undefined);
    return type_;
  }
 
  void type(ShowerPartnerType in) {
    type_ = in;
    assert(type_!=ShowerPartnerType::Undefined);
  }
 
private:
 
  ShowerParticlePtr _particle;
 
  Lorentz5Momentum _original;
 
  Lorentz5Momentum _p;
 
  Lorentz5Momentum _n;
 
  Lorentz5Momentum _qt;
 
  Lorentz5Momentum _shower;
 
  Energy _pt; 
 
  double _x_frac;
 
  Status _status;
 
  Energy _scale;
 
  double _z;
 
  double _phi;
 
  tHardBranchingPtr _parent;
 
  SudakovPtr _sudakov;
 
  vector<HardBranchingPtr> _children;
 
  PPtr _beam;
 
  tHardBranchingPtr _partner;
 
  ShowerPartnerType type_;
};
 
}
 
#endif /* HERWIG_HardBranching_H */