def get_randomized_source_counts(self, source_model_counts): idx = self._spectrum_plugin.observed_count_errors > 0 randomized_source_counts = np.zeros_like(source_model_counts) randomized_source_counts[idx] = np.random.normal( loc=source_model_counts[idx], scale=self._spectrum_plugin.observed_count_errors[idx], ) # Issue a warning if the generated background is less than zero, and fix it by placing it at zero idx = randomized_source_counts < 0 # type: np.ndarray negative_source_n = nb_sum(idx) if negative_source_n > 0: log.warning( "Generated source has negative counts " "in %i channels. Fixing them to zero" % (negative_source_n) ) randomized_source_counts[idx] = 0 return randomized_source_counts
def get_randomized_background_counts(self): # Now randomize the expectations. _, background_model_counts = self.get_current_value() # We cannot generate variates with zero sigma. They variates from those channel will always be zero # This is a limitation of this whole idea. However, remember that by construction an error of zero # it is only allowed when the background counts are zero as well. idx = self._spectrum_plugin.background_count_errors > 0 randomized_background_counts = np.zeros_like(background_model_counts) randomized_background_counts[idx] = np.random.normal( loc=background_model_counts[idx], scale=self._spectrum_plugin.background_count_errors[idx], ) # Issue a warning if the generated background is less than zero, and fix it by placing it at zero idx = randomized_background_counts < 0 # type: np.ndarray negative_background_n = nb_sum(idx) if negative_background_n > 0: log.warning( "Generated background has negative counts " "in %i channels. Fixing them to zero" % (negative_background_n) ) randomized_background_counts[idx] = 0 return randomized_background_counts
def get_current_value(self, precalc_fluxes: Optional[np.array]=None): expected_model_counts = self._spectrum_plugin.get_model(precalc_fluxes=precalc_fluxes) loglike, bkg_model = poisson_observed_gaussian_background( self._spectrum_plugin.current_observed_counts, self._spectrum_plugin.current_background_counts, self._spectrum_plugin.current_background_count_errors, expected_model_counts, ) return nb_sum(loglike), bkg_model
def get_current_value(self, precalc_fluxes: Optional[np.array]=None): # Scale factor between source and background spectrum model_counts = self._spectrum_plugin.get_model(precalc_fluxes=precalc_fluxes) loglike, bkg_model = poisson_observed_poisson_background( self._spectrum_plugin.current_observed_counts, self._spectrum_plugin.current_background_counts, self._spectrum_plugin.scale_factor, model_counts, ) return nb_sum(loglike), bkg_model
def get_current_value(self, precalc_fluxes: Optional[np.array]=None): model_counts = self._spectrum_plugin.get_model(precalc_fluxes=precalc_fluxes) chi2_ = half_chi2( self._spectrum_plugin.current_observed_counts, self._spectrum_plugin.current_observed_count_errors, model_counts, ) assert np.all(np.isfinite(chi2_)) return nb_sum(chi2_) * (-1), None
def get_current_value(self, precalc_fluxes: Optional[np.array]=None): # In this likelihood the background becomes part of the model, which means that # the uncertainty in the background is completely neglected model_counts = self._spectrum_plugin.get_model(precalc_fluxes=precalc_fluxes) loglike, _ = poisson_log_likelihood_ideal_bkg( self._spectrum_plugin.current_observed_counts, self._spectrum_plugin.current_scaled_background_counts, model_counts, ) return nb_sum(loglike), None
def get_current_value(self, precalc_fluxes: Optional[np.array]=None): # In this likelihood the background becomes part of the model, which means that # the uncertainty in the background is completely neglected model_counts = self._spectrum_plugin.get_model(precalc_fluxes=precalc_fluxes) # we scale the background model to the observation background_model_counts = ( self._spectrum_plugin.get_background_model() * self._spectrum_plugin.scale_factor ) loglike, _ = poisson_log_likelihood_ideal_bkg( self._spectrum_plugin.current_observed_counts, background_model_counts, model_counts, ) bkg_log_like = self._spectrum_plugin.background_plugin.get_log_like() total_log_like = nb_sum(loglike) + bkg_log_like return total_log_like, None
def _log_like(self, trial_values): """Compute the log-likelihood""" # Get the value of the log-likelihood for this parameters try: log_like_values = np.zeros(self._n_plugins) # Loop over each dataset and get the likelihood values for each set if not self._share_spectrum: # Old way; every dataset independendly - This is fine if the # spectrum calc is fast. for i, dataset in enumerate(self._data_list.values()): log_like_values[i] = dataset.get_log_like() else: # If the calculation for the input spectrum of one of the sources is expensive # we want to avoid calculating the same thing several times. # Precalc the spectrum for all different Ebin_in that are used in the plugins precalc_fluxes = [] for base_key, e_edges in zip( self._share_spectrum_object.base_plugin_key, self._share_spectrum_object.data_ein_edges): if e_edges is None: precalc_fluxes.append(None) else: precalc_fluxes.append( self._data_list[base_key]._integral_flux()) # Use these precalculated spectra to get the log_like for all plugins for i, dataset in enumerate(list(self._data_list.values())): # call get log_like with precalculated spectrum if self._share_spectrum_object.data_ein_edges[ self._share_spectrum_object. data_ebin_connect[i]] is not None: log_like_values[i] = dataset.get_log_like( precalc_fluxes=precalc_fluxes[ self._share_spectrum_object. data_ebin_connect[i]]) else: log_like_values[i] = dataset.get_log_like() except ModelAssertionViolation: # Fit engine or sampler outside of allowed zone return -np.inf except: # We don't want to catch more serious issues raise # Sum the values of the log-like log_like = nb_sum(log_like_values) if not np.isfinite(log_like): # Issue warning keys = self._likelihood_model.free_parameters.keys() params = [ f"{key}: {self._likelihood_model.free_parameters[key].value}" for key in keys ] log.warning( f"Likelihood value is infinite for parameters: {params}") return -np.inf return log_like