MatchboxHybridAmplitude.h

// -*- C++ -*-
//
// MatchboxHybridAmplitude.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_MatchboxHybridAmplitude_H
#define Herwig_MatchboxHybridAmplitude_H
//
// This is the declaration of the MatchboxHybridAmplitude class.
//
 
#include "Herwig/MatrixElement/Matchbox/Base/MatchboxAmplitude.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class MatchboxHybridAmplitude: public Herwig::MatchboxAmplitude {
 
public:
 
  MatchboxHybridAmplitude();
 
public:
 
  Ptr<MatchboxAmplitude>::tptr treeLevelAmplitude() const { return theTreeLevelAmplitude; }
 
  void treeLevelAmplitude(Ptr<MatchboxAmplitude>::tptr amp) { theTreeLevelAmplitude = amp; }
 
  virtual Ptr<MatchboxAmplitude>::tptr oneLoopAmplitude() const { return theOneLoopAmplitude; }
 
  void oneLoopAmplitude(Ptr<MatchboxAmplitude>::tptr amp) { theOneLoopAmplitude = amp; }
 
  bool isConsistent() const;
 
public:
 
 
  virtual bool canHandle(const PDVector& p,
                         Ptr<MatchboxFactory>::tptr f,
                         bool virt) const;
 
  virtual int nDimAdditional() const {
    if ( !oneLoopAmplitude() )
      return treeLevelAmplitude()->nDimAdditional();
    return
      treeLevelAmplitude()->nDimAdditional() ?
      treeLevelAmplitude()->nDimAdditional() :
      oneLoopAmplitude()->nDimAdditional();
  }
 
  virtual Ptr<MatchboxMEBase>::ptr makeME(const PDVector& p) const {
    return treeLevelAmplitude()->makeME(p);
  }
 
  virtual void orderInGs(unsigned int n) {
    treeLevelAmplitude()->orderInGs(n);
    if ( oneLoopAmplitude() )
      oneLoopAmplitude()->orderInGs(n);
  }
 
  virtual unsigned int orderInGs() const {
    return treeLevelAmplitude()->orderInGs();
  }
 
  virtual void orderInGem(unsigned int n) {
    treeLevelAmplitude()->orderInGem(n);
    if ( oneLoopAmplitude() )
      oneLoopAmplitude()->orderInGem(n);
  }
 
  virtual unsigned int orderInGem() const {
    return treeLevelAmplitude()->orderInGem();
  }
 
  virtual bool hasInitialAverage() const { 
    return treeLevelAmplitude()->hasInitialAverage();
  }
 
  virtual bool hasFinalStateSymmetry() const {
    return treeLevelAmplitude()->hasFinalStateSymmetry();
  }
 
  virtual bool isOLPTree() const { return false; }
 
  virtual bool isOLPLoop() const { 
    if ( !oneLoopAmplitude() )
      return false;
    return oneLoopAmplitude()->isOLPLoop();
  }
 
  virtual bool needsOLPCorrelators() const { 
    return theUseOLPCorrelators;
  }
 
  virtual bool startOLP(const map<pair<Process,int>,int>& procs) {
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->startOLP(procs);
  }
 
  virtual bool isExternal() const { 
    return treeLevelAmplitude()->isExternal();
  }
 
  virtual bool initializeExternal() {
    return treeLevelAmplitude()->initializeExternal();
  }
 
  virtual int externalId(const cPDVector& proc) { 
    return treeLevelAmplitude()->externalId(proc);
  }
 
 
 
  virtual Ptr<ColourBasis>::tptr colourBasis() const { 
    return treeLevelAmplitude()->colourBasis();
  }
 
  virtual bool haveColourFlows() const { 
    return treeLevelAmplitude()->haveColourFlows();
  }
 
  virtual Selector<const ColourLines *> colourGeometries(tcDiagPtr diag) const {
    return treeLevelAmplitude()->colourGeometries(diag);
  }
 
 
 
  virtual void setXComb(tStdXCombPtr xc) {
    treeLevelAmplitude()->setXComb(xc);
    if ( oneLoopAmplitude() )
      oneLoopAmplitude()->setXComb(xc);
    lastMatchboxXComb(xc);
  }
 
  virtual void fillCrossingMap(size_t shift = 0) {
    treeLevelAmplitude()->fillCrossingMap(shift);
  }
 
 
 
  virtual void prepareAmplitudes(Ptr<MatchboxMEBase>::tcptr);
 
  virtual double me2() const {
    return treeLevelAmplitude()->me2();
  }
 
  virtual double largeNME2(Ptr<ColourBasis>::tptr largeNBasis) const {
    return treeLevelAmplitude()->largeNME2(largeNBasis);
  }
 
  virtual double colourCorrelatedME2(pair<int,int> ij) const {
    return 
      theUseOLPCorrelators ?
      oneLoopAmplitude()->colourCorrelatedME2(ij) :
      treeLevelAmplitude()->colourCorrelatedME2(ij);
  }
 
  virtual double largeNColourCorrelatedME2(pair<int,int> ij,
                                           Ptr<ColourBasis>::tptr largeNBasis) const {
    return treeLevelAmplitude()->largeNColourCorrelatedME2(ij,largeNBasis);
  }
 
  virtual LorentzVector<Complex> plusPolarization(const Lorentz5Momentum& p,
                                                  const Lorentz5Momentum& n,
                                                  int id = -1) const {
    return 
      theUseOLPCorrelators ?
      oneLoopAmplitude()->plusPolarization(p,n,id) :
      treeLevelAmplitude()->plusPolarization(p,n,id);
  }
 
  virtual double spinColourCorrelatedME2(pair<int,int> emitterSpectator,
                                         const SpinCorrelationTensor& c) const {
    return 
      theUseOLPCorrelators ?
      oneLoopAmplitude()->spinColourCorrelatedME2(emitterSpectator,c) :
      treeLevelAmplitude()->spinColourCorrelatedME2(emitterSpectator,c);
  }
 
  virtual double spinCorrelatedME2(pair<int,int> emitterSpectator,
                                   const SpinCorrelationTensor& c) const {
    return 
      theUseOLPCorrelators ?
      oneLoopAmplitude()->spinCorrelatedME2(emitterSpectator,c) :
      treeLevelAmplitude()->spinCorrelatedME2(emitterSpectator,c);
  }
 
  virtual bool canFillRhoMatrix() const { 
    return treeLevelAmplitude()->canFillRhoMatrix();
  }
 
  virtual vector<unsigned int> physicalHelicities(const vector<int>& hel) const {
    return treeLevelAmplitude()->physicalHelicities(hel);
  }
 
  virtual bool treeAmplitudes() const { 
    return treeLevelAmplitude()->treeAmplitudes();
  }
 
  virtual Complex evaluate(size_t a, const vector<int>& hel, Complex& largeN) { 
    return treeLevelAmplitude()->evaluate(a,hel,largeN);
  }
 
 
 
  virtual void disableOneLoop() { oneLoopAmplitude(Ptr<MatchboxAmplitude>::ptr()); }
 
  virtual bool haveOneLoop() const { return oneLoopAmplitude(); }
 
  virtual bool onlyOneLoop() const { return false; }
 
  virtual bool oneLoopAmplitudes() const { 
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->oneLoopAmplitudes();
  }
 
  virtual bool isDRbar() const { 
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->isDRbar();
  }
 
  virtual bool isDR() const { 
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->isDR();
  }
 
  virtual bool isCS() const { 
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->isCS();
  }
 
  virtual bool isBDK() const { 
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->isBDK();
  }
 
  virtual bool isExpanded() const { 
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->isExpanded();
  }
 
  virtual Energy2 mu2() const {
    assert(oneLoopAmplitude()); 
    return oneLoopAmplitude()->mu2();
  }
 
  double symmetryRatio() const;
 
  virtual bool hasRunningAlphaS() const { 
    return treeLevelAmplitude()->hasRunningAlphaS();
  }
 
  virtual bool hasRunningAlphaEW() const { 
    return treeLevelAmplitude()->hasRunningAlphaEW();
  }
 
  virtual double oneLoopDoublePole() const { 
    assert(oneLoopAmplitude());
    return symmetryRatio()*oneLoopAmplitude()->oneLoopDoublePole();
  }
 
  virtual double oneLoopSinglePole() const { 
    assert(oneLoopAmplitude());
    return symmetryRatio()*oneLoopAmplitude()->oneLoopSinglePole();
  }
 
  virtual void prepareOneLoopAmplitudes(Ptr<MatchboxMEBase>::tcptr);
 
  virtual double oneLoopInterference() const {
    assert(oneLoopAmplitude());
    return symmetryRatio()*oneLoopAmplitude()->oneLoopInterference();
  }
 
  virtual Complex evaluateOneLoop(size_t a, const vector<int>& hel) { 
    assert(oneLoopAmplitude());
    return oneLoopAmplitude()->evaluateOneLoop(a,hel);
  }
 
 
 
  virtual void flushCaches() {
    treeLevelAmplitude()->flushCaches();
    if ( oneLoopAmplitude() )
      oneLoopAmplitude()->flushCaches();
  }
 
  virtual void cloneDependencies(const std::string& prefix= "" , bool slim=false);
 
protected:
 
 
  virtual void doinit();
 
  virtual void doinitrun();
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
 
private:
 
  Ptr<MatchboxAmplitude>::ptr theTreeLevelAmplitude;
 
  Ptr<MatchboxAmplitude>::ptr theOneLoopAmplitude;
 
  bool theUseOLPCorrelators;
 
  MatchboxHybridAmplitude & operator=(const MatchboxHybridAmplitude &) = delete;
 
};
 
}
 
#endif /* Herwig_MatchboxHybridAmplitude_H */