Add command-line option for python MusicBox

.github/workflows/test.yml → .github/workflows/CI_Tests.yml

@@ -1,9 +1,10 @@
-name: build
+name: CI Tests
 
 on: [push, workflow_dispatch]
 
 jobs:
   build:
+    continue-on-error: true
     strategy:
         matrix:
           os: [ubuntu-latest, macos-latest, windows-latest]
@@ -20,17 +21,13 @@ jobs:
         python-version: '3.9'
         cache: 'pip' 
 
-    - run: pip install -r requirements.txt
+    - name: Install dependencies
+      run: python -m pip install --upgrade pip
 
     - name: Install this package
       run: pip install -e .
-
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install -r requirements.txt
 
-    - name: Run tests
+    - name: Run the smoke tests
       run: |
-        cd tests
-        pytest
+        music_box configFile=tests/configs/analytical_config/my_config.json outputDir=tests/configs/analytical_config
+

pyproject.toml

@@ -21,8 +21,11 @@ classifiers = ["License :: OSI Approved :: Apache Software License"]
 dynamic = ["version", "description"]
 
 dependencies = [
-  "musica==0.6.1.dev0"
+  "musica==0.7.0"
 ]
 
 [project.urls]
-Home = "https://github.com/NCAR/music-box"
+Home = "https://github.com/NCAR/music-box"
+
+[project.scripts]
+music_box = "acom_music_box.music_box_main:main"

requirements.txt

@@ -1,4 +1,4 @@
-musica==0.6.1.dev0
+musica==0.7.0
 pandas
 pipx
 pytest

src/acom_music_box/music_box.py

@@ -1,15 +1,21 @@
 import json
 import os
 
+import logging
+logger = logging.getLogger(__name__)
+
 from .music_box_evolving_conditions import EvolvingConditions
 from .music_box_reaction_list import ReactionList
 from .music_box_reaction import Reaction, Branched, Arrhenius, Tunneling, Troe_Ternary
 from .music_box_species_list import SpeciesList
 from .music_box_model_options import BoxModelOptions
 from .music_box_conditions import Conditions
+
 import csv
 import musica
 
+
+
 class MusicBox:
     """
     Represents a box model with attributes such as box model options, species list, reaction list,
@@ -36,13 +42,15 @@ def __init__(self, box_model_options=None, species_list=None, reaction_list=None
             evolving_conditions (List[EvolvingConditions]): List of evolving conditions over time.
             config_file (String): File path for the configuration file to be located. Default is "camp_data/config.json".
         """
-        self.box_model_options = box_model_options
+        self.box_model_options = box_model_options if box_model_options is not None else BoxModelOptions()
         self.species_list = species_list if species_list is not None else SpeciesList()
         self.reaction_list = reaction_list if reaction_list is not None else ReactionList()
-        self.initial_conditions = initial_conditions
+        self.initial_conditions = initial_conditions if initial_conditions is not None else Conditions()
         self.evolving_conditions = evolving_conditions if evolving_conditions is not None else EvolvingConditions([], [])
         self.config_file = config_file if config_file is not None else "camp_data/config.json"
 
+        self.solver = None
+
 
 
     def add_evolving_condition(self, time_point, conditions):
@@ -409,7 +417,7 @@ def create_solver(self, path_to_config):
             None
         """
         # Create a solver object using the configuration file
-        self.solver = musica.create_micm(path_to_config)
+        self.solver = musica.create_solver(path_to_config)
 
 
     def solve(self, path_to_output = None):
@@ -428,7 +436,7 @@ def solve(self, path_to_output = None):
             list: A 2D list where each inner list represents the results of the simulation 
             at a specific time step.
         """
-
+       
         #sets up initial conditions to be current conditions
         curr_conditions = self.initial_conditions
 
@@ -448,7 +456,7 @@ def solve(self, path_to_output = None):
                 next_conditions_index = 1
                 next_conditions = self.evolving_conditions.conditions[1]
                 next_conditions_time = self.evolving_conditions.times[1]    
-                
+
 
         #initalizes output headers
         output_array = []
@@ -458,10 +466,15 @@ def solve(self, path_to_output = None):
         headers.append("ENV.temperature")
         headers.append("ENV.pressure")
 
+
+        if (self.solver is None):
+            raise Exception("Error: MusicBox object {} has no solver."
+                .format(self))
         rate_constant_ordering = musica.user_defined_reaction_rates(self.solver)
+
         species_constant_ordering = musica.species_ordering(self.solver)
 
-        
+
         #adds species headers to output
         ordered_species_headers =  [k for k, v in sorted(species_constant_ordering.items(), key=lambda item: item[1])]
         for spec in ordered_species_headers:
@@ -478,9 +491,9 @@ def solve(self, path_to_output = None):
         next_output_time = curr_time
         #runs the simulation at each timestep
 
-
-
+
         while(curr_time <= self.box_model_options.simulation_length):
+
             #outputs to output_array if enough time has elapsed
             if(next_output_time <= curr_time):   
                 row = []
@@ -507,30 +520,36 @@ def solve(self, path_to_output = None):
 
                 else:
                     next_conditions = None
-
-
+
+
+            #  calculate air density from the ideal gas law
+            BOLTZMANN_CONSTANT = 1.380649e-23
+            AVOGADRO_CONSTANT = 6.02214076e23;  
+            GAS_CONSTANT = BOLTZMANN_CONSTANT * AVOGADRO_CONSTANT
+            air_density = curr_conditions.pressure / (GAS_CONSTANT * curr_conditions.temperature) 
+
             #updates M accordingly
             if 'M' in species_constant_ordering:
-                BOLTZMANN_CONSTANT = 1.380649e-23
-                AVOGADRO_CONSTANT = 6.02214076e23;  
-                GAS_CONSTANT = BOLTZMANN_CONSTANT * AVOGADRO_CONSTANT
-                ordered_concentrations[species_constant_ordering['M']] = curr_conditions.pressure / (GAS_CONSTANT * curr_conditions.temperature)
+                ordered_concentrations[species_constant_ordering['M']] = air_density
 
             #solves and updates concentration values in concentration array
-            musica.micm_solve(self.solver, self.box_model_options.chem_step_time, curr_conditions.temperature, curr_conditions.pressure, ordered_concentrations, ordered_rate_constants)
-
-
+            if (not ordered_concentrations):
+                logger.info("Warning: ordered_concentrations list is empty.")
+            musica.micm_solve(self.solver, self.box_model_options.chem_step_time,
+                curr_conditions.temperature, curr_conditions.pressure, air_density,
+                ordered_concentrations, ordered_rate_constants)
 
 
             #increments time
             curr_time += self.box_model_options.chem_step_time  
-
+            
         #outputs to file if output is present
         if(path_to_output != None):
+            logger.info("path_to_output = {}".format(path_to_output))
             with open(path_to_output, 'w', newline='') as output:
                 writer = csv.writer(output)
                 writer.writerows(output_array)
-        
+
         #returns output_array 
         return output_array
 

src/acom_music_box/music_box_conditions.py

@@ -19,7 +19,8 @@ class Conditions:
         reactionRates (List[ReactionRate]): A list of reaction rates.
     """
 
-    def __init__(self, pressure, temperature, species_concentrations=None, reaction_rates=None):
+    def __init__(self, pressure=None, temperature=None, species_concentrations=None, reaction_rates=None):
+
         """
         Initializes a new instance of the Conditions class.
 

src/acom_music_box/music_box_main.py

@@ -0,0 +1,90 @@
+from acom_music_box import MusicBox
+
+
+import math
+import datetime
+import sys
+
+import logging
+logger = logging.getLogger(__name__)
+
+import argparse
+import os
+
+
+
+# configure argparse for key-value pairs
+class KeyValueAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        for value in values:
+            key, val = value.split('=')
+            setattr(namespace, key, val)
+
+# Retrieve named arguments from the command line and
+# return in a dictionary of keywords.
+# argPairs = list of arguments, probably from sys.argv[1:]
+#       named arguments are formatted like this=3.14159
+# return dictionary of keywords and values
+def getArgsDictionary(argPairs):
+    parser = argparse.ArgumentParser(description='Process some key=value pairs.')
+    parser.add_argument(
+        'key_value_pairs',
+        nargs='+',  # This means one or more arguments are expected
+        action=KeyValueAction,
+        help="Arguments in key=value format. Example: configFile=my_config.json"
+    )
+
+    argDict = vars(parser.parse_args(argPairs))      # return dictionary
+
+    return(argDict)
+
+
+
+def main():
+    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+    logger.info("{}".format(__file__))
+    logger.info("Start time: {}".format(datetime.datetime.now()))
+
+    logger.info("Hello, MusicBox World!")
+    logger.info("Working directory = {}".format(os.getcwd()))
+
+    # retrieve and parse the command-line arguments
+    myArgs = getArgsDictionary(sys.argv[1:])
+    logger.info("Command line = {}".format(myArgs))
+
+    # set up the home configuration file
+    musicBoxConfigFile = None
+    if ("configFile" in myArgs):
+        musicBoxConfigFile = myArgs.get("configFile")
+
+    # set up the output directory
+    musicBoxOutputDir = ".\\"      # default
+    if ("outputDir" in myArgs):
+        musicBoxOutputDir = myArgs.get("outputDir")
+
+    # check for required arguments and provide examples
+    if (musicBoxConfigFile is None):
+        errorString = "Error: The configFile parameter is required."
+        errorString += (" Example: configFile={}"
+            .format(os.path.join("tests", "configs", "analytical_config", "my_config.json")))
+        raise Exception(errorString)
+
+    # create and load a MusicBox object
+    myBox = MusicBox()
+    myBox.readConditionsFromJson(musicBoxConfigFile)
+    logger.info("myBox = {}".format(myBox))
+
+    # create solver and solve, writing output to requested directory
+    campConfig = os.path.join(os.path.dirname(musicBoxConfigFile), myBox.config_file)
+    logger.info("CAMP config = {}".format(campConfig))
+    myBox.create_solver(campConfig)
+    logger.info("myBox.solver = {}".format(myBox.solver))
+    mySolution = myBox.solve(os.path.join(musicBoxOutputDir, "mySolution.csv"))
+    logger.info("mySolution = {}".format(mySolution))
+
+    logger.info("End time: {}".format(datetime.datetime.now()))
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

src/acom_music_box/music_box_model_options.py

@@ -12,7 +12,8 @@ class BoxModelOptions:
         simulationLength (float): Length of the simulation in hours.
     """
 
-    def __init__(self, chem_step_time, output_step_time, simulation_length, grid="box"):
+    def __init__(self, chem_step_time=None, output_step_time=None, simulation_length=None, grid="box"):
+
         """
         Initializes a new instance of the BoxModelOptions class.