add choise to use customized number of syst uncertainties

FAIR_universe_Higgs_tautau/config.yml

@@ -1,7 +1,29 @@
 General:
-      Measurement    : higgs_tautau_signal_strength
+      Measurement    : 
+          - Name : higgs_tautau_signal_strength_htautau_nosyst 
+            ParametersToFit : 
+                - mu_htautau
+            POI : mu_htautau
+          - Name : higgs_tautau_signal_strength_nosyst 
+            ParametersToFit :
+                - mu_htautau
+                - mu_ztautau
+                - mu_ttbar
+            POI : mu_htautau
+          - Name : higgs_tautau_signal_strength_htautau_ztautau_nosyst 
+            ParametersToFit :
+                - mu_htautau
+                - mu_ztautau
+            POI : mu_htautau 
+          - Name  : higgs_tautau_signal_strength
+            ParametersToFit :
+                -
+            POI : mu_htautau
+
+
+      #Measurement : higgs_tautau_signal_strength
       POI            : mu_htautau
-
+#use_syst : False
 Samples:
     - Name              : htautau
       Tree              : tree_htautau
@@ -197,7 +219,4 @@ Regions:
                ModelsDn: saved_datasets/output_training_systematics/output_model_params_ztautau_JES_Dn/
                RatiosUp: saved_datasets/output_training_systematics/output_ratios_ztautau_JES_Up/ratio_JES_Up.npy
                RatiosDn: saved_datasets/output_training_systematics/output_ratios_ztautau_JES_Dn/ratio_JES_Dn.npy
-
-
-
-
+

src/nsbi_common_utils/model.py

@@ -104,9 +104,11 @@ def _make_map_index_norm(self):
         Maps the index of parameter in the parameter vector to norm factor
         """
         dict_index_normfactor = {}
+        #print(self.list_normfactors)
         for normfactor in self.list_normfactors:
-            index = self.list_parameters.index( normfactor )
-            dict_index_normfactor[normfactor] = index
+            if normfactor in self.list_parameters:
+                index = self.list_parameters.index( normfactor )
+                dict_index_normfactor[normfactor] = index
         return dict_index_normfactor
 
     def _get_param_vec_initial(self):
@@ -367,8 +369,9 @@ def _calculate_norm_variations(self, param_vec):
         for sample in self.all_samples:
             params_sample: list[str] = self.norm_sample_map[sample]
             for param in params_sample:
-                index_param             = self.index_normparam_map[param]
-                norm_var[sample]        *= param_vec[index_param]
+                if param in self.index_normparam_map.keys():
+                    index_param             = self.index_normparam_map[param]
+                    norm_var[sample]        *= param_vec[index_param]
         return norm_var
 
     def _get_systematic_data(self, type_of_fit: str) -> Dict[str, jnp.ndarray]:

src/nsbi_common_utils/workspace_builder.py

@@ -166,11 +166,16 @@ def channels(self) -> List[Dict[str, Any]]:
                 current_sample.update({"name": sample_name})
 
                 sample_path     = sample_dict["SamplePath"]
-                branches_to_load_sample  = branches_to_load.copy()
+                branches_to_load_sample  = branches_to_load.copy(
+
+                )
 
                 datasets            = nsbi_common_utils.datasets.datasets(self.config_path,
                                                                     branches_to_load =  branches_to_load_sample)
+                # if self.config_dict["use_syst"]:
                 datasets_incl       = datasets.load_datasets_from_config(load_systematics = True)
+                # else :
+                #     datasets_incl       = datasets.load_datasets_from_config(load_systematics = False)
                 dataset_region_dict = datasets.filter_region_by_type(datasets_incl, 
                                                                      region = channel_name)
 
@@ -228,42 +233,52 @@ def channels(self) -> List[Dict[str, Any]]:
     def measurements(self):
 
         measurements = []
-        measurement = {}
-        measurement.update({"name": self.config_dict["General"]["Measurement"]})
-        config_dict = {}
-
-        # get the norm factor initial values / bounds / constant setting
-        parameters_list = []
-        for nf in self.config_dict.get("NormFactors", []):
-            nf_name = nf["Name"]  # every NormFactor has a name
-            init = nf.get("Nominal", None)
-            bounds = nf.get("Bounds", None)
-
-            parameter = {"name": nf_name}
-            if init is not None:
-                parameter.update({"inits": [init]})
-            if bounds is not None:
-                parameter.update({"bounds": [bounds]})
-
-            parameters_list.append(parameter)
-
-        for sys in self.config_dict.get("Systematics", []):
-            sys_name = sys["Name"]
-            init = sys.get("Nominal", None)
-            bounds = sys.get("Bounds", None)
-
-            parameter = {"name": sys_name}
-            if init is not None:
-                parameter.update({"inits": [init]})
-            if bounds is not None:
-                parameter.update({"bounds": [bounds]})
-            parameters_list.append(parameter)
-
-        parameters = {"parameters": parameters_list}
-        config_dict.update(parameters)
-        config_dict.update({"poi": self.config_dict["General"].get("POI", "")})
-        measurement.update({"config": config_dict})
-        measurements.append(measurement)
+
+        for measurement_ in self.config_dict["General"]["Measurement"]:
+            print(measurement_["Name"])
+            measurement = {}
+
+            measurement.update({"name": measurement_["Name"]})
+            config_dict = {}
+
+            # get the norm factor initial values / bounds / constant setting
+            parameters_list = []
+            for nf in self.config_dict.get("NormFactors", []):
+                nf_name = nf["Name"]  # every NormFactor has a name
+                init = nf.get("Nominal", None)
+                bounds = nf.get("Bounds", None)
+
+                parameter = {"name": nf_name}
+                if init is not None:
+                    parameter.update({"inits": [init]})
+                if bounds is not None:
+                    parameter.update({"bounds": [bounds]})
+                if nf_name in measurement_["ParametersToFit"] and measurement_["ParametersToFit"]:
+                    parameters_list.append(parameter)
+                else :
+                    parameters_list.append(parameter)
+
+            for sys in self.config_dict.get("Systematics", []):
+                sys_name = sys["Name"]
+                init = sys.get("Nominal", None)
+                bounds = sys.get("Bounds", None)
+
+                parameter = {"name": sys_name}
+                if init is not None:
+                    parameter.update({"inits": [init]})
+                if bounds is not None:
+                    parameter.update({"bounds": [bounds]})
+                if sys_name in measurement_["ParametersToFit"] and measurement_["ParametersToFit"]:
+                    parameters_list.append(parameter)
+                else :
+                    parameters_list.append(parameter)
+
+            parameters = {"parameters": parameters_list}
+            config_dict.update(parameters)
+            config_dict.update({"poi": measurement_.get("POI", "")})
+            measurement.update({"config": config_dict})
+            measurements.append(measurement)
+        #print(measurements)
         return measurements