removed ambiguity in variable names

bye_splits/data_handle/event.py

@@ -158,7 +158,7 @@ def select(self):
         with up.open(self.indata.path, array_cache='550 MB', num_workers=8) as f:
             tree = f[self.indata.tree_path]
             allvars = set([y for x in self.var.values() for y in x.values()])
-            data = tree.arrays(filter_name='/' + '|'.join(allvars) + '/', library='ak')
+            data = tree.arrays(filter_name='/' + '|'.join(allvars) + '/', entry_stop=200, library='ak')
         # data[self.var.v] = data.waferv
         # data[self.newvar.vs] = -1 * data.waferv
         # data[self.newvar.c] = "#8a2be2"

bye_splits/plot/display_plotly/__init__.py

@@ -0,0 +1,6 @@
+import yaml
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import dash_bootstrap_components as dbc
+import dash.dcc as dcc

bye_splits/plot/display_plotly/main.py

@@ -80,11 +80,11 @@ def make_graph(data, slider_value, coef, mip, checkbox, page):
     assert float(mip) >= 0.5, 'mip\u209C value out of range. Minimum value 0.5 !'
     df_dict = {k: pd.read_json(v) for k, v in data.items()}
     df = df_dict[str(coef)]
-    df_sel = df[df.mipPt >= mip]
+    df_sel = df[df.tc_mipPt >= mip]
 
     if page == '3D':
         if 'Layer selection' in checkbox:
-            df_sel = df_sel[(df_sel.layer >= slider_value[0]) & (df_sel.layer <= slider_value[1])]
+            df_sel = df_sel[(df_sel.tc_layer >= slider_value[0]) & (df_sel.tc_layer <= slider_value[1])]
 
         if 'Seed index' in checkbox: discrete = True
         else: discrete = False
@@ -96,7 +96,7 @@ def make_graph(data, slider_value, coef, mip, checkbox, page):
         if 'Coarse seeding' in checkbox:
             plt.add_CS(fig, df_sel) 
     else:
-        df_sel = df_sel[df_sel.layer == slider_value]
+        df_sel = df_sel[df_sel.tc_layer == slider_value]
 
         if 'Cluster trigger cells' in checkbox: 
             df_no_cluster = df_sel[df_sel.tc_cluster_id == 0]

bye_splits/plot/display_plotly/plot_event.py

@@ -24,16 +24,16 @@ def geom_selection(df_dict):
 
 def prepare_slider(df, page='3D'):
     slider_options = {
-        'min': df['layer'].min(),
-        'max': df['layer'].max(),
+        'min': df['tc_layer'].min(),
+        'max': df['tc_layer'].max(),
         'step': None,
-        'marks': {int(layer): {"label": str(int(layer))} for each, layer in enumerate(sorted(df['layer'].unique()))},
+        'marks': {int(layer): {"label": str(int(layer))} for each, layer in enumerate(sorted(df['tc_layer'].unique()))},
         'id': 'slider'
     }
 
     if page == '3D':
         return dcc.RangeSlider(
-            value=[df['layer'].min(), df['layer'].max()],
+            value=[df['tc_layer'].min(), df['tc_layer'].max()],
             **slider_options
         )
     else:
@@ -110,13 +110,13 @@ def update_figure(fig, df, plot_type='2D', discrete=False):
 
 def produce_plot(df, opacity, plot_type, discrete):
     if plot_type == '2D':
-        array_data = df[['diamond_x', 'diamond_y', 'tc_x', 'tc_y', 'colors', 'mipPt']].to_numpy()
+        array_data = df[['diamond_x', 'diamond_y', 'tc_x', 'tc_y', 'colors', 'tc_mipPt']].to_numpy()
         x_column, y_column = 'diamond_x', 'diamond_y'
     elif plot_type == '3D':
         if discrete:
-            array_data = df[['diamond_x', 'diamond_y', 'z', 'waferu', 'waferv', 'color_clusters', 'mipPt']].to_numpy()
+            array_data = df[['diamond_x', 'diamond_y', 'z', 'tc_wu', 'tc_wv', 'color_clusters', 'tc_mipPt']].to_numpy()
         else:
-            array_data = df[['diamond_x', 'diamond_y', 'z', 'waferu', 'waferv', 'color_energy', 'mipPt']].to_numpy()
+            array_data = df[['diamond_x', 'diamond_y', 'z', 'tc_wu', 'tc_wv', 'color_energy', 'tc_mipPt']].to_numpy()
         x_column, y_column = 'z', 'diamond_x'
     else:
         raise ValueError("Invalid plot_type. Choose '2D' or '3D'.")
@@ -143,8 +143,8 @@ def produce_plot(df, opacity, plot_type, discrete):
     if opacity == 1 and not discrete and plot_type == '3D':
         datum = go.Scatter3d(x=[None], y=[None], z=[None], mode="markers", marker=dict(
             colorscale='viridis',
-            cmin=df.mipPt.min(),
-            cmax=df.mipPt.max(),
+            cmin=df.tc_mipPt.min(),
+            cmax=df.tc_mipPt.max(),
             showscale=True,
             colorbar=dict(title=dict(text="[mip\u209c]", side="right"), ticks="outside", x=1)
         ))

bye_splits/plot/display_plotly/processing.py

@@ -90,33 +90,35 @@ def store_event(self, path, data):
 
     def process_event(self, dict_events, gen_info):
 
-        tc_keep = {'seed_idx'  : 'seed_idx',
-                   'tc_mipPt'  : 'mipPt',
-                   'tc_eta'    : 'tc_eta',
-                   'tc_wu'     : 'waferu',
-                   'tc_wv'     : 'waferv',
-                   'tc_cu'     : 'triggercellu',
-                   'tc_cv'     : 'triggercellv',
-                   'tc_layer'  : 'layer'}
+        tc_keep = {'seed_idx'     : 'seed_idx',
+                   'mipPt'        : 'tc_mipPt',
+                   'tc_eta'       : 'tc_eta',
+                   'waferu'       : 'tc_wu',
+                   'waferv'       : 'tc_wv',
+                   'triggercellu' : 'tc_cu',
+                   'triggercellv' : 'tc_cv',
+                   'layer'        : 'tc_layer'}
 
-        sci_update = {'triggercellieta': 'triggercellu',
-                      'triggercelliphi': 'triggercellv',
-                      'tc_wu'          : 'waferu'}
+        sci_update = {'triggercellieta' : 'tc_cu',
+                      'triggercelliphi' : 'tc_cv',
+                      'layer'           : 'tc_layer',
+                      'waferu'          : 'tc_wu'}
+
+        self.ds_geom['si']  = self.ds_geom['si'].rename(columns=tc_keep)
         self.ds_geom['sci'] = self.ds_geom['sci'].rename(columns=sci_update)
 
         for event in dict_events.keys():
             print('Procesing event '+str(event))
             dict_event = dict_events[event]
             for coef in dict_event.keys():
-                dict_event[coef] = dict_event[coef].rename(columns=tc_keep)
                 silicon_df = pd.merge(left=dict_event[coef], right=self.ds_geom['si'], how='inner',
-                                      on=['layer', 'waferu', 'waferv', 'triggercellu', 'triggercellv'])
+                                      on=['tc_layer', 'tc_wu', 'tc_wv', 'tc_cu', 'tc_cv'])
                 silicon_df = silicon_df.drop(['waferorient', 'waferpart'], axis=1)
                 scintillator_df = pd.merge(left=dict_event[coef], right=self.ds_geom['sci'], how='inner',
-                                           on=['layer', 'waferu', 'triggercellu', 'triggercellv'])
+                                           on=['tc_layer', 'tc_wu', 'tc_cu', 'tc_cv'])
 
                 dict_event[coef] = pd.concat([silicon_df, scintillator_df]).reset_index(drop=True)
-                color_continuous = common.colorscale(dict_event[coef], 'mipPt', 'viridis')
+                color_continuous = common.colorscale(dict_event[coef], 'tc_mipPt', 'viridis')
                 color_discrete   = common.colorscale(dict_event[coef], 'seed_idx', qualitative.Light24, True)
                 dict_event[coef] = dict_event[coef].assign(color_energy=color_continuous, color_clusters=color_discrete)
 

bye_splits/production/produce.py

@@ -91,7 +91,7 @@ def skim(tn, inf, outf, particle, nevents):
 
     # gen-related variables
     gen_intv = ["genpart_pid"]
-    gen_floatv = ["genpart_exphi", "genpart_exeta", "genpart_energy"]
+    gen_floatv = ["genpart_exphi", "genpart_exeta", "genpart_energy", "genpart_pt"]
     gen_floatv2 = []
     #gen_floatv2 = ["genpart_posx", "genpart_posy", "genpart_posz"]
     gen_v = gen_intv + gen_floatv + gen_floatv2

bye_splits/scripts/run_radii_chain.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+_all_ = [ "run_default_chain" ]
+
+import os
+from pathlib import Path
+import sys
+
+parent_dir = os.path.abspath(__file__ + 2 * "/..")
+sys.path.insert(0, parent_dir)
+
+import yaml
+import tasks
+import utils
+from utils import params, common, parsing
+import data_handle
+from data_handle.data_process import EventDataParticle, get_data_reco_chain_start
+from data_handle.geometry import GeometryData
+import plot
+from plot import chain_plotter
+from tasks import validation
+
+import argparse
+import pandas as pd
+
+def run_radii_chain(pars, particles, PU, coefs, event=None):
+    df_gen, df_cl, df_tc = get_data_reco_chain_start(nevents=30, reprocess=True, particles=particles, PU=PU, event=event)
+
+    fill_d = params.read_task_params("fill")
+    tasks.fill.fill(pars, df_gen, df_cl, df_tc, **fill_d)
+
+    smooth_d = params.read_task_params("smooth")
+    tasks.smooth.smooth(pars, **smooth_d)
+
+    seed_d = params.read_task_params("seed")
+    tasks.seed.seed(pars, **seed_d)
+
+    cluster_d = params.read_task_params("cluster")
+    dict_cluster = {}
+    for coef in coefs:
+        cluster_d["CoeffA"] = [coef, 0] * 50
+        nevents = tasks.cluster.cluster_default(pars, **cluster_d)
+        store_file = pd.HDFStore(common.fill_path(cluster_d["ClusterOutPlot"], **pars), mode='r')
+        df_list = []
+        filtered_keys = [key for key in store_file.keys() if key.startswith('/df_')]
+        events = [int(key.split('df_')[1]) for key in filtered_keys]
+        for key in filtered_keys:
+            df = store_file.get(key)
+            df_list.append(df)
+        dict_cluster[str(coef)[2:]] = df_list
+        store_file.close() 
+
+    dict_event = {}
+    for index, ev in enumerate(events):
+        dict_event[ev] = {}
+        df_event_tc = df_tc[df_tc.event == ev][['tc_mipPt','tc_eta','tc_wu','tc_wv','tc_cu','tc_cv','tc_layer']]
+        for coef in dict_cluster.keys():
+            dict_event[ev][coef] = pd.merge(left=dict_cluster[coef][index], 
+                                            right=df_event_tc[df_event_tc.tc_layer%2 != 0], 
+                                            on=['tc_wu', 'tc_wv', 'tc_cu', 'tc_cv', 'tc_layer'],
+                                            how='outer').fillna(dict_cluster[coef][index]['seed_idx'].max()+1) 
+    return dict_event, df_gen
+
+if __name__ == "__main__":
+    FLAGS = parsing.parser_radii_chain()
+    if FLAGS.no_valid:
+        FLAGS.no_valid_seed = True
+        FLAGS.no_valid_cluster = True
+
+    assert (FLAGS.sel in ("splits_only", "no_splits", "all") or
+            FLAGS.sel.startswith("above_eta_"))
+
+    run_radii_chain(common.dot_dict(vars(FLAGS)), particles=FLAGS.particles, PU=FLAGS.PU, coefs=FLAGS.coefs, event=FLAGS.event)

bye_splits/scripts/run_roi_chain.py

@@ -69,4 +69,4 @@ def run_roi_chain(pars, user='bfontana'):
     assert (FLAGS.sel in ('splits_only', 'no_splits', 'all') or
             FLAGS.sel.startswith('above_eta_'))
 
-    run_roi_chain(common.dot_dict(vars(FLAGS)))
+    run_roi_chain(common.dot_dict(vars(FLAGS)), user=FLAGS.user)

bye_splits/tasks/fill.py

@@ -61,7 +61,8 @@ def fill(pars, df_gen, df_cl, df_tc, **kw):
                 continue
 
             keep_tc = ['tc_phi_bin', 'Rz_bin', 'tc_layer', 'tc_mipPt', 'tc_pt',
-                       'tc_x', 'tc_y', 'tc_z', 'tc_eta', 'tc_phi', 'gen_eta', 'gen_phi']
+                       'tc_wu', 'tc_wv', 'tc_cu',  'tc_cv', 'tc_x', 'tc_y', 'tc_z',
+                       'tc_eta', 'tc_phi', 'gen_eta', 'gen_phi']
             ev_tc = ev_tc.filter(items=keep_tc)
             wght_f = lambda pos: ev_tc.tc_mipPt*pos/np.abs(ev_tc.tc_z)
             ev_tc['wght_x'] = wght_f(ev_tc.tc_x)

bye_splits/tasks/roi.py

@@ -50,34 +50,7 @@ def roi(pars, df_gen, df_cl, df_tc, **kw):
     """Waiting for ROI future algorithms..."""
     pass
 
-def roi_dummy_calculator(tcs, k=4, threshold=20, nearby=True):
-    with open(params.CfgPath, 'r') as afile:
-        cfg = yaml.safe_load(afile)
-        ntot = cfg['geometry']['nlayersCEE'] + cfg['geometry']['nlayersCEH']
-        availLayers = [x for x in range(1,ntot+1)
-                       if x not in cfg["selection"]["disconnectedTriggerLayers"]]
-
-    initial_layer = find_initial_layer(tcs)
-
-    mask = (tcs.tc_layer>=initial_layer) & (tcs.tc_layer<(availLayers[availLayers.index(initial_layer)+k]))
-    input_df = tcs[mask]
-    roi_df = pd.DataFrame()
-
-    module_sums = create_module_sums(input_df)
-    module_ROI = list(module_sums[module_sums.values >= threshold].index)
-    if nearby:
-        for im, module in enumerate(module_ROI):
-            nearby_modules = [(module[0]+s, module[1]-r)
-                              for s in [-1,0,1] for r in [-1,0,1] for q in [-1,0,1]
-                              if s + r + q == 0]
-            tc_roi = input_df[input_df.set_index(['tc_wu','tc_wv']).index.isin(nearby_modules)]
-            with common.SupressSettingWithCopyWarning():
-                tc_roi['roi_id'] = im
-            roi_df = pd.concat((roi_df, tc_roi), axis=0)                
-
-    return roi_df, pd.DataFrame(module_ROI)
-
-#def roi_dummy_calculator(tcs, k=4, threshold=[170, 180, 200], eta_list=[1.5, 1.9, 2.3, 3.2], nearby=True):
+#def roi_dummy_calculator(tcs, k=4, threshold=20, nearby=True):
 #    with open(params.CfgPath, 'r') as afile:
 #        cfg = yaml.safe_load(afile)
 #        ntot = cfg['geometry']['nlayersCEE'] + cfg['geometry']['nlayersCEH']
@@ -90,29 +63,60 @@ def roi_dummy_calculator(tcs, k=4, threshold=20, nearby=True):
 #    input_df = tcs[mask]
 #    roi_df = pd.DataFrame()
 #    
-#    module_sums = input_df.groupby(['tc_wu','tc_wv']).tc_mipPt.sum()
-#    eta_coord = input_df.groupby(['tc_wu','tc_wv']).tc_eta.mean()
-# 
-#    module_CS = []
-#    for index in range(len(eta_list)-1):
-#        modules = list(module_sums[(module_sums.values >= threshold[index]) &
-#                                   (eta_coord.values <= eta_list[index+1])  &
-#                                   (eta_coord.values > eta_list[index])].index)
-#        module_CS.extend(modules)
-# 
+#    module_sums = create_module_sums(input_df)
+#    module_ROI = list(module_sums[module_sums.values >= threshold].index)
 #    if nearby:
-#        for im, module in enumerate(module_CS):
+#        for im, module in enumerate(module_ROI):
 #            nearby_modules = [(module[0]+s, module[1]-r)
 #                              for s in [-1,0,1] for r in [-1,0,1] for q in [-1,0,1]
 #                              if s + r + q == 0]
-#            skimmed_modules = module_sums[module_sums.index.isin(nearby_modules)].index
+#            tc_roi = input_df[input_df.set_index(['tc_wu','tc_wv']).index.isin(nearby_modules)]
 #            with common.SupressSettingWithCopyWarning():
-#                skimmed_modules['roi_id'] = im
-#            selected_modules.extend(skimmed_modules)
-#        module_CS = selected_modules
+#                tc_roi['roi_id'] = im
+#            roi_df = pd.concat((roi_df, tc_roi), axis=0)                
 #
-#    roi_df = input_df[input_df.set_index(['tc_wu','tc_wv']).index.isin(module_CS)]
-#    return roi_df, pd.DataFrame(module_CS)
+#    return roi_df, pd.DataFrame(module_ROI)
+
+def roi_dummy_calculator(tcs, k=4, threshold=[170, 180, 200], eta_list=[1.5, 1.9, 2.3, 3.2], nearby=False):
+    with open(params.CfgPath, 'r') as afile:
+        cfg = yaml.safe_load(afile)
+        ntot = cfg['geometry']['nlayersCEE'] + cfg['geometry']['nlayersCEH']
+        availLayers = [x for x in range(1,ntot+1)
+                       if x not in cfg["selection"]["disconnectedTriggerLayers"]]
+
+    initial_layer = find_initial_layer(tcs)
+
+    mask = (tcs.tc_layer>=initial_layer) & (tcs.tc_layer<(availLayers[availLayers.index(initial_layer)+k]))
+    input_df = tcs[mask]
+    roi_df = pd.DataFrame()
+
+    module_sums = input_df.groupby(['tc_wu','tc_wv']).tc_mipPt.sum()
+    eta_coord = input_df.groupby(['tc_wu','tc_wv']).tc_eta.mean()
+
+    modules_CS = []
+    for index in range(len(eta_list)-1):
+        modules = list(module_sums[(module_sums.values >= threshold[index]) &
+                                   (eta_coord.values <= eta_list[index+1])  &
+                                   (eta_coord.values > eta_list[index])].index)
+        modules_CS.extend(modules)
+
+    if nearby:
+        selected_modules = []
+        for module in modules_CS:
+            nearby_modules = [(module[0]+s, module[1]-r)
+                              for s in [-1,0,1] for r in [-1,0,1] for q in [-1,0,1]
+                              if s + r + q == 0]
+            skimmed_modules = module_sums[module_sums.index.isin(nearby_modules)].index
+            selected_modules.extend(skimmed_modules)
+        modules_CS = selected_modules
+
+    for im, module_CS in enumerate(modules_CS):
+        tc_roi = input_df[input_df.set_index(['tc_wu','tc_wv']).index.isin(modules_CS)]
+        with common.SupressSettingWithCopyWarning():
+                tc_roi['roi_id'] = im
+        roi_df = pd.concat((roi_df, tc_roi), axis=0)
+
+    return roi_df, pd.DataFrame(modules_CS)
 
 def roi_calculator():
     pass

bye_splits/utils/parsing.py

@@ -62,18 +62,18 @@ def add_parameters(parser):
 
 def common_arguments(description):
     parser = argparse.ArgumentParser(description=description)
-    parser.add_argument("--no_seed",          action="store_true", help='do not run the seeding step')
-    parser.add_argument("--no_cluster",       action="store_true", help='do not run the clustering step')
-    parser.add_argument("--no_valid",         action="store_true", help='do not run any validation')
+    parser.add_argument('--no_seed',          action='store_true', help='do not run the seeding step')
+    parser.add_argument('--no_cluster',       action='store_true', help='do not run the clustering step')
+    parser.add_argument('--no_valid',         action='store_true', help='do not run any validation')
     parser.add_argument('--no_valid_seed',    action='store_true', help='do not run ROI seed validation')
     parser.add_argument('--no_valid_cluster', action='store_true', help='do not run ROI cluster validation')
-    parser.add_argument('--sel',  default="all",    type=str,      help="Selection used to select cluster under study")
-    parser.add_argument('--nevents',      default=100, type=int, help='Number of events')
-    parser.add_argument('--smooth_kernel',choices=("default","flat_top"), default="default", type=str, help="Type of smoothing kernel being applied")
-    parser.add_argument('--seed_window',  default=1, type=int, help='seed_help')
-    parser.add_argument("--cluster_algo", choices=("max_energy", "min_distance"), default="min_distance", type=str, help="Clustering algorithm applied.")
-    parser.add_argument('--user',  default="bfontana",    type=str,      help="User selection")
-    parser.add_argument("--reg", choices=("Si", "ECAL", "HCAL", "All", "MaxShower", "ExcludeMaxShower"), default="Si", type=str,help="Z region in the detector for the trigger cell geometry.")
+    parser.add_argument('--sel',              default='all', type=str, help='Selection used to select cluster under study')
+    parser.add_argument('--nevents',          default=100, type=int, help='Number of events')
+    parser.add_argument('--smooth_kernel',    choices=('default', 'flat_top'), default='default', type=str, help='Type of smoothing kernel being applied')
+    parser.add_argument('--seed_window',      default=1, type=int, help='seed_help')
+    parser.add_argument('--cluster_algo',     choices=('max_energy', 'min_distance'), default='min_distance', type=str, help='Clustering algorithm applied.')
+    parser.add_argument('--user',             default='bfontana', type=str, help='User selection')
+    parser.add_argument('--reg',              choices=('Si', 'ECAL', 'HCAL', 'All', 'MaxShower', 'ExcludeMaxShower'), default='Si', type=str, help='Z region in the detector for the trigger cell geometry.')
 
     return parser