def binned_to_array(self, key, src_representation, dest_representation): """Augmented binned data to array data""" logging.trace('Transforming %s binned to array data' % (key)) self.representation = src_representation weights = self[key] if not src_representation.is_irregular: logging.trace( f"Container `{self.name}`: regularized lookup for {key}") sample = [] dimensions = [] for d in src_representation: if d.is_log: self.representation = "log_events" sample.append(self[d.name]) dimensions.append( OneDimBinning(d.name, domain=np.log(d.domain.m), num_bins=d.num_bins)) else: self.representation = "events" sample.append(self[d.name]) dimensions.append(d) hist_binning = MultiDimBinning(dimensions) else: logging.trace( f"Container `{self.name}`: irregular lookup for {key}") self.representation = dest_representation sample = [self[name] for name in src_representation.names] hist_binning = src_representation return lookup(sample, weights, hist_binning)
def binned_to_array(self, key): """Augmented binned data to array data""" try: binning, hist = self.binned_data[key] except KeyError: if key in self.array_data: logging.debug('No transformation for `%s` array data in container `%s`'%(key, self.name)) return else: raise ValueError('Key `%s` does not exist in container `%s`'%(key, self.name)) logging.debug('Transforming %s binned to array data'%(key)) sample = [self.array_data[n] for n in binning.names] self.add_array_data(key, lookup(sample, hist, binning))
def apply(self): # DO NOT USE THIS STAGE AS YOUR TEMPLATE IF YOU ARE NEW TO PISA! # -------------------------------------------------------------- # # We are overwriting the `apply` method rather than the `apply_function` method # because we are manipulating the data binning in a delicate way that doesn't # work with automatic rebinning. self.data.data_specs = self.input_specs if self.scale_errors: for container in self.data: vectorizer.pow( vals=container["errors"], pwr=2, out=container["variances"], ) input_binvols = SmartArray( self.input_specs.weighted_bin_volumes(attach_units=False).ravel()) output_binvols = SmartArray( self.output_specs.weighted_bin_volumes(attach_units=False).ravel()) for container in self.data: self.data.data_specs = self.input_specs # we want these to be SmartArrays, so no `.get(WHERE)` weights_flat_hist = container["weights"] if self.scale_errors: vars_flat_hist = container["variances"] self.data.data_specs = self.output_specs if self.rs_mode == ResampleMode.UP: # The `unroll_binning` function returns the midpoints of the bins in the # dimension `name`. fine_gridpoints = [ SmartArray( container.unroll_binning(name, self.output_specs)) for name in self.output_specs.names ] # We look up at which bin index of the input binning the midpoints of # the output binning can be found, and assign to each the content of the # bin of that index. container["weights_resampled"] = translation.lookup( fine_gridpoints, weights_flat_hist, self.input_specs, ) if self.scale_errors: container["vars_resampled"] = translation.lookup( fine_gridpoints, vars_flat_hist, self.input_specs, ) # These are the volumes of the bins we sample *from* origin_binvols = translation.lookup( fine_gridpoints, input_binvols, self.input_specs, ) # Finally, we scale the weights and variances by the ratio of the # bin volumes in place: vectorizer.imul(output_binvols, container["weights_resampled"]) vectorizer.itruediv(origin_binvols, container["weights_resampled"]) if self.scale_errors: vectorizer.imul(output_binvols, container["vars_resampled"]) vectorizer.itruediv(origin_binvols, container["vars_resampled"]) elif self.rs_mode == ResampleMode.DOWN: pass # not yet implemented if self.scale_errors: vectorizer.sqrt(vals=container["vars_resampled"], out=container["errors_resampled"])