diff --git a/.ipynb_checkpoints/raremodel-nb-checkpoint.ipynb b/.ipynb_checkpoints/raremodel-nb-checkpoint.ipynb new file mode 100644 index 0000000..18ea8a8 --- /dev/null +++ b/.ipynb_checkpoints/raremodel-nb-checkpoint.ipynb @@ -0,0 +1,2204 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\zfit\\util\\execution.py:57: UserWarning: Not running on Linux. Determining available cpus for thread can failand be overestimated. Workaround (only if too many cpus are used):`zfit.run.set_n_cpu(your_cpu_number)`\n", + " warnings.warn(\"Not running on Linux. Determining available cpus for thread can fail\"\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n", + "For more information, please see:\n", + " * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n", + " * https://github.com/tensorflow/addons\n", + "If you depend on functionality not listed there, please file an issue.\n", + "\n" + ] + } + ], + "source": [ + "import os\n", + "\n", + "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"-1\"\n", + "import random\n", + "import numpy as np\n", + "from pdg_const1 import pdg\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import pickle as pkl\n", + "import sys\n", + "import time\n", + "from helperfunctions import display_time, prepare_plot\n", + "import cmath as c\n", + "import scipy.integrate as integrate\n", + "from scipy.optimize import fminbound\n", + "from array import array as arr\n", + "import collections\n", + "from itertools import compress\n", + "import tensorflow as tf\n", + "import zfit\n", + "from zfit import ztf\n", + "# from IPython.display import clear_output\n", + "import os\n", + "import tensorflow_probability as tfp\n", + "tfd = tfp.distributions\n", + "\n", + "from matplotlib.pyplot import figure" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# chunksize = 10000\n", + "# zfit.run.chunking.active = True\n", + "# zfit.run.chunking.max_n_points = chunksize" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Build model and graphs\n", + "## Create graphs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def formfactor(q2, subscript, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2): #returns real value\n", + " #check if subscript is viable\n", + "\n", + " if subscript != \"0\" and subscript != \"+\" and subscript != \"T\":\n", + " raise ValueError('Wrong subscript entered, choose either 0, + or T')\n", + "\n", + " #get constants\n", + "\n", + " mK = ztf.constant(pdg['Ks_M'])\n", + " mbstar0 = ztf.constant(pdg[\"mbstar0\"])\n", + " mbstar = ztf.constant(pdg[\"mbstar\"])\n", + "\n", + "\n", + " mmu = ztf.constant(pdg['muon_M'])\n", + " mb = ztf.constant(pdg['bquark_M'])\n", + " ms = ztf.constant(pdg['squark_M'])\n", + " mB = ztf.constant(pdg['Bplus_M'])\n", + "\n", + " #N comes from derivation in paper\n", + "\n", + " N = 3\n", + "\n", + " #some helperfunctions\n", + "\n", + " tpos = (mB - mK)**2\n", + " tzero = (mB + mK)*(ztf.sqrt(mB)-ztf.sqrt(mK))**2\n", + "\n", + " z_oben = ztf.sqrt(tpos - q2) - ztf.sqrt(tpos - tzero)\n", + " z_unten = ztf.sqrt(tpos - q2) + ztf.sqrt(tpos - tzero)\n", + " z = tf.divide(z_oben, z_unten)\n", + "\n", + " #calculate f0\n", + "\n", + " if subscript == \"0\":\n", + " prefactor = 1/(1 - q2/(mbstar0**2))\n", + " _sum = 0\n", + " b0 = [b0_0, b0_1, b0_2]\n", + "\n", + " for i in range(N):\n", + " _sum += b0[i]*(tf.pow(z,i))\n", + "\n", + " return ztf.to_complex(prefactor * _sum)\n", + "\n", + " #calculate f+ or fT\n", + "\n", + " else:\n", + " prefactor = 1/(1 - q2/(mbstar**2))\n", + " _sum = 0\n", + "\n", + " if subscript == \"T\":\n", + " bT = [bT_0, bT_1, bT_2]\n", + " for i in range(N):\n", + " _sum += bT[i] * (tf.pow(z, i) - ((-1)**(i-N)) * (i/N) * tf.pow(z, N))\n", + " else:\n", + " bplus = [bplus_0, bplus_1, bplus_2]\n", + " for i in range(N):\n", + " _sum += bplus[i] * (tf.pow(z, i) - ((-1)**(i-N)) * (i/N) * tf.pow(z, N))\n", + "\n", + " return ztf.to_complex(prefactor * _sum)\n", + "\n", + "def resonance(q, _mass, width, phase, scale):\n", + "\n", + " q2 = tf.pow(q, 2)\n", + "\n", + " mmu = ztf.constant(pdg['muon_M'])\n", + "\n", + " p = 0.5 * ztf.sqrt(q2 - 4*(mmu**2))\n", + "\n", + " p0 = 0.5 * ztf.sqrt(_mass**2 - 4*mmu**2)\n", + "\n", + " gamma_j = tf.divide(p, q) * _mass * width / p0\n", + "\n", + " #Calculate the resonance\n", + "\n", + " _top = tf.complex(_mass * width, ztf.constant(0.0))\n", + "\n", + " _bottom = tf.complex(_mass**2 - q2, -_mass*gamma_j)\n", + "\n", + " com = _top/_bottom\n", + "\n", + " #Rotate by the phase\n", + "\n", + " r = ztf.to_complex(scale*tf.abs(com))\n", + "\n", + " _phase = tf.angle(com)\n", + "\n", + " _phase += phase\n", + "\n", + " com = r * tf.exp(tf.complex(ztf.constant(0.0), _phase))\n", + "\n", + " return com\n", + "\n", + "\n", + "def axiv_nonres(q, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2):\n", + "\n", + " GF = ztf.constant(pdg['GF'])\n", + " alpha_ew = ztf.constant(pdg['alpha_ew'])\n", + " Vtb = ztf.constant(pdg['Vtb'])\n", + " Vts = ztf.constant(pdg['Vts'])\n", + " C10eff = ztf.constant(pdg['C10eff'])\n", + "\n", + " mmu = ztf.constant(pdg['muon_M'])\n", + " mb = ztf.constant(pdg['bquark_M'])\n", + " ms = ztf.constant(pdg['squark_M'])\n", + " mK = ztf.constant(pdg['Ks_M'])\n", + " mB = ztf.constant(pdg['Bplus_M'])\n", + "\n", + " q2 = tf.pow(q, 2)\n", + "\n", + " #Some helperfunctions\n", + "\n", + " beta = 1. - 4. * mmu**2. / q2\n", + "\n", + " kabs = ztf.sqrt(mB**2. + tf.pow(q2, 2)/mB**2. + mK**4./mB**2. - 2. * (mB**2. * mK**2. + mK**2. * q2 + mB**2. * q2) / mB**2.)\n", + "\n", + " #prefactor in front of whole bracket\n", + "\n", + " prefactor1 = GF**2. *alpha_ew**2. * (tf.abs(Vtb*Vts))**2. * kabs * beta / (128. * np.pi**5.)\n", + "\n", + " #left term in bracket\n", + "\n", + " bracket_left = 2./3. * tf.pow(kabs,2) * tf.pow(beta,2) * tf.pow(tf.abs(ztf.to_complex(C10eff)*formfactor(q2, \"+\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)),2)\n", + "\n", + " #middle term in bracket\n", + "\n", + " _top = 4. * mmu**2. * (mB**2. - mK**2.) * (mB**2. - mK**2.)\n", + "\n", + " _under = q2 * mB**2.\n", + "\n", + " bracket_middle = _top/_under *tf.pow(tf.abs(ztf.to_complex(C10eff) * formfactor(q2, \"0\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)), 2)\n", + " \n", + " #Note sqrt(q2) comes from derivation as we use q2 and plot q\n", + "\n", + " return prefactor1 * (bracket_left + bracket_middle) * 2 * q\n", + "\n", + "def vec(q, funcs, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2):\n", + " \n", + " q2 = tf.pow(q, 2)\n", + "\n", + " GF = ztf.constant(pdg['GF'])\n", + " alpha_ew = ztf.constant(pdg['alpha_ew'])\n", + " Vtb = ztf.constant(pdg['Vtb'])\n", + " Vts = ztf.constant(pdg['Vts'])\n", + " C7eff = ztf.constant(pdg['C7eff'])\n", + "\n", + " mmu = ztf.constant(pdg['muon_M'])\n", + " mb = ztf.constant(pdg['bquark_M'])\n", + " ms = ztf.constant(pdg['squark_M'])\n", + " mK = ztf.constant(pdg['Ks_M'])\n", + " mB = ztf.constant(pdg['Bplus_M'])\n", + "\n", + " #Some helperfunctions\n", + "\n", + " beta = 1. - 4. * mmu**2. / q2\n", + "\n", + " kabs = ztf.sqrt(mB**2. + tf.pow(q2, 2)/mB**2. + mK**4./mB**2. - 2 * (mB**2 * mK**2 + mK**2 * q2 + mB**2 * q2) / mB**2)\n", + " \n", + " #prefactor in front of whole bracket\n", + "\n", + " prefactor1 = GF**2. *alpha_ew**2. * (tf.abs(Vtb*Vts))**2 * kabs * beta / (128. * np.pi**5.)\n", + "\n", + " #right term in bracket\n", + "\n", + " prefactor2 = tf.pow(kabs,2) * (1. - 1./3. * beta)\n", + "\n", + " abs_bracket = tf.pow(tf.abs(c9eff(q, funcs) * formfactor(q2, \"+\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2) + ztf.to_complex(2.0 * C7eff * (mb + ms)/(mB + mK)) * formfactor(q2, \"T\", b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)),2)\n", + "\n", + " bracket_right = prefactor2 * abs_bracket\n", + "\n", + " #Note sqrt(q2) comes from derivation as we use q2 and plot q\n", + "\n", + " return prefactor1 * bracket_right * 2 * q\n", + "\n", + "def c9eff(q, funcs):\n", + "\n", + " C9eff_nr = ztf.to_complex(ztf.constant(pdg['C9eff']))\n", + "\n", + " c9 = C9eff_nr + funcs\n", + "\n", + " return c9" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def G(y):\n", + " \n", + " def inner_rect_bracket(q):\n", + " return tf.log(ztf.to_complex((1+tf.sqrt(q))/(1-tf.sqrt(q)))-tf.complex(ztf.constant(0), -1*ztf.constant(np.pi))) \n", + " \n", + " def inner_right(q):\n", + " return ztf.to_complex(2 * tf.atan(1/tf.sqrt(tf.math.real(-q))))\n", + " \n", + " big_bracket = tf.where(tf.math.real(y) > ztf.constant(0.0), inner_rect_bracket(y), inner_right(y))\n", + " \n", + " return ztf.to_complex(tf.sqrt(tf.abs(y))) * big_bracket\n", + "\n", + "def h_S(m, q):\n", + " \n", + " return ztf.to_complex(2) - G(ztf.to_complex(1) - ztf.to_complex(4*tf.pow(m, 2)) / ztf.to_complex(tf.pow(q, 2)))\n", + "\n", + "def h_P(m, q):\n", + " \n", + " return ztf.to_complex(2/3) + (ztf.to_complex(1) - ztf.to_complex(4*tf.pow(m, 2)) / ztf.to_complex(tf.pow(q, 2))) * h_S(m,q)\n", + "\n", + "def two_p_ccbar(mD, m_D_bar, m_D_star, q):\n", + " \n", + " \n", + " #Load constants\n", + " nu_D_bar = ztf.to_complex(pdg[\"nu_D_bar\"])\n", + " nu_D = ztf.to_complex(pdg[\"nu_D\"])\n", + " nu_D_star = ztf.to_complex(pdg[\"nu_D_star\"])\n", + " \n", + " phase_D_bar = ztf.to_complex(pdg[\"phase_D_bar\"])\n", + " phase_D = ztf.to_complex(pdg[\"phase_D\"])\n", + " phase_D_star = ztf.to_complex(pdg[\"phase_D_star\"])\n", + " \n", + " #Calculation\n", + " left_part = nu_D_bar * tf.exp(tf.complex(ztf.constant(0.0), phase_D_bar)) * h_S(m_D_bar, q) \n", + " \n", + " right_part_D = nu_D * tf.exp(tf.complex(ztf.constant(0.0), phase_D)) * h_P(m_D, q) \n", + " \n", + " right_part_D_star = nu_D_star * tf.exp(tf.complex(ztf.constant(0.0), phase_D_star)) * h_P(m_D_star, q) \n", + "\n", + " return left_part + right_part_D + right_part_D_star" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class total_pdf_cut(zfit.pdf.ZPDF):\n", + " _N_OBS = 1 # dimension, can be omitted\n", + " _PARAMS = ['b0_0', 'b0_1', 'b0_2', \n", + " 'bplus_0', 'bplus_1', 'bplus_2', \n", + " 'bT_0', 'bT_1', 'bT_2', \n", + " 'rho_mass', 'rho_scale', 'rho_phase', 'rho_width',\n", + " 'jpsi_mass', 'jpsi_scale', 'jpsi_phase', 'jpsi_width',\n", + " 'psi2s_mass', 'psi2s_scale', 'psi2s_phase', 'psi2s_width',\n", + " 'p3770_mass', 'p3770_scale', 'p3770_phase', 'p3770_width',\n", + " 'p4040_mass', 'p4040_scale', 'p4040_phase', 'p4040_width',\n", + " 'p4160_mass', 'p4160_scale', 'p4160_phase', 'p4160_width',\n", + " 'p4415_mass', 'p4415_scale', 'p4415_phase', 'p4415_width',\n", + " 'omega_mass', 'omega_scale', 'omega_phase', 'omega_width',\n", + " 'phi_mass', 'phi_scale', 'phi_phase', 'phi_width',\n", + " 'Dbar_mass', 'Dbar_scale', 'Dbar_phase',\n", + " 'Dstar_mass', 'DDstar_scale', 'DDstar_phase', 'D_mass',\n", + " 'tau_mass', 'C_tt']\n", + "# the name of the parameters\n", + "\n", + " def _unnormalized_pdf(self, x):\n", + " \n", + " x = x.unstack_x()\n", + " \n", + " b0 = [self.params['b0_0'], self.params['b0_1'], self.params['b0_2']]\n", + " bplus = [self.params['bplus_0'], self.params['bplus_1'], self.params['bplus_2']]\n", + " bT = [self.params['bT_0'], self.params['bT_1'], self.params['bT_2']]\n", + " \n", + " def rho_res(q):\n", + " return resonance(q, _mass = self.params['rho_mass'], scale = self.params['rho_scale'],\n", + " phase = self.params['rho_phase'], width = self.params['rho_width'])\n", + " \n", + " def omega_res(q):\n", + " return resonance(q, _mass = self.params['omega_mass'], scale = self.params['omega_scale'],\n", + " phase = self.params['omega_phase'], width = self.params['omega_width'])\n", + " \n", + " def phi_res(q):\n", + " return resonance(q, _mass = self.params['phi_mass'], scale = self.params['phi_scale'],\n", + " phase = self.params['phi_phase'], width = self.params['phi_width'])\n", + "\n", + " def jpsi_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['jpsi_mass'], 2)) * resonance(q, _mass = self.params['jpsi_mass'], \n", + " scale = self.params['jpsi_scale'],\n", + " phase = self.params['jpsi_phase'], \n", + " width = self.params['jpsi_width'])\n", + " def psi2s_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['psi2s_mass'], 2)) * resonance(q, _mass = self.params['psi2s_mass'], \n", + " scale = self.params['psi2s_scale'],\n", + " phase = self.params['psi2s_phase'], \n", + " width = self.params['psi2s_width'])\n", + " def p3770_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p3770_mass'], 2)) * resonance(q, _mass = self.params['p3770_mass'], \n", + " scale = self.params['p3770_scale'],\n", + " phase = self.params['p3770_phase'], \n", + " width = self.params['p3770_width'])\n", + " \n", + " def p4040_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4040_mass'], 2)) * resonance(q, _mass = self.params['p4040_mass'], \n", + " scale = self.params['p4040_scale'],\n", + " phase = self.params['p4040_phase'], \n", + " width = self.params['p4040_width'])\n", + " \n", + " def p4160_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4160_mass'], 2)) * resonance(q, _mass = self.params['p4160_mass'], \n", + " scale = self.params['p4160_scale'],\n", + " phase = self.params['p4160_phase'], \n", + " width = self.params['p4160_width'])\n", + " \n", + " def p4415_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4415_mass'], 2)) * resonance(q, _mass = self.params['p4415_mass'], \n", + " scale = self.params['p4415_scale'],\n", + " phase = self.params['p4415_phase'], \n", + " width = self.params['p4415_width'])\n", + " \n", + " def P2_D(q):\n", + " Dbar_contrib = ztf.to_complex(self.params['Dbar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['Dbar_phase']))*ztf.to_complex(h_S(self.params['Dbar_mass'], q))\n", + " DDstar_contrib = ztf.to_complex(self.params['DDstar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['DDstar_phase']))*(ztf.to_complex(h_P(self.params['Dstar_mass'], q)) + ztf.to_complex(h_P(self.params['D_mass'], q)))\n", + " return Dbar_contrib + DDstar_contrib\n", + " \n", + " def ttau_cusp(q):\n", + " return ztf.to_complex(self.params['C_tt'])*(ztf.to_complex((h_S(self.params['tau_mass'], q))) - ztf.to_complex(h_P(self.params['tau_mass'], q)))\n", + " \n", + "\n", + " funcs = rho_res(x) + omega_res(x) + phi_res(x) + jpsi_res(x) + psi2s_res(x) + p3770_res(x) + p4040_res(x)+ p4160_res(x) + p4415_res(x) + P2_D(x) + ttau_cusp(x)\n", + "\n", + " vec_f = vec(x, funcs, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n", + "\n", + " axiv_nr = axiv_nonres(x, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n", + "\n", + " tot = vec_f + axiv_nr\n", + " \n", + " #Cut out jpsi and psi2s\n", + " \n", + " tot = tf.where(tf.math.logical_or(x < ztf.constant(jpsi_mass-60.), x > ztf.constant(jpsi_mass+70.)), tot, 0.0*tot)\n", + " \n", + " tot = tf.where(tf.math.logical_or(x < ztf.constant(psi2s_mass-50.), x > ztf.constant(psi2s_mass+50.)), tot, 0.0*tot)\n", + " \n", + " return tot\n", + " \n", + "class total_pdf_full(zfit.pdf.ZPDF):\n", + " _N_OBS = 1 # dimension, can be omitted\n", + " _PARAMS = ['b0_0', 'b0_1', 'b0_2', \n", + " 'bplus_0', 'bplus_1', 'bplus_2', \n", + " 'bT_0', 'bT_1', 'bT_2', \n", + " 'rho_mass', 'rho_scale', 'rho_phase', 'rho_width',\n", + " 'jpsi_mass', 'jpsi_scale', 'jpsi_phase', 'jpsi_width',\n", + " 'psi2s_mass', 'psi2s_scale', 'psi2s_phase', 'psi2s_width',\n", + " 'p3770_mass', 'p3770_scale', 'p3770_phase', 'p3770_width',\n", + " 'p4040_mass', 'p4040_scale', 'p4040_phase', 'p4040_width',\n", + " 'p4160_mass', 'p4160_scale', 'p4160_phase', 'p4160_width',\n", + " 'p4415_mass', 'p4415_scale', 'p4415_phase', 'p4415_width',\n", + " 'omega_mass', 'omega_scale', 'omega_phase', 'omega_width',\n", + " 'phi_mass', 'phi_scale', 'phi_phase', 'phi_width',\n", + " 'Dbar_mass', 'Dbar_scale', 'Dbar_phase',\n", + " 'Dstar_mass', 'DDstar_scale', 'DDstar_phase', 'D_mass',\n", + " 'tau_mass', 'C_tt']\n", + "# the name of the parameters\n", + "\n", + " def _unnormalized_pdf(self, x):\n", + " \n", + " x = x.unstack_x()\n", + " \n", + " b0 = [self.params['b0_0'], self.params['b0_1'], self.params['b0_2']]\n", + " bplus = [self.params['bplus_0'], self.params['bplus_1'], self.params['bplus_2']]\n", + " bT = [self.params['bT_0'], self.params['bT_1'], self.params['bT_2']]\n", + " \n", + " def rho_res(q):\n", + " return resonance(q, _mass = self.params['rho_mass'], scale = self.params['rho_scale'],\n", + " phase = self.params['rho_phase'], width = self.params['rho_width'])\n", + " \n", + " def omega_res(q):\n", + " return resonance(q, _mass = self.params['omega_mass'], scale = self.params['omega_scale'],\n", + " phase = self.params['omega_phase'], width = self.params['omega_width'])\n", + " \n", + " def phi_res(q):\n", + " return resonance(q, _mass = self.params['phi_mass'], scale = self.params['phi_scale'],\n", + " phase = self.params['phi_phase'], width = self.params['phi_width'])\n", + "\n", + " def jpsi_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['jpsi_mass'], 2)) * resonance(q, _mass = self.params['jpsi_mass'], \n", + " scale = self.params['jpsi_scale'],\n", + " phase = self.params['jpsi_phase'], \n", + " width = self.params['jpsi_width'])\n", + " def psi2s_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['psi2s_mass'], 2)) * resonance(q, _mass = self.params['psi2s_mass'], \n", + " scale = self.params['psi2s_scale'],\n", + " phase = self.params['psi2s_phase'], \n", + " width = self.params['psi2s_width'])\n", + " def p3770_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p3770_mass'], 2)) * resonance(q, _mass = self.params['p3770_mass'], \n", + " scale = self.params['p3770_scale'],\n", + " phase = self.params['p3770_phase'], \n", + " width = self.params['p3770_width'])\n", + " \n", + " def p4040_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4040_mass'], 2)) * resonance(q, _mass = self.params['p4040_mass'], \n", + " scale = self.params['p4040_scale'],\n", + " phase = self.params['p4040_phase'], \n", + " width = self.params['p4040_width'])\n", + " \n", + " def p4160_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4160_mass'], 2)) * resonance(q, _mass = self.params['p4160_mass'], \n", + " scale = self.params['p4160_scale'],\n", + " phase = self.params['p4160_phase'], \n", + " width = self.params['p4160_width'])\n", + " \n", + " def p4415_res(q):\n", + " return ztf.to_complex(tf.pow(q, 2) / tf.pow(self.params['p4415_mass'], 2)) * resonance(q, _mass = self.params['p4415_mass'], \n", + " scale = self.params['p4415_scale'],\n", + " phase = self.params['p4415_phase'], \n", + " width = self.params['p4415_width'])\n", + " \n", + " def P2_D(q):\n", + " Dbar_contrib = ztf.to_complex(self.params['Dbar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['Dbar_phase']))*ztf.to_complex(h_S(self.params['Dbar_mass'], q))\n", + " DDstar_contrib = ztf.to_complex(self.params['DDstar_scale'])*tf.exp(tf.complex(ztf.constant(0.0), self.params['DDstar_phase']))*(ztf.to_complex(h_P(self.params['Dstar_mass'], q)) + ztf.to_complex(h_P(self.params['D_mass'], q)))\n", + " return Dbar_contrib + DDstar_contrib\n", + " \n", + " def ttau_cusp(q):\n", + " return ztf.to_complex(self.params['C_tt'])*(ztf.to_complex((h_S(self.params['tau_mass'], q))) - ztf.to_complex(h_P(self.params['tau_mass'], q)))\n", + " \n", + "\n", + " funcs = rho_res(x) + omega_res(x) + phi_res(x) + jpsi_res(x) + psi2s_res(x) + p3770_res(x) + p4040_res(x)+ p4160_res(x) + p4415_res(x) + P2_D(x) + ttau_cusp(x)\n", + "\n", + " vec_f = vec(x, funcs, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n", + "\n", + " axiv_nr = axiv_nonres(x, b0_0, b0_1, b0_2, bplus_0, bplus_1, bplus_2, bT_0, bT_1, bT_2)\n", + "\n", + " tot = vec_f + axiv_nr\n", + " \n", + " #Cut out jpsi and psi2s\n", + " \n", + "# tot = tf.where(tf.math.logical_or(x < ztf.constant(jpsi_mass-60.), x > ztf.constant(jpsi_mass+70.)), tot, 0.0*tot)\n", + " \n", + "# tot = tf.where(tf.math.logical_or(x < ztf.constant(psi2s_mass-50.), x > ztf.constant(psi2s_mass+50.)), tot, 0.0*tot)\n", + " \n", + " return tot" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From C:\\Users\\sa_li\\.conda\\envs\\rmd\\lib\\site-packages\\tensorflow\\python\\ops\\resource_variable_ops.py:435: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Colocations handled automatically by placer.\n" + ] + } + ], + "source": [ + "# formfactors\n", + "\n", + "b0_0 = zfit.Parameter(\"b0_0\", ztf.constant(0.292), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n", + "b0_1 = zfit.Parameter(\"b0_1\", ztf.constant(0.281), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n", + "b0_2 = zfit.Parameter(\"b0_2\", ztf.constant(0.150), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n", + "\n", + "bplus_0 = zfit.Parameter(\"bplus_0\", ztf.constant(0.466), lower_limit = -2.0, upper_limit= 2.0)\n", + "bplus_1 = zfit.Parameter(\"bplus_1\", ztf.constant(-0.885), lower_limit = -2.0, upper_limit= 2.0)\n", + "bplus_2 = zfit.Parameter(\"bplus_2\", ztf.constant(-0.213), lower_limit = -2.0, upper_limit= 2.0)\n", + "\n", + "bT_0 = zfit.Parameter(\"bT_0\", ztf.constant(0.460), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n", + "bT_1 = zfit.Parameter(\"bT_1\", ztf.constant(-1.089), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n", + "bT_2 = zfit.Parameter(\"bT_2\", ztf.constant(-1.114), floating = False) #, lower_limit = -2.0, upper_limit= 2.0)\n", + "\n", + "\n", + "#rho\n", + "\n", + "rho_mass, rho_width, rho_phase, rho_scale = pdg[\"rho\"]\n", + "\n", + "rho_m = zfit.Parameter(\"rho_m\", ztf.constant(rho_mass), floating = False) #lower_limit = rho_mass - rho_width, upper_limit = rho_mass + rho_width)\n", + "rho_w = zfit.Parameter(\"rho_w\", ztf.constant(rho_width), floating = False)\n", + "rho_p = zfit.Parameter(\"rho_p\", ztf.constant(rho_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "rho_s = zfit.Parameter(\"rho_s\", ztf.constant(rho_scale), lower_limit=rho_scale-np.sqrt(rho_scale), upper_limit=rho_scale+np.sqrt(rho_scale))\n", + "\n", + "#omega\n", + "\n", + "omega_mass, omega_width, omega_phase, omega_scale = pdg[\"omega\"]\n", + "\n", + "omega_m = zfit.Parameter(\"omega_m\", ztf.constant(omega_mass), floating = False)\n", + "omega_w = zfit.Parameter(\"omega_w\", ztf.constant(omega_width), floating = False)\n", + "omega_p = zfit.Parameter(\"omega_p\", ztf.constant(omega_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "omega_s = zfit.Parameter(\"omega_s\", ztf.constant(omega_scale), lower_limit=omega_scale-np.sqrt(omega_scale), upper_limit=omega_scale+np.sqrt(omega_scale))\n", + "\n", + "\n", + "#phi\n", + "\n", + "phi_mass, phi_width, phi_phase, phi_scale = pdg[\"phi\"]\n", + "\n", + "phi_m = zfit.Parameter(\"phi_m\", ztf.constant(phi_mass), floating = False)\n", + "phi_w = zfit.Parameter(\"phi_w\", ztf.constant(phi_width), floating = False)\n", + "phi_p = zfit.Parameter(\"phi_p\", ztf.constant(phi_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "phi_s = zfit.Parameter(\"phi_s\", ztf.constant(phi_scale), lower_limit=phi_scale-np.sqrt(phi_scale), upper_limit=phi_scale+np.sqrt(phi_scale))\n", + "\n", + "#jpsi\n", + "\n", + "jpsi_mass, jpsi_width, jpsi_phase, jpsi_scale = pdg[\"jpsi\"]\n", + "\n", + "jpsi_m = zfit.Parameter(\"jpsi_m\", ztf.constant(jpsi_mass), floating = False)\n", + "jpsi_w = zfit.Parameter(\"jpsi_w\", ztf.constant(jpsi_width), floating = False)\n", + "jpsi_p = zfit.Parameter(\"jpsi_p\", ztf.constant(jpsi_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "jpsi_s = zfit.Parameter(\"jpsi_s\", ztf.constant(jpsi_scale), floating = False) #, lower_limit=jpsi_scale-np.sqrt(jpsi_scale), upper_limit=jpsi_scale+np.sqrt(jpsi_scale))\n", + "\n", + "#psi2s\n", + "\n", + "psi2s_mass, psi2s_width, psi2s_phase, psi2s_scale = pdg[\"psi2s\"]\n", + "\n", + "psi2s_m = zfit.Parameter(\"psi2s_m\", ztf.constant(psi2s_mass), floating = False)\n", + "psi2s_w = zfit.Parameter(\"psi2s_w\", ztf.constant(psi2s_width), floating = False)\n", + "psi2s_p = zfit.Parameter(\"psi2s_p\", ztf.constant(psi2s_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "psi2s_s = zfit.Parameter(\"psi2s_s\", ztf.constant(psi2s_scale), floating = False) #, lower_limit=psi2s_scale-np.sqrt(psi2s_scale), upper_limit=psi2s_scale+np.sqrt(psi2s_scale))\n", + "\n", + "#psi(3770)\n", + "\n", + "p3770_mass, p3770_width, p3770_phase, p3770_scale = pdg[\"p3770\"]\n", + "\n", + "p3770_m = zfit.Parameter(\"p3770_m\", ztf.constant(p3770_mass), floating = False)\n", + "p3770_w = zfit.Parameter(\"p3770_w\", ztf.constant(p3770_width), floating = False)\n", + "p3770_p = zfit.Parameter(\"p3770_p\", ztf.constant(p3770_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "p3770_s = zfit.Parameter(\"p3770_s\", ztf.constant(p3770_scale), lower_limit=p3770_scale-np.sqrt(p3770_scale), upper_limit=p3770_scale+np.sqrt(p3770_scale))\n", + "\n", + "#psi(4040)\n", + "\n", + "p4040_mass, p4040_width, p4040_phase, p4040_scale = pdg[\"p4040\"]\n", + "\n", + "p4040_m = zfit.Parameter(\"p4040_m\", ztf.constant(p4040_mass), floating = False)\n", + "p4040_w = zfit.Parameter(\"p4040_w\", ztf.constant(p4040_width), floating = False)\n", + "p4040_p = zfit.Parameter(\"p4040_p\", ztf.constant(p4040_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "p4040_s = zfit.Parameter(\"p4040_s\", ztf.constant(p4040_scale), lower_limit=p4040_scale-np.sqrt(p4040_scale), upper_limit=p4040_scale+np.sqrt(p4040_scale))\n", + "\n", + "#psi(4160)\n", + "\n", + "p4160_mass, p4160_width, p4160_phase, p4160_scale = pdg[\"p4160\"]\n", + "\n", + "p4160_m = zfit.Parameter(\"p4160_m\", ztf.constant(p4160_mass), floating = False)\n", + "p4160_w = zfit.Parameter(\"p4160_w\", ztf.constant(p4160_width), floating = False)\n", + "p4160_p = zfit.Parameter(\"p4160_p\", ztf.constant(p4160_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "p4160_s = zfit.Parameter(\"p4160_s\", ztf.constant(p4160_scale), lower_limit=p4160_scale-np.sqrt(p4160_scale), upper_limit=p4160_scale+np.sqrt(p4160_scale))\n", + "\n", + "#psi(4415)\n", + "\n", + "p4415_mass, p4415_width, p4415_phase, p4415_scale = pdg[\"p4415\"]\n", + "\n", + "p4415_m = zfit.Parameter(\"p4415_m\", ztf.constant(p4415_mass), floating = False)\n", + "p4415_w = zfit.Parameter(\"p4415_w\", ztf.constant(p4415_width), floating = False)\n", + "p4415_p = zfit.Parameter(\"p4415_p\", ztf.constant(p4415_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)\n", + "p4415_s = zfit.Parameter(\"p4415_s\", ztf.constant(p4415_scale), lower_limit=p4415_scale-np.sqrt(p4415_scale), upper_limit=p4415_scale+np.sqrt(p4415_scale))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dynamic generation of 2 particle contribution" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "m_c = 1300\n", + "\n", + "Dbar_phase = 0.0\n", + "DDstar_phase = 0.0\n", + "Dstar_mass = pdg['Dst_M']\n", + "Dbar_mass = pdg['D0_M']\n", + "D_mass = pdg['D0_M']\n", + "\n", + "Dbar_s = zfit.Parameter(\"Dbar_s\", ztf.constant(0.0), lower_limit=-0.3, upper_limit=0.3)\n", + "Dbar_m = zfit.Parameter(\"Dbar_m\", ztf.constant(Dbar_mass), floating = False)\n", + "Dbar_p = zfit.Parameter(\"Dbar_p\", ztf.constant(Dbar_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)#, floating = False)\n", + "DDstar_s = zfit.Parameter(\"DDstar_s\", ztf.constant(0.0), lower_limit=-0.3, upper_limit=0.3)#, floating = False)\n", + "Dstar_m = zfit.Parameter(\"Dstar_m\", ztf.constant(Dstar_mass), floating = False)\n", + "D_m = zfit.Parameter(\"D_m\", ztf.constant(D_mass), floating = False)\n", + "DDstar_p = zfit.Parameter(\"DDstar_p\", ztf.constant(DDstar_phase), lower_limit=-2*np.pi, upper_limit=2*np.pi)#, floating = False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tau parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "tau_m = zfit.Parameter(\"tau_m\", ztf.constant(pdg['tau_M']), floating = False)\n", + "Ctt = zfit.Parameter(\"Ctt\", ztf.constant(0.0), lower_limit=-2.5, upper_limit=2.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load data" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "x_min = 2*pdg['muon_M']\n", + "x_max = (pdg[\"Bplus_M\"]-pdg[\"Ks_M\"]-0.1)\n", + "\n", + "# # Full spectrum\n", + "\n", + "obs_toy = zfit.Space('q', limits = (x_min, x_max))\n", + "\n", + "# Jpsi and Psi2s cut out\n", + "\n", + "obs1 = zfit.Space('q', limits = (x_min, jpsi_mass - 60.))\n", + "obs2 = zfit.Space('q', limits = (jpsi_mass + 70., psi2s_mass - 50.))\n", + "obs3 = zfit.Space('q', limits = (psi2s_mass + 50., x_max))\n", + "\n", + "obs_fit = obs1 + obs2 + obs3\n", + "\n", + "# with open(r\"./data/slim_points/slim_points_toy_0_range({0}-{1}).pkl\".format(int(x_min), int(x_max)), \"rb\") as input_file:\n", + "# part_set = pkl.load(input_file)\n", + "\n", + "# x_part = part_set['x_part']\n", + "\n", + "# x_part = x_part.astype('float64')\n", + "\n", + "# data = zfit.data.Data.from_numpy(array=x_part, obs=obs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup pdf" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "total_f = total_pdf_cut(obs=obs_toy, jpsi_mass = jpsi_m, jpsi_scale = jpsi_s, jpsi_phase = jpsi_p, jpsi_width = jpsi_w,\n", + " psi2s_mass = psi2s_m, psi2s_scale = psi2s_s, psi2s_phase = psi2s_p, psi2s_width = psi2s_w,\n", + " p3770_mass = p3770_m, p3770_scale = p3770_s, p3770_phase = p3770_p, p3770_width = p3770_w,\n", + " p4040_mass = p4040_m, p4040_scale = p4040_s, p4040_phase = p4040_p, p4040_width = p4040_w,\n", + " p4160_mass = p4160_m, p4160_scale = p4160_s, p4160_phase = p4160_p, p4160_width = p4160_w,\n", + " p4415_mass = p4415_m, p4415_scale = p4415_s, p4415_phase = p4415_p, p4415_width = p4415_w,\n", + " rho_mass = rho_m, rho_scale = rho_s, rho_phase = rho_p, rho_width = rho_w,\n", + " omega_mass = omega_m, omega_scale = omega_s, omega_phase = omega_p, omega_width = omega_w,\n", + " phi_mass = phi_m, phi_scale = phi_s, phi_phase = phi_p, phi_width = phi_w,\n", + " Dstar_mass = Dstar_m, DDstar_scale = DDstar_s, DDstar_phase = DDstar_p, D_mass = D_m,\n", + " Dbar_mass = Dbar_m, Dbar_scale = Dbar_s, Dbar_phase = Dbar_p,\n", + " tau_mass = tau_m, C_tt = Ctt, b0_0 = b0_0, b0_1 = b0_1, b0_2 = b0_2,\n", + " bplus_0 = bplus_0, bplus_1 = bplus_1, bplus_2 = bplus_2,\n", + " bT_0 = bT_0, bT_1 = bT_1, bT_2 = bT_2)\n", + "\n", + "total_f_fit = total_pdf_full(obs=obs_fit, jpsi_mass = jpsi_m, jpsi_scale = jpsi_s, jpsi_phase = jpsi_p, jpsi_width = jpsi_w,\n", + " psi2s_mass = psi2s_m, psi2s_scale = psi2s_s, psi2s_phase = psi2s_p, psi2s_width = psi2s_w,\n", + " p3770_mass = p3770_m, p3770_scale = p3770_s, p3770_phase = p3770_p, p3770_width = p3770_w,\n", + " p4040_mass = p4040_m, p4040_scale = p4040_s, p4040_phase = p4040_p, p4040_width = p4040_w,\n", + " p4160_mass = p4160_m, p4160_scale = p4160_s, p4160_phase = p4160_p, p4160_width = p4160_w,\n", + " p4415_mass = p4415_m, p4415_scale = p4415_s, p4415_phase = p4415_p, p4415_width = p4415_w,\n", + " rho_mass = rho_m, rho_scale = rho_s, rho_phase = rho_p, rho_width = rho_w,\n", + " omega_mass = omega_m, omega_scale = omega_s, omega_phase = omega_p, omega_width = omega_w,\n", + " phi_mass = phi_m, phi_scale = phi_s, phi_phase = phi_p, phi_width = phi_w,\n", + " Dstar_mass = Dstar_m, DDstar_scale = DDstar_s, DDstar_phase = DDstar_p, D_mass = D_m,\n", + " Dbar_mass = Dbar_m, Dbar_scale = Dbar_s, Dbar_phase = Dbar_p,\n", + " tau_mass = tau_m, C_tt = Ctt, b0_0 = b0_0, b0_1 = b0_1, b0_2 = b0_2,\n", + " bplus_0 = bplus_0, bplus_1 = bplus_1, bplus_2 = bplus_2,\n", + " bT_0 = bT_0, bT_1 = bT_1, bT_2 = bT_2)\n", + " \n", + "# print(total_pdf.obs)\n", + "\n", + "# print(calcs_test)\n", + "\n", + "# for param in total_f.get_dependents():\n", + "# print(zfit.run(param))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# total_f_fit.normalization(obs_fit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test if graphs actually work and compute values" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# def total_test_tf(xq):\n", + "\n", + "# def jpsi_res(q):\n", + "# return resonance(q, jpsi_m, jpsi_s, jpsi_p, jpsi_w)\n", + "\n", + "# def psi2s_res(q):\n", + "# return resonance(q, psi2s_m, psi2s_s, psi2s_p, psi2s_w)\n", + "\n", + "# def cusp(q):\n", + "# return bifur_gauss(q, cusp_m, sig_L, sig_R, cusp_s)\n", + "\n", + "# funcs = jpsi_res(xq) + psi2s_res(xq) + cusp(xq)\n", + "\n", + "# vec_f = vec(xq, funcs)\n", + "\n", + "# axiv_nr = axiv_nonres(xq)\n", + "\n", + "# tot = vec_f + axiv_nr\n", + " \n", + "# return tot\n", + "\n", + "# def jpsi_res(q):\n", + "# return resonance(q, jpsi_m, jpsi_s, jpsi_p, jpsi_w)\n", + "\n", + "# calcs = zfit.run(total_test_tf(x_part))\n", + "\n", + "\n", + "\n", + "test_q = np.linspace(x_min, x_max, int(2e6))\n", + "\n", + "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": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "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": 14, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# probs = mixture.prob(test_q)\n", + "# probs_np = zfit.run(probs)\n", + "# probs_np *= np.max(calcs_test) / np.max(probs_np)\n", + "# plt.figure()\n", + "# plt.semilogy(test_q, probs_np,label=\"importance sampling\")\n", + "# plt.semilogy(test_q, calcs_test, label = 'pdf')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# 0.213/(0.00133+0.213+0.015)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Adjust scaling of different parts" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "total_f.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n", + "# total_f_fit.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n", + "# inte = total_f.integrate(limits = (950., 1050.), norm_range=False)\n", + "# inte_fl = zfit.run(inte)\n", + "# print(inte_fl/4500)\n", + "# print(pdg[\"jpsi_BR\"]/pdg[\"NR_BR\"], inte_fl*pdg[\"psi2s_auc\"]/pdg[\"NR_auc\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# # print(\"jpsi:\", inte_fl)\n", + "# # print(\"Increase am by factor:\", np.sqrt(pdg[\"jpsi_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n", + "# # print(\"New amp:\", pdg[\"jpsi\"][3]*np.sqrt(pdg[\"jpsi_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n", + "\n", + "# # print(\"psi2s:\", inte_fl)\n", + "# # print(\"Increase am by factor:\", np.sqrt(pdg[\"psi2s_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n", + "# # print(\"New amp:\", pdg[\"psi2s\"][3]*np.sqrt(pdg[\"psi2s_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n", + "\n", + "# name = \"phi\"\n", + "\n", + "# print(name+\":\", inte_fl)\n", + "# print(\"Increase am by factor:\", np.sqrt(pdg[name+\"_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n", + "# print(\"New amp:\", pdg[name][0]*np.sqrt(pdg[name+\"_BR\"]/pdg[\"NR_BR\"]*pdg[\"NR_auc\"]/inte_fl))\n", + "\n", + "\n", + "# print(x_min)\n", + "# print(x_max)\n", + "# # total_f.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n", + "# total_f.update_integration_options(mc_sampler=lambda dim, num_results,\n", + "# dtype: tf.random_uniform(maxval=1., shape=(num_results, dim), dtype=dtype),\n", + "# draws_per_dim=1000000)\n", + "# # _ = []\n", + "\n", + "# # for i in range(10):\n", + "\n", + "# # inte = total_f.integrate(limits = (x_min, x_max))\n", + "# # inte_fl = zfit.run(inte)\n", + "# # print(inte_fl)\n", + "# # _.append(inte_fl)\n", + "\n", + "# # print(\"mean:\", np.mean(_))\n", + "\n", + "# _ = time.time()\n", + "\n", + "# inte = total_f.integrate(limits = (x_min, x_max))\n", + "# inte_fl = zfit.run(inte)\n", + "# print(inte_fl)\n", + "# print(\"Time taken: {}\".format(display_time(int(time.time() - _))))\n", + "\n", + "# print(pdg['NR_BR']/pdg['NR_auc']*inte_fl)\n", + "# print(0.25**2*4.2/1000)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sampling\n", + "## Mixture distribution for sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + " \n", + "# print(list_of_borders[:9])\n", + "# print(list_of_borders[-9:])\n", + "\n", + "\n", + "class UniformSampleAndWeights(zfit.util.execution.SessionHolderMixin):\n", + " def __call__(self, limits, dtype, n_to_produce):\n", + " # n_to_produce = tf.cast(n_to_produce, dtype=tf.int32)\n", + " low, high = limits.limit1d\n", + " low = tf.cast(low, dtype=dtype)\n", + " high = tf.cast(high, dtype=dtype)\n", + "# uniform = tfd.Uniform(low=low, high=high)\n", + "# uniformjpsi = tfd.Uniform(low=tf.constant(3080, dtype=dtype), high=tf.constant(3112, dtype=dtype))\n", + "# uniformpsi2s = tfd.Uniform(low=tf.constant(3670, dtype=dtype), high=tf.constant(3702, dtype=dtype))\n", + "\n", + "# list_of_borders = []\n", + "# _p = []\n", + "# splits = 10\n", + "\n", + "# _ = np.linspace(x_min, x_max, splits)\n", + "\n", + "# for i in range(splits):\n", + "# list_of_borders.append(tf.constant(_[i], dtype=dtype))\n", + "# _p.append(tf.constant(1/splits, dtype=dtype))\n", + " \n", + "# mixture = tfd.MixtureSameFamily(mixture_distribution=tfd.Categorical(probs=_p[:(splits-1)]),\n", + "# components_distribution=tfd.Uniform(low=list_of_borders[:(splits-1)], \n", + "# high=list_of_borders[-(splits-1):]))\n", + " mixture = tfd.MixtureSameFamily(mixture_distribution=tfd.Categorical(probs=[tf.constant(0.05, dtype=dtype),\n", + " tf.constant(0.93, dtype=dtype),\n", + " tf.constant(0.05, dtype=dtype),\n", + " tf.constant(0.065, dtype=dtype),\n", + " tf.constant(0.04, dtype=dtype),\n", + " tf.constant(0.05, dtype=dtype)]),\n", + " components_distribution=tfd.Uniform(low=[tf.constant(x_min, dtype=dtype), \n", + " tf.constant(3090, dtype=dtype),\n", + " tf.constant(3681, dtype=dtype), \n", + " tf.constant(3070, dtype=dtype),\n", + " tf.constant(1000, dtype=dtype),\n", + " tf.constant(3660, dtype=dtype)], \n", + " high=[tf.constant(x_max, dtype=dtype),\n", + " tf.constant(3102, dtype=dtype), \n", + " tf.constant(3691, dtype=dtype),\n", + " tf.constant(3110, dtype=dtype),\n", + " tf.constant(1040, dtype=dtype),\n", + " tf.constant(3710, dtype=dtype)]))\n", + "# dtype = tf.float64\n", + "# mixture = tfd.MixtureSameFamily(mixture_distribution=tfd.Categorical(probs=[tf.constant(0.04, dtype=dtype),\n", + "# tf.constant(0.90, dtype=dtype),\n", + "# tf.constant(0.02, dtype=dtype),\n", + "# tf.constant(0.07, dtype=dtype),\n", + "# tf.constant(0.02, dtype=dtype)]),\n", + "# components_distribution=tfd.Uniform(low=[tf.constant(x_min, dtype=dtype), \n", + "# tf.constant(3089, dtype=dtype),\n", + "# tf.constant(3103, dtype=dtype), \n", + "# tf.constant(3681, dtype=dtype),\n", + "# tf.constant(3691, dtype=dtype)], \n", + "# high=[tf.constant(3089, dtype=dtype),\n", + "# tf.constant(3103, dtype=dtype), \n", + "# tf.constant(3681, dtype=dtype),\n", + "# tf.constant(3691, dtype=dtype), \n", + "# tf.constant(x_max, dtype=dtype)]))\n", + "# mixture = tfd.Uniform(tf.constant(x_min, dtype=dtype), tf.constant(x_max, dtype=dtype))\n", + "# sample = tf.random.uniform((n_to_produce, 1), dtype=dtype)\n", + " sample = mixture.sample((n_to_produce, 1))\n", + "# sample = tf.random.uniform((n_to_produce, 1), dtype=dtype)\n", + " weights = mixture.prob(sample)[:,0]\n", + "# weights = tf.broadcast_to(tf.constant(1., dtype=dtype), shape=(n_to_produce,))\n", + " # sample = tf.expand_dims(sample, axis=-1)\n", + "# print(sample, weights)\n", + " \n", + "# weights = tf.ones(shape=(n_to_produce,), dtype=dtype)\n", + " weights_max = None\n", + " thresholds = tf.random_uniform(shape=(n_to_produce,), dtype=dtype)\n", + " return sample, thresholds, weights, weights_max, n_to_produce" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# total_f._sample_and_weights = UniformSampleAndWeights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Constraints" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# 1. Constraint - Real part of sum of Psi contrib and D contribs\n", + "\n", + "sum_list = []\n", + "\n", + "sum_list.append(ztf.to_complex(jpsi_s) * tf.exp(tf.complex(ztf.constant(0.0), jpsi_p)) * ztf.to_complex(jpsi_w / (tf.pow(jpsi_m,3))))\n", + "sum_list.append(ztf.to_complex(psi2s_s) * tf.exp(tf.complex(ztf.constant(0.0), psi2s_p)) * ztf.to_complex(psi2s_w / (tf.pow(psi2s_m,3))))\n", + "sum_list.append(ztf.to_complex(p3770_s) * tf.exp(tf.complex(ztf.constant(0.0), p3770_p)) * ztf.to_complex(p3770_w / (tf.pow(p3770_m,3))))\n", + "sum_list.append(ztf.to_complex(p4040_s) * tf.exp(tf.complex(ztf.constant(0.0), p4040_p)) * ztf.to_complex(p4040_w / (tf.pow(p4040_m,3))))\n", + "sum_list.append(ztf.to_complex(p4160_s) * tf.exp(tf.complex(ztf.constant(0.0), p4160_p)) * ztf.to_complex(p4160_w / (tf.pow(p4160_m,3))))\n", + "sum_list.append(ztf.to_complex(p4415_s) * tf.exp(tf.complex(ztf.constant(0.0), p4415_p)) * ztf.to_complex(p4415_w / (tf.pow(p4415_m,3))))\n", + "sum_list.append(ztf.to_complex(DDstar_s) * tf.exp(tf.complex(ztf.constant(0.0), DDstar_p)) * (ztf.to_complex(1.0 / (10.0*tf.pow(Dstar_m,2)) + 1.0 / (10.0*tf.pow(D_m,2)))))\n", + "sum_list.append(ztf.to_complex(Dbar_s) * tf.exp(tf.complex(ztf.constant(0.0), Dbar_p)) * ztf.to_complex(1.0 / (6.0*tf.pow(Dbar_m,2))))\n", + "\n", + "sum_ru_1 = ztf.to_complex(ztf.constant(0.0))\n", + "\n", + "for part in sum_list:\n", + " sum_ru_1 += part\n", + "\n", + "sum_1 = tf.math.real(sum_ru_1)\n", + "# constraint1 = zfit.constraint.GaussianConstraint(params = sum_1, mu = ztf.constant(1.7*10**-8), \n", + "# sigma = ztf.constant(2.2*10**-8))\n", + "\n", + "constraint1 = tf.pow((sum_1-ztf.constant(1.7*10**-8))/ztf.constant(2.2*10**-8),2)/ztf.constant(2.)\n", + "\n", + "# 2. Constraint - Abs. of sum of Psi contribs and D contribs\n", + "\n", + "sum_2 = tf.abs(sum_ru_1)\n", + "constraint2 = tf.cond(tf.greater_equal(sum_2, 5.0e-8), lambda: 100000., lambda: 0.)\n", + "\n", + "# 3. Constraint - Maximum eta of D contribs\n", + "\n", + "constraint3_0 = tf.cond(tf.greater_equal(tf.abs(Dbar_s), 0.2), lambda: 100000., lambda: 0.)\n", + "\n", + "constraint3_1 = tf.cond(tf.greater_equal(tf.abs(DDstar_s), 0.2), lambda: 100000., lambda: 0.)\n", + "\n", + "# 4. Constraint - Formfactor multivariant gaussian covariance fplus\n", + "\n", + "Cov_matrix = [[ztf.constant( 1.), ztf.constant( 0.45), ztf.constant( 0.19), ztf.constant(0.857), ztf.constant(0.598), ztf.constant(0.531), ztf.constant(0.752), ztf.constant(0.229), ztf.constant(0.117)],\n", + " [ztf.constant( 0.45), ztf.constant( 1.), ztf.constant(0.677), ztf.constant(0.708), ztf.constant(0.958), ztf.constant(0.927), ztf.constant(0.227), ztf.constant(0.443), ztf.constant(0.287)],\n", + " [ztf.constant( 0.19), ztf.constant(0.677), ztf.constant( 1.), ztf.constant(0.595), ztf.constant(0.770), ztf.constant(0.819),ztf.constant(-0.023), ztf.constant( 0.07), ztf.constant(0.196)],\n", + " [ztf.constant(0.857), ztf.constant(0.708), ztf.constant(0.595), ztf.constant( 1.), ztf.constant( 0.83), ztf.constant(0.766), ztf.constant(0.582), ztf.constant(0.237), ztf.constant(0.192)],\n", + " [ztf.constant(0.598), ztf.constant(0.958), ztf.constant(0.770), ztf.constant( 0.83), ztf.constant( 1.), ztf.constant(0.973), ztf.constant(0.324), ztf.constant(0.372), ztf.constant(0.272)],\n", + " [ztf.constant(0.531), ztf.constant(0.927), ztf.constant(0.819), ztf.constant(0.766), ztf.constant(0.973), ztf.constant( 1.), ztf.constant(0.268), ztf.constant(0.332), ztf.constant(0.269)],\n", + " [ztf.constant(0.752), ztf.constant(0.227),ztf.constant(-0.023), ztf.constant(0.582), ztf.constant(0.324), ztf.constant(0.268), ztf.constant( 1.), ztf.constant( 0.59), ztf.constant(0.515)],\n", + " [ztf.constant(0.229), ztf.constant(0.443), ztf.constant( 0.07), ztf.constant(0.237), ztf.constant(0.372), ztf.constant(0.332), ztf.constant( 0.59), ztf.constant( 1.), ztf.constant(0.897)],\n", + " [ztf.constant(0.117), ztf.constant(0.287), ztf.constant(0.196), ztf.constant(0.192), ztf.constant(0.272), ztf.constant(0.269), ztf.constant(0.515), ztf.constant(0.897), ztf.constant( 1.)]]\n", + "\n", + "def triGauss(val1,val2,val3,m = Cov_matrix):\n", + "\n", + " mean1 = ztf.constant(0.466)\n", + " mean2 = ztf.constant(-0.885)\n", + " mean3 = ztf.constant(-0.213)\n", + " sigma1 = ztf.constant(0.014/3.)\n", + " sigma2 = ztf.constant(0.128/3.)\n", + " sigma3 = ztf.constant(0.548/3.)\n", + " x1 = (val1-mean1)/sigma1\n", + " x2 = (val2-mean2)/sigma2\n", + " x3 = (val3-mean3)/sigma3\n", + " rho12 = m[0][1]\n", + " rho13 = m[0][2]\n", + " rho23 = m[1][2]\n", + " w = x1*x1*(rho23*rho23-1) + x2*x2*(rho13*rho13-1)+x3*x3*(rho12*rho12-1)+2*(x1*x2*(rho12-rho13*rho23)+x1*x3*(rho13-rho12*rho23)+x2*x3*(rho23-rho12*rho13))\n", + " d = 2*(rho12*rho12+rho13*rho13+rho23*rho23-2*rho12*rho13*rho23-1)\n", + " \n", + " fcn = -w/d\n", + " chisq = -2*fcn\n", + " return chisq\n", + "\n", + "constraint4 = triGauss(bplus_0, bplus_1, bplus_2)\n", + "\n", + "# mean1 = ztf.constant(0.466)\n", + "# mean2 = ztf.constant(-0.885)\n", + "# mean3 = ztf.constant(-0.213)\n", + "# sigma1 = ztf.constant(0.014)\n", + "# sigma2 = ztf.constant(0.128)\n", + "# sigma3 = ztf.constant(0.548)\n", + "# constraint4_0 = tf.pow((bplus_0-mean1)/sigma1,2)/ztf.constant(2.)\n", + "# constraint4_1 = tf.pow((bplus_1-mean2)/sigma2,2)/ztf.constant(2.)\n", + "# constraint4_2 = tf.pow((bplus_2-mean3)/sigma3,2)/ztf.constant(2.)\n", + "\n", + "# 5. Constraint - Abs. of sum of light contribs\n", + "\n", + "sum_list_5 = []\n", + "\n", + "sum_list_5.append(rho_s*rho_w/rho_m)\n", + "sum_list_5.append(omega_s*omega_w/omega_m)\n", + "sum_list_5.append(phi_s*phi_w/phi_m)\n", + "\n", + "\n", + "sum_ru_5 = ztf.constant(0.0)\n", + "\n", + "for part in sum_list_5:\n", + " sum_ru_5 += part\n", + "\n", + "constraint5 = tf.cond(tf.greater_equal(tf.abs(sum_ru_5), ztf.constant(0.02)), lambda: 100000., lambda: 0.)\n", + "\n", + "# 6. Constraint on phases of Jpsi and Psi2s for cut out fit\n", + "\n", + "\n", + "# constraint6_0 = zfit.constraint.GaussianConstraint(params = jpsi_p, mu = ztf.constant(pdg[\"jpsi_phase_unc\"]),\n", + "# sigma = ztf.constant(jpsi_phase))\n", + "# constraint6_1 = zfit.constraint.GaussianConstraint(params = psi2s_p, mu = ztf.constant(pdg[\"psi2s_phase_unc\"]),\n", + "# sigma = ztf.constant(psi2s_phase))\n", + "\n", + "constraint6_0 = tf.pow((jpsi_p-ztf.constant(jpsi_phase))/ztf.constant(pdg[\"jpsi_phase_unc\"]),2)/ztf.constant(2.)\n", + "constraint6_1 = tf.pow((psi2s_p-ztf.constant(psi2s_phase))/ztf.constant(pdg[\"psi2s_phase_unc\"]),2)/ztf.constant(2.)\n", + "\n", + "# 7. Constraint on Ctt with higher limits\n", + "\n", + "constraint7 = tf.cond(tf.greater_equal(Ctt*Ctt, 0.25), lambda: 100000., lambda: 0.)\n", + "\n", + "constraint7dtype = tf.float64\n", + "\n", + "# zfit.run(constraint6_0)\n", + "\n", + "# ztf.convert_to_tensor(constraint6_0)\n", + "\n", + "#List of all constraints\n", + "\n", + "constraints = [constraint1, constraint2, constraint3_0, constraint3_1, constraint4, #constraint4_0, constraint4_1, constraint4_2,\n", + " constraint6_0, constraint6_1]#, constraint7]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reset params" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "param_values_dic = {\n", + " 'jpsi_m': jpsi_mass,\n", + " 'jpsi_s': jpsi_scale,\n", + " 'jpsi_p': jpsi_phase,\n", + " 'jpsi_w': jpsi_width,\n", + " 'psi2s_m': psi2s_mass,\n", + " 'psi2s_s': psi2s_scale,\n", + " 'psi2s_p': psi2s_phase,\n", + " 'psi2s_w': psi2s_width,\n", + " 'p3770_m': p3770_mass,\n", + " 'p3770_s': p3770_scale,\n", + " 'p3770_p': p3770_phase,\n", + " 'p3770_w': p3770_width,\n", + " 'p4040_m': p4040_mass,\n", + " 'p4040_s': p4040_scale,\n", + " 'p4040_p': p4040_phase,\n", + " 'p4040_w': p4040_width,\n", + " 'p4160_m': p4160_mass,\n", + " 'p4160_s': p4160_scale,\n", + " 'p4160_p': p4160_phase,\n", + " 'p4160_w': p4160_width,\n", + " 'p4415_m': p4415_mass,\n", + " 'p4415_s': p4415_scale,\n", + " 'p4415_p': p4415_phase,\n", + " 'p4415_w': p4415_width,\n", + " 'rho_m': rho_mass,\n", + " 'rho_s': rho_scale,\n", + " 'rho_p': rho_phase,\n", + " 'rho_w': rho_width,\n", + " 'omega_m': omega_mass,\n", + " 'omega_s': omega_scale,\n", + " 'omega_p': omega_phase,\n", + " 'omega_w': omega_width,\n", + " 'phi_m': phi_mass,\n", + " 'phi_s': phi_scale,\n", + " 'phi_p': phi_phase,\n", + " 'phi_w': phi_width,\n", + " 'Dstar_m': Dstar_mass,\n", + " 'DDstar_s': 0.0,\n", + " 'DDstar_p': 0.0,\n", + " 'D_m': D_mass,\n", + " 'Dbar_m': Dbar_mass,\n", + " 'Dbar_s': 0.0,\n", + " 'Dbar_p': 0.0,\n", + " 'tau_m': pdg['tau_M'],\n", + " 'Ctt': 0.0,\n", + " 'b0_0': 0.292,\n", + " 'b0_1': 0.281,\n", + " 'b0_2': 0.150,\n", + " 'bplus_0': 0.466,\n", + " 'bplus_1': -0.885,\n", + " 'bplus_2': -0.213,\n", + " 'bT_0': 0.460,\n", + " 'bT_1': -1.089,\n", + " 'bT_2': -1.114}\n", + "\n", + "\n", + "def reset_param_values(variation = 0.05):\n", + " for param in total_f_fit.get_dependents():\n", + " if param.floating:\n", + " param.set_value(param_values_dic[param.name] + random.uniform(-1, 1) * param_values_dic[param.name]* variation)\n", + "# print(param.name)\n", + "# for param in totalf.get_dependents():\n", + "# param.set_value()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pull dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "# BR_steps = np.linspace(0.0, 1e-3, 11)\n", + "pull_dic = {}\n", + "\n", + "mi = 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": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "36668\n", + "5404696\n" + ] + } + ], + "source": [ + "# for param in total_f_fit.get_dependents():\n", + "# if param.floating:\n", + "# print(param.name)\n", + "\n", + "# print(params[Ctt])\n", + "\n", + "total_BR = 1.7e-10 + 4.9e-10 + 2.5e-9 + 6.02e-5 + 4.97e-6 + 1.38e-9 + 4.2e-10 + 2.6e-9 + 6.1e-10 + 4.37e-7\n", + "cut_BR = 1.0 - (6.02e-5 + 4.97e-6)/total_BR\n", + "\n", + "nevents = int(pdg[\"number_of_decays\"]*cut_BR)\n", + "\n", + "print(nevents)\n", + "print(int(pdg[\"number_of_decays\"]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CLS Code" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0.0003 0.0004 0.0005 0.0006]\n", + "[0. 0.26726124 0.3086067 0.34503278 0.37796447]\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", + "Step: 0/5\n", + "Current Ctt: 0.0\n", + "Ctt floating: True\n", + "Toy 0/1 - Fit 0/1\n", + "------------------------------------------------------------------\n", + "| FCN = 2.977E+05 | Ncalls=1078 (1078 total) |\n", + "| EDM = 0.013 (Goal: 5E-06) | up = 0.5 |\n", + "------------------------------------------------------------------\n", + "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", + "------------------------------------------------------------------\n", + "| False | True | True | False |\n", + "------------------------------------------------------------------\n", + "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", + "------------------------------------------------------------------\n", + "| False | True | False | False | True |\n", + "------------------------------------------------------------------\n", + "Function minimum: 297652.2218218978\n", + "----------------------------------------------------------------------------------------------\n", + "| | Name | Value | Hesse Err | Minos Err- | Minos Err+ | Limit- | Limit+ | Fixed |\n", + "----------------------------------------------------------------------------------------------\n", + "| 0 | phi_s | 20.2 | 0.7 | | | 14.8182 | 23.5818 | |\n", + "| 1 | rho_p | -0.39 | 0.19 | | |-6.28319 | 6.28319 | |\n", + "| 2 | rho_s | 1.59 | 0.24 | | |0.0253049| 2.0747 | |\n", + "| 3 | p4415_p | -2.37 | 0.18 | | |-6.28319 | 6.28319 | |\n", + "| 4 | psi2s_p | 2.08 | 0.04 | | |-6.28319 | 6.28319 | |\n", + "| 5 | Dbar_p | 0.13 | 0.85 | | |-6.28319 | 6.28319 | |\n", + "| 6 | omega_p | 0.16 | 0.21 | | |-6.28319 | 6.28319 | |\n", + "| 7 | DDstar_p | -2.6 | 7.0 | | |-6.28319 | 6.28319 | |\n", + "| 8 | jpsi_p | -1.506 | 0.022 | | |-6.28319 | 6.28319 | |\n", + "| 9 | p3770_s | 2.43 | 0.21 | | |0.918861 | 4.08114 | |\n", + "| 10| p4415_s | 1.50 | 0.19 | | |0.126447 | 2.35355 | |\n", + "| 11| bplus_1 | -0.889 | 0.026 | | | -2 | 2 | |\n", + "| 12| bplus_2 | -0.24 | 0.04 | | | -2 | 2 | |\n", + "| 13| p3770_p | -2.79 | 0.12 | | |-6.28319 | 6.28319 | |\n", + "| 14| bplus_0 | 0.478 | 0.013 | | | -2 | 2 | |\n", + "| 15| p4160_p | -2.19 | 0.07 | | |-6.28319 | 6.28319 | |\n", + "| 16| p4160_s | 2.26 | 0.20 | | | 0.71676 | 3.68324 | |\n", + "| 17| Dbar_s | 0.16 | 0.15 | | | -0.3 | 0.3 | |\n", + "| 18| omega_s | 6.1 | 0.9 | | | 4.19232 | 9.40768 | |\n", + "| 19| phi_p | 0.75 | 0.14 | | |-6.28319 | 6.28319 | |\n", + "| 20| Ctt | 0.09 | 0.16 | | | -2.5 | 2.5 | |\n", + "| 21| p4040_p | -2.88 | 0.14 | | |-6.28319 | 6.28319 | |\n", + "| 22| DDstar_s | 0.04 | 0.18 | | | -0.3 | 0.3 | |\n", + "| 23| p4040_s | 1.28 | 0.20 | | |0.00501244| 2.01499 | |\n", + "----------------------------------------------------------------------------------------------\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| | phi_s rho_p rho_s p4415_p psi2s_p Dbar_p omega_p DDstar_p jpsi_p p3770_s p4415_s bplus_1 bplus_2 p3770_p bplus_0 p4160_p p4160_s Dbar_s omega_s phi_p Ctt p4040_p DDstar_s p4040_s |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| phi_s | 1.000 -0.067 -0.002 -0.063 -0.056 0.057 0.005 0.072 0.003 -0.037 -0.043 0.059 -0.078 0.042 0.057 -0.023 -0.062 -0.067 -0.011 0.427 0.060 -0.055 -0.071 -0.058 |\n", + "| rho_p | -0.067 1.000 0.152 0.105 0.089 -0.085 -0.018 -0.117 -0.031 0.060 0.067 -0.089 0.171 -0.069 -0.088 0.038 0.102 0.109 0.199 -0.169 -0.091 0.088 0.115 0.094 |\n", + "| rho_s | -0.002 0.152 1.000 -0.187 -0.172 0.195 0.041 0.239 -0.052 -0.087 -0.144 0.225 -0.015 0.143 0.245 -0.050 -0.186 -0.218 -0.287 0.046 0.180 -0.150 -0.237 -0.182 |\n", + "| p4415_p | -0.063 0.105 -0.187 1.000 0.553 -0.599 0.050 -0.775 0.245 0.284 0.431 -0.722 0.040 -0.428 -0.712 0.267 0.562 0.700 0.075 -0.036 -0.562 0.511 0.748 0.544 |\n", + "| psi2s_p | -0.056 0.089 -0.172 0.553 1.000 -0.480 0.046 -0.719 0.254 0.148 0.444 -0.668 -0.062 -0.421 -0.661 0.153 0.537 0.638 0.070 -0.033 -0.479 0.415 0.695 0.561 |\n", + "| Dbar_p | 0.057 -0.085 0.195 -0.599 -0.480 1.000 -0.049 0.834 -0.024 -0.172 -0.526 0.780 0.002 0.649 0.772 -0.010 -0.649 -0.790 -0.077 0.040 0.646 -0.397 -0.784 -0.644 |\n", + "| omega_p | 0.005 -0.018 0.041 0.050 0.046 -0.049 1.000 -0.063 0.008 0.024 0.038 -0.057 0.014 -0.038 -0.059 0.014 0.049 0.057 0.390 -0.014 -0.049 0.040 0.062 0.048 |\n", + "| DDstar_p | 0.072 -0.117 0.239 -0.775 -0.719 0.834 -0.063 1.000 -0.286 -0.343 -0.624 0.935 0.016 0.601 0.924 -0.189 -0.781 -0.933 -0.097 0.044 0.746 -0.611 -0.960 -0.769 |\n", + "| jpsi_p | 0.003 -0.031 -0.052 0.245 0.254 -0.024 0.008 -0.286 1.000 0.172 0.152 -0.273 -0.026 -0.071 -0.276 0.161 0.200 0.281 0.015 -0.007 -0.112 0.225 0.239 0.207 |\n", + "| p3770_s | -0.037 0.060 -0.087 0.284 0.148 -0.172 0.024 -0.343 0.172 1.000 0.218 -0.313 -0.020 -0.316 -0.307 0.097 0.281 0.264 0.034 -0.017 -0.290 0.229 0.326 0.322 |\n", + "| p4415_s | -0.043 0.067 -0.144 0.431 0.444 -0.526 0.038 -0.624 0.152 0.218 1.000 -0.552 -0.085 -0.405 -0.546 0.136 0.585 0.591 0.058 -0.026 -0.378 0.411 0.619 0.509 |\n", + "| bplus_1 | 0.059 -0.089 0.225 -0.722 -0.668 0.780 -0.057 0.935 -0.273 -0.313 -0.552 1.000 -0.039 0.571 0.823 -0.184 -0.714 -0.849 -0.089 0.037 0.687 -0.567 -0.926 -0.704 |\n", + "| bplus_2 | -0.078 0.171 -0.015 0.040 -0.062 0.002 0.014 0.016 -0.026 -0.020 -0.085 -0.039 1.000 0.005 -0.040 0.050 0.010 0.034 0.010 -0.025 0.276 0.008 -0.017 -0.020 |\n", + "| p3770_p | 0.042 -0.069 0.143 -0.428 -0.421 0.649 -0.038 0.601 -0.071 -0.316 -0.405 0.571 0.005 1.000 0.566 0.026 -0.479 -0.559 -0.059 0.029 0.395 -0.269 -0.600 -0.480 |\n", + "| bplus_0 | 0.057 -0.088 0.245 -0.712 -0.661 0.772 -0.059 0.924 -0.276 -0.307 -0.546 0.823 -0.040 0.566 1.000 -0.179 -0.703 -0.839 -0.094 0.038 0.681 -0.558 -0.915 -0.695 |\n", + "| p4160_p | -0.023 0.038 -0.050 0.267 0.153 -0.010 0.014 -0.189 0.161 0.097 0.136 -0.184 0.050 0.026 -0.179 1.000 0.077 0.129 0.019 -0.009 -0.242 0.131 0.148 -0.050 |\n", + "| p4160_s | -0.062 0.102 -0.186 0.562 0.537 -0.649 0.049 -0.781 0.200 0.281 0.585 -0.714 0.010 -0.479 -0.703 0.077 1.000 0.720 0.075 -0.036 -0.503 0.584 0.767 0.552 |\n", + "| Dbar_s | -0.067 0.109 -0.218 0.700 0.638 -0.790 0.057 -0.933 0.281 0.264 0.591 -0.849 0.034 -0.559 -0.839 0.129 0.720 1.000 0.088 -0.040 -0.743 0.521 0.916 0.723 |\n", + "| omega_s | -0.011 0.199 -0.287 0.075 0.070 -0.077 0.390 -0.097 0.015 0.034 0.058 -0.089 0.010 -0.059 -0.094 0.019 0.075 0.088 1.000 -0.072 -0.074 0.060 0.096 0.074 |\n", + "| phi_p | 0.427 -0.169 0.046 -0.036 -0.033 0.040 -0.014 0.044 -0.007 -0.017 -0.026 0.037 -0.025 0.029 0.038 -0.009 -0.036 -0.040 -0.072 1.000 0.038 -0.029 -0.045 -0.034 |\n", + "| Ctt | 0.060 -0.091 0.180 -0.562 -0.479 0.646 -0.049 0.746 -0.112 -0.290 -0.378 0.687 0.276 0.395 0.681 -0.242 -0.503 -0.743 -0.074 0.038 1.000 -0.483 -0.732 -0.482 |\n", + "| p4040_p | -0.055 0.088 -0.150 0.511 0.415 -0.397 0.040 -0.611 0.225 0.229 0.411 -0.567 0.008 -0.269 -0.558 0.131 0.584 0.521 0.060 -0.029 -0.483 1.000 0.581 0.401 |\n", + "| DDstar_s | -0.071 0.115 -0.237 0.748 0.695 -0.784 0.062 -0.960 0.239 0.326 0.619 -0.926 -0.017 -0.600 -0.915 0.148 0.767 0.916 0.096 -0.045 -0.732 0.581 1.000 0.753 |\n", + "| p4040_s | -0.058 0.094 -0.182 0.544 0.561 -0.644 0.048 -0.769 0.207 0.322 0.509 -0.704 -0.020 -0.480 -0.695 -0.050 0.552 0.723 0.074 -0.034 -0.482 0.401 0.753 1.000 |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "Hesse errors: OrderedDict([(, {'error': 0.7471080388438764}), (, {'error': 0.18514176261667714}), (, {'error': 0.24325558408812809}), (, {'error': 0.17951439955418258}), (, {'error': 0.036277261386909565}), (, {'error': 0.8521601760503357}), (, {'error': 0.20697201816491884}), (, {'error': 6.981778412516394}), (, {'error': 0.022270745277642945}), (, {'error': 0.20792441648302717}), (, {'error': 0.18559764903708653}), (, {'error': 0.02634389474470422}), (, {'error': 0.04215911524062499}), (, {'error': 0.12126027556157148}), (, {'error': 0.01325866696713196}), (, {'error': 0.07358429037598313}), (, {'error': 0.20004363541048886}), (, {'error': 0.14726695003307771}), (, {'error': 0.8574758160021965}), (, {'error': 0.1386560878188816}), (, {'error': 0.15908203934676957}), (, {'error': 0.13998911285038518}), (, {'error': 0.17548878917420122}), (, {'error': 0.19920259043511457})])\n", + "Step: 0/5\n", + "Current Ctt: 0.0\n", + "Ctt floating: True\n", + "Toy 0/1 - Fit 0/1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------------------------------------\n", + "| FCN = 2.977E+05 | Ncalls=1119 (1119 total) |\n", + "| EDM = 0.000952 (Goal: 5E-06) | up = 0.5 |\n", + "------------------------------------------------------------------\n", + "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", + "------------------------------------------------------------------\n", + "| True | True | False | False |\n", + "------------------------------------------------------------------\n", + "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", + "------------------------------------------------------------------\n", + "| False | True | True | True | False |\n", + "------------------------------------------------------------------\n", + "Function minimum: 297676.8602903808\n", + "----------------------------------------------------------------------------------------------\n", + "| | Name | Value | Hesse Err | Minos Err- | Minos Err+ | Limit- | Limit+ | Fixed |\n", + "----------------------------------------------------------------------------------------------\n", + "| 0 | phi_s | 20.6 | 0.9 | | | 14.8182 | 23.5818 | |\n", + "| 1 | rho_p | -0.3 | 0.7 | | |-6.28319 | 6.28319 | |\n", + "| 2 | rho_s | 0.5 | 0.3 | | |0.0253049| 2.0747 | |\n", + "| 3 | p4415_p | -2.5 | 0.3 | | |-6.28319 | 6.28319 | |\n", + "| 4 | psi2s_p | 2.08 | 0.05 | | |-6.28319 | 6.28319 | |\n", + "| 5 | Dbar_p | -0.9 | 0.5 | | |-6.28319 | 6.28319 | |\n", + "| 6 | omega_p | 0.5 | 0.5 | | |-6.28319 | 6.28319 | |\n", + "| 7 | DDstar_p | 2.1 | 1.7 | | |-6.28319 | 6.28319 | |\n", + "| 8 | jpsi_p | -1.46 | 0.08 | | |-6.28319 | 6.28319 | |\n", + "| 9 | p3770_s | 2.7 | 0.3 | | |0.918861 | 4.08114 | |\n", + "| 10| p4415_s | 1.06 | 0.19 | | |0.126447 | 2.35355 | |\n", + "| 11| bplus_1 | -0.879 | 0.022 | | | -2 | 2 | |\n", + "| 12| bplus_2 | -0.17 | 0.07 | | | -2 | 2 | |\n", + "| 13| p3770_p | -2.78 | 0.18 | | |-6.28319 | 6.28319 | |\n", + "| 14| bplus_0 | 0.452 | 0.011 | | | -2 | 2 | |\n", + "| 15| p4160_p | -2.13 | 0.26 | | |-6.28319 | 6.28319 | |\n", + "| 16| p4160_s | 2.00 | 0.17 | | | 0.71676 | 3.68324 | |\n", + "| 17| Dbar_s | -0.30 | 0.46 | | | -0.3 | 0.3 | |\n", + "| 18| omega_s | 6.5 | 2.1 | | | 4.19232 | 9.40768 | |\n", + "| 19| phi_p | 0.75 | 0.17 | | |-6.28319 | 6.28319 | |\n", + "| 20| Ctt | 0.31 | 0.20 | | | -2.5 | 2.5 | |\n", + "| 21| p4040_p | -2.67 | 0.28 | | |-6.28319 | 6.28319 | |\n", + "| 22| DDstar_s | -0.15 | 0.34 | | | -0.3 | 0.3 | |\n", + "| 23| p4040_s | 1.31 | 0.17 | | |0.00501244| 2.01499 | |\n", + "----------------------------------------------------------------------------------------------\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| | phi_s rho_p rho_s p4415_p psi2s_p Dbar_p omega_p DDstar_p jpsi_p p3770_s p4415_s bplus_1 bplus_2 p3770_p bplus_0 p4160_p p4160_s Dbar_s omega_s phi_p Ctt p4040_p DDstar_s p4040_s |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| phi_s | 1.000 -0.153 -0.029 -0.022 -0.005 0.021 -0.014 -0.001 0.005 -0.017 0.010 -0.010 -0.129 -0.010 -0.016 -0.012 -0.026 -0.001 -0.033 0.529 -0.020 -0.017 -0.006 -0.010 |\n", + "| rho_p | -0.153 1.000 -0.006 0.062 0.025 -0.021 0.089 0.018 0.001 0.040 -0.034 0.059 0.273 0.025 -0.049 0.043 0.051 0.016 0.243 -0.306 0.055 0.048 0.039 0.015 |\n", + "| rho_s | -0.029 -0.006 1.000 -0.002 0.007 -0.047 -0.088 0.046 0.027 0.004 0.032 -0.038 -0.046 0.037 0.213 0.005 0.006 0.014 -0.314 0.093 -0.013 0.006 0.002 0.008 |\n", + "| p4415_p | -0.022 0.062 -0.002 1.000 0.616 0.342 0.026 0.737 0.757 0.549 -0.278 0.035 0.084 0.612 0.072 0.806 0.085 0.541 0.024 0.023 -0.144 0.746 0.818 -0.185 |\n", + "| psi2s_p | -0.005 0.025 0.007 0.616 1.000 0.258 0.017 0.695 0.734 0.396 -0.154 0.073 -0.040 0.577 0.080 0.698 0.092 0.453 0.011 0.032 -0.111 0.642 0.778 -0.055 |\n", + "| Dbar_p | 0.021 -0.021 -0.047 0.342 0.258 1.000 0.014 0.492 0.205 0.318 -0.159 -0.142 -0.017 -0.003 -0.094 0.336 0.134 0.393 0.019 0.015 0.218 0.341 0.395 -0.027 |\n", + "| omega_p | -0.014 0.089 -0.088 0.026 0.017 0.014 1.000 0.011 0.006 0.018 -0.017 0.023 0.051 0.009 -0.052 0.023 0.009 0.011 0.884 -0.136 0.003 0.023 0.026 -0.002 |\n", + "| DDstar_p | -0.001 0.018 0.046 0.737 0.695 0.492 0.011 1.000 0.856 0.628 -0.220 0.206 -0.070 0.693 0.179 0.858 0.123 0.679 -0.004 0.048 -0.153 0.814 0.909 -0.139 |\n", + "| jpsi_p | 0.005 0.001 0.027 0.757 0.734 0.205 0.006 0.856 1.000 0.625 -0.211 0.110 0.007 0.749 0.107 0.865 0.129 0.577 -0.007 0.051 -0.188 0.819 0.923 -0.115 |\n", + "| p3770_s | -0.017 0.040 0.004 0.549 0.396 0.318 0.018 0.628 0.625 1.000 -0.138 0.070 -0.055 0.357 0.090 0.610 0.131 0.394 0.015 0.021 -0.206 0.584 0.670 0.013 |\n", + "| p4415_s | 0.010 -0.034 0.032 -0.278 -0.154 -0.159 -0.017 -0.220 -0.211 -0.138 1.000 0.116 -0.140 -0.196 0.066 -0.239 0.277 -0.151 -0.024 0.002 0.181 -0.178 -0.225 0.191 |\n", + "| bplus_1 | -0.010 0.059 -0.038 0.035 0.073 -0.142 0.023 0.206 0.110 0.070 0.116 1.000 -0.271 0.170 -0.511 0.073 0.022 0.078 0.035 -0.018 -0.160 0.078 0.067 0.013 |\n", + "| bplus_2 | -0.129 0.273 -0.046 0.084 -0.040 -0.017 0.051 -0.070 0.007 -0.055 -0.140 -0.271 1.000 -0.069 -0.167 -0.007 0.110 -0.010 0.078 -0.085 0.594 -0.010 -0.000 0.066 |\n", + "| p3770_p | -0.010 0.025 0.037 0.612 0.577 -0.003 0.009 0.693 0.749 0.357 -0.196 0.170 -0.069 1.000 0.166 0.740 0.051 0.392 -0.002 0.037 -0.363 0.703 0.724 -0.181 |\n", + "| bplus_0 | -0.016 -0.049 0.213 0.072 0.080 -0.094 -0.052 0.179 0.107 0.090 0.066 -0.511 -0.167 0.166 1.000 0.099 0.037 0.081 -0.096 0.034 -0.124 0.103 0.095 0.007 |\n", + "| p4160_p | -0.012 0.043 0.005 0.806 0.698 0.336 0.023 0.858 0.865 0.610 -0.239 0.073 -0.007 0.740 0.099 1.000 0.076 0.594 0.018 0.035 -0.314 0.825 0.913 -0.302 |\n", + "| p4160_s | -0.026 0.051 0.006 0.085 0.092 0.134 0.009 0.123 0.129 0.131 0.277 0.022 0.110 0.051 0.037 0.076 1.000 0.122 0.010 -0.007 0.235 0.283 0.175 -0.018 |\n", + "| Dbar_s | -0.001 0.016 0.014 0.541 0.453 0.393 0.011 0.679 0.577 0.394 -0.151 0.078 -0.010 0.392 0.081 0.594 0.122 1.000 0.005 0.030 -0.195 0.553 0.732 -0.046 |\n", + "| omega_s | -0.033 0.243 -0.314 0.024 0.011 0.019 0.884 -0.004 -0.007 0.015 -0.024 0.035 0.078 -0.002 -0.096 0.018 0.010 0.005 1.000 -0.201 0.010 0.018 0.021 -0.002 |\n", + "| phi_p | 0.529 -0.306 0.093 0.023 0.032 0.015 -0.136 0.048 0.051 0.021 0.002 -0.018 -0.085 0.037 0.034 0.035 -0.007 0.030 -0.201 1.000 -0.021 0.031 0.041 -0.009 |\n", + "| Ctt | -0.020 0.055 -0.013 -0.144 -0.111 0.218 0.003 -0.153 -0.188 -0.206 0.181 -0.160 0.594 -0.363 -0.124 -0.314 0.235 -0.195 0.010 -0.021 1.000 -0.263 -0.217 0.342 |\n", + "| p4040_p | -0.017 0.048 0.006 0.746 0.642 0.341 0.023 0.814 0.819 0.584 -0.178 0.078 -0.010 0.703 0.103 0.825 0.283 0.553 0.018 0.031 -0.263 1.000 0.877 -0.210 |\n", + "| DDstar_s | -0.006 0.039 0.002 0.818 0.778 0.395 0.026 0.909 0.923 0.670 -0.225 0.067 -0.000 0.724 0.095 0.913 0.175 0.732 0.021 0.041 -0.217 0.877 1.000 -0.105 |\n", + "| p4040_s | -0.010 0.015 0.008 -0.185 -0.055 -0.027 -0.002 -0.139 -0.115 0.013 0.191 0.013 0.066 -0.181 0.007 -0.302 -0.018 -0.046 -0.002 -0.009 0.342 -0.210 -0.105 1.000 |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "Hesse errors: OrderedDict([(, {'error': 0.9142957081972742}), (, {'error': 0.6936535176060628}), (, {'error': 0.31992987771310377}), (, {'error': 0.3242479743998188}), (, {'error': 0.04877084961929512}), (, {'error': 0.4693624571295927}), (, {'error': 0.5448127134133323}), (, {'error': 1.6782936194122264}), (, {'error': 0.076502815887741}), (, {'error': 0.3269991972653048}), (, {'error': 0.19331473430113788}), (, {'error': 0.022453161599432336}), (, {'error': 0.07164712471903711}), (, {'error': 0.18127978100197017}), (, {'error': 0.010823487498148543}), (, {'error': 0.26287545614952745}), (, {'error': 0.16605504500407542}), (, {'error': 0.4621450517273268}), (, {'error': 2.074388629496891}), (, {'error': 0.16789257624839893}), (, {'error': 0.2011430528044098}), (, {'error': 0.28336427935455255}), (, {'error': 0.3358643253844139}), (, {'error': 0.1701201938999789})])\n", + "\n", + "Time taken: 3 min, 37 s\n", + "Estimated time left: 18 min, 5 s\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# zfit.run.numeric_checks = False \n", + "\n", + "load = False\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", + "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", + "newset = True\n", + "\n", + "#-----------------------------------------------------\n", + "\n", + "if not load:\n", + " for Ctt_step in Ctt_steps:\n", + "\n", + " if not newset:\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 not newset:\n", + " break\n", + " \n", + " newset = True\n", + " \n", + " while newset:\n", + " \n", + " for floaty in [True, False]:\n", + " Ctt.floating = floaty\n", + " \n", + " if 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", + " 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": null, + "metadata": {}, + "outputs": [], + "source": [ + "if load:\n", + " \n", + " phase_combi = '-+'\n", + " \n", + " if D_contribs:\n", + " D_dir = 'D-True'\n", + " else:\n", + " D_dir = 'D-False'\n", + "\n", + " _dir = 'data/CLs/finished/f3d41/{}/{}/'.format(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": null, + "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": null, + "metadata": {}, + "outputs": [], + "source": [ + "# print(variab['mi'] != mi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "l = []\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", + " plt.clf()\n", + " plt.title('Branching ratio: {:.1E}'.format(BR_steps[step]))\n", + " plt.hist(CLs_values[0], bins = 40, range = (-5, 15), label = 'Ctt = 0', alpha = 0.8)\n", + " plt.hist(CLs_values[step], bins = 40, range = (-5, 15), label = 'Ctt = {:.2f}'.format(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-BR({:.1E}).png'.format(BR_steps[step]))\n", + " \n", + " l.append(len(np.where(np.array(CLs_values[step]) < np.mean(CLs_values[0]))[0])) \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 {} - Ctt value {:.2f} - floating {}'.format(key, 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/{}/{:.2f}Ctt{}s{}f.png'.format(key, Ctt_steps[int(step/2)], step, floaty))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "for s in range(len(l)):\n", + " print('BR: {:.4f}'.format(BR_steps[s+1]))\n", + " print(l[s]/len(np.where(np.array(CLs_values[0]) < np.mean(CLs_values[0]))[0]))\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", + "# # plt.title('Pull {} - Ctt value {:.2f} - floating {}'.format(key, Ctt_steps[int(step/2)], floaty))\n", + "# plt.hist(CLs_values[0], bins = 150, range = (-25, 50), label = 'Ctt fixed to 0')\n", + "# plt.axvline(x=np.mean(CLs_values[0]),color='red', linewidth=1.0, linestyle = 'dotted')\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# for step in range(2*ste):\n", + "# for key in pull_dic.keys():\n", + "# print(pull_dic[key][step])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# for param in total_f_fit.get_dependents():\n", + "# if param.floating:\n", + "# print(params[param]['value'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(display_time(int(time.time()-start)))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "probs = total_f_fit.pdf(test_q, norm_range=False)\n", + "\n", + "calcs_test = zfit.run(probs)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.clf()\n", + "plt.plot(test_q, calcs_test)\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": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "45702000\n", + "0 22\n", + "1 22\n", + "2 22\n", + "3 22\n", + "4 22\n", + "5 22\n", + "6 22\n", + "7 22\n", + "8 22\n", + "9 22\n", + "10 22\n", + "11 22\n", + "12 22\n", + "13 22\n", + "14 22\n", + "15 22\n", + "16 22\n", + "17 22\n", + "18 22\n", + "19 22\n", + "20 22\n", + "21 22\n", + "Full integration finished in 4 min, 19 s\n", + "1051146\n" + ] + } + ], + "source": [ + "# total_f_fit.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n", + "\n", + "start = time.time()\n", + "\n", + "_max_size = 2000000\n", + "\n", + "step_size = 1000\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(l/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-1)*_max_size:], norm_range=False)\n", + "\n", + "inte_fl = zfit.run(_c)\n", + "\n", + "for i in range(int(l/step_size)):\n", + " _list.append(np.mean(steps[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": 39, + "metadata": {}, + "outputs": [], + "source": [ + "dirName = 'data/CLs'\n", + "with open(\"{}/inte_100keV_steps.pkl\".format(dirName), \"wb\") as f:\n", + " pkl.dump(_list, f, pkl.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "45701.99999999999" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(x_max-x_min)/0.1" + ] + }, + { + "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 +} diff --git a/__pycache__/helperfunctions.cpython-37.pyc b/__pycache__/helperfunctions.cpython-37.pyc new file mode 100644 index 0000000..becd44c --- /dev/null +++ b/__pycache__/helperfunctions.cpython-37.pyc Binary files differ diff --git a/__pycache__/pdg_const1.cpython-37.pyc b/__pycache__/pdg_const1.cpython-37.pyc new file mode 100644 index 0000000..e486534 --- /dev/null +++ b/__pycache__/pdg_const1.cpython-37.pyc Binary files differ diff --git a/data/CLs/inte_100keV_steps.pkl b/data/CLs/inte_100keV_steps.pkl new file mode 100644 index 0000000..97f6fac --- /dev/null +++ b/data/CLs/inte_100keV_steps.pkl Binary files differ diff --git a/data/CLs/plots/set_histo0.png b/data/CLs/plots/set_histo0.png index 58c9664..4439662 100644 --- a/data/CLs/plots/set_histo0.png +++ b/data/CLs/plots/set_histo0.png Binary files differ diff --git a/raremodel-nb.ipynb b/raremodel-nb.ipynb index ce4f8f3..18ea8a8 100644 --- a/raremodel-nb.ipynb +++ b/raremodel-nb.ipynb @@ -876,7 +876,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -902,7 +902,7 @@ "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.ylim(0.0, 1.5e-6)\n", "plt.xlabel(r'$q^2 [MeV^2]$')\n", "# plt.yscale('log')\n", "# plt.xlim(770, 785)\n", @@ -949,6 +949,7 @@ "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", @@ -1155,7 +1156,7 @@ "\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", + "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", @@ -1237,7 +1238,7 @@ "\n", "#List of all constraints\n", "\n", - "constraints = [constraint1, constraint2, constraint3_0, constraint3_1,# constraint4, #constraint4_0, constraint4_1, constraint4_2,\n", + "constraints = [constraint1, constraint2, constraint3_0, constraint3_1, constraint4, #constraint4_0, constraint4_1, constraint4_2,\n", " constraint6_0, constraint6_1]#, constraint7]" ] }, @@ -1417,14 +1418,183 @@ "[0. 0.26726124 0.3086067 0.34503278 0.37796447]\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" + "Use tf.cast instead.\n", + "Step: 0/5\n", + "Current Ctt: 0.0\n", + "Ctt floating: True\n", + "Toy 0/1 - Fit 0/1\n", + "------------------------------------------------------------------\n", + "| FCN = 2.977E+05 | Ncalls=1078 (1078 total) |\n", + "| EDM = 0.013 (Goal: 5E-06) | up = 0.5 |\n", + "------------------------------------------------------------------\n", + "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", + "------------------------------------------------------------------\n", + "| False | True | True | False |\n", + "------------------------------------------------------------------\n", + "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", + "------------------------------------------------------------------\n", + "| False | True | False | False | True |\n", + "------------------------------------------------------------------\n", + "Function minimum: 297652.2218218978\n", + "----------------------------------------------------------------------------------------------\n", + "| | Name | Value | Hesse Err | Minos Err- | Minos Err+ | Limit- | Limit+ | Fixed |\n", + "----------------------------------------------------------------------------------------------\n", + "| 0 | phi_s | 20.2 | 0.7 | | | 14.8182 | 23.5818 | |\n", + "| 1 | rho_p | -0.39 | 0.19 | | |-6.28319 | 6.28319 | |\n", + "| 2 | rho_s | 1.59 | 0.24 | | |0.0253049| 2.0747 | |\n", + "| 3 | p4415_p | -2.37 | 0.18 | | |-6.28319 | 6.28319 | |\n", + "| 4 | psi2s_p | 2.08 | 0.04 | | |-6.28319 | 6.28319 | |\n", + "| 5 | Dbar_p | 0.13 | 0.85 | | |-6.28319 | 6.28319 | |\n", + "| 6 | omega_p | 0.16 | 0.21 | | |-6.28319 | 6.28319 | |\n", + "| 7 | DDstar_p | -2.6 | 7.0 | | |-6.28319 | 6.28319 | |\n", + "| 8 | jpsi_p | -1.506 | 0.022 | | |-6.28319 | 6.28319 | |\n", + "| 9 | p3770_s | 2.43 | 0.21 | | |0.918861 | 4.08114 | |\n", + "| 10| p4415_s | 1.50 | 0.19 | | |0.126447 | 2.35355 | |\n", + "| 11| bplus_1 | -0.889 | 0.026 | | | -2 | 2 | |\n", + "| 12| bplus_2 | -0.24 | 0.04 | | | -2 | 2 | |\n", + "| 13| p3770_p | -2.79 | 0.12 | | |-6.28319 | 6.28319 | |\n", + "| 14| bplus_0 | 0.478 | 0.013 | | | -2 | 2 | |\n", + "| 15| p4160_p | -2.19 | 0.07 | | |-6.28319 | 6.28319 | |\n", + "| 16| p4160_s | 2.26 | 0.20 | | | 0.71676 | 3.68324 | |\n", + "| 17| Dbar_s | 0.16 | 0.15 | | | -0.3 | 0.3 | |\n", + "| 18| omega_s | 6.1 | 0.9 | | | 4.19232 | 9.40768 | |\n", + "| 19| phi_p | 0.75 | 0.14 | | |-6.28319 | 6.28319 | |\n", + "| 20| Ctt | 0.09 | 0.16 | | | -2.5 | 2.5 | |\n", + "| 21| p4040_p | -2.88 | 0.14 | | |-6.28319 | 6.28319 | |\n", + "| 22| DDstar_s | 0.04 | 0.18 | | | -0.3 | 0.3 | |\n", + "| 23| p4040_s | 1.28 | 0.20 | | |0.00501244| 2.01499 | |\n", + "----------------------------------------------------------------------------------------------\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| | phi_s rho_p rho_s p4415_p psi2s_p Dbar_p omega_p DDstar_p jpsi_p p3770_s p4415_s bplus_1 bplus_2 p3770_p bplus_0 p4160_p p4160_s Dbar_s omega_s phi_p Ctt p4040_p DDstar_s p4040_s |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| phi_s | 1.000 -0.067 -0.002 -0.063 -0.056 0.057 0.005 0.072 0.003 -0.037 -0.043 0.059 -0.078 0.042 0.057 -0.023 -0.062 -0.067 -0.011 0.427 0.060 -0.055 -0.071 -0.058 |\n", + "| rho_p | -0.067 1.000 0.152 0.105 0.089 -0.085 -0.018 -0.117 -0.031 0.060 0.067 -0.089 0.171 -0.069 -0.088 0.038 0.102 0.109 0.199 -0.169 -0.091 0.088 0.115 0.094 |\n", + "| rho_s | -0.002 0.152 1.000 -0.187 -0.172 0.195 0.041 0.239 -0.052 -0.087 -0.144 0.225 -0.015 0.143 0.245 -0.050 -0.186 -0.218 -0.287 0.046 0.180 -0.150 -0.237 -0.182 |\n", + "| p4415_p | -0.063 0.105 -0.187 1.000 0.553 -0.599 0.050 -0.775 0.245 0.284 0.431 -0.722 0.040 -0.428 -0.712 0.267 0.562 0.700 0.075 -0.036 -0.562 0.511 0.748 0.544 |\n", + "| psi2s_p | -0.056 0.089 -0.172 0.553 1.000 -0.480 0.046 -0.719 0.254 0.148 0.444 -0.668 -0.062 -0.421 -0.661 0.153 0.537 0.638 0.070 -0.033 -0.479 0.415 0.695 0.561 |\n", + "| Dbar_p | 0.057 -0.085 0.195 -0.599 -0.480 1.000 -0.049 0.834 -0.024 -0.172 -0.526 0.780 0.002 0.649 0.772 -0.010 -0.649 -0.790 -0.077 0.040 0.646 -0.397 -0.784 -0.644 |\n", + "| omega_p | 0.005 -0.018 0.041 0.050 0.046 -0.049 1.000 -0.063 0.008 0.024 0.038 -0.057 0.014 -0.038 -0.059 0.014 0.049 0.057 0.390 -0.014 -0.049 0.040 0.062 0.048 |\n", + "| DDstar_p | 0.072 -0.117 0.239 -0.775 -0.719 0.834 -0.063 1.000 -0.286 -0.343 -0.624 0.935 0.016 0.601 0.924 -0.189 -0.781 -0.933 -0.097 0.044 0.746 -0.611 -0.960 -0.769 |\n", + "| jpsi_p | 0.003 -0.031 -0.052 0.245 0.254 -0.024 0.008 -0.286 1.000 0.172 0.152 -0.273 -0.026 -0.071 -0.276 0.161 0.200 0.281 0.015 -0.007 -0.112 0.225 0.239 0.207 |\n", + "| p3770_s | -0.037 0.060 -0.087 0.284 0.148 -0.172 0.024 -0.343 0.172 1.000 0.218 -0.313 -0.020 -0.316 -0.307 0.097 0.281 0.264 0.034 -0.017 -0.290 0.229 0.326 0.322 |\n", + "| p4415_s | -0.043 0.067 -0.144 0.431 0.444 -0.526 0.038 -0.624 0.152 0.218 1.000 -0.552 -0.085 -0.405 -0.546 0.136 0.585 0.591 0.058 -0.026 -0.378 0.411 0.619 0.509 |\n", + "| bplus_1 | 0.059 -0.089 0.225 -0.722 -0.668 0.780 -0.057 0.935 -0.273 -0.313 -0.552 1.000 -0.039 0.571 0.823 -0.184 -0.714 -0.849 -0.089 0.037 0.687 -0.567 -0.926 -0.704 |\n", + "| bplus_2 | -0.078 0.171 -0.015 0.040 -0.062 0.002 0.014 0.016 -0.026 -0.020 -0.085 -0.039 1.000 0.005 -0.040 0.050 0.010 0.034 0.010 -0.025 0.276 0.008 -0.017 -0.020 |\n", + "| p3770_p | 0.042 -0.069 0.143 -0.428 -0.421 0.649 -0.038 0.601 -0.071 -0.316 -0.405 0.571 0.005 1.000 0.566 0.026 -0.479 -0.559 -0.059 0.029 0.395 -0.269 -0.600 -0.480 |\n", + "| bplus_0 | 0.057 -0.088 0.245 -0.712 -0.661 0.772 -0.059 0.924 -0.276 -0.307 -0.546 0.823 -0.040 0.566 1.000 -0.179 -0.703 -0.839 -0.094 0.038 0.681 -0.558 -0.915 -0.695 |\n", + "| p4160_p | -0.023 0.038 -0.050 0.267 0.153 -0.010 0.014 -0.189 0.161 0.097 0.136 -0.184 0.050 0.026 -0.179 1.000 0.077 0.129 0.019 -0.009 -0.242 0.131 0.148 -0.050 |\n", + "| p4160_s | -0.062 0.102 -0.186 0.562 0.537 -0.649 0.049 -0.781 0.200 0.281 0.585 -0.714 0.010 -0.479 -0.703 0.077 1.000 0.720 0.075 -0.036 -0.503 0.584 0.767 0.552 |\n", + "| Dbar_s | -0.067 0.109 -0.218 0.700 0.638 -0.790 0.057 -0.933 0.281 0.264 0.591 -0.849 0.034 -0.559 -0.839 0.129 0.720 1.000 0.088 -0.040 -0.743 0.521 0.916 0.723 |\n", + "| omega_s | -0.011 0.199 -0.287 0.075 0.070 -0.077 0.390 -0.097 0.015 0.034 0.058 -0.089 0.010 -0.059 -0.094 0.019 0.075 0.088 1.000 -0.072 -0.074 0.060 0.096 0.074 |\n", + "| phi_p | 0.427 -0.169 0.046 -0.036 -0.033 0.040 -0.014 0.044 -0.007 -0.017 -0.026 0.037 -0.025 0.029 0.038 -0.009 -0.036 -0.040 -0.072 1.000 0.038 -0.029 -0.045 -0.034 |\n", + "| Ctt | 0.060 -0.091 0.180 -0.562 -0.479 0.646 -0.049 0.746 -0.112 -0.290 -0.378 0.687 0.276 0.395 0.681 -0.242 -0.503 -0.743 -0.074 0.038 1.000 -0.483 -0.732 -0.482 |\n", + "| p4040_p | -0.055 0.088 -0.150 0.511 0.415 -0.397 0.040 -0.611 0.225 0.229 0.411 -0.567 0.008 -0.269 -0.558 0.131 0.584 0.521 0.060 -0.029 -0.483 1.000 0.581 0.401 |\n", + "| DDstar_s | -0.071 0.115 -0.237 0.748 0.695 -0.784 0.062 -0.960 0.239 0.326 0.619 -0.926 -0.017 -0.600 -0.915 0.148 0.767 0.916 0.096 -0.045 -0.732 0.581 1.000 0.753 |\n", + "| p4040_s | -0.058 0.094 -0.182 0.544 0.561 -0.644 0.048 -0.769 0.207 0.322 0.509 -0.704 -0.020 -0.480 -0.695 -0.050 0.552 0.723 0.074 -0.034 -0.482 0.401 0.753 1.000 |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "Hesse errors: OrderedDict([(, {'error': 0.7471080388438764}), (, {'error': 0.18514176261667714}), (, {'error': 0.24325558408812809}), (, {'error': 0.17951439955418258}), (, {'error': 0.036277261386909565}), (, {'error': 0.8521601760503357}), (, {'error': 0.20697201816491884}), (, {'error': 6.981778412516394}), (, {'error': 0.022270745277642945}), (, {'error': 0.20792441648302717}), (, {'error': 0.18559764903708653}), (, {'error': 0.02634389474470422}), (, {'error': 0.04215911524062499}), (, {'error': 0.12126027556157148}), (, {'error': 0.01325866696713196}), (, {'error': 0.07358429037598313}), (, {'error': 0.20004363541048886}), (, {'error': 0.14726695003307771}), (, {'error': 0.8574758160021965}), (, {'error': 0.1386560878188816}), (, {'error': 0.15908203934676957}), (, {'error': 0.13998911285038518}), (, {'error': 0.17548878917420122}), (, {'error': 0.19920259043511457})])\n", + "Step: 0/5\n", + "Current Ctt: 0.0\n", + "Ctt floating: True\n", + "Toy 0/1 - Fit 0/1\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------------------------------------\n", + "| FCN = 2.977E+05 | Ncalls=1119 (1119 total) |\n", + "| EDM = 0.000952 (Goal: 5E-06) | up = 0.5 |\n", + "------------------------------------------------------------------\n", + "| Valid Min. | Valid Param. | Above EDM | Reached call limit |\n", + "------------------------------------------------------------------\n", + "| True | True | False | False |\n", + "------------------------------------------------------------------\n", + "| Hesse failed | Has cov. | Accurate | Pos. def. | Forced |\n", + "------------------------------------------------------------------\n", + "| False | True | True | True | False |\n", + "------------------------------------------------------------------\n", + "Function minimum: 297676.8602903808\n", + "----------------------------------------------------------------------------------------------\n", + "| | Name | Value | Hesse Err | Minos Err- | Minos Err+ | Limit- | Limit+ | Fixed |\n", + "----------------------------------------------------------------------------------------------\n", + "| 0 | phi_s | 20.6 | 0.9 | | | 14.8182 | 23.5818 | |\n", + "| 1 | rho_p | -0.3 | 0.7 | | |-6.28319 | 6.28319 | |\n", + "| 2 | rho_s | 0.5 | 0.3 | | |0.0253049| 2.0747 | |\n", + "| 3 | p4415_p | -2.5 | 0.3 | | |-6.28319 | 6.28319 | |\n", + "| 4 | psi2s_p | 2.08 | 0.05 | | |-6.28319 | 6.28319 | |\n", + "| 5 | Dbar_p | -0.9 | 0.5 | | |-6.28319 | 6.28319 | |\n", + "| 6 | omega_p | 0.5 | 0.5 | | |-6.28319 | 6.28319 | |\n", + "| 7 | DDstar_p | 2.1 | 1.7 | | |-6.28319 | 6.28319 | |\n", + "| 8 | jpsi_p | -1.46 | 0.08 | | |-6.28319 | 6.28319 | |\n", + "| 9 | p3770_s | 2.7 | 0.3 | | |0.918861 | 4.08114 | |\n", + "| 10| p4415_s | 1.06 | 0.19 | | |0.126447 | 2.35355 | |\n", + "| 11| bplus_1 | -0.879 | 0.022 | | | -2 | 2 | |\n", + "| 12| bplus_2 | -0.17 | 0.07 | | | -2 | 2 | |\n", + "| 13| p3770_p | -2.78 | 0.18 | | |-6.28319 | 6.28319 | |\n", + "| 14| bplus_0 | 0.452 | 0.011 | | | -2 | 2 | |\n", + "| 15| p4160_p | -2.13 | 0.26 | | |-6.28319 | 6.28319 | |\n", + "| 16| p4160_s | 2.00 | 0.17 | | | 0.71676 | 3.68324 | |\n", + "| 17| Dbar_s | -0.30 | 0.46 | | | -0.3 | 0.3 | |\n", + "| 18| omega_s | 6.5 | 2.1 | | | 4.19232 | 9.40768 | |\n", + "| 19| phi_p | 0.75 | 0.17 | | |-6.28319 | 6.28319 | |\n", + "| 20| Ctt | 0.31 | 0.20 | | | -2.5 | 2.5 | |\n", + "| 21| p4040_p | -2.67 | 0.28 | | |-6.28319 | 6.28319 | |\n", + "| 22| DDstar_s | -0.15 | 0.34 | | | -0.3 | 0.3 | |\n", + "| 23| p4040_s | 1.31 | 0.17 | | |0.00501244| 2.01499 | |\n", + "----------------------------------------------------------------------------------------------\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| | phi_s rho_p rho_s p4415_p psi2s_p Dbar_p omega_p DDstar_p jpsi_p p3770_s p4415_s bplus_1 bplus_2 p3770_p bplus_0 p4160_p p4160_s Dbar_s omega_s phi_p Ctt p4040_p DDstar_s p4040_s |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "| phi_s | 1.000 -0.153 -0.029 -0.022 -0.005 0.021 -0.014 -0.001 0.005 -0.017 0.010 -0.010 -0.129 -0.010 -0.016 -0.012 -0.026 -0.001 -0.033 0.529 -0.020 -0.017 -0.006 -0.010 |\n", + "| rho_p | -0.153 1.000 -0.006 0.062 0.025 -0.021 0.089 0.018 0.001 0.040 -0.034 0.059 0.273 0.025 -0.049 0.043 0.051 0.016 0.243 -0.306 0.055 0.048 0.039 0.015 |\n", + "| rho_s | -0.029 -0.006 1.000 -0.002 0.007 -0.047 -0.088 0.046 0.027 0.004 0.032 -0.038 -0.046 0.037 0.213 0.005 0.006 0.014 -0.314 0.093 -0.013 0.006 0.002 0.008 |\n", + "| p4415_p | -0.022 0.062 -0.002 1.000 0.616 0.342 0.026 0.737 0.757 0.549 -0.278 0.035 0.084 0.612 0.072 0.806 0.085 0.541 0.024 0.023 -0.144 0.746 0.818 -0.185 |\n", + "| psi2s_p | -0.005 0.025 0.007 0.616 1.000 0.258 0.017 0.695 0.734 0.396 -0.154 0.073 -0.040 0.577 0.080 0.698 0.092 0.453 0.011 0.032 -0.111 0.642 0.778 -0.055 |\n", + "| Dbar_p | 0.021 -0.021 -0.047 0.342 0.258 1.000 0.014 0.492 0.205 0.318 -0.159 -0.142 -0.017 -0.003 -0.094 0.336 0.134 0.393 0.019 0.015 0.218 0.341 0.395 -0.027 |\n", + "| omega_p | -0.014 0.089 -0.088 0.026 0.017 0.014 1.000 0.011 0.006 0.018 -0.017 0.023 0.051 0.009 -0.052 0.023 0.009 0.011 0.884 -0.136 0.003 0.023 0.026 -0.002 |\n", + "| DDstar_p | -0.001 0.018 0.046 0.737 0.695 0.492 0.011 1.000 0.856 0.628 -0.220 0.206 -0.070 0.693 0.179 0.858 0.123 0.679 -0.004 0.048 -0.153 0.814 0.909 -0.139 |\n", + "| jpsi_p | 0.005 0.001 0.027 0.757 0.734 0.205 0.006 0.856 1.000 0.625 -0.211 0.110 0.007 0.749 0.107 0.865 0.129 0.577 -0.007 0.051 -0.188 0.819 0.923 -0.115 |\n", + "| p3770_s | -0.017 0.040 0.004 0.549 0.396 0.318 0.018 0.628 0.625 1.000 -0.138 0.070 -0.055 0.357 0.090 0.610 0.131 0.394 0.015 0.021 -0.206 0.584 0.670 0.013 |\n", + "| p4415_s | 0.010 -0.034 0.032 -0.278 -0.154 -0.159 -0.017 -0.220 -0.211 -0.138 1.000 0.116 -0.140 -0.196 0.066 -0.239 0.277 -0.151 -0.024 0.002 0.181 -0.178 -0.225 0.191 |\n", + "| bplus_1 | -0.010 0.059 -0.038 0.035 0.073 -0.142 0.023 0.206 0.110 0.070 0.116 1.000 -0.271 0.170 -0.511 0.073 0.022 0.078 0.035 -0.018 -0.160 0.078 0.067 0.013 |\n", + "| bplus_2 | -0.129 0.273 -0.046 0.084 -0.040 -0.017 0.051 -0.070 0.007 -0.055 -0.140 -0.271 1.000 -0.069 -0.167 -0.007 0.110 -0.010 0.078 -0.085 0.594 -0.010 -0.000 0.066 |\n", + "| p3770_p | -0.010 0.025 0.037 0.612 0.577 -0.003 0.009 0.693 0.749 0.357 -0.196 0.170 -0.069 1.000 0.166 0.740 0.051 0.392 -0.002 0.037 -0.363 0.703 0.724 -0.181 |\n", + "| bplus_0 | -0.016 -0.049 0.213 0.072 0.080 -0.094 -0.052 0.179 0.107 0.090 0.066 -0.511 -0.167 0.166 1.000 0.099 0.037 0.081 -0.096 0.034 -0.124 0.103 0.095 0.007 |\n", + "| p4160_p | -0.012 0.043 0.005 0.806 0.698 0.336 0.023 0.858 0.865 0.610 -0.239 0.073 -0.007 0.740 0.099 1.000 0.076 0.594 0.018 0.035 -0.314 0.825 0.913 -0.302 |\n", + "| p4160_s | -0.026 0.051 0.006 0.085 0.092 0.134 0.009 0.123 0.129 0.131 0.277 0.022 0.110 0.051 0.037 0.076 1.000 0.122 0.010 -0.007 0.235 0.283 0.175 -0.018 |\n", + "| Dbar_s | -0.001 0.016 0.014 0.541 0.453 0.393 0.011 0.679 0.577 0.394 -0.151 0.078 -0.010 0.392 0.081 0.594 0.122 1.000 0.005 0.030 -0.195 0.553 0.732 -0.046 |\n", + "| omega_s | -0.033 0.243 -0.314 0.024 0.011 0.019 0.884 -0.004 -0.007 0.015 -0.024 0.035 0.078 -0.002 -0.096 0.018 0.010 0.005 1.000 -0.201 0.010 0.018 0.021 -0.002 |\n", + "| phi_p | 0.529 -0.306 0.093 0.023 0.032 0.015 -0.136 0.048 0.051 0.021 0.002 -0.018 -0.085 0.037 0.034 0.035 -0.007 0.030 -0.201 1.000 -0.021 0.031 0.041 -0.009 |\n", + "| Ctt | -0.020 0.055 -0.013 -0.144 -0.111 0.218 0.003 -0.153 -0.188 -0.206 0.181 -0.160 0.594 -0.363 -0.124 -0.314 0.235 -0.195 0.010 -0.021 1.000 -0.263 -0.217 0.342 |\n", + "| p4040_p | -0.017 0.048 0.006 0.746 0.642 0.341 0.023 0.814 0.819 0.584 -0.178 0.078 -0.010 0.703 0.103 0.825 0.283 0.553 0.018 0.031 -0.263 1.000 0.877 -0.210 |\n", + "| DDstar_s | -0.006 0.039 0.002 0.818 0.778 0.395 0.026 0.909 0.923 0.670 -0.225 0.067 -0.000 0.724 0.095 0.913 0.175 0.732 0.021 0.041 -0.217 0.877 1.000 -0.105 |\n", + "| p4040_s | -0.010 0.015 0.008 -0.185 -0.055 -0.027 -0.002 -0.139 -0.115 0.013 0.191 0.013 0.066 -0.181 0.007 -0.302 -0.018 -0.046 -0.002 -0.009 0.342 -0.210 -0.105 1.000 |\n", + "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n", + "Hesse errors: OrderedDict([(, {'error': 0.9142957081972742}), (, {'error': 0.6936535176060628}), (, {'error': 0.31992987771310377}), (, {'error': 0.3242479743998188}), (, {'error': 0.04877084961929512}), (, {'error': 0.4693624571295927}), (, {'error': 0.5448127134133323}), (, {'error': 1.6782936194122264}), (, {'error': 0.076502815887741}), (, {'error': 0.3269991972653048}), (, {'error': 0.19331473430113788}), (, {'error': 0.022453161599432336}), (, {'error': 0.07164712471903711}), (, {'error': 0.18127978100197017}), (, {'error': 0.010823487498148543}), (, {'error': 0.26287545614952745}), (, {'error': 0.16605504500407542}), (, {'error': 0.4621450517273268}), (, {'error': 2.074388629496891}), (, {'error': 0.16789257624839893}), (, {'error': 0.2011430528044098}), (, {'error': 0.28336427935455255}), (, {'error': 0.3358643253844139}), (, {'error': 0.1701201938999789})])\n", + "\n", + "Time taken: 3 min, 37 s\n", + "Estimated time left: 18 min, 5 s\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAEICAYAAAC9E5gJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAYU0lEQVR4nO3dfZBldX3n8fcngBAFwwANxQLaYCEbTOnoThFTRlfFB5CUYGKyQyxlE3ZnXaXWp6rNGHaN2SpThI0aLY3UGCmxFEQFVirgwxSLca31IQ3CMOygDASXkclMi4oYXBLwu3/c03Jpbnff7vvQ9+H9qrp1z/2d3zn3d37d9/c559yHk6pCkjTdfmm9GyBJWn+GgSTJMJAkGQaSJAwDSRKGgSQJw0AiybuTfHK92yGtJ8NA6yLJ7yeZS/LTJHuTfCHJbzbznjA4J/lKkn+3Pq3tnySnJ7kjyUNJbkzy9GXqzjZ1HmqWedmi+W9L8g9JHkhyaZKDB78FmlSGgYYuyduBvwT+DDgGeBrwV8DZ69muQUtyFHA18F+BI4A54MplFrkC+DZwJHAh8LkkM826XglsBU4HZoGTgD8dVNs1BarKm7eh3YBfAX4K/O4S888A/gn456bercB7gEeB/9eUfajDcl8ELlhUdivw2830B4B7gZ8ANwEvbKv3buCTzfSLgT2L1nMP8LJm+pdoDcJ3AfcDnwGO6HLbtwD/u+3xU4CfAf+yQ91nAg8Dh7WV/S/gjc305cCftc07HfiH9f77ehvfm0cGGrbfAA4Bruk0s6q+SOuI4cqqOrSqnlNVF9IaCC9oyi7osOjlwLkLD5KcCjwduK4p+jtgI6098suBzyY5ZA3t/0/AOcC/Bv4F8CPgw23PuyPJ7y+x7LNoBdTCtv4jrVB51hJ1766qB9vKbm2r+7h1NdPHJDlyVVsjNQwDDduRwA+q6pE+r/caYGPbOfjXAVdX1cMAVfXJqrq/qh6pqvcCBwOnrOF5/gNwYVXtadb9buC1SQ5snufZVXX5EsseCjywqOwB4LA11F08f2G607qkFRkGGrb7gaMWBs9+afagrwM2N0WbgU8tzE/yjiS7mjdbf0zrdNVRa3iqpwPXJPlxs55dtE5hHdPFsj8Fnrqo7KnAg2uou3j+wnSndUkrMgw0bF+nde7/nGXqdPop3W5+XvcK4NwkvwH8MnAjQJIXAn8E/B6woaoOp7UnnQ7r+EfgyQsPkhwAzLTNvxc4s6oOb7sdUlXf76J9twPPaVv3U4BnNOWd6p6UpH1P/zltdR+3rmZ6X1Xd30U7pCcwDDRUVfUA8C7gw0nOSfLkJAclOTPJxU21fcBskvb/z320PjGznOtp7bn/N1rvOfy8KT8MeASYBw5M8i6euNe94LvAIUnOSnIQ8F9onVJacAnwnoXTUUlmknT7KahrgF9L8jvN+xXvAnZU1R2LK1bVd4FbgD9JckiS1wDPBq5qqnwCOD/JqUk2NO38eJftkJ7AMNDQVdX7gLfTGsDmae1tXwD8j6bKZ5v7+5Pc3Ex/gNa5+R8l+eAS632Y1kc3X0brTeIFXwK+QGug/x6tI5N7l1jHA8CbgL8Gvk/rSGFPW5UPANcCX07yIPAN4NcXZia5Pcnrllj3PPA7tD4d9aNmuc1ty16S5JK2RTYDm5q6FwGvbdax8Eb7xbSOfr7X3P6k0/NK3UiVF7eRpGnnkYEkyTCQJBkGkiQMA0kS0Ncv/qzVUUcdVbOzs+vdDEkaKzfddNMPqmpm5ZorG4kwmJ2dZW5ubr2bIUljJcn3+rUuTxNJkgwDSZJhIEnCMJAkYRhIkjAMJEkYBpIkDANJEoaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJGAaSJAwDaazMbr1uvZugCbViGCQ5IcmNSXYluT3JW5ryI5JsT3Jnc7+hKU+SDybZnWRHkucNeiMkSb3p5sjgEeAdVfWrwPOBNyc5FdgK3FBVJwM3NI8BzgRObm5bgI/0vdWSpL5aMQyqam9V3dxMPwjsAo4DzgYua6pdBpzTTJ8NfKJavgEcnuTYvrdcktQ3q3rPIMks8Fzgm8AxVbUXWoEBHN1UOw64t22xPU2ZJGlEdR0GSQ4FrgLeWlU/Wa5qh7LqsL4tSeaSzM3Pz3fbDEkTwDfCR09XYZDkIFpB8Kmqurop3rdw+qe539+U7wFOaFv8eOC+xeusqm1VtamqNs3MzKy1/ZKkPujm00QBPgbsqqr3tc26FjivmT4P+Hxb+RuaTxU9H3hg4XSSJGk0HdhFnRcArwduS3JLU/bHwEXAZ5KcD/xf4HebedcDrwJ2Aw8Bf9DXFkuS+m7FMKiqr9H5fQCA0zvUL+DNPbZLkjREfgNZkmQYSJIMA0kShoEkCcNAkoRhIEnCMJAkYRhImgL+FtLKDANJkmEgSTIMJEkYBpIkDANJEoaBJAnDQJKEYSBJorvLXl6aZH+SnW1lVya5pbnds3AFtCSzSX7WNu+SQTZektQf3Vz28uPAh4BPLBRU1b9ZmE7yXuCBtvp3VdXGfjVQkjR43Vz28qtJZjvNSxLg94CX9rdZkqRh6vU9gxcC+6rqzrayE5N8O8nfJnnhUgsm2ZJkLsnc/Px8j82QJPWi1zA4F7ii7fFe4GlV9Vzg7cDlSZ7aacGq2lZVm6pq08zMTI/NkCT1Ys1hkORA4LeBKxfKqurhqrq/mb4JuAt4Zq+NlCQNVi9HBi8D7qiqPQsFSWaSHNBMnwScDNzdWxMlSYPWzUdLrwC+DpySZE+S85tZm3n8KSKAFwE7ktwKfA54Y1X9sJ8NliT1XzefJjp3ifJ/26HsKuCq3pslSRomv4EsSTIMJEmGgSQJw0CShGEgScIwkCRhGEgastmt1613E9SBYSBJMgwkSYaBJAnDQJKEYSBJwjCQJGEYSJIwDCRJdHdxm0uT7E+ys63s3Um+n+SW5vaqtnnvTLI7yXeSvHJQDZck9U83RwYfB87oUP7+qtrY3K4HSHIqrSugPatZ5q8WLoMpSRpdK4ZBVX0V6PbSlWcDn66qh6vq74HdwGk9tE+SNAS9vGdwQZIdzWmkDU3ZccC9bXX2NGWSeuRv+miQ1hoGHwGeAWwE9gLvbcrToW51WkGSLUnmkszNz8+vsRmStLyFEDVMl7emMKiqfVX1aFX9HPgoj50K2gOc0Fb1eOC+Jdaxrao2VdWmmZmZtTRDkpZlAHRvTWGQ5Ni2h68BFj5pdC2wOcnBSU4ETga+1VsTJak/DIeldfPR0iuArwOnJNmT5Hzg4iS3JdkBvAR4G0BV3Q58Bvg/wBeBN1fVowNrvaSOpmHQm4ZtHKYDV6pQVed2KP7YMvXfA7ynl0ZJmnyzW6/jnovOWu9mqOE3kCVJhoEkyTCQJGEYSJIwDCRJGAaSJAwDSRKGgaQx55fP+sMwkLSuHMxHg2EgSTIMJEmGgaQp42mpzgwDSZJhIE2yUdsLHrX26DGGgaSRZ4gMnmEgSerqSmeXJtmfZGdb2X9PckeSHUmuSXJ4Uz6b5GdJbmlulwyy8ZLGx7D37j2aWJ1ujgw+DpyxqGw78GtV9Wzgu8A72+bdVVUbm9sb+9NMSVqeg39vVgyDqvoq8MNFZV+uqkeah98Ajh9A2yRJQ9KP9wz+EPhC2+MTk3w7yd8meeFSCyXZkmQuydz8/HwfmiFp3Lg3Pzp6CoMkFwKPAJ9qivYCT6uq5wJvBy5P8tROy1bVtqraVFWbZmZmemmGpCllmPTPmsMgyXnAbwGvq6oCqKqHq+r+Zvom4C7gmf1oqCQtxVDo3ZrCIMkZwB8Br66qh9rKZ5Ic0EyfBJwM3N2PhkrSAgf//uvmo6VXAF8HTkmyJ8n5wIeAw4Dtiz5C+iJgR5Jbgc8Bb6yqH3ZcsSR10MtAv9ZlDRc4cKUKVXVuh+KPLVH3KuCqXhslSRouv4EsTahx2tsdp7ZOKsNAkpYxLUFlGEiaOtMywK+GYSBJMgwkSYaBpBE0zNM4yz3XNJ1OMgykMdCPQWkcBrZxaOOkMgykEecAqWEwDCStyaiG1CDaNarb2k+GgTTCpmEQGieT/PcwDCRJhoE06SZ5b1b9YxhIEoamYSBJMgwkjYZu9synfe99kLoKgySXJtmfZGdb2RFJtie5s7nf0JQnyQeT7E6yI8nzBtV4Sb0Z5cF1qbaNcpvHWbdHBh8HzlhUthW4oapOBm5oHgOcSetylycDW4CP9N5MSdPIgX94VrzSGUBVfTXJ7KLis4EXN9OXAV+hdV3ks4FPVFUB30hyeJJjq2pvPxosSSvxlNPq9fKewTELA3xzf3RTfhxwb1u9PU2ZJGlEDeIN5HQoqydUSrYkmUsyNz8/P4BmSOqFe87TpZcw2JfkWIDmfn9Tvgc4oa3e8cB9ixeuqm1VtamqNs3MzPTQDEnDMg0/97zSdkzKdi7WSxhcC5zXTJ8HfL6t/A3Np4qeDzzg+wXSaFjtQDapA5+eqNuPll4BfB04JcmeJOcDFwEvT3In8PLmMcD1wN3AbuCjwJv63mppgvmrm6Nh2vqs208TnbvErNM71C3gzb00StLwzG69jnsuOmvdlu9m/cMybQHQzm8gS1Nq3Aa+cWvvuDEMJHXFwfgxk9gXhoEkYDIHOHXPMJD0C90GgsExeQwDSatiEEwmw0CSZBhIo2qte+BrWc69fRkGktSFSQ9Mw0CaMtP62ztanmEgDYEDrEadYSBpWQbZdDAMpHU0LgPtuLRzmCatTwwDSZJhIK2H9d6r7Nfzr/d2jIJJ6QPDQBpB4zbAjFt7+2WSttswkCR1d3GbTpKcAlzZVnQS8C7gcODfAwtXuf/jqrp+zS2UJA3cmo8Mquo7VbWxqjYC/wp4CLimmf3+hXkGgabZJJ1GmCbT+Hfr12mi04G7qup7fVqfNJGmcZDReOhXGGwGrmh7fEGSHUkuTbKh0wJJtiSZSzI3Pz/fqYo0NQwJrbeewyDJk4BXA59tij4CPAPYCOwF3ttpuaraVlWbqmrTzMxMr82QRoYDu8ZRP44MzgRurqp9AFW1r6oeraqfAx8FTuvDc0hjz5DQKOtHGJxL2ymiJMe2zXsNsLMPzyFJI2sSgr6nMEjyZODlwNVtxRcnuS3JDuAlwNt6eQ5pmLwGsKbVmr9nAFBVDwFHLip7fU8tkiacQaJR5DeQpRExSiExSm3RcBgG0jpxwNUoMQykPmof4Nfy/oMBofViGEiSDANJkmEgdW2pUzidyj3do3FjGEir4CCvSWUYSFIfjesOg2EgSTIMpNVa2PMb1z1AqRPDQGPJgVjqL8NA6hMDSuPMMJAWWc2g7ikjTQrDQFNjvQbsaQqKadrWSWMYaCo4SEnLMwykJRggmiY9h0GSe5orm92SZK4pOyLJ9iR3Nvcbem+qJsmon7JZXM9g0ErG/X+kX0cGL6mqjVW1qXm8Fbihqk4Gbmgea4oM84Ux7i9CTY5x/l8c1Gmis4HLmunLgHMG9DxaJ+P8T78as1uvm5ptVX+N2/9NP8KggC8nuSnJlqbsmKraC9DcH714oSRbkswlmZufn+9DMzSpBnXKZtxerBo/4/Q/dmAf1vGCqrovydHA9iR3dLNQVW0DtgFs2rSp+tAOac3G6UWr0TeO/089HxlU1X3N/X7gGuA0YF+SYwGa+/29Po+0knF8AUqjoqcwSPKUJIctTAOvAHYC1wLnNdXOAz7fy/NoejigS+uj1yODY4CvJbkV+BZwXVV9EbgIeHmSO4GXN4/VJQfE7thPUv/09J5BVd0NPKdD+f3A6b2sW+qH2a3Xcc9FZ3Us7zQtTSu/gayR5kAtDYdhoJHRzcC/Uh33+KW1MQy0bpb7QtdqB/Ll6hsK0soMA/VVPwZeB29p+AwD9X3wXe3efr+ODtaynMEjtRgG6smo/nbPKLZJGmWGgQauH78t1M/B3aCQnsgw0JJ6vb7vMD7Z48Au9YdhMKUcRCW1MwzUkWEhTRfDYMSMwyA8Dm2UtDqGgZ6g07n+fnw7eFDLSuqdYTAlBjHYOoBLk8MwmECDHKT7+TMR0rQZ5deDYaCxMcovJGkp4/J/u+YwSHJCkhuT7Epye5K3NOXvTvL9JLc0t1f1r7mTq9d/mLWc0x+Xf1JJg9fLxW0eAd5RVTc3l768Kcn2Zt77q+ovem+e+mGUBv1Raos0TKP+v7/mI4Oq2ltVNzfTDwK7gOP61bBxNsw/+nLf8h3WD9BJWt44vHb68p5BklngucA3m6ILkuxIcmmSDUsssyXJXJK5+fn5fjRjbKxXWKw0fxz+YSUNRs9hkORQ4CrgrVX1E+AjwDOAjcBe4L2dlquqbVW1qao2zczM9NqMiTUue/cGiTTeegqDJAfRCoJPVdXVAFW1r6oeraqfAx8FTuu9mdNtGL/P3+uP0kkab718mijAx4BdVfW+tvJj26q9Bti59uZNtkF+gsjLQEpajV6ODF4AvB546aKPkV6c5LYkO4CXAG/rR0NH0bC/gOUgLmlQ1vzR0qr6GpAOs65fe3Mmx+zW67jnorMe97ibesutT5IGxW8gj4BOA/1y4eGXxyT1m2GwCqsZtCVpnBgGKxjVwX5U2yVpPBkGazSIL2s5wEtaL4ZBox8D8TC+DyBJg2AYLMP3CCRNC8NgDVbzhS4vBSlpHExVGAxyYPYbv5LG2VSFQSfLfZ5/pTprXbek6TWq48LUhYE/2SxJTzR1YQCGgKT1NYpjUC+XvRwra7lGsCQNSre/SzYsE31k0O3gPkpXHpOk9TDRYQDdvUEsSdNuosLAgV+S1maiwmCBg78krc7AwiDJGUm+k2R3kq2Deh5JUu8GEgZJDgA+DJwJnAqcm+TUQTzXUjw6kKTuDerI4DRgd1XdXVX/BHwaOHtAz/U4hoAkrd6gvmdwHHBv2+M9wK+3V0iyBdjSPPxpkvuBHwyoPePmKOyLBfZFyy/6IX++zi1ZwRDaNzH/Ez321VHA0/vTksGFQTqU1eMeVG0Dtv1igWSuqjYNqD1jxb54jH3RYj88xr5oafphtl/rG9Rpoj3ACW2PjwfuG9BzSZJ6NKgw+Dvg5CQnJnkSsBm4dkDPJUnq0UBOE1XVI0kuAL4EHABcWlW3r7DYthXmTxP74jH2RYv98Bj7oqWv/ZCqWrmWJGmiTeQ3kCVJq2MYSJJGIwym4acrklyaZH+SnW1lRyTZnuTO5n5DU54kH2z6Y0eS57Utc15T/84k563HtvQiyQlJbkyyK8ntSd7SlE9VXyQ5JMm3ktza9MOfNuUnJvlms01XNh/AIMnBzePdzfzZtnW9syn/TpJXrs8W9S7JAUm+neRvmsdT2RdJ7klyW5Jbksw1ZYN/fVTVut5ovcF8F3AS8CTgVuDU9W7XALbzRcDzgJ1tZRcDW5vprcCfN9OvAr5A6/sazwe+2ZQfAdzd3G9opjes97atsh+OBZ7XTB8GfJfWT5ZMVV8023NoM30Q8M1m+z4DbG7KLwH+YzP9JuCSZnozcGUzfWrzmjkYOLF5LR2w3tu3xj55O3A58DfN46nsC+Ae4KhFZQN/fYzCkcG6/XTFMFXVV4EfLio+G7ismb4MOKet/BPV8g3g8CTHAq8EtlfVD6vqR8B24IzBt75/qmpvVd3cTD8I7KL1jfWp6otme37aPDyouRXwUuBzTfnifljon88BpydJU/7pqnq4qv4e2E3rNTVWkhwPnAX8dfM4TGlfLGHgr49RCINOP11x3Dq1ZdiOqaq90BokgaOb8qX6ZKL6qjm8fy6tveKp64vmtMgtwH5aL9a7gB9X1SNNlfZt+sX2NvMfAI5kAvqh8ZfAfwZ+3jw+kuntiwK+nOSmtH62B4bw+hiFayCv+NMVU2ipPpmYvkpyKHAV8Naq+klrx65z1Q5lE9EXVfUosDHJ4cA1wK92qtbcT2w/JPktYH9V3ZTkxQvFHapOfF80XlBV9yU5Gtie5I5l6vatL0bhyGCaf7piX3NIR3O/vylfqk8moq+SHEQrCD5VVVc3xVPZFwBV9WPgK7TO+R6eZGEnrX2bfrG9zfxfoXXacRL64QXAq5PcQ+s08UtpHSlMY19QVfc19/tp7SScxhBeH6MQBtP80xXXAgvv8p8HfL6t/A3NJwWeDzzQHBp+CXhFkg3Npwle0ZSNjebc7seAXVX1vrZZU9UXSWaaIwKS/DLwMlrvn9wIvLaptrgfFvrntcD/rNY7hdcCm5tP2JwInAx8azhb0R9V9c6qOr5aP7q2mda2vY4p7IskT0ly2MI0rf/rnQzj9bHe75y3vSP+XVrnTC9c7/YMaBuvAPYC/0wrtc+ndZ7zBuDO5v6Ipm5oXRzoLuA2YFPbev6Q1htju4E/WO/tWkM//Catw9UdwC3N7VXT1hfAs4FvN/2wE3hXU34SrQFsN/BZ4OCm/JDm8e5m/klt67qw6Z/vAGeu97b12C8v5rFPE01dXzTbfGtzu31hPBzG68Ofo5AkjcRpIknSOjMMJEmGgSTJMJAkYRhIkjAMJEkYBpIk4P8DqE+/Gh539BkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ "# zfit.run.numeric_checks = False \n", "\n", - "load = True\n", + "load = False\n", "\n", "bo = True\n", "\n", @@ -1477,10 +1647,15 @@ "\n", "__ = -1\n", "\n", + "newset = True\n", + "\n", "#-----------------------------------------------------\n", "\n", "if not load:\n", " for Ctt_step in Ctt_steps:\n", + "\n", + " if not newset:\n", + " break\n", " \n", " __ += 1\n", " \n", @@ -1494,7 +1669,10 @@ " pull_dic[param.name].append([])\n", " \n", " for toy in range(nr_of_toys): \n", - " \n", + " \n", + " if not newset:\n", + " break\n", + " \n", " newset = True\n", " \n", " while newset:\n", @@ -1502,6 +1680,9 @@ " for floaty in [True, False]:\n", " Ctt.floating = floaty\n", " \n", + " if not floaty:\n", + " break\n", + " \n", " for bo_step in range(bo_set):\n", "\n", " print('Step: {0}/{1}'.format(int(__), ste))\n", @@ -1582,243 +1763,9 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of jobs: 300\n", - "2317442\n", - "2317446\n", - "2317447\n", - "2317455\n", - "2317458\n", - "2317459\n", - "2317461\n", - "2317462\n", - "2317464\n", - "2317465\n", - "2317931\n", - "2317932\n", - "2317933\n", - "2317934\n", - "2317935\n", - "2317936\n", - "2317937\n", - "2317938\n", - "2317939\n", - "2317940\n", - "2317941\n", - "2317942\n", - "2317943\n", - "2317944\n", - "2317945\n", - "2317946\n", - "2317947\n", - "2317948\n", - "2317949\n", - "2317950\n", - "2317951\n", - "2317952\n", - "2317953\n", - "2317954\n", - "2317955\n", - "2317956\n", - "2317957\n", - "2317958\n", - "2317959\n", - "2317960\n", - "2317961\n", - "2317962\n", - "2317963\n", - "2317964\n", - "2317965\n", - "2317966\n", - "2317967\n", - "2317968\n", - "2317969\n", - "2317970\n", - "2317971\n", - "2317972\n", - "2317973\n", - "2317974\n", - "2317975\n", - "2317976\n", - "2317977\n", - "2317978\n", - "2317979\n", - "2317980\n", - "2317981\n", - "2317982\n", - "2317983\n", - "2317984\n", - "2317985\n", - "2317986\n", - "2317987\n", - "2317988\n", - "2317989\n", - "2317990\n", - "2317991\n", - "2317992\n", - "2317993\n", - "2317994\n", - "2317995\n", - "2317996\n", - "2317997\n", - "2317998\n", - "2317999\n", - "2318000\n", - "2318001\n", - "2318002\n", - "2318003\n", - "2318004\n", - "2318005\n", - "2318006\n", - "2318007\n", - "2318008\n", - "2318009\n", - "2318010\n", - "2318011\n", - "2318012\n", - "2318013\n", - "2318014\n", - "2318015\n", - "2318016\n", - "2318017\n", - "2318018\n", - "2318019\n", - "2318020\n", - "2318021\n", - "2318022\n", - "2318023\n", - "2318024\n", - "2318025\n", - "2318026\n", - "2318027\n", - "2318028\n", - "2318029\n", - "2318030\n", - "2318031\n", - "2318032\n", - "2318033\n", - "2318034\n", - "2318035\n", - "2318036\n", - "2318037\n", - "2318038\n", - "2318039\n", - "2318040\n", - "2318041\n", - "2318042\n", - "2318043\n", - "2318044\n", - "2318045\n", - "2318046\n", - "2318047\n", - "2318048\n", - "2318049\n", - "2318050\n", - "2318051\n", - "2318052\n", - "2318053\n", - "2318054\n", - "2318055\n", - "2318056\n", - "2318057\n", - "2318058\n", - "2318059\n", - "2318060\n", - "2318061\n", - "2318062\n", - "2318063\n", - "2318064\n", - "2318065\n", - "2318066\n", - "2318067\n", - "2318068\n", - "2318069\n", - "2318070\n", - "2318071\n", - "2318072\n", - "2318073\n", - "2318074\n", - "2318075\n", - "2318076\n", - "2318077\n", - "2318078\n", - "2318079\n", - "2318080\n", - "2318081\n", - "2318082\n", - "2318083\n", - "2318084\n", - "2318085\n", - "2318086\n", - "2318087\n", - "2318088\n", - "2318089\n", - "2318090\n", - "2318091\n", - "2318092\n", - "2318093\n", - "2318094\n", - "2318095\n", - "2318096\n", - "2318097\n", - "2318098\n", - "2318099\n", - "2318100\n", - "2318101\n", - "2318102\n", - "2318103\n", - "2318104\n", - "2318105\n", - "2318106\n", - "2318107\n", - "2318108\n", - "2318109\n", - "2318110\n", - "2318111\n", - "2318112\n", - "2318113\n", - "2318114\n", - "2318115\n", - "2318116\n", - "2318117\n", - "2318118\n", - "2318119\n", - "2318120\n", - "2318121\n", - "2318122\n", - "2318123\n", - "2318124\n", - "2318125\n", - "2318126\n", - "2318127\n", - "2318128\n", - "2318129\n", - "2318130\n", - "2318131\n", - "2318132\n", - "2318133\n", - "2318134\n", - "2318135\n", - "2318136\n", - "2318137\n", - "2318138\n", - "2318139\n", - "2318140\n", - "2318141\n", - "2318142\n", - "2318143\n", - "2318144\n", - "2318145\n", - "2318146\n" - ] - } - ], + "outputs": [], "source": [ "if load:\n", " \n", @@ -1895,7 +1842,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1956,7 +1903,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1972,39 +1919,9 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(5, 74)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "l = []\n", "\n", @@ -2051,30 +1968,11 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": { "scrolled": false }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "BR: 0.0003\n", - "0.0\n", - "\n", - "BR: 0.0004\n", - "0.0\n", - "\n", - "BR: 0.0005\n", - "0.0\n", - "\n", - "BR: 0.0006\n", - "0.0\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "for s in range(len(l)):\n", " print('BR: {:.4f}'.format(BR_steps[s+1]))\n", @@ -2093,7 +1991,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2104,7 +2002,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2115,29 +2013,171 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "39 s\n" - ] - } - ], + "outputs": [], "source": [ "print(display_time(int(time.time()-start)))" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "# variab['mi'] =! mi" + "probs = total_f_fit.pdf(test_q, norm_range=False)\n", + "\n", + "calcs_test = zfit.run(probs)" ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.clf()\n", + "plt.plot(test_q, calcs_test)\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": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "45702000\n", + "0 22\n", + "1 22\n", + "2 22\n", + "3 22\n", + "4 22\n", + "5 22\n", + "6 22\n", + "7 22\n", + "8 22\n", + "9 22\n", + "10 22\n", + "11 22\n", + "12 22\n", + "13 22\n", + "14 22\n", + "15 22\n", + "16 22\n", + "17 22\n", + "18 22\n", + "19 22\n", + "20 22\n", + "21 22\n", + "Full integration finished in 4 min, 19 s\n", + "1051146\n" + ] + } + ], + "source": [ + "# total_f_fit.update_integration_options(draws_per_dim=2000000, mc_sampler=None)\n", + "\n", + "start = time.time()\n", + "\n", + "_max_size = 2000000\n", + "\n", + "step_size = 1000\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(l/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-1)*_max_size:], norm_range=False)\n", + "\n", + "inte_fl = zfit.run(_c)\n", + "\n", + "for i in range(int(l/step_size)):\n", + " _list.append(np.mean(steps[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": 39, + "metadata": {}, + "outputs": [], + "source": [ + "dirName = 'data/CLs'\n", + "with open(\"{}/inte_100keV_steps.pkl\".format(dirName), \"wb\") as f:\n", + " pkl.dump(_list, f, pkl.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "45701.99999999999" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(x_max-x_min)/0.1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/test.png b/test.png index 9fdbe52..3815a28 100644 --- a/test.png +++ b/test.png Binary files differ