Commit e4062427 authored by Hendrik Hoeth's avatar Hendrik Hoeth

merged AHADIC++ r17222 from sinic to trunk

parent 1985bef2
#include "AHADIC++/Decays/Cluster_Decay_Analysis.H"
#include "ATOOLS/Org/Run_Parameter.H"
#include "ATOOLS/Math/Vector.H"
using namespace AHADIC;
using namespace ATOOLS;
using namespace std;
Cluster_Decay_Analysis::Cluster_Decay_Analysis()
{
return;
m_histograms[string("pi+_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("pi-_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("pi0_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("K+_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("K-_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("K0_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("K0_Bar_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("eta_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("etaPrime_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("rho+_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("rho-_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("rho0_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("KStar+_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("KStar-_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("KStar0_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("KStar0_Bar_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("omega_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("phi_Number")] = new Histogram(0,0.,20.,20);
m_histograms[string("x_p_Pseudoscalars")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_p_Vectors")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_p_C-Hadrons")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_p_B-Mesons")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_p_Bstar-Mesons")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_E_Bstar-Mesons")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_E_B-Mesons")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_E_B-Quarks")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_E_B-Mesons_L")] = new Histogram(0,0.,1.,100);
m_histograms[string("x_E_B-Quarks_L")] = new Histogram(0,0.,1.,100);
m_histograms[string("Q(Lambda_Lambda)")] = new Histogram(0,0.,5.5,11);
}
Cluster_Decay_Analysis::~Cluster_Decay_Analysis()
{
return;
Histogram * histo;
string name;
for (map<string,Histogram *>::iterator hit=m_histograms.begin();
hit!=m_histograms.end();hit++) {
histo = hit->second;
name = string("Fragmentation_Analysis/")+hit->first+string(".dat");
histo->Output(name);
delete histo;
}
m_histograms.clear();
}
void Cluster_Decay_Analysis::AnalyseThis(Blob * blob)
{
return;
int Npiplus(0),Npiminus(0),Npi0(0),NKplus(0),NKminus(0),NK0(0),NK0b(0),Neta(0),Netaprime(0),
Nrhoplus(0),Nrhominus(0),Nrho0(0),NKstarplus(0),NKstarminus(0),NKstar0(0),NKstar0b(0),
Nomega(0),Nphi(0);
Particle * part;
int kfc, LambdaCount(0), LambdaP(0), LambdaM(0);
Vec4D QLambda(0.,0.,0.,0.);
double x, max_x = 0., max_xB = 0.;
for (int i=0;i<blob->NInP();i++) {
part = blob->InParticle(i);
kfc = int(part->Flav());
x = 2.*part->Momentum()[0]/rpa.gen.Ecms();
if (x>max_x) max_x = x;
switch (kfc) {
case 5:
case -5:
if (x>max_xB) max_xB = x;
m_histograms[string("x_E_B-Quarks")]->Insert(x);
break;
}
}
if (max_x==max_xB) m_histograms[string("x_E_B-Quarks_L")]->Insert(max_x);
max_x = max_xB = 0.;
for (int i=0;i<blob->NOutP();i++) {
part = blob->OutParticle(i);
x = 2.*part->Momentum()[0]/rpa.gen.Ecms();
if (x>max_x) max_x = x;
kfc = int(part->Flav());
switch (kfc) {
case 111:
Npi0++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 211:
Npiplus++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case -211:
Npiminus++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 221:
Neta++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 311:
NK0++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case -311:
NK0b++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 321:
NKplus++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case -321:
NKminus++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 331:
Netaprime++;
m_histograms[string("x_p_Pseudoscalars")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 113:
Nrho0++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 213:
Nrhoplus++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case -213:
Nrhominus++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 223:
Nomega++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 313:
NKstar0++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case -313:
NKstar0b++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 323:
NKstarplus++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case -323:
NKstarminus++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 333:
Nphi++;
m_histograms[string("x_p_Vectors")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 411:
case 413:
case 421:
case 423:
case 431:
case 433:
m_histograms[string("x_p_C-Hadrons")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
break;
case 511:
case 521:
//case 531:
// if (2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms()<0.89 &&
// 2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms()>0.88)
// cout<<(*blob)<<endl<<endl
// <<"#################################################################################"<<endl<<endl;
m_histograms[string("x_p_B-Mesons")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
m_histograms[string("x_E_B-Mesons")]->Insert(x);
if (x>max_xB) max_xB = x;
break;
case 513:
case 523:
case 533:
m_histograms[string("x_p_Bstar-Mesons")]->Insert(2.*Vec3D(part->Momentum()).Abs()/rpa.gen.Ecms());
m_histograms[string("x_E_Bstar-Mesons")]->Insert(x);
break;
case 3122:
QLambda += part->Momentum();
LambdaCount++; LambdaP++;
break;
case -3122:
QLambda -= part->Momentum();
LambdaCount++; LambdaM++;
break;
}
}
if (LambdaCount==2 && LambdaP==1 && LambdaM==1)
m_histograms[string("Q(Lambda_Lambda)")]->Insert(sqrt(-QLambda.Abs2()));
if (max_x==max_xB) m_histograms[string("x_E_B-Mesons_L")]->Insert(max_x);
m_histograms[string("pi+_Number")]->Insert(Npiplus);
m_histograms[string("pi-_Number")]->Insert(Npiminus);
m_histograms[string("pi0_Number")]->Insert(Npi0);
m_histograms[string("K+_Number")]->Insert(NKplus);
m_histograms[string("K-_Number")]->Insert(NKminus);
m_histograms[string("K0_Number")]->Insert(NK0);
m_histograms[string("K0_Bar_Number")]->Insert(NK0b);
m_histograms[string("eta_Number")]->Insert(Neta);
m_histograms[string("etaPrime_Number")]->Insert(Netaprime);
m_histograms[string("rho+_Number")]->Insert(Nrhoplus);
m_histograms[string("rho-_Number")]->Insert(Nrhominus);
m_histograms[string("rho0_Number")]->Insert(Nrho0);
m_histograms[string("KStar+_Number")]->Insert(NKstarplus);
m_histograms[string("KStar-_Number")]->Insert(NKstarminus);
m_histograms[string("KStar0_Number")]->Insert(NKstar0);
m_histograms[string("KStar0_Bar_Number")]->Insert(NKstar0b);
m_histograms[string("omega_Number")]->Insert(Nomega);
m_histograms[string("phi_Number")]->Insert(Nphi);
}
#ifndef AHADIC_Decays_Cluster_Decay_Analysis_H
#define AHADIC_Decays_Cluster_Decay_Analysis_H
#include "ATOOLS/Phys/Blob.H"
#include "AHADIC++/Tools/Cluster.H"
#include "ATOOLS/Math/Histogram.H"
#include <map>
namespace AHADIC {
class Cluster_Decay_Analysis {
private:
std::map<std::string,ATOOLS::Histogram *> m_histograms;
public:
Cluster_Decay_Analysis();
~Cluster_Decay_Analysis();
void AnalyseThis(ATOOLS::Blob *);
};
/*!
\file Cluster_Decay_Analysis.H
\brief Contains the class AHADIC::Cluster_Decay_Analysis.
*/
/*!
\class Cluster_Decay_Analysis
\brief The class Cluster_Decay_Analysis contains and fills histograms concerning the
composition of the sets of primordial hadrons emerging from fragmentation and their momenta.
*/
/*!
\fn Cluster_Decay_Analysis::Cluster_Decay_Analysis()
\brief Constructor, initialises the histograms.
*/
/*!
\fn Cluster_Decay_Analysis::~Cluster_Decay_Analysis()
\brief Destructor, writes out the histograms.
*/
/*!
\fn void Cluster_Decay_Analysis::
\brief Fills the histograms.
*/
}
#endif
#include "AHADIC++/Decays/Cluster_Decay_Handler.H"
#include "AHADIC++/Decays/Cluster_Part.H"
#include "AHADIC++/Tools/Hadronisation_Parameters.H"
using namespace AHADIC;
using namespace ATOOLS;
using namespace std;
Cluster_Decay_Handler::Cluster_Decay_Handler(Cluster_List * clulist,bool ana) :
p_softclusters(hadpars.GetSoftClusterHandler()),
p_clus(new Cluster_Part(hadpars.GetSplitter(),ana)),
p_clulist(clulist),
p_analysis(ana?new Cluster_Decay_Analysis():NULL)
{ }
Cluster_Decay_Handler::~Cluster_Decay_Handler()
{
if (p_clus) { delete p_clus; p_clus=NULL; }
if (p_analysis) { delete p_analysis; p_analysis=NULL; }
}
int Cluster_Decay_Handler::DecayClusters(Blob * blob)
{
Cluster * cluster;
Cluster_List clist;
msg_Tracking()<<"+++++++++++++++++++++++++++++++++++++++++++++++++++++"<<std::endl
<<"+++ "<<METHOD<<" for "<<p_clulist->size()<<" clusters."<<std::endl;
Cluster_Iterator cit(p_clulist->begin());
while (!p_clulist->empty()) {
cluster = p_clulist->front();
if (!cluster->Active()) {
msg_Error()<<"Error in "<<METHOD<<" inactive cluster:"<<std::endl;
cluster->Print();
msg_Error()<<" Will continue and hope for the best."<<std::endl;
return -1;
}
msg_Tracking()<<"+++ Test cluster ["
<<cluster->GetTrip()->m_flav<<"("<<cluster->GetTrip()->m_info<<"), "
<<cluster->GetAnti()->m_flav<<"("<<cluster->GetAnti()->m_info<<")]."<<std::endl;
if (p_clus->TestDecay(cluster)) {
clist.empty();
clist.push_back(cluster->GetLeft());
clist.push_back(cluster->GetRight());
msg_Tracking()<<"++++ From "<<cluster->Number()<<"("<<cluster->Mass()<<"): "
<<cluster->GetLeft()->Number()<<" ("<<cluster->GetLeft()->Mass()<<") "
<<cluster->GetRight()->Number()<<" ("<<cluster->GetRight()->Mass()<<"), "
<<"popped "<<cluster->GetLeft()->GetAnti()->m_flav<<"."<<std::endl;
if (!p_softclusters->TreatClusterDecay(&clist,blob)) {
msg_Error()<<"Error in "<<METHOD<<" : "<<std::endl
<<" Did not find a kinematically allowed "
<<"solution for the cluster list."<<std::endl
<<" Will trigger retrying the event."<<std::endl;
return -1;
}
while (!clist.empty()) {
p_clulist->push_back(clist.front());
clist.pop_front();
}
}
else {
msg_Tracking()<<"+++ TestDecay did not work out - try to enforce decay."<<std::endl;
if (!p_softclusters->EnforcedDecay(cluster,blob,true)) {
msg_Error()<<"+++ EnforcedDecay did not work out, will return -1."<<std::endl;
return -1;
}
msg_Tracking()<<"+++ EnforcedDecay did work out, will continue."<<std::endl;
}
delete (p_clulist->front()->GetTrip());
delete (p_clulist->front()->GetAnti());
delete (p_clulist->front());
p_clulist->pop_front();
msg_Tracking()<<"++++ After popping front cluster list has now size = "
<<p_clulist->size()<<"."<<std::endl;
}
if (p_analysis) p_analysis->AnalyseThis(blob);
return 1;
}
ATOOLS::Blob * Cluster_Decay_Handler::ClusterDecayBlob(Cluster * cluster,Cluster_List * p_clulist) {
Blob * decblob(cluster->ConstructDecayBlob());
if (cluster->GetLeft()!=NULL && cluster->GetLeft()->GetFlav()==Flavour(kf_cluster)) {
p_clulist->push_back(cluster->GetLeft());
}
if (cluster->GetRight()!=NULL && cluster->GetRight()->GetFlav()==Flavour(kf_cluster)) {
p_clulist->push_back(cluster->GetRight());
}
if (cluster) cluster->SetActive(false);
return decblob;
}
#ifndef AHADIC_Decays_Cluster_Decay_Handler_H
#define AHADIC_Decays_Cluster_Decay_Handler_H
#include "AHADIC++/Decays/Cluster_Part.H"
#include "AHADIC++/Tools/Dipole_Splitter.H"
#include "AHADIC++/Tools/Soft_Cluster_Handler.H"
#include "ATOOLS/Phys/Blob_List.H"
#include "AHADIC++/Tools/Cluster.H"
#include "AHADIC++/Decays/Cluster_Decay_Analysis.H"
namespace AHADIC {
class Cluster_Decay_Handler {
private:
Soft_Cluster_Handler * p_softclusters;
Cluster_Part * p_clus;
Cluster_List * p_clulist;
Cluster_Decay_Analysis * p_analysis;
ATOOLS::Blob * DecayIt(Cluster *);
ATOOLS::Blob * ClusterDecayBlob(Cluster *,Cluster_List *);
public:
Cluster_Decay_Handler(Cluster_List *,bool=false);
~Cluster_Decay_Handler();
int DecayClusters(ATOOLS::Blob *);
};
/*!
\file Cluster_Decay_Handler.H
\brief Contains the class AHADIC::Cluster_Formeration_Handler.
*/
/*!
\class Cluster_Decay_Handler
\brief The Cluster_Decay_Handler organises the decay of clusters at the end of
the parton shower phase.
The central (and also the only public) method of this class is
Cluster_Decay_Handler::DecayClusters(Cluster_List *,ATOOLS::Blob_List *),
which is being called, once the previous cluster formation from partons,
managed by the class Cluster_Formation_Handler, is finished.
*/
/*!
\var Soft_Cluster_Handler * p_softclusters
\brief A pointer to the common Soft_Cluster_Handler, used in both the formation
and decay phase to decide on forced cluster to hadron transitions and decays
and to perform them.
*/
/*!
\var Cluster_Part * p_clus
\brief Pointer to the Cluster_Part, responsible for the definition of the actual
cluster decay kinematics.
*/
/*!
\var Cluster_Decay_Analysis * p_analysis
\brief Pointer to the Cluster_Decay_Analysis.
*/
/*!
\fn ATOOLS::Blob * Cluster_Decay_Handler::DecayIt(Cluster *)
\brief Managing for the decay of one single cluster.
The following steps are taken:
- a decay blob (status: blob_status::needs_hadrondecays) is initialised
and the cluster is added as incoming particle;
- the method Cluster_Part::TestDecay(Cluster*) decides upon a flavour to be
popped out of the vacuum and instantiates two new clusters with according
flavour content. They are then linked as left and right pointers to the
decaying one;
- finally, the cluster decay blob (without the two outgoing clusters added)
is returned.
*/
/*!
\fn Cluster_Decay_Handler::Cluster_Decay_Handler(Soft_Cluster_Handler *,bool=false)
\brief Constructor of the class. Initialises a new Cluster_Part and, eventually,
a Cluster_Decay_Analysis object.
The boolean steers, whether the Cluster_Decay_Analysis object is instantiated.
*/
/*!
\fn Cluster_Decay_Handler::~Cluster_Decay_Handler()
\brief Deletes the Cluster_Part and the Cluster_Decay_Analysis object.
*/
/*!
\fn int Cluster_Decay_Handler::DecayClusters(Cluster_List *,ATOOLS::Blob_List * = NULL)
\brief Managing the decays of the clusters in a Cluster_List into secondary
clusters and, ultimately, the primordial hadrons.
The idea is the following: each decaying cluster is connected with a cluster list,
filled by its offsprings. These emerge from the call to the method
Cluster_Decay_Handler::DecayIt(Cluster *) and, at that point, are still clusters.
Then the Soft_Cluster_Handler tests the two offspring clusters, whether they must
decay or transit into hadrons. This is done through the method
Soft_Cluster_Handler::TreatClusterList(Cluster_List *,ATOOLS::Blob *). Now the
offspring list is iterated over. Each of them is treated in the following way:
- First, the ATOOLS::Particle related to it is added as outgoing particle to the decay
ATOOLS::Blob of the original cluster.
- If the offspring does not have any filled left and right pointers, it did not decay into
hadrons and hence it can safely be added to the original cluster list for further treatment.
- If, on the other hand, the offspring does have filled left and right pointers, it decayed
into hadrons or clusters. Then the offsprings of the offspring are tested: If they are
not hadrons, they are added to the original cluster list for further treatment.
Finally, the original cluster is deleted and taken out of the original cluster list.
This procedure is repeated until the original cluster list is empty, i.e., until all
clusters are decayed into hadrons.
*/
}
#endif
#include "AHADIC++/Decays/Cluster_Part.H"
#include "ATOOLS/Org/Message.H"
#include "ATOOLS/Math/Random.H"
using namespace AHADIC;
using namespace ATOOLS;
using namespace std;
Cluster_Part::Cluster_Part(Dipole_Splitter * splitter,bool ana) :
m_ana(ana), p_splitter(splitter), m_fails(0), m_att(0)
{
if (m_ana) {
m_histograms[string("PT_Cluster")] = new Histogram(0,0.,1.5,150);
}
}
Cluster_Part::~Cluster_Part()
{
if (m_ana) {
msg_Out()<<METHOD<<" (had "<<m_fails<<" fails in "<<m_att<<" attempts).\n";
Histogram * histo;
string name;
for (map<string,Histogram *>::iterator hit=m_histograms.begin();
hit!=m_histograms.end();hit++) {
histo = hit->second;
name = string("Fragmentation_Analysis/")+hit->first+string(".dat");
histo->Output(name);
delete histo;
}
m_histograms.clear();
}
}
bool Cluster_Part::TestDecay(Cluster * const cluster)
{
m_att++;
if (!p_splitter->SplitCluster(cluster)) {
m_fails++;
return false;
}
if (m_ana) {
Vec4D lmom(cluster->GetLeft()->Momentum());
double pt = sqrt(sqr(lmom[1]) + sqr(lmom[2]));
Histogram* histo((m_histograms.find(std::string("PT_Cluster")))->second);
histo->Insert(pt);
}
#ifdef AHAmomcheck
cluster->CheckConsistency(msg_Error(),METHOD);
#endif
return true;
}
#ifndef AHADIC_Decays_Cluster_Part_H
#define AHADIC_Decays_Cluster_Part_H
#include "AHADIC++/Tools/Cluster.H"
#include "AHADIC++/Tools/Dipole_Splitter.H"
#include "ATOOLS/Math/Histogram.H"
#include "AHADIC++/Tools/Hadronisation_Parameters.H"
#include "ATOOLS/Org/Return_Value.H"
#include "ATOOLS/Math/Histogram.H"
#include <map>
namespace AHADIC {
class Cluster_Part {
protected:
bool m_ana;
Dipole_Splitter * p_splitter;
long int m_fails, m_att;
std::map<std::string,ATOOLS::Histogram *> m_histograms;
public:
Cluster_Part(Dipole_Splitter * =NULL,bool=false);
~Cluster_Part();
bool TestDecay(Cluster * const);
};
/*!
\file Cluster_Part.H
\brief This file contains the class Cluster_Part.
*/
/*!
\class Cluster_Part
\brief The class cluster part is responsible for the decays of clusters into test clusters.
These are either kept as clusters for further decays or they are transformed into hadrons by
the Soft_Cluster_Handler.
*/
/*!
\var int Cluster_Part::m_4Qmode
\brief Up to now: 0 by default.
\todo: Think about improvement.
*/
/*!
\var int Cluster_Part::m_ybar_mode
\brief Up to now: 0 by default. For details, cf.
Cluster_Part::GetYBar(const double,const double)
*/
/*!
\var double Cluster_Part::m_fraction
\brief The variable \f$f\f$ in Cluster_Part::BuildKinematics(Cluster * const,ATOOLS::Flavour &).
It is set by the parameter "CLUSTER_MASS_FRACTION", default is 0.5.
*/
/*!
\var double Cluster_Part::m_ystar_expvalue
\brief The expectation value of the \f$y^*\f$ shift in terms of \f$y^{*,max}\f$.
For more details see the description of
Cluster_Part::GetYStar(const double,const double), there it is named
\f$\langle\delta y^*\rangle\f$.
It is set by the parameter "<Y*_SHIFT>", default is 0.5.
*/
/*!
\var double Cluster_Part::m_ystar_sigma
\brief The width of the \f$y^*\f$ distribution in a Gaussian.
For more details see the description of
Cluster_Part::GetYStar(const double,const double), there it is named \f$\sigma_y\f$.
It is set by the parameter "<Y*_WIDTH>", default is 0.5.
*/
/*!
\var ATOOLS::Vec4D Cluster_Part::m_momenta[4]
\brief The four momenta of the cluster constituents and the popped quark pair.
*/
/*!
\var bool Cluster_Part::m_ana
\brief Switches the analysis on and off. Default is true.
*/
/*!
\var std::map<std::string,ATOOLS::Histogram *> Cluster_Part::m_histograms
\brief A number of histograms monitoring the decay kinematics.
In particular, the \f$p_\perp\f$ distribution and the centre-of-mass energy squared of
the popped quarks is monitored, as well as the flavour composition of the popped quarks.
In addition, \f$y^*\f$, \f$y^{*}/y^{*, max}\f$, \f$\bar y\f$, \f$\bar y/\bar y^{max}\f$
are monitored.
*/
/*!
\fn Cluster_Part::Cluster_Part()
\brief Initialises the constants and, if neccessary, the histograms.
*/
/*!
\fn Cluster_Part::~Cluster_Part()
\brief Outputs the histograms from the analysis.
*/
/*!
\fn bool Cluster_Part::TestDecay(Cluster *)
\brief Decides the popped flavour and instantiates two clusters accordingly.
The procedure is as follows:
- First the decaying cluster is boosted in its c.m. frame and its constitutents
are oriented along the z-axis;
- then Cluster_Part::BuildKinematics(Cluster * const,ATOOLS::Flavour &) is invoked
to pop a flavour and fix the decay kinematics;
- finally, offspring clusters are constructed with flavour content and momenta
(eventually these clusters may become hadrons through the Soft_Cluster_Handler);
- the system is boosted and rotated back, the offsprings are linked to the decaying
cluster, corresponding particles are instantiated for them.
*/
/*!
\fn bool Cluster_Part::UpdateDecay(Cluster *,const int)
\brief Updates decay kinematics after one or both outgoing particles have been
shifted to a new mass-shell.
The basic idea is that the original decay is boosted in its c.m. system, with orientation
of the original clusters constituents along the z-axis. The energies and longitudinal (z-)
momenta of the outgoing particles are then recalculated with the new shifted masses of
the offsrpings. Their \f$p_\perp\f$ is kept and eventually rotated around the z-axis.
Finally the full system is boosted and rotated back in its original frame.
*/
/*!
\fn bool Cluster_Part::BuildKinematics(Cluster * const,ATOOLS::Flavour &)
\brief Builds the kinematics of a cluster->cluster+cluster decay in its own
rest frame.
The algorithm is as follows:
The procedure is repeated, until physical energies for the original cluster
constituents (larger than their mass) emerge.
*/
}
#endif
pkglib_LTLIBRARIES = libAhadicDecays.la
SVNTAG = AHADIC++/Decays
include ../../svn.make
libAhadicDecays_la_SOURCES = \
SVN_Info.C \
Cluster_Decay_Handler.C \
Cluster_Decay_Analysis.C \
Cluster_Part.C
localincdir = $(pkgincludedir)/AHADIC++/Decays
localinc_HEADERS = \
Cluster_Decay_Handler.H \
Cluster_Decay_Analysis.H \
Cluster_Part.H
EXTRA_DIST = @SVNINCLUDE@
This diff is collapsed.
This diff is collapsed.