calphy 1.2.14__py3-none-any.whl → 1.3.0__py3-none-any.whl

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.0"
 
 def addtest(a,b):
     return a+b

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/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):
@@ -117,19 +118,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 +143,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 +159,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 +200,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 +216,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/input.py

@@ -58,10 +58,27 @@ 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)]
@@ -185,7 +202,6 @@ class Calculation(BaseModel, title='Main input class'):
 
     #add second level options; for example spring constants
     spring_constants: Annotated[List[float], Field(default = None)]
-    _ghost_element_count: int = PrivateAttr(default=0)
 
     #structure items
     _structure: Any = PrivateAttr(default=None)
@@ -312,6 +328,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 +336,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 +350,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 +379,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 +392,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 +401,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 +423,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 +440,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 +535,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.')
@@ -645,23 +656,4 @@ def _convert_legacy_inputfile(file, return_calcs=False):
         warnings.warn(f'Old style input file calphy < v2 found. Converted input in {outfile}. Please check!')
         with open(outfile, 'w') as fout:
             yaml.safe_dump(newdata, fout)
-        return outfile
-
-
-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] 
+        return outfile

calphy/integrators.py

@@ -30,7 +30,7 @@ import warnings
 from calphy.splines import splines, sum_spline1, sum_spline25, sum_spline50, sum_spline75, sum_spline100
 from scipy.integrate import cumtrapz
 from tqdm import tqdm
-import pyscal.core as pc
+import pyscal3.core as pc
 from ase.io import read
 
 #Constants
@@ -46,10 +46,12 @@ eV2J = const.eV
 #             TI PATH INTEGRATION ROUTINES
 #--------------------------------------------------------------------
 
-def integrate_path(fwdfilename, bkdfilename, 
-    nelements=1, concentration=[1,], 
-    usecols=(0, 1, 2), solid=True,
-    alchemy=False, composition_integration=False):
+def integrate_path(calc,
+    fwdfilename, 
+    bkdfilename,  
+    solid=True,
+    alchemy=False, 
+    composition_integration=False):
     """
     Get a filename with columns du and dlambda and integrate
 
@@ -72,23 +74,36 @@ def integrate_path(fwdfilename, bkdfilename,
     q : float
         heat dissipation during switching of system
     """
+    natoms = np.array([calc._element_dict[x]['count'] for x in calc.element])
+    concentration = np.array([calc._element_dict[x]['composition'] for x in calc.element])
+    fdata = np.loadtxt(fwdfilename, unpack=True, comments="#")
+    bdata = np.loadtxt(bkdfilename, unpack=True, comments="#")
+
     if solid:
-        fdui = np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=(0,))
-        bdui = np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=(0,))
+        fdui = fdata[0]
+        bdui = bdata[0]
 
         fdur = np.zeros(len(fdui))
         bdur = np.zeros(len(bdui))
 
-        for i in range(nelements):
-            fdur += concentration[i]*np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=(i+1,))
-            bdur += concentration[i]*np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=(i+1,))
+        for i in range(calc.n_elements):
+            if natoms[i] > 0:
+                fdur += concentration[i]*fdata[i+1]/natoms[i]
+                bdur += concentration[i]*bdata[i+1]/natoms[i]
 
-        flambda = np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=(nelements+1,))
-        blambda = np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=(nelements+1,))
+        flambda = fdata[calc.n_elements+1]
+        blambda = bdata[calc.n_elements+1]
 
     else:
-        fdui, fdur, flambda = np.loadtxt(fwdfilename, unpack=True, comments="#", usecols=usecols)
-        bdui, bdur, blambda = np.loadtxt(bkdfilename, unpack=True, comments="#", usecols=usecols)
+        fdui = fdata[0]
+        bdui = bdata[0]
+
+        fdur = fdata[1]
+        bdur = bdata[1]
+
+        flambda = fdata[2]
+        blambda = bdata[2]
+
 
     fdu = fdui - fdur
     bdu = bdui - bdur
@@ -106,11 +121,12 @@ def integrate_path(fwdfilename, bkdfilename,
     return w, q, flambda
 
 
-def find_w(mainfolder, nelements=1, 
-    concentration=[1,], nsims=5, 
-    full=False, usecols=(0,1,2), 
+def find_w(mainfolder,
+    calc, 
+    full=False, 
     solid=True,
-    alchemy=False, composition_integration=False):
+    alchemy=False, 
+    composition_integration=False):
     """
     Integrate the irreversible work and dissipation for independent simulations
 
@@ -142,15 +158,20 @@ def find_w(mainfolder, nelements=1,
     ws = []
     qs = []
 
-    for i in range(nsims):
+    for i in range(calc.n_iterations):
         fwdfilestring = 'forward_%d.dat' % (i+1)
         fwdfilename = os.path.join(mainfolder,fwdfilestring)
+        
         bkdfilestring = 'backward_%d.dat' % (i+1)
         bkdfilename = os.path.join(mainfolder,bkdfilestring)
-        w, q, flambda = integrate_path(fwdfilename, bkdfilename, 
-            nelements=nelements, concentration=concentration, 
-            usecols=usecols, solid=solid,
-            alchemy=alchemy, composition_integration=composition_integration)
+        
+        w, q, flambda = integrate_path(calc,
+            fwdfilename, 
+            bkdfilename, 
+            solid=solid,
+            alchemy=alchemy, 
+            composition_integration=composition_integration)
+        
         ws.append(w)
         qs.append(q)
     
@@ -356,12 +377,10 @@ def integrate_dcc(folder1, folder2, nsims=1, scale_energy=True,
     """
 
     #get number of atoms
-    sys = pc.System()
-    sys.read_inputfile(os.path.join(folder1, "traj.equilibration_stage1.dat"))
+    sys = pc.System(os.path.join(folder1, "traj.equilibration_stage1.dat"))
     natoms1 = int(sys.natoms)
 
-    sys = pc.System()
-    sys.read_inputfile(os.path.join(folder2, "traj.equilibration_stage1.dat"))
+    sys = pc.System(os.path.join(folder2, "traj.equilibration_stage1.dat"))
     natoms2 = int(sys.natoms)
 
     #get temp and pressure
@@ -446,7 +465,11 @@ def integrate_dcc(folder1, folder2, nsims=1, scale_energy=True,
 #             REF. STATE ROUTINES: SOLID
 #--------------------------------------------------------------------
 
-def get_einstein_crystal_fe(temp, natoms, mass, vol, k, concentration, cm_correction=True):
+def get_einstein_crystal_fe(
+    calc,
+    vol, 
+    k, 
+    cm_correction=True):
     """
     Get the free energy of einstein crystal
 
@@ -477,7 +500,10 @@ def get_einstein_crystal_fe(temp, natoms, mass, vol, k, concentration, cm_correc
 
     """
     #convert mass first for single particle in kg
-    mass = (np.array(mass)/Na)*1E-3
+    mass = np.array([calc._element_dict[x]['mass'] for x in calc.element])
+    mass = (mass/Na)*1E-3
+    natoms = np.sum([calc._element_dict[x]['count'] for x in calc.element])
+    concentration = np.array([calc._element_dict[x]['composition'] for x in calc.element])
 
     #convert k from ev/A2 to J/m2
     k = np.array(k)*(eV2J/1E-20)
@@ -490,12 +516,13 @@ def get_einstein_crystal_fe(temp, natoms, mass, vol, k, concentration, cm_correc
     F_cm = 0
 
     for count, om in enumerate(omega):
-        F_harm += concentration[count]*np.log((hbar*om)/(kb*temp))
-        if cm_correction:
-            F_cm += np.log((natoms*concentration[count]/vol)*(2*np.pi*kbJ*temp/(natoms*concentration[count]*k[count]))**1.5)
+        if concentration[count] > 0:
+            F_harm += concentration[count]*np.log((hbar*om)/(kb*calc._temperature))
+            if cm_correction:
+                F_cm += np.log((natoms*concentration[count]/vol)*(2*np.pi*kbJ*calc._temperature/(natoms*concentration[count]*k[count]))**1.5)
             #F_cm = 0
-    F_harm = 3*kb*temp*F_harm
-    F_cm = (kb*temp/natoms)*F_cm
+    F_harm = 3*kb*calc._temperature*F_harm
+    F_cm = (kb*calc._temperature/natoms)*F_cm
 
     F_harm = F_harm + F_cm