MadGraphAmplitude.h

// -*- C++ -*-
//
// MadGraphAmplitude.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_MadGraphAmplitude_H
#define Herwig_MadGraphAmplitude_H
//
// This is the declaration of the MadGraphAmplitude class.
//
 
#include "Herwig/MatrixElement/Matchbox/Base/MatchboxAmplitude.h"
#include "Herwig/MatrixElement/Matchbox/Builtin/Amplitudes/MatchboxCurrents.h"
#include "ThePEG/Utilities/DynamicLoader.h"
 
namespace Herwig {
 
 
using namespace ThePEG; 
 
class MadGraphAmplitude: 
    public MatchboxAmplitude {
 
public:
 
  MadGraphAmplitude();
 
  virtual ~MadGraphAmplitude();
 
public:
 
  virtual bool canHandle(const PDVector&,
                         Ptr<MatchboxFactory>::tptr,
                         bool) const;
 
  virtual bool hasFinalStateSymmetry() const { return false; }
 
  virtual void orderInGs(unsigned int ogs) { theOrderInGs = ogs; }
 
  virtual unsigned int orderInGs() const { return theOrderInGs; }
 
  virtual void orderInGem(unsigned int oge) { theOrderInGem = oge; }
 
  virtual unsigned int orderInGem() const { return theOrderInGem; }
 
  virtual bool haveOneLoop() const { return true; }
 
  virtual void prepareAmplitudes(Ptr<MatchboxMEBase>::tcptr);
  
  virtual void prepareOneLoopAmplitudes(Ptr<MatchboxMEBase>::tcptr);
 
  virtual Complex evaluate(size_t, const vector<int>&, Complex&);
 
  virtual bool oneLoopAmplitudes() const { return false; }
  
  virtual double oneLoopInterference() const;
  
  void evaloneLoopInterference() const;
 
 
  virtual bool isCS() const { return false; }
  virtual bool isExpanded() const { return true; }
  virtual bool isBDK() const { return false; }
  virtual bool isDR() const { return false; }
  virtual bool isDRbar() const {return false;}
 
  virtual Energy2 mu2() const { return sqr(91.18800000000*GeV);}
  //virtual Energy2 mu2() const { return lastSHat(); }
  
  
  virtual LorentzVector<Complex> plusPolarization(const Lorentz5Momentum& p,
                                                  const Lorentz5Momentum& n,
                                                  int id = -1) const;
  virtual double spinColourCorrelatedME2(pair<int,int> emitterSpectator,
                                         const SpinCorrelationTensor& c) const;
 
  vector<size_t> gluonsFirst(vector<size_t> i);
 
  virtual void flushCaches() {
    MatchboxAmplitude::flushCaches();
  }
 
  virtual bool isExternal() const { return true; }
 
  virtual bool initializeExternal();
 
  virtual int externalId(const cPDVector&);
      
  
  virtual bool writeAmplitudesDat();
      
  virtual bool checkAmplitudes();
      
  
  string mgProcLibPath();
 
  virtual bool canFillRhoMatrix() const { return true; }
 
  virtual vector<unsigned int> physicalHelicities(const vector<int>&) 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;
 
 
// If needed, insert declarations of virtual function defined in the
// InterfacedBase class here (using ThePEG-interfaced-decl in Emacs).
 
protected:
 
  virtual void doinit();
 
  virtual void doinitrun();
 
  unsigned int theOrderInGs;
 
  unsigned int theOrderInGem;
  
  static string theProcessPath;
  
  static string theMGmodel;
  
  bool keepinputtopmass;
 
 
  void initProcess(const cPDVector&);
 
 
  static vector<string>  BornAmplitudes,VirtAmplitudes;
   
  mutable vector<int>  colourindex, crossing;
  
        
  static bool ranMadGraphInitializeExternal;
  static bool initializedMad;
  
 
  
 
protected:
 
  static string bindir_;
 
  static string includedir_;
 
  static string pkgdatadir_;
 
  static string madgraphPrefix_;
      
  void setProcessPath(string );
  string getProcessPath() const;
      
  void setBinDir(string p);
  string getBinDir() const;
      
  void setDataDir(string p);
  string getDataDir() const;
     
  void setModel(string p);
  string getModel() const;
      
  void setMadgraphPrefix(string p);
  string getMadgraphPrefix() const ;
 
private:
 
  MadGraphAmplitude & operator=(const MadGraphAmplitude &) = delete;
 
 
};
 
}
 
#endif /* Herwig_MadGraphAmplitude_H */