calphy 1.4.5__py3-none-any.whl → 1.4.12__py3-none-any.whl

calphy/phase_diagram.py

@@ -254,6 +254,142 @@ 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]]
+        # Check if this single composition equals the reference
+        is_reference = [np.abs(comp_range[0] - reference) < COMPOSITION_TOLERANCE]
+    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 +445,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 +486,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 +517,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 +548,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 +566,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 +592,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}')

calphy/routines.py

@@ -94,6 +94,9 @@ class MeltingTemp:
         calc["mode"] = "ts"
         calc["temperature"] = [int(self.tmin), int(self.tmax)]
         calc["reference_phase"] = 'solid'
+        # Preserve n_iterations from the original melting_temperature calculation
+        if "n_iterations" in data["calculations"][int(self.calc.kernel)]:
+            calc["n_iterations"] = data["calculations"][int(self.calc.kernel)]["n_iterations"]
         calculations["calculations"].append(calc)
 
         with open(self.calc.inputfile, 'r') as fin:
@@ -103,6 +106,9 @@ class MeltingTemp:
         calc["mode"] = "ts"
         calc["temperature"] = [int(self.tmin), int(self.tmax)]
         calc["reference_phase"] = 'liquid'
+        # Preserve n_iterations from the original melting_temperature calculation
+        if "n_iterations" in data["calculations"][int(self.calc.kernel)]:
+            calc["n_iterations"] = data["calculations"][int(self.calc.kernel)]["n_iterations"]
         calculations["calculations"].append(calc)
 
         outfile = f'{self.calc.create_identifier()}.{self.attempts}.yaml'

calphy/scheduler.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.
@@ -25,25 +25,26 @@ import subprocess as sub
 import os
 import stat
 
+
 class Local:
     """
     Local submission script
     """
+
     def __init__(self, options, cores=1, directory=os.getcwd()):
-        self.queueoptions = {"scheduler": "local",
-                             "jobname": "tis",
-                             "queuename": None,
-                             "memory": None,
-                             "cores": cores,
-                             "hint": None,
-                             "directory": directory,
-                             "options": [],
-                             "commands": [],
-                             "modules": [],
-                             "header": "#!/bin/bash"
-
-                            }
-        for (key, val) in options.items():
+        self.queueoptions = {
+            "scheduler": "local",
+            "jobname": "tis",
+            "queuename": None,
+            "memory": None,
+            "cores": cores,
+            "hint": None,
+            "directory": directory,
+            "options": [],
+            "commands": [],
+            "header": "#!/bin/bash",
+        }
+        for key, val in options.items():
             if key in self.queueoptions.keys():
                 if val is not None:
                     self.queueoptions[key] = val
@@ -60,14 +61,10 @@ class Local:
             fout.write(self.queueoptions["header"])
             fout.write("\n")
 
-            #now write modules
-            for module in self.queueoptions["modules"]:
-                fout.write("module load %s\n"   %module)
-
-            #now finally commands
+            # now finally commands
             for command in self.queueoptions["commands"]:
-                fout.write("%s\n"   %command)
-            fout.write("%s > %s 2> %s\n"   %(self.maincommand, jobout, joberr))
+                fout.write("%s\n" % command)
+            fout.write("%s > %s 2> %s\n" % (self.maincommand, jobout, joberr))
         self.script = outfile
 
     def submit(self):
@@ -77,41 +74,42 @@ class Local:
         st = os.stat(self.script)
         os.chmod(self.script, st.st_mode | stat.S_IEXEC)
         cmd = [self.script]
-        proc = sub.Popen(cmd, stdin=sub.PIPE,stdout=sub.PIPE,stderr=sub.PIPE)
+        proc = sub.Popen(cmd, stdin=sub.PIPE, stdout=sub.PIPE, stderr=sub.PIPE)
         return proc
 
+
 class SLURM:
     """
     Slurm class for writing submission script
     """
+
     def __init__(self, options, cores=1, directory=os.getcwd()):
         """
         Create class
         """
-        self.queueoptions = {"scheduler": "slurm",
-                             "jobname": "tis",
-                             "queuename": None,
-                             "walltime": "23:59:00",
-                             "memory": "3GB",
-                             "cores": cores,
-                             "hint": "nomultithread",
-                             "directory": directory,
-                             "options": [],
-                             "commands": [ "uss=$(whoami)",
-                                           "find /dev/shm/ -user $uss -type f -mmin +30 -delete",
-                                         ],
-                             "modules": [],
-                             "header": "#!/bin/bash"
-
-                            }
-        for (key, val) in options.items():
+        self.queueoptions = {
+            "scheduler": "slurm",
+            "jobname": "tis",
+            "queuename": None,
+            "walltime": "23:59:00",
+            "memory": "3GB",
+            "cores": cores,
+            "hint": "nomultithread",
+            "directory": directory,
+            "options": [],
+            "commands": [
+                "uss=$(whoami)",
+                "find /dev/shm/ -user $uss -type f -mmin +30 -delete",
+            ],
+            "header": "#!/bin/bash",
+        }
+        for key, val in options.items():
             if key in self.queueoptions.keys():
                 if val is not None:
                     if val != "":
                         self.queueoptions[key] = val
         self.maincommand = ""
 
-
     def write_script(self, outfile):
         """
         Write the script file
@@ -123,28 +121,24 @@ class SLURM:
             fout.write(self.queueoptions["header"])
             fout.write("\n")
 
-            #write the main header options
-            fout.write("#SBATCH --job-name=%s\n" %self.queueoptions["jobname"])
-            fout.write("#SBATCH --time=%s\n"     %self.queueoptions["walltime"])
+            # write the main header options
+            fout.write("#SBATCH --job-name=%s\n" % self.queueoptions["jobname"])
+            fout.write("#SBATCH --time=%s\n" % self.queueoptions["walltime"])
             if self.queueoptions["queuename"] is not None:
-                fout.write("#SBATCH --partition=%s\n"%self.queueoptions["queuename"])
-            fout.write("#SBATCH --ntasks=%s\n"   %str(self.queueoptions["cores"]))
-            fout.write("#SBATCH --mem-per-cpu=%s\n"%self.queueoptions["memory"])
-            fout.write("#SBATCH --hint=%s\n"     %self.queueoptions["hint"])
-            fout.write("#SBATCH --chdir=%s\n"    %self.queueoptions["directory"])
+                fout.write("#SBATCH --partition=%s\n" % self.queueoptions["queuename"])
+            fout.write("#SBATCH --ntasks=%s\n" % str(self.queueoptions["cores"]))
+            fout.write("#SBATCH --mem-per-cpu=%s\n" % self.queueoptions["memory"])
+            fout.write("#SBATCH --hint=%s\n" % self.queueoptions["hint"])
+            fout.write("#SBATCH --chdir=%s\n" % self.queueoptions["directory"])
 
-            #now write extra options
+            # now write extra options
             for option in self.queueoptions["options"]:
-                fout.write("#SBATCH %s\n"   %option)
+                fout.write("#SBATCH %s\n" % option)
 
-            #now write modules
-            for module in self.queueoptions["modules"]:
-                fout.write("module load %s\n"   %module)
-
-            #now finally commands
+            # now finally commands
             for command in self.queueoptions["commands"]:
-                fout.write("%s\n"   %command)
-            fout.write("%s > %s 2> %s\n"   %(self.maincommand, jobout, joberr))
+                fout.write("%s\n" % command)
+            fout.write("%s > %s 2> %s\n" % (self.maincommand, jobout, joberr))
 
         self.script = outfile
 
@@ -152,40 +146,41 @@ class SLURM:
         """
         Submit the job
         """
-        cmd = ['sbatch', self.script]
-        proc = sub.Popen(cmd, stdin=sub.PIPE,stdout=sub.PIPE,stderr=sub.PIPE)
+        cmd = ["sbatch", self.script]
+        proc = sub.Popen(cmd, stdin=sub.PIPE, stdout=sub.PIPE, stderr=sub.PIPE)
         print(f'submitting {self.queueoptions["jobname"]}')
         proc.communicate()
         return proc
 
 
-
 class SGE:
     """
     Slurm class for writing submission script
     """
+
     def __init__(self, options, cores=1, directory=os.getcwd()):
         """
         Create class
         """
-        self.queueoptions = {"scheduler": "sge",
-                             "jobname": "tis",
-                             "walltime": "23:59:00",
-                             "queuename": None,
-                             "memory": "3GB",
-                             "system": "smp",
-                             "commands": [],
-                             "modules": [], 
-                             "options": ["-j y",
-                                         "-R y",
-                                         "-P ams.p",
-                                        ],
-                             "cores": cores,
-                             "hint": None,
-                             "directory": directory,
-                             "header": "#!/bin/bash"
-                            }
-        for (key, val) in options.items():
+        self.queueoptions = {
+            "scheduler": "sge",
+            "jobname": "tis",
+            "walltime": "23:59:00",
+            "queuename": None,
+            "memory": "3GB",
+            "system": "smp",
+            "commands": [],
+            "options": [
+                "-j y",
+                "-R y",
+                "-P ams.p",
+            ],
+            "cores": cores,
+            "hint": None,
+            "directory": directory,
+            "header": "#!/bin/bash",
+        }
+        for key, val in options.items():
             if key in self.queueoptions.keys():
                 if val is not None:
                     self.queueoptions[key] = val
@@ -195,40 +190,40 @@ class SGE:
         """
         Write the script file
         """
+        jobout = ".".join([outfile, "out"])
+        joberr = ".".join([outfile, "err"])
+
         with open(outfile, "w") as fout:
             fout.write(self.queueoptions["header"])
             fout.write("\n")
 
-            #write the main header options
-            fout.write("#$ -N %s\n" %self.queueoptions["jobname"])
-            fout.write("#$ -l h_rt=%s\n"     %self.queueoptions["walltime"])
-            fout.write("#$ -l qname=%s\n"%self.queueoptions["queuename"])
-            fout.write("#$ -pe %s %s\n"   %( self.queueoptions["system"], str(self.queueoptions["cores"])))
-            fout.write("#$ -l h_vmem=%s\n"%self.queueoptions["memory"])
-            fout.write("#$ -cwd %s\n"    %self.queueoptions["directory"])
-
-            #now write extra options
+            # write the main header options
+            fout.write("#$ -N %s\n" % self.queueoptions["jobname"])
+            fout.write("#$ -l h_rt=%s\n" % self.queueoptions["walltime"])
+            fout.write("#$ -l qname=%s\n" % self.queueoptions["queuename"])
+            fout.write(
+                "#$ -pe %s %s\n"
+                % (self.queueoptions["system"], str(self.queueoptions["cores"]))
+            )
+            fout.write("#$ -l h_vmem=%s\n" % self.queueoptions["memory"])
+            fout.write("#$ -cwd %s\n" % self.queueoptions["directory"])
+
+            # now write extra options
             for option in self.queueoptions["options"]:
-                fout.write("#$ %s\n"   %option)
-
-            #now write modules
-            for module in self.queueoptions["modules"]:
-                fout.write("module load %s\n"   %module)
+                fout.write("#$ %s\n" % option)
 
-            #now finally commands
+            # now finally commands
             for command in self.queueoptions["commands"]:
-                fout.write("%s\n"   %command)
+                fout.write("%s\n" % command)
 
-            fout.write("%s > %s 2> %s\n"   %(self.maincommand, jobout, joberr))
-        
-        self.script = outfile   
+            fout.write("%s > %s 2> %s\n" % (self.maincommand, jobout, joberr))
 
+        self.script = outfile
 
     def submit(self):
         """
         Submit the job
         """
-        cmd = ['qsub', self.script]
-        proc = sub.Popen(cmd, stdin=sub.PIPE,stdout=sub.PIPE,stderr=sub.PIPE)
+        cmd = ["qsub", self.script]
+        proc = sub.Popen(cmd, stdin=sub.PIPE, stdout=sub.PIPE, stderr=sub.PIPE)
         return proc
-