Merge pull request #641 from bobmyhill/perplex_build

Perplex build

Author: bobmyhill

.gitignore

@@ -6,3 +6,5 @@
 /build/*
 *.tmp
 *.pyc
+/contrib/perplex/perplex-installer
+/contrib/perplex/iron_olivine_lo_res

burnman/classes/composition.py

@@ -94,17 +94,8 @@ def __init__(self, composition_dictionary, unit_type="mass", normalize=False):
                 input_dictionary[k] = composition_dictionary[k] / n_total
 
         # Break component formulae into atomic dictionaries
-        self.component_formulae = {
-            c: dictionarize_formula(c) for c in composition_dictionary.keys()
-        }
-
-        # Create lists of elemental compositions of components
-        self.element_list = OrderedCounter()
-        for component in self.component_formulae.values():
-            self.element_list += OrderedCounter(
-                {element: n_atoms for (element, n_atoms) in component.items()}
-            )
-        self.element_list = list(self.element_list.keys())
+        fl = self._component_formulae_and_element_lists(composition_dictionary.keys())
+        self.component_formulae, self.element_list = fl
 
         if unit_type == "mass" or unit_type == "weight":
             self.mass_composition = input_dictionary
@@ -116,6 +107,30 @@ def __init__(self, composition_dictionary, unit_type="mass", normalize=False):
                 "Should be either mass, weight or molar."
             )
 
+    def _component_formulae_and_element_lists(self, component_strings):
+        """
+        Converts a list of components in string form into a list of components in dictionary form
+        and a list of elements.
+
+        :param component_strings: A list of strings containing a formula for each component
+        :type component_strings: list of strings
+        :return: a list of components in dictionary form and a list of elements.
+        :rtype: _type_
+        """
+
+        # Break component formulae into atomic dictionaries
+        component_formulae = {c: dictionarize_formula(c) for c in component_strings}
+
+        # Create lists of elemental compositions of components
+        element_list = OrderedCounter()
+        for component in component_formulae.values():
+            element_list += OrderedCounter(
+                {element: n_atoms for (element, n_atoms) in component.items()}
+            )
+        element_list = list(element_list.keys())
+
+        return component_formulae, element_list
+
     def renormalize(self, unit_type, normalization_component, normalization_amount):
         """
         Change the total amount of material in the composition
@@ -191,6 +206,14 @@ def change_component_set(self, new_component_list):
         :param new_component_list: New set of basis components.
         :type new_component_list: list of strings
         """
+
+        old_element_list = self.element_list
+        _, new_element_list = self._component_formulae_and_element_lists(
+            new_component_list
+        )
+
+        self.element_list = list(set(old_element_list).union(set(new_element_list)))
+
         composition = np.array(
             [self.atomic_composition[element] for element in self.element_list]
         )
@@ -218,6 +241,24 @@ def change_component_set(self, new_component_list):
         # Reinitialize the object
         self.__init__(composition, "molar")
 
+    def remove_null_components(self, tol=1.0e-12):
+        """
+        Removes components with absolute concentrations less than a given tolerance.
+
+        :param tol: zero tolerance, defaults to 1.e-12
+        :type tol: float, optional
+        """
+        c = deepcopy(self.molar_composition)
+        del_keys = []
+        for key, value in c.items():
+            if np.abs(value) < tol:
+                del_keys.append(key)
+        for key in del_keys:
+            c.pop(key)
+
+        # Reinitialize the object
+        self.__init__(c, "molar")
+
     def _mole_to_mass_composition(self, molar_comp):
         """
         Hidden function to returns the mass composition as a counter [kg]

burnman/classes/perplex.py

@@ -5,9 +5,6 @@
 from __future__ import absolute_import
 from __future__ import print_function
 
-import subprocess
-from os import rename
-
 import numpy as np
 from scipy.interpolate import RegularGridInterpolator
 from scipy.interpolate import griddata
@@ -17,125 +14,6 @@
 from ..utils.misc import copy_documentation
 
 
-def create_perplex_table(
-    werami_path,
-    project_name,
-    outfile,
-    n_pressures,
-    n_temperatures,
-    pressure_range=None,
-    temperature_range=None,
-):
-    """
-    This function uses PerpleX's werami software to output a table file
-    containing the following material properties.
-    2 - Density (kg/m3)
-    4 - Expansivity (1/K, for volume)
-    5 - Compressibility (1/bar, for volume)
-    10 - Adiabatic bulk modulus (bar)
-    11 - Adiabatic shear modulus (bar)
-    12 - Sound velocity (km/s)
-    13 - P-wave velocity (Vp, km/s)
-    14 - S-wave velocity (Vs, km/s)
-    17 - Entropy (J/K/kg)
-    18 - Enthalpy (J/kg)
-    19 - Heat Capacity (J/K/kg)
-    22 - Molar Volume (J/bar)
-
-    The user must already have a PerpleX build file,
-    and have run vertex on that build file.
-    """
-
-    print(
-        "Creating a {0}x{1} P-T table file using werami. Please wait.\n".format(
-            n_pressures, n_temperatures
-        )
-    )
-
-    try:
-        str2 = "y\n{0} {1}\n{2} {3}\n".format(
-            pressure_range[0] / 1.0e5,
-            pressure_range[1] / 1.0e5,
-            temperature_range[0],
-            temperature_range[1],
-        )
-    except TypeError:
-        print("Keeping P-T range the same as the original project range.\n")
-        str2 = "n\n"
-
-    stdin = (
-        "{0:s}\n2\n"
-        "2\nn\n"
-        "4\nn\n"
-        "5\nn\n"
-        "10\nn\n"
-        "11\nn\n"
-        "12\nn\n"
-        "13\nn\n"
-        "14\nn\n"
-        "17\nn\n"
-        "18\nn\n"
-        "19\nn\n"
-        "22\nn\n"
-        "0\n"
-        "{1:s}"
-        "{2:d} {3:d}\n"
-        "0\n".format(project_name, str2, n_pressures, n_temperatures)
-    )
-
-    with subprocess.Popen(
-        werami_path,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        encoding="utf8",
-    ) as process:
-        process.stdin.write(stdin)
-        process.stdin.flush()
-
-        out = ""
-        # Grab stdout line by line as it becomes available.
-        # This will loop until the process terminates.
-        stdoutput = ""
-        while process.poll() is not None:
-            line = process.stdout.readline()
-            stdoutput += line
-
-            # Check if vertex has been run on the build file
-            if "missing *.tof file" in line:
-                raise Exception(
-                    "You must run Perple_X vertex "
-                    f"({werami_path[0].split('werami')[0]}vertex) "
-                    "using the PerpleX build file ({project_name}) "
-                    "before running this script."
-                )
-
-        while process.poll() is None:
-            line = process.stdout.readline()
-            stdoutput += line
-
-            # Check if werami is trying to create a standard resolution grid
-            # Tell the user to modify their local perplex option file if so.
-            if "Continue (y/n)?" in line:
-                raise Exception(
-                    "If you do not want to define your own P-T range for the grid,\n"
-                    "you must set sample_on_grid to F in the perplex option file\n"
-                    "(default is perplex_option.dat)."
-                )
-
-            # Get the output file name
-            if "Output has been written to the" in line:
-                out = line.split()[-1]
-
-        # Print stdoutput
-        print(stdoutput)
-        print(process.stdout.read())
-
-        # Rename the file to the user-specified filename
-        rename(out, outfile)
-        print("Output file renamed to {0:s}".format(outfile))
-        print("Processing complete")
-
-
 class PerplexMaterial(Material):
     """
     This is the base class for a PerpleX material. States of the material

burnman/utils/misc.py

@@ -6,6 +6,7 @@
 from __future__ import absolute_import
 from __future__ import print_function
 
+import subprocess
 import operator
 import bisect
 import pkgutil
@@ -237,3 +238,69 @@ def f(x):
         return value
 
     return f
+
+
+def extract_lines_between_markers(file, start_string, end_string, inclusive=False):
+    """
+    Extract lines from a file between two marker strings.
+
+    :param file: Path to the input text file.
+    :type file: str
+    :param start_string: The marker string indicating where to start collecting lines.
+    :type start_string: str
+    :param end_string: The marker string indicating where to stop collecting lines.
+    :type end_string: str
+    :param inclusive: Whether to include the lines containing start_string and end_string, defaults to False.
+    :type inclusive: bool, optional
+    :return: A list of lines between the two markers.
+    :rtype: list[str]
+    """
+    lines = []
+    with open(file, encoding="latin-1") as f:
+        inside = False
+        for line in f:
+            if start_string in line and not inside:
+                inside = True
+                if inclusive:
+                    lines.append(line.strip())
+                continue  # Don't reprocess the start line if not inclusive
+
+            if inside:
+                if end_string in line:
+                    if inclusive:
+                        lines.append(line.strip())
+                    break
+                lines.append(line.strip())
+
+    return lines
+
+
+def run_cli_program_with_input(program_path, stdin, verbose=True):
+    """
+    Run a command-line program with provided input and capture its output.
+
+    :param program_path: Path to the CLI executable or a list of command-line arguments.
+    :type program_path: str | list[str]
+    :param stdin: The input string to pass to the program via standard input.
+    :type stdin: str
+    :param verbose: If True, prints the program's output to stdout, defaults to True.
+    :type verbose: bool, optional
+    :return: The standard output produced by the program.
+    :rtype: str
+    """
+    process = subprocess.Popen(
+        program_path,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+    stdoutput, stderr = process.communicate(stdin)
+
+    if verbose:
+        print(stdoutput)
+        if stderr:
+            print("Error output:", stderr)
+
+    return stdoutput

contrib/perplex/Readme.md

@@ -0,0 +1,49 @@
+# Perple_X P-T Table Generation
+
+This repository contains scripts and resources to download, install, and use **Perple_X** to generate and read a low-resolution thermodynamic table for an iron-olivine system. It can be used as a template to
+create and read your own tables.
+
+## Contents
+
+- **download_and_install_perplex.sh**  
+  A shell script to automatically download and install Perple_X in the local directory.
+
+- **create_lo_res_table.py**  
+  A Python script to generate a low-resolution thermodynamic table using Perple_X. This script calls Perple_X programs and configures the run for a simplified system.
+
+- **read_lo_res_table.py**  
+  A Python script to read and parse the generated low-resolution table (e.g., from `table.txt`) for further analysis or plotting.
+
+- **perplex_utils.py**  
+  A python file containing useful Perple_X-related functions.
+
+## Getting Started
+
+1. **Install Perple_X:**
+
+   ```bash
+   ./download_and_install_perplex.sh
+   ```
+
+   This will download the latest Perple_X release and compile it locally.
+
+2. **Create the Thermodynamic Table:**
+
+   ```bash
+   python create_lo_res_table.py
+   ```
+
+   This will use Perple_X to generate the low-resolution table in a newly created project directory.
+
+3. **Read and Analyze the Table:**
+
+   ```bash
+   python read_lo_res_table.py
+   ```
+
+   This script parses the output table for further use (e.g., plotting or machine learning workflows).
+
+## Notes
+
+- The resolution and thermodynamic scope in this example are intentionally simplified.
+- Make sure to review Perple_X license and citation guidelines when using in published work.