diff --git a/README.md b/README.md
index 90c0ef45261cea8c896a97825423970cdb9e86fb..b35e63ada34fbcba4dba0bf441ee58bbbeab1fd1 100644
--- a/README.md
+++ b/README.md
@@ -39,14 +39,31 @@ You will require whatever libraries with which binary_c was compiled, as well as
If you want to be able to import the binary_c module correctly for child directories (or anywhere for that matter), execute or put the following code in your .bashrc/.zshrc:
```
-export LD_LIBRARY_PATH=<full path to directory containing libbinary_c_api.so>
+export LD_LIBRARY_PATH=<full path to directory containing libbinary_c_api.so>:$LD_LIBRARY_PATH
+export PYTHONPATH=<full path to directory containing libbinary_c_api.so>:$PYTHONPATH
```
+Usage notes
+---------------------
+When running a jupyter notebook and importing binary_c, it might happen that the module binary_c cannot be found. I experienced this when I executed Jupyter Notebook from a virtual environment which didnt use the same python (version/binary/shim) as the one I built this library with. Make sure jupyter does use the same underlying python version/binary/shim. That resolved the issue for me.
+
+Also: I figured that having binaryc output the log like "<LOG HEADER> t=10e4 ..." (i.e. printing the parameter names as well as their values) would be useful because in that way one can easily have python read that out automatically instead of having to manually copy the list of parameter names.
+
+
+
TODO
---------------------
+General:
- ?Put the header and src files in a dedicated directory.
- ?Have the compiled files be written into build
+- Get a more reliable way of loading the default values (running a ./tbse echo or something?)
+- make routine that reads out all the lines, splits them into pieces and reads out the correct key
+- Add PYTHONPATH thing to readme
+- Make sure importing binary_c is not a problem
+
+If we're going to do populations:
- Use sphinx for auto generation of docs
- Use queueing system/asynchronous task queue
- Make some parse-data that can be easily used
- Make some simple script to assign probabilities
+- rebuild all perl stuff into a python grid code.
\ No newline at end of file
diff --git a/build/temp.linux-x86_64-3.6/binary_c_python.o b/build/temp.linux-x86_64-3.6/binary_c_python.o
index ca9e7c36ab4089a52d0b5498471952e18df97964..af46f6afbc91b58d8074d7de4f69635428a0328d 100644
Binary files a/build/temp.linux-x86_64-3.6/binary_c_python.o and b/build/temp.linux-x86_64-3.6/binary_c_python.o differ
diff --git a/examples/.ipynb_checkpoints/example_notebook-checkpoint.ipynb b/examples/.ipynb_checkpoints/example_notebook-checkpoint.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f9db89b1350c3f8d1bbbe76e95a65bffd733a9c1
--- /dev/null
+++ b/examples/.ipynb_checkpoints/example_notebook-checkpoint.ipynb
@@ -0,0 +1,165 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Example notebook binarypy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/user/HS128/dh00601/.pyenv/versions/3.6.4/envs/binaryc_py3.6.4/bin/python\n"
+ ]
+ }
+ ],
+ "source": [
+ "import os, sys\n",
+ "import matplotlib.pyplot as plt\n",
+ "import pandas as pd\n",
+ "\n",
+ "# Append root dir of this project to include functionality\n",
+ "print(sys.executable)\n",
+ "sys.path.append(os.path.dirname(os.getcwd()))\n",
+ "import binary_c\n",
+ "from utils.defaults import physics_defaults\n",
+ "from utils.functions import create_arg_string"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def example_with_loading_default_args():\n",
+ " \"\"\"\n",
+ " Example function loading the default physics args for a binary_c system. Got\n",
+ " it from the binary_grid2 perl module\n",
+ "\n",
+ " This function works if binary_c is set to log something every timestep so that we can plot the evolution of a system\n",
+ " \"\"\"\n",
+ "\n",
+ " # Load args\n",
+ " physics_args = physics_defaults.copy()\n",
+ "\n",
+ " # Manually set M_1, M_2, orbital_period and separation values:\n",
+ " physics_args['M_1'] = 20\n",
+ " physics_args['M_2'] = 15\n",
+ " physics_args['separation'] = 0 # 0 = ignored, use period\n",
+ " physics_args['orbital_period'] = 4530.0\n",
+ "\n",
+ " arg_string = create_arg_string(physics_args)\n",
+ " arg_string = 'binary_c {arg_string}'.format(arg_string=arg_string)\n",
+ "\n",
+ " buffer = \"\"\n",
+ "\n",
+ " output = binary_c.run_binary(arg_string)\n",
+ "\n",
+ " # Make some \n",
+ " results = {}\n",
+ " time_arr = []\n",
+ " mass_arr = []\n",
+ " mass_2_arr = []\n",
+ "\n",
+ " # split output on newlines\n",
+ " for line in output.split('\\n'):\n",
+ " # Skip any blank lines\n",
+ " if not line=='':\n",
+ " split_line = line.split()\n",
+ " header = split_line[0]\n",
+ " value_array = split_line[1:]\n",
+ "\n",
+ " # Use parse data here:\n",
+ " if header=='TESTLOG':\n",
+ " # Add values to lists\n",
+ " time_arr.append(float(value_array[0]))\n",
+ " mass_arr.append(float(value_array[1]))\n",
+ " mass_2_arr.append(float(value_array[4]))\n",
+ "\n",
+ " # Save in results dir\n",
+ " results['time'] = time_arr\n",
+ " results['mass'] = mass_arr\n",
+ " results['mass2'] = mass_2_arr\n",
+ "\n",
+ " return results\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "results = example_with_loading_default_args()\n",
+ "df = pd.DataFrame.from_dict(results)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 720x720 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "min_time = 1e-1\n",
+ "max_time = 3000\n",
+ "# Plot some stuff\n",
+ "plt.figure(figsize=[10,10])\n",
+ "plt.plot(df[(df.time>min_time) & (df.time<max_time)]['time'], df[(df.time>min_time) & (df.time<max_time)]['mass'])\n",
+ "plt.plot(df[(df.time>min_time) & (df.time<max_time)]['time'], df[(df.time>min_time) & (df.time<max_time)]['mass2'])\n",
+ "plt.xscale('log')\n",
+ "plt.ylabel(r'Mass $M_{\\odot}$')\n",
+ "plt.xlabel('time (MYr)')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.6.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/example_notebook.ipynb b/examples/example_notebook.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f9db89b1350c3f8d1bbbe76e95a65bffd733a9c1
--- /dev/null
+++ b/examples/example_notebook.ipynb
@@ -0,0 +1,165 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Example notebook binarypy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "/user/HS128/dh00601/.pyenv/versions/3.6.4/envs/binaryc_py3.6.4/bin/python\n"
+ ]
+ }
+ ],
+ "source": [
+ "import os, sys\n",
+ "import matplotlib.pyplot as plt\n",
+ "import pandas as pd\n",
+ "\n",
+ "# Append root dir of this project to include functionality\n",
+ "print(sys.executable)\n",
+ "sys.path.append(os.path.dirname(os.getcwd()))\n",
+ "import binary_c\n",
+ "from utils.defaults import physics_defaults\n",
+ "from utils.functions import create_arg_string"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def example_with_loading_default_args():\n",
+ " \"\"\"\n",
+ " Example function loading the default physics args for a binary_c system. Got\n",
+ " it from the binary_grid2 perl module\n",
+ "\n",
+ " This function works if binary_c is set to log something every timestep so that we can plot the evolution of a system\n",
+ " \"\"\"\n",
+ "\n",
+ " # Load args\n",
+ " physics_args = physics_defaults.copy()\n",
+ "\n",
+ " # Manually set M_1, M_2, orbital_period and separation values:\n",
+ " physics_args['M_1'] = 20\n",
+ " physics_args['M_2'] = 15\n",
+ " physics_args['separation'] = 0 # 0 = ignored, use period\n",
+ " physics_args['orbital_period'] = 4530.0\n",
+ "\n",
+ " arg_string = create_arg_string(physics_args)\n",
+ " arg_string = 'binary_c {arg_string}'.format(arg_string=arg_string)\n",
+ "\n",
+ " buffer = \"\"\n",
+ "\n",
+ " output = binary_c.run_binary(arg_string)\n",
+ "\n",
+ " # Make some \n",
+ " results = {}\n",
+ " time_arr = []\n",
+ " mass_arr = []\n",
+ " mass_2_arr = []\n",
+ "\n",
+ " # split output on newlines\n",
+ " for line in output.split('\\n'):\n",
+ " # Skip any blank lines\n",
+ " if not line=='':\n",
+ " split_line = line.split()\n",
+ " header = split_line[0]\n",
+ " value_array = split_line[1:]\n",
+ "\n",
+ " # Use parse data here:\n",
+ " if header=='TESTLOG':\n",
+ " # Add values to lists\n",
+ " time_arr.append(float(value_array[0]))\n",
+ " mass_arr.append(float(value_array[1]))\n",
+ " mass_2_arr.append(float(value_array[4]))\n",
+ "\n",
+ " # Save in results dir\n",
+ " results['time'] = time_arr\n",
+ " results['mass'] = mass_arr\n",
+ " results['mass2'] = mass_2_arr\n",
+ "\n",
+ " return results\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "results = example_with_loading_default_args()\n",
+ "df = pd.DataFrame.from_dict(results)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 720x720 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "min_time = 1e-1\n",
+ "max_time = 3000\n",
+ "# Plot some stuff\n",
+ "plt.figure(figsize=[10,10])\n",
+ "plt.plot(df[(df.time>min_time) & (df.time<max_time)]['time'], df[(df.time>min_time) & (df.time<max_time)]['mass'])\n",
+ "plt.plot(df[(df.time>min_time) & (df.time<max_time)]['time'], df[(df.time>min_time) & (df.time<max_time)]['mass2'])\n",
+ "plt.xscale('log')\n",
+ "plt.ylabel(r'Mass $M_{\\odot}$')\n",
+ "plt.xlabel('time (MYr)')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.6.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/full_evolution_with_plot.py b/examples/full_evolution_with_plot.py
index 02cf4fd511e78ba83a9a55abd5d965882c833b0f..96a8af73f6ea53cfdcfaa8958f0638930aee1786 100644
--- a/examples/full_evolution_with_plot.py
+++ b/examples/full_evolution_with_plot.py
@@ -1,16 +1,12 @@
import os, sys
import matplotlib.pyplot as plt
-import binary_c
-
# Append root dir of this project to include functionality
sys.path.append(os.path.dirname(os.getcwd()))
+import binary_c
from utils.defaults import physics_defaults
from utils.functions import create_arg_string
-
-
-
def example_with_loading_default_args():
"""
Example function loading the default physics args for a binary_c system. Got
@@ -29,7 +25,6 @@ def example_with_loading_default_args():
physics_args['orbital_period'] = 4530.0
arg_string = create_arg_string(physics_args)
-
arg_string = f'binary_c {arg_string}'
buffer = ""
diff --git a/examples/log_filename_test.py b/examples/log_filename_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..80d244bac185b7c6730fbba7428a74b335db1626
--- /dev/null
+++ b/examples/log_filename_test.py
@@ -0,0 +1,43 @@
+import os, sys
+import matplotlib.pyplot as plt
+
+# Append root dir of this project to include functionality
+sys.path.append(os.path.dirname(os.getcwd()))
+import binary_c
+from utils.defaults import physics_defaults
+from utils.functions import create_arg_string
+
+"""
+This script is intended to have the logfile of a binary system being outputted to a given directory so that we can use that logfile for other purposes
+Like plotting/visualizing the general evolution of that system using e.g. Mirons script
+"""
+
+def example_with_loading_default_args():
+ """
+ Example function loading the default physics args for a binary_c system. Got
+ it from the binary_grid2 perl module
+
+ This function works if binary_c is set to log something every timestep so that we can plot the evolution of a system
+ """
+
+ # Load args
+ physics_args = physics_defaults.copy()
+
+ # Manually set M_1, M_2, orbital_period and separation values:
+ physics_args['M_1'] = 20
+ physics_args['M_2'] = 15
+ physics_args['separation'] = 0 # 0 = ignored, use period
+ physics_args['orbital_period'] = 4530.0
+
+ physics_args['log_filename'] = os.path.join(os.getcwd(), 'test.log')
+ print(physics_args['log_filename'])
+
+ arg_string = create_arg_string(physics_args)
+ arg_string = f'binary_c {arg_string}'
+
+ buffer = ""
+
+ print(arg_string)
+
+ output = binary_c.run_binary(arg_string)
+example_with_loading_default_args()
\ No newline at end of file
diff --git a/test_david.py b/examples/loop_system.py
similarity index 55%
rename from test_david.py
rename to examples/loop_system.py
index 99f0154fab215d539e1dcb5387c02948d5a85b13..622b9c75c6dce6e63a32a715d235b7861561a824 100644
--- a/test_david.py
+++ b/examples/loop_system.py
@@ -1,32 +1,19 @@
-#!/usr/bin/python3
-import os
-import binary_c
+import os, sys
import matplotlib.pyplot as plt
-from defaults import physics_defaults
-
-############################################################
-# Test script to run a binary using the binary_c Python
-# module.
-############################################################
+# Append root dir of this project to include functionality
+sys.path.append(os.path.dirname(os.getcwd()))
+import binary_c
+from utils.defaults import physics_defaults
+from utils.functions import create_arg_string
-def run_test_binary():
- m1 = 15.0 # Msun
- m2 = 14.0 # Msun
- separation = 0 # 0 = ignored, use period
- orbital_period = 4530.0 # days
- eccentricity = 0.0
- metallicity = 0.02
- max_evolution_time = 15000
- buffer = ""
- # argstring = "binary_c M_1 {0:g} M_2 {1:g} separation {2:g} orbital_period {3:g} eccentricity {4:g} metallicity {5:g} max_evolution_time {6:g} ".format(m1,m2,separation,orbital_period,eccentricity,metallicity,max_evolution_time)
-
- argstring = f"binary_c M_1 {m1} M_2 {m2} separation {separation} orbital_period {orbital_period} eccentricity {eccentricity} metallicity {metallicity} max_evolution_time {max_evolution_time}"
+"""
+This script is an example of running a group of binary systems using a loop. For big grids this is not wise, the grid functionality will be built later
- output = binary_c.run_binary(argstring)
+I made this script to with the logging of binaryc set to log only one line per system (when a certain requirement is met).
- # print ("Binary_c output:\n\n")
- print (output)
+You can either capture the data and print it, or write it to a file
+"""
def run_simple_loop_binary():
# Some simple function with a loop
@@ -76,24 +63,4 @@ def run_simple_loop_binary():
print('mass1:', mass_1)
print('zams_mass1:' ,initial_m1)
- print('time:', time)
-
-# print("Current binary_c object class functions: ")
-# print(dir(binary_c))
-
-# print("Current binary_c.new_system object class functions: ")
-# print(dir(binary_c.new_system()))
-## WHat is the use of new_system?
-
-# print("Current binary_c.run_binary object class functions: ")
-# print(dir(binary_c.run_binary()))
-
-# binary_star=binary_c.new_system()
-# print(binary_star)
-# print(dir(binary_star))
-
-# Test single system
-# run_test_binary()
-
-# Test grid-like
-# run_simple_loop_binary()
\ No newline at end of file
+ print('time:', time)
\ No newline at end of file
diff --git a/examples/single_system.py b/examples/single_system.py
new file mode 100644
index 0000000000000000000000000000000000000000..561a0fd0ee9495cec38900df75cd550086ffd0ae
--- /dev/null
+++ b/examples/single_system.py
@@ -0,0 +1,40 @@
+import os, sys
+
+# Append root dir of this project to include functionality
+sys.path.append(os.path.dirname(os.getcwd()))
+import binary_c
+
+
+"""
+Example script for running a single system. This is a very simple set up.
+For a different way of inputting arg strings:
+
+from utils.defaults import physics_defaults
+from utils.functions import create_arg_string
+
+physics_args = physics_defaults.copy()
+physics_args['orbital_period'] = 4530.0
+
+arg_string = create_arg_string(physics_args)
+arg_string = f'binary_c {arg_string}'
+
+Other examples can be found using this method
+"""
+
+def run_test_binary():
+ m1 = 15.0 # Msun
+ m2 = 14.0 # Msun
+ separation = 0 # 0 = ignored, use period
+ orbital_period = 4530.0 # days
+ eccentricity = 0.0
+ metallicity = 0.02
+ max_evolution_time = 15000
+ buffer = ""
+ # argstring = "binary_c M_1 {0:g} M_2 {1:g} separation {2:g} orbital_period {3:g} eccentricity {4:g} metallicity {5:g} max_evolution_time {6:g} ".format(m1,m2,separation,orbital_period,eccentricity,metallicity,max_evolution_time)
+
+ argstring = f"binary_c M_1 {m1} M_2 {m2} separation {separation} orbital_period {orbital_period} eccentricity {eccentricity} metallicity {metallicity} max_evolution_time {max_evolution_time}"
+
+ output = binary_c.run_binary(argstring)
+
+ # print ("Binary_c output:\n\n")
+ print (output)
\ No newline at end of file
diff --git a/tests_david/.ipynb_checkpoints/test_noteboo-checkpoint.ipynb b/tests_david/.ipynb_checkpoints/test_noteboo-checkpoint.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..2fd64429bf421126b7000c94ce0f6fd186fbd01f
--- /dev/null
+++ b/tests_david/.ipynb_checkpoints/test_noteboo-checkpoint.ipynb
@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tests_david/test_david.py b/tests_david/test_david.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b950999125ffbf742a47303c1f9f87cd5d18d63
--- /dev/null
+++ b/tests_david/test_david.py
@@ -0,0 +1,36 @@
+#!/usr/bin/python3
+import os
+import binary_c
+import matplotlib.pyplot as plt
+
+from utils.defaults import physics_defaults
+
+############################################################
+# Test script to run a binary using the binary_c Python
+# module.
+############################################################
+
+
+
+print(binary_c)
+
+
+# print("Current binary_c object class functions: ")
+# print(dir(binary_c))
+
+# print("Current binary_c.new_system object class functions: ")
+# print(dir(binary_c.new_system()))
+## WHat is the use of new_system?
+
+# print("Current binary_c.run_binary object class functions: ")
+# print(dir(binary_c.run_binary()))
+
+# binary_star=binary_c.new_system()
+# print(binary_star)
+# print(dir(binary_star))
+
+# Test single system
+# run_test_binary()
+
+# Test grid-like
+# run_simple_loop_binary()
\ No newline at end of file
diff --git a/tests_david/test_import.py b/tests_david/test_import.py
new file mode 100644
index 0000000000000000000000000000000000000000..848cfc72e9989fcaa449e2ee02753f17ce00156a
--- /dev/null
+++ b/tests_david/test_import.py
@@ -0,0 +1,5 @@
+import os, sys
+import binary_c
+# sys.path.append(os.path.dirname(file))
+print(os.getenv('PYTHONPATH'))
+#paths = os.getenv('PYTHONPATH').split(':' if os.name=='posix' else ';')
\ No newline at end of file
diff --git a/tests_david/test_noteboo.ipynb b/tests_david/test_noteboo.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..6592ec55f82712d48a76ac5dbf51a0e062b39919
--- /dev/null
+++ b/tests_david/test_noteboo.ipynb
@@ -0,0 +1,41 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import binary_c"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.6.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tests_david/testing_automatic_log_readout.py b/tests_david/testing_automatic_log_readout.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbd50cfdb32ba33fef5ab6f7dd7fba87ef167472
--- /dev/null
+++ b/tests_david/testing_automatic_log_readout.py
@@ -0,0 +1,13 @@
+import os, sys
+import matplotlib.pyplot as plt
+
+# # Append root dir of this project to include functionality
+# sys.path.append(os.path.dirname(os.getcwd()))
+# print(sys.path)
+# quit()
+
+import binary_c
+from utils.defaults import physics_defaults
+from utils.functions import create_arg_string
+
+
diff --git a/utils/__pycache__/defaults.cpython-35.pyc b/utils/__pycache__/defaults.cpython-35.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a32ade99bbfa82a830d3b87e46bc48ee0ce68ab5
Binary files /dev/null and b/utils/__pycache__/defaults.cpython-35.pyc differ
diff --git a/utils/__pycache__/defaults.cpython-36.pyc b/utils/__pycache__/defaults.cpython-36.pyc
index d364497266246ceb5cb898c81ad256338ab74946..66affbd99df305c1259678cf298c21735745c30f 100644
Binary files a/utils/__pycache__/defaults.cpython-36.pyc and b/utils/__pycache__/defaults.cpython-36.pyc differ
diff --git a/utils/__pycache__/functions.cpython-35.pyc b/utils/__pycache__/functions.cpython-35.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..62464c4667b48e168d6014c7ba2aa05b6cfb2208
Binary files /dev/null and b/utils/__pycache__/functions.cpython-35.pyc differ
diff --git a/utils/__pycache__/functions.cpython-36.pyc b/utils/__pycache__/functions.cpython-36.pyc
index 16a46b9804ec090a27bc98609a51840fce995f10..7aae7529a0a2c7d369cbd2ff93845ac4b5687f1f 100644
Binary files a/utils/__pycache__/functions.cpython-36.pyc and b/utils/__pycache__/functions.cpython-36.pyc differ
diff --git a/utils/functions.py b/utils/functions.py
index a116cd908ce120498b54d4c3764ec161bca63acf..2d4a479eaf5c6e358c4af210ee13392de0f13cd5 100644
--- a/utils/functions.py
+++ b/utils/functions.py
@@ -5,6 +5,8 @@ def create_arg_string(arg_dict):
arg_string = ''
for key in arg_dict.keys():
- arg_string += f'{key} {arg_dict[key]} '
+ arg_string += "{key} {value} ".format(key=key, value=arg_dict[key])
arg_string = arg_string.strip()
- return arg_string
\ No newline at end of file
+ return arg_string
+
+