#include <ColorSingletModels.h>

Inheritance diagram for chigen::models::ColorSingletPartonicModel:

Public Member Functions
	ColorSingletPartonicModel (double ecm, int pdgId, EvtId evtId, EvtSpinDensity spinDensity, double mesonMass, double particleR20, double particleMaxSigma)

virtual double	dsdt ()

virtual void	setSigma ()

virtual bool	setKin ()

bool	setTrialKin ()

	ClassDef (ColorSingletPartonicModel, 1)

virtual bool	next ()

	ClassDef (PartonicModel, 1)

Public Attributes
double	__S__

double	R20

double	alpS

double	Xmin

double	Xmax

double	Pfct

double	PhSp

double	sH2

double	tH2

double	uH2

double	eCM

int	pdgId

EvtSpinDensity	spinDensity

EvtId	evtId

double	mesonMass

double	mesonMass2

double	x1

double	x2

double	sH

double	tH

double	uH

double	sigma

double	MaxSigma

double	MaxSigmaBackup

int	nCall

Detailed Description

Definition at line 30 of file ColorSingletModels.h.

Constructor & Destructor Documentation

chigen::models::ColorSingletPartonicModel::ColorSingletPartonicModel	(	double	ecm,
		int	pdgId,
		EvtId	evtId,
		EvtSpinDensity	spinDensity,
		double	mesonMass,
		double	particleR20,
		double	particleMaxSigma
	)

Definition at line 63 of file ColorSingletModels.cxx.

References __S__, alpS, chigen::PartonicModel::eCM, chigen::PartonicModel::MaxSigma, chigen::PartonicModel::MaxSigmaBackup, chigen::PartonicModel::mesonMass2, Pfct, PROTON_MASS, R20, Xmax, and Xmin.

 : chigen::PartonicModel(ecm, pdg, evt, spin, mm) {
     R20 = particleR20;
     __S__ = eCM * eCM - 4 * pow2(PROTON_MASS);
     alpS = 0.3;
     Xmin = 1.01 * mesonMass2 / __S__;
     Xmax = 1;
     Pfct = 20;
     MaxSigma = particleMaxSigma * R20 * pow3(alpS);
     MaxSigmaBackup = MaxSigma;
 }

Member Function Documentation

chigen::PartonicModel::ClassDef	(	PartonicModel	,
		1
	)

inherited

chigen::models::ColorSingletPartonicModel::ClassDef	(	ColorSingletPartonicModel	,
		1
	)

virtual double chigen::models::ColorSingletPartonicModel::dsdt ( )

inlinevirtual

d sigma/ dt

Returns: d sigma/ dt

Reimplemented in chigen::models::chi_2_2, chigen::models::chi_2_1, chigen::models::chi_2_0, chigen::models::chi_2, chigen::models::x3872_1, chigen::models::chi_1_1, chigen::models::x3872_0, chigen::models::chi_1_0, chigen::models::x3872, and chigen::models::chi_1.

Definition at line 44 of file ColorSingletModels.h.

                                   {
                 return 0.0;
             };

bool chigen::PartonicModel::next ( )

virtualinherited

Calculates the partonic cross section

Definition at line 22 of file PartonicModel.cxx.

References __chigen_cout__, i, chigen::random::random_engine, and sigma.

                                {
     nCall = 0;
     // trying 1000 attempts
     for (int i = 0; i < 1000; ++i) {
         ++nCall;
         if (!setKin()) {
             continue;
         };
         setSigma();
         if (sigma > MaxSigma) {
             //todo add proper info
             __chigen_cout__ <<
                     "sigma=" << std::setiosflags(ios::scientific) << sigma <<
                     " > MasSigma=" << std::setiosflags(ios::scientific) << MaxSigma <<
                     " Efct=" << sigma / MaxSigma << endl;
             MaxSigma = sigma;
             continue;
         };
         if (sigma / MaxSigma > chigen::random::random_engine->flat()) return true;
 
     }
     sigma = -1;
     return false;
 }

bool chigen::models::ColorSingletPartonicModel::setKin ( )

virtual

fills kinematic variables

Reimplemented from chigen::PartonicModel.

Definition at line 86 of file ColorSingletModels.cxx.

References exp(), chigen::ChiGenRandomEngine::flat(), log(), chigen::random::random_engine, sqrt(), X, and Y.

                                                    {
     PhSp = 1;
 
     //double Pfct = -1;
     double Amin = pow(Xmin, -Pfct), Amax = pow(Xmax, -Pfct);
     double X = pow(Amin + chigen::random::random_engine->flat()*(Amax - Amin), -1 / Pfct);
     PhSp *= -1 / Pfct * (Amax - Amin) * pow(X, Pfct + 1);
     sH = X*__S__;
 
 
 
     //    double Xmin = 1.1 * mChi2 / S;
     //    double Xmax=1;
     //    double X = Xmin + (1 - Xmin) * rndm.flat();
     //    PhSp *= (1 - Xmin);
 
     double Ymax = log(1 / X) / 2;
     double Y = Ymax * (2 * chigen::random::random_engine->flat() - 1);
     PhSp *= 2 * Ymax;
 
     x1 = sqrt(X) * exp(Y);
     x2 = sqrt(X) * exp(-Y);
 
     if (x1 * x2 * __S__ < mesonMass2) {
         return false;
     }
 
     sH = x1 * x2*__S__;
 
     tH = (mesonMass2 - sH) * chigen::random::random_engine->flat();
     PhSp = PhSp * (sH - mesonMass2);
     uH = mesonMass2 - sH - tH;
     sH2 = pow2(sH);
     tH2 = pow2(tH);
     uH2 = pow2(uH);
     return true;
 }

void chigen::models::ColorSingletPartonicModel::setSigma ( )

virtual

calculate f1*f2*dSigma/dT of the hard process for the selected kinematics

Reimplemented from chigen::PartonicModel.

Definition at line 77 of file ColorSingletModels.cxx.

References chigen::pythia::pdf, and sigma.

                                                      {
     // hard cross section
     sigma = dsdt();
     // Multiply by PDF's
     sigma = sigma * chigen::pythia::pdf->xf(1, x1, mesonMass2) * chigen::pythia::pdf->xf(1, x2, mesonMass2) / x1 / x2;
     // Correct on change of integration variables
     sigma = sigma*PhSp;
 }

bool chigen::models::ColorSingletPartonicModel::setTrialKin ( )

Calculates trial kinematics

Definition at line 124 of file ColorSingletModels.cxx.

References exp(), log(), chigen::random::random_engine, sigma, sqrt(), X, xmin, and Y.

                                                         {
     PhSp = 1;
 
     double xmin = 0.67;
     double X = 1.1 * xmin;
     PhSp *= (1 - xmin);
     double Ymax = log(1 / xmin) / 2;
     double Y = 0;
     PhSp *= 2 * Ymax;
 
 
     x1 = sqrt(X) * exp(Y);
     x2 = sqrt(X) * exp(-Y);
 
     if (x1 * x2 * __S__ < mesonMass2) {
         return false;
     }
     sH = X*__S__;
     tH = (mesonMass2 - sH) * chigen::random::random_engine->flat();
     PhSp = PhSp * (sH - mesonMass2);
     uH = mesonMass2 - sH - tH;
 
     //    MaxSigma = 100000*setSigma();
     setSigma();
     MaxSigma = 16 * 10000 * sigma;
     MaxSigmaBackup = MaxSigma;
     return true;
 }