calphy 1.2.14__tar.gz → 1.3.2__tar.gz

{calphy-1.2.14/calphy.egg-info → calphy-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: calphy
-Version: 1.2.14
+Version: 1.3.2
 Summary: free energy calculation for python
 Home-page: https://github.com/ICAMS/calphy
 Author: Sarath Menon, Yury Lysogorskiy, Ralf Drautz
@@ -21,7 +21,6 @@ Requires-Dist: mendeleev
 Requires-Dist: tqdm
 Requires-Dist: scipy
 Requires-Dist: pydantic
-Requires-Dist: pyscal
 Requires-Dist: pyscal3
 
 # calphy

{calphy-1.2.14 → calphy-1.3.2}/calphy/__init__.py

@@ -4,7 +4,7 @@ from calphy.solid import Solid
 from calphy.alchemy import Alchemy
 from calphy.routines import MeltingTemp
 
-__version__ = "1.2.14"
+__version__ = "1.3.2"
 
 def addtest(a,b):
     return a+b

{calphy-1.2.14 → calphy-1.3.2}/calphy/alchemy.py

@@ -24,9 +24,7 @@ sarath.menon@ruhr-uni-bochum.de/yury.lysogorskiy@icams.rub.de
 import numpy as np
 import yaml
 
-import pyscal.traj_process as ptp
 from calphy.integrators import *
-import calphy.lattice as pl
 import calphy.helpers as ph
 import calphy.phase as cph
 
@@ -79,11 +77,14 @@ class Alchemy(cph.Phase):
         lmp = ph.create_object(self.cores, self.simfolder, self.calc.md.timestep, 
             self.calc.md.cmdargs, self.calc.md.init_commands)
 
+        lmp.command(f'pair_style {self.calc._pair_style_with_options[0]}')
+
         #set up structure
         lmp = ph.create_structure(lmp, self.calc)
 
         #set up potential
-        lmp = ph.set_potential(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
+        lmp = ph.set_mass(lmp, self.calc)
 
         #add some computes
         lmp.command("variable         mvol equal vol")
@@ -145,6 +146,8 @@ class Alchemy(cph.Phase):
         # Adiabatic switching parameters.
         lmp.command("variable        li       equal   1.0")
         lmp.command("variable        lf       equal   0.0")
+
+        lmp.command(f'pair_style {self.calc._pair_style_with_options[0]}')
         
         #read dump file
         #conf = os.path.join(self.simfolder, "conf.equilibration.dump")
@@ -153,7 +156,9 @@ class Alchemy(cph.Phase):
 
         #set up hybrid potential
         #here we only need to set one potential
-        lmp = ph.set_potential(lmp, self.calc, ghost_elements=self.calc._ghost_element_count)
+        lmp.command(f'pair_coeff {self.calc.pair_coeff[0]}')
+        lmp = ph.set_mass(lmp, self.calc)
+
         #lmp = ph.set_double_hybrid_potential(lmp, self.options, self.calc._pressureair_style, self.calc._pressureair_coeff)
 
         #remap the box to get the correct pressure

{calphy-1.2.14 → calphy-1.3.2}/calphy/helpers.py

@@ -22,16 +22,17 @@ sarath.menon@ruhr-uni-bochum.de/yury.lysogorskiy@icams.rub.de
 """
 
 import os
-from pylammpsmpi import LammpsLibrary
+import shutil
+import warnings
 import logging
 import numpy as np
+
+from pylammpsmpi import LammpsLibrary
 from lammps import lammps
-import calphy.lattice as pl
-import shutil
-import pyscal.core as pc
 from ase.io import read, write
-from pyscal.trajectory import Trajectory
-import warnings
+
+import pyscal3.core as pc
+from pyscal3.trajectory import Trajectory
 
 class LammpsScript:
     def __init__(self):
@@ -45,8 +46,8 @@ class LammpsScript:
             for line in self.script:
                 fout.write(f'{line}\n')
 
-def create_object(cores, directory, timestep, cmdargs=None, 
-    init_commands=None, script_mode=False):
+def create_object(cores, directory, timestep, cmdargs="", 
+    init_commands=(), script_mode=False):
     """
     Create LAMMPS object
 
@@ -68,6 +69,8 @@ def create_object(cores, directory, timestep, cmdargs=None,
     if script_mode:
         lmp = LammpsScript()
     else:
+        if cmdargs == "":
+            cmdargs = None
         lmp = LammpsLibrary(
             cores=cores, working_directory=directory, cmdargs=cmdargs
         )
@@ -78,7 +81,7 @@ def create_object(cores, directory, timestep, cmdargs=None,
     ["timestep", str(timestep)],
     ["box", "tilt large"]]
 
-    if init_commands is not None:
+    if len(init_commands) > 0:
         #we need to replace some initial commands
         for rc in init_commands:
             #split the command
@@ -117,19 +120,13 @@ def create_structure(lmp, calc):
     return lmp
 
 
-def set_mass(lmp, options, ghost_elements=0):
-    count = 1
+def set_mass(lmp, options):
     for i in range(options.n_elements):
         lmp.command(f'mass {i+1} {options.mass[i]}')
-        count += 1
-
-    for i in range(ghost_elements):
-        lmp.command(f'mass {count+i} 1.00')
-
     return lmp
 
 
-def set_potential(lmp, options, ghost_elements=0):
+def set_potential(lmp, options):
     """
     Set the interatomic potential
 
@@ -148,50 +145,14 @@ def set_potential(lmp, options, ghost_elements=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, ghost_elements=ghost_elements)
-
-    return lmp
+    lmp = set_mass(lmp, options)
 
-
-def read_dump(lmp, file, species=1):
-    # Read atoms positions, velocities and box parameters.
-    lmp.command("lattice          fcc 4.0")
-    lmp.command("region           box block 0 2 0 2 0 2")
-    lmp.command("create_box       %d box" % species)
-    lmp.command(
-        "read_dump        %s 0 x y z vx vy vz scaled no box yes add keep" % file
-    )
-    lmp.command("change_box       all triclinic")
     return lmp
 
-
 def read_data(lmp, file):
     lmp.command(f"read_data {file}")
     return lmp
 
-
-def convert_to_data_file(inputfile, outputfile, ghost_elements=0):
-    atoms = read(inputfile, format="lammps-dump-text")
-    write(outputfile, atoms, format="lammps-data")
-
-    if ghost_elements > 0:
-        lines = []
-        with open(outputfile, "r") as fin:
-            for line in fin:
-                raw = line.strip().split()
-                if (len(raw) == 3) and (raw[2] == "types"):
-                    raw[0] = "%d" % ghost_elements
-                    raw.append("\n")
-                    rline = " ".join(raw)
-                    lines.append(rline)
-                else:
-                    lines.append(line)
-
-        with open(outputfile, "w") as fout:
-            for line in lines:
-                fout.write(line)
-
-
 def get_structures(file, species, index=None):
     traj = Trajectory(file)
     if index is None:
@@ -200,94 +161,6 @@ def get_structures(file, species, index=None):
         aseobjs = traj[index].to_ase(species=species)
     return aseobjs
 
-
-def set_hybrid_potential(lmp, options, eps, ghost_elements=0):
-    pc = options.pair_coeff[0]
-    pcraw = pc.split()
-    pcnew = " ".join(
-        [
-            *pcraw[:2],
-            *[
-                options._pair_style_names[0],
-            ],
-            *pcraw[2:],
-        ]
-    )
-
-    lmp.command(
-        "pair_style       hybrid/overlay %s ufm 7.5"
-        % options._pair_style_with_options[0]
-    )
-    lmp.command("pair_coeff       %s" % pcnew)
-    lmp.command("pair_coeff       * * ufm %f 1.5" % eps)
-
-    lmp = set_mass(lmp, options, ghost_elements=ghost_elements)
-
-    return lmp
-
-
-def set_double_hybrid_potential(lmp, options, ghost_elements=0):
-
-    pc1 = options.pair_coeff[0]
-    pcraw1 = pc1.split()
-
-    pc2 = options.pair_coeff[1]
-    pcraw2 = pc2.split()
-
-    if options.pair_style[0] == options.pair_style[1]:
-        pcnew1 = " ".join(
-            [
-                *pcraw1[:2],
-                *[
-                    options._pair_style_names[0],
-                ],
-                "1",
-                *pcraw1[2:],
-            ]
-        )
-        pcnew2 = " ".join(
-            [
-                *pcraw2[:2],
-                *[
-                    options._pair_style_names[1],
-                ],
-                "2",
-                *pcraw2[2:],
-            ]
-        )
-    else:
-        pcnew1 = " ".join(
-            [
-                *pcraw1[:2],
-                *[
-                    options._pair_style_names[0],
-                ],
-                *pcraw1[2:],
-            ]
-        )
-        pcnew2 = " ".join(
-            [
-                *pcraw2[:2],
-                *[
-                    options._pair_style_names[1],
-                ],
-                *pcraw2[2:],
-            ]
-        )
-
-    lmp.command(
-        "pair_style       hybrid/overlay %s %s"
-        % (options._pair_style_with_options[0], options._pair_style_with_options[1])
-    )
-
-    lmp.command("pair_coeff       %s" % pcnew1)
-    lmp.command("pair_coeff       %s" % pcnew2)
-
-    lmp = set_mass(lmp, options, ghost_elements=ghost_elements)
-
-    return lmp
-
-
 def remap_box(lmp, x, y, z):
     lmp.command("run 0")
     lmp.command(
@@ -329,15 +202,15 @@ PYSCAL helper routines
 
 
 def find_solid_fraction(file):
-    sys = pc.System()
-    sys.read_inputfile(file)
+    sys = pc.System(file)
     try:
-        sys.find_neighbors(method="cutoff", cutoff=0)
+        sys.find.neighbors(method="cutoff", cutoff=0)
     except RuntimeError:
-        sys.find_neighbors(
+        sys.find.neighbors(
             method="cutoff", cutoff=5.0
         )  # Maybe add value as convergence param?
-    solids = sys.find_solids()
+    sys.find.solids(cluster=False)
+    solids = np.sum(sys.atoms.solid)
     return solids
 
 
@@ -345,49 +218,6 @@ def write_data(lmp, file):
     lmp.command(f"write_data {file}")
     return lmp
 
-
-def reset_timestep(conf, file="current.data", init_commands=None):
-    lmp = create_object(
-        cores=1,
-        directory=os.path.dirname(file),
-        timestep=0,
-        cmdargs=None,
-        init_commands=init_commands,
-    )
-    lmp = read_data(lmp, file)
-    lmp = write_data(lmp, conf)
-    return lmp
-
-    # with open(file, "r") as f:
-    #    with open(conf, "w") as c:
-    #        zero = False
-    #        for l in f:
-    #            if zero:
-    #                c.write("0\n")
-    #                zero = False
-    #                continue
-    #            elif l.startswith("ITEM: TIMESTEP"):
-    #                zero = True
-    #            c.write(l)
-
-    # lmp = create_object(
-    #    cores=1,
-    #    directory = os.path.dirname(file),
-    #    timestep=0,
-    #    cmdargs=None,
-    # )
-    # lmp.command("dump              2 all custom 1 %s id type mass x y z vx vy vz"%(file))+
-    # lmp.command("reset_timestep     0")
-    # lmp.command("run               0")
-    # lmp.command("undump            2")
-
-
-"""
-NOrmal helper routines
----------------------------------------------------------------------
-"""
-
-
 def prepare_log(file, screen=False):
     logger = logging.getLogger(__name__)
     handler = logging.FileHandler(file)

{calphy-1.2.14 → calphy-1.3.2}/calphy/input.py

@@ -40,6 +40,7 @@ from pyscal3.core import structure_dict, element_dict, _make_crystal
 from ase.io import read, write
 import shutil
 
+__version__ = "1.3.2"
 
 def read_report(folder):
     """
@@ -58,13 +59,30 @@ def _check_equal(val):
         return False
     return True
 
-
 def to_list(v: Any) -> List[Any]:
     return np.atleast_1d(v)
 
+def _to_str(val):
+    if np.isscalar(val):
+        return str(val)
+    else:
+        return [str(x) for x in val] 
+
+def _to_int(val):
+    if np.isscalar(val):
+        return int(val)
+    else:
+        return [int(x) for x in val] 
+
+def _to_float(val):
+    if np.isscalar(val):
+        return float(val)
+    else:
+        return [float(x) for x in val] 
+        
 class CompositionScaling(BaseModel, title='Composition scaling input options'):
     _input_chemical_composition: PrivateAttr(default=None)
-    output_chemical_composition: Annotated[dict, Field(default=None, required=False)]
+    output_chemical_composition: Annotated[dict, Field(default={}, required=False)]
     restrictions: Annotated[List[str], BeforeValidator(to_list),
                                             Field(default=[], required=False)]
 
@@ -78,8 +96,8 @@ class MD(BaseModel, title='MD specific input options'):
     n_cycles: Annotated[int, Field(default=100, gt=0)]
     thermostat_damping: Annotated[Union[float, conlist(float, min_length=2, max_length=2)], Field(default=0.1, gt=0)]
     barostat_damping: Annotated[Union[float, conlist(float, min_length=2, max_length=2)], Field(default=0.1, gt=0)]
-    cmdargs: Annotated[str, Field(default=None)]
-    init_commands: Annotated[str, Field(default=None)]
+    cmdargs: Annotated[str, Field(default="")]
+    init_commands: Annotated[List, Field(default=[])]
 
 
 class NoseHoover(BaseModel, title='Specific input options for Nose-Hoover thermostat'):
@@ -94,12 +112,12 @@ class Queue(BaseModel, title='Options for configuring queue'):
     scheduler: Annotated[str, Field(default='local')]
     cores: Annotated[int, Field(default=1, gt=0)]
     jobname: Annotated[str, Field(default='calphy')]
-    walltime: Annotated[str, Field(default=None)]
-    queuename: Annotated[str, Field(default=None)]
+    walltime: Annotated[str, Field(default="23:59:00")]
+    queuename: Annotated[str, Field(default="")]
     memory: Annotated[str, Field(default="3GB")]
-    commands: Annotated[List[str], Field(default=None)]
-    options: Annotated[List[str], Field(default=None)]
-    modules: Annotated[List[str], Field(default=None)]
+    commands: Annotated[List, Field(default=[])]
+    options: Annotated[List, Field(default=[])]
+    modules: Annotated[List, Field(default=[])]
 
 class Tolerance(BaseModel, title='Tolerance settings for convergence'):
     lattice_constant: Annotated[float, Field(default=0.0002, ge=0)]
@@ -109,7 +127,7 @@ class Tolerance(BaseModel, title='Tolerance settings for convergence'):
     pressure: Annotated[float, Field(default=0.5, ge=0)]
 
 class MeltingTemperature(BaseModel, title='Input options for melting temperature mode'):
-    guess: Annotated[float, Field(default=None, gt=0)]
+    guess: Annotated[Union[float, None], Field(default=None, gt=0)]
     step: Annotated[int, Field(default=200, ge=20)]
     attempts: Annotated[int, Field(default=5, ge=1)]
 
@@ -130,7 +148,7 @@ class Calculation(BaseModel, title='Main input class'):
     kernel: Annotated[int, Field(default=0)]
     inputfile: Annotated[str, Field(default='')]
 
-    mode: Annotated[str, Field(default=None)]
+    mode: Annotated[Union[str, None], Field(default=None)]
     lattice: Annotated[str, Field(default="")]
     file_format: Annotated[str, Field(default='lammps-data')]
     
@@ -155,13 +173,13 @@ class Calculation(BaseModel, title='Main input class'):
     
     melting_cycle: Annotated[ bool, Field(default=True)]
     
-    pair_style: Annotated[ List[str], BeforeValidator(to_list),
+    pair_style: Annotated[ Union[List[str], None], BeforeValidator(to_list),
                             Field(default=None)]
-    pair_coeff: Annotated[ List[str], BeforeValidator(to_list),
+    pair_coeff: Annotated[ Union[List[str], None], BeforeValidator(to_list),
                             Field(default=None)]
-    potential_file: Annotated[ str, Field(default=None)]
+    potential_file: Annotated[ Union[str,None], Field(default=None)]
     fix_potential_path: Annotated[bool, Field(default=True)]
-    _pair_style_with_options: float = PrivateAttr(default=None)
+    _pair_style_with_options: List[str] = PrivateAttr(default=None)
     
     
     reference_phase: Annotated[ str, Field(default = "")]
@@ -170,8 +188,8 @@ class Calculation(BaseModel, title='Main input class'):
                             Field(default=[1,1,1])]
     
     script_mode: Annotated[ bool, Field(default = False)]
-    lammps_executable: Annotated[ str, Field(default = None)]
-    mpi_executable: Annotated[ str, Field(default = None)]
+    lammps_executable: Annotated[ Union[str,None], Field(default = None)]
+    mpi_executable: Annotated[ Union[str,None], Field(default = None)]
     
     npt: Annotated[ bool, Field(default = True)]
     n_equilibration_steps: Annotated[ int, Field(default = 25000)]
@@ -180,12 +198,11 @@ class Calculation(BaseModel, title='Main input class'):
     _n_sweep_steps: int = PrivateAttr(default=50000)
     n_print_steps: Annotated[int, Field(default = 0)]
     n_iterations: Annotated[int, Field(default = 1)]
-    equilibration_control: Annotated[str, Field(default = None)]
-    folder_prefix: Annotated[str, Field(default = None)]
+    equilibration_control: Annotated[Union[str,None], Field(default = None)]
+    folder_prefix: Annotated[Union[str,None], Field(default = None)]
 
     #add second level options; for example spring constants
-    spring_constants: Annotated[List[float], Field(default = None)]
-    _ghost_element_count: int = PrivateAttr(default=0)
+    spring_constants: Annotated[Union[List[float],None], Field(default = None)]
 
     #structure items
     _structure: Any = PrivateAttr(default=None)
@@ -312,6 +329,7 @@ class Calculation(BaseModel, title='Main input class'):
             self._element_dict[element]['mass'] = self.mass[count]
             self._element_dict[element]['count'] = 0
             self._element_dict[element]['composition'] = 0.0
+            self._element_dict[element]['atomic_number'] = mendeleev.element(element).atomic_number
 
         #generate temporary filename if needed
         write_structure_file = False
@@ -319,7 +337,7 @@ class Calculation(BaseModel, title='Main input class'):
         if self.lattice == "":
             #fetch from dict
             if len(self.element) > 1:
-                raise ValueError("Cannot create lattice for more than one element")
+                raise ValueError("Cannot create lattice for more than one element, provide a lammps-data file explicitly")
             if self.element[0] in element_dict.keys():
                 self.lattice = element_dict[self.element[0]]['structure']
                 self.lattice_constant = element_dict[self.element[0]]['lattice_constant']
@@ -333,20 +351,23 @@ class Calculation(BaseModel, title='Main input class'):
                 lattice_constant=self.lattice_constant,
                 repetitions=self.repeat,
                 element=self.element)
+            structure = structure.write.ase()
             
             #extract composition
-            typelist = structure.atoms.species
-            types, typecounts = np.unique(typelist, return_counts=True)
+            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 = structure.natoms
+            self._natoms = len(structure)
             self._original_lattice = self.lattice.lower()
             write_structure_file = True
 
         elif self.lattice.lower() in structure_dict.keys():
+            if len(self.element) > 1:
+                raise ValueError("Cannot create lattice for more than one element, provide a lammps-data file explicitly")
+
             #this is a valid structure
             if self.lattice_constant == 0:
                 #we try try to get lattice_constant
@@ -359,10 +380,10 @@ class Calculation(BaseModel, title='Main input class'):
                 lattice_constant=self.lattice_constant,
                 repetitions=self.repeat,
                 element=self.element)
+            structure = structure.write.ase()
             
             #extract composition
-            typelist = structure.atoms.species
-            types, typecounts = np.unique(typelist, return_counts=True)
+            types, typecounts = np.unique(structure.get_chemical_symbols(), return_counts=True)
 
             for c, t in enumerate(types):
                 self._element_dict[t]['count'] = typecounts[c]
@@ -372,7 +393,7 @@ class Calculation(BaseModel, title='Main input class'):
             #concdict_frac = {str(t): typecounts[c]/np.sum(typecounts) for c, t in enumerate(types)}
             #self._composition = concdict_frac
             #self._composition_counts = concdict_counts
-            self._natoms = structure.natoms
+            self._natoms = len(structure)
             self._original_lattice = self.lattice.lower()
             write_structure_file = True
             
@@ -381,20 +402,21 @@ class Calculation(BaseModel, title='Main input class'):
             if not os.path.exists(self.lattice):
                 raise ValueError(f'File {self.lattice} could not be found')
             if self.file_format == 'lammps-data':
-                aseobj = read(self.lattice, format='lammps-data', style='atomic')
-                structure = System(aseobj, format='ase')
+                #create atomic numbers for proper reading
+                Z_of_type = dict([(count+1, self._element_dict[element]['atomic_number']) for count, element in enumerate(self.element)])
+                structure = read(self.lattice, format='lammps-data', style='atomic', Z_of_type=Z_of_type)
+                #structure = System(aseobj, format='ase')
             else:
                 raise TypeError('Only lammps-data files are supported!')                
 
             #extract composition
-            typelist = structure.atoms.types
-            #convert to species
-            typelist = [self.element[x-1] for x in typelist]
-            types, typecounts = np.unique(typelist, return_counts=True)
+            #this is the types read in from the file
+            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 = structure.natoms
+            
+            self._natoms = len(structure)
             self._original_lattice = os.path.basename(self.lattice)
             self.lattice = os.path.abspath(self.lattice)
 
@@ -402,13 +424,10 @@ class Calculation(BaseModel, title='Main input class'):
         if write_structure_file:
             structure_filename = ".".join([self.create_identifier(), str(self.kernel), "data"])
             structure_filename = os.path.join(os.getcwd(), structure_filename)
-            structure.write.file(structure_filename, format='lammps-data')
+            write(structure_filename, structure, format='lammps-data')
             self.lattice = structure_filename
         
         if self.mode == 'composition_scaling':
-            aseobj = read(self.lattice, format='lammps-data', style='atomic')
-            structure = System(aseobj, format='ase')
-
             #we also should check if actual contents are present
             input_chem_comp = {}
             for key, val in self._element_dict.items():
@@ -422,7 +441,7 @@ class Calculation(BaseModel, title='Main input class'):
 
             natoms1 = np.sum([val for key, val in self.composition_scaling._input_chemical_composition.items()])
             natoms2 = np.sum([val for key, val in self.composition_scaling.output_chemical_composition.items()])
-            if not (natoms1==natoms2==structure.natoms):
+            if not (natoms1==natoms2):
                 raise ValueError(f"Input and output number of atoms are not conserved! Input {self.dict_to_string(self.input_chemical_composition)}, output {self.dict_to_string(self.output_chemical_composition)}, total atoms in structure {structure.natoms}")
         return self
 
@@ -517,13 +536,6 @@ def load_job(filename):
     job = np.load(filename, allow_pickle=True).flatten()[0]
     return job
 
-def check_dict(indict, key, retval=None):
-    if key in indict.items():
-        return indict[key]
-    else:
-        return retval
-
-
 def read_inputfile(file):
     if not os.path.exists(file):
         raise FileNotFoundError(f'Input file {file} not found.')
@@ -648,20 +660,18 @@ def _convert_legacy_inputfile(file, return_calcs=False):
         return outfile
 
 
-def _to_str(val):
-    if np.isscalar(val):
-        return str(val)
-    else:
-        return [str(x) for x in val] 
+def generate_metadata():
+    metadata = {}
+    metadata["software"] = {}
+    metadata["software"]["name"] = "calphy"
+    metadata["software"]["doi"] = "10.5281/zenodo.10527452"
+    metadata["software"]["version"] = __version__
+    metadata["software"]["repository"] = "https://github.com/ICAMS/calphy"
+    metadata["software"]["webpage"] = "https://calphy.org/"
 
-def _to_int(val):
-    if np.isscalar(val):
-        return int(val)
-    else:
-        return [int(x) for x in val] 
+    metadata["files"] = {}
+    metadata["files"]["input_file.yml"] = "input file"
+    metadata["files"]["report.yaml"] = "results after thermodynamic integration"
+    metadata["files"]["input_configuration.data"] = "input atomic configuration"
 
-def _to_float(val):
-    if np.isscalar(val):
-        return float(val)
-    else:
-        return [float(x) for x in val] 
+    return metadata