Page MenuHomeHEPForge
Files F8309419

WaveOverlap.cpp
No OneTemporary
Actions

WaveOverlap.cpp
View Options

//==============================================================================
// WaveOverlap.cpp
//
// Copyright (C) 2010-2013 Tobias Toll and Thomas Ullrich
//
// This file is part of Sartre version: 1.1
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation.
// This program is distributed in the hope that it will be useful,
// but without any warranty; without even the implied warranty of
// merchantability or fitness for a particular purpose. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// Author: Tobias Toll
// Last update:
// $Date: 2013-09-10 19:11:59 +0100 (Tue, 10 Sep 2013) $
// $Author: tobilibob@gmail.com $
//==============================================================================
#include <iostream>
#include "WaveOverlap.h"
#include "Constants.h"
#include <cmath>
#include "TMath.h"
#include "WaveOverlapVMParameters.h"
using namespace std;
WaveOverlap::WaveOverlap() {/* no op*/}
WaveOverlap::~WaveOverlap() {/* no op*/}
//VECTOR MESONS: **********************************************
WaveOverlapVM::WaveOverlapVM()
{
mNT = mRT2 = 0;
mMf = 0;
mMf2 = 0;
mEf = 0;
mMV = 0;
mNL = mRL2 = 0;
}
double WaveOverlapVM::transverseWaveFunction(double r, double z)
{
return mNT*z*(1-z)*exp(-(mMf2*mRT2)/(8*z*(1-z)) -
(2*z*(1-z)*r*r)/mRT2/hbarc2 + (mMf2*mRT2)/2);
}
double WaveOverlapVM::dDrTransverseWaveFunction(double r, double z)
{
return transverseWaveFunction(r,z) * (-4*z*(1-z)*r/mRT2/hbarc);
}
double WaveOverlapVM::T(double z, double Q2, double r)
{
// Units:
// Q2 in GeV^2
// r in fm
const double e = sqrt(4*M_PI*alpha_em);
double eps2 = z*(1-z)*Q2 + mMf2;
double eps = sqrt(eps2);
double term0 = mEf*e*(Nc/(M_PI*z*(1-z)));
double term1 = mMf2*TMath::BesselK0(r*eps/hbarc)*transverseWaveFunction(r,z);
double term2 = (z*z + (1-z)*(1-z))*eps*TMath::BesselK1(r*eps/hbarc)*dDrTransverseWaveFunction(r,z);
return term0*(term1-term2);
}
double WaveOverlapVM::L(double z, double Q2, double r)
{
// Units:
// Q2 in GeV^2
// r in fm
const double e = sqrt(4*M_PI*alpha_em);
double eps2 = z*(1-z)*Q2 + mMf2;
double eps = sqrt(eps2);
double result = mEf*e*(Nc/M_PI)*2*sqrt(Q2)*z*(1-z);
result *= TMath::BesselK0(r*eps/hbarc);
double term1 = mMV*longitudinalWaveFunction(r,z);
double term2 = mMf2*longitudinalWaveFunction(r,z) - laplaceRLongitudinalWaveFunction(r,z);
term2 /= (mMV*z*(1-z));
return result*(term1+term2);
}
double WaveOverlapVM::longitudinalWaveFunction(double r, double z)
{
return mNL*z*(1-z)*exp(-(mMf2*mRL2)/(8*z*(1-z)) -
(2*z*(1-z)*r*r)/mRL2/hbarc2 + (mMf2*mRL2)/2);
}
double WaveOverlapVM::laplaceRLongitudinalWaveFunction(double r, double z)
{
double t = 4*z*(1-z)/mRL2;
return longitudinalWaveFunction(r,z)* (r*r*t*t/hbarc2 - 2*t);
}
void WaveOverlapVM::setWaveOverlapFunctionParameters(int val)
{
//
// mRL2 (GeV^-2)
//
switch (val) {
case 113:
mRL2 = RL2_rho;
break;
case 333:
mRL2 = RL2_phi;
break;
case 443:
default:
mRL2 = RL2_jpsi;
break;
}
mRT2 = mRL2;
switch (val) {
case 113:
mNL = NL_rho;
break;
case 333:
mNL = NL_phi;
break;
case 443:
default:
mNL = NL_jpsi;
break;
}
switch (val) {
case 113:
mNT = NT_rho;
break;
case 333:
mNT = NT_phi;
break;
case 443:
default:
mNT = NT_jpsi;
break;
}
}
void WaveOverlapVM::setProcess(int val)
{
switch (val) {
case 113:
mMf = quarkMass[1]; //Should be super-position? uu+dd
mMV = 0.776;
mEf = 1./sqrt(2.);
break;
case 333:
mMf = quarkMass[2]; //Should be super-position? uu+dd+ss
mMV = 1.019;
mEf = 1./3.;
break;
case 443:
mMf = quarkMass[3];
mMV = 3.096916;
mEf = 2./3.;
break;
default:
cerr << "WaveOverlap::setProcess(): error no such type: " << val << endl;
break;
}
mMf2 = mMf*mMf;
}
//DVCS: **********************************************
double WaveOverlapDVCS::T(double z, double Q2, double r)
{
//eq.(17) in KMW
double term0, term1, term2;
double result=0;
for (int iFlav=0; iFlav<4; iFlav++) {
double mf=quarkMass[iFlav];
double ef=quarkCharge[iFlav];
double eps2 = z*(1-z)*Q2 + mf*mf;
double eps = sqrt(eps2);
term0=2.*Nc/M_PI*alpha_em*ef*ef;
term1=( z*z+(1-z)*(1-z) )*
eps*TMath::BesselK1(eps*r/hbarc)*mf*TMath::BesselK1(mf*r/hbarc);
term2=mf*mf*TMath::BesselK0(eps*r/hbarc)*TMath::BesselK0(mf*r/hbarc);
result += term0*(term1+term2);
}
return result;
}
double WaveOverlapDVCS::L(double, double, double) {return 0;}

File Metadata

Mime Type
text/x-c
Expires
Sat, Dec 21, 3:17 PM (1 d, 7 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4000678
Default Alt Text
WaveOverlap.cpp (5 KB)

Event Timeline