Page MenuHomeHEPForge
Files F8724226

No OneTemporary
Actions

View Options

diff --git a/MatrixElement/Lepton/MEee2VectorMeson.cc b/MatrixElement/Lepton/MEee2VectorMeson.cc
--- a/MatrixElement/Lepton/MEee2VectorMeson.cc
+++ b/MatrixElement/Lepton/MEee2VectorMeson.cc
@@ -1,231 +1,228 @@
// -*- C++ -*-
//
// MEee2VectorMeson.cc is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2017 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.
//
//
// This is the implementation of the non-inlined, non-templated member
// functions of the MEee2VectorMeson class.
//
#include "MEee2VectorMeson.h"
#include "ThePEG/Utilities/DescribeClass.h"
#include "ThePEG/Interface/ClassDocumentation.h"
#include "ThePEG/Interface/Switch.h"
#include "ThePEG/Interface/Parameter.h"
#include "ThePEG/Interface/Reference.h"
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
#include "ThePEG/PDT/EnumParticles.h"
#include "ThePEG/MatrixElement/Tree2toNDiagram.h"
#include "ThePEG/Cuts/Cuts.h"
#include "Herwig/PDT/GenericMassGenerator.h"
#include "ThePEG/Handlers/StandardXComb.h"
+#include "Herwig/Models/StandardModel/StandardModel.h"
#include "Herwig/MatrixElement/HardVertex.h"
using namespace Herwig;
using namespace ThePEG;
using namespace ThePEG::Helicity;
-
void MEee2VectorMeson::getDiagrams() const {
tcPDPtr em = getParticleData(ParticleID::eminus);
tcPDPtr ep = getParticleData(ParticleID::eplus);
- add(new_ptr((Tree2toNDiagram(2), em, ep, 1, _vector,-1)));
+ add(new_ptr((Tree2toNDiagram(2), em, ep, 1, vector_,-1)));
}
Energy2 MEee2VectorMeson::scale() const {
return sHat();
}
int MEee2VectorMeson::nDim() const {
- return 1;
+ return 0;
}
void MEee2VectorMeson::setKinematics() {
- MEBase::setKinematics(); // Always call the base class method first.
+ MEBase::setKinematics();
}
-bool MEee2VectorMeson::generateKinematics(const double *r) {
+bool MEee2VectorMeson::generateKinematics(const double *) {
Lorentz5Momentum pout=meMomenta()[0]+meMomenta()[1];
pout.rescaleMass();
meMomenta()[2] = pout;
jacobian(1.0);
// check passes all the cuts
vector<LorentzMomentum> out(1,meMomenta()[2]);
tcPDVector tout(1,mePartonData()[2]);
- jacobian(1.+0.002*(0.5-r[0]));
- // return true if passes the cuts
return lastCuts().passCuts(tout, out, mePartonData()[0], mePartonData()[1]);
}
unsigned int MEee2VectorMeson::orderInAlphaS() const {
return 0;
}
unsigned int MEee2VectorMeson::orderInAlphaEW() const {
- return 0;
+ return 2;
}
Selector<const ColourLines *>
MEee2VectorMeson::colourGeometries(tcDiagPtr) const {
static ColourLines neutral ( " " );
Selector<const ColourLines *> sel;sel.insert(1.,&neutral);
return sel;
}
void MEee2VectorMeson::persistentOutput(PersistentOStream & os) const {
- os << _coupling << _vector << _massgen << _lineshape;
+ os << coupling_ << vector_ << massGen_ << lineShape_;
}
void MEee2VectorMeson::persistentInput(PersistentIStream & is, int) {
- is >> _coupling >> _vector >> _massgen >> _lineshape;
+ is >> coupling_ >> vector_ >> massGen_ >> lineShape_;
}
// The following static variable is needed for the type
// description system in ThePEG.
DescribeClass<MEee2VectorMeson,MEBase>
describeHerwigMEee2VectorMeson("Herwig::MEee2VectorMeson", "HwMELepton.so");
void MEee2VectorMeson::Init() {
static ClassDocumentation<MEee2VectorMeson> documentation
("The MEee2VectorMeson class implements the production of a vector meson"
" in e+e- collisions and is primilarly intended to test the hadron decay package");
static Switch<MEee2VectorMeson,bool> interfaceLineShape
("LineShape",
"Option for the vector meson lineshape",
- &MEee2VectorMeson::_lineshape, false, false, false);
+ &MEee2VectorMeson::lineShape_, false, false, false);
static SwitchOption interfaceLineShapeMassGenerator
(interfaceLineShape,
"MassGenerator",
"Use the mass generator if available",
true);
static SwitchOption interfaceLineShapeBreitWigner
(interfaceLineShape,
"BreitWigner",
"Use a Breit-Wigner with the naive running width",
false);
static Reference<MEee2VectorMeson,ParticleData> interfaceVectorMeson
("VectorMeson",
"The vector meson produced",
- &MEee2VectorMeson::_vector, false, false, true, false, false);
+ &MEee2VectorMeson::vector_, false, false, true, false, false);
static Parameter<MEee2VectorMeson,double> interfaceCoupling
("Coupling",
"The leptonic coupling of the vector meson",
- &MEee2VectorMeson::_coupling, 0.0012, 0.0, 10.0,
+ &MEee2VectorMeson::coupling_, 0., 0.0, 100.0,
false, false, Interface::limited);
}
Selector<MEBase::DiagramIndex>
MEee2VectorMeson::diagrams(const DiagramVector &) const {
Selector<DiagramIndex> sel;sel.insert(1.0, 0);
return sel;
}
CrossSection MEee2VectorMeson::dSigHatDR() const {
InvEnergy2 wgt;
- Energy M(_vector->mass()),G(_vector->width());
+ Energy M(vector_->mass()),G(vector_->width());
Energy2 M2(sqr(M)),GM(G*M);
- if(_massgen&&_lineshape) {
- wgt =Constants::pi*_massgen->weight(sqrt(sHat()))/(sqr(sHat()-M2)+sqr(GM))*UnitRemoval::E2;
- }
- else {
+ if(massGen_&&lineShape_)
+ wgt = Constants::pi*massGen_->BreitWignerWeight(sqrt(sHat()));
+ else
wgt = sHat()*G/M/(sqr(sHat()-M2)+sqr(sHat()*G/M));
- }
- return me2()*jacobian()*wgt*sqr(hbarc);
+ return sqr(4.*Constants::pi*SM().alphaEM(sHat()))*me2()*jacobian()*wgt*sqr(hbarc)*sqr(M2/sHat());
}
void MEee2VectorMeson::doinit() {
MEBase::doinit();
// mass generator
- tMassGenPtr mass=_vector->massGenerator();
+ tMassGenPtr mass=vector_->massGenerator();
if(mass) {
- _massgen=dynamic_ptr_cast<GenericMassGeneratorPtr>(mass);
+ massGen_=dynamic_ptr_cast<GenericMassGeneratorPtr>(mass);
}
}
double MEee2VectorMeson::me2() const {
double aver=0.;
// get the order right
int ielectron(0),ipositron(1);
if(mePartonData()[0]->id()!=11) swap(ielectron,ipositron);
// the vectors for the wavefunction to be passed to the matrix element
vector<SpinorWaveFunction> fin;
vector<SpinorBarWaveFunction> ain;
vector<VectorWaveFunction> vout;
for(unsigned int ihel=0;ihel<2;++ihel) {
fin.push_back(SpinorWaveFunction(meMomenta()[ielectron],
mePartonData()[ielectron],ihel,incoming));
ain.push_back(SpinorBarWaveFunction(meMomenta()[ipositron],
mePartonData()[ipositron],ihel,incoming));
}
for(unsigned int ihel=0;ihel<3;++ihel) {
vout.push_back(VectorWaveFunction(meMomenta()[2],mePartonData()[2],ihel,outgoing));
}
ProductionMatrixElement temp=HelicityME(fin,ain,vout,aver);
return aver;
}
// the helicity amplitude matrix element
ProductionMatrixElement MEee2VectorMeson::HelicityME(vector<SpinorWaveFunction> fin,
vector<SpinorBarWaveFunction> ain,
vector<VectorWaveFunction> vout,
double & aver) const {
ProductionMatrixElement output(PDT::Spin1Half,PDT::Spin1Half,PDT::Spin1);
Complex product;
// sum over helicities to get the matrix element
unsigned int inhel1,inhel2,outhel1;
- double me(0.);
- LorentzPolarizationVector vec;
+ aver = 0.;
+ LorentzPolarizationVectorE vec;
Complex ii(0.,1.);
+ Energy ecms = sqrt(sHat());
for(inhel1=0;inhel1<2;++inhel1) {
for(inhel2=0;inhel2<2;++inhel2) {
- vec = fin[inhel1].wave().vectorCurrent(ain[inhel2].wave());
- vec*=_coupling;
+ vec = fin[inhel1].dimensionedWave().vectorCurrent(ain[inhel2].dimensionedWave());
+ vec /= coupling_;
for(outhel1=0;outhel1<3;++outhel1) {
- product = vec.dot(vout[outhel1].wave());
+ product = vec.dot(vout[outhel1].wave())/ecms;
output(inhel1,inhel2,outhel1)=product;
- me+=real(product*conj(product));
+ aver += norm(product);
}
}
}
- aver=(me*UnitRemoval::E2)/sHat();
+ aver *= 0.25;
return output;
}
void MEee2VectorMeson::constructVertex(tSubProPtr sub) {
// extract the particles in the hard process
ParticleVector hard;
hard.push_back(sub->incoming().first);hard.push_back(sub->incoming().second);
hard.push_back(sub->outgoing()[0]);
if(hard[0]->id()<hard[1]->id()) swap(hard[0],hard[1]);
vector<SpinorWaveFunction> fin;
vector<SpinorBarWaveFunction> ain;
vector<VectorWaveFunction> vout;
SpinorWaveFunction( fin ,hard[0],incoming,false,true);
SpinorBarWaveFunction(ain ,hard[1],incoming,false,true);
VectorWaveFunction(vout ,hard[2],outgoing,true,false,true);
double dummy;
ProductionMatrixElement prodme=HelicityME(fin,ain,vout,dummy);
// construct the vertex
HardVertexPtr hardvertex=new_ptr(HardVertex());
// set the matrix element for the vertex
hardvertex->ME(prodme);
// set the pointers and to and from the vertex
for(unsigned int ix=0;ix<3;++ix) {
(hard[ix]->spinInfo())->productionVertex(hardvertex);
}
}
diff --git a/MatrixElement/Lepton/MEee2VectorMeson.h b/MatrixElement/Lepton/MEee2VectorMeson.h
--- a/MatrixElement/Lepton/MEee2VectorMeson.h
+++ b/MatrixElement/Lepton/MEee2VectorMeson.h
@@ -1,236 +1,236 @@
// -*- C++ -*-
//
// MEee2VectorMeson.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2017 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 THEPEG_MEee2VectorMeson_H
-#define THEPEG_MEee2VectorMeson_H
+#ifndef HERWIG_MEee2VectorMeson_H
+#define HERWIG_MEee2VectorMeson_H
//
// This is the declaration of the MEee2VectorMeson class.
//
#include "ThePEG/MatrixElement/MEBase.h"
#include "Herwig/PDT/GenericMassGenerator.fh"
#include "Herwig/MatrixElement/ProductionMatrixElement.h"
#include "ThePEG/Helicity/WaveFunction/SpinorWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/SpinorBarWaveFunction.h"
#include "ThePEG/Helicity/WaveFunction/VectorWaveFunction.h"
namespace Herwig {
using namespace ThePEG;
using Helicity::SpinorWaveFunction;
using Helicity::SpinorBarWaveFunction;
using Helicity::VectorWaveFunction;
/**
* The MEee2VectorMeson class is designed to produce neutral vector mesons
* in \f$e^+e^-\f$ collisions and is primarily intended to test the hadronic
* decay package.
*
* @see \ref MEee2VectorMesonInterfaces "The interfaces"
* defined for MEee2VectorMeson.
*/
class MEee2VectorMeson: public MEBase {
public:
/**
* The default constructor.
*/
- inline MEee2VectorMeson() :_coupling(0.0012), _lineshape(false)
+ MEee2VectorMeson() : coupling_(0.0012), lineShape_(false)
{}
/** @name Virtual functions required by the MEBase class. */
//@{
/**
* Return the order in \f$\alpha_S\f$ in which this matrix
* element is given.
*/
virtual unsigned int orderInAlphaS() const;
/**
* Return the order in \f$\alpha_{EW}\f$ in which this matrix
* element is given.
*/
virtual unsigned int orderInAlphaEW() const;
/**
* The matrix element for the kinematical configuration
* previously provided by the last call to setKinematics(), suitably
* scaled by sHat() to give a dimension-less number.
* @return the matrix element scaled with sHat() to give a
* dimensionless number.
*/
virtual double me2() const;
/**
* Return the scale associated with the last set phase space point.
*/
virtual Energy2 scale() const;
/**
* Set the typed and momenta of the incoming and outgoing partons to
* be used in subsequent calls to me() and colourGeometries()
* according to the associated XComb object. If the function is
* overridden in a sub class the new function must call the base
* class one first.
*/
virtual void setKinematics();
/**
* The number of internal degrees of freedom used in the matrix
* element.
*/
virtual int nDim() const;
/**
* Generate internal degrees of freedom given nDim() uniform
* random numbers in the interval \f$ ]0,1[ \f$. To help the phase space
* generator, the dSigHatDR should be a smooth function of these
* numbers, although this is not strictly necessary.
* @param r a pointer to the first of nDim() consecutive random numbers.
* @return true if the generation succeeded, otherwise false.
*/
virtual bool generateKinematics(const double * r);
/**
* Return the matrix element squared differential in the variables
* given by the last call to generateKinematics().
*/
virtual CrossSection dSigHatDR() const;
/**
* Add all possible diagrams with the add() function.
*/
virtual void getDiagrams() const;
/**
* Get diagram selector. With the information previously supplied with the
* setKinematics method, a derived class may optionally
* override this method to weight the given diagrams with their
* (although certainly not physical) relative probabilities.
* @param dv the diagrams to be weighted.
* @return a Selector relating the given diagrams to their weights.
*/
virtual Selector<DiagramIndex> diagrams(const DiagramVector & dv) const;
/**
* Return a Selector with possible colour geometries for the selected
* diagram weighted by their relative probabilities.
* @param diag the diagram chosen.
* @return the possible colour geometries weighted by their
* relative probabilities.
*/
virtual Selector<const ColourLines *>
colourGeometries(tcDiagPtr diag) const;
/**
* Set up the spin correlations
*/
virtual void constructVertex(tSubProPtr sub);
//@}
public:
/** @name Functions used by the persistent I/O system. */
//@{
/**
* Function used to write out object persistently.
* @param os the persistent output stream written to.
*/
void persistentOutput(PersistentOStream & os) const;
/**
* Function used to read in object persistently.
* @param is the persistent input stream read from.
* @param version the version number of the object when written.
*/
void persistentInput(PersistentIStream & is, int version);
//@}
/**
* The standard Init function used to initialize the interfaces.
* Called exactly once for each class by the class description system
* before the main function starts or
* when this class is dynamically loaded.
*/
static void Init();
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
inline virtual IBPtr clone() const {return new_ptr(*this);}
/** Make a clone of this object, possibly modifying the cloned object
* to make it sane.
* @return a pointer to the new object.
*/
inline virtual IBPtr fullclone() const {return new_ptr(*this);}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object after the setup phase before saving an
* EventGenerator to disk.
* @throws InitException if object could not be initialized properly.
*/
virtual void doinit();
//@}
private:
/**
* Member to return the helicity amplitudes
*/
ProductionMatrixElement HelicityME(vector<SpinorWaveFunction> fin,
vector<SpinorBarWaveFunction> ain,
vector<VectorWaveFunction> vout,double& me) const;
private:
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
MEee2VectorMeson & operator=(const MEee2VectorMeson &);
private:
/**
* The vector meson being produced
*/
- PDPtr _vector;
+ PDPtr vector_;
/**
* The coupling
*/
- double _coupling;
+ double coupling_;
/**
* Use the mass generator for the line shape
*/
- bool _lineshape;
+ bool lineShape_;
/**
* Pointer to the mass generator for the Higgs
*/
- GenericMassGeneratorPtr _massgen;
+ GenericMassGeneratorPtr massGen_;
};
}
-#endif /* THEPEG_MEee2VectorMeson_H */
+#endif /* HERWIG_MEee2VectorMeson_H */

File Metadata

Mime Type
text/x-diff
Expires
Mon, Jan 20, 10:56 PM (1 d, 17 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4195422
Default Alt Text
(15 KB)

Event Timeline