Page MenuHomeHEPForge
Files F7877655

No OneTemporary
Actions

View Options

diff --git a/Analysis/LEPFourJetsAnalysis.h b/Analysis/LEPFourJetsAnalysis.h
--- a/Analysis/LEPFourJetsAnalysis.h
+++ b/Analysis/LEPFourJetsAnalysis.h
@@ -1,265 +1,265 @@
// -*- C++ -*-
//
// LEPFourJetsAnalysis.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_LEPFourJetsAnalysis_H
#define HERWIG_LEPFourJetsAnalysis_H
//
// This is the declaration of the LEPFourJetsAnalysis class.
//
#include "ThePEG/Handlers/AnalysisHandler.h"
#include "ThePEG/Repository/EventGenerator.h"
#include "ThePEG/Vectors/Lorentz5Vector.h"
#include "Herwig/Utilities/Histogram.h"
#include "ThePEG/Repository/CurrentGenerator.h"
namespace Herwig {
using namespace ThePEG;
/** \ingroup Analysis
* The LEPFourJetsAnalysis class performs analysis for four jet angles and
* compares them to LEP data.
*
* @see \ref LEPFourJetsAnalysisInterfaces "The interfaces"
* defined for LEPFourJetsAnalysis.
*/
class LEPFourJetsAnalysis: public AnalysisHandler {
public:
/**
* Default constructor
*/
LEPFourJetsAnalysis ()
: _ca34(), _cchiBZ(), _cphiKSW(), _cthNR(),
_charged(true) {}
public:
/** @name Virtual functions required by the AnalysisHandler class. */
//@{
/**
* Analyze a given Event. Note that a fully generated event
* may be presented several times, if it has been manipulated in
* between. The default version of this function will call transform
* to make a lorentz transformation of the whole event, then extract
* all final state particles and call analyze(tPVector) of this
* analysis object and those of all associated analysis objects. The
* default version will not, however, do anything on events which
* have not been fully generated, or have been manipulated in any
* way.
* @param event pointer to the Event to be analyzed.
* @param ieve the event number.
* @param loop the number of times this event has been presented.
* If negative the event is now fully generated.
* @param state a number different from zero if the event has been
* manipulated in some way since it was last presented.
*/
virtual void analyze(tEventPtr event, long ieve, int loop, int state);
//@}
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:
/**
* Methods to compute the four jet angles, assumes the jets are energy ordered
*/
//@{
/**
* Compute \f$\cos\chi_{BZ}\f$
*/
double cosChiBZ(vector<Lorentz5Momentum> p) {
if (p.size() == 4) {
ThreeVector<Energy2> v1 = p[0].vect().cross(p[1].vect());
ThreeVector<Energy2> v2 = p[2].vect().cross(p[3].vect());
return cos(v1.angle(v2));
}
else return 123;
}
/**
* Compute \f$\cos\Phi_{KSW}\f$.
*/
double cosPhiKSW(vector<Lorentz5Momentum> p) {
if (p.size() == 4) {
ThreeVector<Energy2> v1 = p[0].vect().cross(p[3].vect());
ThreeVector<Energy2> v2 = p[1].vect().cross(p[2].vect());
double alpha1 = v1.angle(v2);
v1 = p[0].vect().cross(p[2].vect());
v2 = p[1].vect().cross(p[3].vect());
double alpha2 = v1.angle(v2);
return cos((alpha1+alpha2)/2.);
}
else return 123;
}
/**
* Compute \f$\cos\Theta_{NR}\f$
*/
double cosThetaNR(vector<Lorentz5Momentum> p) {
if (p.size() == 4) {
ThreeVector<Energy> v1 = p[0].vect() - p[1].vect();
ThreeVector<Energy> v2 = p[2].vect() - p[3].vect();
return cos(v1.angle(v2));
}
else return 123;
}
/**
* Compute \f$\cos\alpha_{34}\f$
*/
double cosAlpha34(std::vector<Lorentz5Momentum> p) {
if (p.size() == 4)
return cos(p[2].vect().angle(p[3].vect()));
else
return 123;
}
//@}
protected:
/** @name Clone Methods. */
//@{
/**
* Make a simple clone of this object.
* @return a pointer to the new object.
*/
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.
*/
virtual IBPtr fullclone() const {
return new_ptr(*this);
}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object. Called in the run phase just before
* a run begins.
*/
virtual void doinitrun();
/**
* Finalize this object. Called in the run phase just after a
* run has ended. Used eg. to write out statistics.
*/
virtual void dofinish();
//@}
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is a concrete class with persistent data.
*/
static ClassDescription<LEPFourJetsAnalysis> initLEPFourJetsAnalysis;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
LEPFourJetsAnalysis & operator=(const LEPFourJetsAnalysis &);
private:
/**
* Histogram for the \f$\cos\alpha_{34}\f$ distribution
*/
HistogramPtr _ca34;
/**
* Histogram for the \f$\cos\chi_{BZ}\f$ distribution
*/
HistogramPtr _cchiBZ;
/**
* Histogram for the \f$\cos\Phi_{KSW}\f$ distribution
*/
HistogramPtr _cphiKSW;
/**
* Histogram for the \f$\cos\Theta_{NR}\f$ distribution
*/
HistogramPtr _cthNR;
/**
* Use charged particles only
*/
bool _charged;
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of LEPFourJetsAnalysis. */
template <>
struct BaseClassTrait<Herwig::LEPFourJetsAnalysis,1> {
/** Typedef of the first base class of LEPFourJetsAnalysis. */
typedef AnalysisHandler NthBase;
};
/** This template specialization informs ThePEG about the name of
* the LEPFourJetsAnalysis class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::LEPFourJetsAnalysis>
: public ClassTraitsBase<Herwig::LEPFourJetsAnalysis> {
/** Return a platform-independent class name */
static string className() { return "Herwig::LEPFourJetsAnalysis"; }
/** Return the name(s) of the shared library (or libraries) be loaded to get
* access to the LEPFourJetsAnalysis class and any other class on which it depends
* (except the base class). */
- static string library() { return "libfastjet.so HwLEPJetAnalysis.so"; }
+ static string library() { return "HwLEPJetAnalysis.so"; }
};
/** @endcond */
}
#endif /* HERWIG_LEPFourJetsAnalysis_H */
diff --git a/Analysis/LEPJetAnalysis.h b/Analysis/LEPJetAnalysis.h
--- a/Analysis/LEPJetAnalysis.h
+++ b/Analysis/LEPJetAnalysis.h
@@ -1,282 +1,282 @@
// -*- C++ -*-
//
// LEPJetAnalysis.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2011 The Herwig Collaboration
//
// Herwig is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef HERWIG_LEPJetAnalysis_H
#define HERWIG_LEPJetAnalysis_H
//
// This is the declaration of the LEPJetAnalysis class.
//
#include "ThePEG/Handlers/AnalysisHandler.h"
#include "Herwig/Utilities/Histogram.h"
namespace Herwig {
using namespace ThePEG;
/** \ingroup Analysis
* The LEPJetAnalysis class compares the results of Heriwg++ with LEP data for
* various jet distributions.
*
* @see \ref LEPJetAnalysisInterfaces "The interfaces"
* defined for LEPJetAnalysis.
*/
class LEPJetAnalysis: public AnalysisHandler {
public:
/// Default constructor
LEPJetAnalysis() : _nevent() {}
/** @name Virtual functions required by the AnalysisHandler class. */
//@{
/**
* Analyze a given Event. Note that a fully generated event
* may be presented several times, if it has been manipulated in
* between. The default version of this function will call transform
* to make a lorentz transformation of the whole event, then extract
* all final state particles and call analyze(tPVector) of this
* analysis object and those of all associated analysis objects. The
* default version will not, however, do anything on events which
* have not been fully generated, or have been manipulated in any
* way.
* @param event pointer to the Event to be analyzed.
* @param ieve the event number.
* @param loop the number of times this event has been presented.
* If negative the event is now fully generated.
* @param state a number different from zero if the event has been
* manipulated in some way since it was last presented.
*/
virtual void analyze(tEventPtr event, long ieve, int loop, int state);
//@}
public:
/**
* 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.
*/
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.
*/
virtual IBPtr fullclone() const {return new_ptr(*this);}
//@}
protected:
/** @name Standard Interfaced functions. */
//@{
/**
* Initialize this object. Called in the run phase just before
* a run begins.
*/
virtual void doinitrun();
/**
* Finalize this object. Called in the run phase just after a
* run has ended. Used eg. to write out statistics.
*/
virtual void dofinish();
//@}
private:
/**
* The static object used to initialize the description of this class.
* Indicates that this is an concrete class without persistent data.
*/
static NoPIOClassDescription<LEPJetAnalysis> initLEPJetAnalysis;
/**
* The assignment operator is private and must never be called.
* In fact, it should not even be implemented.
*/
LEPJetAnalysis & operator=(const LEPJetAnalysis &);
private:
/**
* Histograms ofr the \f$y\f$ distributions
*/
//@{
/**
* \f$y_{23}\f$
*/
HistogramPtr _y23;
/**
* \f$y_{34}\f$
*/
HistogramPtr _y34;
/**
* \f$y_{45}\f$
*/
HistogramPtr _y45;
/**
* \f$y_{56}\f$
*/
HistogramPtr _y56;
//@}
/**
* Bins for the y fractions
*/
vector<double> _yc_frac;
/**
* Points for the y fractions
*/
//@{
/**
* 1 jet
*/
vector<int> _frac1;
/**
* 2 jet
*/
vector<int> _frac2;
/**
* 3 jet
*/
vector<int> _frac3;
/**
* 4 jet
*/
vector<int> _frac4;
/**
* 5 jet
*/
vector<int> _frac5;
/**
* 6 jet
*/
vector<int> _frac6;
//@}
/**
* Number of events analysed
*/
unsigned int _nevent;
/**
* N jet distribution
*/
vector<Statistic> _njet;
/**
* For different jet rates
*/
//@{
/**
* Differential two jet rate
*/
vector<double> _d2dbins;
/**
* Differential three jet rate
*/
vector<double> _d3dbins;
/**
* Differential four jet rate
*/
vector<double> _d4dbins;
/**
* differential 2->2
*/
vector<int> _d2dN2;
/**
* differential 3->2
*/
vector<int> _d3dN2;
/**
* differential 3->2
*/
vector<int> _d3dN3;
/**
* differential 4->2
*/
vector<int> _d4dN2;
/**
* differential 4->3
*/
vector<int> _d4dN3;
/**
* differential 4->4
*/
vector<int> _d4dN4;
//@}
};
}
#include "ThePEG/Utilities/ClassTraits.h"
namespace ThePEG {
/** @cond TRAITSPECIALIZATIONS */
/** This template specialization informs ThePEG about the
* base classes of LEPJetAnalysis. */
template <>
struct BaseClassTrait<Herwig::LEPJetAnalysis,1> {
/** Typedef of the first base class of LEPJetAnalysis. */
typedef AnalysisHandler NthBase;
};
/** This template specialization informs ThePEG about the name of
* the LEPJetAnalysis class and the shared object where it is defined. */
template <>
struct ClassTraits<Herwig::LEPJetAnalysis>
: public ClassTraitsBase<Herwig::LEPJetAnalysis> {
/** Return a platform-independent class name */
static string className() { return "Herwig::LEPJetAnalysis"; }
/**
* The name of a file containing the dynamic library where the class
* LEPJetAnalysis is implemented. It may also include several, space-separated,
* libraries if the class LEPJetAnalysis depends on other classes (base classes
* excepted). In this case the listed libraries will be dynamically
* linked in the order they are specified.
*/
- static string library() { return "libfastjet.so HwLEPJetAnalysis.so"; }
+ static string library() { return "HwLEPJetAnalysis.so"; }
};
/** @endcond */
}
#endif /* HERWIG_LEPJetAnalysis_H */

File Metadata

Mime Type
text/x-diff
Expires
Tue, Nov 19, 4:03 PM (1 d, 15 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3799584
Default Alt Text
(13 KB)

Event Timeline