calphy 1.4.4__py3-none-any.whl → 1.4.6__py3-none-any.whl

calphy/helpers.py

@@ -3,14 +3,14 @@ calphy: a Python library and command line interface for automated free
 energy calculations.
 
 Copyright 2021  (c) Sarath Menon^1, Yury Lysogorskiy^2, Ralf Drautz^2
-^1: Max Planck Institut für Eisenforschung, Dusseldorf, Germany 
+^1: Max Planck Institut für Eisenforschung, Dusseldorf, Germany
 ^2: Ruhr-University Bochum, Bochum, Germany
 
-calphy is published and distributed under the Academic Software License v1.0 (ASL). 
-calphy is distributed in the hope that it will be useful for non-commercial academic research, 
-but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+calphy is published and distributed under the Academic Software License v1.0 (ASL).
+calphy is distributed in the hope that it will be useful for non-commercial academic research,
+but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 calphy API is published and distributed under the BSD 3-Clause "New" or "Revised" License
-See the LICENSE FILE for more details. 
+See the LICENSE FILE for more details.
 
 More information about the program can be found in:
 Menon, Sarath, Yury Lysogorskiy, Jutta Rogal, and Ralf Drautz.
@@ -34,6 +34,7 @@ from ase.io import read, write
 import pyscal3.core as pc
 from pyscal3.trajectory import Trajectory
 
+
 class LammpsScript:
     def __init__(self):
         self.script = []
@@ -42,12 +43,14 @@ class LammpsScript:
         self.script.append(command_str)
 
     def write(self, infile):
-        with open(infile, 'w') as fout:
+        with open(infile, "w") as fout:
             for line in self.script:
-                fout.write(f'{line}\n')
+                fout.write(f"{line}\n")
+
 
-def create_object(cores, directory, timestep, cmdargs="", 
-    init_commands=(), script_mode=False):
+def create_object(
+    cores, directory, timestep, cmdargs="", init_commands=(), script_mode=False
+):
     """
     Create LAMMPS object
 
@@ -71,28 +74,28 @@ def create_object(cores, directory, timestep, cmdargs="",
     else:
         if cmdargs == "":
             cmdargs = None
-        lmp = LammpsLibrary(
-            cores=cores, working_directory=directory, cmdargs=cmdargs
-        )
+        lmp = LammpsLibrary(cores=cores, working_directory=directory, cmdargs=cmdargs)
 
-    commands = [["units", "metal"], 
-    ["boundary", "p p p"],
-    ["atom_style", "atomic"],
-    ["timestep", str(timestep)],
-    ["box", "tilt large"]]
+    commands = [
+        ["units", "metal"],
+        ["boundary", "p p p"],
+        ["atom_style", "atomic"],
+        ["timestep", str(timestep)],
+        ["box", "tilt large"],
+    ]
 
     if len(init_commands) > 0:
-        #we need to replace some initial commands
+        # we need to replace some initial commands
         for rc in init_commands:
-            #split the command
+            # split the command
             raw = rc.split()
             for x in range(len(commands)):
                 if raw[0] == commands[x][0]:
-                    #we found a matching command
+                    # we found a matching command
                     commands[x] = [rc]
                     break
             else:
-                #its a new command, add it to the list
+                # its a new command, add it to the list
                 commands.append([rc])
 
     for command in commands:
@@ -121,12 +124,12 @@ def create_structure(lmp, calc):
 
 
 def set_mass(lmp, options):
-    if options.mode == 'composition_scaling':
-        lmp.command(f'mass * {options.mass[-1]}')
+    if options.mode == "composition_scaling":
+        lmp.command(f"mass * {options.mass[-1]}")
 
     else:
         for i in range(options.n_elements):
-            lmp.command(f'mass {i+1} {options.mass[i]}')
+            lmp.command(f"mass {i+1} {options.mass[i]}")
     return lmp
 
 
@@ -144,19 +147,21 @@ def set_potential(lmp, options):
     -------
     lmp : LammpsLibrary object
     """
-    #lmp.pair_style(options.pair_style_with_options[0])
-    #lmp.pair_coeff(options.pair_coeff[0])
-    lmp.command(f'pair_style {options._pair_style_with_options[0]}')
-    lmp.command(f'pair_coeff {options.pair_coeff[0]}')
+    # lmp.pair_style(options.pair_style_with_options[0])
+    # lmp.pair_coeff(options.pair_coeff[0])
+    lmp.command(f"pair_style {options._pair_style_with_options[0]}")
+    lmp.command(f"pair_coeff {options.pair_coeff[0]}")
 
     lmp = set_mass(lmp, options)
 
     return lmp
 
+
 def read_data(lmp, file):
     lmp.command(f"read_data {file}")
     return lmp
 
+
 def get_structures(file, species, index=None):
     traj = Trajectory(file)
     if index is None:
@@ -165,6 +170,7 @@ def get_structures(file, species, index=None):
         aseobjs = traj[index].to_ase(species=species)
     return aseobjs
 
+
 def remap_box(lmp, x, y, z):
     lmp.command("run 0")
     lmp.command(
@@ -222,8 +228,15 @@ def write_data(lmp, file):
     lmp.command(f"write_data {file}")
     return lmp
 
+
 def prepare_log(file, screen=False):
     logger = logging.getLogger(__name__)
+
+    # Remove all existing handlers to prevent duplicate logging
+    for handler in logger.handlers[:]:
+        handler.close()
+        logger.removeHandler(handler)
+
     handler = logging.FileHandler(file)
     formatter = logging.Formatter("%(asctime)s %(name)-12s %(levelname)-8s %(message)s")
     handler.setFormatter(formatter)
@@ -238,6 +251,7 @@ def prepare_log(file, screen=False):
         logger.addHandler(scr)
     return logger
 
+
 def check_if_any_is_none(data):
     """
     Check if any elements of a list is None, if so return True

calphy/input.py

@@ -49,7 +49,7 @@ from pyscal3.core import structure_dict, element_dict, _make_crystal
 from ase.io import read, write
 import shutil
 
-__version__ = "1.4.4"
+__version__ = "1.4.6"
 
 
 def _check_equal(val):
@@ -92,6 +92,49 @@ def _to_float(val):
         return [float(x) for x in val]
 
 
+def _extract_elements_from_pair_coeff(pair_coeff_string):
+    """
+    Extract element symbols from pair_coeff string.
+    Returns None if pair_coeff doesn't contain element specifications.
+
+    Parameters
+    ----------
+    pair_coeff_string : str
+        The pair_coeff command string (e.g., "* * potential.eam.fs Cu Zr")
+
+    Returns
+    -------
+    list or None
+        List of element symbols in order, or None if no elements found
+    """
+    if pair_coeff_string is None:
+        return None
+
+    pcsplit = pair_coeff_string.strip().split()
+    elements = []
+
+    # Start collecting after we find element symbols
+    # Elements are typically after the potential filename
+    started = False
+
+    for p in pcsplit:
+        # Check if this looks like an element symbol
+        # Element symbols are 1-2 characters, start with uppercase
+        if len(p) <= 2 and p[0].isupper():
+            try:
+                # Verify it's a valid element using mendeleev
+                _ = mendeleev.element(p)
+                elements.append(p)
+                started = True
+            except:
+                # Not a valid element, might be done collecting
+                if started:
+                    # We already started collecting elements and hit a non-element
+                    break
+
+    return elements if len(elements) > 0 else None
+
+
 class UFMP(BaseModel, title="UFM potential input options"):
     p: Annotated[float, Field(default=50.0)]
     sigma: Annotated[float, Field(default=1.5)]
@@ -165,7 +208,6 @@ class Queue(BaseModel, title="Options for configuring queue"):
     memory: Annotated[str, Field(default="3GB")]
     commands: Annotated[List, Field(default=[])]
     options: Annotated[List, Field(default=[])]
-    modules: Annotated[List, Field(default=[])]
 
 
 class Tolerance(BaseModel, title="Tolerance settings for convergence"):
@@ -181,10 +223,17 @@ class MeltingTemperature(BaseModel, title="Input options for melting temperature
     step: Annotated[int, Field(default=200, ge=20)]
     attempts: Annotated[int, Field(default=5, ge=1)]
 
-class MaterialsProject(BaseModel, title='Input options for materials project'):
+
+class MaterialsProject(BaseModel, title="Input options for materials project"):
     api_key: Annotated[str, Field(default="", exclude=True)]
     conventional: Annotated[bool, Field(default=True)]
-    target_natoms: Annotated[int, Field(default=1500, description='The structure parsed from materials project would be repeated to approximately this value')]
+    target_natoms: Annotated[
+        int,
+        Field(
+            default=1500,
+            description="The structure parsed from materials project would be repeated to approximately this value",
+        ),
+    ]
 
     @field_validator("api_key", mode="after")
     def resolve_api_key(cls, v: str) -> str:
@@ -198,6 +247,7 @@ class MaterialsProject(BaseModel, title='Input options for materials project'):
             )
         return value
 
+
 class Calculation(BaseModel, title="Main input class"):
     monte_carlo: Optional[MonteCarlo] = MonteCarlo()
     composition_scaling: Optional[CompositionScaling] = CompositionScaling()
@@ -306,6 +356,43 @@ class Calculation(BaseModel, title="Main input class"):
 
         self.n_elements = len(self.element)
 
+        # Validate element/mass/pair_coeff ordering consistency
+        # This is critical for multi-element systems where LAMMPS type numbers
+        # are assigned based on element order: element[0]=Type1, element[1]=Type2, etc.
+        if (
+            len(self.element) > 1
+            and self.pair_coeff is not None
+            and len(self.pair_coeff) > 0
+        ):
+            extracted_elements = _extract_elements_from_pair_coeff(self.pair_coeff[0])
+
+            if extracted_elements is not None:
+                # pair_coeff specifies elements - check ordering
+                if set(extracted_elements) != set(self.element):
+                    raise ValueError(
+                        f"Element mismatch between 'element' and 'pair_coeff'!\n"
+                        f"  element:    {self.element}\n"
+                        f"  pair_coeff: {extracted_elements}\n"
+                        f"The elements specified must be the same."
+                    )
+
+                if list(extracted_elements) != list(self.element):
+                    raise ValueError(
+                        f"Element ordering mismatch detected!\n\n"
+                        f"  element:    {self.element}\n"
+                        f"  pair_coeff: {extracted_elements}\n"
+                        f"  mass:       {self.mass}\n\n"
+                        f"For multi-element systems, all three must be in the SAME order.\n\n"
+                        f"Why this matters:\n"
+                        f"  - Element order determines LAMMPS type numbers:\n"
+                        f"      element[0] → Type 1, element[1] → Type 2, etc.\n"
+                        f"  - The pair_coeff elements must match this type order\n"
+                        f"  - The mass values must correspond to the same order\n"
+                        f"  - Composition transformations depend on this ordering\n\n"
+                        f"Please reorder your input so element, mass, and pair_coeff\n"
+                        f"all use the same element ordering."
+                    )
+
         self._pressure_input = copy.copy(self.pressure)
         if self.pressure is None:
             self._iso = True
@@ -515,40 +602,58 @@ class Calculation(BaseModel, title="Main input class"):
             self._original_lattice = self.lattice.lower()
             write_structure_file = True
 
-        elif self.lattice.split('-')[0] == 'mp':
-            #confirm here that API key exists
+        elif self.lattice.split("-")[0] == "mp":
+            # confirm here that API key exists
             if not self.materials_project.api_key:
-                raise ValueError('could not find API KEY, pls set it.')
-            #now we need to fetch the structure
+                raise ValueError("could not find API KEY, pls set it.")
+            # now we need to fetch the structure
             try:
                 from mp_api.client import MPRester
             except ImportError:
-                raise ImportError('Could not import mp_api, make sure you install mp_api package!')
-            #now all good
+                raise ImportError(
+                    "Could not import mp_api, make sure you install mp_api package!"
+                )
+            # now all good
             rest = {
-                    "use_document_model": False,
-                    "include_user_agent": True,
-                    "api_key": self.materials_project.api_key, 
-                }
+                "use_document_model": False,
+                "include_user_agent": True,
+                "api_key": self.materials_project.api_key,
+            }
             with MPRester(**rest) as mpr:
                 docs = mpr.materials.summary.search(material_ids=[self.lattice])
 
             structures = []
             for doc in docs:
-                struct = doc['structure']
+                struct = doc["structure"]
                 if self.materials_project.conventional:
                     aseatoms = struct.to_conventional().to_ase_atoms()
                 else:
                     aseatoms = struct.to_primitive().to_ase_atoms()
                 structures.append(aseatoms)
             structure = structures[0]
-            
+
             if np.prod(self.repeat) == 1:
-                x = int(np.ceil((self.materials_project.target_natoms/len(structure))**(1/3)))
+                x = int(
+                    np.ceil(
+                        (self.materials_project.target_natoms / len(structure))
+                        ** (1 / 3)
+                    )
+                )
                 structure = structure.repeat(x)
             else:
                 structure = structure.repeat(self.repeat)
 
+            # extract composition
+            types, typecounts = np.unique(
+                structure.get_chemical_symbols(), return_counts=True
+            )
+
+            for c, t in enumerate(types):
+                self._element_dict[t]["count"] = typecounts[c]
+                self._element_dict[t]["composition"] = typecounts[c] / np.sum(
+                    typecounts
+                )
+
             self._natoms = len(structure)
             self._original_lattice = self.lattice.lower()
             write_structure_file = True

calphy/phase_diagram.py

@@ -254,6 +254,141 @@ matcolors = {
 	}
 }
 
+def read_structure_composition(lattice_file, element_list):
+    """
+    Read a LAMMPS data file and determine the input chemical composition.
+    
+    Parameters
+    ----------
+    lattice_file : str
+        Path to the LAMMPS data file
+    element_list : list
+        List of element symbols in order (element[0] = type 1, element[1] = type 2, etc.)
+    
+    Returns
+    -------
+    dict
+        Dictionary mapping element symbols to atom counts
+        Elements not present in the structure will have count 0
+    """
+    from ase.io import read
+    from collections import Counter
+    
+    # Read the structure file
+    structure = read(lattice_file, format='lammps-data', style='atomic')
+    
+    # Get the species/types from the structure
+    # ASE reads LAMMPS types as species strings ('1', '2', etc.)
+    if 'species' in structure.arrays:
+        types_in_structure = structure.arrays['species']
+    else:
+        # Fallback: get atomic numbers and convert to strings
+        types_in_structure = [str(x) for x in structure.get_atomic_numbers()]
+    
+    # Count atoms by type
+    type_counts = Counter(types_in_structure)
+    
+    # Build composition mapping element names to counts
+    # element[0] corresponds to LAMMPS type '1', element[1] to type '2', etc.
+    input_chemical_composition = {}
+    for idx, element in enumerate(element_list):
+        lammps_type = str(idx + 1)  # LAMMPS types are 1-indexed
+        input_chemical_composition[element] = type_counts.get(lammps_type, 0)
+    
+    return input_chemical_composition
+
+
+# Constants for phase diagram preparation
+COMPOSITION_TOLERANCE = 1E-5
+
+
+def _create_composition_array(comp_range, interval, reference):
+    """
+    Create composition array from range specification.
+    
+    Parameters
+    ----------
+    comp_range : list or scalar
+        Composition range [min, max] or single value
+    interval : float
+        Composition interval
+    reference : float
+        Reference composition value
+    
+    Returns
+    -------
+    tuple
+        (comp_arr, is_reference) - composition array and boolean array marking reference compositions
+    """
+    # Convert to list if scalar
+    if not isinstance(comp_range, list):
+        comp_range = [comp_range]
+    
+    if len(comp_range) == 2:
+        comp_arr = np.arange(comp_range[0], comp_range[-1], interval)
+        last_val = comp_range[-1]
+        if last_val not in comp_arr:
+            comp_arr = np.append(comp_arr, last_val)
+        is_reference = np.abs(comp_arr - reference) < COMPOSITION_TOLERANCE
+    elif len(comp_range) == 1:
+        comp_arr = [comp_range[0]]
+        is_reference = [True]
+    else:
+        raise ValueError("Composition range should be scalar or list of two values!")
+    
+    return comp_arr, is_reference
+
+
+def _create_temperature_array(temp_range, interval):
+    """
+    Create temperature array from range specification.
+    
+    Parameters
+    ----------
+    temp_range : list or scalar
+        Temperature range [min, max] or single value
+    interval : float
+        Temperature interval
+    
+    Returns
+    -------
+    ndarray
+        Temperature array
+    """
+    # Convert to list if scalar
+    if not isinstance(temp_range, list):
+        temp_range = [temp_range]
+    
+    if len(temp_range) == 2:
+        ntemps = int((temp_range[-1] - temp_range[0]) / interval) + 1
+        temp_arr = np.linspace(temp_range[0], temp_range[-1], ntemps, endpoint=True)
+    elif len(temp_range) == 1:
+        temp_arr = [temp_range[0]]
+    else:
+        raise ValueError("Temperature range should be scalar or list of two values!")
+    
+    return temp_arr
+
+
+def _add_temperature_calculations(calc_dict, temp_arr, all_calculations):
+    """
+    Helper to add calculations for each temperature point.
+    
+    Parameters
+    ----------
+    calc_dict : dict
+        Base calculation dictionary
+    temp_arr : array
+        Array of temperatures
+    all_calculations : list
+        List to append calculations to
+    """
+    for temp in temp_arr:
+        calc_for_temp = copy.deepcopy(calc_dict)
+        calc_for_temp['temperature'] = int(temp)
+        all_calculations.append(calc_for_temp)
+
+
 def fix_data_file(datafile, nelements):
     """
     Change the atom types keyword in the structure file
@@ -309,6 +444,31 @@ def prepare_inputs_for_phase_diagram(inputyamlfile, calculation_base_name=None):
         calculation_base_name = inputyamlfile    
     
     for phase in data['phases']:
+        # Validate binary system assumption
+        n_elements = len(phase['element'])
+        if n_elements != 2:
+            raise ValueError(
+                f"Phase diagram preparation currently supports only binary systems. "
+                f"Found {n_elements} elements: {phase['element']}"
+            )
+        
+        # Validate element ordering consistency with pair_coeff
+        # This ensures element[0] -> type 1, element[1] -> type 2
+        if 'pair_coeff' in phase:
+            from calphy.input import _extract_elements_from_pair_coeff
+            # pair_coeff can be a list or a string - handle both
+            pair_coeff = phase['pair_coeff']
+            if isinstance(pair_coeff, list):
+                pair_coeff = pair_coeff[0] if pair_coeff else None
+            pair_coeff_elements = _extract_elements_from_pair_coeff(pair_coeff)
+            if pair_coeff_elements != phase['element']:
+                raise ValueError(
+                    f"Element ordering mismatch for phase '{phase.get('phase_name', 'unnamed')}'!\n"
+                    f"Elements in 'element' field: {phase['element']}\n"
+                    f"Elements from pair_coeff: {pair_coeff_elements}\n"
+                    f"These must match exactly in order (element[0] -> LAMMPS type 1, element[1] -> type 2)."
+                )
+        
         phase_reference_state = phase['reference_phase']
         phase_name = phase['phase_name']
 
@@ -325,34 +485,18 @@ def prepare_inputs_for_phase_diagram(inputyamlfile, calculation_base_name=None):
         other_element_list.remove(reference_element)
         other_element = other_element_list[0]
 
-        #convert to list if scalar
-        if not isinstance(comps['range'], list):
-            comps["range"] = [comps["range"]]
-        if len(comps["range"]) == 2: 
-            comp_arr = np.arange(comps['range'][0], comps['range'][-1], comps['interval'])
-            last_val = comps['range'][-1]
-            if last_val not in comp_arr:
-                comp_arr = np.append(comp_arr, last_val)
-            ncomps = len(comp_arr)
-            is_reference = np.abs(comp_arr-comps['reference']) < 1E-5
-        elif len(comps["range"]) == 1:
-            ncomps = 1
-            comp_arr = [comps["range"][0]]
-            is_reference = [True]
-        else:
-            raise ValueError("Composition range should be scalar of list of two values!")
+        # Create composition array using helper function
+        comp_arr, is_reference = _create_composition_array(
+            comps['range'], 
+            comps['interval'], 
+            comps['reference']
+        )
+        ncomps = len(comp_arr)
 
+        # Create temperature array using helper function
         temps = phase["temperature"]
-        if not isinstance(temps['range'], list):
-            temps["range"] = [temps["range"]]
-        if len(temps["range"]) == 2: 
-            ntemps = int((temps['range'][-1]-temps['range'][0])/temps['interval'])+1
-            temp_arr = np.linspace(temps['range'][0], temps['range'][-1], ntemps, endpoint=True)
-        elif len(temps["range"]) == 1:
-            ntemps = 1
-            temp_arr = [temps["range"][0]]
-        else:
-            raise ValueError("Temperature range should be scalar of list of two values!")
+        temp_arr = _create_temperature_array(temps['range'], temps['interval'])
+        ntemps = len(temp_arr)
 
         all_calculations = []
 
@@ -372,27 +516,30 @@ def prepare_inputs_for_phase_diagram(inputyamlfile, calculation_base_name=None):
                 outfile = fix_data_file(calc['lattice'], len(calc['element']))
                 
                 #add ref phase, needed
-                calc['reference_phase'] = str(phase_reference_state)
+                calc['reference_phase'] = phase_reference_state
                 calc['reference_composition'] = comps['reference']
-                calc['mode'] = str('fe')
+                calc['mode'] = 'fe'
                 calc['folder_prefix'] = f'{phase_name}-{comp:.2f}'
-                calc['lattice'] = str(outfile)
+                calc['lattice'] = outfile
                 
-                #now we need to run this for different temp
-                for temp in temp_arr:
-                    calc_for_temp = copy.deepcopy(calc)
-                    calc_for_temp['temperature'] = int(temp)
-                    all_calculations.append(calc_for_temp)
+                # Add calculations for each temperature
+                _add_temperature_calculations(calc, temp_arr, all_calculations)
             else:
                 #off stoichiometric
                 #copy the dict
                 calc = copy.deepcopy(phase)
 
-                #first thing first, we need to calculate the number of atoms
-                #we follow the convention that composition is always given with the second species
-                n_atoms = np.sum(calc['composition']['number_of_atoms'])
+                #read the structure file to determine input composition automatically
+                input_chemical_composition = read_structure_composition(calc['lattice'], calc['element'])
+                
+                #calculate total number of atoms from structure
+                n_atoms = sum(input_chemical_composition.values())
+                
+                if n_atoms == 0:
+                    raise ValueError(f"No atoms found in structure file {calc['lattice']}")
                 
-                #find number of atoms of second species
+                #find number of atoms of second species based on target composition
+                #we follow the convention that composition is always given with the reference element
                 output_chemical_composition = {}
                 n_species_b = int(np.round(comp*n_atoms, decimals=0))
                 output_chemical_composition[reference_element] = n_species_b
@@ -400,11 +547,8 @@ def prepare_inputs_for_phase_diagram(inputyamlfile, calculation_base_name=None):
                 n_species_a = int(n_atoms-n_species_b)
                 output_chemical_composition[other_element] = n_species_a
 
-                if n_species_a == 0:
-                    raise ValueError("Please add pure phase as a new entry!")
-                #create input comp dict and output comp dict
-                input_chemical_composition = {element:number for element, number in zip(calc['element'],
-                                                                    calc['composition']['number_of_atoms'])}
+                # Note: Pure phases (n_species_a == 0 or n_species_b == 0) are allowed
+                # Composition transformation can handle 100% replacement
 
                 #good, now we need to write such a structure out; likely better to use working directory for that
                 folder_prefix = f'{phase_name}-{comp:.2f}'
@@ -421,7 +565,7 @@ def prepare_inputs_for_phase_diagram(inputyamlfile, calculation_base_name=None):
                     
                     #just submit comp scales
                     #add ref phase, needed
-                    calc['mode'] = str('composition_scaling')
+                    calc['mode'] = 'composition_scaling'
                     calc['folder_prefix'] = folder_prefix
                     calc['composition_scaling'] = {}
                     calc['composition_scaling']['output_chemical_composition'] = output_chemical_composition
@@ -447,22 +591,20 @@ def prepare_inputs_for_phase_diagram(inputyamlfile, calculation_base_name=None):
                         _ = calc.pop(key, None)
 
                     #add ref phase, needed
-                    calc['mode'] = str('fe')
+                    calc['mode'] = 'fe'
                     calc['folder_prefix'] = folder_prefix
-                    calc['lattice'] = str(outfile)
+                    calc['lattice'] = outfile
             
-            #now we need to run this for different temp
-            for temp in temp_arr:
-                calc_for_temp = copy.deepcopy(calc)
-                calc_for_temp['temperature'] = int(temp)
-                all_calculations.append(calc_for_temp)       
+                # Add calculations for each temperature
+                _add_temperature_calculations(calc, temp_arr, all_calculations)
             
         #finish and write up the file
         output_data = {"calculations": all_calculations}
+        base_name = os.path.basename(calculation_base_name)
         for rep in ['.yml', '.yaml']:
-            calculation_base_name = calculation_base_name.replace(rep, '')
+            base_name = base_name.replace(rep, '')
 
-        outfile_phase = phase_name + '_' + calculation_base_name + ".yaml"
+        outfile_phase = phase_name + '_' + base_name + ".yaml"
         with open(outfile_phase, 'w') as fout:
             yaml.safe_dump(output_data, fout)
         print(f'Total {len(all_calculations)} calculations found for phase {phase_name}, written to {outfile_phase}')