Output files to original working directory if absolute path not specified (otherwise defaults to src/geophires_x which is undesirable)

Author: softwareengineerprogrammer

src/geophires_x/GEOPHIRESv3.py

@@ -19,6 +19,8 @@ def main(enable_geophires_logging_config=True):
     logging will be configured in the Model class.
     :return: None
     """
+    original_cwd:Path = Path.cwd().absolute()
+
     # set the starting directory to be the directory that this file is in
     os.chdir(os.path.dirname(os.path.abspath(__file__)))
 
@@ -33,7 +35,7 @@ def main(enable_geophires_logging_config=True):
     model = Model.Model(enable_geophires_logging_config=enable_geophires_logging_config)
 
     # read the parameters that apply to the model
-    model.read_parameters()
+    model.read_parameters(default_output_path=original_cwd)
 
     # Calculate the entire model
     model.Calculate()

src/geophires_x/Model.py

@@ -1,4 +1,5 @@
 import sys
+from email.policy import default
 from pathlib import Path
 import logging
 import time
@@ -196,9 +197,10 @@ def __init__(self, enable_geophires_logging_config=True, input_file=None):
     def __str__(self):
         return "Model"
 
-    def read_parameters(self) -> None:
+    def read_parameters(self, default_output_path: Path = None) -> None:
         """
         The read_parameters function reads the parameters from the input file and stores them in a dictionary.
+        :param default_output_path: Relative path for non-absolute output path parameters
         :return: None
         """
         self.logger.info(f'Init {__class__}: {__name__}')
@@ -209,17 +211,17 @@ def read_parameters(self) -> None:
         self.wellbores.read_parameters(self)
         self.surfaceplant.read_parameters(self)
         self.economics.read_parameters(self)
-        self.outputs.read_parameters(self)
+        self.outputs.read_parameters(self, default_output_path=default_output_path)
 
         # having read in the parameters, we now need to set up the objects that are specific to the user's choices
         # if we find out we have an add-ons, read the parameters
         if self.economics.DoAddOnCalculations.value:
             self.addeconomics.read_parameters(self)
-            self.addoutputs.read_parameters(self)
+            self.addoutputs.read_parameters(self, default_output_path=default_output_path)
         # if we find out we have an S-DAC-GT calculation, read for the parameters
         if self.economics.DoSDACGTCalculations.value:
             self.sdacgteconomics.read_parameters(self)
-            self.sdacgtoutputs.read_parameters(self)
+            self.sdacgtoutputs.read_parameters(self, default_output_path=default_output_path)
 
         # Once we are done reading and processing parameters,
         # we reset the objects to more specific objects based on user choices

src/geophires_x/Outputs.py

@@ -22,6 +22,7 @@
 from geophires_x.OptionList import EndUseOptions, EconomicModel, ReservoirModel, FractureShape, ReservoirVolume, \
     PlantType
 from geophires_x.GeoPHIRESUtils import UpgradeSymbologyOfUnits, render_default, InsertImagesIntoHTML
+from geophires_x.Parameter import Parameter
 
 NL = '\n'
 validFilenameChars = "-_.() %s%s" % (string.ascii_letters, string.digits)
@@ -639,24 +640,29 @@ def __init__(self, model:Model, output_file:str ='HDR.out'):
         model.logger.info(f'Init {__class__!s}: {__name__}')
         self.ParameterDict = {}
         self.OutputParameterDict = {}
+        self.filepath_parameter_names = []
 
-        self.text_output_file = self.ParameterDict[self.text_output_file.Name] = strParameter(
+        def file_path_parameter(p: Parameter) -> Parameter:
+            self.filepath_parameter_names.append(p.Name)
+            return p
+
+        self.text_output_file = self.ParameterDict[self.text_output_file.Name] = file_path_parameter(strParameter(
                 'Improved Text Output File',
                 DefaultValue='GEOPHIRES_Text.html',
                 Required=False,
                 Provided=False,
                 ErrMessage='assume no improved text output',
                 ToolTipText='Provide a improved text output name if you want to have improved text output (no output if not provided)',
-            )
+        ))
 
-        self.html_output_file = self.ParameterDict[self.html_output_file.Name] = strParameter(
+        self.html_output_file = self.ParameterDict[self.html_output_file.Name] = file_path_parameter(strParameter(
                 'HTML Output File',
                 DefaultValue='GEOPHIRES.html',
                 Required=False,
                 Provided=False,
                 ErrMessage='assume no HTML output',
                 ToolTipText='Provide a HTML output name if you want to have HTML output (no output if not provided)',
-            )
+        ))
 
         self.printoutput = self.ParameterDict[self.printoutput.Name] = boolParameter(
                 'Print Output to Console',
@@ -677,7 +683,7 @@ def __init__(self, model:Model, output_file:str ='HDR.out'):
     def __str__(self):
         return 'Outputs'
 
-    def read_parameters(self, model:Model) -> None:
+    def read_parameters(self, model: Model, default_output_path: Path = None) -> None:
         """
         The read_parameters function reads in the parameters from a dictionary and stores them in the parameters.
         It also handles special cases that need to be handled after a value has been read in and checked.
@@ -692,6 +698,7 @@ def read_parameters(self, model:Model) -> None:
         to call this method from you class, which can effectively modify all these superclass parameters in your class.
         :param model: The container class of the application, giving access to everything else, including the logger
         :type model: :class:`~geophires_x.Model.Model`
+        :param default_output_path: Relative path for non-absolute output path parameters
         :return: None
         """
         model.logger.info(f'Init {__class__!s}: {__name__}')
@@ -702,6 +709,15 @@ def read_parameters(self, model:Model) -> None:
                 key = ParameterToModify.Name.strip()
                 if key in model.InputParameters:
                     ParameterReadIn = model.InputParameters[key]
+
+                    if key in self.filepath_parameter_names:
+                        if not Path(ParameterReadIn.sValue).is_absolute():
+                            original_val = ParameterReadIn.sValue
+                            ParameterReadIn.sValue = str(
+                                default_output_path.joinpath(ParameterReadIn.sValue).absolute())
+                            model.logger.info(f'Adjusted {key} path to {ParameterReadIn.sValue} because original value '
+                                              f'({original_val}) was not an absolute path.')
+
                     # Before we change the parameter, let's assume that the unit preferences will match
                     # - if they don't, the later code will fix this.
                     ParameterToModify.CurrentUnits = ParameterToModify.PreferredUnits

src/geophires_x/SUTRAOutputs.py

@@ -5,13 +5,13 @@
 import geophires_x
 import numpy as np
 import geophires_x.Model as Model
-from .Parameter import LookupUnits
+from geophires_x.Outputs import Outputs
 from .OptionList import EconomicModel
 
 NL="\n"
 
-class SUTRAOutputs:
-    """TODO should inherit from Outputs"""
+
+class SUTRAOutputs(Outputs):
 
     def __init__(self, model:Model, output_file:str ='HDR.out'):
         """
@@ -35,45 +35,8 @@ def __init__(self, model:Model, output_file:str ='HDR.out'):
         model.logger.info(f'Complete {str(__class__)}: {sys._getframe().f_code.co_name}')
 
     def __str__(self):
-        return 'Outputs'
-
-    def read_parameters(self, model:Model) -> None:
-        """
-        The read_parameters function reads in the parameters from a dictionary and stores them in the parameters.
-        It also handles special cases that need to be handled after a value has been read in and checked.
-        If you choose to subclass this master class, you can also choose to override this method (or not), and if you do
-        Deals with all the parameter values that the user has provided.  They should really only provide values that
-        they want to change from the default values, but they can provide a value that is already set because it is a
-        default value set in __init__.  It will ignore those.
-        This also deals with all the special cases that need to be taken care of after a value has been read in
-        and checked.
-        If you choose to subclass this master class, you can also choose to override this method (or not),
-        and if you do, do it before or after you call you own version of this method.  If you do, you can also choose
-        to call this method from you class, which can effectively modify all these superclass parameters in your class.
-        :param model: The container class of the application, giving access to everything else, including the logger
-        :type model: :class:`~geophires_x.Model.Model`
-        :return: None
-        """
-        model.logger.info(f'Init {str(__class__)}: {sys._getframe().f_code.co_name}')
-
-        if len(model.InputParameters) > 0:
-            # if the user wants it, we need to know if the user wants to copy the contents of the
-            # output file to the screen - this serves as the screen report
-            if "Print Output to Console" in model.InputParameters:
-                ParameterReadIn = model.InputParameters["Print Output to Console"]
-                if ParameterReadIn.sValue == "0":
-                    self.printoutput = False
+        return 'SUTRAOutputs'
 
-            # loop through all the parameters that the user wishes to set, looking for parameters that contain the
-            # prefix "Units:" - that means we want to set a special case for converting this
-            # output parameter to new units
-            for key in model.InputParameters.keys():
-                if key.startswith("Units:"):
-                    self.ParameterDict[key.replace("Units:", "")] = LookupUnits(model.InputParameters[key].sValue)[0]
-
-                    # handle special cases
-
-        model.logger.info(f'Complete {str(__class__)}: {sys._getframe().f_code.co_name}')
 
     def PrintOutputs(self, model: Model):
         """