{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Import"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\zfit\\util\\execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n",
" warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
"For more information, please see:\n",
" * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
" * https://github.com/tensorflow/addons\n",
"If you depend on functionality not listed there, please file an issue.\n",
"\n"
]
}
],
"source": [
"import os\n",
"\n",
"# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"-1\"\n",
"import random\n",
"import numpy as np\n",
"from pdg_const1 import pdg\n",
"import matplotlib\n",
"import matplotlib.pyplot as plt\n",
"import pickle as pkl\n",
"import sys\n",
"import time\n",
"from helperfunctions import display_time, prepare_plot\n",
"import cmath as c\n",
"import scipy.integrate as integrate\n",
"from scipy.optimize import fminbound\n",
"from array import array as arr\n",
"import collections\n",
"from itertools import compress\n",
"import tensorflow as tf\n",
"import zfit\n",
"from zfit import ztf\n",
"# from IPython.display import clear_output\n",
"import os\n",
"import tensorflow_probability as tfp\n",
"tfd = tfp.distributions\n",
"\n",
"from matplotlib.pyplot import figure"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# chunksize = 10000\n",
"# zfit.run.chunking.active = True\n",
"# zfit.run.chunking.max_n_points = chunksize"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Build model and graphs\n",
"## Create graphs"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def formfactor(q2, subscript, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2): #returns real value\n",
" #check if subscript is viable\n",
"\n",
" if subscript != \"0\" and subscript != \"+\" and subscript != \"T\":\n",
" raise ValueError('Wrong subscript entered, choose either 0, + or T')\n",
"\n",
" #get constants\n",
"\n",
" mK = ztf.constant(pdg['Ks_M'])\n",
" mbstar0 = ztf.constant(pdg[\"mbstar0\"])\n",
" mbstar = ztf.constant(pdg[\"mbstar\"])\n",
"\n",
"\n",
" mmu = ztf.constant(pdg['muon_M'])\n",
" mb = ztf.constant(pdg['bquark_M'])\n",
" ms = ztf.constant(pdg['squark_M'])\n",
" mB = ztf.constant(pdg['Bplus_M'])\n",
"\n",
" #N comes from derivation in paper\n",
"\n",
" N = 3\n",
"\n",
" #some helperfunctions\n",
"\n",
" tpos = (mB - mK)**2\n",
" tzero = (mB + mK)*(ztf.sqrt(mB)-ztf.sqrt(mK))**2\n",
"\n",
" z_oben = ztf.sqrt(tpos - q2) - ztf.sqrt(tpos - tzero)\n",
" z_unten = ztf.sqrt(tpos - q2) + ztf.sqrt(tpos - tzero)\n",
" z = tf.divide(z_oben, z_unten)\n",
"\n",
" #calculate f0\n",
"\n",
" if subscript == \"0\":\n",
" prefactor = 1/(1 - q2/(mbstar0**2))\n",
" _sum = 0\n",
" b0 = [b0_0, b0_1, b0_2]\n",
"\n",
" for i in range(N):\n",
" _sum += b0[i]*(tf.pow(z,i))\n",
"\n",
" return ztf.to_complex(prefactor * _sum)\n",
"\n",
" #calculate f+ or fT\n",
"\n",
" else:\n",
" prefactor = 1/(1 - q2/(mbstar**2))\n",
" _sum = 0\n",
"\n",
" if subscript == \"T\":\n",
" bT = [bT_0, bT_1, bT_2]\n",
" for i in range(N):\n",
" _sum += bT[i] * (tf.pow(z, i) - ((-1)**(i-N)) * (i/N) * tf.pow(z, N))\n",
" else:\n",
" bplus = [bplus_0, bplus_1, bplus_2]\n",
" for i in range(N):\n",
" _sum += bplus[i] * (tf.pow(z, i) - ((-1)**(i-N)) * (i/N) * tf.pow(z, N))\n",
"\n",
" return ztf.to_complex(prefactor * _sum)\n",
"\n",
"def resonance(q, _mass, width, phase, scale):\n",
"\n",
" q2 = tf.pow(q, 2)\n",
"\n",
" mmu = ztf.constant(pdg['muon_M'])\n",
"\n",
" p = 0.5 * ztf.sqrt(q2 - 4*(mmu**2))\n",
"\n",
" p0 = 0.5 * ztf.sqrt(_mass**2 - 4*mmu**2)\n",
"\n",
" gamma_j = tf.divide(p, q) * _mass * width / p0\n",
"\n",
" #Calculate the resonance\n",
"\n",
" _top = tf.complex(_mass * width, ztf.constant(0.0))\n",
"\n",
" _bottom = tf.complex(_mass**2 - q2, -_mass*gamma_j)\n",
"\n",
" com = _top/_bottom\n",
"\n",
" #Rotate by the phase\n",
"\n",
" r = ztf.to_complex(scale*tf.abs(com))\n",
"\n",
" _phase = tf.angle(com)\n",
"\n",
" _phase += phase\n",
"\n",
" com = r * tf.exp(tf.complex(ztf.constant(0.0), _phase))\n",
"\n",
" return com\n",
"\n",
"\n",
"def axiv_nonres(q, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2):\n",
"\n",
" GF = ztf.constant(pdg['GF'])\n",
" alpha_ew = ztf.constant(pdg['alpha_ew'])\n",
" Vtb = ztf.constant(pdg['Vtb'])\n",
" Vts = ztf.constant(pdg['Vts'])\n",
" C10eff = ztf.constant(pdg['C10eff'])\n",
"\n",
" mmu = ztf.constant(pdg['muon_M'])\n",
" mb = ztf.constant(pdg['bquark_M'])\n",
" ms = ztf.constant(pdg['squark_M'])\n",
" mK = ztf.constant(pdg['Ks_M'])\n",
" mB = ztf.constant(pdg['Bplus_M'])\n",
"\n",
" q2 = tf.pow(q, 2)\n",
"\n",
" #Some helperfunctions\n",
"\n",
" beta = 1. - 4. * mmu**2. / q2\n",
"\n",
" kabs = ztf.sqrt(mB**2. + tf.pow(q2, 2)/mB**2. + mK**4./mB**2. - 2. * (mB**2. * mK**2. + mK**2. * q2 + mB**2. * q2) / mB**2.)\n",
"\n",
" #prefactor in front of whole bracket\n",
"\n",
" prefactor1 = GF**2. *alpha_ew**2. * (tf.abs(Vtb*Vts))**2. * kabs * beta / (128. * np.pi**5.)\n",
"\n",
" #left term in bracket\n",
"\n",
" bracket_left = 2./3. * tf.pow(kabs,2) * tf.pow(beta,2) * tf.pow(tf.abs(ztf.to_complex(C10eff)*formfactor(q2, \"+\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)),2)\n",
"\n",
" #middle term in bracket\n",
"\n",
" _top = 4. * mmu**2. * (mB**2. - mK**2.) * (mB**2. - mK**2.)\n",
"\n",
" _under = q2 * mB**2.\n",
"\n",
" bracket_middle = _top/_under *tf.pow(tf.abs(ztf.to_complex(C10eff) * formfactor(q2, \"0\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)), 2)\n",
" \n",
" #Note sqrt(q2) comes from derivation as we use q2 and plot q\n",
"\n",
" return prefactor1 * (bracket_left + bracket_middle) * 2 * q\n",
"\n",
"def vec(q, funcs, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2):\n",
" \n",
" q2 = tf.pow(q, 2)\n",
"\n",
" GF = ztf.constant(pdg['GF'])\n",
" alpha_ew = ztf.constant(pdg['alpha_ew'])\n",
" Vtb = ztf.constant(pdg['Vtb'])\n",
" Vts = ztf.constant(pdg['Vts'])\n",
" C7eff = ztf.constant(pdg['C7eff'])\n",
"\n",
" mmu = ztf.constant(pdg['muon_M'])\n",
" mb = ztf.constant(pdg['bquark_M'])\n",
" ms = ztf.constant(pdg['squark_M'])\n",
" mK = ztf.constant(pdg['Ks_M'])\n",
" mB = ztf.constant(pdg['Bplus_M'])\n",
"\n",
" #Some helperfunctions\n",
"\n",
" beta = 1. - 4. * mmu**2. / q2\n",
"\n",
" kabs = ztf.sqrt(mB**2. + tf.pow(q2, 2)/mB**2. + mK**4./mB**2. - 2 * (mB**2 * mK**2 + mK**2 * q2 + mB**2 * q2) / mB**2)\n",
" \n",
" #prefactor in front of whole bracket\n",
"\n",
" prefactor1 = GF**2. *alpha_ew**2. * (tf.abs(Vtb*Vts))**2 * kabs * beta / (128. * np.pi**5.)\n",
"\n",
" #right term in bracket\n",
"\n",
" prefactor2 = tf.pow(kabs,2) * (1. - 1./3. * beta)\n",
"\n",
" abs_bracket = tf.pow(tf.abs(c9eff(q, funcs) * formfactor(q2, \"+\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2) + ztf.to_complex(2.0 * C7eff * (mb + ms)/(mB + mK)) * formfactor(q2, \"T\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)),2)\n",
"\n",
" bracket_right = prefactor2 * abs_bracket\n",
"\n",
" #Note sqrt(q2) comes from derivation as we use q2 and plot q\n",
"\n",
" return prefactor1 * bracket_right * 2 * q\n",
"\n",
"def c9eff(q, funcs):\n",
"\n",
" C9eff_nr = ztf.to_complex(ztf.constant(pdg['C9eff']))\n",
"\n",
" c9 = C9eff_nr + funcs\n",
"\n",
" return c9"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def G(y):\n",
" \n",
" def inner_rect_bracket(q):\n",
" return tf.log(ztf.to_complex((1+tf.sqrt(q))/(1-tf.sqrt(q)))-tf.complex(ztf.constant(0), -1*ztf.constant(np.pi))) \n",
" \n",
" def inner_right(q):\n",
" return ztf.to_complex(2 * tf.atan(1/tf.sqrt(tf.math.real(-q))))\n",
" \n",
" big_bracket = tf.where(tf.math.real(y) > ztf.constant(0.0), inner_rect_bracket(y), inner_right(y))\n",
" \n",
" return ztf.to_complex(tf.sqrt(tf.abs(y))) * big_bracket\n",
"\n",
"def h_S(m, q):\n",
" \n",
" return ztf.to_complex(2) - G(ztf.to_complex(1) - ztf.to_complex(4*tf.pow(m, 2)) / ztf.to_complex(tf.pow(q, 2)))\n",
"\n",
"def h_P(m, q):\n",
" \n",
" return ztf.to_complex(2/3) + (ztf.to_complex(1) - ztf.to_complex(4*tf.pow(m, 2)) / ztf.to_complex(tf.pow(q, 2))) * h_S(m,q)\n",
"\n",
"def two_p_ccbar(mD, m_D_bar, m_D_star, q):\n",
" \n",
" \n",
" #Load constants\n",
" nu_D_bar = ztf.to_complex(pdg[\"nu_D_bar\"])\n",
" nu_D = ztf.to_complex(pdg[\"nu_D\"])\n",
" nu_D_star = ztf.to_complex(pdg[\"nu_D_star\"])\n",
" \n",
" phase_D_bar = ztf.to_complex(pdg[\"phase_D_bar\"])\n",
" phase_D = ztf.to_complex(pdg[\"phase_D\"])\n",
" phase_D_star = ztf.to_complex(pdg[\"phase_D_star\"])\n",
" \n",
" #Calculation\n",
" left_part = nu_D_bar * tf.exp(tf.complex(ztf.constant(0.0), phase_D_bar)) * h_S(m_D_bar, q) \n",
" \n",
" right_part_D = nu_D * tf.exp(tf.complex(ztf.constant(0.0), phase_D)) * h_P(m_D, q) \n",
" \n",
" right_part_D_star = nu_D_star * tf.exp(tf.complex(ztf.constant(0.0), phase_D_star)) * h_P(m_D_star, q) \n",
"\n",
" return left_part + right_part_D + right_part_D_star"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Build pdf"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"class total_pdf_cut(zfit.pdf.ZPDF):\n",
" _N_OBS = 1 # dimension, can be omitted\n",
" _PARAMS = ['b0_0', 'b0_1', 'b0_2', \n",
" 'bplus_0', 'bplus_1', 'bplus_2', \n",
" 'bT_0', 'bT_1', 'bT_2', \n",
" 'rho_mass', 'rho_scale', 'rho_phase', 'rho_width',\n",
" 'jpsi_mass', 'jpsi_scale', 'jpsi_phase', 'jpsi_width',\n",
" 'psi2s_mass', 'psi2s_scale', 'psi2s_phase', 'psi2s_width',\n",
" 'p3770_mass', 'p3770_scale', 'p3770_phase', 'p3770_width',\n",
" 'p4040_mass', 'p4040_scale', 'p4040_phase', 'p4040_width',\n",
" 'p4160_mass', 'p4160_scale', 'p4160_phase', 'p4160_width',\n",
" 'p4415_mass', 'p4415_scale', 'p4415_phase', 'p4415_width',\n",
" 'omega_mass', 'omega_scale', 'omega_phase', 'omega_width',\n",
" 'phi_mass', 'phi_scale', 'phi_phase', 'phi_width',\n",
" 'Dbar_mass', 'Dbar_scale', 'Dbar_phase',\n",
" 'Dstar_mass', 'DDstar_scale', 'DDstar_phase', 'D_mass',\n",
" 'tau_mass', 'C_tt']\n",
"# the name of the parameters\n",
"\n",
" def _unnormalized_pdf(self, x):\n",
" \n",
" x = x.unstack_x()\n",
" \n",
" b0 = [self.params['b0_0'], self.params['b0_1'], self.params['b0_2']]\n",
" bplus = [self.params['bplus_0'], self.params['bplus_1'], self.params['bplus_2']]\n",
" bT = [self.params['bT_0'], self.params['bT_1'], self.params['bT_2']]\n",
" \n",
" def rho_res(q):\n",
" return resonance(q, _mass = self.params['rho_mass'], scale = self.params['rho_scale'],\n",
" phase = self.params['rho_phase'], width = self.params['rho_width'])\n",
" \n",
" def omega_res(q):\n",
" return resonance(q, _mass = self.params['omega_mass'], scale = self.params['omega_scale'],\n",
" phase = self.params['omega_phase'], width = self.params['omega_width'])\n",
" \n",
" def phi_res(q):\n",
" return resonance(q, _mass = self.params['phi_mass'], scale = self.params['phi_scale'],\n",
" phase = self.params['phi_phase'], width = self.params['phi_width'])\n",
"\n",
" def jpsi_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['jpsi_mass'], 2)) * resonance(q, _mass = self.params['jpsi_mass'], \n",
" scale = self.params['jpsi_scale'],\n",
" phase = self.params['jpsi_phase'], \n",
" width = self.params['jpsi_width'])\n",
" def psi2s_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['psi2s_mass'], 2)) * resonance(q, _mass = self.params['psi2s_mass'], \n",
" scale = self.params['psi2s_scale'],\n",
" phase = self.params['psi2s_phase'], \n",
" width = self.params['psi2s_width'])\n",
" def p3770_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p3770_mass'], 2)) * resonance(q, _mass = self.params['p3770_mass'], \n",
" scale = self.params['p3770_scale'],\n",
" phase = self.params['p3770_phase'], \n",
" width = self.params['p3770_width'])\n",
" \n",
" def p4040_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4040_mass'], 2)) * resonance(q, _mass = self.params['p4040_mass'], \n",
" scale = self.params['p4040_scale'],\n",
" phase = self.params['p4040_phase'], \n",
" width = self.params['p4040_width'])\n",
" \n",
" def p4160_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4160_mass'], 2)) * resonance(q, _mass = self.params['p4160_mass'], \n",
" scale = self.params['p4160_scale'],\n",
" phase = self.params['p4160_phase'], \n",
" width = self.params['p4160_width'])\n",
" \n",
" def p4415_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4415_mass'], 2)) * resonance(q, _mass = self.params['p4415_mass'], \n",
" scale = self.params['p4415_scale'],\n",
" phase = self.params['p4415_phase'], \n",
" width = self.params['p4415_width'])\n",
" \n",
" def P2_D(q):\n",
" Dbar_contrib = ztf.to_complex(self.params['Dbar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['Dbar_phase']))*ztf.to_complex(h_S(self.params['Dbar_mass'], q))\n",
" DDstar_contrib = ztf.to_complex(self.params['DDstar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['DDstar_phase']))*(ztf.to_complex(h_P(self.params['Dstar_mass'], q)) + ztf.to_complex(h_P(self.params['D_mass'], q)))\n",
" return Dbar_contrib + DDstar_contrib\n",
" \n",
" def ttau_cusp(q):\n",
" return ztf.to_complex(self.params['C_tt'])*(ztf.to_complex((h_S(self.params['tau_mass'], q))) - ztf.to_complex(h_P(self.params['tau_mass'], q)))\n",
" \n",
"\n",
" funcs = rho_res(x) + omega_res(x) + phi_res(x) + jpsi_res(x) + psi2s_res(x) + p3770_res(x) + p4040_res(x)+ p4160_res(x) + p4415_res(x) + P2_D(x) + ttau_cusp(x)\n",
"\n",
" vec_f = vec(x, funcs, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n",
"\n",
" axiv_nr = axiv_nonres(x, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n",
"\n",
" tot = vec_f + axiv_nr\n",
" \n",
" #Cut out jpsi and psi2s\n",
" \n",
" tot = tf.where(tf.math.logical_or(x < ztf.constant(jpsi_mass-60.), x > ztf.constant(jpsi_mass+70.)), tot, 0.0*tot)\n",
" \n",
" tot = tf.where(tf.math.logical_or(x < ztf.constant(psi2s_mass-50.), x > ztf.constant(psi2s_mass+50.)), tot, 0.0*tot)\n",
" \n",
" return tot\n",
" \n",
"class total_pdf_full(zfit.pdf.ZPDF):\n",
" _N_OBS = 1 # dimension, can be omitted\n",
" _PARAMS = ['b0_0', 'b0_1', 'b0_2', \n",
" 'bplus_0', 'bplus_1', 'bplus_2', \n",
" 'bT_0', 'bT_1', 'bT_2', \n",
" 'rho_mass', 'rho_scale', 'rho_phase', 'rho_width',\n",
" 'jpsi_mass', 'jpsi_scale', 'jpsi_phase', 'jpsi_width',\n",
" 'psi2s_mass', 'psi2s_scale', 'psi2s_phase', 'psi2s_width',\n",
" 'p3770_mass', 'p3770_scale', 'p3770_phase', 'p3770_width',\n",
" 'p4040_mass', 'p4040_scale', 'p4040_phase', 'p4040_width',\n",
" 'p4160_mass', 'p4160_scale', 'p4160_phase', 'p4160_width',\n",
" 'p4415_mass', 'p4415_scale', 'p4415_phase', 'p4415_width',\n",
" 'omega_mass', 'omega_scale', 'omega_phase', 'omega_width',\n",
" 'phi_mass', 'phi_scale', 'phi_phase', 'phi_width',\n",
" 'Dbar_mass', 'Dbar_scale', 'Dbar_phase',\n",
" 'Dstar_mass', 'DDstar_scale', 'DDstar_phase', 'D_mass',\n",
" 'tau_mass', 'C_tt']\n",
"# the name of the parameters\n",
"\n",
" def _unnormalized_pdf(self, x):\n",
" \n",
" x = x.unstack_x()\n",
" \n",
" b0 = [self.params['b0_0'], self.params['b0_1'], self.params['b0_2']]\n",
" bplus = [self.params['bplus_0'], self.params['bplus_1'], self.params['bplus_2']]\n",
" bT = [self.params['bT_0'], self.params['bT_1'], self.params['bT_2']]\n",
" \n",
" def rho_res(q):\n",
" return resonance(q, _mass = self.params['rho_mass'], scale = self.params['rho_scale'],\n",
" phase = self.params['rho_phase'], width = self.params['rho_width'])\n",
" \n",
" def omega_res(q):\n",
" return resonance(q, _mass = self.params['omega_mass'], scale = self.params['omega_scale'],\n",
" phase = self.params['omega_phase'], width = self.params['omega_width'])\n",
" \n",
" def phi_res(q):\n",
" return resonance(q, _mass = self.params['phi_mass'], scale = self.params['phi_scale'],\n",
" phase = self.params['phi_phase'], width = self.params['phi_width'])\n",
"\n",
" def jpsi_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['jpsi_mass'], 2)) * resonance(q, _mass = self.params['jpsi_mass'], \n",
" scale = self.params['jpsi_scale'],\n",
" phase = self.params['jpsi_phase'], \n",
" width = self.params['jpsi_width'])\n",
" def psi2s_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['psi2s_mass'], 2)) * resonance(q, _mass = self.params['psi2s_mass'], \n",
" scale = self.params['psi2s_scale'],\n",
" phase = self.params['psi2s_phase'], \n",
" width = self.params['psi2s_width'])\n",
" def p3770_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p3770_mass'], 2)) * resonance(q, _mass = self.params['p3770_mass'], \n",
" scale = self.params['p3770_scale'],\n",
" phase = self.params['p3770_phase'], \n",
" width = self.params['p3770_width'])\n",
" \n",
" def p4040_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4040_mass'], 2)) * resonance(q, _mass = self.params['p4040_mass'], \n",
" scale = self.params['p4040_scale'],\n",
" phase = self.params['p4040_phase'], \n",
" width = self.params['p4040_width'])\n",
" \n",
" def p4160_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4160_mass'], 2)) * resonance(q, _mass = self.params['p4160_mass'], \n",
" scale = self.params['p4160_scale'],\n",
" phase = self.params['p4160_phase'], \n",
" width = self.params['p4160_width'])\n",
" \n",
" def p4415_res(q):\n",
" return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4415_mass'], 2)) * resonance(q, _mass = self.params['p4415_mass'], \n",
" scale = self.params['p4415_scale'],\n",
" phase = self.params['p4415_phase'], \n",
" width = self.params['p4415_width'])\n",
" \n",
" def P2_D(q):\n",
" Dbar_contrib = ztf.to_complex(self.params['Dbar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['Dbar_phase']))*ztf.to_complex(h_S(self.params['Dbar_mass'], q))\n",
" DDstar_contrib = ztf.to_complex(self.params['DDstar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['DDstar_phase']))*(ztf.to_complex(h_P(self.params['Dstar_mass'], q)) + ztf.to_complex(h_P(self.params['D_mass'], q)))\n",
" return Dbar_contrib + DDstar_contrib\n",
" \n",
" def ttau_cusp(q):\n",
" return ztf.to_complex(self.params['C_tt'])*(ztf.to_complex((h_S(self.params['tau_mass'], q))) - ztf.to_complex(h_P(self.params['tau_mass'], q)))\n",
" \n",
"\n",
" funcs = rho_res(x) + omega_res(x) + phi_res(x) + jpsi_res(x) + psi2s_res(x) + p3770_res(x) + p4040_res(x)+ p4160_res(x) + p4415_res(x) + P2_D(x) + ttau_cusp(x)\n",
"\n",
" vec_f = vec(x, funcs, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n",
"\n",
" axiv_nr = axiv_nonres(x, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n",
"\n",
" tot = vec_f + axiv_nr\n",
" \n",
" #Cut out jpsi and psi2s\n",
" \n",
"# tot = tf.where(tf.math.logical_or(x < ztf.constant(jpsi_mass-60.), x > ztf.constant(jpsi_mass+70.)), tot, 0.0*tot)\n",
" \n",
"# tot = tf.where(tf.math.logical_or(x < ztf.constant(psi2s_mass-50.), x > ztf.constant(psi2s_mass+50.)), tot, 0.0*tot)\n",
" \n",
" return tot"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup parameters"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"WARNING:tensorflow:From C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"Colocations handled automatically by placer.\n"
]
}
],
"source": [
"# formfactors\n",
"\n",
"b0_0 = zfit.Parameter(\"b0_0\", ztf.constant(0.292), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n",
"b0_1 = zfit.Parameter(\"b0_1\", ztf.constant(0.281), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n",
"b0_2 = zfit.Parameter(\"b0_2\", ztf.constant(0.150), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n",
"\n",
"bplus_0 = zfit.Parameter(\"bplus_0\", ztf.constant(0.466), lower_limit = -2.0, upper_limit= 2.0)\n",
"bplus_1 = zfit.Parameter(\"bplus_1\", ztf.constant(-0.885), lower_limit = -2.0, upper_limit= 2.0)\n",
"bplus_2 = zfit.Parameter(\"bplus_2\", ztf.constant(-0.213), lower_limit = -2.0, upper_limit= 2.0)\n",
"\n",
"bT_0 = zfit.Parameter(\"bT_0\", ztf.constant(0.460), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n",
"bT_1 = zfit.Parameter(\"bT_1\", ztf.constant(-1.089), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n",
"bT_2 = zfit.Parameter(\"bT_2\", ztf.constant(-1.114), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n",
"\n",
"\n",
"#rho\n",
"\n",
"rho_mass, rho_width, rho_phase, rho_scale = pdg[\"rho\"]\n",
"\n",
"rho_m = zfit.Parameter(\"rho_m\", ztf.constant(rho_mass), floating = False) #lower_limit = rho_mass - rho_width, upper_limit = rho_mass + rho_width)\n",
"rho_w = zfit.Parameter(\"rho_w\", ztf.constant(rho_width), floating = False)\n",
"rho_p = zfit.Parameter(\"rho_p\", ztf.constant(rho_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"rho_s = zfit.Parameter(\"rho_s\", ztf.constant(rho_scale), lower_limit=rho_scale-np.sqrt(rho_scale), upper_limit=rho_scale+np.sqrt(rho_scale))\n",
"\n",
"#omega\n",
"\n",
"omega_mass, omega_width, omega_phase, omega_scale = pdg[\"omega\"]\n",
"\n",
"omega_m = zfit.Parameter(\"omega_m\", ztf.constant(omega_mass), floating = False)\n",
"omega_w = zfit.Parameter(\"omega_w\", ztf.constant(omega_width), floating = False)\n",
"omega_p = zfit.Parameter(\"omega_p\", ztf.constant(omega_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"omega_s = zfit.Parameter(\"omega_s\", ztf.constant(omega_scale), lower_limit=omega_scale-np.sqrt(omega_scale), upper_limit=omega_scale+np.sqrt(omega_scale))\n",
"\n",
"\n",
"#phi\n",
"\n",
"phi_mass, phi_width, phi_phase, phi_scale = pdg[\"phi\"]\n",
"\n",
"phi_m = zfit.Parameter(\"phi_m\", ztf.constant(phi_mass), floating = False)\n",
"phi_w = zfit.Parameter(\"phi_w\", ztf.constant(phi_width), floating = False)\n",
"phi_p = zfit.Parameter(\"phi_p\", ztf.constant(phi_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"phi_s = zfit.Parameter(\"phi_s\", ztf.constant(phi_scale), lower_limit=phi_scale-np.sqrt(phi_scale), upper_limit=phi_scale+np.sqrt(phi_scale))\n",
"\n",
"#jpsi\n",
"\n",
"jpsi_mass, jpsi_width, jpsi_phase, jpsi_scale = pdg[\"jpsi\"]\n",
"\n",
"jpsi_m = zfit.Parameter(\"jpsi_m\", ztf.constant(jpsi_mass), floating = False)\n",
"jpsi_w = zfit.Parameter(\"jpsi_w\", ztf.constant(jpsi_width), floating = False)\n",
"jpsi_p = zfit.Parameter(\"jpsi_p\", ztf.constant(jpsi_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"jpsi_s = zfit.Parameter(\"jpsi_s\", ztf.constant(jpsi_scale), floating = False) #, lower_limit=jpsi_scale-np.sqrt(jpsi_scale), upper_limit=jpsi_scale+np.sqrt(jpsi_scale))\n",
"\n",
"#psi2s\n",
"\n",
"psi2s_mass, psi2s_width, psi2s_phase, psi2s_scale = pdg[\"psi2s\"]\n",
"\n",
"psi2s_m = zfit.Parameter(\"psi2s_m\", ztf.constant(psi2s_mass), floating = False)\n",
"psi2s_w = zfit.Parameter(\"psi2s_w\", ztf.constant(psi2s_width), floating = False)\n",
"psi2s_p = zfit.Parameter(\"psi2s_p\", ztf.constant(psi2s_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"psi2s_s = zfit.Parameter(\"psi2s_s\", ztf.constant(psi2s_scale), floating = False) #, lower_limit=psi2s_scale-np.sqrt(psi2s_scale), upper_limit=psi2s_scale+np.sqrt(psi2s_scale))\n",
"\n",
"#psi(3770)\n",
"\n",
"p3770_mass, p3770_width, p3770_phase, p3770_scale = pdg[\"p3770\"]\n",
"\n",
"p3770_m = zfit.Parameter(\"p3770_m\", ztf.constant(p3770_mass), floating = False)\n",
"p3770_w = zfit.Parameter(\"p3770_w\", ztf.constant(p3770_width), floating = False)\n",
"p3770_p = zfit.Parameter(\"p3770_p\", ztf.constant(p3770_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"p3770_s = zfit.Parameter(\"p3770_s\", ztf.constant(p3770_scale), lower_limit=p3770_scale-np.sqrt(p3770_scale), upper_limit=p3770_scale+np.sqrt(p3770_scale))\n",
"\n",
"#psi(4040)\n",
"\n",
"p4040_mass, p4040_width, p4040_phase, p4040_scale = pdg[\"p4040\"]\n",
"\n",
"p4040_m = zfit.Parameter(\"p4040_m\", ztf.constant(p4040_mass), floating = False)\n",
"p4040_w = zfit.Parameter(\"p4040_w\", ztf.constant(p4040_width), floating = False)\n",
"p4040_p = zfit.Parameter(\"p4040_p\", ztf.constant(p4040_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"p4040_s = zfit.Parameter(\"p4040_s\", ztf.constant(p4040_scale), lower_limit=p4040_scale-np.sqrt(p4040_scale), upper_limit=p4040_scale+np.sqrt(p4040_scale))\n",
"\n",
"#psi(4160)\n",
"\n",
"p4160_mass, p4160_width, p4160_phase, p4160_scale = pdg[\"p4160\"]\n",
"\n",
"p4160_m = zfit.Parameter(\"p4160_m\", ztf.constant(p4160_mass), floating = False)\n",
"p4160_w = zfit.Parameter(\"p4160_w\", ztf.constant(p4160_width), floating = False)\n",
"p4160_p = zfit.Parameter(\"p4160_p\", ztf.constant(p4160_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"p4160_s = zfit.Parameter(\"p4160_s\", ztf.constant(p4160_scale), lower_limit=p4160_scale-np.sqrt(p4160_scale), upper_limit=p4160_scale+np.sqrt(p4160_scale))\n",
"\n",
"#psi(4415)\n",
"\n",
"p4415_mass, p4415_width, p4415_phase, p4415_scale = pdg[\"p4415\"]\n",
"\n",
"p4415_m = zfit.Parameter(\"p4415_m\", ztf.constant(p4415_mass), floating = False)\n",
"p4415_w = zfit.Parameter(\"p4415_w\", ztf.constant(p4415_width), floating = False)\n",
"p4415_p = zfit.Parameter(\"p4415_p\", ztf.constant(p4415_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n",
"p4415_s = zfit.Parameter(\"p4415_s\", ztf.constant(p4415_scale), lower_limit=p4415_scale-np.sqrt(p4415_scale), upper_limit=p4415_scale+np.sqrt(p4415_scale))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Dynamic generation of 2 particle contribution"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"m_c = 1300\n",
"\n",
"Dbar_phase = 0.0\n",
"DDstar_phase = 0.0\n",
"Dstar_mass = pdg['Dst_M']\n",
"Dbar_mass = pdg['D0_M']\n",
"D_mass = pdg['D0_M']\n",
"\n",
"Dbar_s = zfit.Parameter(\"Dbar_s\", ztf.constant(0.0), lower_limit=-0.3, upper_limit=0.3)\n",
"Dbar_m = zfit.Parameter(\"Dbar_m\", ztf.constant(Dbar_mass), floating = False)\n",
"Dbar_p = zfit.Parameter(\"Dbar_p\", ztf.constant(Dbar_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)#, floating = False)\n",
"DDstar_s = zfit.Parameter(\"DDstar_s\", ztf.constant(0.0), lower_limit=-0.3, upper_limit=0.3)#, floating = False)\n",
"Dstar_m = zfit.Parameter(\"Dstar_m\", ztf.constant(Dstar_mass), floating = False)\n",
"D_m = zfit.Parameter(\"D_m\", ztf.constant(D_mass), floating = False)\n",
"DDstar_p = zfit.Parameter(\"DDstar_p\", ztf.constant(DDstar_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)#, floating = False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tau parameters"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"tau_m = zfit.Parameter(\"tau_m\", ztf.constant(pdg['tau_M']), floating = False)\n",
"Ctt = zfit.Parameter(\"Ctt\", ztf.constant(0.0), lower_limit=-2.5, upper_limit=2.5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Load data"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"x_min = 2*pdg['muon_M']\n",
"x_max = (pdg[\"Bplus_M\"]-pdg[\"Ks_M\"]-0.1)\n",
"\n",
"# # Full spectrum\n",
"\n",
"obs_toy = zfit.Space('q', limits = (x_min, x_max))\n",
"\n",
"# Jpsi and Psi2s cut out\n",
"\n",
"obs1 = zfit.Space('q', limits = (x_min, jpsi_mass - 60.))\n",
"obs2 = zfit.Space('q', limits = (jpsi_mass + 70., psi2s_mass - 50.))\n",
"obs3 = zfit.Space('q', limits = (psi2s_mass + 50., x_max))\n",
"\n",
"obs_fit = obs1 + obs2 + obs3\n",
"\n",
"# with open(r\"./data/slim_points/slim_points_toy_0_range({0}-{1}).pkl\".format(int(x_min), int(x_max)), \"rb\") as input_file:\n",
"# part_set = pkl.load(input_file)\n",
"\n",
"# x_part = part_set['x_part']\n",
"\n",
"# x_part = x_part.astype('float64')\n",
"\n",
"# data = zfit.data.Data.from_numpy(array=x_part, obs=obs)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Setup pdf"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"total_f = total_pdf_cut(obs=obs_toy, jpsi_mass = jpsi_m, jpsi_scale = jpsi_s, jpsi_phase = jpsi_p, jpsi_width = jpsi_w,\n",
" psi2s_mass = psi2s_m, psi2s_scale = psi2s_s, psi2s_phase = psi2s_p, psi2s_width = psi2s_w,\n",
" p3770_mass = p3770_m, p3770_scale = p3770_s, p3770_phase = p3770_p, p3770_width = p3770_w,\n",
" p4040_mass = p4040_m, p4040_scale = p4040_s, p4040_phase = p4040_p, p4040_width = p4040_w,\n",
" p4160_mass = p4160_m, p4160_scale = p4160_s, p4160_phase = p4160_p, p4160_width = p4160_w,\n",
" p4415_mass = p4415_m, p4415_scale = p4415_s, p4415_phase = p4415_p, p4415_width = p4415_w,\n",
" rho_mass = rho_m, rho_scale = rho_s, rho_phase = rho_p, rho_width = rho_w,\n",
" omega_mass = omega_m, omega_scale = omega_s, omega_phase = omega_p, omega_width = omega_w,\n",
" phi_mass = phi_m, phi_scale = phi_s, phi_phase = phi_p, phi_width = phi_w,\n",
" Dstar_mass = Dstar_m, DDstar_scale = DDstar_s, DDstar_phase = DDstar_p, D_mass = D_m,\n",
" Dbar_mass = Dbar_m, Dbar_scale = Dbar_s, Dbar_phase = Dbar_p,\n",
" tau_mass = tau_m, C_tt = Ctt, b0_0 = b0_0, b0_1 = b0_1, b0_2 = b0_2,\n",
" bplus_0 = bplus_0, bplus_1 = bplus_1, bplus_2 = bplus_2,\n",
" bT_0 = bT_0, bT_1 = bT_1, bT_2 = bT_2)\n",
"\n",
"total_f_fit = total_pdf_full(obs=obs_fit, jpsi_mass = jpsi_m, jpsi_scale = jpsi_s, jpsi_phase = jpsi_p, jpsi_width = jpsi_w,\n",
" psi2s_mass = psi2s_m, psi2s_scale = psi2s_s, psi2s_phase = psi2s_p, psi2s_width = psi2s_w,\n",
" p3770_mass = p3770_m, p3770_scale = p3770_s, p3770_phase = p3770_p, p3770_width = p3770_w,\n",
" p4040_mass = p4040_m, p4040_scale = p4040_s, p4040_phase = p4040_p, p4040_width = p4040_w,\n",
" p4160_mass = p4160_m, p4160_scale = p4160_s, p4160_phase = p4160_p, p4160_width = p4160_w,\n",
" p4415_mass = p4415_m, p4415_scale = p4415_s, p4415_phase = p4415_p, p4415_width = p4415_w,\n",
" rho_mass = rho_m, rho_scale = rho_s, rho_phase = rho_p, rho_width = rho_w,\n",
" omega_mass = omega_m, omega_scale = omega_s, omega_phase = omega_p, omega_width = omega_w,\n",
" phi_mass = phi_m, phi_scale = phi_s, phi_phase = phi_p, phi_width = phi_w,\n",
" Dstar_mass = Dstar_m, DDstar_scale = DDstar_s, DDstar_phase = DDstar_p, D_mass = D_m,\n",
" Dbar_mass = Dbar_m, Dbar_scale = Dbar_s, Dbar_phase = Dbar_p,\n",
" tau_mass = tau_m, C_tt = Ctt, b0_0 = b0_0, b0_1 = b0_1, b0_2 = b0_2,\n",
" bplus_0 = bplus_0, bplus_1 = bplus_1, bplus_2 = bplus_2,\n",
" bT_0 = bT_0, bT_1 = bT_1, bT_2 = bT_2)\n",
" \n",
"# print(total_pdf.obs)\n",
"\n",
"# print(calcs_test)\n",
"\n",
"# for param in total_f.get_dependents():\n",
"# print(zfit.run(param))"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"# total_f_fit.normalization(obs_fit)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Test if graphs actually work and compute values"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"# def total_test_tf(xq):\n",
"\n",
"# def jpsi_res(q):\n",
"# return resonance(q, jpsi_m, jpsi_s, jpsi_p, jpsi_w)\n",
"\n",
"# def psi2s_res(q):\n",
"# return resonance(q, psi2s_m, psi2s_s, psi2s_p, psi2s_w)\n",
"\n",
"# def cusp(q):\n",
"# return bifur_gauss(q, cusp_m, sig_L, sig_R, cusp_s)\n",
"\n",
"# funcs = jpsi_res(xq) + psi2s_res(xq) + cusp(xq)\n",
"\n",
"# vec_f = vec(xq, funcs)\n",
"\n",
"# axiv_nr = axiv_nonres(xq)\n",
"\n",
"# tot = vec_f + axiv_nr\n",
" \n",
"# return tot\n",
"\n",
"# def jpsi_res(q):\n",
"# return resonance(q, jpsi_m, jpsi_s, jpsi_p, jpsi_w)\n",
"\n",
"# calcs = zfit.run(total_test_tf(x_part))\n",
"\n",
"\n",
"\n",
"test_q = np.linspace(x_min, x_max, int(2e6))\n",
"\n",
"Dbar_s.set_value(0.0)\n",
"\n",
"DDstar_s.set_value(0.0)\n",
"\n",
"probs = total_f_fit.pdf(test_q, norm_range=False)\n",
"\n",
"calcs_test = zfit.run(probs)\n",
"\n",
"Ctt.set_value(0.5)\n",
"\n",
"calcs_test1 = zfit.run(probs)\n",
"\n",
"Ctt.set_value(0.0)\n",
"\n",
"Dbar_s.set_value(0.2)\n",
"\n",
"DDstar_s.set_value(0.2)\n",
"\n",
"calcs_test2 = zfit.run(probs)\n",
"# res_y = zfit.run(jpsi_res(test_q))\n",
"# b0 = [b0_0, b0_1, b0_2]\n",
"# bplus = [bplus_0, bplus_1, bplus_2]\n",
"# bT = [bT_0, bT_1, bT_2]\n",
"# f0_y = zfit.run(tf.math.real(formfactor(test_q,\"0\", b0, bplus, bT)))\n",
"# fplus_y = zfit.run(tf.math.real(formfactor(test_q,\"+\", b0, bplus, bT)))\n",
"# fT_y = zfit.run(tf.math.real(formfactor(test_q,\"T\", b0, bplus, bT)))"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"<Figure size 432x288 with 0 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 1500x1000 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.clf()\n",
"\n",
"figure(dpi = 250)\n",
"# plt.plot(x_part, calcs, '.')\n",
"plt.plot(test_q, calcs_test)#, label = r'$C_9^\\tau = 0.0$')\n",
"# plt.plot(test_q, calcs_test1, label = r'$C_9^\\tau = 0.5$')\n",
"# plt.plot(test_q, calcs_test2, label = r'$\\eta_{\\overline{D},DD^*} = 0.2$')\n",
"# plt.plot(test_q, f0_y, label = '0')\n",
"# plt.plot(test_q, fT_y, label = 'T')\n",
"# plt.plot(test_q, fplus_y, label = '+')\n",
"# plt.plot(test_q, res_y, label = 'res')\n",
"plt.axvline(x=jpsi_mass -70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=jpsi_mass +70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=psi2s_mass -50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=psi2s_mass +50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.legend()\n",
"plt.ylim(0.0, 1.5e-6)\n",
"plt.xlabel(r'$q^2 [MeV^2]$')\n",
"plt.ylabel(r'$\\mathcal{B} (B^+ \\to K^+ \\mu^+ \\mu^- ) / dq^2$')\n",
"plt.tight_layout()\n",
"# plt.yscale('log')\n",
"# plt.xlim(770, 785)\n",
"plt.savefig('test.png')\n",
"# print(jpsi_width)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"\n",
"\n",
"# probs = mixture.prob(test_q)\n",
"# probs_np = zfit.run(probs)\n",
"# probs_np *= np.max(calcs_test) / np.max(probs_np)\n",
"# plt.figure()\n",
"# plt.semilogy(test_q, probs_np,label=\"importance sampling\")\n",
"# plt.semilogy(test_q, calcs_test, label = 'pdf')\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"# 0.213/(0.00133+0.213+0.015)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Adjust scaling of different parts"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"total_f.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n",
"# total_f_fit.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n",
"# inte = total_f.integrate(limits = (950., 1050.), norm_range=False)\n",
"# inte_fl = zfit.run(inte)\n",
"# print(inte_fl/4500)\n",
"# print(pdg[\"jpsi_BR\"]/pdg[\"NR_BR\"], inte_fl*pdg[\"psi2s_auc\"]/pdg[\"NR_auc\"])"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"# # print(\"jpsi:\", inte_fl)\n",
"# # print(\"Increase am by factor:\", np.sqrt(pdg[\"jpsi_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n",
"# # print(\"New amp:\", pdg[\"jpsi\"][3]*np.sqrt(pdg[\"jpsi_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n",
"\n",
"# # print(\"psi2s:\", inte_fl)\n",
"# # print(\"Increase am by factor:\", np.sqrt(pdg[\"psi2s_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n",
"# # print(\"New amp:\", pdg[\"psi2s\"][3]*np.sqrt(pdg[\"psi2s_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n",
"\n",
"# name = \"phi\"\n",
"\n",
"# print(name+\":\", inte_fl)\n",
"# print(\"Increase am by factor:\", np.sqrt(pdg[name+\"_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n",
"# print(\"New amp:\", pdg[name][0]*np.sqrt(pdg[name+\"_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n",
"\n",
"\n",
"# print(x_min)\n",
"# print(x_max)\n",
"# # total_f.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n",
"# total_f.update_integration_options(mc_sampler=lambda dim, num_results,\n",
"# dtype: tf.random_uniform(maxval=1., shape=(num_results, dim), dtype=dtype),\n",
"# draws_per_dim=1000000)\n",
"# # _ = []\n",
"\n",
"# # for i in range(10):\n",
"\n",
"# # inte = total_f.integrate(limits = (x_min, x_max))\n",
"# # inte_fl = zfit.run(inte)\n",
"# # print(inte_fl)\n",
"# # _.append(inte_fl)\n",
"\n",
"# # print(\"mean:\", np.mean(_))\n",
"\n",
"# _ = time.time()\n",
"\n",
"# inte = total_f.integrate(limits = (x_min, x_max))\n",
"# inte_fl = zfit.run(inte)\n",
"# print(inte_fl)\n",
"# print(\"Time taken: {}\".format(display_time(int(time.time() - _))))\n",
"\n",
"# print(pdg['NR_BR']/pdg['NR_auc']*inte_fl)\n",
"# print(0.25**2*4.2/1000)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Sampling\n",
"## Mixture distribution for sampling"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"\n",
" \n",
"# print(list_of_borders[:9])\n",
"# print(list_of_borders[-9:])\n",
"\n",
"\n",
"class UniformSampleAndWeights(zfit.util.execution.SessionHolderMixin):\n",
" def __call__(self, limits, dtype, n_to_produce):\n",
" # n_to_produce = tf.cast(n_to_produce, dtype=tf.int32)\n",
" low, high = limits.limit1d\n",
" low = tf.cast(low, dtype=dtype)\n",
" high = tf.cast(high, dtype=dtype)\n",
"# uniform = tfd.Uniform(low=low, high=high)\n",
"# uniformjpsi = tfd.Uniform(low=tf.constant(3080, dtype=dtype), high=tf.constant(3112, dtype=dtype))\n",
"# uniformpsi2s = tfd.Uniform(low=tf.constant(3670, dtype=dtype), high=tf.constant(3702, dtype=dtype))\n",
"\n",
"# list_of_borders = []\n",
"# _p = []\n",
"# splits = 10\n",
"\n",
"# _ = np.linspace(x_min, x_max, splits)\n",
"\n",
"# for i in range(splits):\n",
"# list_of_borders.append(tf.constant(_[i], dtype=dtype))\n",
"# _p.append(tf.constant(1/splits, dtype=dtype))\n",
" \n",
"# mixture = tfd.MixtureSameFamily(mixture_distribution=tfd.Categorical(probs=_p[:(splits-1)]),\n",
"# components_distribution=tfd.Uniform(low=list_of_borders[:(splits-1)], \n",
"# high=list_of_borders[-(splits-1):]))\n",
" mixture = tfd.MixtureSameFamily(mixture_distribution=tfd.Categorical(probs=[tf.constant(0.05, dtype=dtype),\n",
" tf.constant(0.93, dtype=dtype),\n",
" tf.constant(0.05, dtype=dtype),\n",
" tf.constant(0.065, dtype=dtype),\n",
" tf.constant(0.04, dtype=dtype),\n",
" tf.constant(0.05, dtype=dtype)]),\n",
" components_distribution=tfd.Uniform(low=[tf.constant(x_min, dtype=dtype), \n",
" tf.constant(3090, dtype=dtype),\n",
" tf.constant(3681, dtype=dtype), \n",
" tf.constant(3070, dtype=dtype),\n",
" tf.constant(1000, dtype=dtype),\n",
" tf.constant(3660, dtype=dtype)], \n",
" high=[tf.constant(x_max, dtype=dtype),\n",
" tf.constant(3102, dtype=dtype), \n",
" tf.constant(3691, dtype=dtype),\n",
" tf.constant(3110, dtype=dtype),\n",
" tf.constant(1040, dtype=dtype),\n",
" tf.constant(3710, dtype=dtype)]))\n",
"# dtype = tf.float64\n",
"# mixture = tfd.MixtureSameFamily(mixture_distribution=tfd.Categorical(probs=[tf.constant(0.04, dtype=dtype),\n",
"# tf.constant(0.90, dtype=dtype),\n",
"# tf.constant(0.02, dtype=dtype),\n",
"# tf.constant(0.07, dtype=dtype),\n",
"# tf.constant(0.02, dtype=dtype)]),\n",
"# components_distribution=tfd.Uniform(low=[tf.constant(x_min, dtype=dtype), \n",
"# tf.constant(3089, dtype=dtype),\n",
"# tf.constant(3103, dtype=dtype), \n",
"# tf.constant(3681, dtype=dtype),\n",
"# tf.constant(3691, dtype=dtype)], \n",
"# high=[tf.constant(3089, dtype=dtype),\n",
"# tf.constant(3103, dtype=dtype), \n",
"# tf.constant(3681, dtype=dtype),\n",
"# tf.constant(3691, dtype=dtype), \n",
"# tf.constant(x_max, dtype=dtype)]))\n",
"# mixture = tfd.Uniform(tf.constant(x_min, dtype=dtype), tf.constant(x_max, dtype=dtype))\n",
"# sample = tf.random.uniform((n_to_produce, 1), dtype=dtype)\n",
" sample = mixture.sample((n_to_produce, 1))\n",
"# sample = tf.random.uniform((n_to_produce, 1), dtype=dtype)\n",
" weights = mixture.prob(sample)[:,0]\n",
"# weights = tf.broadcast_to(tf.constant(1., dtype=dtype), shape=(n_to_produce,))\n",
" # sample = tf.expand_dims(sample, axis=-1)\n",
"# print(sample, weights)\n",
" \n",
"# weights = tf.ones(shape=(n_to_produce,), dtype=dtype)\n",
" weights_max = None\n",
" thresholds = tf.random_uniform(shape=(n_to_produce,), dtype=dtype)\n",
" return sample, thresholds, weights, weights_max, n_to_produce"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"# total_f._sample_and_weights = UniformSampleAndWeights"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Constraints"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"# 1. Constraint - Real part of sum of Psi contrib and D contribs\n",
"\n",
"sum_list = []\n",
"\n",
"sum_list.append(ztf.to_complex(jpsi_s) * tf.exp(tf.complex(ztf.constant(0.0), jpsi_p)) * ztf.to_complex(jpsi_w / (tf.pow(jpsi_m,3))))\n",
"sum_list.append(ztf.to_complex(psi2s_s) * tf.exp(tf.complex(ztf.constant(0.0), psi2s_p)) * ztf.to_complex(psi2s_w / (tf.pow(psi2s_m,3))))\n",
"sum_list.append(ztf.to_complex(p3770_s) * tf.exp(tf.complex(ztf.constant(0.0), p3770_p)) * ztf.to_complex(p3770_w / (tf.pow(p3770_m,3))))\n",
"sum_list.append(ztf.to_complex(p4040_s) * tf.exp(tf.complex(ztf.constant(0.0), p4040_p)) * ztf.to_complex(p4040_w / (tf.pow(p4040_m,3))))\n",
"sum_list.append(ztf.to_complex(p4160_s) * tf.exp(tf.complex(ztf.constant(0.0), p4160_p)) * ztf.to_complex(p4160_w / (tf.pow(p4160_m,3))))\n",
"sum_list.append(ztf.to_complex(p4415_s) * tf.exp(tf.complex(ztf.constant(0.0), p4415_p)) * ztf.to_complex(p4415_w / (tf.pow(p4415_m,3))))\n",
"sum_list.append(ztf.to_complex(DDstar_s) * tf.exp(tf.complex(ztf.constant(0.0), DDstar_p)) * (ztf.to_complex(1.0 / (10.0*tf.pow(Dstar_m,2)) + 1.0 / (10.0*tf.pow(D_m,2)))))\n",
"sum_list.append(ztf.to_complex(Dbar_s) * tf.exp(tf.complex(ztf.constant(0.0), Dbar_p)) * ztf.to_complex(1.0 / (6.0*tf.pow(Dbar_m,2))))\n",
"\n",
"sum_ru_1 = ztf.to_complex(ztf.constant(0.0))\n",
"\n",
"for part in sum_list:\n",
" sum_ru_1 += part\n",
"\n",
"sum_1 = tf.math.real(sum_ru_1)\n",
"# constraint1 = zfit.constraint.GaussianConstraint(params = sum_1, mu = ztf.constant(1.7*10**-8), \n",
"# sigma = ztf.constant(2.2*10**-8))\n",
"\n",
"constraint1 = tf.pow((sum_1-ztf.constant(1.7*10**-8))/ztf.constant(2.2*10**-8),2)/ztf.constant(2.)\n",
"\n",
"# 2. Constraint - Abs. of sum of Psi contribs and D contribs\n",
"\n",
"sum_2 = tf.abs(sum_ru_1)\n",
"constraint2 = tf.cond(tf.greater_equal(sum_2, 5.0e-8), lambda: 100000., lambda: 0.)\n",
"\n",
"# 3. Constraint - Maximum eta of D contribs\n",
"\n",
"constraint3_0 = tf.cond(tf.greater_equal(tf.abs(Dbar_s), 0.2), lambda: 100000., lambda: 0.)\n",
"\n",
"constraint3_1 = tf.cond(tf.greater_equal(tf.abs(DDstar_s), 0.2), lambda: 100000., lambda: 0.)\n",
"\n",
"# 4. Constraint - Formfactor multivariant gaussian covariance fplus\n",
"\n",
"Cov_matrix = [[ztf.constant( 1.), ztf.constant( 0.45), ztf.constant( 0.19), ztf.constant(0.857), ztf.constant(0.598), ztf.constant(0.531), ztf.constant(0.752), ztf.constant(0.229), ztf.constant(0.117)],\n",
" [ztf.constant( 0.45), ztf.constant( 1.), ztf.constant(0.677), ztf.constant(0.708), ztf.constant(0.958), ztf.constant(0.927), ztf.constant(0.227), ztf.constant(0.443), ztf.constant(0.287)],\n",
" [ztf.constant( 0.19), ztf.constant(0.677), ztf.constant( 1.), ztf.constant(0.595), ztf.constant(0.770), ztf.constant(0.819),ztf.constant(-0.023), ztf.constant( 0.07), ztf.constant(0.196)],\n",
" [ztf.constant(0.857), ztf.constant(0.708), ztf.constant(0.595), ztf.constant( 1.), ztf.constant( 0.83), ztf.constant(0.766), ztf.constant(0.582), ztf.constant(0.237), ztf.constant(0.192)],\n",
" [ztf.constant(0.598), ztf.constant(0.958), ztf.constant(0.770), ztf.constant( 0.83), ztf.constant( 1.), ztf.constant(0.973), ztf.constant(0.324), ztf.constant(0.372), ztf.constant(0.272)],\n",
" [ztf.constant(0.531), ztf.constant(0.927), ztf.constant(0.819), ztf.constant(0.766), ztf.constant(0.973), ztf.constant( 1.), ztf.constant(0.268), ztf.constant(0.332), ztf.constant(0.269)],\n",
" [ztf.constant(0.752), ztf.constant(0.227),ztf.constant(-0.023), ztf.constant(0.582), ztf.constant(0.324), ztf.constant(0.268), ztf.constant( 1.), ztf.constant( 0.59), ztf.constant(0.515)],\n",
" [ztf.constant(0.229), ztf.constant(0.443), ztf.constant( 0.07), ztf.constant(0.237), ztf.constant(0.372), ztf.constant(0.332), ztf.constant( 0.59), ztf.constant( 1.), ztf.constant(0.897)],\n",
" [ztf.constant(0.117), ztf.constant(0.287), ztf.constant(0.196), ztf.constant(0.192), ztf.constant(0.272), ztf.constant(0.269), ztf.constant(0.515), ztf.constant(0.897), ztf.constant( 1.)]]\n",
"\n",
"def triGauss(val1,val2,val3,m = Cov_matrix):\n",
"\n",
" mean1 = ztf.constant(0.466)\n",
" mean2 = ztf.constant(-0.885)\n",
" mean3 = ztf.constant(-0.213)\n",
" sigma1 = ztf.constant(0.014/3.)\n",
" sigma2 = ztf.constant(0.128/3.)\n",
" sigma3 = ztf.constant(0.548/3.)\n",
" x1 = (val1-mean1)/sigma1\n",
" x2 = (val2-mean2)/sigma2\n",
" x3 = (val3-mean3)/sigma3\n",
" rho12 = m[0][1]\n",
" rho13 = m[0][2]\n",
" rho23 = m[1][2]\n",
" w = x1*x1*(rho23*rho23-1) + x2*x2*(rho13*rho13-1)+x3*x3*(rho12*rho12-1)+2*(x1*x2*(rho12-rho13*rho23)+x1*x3*(rho13-rho12*rho23)+x2*x3*(rho23-rho12*rho13))\n",
" d = 2*(rho12*rho12+rho13*rho13+rho23*rho23-2*rho12*rho13*rho23-1)\n",
" \n",
" fcn = -w/d\n",
" chisq = -2*fcn\n",
" return chisq\n",
"\n",
"constraint4 = triGauss(bplus_0, bplus_1, bplus_2)\n",
"\n",
"# mean1 = ztf.constant(0.466)\n",
"# mean2 = ztf.constant(-0.885)\n",
"# mean3 = ztf.constant(-0.213)\n",
"# sigma1 = ztf.constant(0.014)\n",
"# sigma2 = ztf.constant(0.128)\n",
"# sigma3 = ztf.constant(0.548)\n",
"# constraint4_0 = tf.pow((bplus_0-mean1)/sigma1,2)/ztf.constant(2.)\n",
"# constraint4_1 = tf.pow((bplus_1-mean2)/sigma2,2)/ztf.constant(2.)\n",
"# constraint4_2 = tf.pow((bplus_2-mean3)/sigma3,2)/ztf.constant(2.)\n",
"\n",
"# 5. Constraint - Abs. of sum of light contribs\n",
"\n",
"sum_list_5 = []\n",
"\n",
"sum_list_5.append(rho_s*rho_w/rho_m)\n",
"sum_list_5.append(omega_s*omega_w/omega_m)\n",
"sum_list_5.append(phi_s*phi_w/phi_m)\n",
"\n",
"\n",
"sum_ru_5 = ztf.constant(0.0)\n",
"\n",
"for part in sum_list_5:\n",
" sum_ru_5 += part\n",
"\n",
"constraint5 = tf.cond(tf.greater_equal(tf.abs(sum_ru_5), ztf.constant(0.02)), lambda: 100000., lambda: 0.)\n",
"\n",
"# 6. Constraint on phases of Jpsi and Psi2s for cut out fit\n",
"\n",
"\n",
"# constraint6_0 = zfit.constraint.GaussianConstraint(params = jpsi_p, mu = ztf.constant(pdg[\"jpsi_phase_unc\"]),\n",
"# sigma = ztf.constant(jpsi_phase))\n",
"# constraint6_1 = zfit.constraint.GaussianConstraint(params = psi2s_p, mu = ztf.constant(pdg[\"psi2s_phase_unc\"]),\n",
"# sigma = ztf.constant(psi2s_phase))\n",
"\n",
"constraint6_0 = tf.pow((jpsi_p-ztf.constant(jpsi_phase))/ztf.constant(pdg[\"jpsi_phase_unc\"]),2)/ztf.constant(2.)\n",
"constraint6_1 = tf.pow((psi2s_p-ztf.constant(psi2s_phase))/ztf.constant(pdg[\"psi2s_phase_unc\"]),2)/ztf.constant(2.)\n",
"\n",
"# 7. Constraint on Ctt with higher limits\n",
"\n",
"constraint7 = tf.cond(tf.greater_equal(Ctt*Ctt, 0.25), lambda: 100000., lambda: 0.)\n",
"\n",
"constraint7dtype = tf.float64\n",
"\n",
"# zfit.run(constraint6_0)\n",
"\n",
"# ztf.convert_to_tensor(constraint6_0)\n",
"\n",
"#List of all constraints\n",
"\n",
"constraints = [constraint1, constraint2, constraint3_0, constraint3_1, constraint4, #constraint4_0, constraint4_1, constraint4_2,\n",
" constraint6_0, constraint6_1]#, constraint7]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Reset params"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"param_values_dic = {\n",
" 'jpsi_m': jpsi_mass,\n",
" 'jpsi_s': jpsi_scale,\n",
" 'jpsi_p': jpsi_phase,\n",
" 'jpsi_w': jpsi_width,\n",
" 'psi2s_m': psi2s_mass,\n",
" 'psi2s_s': psi2s_scale,\n",
" 'psi2s_p': psi2s_phase,\n",
" 'psi2s_w': psi2s_width,\n",
" 'p3770_m': p3770_mass,\n",
" 'p3770_s': p3770_scale,\n",
" 'p3770_p': p3770_phase,\n",
" 'p3770_w': p3770_width,\n",
" 'p4040_m': p4040_mass,\n",
" 'p4040_s': p4040_scale,\n",
" 'p4040_p': p4040_phase,\n",
" 'p4040_w': p4040_width,\n",
" 'p4160_m': p4160_mass,\n",
" 'p4160_s': p4160_scale,\n",
" 'p4160_p': p4160_phase,\n",
" 'p4160_w': p4160_width,\n",
" 'p4415_m': p4415_mass,\n",
" 'p4415_s': p4415_scale,\n",
" 'p4415_p': p4415_phase,\n",
" 'p4415_w': p4415_width,\n",
" 'rho_m': rho_mass,\n",
" 'rho_s': rho_scale,\n",
" 'rho_p': rho_phase,\n",
" 'rho_w': rho_width,\n",
" 'omega_m': omega_mass,\n",
" 'omega_s': omega_scale,\n",
" 'omega_p': omega_phase,\n",
" 'omega_w': omega_width,\n",
" 'phi_m': phi_mass,\n",
" 'phi_s': phi_scale,\n",
" 'phi_p': phi_phase,\n",
" 'phi_w': phi_width,\n",
" 'Dstar_m': Dstar_mass,\n",
" 'DDstar_s': 0.0,\n",
" 'DDstar_p': 0.0,\n",
" 'D_m': D_mass,\n",
" 'Dbar_m': Dbar_mass,\n",
" 'Dbar_s': 0.0,\n",
" 'Dbar_p': 0.0,\n",
" 'tau_m': pdg['tau_M'],\n",
" 'Ctt': 0.0,\n",
" 'b0_0': 0.292,\n",
" 'b0_1': 0.281,\n",
" 'b0_2': 0.150,\n",
" 'bplus_0': 0.466,\n",
" 'bplus_1': -0.885,\n",
" 'bplus_2': -0.213,\n",
" 'bT_0': 0.460,\n",
" 'bT_1': -1.089,\n",
" 'bT_2': -1.114}\n",
"\n",
"\n",
"def reset_param_values(variation = 0.05):\n",
" for param in total_f_fit.get_dependents():\n",
" if param.floating:\n",
" param.set_value(param_values_dic[param.name] + random.uniform(-1, 1) * param_values_dic[param.name]* variation)\n",
"# print(param.name)\n",
"# for param in totalf.get_dependents():\n",
"# param.set_value()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Pull dictionary"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [],
"source": [
"# BR_steps = np.linspace(0.0, 1e-3, 11)\n",
"pull_dic = {}\n",
"\n",
"mi = 1e-4\n",
"ma = 3e-3\n",
"ste = 20\n",
"\n",
"# mi = 0e-4\n",
"# ma = 4e-4\n",
"# ste = 4\n",
"\n",
"for param in total_f_fit.get_dependents():\n",
" if param.floating:\n",
" pull_dic[param.name] = []\n",
" for step in range(2*ste):\n",
" pull_dic[param.name].append([])\n",
" \n",
"\n",
"\n",
"def save_pulls(step):\n",
" for param in total_f_fit.get_dependents():\n",
" if param.floating:\n",
" pull_dic[param.name][step].append((params[param]['value'] - param_values_dic[param.name])/params[param]['minuit_hesse']['error'])\n",
"\n",
"\n",
"\n",
"# for key in pull_dic.keys():\n",
"# print(np.shape(pull_dic[key]))\n",
"# save_pulls(New_step=True)\n",
"# params[Ctt]['value']"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"36668\n",
"5404696\n"
]
}
],
"source": [
"# for param in total_f_fit.get_dependents():\n",
"# if param.floating:\n",
"# print(param.name)\n",
"\n",
"# print(params[Ctt])\n",
"\n",
"total_BR = 1.7e-10 + 4.9e-10 + 2.5e-9 + 6.02e-5 + 4.97e-6 + 1.38e-9 + 4.2e-10 + 2.6e-9 + 6.1e-10 + 4.37e-7\n",
"cut_BR = 1.0 - (6.02e-5 + 4.97e-6)/total_BR\n",
"\n",
"nevents = int(pdg[\"number_of_decays\"]*cut_BR)\n",
"\n",
"print(nevents)\n",
"print(int(pdg[\"number_of_decays\"]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# CLS Code"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 0.00025263 0.00040526 0.00055789 0.00071053 0.00086316\n",
" 0.00101579 0.00116842 0.00132105 0.00147368 0.00162632 0.00177895\n",
" 0.00193158 0.00208421 0.00223684 0.00238947 0.00254211 0.00269474\n",
" 0.00284737 0.003 ]\n",
"[ 0. 197.24636616 249.82376831 293.11721454 330.79221229\n",
" 364.59467078 395.51872296 424.19434987 451.05058775 476.39523398\n",
" 500.45799545 523.41569661 545.4079003 566.54705361 586.92533614\n",
" 606.61943297 625.69395291 644.20393429 662.19671941 679.71338184]\n",
"595.1433122960505\n"
]
}
],
"source": [
"BR_steps = np.linspace(mi, ma, ste)\n",
"\n",
"BR_steps[0] = 0.0\n",
"\n",
"print(BR_steps)\n",
"\n",
"Ctt_steps = np.sqrt(BR_steps/4.2*1000)\n",
"\n",
"Ctt_steps *= 128*2*np.pi\n",
"\n",
"print(Ctt_steps)\n",
"\n",
"print(0.74*128*2*np.pi)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 0.00025263 0.00040526 0.00055789 0.00071053 0.00086316\n",
" 0.00101579 0.00116842 0.00132105 0.00147368 0.00162632 0.00177895\n",
" 0.00193158 0.00208421 0.00223684 0.00238947 0.00254211 0.00269474\n",
" 0.00284737 0.003 ]\n",
"[0. 0.24525574 0.31063037 0.36446136 0.41130637 0.45333628\n",
" 0.49178719 0.5274424 0.5608354 0.59234888 0.62226847 0.65081403\n",
" 0.67815909 0.70444347 0.72978178 0.75426939 0.77798661 0.80100188\n",
" 0.82337407 0.84515425]\n",
"WARNING:tensorflow:From C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\zfit\\core\\sample.py:163: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
"Instructions for updating:\n",
"Use tf.cast instead.\n"
]
}
],
"source": [
"# zfit.run.numeric_checks = False \n",
"\n",
"load = True\n",
"\n",
"bo = True\n",
"\n",
"D_contribs = True\n",
"\n",
"if not D_contribs:\n",
" Dbar_s.floating = False\n",
" Dbar_p.floating = False\n",
" DDstar_s.floating = False\n",
" DDstar_p.floating = False\n",
"\n",
"bo_set = 1\n",
"\n",
"fitting_range = 'cut'\n",
"total_BR = 1.7e-10 + 4.9e-10 + 2.5e-9 + 6.02e-5 + 4.97e-6 + 1.38e-9 + 4.2e-10 + 2.6e-9 + 6.1e-10 + 4.37e-7\n",
"cut_BR = 1.0 - (6.02e-5 + 4.97e-6)/total_BR\n",
"\n",
"Ctt_list = []\n",
"Ctt_error_list = []\n",
"\n",
"nr_of_toys = 1\n",
"nevents = int(pdg[\"number_of_decays\"]*cut_BR)\n",
"# nevents = pdg[\"number_of_decays\"]\n",
"event_stack = 1000000\n",
"# nevents *= 41\n",
"# zfit.settings.set_verbosity(10)\n",
"\n",
"# mi = 0.0\n",
"\n",
"# ma = 4e-4\n",
"\n",
"# ste = 4\n",
"\n",
"# mi = 0\n",
"# ma = 3e-3\n",
"# ste = 7\n",
"\n",
"BR_steps = np.linspace(mi, ma, ste)\n",
"\n",
"BR_steps[0] = 0.0\n",
"\n",
"print(BR_steps)\n",
"\n",
"Ctt_steps = np.sqrt(BR_steps/4.2*1000)\n",
"\n",
"# Ctt_steps = [0.0, 0.1, 0.25, 0.5]\n",
"\n",
"print(Ctt_steps)\n",
"\n",
"# total_samp = []\n",
"\n",
"start = time.time()\n",
"\n",
"Nll_list = []\n",
"\n",
"sampler = total_f.create_sampler(n=nevents, fixed_params = False)\n",
"sampler.set_data_range(obs_fit)\n",
"\n",
"__ = -1\n",
"\n",
"pause = False\n",
"\n",
"#-----------------------------------------------------\n",
"\n",
"if not load:\n",
" for Ctt_step in Ctt_steps:\n",
"\n",
" if pause:\n",
" break\n",
" \n",
" __ += 1\n",
" \n",
" for i in range(2):\n",
" Ctt_list.append([])\n",
" Ctt_error_list.append([])\n",
" Nll_list.append([])\n",
"\n",
" for param in total_f_fit.get_dependents():\n",
" if param.floating:\n",
" pull_dic[param.name].append([])\n",
" \n",
" for toy in range(nr_of_toys): \n",
" \n",
" if pause:\n",
" break\n",
" \n",
" newset = True\n",
" \n",
" while newset:\n",
" \n",
" for floaty in [True, False]:\n",
" Ctt.floating = floaty\n",
" \n",
" if pause and not floaty:\n",
" break\n",
" \n",
" for bo_step in range(bo_set):\n",
"\n",
" print('Step: {0}/{1}'.format(int(__), ste))\n",
" print('Current Ctt: {0}'.format(Ctt_step))\n",
" print('Ctt floating: {0}'.format(floaty))\n",
" \n",
" reset_param_values(variation = 0.0)\n",
"\n",
" if floaty:\n",
" print('Toy {0}/{1} - Fit {2}/{3}'.format(toy, nr_of_toys, bo_step, bo_set))\n",
" Ctt.set_value(Ctt_step)\n",
"\n",
" else:\n",
" Ctt.set_value(0.0)\n",
" print('Toy {0}/{1} - Fit {2}/{3}'.format(toy, nr_of_toys, bo_step, bo_set))\n",
"\n",
" if newset:\n",
" sampler.resample(n=nevents)\n",
" data = sampler\n",
" newset = False\n",
"\n",
" ### Fit data\n",
" \n",
" if floaty:\n",
" plt.clf()\n",
" figure(dpi=250)\n",
" plt.title(r'$C_9^\\tau = $'+'{:.2f}'.format(int(Ctt_step*128*2*np.pi)))\n",
" plt.hist(zfit.run(data), bins = int((x_max-x_min)/7), range = (x_min, x_max))\n",
" plt.xlabel(r'$q^2 [MeV^2]$')\n",
" plt.ylabel('# Events')\n",
" plt.savefig('data/CLs/plots/set_histo{}.png'.format(__))\n",
" _step = 2*__\n",
" else:\n",
" _step = 2*__+1\n",
"\n",
" nll = zfit.loss.UnbinnedNLL(model=total_f_fit, data=data, constraints = constraints)\n",
"\n",
" minimizer = zfit.minimize.MinuitMinimizer(verbosity = 5)\n",
" # minimizer._use_tfgrad = False\n",
" result = minimizer.minimize(nll)\n",
"\n",
" print(\"Function minimum:\", result.fmin)\n",
" print(\"Hesse errors:\", result.hesse())\n",
"\n",
" params = result.params\n",
"\n",
" if result.converged:\n",
" \n",
" save_pulls(step = _step)\n",
" \n",
" pause = True\n",
"\n",
" if floaty:\n",
" Nll_list[-2].append(result.fmin)\n",
" Ctt_list[-2].append(params[Ctt]['value'])\n",
" Ctt_error_list[-2].append(params[Ctt]['minuit_hesse']['error'])\n",
"\n",
" else:\n",
" Nll_list[-1].append(result.fmin)\n",
" Ctt_list[-1].append(0.0)\n",
" Ctt_error_list[-1].append(0.0)\n",
" \n",
"\n",
" else:\n",
" for _ in [1,2]:\n",
" del Nll_list[-_][toy*bo_set:]\n",
"# print(np.shape(Nll_list[-_]))\n",
" del Ctt_list[-_][toy*bo_set:]\n",
" del Ctt_error_list[-_][toy*bo_set:]\n",
" for param in total_f_fit.get_dependents():\n",
" if param.floating:\n",
" del pull_dic[param.name][_step+1-_][toy*bo_set:]\n",
" newset = True\n",
" break\n",
" \n",
" if not result.converged:\n",
" break\n",
" \n",
" print()\n",
" print('Time taken: {}'.format(display_time(int(time.time()-start))))\n",
" print('Estimated time left: {}'.format(display_time(int((time.time()-start)/(__+(toy+1)/nr_of_toys)*(ste-__-(nr_of_toys-toy-1)/nr_of_toys)))))"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Number of jobs: 1000\n",
"(20, 1000)\n"
]
}
],
"source": [
"if load:\n",
" \n",
" phase_combi = '-+'\n",
" \n",
" scen = 'f1d1'\n",
" \n",
" if D_contribs:\n",
" D_dir = 'D-True'\n",
" else:\n",
" D_dir = 'D-False'\n",
"\n",
" _dir = 'data/CLs/finished/{}/{}/{}/'.format(scen, phase_combi, D_dir)\n",
" \n",
" jobs = os.listdir(_dir)\n",
" \n",
" First = True\n",
" \n",
" print('Number of jobs: {}'.format(len(jobs)))\n",
" \n",
" for job in jobs:\n",
" \n",
" dirName = _dir + str(job) + '/data/CLs'\n",
" \n",
" if not os.path.exists(\"{}/{}-{}_{}s{}b{}t--CLs_Nll_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys)):\n",
" print(\"{}/{}-{}_{}s{}b{}t--CLs_Nll_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys))\n",
" print(job)\n",
" continue\n",
" \n",
" with open(r\"{}/variab.pkl\".format(dirName), \"rb\") as input_file:\n",
" variab = pkl.load(input_file)\n",
"# print(variab)\n",
" \n",
" ### sanity check:\n",
" if variab['mi'] != mi or variab['ma'] != ma or variab['ste'] != ste or bo_set != bo_set:\n",
" print('Fitting parameters of data dont equal the ones given -- Job {} skipped!'.format(job))\n",
" continue\n",
" \n",
" with open(r\"{}/{}-{}_{}s{}b{}t--CLs_Nll_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"rb\") as input_file:\n",
" _Nll_list = pkl.load(input_file)\n",
" \n",
" with open(r\"{}/{}-{}_{}s{}b{}t--Ctt_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"rb\") as input_file:\n",
" _Ctt_list = pkl.load(input_file)\n",
" \n",
" with open(r\"{}/{}-{}_{}s{}b{}t--Ctt_error_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"rb\") as input_file:\n",
" _Ctt_error_list = pkl.load(input_file)\n",
" \n",
" with open(r\"{}/{}-{}_{}s{}b{}t--pull_dic.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"rb\") as input_file:\n",
" _pull_dic = pkl.load(input_file)\n",
" \n",
" with open(r\"{}/{}-{}_{}s--CLs_list.pkl\".format(dirName, mi,ma,ste), \"rb\") as input_file:\n",
" _CLs_list = pkl.load(input_file)\n",
" \n",
" if First:\n",
" Nll_list = _Nll_list\n",
" Ctt_list = _Ctt_list\n",
" Ctt_error_list = _Ctt_error_list\n",
" pull_dic = _pull_dic\n",
"# print(_pull_dic)\n",
" CLs_list = _CLs_list\n",
" First = False\n",
" else:\n",
" for step in range(2*ste):\n",
"# print(Nll_list[step], step)\n",
" Nll_list[step].extend(_Nll_list[step])\n",
" Ctt_list[step].extend(_Ctt_list[step])\n",
" Ctt_error_list[step].extend(_Ctt_error_list[step])\n",
" for key in pull_dic.keys():\n",
"# print(key, np.shape(pull_dic[key]))\n",
" pull_dic[key][step].extend(_pull_dic[key][step])\n",
" for step in range(ste):\n",
" CLs_list[step].extend(_CLs_list[step])\n",
" \n",
"# print(_CLs_list)\n",
"\n",
"# print('----------------------')\n",
"\n",
"print(np.shape(CLs_list))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"dirName = 'data/CLs'\n",
"\n",
"# if bo and not load:\n",
"# for s in range(2*ste):\n",
"# Nll_list[s] = [np.min(Nll_list[s])]\n",
"\n",
"\n",
"if not load:\n",
" \n",
" if not os.path.exists(dirName):\n",
" os.mkdir(dirName)\n",
" print(\"Directory \" , dirName , \" Created \")\n",
"\n",
" with open(\"{}/{}-{}_{}s{}b{}t--CLs_Nll_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"wb\") as f:\n",
" pkl.dump(Nll_list, f, pkl.HIGHEST_PROTOCOL)\n",
" \n",
" with open(\"{}/{}-{}_{}s{}b{}t--Ctt_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"wb\") as f:\n",
" pkl.dump(Ctt_list, f, pkl.HIGHEST_PROTOCOL)\n",
" \n",
" with open(\"{}/{}-{}_{}s{}b{}t--Ctt_error_list.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"wb\") as f:\n",
" pkl.dump(Ctt_error_list, f, pkl.HIGHEST_PROTOCOL)\n",
" \n",
" with open(\"{}/{}-{}_{}s{}b{}t--pull_dic.pkl\".format(dirName, mi,ma,ste,bo_set,nr_of_toys), \"wb\") as f:\n",
" pkl.dump(pull_dic, f, pkl.HIGHEST_PROTOCOL)\n",
" \n",
" variab = {'mi': mi,\n",
" 'ma': ma,\n",
" 'ste': ste,\n",
" 'bo_set': bo_set,\n",
" 'nr_of_toys': nr_of_toys}\n",
" \n",
" with open(\"{}/variab.pkl\".format(dirName), \"wb\") as f:\n",
" pkl.dump(variab, f, pkl.HIGHEST_PROTOCOL)\n",
" \n",
" CLs_values = []\n",
" \n",
" toy_size = bo_set\n",
"\n",
" print(np.shape(Nll_list))\n",
" print(Nll_list[0:1])\n",
" \n",
" for step in range(ste):\n",
" CLs_values.append([])\n",
" for toy in range(nr_of_toys):\n",
" float_min = np.min(Nll_list[2*step][toy*bo_set:(toy+1)*bo_set])\n",
" fix_min = np.min(Nll_list[2*step+1][toy*bo_set:(toy+1)*bo_set])\n",
" CLs_values[step].append(float_min-fix_min)\n",
" \n",
" \n",
" print(np.shape(CLs_values))\n",
" \n",
" with open(\"{}/{}-{}_{}s--CLs_list.pkl\".format(dirName, mi,ma,ste), \"wb\") as f:\n",
" pkl.dump(CLs_values, f, pkl.HIGHEST_PROTOCOL)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"Ctt_steps = np.array(Ctt_steps)\n",
"\n",
"Ctt_steps = Ctt_steps*128*2*np.pi"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Plot"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(20, 1000)\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 444x720 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"l = []\n",
"sensitivity = []\n",
"\n",
"if load:\n",
" CLs_values = -1*np.array(CLs_list)\n",
"\n",
"if not os.path.exists('data/CLs/plots'):\n",
" os.mkdir('data/CLs/plots')\n",
" print(\"Directory \" , 'data/CLs/plots' , \" Created \")\n",
"\n",
"print(np.shape(CLs_values))\n",
"\n",
"figure(figsize=(3.7, 6), dpi=120)\n",
"\n",
"for step in range(1,ste):\n",
" l.append(len(np.where(np.array(CLs_values[step]) < np.mean(CLs_values[0]))[0]))\n",
" sensitivity.append(l[-1]/len(np.where(np.array(CLs_values[0]) < np.mean(CLs_values[0]))[0]))\n",
" plt.clf()\n",
" plt.title('Sensitivity: {:.1f}%'.format(sensitivity[-1]*100))\n",
" plt.hist(CLs_values[0], bins = 40, range = (-5, 15), label = r'$C_9^\\tau$' + ' = 0', alpha = 0.8)\n",
" plt.hist(CLs_values[step], bins = 40, range = (-5, 15), label = r'$C_9^\\tau$' + ' = {}'.format(int(np.around(Ctt_steps[step]))), alpha = 0.7)\n",
"# plt.hist(CLs_values[0][np.where(np.array(CLs_values[0]) > np.mean(CLs_values[0]))[0]], bins = 40, range = (-5, 15), alpha = 0.9)\n",
"# plt.hist(CLs_values[step][np.where(np.array(CLs_values[step]) < np.mean(CLs_values[0]))[0]], bins = 40, range = (-5, 15), alpha = 0.9)\n",
" plt.axvline(x=np.mean(CLs_values[0]),color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.xlabel(r'$\\Delta NLL$')\n",
" plt.ylabel('# Toys')\n",
" plt.legend() \n",
" plt.tight_layout()\n",
" plt.savefig('data/CLs/plots/CLs-Ctt({}).png'.format(int(np.around(Ctt_steps[step]))))\n",
"\n",
"if scen == 'f3d41' or scen == 'f1d41':\n",
"\n",
"\n",
" plt.clf()\n",
" plt.title('Sensitivity: {:.1f}%'.format(sensitivity[-1]*100))\n",
" plt.hist(CLs_values[0], bins = 120, range = (-5, 55), label = r'$C_9^\\tau$' + ' = 0', alpha = 0.8)\n",
" plt.hist(CLs_values[step], bins = 120, range = (-5, 55), label = r'$C_9^\\tau$' + ' = {}'.format(int(np.around(Ctt_steps[-1]))), alpha = 0.7)\n",
" # plt.hist(CLs_values[0][np.where(np.array(CLs_values[0]) > np.mean(CLs_values[0]))[0]], bins = 40, range = (-5, 15), alpha = 0.9)\n",
" # plt.hist(CLs_values[step][np.where(np.array(CLs_values[step]) < np.mean(CLs_values[0]))[0]], bins = 40, range = (-5, 15), alpha = 0.9)\n",
" plt.axvline(x=np.mean(CLs_values[0]),color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.xlabel(r'$\\Delta NLL$')\n",
" plt.ylabel('# Toys')\n",
" plt.legend()\n",
" plt.tight_layout()\n",
" plt.savefig('data/CLs/plots/CLs-Ctt({}).png'.format(int(np.around(Ctt_steps[step]))))\n",
"\n",
"figure() \n",
" \n",
"for step in range(2*ste):\n",
" if step%2 == 0:\n",
" floaty = True\n",
" else:\n",
" floaty = False\n",
" for key in pull_dic.keys():\n",
" if not os.path.exists('data/CLs/plots/{}'.format(key)):\n",
" os.mkdir('data/CLs/plots/{}'.format(key))\n",
" plt.clf()\n",
" plt.title(('Pull {} - ' + r'$C_9^\\tau = $' + ' {} - floating {}').format(key, np.around(Ctt_steps[int(step/2)]), floaty))\n",
" plt.hist(pull_dic[key][step], bins = 50, range = (-5,5))\n",
" plt.xlabel('Pull')\n",
" plt.ylabel('# Toys')\n",
" plt.savefig('data/CLs/plots/{}/{}Ctt{}s{}f.png'.format(key, np.around(Ctt_steps[int(step/2)]), step, floaty))"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"scrolled": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"BR: 197.2464\n",
"0.7530487804878049\n",
"\n",
"BR: 249.8238\n",
"0.6280487804878049\n",
"\n",
"BR: 293.1172\n",
"0.510670731707317\n",
"\n",
"BR: 330.7922\n",
"0.4222560975609756\n",
"\n",
"BR: 364.5947\n",
"0.35365853658536583\n",
"\n",
"BR: 395.5187\n",
"0.2926829268292683\n",
"\n",
"BR: 424.1943\n",
"0.23932926829268292\n",
"\n",
"BR: 451.0506\n",
"0.20884146341463414\n",
"\n",
"BR: 476.3952\n",
"0.15701219512195122\n",
"\n",
"BR: 500.4580\n",
"0.1402439024390244\n",
"\n",
"BR: 523.4157\n",
"0.10365853658536585\n",
"\n",
"BR: 545.4079\n",
"0.09451219512195122\n",
"\n",
"BR: 566.5471\n",
"0.07164634146341463\n",
"\n",
"BR: 586.9253\n",
"0.04725609756097561\n",
"\n",
"BR: 606.6194\n",
"0.04420731707317073\n",
"\n",
"BR: 625.6940\n",
"0.04725609756097561\n",
"\n",
"BR: 644.2039\n",
"0.025914634146341462\n",
"\n",
"BR: 662.1967\n",
"0.022865853658536585\n",
"\n",
"BR: 679.7134\n",
"0.024390243902439025\n",
"\n",
"5% sensitivity: 584.632779356014\n",
"10% sensitivity: 532.212578083589\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"for s in range(len(l)):\n",
" print('BR: {:.4f}'.format(Ctt_steps[s+1]))\n",
" print(sensitivity[s])\n",
" print()\n",
"\n",
"Ctt_top = Ctt_steps[-7]\n",
"Ctt_low = Ctt_steps[-6]\n",
"sens_top = sensitivity[-7]\n",
"sens_low = sensitivity[-6]\n",
"# Ctt_top = Ctt_steps[-2]\n",
"# Ctt_low = Ctt_steps[-1]\n",
"# sens_top = sensitivity[-2]\n",
"# sens_low = sensitivity[-1]\n",
"\n",
"Ctt_ampli = Ctt_steps /4.2\n",
"# Ctt_10 = 532/4.2\n",
"# Ctt_5 = 585/4.2\n",
"\n",
"Ctt_5 = ( Ctt_low + (Ctt_top-Ctt_low)/(sens_top-sens_low)*(0.05-sens_low))\n",
"\n",
"Ctt_top = Ctt_steps[-9]\n",
"Ctt_low = Ctt_steps[-8]\n",
"sens_top = sensitivity[-9]\n",
"sens_low = sensitivity[-8]\n",
"# Ctt_top = Ctt_steps[-2]\n",
"# Ctt_low = Ctt_steps[-1]\n",
"# sens_top = sensitivity[-2]\n",
"# sens_low = sensitivity[-1]\n",
"Ctt_10 =( Ctt_low + (Ctt_top-Ctt_low)/(sens_top-sens_low)*(0.1-sens_low))\n",
"\n",
"\n",
"figure()\n",
"plt.clf()\n",
"# figure(dpi=120)\n",
"plt.title(r'$C_9^\\tau$' + ' sensitivity')\n",
"plt.plot(Ctt_ampli[1:], sensitivity)\n",
"plt.plot(Ctt_ampli[1:], sensitivity, '.')\n",
"plt.axhline(y = 0.05 ,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axhline(y = 0.1 ,color='green', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x = Ctt_5 ,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x = Ctt_10,color='green', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axhline(x = 0.1 ,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.text(80, 0.11, r'$10\\%$')\n",
"plt.text(80, 0.025, r'$5\\%$')\n",
"plt.xlabel(r'$C_9^\\tau$' + ' Amplification')\n",
"plt.ylabel('Sensitivity')\n",
"plt.tight_layout()\n",
"if scen == 'f1d1':\n",
" plt.savefig('sensitivity_current.png')\n",
"else:\n",
" plt.savefig('sensitivity_upgraded.png')\n",
"# plt.show()\n",
"\n",
"print('5% sensitivity: {}'.format(Ctt_5))\n",
"print('10% sensitivity: {}'.format(Ctt_10))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# a = (sensitivity[-8]-sensitivity[-9])/(Ctt_steps[-8]-Ctt_steps[-9])\n",
"# print(sensitivity[-9])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Ctt_steps[-9]+(0.1-sensitivity[-9])/a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Nice plots of pulls for D contribs"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"for step in range(2*ste):\n",
" if step%2 == 0:\n",
" floaty = True\n",
" else:\n",
" floaty = False\n",
" for key in pull_dic.keys():\n",
" if not key == 'Dbar_s':\n",
" continue\n",
" if not os.path.exists('data/CLs/plots/{}'.format(key)):\n",
" os.mkdir('data/CLs/plots/{}'.format(key))\n",
" plt.clf()\n",
" figure(dpi=120)\n",
" plt.title('Pull ' + r'$\\overline{D}$' + ' amplitude - ' + r'$C_9^\\tau = $' + ' {} - '.format(np.around(Ctt_steps[int(step/2)])) + r'$C_9^\\tau$' + ' floating')\n",
" plt.hist(pull_dic[key][step], bins = 50, range = (-5,5))\n",
" plt.xlabel('Pull')\n",
" plt.ylabel('# Toys')\n",
" plt.tight_layout()\n",
" plt.savefig('data/CLs/plots/{}/Dbar_s-{}Ctt{}s{}f.png'.format(key, int(np.around(Ctt_steps[int(step/2)])), step, floaty))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# for param in total_f_fit.get_dependents():\n",
"# if param.floating:\n",
"# print(params[param]['value'])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(display_time(int(time.time()-start)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Smearing"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"test_q = np.linspace(x_min, x_max, int(2e6))\n",
"\n",
"Ctt.set_value(0.72)\n",
"\n",
"probs = total_f_fit.pdf(test_q, norm_range=False)\n",
"\n",
"calcs_test = zfit.run(probs)\n",
"\n",
"plt.clf()\n",
"figure(dpi=250)\n",
"# plt.plot(x_part, calcs, '.')\n",
"plt.title('Fitted curve before smearing')\n",
"plt.plot(test_q, calcs_test)#, label = 'pdf (Ctt = 0.0)')\n",
"# plt.plot(test_q, calcs_test1, label = 'pdf (Ctt = 0.5)')\n",
"# plt.plot(test_q, calcs_test2, label = 'pdf (D-contribs = 0.3)')\n",
"# plt.plot(test_q, f0_y, label = '0')\n",
"# plt.plot(test_q, fT_y, label = 'T')\n",
"# plt.plot(test_q, fplus_y, label = '+')\n",
"# plt.plot(test_q, res_y, label = 'res')\n",
"plt.axvline(x=jpsi_mass -70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=jpsi_mass +70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=psi2s_mass -50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=psi2s_mass +50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.legend()\n",
"plt.ylim(0.0, 1.5e-6)\n",
"plt.xlabel(r'$q^2 [MeV^2]$')\n",
"plt.ylabel(r'$\\mathcal{B} (B^+ \\to K^+ \\mu^+ \\mu^- ) / dq^2$')\n",
"plt.tight_layout()\n",
"# plt.yscale('log')\n",
"# plt.xlim(770, 785)\n",
"plt.savefig('fitted_before_smearing.png')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"integrate = True\n",
"\n",
"if integrate:\n",
"\n",
" probs = total_f_fit.pdf(test_q, norm_range=False)\n",
"\n",
" calcs_test1 = zfit.run(probs)\n",
" \n",
" plt.clf()\n",
" plt.plot(test_q, calcs_test1)\n",
" plt.title('Fitted curve before smearing')\n",
" plt.axvline(x=jpsi_mass -70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.axvline(x=jpsi_mass +70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.axvline(x=psi2s_mass -50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.axvline(x=psi2s_mass +50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.ylim(0.0, 1.5e-6)\n",
" plt.xlabel(r'$q^2 [MeV^2]$')\n",
" plt.ylabel(r'$\\mathcal{B} (B^+ \\to K^+ \\mu^+ \\mu^- ) / dq^2$')\n",
" plt.tight_layout()\n",
" plt.savefig('test.png')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# if integrate:\n",
"\n",
"# plt.clf()\n",
"# plt.plot(test_q, calcs_test1)\n",
"# plt.title('Fitted curve before smearing')\n",
"# plt.axvline(x=jpsi_mass -70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axvline(x=jpsi_mass +70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axvline(x=psi2s_mass -50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axvline(x=psi2s_mass +50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.ylim(0.0, 1.5e-6)\n",
"# plt.xlabel(r'$q^2 [MeV^2]$')\n",
"# plt.savefig('test.png')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Integration"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# total_f_fit.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n",
"\n",
"if integrate:\n",
"\n",
" start = time.time()\n",
"\n",
" _max_size = 2000000\n",
"\n",
" step_size = 2000\n",
"\n",
" steps = np.arange(x_min, x_max, 0.1/step_size)\n",
"\n",
" l = len(steps)\n",
"\n",
" parts = int(l/_max_size)\n",
"\n",
" print(l)\n",
"\n",
" start_ = time.time()\n",
"\n",
" _list = []\n",
"\n",
" for j in range(parts):\n",
"\n",
" print(j, parts)\n",
"\n",
" _c = total_f_fit.pdf(steps[j*_max_size:(j+1)*_max_size], norm_range=False)\n",
"\n",
" inte_fl = zfit.run(_c)\n",
"\n",
" for i in range(int(_max_size/step_size)):\n",
" _list.append(np.mean(inte_fl[int(i*step_size):int((i+1)*step_size)]))\n",
"\n",
" _c = total_f_fit.pdf(steps[(parts)*_max_size:], norm_range=False)\n",
"\n",
" inte_fl = zfit.run(_c)\n",
" \n",
" rest = l%_max_size\n",
"\n",
" for i in range(int(rest/step_size)):\n",
" _list.append(np.mean(inte_fl[int(i*step_size):int((i+1)*step_size)]))\n",
"\n",
" print('Full integration finished in {}'.format(display_time(int(time.time()-start))))\n",
" print(len(_list))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"if integrate:\n",
"\n",
" dirName = 'data/CLs'\n",
" with open(\"{}/inte_100keV_steps.pkl\".format(dirName), \"wb\") as f:\n",
" pkl.dump(_list, f, pkl.HIGHEST_PROTOCOL)\n",
"\n",
"if integrate:\n",
" \n",
" center = np.arange(x_min+0.05, x_max, 0.1)\n",
"\n",
" probs = total_f_fit.pdf(test_q, norm_range=False)\n",
"\n",
" calcs_test1 = zfit.run(probs)\n",
" \n",
" plt.clf()\n",
" figure(dpi = 250)\n",
" plt.title('Integrated curve before smearing')\n",
" plt.axvline(x=jpsi_mass -70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.axvline(x=jpsi_mass +70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.axvline(x=psi2s_mass -50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.axvline(x=psi2s_mass +50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
" plt.ylim(0.0, 1.6e-6)\n",
" plt.plot(center,_list)\n",
" plt.xlabel(r'$q^2 [MeV^2]$')\n",
" plt.ylabel(r'$\\mathcal{B} (B^+ \\to K^+ \\mu^+ \\mu^- ) / dq^2$')\n",
" plt.tight_layout()\n",
" plt.savefig('integrated_before_smearing.png')\n",
"# plt.plot(inte_fl)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Smearing"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def gauss(x, area, m, sig = 7, step_s = 0.1):\n",
" \n",
" prefac = 1/(sig*np.sqrt(np.pi))\n",
" \n",
" y = np.zeros(np.shape(x))\n",
" \n",
" start = time.time()\n",
" \n",
" for i in range(len(area)):\n",
" \n",
" y += prefac*area[i]*np.exp(-1/2*((x-m[i])/sig)**2)\n",
" \n",
" t = time.time()\n",
" \n",
" j = i+1\n",
" \n",
" if i % 500 == 0:\n",
" print(display_time(int((t-start)/(j)*(len(area)-j))))\n",
" \n",
" return y*step_s\n",
" \n",
" \n",
" \n",
"\n",
"# _y += prefac*area*np.exp(-1/2*((x-_m)/sig)**2) \n",
"\n",
"# gauss(scan_x, _list)\n",
"\n",
"# print(np.shape(_list)[0], np.shape(center)[0])\n",
"\n",
"# print(int(1.25/0.1)*0.1)\n",
"\n",
"# print((1.25-1.25%0.1)/0.1)\n",
"\n",
"# print((x_max-x_min)*10)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"scan_x = np.linspace(x_min, x_max, 1e5)\n",
"\n",
"center = np.arange(x_min+0.05, x_max, 0.1)\n",
"\n",
"# for i in range(len(steps)/step_size):\n",
"# center.append(i)\n",
"\n",
"\n",
"sum_y = gauss(x =scan_x, m = center, area = _list)\n",
"\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# plt.clf()\n",
"# plt.title('Fitted curve after smearing')\n",
"# plt.axvline(x=jpsi_mass -70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axvline(x=jpsi_mass +70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axvline(x=psi2s_mass -50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axvline(x=psi2s_mass +50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.ylim(0.0, 2.5e-6)\n",
"# plt.plot(scan_x,sum_y)\n",
"# plt.xlabel(r'$q^2 [MeV^2]$')\n",
"# plt.savefig('curve_after_smearing.png')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"figure(dpi=250)\n",
"\n",
"plt.clf()\n",
"plt.title('Fitted curve after convolution')\n",
"plt.axvline(x=jpsi_mass -70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=jpsi_mass +70,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=psi2s_mass -50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x=psi2s_mass +50,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.ylim(0.0, 1.6e-6)\n",
"plt.plot(test_q, calcs_test, label = 'inf. precision')\n",
"plt.plot(scan_x,sum_y*0.7, label = 'smeared')\n",
"plt.legend()\n",
"plt.xlabel(r'$q^2 [MeV^2]$')\n",
"plt.ylabel(r'$\\mathcal{B} (B^+ \\to K^+ \\mu^+ \\mu^- ) / dq^2$')\n",
"plt.tight_layout()\n",
"# plt.xlim(jpsi_mass, psi2s_mass)\n",
"plt.savefig('curve_after_smearing-vs-before_smearing.png')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Create convonluted data"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"nbins = 50\n",
"\n",
"b_w = int(len(scan_x)/nbins)\n",
"\n",
"conv_data = []\n",
"\n",
"means = []\n",
"\n",
"_ = np.linspace(x_min, x_max, nbins+1)\n",
"\n",
"bin_centers = []\n",
"\n",
"_area = np.mean(sum_y)#*(x_max-x_min)\n",
"\n",
"# print(_area)\n",
"\n",
"_sum_y = sum_y/_area*pdg[\"number_of_decays\"]/100\n",
"\n",
"# print(np.mean(_sum_y))\n",
"\n",
"for i in range(nbins):\n",
" bin_centers.append((_[i]+_[i+1])/2.)\n",
" means.append(np.mean(_sum_y[i*b_w:(i+1)*b_w]))\n",
" _width = np.sqrt(means[-1])\n",
" conv_data.append(np.around(np.random.normal(means[-1], _width)))\n",
" \n",
"print(conv_data)\n",
"\n",
"figure(num=None, dpi=80, facecolor='w', edgecolor='k')\n",
"\n",
"plt.clf()\n",
"figure(dpi=250)\n",
"# plt.hist(x = bin_centers, bins = nbins, range = (x_min, x_max), weights = conv_data, histtype = 'step', label = 'Example data')\n",
"# plt.plot(bin_centers, conv_data, '.',, color = 'r')\n",
"plt.plot(scan_x,_sum_y, label = 'Convoluted fit', color = 'darkorange')\n",
"plt.errorbar(bin_centers, conv_data,yerr = np.sqrt(conv_data), elinewidth=1, fmt = '.', ecolor = 'forestgreen', color = 'forestgreen', label = 'Example data')\n",
"plt.ylim(0.,1200)\n",
"plt.xlabel(r'$q^2 [MeV^2]$')\n",
"plt.ylabel('# Events')\n",
"plt.legend()\n",
"plt.title('Convoluted fit with possible data set')\n",
"# plt.xlim(jpsi_mass, psi2s_mass)\n",
"# print(conv_data)\n",
"plt.tight_layout()\n",
"plt.savefig('smeared_fit_with_data.png')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# figure(num=None, dpi=80, facecolor='w', edgecolor='k')\n",
"\n",
"# plt.clf()\n",
"# # plt.hist(x = bin_centers, bins = nbins, range = (x_min, x_max), weights = conv_data, histtype = 'step', label = 'Example data')\n",
"# # plt.plot(bin_centers, conv_data, '.',, color = 'r')\n",
"# plt.plot(scan_x,_sum_y, label = 'Convoluted fit', color = 'darkorange')\n",
"# plt.errorbar(bin_centers, conv_data,yerr = np.sqrt(conv_data), elinewidth=1, fmt = '.', ecolor = 'forestgreen', color = 'forestgreen', label = 'Example data')\n",
"# plt.ylim(0.,1200)\n",
"# plt.legend()\n",
"# plt.title('Convoluted fit with possible data set')\n",
"# # plt.xlim(jpsi_mass, psi2s_mass)\n",
"# # print(conv_data)\n",
"# plt.savefig('smeared_fit_with_data.png')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
