{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Import"
]
},
{
"cell_type": "code",
"execution_count": 2,
"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": 3,
"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": 4,
"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": 5,
"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": 6,
"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": 7,
"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": 8,
"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": 9,
"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": 10,
"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": 11,
"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": 12,
"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": 13,
"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",
"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.3)\n",
"\n",
"DDstar_s.set_value(0.3)\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": 14,
"metadata": {},
"outputs": [
{
"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": [
"plt.clf()\n",
"# plt.plot(x_part, calcs, '.')\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.yscale('log')\n",
"# plt.xlim(770, 785)\n",
"plt.savefig('test.png')\n",
"# print(jpsi_width)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"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": 16,
"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": 17,
"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": 18,
"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": 19,
"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": 20,
"metadata": {},
"outputs": [],
"source": [
"# total_f._sample_and_weights = UniformSampleAndWeights"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Constraints"
]
},
{
"cell_type": "code",
"execution_count": 21,
"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": 22,
"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": 23,
"metadata": {},
"outputs": [],
"source": [
"# BR_steps = np.linspace(0.0, 1e-3, 11)\n",
"pull_dic = {}\n",
"\n",
"# mi = 2e-4\n",
"# ma = 6e-4\n",
"# ste = 5\n",
"\n",
"mi = 1e-4\n",
"ma = 3e-3\n",
"ste = 20\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": 24,
"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": 25,
"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": 26,
"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 = 1e-4\n",
"# ma = 3e-3\n",
"# ste = 13\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.74\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",
" plt.title('Ctt value: {:.2f}'.format(Ctt_step))\n",
" plt.hist(zfit.run(data), bins = int((x_max-x_min)/7), range = (x_min, x_max))\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": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Number of jobs: 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(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",
" \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('----------------------')"
]
},
{
"cell_type": "code",
"execution_count": 28,
"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": 29,
"metadata": {},
"outputs": [],
"source": [
"Ctt_steps *= 128*2*np.pi"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Plot"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(20, 1000)\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 216x400 with 1 Axes>"
]
},
"metadata": {},
"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(num=None, figsize=(2.7, 5), dpi=80, facecolor='w', edgecolor='k')\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.legend()\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.savefig('data/CLs/plots/{}/{}Ctt{}s{}f.png'.format(key, np.around(Ctt_steps[int(step/2)]), step, floaty))"
]
},
{
"cell_type": "code",
"execution_count": 75,
"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"
]
},
{
"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 480x320 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",
"# print(l[s], len(CLs_values[s]))\n",
"# print()\n",
"# print(len(CLs_values[0])/2)\n",
"# print(len(np.where(np.array(CLs_values[0]) < np.mean(CLs_values[0]))[0]))\n",
"plt.clf()\n",
"figure(dpi=80)\n",
"plt.title(r'$C_9^\\tau$' + ' sensitivity')\n",
"plt.plot(Ctt_steps[1:], sensitivity)\n",
"plt.plot(Ctt_steps[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 = 584.63 ,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.axvline(x = 532.2 ,color='green', linewidth=1.0, linestyle = 'dotted')\n",
"# plt.axhline(x = 0.1 ,color='red', linewidth=1.0, linestyle = 'dotted')\n",
"plt.text(200, 0.11, r'$10\\%$')\n",
"plt.text(200, 0.01, r'$5\\%$')\n",
"plt.xlabel(r'$C_9^\\tau$')\n",
"plt.ylabel('Sensitivity')\n",
"if scen == 'f1d1':\n",
" plt.savefig('sensitivity_current.png')\n",
"else:\n",
" \n",
" plt.savefig('sensitivity_upgraded.png')\n",
"# plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.10365853658536585\n"
]
}
],
"source": [
"# a = (sensitivity[-8]-sensitivity[-9])/(Ctt_steps[-8]-Ctt_steps[-9])\n",
"# print(sensitivity[-9])"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"532.212578083589"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"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": 78,
"metadata": {},
"outputs": [
{
"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 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 == 'DDstar_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",
" plt.title('Pull ' + r'$DD^*$' + ' 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.savefig('data/CLs/plots/{}/DDstar-{}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": 69,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"56 s\n"
]
}
],
"source": [
"print(display_time(int(time.time()-start)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Smearing"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"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": [
"test_q = np.linspace(x_min, x_max, int(2e6))\n",
"\n",
"probs = total_f_fit.pdf(test_q, norm_range=False)\n",
"\n",
"calcs_test = zfit.run(probs)\n",
"\n",
"plt.clf()\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.yscale('log')\n",
"# plt.xlim(770, 785)\n",
"plt.savefig('fitted_before_smearing.png')"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAaUAAAEcCAYAAABnF6sTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOydeXxU5dXHv2dmspAQSAibrGEJKLihiBviWsUWRVut6NtWrS22VduqtdX2raKVtrZVal3aUve+IqK1FS3FpUApisimLCIQ9hCWQBLIQraZ5/3j3gmTySx3QmZJcr6fTz7O3Hvuec4dw/xyznPu84gxBkVRFEVJBVzJDkBRFEVR/KgoKYqiKCmDipKiKIqSMqgoKYqiKCmDipKiKIqSMqgoKYqiKCmDipKSEERkkIhUiYg7jmO8ICIPx8t/PBCR7SJySSuvHSkiq0WkUkS+39axtQcS8XulJBYVJaVNsb9kj9hfFP6ffsaYncaYrsYYr223SES+FXStEZHhyYm8XfJjYJExJscY84dkB5MMgn+vlPaPipISD66wvyj8PyXJDqitEBFPsmMIYDCwvjUXpth9tIqOcA9KS1SUlIQgIgV2JuQRkenAecCTdib1pIgstk0/tY9dZ183SUQ+EZEKEflQRE4O8DlGRFbZ5atXgcwoMXxbRDbY9p+JyGn28WYZWmAZUEQuEJFiEfmJiOwFnrd9TAqw94jIgQB/Z9mxVojIpyJyQZSP5ww7nnIReV5Emu4j3P2LyALgwoDPcISIdBeRl0SkVER2iMj/iojLtr9JRD4QkRkiUgZMs49/076fchF5R0QGh/nsMkXk/0TkoB3LchHpY59bJCIP2/FVichbIpIvIi+LyGHbtiDA1/Ei8p6IlInIRhH5asC5L9klycMisktEpgWc8/8O3SIiO4EFgb9XAbH8wr7XShF5V0R6Bvj4hv3ZHBSRn8sxlE+VOGGM0R/9abMfYDtwSYjjBYABPPb7RcC3gmwMMDzg/WnAfuBMwA3caPvPANKBHcCdQBpwDdAAPBwmrmuB3cAZgADDgcFhxn3B7we4AGgEHrHH7QLcD7wcYP8l4HP7dX/gIPBFrD/6vmC/7xXh81oHDAR6AB8EjB32/kN9hsBLwJtAjv15bwJusc/dZN/HHYDHvo+rgCLgBPvY/wIfhonzVuAtIMuO5XSgW0AcRcAwoDvwmT32Jbbfl4DnbdtsYBdws33uNOAAMDrg8z7J/uxOBvYBVwX9Dr1k++lC6N+rLcAI+/wi4Nf2uVFAFTAe6/fnd1i/My1+X/UneT+aKSnx4B/2X9MVIvKPY/DzbeDPxphlxhivMeZFoA44y/5JA35vjGkwxrwOLI/g61vAb4wxy41FkTFmh8M4fMADxpg6Y8wRYBZwpYhk2edvsI8BfA2YZ4yZZ4zxGWPeA1ZgiVQ4njTG7DLGlAHTgesd3H8zxJrovw64zxhTaYzZDjwKfD3ArMQY84QxptG+j1uBXxljNhhjGoFfAqeGyZYagHws8fYaY1YaYw4HnH/eGLPFGHMI+BewxRjzvu33NWCMbTcJ2G6Med6OYxXwN6w/KjDGLDLGrLU/uzXAK8D5QbFMM8ZU2/cQiueNMZvs83OAU+3j1wBvGWOWGGPqsf640MU/UwwVJSUeXGWMybV/rjoGP4OBuwMErgIro+hn/+w2xgR+qUQSmYFYf0G3hlJjTK3/jTGmCNgAXGEL05UcFaXBwLVBMY8Hjovgf1fA6x1Y9+b3Fe7+g+nJ0ewx0Ff/MOP4/T8e4LsMK4vsT0v+CrwDzBaREhH5jYikBZzfF/D6SIj3XQPGPDPonv4H6AsgImeKyEK7BHkI+I59b4EE30cwewNe1wSM3S/wWmNMDVYWq6QQOlGoJAsnf6HuAqYbY6YHnxCR84H+IiIBwjSI8MKzC6u8FIoarLKUn75AcZRYX8HKaFzAZ7ZQ+cf5qzHm22HGCsXAgNeDAH9jSNj7D8EBrGxmMFb5zO9rd4BN8H34/b8czbkxpgF4EHjQnh+aB2wEnnUQW/CY/zHGfCHM+VnAk8DlxphaEfk9LUWptdnNHmCk/42IdMHK/pQUQjMlJVnsA4ZGOfYX4Dv2X88iItn2RHgOsBRrjuT7dqPBl4FxEcZ7BviRiJxu+xoeUKb6BLhBRNwiMpGW5aJQzAYuBb7L0SwJ4P+wMqjLbH+ZYjVLDIjg6zYRGSAiPYCfAq86uP9mGKsleg4wXURy7Hu7y44nHH8C7hOR0QBiNUpcG8pQRC4UkZPsMuFhLAFsTRv228AIEfm6iKTZP2eIyAn2+RygzBakcVil0bbidaz/N+eISDqWyEob+lfaABUlJVk8DlwjVteX/xmbacCLdlnnq8aYFVjzKk8C5ViT6TcB2HMCX7bfl2PNp7wRbjBjzGtY8zWzgErgH1iNBQA/AK4A/KWkqPNgxpg9WMJ4DkdFBGPMLmAylriUYmUG9xD539os4F1gq/3zsO0r7P2H4Q6g2vaxxPb7XIR7+DtWA8dsETmM1XBxeRjzvlhf6oexSpf/IbLghRuzEkvMp2BlhHs52kQC8D3gIRGpxJrzmRPrGBHGXo/1Gc3GypoqsRpJ6tpqDOXYkeYleUVRlM6BiHTF+kOk0BizLdnxKBaaKSmK0mkQkStEJEtEsrFawtditdkrKYKKkqIonYnJWGXDEqAQmGK0XJRSaPlOURRFSRk0U1IURVFSBhUlRVEUJWXQh2eD6NmzpykoKEh2GIqS0hxp8FK0v4rBPbLo1iWt2TmfgfUlh+jbLZNeORlhPMQfY2BdySH6dMuktx3H2t2H6J2TQZ9uEdfuVVrBypUrDxhjeh2rHxWlIAoKClixYkWyw1CUlGbDf1Zw+b/28ccbx3LxCX2anatr9DLyf+dzz2Ujua2/D0aMSEqMdes3MPKvW/nxxJF87wJrEfjhP53H1AlD+fFQV9Li6qiIiNO1JCOi5TtFUWJmyM1TAHC5Wi6I4BbrmNdnYNKkFucTRdpVkwFwydEYXS7BZ0hqXEpkVJQURYmZdQs+Bo4KUCBuV4AobdqU0LgCObLOWgIwMEKXgM8kNy4lMipKiqLETN8ZvwaOClAgInL0y3/atARHdpS0Xzxkx3P0mFvEEsskxqVERkVJUZSY8T/e6AqRKYElVo2+5D4DaezFxFuW7/TZzFRGRUlRlJjZccePgdCZElhC4EtyRlL7s/tbHEuFuJTIqCgpihIzp116JgDuMN8gHpddJktih1vXk0cBVjnRj9sleE1y41Iio6KkKErMrPmjtWtFuPKdy//l//bbiQyrGdWv/92KJSBEl9jdd0mMS4mMipKiKDHjqqq0/hthTsnrM1BZmciwmmEqq4AQ3XdJjkuJjIqSoigxc/wDPwLCzyk1dblNnZrIsJqRfcf3gBDluyTHpUTGkSiJyEQR2SgiRSJyb4jzGSLyqn1+mYgUBJy7zz6+UUQui+ZTRIbYPjbbPtMjjSEi+SKyUESqROTJMPHPFZF1zj4SRVGi8eGr7wCRMyWfMbByZSLDakbFf5cCYcp3SYxLiUxUURIRN/AU1jbJo4DrRWRUkNktQLkxZjgwA2t7Y2y7KcBoYCLwtIi4o/h8BJhhjCnE2gL6lkhjALXAz4EfhYn/y0BVtPtUFMU5I37zIBAhU/JnJHffnciwmpF1n9UhSLOWcPv5qSTGpUTGSaY0Digyxmw1xtRj7W8/OchmMvCi/fp14GKxcubJwGxjTJ293XCR7S+kT/uai2wf2D6vijSGMabaGLMES5yaYW93fBfwsIP7VBTFIUd69QbCd9+5RPD6gH79EhdUEN6+xwHN55SayopJjEuJjBNR6g/sCnhfbB8LaWOMaQQOAfkRrg13PB+osH0EjxVujEj8AngUqIlkJCJTRWSFiKwoLS2N4lJRlM1fuxUIX77zuAWvz5fUjKTmjh8CYR6e1UwpZXEiSqF+64IfiQ5n01bHncZxNCCRU4Hhxpi/h7NpcmLMTGPMWGPM2F69jnnldUXp8Fx26WlAlEYHQ1Izkp4jhwDNlxmy5pQ0U0plnIhSMTAw4P0ArP3tQ9qIiAfoDpRFuDbc8QNAru0jeKxwY4TjbOB0EdkOLAFGiMiiiHeqKIoj3n/Jes4n0nNKPp+BJG4DU7pgCRCmfKfb06QsTkRpOVBod8WlYzUuzA2ymQvcaL++BlhgjDH28Sl259wQoBD4OJxP+5qFtg9sn29GGSMkxpg/GmP6GWMKgPHAJmPMBQ7uV1GUKGTv2AqE3roCAr78k7gat3tLERBm6wpdJTxliSpK9vzN7cA7wAZgjjFmvYg8JCJX2mbPAvkiUoTVWHCvfe16YA7wGTAfuM0Y4w3n0/b1E+Au21e+7TvsGAB2NvQYcJOIFIfoDlQUpQ0ZPfP3QOitKyBgQdYkrjGX8+vp1otm5Tt07bsUx9HOs8aYecC8oGP3B7yuBa4Nc+10YLoTn/bxrVjdecHHI41RECX+7cCJkWwURXHOu0/Phn+swxXmz9qm55QWLUpoXIGUzp0Pv1nYvHznX/4oiXEpkdEVHRRFiZkzf2UVKqJmSklcOSHvh7cDQeU7/8OzuqJDyqKipChKzJSOPAkI332X5hYavT4YOzaRYTWj9tQxQHD3nV2+S2JcSmRUlBRFiZnPJk0BwBPm6VmPy0WjN7mZUuU3vgk0FyWPy0Wjz6eZUgqjoqQoSszcOPFkwNo3KRQet9Dg80FOTiLDasbggr5A8/Jd0/JHSYxLiYyKkqIoMfPcq/8FIpXv7EypJPiRxsSxbU3Ltm+P257rSmJcSmRUlBRFiZnjVi8DImRKLqHB60tql1uXDyzhDNy6omlH3EWLaPD6WLyplAiPOypJQEVJUZSYOXHeq7hd0uwLP5A0t8vKSGbOTHBkR+n21+eB5ltXuF0uGrxWXM8t2cY3nvuYJUUHkhShEgoVJUVRYua1B/4YtnQHdpnM64O33kpgVM3Z/dIcACTgSaU0/0Kxb73F2t2HADhYVZ+U+JTQqCgpihIzk359d9jSHVhdbg1eAzfckMComtP3e1b3XfNMSay5rhtuIMPjBqC+0ZeM8JQwqCgpihIzG8eeH1GU0txitV5PmpTAqJpTefFEILgl3G50mDSpKX6vzimlFCpKiqLEzCfnfTHsM0rgL98lN1M6dLV/XeeARge3y2p0uOGGpsVkG30qSqmEipKiKDHzi6tPijyn5HJR7/U1T1MSzOj+uUDz8l1TV6BIU6ak5bvUQkVJUZSYuWfOJ6RFK995DSSxNLZ2VwUQ1BLutlvCjWkS1bpGb1LiU0KjoqQoSsycsngebnek7jt7OZ9ZsxIYVXO6/93ffXcUa5khA7NmNa30UNegmVIqoaKkKErMHL9qMZ5w+1YAaS6hwWswb7+dwKiak/PvdwCaba9hdd/54O23rdZwoE7LdymFipKiKDHz3PcejvKckvXV4v3r/yUqpBZs/8NfgObPKTUtMzRrVlODQ22Dlu9SCRUlRVFi5tbf/TDyc0p2aU+uvDKsTbwZ+s3rrRehWsKvuMKa8wKrIUNJGVSUFEWJmf+cf3WT8IQiza6Z1X3zlkSF1ILS628EglcJt1rCzbe/ba1ijs4ppRoqSoqixMy6wjG4I8wp+QWr7twJiQqpBYfPPAdo3ujg7xj0Tjjf6sJDu+9SDRUlRVFi5vG7J0VsCffPKXUvLEhQRC055azRQFCmZIule+CAo+U7bXRIKRyJkohMFJGNIlIkIveGOJ8hIq/a55eJSEHAufvs4xtF5LJoPkVkiO1js+0zPdIYIpIvIgtFpEpEngzwkyUi/xSRz0VkvYj8OvaPR1GUUNz0+PsRGx38grV31/5EhdSC5Wt2AM277/xlxeoD5dZDtGj3XaoRVZRExA08BVwOjAKuF5FRQWa3AOXGmOHADOAR+9pRwBRgNDAReFpE3FF8PgLMMMYUAuW277BjALXAz4EfhQj/d8aY44ExwLkicnm0+1UUJToXLv5HxDklf6aU8dyziQqpBb1mvQi03HkWwPWXmVq+S1GcZErjgCJjzFZjTD0wG5gcZDMZeNF+/TpwsViPUU8GZhtj6owx24Ai219In/Y1F9k+sH1eFWkMY0y1MWYJljg1YYypMcYstF/XA6uAAQ7uV1GUKAzZviHyc0q2YKV9sjJRIbUge+0nQPPdcf1C6lq5kgaflu9SESei1B/YFfC+2D4W0sYY0wgcAvIjXBvueD5QYfsIHivcGFERkVzgCuDfYc5PFZEVIrKitLTUiUtF6dQ8MeWeqFtXAOz5zR8SFVILNv7iUSB47TsrrkOPP2U9RIuW71INJ6IU6jcveEGrcDZtddxpHC0QEQ/wCvAHY8zWUDbGmJnGmLHGmLG9evWK5lJROj2/fPz7UTf5AxhwdfIq5id/zSqyBG+HDpD7xUubGh1UlFILJ6JUDAwMeD8AKAlnY4tAd6AswrXhjh8Acm0fwWOFGyMaM4HNxpjfO7BVFMUBL156Y+TnlOxze+5s0ReVMLbdfjcAbmlZviu/5z5rbT60fJdqOBGl5UCh3RWXjtW4MDfIZi5wo/36GmCBMcbYx6fYnXNDgELg43A+7WsW2j6wfb4ZZYywiMjDWOL1Qwf3qSiKQ3bkD4g4p+Q/Vz14SKJCakHVoGFA6EaH2qHDm5YZ0kaH1CKqKNnzN7cD7wAbgDnGmPUi8pCI+NcQeRbIF5Ei4C7gXvva9cAc4DNgPnCbMcYbzqft6yfAXbavfNt32DEARGQ78Bhwk4gUi8goERkA/Ayru2+ViHwiIt+K/SNSFCWYPz3+HUfLDJ1w5cWJCqkF475qPYESqJ1+sRzwhQnWdu1o+S7V8EQ3AWPMPGBe0LH7A17XAteGuXY6MN2JT/v4VqzuvODjkcYoCBN68nYYU5QOzBX3vcr4iPspWV/+y5as5bxEBRXEwn+vhpdXNcuU/GK5cdXneF+1uvO0fJda6IoOiqLEzHWL50TeDt0WrOOeeTpRIbVg8At/AoJawu3XeX98QhsdUhQVJUVRYib/8MGI5Tt/puTZtydRIbUgo3Qv0Lwl3C9Q7r17mhZk9fpMU3u4knxUlBRFiZnffOHbEVvCMzzWV8vaO+8PaxNv1t1ljR3YEu4Xyx0//UVTpgSaLaUSKkqKosTM7D/fTron/NdHhscNwPgpExMVUgsmXG89I+UO0X036ooLm7rvQOeVUgkVJUVRYuanE29vehYpFH7B+ujeXyUqpBas/Jm1BrOrWaZkNzo89CiNXl/Te82UUgcVJUVRYsLnMxxO69JUCguFv3xXk56ZqLBaUN8lG2jeEp7utjK42swsGr2GrHSrAVmfVUodVJQURYmJeq+PZ19/MGL5zn/u4h8n79HA8XfeDDTPlPxxnfLdr9PoM2SnWyKl5bvUQUVJUZSYaPD6uGjqTNIdZEovvfBuosJqwduvLQJCi9J7//gPXp8hO8OfKakopQoqSoqixESD1/DDJS9HLN953C5cAmOffzyBkTXnxL88BgSV72xRKnz6URp8PrLsTEnLd6mDipKiKDHhL3VFEiWwOvACO9wSjX9lzMBMyZ/BNXp9GEPAnJJmSqmCipKiKDHR4PXx+/H/E3FOCays5N/XfTdBUbVk9Td/ADRvCffH/OE37gDQ8l0KoqKkKEpM1Ht9LJg5NWJLOFhZye3f/VKComrJ1VMuAoLmlOzsbsrXLgE4Wr5riL8olVXX88IH23T1iCioKCmKEhP1jT5uueaBiI0OYGUlz9yTvJ1n33nkGSC4Jdx6M+t/rTX5sjPs7rsECMUfFxUx7a3PWLxZd7eOhIqSoigx0eD1kV1/JGr5LsPjQqqrEhRVSzz22IGZksslpLtdmMOHAcj2zyk1xL/RYU3xIQA27KmM+1jtGRUlRVFiosHr41fzn4ja6JDucXP9Mw8nKKqWnPfbnwHNRQmsDO6qPz4IBJTvEjCndMQWvt0VR+I+VntGRUlRlJiobzRccdPjDrrvXPzvz19ITFAhmPPnfwDNy3dgidKD014CIMtudEjEw7OVtY0A7D9cF/ex2jMqSkpYdlcc4Zn/bk12GEqKUe/18bMFzzjqvrtu9u8TFFVLznn6l0CITMnt4uqXZwCJ7b6rrG0AoLRKRSkSjnaeVTont7ywnM/3VvLFk46jX26XZIejpAgNjT72de0RtdEhw+OiNCc/QVG1pLJHb6B5SzhYYrmvaw8AstIS9/DsYTtTKj1cG/ex2jOaKSlh8ZcbfCZ5D0AqqUeD18cz475Mmid6S/hr51+XoKhasuKabwIQpElkeFy8Mv5aANI8LtLcEvdMqa7R21QiLK9piOtY7R0VJUVRYqLe62PZU99wkCm5een+qxMUVUumThmPSPNN/sDKlF6Z9hUA0uxuvHjPKfn/wOudk8GRBi+1Cej2a684EiURmSgiG0WkSETuDXE+Q0Retc8vE5GCgHP32cc3ishl0XyKyBDbx2bbZ3qkMUQkX0QWikiViDwZFNfpIrLWvuYPEvzbqShKzNQ3+rjiGzMcdN+5+NYdTycoqpa89MTrLUp3YMV1w63WV4XbJWSkueNevjt8xMqOBvbIavZeaUlUURIRN/AUcDkwCrheREYFmd0ClBtjhgMzgEfsa0cBU4DRwETgaRFxR/H5CDDDGFMIlNu+w44B1AI/B34UIvw/AlOBQvsnedtgKkoHocFrGFq+29FzSn337EpQVC3J3bW9RZMDWI0OffbuAMDjFjI9LmrjvKKDP1MamGfNzVaoKIXFSaY0Digyxmw1xtQDs4HJQTaTgRft168DF9tZyWRgtjGmzhizDSiy/YX0aV9zke0D2+dVkcYwxlQbY5ZgiVMTInIc0M0Ys9QYY4CXAnwpMaBTSkogDV4fP1wyy1Gjwy3/filBUbXk3JefbNEODlamdNt//g8Aj8tFVoaH6rrGuMbSJEp2plSh80phcSJK/YHAP3eK7WMhbYwxjcAhID/CteGO5wMVto/gscKNESnu4ihxAyAiU0VkhYisKC3VJUAUJRINXh9Tbvg1aVEypcx0N//ztV8nKKqW/PWXL4TMlDI8bqbcYMXlcQldMzxUxV2ULBEa4M+UaurjOl57xokohZqHCf7bOZxNWx13GoeTmFoeNGamMWasMWZsr169IrjsnOhMnBJIXaOPX85/IuqCrFlpHqa9/TjeJG1fcfkTD4QUpewMN7+c/wRgzSl1TWSmlGdnSlq+C4sTUSoGBga8HwCUhLMREQ/QHSiLcG244weAXNtH8FjhxogU94AocSsO0PKdEkh9o4+1fQtJC1UbCyAr3c3avoXU1Mf3Cz8cu4eNwu1qKUpZ6R7W9i0ErM0IszPcVNfFudGhVhsdnOJElJYDhXZXXDpW48LcIJu5wI3262uABfY8zlxgit05NwSr2eDjcD7taxbaPrB9vhlljJAYY/YAlSJylj1X9Y0AX4qitJLaRi9/G/tFXCG+8APpku7mlVMncqQ+Oe3Py75wTchsLtuOCyAzzUV2Qsp3lv/jumfidonOKUUgqijZ8ze3A+8AG4A5xpj1IvKQiFxpmz0L5ItIEXAXcK997XpgDvAZMB+4zRjjDefT9vUT4C7bV77tO+wYACKyHXgMuElEigM6+b4LPIPVYLEF+FcsH45ioeU7JZC6Bh+rf/uVqHZZ6W7WzbiWmiSJ0v03nBUyU8rO8LBuhvXwbIbHTU6CRCk73Y3H7aJ7lzQqjuicUjgcLTNkjJkHzAs6dn/A61rg2jDXTgemO/FpH9+K1Z0XfDzSGAVhjq8ATgx1TnGOlu+UQGobvHzpJ7NZFMUuK93Nmd97kdeSJEoP/fk9PCUtl/TJzrDiAqtDMNueUzLGtHjQtq2orG0gJzMNgNwuaZopRUBXdFAUJSZqG7yctXNtVLsu6R7O2rWWIw3JmVMasm552Dmls3ZZ8ftFqdFn4rrUUGVtIzmZVg7QPUtFKRIqSkpUtHynBFLb4OOq5f+MapeV7ub6T+YnrXx35vt/wxOyfGfFBXb5zhaLeJbwKusamsbJy0qnXFvCw6KipERFy3dKILWNXn753d9EteuS5uZb1zyQNFF6+q4ZYTOlb13zAAAZaa6m3Wfj2RZuZUpW+S4vK10zpQioKCmKEhO1DV5+/OJDUe2y0t08Pve3Seu+u+mpn+EJsepE1wwPj8/9LWAtOeTfU8nfIRcPAst3eVlplFVrphQOFSUlKlq+UwKpbfCxZsz4qHZZ6R7+PfyMpGVKn5x8bpjynRUXgMsldO9iZTD+Z4niQWCjQ152uq4UHgEVJSUqWr5TAqlt8LJ6/Bej2nVJdzN31AVJe3j2gzMvC1m+69Mtg7mjLmh6n5dtiUV5dfxE6XBtI90C5pQAnVcKg4qSoigxUdfo4y83nhHVLivdzfZHJiWtfPfSLWeGzJR652Sy/ZFJTe972CJRFieR8G/wF1i+g/iKYHtGRUmJipbvlEBqG7zcM+eTqHZpbheFP/0nNUkqU133pw9DZkpulzDlzx9y87kFAOTaolQRp3ke/1xVYPkONFMKh4qSEhUt3ymB1DZ4Gbd0viPbr3y+OGmZ0lnL3sETZtHYWVlbuX+StfBLusdFToYnbpnSUVHS8p0TVJQURYmJ2gYfJ6xa7Mj2oqKP49rVFonT1nyAJ8yisa55/2y2ekNudhrlccqU/IuvdmvKlPzlOxWlUKgoKVHR8p3ixxhDbaOX+fc95sj+0ZumNe0llGh+e+P9IeeUAJg1q9nbHlnplMXp2SG/KHfr4l9myJ8p6ZxSKFSUlKho+U7xU+/1YQx8Zdp3HdlPf/6ncW21jsT//uknIeeUALjiimZv87LT45cp2fffrYtVvmsqF2qmFBIVJUVRHFPbYK0Pt3ny9Y7sP7zoy0kr3/3zrCvCzikxdWqztz2y0zlQVReXOILLd2CVC3X32dCoKCmK4hj/A5/l485xZF9y6plJy5RWDjkFd7iNCC+4oNnb47pnsr+yLi675Prv39/oAPEtF7Z3VJSUqGj5TvHjX7T0K1ec6cj+we9eyuEjycmUXv/FNeHnlPr1a/a2b/cueH0mLtlSZW0jLqFpjT2wyoVl1fHJzNo7KkqKojimxt42fOHyLY7sn/jHKiprG4iwSXTcuGTaW+FFqbKy2dt+3agDYbcAACAASURBVDMBKKk40uZxHD5iLTEUuFNv75wMSitVlEKhoqRExaCpkmLhz5SG/v1lR/bj3nsdn4HqJDyrNGnZ2+HnlGbObPa2ry1Kew+13BTwWDlc29jU5OCnT7dMSuNULmzvqCgpUdHyneLHv71D7vo1juz7F60Hjk72J5LjizfiCvc8w4oVzd4e170LAHviIUpHGpo1OQD07paJz8DBODVXtGdUlBRFcUy1vbhq+e+fdGS/8RePAvFdgTscD3zpB6R7wnzFBWVKeVlpZHhccSnfVRxpaFqJ3E+fnAwA9h1WUQpGRUmJiiZKip9qe05p0JejrxIOcM63rgHiu1dROJ554Z7wohTUfSciDM7PYvvB6pjHqWv08v1XVvP8B9tCnj9YVUd+14xmx/p0s8uFh9s+M2vvOBIlEZkoIhtFpEhE7g1xPkNEXrXPLxORgoBz99nHN4rIZdF8isgQ28dm22f6MYxxp4isF5F1IvKKiGTG9vEoQFImqZXUxL8NRcP99zuyP3D3fQAcSnD7szGGGedeT0aITf4AmDatxaFhvbqytTR2UVqwYT9zPy3hwbc+C9m9d7Cqnp5d05sd889h7VNRakFUURIRN/AUcDkwCrheREYFmd0ClBtjhgMzgEfsa0cBU4DRwETgaRFxR/H5CDDDGFMIlNu+WzNGf+D7wFhjzImA27ZTFKWV+BsdMked4Mg+60TLLtGrFzR4DVvz+ofPlEaMaHFoaK9sdpbV0OD1xTTW0q0Hm16//9m+ZudqG7xU1jXSMyhTys9OxyWwX0WpBU4ypXFAkTFmqzGmHpgNTA6ymQy8aL9+HbhYrNUOJwOzjTF1xphtQJHtL6RP+5qLbB/YPq9q5RgAHqCLiHiALKDEwf0qQWiepPipqfeSmebCPS76fkoAx11yHgAHEvxMTl2jl7deujO8KI0d2+LQ0J5dafQZdpbVxDTW5n1VnDYol145GXy45WCzcwdtMc7Pbp4pedwuenbN0PJdCJyIUn9gV8D7YvtYSBtjTCNwCMiPcG244/lAhe0jeKyYxjDG7AZ+B+wE9gCHjDHvhrpBEZkqIitEZEVpaWnYD6KzotU7xU9VXSNdMzxQ4uzvOykpITvdzcGqxGZK9Y0+zrztJdLDle9CxD+0VzYARfurYhqruKKGgT2yOGdYPh9uOdis3O3vrgueUwI4LrcLJRUqSsE4EaVQPZXBX1PhbNrqeMxjiEgeVhY1BOgHZIvI10LYYoyZaYwZa4wZ26tXr1AmiqIANXWNZGd44NFHnV3w6KPkd81IeOtzvdfHtz5+g3SPO2xcwYzsm4NLYH3JYcfjNHp97KmoZUBeF84Zls+Bqjo2B4ia/7mn3jktRWlwj6yYs7LOgBNRKgYGBrwfQMsyWJONXSrrDpRFuDbc8QNAru0jeKxYx7gE2GaMKTXGNABvAM4W7FKC0FRJsaiq85KV7jxToqSE/K7pTWWsRFHf6KNPVVn48l2I+LPSPRT2zmFNcYXjcfZV1tHoMwzIy+KcYT0B+KDoQNP5XeVWi/nAHlktrh3UI4vdFUdinsPq6DgRpeVAod0Vl47VLDA3yGYucKP9+hpggbFy2LnAFLtzbghQCHwczqd9zULbB7bPN1s5xk7gLBHJsueeLgY2OPtYFEUJxeHaBrplxpgpZSd+SZ36Rh/TL/pWeFEKE//JA7qzpviQ447TYjvTGZDXhYE9shjUI4sPio7OK+0qqyE73U1eVlqLawf1yMLrM+zREl4zooqSPX9zO/AO1pf6HGPMehF5SESutM2eBfJFpAi4C7jXvnY9MAf4DJgP3GaM8Ybzafv6CXCX7Svf9t2aMZZhNUSsAtba99r8iTnFETqnpPg5VGM/CHr66c4uOP10eiYhU6pr9PHWCz8IP6cUJv6TB+ZSVl1Pcbmzh2h32w/bDsizMqFzh+ezbOtBGu3sZ1dZDQPysprtcutnUL51zY6y2NvQOzKe6CZgjJkHzAs6dn/A61rg2jDXTgemO/FpH9/K0e65wOOtGeMB4IFQ1yjOUU1S/Bw60kBuVlqLFRHCMnMm+QfSKauux+czzRYljSf1Xh/3T7yDux2u6ODn9EF5ACzbVhay5BaMX7z65VrPHZ0zrCevfLyLtbsPMWZQHp/vreS0wXkhrx1k+9d5peboig6KojjmkH/JnJwcZxfk5NA7JxOvzyQ0W6pv9FGd3iV8+S5M/Mf3zSE/O50lm5114RaX19CnWwYZdkPF+OE98biEeWv3UF5dz+6KI4zu1y3ktX26ZZLucbHjoIpSICpKSlS0fKeA9ezPkQavJUqTJjm7aNIk+uVai53GY125cNQ3+nj29QfDi1KY+F0u4dzhPVlSdNDRvFJx+RH62/cH1j5JF5/QmzdW7ea9DdaDtGcUhM6U3C5hWK+ubNxbGfJ8Z0VFSYmKbl2hgJUlAZYobdrk7KJNm5pKW4kUpbpGHxdNnUlGOFGKEP/4wp4cqKpz1Bq+q7ymaT7Jz83nDuFgdT0/fn0N/bpncurA0KIEMLJPVzbtU1EKREVJURRH+Lef6NYlLeTacSGZNo0BudaX9u4EilJNfSM/XPIyWelhnlOKEP8lJ/TB4xLeXrMn4hj+Z5QG9ujS7PhZQ/O56wsjGNIzm+lfPgl3hHm0kX27sedQbcLXBkxlVJSUqGj5ToGjmVJuVnoUy+Z06+IhO92dUFE6Ym8qmJXuqJerGT2y0zl3eE/eXlMSsYQX+IxSMN+/uJCFP7qAC0f2jjjW8X2tua1N+zVb8qOipERFRUkBqKgJKN/FkCmJCP3zurDbYZt1W1Bd7+X34/+nVZkSwBWn9KO4/Agrd5SHtdlld80NDCFKThlhi9LnOq/UhIqSoiiOaCZKIVbZDolt1y+3i+Nnf9qCI/WNLJg5NXymFCX+y0/sS06mh5eW7ghr47+fAXldwtpEo1/3THKz0lhXfKjVPjoaKkpKVLTRQQE4aK/03bNrOrz9trOLbLuhPbuy7UA1Pl9ifpeq671MvXZa+O67KPFnZ3j46tiBzFu7J+yeR7vKahChqbuwNYgIYwbmsmpn+Iyss6GipERFy3cKQGllHZlpLmuV8EqH5Sbbbnjvrhxp8CZsXulIvZd8E2FpIwfxf/2swfiM4S+Lt4Y8X7S/ikE9ssILn0PGDMpj8/6qpjm7zo6KkqIojjhQVU/PrhnWkjlTpzq7yLYr7NMVgKLS2LaFaC019Y08+M8/hDdwEH9Bz2yuHjOAlz7awZ5DLcX0872HGdnH4UPEETjNXkUiloVgOzIqSoqiOOJAVd3RHVRXrnR2kW03vJctSvsSI0rV9V6+d2eEpZAcxv/DSwoxxvDYu82fa6pt8LL9YA0j2kCUThnYHRFYtUNFCVSUFAdo+U4Bq3zXy78v0N13O7vItsvLTqdn13Q2JuhB0araRu6Y96eocUVjYI8svjl+CK+tLG62JcWqHeV4fYbTBucea6jkZKZxQt9ufLT1YHTjToCKkqIojmiWKfXr5+yiALuT+nfn012JyQYqjjRwpGeEZ4Scxg/ceckICvKz+PHra5o2K/zP5lLcLuGMgh7HGipgrSKxckd50/NVnRkVJSUq2n2neH2Gsur6VmdKYE3oF5VWcbg2/hP6h2rqWXr1zY7iikZmmpvHp4zhQFUdt7y4gnW7D/H6imIuHNmbnMyW+yS1hvHDe1Lv9bFsm2ZLKkpKVLR8pxyoqsNnOCpKrciUxgzKxRhYsyv+z+SU1zQw/bbLHMXlhFMG5vKH68ewYc9hJj2xhMO1Dfzg4sJjjPIoZxT0IN3talYi7KzEvgaHoiidjqYHRf3P5KxY4ezCALtTBubiEvh4exnjC3u2dYhNeH2Gw7UNvPLU69zqIC6nXDa6L/N/OIEFn+/nzCE9OLF/92OKM5Au6W7GFuTx380qSpopKVHRREkpLreW1OnvX70ghlXC/XTLTOPUgbks2ri/rcNrxuEjDRgDAw7sdhRXLAzpmc0t44e0qSD5uej43ny+t7Jp+aLOioqSEhYn+8konQP/Q69NewfFsPZdIBcd35s1xYfYXxl6lYS2YJ/t+8wXn3AcVypw6ai+ALyzfm+SI0kuKkpKVFSclN3lR8jNSiM7w674L1rk7MIgu4uO7wPAu+v3tV1wQeypsERpx98iLCXkNP4EMig/i+P75sT1s2kPqCgpUVFJUnZXNN9hNdYVHfyccFwOx/fN4bUVu9owuuaU2KsvnPDAjxzHlSpcOrovK3aUcaCq5RJJLy3dzh/+vbnD/5HoSJREZKKIbBSRIhG5N8T5DBF51T6/TEQKAs7dZx/fKCKXRfMpIkNsH5ttn+nHMEauiLwuIp+LyAYROTu2j6dz07F/9ZVY2FlW03w17LFjnV0YZCcifHXsQD4tPsS63fHpwisuP4LHJWSedabjuFKFS0f1wWfg/c+aZ0vl1fXc/+Z6HntvU4dfvDWqKImIG3gKuBwYBVwvIqOCzG4Byo0xw4EZwCP2taOAKcBoYCLwtIi4o/h8BJhhjCkEym3fMY9hX/M4MN8YczxwCrDB6QejHKWD/2GmRKHB62PnwRqG2UsFAa3OlAC+cvoAcjI9/P79zccc24GqOv7nmY+areS9cW8lw3t3xfWdsL13KZspje7XjcH5Wcz9tKTZ8U8CHjr+19qOPefkJFMaBxQZY7YaY+qB2cDkIJvJwIv269eBi0VE7OOzjTF1xphtQJHtL6RP+5qLbB/YPq9qzRgi0g2YADwLYIypN8bo4lKtQlWpM7PjYDWNPsPw3gGilONwzbcQdt27pDH1vKG8v2EfH245thboV5fv4oOigzy9sAiw5j8/KznMyL45kWN0Gn+CERGuOrU/S7cebLYI7Oqd5bgETh7QnWXbypIYYfxxIkr9gcACcLF9LKSNMaYROATkR7g23PF8oML2ETxWrGMMBUqB50VktYg8IyLZoW5QRKaKyAoRWVFaWhr+k+hkaIakgLVFA9BclEpKwlgHEcbulvOGUJCfxT2vraGipr7VsflXh1i2rQxjDEX7q9h7uJZxQ3pEjtFp/Eng6jH9MQbmfnI0xtW7KhjZtxsXjOzN+pJDCVkVI1k4ESUJcSz46yqcTVsdb80YHuA04I/GmDFANdBiPgzAGDPTGDPWGDO2V69eoUw6NSpOnZstpdUAzct3rey+85OV7uGx606ltLKOm19Y3qov2Z0Ha5j10U7A2k58xnubmLl4K26XcPHxfSLHmILdd34KemYzZlAuf19tPWfl8xk+2VXBmEG5jCvogc9YC8J2VJyIUjEwMOD9ACD4z4wmGxHxAN2BsgjXhjt+AMi1fQSP1Zoxio0xy+zjr2OJlBIjqkmdm8/3VtI/t8vRdnCAmRG2hQgkgt1pg/L4w/Wnsrb4EFc9+QErtjsrS/l8hnfX7+WaP32I2y0suPt8rh7Tnz8sKOK1lcV8/azB9O2eGTlGp/EniavH9OfzvZWs232ILaVVVNY2curAXE4dlIvbJazswKLkZJmh5UChiAwBdmM1FdwQZDMXuBFYClwDLDDGGBGZC8wSkceAfkAh8DFWdtPCp33NQtvHbNvnm60ZwxjjFZFdIjLSGLMRuBj4LNYPqDOjC7EqYG0+d1LwCgZvveXs4ih2E088jlnfzuD7r6zmmj8t5cwhPZh08nGcMjCXvt0z6Zrh4Ui9l7LqeraUVrFqZwXvf7aPrQeqGdYrmydvOI2hvbry2FdP4cpT+1HX4OUL9kOoEcd2Gn+SmHxqfx751+c8u2QbZw21ViI/fXAeXTM8nHBcDssdCnh7JKooGWMaReR24B3ADTxnjFkvIg8BK4wxc7GaCf4qIkVY2csU+9r1IjIHSwwagduMMV6AUD7tIX8CzBaRh4HVtm9aMwZwB/Cy3Va+FYiwbLASDi3fdV4qaurZcbCG684Y2PzEDTfArFnRHTiwGzekBwt+dD4vfriDOSt28fM314e1TXe7GDekB7dfNJwrTulHmtsq9ogIF44M2qoi0thO408S3bukcd0Zg3hp6XbWlxyiZ9cMhva0psTHDu7B7OU7afD6mu6/I+FoQVZjzDxgXtCx+wNe1wLXhrl2OjDdiU/7+Fas7rzg460Z4xMgNR9IaEd09If1lPCstZ8lOmVA0GZ2kyY5c+DQLivdw3cvGMZ3zh9KcfkR1u0+xIGqOqrrvXRJc5OblcbQnl0Z1jubrHSH60hHGttp/Enk1vOH8sbqYjbtq+LW84da29ADYwvyeOHD7awvOcypA499k8FUQ1cJV8KiWqSs2lGBCC0XIL0huIIfBqd2NiLCwB5ZDOyRFdN1MY8dY1zJoE+3TObcejYfbyvjmtMHNB0fO9gq563YXtYhRanj5X5Km6Pa1Hn5YMsBTuzXne5dgjazk1BNryFwahcPIo2dzLhiYESfHL521mAy09xNx/p2z2RAXhdWbO+YzQ4qSkpUNGPqnNTUN7J6ZznnDM9vedLpL0Uyf3kijd3Of6nPKOjBih3lHbK0rqKkhKXj/borsbBsWxkNXsP44SE25HPaJJDMZoJIY6dwk4MTxhbkcaCqjh0HO97eSypKSlS0Nbxz8s66vWSnuzmjoEfLk29H2BaiNXbxINLYyYyrDWiaV+qAzyupKClh6YCVAcUhDV4f89fv5ZJRfZrNZzShmVJSKezdlW6ZHscPHLcnVJSU6Kg4dTqWFB2goqaBL510XGiDK65w5sipXTyINHYy42oDXC5hbEEPPu6Ai7OqKClRUU3qfLz80U7ys9M5f2SYtSCPYeuKhBFp7BTduiIWzhmWz9YD1U1b1XcUVJSUCKgcdUaKy2tY8Pk+powbSIYnROkO4IILnDlzahcPIo2dzLjaiAkjrD8YlmzuWDsbqCgpUdG5pc7FzMVbcYlww5mDwxv16+fMmVO7eBBp7GTG1UYU9u5Kn24ZLN58bHtSpRoqSkpUtPuu87CrrIZXPt7JV88YSP/cLuENKyudOXRqFw8ijZ3MuNoIEeG8wl58UHQAr6/j/BtVUVLCohlS5+OR+Z8jItxx0fDIhm2wdUXcacdbVzjlvMKeVNQ0sM5eo7AjoKKkREXFqXOw4PN9vL1mD7ddMJzjukfIkgBWrHDm1KldPIg0djLjakP8Dzb/twPNK6koKVFRTer4HKyq46dvrKOwd1e+e8Gw6BdoppQS5HfN4MT+3TrUvJKKkqJ0crw+ww9mf0JZTT0zrjuVdI+DrwXtvksZzivsxaod5VS2Ykv5VERFSYlKR1z0UbEwxjBt7nqWFB3g4cknttyiIhzTprWtXTyINHYy42pjJhT2otFnWLrlYLJDaRNUlJSoqCR1TIwxPPruJv760Q5unTCUrwbvLhuJESPa1i4eRBo7mXG1MacPziM73c3iDjKvpKKkhEXFqOPi8xl+8fYGnlxYxPXjBnLv5cfH5mCsww2dndrFg0hjJzOuNibd4+LsYfks3tQx5pVUlJToqDp1KGobvHx/9mqe+2AbN59bwPSrTmraatsxJSVtaxcPIo2dzLjiwIQRvdhZVsP2A9XJDuWYUVFSoqIPz3Ycth2o5qqnPuDtNXu49/LjuX/SKFyuVuzC+uijbWsXDyKNncy44sCEQmvJoY5QwnMkSiIyUUQ2ikiRiNwb4nyGiLxqn18mIgUB5+6zj28Ukcui+RSRIbaPzbbP9NaOYZ9zi8hqEWnfG6gkAW1w6DgYY5j7aQlXPrGEvYdref7mM/jO+cNiz5D8aKaUUhT0zGZQjywWb+oEoiQibuAp4HJgFHC9iIwKMrsFKDfGDAdmAI/Y144CpgCjgYnA07ZIRPL5CDDDGFMIlNu+Yx4jILYfABucfRxKKFSb2jf7D9dy619X8v1XVjO8T1f++f3zuHBk72NzqplSyjFhRE+WbjlIfaMv2aEcE04ypXFAkTFmqzGmHpgNTA6ymQy8aL9+HbhYrD/BJgOzjTF1xphtQJHtL6RP+5qLbB/YPq9q5RiIyADgS8Azzj4OJRQqSu0Tn88wZ/kuvjBjMYs2lXLf5cfz2q1nR17Tzimnn962dvEg0tjJjCtOTCjsRXW9l5XtfDdajwOb/sCugPfFwJnhbIwxjSJyCMi3j38UdG1/+3Uon/lAhTGmMYR9a8b4PfBjICfSDYrIVGAqwKBBgyKZdipUi9ovK3eUMW3uZ6zdfYixg/N45JqTGdara9sNoCs6pBxnD8vH4xIWby7l7GH5yQ6n1TjJlEIVnYO/r8LZtNXxmMcQkUnAfmPMyhDnmxsbM9MYM9YYM7ZXrzCbmnViVJzaDyUVR/jB7NV85Y9L2V9Zy++vO5XXvnN22woSQE7Ev/Nit4sHkcZOZlxxIiczjdMG5bX7eSUnolQMBD5VNwAIniVsshERD9AdKItwbbjjB4Bc20fwWLGOcS5wpYhsxyoPXiQi/+fgfhUbLdu1H0or63jwrfVc8NtF/GvdXm6/cDgL7r6Aq8b0b30zQyQmTWpbu3gQaexkxhVHJozoyfqSw5RW1iU7lFbjRJSWA4V2V1w6VlPB3CCbucCN9utrgAXGat2aC0yxO+eGAIXAx+F82tcstH1g+3yzNWMYY+4zxgwwxhTY/hcYY77m8HNRAJ+tStqFl7pU1NTz6399zoTfLOSlpTu4ekx/Ftx9Pj+6bCTZGU6q861k06a2tYsHkcZOZlxxpGk32qL2my1FFSV7fud24B2sLrY5xpj1IvKQiFxpmz0L5ItIEXAXcK997XpgDvAZMB+4zRjjDefT9vUT4C7bV77tO+YxWvuBKEfxa5FKUupRXl3PY+9t4rxHFvLnxVu4dHQf3rtzAo9cczID8rLiH4CufZeSnNivOz2y09v16g6O/pQyxswD5gUduz/gdS1wbZhrpwPTnfi0j2/F7p4LOh7zGAHnFwGLwp1XQuPTDCnlKKk4wjP/3cYrH+/kSIOXy0b34c4vjOD4vt2SHZqSArhcwvjhPfnv5gP4fKZ1D0YnmTjm90p752j5LsmBKGwpreJPi7bwj0924zMw+ZR+fOeCYYzok6QJe82UUpYJI3ox99MSNuw9zOh+Dld9TyFUlJSw+JrESFUpWazaWc5fFm9l/vq9pLtd3DBuEN+eMDQxJbpIjBjhbF7GqV08iDR2MuOKMxMKrd1oF286oKKkdCy0wSE5NHh9zFu7h+c+2M6nuyrIyfTwvQuGcfO5Q+jZNSPZ4Vm87XDVLqd28SDS2MmMK8707pbJ8X1zWLyp1NkuwimGipISFn+mpNqUGMqq63nl4528tHQ7+w7XMaRnNg9NHs1XThsQ30661lBZ2bZ28SDS2MmMKwGcP6IXz32wjeq6xtT73YmCrhKuhKVpTinJcXR0Nu2r5L431nD2r/7Nb9/ZyIg+OTx301j+fdf5fOPsgtT8Upk6tW3t4kGksZMZVwKYMKIXDV7DR1vb3260KfjbrqQKmiHFjwavj3fX7+PlZTv4cMtBMjwuvnxaf246Zwgj+7aD1QZWRl0oJTa7eBBp7GTGlQDGFuSR4XHx4ZaDXHxCn2SHExOaKSlRUXFqO4rLa/jdOxs559cLuG3WKnYcrOGey0ay9L6L+dWXT24fggRw991taxcPIo2dzLgSQIbHzemD8zRTUjomusnfseH1Gf6zaT8vf7SThRv3Y4CLRvbma2cNZsKIXrjb4bMk9OvXtnbxINLYyYwrQZw1NJ8Z72+ioqae3Kz0ZIfjGBUlRYkTpZV1zFmxi1nLdrK74gg9u2bwvQuGM2XcwOS3dB8rmimlPGcNzccY+HhbGZeO7pvscByjoqRERct3zmn0+li8uZQ5y4v59+f7aPAazhmWz0+/eAKXju5DmruDVMz79XO2e6tTu3gQaexkxpUgThnYnQyPi4+2qigpHQzVpOhsO1DNayt28bdVxew7XEd+djo3nl3A9WcOavttI1KBFSva1i4eRBo7mXEliPY6r6SipCitpKa+kXlr9zJn+S4+3l6GS+DCkb158MqBXHR8b9I9HSQrCsWmTc7mZZzaxYNIYyczrgRy9tB8Hmtn80oqSkpUdGWHoxhjWLWzgtdW7OKtT0uorvcypGc2P544kq+cNoA+3TKTHWJimDYNFi1qO7t4EGnsZMaVQM4alo95D5ZtK+OydlLCU1FSFAcUl9fw5iclvLGqmC2l1XRJc/Olk4/jujMGMnZwXnw20ktlnH6hJ/OLP9LYnUCQAE4e0J3MNBcfbT2ooqQo7Z1DRxr419o9vLF6Nx9vKwPgjII8vn3eUCad0o+uqbjSQqKYOhVmzmw7u3gQaexkxpVAjs4rlSU7FMd04n9VilM6U/WuvtHHfzaV8o/Vu3lvwz7qG30M7ZnN3V8YwVVj+jOwRztv5W4rxo5tW7t4EGnsZMaVYM4aks+j77WfeSUVJaXTY4zhk10V/H31bt76tITymgZ6ZKdzw7hBXDWmP6cM6N75ynPR0LXv2g3jhvQAYOWO8nax5JCKkhKSRq+v6XVHXdGhaH8lb326h7mflrDtQDUZHheXjOrDl8f0Z8KIXh3nmaJ4kJPjbKVtp3bxINLYyYwrwZwyMJc0t7B8u4qS0o5p8B4Voo5Uvtt5sIa31pTw1qclfL63EhE4c0gPvnv+MCae1JdumWnJDrF94PTB02Q+oBpp7A7+4GwgmWluRvfrzsod7WNeSUVJCUl9oy+6UTthz6Ej/HPNHt76tIRPiw8BcNqgXB64YhRfPOm4ztPG3ZYsWgRXXNF2dvEg0tjJjCsJnFGQx4tLd1DX6CXD4052OBFxVJ8QkYkislFEikTk3hDnM0TkVfv8MhEpCDh3n318o4hcFs2niAyxfWy2faa3ZgwRGSgiC0Vkg4isF5EfxP7xtH/Kq+upa/TGfF19YPmuHWZK+ytrefHD7Vz7pw85+1cLePifG/AZuO/y41nykwt543vncvO5Q1SQWovTzrVkdrhFGrsTdN4FcvrgHtQ3+li3+3CyQ4lK1ExJRNzAU8AXgGJguYjMNcZ8FmB2Ta/xdwAAFEFJREFUC1BujBkuIlOAR4DrRGQUMAUYDfQD3heREfY14Xw+AswwxswWkT/Zvv/YijEagbuNMatEJAdYKSLvBcXd4Rnzi/c4Z1g+s759VkzXNROltg4qThysquPdz/bx9poSlm45iM/AyD45/OjSEUw6uR8FPbOTHWLH4a232tYuHkQaO5lxJYHTB+cBsGJ7WdPrVMVJpjQOKDLGbDXG1AOzgclBNpOBF+3XrwMXi9WuNBmYbYypM8ZsA4psfyF92tdcZPvA9nlVa8YwxuwxxqwCMMZUAhuA/s4+lo6Bz97P/MMtsa99daS+sa3DiQt7D1kZ0ZSZSzlj+vvc98ZaSipquf3C4bx75wTeuXMCt19UqILU1txwQ9vaxYNIYyczriTQKyeDgvwsVuwoT3YoUXEyp9Qf2BXwvhg4M5yNMaZRRA4B+fbxj4Ku9QtDKJ/5QIUxpjGEfWvGAMAu9Y0BloW6QRGZCkwFGDRoUCiTdkn1MQhLZe3Ra1NtmaEdB6uZv24v89fvZfXOCgAKe3fl9guHc9mJfRl1XDdt4Y43kya1rV08iDR2MuNKEmMLerDg8/0YY1L634cTUQoVffC3VDibcMdDZWiR7FszhnWRSFfgb8APjTEhC6rGmJnATICxY8em1jfwMRAoLLFSVRcgSm0RzDFgjGHTvqomIdqwx/rfeFL/7txz2UguG92X4b074ErcqYxmSu2OsYPzeH1lMVsPVKf0yvVORKkYGBjwfgAQ3E/ptykWEQ/QHSiLcm2o4weAXBHx2NlSoH3MY4hIGpYgvWyMecPBvXYojkmUjuHatsAYw5riQ8xfv5d31u1l64FqRKx/WD+fNIrLRvdp/xvltWdEnHXAOLWLB5HGTmZcSWJsgTWXtHJ7ebsXpeVAoYgMAXZjNRUE/5kxF7gRWApcAywwxhgRmQvMEpHHsJoQCoGPsbKbFj7taxbaPmbbPt9szRj2fNOzwAZjzGOxfjAdgaq6hlZfe+hIwLUJ+rfr9RlWbC9rEqKSQ7V4XMLZw/L55vghXDq6D71ztFsuJXD6hZ7ML/5IY3cyQQIY1qsreVlprNhRxlfPGBj9giQRVZTs+ZvbgXcAN/CcMWa9iDwErDDGzMX68v+riBRhZS9T7GvXi8gc4DOsbrjbjDFegFA+7SF/AswWkYeB1bZvYh1DRMYDXwfWisgnto+fGmPmte6jan8ctrOdjFbs67PvcF3T63iu6FDf6GPp1oPMX7eX9z7by4GqetI9LiYU9uKuS0dyyQm928V6XZ2OWbOclcCc2sWDSGMnM64kISKcPjiPFdtTu9nB0cOz9hf5vKBj9we8rgWuDXPtdGC6E5/28a1Y3XnBx2MawxizhNDzTZ0GfwkuMy32h+X2Hj7S1uE0Udvg5T+bSnln3V7e37CPw7WNZKe7ufD43kw8sS8XjuxNdmdegbs98Pbbzr7UndrFg0hjJzOuJHL64B68v2E/B6vqyO+akexwQqL/8jswlceQKe0sq6FXTgallXVtUumorG1g4cZS5q/bw8LPSznS4KV7lzQuHd2XiaP7Mr6wZ6vEU0kSs2a1rV08iDR2MuNKIk3zSjvKuTRF91dSUerAlFZaJbiczNj+NxtjWF9ymFMH5rJoY2mri3cVNfW899k+5q/by383H6De66NXTgZfPq0/l594HGcO7aGLnrZXrrjC2QOoTu3iQaSxkxlXEjmpf3fS3S4VJSU57D1cCxDzMwmf762koqaB0wflsWhjKY0+57JUWlnHO+v38s76vSzdcpBGn6F/bhe+fvZgLj+xL6cNysPl6tRV1Y6Bbl3RLslMc3Ni/24p/RCtilIHZs8ha16owRvb4qpvrCrGJXD5Scfx6HubaIiyOGtlbQPvrN/Hm5/s5oOiA/gMDOmZzbcnDOXyE/tyUn/dj6jDccEFbWsXDyKNncy4kszYgh688MF2ahu8KVkyV1HqwPgfMo0mKoFs3FvJS0t3cNWp/emXa7Vf14cQNWMMS7ceZNaynbz32T7qGn0M7NGF2y4czqST+zGiT1cVoo5Mv37O9iNyahcPIo2dzLiSzOmD85i5eCvrdh9ibEGPZIfTAhWlDsqW0qqmtu56r7Py27rdh/jWiyvo1iWNey8/nnR7vidwG4tGr4+/r97NX/67lU37qsjNSuOrYwdy1Zj+nDYoV4Wos+D0Cz2ZX/yRxu6kggQBi7PuKE9JUdJZ5g7Ks0u24XYJE0f3jVq+Ky6v4UevfcqVTy5BBF765jh6d8vE43bhkqOitHJHOZc//l/ueX0NHpeL31xzMh/ddzG/uOpETh+cp4LUmdCtK9otPbtmMKRndso+r6Si1MGob/Tx2LsbmbVsJzeeXcCAvC5hRam0so5pc9dz4e8WMffTEm4+dwhv3zGeE47r1mST5nbx/+3de3BU1R3A8e+PkAAFDFFeEhjer8QQhVStOkqVSrEqjlqKU6u2ndqXtlXrg6lt0TrToR370D7UKjPVPujDPiittrH1UVsFg4AEUkIIkSIYwPAGgSS//nHOstuw2WzI3dyb3d9nJpO7J+eec/dMdn977577O0dbWlmyYgvzHn2Fw8daeOT66fz5Cxcwr2JUJK9Jm25QVRVsvUxI1XeYxxUBM0YX8fqW3ZFLtgx2+S5rNLe0snTNNn7wfB31Ow9y9fRiFlw2he9U1p4QlPYePsZjL21i8csNHG1pZV7FSG69eCIjBvU7od2C3r14rqaR+p0HmTl5CA9fdxYDbclwY2dKPVosOevmXQcZF7E8eBaUerhDR5v5/aq3ePTFerY0HWLK8IE8cWMFl0wdBrgznWMtiqrS0qo89eqbfP/vG9lz6BhXlI/gtlkTU/9TKtTvPMj4If155PoZdmZknJkz3ZLiQdXLhFR9h3lcERC7ibbqzd0WlEwwNjbu5+fLt/D061vZ/24z5SML+erlFVwyZej/3QdUkOe2dx44wq2/WMXyzU2cP+E0FsyZyhnFhR32M2HYAFZt2cM3r55mAcnELVwYbL1MSNV3mMcVAeMGD6CwXz4rG3YzryJayVktKPUg9TsPHM+gvWbrXgryejGnbDjXnzuainYmGsQyJty0+DXqdh7gwQ+Xc/X04rQnJTxw1Rm8vfddzh4bvVk6JkSTJgVbLxNS9R3mcUVAr14+OeubTWEfygksKEWYqlKzfT/PrnubZ6u3U9t4AIDyUYNYMGcK184Y2WFSxVhQWr99H4uuKeOaGSM7dQylIwopHdHxGZXJMRUVsK3tsmpdqJcJqfoO87giYsboIv7xnx3sPniUov7RycRvQSliWluV1Vv3uFVWq99mS9Mhegm8d8ypfP2KEmaXDk86IaE9+f7yXf+CPK6Z3rmAZEy70n1DD/ONP1XfOR6QwE12AHerx6ySYSEfTZwFpQhobmllRUMTz1a7nHGN+46QnyecN34wn5s5nlklwxh8kmnmi4tcAPvy7Mn0tuSnJigPPgh33BFcvUxI1XeYxxUR5aMGkZ8nVFlQMuDuJ/pX3S6eqd5O5fpGdh86Rt/8Xsyc5NcUmjKUwn5dn3r9/slD+dMtF3BG8SkdVzYmXXam1OP1zc+jdEQhKyP2vZJE8eapMFVUVGhVhm6sO9Lcwj9rd/EXH4j2v9vMwD69uWSqC0QXThrCewrsc4Ixpns8sGw9T776JmsXXkqf3l2bXSsiK1W1oqvHZO+AGaaqrH1rL0te+y9/Wr2N/UeaOaVvb2aXDudDZadz3oTTuvzPYEy3mzEDVq4Mrl4mpOo7zOOKkIoxRTz+8maq39p3PCde2CwoZUhLq/Js9dv8+MU6qt/aR9/8XlxWdjpXlo/gvPGDKTiJ1WCNiQzL6JAVZox2t3pUNTRZUMpmKzY3ce8f1lLbeIBxQ/rzjbmlXHlmcSDfERkTCQMHBlsvE1L1HeZxRciQgX2YNGwAL2zYyacvGh/24QBpJmQVkQ+KyAYRqRORe5L8vY+I/Mr/fbmIjEn42wJfvkFEZnfUpoiM9W1s9G0WBN1HpjS3tPLAsvXMe/QVDh1t4eHrzqLytov42PvGWEAy2eXyy4Otlwmp+g7zuCLmAyXDWNHQxJ5DR8M+FCCNoCQiecAPgTlACXCdiJS0qfZJYLeqTgC+Cyzy+5YA84FS4IPAj0Qkr4M2FwHfVdWJwG7fdtB9BO5YSyuf+dnrPP7yZm5432gqb7uIK8pHkGdLf5tsVFsbbL1MSNV3mMcVMR8oGU5Lq/JczY6wDwVI70zpbKBOVetV9SiwBJjbps5c4Kd++7fAJeLy2MwFlqjqEVXdDNT59pK26fe52LeBb/OqIPtIb1g6p7VVufM3a3iuppH7rizl/rln0K/AJi+YLGa577LGtOJCxg/pzw+fr+OdA0fCPpy0vlMqBv6b8HgrcE57dVS1WUT2Aqf58lfb7Fvst5O1eRqwR1Wbk9QPqo8TiMjNwM3+4QEReQfYlaxuR25aBDedzI7RNJiTHIcsZGMR58bivvvSq51uvUxI1XfXjyvr/icG33nyuwKjgziGdIJSsutPbW9uaq9Oe+XJztBS1Q+yjxMLVR8Djk/HEZGqIObb93Q2DnE2FnE2Fo6NQ5wfizFBtJXO5butQGJu85FA29uhj9cRkd5AIdCUYt/2yncBg3wbbfsKqg9jjDERlU5Qeg2Y6GfFFeAmFSxtU2cpcKPfvhb4h7pUEUuB+X7m3FhgIrCivTb9Ps/7NvBt/jHIPtIbFmOMMWHo8PKd//7mFuCvQB6wWFXXicj9QJWqLgWeAJ4SkTrc2ct8v+86Efk1sB5oBj6vqi0Aydr0Xd4NLBGRB4BVvm0C7qMjdmedY+MQZ2MRZ2Ph2DjEBTYWlvvOGGNMZFiuG2OMMZFhQckYY0xkWFBK0N1picIgIotFZIeIVCeUnSoilT61U6WIFPlyEZGH/Hi8ISLTE/a50dffKCI3JusrykRklIg8LyI1IrJORL7oy3NxLPqKyAoRWePH4j5fHljKr57EZ4RZJSLL/ONcHYcGEVkrIqtFpMqXZf71oar2475XywM2AeOAAmANUBL2cWXgeV4ITAeqE8q+Bdzjt+8BFvnty4BncPeCnQss9+WnAvX+d5HfLgr7uXVyHE4HpvvtgUAtLh1VLo6FAAP8dj6w3D/HXwPzffkjwGf99ueAR/z2fOBXfrvEv276AGP96ykv7Od3EuNxO/ALYJl/nKvj0AAMblOW8deHnSnFdVtaojCp6ku42YuJElM4tU3t9KQ6r+LuITsdmA1UqmqTqu4GKnF5B3sMVd2uqq/77f1ADS4TSC6OharqAf8w3/8owaX86jFEZCTwIeBx/zjI1GfZIOOvDwtKccnSKRW3UzfbDFPV7eDerIGhvry9McmqsfKXXc7CnSHk5Fj4S1argR24N45NpJnyC0hM+dXTx+J7wF1Aq3+cduozsmscwH0w+ZuIrBSXig264fVh6ynFpZNOKdd0NrVTjyMiA4CngS+p6j73QTd51SRlWTMW6u7tO1NEBgG/B6Ymq+Z/Z+VYiMjlwA5VXSkiM2PFSapm9TgkOF9Vt4nIUKBSRP6Tom5gY2FnSnG5nJao0Z9q43/HcthndQonEcnHBaSfq+rvfHFOjkWMqu4BXsB9LxBUyq+e4nzgShFpwF2+vxh35pRr4wCAqm7zv3fgPqicTTe8PiwoxeVyWqLEFE5tUzvd4GfWnAvs9afsfwUuFZEiP/vmUl/WY/hr/08ANar6nYQ/5eJYDPFnSIhIP2AW7ju2oFJ+9QiqukBVR6pLLDof97w+So6NA4CI9BeRgbFt3P91Nd3x+gh7hkeUfnAzSGpx19O/EvbxZOg5/hLYDhzDfYr5JO46+N+Bjf73qb6u4BZK3ASsBSoS2vkE7gvcOuDjYT+vkxiHC3CXEd4AVvufy3J0LKbhUnq94d94vubLx+HeTOuA3wB9fHlf/7jO/31cQltf8WO0AZgT9nPrwpjMJD77LufGwT/nNf5nXez9sDteH5ZmyBhjTGTY5TtjjDGRYUHJGGNMZFhQMsYYExkWlIwxxkSGBSVjjDGRYUHJGGNMZFhQMqYbiMhVIvITEfmjiFyaK30b01kWlIzpBqr6B1X9FHAT8BFwiWBF5LBPhIov+7SIqIhclFB2iy+b1V77IjJBRNa2KesjIpuB2iR99/Pr5BwVkcEBPlVjusSCkjHd617cne8xm1T1zITH03CZFaYCiMh7cFk3duLulG9PPTBKRBJf0zcDL6rq+rZ9q+ph32+Py8lmspsFJWMCJiITReQFEakSkW/51ThFRBYBz6hfx6kdZbhUUFP84y/gUtm0qmqjb3+svxRXJW7F2Mmq2gpsAcb4Ov2AO4CFnejbmNBZUDImQCKSBzwJ3K6qFUA/XO6wW3GJTq8Vkc+kaGIqbqXTKSJSiLvc9m9cTrpYZvPHE9pfiFsBFFwS1Vgw+zywVFUbOtG3MaGz9ZSMCdZVwPqEM5Ia3CJxDwEPpdpRREYB76hqvV/D5i7gYWAS7pJerP1S4Gm/9lNv4J8JfU0WkZdwQelcgHT6NiYqLCgZE6yzcBnHY8pxK7mmYxrx743245aNPhu3pk8syJXjMjY/kWT/GtwaQF/ErRHV2LlDNyZ8dvnOmGC9g7+EJiLnADcQP8vpSBnxoPRt4BZ1K8KWJbSxHZgdm9AgImUSXy63BhfEPuH3N6bHsaBkTLCeAir89OyrcUGqLs19y/DfHanqMlV9xZeXALEZdItxr9saP5X8bo2vP7PBt/GYqu7t8jMxJgR2+c6YAKnqLuAcOP4d0Uw/My6dfT/aTvnQhO3DxFdBbVvvCPaaNj2cnSkZkznlpL501wIUJt48211iN88C+UBaQdOY7mArzxpjjIkMO1MyxhgTGRaUjDHGRIYFJWOMMZFhQckYY0xkWFAyxhgTGRaUjDHGRIYFJWOMMZFhQckYY0xkWFAyxhgTGf8DNR3VNpHG9KcAAAAASUVORK5CYII=\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"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.savefig('test.png')"
]
},
{
"cell_type": "code",
"execution_count": 27,
"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": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"91404000\n",
"0 45\n",
"1 45\n",
"2 45\n",
"3 45\n",
"4 45\n",
"5 45\n",
"6 45\n",
"7 45\n",
"8 45\n",
"9 45\n",
"10 45\n",
"11 45\n",
"12 45\n",
"13 45\n",
"14 45\n",
"15 45\n",
"16 45\n",
"17 45\n",
"18 45\n",
"19 45\n",
"20 45\n",
"21 45\n",
"22 45\n",
"23 45\n",
"24 45\n",
"25 45\n",
"26 45\n",
"27 45\n",
"28 45\n",
"29 45\n",
"30 45\n",
"31 45\n",
"32 45\n",
"33 45\n",
"34 45\n",
"35 45\n",
"36 45\n",
"37 45\n",
"38 45\n",
"39 45\n",
"40 45\n",
"41 45\n",
"42 45\n",
"43 45\n",
"44 45\n",
"Full integration finished in 5 min, 35 s\n",
"45702\n"
]
}
],
"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": 29,
"metadata": {},
"outputs": [
{
"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": [
"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",
" 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, 2.5e-6)\n",
" plt.plot(center,_list)\n",
" plt.xlabel(r'$q^2 [MeV^2]$')\n",
" plt.savefig('integrated_before_smearing.png')\n",
"# plt.plot(inte_fl)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Smearing"
]
},
{
"cell_type": "code",
"execution_count": 30,
"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*0.07\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": 31,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\ipykernel_launcher.py:1: DeprecationWarning: object of type <class 'float'> cannot be safely interpreted as an integer.\n",
" \"\"\"Entry point for launching an IPython kernel.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"12 min, 9 s\n",
"5 min, 29 s\n",
"5 min, 17 s\n",
"5 min, 18 s\n",
"5 min, 15 s\n",
"5 min, 8 s\n",
"5 min, 3 s\n",
"5 min\n",
"4 min, 56 s\n",
"4 min, 53 s\n",
"4 min, 50 s\n",
"4 min, 45 s\n",
"4 min, 41 s\n",
"4 min, 36 s\n",
"4 min, 32 s\n",
"4 min, 28 s\n",
"4 min, 25 s\n",
"4 min, 21 s\n",
"4 min, 17 s\n",
"4 min, 13 s\n",
"4 min, 9 s\n",
"4 min, 5 s\n",
"4 min, 1 \n",
"3 min, 57 s\n",
"3 min, 54 s\n",
"3 min, 50 s\n",
"3 min, 46 s\n",
"3 min, 42 s\n",
"3 min, 38 s\n",
"3 min, 35 s\n",
"3 min, 31 s\n",
"3 min, 27 s\n",
"3 min, 24 s\n",
"3 min, 20 s\n",
"3 min, 16 s\n",
"3 min, 13 s\n",
"3 min, 9 s\n",
"3 min, 5 s\n",
"3 min, 2 s\n",
"2 min, 58 s\n",
"2 min, 55 s\n",
"2 min, 51 s\n",
"2 min, 48 s\n",
"2 min, 44 s\n",
"2 min, 41 s\n",
"2 min, 37 s\n",
"2 min, 34 s\n",
"2 min, 30 s\n",
"2 min, 27 s\n",
"2 min, 23 s\n",
"2 min, 20 s\n",
"2 min, 16 s\n",
"2 min, 13 s\n",
"2 min, 9 s\n",
"2 min, 6 s\n",
"2 min, 2 s\n",
"1 min, 59 s\n",
"1 min, 55 s\n",
"1 min, 52 s\n",
"1 min, 48 s\n",
"1 min, 45 s\n",
"1 min, 41 s\n",
"1 min, 38 s\n",
"1 min, 34 s\n",
"1 min, 31 s\n",
"1 min, 28 s\n",
"1 min, 24 s\n",
"1 min, 21 s\n",
"1 min, 18 s\n",
"1 min, 14 s\n",
"1 min, 11 s\n",
"1 min, 7 s\n",
"1 min, 4 s\n",
"1 min, 1 \n",
"57 s\n",
"54 s\n",
"51 s\n",
"47 s\n",
"44 s\n",
"41 s\n",
"37 s\n",
"34 s\n",
"31 s\n",
"27 s\n",
"24 s\n",
"21 s\n",
"17 s\n",
"14 s\n",
"11 s\n",
"7 s\n",
"4 s\n",
"1 \n"
]
}
],
"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": 36,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\ipykernel_launcher.py:24: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\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": [
"# 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": 93,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\ipykernel_launcher.py:15: UserWarning: Creating legend with loc=\"best\" can be slow with large amounts of data.\n",
" from ipykernel import kernelapp as app\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 480x320 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"figure(num=None, dpi=80, facecolor='w', edgecolor='k')\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, 2.5e-6)\n",
"plt.plot(test_q, calcs_test, label = 'inf. precision')\n",
"plt.plot(scan_x,sum_y, label = 'smeared')\n",
"plt.legend()\n",
"plt.xlabel(r'$q^2 [MeV^2]$')\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": 92,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[21.0, 46.0, 53.0, 76.0, 79.0, 115.0, 112.0, 93.0, 197.0, 119.0, 127.0, 147.0, 167.0, 179.0, 168.0, 177.0, 232.0, 277.0, 267.0, 307.0, 295.0, 298.0, 331.0, 373.0, 357.0, 406.0, 426.0, 441.0, 538.0, 568.0, 976.0, 2477115.0, 1213.0, 693.0, 665.0, 634.0, 659.0, 88601.0, 117254.0, 996.0, 761.0, 782.0, 879.0, 1033.0, 803.0, 686.0, 571.0, 475.0, 285.0, 90.0]\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": [
"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",
"# 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": 95,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 480x320 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"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
}
