Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.core.display import display, HTML\n",
    "from collections import defaultdict\n",
    "\n",
    "pd.set_option('display.max_columns', 999)\n",
    "\n",
    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from rdstar.offline_analysis.mc_ids import sig_id_to_label\n",
    "from rdstar.offline_analysis.rdstar_plots import get_rdstar_color_dict\n",
    "from rdstar.offline_analysis.rdstar_samples import data_type_combinations\n",
    "from rdstar.offline_analysis.corrections.fei_tag_correction import TagCorrection\n",
    "from rdstar.offline_analysis.systematics import full_systematics_cols, full_systematics_name, get_systematics\n",
    "from rdstar.offline_analysis.validation.sideband_validation import plot_data_mc_comparison, hvar_missing_mass_q2sb, SidebandInfo, create_sideband_infos_with_systematics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "logger = logging.getLogger()\n",
    "logger.setLevel(logging.DEBUG)\n",
    "mpl_logger = logging.getLogger('matplotlib')\n",
    "mpl_logger.setLevel(logging.WARNING)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_plots = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def correct_sig_id(df: pd.DataFrame):\n",
    "    assert \"SIG_ID\" in df.columns\n",
    "    assert len(df.SIG_ID.unique()) <= 9, (len(df.SIG_ID.unique()), df.SIG_ID.unique())\n",
    "    original_unique_len = len(df.SIG_ID.unique())\n",
    "    assert 7 not in df.SIG_ID.unique(), df.SIG_ID.unique()\n",
    "    \n",
    "    df.loc[df.SIG_ID == 8, \"SIG_ID\"] = 7\n",
    "    df.loc[df.SIG_ID == 9, \"SIG_ID\"] = 8\n",
    "    df.loc[df.SIG_ID == 10, \"SIG_ID\"] = 9\n",
    "    \n",
    "    assert len(df.SIG_ID.unique()) <= 9, (len(df.SIG_ID.unique()), df.SIG_ID.unique())\n",
    "    assert len(df.SIG_ID.unique()) == original_unique_len, (len(df.SIG_ID.unique()), original_unique_len, df.SIG_ID.unique())\n",
    "    assert 10 not in df.SIG_ID.unique(), df.SIG_ID.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "side_band = \"q2\"\n",
    "base_input_path = os.fspath(\"/ceph/fmetzner/rdstar/data_set_prod_11thJan2020_stream0/CombinedSamples/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_file_name(data_type, side_band_name):\n",
    "    return f\"{data_type}_withFinalWeights_withMMSQResCorr_first_selection_with_CS_CS1_{side_band_name}_sideband.h5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mc_data_types = [\"Charged\", \"Mixed\", \"Charm\", \"UDS\", \"Gap\", \"Dss\", \"Special\"]\n",
    "data_key = \"DataY4S\"\n",
    "\n",
    "data_types = mc_data_types + [data_key]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_paths = {data_type: os.path.join(base_input_path, get_file_name(data_type, side_band)) for data_type in data_types}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_mc = pd.concat([pd.read_hdf(data_paths[data_type]) for data_type in mc_data_types], ignore_index=True, sort=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_mc.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# correct_sig_id(df=df_mc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_data = pd.read_hdf(data_paths[data_key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ff_cols = [c for c in df_mc.columns if c.startswith(\"weight_ff_\") and c.endswith(\"nom\")]\n",
    "ff_weight_names = ff_cols\n",
    "ff_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt_list = data_type_combinations[\"Special\"]\n",
    "data_type_combinations[\"Special\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in ff_weight_names:\n",
    "    df_mc.loc[np.isnan(df_mc[c]) & df_mc.data_type.isin(dt_list), c] = 1.0\n",
    "    for cc in [col for col in df_mc.columns if col.startswith(c.replace(\"_nom\", \"_var_\"))]:\n",
    "        df_mc.loc[np.isnan(df_mc[cc]) & df_mc.data_type.isin(dt_list), cc] = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dts = []\n",
    "for c in ff_weight_names:\n",
    "    dts.append(df_mc.loc[np.isnan(df_mc[c]) & df_mc.data_type.isin(dt_list), \"__weight_full__\"].unique())\n",
    "    #dts.append((c, df_mc.loc[df_mc[c] == df_mc[c].min(), c].min(), list(df_mc.loc[df_mc[c] == df_mc[c].min(), \"data_type\"].unique()), list(df_mc.loc[df_mc[c] == df_mc[c].min(), \"__weight_full__\"].unique())))\n",
    "    \n",
    "dts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fei_tag_corrector = TagCorrection(correct_only_true_b=False)\n",
    "fei_tag_corrector.apply_tagging_correction(sample=df_mc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_mc[TagCorrection.tagging_correction_name].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert \"__weight_final_wFEI_corr__\" not in df_mc.columns\n",
    "df_mc.loc[:, \"__weight_final_wFEI_corr__\"] = df_mc[[\"__weight_full__\", TagCorrection.tagging_correction_name]].product(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[c for c in df_mc.columns if \"weight_ff_Dtwostar_var_\" in c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_systematics_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_miss_sb_info = SidebandInfo(\n",
    "    key=\"q2_sideband\",\n",
    "    hist_var=hvar_missing_mass_q2sb,\n",
    "    title=r\"$\\mathrm{q}^2$ Sideband\",\n",
    "    sb_text=r\"$\\mathrm{q}^2 < 4.0$ GeV$^2$\",\n",
    "    text_h_pos=(0.64, 0.03),\n",
    "    text_v_pos=(0.76, 0.97),\n",
    "    legend_loc=1,\n",
    "    legend_cols=1,\n",
    "    y_scale=1.1,\n",
    "    systematics=None\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_miss_sb_info_w_sys = create_sideband_infos_with_systematics(\n",
    "    sideband_info_list=[m_miss_sb_info],\n",
    "    systematics_collection=full_systematics_cols,\n",
    "    sys_name_tag=full_systematics_name\n",
    ")[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from templatefitter.plotter.histogram_variable import HistVariable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hvar_pStarL = HistVariable(\"pStarL\", 2, (0.1, 2.2), r\"$\\mathrm{p}_\\ell^\\ast$\", r\"$\\mathrm{GeV}$\")\n",
    "pStarL_sb_info = SidebandInfo(\n",
    "    key=\"q2_sideband\",\n",
    "    hist_var=hvar_pStarL,\n",
    "    title=r\"$\\mathrm{q}^2$ Sideband\",\n",
    "    sb_text=r\"$\\mathrm{q}^2 < 4.0$ GeV$^2$\",\n",
    "    text_h_pos=(0.64, 0.03),\n",
    "    text_v_pos=(0.76, 0.97),\n",
    "    legend_loc=1,\n",
    "    legend_cols=1,\n",
    "    y_scale=1.1,\n",
    "    systematics=None\n",
    ")\n",
    "\n",
    "pStarL_sb_info_w_sys = create_sideband_infos_with_systematics(\n",
    "    sideband_info_list=[pStarL_sb_info],\n",
    "    systematics_collection=full_systematics_cols,\n",
    "    sys_name_tag=full_systematics_name\n",
    ")[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hvar_missing_mom_cms = HistVariable(\"missingMomentumInCMSFrame\", 2, (-1., 3.), r\"$p_\\mathrm{miss}^\\ast$\", \"GeV\")\n",
    "\n",
    "miss_mom_sb_info = SidebandInfo(\n",
    "    key=\"q2_sideband\",\n",
    "    hist_var=hvar_missing_mom_cms,\n",
    "    title=r\"$\\mathrm{q}^2$ Sideband\",\n",
    "    sb_text=r\"$\\mathrm{q}^2 < 4.0$ GeV$^2$\",\n",
    "    text_h_pos=(0.64, 0.03),\n",
    "    text_v_pos=(0.76, 0.97),\n",
    "    legend_loc=1,\n",
    "    legend_cols=1,\n",
    "    y_scale=1.1,\n",
    "    systematics=None\n",
    ")\n",
    "\n",
    "miss_mom_sb_info_w_sys = create_sideband_infos_with_systematics(\n",
    "    sideband_info_list=[miss_mom_sb_info],\n",
    "    systematics_collection=full_systematics_cols,\n",
    "    sys_name_tag=full_systematics_name\n",
    ")[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write out small data set for test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns_to_keep = [\n",
    "    \"__weight_final_wFEI_corr__\",\n",
    "    \"daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc\",\n",
    "    \"SIG_ID\",\n",
    "    \"m2RecoilSignalSide\",\n",
    "    \"__weight_full__\",\n",
    "    TagCorrection.tagging_correction_name\n",
    "]\n",
    "\n",
    "columns_to_keep.extend([si.var for si in m_miss_sb_info_w_sys.systematics])\n",
    "columns_to_keep.extend([si.ratio for si in m_miss_sb_info_w_sys.systematics if si.ratio is not None])\n",
    "\n",
    "columns_to_keep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns_to_drop = [c for c in df_mc.columns if c not in columns_to_keep]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_mc_reduced = df_mc.drop(columns=columns_to_drop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_mc_reduced.to_hdf(path_or_buf=\"/home/fmetzner/Downloads/test_mc.h5\", key=\"mc\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_columns_to_drop = [c for c in columns_to_drop if c in df_data.columns]\n",
    "df_data_reduced = df_data.drop(columns=data_columns_to_drop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_data.to_hdf(path_or_buf=\"/home/fmetzner/Downloads/test_data.h5\", key=\"data\")\n",
    "df_data_reduced.to_hdf(path_or_buf=\"/home/fmetzner/Downloads/test_data_reduced.h5\", key=\"data\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotter Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if test_plots:\n",
    "    plot_data_mc_comparison(\n",
    "        mc_df=df_mc,\n",
    "        data_df=df_data,\n",
    "        weight_col=\"__weight_final_wFEI_corr__\",\n",
    "        #sideband_info=m_miss_sb_info_w_sys,\n",
    "        sideband_info=m_miss_sb_info,\n",
    "        export_path=None,\n",
    "        style=\"stacked\",\n",
    "        ratio_type=\"vs_uncert\",\n",
    "        normalize_mc_to_data=False,\n",
    "        gof_check_method=\"toys\",\n",
    "        adaptive_binning=True,\n",
    "        show_plots=True\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if test_plots:\n",
    "    plot_data_mc_comparison(\n",
    "        mc_df=df_mc,\n",
    "        data_df=df_data,\n",
    "        weight_col=\"__weight_final_wFEI_corr__\",\n",
    "        #sideband_info=pStarL_sb_info_w_sys,\n",
    "        sideband_info=pStarL_sb_info,\n",
    "        export_path=None,\n",
    "        style=\"stacked\",\n",
    "        ratio_type=\"vs_uncert\",\n",
    "        normalize_mc_to_data=False,\n",
    "        gof_check_method=\"toys\",\n",
    "        adaptive_binning=True,\n",
    "        show_plots=True\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if test_plots:\n",
    "    plot_data_mc_comparison(\n",
    "        mc_df=df_mc,\n",
    "        data_df=df_data,\n",
    "        weight_col=\"__weight_final_wFEI_corr__\",\n",
    "        #sideband_info=miss_mom_sb_info_w_sys,\n",
    "        sideband_info=miss_mom_sb_info,\n",
    "        export_path=None,\n",
    "        style=\"stacked\",\n",
    "        ratio_type=\"vs_uncert\",\n",
    "        normalize_mc_to_data=False,\n",
    "        gof_check_method=\"toys\",\n",
    "        adaptive_binning=True,\n",
    "        show_plots=True\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"__tagging_fei_corr_factor__\" in df_mc.loc[df_mc.__tagging_fei_corr_factor__<-111111].columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fitter Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "from rdstar.offline_analysis.mc_ids import rdstar_sig_queries\n",
    "\n",
    "from templatefitter.fit_model.parameter_handler import ParameterHandler\n",
    "from templatefitter.fit_model.template import Template\n",
    "from templatefitter.fit_model.model_builder import FitModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rdstar_dec_modes = {\n",
    "    \"DZ\": [13, 14],\n",
    "    \"DM\": [11, 12],\n",
    "    \"DSZ\": [17, 18],\n",
    "    \"DSM\": [15, 16],\n",
    "}\n",
    "\n",
    "rdstar_miss_mass_binning_for_dec_modes_adapted = {\n",
    "    \"DZ\": ((-2.0, -1.76, -1.52, -1.28, -1.04, -0.8, -0.56, -0.32000000000000006, -0.08000000000000007, 0.16000000000000014, 0.3999999999999999, 0.6399999999999997, 0.8799999999999999, 1.12, 1.3599999999999999, 1.5999999999999996, 1.8399999999999999, 2.08, 2.3200000000000003, 2.5599999999999996, 2.8, 4.0),),\n",
    "    \"DM\": ((-2.0, -1.52, -1.28, -1.04, -0.8, -0.56, -0.32000000000000006, -0.08000000000000007, 0.16000000000000014, 0.3999999999999999, 0.6399999999999997, 0.8799999999999999, 1.12, 1.3599999999999999, 1.5999999999999996, 1.8399999999999999, 2.08, 2.3200000000000003, 2.5599999999999996, 4.0),),\n",
    "    \"DSZ\": ((-2.0, -1.76, -1.52, -1.28, -1.04, -0.8, -0.56, -0.32000000000000006, -0.08000000000000007, 0.16000000000000014, 0.3999999999999999, 0.6399999999999997, 0.8799999999999999, 1.12, 1.3599999999999999, 1.5999999999999996, 1.8399999999999999, 2.08, 2.3200000000000003, 2.5599999999999996, 2.8, 4.0),),\n",
    "    \"DSM\": ((-2.0, -1.52, -1.04, -0.8, -0.56, -0.32000000000000006, -0.08000000000000007, 0.16000000000000014, 0.3999999999999999, 0.6399999999999997, 0.8799999999999999, 1.12, 1.3599999999999999, 1.5999999999999996, 1.8399999999999999, 2.08, 4.0),),\n",
    "    \"all_modes\": ((-2.0, -1.76, -1.52, -1.28, -1.04, -0.8, -0.56, -0.32000000000000006, -0.08000000000000007, 0.16000000000000014, 0.3999999999999999, 0.6399999999999997, 0.8799999999999999, 1.12, 1.3599999999999999, 1.5999999999999996, 1.8399999999999999, 2.08, 2.3200000000000003, 2.5599999999999996, 2.8, 4.0),),\n",
    "}\n",
    "\n",
    "rdstar_miss_mass_binning_for_dec_modes_simple = {i: len(c[0]) for i,c in rdstar_miss_mass_binning_for_dec_modes_adapted.items()}\n",
    "\n",
    "rdstar_miss_mass_binning_for_dec_modes = rdstar_miss_mass_binning_for_dec_modes_adapted\n",
    "\n",
    "rdstar_dec_titles = {\n",
    "    \"DZ\": r\"$B^- \\rightarrow D^0 \\ell^-$\",\n",
    "    \"DM\": r\"$B^0 \\rightarrow D^- \\ell^+$\",\n",
    "    \"DSZ\": r\"$B^- \\rightarrow D^{*0} \\ell^-$\",\n",
    "    \"DSM\": r\"$B^0 \\rightarrow D^{*-} \\ell^+$\",\n",
    "    \"all_modes\": \"All Reconstruction Modes\",\n",
    "}\n",
    "\n",
    "plot_order = [\"CBKG\", \"GBKG\", \"HBKG\", \"DSSlbkg\", \"DSSl\", \"DSl\", \"Dl\", \"DStau\", \"Dtau\"]\n",
    "weight_col_for_fit = \"__weight_final_wFEI_corr__\"\n",
    "weight_col_for_fit2 = \"__weight_final_wFEI_corr_x_fac2__\"\n",
    "df_mc.loc[:, weight_col_for_fit2] = df_mc[weight_col_for_fit] * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dec_modes = rdstar_dec_modes\n",
    "dec_titles = rdstar_dec_titles\n",
    "\n",
    "all_mode_ids = [d_id for d_ids in dec_modes.values() for d_id in d_ids]\n",
    "output_dict = {}\n",
    "\n",
    "mode_infos = [(k, v) for k, v in dec_modes.items()]\n",
    "mode_infos.append((\"all_modes\", all_mode_ids))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_yield_dict = {}\n",
    "\n",
    "for comp in plot_order:\n",
    "    reco_id = rdstar_sig_queries[comp][\"id\"]\n",
    "    \n",
    "    sig_id_constraint = df_mc.SIG_ID == reco_id\n",
    "    mode_constraint = df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(all_mode_ids)\n",
    "    \n",
    "    initial_yield_dict[comp] = df_mc.loc[sig_id_constraint & mode_constraint, weight_col_for_fit].sum()\n",
    "    \n",
    "initial_yield_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_eff_dict = defaultdict(dict)\n",
    "\n",
    "for comp in plot_order:\n",
    "    for mode_name, mode_ids in mode_infos:\n",
    "        reco_id = rdstar_sig_queries[comp][\"id\"]\n",
    "    \n",
    "        sig_id_constraint = df_mc.SIG_ID == reco_id\n",
    "        mode_constraint = df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)\n",
    "\n",
    "        count_in_mode = df_mc.loc[sig_id_constraint & mode_constraint, weight_col_for_fit].sum()\n",
    "        \n",
    "        initial_eff_dict[comp][mode_name] = count_in_mode * 1. / initial_yield_dict[comp]\n",
    "\n",
    "initial_eff_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_handler = ParameterHandler()\n",
    "my_fit_model = FitModel(parameter_handler=param_handler)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining MC Templates of FitModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for comp in plot_order:\n",
    "    my_fit_model.add_model_parameter(\n",
    "        name=f\"yield_{comp}\",\n",
    "        parameter_type=ParameterHandler.yield_parameter_type,\n",
    "        floating=True,\n",
    "        initial_value=initial_yield_dict[comp],\n",
    "        constrain_to_value=None,\n",
    "        constraint_sigma=None\n",
    "    )\n",
    "    \n",
    "channel_templates = defaultdict(list)\n",
    "channel_eff_parameters = defaultdict(list)\n",
    "\n",
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name == \"all_modes\":\n",
    "        continue\n",
    "        \n",
    "    for comp in plot_order:\n",
    "        reco_id = rdstar_sig_queries[comp][\"id\"]\n",
    "        \n",
    "        template = Template(\n",
    "            name=f\"{mode_name}_{comp}\",\n",
    "            latex_label=sig_id_to_label[reco_id],\n",
    "            color=get_rdstar_color_dict()[reco_id],\n",
    "            process_name=comp,\n",
    "            dimensions=3,\n",
    "            bins=(rdstar_miss_mass_binning_for_dec_modes[mode_name][0], (0.1, 1.05, 2.2), (-1., 1.0, 3.)),\n",
    "            scope=(m_miss_sb_info.hist_var.scope, pStarL_sb_info.hist_var.scope, miss_mom_sb_info.hist_var.scope),\n",
    "            params=param_handler,\n",
    "            data_column_names=[m_miss_sb_info.hist_var.df_label, pStarL_sb_info.hist_var.df_label, miss_mom_sb_info.hist_var.df_label],\n",
    "            data=df_mc.loc[\n",
    "        df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)\n",
    "            ].query(f\"SIG_ID == {reco_id}\"),\n",
    "            weights=weight_col_for_fit,\n",
    "            systematics=get_systematics(df=df_mc, sys_cols_infos=full_systematics_cols),\n",
    "            log_scale_mask=False\n",
    "        )\n",
    "        \n",
    "        template_id = my_fit_model.add_template(\n",
    "            template=template,\n",
    "            yield_parameter=f\"yield_{comp}\",\n",
    "            use_other_systematics=True\n",
    "        )\n",
    "        channel_templates[mode_name].append(f\"temp_{template_id}\")\n",
    "        \n",
    "        eff_param_name = f\"eff_{mode_name}_{comp}\"\n",
    "        my_fit_model.add_model_parameter(\n",
    "            name=eff_param_name,\n",
    "            parameter_type=\"efficiency\",\n",
    "            floating=False,\n",
    "            initial_value=initial_eff_dict[comp][mode_name],\n",
    "            constrain_to_value=initial_eff_dict[comp][mode_name],\n",
    "            constraint_sigma=0.1\n",
    "        )\n",
    "        channel_eff_parameters[mode_name].append(eff_param_name)\n",
    "        \n",
    "    my_fit_model.add_channel(\n",
    "            efficiency_parameters=channel_eff_parameters[mode_name],\n",
    "            name=mode_name,\n",
    "            components=channel_templates[mode_name],\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Adding Data to FitModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_channel_infos = {}\n",
    "data_channel_weight_infos = {}\n",
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name == \"all_modes\":\n",
    "        continue\n",
    "    data_channel_infos.update({\n",
    "        f\"{mode_name}\":\n",
    "        df_mc.loc[df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)]\n",
    "    })\n",
    "    \n",
    "    data_channel_weight_infos.update({f\"{mode_name}\": weight_col_for_fit})\n",
    "\n",
    "my_fit_model.add_data(channels=data_channel_infos, channel_weights=data_channel_weight_infos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fit_model.finalize_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test FitResultPlotter with initial values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from templatefitter.plotter.fit_result_plots import FitResultPlotter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_result_plotter = FitResultPlotter(\n",
    "    variable=m_miss_sb_info.hist_var,\n",
    "    fit_model=my_fit_model,\n",
    "    reference_dimension=0,\n",
    "    involved_hist_variables=[m_miss_sb_info.hist_var, pStarL_sb_info.hist_var, miss_mom_sb_info.hist_var],\n",
    "    channel_label_dict=dec_titles,\n",
    "    data_label=\"Asimov Data\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_result_plotter.plot_fit_result(\n",
    "    use_initial_values=True,\n",
    "    output_dir_path=\"/home/fmetzner/Downloads/fit_result_plot_examples/\",\n",
    "    output_name_tag=\"AsimovData_fixed_Nuisance_Params\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Fitter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from templatefitter.fitter import TemplateFitter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fitter = TemplateFitter(fit_model=my_fit_model, minimizer_id=\"iminuit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fitter.do_fit(update_templates=True, get_hesse=True, verbose=True, fix_nui_params=True)\n",
    "# %prun my_fitter.do_fit(update_templates=True, get_hesse=True, verbose=True, fix_nui_params=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test FitResultPlotter with fitted values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_result_plotter.plot_fit_result(\n",
    "    output_dir_path=\"/home/fmetzner/Downloads/fit_result_plot_examples/\",\n",
    "    output_name_tag=\"AsimovData_fixed_Nuisance_Params\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitter Test with Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_handler_wd = ParameterHandler()\n",
    "my_fit_model_wd = FitModel(parameter_handler=param_handler_wd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for comp in plot_order:\n",
    "    my_fit_model_wd.add_model_parameter(\n",
    "        name=f\"yield_{comp}\",\n",
    "        parameter_type=ParameterHandler.yield_parameter_type,\n",
    "        floating=True,\n",
    "        initial_value=initial_yield_dict[comp],\n",
    "        constrain_to_value=None,\n",
    "        constraint_sigma=None\n",
    "    )\n",
    "    \n",
    "channel_templates = defaultdict(list)\n",
    "channel_eff_parameters = defaultdict(list)\n",
    "\n",
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name == \"all_modes\":\n",
    "        continue\n",
    "        \n",
    "    for comp in plot_order:\n",
    "        reco_id = rdstar_sig_queries[comp][\"id\"]\n",
    "        \n",
    "        template = Template(\n",
    "            name=f\"{mode_name}_{comp}\",\n",
    "            latex_label=sig_id_to_label[reco_id],\n",
    "            color=get_rdstar_color_dict()[reco_id],\n",
    "            process_name=comp,\n",
    "            dimensions=3,\n",
    "            bins=(rdstar_miss_mass_binning_for_dec_modes[mode_name], 2, 2),\n",
    "            scope=(m_miss_sb_info.hist_var.scope, pStarL_sb_info.hist_var.scope, miss_mom_sb_info.hist_var.scope),\n",
    "            params=param_handler_wd,\n",
    "            data_column_names=[m_miss_sb_info.hist_var.df_label, pStarL_sb_info.hist_var.df_label, miss_mom_sb_info.hist_var.df_label],\n",
    "            data=df_mc.loc[\n",
    "        df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)\n",
    "            ].query(f\"SIG_ID == {reco_id}\"),\n",
    "            weights=weight_col_for_fit,\n",
    "            systematics=get_systematics(df=df_mc, sys_cols_infos=full_systematics_cols),\n",
    "            log_scale_mask=False\n",
    "        )\n",
    "        \n",
    "        template_id = my_fit_model_wd.add_template(\n",
    "            template=template,\n",
    "            yield_parameter=f\"yield_{comp}\",\n",
    "            use_other_systematics=True\n",
    "        )\n",
    "        channel_templates[mode_name].append(f\"temp_{template_id}\")\n",
    "        \n",
    "        eff_param_name = f\"eff_{mode_name}_{comp}\"\n",
    "        my_fit_model_wd.add_model_parameter(\n",
    "            name=eff_param_name,\n",
    "            parameter_type=\"efficiency\",\n",
    "            floating=False,\n",
    "            initial_value=initial_eff_dict[comp][mode_name],\n",
    "            constrain_to_value=initial_eff_dict[comp][mode_name],\n",
    "            constraint_sigma=0.1\n",
    "        )\n",
    "        channel_eff_parameters[mode_name].append(eff_param_name)\n",
    "        \n",
    "    my_fit_model_wd.add_channel(\n",
    "            efficiency_parameters=channel_eff_parameters[mode_name],\n",
    "            name=mode_name,\n",
    "            components=channel_templates[mode_name],\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_channel_infos = {}\n",
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name == \"all_modes\":\n",
    "        continue\n",
    "    data_channel_infos.update({\n",
    "        f\"{mode_name}\":\n",
    "        df_data.loc[df_data.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)]\n",
    "    })\n",
    "    \n",
    "\n",
    "my_fit_model_wd.add_data(channels=data_channel_infos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fit_model_wd.finalize_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_result_plotter_wd = FitResultPlotter(\n",
    "    variable=m_miss_sb_info.hist_var,\n",
    "    fit_model=my_fit_model_wd,\n",
    "    reference_dimension=0,\n",
    "    involved_hist_variables=[m_miss_sb_info.hist_var, pStarL_sb_info.hist_var, miss_mom_sb_info.hist_var],\n",
    "    channel_label_dict=dec_titles\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_result_plotter_wd.plot_fit_result(\n",
    "    use_initial_values=True,\n",
    "    output_dir_path=\"/home/fmetzner/Downloads/fit_result_plot_examples/\",\n",
    "    output_name_tag=\"Data_fixed_Nuisance_Params\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fitter_wd = TemplateFitter(fit_model=my_fit_model_wd, minimizer_id=\"iminuit\")\n",
    "for i in range(9):\n",
    "    my_fitter_wd.set_parameter_bounds(param_id=i, bounds=(0., None))\n",
    "    \n",
    "my_fitter_wd\n",
    "my_fitter_wd.do_fit(update_templates=True, get_hesse=True, verbose=True, fix_nui_params=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_result_plotter_wd.plot_fit_result(\n",
    "    use_initial_values=False,\n",
    "    output_dir_path=\"/home/fmetzner/Downloads/fit_result_plot_examples/\",\n",
    "    output_name_tag=\"Data_fixed_Nuisance_Params\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Second Fitter Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_order_one = [\"Dl\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_handler_2 = ParameterHandler()\n",
    "my_fit_model_2 = FitModel(parameter_handler=param_handler_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for comp in plot_order_one:\n",
    "    my_fit_model_2.add_model_parameter(\n",
    "        name=f\"yield_{comp}\",\n",
    "        parameter_type=ParameterHandler.yield_parameter_type,\n",
    "        floating=True,\n",
    "        initial_value=initial_yield_dict[comp],\n",
    "        constrain_to_value=None,\n",
    "        constraint_sigma=None\n",
    "    )\n",
    "    \n",
    "channel_templates_2 = defaultdict(list)\n",
    "channel_eff_parameters_2 = defaultdict(list)\n",
    "\n",
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name != \"all_modes\":\n",
    "        continue\n",
    "        \n",
    "    for comp in plot_order_one:\n",
    "        reco_id = rdstar_sig_queries[comp][\"id\"]\n",
    "        \n",
    "        template = Template(\n",
    "            name=f\"{mode_name}_{comp}\",\n",
    "            process_name=comp,\n",
    "            dimensions=1,\n",
    "            bins=rdstar_miss_mass_binning_for_dec_modes[mode_name],\n",
    "            scope=m_miss_sb_info.hist_var.scope,\n",
    "            params=param_handler_2,\n",
    "            data_column_names=m_miss_sb_info.hist_var.df_label,\n",
    "            data=df_mc.loc[\n",
    "        df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)\n",
    "            ].query(f\"SIG_ID == {reco_id}\"),\n",
    "            weights=weight_col_for_fit,\n",
    "            systematics=get_systematics(df=df_mc, sys_cols_infos=full_systematics_cols),\n",
    "            log_scale_mask=False\n",
    "        )\n",
    "        \n",
    "        template_id = my_fit_model_2.add_template(\n",
    "            template=template,\n",
    "            yield_parameter=f\"yield_{comp}\",\n",
    "            use_other_systematics=True\n",
    "        )\n",
    "        channel_templates_2[mode_name].append(f\"temp_{template_id}\")\n",
    "        \n",
    "        eff_param_name = f\"eff_{mode_name}_{comp}\"\n",
    "        my_fit_model_2.add_model_parameter(\n",
    "            name=eff_param_name,\n",
    "            parameter_type=\"efficiency\",\n",
    "            floating=False,\n",
    "            initial_value=initial_eff_dict[comp][mode_name],\n",
    "            constrain_to_value=initial_eff_dict[comp][mode_name],\n",
    "            constraint_sigma=0.1\n",
    "        )\n",
    "        channel_eff_parameters_2[mode_name].append(eff_param_name)\n",
    "        \n",
    "    my_fit_model_2.add_channel(\n",
    "            efficiency_parameters=channel_eff_parameters_2[mode_name],\n",
    "            name=f\"mode_{mode_name}\",\n",
    "            components=channel_templates_2[mode_name],\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_channel_infos = {}\n",
    "data_channel_weight_infos = {}\n",
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name != \"all_modes\":\n",
    "        continue\n",
    "        \n",
    "    reco_id = rdstar_sig_queries[plot_order_one[0]][\"id\"]\n",
    "    sig_cond = df_mc.SIG_ID == reco_id\n",
    "    \n",
    "    data_channel_infos.update({\n",
    "        f\"mode_{mode_name}\":\n",
    "        df_mc.loc[df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids) & sig_cond]\n",
    "    })\n",
    "    \n",
    "    data_channel_weight_infos.update({f\"mode_{mode_name}\": weight_col_for_fit})\n",
    "\n",
    "my_fit_model_2.add_data(channels=data_channel_infos, channel_weights=data_channel_weight_infos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fit_model_2.finalize_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fitter_2 = TemplateFitter(fit_model=my_fit_model_2, minimizer_id=\"iminuit\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_fitter_2.do_fit(update_templates=False, get_hesse=True, verbose=True, fix_nui_params=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testing application of factor 2 in statistical_error_squared array:\n",
    "# Yield before: yield_Dl  12640  112.414\n",
    "# Yield after: yield_Dl   12640  112.414 -> No change!\n",
    "# Increasing statistics overall by adding factor 2 to the weights:\n",
    "# Yield after: yield_Dl   25270  158.965 -> Increase by factor sqrt(2)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_result_plotter_2 = FitResultPlotter(\n",
    "    variable=m_miss_sb_info.hist_var,\n",
    "    fit_model=my_fit_model_2,\n",
    "    reference_dimension=0\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_result_plotter_2.plot_fit_result()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Max' Fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "\n",
    "import maxtemplatefitter as tf\n",
    "matplotlib.use('Agg')\n",
    "\n",
    "num_bins = rdstar_miss_mass_binning_for_dec_modes\n",
    "limits = m_miss_sb_info.hist_var.scope\n",
    "\n",
    "\n",
    "mct = tf.templates.MultiChannelTemplate()\n",
    "\n",
    "for comp in plot_order_one:\n",
    "    mct.define_process(comp)\n",
    "\n",
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name != \"all_modes\":\n",
    "        continue\n",
    "        \n",
    "    mct.define_channel(mode_name, num_bins[mode_name], limits)\n",
    "        \n",
    "    for comp in plot_order_one:\n",
    "        reco_id = rdstar_sig_queries[comp][\"id\"]\n",
    "        \n",
    "        sig_q = df_mc.SIG_ID == reco_id\n",
    "        mode_q = df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)\n",
    "        \n",
    "        data = df_mc.loc[sig_q & mode_q, m_miss_sb_info.hist_var.df_label].values\n",
    "        weight = df_mc.loc[sig_q & mode_q, weight_col_for_fit].values\n",
    "        \n",
    "        temp_hist = tf.histograms.Hist1d(bins=num_bins[mode_name], range=limits, data=data, weights=weight)\n",
    "        temp = tf.templates.Template1d(comp, \"missingMass\", temp_hist, color=get_rdstar_color_dict()[reco_id])\n",
    "\n",
    "        mct.add_template(mode_name, comp, temp, initial_eff_dict[comp][mode_name])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for mode_name, mode_ids in mode_infos:\n",
    "    if mode_name != \"all_modes\":\n",
    "        continue\n",
    "\n",
    "    sig_q = df_mc.SIG_ID == rdstar_sig_queries[plot_order_one[0]][\"id\"]\n",
    "    mode_q = df_mc.daughter__bo1__cm__spextraInfo__bodecayModeID__bc__bc.isin(mode_ids)\n",
    "    \n",
    "    sdata = df_mc.loc[mode_q & sig_q, m_miss_sb_info.hist_var.df_label].values\n",
    "    sweight = df_mc.loc[mode_q & sig_q, weight_col_for_fit].values\n",
    "    info_dict = {mode_name: tf.histograms.Hist1d(num_bins[mode_name], limits, data=sdata, weights=sweight)}\n",
    "        \n",
    "    mct.add_data(**info_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for channel in mct.channels.values():\n",
    "    fig, axis = plt.subplots(1,1, figsize=(5,5), dpi=200)\n",
    "    channel.plot_stacked_on(axis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxfitter = tf.TemplateFitter(mct, \"iminuit\")\n",
    "\n",
    "maxfitter.do_fit(update_templates=True, get_hesse=True, verbose=True, fix_nui_params=False)\n",
    "print(mct.rate_uncertainties_nui_params)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for channel in mct.channels.values():\n",
    "    fig, axis = plt.subplots(1,1, figsize=(5,5), dpi=200)\n",
    "    channel.plot_stacked_on(axis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "git": {
   "suppress_outputs": true
  },
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (Belle2)",
   "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}