slophep.Predictions.FormFactorsBToV

class slophep.Predictions.FormFactorsBToV.BGLGeneric_BToV(B: str, V: str, par: dict = None, scale: float = None, order_g: int = 2, order_f: int = 2, order_F1: int = 2, order_F2: int = 1)

Bases: FormFactorBToV

blaschke(BcStates: list, z: float, Mb: float, Mc: float) → float

Calculate Blaschke factor P(t) from B_c-type resonances

get_ff(q2: float) → dict

Calculates BGL form factors (SM only) as in hammer https://gitlab.com/mpapucci/Hammer/-/blob/v1.2.1/src/FormFactors/FFBtoDstarBGL.cc?ref_type=tags

Note that there is an additional 1./(etaEW*Vcb) factor applied to FFs in Hammer that is not present here. For that exact correspondence use BGL_Hammer FFs for the decay mode.

Parameters:

q2 (float)

Returns:

FF dictionary

Return type:

dict

outer_fcns(z: float) → dict

Computation of the outer functions

params_setup(order_g: int, order_f: int, order_F1: int, order_F2: int) → None

class slophep.Predictions.FormFactorsBToV.BGL_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

blaschke(BcStates: list, z: float, Mb: float, Mc: float) → float

Calculate Blaschke factor P(t) from B_c-type resonances

get_ff(q2: float) → dict

Calculates BGL form factors (SM only) as in hammer https://gitlab.com/mpapucci/Hammer/-/blob/v1.2.1/src/FormFactors/FFBtoDstarBGL.cc?ref_type=tags

Note that there is an additional 1./(etaEW*Vcb) factor applied to FFs in Hammer that is not present here. For that exact correspondence use BGL_Hammer FFs for the decay mode.

Parameters:

q2 (float)

Returns:

FF dictionary

Return type:

dict

outer_fcns(z: float) → dict

Computation of the outer functions

class slophep.Predictions.FormFactorsBToV.BGL_BToV_Hammer(B: str, V: str, par: dict, scale: float, *ffargs)

Bases: BGL_BToV

get_ff(q2: float) → dict

Calculates BGL form factors (SM only) as in hammer https://gitlab.com/mpapucci/Hammer/-/blob/v1.2.1/src/FormFactors/FFBtoDstarBGL.cc?ref_type=tags

Note that there is an additional 1./(etaEW*Vcb) factor applied to FFs as in Hammer.

Parameters:

q2 (float)

Returns:

FF dictionary

Return type:

dict

class slophep.Predictions.FormFactorsBToV.BLPRXP_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

IW(w: float) → dict

Li1(w: float, IWs: dict = None) → list[float]

Li2(w: float, IWs: dict = None) → list[float]

Mi(w: float, IWs: dict = None) → list[float]

calculate_internal(rawinternalpar: dict = {})

get_ff(q2: float) → dict

FF in BLPRXP parameterisation from https://arxiv.org/abs/2206.11281 as in HAMMER v1.4.1

Parameters:

q2 (float) – q2 value to calculate FF at

Returns:

FF dictionary

Return type:

dict

get_hhat(q2: float) → dict

xi(w: float) → float

z_of_w(w: float, a: float) → float

class slophep.Predictions.FormFactorsBToV.BLPR_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

get_ff(q2: float) → dict

FF in BLPR parameterisation from https://arxiv.org/pdf/1703.05330 as in HAMMER v1.4.1

Parameters:

q2 (float) – q2 value to calculate FF at

Returns:

FF dictionary

Return type:

dict

get_hhat(q2: float) → dict

class slophep.Predictions.FormFactorsBToV.BLPR_BToV_Hammer(B: str, V: str, par: dict, scale: float, *ffargs)

Bases: BLPR_BToV

class slophep.Predictions.FormFactorsBToV.BSZ_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

get_ff(q2: float) → dict

Calculates BSZ form factors, following https://arxiv.org/pdf/1503.05534 and https://arxiv.org/pdf/1811.00983. Implementation lifted from flavio https://github.com/flav-io/flavio/blob/master/flavio/physics/bdecays/formfactors/b_v/bsz.py, and should be in line with EOS https://github.com/eos/eos/blob/master/eos/form-factors/parametric-bsz2015-impl.hh

Parameters:

q2 (float)

Returns:

FF dictionary

Return type:

dict

pole(q2: float, mres: float)

z(mB: float, mM: float, q2: float, t0: float = None)

Form factor expansion parameter z.

Parameters:

• mB (float) – initial pseudoscalar meson mass

• mM (float) – final meson meson mass

• q2 (float) – momentum transfer squared q2

• t0 (float) – parameter t_0. If not given, chosen as t_0 = t_+ (1 - sqrt(1 - t_-/t_+))$ where t_+- = (m_B +- m_M)^2. If equal to tm, set to t_0=t_-

zs(mB: float, mV: float, q2: float, t0: float = None)

class slophep.Predictions.FormFactorsBToV.CLN2_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

get_ff(q2: float) → dict

Central value of $B o V$ form factors in the lattice convention CLN parametrization. See eqs. (B4)-(B7) of arXiv:1203.2654.

Directly lifted from flavio, see https://github.com/flav-io/flavio/blob/master/flavio/physics/bdecays/formfactors/b_v/clnexp.py

For SM, this behaviour should be the same as HQET2 in EvtGen and CLN in HAMMER (though haven’t verified throughly)

For BSM, this follows flavio behaviour implementing eq. 11 in https://arxiv.org/pdf/1503.05534 and assuming r(q2) = 1 for all three terms in the equation

Parameters:

q2 (float) – q2 value to calculate FF at

Returns:

FF dictionary

Return type:

dict

isgur_wise(q2: float, ff: dict) → dict

Isgur-Wise-like relations to obtain tensor form factors from vector form factors from the equations of motion in the heavy quark limit

Implements eq. 11 in https://arxiv.org/pdf/1503.05534 and assumes r(q2) = 1 for all three terms in the equation

Directly lifted from flavio https://github.com/flav-io/flavio/blob/master/flavio/physics/bdecays/formfactors/b_v/isgurwise.py

Parameters:

• q2 (float) – q2 value to calculate FF at

• ff (dict) – dictionary with other FFs

Returns:

FF dictionary with a tensor FFs

Return type:

dict

class slophep.Predictions.FormFactorsBToV.CLN_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

get_ff(q2: float) → dict

Central value of $B o V$ form factors in the lattice convention CLN parametrization. See eqs. (B4)-(B7) of arXiv:1203.2654.

Directly lifted from flavio, see https://github.com/flav-io/flavio/blob/master/flavio/physics/bdecays/formfactors/b_v/clnexp.py

For SM, this behaviour should be the same as HQET2 in EvtGen and CLN in HAMMER (though haven’t verified throughly)

Parameters:

q2 (float) – q2 value to calculate FF at

Returns:

FF dictionary

Return type:

dict

class slophep.Predictions.FormFactorsBToV.CLN_BToV_Hammer(B: str, V: str, par: dict, scale: float, *ffargs)

Bases: CLN_BToV

class slophep.Predictions.FormFactorsBToV.FormFactorBToV(B: str, V: str, par: dict = None, scale: float = None)

Bases: FormFactor

property B: str

The B meson

property V: str

The Charmed Vector meson

get_ff(q2: float) → dict

Calculate form factors at particular q2. To implement in derived class. Must return in basis V, A0, A1, A12, T1, T2, T23

Parameters:

q2 (float)

Returns:

dictionary with FFs V, A0, A1, A12, T1, T2, T23

Return type:

dict

get_ff_R_basis(q2: float) → dict

Calculate FF CLN ratios R0, R1, R2, formulae from ancillary material in https://arxiv.org/abs/2304.03137. Directly lifted from the ancillary files (LOAD_FIT.py)

Parameters:

q2 (float)

Returns:

dictionary with FFs hA1, R0, R1, R2

Return type:

dict

get_ff_gfF1F2_basis(q2: float) → dict

Calculate FFs in common BGL basis g, f, F1, F2

Parameters:

q2 (float)

Returns:

dictionary with FFs g, f, F1, F2

Return type:

dict

get_ff_h_basis(q2: float) → dict

Calculate form factors in HQET basis h_i

NOTE: hT3 and thus T3 must be computed from T23 and this requires dividing by a term that is zero at zero recoil. Because of this, the zero-recoil value is slightly offset from q2_max -> 0.999999999*q2_max

This affects only this transformation of basis. The method get_ff(q2) does not have this issue.

Parameters:

q2 (float)

Returns:

dictionary with FFs hV, hA0, hA1, hA2, hA3, hT1, hT2, hT3

Return type:

dict

w(q2: float) → float

class slophep.Predictions.FormFactorsBToV.HPQCD_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

_get_ff_h(q2: float, A: str) → float

Calculates h form factors according to https://arxiv.org/abs/2304.03137. Directly lifted from the ancillary files (LOAD_FIT.py)

Parameters:

• q2 (float)

• A (str) – FF to compute, hA1, hA2, hA3, hV, hT1, hT2, hT3

Returns:

FF computed at q2 value

Return type:

float

get_ff(q2: float) → dict[float]

Implements FF caclculation according to https://arxiv.org/abs/2304.03137. Directly lifted from the ancillary files (LOAD_FIT.py)

Parameters:

q2 (float)

Returns:

FF dictionary

Return type:

dict[float]

class slophep.Predictions.FormFactorsBToV.ISGW2_BToV(B: str, V: str, par: dict = None, scale: float = None, *ffargs)

Bases: FormFactorBToV

get_as(mq1: float, mq2: float) → float

get_ff(q2: float) → dict

ISGW2 FFs - in general not good

Parameters:

q2 (float) – q2 value to calculate FF at

Returns:

FF dictionary

Return type:

dict

get_gammaji(z: float) → float