1"""
  2# Description
  3
  4This module contains functions to normalize data and other variables.
  5
  6
  7# Index
  8
  9| | |
 10| --- | --- |
 11| `height()`   | Normalize a `spectra` by height |
 12| `area()`     | Normalize a `spectra` by the area under the datasets |
 13| `unit_str()` | Normalize a `unit` string from user input |
 14
 15---
 16"""
 17
 18
 19import aton.alias as alias
 20from .classes import *
 21from .fit import *
 22
 23
 24def height(
 25        spectra:Spectra,
 26        range:list=None,
 27        axis:str='x',
 28        df_index:int=0,
 29        ) -> Spectra:
 30    """Normalize a set of `spectra` by height.
 31
 32    By default it normalises the spectra over the entire range.
 33    This can be modified by setting a specific range,
 34    as in `range = [x_min, x_max]` with `axis = 'x'`.
 35    It can also normalise over manual y-positions,
 36    for example for peaks with different baselines.
 37    This can be done by settingch `axis='y'`, and
 38    `range = [[y_min_1, y_max_1], ..., [y_min_N, y_max_N]]`.
 39
 40    Heights are normalised with respect to the
 41    reference dataframe `df_index`, the first one by default.
 42    """
 43    sdata = deepcopy(spectra)
 44    if axis.lower() in alias.spatial['y']:
 45        return _height_y(sdata, range, df_index)
 46    df0 = sdata.dfs[df_index]
 47    if range:
 48        if not isinstance(range, list):
 49            raise ValueError("range must be a list")
 50        if len(range) != 2:
 51            raise ValueError(f"With axis='x', range must be [xmin, xmax]. Yours was:\n{range}")
 52        range.sort()
 53        xmin = range[0]
 54        xmax = range[1]
 55    else:
 56        xmin = min(df0[df0.columns[0]])
 57        xmax = max(df0[df0.columns[0]])
 58    df0 = df0[(df0[df0.columns[0]] >= xmin) & (df0[df0.columns[0]] <= xmax)]
 59    ymax_on_range = df0[df0.columns[1]].max()
 60    normalized_dataframes = []
 61    for df in sdata.dfs:
 62        df_range = df[(df[df.columns[0]] >= xmin) & (df[df.columns[0]] <= xmax)]
 63        i_ymax_on_range = df_range[df_range.columns[1]].max()
 64        df[df.columns[1]] =  df[df.columns[1]] * ymax_on_range / i_ymax_on_range
 65        normalized_dataframes.append(df)
 66    sdata.dfs = normalized_dataframes
 67    return sdata
 68
 69
 70def _height_y(
 71        sdata:Spectra,
 72        range:list,
 73        df_index:int=0,
 74        ) -> Spectra:
 75    """Private function to handle normalisation in the y-axis"""
 76    if not range:
 77        raise ValueError(f"A range must be specified to normalise the Y axis, as in range=[[y_min_1,y_max_1],...,[y_min_N,y_max_N]]\nYours was:\n{range}")
 78    if not len(range) == len(sdata.dfs):
 79        raise ValueError("len(range) must match len(Spectra.dfs) for axis='y'")
 80    ymax = []
 81    ymin = []
 82    for values in range:
 83        if not isinstance(values, list):
 84            raise ValueError(f"The range for axis='y' must be a list of lists,\nas in range=[[y_min_1,y_max_1],...,[y_min_N,y_max_N]].\nYours was:\n{range}")
 85        if len(values) != 2:
 86            raise ValueError(f"2 values needed to normalise the y-axis, ymin and ymax,\nas in range=[[y_min_1,y_max_1],...,[y_min_N,y_max_N]].\nYours was:\n{range}")
 87        values.sort()
 88        i_ymin = values[0]
 89        i_ymax = values[1]
 90        ymin.append(i_ymin)
 91        ymax.append(i_ymax)
 92    reference_height = ymax[df_index] - ymin[df_index]
 93    normalized_dataframes = []
 94    for i, df in enumerate(sdata.dfs):
 95        height = ymax[i] - ymin[i]
 96        df[df.columns[1]] =  df[df.columns[1]] * reference_height / height
 97        normalized_dataframes.append(df)
 98    sdata.dfs = normalized_dataframes
 99    return sdata
100
101
102def area(
103        spectra:Spectra,
104        range:list=None,
105        df_index:int=0
106        ) -> Spectra:
107    """Normalize `spectra` by the area under the datasets."""
108    sdata = deepcopy(spectra)
109    df0 = sdata.dfs[df_index]
110    if range:
111        if len(range) != 2:
112            raise ValueError(f"The range must be a list of 2 elements, as in [xmin, xmax]. Yours was:\n{range}")
113        range.sort()
114        xmin = range[0]
115        xmax = range[1]
116    else:
117        xmin = min(df0[df0.columns[0]])
118        xmax = max(df0[df0.columns[0]])
119    df0 = df0[(df0[df0.columns[0]] >= xmin) & (df0[df0.columns[0]] <= xmax)]
120    area_df0, _ = area_under_peak(sdata, peak=[xmin,xmax], df_index=df_index, min_as_baseline=True)
121    normalized_dataframes = []
122    for df_i, df in enumerate(sdata.dfs):
123        area_df, _ = area_under_peak(sdata, peak=[xmin,xmax], df_index=df_i, min_as_baseline=True)
124        scaling_factor = area_df0 / area_df
125        df[df.columns[1]] =  df[df.columns[1]] * scaling_factor
126        normalized_dataframes.append(df)
127    sdata.dfs = normalized_dataframes
128    return sdata
129
130
131def unit_str(unit:str):
132    """Normalize `unit` string from user input."""
133    for key, value in alias.units.items():
134        if unit in value:
135            return key
136    print(f"WARNING: Unknown unit '{unit}'")
137    return unit