[u/mrichter/AliRoot.git] / TEvtGen / EvtGenModels / EvtVubBLNPHybrid.hh


//////////////////////////////////////////////////////////////////////
//
// Module: EvtVubBLNPHybrid.hh
//
//
// tripleDiff from BLNPHybrid's notebook, based on hep-ph/0504071
// 
// Description:
// Class to generate inclusive B to X_u l nu decays.
// This class is based on EvtVubBLNP by Sheila Mclachlin with an update to
// generate the inclusive decays in such a way that the right
// mix of inclusive and exclusive decays is obtained.
// 
//NOTE:
// - A set of weights (for bins in the kinematic variables mX, q2, El)
//   is read from DECAY.DEC. This set of weights must be consistent
//   with the other parameters specified (excl. BF, non-res BF, mb, a).
// - If no binning/weights are specified in DECAY.DEC the hybrid
//   reweighting is not activated
//
//
//////////////////////////////////////////////////////////////////


#ifndef EVTVUBBLNPHYBRID_HH
#define EVTVUBBLNPHYBRID_HH

#include <vector>
#include "EvtGenBase/EvtDecayIncoherent.hh"

class EvtParticle;

class EvtVubBLNPHybrid:public  EvtDecayIncoherent  {

public:
  
  EvtVubBLNPHybrid(); 
  virtual ~EvtVubBLNPHybrid();
  
  std::string getName();
  
  EvtDecayBase* clone();

  void initProbMax();

  void init();

  void decay(EvtParticle *Bmeson); 

  void readWeights(int startArg=0);
  
  double getWeight(double mX, double q2, double El);

private:
  //Input for hybrid modell
  enum { nParameters = 10, nVariables = 3 };
  bool _noHybrid;
  bool _storeWhat;
  int    _nbins_mX;
  int    _nbins_q2;
  int    _nbins_El;
  int    _nbins;
  double _masscut;
  double * _bins_mX;
  double * _bins_q2;
  double * _bins_El;
  double * _weights;
  
  // Input parameters
  double mBB;
  double lambda2;

  // Shape function parameters
  double b;
  double Lambda;
  double Ecut;
  double wzero;

  // SF and SSF modes
  int itype;
  double dtype;
  int isubl;

  // flags
  int flag1;
  int flag2;
  int flag3;

  // Quark mass
  double mb;

  // Matching scales
  double muh;
  double mui;
  double mubar;

  // Perturbative quantities
  double CF;
  double CA;

  double beta0;
  double beta1;
  double beta2;

  double zeta3;

  double Gamma0;
  double Gamma1;
  double Gamma2;

  double gp0;
  double gp1;

  double Lbar;
  double mupisq;
  double moment2;

  int flagpower;
  int flag2loop;

  int maxLoop;
  double precision;

  std::vector<double> gvars;
  
  double rate3(double Pp, double Pl, double Pm);
  double F1(double Pp, double Pm, double muh, double mui, double mubar, double doneJS, double done1);
  double F2(double Pp, double Pm, double muh, double mui, double mubar, double done3);
  double F3(double Pp, double Pm, double muh, double mui, double mubar, double done2);
  double DoneJS(double Pp, double Pm, double mui);
  double Done1(double Pp, double Pm, double mui);
  double Done2(double Pp, double Pm, double mui);
  double Done3(double Pp, double Pm, double mui);
  static double IntJS(double what, const std::vector<double> &vars);
  static double Int1(double what, const std::vector<double> &vars);
  static double Int2(double what, const std::vector<double> &vars);
  static double Int3(double what, const std::vector<double> &vars);
  static double g1(double w, const std::vector<double> &vars);
  static double g2(double w, const std::vector<double> &vars);
  static double g3(double w, const std::vector<double> &vars);
  static double Shat(double w, const std::vector<double> &vars);
  static double Mzero(double muf, double mu, double mupisq, const std::vector<double> &vars);
  double wS(double w);
  double t(double w);
  double u(double w);
  double v(double w);
  double myfunction(double w, double Lbar, double mom2);
  double myfunctionBIK(double w, double Lbar, double mom2);
  double dU1nlo(double muh, double mui);
  double U1lo(double muh, double mui);
  double Sfun(double mu1, double mu2, double epsilon);
  double S0(double a1, double r);
  double S1(double a1, double r);
  double S2(double a1, double r);
  double aGamma(double mu1, double mu2, double epsilon);
  double agp(double mu1, double mu2, double epsilon);
  double alo(double muh, double mui);
  double anlo(double muh, double mui);   // d/depsilon of aGamma
  static double alphas(double mu, const std::vector<double> &vars);
  double PolyLog(double v, double z);
  static double Gamma(double z);
  static double Gamma(double a, double x);
  static double gamser(double a, double x, double LogGamma);
  static double gammcf(double a, double x, double LogGamma);
  double findBLNPWhat();
  std::vector<double> _pf;
};

#endif
Commit	Line	Data
da0e9ce3	1
	2	//////////////////////////////////////////////////////////////////////
	3	//
	4	// Module: EvtVubBLNPHybrid.hh
	5	//
	6	//
	7	// tripleDiff from BLNPHybrid's notebook, based on hep-ph/0504071
	8	//
	9	// Description:
	10	// Class to generate inclusive B to X_u l nu decays.
	11	// This class is based on EvtVubBLNP by Sheila Mclachlin with an update to
	12	// generate the inclusive decays in such a way that the right
	13	// mix of inclusive and exclusive decays is obtained.
	14	//
	15	//NOTE:
	16	// - A set of weights (for bins in the kinematic variables mX, q2, El)
	17	// is read from DECAY.DEC. This set of weights must be consistent
	18	// with the other parameters specified (excl. BF, non-res BF, mb, a).
	19	// - If no binning/weights are specified in DECAY.DEC the hybrid
	20	// reweighting is not activated
	21	//
	22	//
	23	//////////////////////////////////////////////////////////////////
	24
	25
	26	#ifndef EVTVUBBLNPHYBRID_HH
	27	#define EVTVUBBLNPHYBRID_HH
	28
	29	#include <vector>
	30	#include "EvtGenBase/EvtDecayIncoherent.hh"
	31
	32	class EvtParticle;
	33
	34	class EvtVubBLNPHybrid:public EvtDecayIncoherent {
	35
	36	public:
	37
	38	EvtVubBLNPHybrid();
	39	virtual ~EvtVubBLNPHybrid();
	40
	41	std::string getName();
	42
	43	EvtDecayBase* clone();
	44
	45	void initProbMax();
	46
	47	void init();
	48
	49	void decay(EvtParticle *Bmeson);
	50
	51	void readWeights(int startArg=0);
	52
	53	double getWeight(double mX, double q2, double El);
	54
	55	private:
	56	//Input for hybrid modell
	57	enum { nParameters = 10, nVariables = 3 };
	58	bool _noHybrid;
	59	bool _storeWhat;
	60	int _nbins_mX;
	61	int _nbins_q2;
	62	int _nbins_El;
	63	int _nbins;
	64	double _masscut;
65	double * _bins_mX;
66	double * _bins_q2;
67	double * _bins_El;
68	double * _weights;
69
70	// Input parameters
71	double mBB;
72	double lambda2;
73
74	// Shape function parameters
75	double b;
76	double Lambda;
77	double Ecut;
78	double wzero;
79
80	// SF and SSF modes
81	int itype;
82	double dtype;
83	int isubl;
84
85	// flags
86	int flag1;
87	int flag2;
88	int flag3;
89
90	// Quark mass
91	double mb;
92
93	// Matching scales
94	double muh;
95	double mui;
96	double mubar;
97
98	// Perturbative quantities
99	double CF;
100	double CA;
101
102	double beta0;
103	double beta1;
104	double beta2;
105
106	double zeta3;
107
108	double Gamma0;
109	double Gamma1;
110	double Gamma2;
111
112	double gp0;
113	double gp1;
114
115	double Lbar;
116	double mupisq;
117	double moment2;
118
119	int flagpower;
120	int flag2loop;
121
122	int maxLoop;
123	double precision;
124
125	std::vector<double> gvars;
126
127	double rate3(double Pp, double Pl, double Pm);
128	double F1(double Pp, double Pm, double muh, double mui, double mubar, double doneJS, double done1);
129	double F2(double Pp, double Pm, double muh, double mui, double mubar, double done3);
130	double F3(double Pp, double Pm, double muh, double mui, double mubar, double done2);
131	double DoneJS(double Pp, double Pm, double mui);
132	double Done1(double Pp, double Pm, double mui);
133	double Done2(double Pp, double Pm, double mui);
134	double Done3(double Pp, double Pm, double mui);
135	static double IntJS(double what, const std::vector<double> &vars);
136	static double Int1(double what, const std::vector<double> &vars);
137	static double Int2(double what, const std::vector<double> &vars);
138	static double Int3(double what, const std::vector<double> &vars);
139	static double g1(double w, const std::vector<double> &vars);
140	static double g2(double w, const std::vector<double> &vars);
141	static double g3(double w, const std::vector<double> &vars);
142	static double Shat(double w, const std::vector<double> &vars);
143	static double Mzero(double muf, double mu, double mupisq, const std::vector<double> &vars);
144	double wS(double w);
145	double t(double w);
146	double u(double w);
147	double v(double w);
148	double myfunction(double w, double Lbar, double mom2);
149	double myfunctionBIK(double w, double Lbar, double mom2);
150	double dU1nlo(double muh, double mui);
151	double U1lo(double muh, double mui);
152	double Sfun(double mu1, double mu2, double epsilon);
153	double S0(double a1, double r);
154	double S1(double a1, double r);
155	double S2(double a1, double r);
156	double aGamma(double mu1, double mu2, double epsilon);
157	double agp(double mu1, double mu2, double epsilon);
158	double alo(double muh, double mui);
159	double anlo(double muh, double mui); // d/depsilon of aGamma
160	static double alphas(double mu, const std::vector<double> &vars);
161	double PolyLog(double v, double z);
162	static double Gamma(double z);
163	static double Gamma(double a, double x);
164	static double gamser(double a, double x, double LogGamma);
165	static double gammcf(double a, double x, double LogGamma);
166	double findBLNPWhat();
167	std::vector<double> _pf;
168	};
169
170	#endif
171