Typo

fsl_mrs_mce/mc_in.py

@@ -0,0 +1,124 @@
+# mc_in.py - Helpers for Monte-Carlo style simulations
+#
+# Author: Konstantin E Bosbach <konstantin.bosbach@mars.uni-freiburg.de>
+
+
+import numpy as np
+import pandas as pd
+from configparser import ConfigParser
+
+
+def load_config(input_folder="input/", section="default"):
+    """Loads configuration file.
+    If given option section="": returns list of config sections"""
+# Information from config txt
+    try:
+        # Load txt
+        configFilePath = str(input_folder + "config.txt")
+        configParser = ConfigParser()
+        configParser.read(configFilePath)
+        try:
+            if section == "":
+                return configParser.sections()
+            else:
+                return configParser[section]
+        except input:
+            print(configParser.sections())
+            print(f"No {section} section.")
+    except input:
+        print(f"No {configFilePath} provided.")
+
+
+def conc_df_from_file(input_path="input/", foundation="vivo_average",
+                      include_molecules=[], save_df=True):
+    sections = load_config(input_path, "")
+    """Generates concentration dataframe for mc method.
+    Supports different variation types (absolute/delta/relative)
+    Returns data_frame of different concentrations.
+    include_molecules needed for option some_molecules"""
+    # Load all relevant sections
+    list_parser_parameter = []
+
+    for i in sections:
+        if i[0:20] == "generation_parameter":
+            list_parser_parameter.append(load_config(input_path, i))
+
+    # Load foundation file, a line with e.g. in-vivo averages
+    # The code expects a one-line-foundation.
+    molecule_names = ['Ala', 'Asc', 'Asp', 'Cr', 'GABA', 'GPC', 'GSH',
+                      'Glc', 'Gln', 'Glu', 'Ins', 'Lac', 'NAA', 'NAAG',
+                      'PCho', 'PCr', 'PE', 'Scyllo', 'Tau',
+                      'mm', 'Glu+Gln', 'GPC+PCho', 'Cr+PCr',
+                      'Glc+Tau', 'NAA+NAAG']
+
+    if foundation == "vivo_average":
+        try:
+            df_foundation = pd.read_csv(
+                "basis/fit_conc_result.csv").mean().to_frame().transpose()
+        except:
+            print("No basis/fit_conc_result.csv file supplied")
+    # Sets all initial molecules, including some groups, to 0
+    if foundation == "flat":
+        try:
+            df_foundation = pd.read_csv(
+                "basis/fit_conc_result.csv").mean().to_frame().transpose()
+            for molecule in molecule_names:
+                df_foundation[molecule] = 0
+        except:
+            print("No basis/fit_conc_result.csv file supplied")
+    if foundation == "some_molecules":
+        try:
+            df_foundation = pd.read_csv(
+                "basis/fit_conc_result.csv").mean().to_frame().transpose()
+            for molecule in molecule_names:
+                if molecule not in include_molecules:
+                    df_foundation[molecule] = 0
+        except:
+            print("No basis/fit_conc_result.csv file supplied")
+    else:
+        print("Only foundation mode vivo_average not chosen")
+
+    # Load values, dependent on type absolute/delta/relative
+    list_parameter_values = []
+    list_parameter_names = []
+    for i in list_parser_parameter:
+        string_values = i["amount"][1:-1]
+        list_values = list(map(float, string_values.split(",")))
+        if i["type"] == "absolute":
+            # set absolute values
+            None
+
+        elif i["type"] == "delta":
+            # set absolute value offset from foundation
+            list_values = np.add(list_values, df_foundation[i["param"]].mean())
+
+        elif i["type"] == "relative":
+            # set relative value from foundation
+            list_values = np.multiply(
+                list_values, df_foundation[i["param"]].mean())
+
+        list_parameter_values.append(list_values)
+        list_parameter_names.append(i["param"])
+
+    # Create parameter tensor
+    mesh_parameter_values = np.meshgrid(*list_parameter_values)
+
+    # Create 'empty' standard data
+    df_conc = pd.concat(
+        [df_foundation]*int(np.array(mesh_parameter_values[0]).size),
+        ignore_index=True
+    )
+
+    # Write parameter values into dataframe
+    i = 0
+    while i <= len(list_parameter_values)-1:
+        parameter_values = mesh_parameter_values[i].ravel()
+        parameter_name = list_parameter_names[i]
+        print(parameter_name, parameter_values)
+        df_conc[parameter_name] = parameter_values
+        i = i+1
+
+    if save_df:
+        df_conc.to_csv(str(input_path+"df_conc.csv"))
+
+    return df_conc

fsl_mrs_mce/mc_sim.py

@@ -10,7 +10,9 @@ import pandas as pd
 def get_convergence(
     output_file_paths, molecule, crit_mean=0.01, crit_std=0.10
 ):
-    """Function checks if last two files contain converging datasets."""
+    """Function checks if data results from last two
+    files contain are within convergence criteria.
+    Returns Boolean"""
 
     if len(output_file_paths) < 2:
         print("One iteration, therefore no convergence.")
@@ -30,6 +32,7 @@ def get_convergence(
     older_std = older_fit_results[molecule].std()
     measure_std = abs(abs(np.abs(newer_std) - abs(older_std))/norm)
 
+    # check if results within convergence criteria
     if measure_mean <= crit_mean:
         if measure_std <= crit_std:
             convergence = True
@@ -39,7 +42,8 @@ def get_convergence(
     print(
         "Convergence result for ", output_file_paths[-1], " and ",
         output_file_paths[-2], "\n\t\t\t",
-        measure_mean, measure_std, "convergence: ", str(convergence)
+        round(measure_mean, 4), round(measure_std, 4),
+        "convergence: ", str(convergence)
     )
 
     return convergence

setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup
 
 setup(name='fsl_mrs_mce',
-      version='0.0.2',
+      version='0.0.22',
       description='A fsl_mrs Moncte Carlo estimation approach',
       url='https://git.thoffbauer.de/konstantin.bosbach/fsl_mrs_mce.git',
       author='Konstantin E Bosbach',