Merge metric unit conversion functions

shimmingtoolbox/coils/spher_harm_basis.py

@@ -6,8 +6,7 @@
 
 from shimmingtoolbox.coils.spherical_harmonics import spherical_harmonics
 from shimmingtoolbox.conversion import (hz_per_cm_to_micro_tesla_per_m, hz_per_cm2_to_micro_tesla_per_m2,
-                                        metric_unit_to_metric_unit, unit_per_metric_unit_to_unit_per_metric_unit,
-                                        tesla_to_hz)
+                                        metric_unit_to_metric_unit, tesla_to_hz)
 
 logger = logging.getLogger(__name__)
 
@@ -188,9 +187,7 @@ def _reorder_scaling_to_shim(coefs):
                 reordered_spher_array = convert_spher_harm_to_array(reordered_spher_necessary)
 
                 scaled[2][..., i_channel] = np.matmul(reordered_spher_array, orders_to_order2_ut[:, i_channel])
-                scaled[2][..., i_channel] = unit_per_metric_unit_to_unit_per_metric_unit(scaled[2][..., i_channel],
-                                                                                         '',
-                                                                                         'm')
+                scaled[2][..., i_channel] = metric_unit_to_metric_unit(scaled[2][..., i_channel], '', 'm', power=-1)
                 # Todo: We need a /2 between expected zx, zy, xy results and calculated results
                 if i_channel in [0, 1, 2]:
                     scaled[2][..., i_channel] /= 2

shimmingtoolbox/conversion.py

@@ -19,13 +19,13 @@
 
 
 def metric_unit_to_metric_unit(x, prefix_in, prefix_out, power=1):
-    """ Convert units with metric prefixes to other metric prefixes (i.e. T to uT)
+    """ Convert units with metric prefixes to other metric prefixes (i.e. T to uT, 1/cm^2 to 1/m^2).
 
     Args:
         x: Float or array of floats
         prefix_in (str): Prefix of the input unit
         prefix_out (str): Prefix of the output unit
-        power (int): Power of the unit, use 2 for squared units (i.e. m^2)
+        power (int): Power of the unit, use 2 for squared units (i.e. m^2), to convert x/cm to x/m, use a negative power
 
     Returns:
         Float or array of floats converted
@@ -36,25 +36,6 @@ def metric_unit_to_metric_unit(x, prefix_in, prefix_out, power=1):
     return x * factor
 
 
-def unit_per_metric_unit_to_unit_per_metric_unit(x, prefix_in, prefix_out, power=1):
-    """ Convert units per metric prefixes to other metric prefixes (i.e. unit/cm to unit/m)
-
-    Args:
-        x: Float or array of floats
-        prefix_in (str): Prefix of the input unit
-        prefix_out (str): Prefix of the output unit
-        power (int): Power of the unit, use 2 for squared units (i.e. m^2)
-
-    Returns:
-        Float or array of floats converted
-    """
-    if prefix_in not in METRIC_PREFIXES or prefix_out not in METRIC_PREFIXES:
-        raise ValueError('Invalid prefix')
-
-    factor = (METRIC_PREFIXES[prefix_out] / METRIC_PREFIXES[prefix_in]) ** power
-    return x * factor
-
-
 def hz_to_rad_per_sec(hz):
     """ Convert Hz to rad/s """
     return hz * 2 * math.pi
@@ -168,26 +149,26 @@ def rad_to_gauss(rad, dt):
 def hz_per_cm_to_micro_tesla_per_m(hz_per_cm):
     """ Convert Hz/cm to microTesla/m """
     micro_tesla_per_cm = hz_to_micro_tesla(hz_per_cm)
-    micro_tesla_per_m = unit_per_metric_unit_to_unit_per_metric_unit(micro_tesla_per_cm, 'c', '')
+    micro_tesla_per_m = metric_unit_to_metric_unit(micro_tesla_per_cm, 'c', '', power=-1)
     return micro_tesla_per_m
 
 
 def micro_tesla_per_m_to_hz_per_cm(micro_tesla_per_m):
     """ Convert microTesla/m to Hz/cm """
-    micro_tesla_per_cm = unit_per_metric_unit_to_unit_per_metric_unit(micro_tesla_per_m, '', 'c')
+    micro_tesla_per_cm = metric_unit_to_metric_unit(micro_tesla_per_m, '', 'c', power=-1)
     hz_per_cm = micro_tesla_to_hz(micro_tesla_per_cm)
     return hz_per_cm
 
 
 def hz_per_cm2_to_micro_tesla_per_m2(hz_per_cm2):
     """ Convert Hz/cm^2 to microTesla/m^2 """
     micro_tesla_per_cm2 = hz_to_micro_tesla(hz_per_cm2)
-    micro_tesla_per_m2 = unit_per_metric_unit_to_unit_per_metric_unit(micro_tesla_per_cm2, 'c', '', 2)
+    micro_tesla_per_m2 = metric_unit_to_metric_unit(micro_tesla_per_cm2, 'c', '', power=-2)
     return micro_tesla_per_m2
 
 
 def micro_tesla_per_m2_to_hz_per_cm2(micro_tesla_per_m2):
     """ Convert microTesla/m^2 to Hz/cm^2 """
-    micro_tesla_per_cm2 = unit_per_metric_unit_to_unit_per_metric_unit(micro_tesla_per_m2, '', 'c', 2)
+    micro_tesla_per_cm2 = metric_unit_to_metric_unit(micro_tesla_per_m2, '', 'c', -2)
     hz_per_cm2 = micro_tesla_to_hz(micro_tesla_per_cm2)
     return hz_per_cm2

test/test_conversion.py

@@ -11,7 +11,7 @@
                                         rad_to_gauss, hz_to_micro_tesla, micro_tesla_to_hz,
                                         hz_per_cm2_to_micro_tesla_per_m2, micro_tesla_per_m2_to_hz_per_cm2,
                                         hz_per_cm_to_micro_tesla_per_m, micro_tesla_per_m_to_hz_per_cm,
-                                        metric_unit_to_metric_unit, unit_per_metric_unit_to_unit_per_metric_unit)
+                                        metric_unit_to_metric_unit)
 
 
 def test_hz_to_rad_per_sec():
@@ -109,11 +109,11 @@ def test_m2_to_cm2():
 
 
 def test_unit_per_cm_to_unit_per_m():
-    assert unit_per_metric_unit_to_unit_per_metric_unit(1, 'c', '') == 1e2
+    assert metric_unit_to_metric_unit(1, 'c', '', power=-1) == 1e2
 
 
 def test_unit_per_m_to_unit_per_cm():
-    assert unit_per_metric_unit_to_unit_per_metric_unit(1e2, '', 'c') == 1
+    assert metric_unit_to_metric_unit(1e2, '', 'c', power=-1) == 1
 
 
 def test_hz_per_cm_to_micro_tesla_per_m():
@@ -125,11 +125,11 @@ def test_micro_tesla_per_m_to_hz_per_cm():
 
 
 def test_unit_per_cm2_to_unit_per_m2():
-    assert unit_per_metric_unit_to_unit_per_metric_unit(1, 'c', '', 2) == 1e4
+    assert metric_unit_to_metric_unit(1, 'c', '', power=-2) == 1e4
 
 
 def test_unit_per_m2_to_unit_per_cm2():
-    assert unit_per_metric_unit_to_unit_per_metric_unit(1e4, '', 'c', 2) == 1
+    assert metric_unit_to_metric_unit(1e4, '', 'c', power=-2) == 1
 
 
 def test_hz_per_cm2_to_micro_tesla_per_m2():