A class for mesons. More...

#include <Meson.h>

Inheritance diagram for Meson:

Detailed Description

A class for mesons.

Author: HEPfit Collaboration

Copyright: GNU General Public License

This class is used to define a meson and three of its characteristics: mass, lifetime and decay constant. For selected mesons, also the Gegenbauer moments are defined. This class inherits the public access members of the Particle class.

Model parameters

The model parameters of Meson are summarized below:

Label	LaTeX symbol	Description
MP0	\(M_{\pi^0}\)	The mass of the \( \pi^0 \) meson in GeV.
tP0	\(\tau_{\pi^0}\)	The lifetime of the \( \pi^0 \) meson in \(\mathrm{ps}^{-1} \).
FP0	\(F_{\pi^0}\)	The decay constant of the \( \pi^0 \) meson in GeV.
MPp	\(M_{\pi^\pm}\)	The mass of the \( \pi^\pm \) meson in GeV.
tPp	\(\tau_{\pi^\pm}\)	The lifetime of the \( \pi^\pm \) meson in \(\mathrm{ps}^{-1} \).
FPp	\(F_{\pi^\pm}\)	The decay constant of the \( \pi^{\pm} \) meson in GeV.
MK0	\(M_{K^0}\)	The mass of the \( K^0 \) meson in GeV.
tKl	\(\tau_{K_L}\)	The lifetime of the \( K_L \) meson in \(\mathrm{ps}^{-1} \).
MKp	\(M_{K^\pm}\)	The mass of the \( K^\pm \) meson in GeV.
tKp	\(\tau_{K^\pm}\)	The lifetime of the \( K^\pm \) meson in \(\mathrm{ps}^{-1} \).
FK	\(F_{K}\)	The decay constant of the \( K^{0,\pm} \) meson in GeV.
alpha1kp, alpha2kp	\(\alpha_1(K^+), \alpha_2(K^+)\)	The Gegenbauer coefficients for the \(K^+\) meson.
MD	\(M_{D^0}\)	The mass of the \( D^0 \) meson in GeV.
tD	\(\tau_{D^0}\)	The lifetime of the \( D^0 \) meson in \(\mathrm{ps}^{-1} \).
FD	\(F_{D^0}\)	The decay constant of the \( D^0 \) meson in GeV.
MDp	\(M_{D^\pm}\)	The mass of the \( D^\pm \) meson in GeV.
tDp	\(\tau_{D^\pm}\)	The lifetime of the \( D^\pm \) meson in \(\mathrm{ps}^{-1} \).
FDp	\(F_{D^\pm}\)	The decay constant of the \( D^\pm \) meson in GeV.
MBd	\(M_{B_d}\)	The mass of the \( B_d \) meson in GeV.
tBd	\(\tau_{B_d}\)	The lifetime of the \( B_d \) meson in \(\mathrm{ps}^{-1} \).
MBp	\(M_{B^\pm}\)	The mass of the \( B^\pm \) meson in GeV.
tBp	\(\tau_{B^\pm}\)	The lifetime of the \( B^\pm \) meson in \(\mathrm{ps}^{-1} \).
FBsoFBd	\(F_{B_s}/F_{B_d}\)	The ratio of decay constants of the \( B_s \) and \( B_d \) mesons.
MBs	\(M_{B_s}\)	The mass of the \( B_s \) meson in GeV.
tBs	\(\tau_{B_s}\)	The lifetime of the \( B_s \) meson in \(\mathrm{ps}^{-1} \).
FBs	\(F_{B_s}\)	The decay constant of the \( B_s \) meson in GeV.
lambdaB	\(\Lambda_{B,+}\)	The integrated leading twist light-cone distribution amplitudes of the B meson divided by the integral variable.
DGs_Gs	\( \Delta \Gamma_s /\Gamma_s \)	The oscillation parameter for the \(B_s\) meson.
MBc	\(M_{B_c}\)	The mass of the \( B_c \) meson in GeV.
tBc	\(\tau_{B_c}\)	The lifetime of the \( B_c \) meson in \(\mathrm{ps}^{-1} \).
FBc	\(F_{B_c}\)	The decay constant of the \( B_c \) meson in GeV.
Mphi	\(M_{\phi}\)	The mass of the \( \phi \) meson in GeV.
tphi	\(\tau_{\phi}\)	The lifetime of the \( \phi \) meson in \(\mathrm{ps}^{-1} \).
Fphi	\(F_{\phi}\)	The decay constant of the \( \phi \) meson in GeV.
Fphip	\(F_{\phi}^{\perp}\)	The decay constant of a transversely polarized \( \phi \) meson in GeV.
alpha2phi	\(\alpha_2(\phi)\)	The Gegenbauer coefficient for the \(\phi\) meson.
MKstar	\(M_{K^{*0}}\)	The mass of the \( K^{*0} \) meson in GeV.
MKstarP	\(M_{K^{*\pm}}\)	The mass of the \( K^{*\pm} \) meson in GeV.
tKstar	\(\tau_{K^*}\)	The lifetime of the \( K^* \) meson in \(\mathrm{ps}^{-1} \).
FKstar	\(F_{K^*}\)	The decay constant of the \( K^* \) meson in GeV.
FKstarp	\(F_{K^*}^{\perp}\)	The decay constant of a transversely polarized \( K^* \) meson in GeV.
alpha1kst, alpha2kst	\(\alpha_1(\bar{K}^), \alpha_2(\bar{K}^)\)	The Gegenbauer coefficients for the \(\bar{K}^*\) meson.
MDstarP	\(M_{D^{*\pm}}\)	The mass of the \( K^{*\pm} \) meson in GeV.
tDstarP	\(\tau_{D^{*\pm}}\)	The lifetime of the \( D^{*\pm} \) meson in \(\mathrm{ps}^{-1} \).
FDstarP	\(F_{D^{*\pm}}\)	The decay constant of the \( D^{*\pm} \) meson in GeV.
Mrho	\(M_{\rho}\)	The mass of the \( \rho \) meson in GeV.
trho	\(\tau_{\rho}\)	The lifetime of the \( \rho \) meson in \(\mathrm{ps}^{-1} \).
Frho	\(F_{\rho}\)	The decay constant of the \( \rho \) meson in GeV.
MrhoP	\(M_{\rho^{\pm}}\)	The mass of the \( \rho^{\pm} \) meson in GeV.
trhoP	\(\tau_{\rho^{\pm}}\)	The lifetime of the \( \rho^{\pm} \) meson in \(\mathrm{ps}^{-1} \).
FrhoP	\(F_{\rho^{\pm}}\)	The decay constant of the \( \rho^{\pm} \) meson in GeV.
Momega	\(M_{\omega}\)	The mass of the \( \omega \) meson in GeV.
tomega	\(\tau_{\omega}\)	The lifetime of the \( \omega \) meson in \(\mathrm{ps}^{-1} \).
Fomega	\(F_{\omega}\)	The decay constant of the \( \omega \) meson in GeV.

Definition at line 315 of file Meson.h.

Public Member Functions
double	computeWidth () const
	A method to compute the width of the meson from its lifetime. More...

const double &	getDecayconst () const
	A get method for the decay constant of the meson. More...

const double &	getDecayconst_p () const
	A get method for the perpendicular decay constant of a vector meson. More...

const double &	getDgamma_gamma () const

double	getFBsoFBd () const

const double &	getGegenalpha (int i) const
	A get method to get the Gegenbaur coefficient. More...

const double &	getLambdaM () const

double	getLifetime () const
	A get method for the lifetime of the meson. More...

std::string	getName () const
	A get method to get the name of the meson. More...

void	initializeParameters ()

	Meson ()
	The default constructor. More...

	Meson (double mass, double lifetime, double decayconst, double lambdaM, double gegenalpha1, double gegenalpha2)
	Constructor. More...

void	ModelParameterMapInsert (std::map< std::string, std::reference_wrapper< const double > > &ModelParamMap)

std::vector< std::string >	parameterList (std::string name_i)

void	setDecayconst (double decayconst)
	A set method for the decay constant of the meson. More...

void	setDgamma_gamma (double Dgamma_gamma)

void	setName (std::string name_i)
	A set method to set the name of the meson. More...

bool	setParameter (std::string name_i, double value)

virtual	~Meson ()
	The default destructor. More...

Public Member Functions inherited from Particle
double	getCharge () const
	A get method to access the particle charge. More...

int	getIndex () const

double	getIsospin () const
	A get method to access the particle isospin. More...

const double &	getMass () const
	A get method to access the particle mass. More...

double	getMass_scale () const
	A get method to access the scale at which the particle mass is defined. More...

std::string	getName () const

const double &	getWidth () const
	A get method to access the particle width. More...

bool	is (std::string name_i) const

	Particle ()
	The default constructor. More...

	Particle (std::string name, double mass, double mass_scale=0., double width=0., double charge=0., double isospin=0.)
	Constructor. More...

void	setCharge (double charge)
	A set method to fix the particle charge. More...

void	setIsospin (double isospin)
	A set method to fix the particle isospin. More...

void	setMass (double mass)
	A set method to fix the particle mass. More...

void	setMass_scale (double mass_scale)
	A set method to fix the scale at which the particle mass is defined. More...

void	setName (std::string name)

void	setWidth (double width)
	A set method to fix the particle width. More...

virtual	~Particle ()

Private Attributes
double	decayconst
	The decay constant of the meson. More...

double	decayconst_p
	The perpendicular decay constant of a vector meson. More...

double	Dgamma_gamma
	Dgamma/gamma for neutral mesons. More...

double	FBsoFBd

double	gegenalpha [2]
	Gegenbauer moments. More...

double	lambdaM
	First moment of LCDA. More...

double	lifetime
	The lifetime of the meson. More...

Additional Inherited Members
Protected Member Functions inherited from Particle
void	setIndex ()

Protected Attributes inherited from Particle
double	charge
	The particle charge. More...

int	index
	The index of the particle. More...

double	isospin
	The particle isospin. More...

double	mass
	The particle mass in GeV. More...

double	mass_scale
	The scale in GeV at which the particle mass is defined. More...

std::string	name
	The particle name. More...

double	width
	The particle width in GeV. More...

Constructor & Destructor Documentation

◆ Meson() [1/2]

Meson::Meson ( )

The default constructor.

Definition at line 22 of file Meson.cpp.

{
    mass = 0.;
    lifetime = 5.e29;
    decayconst = 0.;
    lambdaM = 0.;
    gegenalpha[0] = 0.;
    gegenalpha[1] = 0.;
    name = "";
}

◆ Meson() [2/2]

Meson::Meson	(	double	mass,
		double	lifetime = `5.e29`,
		double	decayconst = `0.`,
		double	lambdaM = `0.`,
		double	gegenalpha1 = `0.`,
		double	gegenalpha2 = `0.`
	)

Constructor.

Parameters

[in]	mass	the mass of the meson in GeV
[in]	lifetime	the lifetime of the meson in \( \mathrm{ps}^{-1} \)
[in]	decayconst	the decay constant of the meson in GeV
[in]	lambdaM	the first moment of the LCDA
[in]	gegenalpha1	first Gegenbauer moment of LCDA
[in]	gegenalpha2	second Gegenbauer moment of LCDA

Definition at line 11 of file Meson.cpp.

{
    this->mass = mass;
    this->lifetime = lifetime;
    this->decayconst = decayconst;
    this->lambdaM = lambdaM;
    gegenalpha[0] = gegenalpha1;
    gegenalpha[1] = gegenalpha2;
}

◆ ~Meson()

Meson::~Meson ( )

virtual

The default destructor.

Definition at line 33 of file Meson.cpp.

34{}

Member Function Documentation

◆ computeWidth()

double Meson::computeWidth ( ) const

A method to compute the width of the meson from its lifetime.

Returns: the width of the meson in GeV

Definition at line 521 of file Meson.cpp.

{
    return (HCUT / lifetime);
}

◆ getDecayconst()

const double & Meson::getDecayconst ( ) const

inline

A get method for the decay constant of the meson.

Returns: the decay constant of the meson in GeV

Definition at line 360 of file Meson.h.

    {
        return decayconst;
    }

◆ getDecayconst_p()

const double & Meson::getDecayconst_p ( ) const

inline

A get method for the perpendicular decay constant of a vector meson.

Returns: the decay constant of the meson in GeV

Definition at line 378 of file Meson.h.

    {
        return decayconst_p;
    }

◆ getDgamma_gamma()

const double & Meson::getDgamma_gamma ( ) const

inline

Definition at line 411 of file Meson.h.

    {
        return Dgamma_gamma;
    }

◆ getFBsoFBd()

double Meson::getFBsoFBd ( ) const

inline

Definition at line 434 of file Meson.h.

    {
        return FBsoFBd;
    }

◆ getGegenalpha()

const double & Meson::getGegenalpha ( int i ) const

inline

A get method to get the Gegenbaur coefficient.

Parameters

[in] the order of the Gegenbaur coefficient

Returns: the Gegenbaur coefficient

Definition at line 394 of file Meson.h.

    {
        if (i >= 0 && i < 2)
            return gegenalpha[i];
        else 
            throw std::runtime_error("Meson::getGegenalpha(" + boost::lexical_cast<std::string>(i) + "): index out of range");
    }

◆ getLambdaM()

const double & Meson::getLambdaM ( ) const

inline

Definition at line 402 of file Meson.h.

    {
        return lambdaM;
    }

◆ getLifetime()

double Meson::getLifetime ( ) const

inline

A get method for the lifetime of the meson.

Returns: the lifetime of the meson in \( \mathrm{ps}^{-1} \)

Definition at line 351 of file Meson.h.

    {
        return lifetime;
    }

◆ getName()

std::string Meson::getName ( ) const

inline

A get method to get the name of the meson.

Returns: the the name of the meson

Definition at line 420 of file Meson.h.

    {
        return name;
    }

◆ initializeParameters()

void Meson::initializeParameters ( )

◆ ModelParameterMapInsert()

void Meson::ModelParameterMapInsert ( std::map< std::string, std::reference_wrapper< const double > > & ModelParamMap )

Definition at line 36 of file Meson.cpp.

{
    if (name.compare("P_0") == 0) {
        ModelParamMap.insert(std::make_pair("MP0", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tP0", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FP0", std::cref(decayconst)));
        return;
    }
    if (name.compare("P_P") == 0) {
        ModelParamMap.insert(std::make_pair("MPp", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tPp", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FPp", std::cref(decayconst)));
        return;
    }
    if (name.compare("K_0") == 0) {
        ModelParamMap.insert(std::make_pair("MK0", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tKl", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FK", std::cref(decayconst)));
        return;
    }
    if (name.compare("K_S") == 0) {
        ModelParamMap.insert(std::make_pair("MK0", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tKs", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FK", std::cref(decayconst)));
        return;
    }
    if (name.compare("K_P") == 0) {
        ModelParamMap.insert(std::make_pair("MKp", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tKp", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FK", std::cref(decayconst)));
        ModelParamMap.insert(std::make_pair("alpha1kp", std::cref(gegenalpha[0])));
        ModelParamMap.insert(std::make_pair("alpha2kp", std::cref(gegenalpha[1])));
        return;
    }
    if (name.compare("D_0") == 0) {
        ModelParamMap.insert(std::make_pair("MD0", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tD0", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FD", std::cref(decayconst)));
        return;
    }
    if (name.compare("D_P") == 0) {
        ModelParamMap.insert(std::make_pair("MDP", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tDP", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FDP", std::cref(decayconst)));
        return;
    }
    if (name.compare("D_S") == 0) {
        ModelParamMap.insert(std::make_pair("MDs", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tDs", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FDs", std::cref(decayconst)));
        return;
    }
    if (name.compare("B_D") == 0) {
        ModelParamMap.insert(std::make_pair("MBd", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tBd", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FBd", std::cref(decayconst)));
        ModelParamMap.insert(std::make_pair("FBsoFBd", std::cref(FBsoFBd)));
        ModelParamMap.insert(std::make_pair("lambdaB", std::cref(lambdaM)));
        return;
    }
    if (name.compare("B_P") == 0) {
        ModelParamMap.insert(std::make_pair("MBp", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tBp", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FBp", std::cref(decayconst)));
        ModelParamMap.insert(std::make_pair("FBsoFBd", std::cref(FBsoFBd)));
        ModelParamMap.insert(std::make_pair("lambdaB", std::cref(lambdaM)));
        return;
    }
    if (name.compare("B_S") == 0) {
        ModelParamMap.insert(std::make_pair("MBs", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tBs", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FBs", std::cref(decayconst)));
        ModelParamMap.insert(std::make_pair("lambdaB", std::cref(lambdaM)));
        ModelParamMap.insert(std::make_pair("DGs_Gs", std::cref(Dgamma_gamma)));
        return;
    }
    if (name.compare("B_C") == 0) {
        ModelParamMap.insert(std::make_pair("MBc", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tBc", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FBc", std::cref(decayconst)));
        return;
    }
    if (name.compare("PHI") == 0) {
        ModelParamMap.insert(std::make_pair("Mphi", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tphi", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("Fphi", std::cref(decayconst)));
        ModelParamMap.insert(std::make_pair("Fphip", std::cref(decayconst_p)));
        ModelParamMap.insert(std::make_pair("alpha2phi", std::cref(gegenalpha[1])));
        return;
    }
    if (name.compare("K_star") == 0) {
        ModelParamMap.insert(std::make_pair("MKstar", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tKstar", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FKstar", std::cref(decayconst)));
        ModelParamMap.insert(std::make_pair("FKstarp", std::cref(decayconst_p)));
        ModelParamMap.insert(std::make_pair("alpha1kst", std::cref(gegenalpha[0])));
        ModelParamMap.insert(std::make_pair("alpha2kst", std::cref(gegenalpha[1])));
        return;
    }
    if (name.compare("K_star_P") == 0) {
        ModelParamMap.insert(std::make_pair("MKstarP", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tKstarP", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FKstar", std::cref(decayconst)));
        ModelParamMap.insert(std::make_pair("FKstarp", std::cref(decayconst_p)));
        ModelParamMap.insert(std::make_pair("alpha1kst", std::cref(gegenalpha[0])));
        ModelParamMap.insert(std::make_pair("alpha2kst", std::cref(gegenalpha[1])));
        return;
    }
    if (name.compare("D_star_P") == 0) {
        ModelParamMap.insert(std::make_pair("MDstarP", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tDstarP", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("FDstarP", std::cref(decayconst)));
        return;
    }
    if (name.compare("RHO") == 0) {
        ModelParamMap.insert(std::make_pair("Mrho", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("trho", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("Frho", std::cref(decayconst)));
        return;
    }
    if (name.compare("RHO_P") == 0) {
        ModelParamMap.insert(std::make_pair("MrhoP", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("trho", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("Frho", std::cref(decayconst)));
        return;
    }
    if (name.compare("OMEGA") == 0) {
        ModelParamMap.insert(std::make_pair("Momega", std::cref(mass)));
        ModelParamMap.insert(std::make_pair("tomega", std::cref(lifetime)));
        ModelParamMap.insert(std::make_pair("Fomega", std::cref(decayconst)));
        return;
    } else throw std::runtime_error(name + " is not implemented in Meson class");
}

◆ parameterList()

std::vector< std::string > Meson::parameterList ( std::string name_i )

Definition at line 170 of file Meson.cpp.

{
    if (name_i.compare("P_0") == 0) return make_vector<std::string>() << "MP0" << "tP0" << "FP0";
    if (name_i.compare("P_P") == 0) return make_vector<std::string>() << "MPp" << "tPp" << "FPp";
    if (name_i.compare("K_0") == 0) return make_vector<std::string>() << "MK0" << "tKl" << "FK";
    if (name_i.compare("K_P") == 0) return make_vector<std::string>() << "MKp" << "tKp" << "FK" << "alpha1kp" << "alpha2kp";
    if (name_i.compare("K_S") == 0) return make_vector<std::string>() << "MK0" << "tKs" << "FK";
    if (name_i.compare("D_0") == 0) return make_vector<std::string>() << "MD"  << "tD"  << "FD";
    if (name_i.compare("D_P") == 0) return make_vector<std::string>() << "MDP"  << "tDP"  << "FDP";
    if (name_i.compare("D_S") == 0) return make_vector<std::string>() << "MDs"  << "tDs"  << "FDs";
    if (name_i.compare("B_D") == 0) return make_vector<std::string>() << "MBd" << "tBd" << "FBsoFBd" << "lambdaB";
    if (name_i.compare("B_P") == 0) return make_vector<std::string>() << "MBp" << "tBp" << "FBsoFBd" << "lambdaB";
    if (name_i.compare("B_S") == 0) return make_vector<std::string>() << "MBs" << "tBs" << "FBs" << "lambdaB" << "DGs_Gs";
    if (name_i.compare("B_C") == 0) return make_vector<std::string>() << "MBc" << "tBc" << "FBc";
    if (name_i.compare("PHI") == 0) return make_vector<std::string>() << "Mphi" << "tphi"  << "Fphi" << "Fphip" << "alpha2phi";
    if (name_i.compare("K_star") == 0) return make_vector<std::string>() << "MKstar"  << "tKstar"  << "FKstar" << "FKstarp" << "alpha1kst" << "alpha2kst";
    if (name_i.compare("K_star_P") == 0) return make_vector<std::string>() << "MKstarP" << "tKstar" << "FKstar" << "FKstarp" << "alpha1kst" << "alpha2kst";
    if (name_i.compare("D_star_P") == 0) return make_vector<std::string>() << "MDstarP"  << "tDstarP"  << "FDstarP";
    if (name_i.compare("RHO") == 0) return make_vector<std::string>() << "Mrho"  << "trho"  << "Frho";
    if (name_i.compare("RHO_P") == 0) return make_vector<std::string>() << "MrhoP"  << "trho"  << "Frho";
    if (name_i.compare("OMEGA") == 0) return make_vector<std::string>() << "Momega"  << "tomega"  << "Fomega";
    else throw std::runtime_error(name_i + " is not implemented in Meson class");
}

◆ setDecayconst()

void Meson::setDecayconst ( double decayconst )

inline

A set method for the decay constant of the meson.

Parameters

[in] decayconst the decay constant of the meson in GeV

Definition at line 369 of file Meson.h.

    {
        this->decayconst = decayconst;
    }

◆ setDgamma_gamma()

void Meson::setDgamma_gamma ( double Dgamma_gamma )

inline

Definition at line 407 of file Meson.h.

                                             {
        this->Dgamma_gamma = Dgamma_gamma;
    }

◆ setName()

void Meson::setName ( std::string name_i )

inline

A set method to set the name of the meson.

Parameters

[in] name_i the the name of the meson

Definition at line 429 of file Meson.h.

    {
        this->name = name_i;
    }

◆ setParameter()

bool Meson::setParameter	(	std::string	name_i,
		double	value
	)

Definition at line 194 of file Meson.cpp.

{
    if (name.compare("P_0") == 0) {
        if (name_i.compare("MP0") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tP0") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FP0") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("P_P") == 0) {
        if (name_i.compare("MPp") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tPp") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FPp") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("K_0") == 0) {
        if (name_i.compare("MK0") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tKl") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FK") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("K_S") == 0) {
        if (name_i.compare("MK0") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tKs") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FK") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("K_P") == 0) {
        if (name_i.compare("MKp") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tKp") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FK") == 0) {
            decayconst = value;
            return true;
        }
        if (name_i.compare("alpha1kp") == 0) {
            gegenalpha[0] = value;
            return true;
        }
        if (name_i.compare("alpha2kp") == 0) {
            gegenalpha[1] = value;
            return true;
        }
    }
    if (name.compare("D_0") == 0) {
        if (name_i.compare("MD") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tD") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FD") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("D_P") == 0) {
        if (name_i.compare("MDP") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tDP") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FDP") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("D_S") == 0) {
        if (name_i.compare("MDs") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tDs") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FDs") == 0) {
            decayconst = value;
            return true;
        }
    }
     if (name.compare("B_D") == 0) {
        if (name_i.compare("MBd") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tBd") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FBsoFBd") == 0) {
            FBsoFBd = value;
            return true;
        }
        if (name_i.compare("lambdaB") == 0) {
            lambdaM = value;
            return true;
        }
    }
    if (name.compare("B_P") == 0) {
        if (name_i.compare("MBp") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tBp") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FBsoFBd") == 0) {
            FBsoFBd = value;
            return true;
        }
        if (name_i.compare("lambdaB") == 0) {
            lambdaM = value;
            return true;
        }
    }
    if (name.compare("B_S") == 0) {
        if (name_i.compare("MBs") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tBs") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FBs") == 0) {
            decayconst = value;
            return true;
        }
        if (name_i.compare("lambdaB") == 0) {
            lambdaM = value;
            return true;
        }
        if (name_i.compare("DGs_Gs") == 0) {
            Dgamma_gamma = value;
            return true;
        }
    }
    if (name.compare("B_C") == 0) {
        if (name_i.compare("MBc") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tBc") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FBc") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("PHI") == 0) {
        if (name_i.compare("Mphi") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tphi") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("Fphi") == 0) {
            decayconst = value;
            return true;
        }
        if (name_i.compare("Fphip") == 0) {
            decayconst_p = value;
            return true;
        }
        if (name_i.compare("alpha2phi") == 0) {
            gegenalpha[1] = value;
            return true;
        }
    }
    if (name.compare("K_star") == 0) {
        if (name_i.compare("MKstar") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tKstar") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FKstar") == 0) {
            decayconst = value;
            return true;
        }
        if (name_i.compare("FKstarp") == 0) {
            decayconst_p = value;
            return true;
        }
        if (name_i.compare("alpha1kst") == 0) {
            gegenalpha[0] = value;
            return true;
        }
        if (name_i.compare("alpha2kst") == 0) {
            gegenalpha[1] = value;
            return true;
        }
    }
    if (name.compare("K_star_P") == 0) {
        if (name_i.compare("MKstarP") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tKstar") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FKstar") == 0) {
            decayconst = value;
            return true;
        }
        if (name_i.compare("FKstarp") == 0) {
            decayconst_p = value;
            return true;
        }
        if (name_i.compare("alpha1kst") == 0) {
            gegenalpha[0] = value;
            return true;
        }
        if (name_i.compare("alpha2kst") == 0) {
            gegenalpha[1] = value;
            return true;
        }
    }
    if (name.compare("D_star_P") == 0) {
        if (name_i.compare("MDstarP") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tDstarP") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("FDstarP") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("RHO") == 0) {
        if (name_i.compare("Mrho") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("trho") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("Frho") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("RHO_P") == 0) {
        if (name_i.compare("MrhoP") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("trho") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("Frho") == 0) {
            decayconst = value;
            return true;
        }
    }
    if (name.compare("OMEGA") == 0) {
        if (name_i.compare("Momega") == 0) {
            mass = value;
            return true;
        }
        if (name_i.compare("tomega") == 0) {
            lifetime = value;
            return true;
        }
        if (name_i.compare("Fomega") == 0) {
            decayconst = value;
            return true;
        }
    }
    return false;
}

Member Data Documentation

◆ decayconst

double Meson::decayconst

private

The decay constant of the meson.

Definition at line 440 of file Meson.h.

◆ decayconst_p

double Meson::decayconst_p

private

The perpendicular decay constant of a vector meson.

Definition at line 441 of file Meson.h.

◆ Dgamma_gamma

double Meson::Dgamma_gamma

private

Dgamma/gamma for neutral mesons.

Definition at line 445 of file Meson.h.

◆ FBsoFBd

double Meson::FBsoFBd

private

Definition at line 446 of file Meson.h.

◆ gegenalpha

double Meson::gegenalpha[2]

private

Gegenbauer moments.

Definition at line 443 of file Meson.h.

◆ lambdaM

double Meson::lambdaM

private

First moment of LCDA.

Definition at line 444 of file Meson.h.

◆ lifetime

double Meson::lifetime

private

The lifetime of the meson.

Definition at line 442 of file Meson.h.

The documentation for this class was generated from the following files:

Detailed Description

Model parameters

Public Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ Meson() [1/2]

◆ Meson() [2/2]

◆ ~Meson()

Member Function Documentation

◆ computeWidth()

◆ getDecayconst()

◆ getDecayconst_p()

◆ getDgamma_gamma()

◆ getFBsoFBd()

◆ getGegenalpha()

◆ getLambdaM()

◆ getLifetime()

◆ getName()

◆ initializeParameters()

◆ ModelParameterMapInsert()

◆ parameterList()

◆ setDecayconst()

◆ setDgamma_gamma()

◆ setName()

◆ setParameter()

Member Data Documentation

◆ decayconst

◆ decayconst_p

◆ Dgamma_gamma

◆ FBsoFBd

◆ gegenalpha

◆ lambdaM

◆ lifetime