brukerapi 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

brukerapi/splitters.py

@@ -1,20 +1,21 @@
-from .utils import index_to_slice
-from .dataset import Dataset
-
-import numpy as np
 import copy
+import os
 from pathlib import Path
 
-SUPPORTED_FG = ['FG_ISA','FG_IRMODE','FG_ECHO']
+import numpy as np
 
+from .dataset import Dataset
+from .exceptions import MissingProperty
+from .utils import index_to_slice
 
-class Splitter(object):
+SUPPORTED_FG = ["FG_ISA", "FG_IRMODE", "FG_ECHO"]
 
-    def write(self, datasets, path_out=None):
 
+class Splitter:
+    def write(self, datasets, path_out=None):
         for dataset in datasets:
             if path_out:
-                dataset.write('{}/{}/{}'.format(Path(path_out), dataset.path.parents[0].name, dataset.path.name))
+                dataset.write(f"{Path(path_out)}/{dataset.path.parents[0].name}/{dataset.path.name}")
             else:
                 dataset.write(dataset.path)
 
@@ -37,11 +38,11 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataMin = visu_pars['VisuCoreDataMin']
-        value = np.reshape(VisuCoreDataMin.value, dataset.shape_final[dataset.encoded_dim:], order='F')
+        VisuCoreDataMin = visu_pars["VisuCoreDataMin"]
+        value = np.reshape(VisuCoreDataMin.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataMin.size = (np.prod(value.shape),)
-        VisuCoreDataMin.value = value.flatten(order='F')
+        VisuCoreDataMin.size = (int(np.prod(value.shape)),)
+        VisuCoreDataMin.value = value.flatten(order="F")
 
     def _split_VisuCoreDataMax(self, dataset, visu_pars, select, fg_rel_index):
         """
@@ -51,11 +52,11 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataMax = visu_pars['VisuCoreDataMax']
-        value = np.reshape(VisuCoreDataMax.value, dataset.shape_final[dataset.encoded_dim:], order='F')
+        VisuCoreDataMax = visu_pars["VisuCoreDataMax"]
+        value = np.reshape(VisuCoreDataMax.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataMax.size = (np.prod(value.shape),)
-        VisuCoreDataMax.value = value.flatten(order='F')
+        VisuCoreDataMax.size = (int(np.prod(value.shape)),)
+        VisuCoreDataMax.value = value.flatten(order="F")
 
     def _split_VisuCoreDataOffs(self, dataset, visu_pars, select, fg_rel_index):
         """
@@ -65,11 +66,11 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataOffs = visu_pars['VisuCoreDataOffs']
-        value = np.reshape(VisuCoreDataOffs.value, dataset.shape_final[dataset.encoded_dim:],order='F')
+        VisuCoreDataOffs = visu_pars["VisuCoreDataOffs"]
+        value = np.reshape(VisuCoreDataOffs.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataOffs.size = (np.prod(value.shape),)
-        VisuCoreDataOffs.value = value.flatten(order='F')
+        VisuCoreDataOffs.size = (int(np.prod(value.shape)),)
+        VisuCoreDataOffs.value = value.flatten(order="F")
 
     def _split_VisuCoreDataSlope(self, dataset, visu_pars, select, fg_rel_index):
         """
@@ -79,34 +80,34 @@ class Splitter(object):
         :param fg_index:
         :return:
         """
-        VisuCoreDataSlope = visu_pars['VisuCoreDataSlope']
-        value = np.reshape(VisuCoreDataSlope.value, dataset.shape_final[dataset.encoded_dim:],order='F')
+        VisuCoreDataSlope = visu_pars["VisuCoreDataSlope"]
+        value = np.reshape(VisuCoreDataSlope.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(select, value.shape, fg_rel_index)]
-        VisuCoreDataSlope.size = (np.prod(value.shape),)
-        VisuCoreDataSlope.value = value.flatten(order='F')
+        VisuCoreDataSlope.size = (int(np.prod(value.shape)),)
+        VisuCoreDataSlope.value = value.flatten(order="F")
 
     def _split_VisuCoreTransposition(self, dataset, visu_pars, index, fg_index):
         try:
-            VisuCoreTransposition = visu_pars['VisuCoreTransposition']
+            VisuCoreTransposition = visu_pars["VisuCoreTransposition"]
         except KeyError:
             return VisuCoreTransposition
 
-        value = np.reshape(VisuCoreTransposition.value, dataset.shape_final[dataset.encoded_dim:], order='F')
+        value = np.reshape(VisuCoreTransposition.value, dataset.shape_final[dataset.encoded_dim :], order="F")
         value = value[index_to_slice(index, value.shape, fg_index - dataset.encoded_dim)]
-        VisuCoreTransposition.size = (np.prod(value.shape),)
-        VisuCoreTransposition.value = value.flatten(order='F')
+        VisuCoreTransposition.size = (int(np.prod(value.shape)),)
+        VisuCoreTransposition.value = value.flatten(order="F")
+        return None
 
 
 class FrameGroupSplitter(Splitter):
     def __init__(self, fg):
         if fg not in SUPPORTED_FG:
-            raise NotImplemented('Split operation for {} is not implemented'.format(fg))
+            raise NotImplementedError(f"Split operation for {fg} is not implemented")
 
-        super(FrameGroupSplitter, self).__init__()
+        super().__init__()
         self.fg = fg
 
-
-    def split(self, dataset, select=None, write=False, path_out=None, **kwargs):
+    def split(self, dataset, select=None, write=None, path_out=None, **kwargs):
         """Split Bruker object along a dimension of specific frame group.
         Only the frame groups listed in SPLIT_FG_IMPLEMENTED can be used to split the object.
 
@@ -121,14 +122,17 @@ class FrameGroupSplitter(Splitter):
 
         """
 
-        if "<{}>".format(self.fg) not in dataset.dim_type:
-            raise ValueError(f'Dataset does not contain {self.fg} frame group')
+        if write is None:
+            write = False
+
+        if f"<{self.fg}>" not in dataset.dim_type:
+            raise ValueError(f"Dataset does not contain {self.fg} frame group")
 
         """
         CHECK if FG and index are valid
         """
         # absolute index of FG_SLICE among dimensions of the dataset
-        fg_abs_index = dataset.dim_type.index("<{}>".format(self.fg))
+        fg_abs_index = dataset.dim_type.index(f"<{self.fg}>")
 
         # index of FG_SLICE among frame group dimensions of the dataset
         fg_rel_index = fg_abs_index - dataset.encoded_dim
@@ -136,15 +140,17 @@ class FrameGroupSplitter(Splitter):
         # number of samples in self.fg dimension
         fg_size = dataset.shape[fg_abs_index]
 
-        # If no index is specified, all elements of given dimension will be splited
+        # If no index is specified, all elements of given dimension will be split
         if select is None:
             select = list(range(0, fg_size))
 
         if isinstance(select, int):
-            select = [select,]
+            select = [
+                select,
+            ]
 
         if max(select) >= fg_size:
-            raise IndexError(f'Selection {select} out of bounds, size of {self.fg} dimension is {fg_size}')
+            raise IndexError(f"Selection {select} out of bounds, size of {self.fg} dimension is {fg_size}")
 
         """
         PERFORM splitting
@@ -153,10 +159,13 @@ class FrameGroupSplitter(Splitter):
 
         for select_ in select:
             # construct a new Dataset, without loading data, the data will be supplied later
-            name = '{}_{}_{}/2dseq'.format(dataset.path.parents[0].name, self.fg, select_)
+            name = f"{dataset.path.parents[0].name}_{self.fg}_{select_}/2dseq"
+
+            dset_path = dataset.path.parents[1] / name
+            os.makedirs(dset_path, exist_ok=True)
 
             # construct a new Dataset, without loading data, the data will be supplied later
-            dataset_ = Dataset(dataset.path.parents[1] / name, load=False)
+            dataset_ = Dataset(dataset.path.parents[1] / name, load=0)
 
             dataset_.parameters = self._split_params(dataset, select_, fg_abs_index, fg_rel_index, fg_size)
 
@@ -178,8 +187,7 @@ class FrameGroupSplitter(Splitter):
         return datasets
 
     def _split_params(self, dataset, select, fg_abs_index, fg_rel_index, fg_size):
-
-        visu_pars = copy.deepcopy(dataset.parameters['visu_pars'])
+        visu_pars = copy.deepcopy(dataset.parameters["visu_pars"])
 
         self._split_VisuCoreFrameCount(visu_pars, fg_size)
         self._split_VisuFGOrderDescDim(visu_pars)
@@ -189,12 +197,12 @@ class FrameGroupSplitter(Splitter):
         self._split_VisuCoreDataMin(dataset, visu_pars, select, fg_rel_index)
         self._split_VisuCoreDataMax(dataset, visu_pars, select, fg_rel_index)
 
-        if self.fg == 'FG_ECHO':
+        if self.fg == "FG_ECHO":
             self._split_params_FG_ECHO(dataset, select, fg_abs_index, fg_rel_index, fg_size, visu_pars)
-        if self.fg == 'FG_ISA':
+        if self.fg == "FG_ISA":
             self._split_params_FG_ISA(dataset, select, fg_abs_index, fg_rel_index, fg_size, visu_pars)
 
-        return {'visu_pars': visu_pars}
+        return {"visu_pars": visu_pars}
 
     def _split_params_FG_ISA(self, dataset, select, fg_abs_index, fg_rel_index, fg_size, visu_pars):
         self._split_VisuCoreDataUnits(visu_pars, dataset, select, fg_rel_index)
@@ -204,43 +212,42 @@ class FrameGroupSplitter(Splitter):
         self._split_VisuAcqEchoTime(visu_pars, select)
 
     def _split_VisuCoreFrameCount(self, visu_pars, fg_size):
-        VisuCoreFrameCount = visu_pars['VisuCoreFrameCount']
+        VisuCoreFrameCount = visu_pars["VisuCoreFrameCount"]
         value = int(VisuCoreFrameCount.value / fg_size)
         VisuCoreFrameCount.value = value
 
     def _split_VisuFGOrderDescDim(self, visu_pars):
-        VisuFGOrderDescDim = visu_pars['VisuFGOrderDescDim']
+        VisuFGOrderDescDim = visu_pars["VisuFGOrderDescDim"]
         value = VisuFGOrderDescDim.value - 1
 
         if value > 1:
             VisuFGOrderDescDim.value = value
         else:
-            del visu_pars['VisuFGOrderDescDim']
+            del visu_pars["VisuFGOrderDescDim"]
 
     def _split_VisuCoreDataUnits(self, visu_pars, fg_scheme, index, fg_index):
-        VisuCoreDataUnits = visu_pars['VisuCoreDataUnits']
+        VisuCoreDataUnits = visu_pars["VisuCoreDataUnits"]
         value = VisuCoreDataUnits.value
         VisuCoreDataUnits.value = value[index]
         VisuCoreDataUnits.size = (65,)
 
     def _split_VisuFGOrderDesc(self, visu_pars, fg):
-        VisuFGOrderDesc = visu_pars['VisuFGOrderDesc']
+        VisuFGOrderDesc = visu_pars["VisuFGOrderDesc"]
 
         size = VisuFGOrderDesc.size[0] - 1
         VisuFGOrderDesc.size = size
 
         value = VisuFGOrderDesc.nested
         for fg_ in value:
-            if fg_[1] == '<{}>'.format(fg):
+            if fg_[1] == f"<{fg}>":
                 value.remove(fg_)
         if value:
             VisuFGOrderDesc.value = value
         else:
-            del visu_pars['VisuFGOrderDesc']
+            del visu_pars["VisuFGOrderDesc"]
 
     def _split_VisuFGElemComment(self, visu_pars, fg_scheme, index, fg_index):
-
-        VisuFGElemComment = visu_pars['VisuFGElemComment']
+        VisuFGElemComment = visu_pars["VisuFGElemComment"]
 
         value = VisuFGElemComment.value
 
@@ -249,9 +256,9 @@ class FrameGroupSplitter(Splitter):
         VisuFGElemComment.size = (65,)
 
     def _split_VisuAcqEchoTime(self, visu_pars, select):
-        VisuAcqEchoTime = visu_pars['VisuAcqEchoTime']
-        value = VisuAcqEchoTime.value
-        VisuAcqEchoTime.size=(1,)
+        VisuAcqEchoTime = visu_pars["VisuAcqEchoTime"]
+        value = VisuAcqEchoTime.list
+        VisuAcqEchoTime.size = (1,)
         VisuAcqEchoTime.value = float(value[select])
 
 
@@ -259,31 +266,35 @@ class SlicePackageSplitter(Splitter):
     """
     Split 2dseq data set along individual slice packages
     """
-    def split(self, dataset, write=False, path_out=None):
+
+    def split(self, dataset, write=None, path_out=None):
         """
         Split 2dseq data set containing multiple data sets into a list of 2dseq data sets containing individual slice packages.
 
         This functionality might be used for instance when converting data to a different data format.
 
         :param dataset: 2dseq dataset with multiple slice packages
-        :param write: if True, splitted data sets will we writen to drive
+        :param write: if True, split data sets will be written to drive
         :param path_out: a path to store data sets (optional)
-        :return: list of splitted data sets
+        :return: list of split data sets
         """
 
+        if write is None:
+            write = False
+
         try:
-            VisuCoreSlicePacksSlices = dataset['VisuCoreSlicePacksSlices'].value
+            VisuCoreSlicePacksSlices = dataset["VisuCoreSlicePacksSlices"].nested
         except KeyError:
-            print('Parameter VisuCoreSlicePacksSlices not found')
+            raise MissingProperty("Parameter VisuCoreSlicePacksSlices not found") from KeyError
 
-        # list of splitted data sets
+        # list of split data sets
         datasets = []
 
         # range of frames of given slice package
-        frame_range = range(0,0)
+        frame_range = range(0, 0)
 
         # absolute index of FG_SLICE among dimensions of the dataset
-        fg_rel_index = dataset['VisuFGOrderDesc'].sub_list(1).index('<FG_SLICE>')
+        fg_rel_index = dataset["VisuFGOrderDesc"].sub_list(1).index("<FG_SLICE>")
 
         # index of FG_SLICE among frame group dimensions of the dataset
         fg_abs_index = fg_rel_index + dataset.encoded_dim
@@ -291,31 +302,32 @@ class SlicePackageSplitter(Splitter):
         # slice package split loop
         for sp_index in range(len(VisuCoreSlicePacksSlices)):
             # set range
-            frame_range= range(frame_range.stop, frame_range.stop + VisuCoreSlicePacksSlices[sp_index][1])
+            frame_range = range(frame_range.stop, frame_range.stop + VisuCoreSlicePacksSlices[sp_index][1])
 
             # number of frames contained in given slice package
             frame_count = frame_range.stop - frame_range.start
 
             # name of the data set created by the split
-            name = '{}_sp_{}/2dseq'.format(dataset.path.parents[0].name, sp_index)
+            name = f"{dataset.path.parents[0].name}_sp_{sp_index}/2dseq"
 
+            os.makedirs(dataset.path.parents[1] / name, exist_ok=True)
 
             # construct a new Dataset, without loading data, the data will be supplied later
-            dataset_ = Dataset(dataset.path.parents[1] / name, load=False)
+            dataset_ = Dataset(dataset.path.parents[1] / name, load=0)
 
-            # SPLIT parameteres
+            # SPLIT parameters
             dataset_.parameters = self._split_parameters(dataset, frame_range, fg_rel_index, fg_abs_index, sp_index, frame_count)
 
             # construct properties from the new set of parameters
             dataset_.load_properties()
 
             # change id
-            dataset_.id = '{}_sp_{}'.format(dataset_.id, sp_index)
+            dataset_.id = f"{dataset_.id}_sp_{sp_index}"
 
             # construct schema
             dataset_.load_schema()
 
-            #SPLIT data
+            # SPLIT data
             dataset_.data = self._split_data(dataset, frame_range, fg_abs_index)
 
             # append to result
@@ -328,7 +340,7 @@ class SlicePackageSplitter(Splitter):
 
     def _split_parameters(self, dataset, frame_range, fg_rel_index, fg_abs_index, sp_index, frame_count):
         # create a copy of visu_pars of the original data set
-        visu_pars_ = copy.deepcopy(dataset.parameters['visu_pars'])
+        visu_pars_ = copy.deepcopy(dataset.parameters["visu_pars"])
 
         # modify individual parameters so that the resulting data set is consistent
         self._split_VisuCorePosition(visu_pars_, frame_range, frame_count)
@@ -337,37 +349,38 @@ class SlicePackageSplitter(Splitter):
         self._split_VisuCoreDataMax(dataset, visu_pars_, frame_range, fg_rel_index)
         self._split_VisuCoreDataOffs(dataset, visu_pars_, frame_range, fg_rel_index)
         self._split_VisuCoreDataSlope(dataset, visu_pars_, frame_range, fg_rel_index)
-        self._split_VisuCoreTransposition(dataset, visu_pars_, frame_range, fg_rel_index)
+        if "VisuCoreTransposition" in dataset:
+            self._split_VisuCoreTransposition(dataset, visu_pars_, frame_range, fg_rel_index)
         self._split_VisuCoreFrameCount(dataset, visu_pars_, frame_count, fg_abs_index)
         self._split_VisuFGOrderDesc(visu_pars_, fg_rel_index, frame_count)
         self._split_VisuCoreSlicePacksDef(visu_pars_)
         self._split_VisuCoreSlicePacksSlices(visu_pars_, sp_index)
         self._split_VisuCoreSlicePacksSliceDist(visu_pars_, sp_index)
 
-        return {"visu_pars":visu_pars_}
+        return {"visu_pars": visu_pars_}
 
     def _split_VisuCoreFrameCount(self, dataset, visu_pars, frame_count, fg_ind_abs):
-        VisuCoreFrameCount = visu_pars['VisuCoreFrameCount']
+        VisuCoreFrameCount = visu_pars["VisuCoreFrameCount"]
 
         layout = np.array(dataset.shape_final)
-        layout[0:dataset.encoded_dim] = 1
+        layout[0 : dataset.encoded_dim] = 1
         layout[fg_ind_abs] = 1
         frames = int(frame_count * np.prod(layout))
 
         VisuCoreFrameCount.value = frames
 
     def _split_VisuCoreOrientation(self, visu_pars, frame_range, frame_count):
-        VisuCoreOrientation = visu_pars['VisuCoreOrientation']
-        VisuCoreOrientation.value = VisuCoreOrientation.value[frame_range, :].flatten(order='C')
+        VisuCoreOrientation = visu_pars["VisuCoreOrientation"]
+        VisuCoreOrientation.value = VisuCoreOrientation.value[frame_range, :].flatten(order="C")
         VisuCoreOrientation.size = (frame_count, 9)
 
     def _split_VisuCorePosition(self, visu_pars, frame_range, frame_count):
-        VisuCorePosition = visu_pars['VisuCorePosition']
-        VisuCorePosition.value = VisuCorePosition.value[frame_range, :].flatten(order='C')
+        VisuCorePosition = visu_pars["VisuCorePosition"]
+        VisuCorePosition.value = VisuCorePosition.value[frame_range, :].flatten(order="C")
         VisuCorePosition.size = (frame_count, 3)
 
     def _split_VisuFGOrderDesc(self, visu_pars, fg_rel_ind, frame_count):
-        VisuFGOrderDesc = visu_pars['VisuFGOrderDesc']
+        VisuFGOrderDesc = visu_pars["VisuFGOrderDesc"]
         value = VisuFGOrderDesc.value
 
         if isinstance(value[fg_rel_ind], list):
@@ -377,18 +390,18 @@ class SlicePackageSplitter(Splitter):
 
         VisuFGOrderDesc.value = value
 
-    def _split_VisuCoreSlicePacksDef(self,visu_pars):
-        VisuCoreSlicePacksDef = visu_pars['VisuCoreSlicePacksDef']
+    def _split_VisuCoreSlicePacksDef(self, visu_pars):
+        VisuCoreSlicePacksDef = visu_pars["VisuCoreSlicePacksDef"]
         value = VisuCoreSlicePacksDef.value
         value[1] = 1
         VisuCoreSlicePacksDef.value = value
 
     def _split_VisuCoreSlicePacksSlices(self, visu_pars_, sp_index):
-        VisuCoreSlicePacksSlices = visu_pars_['VisuCoreSlicePacksSlices']
+        VisuCoreSlicePacksSlices = visu_pars_["VisuCoreSlicePacksSlices"]
         VisuCoreSlicePacksSlices.value = [VisuCoreSlicePacksSlices.value[sp_index]]
 
     def _split_VisuCoreSlicePacksSliceDist(self, visu_pars_, sp_index):
-        VisuCoreSlicePacksSliceDist = visu_pars_['VisuCoreSlicePacksSliceDist']
-        value = int(VisuCoreSlicePacksSliceDist.value[sp_index])
+        VisuCoreSlicePacksSliceDist = visu_pars_["VisuCoreSlicePacksSliceDist"]
+        value = int(VisuCoreSlicePacksSliceDist.array[sp_index])
         VisuCoreSlicePacksSliceDist.value = value
-        VisuCoreSlicePacksSliceDist.size = 1
+        VisuCoreSlicePacksSliceDist.size = 1

brukerapi/utils.py

@@ -1,12 +1,12 @@
 import numpy as np
 
+
 def index_to_slice(index, data_shape, dim_index):
     out = []
 
     if isinstance(index, range):
         index = slice(index.start, index.stop)
 
-
     for i in range(len(data_shape)):
         if i != dim_index:
             out.append(slice(0, data_shape[i]))
@@ -15,48 +15,47 @@ def index_to_slice(index, data_shape, dim_index):
 
     return tuple(out)
 
+
 def simple_measurement(dataset):
+    if dataset.encoded_dim == 1:
+        axes = (0,)
+    elif dataset.encoded_dim == 2:
+        axes = (0, 1)
+    elif dataset.encoded_dim == 3:
+        axes = (0, 1, 2)
 
-        if dataset.encoded_dim == 1:
-            axes = (0,)
-        elif dataset.encoded_dim == 2:
-            axes = (0,1)
-        elif dataset.encoded_dim == 3:
-            axes = (0,1,2)
+    return np.fft.fftshift(np.fft.fft2(dataset.data, axes=axes), axes=axes)
 
-        return np.fft.fftshift(np.fft.fft2(dataset.data,axes=axes),axes=axes)
 
 def simple_reconstruction(dataset, **kwargs):
-        """
-        Simple Fourier reconstruction
-        :return: image
-        """
-        if dataset.encoded_dim == 1:
-            axes = (0,)
-        elif dataset.encoded_dim == 2:
-            axes = (0,1)
-        elif dataset.encoded_dim == 3:
-            axes = (0,1,2)
-
-        data = np.fft.fftshift(np.fft.ifft2(dataset.data, axes=axes),
-                               axes=axes)
-
-        if kwargs.get("COMBINE_CHANNELS") is True:
-            return combine_channels(data=data)
-        else:
-            return data
+    """
+    Simple Fourier reconstruction
+    :return: image
+    """
+    if dataset.encoded_dim == 1:
+        axes = (0,)
+    elif dataset.encoded_dim == 2:
+        axes = (0, 1)
+    elif dataset.encoded_dim == 3:
+        axes = (0, 1, 2)
 
-def combine_channels(dataset, data=None):
+    data = np.fft.fftshift(np.fft.ifft2(dataset.data, axes=axes), axes=axes)
 
-        if dataset.scheme is not None:
-            channel_dim = dataset.scheme.dim_type.index('channel')
-        else:
-            raise NotImplemented
+    if kwargs.get("COMBINE_CHANNELS") is True:
+        return combine_channels(data=data)
+    return data
+
+
+def combine_channels(dataset, data=None):
+    if dataset.scheme is not None:
+        channel_dim = dataset.scheme.dim_type.index("channel")
+    else:
+        raise NotImplementedError
 
-        if data is None:
-            data = dataset.data
+    if data is None:
+        data = dataset.data
 
-        data = data ** 2
-        data = np.expand_dims(np.sum(data, channel_dim), channel_dim)
+    data = data**2
+    data = np.expand_dims(np.sum(data, channel_dim), channel_dim)
 
-        return np.sqrt(data)
+    return np.sqrt(data)