From ccabc915fedc3e6479d7696e394a7b8b56dd5cbd Mon Sep 17 00:00:00 2001
From: Mark Driver <mdd31@alumni.cam.ac.uk>
Date: Wed, 19 Feb 2020 14:32:30 +0000
Subject: [PATCH] formatting with black.
---
phasecalculator/__main__.py | 4 +-
phasecalculator/analysis/fgipanalysis.py | 95 +++++--
.../analysis/similarityanalysis.py | 40 +--
phasecalculator/analysis/vleanalysis.py | 1 -
phasecalculator/classes/molecule.py | 47 +++-
phasecalculator/classes/outputinformation.py | 74 +++--
phasecalculator/classes/phase.py | 41 ++-
phasecalculator/classes/phases.py | 36 ++-
phasecalculator/classes/runtimeinformation.py | 59 ++--
phasecalculator/classes/system.py | 62 ++++-
phasecalculator/classes/temperature.py | 43 ++-
phasecalculator/classes/xmlnamespacing.py | 4 +-
phasecalculator/io/phasecsvconverter.py | 12 +-
phasecalculator/io/phasetransferxmlcreator.py | 25 +-
phasecalculator/io/polynomialio.py | 51 ++--
phasecalculator/io/solventextractor.py | 11 +-
.../io/systemcollectionprocessor.py | 6 +-
phasecalculator/phasecalculatorcli.py | 131 ++++++---
phasecalculator/runners/fgipanalysisrunner.py | 53 +++-
.../runners/phasecalculatorrunner.py | 64 +++--
.../runners/phasetransferrunner.py | 107 +++++--
.../runners/phasexmlcreatorrunner.py | 65 +++--
.../runners/similarityanalysisrunner.py | 49 +++-
phasecalculator/runners/vleanalysisrunner.py | 5 +-
.../test/analysistest/fgipanalysistest.py | 62 ++++-
.../analysistest/similarityanalysistest.py | 152 +++++++---
.../test/classestest/moleculetest.py | 17 +-
.../test/classestest/outputinformationtest.py | 32 ++-
.../test/classestest/phasestest.py | 26 +-
phasecalculator/test/classestest/phasetest.py | 24 +-
.../classestest/runtimeinformationtest.py | 40 ++-
.../test/classestest/systemtest.py | 46 +++-
.../test/classestest/temperaturetest.py | 15 +-
.../test/iotest/phasecsvconvertertest.py | 26 +-
.../iotest/phasetransferxmlcreatortest.py | 79 ++++--
.../test/iotest/polynomialiotest.py | 132 +++++++--
.../test/iotest/solventextractortest.py | 21 +-
.../iotest/systemcollectionprocessortest.py | 13 +-
phasecalculator/test/phasecalculatortests.py | 54 ++--
.../runnerstest/fgipanalysisrunnertest.py | 87 ++++--
.../runnerstest/phasecalculatorrunnertest.py | 125 +++++++--
.../runnerstest/phasetransferrunnertest.py | 260 ++++++++++++++----
.../runnerstest/phasexmlcreatorrunnertest.py | 86 ++++--
.../similarityanalysisrunnertest.py | 84 ++++--
.../test/runnerstest/vleanalysisrunnertest.py | 48 +++-
45 files changed, 1899 insertions(+), 615 deletions(-)
diff --git a/phasecalculator/__main__.py b/phasecalculator/__main__.py
index 0558d70..1b341ce 100644
--- a/phasecalculator/__main__.py
+++ b/phasecalculator/__main__.py
@@ -22,5 +22,5 @@ Main script to be called for module level operation.
from phasecalculator.phasecalculatorcli import main
-if __name__ == '__main__':
- main()
\ No newline at end of file
+if __name__ == "__main__":
+ main()
diff --git a/phasecalculator/analysis/fgipanalysis.py b/phasecalculator/analysis/fgipanalysis.py
index b9efae9..40cbdc6 100755
--- a/phasecalculator/analysis/fgipanalysis.py
+++ b/phasecalculator/analysis/fgipanalysis.py
@@ -30,13 +30,14 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-EPSILON_I_LIST = np.array([(float(x)/10.0) - 10.0 for x in range(101)])
+EPSILON_I_LIST = np.array([(float(x) / 10.0) - 10.0 for x in range(101)])
-EPSILON_J_LIST = np.array([(float(x)/10.0) for x in range(51)])
+EPSILON_J_LIST = np.array([(float(x) / 10.0) for x in range(51)])
-def create_solv_map_and_fgips_from_files(solvent_filename, polynomial_filename_list,
- directory, **kwargs):
+def create_solv_map_and_fgips_from_files(
+ solvent_filename, polynomial_filename_list, directory, **kwargs
+):
"""Creates solvent map and FGIPs and output matrix of numerical values.
The default ranges are used for epsilon: 0< epsilon_j < 5 and
@@ -62,12 +63,19 @@ def create_solv_map_and_fgips_from_files(solvent_filename, polynomial_filename_l
"""
pathlib.Path(directory).mkdir(exist_ok=True)
- results, filenames = create_solvation_plots_from_poly_files(EPSILON_I_LIST,EPSILON_J_LIST,
- solvent_filename, polynomial_filename_list, 8,
- directory=directory, **kwargs)
+ results, filenames = create_solvation_plots_from_poly_files(
+ EPSILON_I_LIST,
+ EPSILON_J_LIST,
+ solvent_filename,
+ polynomial_filename_list,
+ 8,
+ directory=directory,
+ **kwargs
+ )
latex_blocks = create_fgips_from_file_list(filenames, directory=directory)
return results, latex_blocks
+
def create_fgips_from_file_list(filename_list, **kwargs):
"""Create FGIPs from given solvent map files.
@@ -95,9 +103,14 @@ def create_fgips_from_file_list(filename_list, **kwargs):
return latex_blocks
-def create_solvation_plots_from_poly_files(epsilon_i_list, epsilon_j_list,
- solvent_filename, polynomial_filename_list,
- polynomial_order, **kwargs):
+def create_solvation_plots_from_poly_files(
+ epsilon_i_list,
+ epsilon_j_list,
+ solvent_filename,
+ polynomial_filename_list,
+ polynomial_order,
+ **kwargs
+):
"""Create solvation maps and writes energy matrices to file for given solvents.
Parameters
@@ -125,7 +138,7 @@ def create_solvation_plots_from_poly_files(epsilon_i_list, epsilon_j_list,
"""
plot_outputs = []
filename_list = []
- directory = kwargs.get("directory","")
+ directory = kwargs.get("directory", "")
for polynomial_filename in polynomial_filename_list:
LOGGER.info("polynomial_filename:")
LOGGER.info(polynomial_filename)
@@ -133,18 +146,30 @@ def create_solvation_plots_from_poly_files(epsilon_i_list, epsilon_j_list,
LOGGER.info("solvent_id:")
LOGGER.info(solvent_id)
try:
- plot_outputs.append(create_solvation_plot(epsilon_i_list, epsilon_j_list,
- solvent_filename, solvent_id,
- polynomial_filename,
- polynomial_order, **kwargs))
- filename_list.append(solvmapgen.create_output_filename_stem(solvent_id,
- directory) +"." + kwargs.get("fileformat", "svg"))
+ plot_outputs.append(
+ create_solvation_plot(
+ epsilon_i_list,
+ epsilon_j_list,
+ solvent_filename,
+ solvent_id,
+ polynomial_filename,
+ polynomial_order,
+ **kwargs
+ )
+ )
+ filename_list.append(
+ solvmapgen.create_output_filename_stem(solvent_id, directory)
+ + "."
+ + kwargs.get("fileformat", "svg")
+ )
except Exception as err:
plot_outputs.append((solvent_id, err.args))
return plot_outputs, filename_list
-def get_solvent_id_from_poly_filename(poly_filename,
- suffix="binding_poly_fit_split.csv"):
+
+def get_solvent_id_from_poly_filename(
+ poly_filename, suffix="binding_poly_fit_split.csv"
+):
"""Extracts solvent ID from polynomial filename.
Parameters
@@ -160,11 +185,18 @@ def get_solvent_id_from_poly_filename(poly_filename,
solvent ID.
"""
- return poly_filename.split('/')[-1].replace(suffix, "").replace("_", ",")
-
-def create_solvation_plot(epsilon_i_list, epsilon_j_list,
- solvent_filename, solvent_id,
- polynomial_filename, polynomial_order, **kwargs):
+ return poly_filename.split("/")[-1].replace(suffix, "").replace("_", ",")
+
+
+def create_solvation_plot(
+ epsilon_i_list,
+ epsilon_j_list,
+ solvent_filename,
+ solvent_id,
+ polynomial_filename,
+ polynomial_order,
+ **kwargs
+):
"""Create solvation map plot and write matrix of values to file.
Parameters
@@ -190,9 +222,12 @@ def create_solvation_plot(epsilon_i_list, epsilon_j_list,
results of solvation map plotting and matrix writing.
"""
- return solvmapgen.create_solvation_plot(epsilon_i_list,
- epsilon_j_list,
- solvent_filename,
- solvent_id,
- polynomial_filename,
- polynomial_order, **kwargs)
\ No newline at end of file
+ return solvmapgen.create_solvation_plot(
+ epsilon_i_list,
+ epsilon_j_list,
+ solvent_filename,
+ solvent_id,
+ polynomial_filename,
+ polynomial_order,
+ **kwargs
+ )
diff --git a/phasecalculator/analysis/similarityanalysis.py b/phasecalculator/analysis/similarityanalysis.py
index 6aa0cb3..068d836 100755
--- a/phasecalculator/analysis/similarityanalysis.py
+++ b/phasecalculator/analysis/similarityanalysis.py
@@ -31,6 +31,7 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
def read_polynomial_files(poly_filename_list, **kwargs):
"""Parse each file, and then returns the dictionary of information, by solvent ID.
@@ -53,7 +54,11 @@ def read_polynomial_files(poly_filename_list, **kwargs):
"""
return polyio.read_poly_data_to_dict(poly_filename_list, **kwargs)
-PURE_SOLVENT_INFO = read_polynomial_files(pureinf.get_polynomial_filenames(), suffix="free_poly_fit_split.csv")
+
+PURE_SOLVENT_INFO = read_polynomial_files(
+ pureinf.get_polynomial_filenames(), suffix="free_poly_fit_split.csv"
+)
+
def compare_all_solvents(poly_filename_list, output_dir, output_filename):
"""
@@ -72,13 +77,14 @@ def compare_all_solvents(poly_filename_list, output_dir, output_filename):
None.
"""
- poly_data_by_id = read_polynomial_files(poly_filename_list,
- suffix="free_poly_split_fit.csv",
- temperature_dir=True)
+ poly_data_by_id = read_polynomial_files(
+ poly_filename_list, suffix="free_poly_split_fit.csv", temperature_dir=True
+ )
sim_dframe = calculate_similarity_matrix({**poly_data_by_id, **PURE_SOLVENT_INFO})
output_filename = (pathlib.Path(output_dir) / output_filename).as_posix()
write_frame_to_file(sim_dframe, output_filename)
+
def compare_with_pure_solvents(poly_filename_list, output_dir):
"""
@@ -94,16 +100,16 @@ def compare_with_pure_solvents(poly_filename_list, output_dir):
None.
"""
- poly_data_by_id = read_polynomial_files(poly_filename_list,
- suffix="free_poly_split_fit.csv",
- temperature_dir=True)
+ poly_data_by_id = read_polynomial_files(
+ poly_filename_list, suffix="free_poly_split_fit.csv", temperature_dir=True
+ )
sim_dframe = calculate_similarity_matrix({**poly_data_by_id, **PURE_SOLVENT_INFO})
for solv_id in poly_data_by_id.keys():
output_filename = create_slice_output_filename(solv_id, output_dir)
similarity_slice = extract_comparison_to_pure_solvents(sim_dframe, solv_id)
write_frame_to_file(similarity_slice, output_filename)
-
+
def compare_solvent_list(poly_filename_list, output_dir, output_filename):
"""
@@ -121,13 +127,14 @@ def compare_solvent_list(poly_filename_list, output_dir, output_filename):
None.
"""
- poly_data_by_id = read_polynomial_files(poly_filename_list,
- suffix="free_poly_split_fit.csv",
- temperature_dir=True)
+ poly_data_by_id = read_polynomial_files(
+ poly_filename_list, suffix="free_poly_split_fit.csv", temperature_dir=True
+ )
sim_dframe = calculate_similarity_matrix(poly_data_by_id)
output_filename = (pathlib.Path(output_dir) / output_filename).as_posix()
write_frame_to_file(sim_dframe, output_filename)
+
def create_slice_output_filename(solv_id, output_dir):
"""
@@ -144,10 +151,10 @@ def create_slice_output_filename(solv_id, output_dir):
DESCRIPTION.
"""
- filename = solv_id.replace(",","_") + ".csv"
+ filename = solv_id.replace(",", "_") + ".csv"
return (pathlib.Path(output_dir) / filename).as_posix()
-
+
def write_frame_to_file(dframe, output_filename):
"""
@@ -165,6 +172,7 @@ def write_frame_to_file(dframe, output_filename):
"""
dframe.to_csv(output_filename, sep="\t", header=True)
+
def extract_comparison_to_pure_solvents(similarity_dframe, solv_id):
"""
@@ -182,7 +190,8 @@ def extract_comparison_to_pure_solvents(similarity_dframe, solv_id):
"""
return similarity_dframe.loc[solv_id, PURE_SOLVENT_INFO.keys()].sort_values()
-
+
+
def calculate_similarity_matrix(poly_data_by_id):
"""
@@ -203,5 +212,4 @@ def calculate_similarity_matrix(poly_data_by_id):
)
mean_matrix = multicluster.condense_matrix_to_mean(stacked_matrix)
labels = sorted(poly_data_by_id.keys())
- return pandas.DataFrame(mean_matrix,index=labels, columns=labels)
-
+ return pandas.DataFrame(mean_matrix, index=labels, columns=labels)
diff --git a/phasecalculator/analysis/vleanalysis.py b/phasecalculator/analysis/vleanalysis.py
index 7149168..ad90fa4 100755
--- a/phasecalculator/analysis/vleanalysis.py
+++ b/phasecalculator/analysis/vleanalysis.py
@@ -25,4 +25,3 @@ import logging
logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-
diff --git a/phasecalculator/classes/molecule.py b/phasecalculator/classes/molecule.py
index 6eca23b..544271a 100755
--- a/phasecalculator/classes/molecule.py
+++ b/phasecalculator/classes/molecule.py
@@ -22,17 +22,21 @@ Script for molecule class.
import logging
from lxml import etree
-from phasecalculator.classes.xmlnamespacing import PHASE_CALCULATOR, PHASE_CALC_NAMESPACE_DICT
+from phasecalculator.classes.xmlnamespacing import (
+ PHASE_CALCULATOR,
+ PHASE_CALC_NAMESPACE_DICT,
+)
logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class Molecule(object):
"""Molecule class."""
-
+
TOLERANCE = 0.0001
-
+
def __init__(self, name, inchikey, ssip_file_loc, molefraction):
"""Initialise object.
@@ -56,6 +60,7 @@ class Molecule(object):
self.inchikey = inchikey
self.ssip_file_loc = ssip_file_loc
self.molefraction = molefraction
+
def __eq__(self, other):
"""Overload equality comparison operator.
@@ -73,9 +78,15 @@ class Molecule(object):
if other is None:
return False
if isinstance(other, type(self)):
- return (abs(self.molefraction - other.molefraction) < self.TOLERANCE and self.name == other.name and self.inchikey == other.inchikey and self.ssip_file_loc == other.ssip_file_loc)
+ return (
+ abs(self.molefraction - other.molefraction) < self.TOLERANCE
+ and self.name == other.name
+ and self.inchikey == other.inchikey
+ and self.ssip_file_loc == other.ssip_file_loc
+ )
else:
return False
+
@classmethod
def parse_xml(cls, molecule_xml):
"""Parse XML representation to new instance.
@@ -91,11 +102,22 @@ class Molecule(object):
New instance.
"""
- name = molecule_xml.xpath("@phasecalc:name", namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
- inchikey = molecule_xml.xpath("@phasecalc:inChIKey", namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
- ssip_file_loc = molecule_xml.xpath("@phasecalc:ssipFileLocation", namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
- molefraction = float(molecule_xml.xpath("@phasecalc:molefraction", namespaces=PHASE_CALC_NAMESPACE_DICT)[0])
+ name = molecule_xml.xpath(
+ "@phasecalc:name", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
+ inchikey = molecule_xml.xpath(
+ "@phasecalc:inChIKey", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
+ ssip_file_loc = molecule_xml.xpath(
+ "@phasecalc:ssipFileLocation", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
+ molefraction = float(
+ molecule_xml.xpath(
+ "@phasecalc:molefraction", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
+ )
return Molecule(name, inchikey, ssip_file_loc, molefraction)
+
def write_to_xml(self):
"""Write information to Etree representation of XML.
@@ -105,10 +127,13 @@ class Molecule(object):
XML representation of Molecule.
"""
- mol_element = etree.Element(PHASE_CALCULATOR + "Molecule", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ mol_element = etree.Element(
+ PHASE_CALCULATOR + "Molecule", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
mol_element.set(PHASE_CALCULATOR + "name", self.name)
mol_element.set(PHASE_CALCULATOR + "inChIKey", self.inchikey)
mol_element.set(PHASE_CALCULATOR + "ssipFileLocation", self.ssip_file_loc)
- mol_element.set(PHASE_CALCULATOR + "molefraction", "{:.4f}".format(self.molefraction))
+ mol_element.set(
+ PHASE_CALCULATOR + "molefraction", "{:.4f}".format(self.molefraction)
+ )
return mol_element
-
\ No newline at end of file
diff --git a/phasecalculator/classes/outputinformation.py b/phasecalculator/classes/outputinformation.py
index c78f7a8..91583df 100755
--- a/phasecalculator/classes/outputinformation.py
+++ b/phasecalculator/classes/outputinformation.py
@@ -22,16 +22,23 @@ Class for output information.
import logging
from lxml import etree
-from phasecalculator.classes.xmlnamespacing import PHASE_CALCULATOR, PHASE_CALC_NAMESPACE_DICT
+from phasecalculator.classes.xmlnamespacing import (
+ PHASE_CALCULATOR,
+ PHASE_CALC_NAMESPACE_DICT,
+)
logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class OutputInformation(object):
"""Class representation of output information."""
- def __init__(self, fgip_output, similarity_output, similarity_output_type, vle_output):
+
+ def __init__(
+ self, fgip_output, similarity_output, similarity_output_type, vle_output
+ ):
"""Initialise OutputInformation.
Parameters
@@ -55,6 +62,7 @@ class OutputInformation(object):
self.similarity_output = similarity_output
self.similarity_output_type = similarity_output_type
self.vle_output = vle_output
+
def __eq__(self, other):
"""Overload equality comparison operator.
@@ -72,9 +80,14 @@ class OutputInformation(object):
if other is None:
return False
if isinstance(other, type(self)):
- return (self.fgip_output == other.fgip_output and self.similarity_output == other.similarity_output and self.vle_output == other.vle_output)
+ return (
+ self.fgip_output == other.fgip_output
+ and self.similarity_output == other.similarity_output
+ and self.vle_output == other.vle_output
+ )
else:
return False
+
@classmethod
def parse_xml(cls, output_xml):
"""Parse XML representation.
@@ -91,9 +104,14 @@ class OutputInformation(object):
"""
fgip_output = OutputInformation.parse_fgip_output(output_xml)
- similarity_output, similarity_output_type = OutputInformation.parse_similarity_output(output_xml)
+ similarity_output, similarity_output_type = OutputInformation.parse_similarity_output(
+ output_xml
+ )
vle_output = OutputInformation.parse_vle_output(output_xml)
- return OutputInformation(fgip_output, similarity_output, similarity_output_type, vle_output)
+ return OutputInformation(
+ fgip_output, similarity_output, similarity_output_type, vle_output
+ )
+
@classmethod
def parse_fgip_output(cls, output_xml):
"""Parse FGIP output information from from output information element.
@@ -110,8 +128,11 @@ class OutputInformation(object):
"""
xpath_expression = "phasecalc:FGIPOutput/text()"
- fgip_output = output_xml.xpath(xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ fgip_output = output_xml.xpath(
+ xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
return True if fgip_output == "true" else False
+
@classmethod
def parse_similarity_output(cls, output_xml):
"""Parse similarity output information from output information element.
@@ -130,14 +151,19 @@ class OutputInformation(object):
"""
xpath_expression = "phasecalc:SimilarityOutput/text()"
- similarity_output = output_xml.xpath(xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ similarity_output = output_xml.xpath(
+ xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
if similarity_output:
type_xpath = "phasecalc:SimilarityOutput/@phasecalc:outputType"
- similarity_output_type = output_xml.xpath(type_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ similarity_output_type = output_xml.xpath(
+ type_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
else:
similarity_output_type = None
- similarity_output = True if similarity_output == "true" else False
+ similarity_output = True if similarity_output == "true" else False
return similarity_output, similarity_output_type
+
@classmethod
def parse_vle_output(cls, output_xml):
"""Parse VLE from output information element.
@@ -154,8 +180,11 @@ class OutputInformation(object):
"""
xpath_expression = "phasecalc:FGIPOutput/text()"
- vle_output = output_xml.xpath(xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ vle_output = output_xml.xpath(
+ xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
return True if vle_output == "true" else False
+
def write_to_xml(self):
"""Write information to Etree representation of XML.
@@ -165,11 +194,14 @@ class OutputInformation(object):
XML representation of OutputInformation.
"""
- out_element = etree.Element(PHASE_CALCULATOR + "OutputInformation", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ out_element = etree.Element(
+ PHASE_CALCULATOR + "OutputInformation", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
out_element.append(self.write_fgip_output())
out_element.append(self.write_similarity_output())
out_element.append(self.write_vle_output())
return out_element
+
def write_fgip_output(self):
"""Write FGIP output XML Element.
@@ -179,9 +211,12 @@ class OutputInformation(object):
FGIP element representation.
"""
- fgip_element = etree.Element(PHASE_CALCULATOR + "FGIPOutput", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ fgip_element = etree.Element(
+ PHASE_CALCULATOR + "FGIPOutput", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
fgip_element.text = str(self.fgip_output).lower()
return fgip_element
+
def write_similarity_output(self):
"""Write Similarity output XML Element.
@@ -191,11 +226,16 @@ class OutputInformation(object):
Similarity element representation.
"""
- sim_element = etree.Element(PHASE_CALCULATOR + "SimilarityOutput", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ sim_element = etree.Element(
+ PHASE_CALCULATOR + "SimilarityOutput", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
sim_element.text = str(self.similarity_output).lower()
if self.similarity_output_type is not None:
- sim_element.set(PHASE_CALCULATOR + "outputType", self.similarity_output_type)
+ sim_element.set(
+ PHASE_CALCULATOR + "outputType", self.similarity_output_type
+ )
return sim_element
+
def write_vle_output(self):
"""Write VLE output XML Element.
@@ -205,6 +245,8 @@ class OutputInformation(object):
VLE element representation.
"""
- vle_element = etree.Element(PHASE_CALCULATOR + "VLEOutput", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ vle_element = etree.Element(
+ PHASE_CALCULATOR + "VLEOutput", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
vle_element.text = str(self.vle_output).lower()
- return vle_element
\ No newline at end of file
+ return vle_element
diff --git a/phasecalculator/classes/phase.py b/phasecalculator/classes/phase.py
index 8181271..4c6afc5 100755
--- a/phasecalculator/classes/phase.py
+++ b/phasecalculator/classes/phase.py
@@ -23,7 +23,10 @@ Created on Tue Jan 7 16:34:17 2020
import logging
from lxml import etree
import functools
-from phasecalculator.classes.xmlnamespacing import PHASE_CALCULATOR, PHASE_CALC_NAMESPACE_DICT
+from phasecalculator.classes.xmlnamespacing import (
+ PHASE_CALCULATOR,
+ PHASE_CALC_NAMESPACE_DICT,
+)
from phasecalculator.classes.molecule import Molecule
from phasecalculator.classes.temperature import Temperature
@@ -31,8 +34,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class Phase(object):
"""Phase object."""
+
def __init__(self, molecule_list, temperature):
"""Initialise Phase.
@@ -50,6 +55,7 @@ class Phase(object):
"""
self.molecule_list = molecule_list
self.temperature = temperature
+
def __eq__(self, other):
"""Overload equality comparison operator.
@@ -69,12 +75,18 @@ class Phase(object):
if isinstance(other, type(self)):
if len(self.molecule_list) != len(other.molecule_list):
return False
- mol_comps = all([self.molecule_list[i] == other.molecule_list[i] for i in range(len(self.molecule_list))])
- return (self.temperature == other.temperature and mol_comps)
+ mol_comps = all(
+ [
+ self.molecule_list[i] == other.molecule_list[i]
+ for i in range(len(self.molecule_list))
+ ]
+ )
+ return self.temperature == other.temperature and mol_comps
else:
return False
+
@classmethod
- def parse_xml(cls,phase_xml):
+ def parse_xml(cls, phase_xml):
"""Parse XML representation to new instance.
Parameters
@@ -88,11 +100,14 @@ class Phase(object):
New instance.
"""
-
+
molecule_list = cls.parse_molecules(phase_xml)
- temp_xml = phase_xml.xpath("phasecalc:Temperature", namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ temp_xml = phase_xml.xpath(
+ "phasecalc:Temperature", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
temperature = cls.parse_temperature(temp_xml)
return Phase(molecule_list, temperature)
+
@classmethod
def parse_molecules(cls, phase_xml):
"""Parse list of molecule XML.
@@ -109,8 +124,11 @@ class Phase(object):
"""
molecule_xpath = "phasecalc:Molecule"
- molecule_xml_list = phase_xml.xpath(molecule_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT)
+ molecule_xml_list = phase_xml.xpath(
+ molecule_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )
return [Molecule.parse_xml(molecule_xml) for molecule_xml in molecule_xml_list]
+
@classmethod
def parse_temperature(cls, temperature_xml):
"""Parse temperature XML.
@@ -127,6 +145,7 @@ class Phase(object):
"""
return Temperature.parse_xml(temperature_xml)
+
def write_to_xml(self):
"""Write information to Etree representation of XML.
@@ -136,11 +155,14 @@ class Phase(object):
XML representation of Phase.
"""
- phase_element = etree.Element(PHASE_CALCULATOR + "Phase", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ phase_element = etree.Element(
+ PHASE_CALCULATOR + "Phase", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
for molecule in self.molecule_list:
phase_element.append(molecule.write_to_xml())
phase_element.append(self.temperature.write_to_xml())
return phase_element
+
def get_molefractions_by_molecule(self):
"""Get the molefractions of all molecules in the phase, labelled by name.
@@ -154,6 +176,7 @@ class Phase(object):
for molecule in self.molecule_list:
mole_fraction_by_name[molecule.name] = molecule.molefraction
return mole_fraction_by_name
+
def get_ssip_file_locations(self):
"""Get SSIP file locations ofr all molecules in the phase.
@@ -163,4 +186,4 @@ class Phase(object):
List of SSIP file locations.
"""
- return [molecule.ssip_file_loc for molecule in self.molecule_list]
\ No newline at end of file
+ return [molecule.ssip_file_loc for molecule in self.molecule_list]
diff --git a/phasecalculator/classes/phases.py b/phasecalculator/classes/phases.py
index 6b5a86f..67527cd 100755
--- a/phasecalculator/classes/phases.py
+++ b/phasecalculator/classes/phases.py
@@ -23,12 +23,16 @@ Script for Phases class.
import logging
from lxml import etree
from phasecalculator.classes.phase import Phase
-from phasecalculator.classes.xmlnamespacing import PHASE_CALCULATOR, PHASE_CALC_NAMESPACE_DICT
+from phasecalculator.classes.xmlnamespacing import (
+ PHASE_CALCULATOR,
+ PHASE_CALC_NAMESPACE_DICT,
+)
logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class Phases(object):
"""Phases class."""
@@ -46,7 +50,7 @@ class Phases(object):
"""
self.phase_list = phase_list
-
+
def __eq__(self, other):
"""Overload equality comparison operator.
@@ -66,11 +70,16 @@ class Phases(object):
if isinstance(other, type(self)):
if len(self.phase_list) != len(other.phase_list):
return False
- phase_comps = all([self.phase_list[i] == other.phase_list[i] for i in range(len(self.phase_list))])
+ phase_comps = all(
+ [
+ self.phase_list[i] == other.phase_list[i]
+ for i in range(len(self.phase_list))
+ ]
+ )
return phase_comps
else:
return False
-
+
@classmethod
def parse_xml(cls, phases_xml):
"""Parse XML representation to new instance.
@@ -87,9 +96,12 @@ class Phases(object):
"""
phase_xpath = "phasecalc:Phase"
- phase_xml_list = phases_xml.xpath(phase_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT)
+ phase_xml_list = phases_xml.xpath(
+ phase_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )
phase_list = [Phase.parse_xml(phase_xml) for phase_xml in phase_xml_list]
return Phases(phase_list)
+
def write_to_xml(self):
"""Write phases to XML.
@@ -99,10 +111,13 @@ class Phases(object):
XML representation of Phases.
"""
- phases_element = etree.Element(PHASE_CALCULATOR + "Phases", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ phases_element = etree.Element(
+ PHASE_CALCULATOR + "Phases", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
for phase in self.phase_list:
phases_element.append(phase.write_to_xml())
return phases_element
+
def get_phase_compositions_by_temperature(self):
"""Get phases split up by temperature. This is for solvent XML generation.
@@ -119,6 +134,7 @@ class Phases(object):
else:
phase_dict[phase.temperature] = [phase]
return phase_dict
+
def get_phase_molefractions_by_temperature(self):
"""Get molefraction dictionaries for all phases in collection grouped by temperature.
@@ -131,10 +147,13 @@ class Phases(object):
phase_dict = {}
for phase in self.phase_list:
if phase.temperature in phase_dict.keys():
- phase_dict[phase.temperature].append(phase.get_molefractions_by_molecule())
+ phase_dict[phase.temperature].append(
+ phase.get_molefractions_by_molecule()
+ )
else:
phase_dict[phase.temperature] = [phase.get_molefractions_by_molecule()]
return phase_dict
+
def get_molefractions_by_molecule_list(self):
"""List of molefraction dictionaries for all phases in collection.
@@ -148,6 +167,7 @@ class Phases(object):
for phase in self.phase_list:
mole_fraction_dict_list.append(phase.get_molefractions_by_molecule())
return mole_fraction_dict_list
+
def get_ssip_file_locations(self):
"""Get the SSIP file locations for all molecules in any phase.
@@ -161,5 +181,3 @@ class Phases(object):
for phase in self.phase_list:
ssip_file_locations.extend(phase.get_ssip_file_locations())
return set(ssip_file_locations)
-
-
\ No newline at end of file
diff --git a/phasecalculator/classes/runtimeinformation.py b/phasecalculator/classes/runtimeinformation.py
index f323c75..d196db6 100755
--- a/phasecalculator/classes/runtimeinformation.py
+++ b/phasecalculator/classes/runtimeinformation.py
@@ -22,15 +22,19 @@ Class for runtime information.
import logging
from lxml import etree
-from phasecalculator.classes.xmlnamespacing import PHASE_CALCULATOR, PHASE_CALC_NAMESPACE_DICT
+from phasecalculator.classes.xmlnamespacing import (
+ PHASE_CALCULATOR,
+ PHASE_CALC_NAMESPACE_DICT,
+)
logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class RuntimeInformation(object):
"""Class representation of runtime information."""
-
+
def __init__(self, phasetransfer_jar, scratch_dir, output_dir):
"""Initialise RuntimeInformation.
@@ -69,13 +73,16 @@ class RuntimeInformation(object):
if other is None:
return False
if isinstance(other, type(self)):
- return (self.phasetransfer_jar == other.phasetransfer_jar and
- self.scratch_dir == other.scratch_dir and
- self.output_dir == other.output_dir)
+ return (
+ self.phasetransfer_jar == other.phasetransfer_jar
+ and self.scratch_dir == other.scratch_dir
+ and self.output_dir == other.output_dir
+ )
else:
return False
+
@classmethod
- def parse_xml(cls,runtime_xml):
+ def parse_xml(cls, runtime_xml):
"""Parse runtime information XML to populate new instance.
Parameters
@@ -93,9 +100,9 @@ class RuntimeInformation(object):
scratch_dir = cls.parse_scratch_dir(runtime_xml)
output_dir = cls.parse_output_dir(runtime_xml)
return RuntimeInformation(phasetransfer_jar, scratch_dir, output_dir)
-
+
@classmethod
- def parse_phasetransfer_jar(cls,runtime_xml):
+ def parse_phasetransfer_jar(cls, runtime_xml):
"""Parse phasetransfer jar file path.
Parameters
@@ -110,8 +117,11 @@ class RuntimeInformation(object):
"""
xpath_expression = "phasecalc:PhaseTransferJar/text()"
- phasetransfer_jar = runtime_xml.xpath(xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ phasetransfer_jar = runtime_xml.xpath(
+ xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
return phasetransfer_jar
+
@classmethod
def parse_scratch_dir(cls, runtime_xml):
"""Parse scratch directory path.
@@ -128,8 +138,11 @@ class RuntimeInformation(object):
"""
xpath_expression = "phasecalc:ScratchDirectory/text()"
- scratch_dir = runtime_xml.xpath(xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ scratch_dir = runtime_xml.xpath(
+ xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
return scratch_dir
+
@classmethod
def parse_output_dir(cls, runtime_xml):
"""Parse output directory from given XML.
@@ -148,8 +161,11 @@ class RuntimeInformation(object):
"""
xpath_expression = "phasecalc:OutputDirectory/text()"
- output_dir = runtime_xml.xpath(xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ output_dir = runtime_xml.xpath(
+ xpath_expression, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
return output_dir
+
def write_to_xml(self):
"""Write information to Etree representation of XML.
@@ -159,11 +175,14 @@ class RuntimeInformation(object):
XML representation of RuntimeInformation.
"""
- run_element = etree.Element(PHASE_CALCULATOR + "RuntimeInformation", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ run_element = etree.Element(
+ PHASE_CALCULATOR + "RuntimeInformation", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
run_element.append(self.write_phasetransfer_jar_xml())
run_element.append(self.write_scratch_dir_xml())
run_element.append(self.write_output_dir_xml())
return run_element
+
def write_phasetransfer_jar_xml(self):
"""Write PhaseTransferJar element.
@@ -173,9 +192,12 @@ class RuntimeInformation(object):
XML representation of PhaseTransferJar.
"""
- pt_jar_element = etree.Element(PHASE_CALCULATOR + "PhaseTransferJar", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ pt_jar_element = etree.Element(
+ PHASE_CALCULATOR + "PhaseTransferJar", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
pt_jar_element.text = self.phasetransfer_jar
return pt_jar_element
+
def write_scratch_dir_xml(self):
"""Write ScratchDirectory element.
@@ -185,9 +207,12 @@ class RuntimeInformation(object):
XML representation of ScratchDirectory.
"""
- scratch_element = etree.Element(PHASE_CALCULATOR + "ScratchDirectory", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ scratch_element = etree.Element(
+ PHASE_CALCULATOR + "ScratchDirectory", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
scratch_element.text = self.scratch_dir
return scratch_element
+
def write_output_dir_xml(self):
"""Write OutputDirectory element.
@@ -197,6 +222,8 @@ class RuntimeInformation(object):
XML representation of OutputDirectory.
"""
- output_element = etree.Element(PHASE_CALCULATOR + "OutputDirectory", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ output_element = etree.Element(
+ PHASE_CALCULATOR + "OutputDirectory", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
output_element.text = self.output_dir
- return output_element
\ No newline at end of file
+ return output_element
diff --git a/phasecalculator/classes/system.py b/phasecalculator/classes/system.py
index 56b8369..33384d3 100755
--- a/phasecalculator/classes/system.py
+++ b/phasecalculator/classes/system.py
@@ -25,7 +25,10 @@ from lxml import etree
from phasecalculator.classes.phases import Phases
from phasecalculator.classes.runtimeinformation import RuntimeInformation
from phasecalculator.classes.outputinformation import OutputInformation
-from phasecalculator.classes.xmlnamespacing import PHASE_CALCULATOR, PHASE_CALC_NAMESPACE_DICT
+from phasecalculator.classes.xmlnamespacing import (
+ PHASE_CALCULATOR,
+ PHASE_CALC_NAMESPACE_DICT,
+)
logging.basicConfig()
@@ -35,6 +38,7 @@ LOGGER.setLevel(logging.WARN)
class SystemCollection(object):
"""System Collection class."""
+
def __init__(self, system_list):
"""
@@ -49,6 +53,7 @@ class SystemCollection(object):
"""
self.system_list = system_list
+
def __eq__(self, other):
"""Overload equality comparison operator.
@@ -68,10 +73,16 @@ class SystemCollection(object):
if isinstance(other, type(self)):
if len(self.system_list) != len(other.system_list):
return False
- sys_comps = all([self.system_list[i] == other.system_list[i] for i in range(len(self.system_list))])
+ sys_comps = all(
+ [
+ self.system_list[i] == other.system_list[i]
+ for i in range(len(self.system_list))
+ ]
+ )
return sys_comps
else:
return False
+
@classmethod
def parse_xml(cls, system_collection_xml):
"""Parse XML representation to new instance.
@@ -87,9 +98,12 @@ class SystemCollection(object):
New instance.
"""
- system_xml_list = system_collection_xml.xpath("phasecalc:System", namespaces=PHASE_CALC_NAMESPACE_DICT)
+ system_xml_list = system_collection_xml.xpath(
+ "phasecalc:System", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )
system_list = [System.parse_xml(system_xml) for system_xml in system_xml_list]
return SystemCollection(system_list)
+
def write_to_xml(self):
"""Write SystemCollection to XML.
@@ -99,13 +113,17 @@ class SystemCollection(object):
XML representation of SystemCollection.
"""
- sys_coll_element = etree.Element(PHASE_CALCULATOR + "SystemCollection", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ sys_coll_element = etree.Element(
+ PHASE_CALCULATOR + "SystemCollection", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
for system in self.system_list:
sys_coll_element.append(system.write_to_xml())
return sys_coll_element
+
class System(object):
"""System class"""
+
def __init__(self, phases, runtime_information, output_information):
"""Initialise new System.
@@ -126,6 +144,7 @@ class System(object):
self.phases = phases
self.runtime_information = runtime_information
self.output_information = output_information
+
def __eq__(self, other):
"""Overload equality comparison operator.
@@ -143,9 +162,14 @@ class System(object):
if other is None:
return False
if isinstance(other, type(self)):
- return (self.phases == other.phases and self.runtime_information == other.runtime_information and self.output_information == other.output_information)
+ return (
+ self.phases == other.phases
+ and self.runtime_information == other.runtime_information
+ and self.output_information == other.output_information
+ )
else:
return False
+
@classmethod
def parse_xml(cls, system_xml):
"""Parse XML representation to new instance.
@@ -161,13 +185,20 @@ class System(object):
New instance.
"""
- phases_xml = system_xml.xpath("phasecalc:Phases", namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
- runtime_xml = system_xml.xpath("phasecalc:RuntimeInformation", namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
- output_xml = system_xml.xpath("phasecalc:OutputInformation", namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ phases_xml = system_xml.xpath(
+ "phasecalc:Phases", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
+ runtime_xml = system_xml.xpath(
+ "phasecalc:RuntimeInformation", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
+ output_xml = system_xml.xpath(
+ "phasecalc:OutputInformation", namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
phases = Phases.parse_xml(phases_xml)
runtime_information = RuntimeInformation.parse_xml(runtime_xml)
output_information = OutputInformation.parse_xml(output_xml)
return System(phases, runtime_information, output_information)
+
def write_to_xml(self):
"""Write System to XML.
@@ -177,11 +208,14 @@ class System(object):
XML representation of System.
"""
- system_element = etree.Element(PHASE_CALCULATOR + "System", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ system_element = etree.Element(
+ PHASE_CALCULATOR + "System", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
system_element.append(self.phases.write_to_xml())
system_element.append(self.runtime_information.write_to_xml())
system_element.append(self.output_information.write_to_xml())
return system_element
+
def get_phase_compositions_by_temperature(self):
"""Get phases split up by temperature. This is for solvent XML generation.
@@ -192,6 +226,7 @@ class System(object):
"""
return self.phases.get_phase_molefractions_by_temperature()
+
def get_phases_by_temp_list(self):
"""Get temperature information and phase composition list for XML creation.
@@ -207,8 +242,11 @@ class System(object):
phase_comps_by_temp = self.get_phase_compositions_by_temperature()
phase_comp_by_temp_list = []
for temperature, phases_mol_frac_list in phase_comps_by_temp.items():
- phase_comp_by_temp_list.append([[temperature.to_dict()], phases_mol_frac_list])
+ phase_comp_by_temp_list.append(
+ [[temperature.to_dict()], phases_mol_frac_list]
+ )
return phase_comp_by_temp_list
+
def get_molefractions_by_molecule_list(self):
"""List of molefraction dictionaries for all phases in collection.
@@ -219,6 +257,7 @@ class System(object):
"""
return self.phases.get_molefractions_by_molecule_list()
+
def get_ssip_file_locations(self):
"""Get the SSIP file locations for all molecules in any phase.
@@ -229,6 +268,7 @@ class System(object):
"""
return self.phases.get_ssip_file_locations()
+
def calc_fgip(self):
"""Boolean indicating whether to Calculate FGIP information for Phases.
@@ -239,6 +279,7 @@ class System(object):
"""
return self.output_information.fgip_output
+
def calc_similarity(self):
"""Boolean indicating whether to calculate similarity information for Phases.
@@ -249,6 +290,7 @@ class System(object):
"""
return self.output_information.similarity_output
+
def calc_vle(self):
"""Boolean indicating whether to calculate VLE information for Phases.
diff --git a/phasecalculator/classes/temperature.py b/phasecalculator/classes/temperature.py
index 991758d..5d60348 100755
--- a/phasecalculator/classes/temperature.py
+++ b/phasecalculator/classes/temperature.py
@@ -22,12 +22,16 @@ Script for temperature class.
import logging
from lxml import etree
-from phasecalculator.classes.xmlnamespacing import PHASE_CALCULATOR, PHASE_CALC_NAMESPACE_DICT
+from phasecalculator.classes.xmlnamespacing import (
+ PHASE_CALCULATOR,
+ PHASE_CALC_NAMESPACE_DICT,
+)
logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class Temperature(object):
"""Temperature class."""
@@ -50,6 +54,7 @@ class Temperature(object):
"""
self.temperature = temperature
self.temperature_unit = temperature_unit
+
def __eq__(self, other):
"""Overload equality comparison operator.
@@ -67,10 +72,13 @@ class Temperature(object):
if other is None:
return False
if isinstance(other, type(self)):
- return (abs(self.temperature - other.temperature)< self.TOLERANCE and self.temperature_unit == other.temperature_unit)
+ return (
+ abs(self.temperature - other.temperature) < self.TOLERANCE
+ and self.temperature_unit == other.temperature_unit
+ )
else:
return False
-
+
def __hash__(self):
"""Overload hash operator of Temperature class.
@@ -83,10 +91,14 @@ class Temperature(object):
hash of temperature object.
"""
- temperature = self.temperature if self.temperature_unit == "KELVIN" else self.temperature + 273.15
+ temperature = (
+ self.temperature
+ if self.temperature_unit == "KELVIN"
+ else self.temperature + 273.15
+ )
temp_str = "{:.2f}".format(abs(temperature))
return hash(temp_str) + hash(self.temperature_unit)
-
+
@classmethod
def parse_xml(cls, temperature_xml):
"""Parse XML representation to new instance.
@@ -103,11 +115,15 @@ class Temperature(object):
"""
temp_xpath = "@phasecalc:value"
- temperature = float(temperature_xml.xpath(temp_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT)[0])
+ temperature = float(
+ temperature_xml.xpath(temp_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ )
unit_xpath = "@phasecalc:unit"
- temperature_unit = temperature_xml.xpath(unit_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT)[0]
+ temperature_unit = temperature_xml.xpath(
+ unit_xpath, namespaces=PHASE_CALC_NAMESPACE_DICT
+ )[0]
return Temperature(temperature, temperature_unit)
-
+
def write_to_xml(self):
"""Write information to Etree representation of XML.
@@ -117,10 +133,13 @@ class Temperature(object):
XML representation of Temperature.
"""
- temp_element = etree.Element(PHASE_CALCULATOR + "Temperature", nsmap=PHASE_CALC_NAMESPACE_DICT)
+ temp_element = etree.Element(
+ PHASE_CALCULATOR + "Temperature", nsmap=PHASE_CALC_NAMESPACE_DICT
+ )
temp_element.set(PHASE_CALCULATOR + "value", "{:.1f}".format(self.temperature))
temp_element.set(PHASE_CALCULATOR + "unit", self.temperature_unit)
return temp_element
+
def to_dict(self):
"""Convert to dictionary.
@@ -130,5 +149,7 @@ class Temperature(object):
Dictionary representation.
"""
- return {"temperature_value":self.temperature,
- "temperature_units":self.temperature_unit}
\ No newline at end of file
+ return {
+ "temperature_value": self.temperature,
+ "temperature_units": self.temperature_unit,
+ }
diff --git a/phasecalculator/classes/xmlnamespacing.py b/phasecalculator/classes/xmlnamespacing.py
index 82bfe41..2530f9a 100755
--- a/phasecalculator/classes/xmlnamespacing.py
+++ b/phasecalculator/classes/xmlnamespacing.py
@@ -26,6 +26,8 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-PHASE_CALC_NAMESPACE_DICT = {"phasecalc": "http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema"}
+PHASE_CALC_NAMESPACE_DICT = {
+ "phasecalc": "http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema"
+}
PHASE_CALCULATOR = "{{{}}}".format(PHASE_CALC_NAMESPACE_DICT["phasecalc"])
diff --git a/phasecalculator/io/phasecsvconverter.py b/phasecalculator/io/phasecsvconverter.py
index c041517..94e55f0 100755
--- a/phasecalculator/io/phasecsvconverter.py
+++ b/phasecalculator/io/phasecsvconverter.py
@@ -36,6 +36,7 @@ LOGGER.setLevel(logging.WARN)
NAME_INCHIKEY_MAP = pureinf.get_name_inchikey_mapping()
INCHIKEY_SSIP_FILE_DICT = pureinf.get_ssip_file_dict()
+
def convert_csv_file_to_phases(csv_filename):
"""Read CSV file and convert contents to Phases.
@@ -53,6 +54,7 @@ def convert_csv_file_to_phases(csv_filename):
csv_file_contents = read_csv_file(csv_filename)
return create_phases(csv_file_contents)
+
def read_csv_file(csv_filename):
"""Read CSV file to list of rows.
@@ -71,6 +73,7 @@ def read_csv_file(csv_filename):
csv_reader = csv.reader(csv_file, delimiter="\t")
return [row for row in csv_reader]
+
def create_phases(csv_file_contents):
"""Create Phases for csv file contents
@@ -89,7 +92,6 @@ def create_phases(csv_file_contents):
for csv_file_line in csv_file_contents:
phase_list.append(create_phase(csv_file_line))
return Phases(phase_list)
-
def create_phase(csv_file_line):
@@ -109,12 +111,13 @@ def create_phase(csv_file_line):
"""
temperature = create_temperature(float(csv_file_line[0]))
molecule_list = []
- for i in range(1,len(csv_file_line),2):
+ for i in range(1, len(csv_file_line), 2):
name = csv_file_line[i]
- molefraction = float(csv_file_line[i+1])
+ molefraction = float(csv_file_line[i + 1])
molecule_list.append(create_molecule(name, molefraction))
return Phase(molecule_list, temperature)
+
def create_molecule(name, molefraction):
"""Create Molecule.
@@ -144,6 +147,7 @@ def create_molecule(name, molefraction):
LOGGER.error("Invalid entry: %s Not found.", name)
raise keyerr
+
def create_temperature(temperature_value):
"""Create Temperature.
@@ -158,4 +162,4 @@ def create_temperature(temperature_value):
Temperature object.
"""
- return Temperature(temperature_value, "KELVIN")
\ No newline at end of file
+ return Temperature(temperature_value, "KELVIN")
diff --git a/phasecalculator/io/phasetransferxmlcreator.py b/phasecalculator/io/phasetransferxmlcreator.py
index 9381a77..e003bf0 100755
--- a/phasecalculator/io/phasetransferxmlcreator.py
+++ b/phasecalculator/io/phasetransferxmlcreator.py
@@ -30,6 +30,7 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
def create_solvent_file(mole_fraction_dict_list, solvent_filename, **kwargs):
"""Create solvent XML file for given compositions.
@@ -58,6 +59,7 @@ def create_solvent_file(mole_fraction_dict_list, solvent_filename, **kwargs):
solvent_info_list = generate_solv_info_list(mole_fraction_dict_list, **kwargs)
write_solvent_file(solvent_info_list, solvent_filename)
+
def create_phase_file(mole_fraction_dict_list_by_temp, phase_filename, **kwargs):
"""Create phase XML file for given compositions and temperatures.
@@ -91,6 +93,7 @@ def create_phase_file(mole_fraction_dict_list_by_temp, phase_filename, **kwargs)
phase_info_by_temp.append([temperature_info, phase_info_list])
write_phase_file(phase_info_by_temp, phase_filename)
+
def write_solvent_file(solvent_info_list, solvent_filename):
"""Write solvent XML file for given compositions.
@@ -129,7 +132,10 @@ def write_phase_file(phase_info_list_by_temp, phase_filename):
None.
"""
- phasemake.write_phase_information_to_file_diff_temp(phase_info_list_by_temp, phase_filename)
+ phasemake.write_phase_information_to_file_diff_temp(
+ phase_info_list_by_temp, phase_filename
+ )
+
def generate_solv_info_list(mole_fraction_dict_list, **kwargs):
"""Generate solvent info from read in SSIP files and solvent information.
@@ -156,7 +162,16 @@ def generate_solv_info_list(mole_fraction_dict_list, **kwargs):
compositions.
"""
- solvent_filename = kwargs.get("solvent_info_filename", multiassem.solvconcreader.DEFAULT_SOLVENT_INFORMATION_FILE)
- ssip_filename_list = kwargs.get("ssip_filename_list",pureinfo.get_ssip_file_dict().values())
- name_inchikey_map = kwargs.get("name_inchikey_map", pureinfo.get_name_inchikey_mapping())
- return multiassem.generate_solv_info_from_files(mole_fraction_dict_list, solvent_filename, ssip_filename_list, name_inchikey_map)
+ solvent_filename = kwargs.get(
+ "solvent_info_filename",
+ multiassem.solvconcreader.DEFAULT_SOLVENT_INFORMATION_FILE,
+ )
+ ssip_filename_list = kwargs.get(
+ "ssip_filename_list", pureinfo.get_ssip_file_dict().values()
+ )
+ name_inchikey_map = kwargs.get(
+ "name_inchikey_map", pureinfo.get_name_inchikey_mapping()
+ )
+ return multiassem.generate_solv_info_from_files(
+ mole_fraction_dict_list, solvent_filename, ssip_filename_list, name_inchikey_map
+ )
diff --git a/phasecalculator/io/polynomialio.py b/phasecalculator/io/polynomialio.py
index 0d7b2a0..cdb4f6b 100755
--- a/phasecalculator/io/polynomialio.py
+++ b/phasecalculator/io/polynomialio.py
@@ -31,9 +31,10 @@ LOGGER.setLevel(logging.WARN)
POLY_ORDER_LIST = [8]
-POSITIVE_POINTS = ["{:.3f}solute".format((float(x)/10.0)) for x in range(101)]
+POSITIVE_POINTS = ["{:.3f}solute".format((float(x) / 10.0)) for x in range(101)]
+
+NEGATIVE_POINTS = ["{:.3f}solute".format((float(x) / 10.0) - 20.0) for x in range(201)]
-NEGATIVE_POINTS = ["{:.3f}solute".format((float(x)/10.0) - 20.0) for x in range(201)]
def read_poly_data_to_dict(poly_filename_list, **kwargs):
"""Parse each file, and then returns the dictionary of information, by solvent ID.
@@ -57,6 +58,7 @@ def read_poly_data_to_dict(poly_filename_list, **kwargs):
"""
return polyread.parse_polynomial_data_file_list(poly_filename_list, **kwargs)
+
def generate_polynomial_data_free_energy_file_list(free_energy_filename_list):
"""Generate polynomial fits for free energy data in given files.
@@ -76,15 +78,22 @@ def generate_polynomial_data_free_energy_file_list(free_energy_filename_list):
out_res_split = []
filename_list = []
for free_energy_filename in free_energy_filename_list:
- poly_filename_split = generate_polynomial_filename(free_energy_filename, suffix="_poly_fit_split.csv")
- out_res_split.append(polyplot.parse_free_energy_poly_data_to_file_split_fit(free_energy_filename,
- POLY_ORDER_LIST,
- poly_filename_split,
- POSITIVE_POINTS,
- NEGATIVE_POINTS))
+ poly_filename_split = generate_polynomial_filename(
+ free_energy_filename, suffix="_poly_fit_split.csv"
+ )
+ out_res_split.append(
+ polyplot.parse_free_energy_poly_data_to_file_split_fit(
+ free_energy_filename,
+ POLY_ORDER_LIST,
+ poly_filename_split,
+ POSITIVE_POINTS,
+ NEGATIVE_POINTS,
+ )
+ )
filename_list.append(poly_filename_split)
return out_res_split, filename_list
+
def generate_polynomial_data_binding_energy_file_list(binding_energy_filename_list):
"""Generate polynomial fits for binding energy data in given files.
@@ -104,16 +113,23 @@ def generate_polynomial_data_binding_energy_file_list(binding_energy_filename_li
out_res_split = []
filename_list = []
for binding_energy_filename in binding_energy_filename_list:
- poly_filename_split = generate_polynomial_filename(binding_energy_filename, suffix="_poly_fit_split.csv")
- out_res_split.append(polyplot.parse_binding_energy_poly_data_to_file_split_fit(binding_energy_filename,
- POLY_ORDER_LIST,
- poly_filename_split,
- POSITIVE_POINTS,
- NEGATIVE_POINTS))
+ poly_filename_split = generate_polynomial_filename(
+ binding_energy_filename, suffix="_poly_fit_split.csv"
+ )
+ out_res_split.append(
+ polyplot.parse_binding_energy_poly_data_to_file_split_fit(
+ binding_energy_filename,
+ POLY_ORDER_LIST,
+ poly_filename_split,
+ POSITIVE_POINTS,
+ NEGATIVE_POINTS,
+ )
+ )
filename_list.append(poly_filename_split)
- return out_res_split, filename_list
+ return out_res_split, filename_list
+
-def generate_polynomial_filename(free_energy_filename, suffix='_poly_fit.csv'):
+def generate_polynomial_filename(free_energy_filename, suffix="_poly_fit.csv"):
"""Generate polynomial filename from energy XML filename.
Parameters
@@ -129,5 +145,4 @@ def generate_polynomial_filename(free_energy_filename, suffix='_poly_fit.csv'):
polynomial filename.
"""
- return free_energy_filename.replace('.xml', suffix)
-
+ return free_energy_filename.replace(".xml", suffix)
diff --git a/phasecalculator/io/solventextractor.py b/phasecalculator/io/solventextractor.py
index 4f1ea61..0fc508a 100755
--- a/phasecalculator/io/solventextractor.py
+++ b/phasecalculator/io/solventextractor.py
@@ -27,7 +27,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-def extract_and_write_energy_values_from_files(solvent_filename, energy_xml_filename, energy_type, directory):
+
+def extract_and_write_energy_values_from_files(
+ solvent_filename, energy_xml_filename, energy_type, directory
+):
"""Extracts energies and splits to different file for each solvent.
Parameters
@@ -47,6 +50,6 @@ def extract_and_write_energy_values_from_files(solvent_filename, energy_xml_file
filenames for files outputted to disk.
"""
- return solvextract.extract_and_write_energy_values_from_files(solvent_filename, energy_xml_filename, energy_type, directory)
-
-
+ return solvextract.extract_and_write_energy_values_from_files(
+ solvent_filename, energy_xml_filename, energy_type, directory
+ )
diff --git a/phasecalculator/io/systemcollectionprocessor.py b/phasecalculator/io/systemcollectionprocessor.py
index 7084582..7aa61b7 100755
--- a/phasecalculator/io/systemcollectionprocessor.py
+++ b/phasecalculator/io/systemcollectionprocessor.py
@@ -44,7 +44,9 @@ def read_system_collection_file(xml_filename):
SystemCollection for calculations.
"""
- system_collection_etree = xmlval.validate_and_read_xml_file(xml_filename, xmlval.PHASE_CALCULATOR_SCHEMA)
+ system_collection_etree = xmlval.validate_and_read_xml_file(
+ xml_filename, xmlval.PHASE_CALCULATOR_SCHEMA
+ )
return SystemCollection.parse_xml(system_collection_etree)
@@ -68,4 +70,4 @@ def write_system_collection_file(system_collection, xml_filename):
xmlval.validate_xml(system_coll_etree, xmlval.PHASE_CALCULATOR_SCHEMA)
system_coll_etree.write(
xml_filename, encoding="UTF-8", xml_declaration=True, pretty_print=True
- )
\ No newline at end of file
+ )
diff --git a/phasecalculator/phasecalculatorcli.py b/phasecalculator/phasecalculatorcli.py
index 71e549f..183dd17 100755
--- a/phasecalculator/phasecalculatorcli.py
+++ b/phasecalculator/phasecalculatorcli.py
@@ -49,6 +49,7 @@ def main():
args = parser.parse_args()
return process_args(args)
+
def process_args(args):
"""Process CLI Arguments.
@@ -65,6 +66,7 @@ def process_args(args):
"""
return args.func(args)
+
def process_inputgen(args):
"""Process arguments to run input file creation for phase calculation.
@@ -82,6 +84,7 @@ def process_inputgen(args):
system_collection = create_system_collection(args)
sysproc.write_system_collection_file(system_collection, output_filename)
+
def process_phasecalculator(args):
"""Process arguments to run phase calculation.
@@ -102,6 +105,7 @@ def process_phasecalculator(args):
else:
run_system_collection(system_collection)
+
def create_system_collection(args):
"""Create SystemCollection from input arguments
@@ -125,11 +129,16 @@ def create_system_collection(args):
similarity_output = args.sim
similarity_output_type = args.sim_type if similarity_output else None
vle_output = args.vle
- out_inf = create_output_inf(fgip_output, similarity_output, similarity_output_type, vle_output)
+ out_inf = create_output_inf(
+ fgip_output, similarity_output, similarity_output_type, vle_output
+ )
system = System(phases, run_inf, out_inf)
return SystemCollection([system])
-
-def create_output_inf(fgip_output, similarity_output, similarity_output_type, vle_output):
+
+
+def create_output_inf(
+ fgip_output, similarity_output, similarity_output_type, vle_output
+):
"""Create OutputInformation
Parameters
@@ -149,7 +158,10 @@ def create_output_inf(fgip_output, similarity_output, similarity_output_type, vl
Output information for calculation.
"""
- return OutputInformation(fgip_output, similarity_output, similarity_output_type, vle_output)
+ return OutputInformation(
+ fgip_output, similarity_output, similarity_output_type, vle_output
+ )
+
def create_runtime_inf(jar_path, scratch_dir, output_dir):
"""Create RuntimeInformation
@@ -170,7 +182,8 @@ def create_runtime_inf(jar_path, scratch_dir, output_dir):
"""
return RuntimeInformation(jar_path, scratch_dir, output_dir)
-
+
+
def read_calculator_xml(xml_filename):
"""Read SystemCollection XML.
@@ -187,6 +200,7 @@ def read_calculator_xml(xml_filename):
"""
return sysproc.read_system_collection_file(xml_filename)
+
def read_phasecsv(csv_filename):
"""Read CSV file containing phase infomration and create Phases object.
@@ -203,6 +217,7 @@ def read_phasecsv(csv_filename):
"""
return csvconv.convert_csv_file_to_phases(csv_filename)
+
def run_system_collection(system_collection, **kwargs):
"""Run all systems in collection.
@@ -221,6 +236,7 @@ def run_system_collection(system_collection, **kwargs):
for system_info in system_collection.system_list:
phasecrun.run_all_analysis(system_info, **kwargs)
+
def create_phasecalculator_argparser():
"""Create Argument parser for Phasecalculator module.
@@ -232,49 +248,82 @@ def create_phasecalculator_argparser():
description = """Phase Calculator provides methods to perform FGIP,
similarity and VLE analysis for solvents."""
epilog = """Example usage"""
- phase_argparser= argparse.ArgumentParser(description=description,
- epilog=epilog,
- conflict_handler='resolve',
- formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+ phase_argparser = argparse.ArgumentParser(
+ description=description,
+ epilog=epilog,
+ conflict_handler="resolve",
+ formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+ )
subparsers = phase_argparser.add_subparsers(title="commands", dest="command")
calc_description = """Calculation runner based on input System XML."""
calc_epilog = """"""
- calc_argparser = subparsers.add_parser("calculate", description=calc_description,
- epilog=calc_epilog,
- help="calculate phase properties.",
- formatter_class=argparse.ArgumentDefaultsHelpFormatter)
- calc_argparser.add_argument("-i", "-f","--file", type=str, required=True,
- help="filename for SystemCollectionXML")
- calc_argparser.add_argument("--memreq", type=str, default=None,
- help="memory specifier for jar call. Defaults to system default.")
+ calc_argparser = subparsers.add_parser(
+ "calculate",
+ description=calc_description,
+ epilog=calc_epilog,
+ help="calculate phase properties.",
+ formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+ )
+ calc_argparser.add_argument(
+ "-i",
+ "-f",
+ "--file",
+ type=str,
+ required=True,
+ help="filename for SystemCollectionXML",
+ )
+ calc_argparser.add_argument(
+ "--memreq",
+ type=str,
+ default=None,
+ help="memory specifier for jar call. Defaults to system default.",
+ )
calc_argparser.set_defaults(func=process_phasecalculator)
-
+
inpgen_description = """Input SystemCollection XML generation."""
inpgen_epilog = """"""
-
- inpgen_argparser = subparsers.add_parser("inpgen", description=inpgen_description,
- epilog=inpgen_epilog,
- help="create system input xml.",
- formatter_class=argparse.ArgumentDefaultsHelpFormatter)
- inpgen_argparser.add_argument("-p", "--phases", type=str,
- help="")
- inpgen_argparser.add_argument("-j", "--jar", type=str, required=True,
- help="Phasetransfer jar path.")
- inpgen_argparser.add_argument("-x", "--scratch", type=str, default="scratch",
- help="scratch directory path.")
- inpgen_argparser.add_argument("-o", "--out_dir", type=str, default="output",
- help="output directory for calculation results")
-
- inpgen_argparser.add_argument("-f", "--fgip", action='store_true',
- help="Calculate FGIPs for input solvents")
- inpgen_argparser.add_argument("-s","--sim", action='store_true',
- help="Calculate similarity for input solvents")
- inpgen_argparser.add_argument("--sim_type", type=str, default="all",
- help="similarity output type.")
- inpgen_argparser.add_argument("-v","--vle", action='store_true',
- help="Calculate VLE for input solvents")
- inpgen_argparser.add_argument("--filename", type=str, default="systemcollection.xml")
+
+ inpgen_argparser = subparsers.add_parser(
+ "inpgen",
+ description=inpgen_description,
+ epilog=inpgen_epilog,
+ help="create system input xml.",
+ formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+ )
+ inpgen_argparser.add_argument("-p", "--phases", type=str, help="")
+ inpgen_argparser.add_argument(
+ "-j", "--jar", type=str, required=True, help="Phasetransfer jar path."
+ )
+ inpgen_argparser.add_argument(
+ "-x", "--scratch", type=str, default="scratch", help="scratch directory path."
+ )
+ inpgen_argparser.add_argument(
+ "-o",
+ "--out_dir",
+ type=str,
+ default="output",
+ help="output directory for calculation results",
+ )
+
+ inpgen_argparser.add_argument(
+ "-f", "--fgip", action="store_true", help="Calculate FGIPs for input solvents"
+ )
+ inpgen_argparser.add_argument(
+ "-s",
+ "--sim",
+ action="store_true",
+ help="Calculate similarity for input solvents",
+ )
+ inpgen_argparser.add_argument(
+ "--sim_type", type=str, default="all", help="similarity output type."
+ )
+ inpgen_argparser.add_argument(
+ "-v", "--vle", action="store_true", help="Calculate VLE for input solvents"
+ )
+ inpgen_argparser.add_argument(
+ "--filename", type=str, default="systemcollection.xml"
+ )
inpgen_argparser.set_defaults(func=process_inputgen)
return phase_argparser
diff --git a/phasecalculator/runners/fgipanalysisrunner.py b/phasecalculator/runners/fgipanalysisrunner.py
index 72623c4..d75e999 100755
--- a/phasecalculator/runners/fgipanalysisrunner.py
+++ b/phasecalculator/runners/fgipanalysisrunner.py
@@ -32,7 +32,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-def calc_energies_and_fgips(jar_path, energy_xml_filename, solvent_filename, directory_base, **kwargs):
+
+def calc_energies_and_fgips(
+ jar_path, energy_xml_filename, solvent_filename, directory_base, **kwargs
+):
"""Run phasetransfer calculation and generate FGIPs for input solvent.
Parameters
@@ -60,12 +63,19 @@ def calc_energies_and_fgips(jar_path, energy_xml_filename, solvent_filename, dir
List of results of calculation outcomes, and latex text block for figures.
"""
- temperature = kwargs.get("temperature",298.0)
+ temperature = kwargs.get("temperature", 298.0)
temperature_unit = kwargs.get("temperature_unit", "KELVIN")
- run_binding_energy_calculation(jar_path, energy_xml_filename, solvent_filename, **kwargs)
+ run_binding_energy_calculation(
+ jar_path, energy_xml_filename, solvent_filename, **kwargs
+ )
directory = generate_directory(directory_base, temperature, temperature_unit)
- out_res, polynomial_filename_list = extract_solvents_and_generate_polynomials(solvent_filename, energy_xml_filename, directory)
- return run_fgip_analysis(solvent_filename, polynomial_filename_list, directory, **kwargs)
+ out_res, polynomial_filename_list = extract_solvents_and_generate_polynomials(
+ solvent_filename, energy_xml_filename, directory
+ )
+ return run_fgip_analysis(
+ solvent_filename, polynomial_filename_list, directory, **kwargs
+ )
+
def generate_directory(directory_base, temperature, temperature_unit):
"""Generate directory to put information based on temperature of simulation.
@@ -89,11 +99,14 @@ def generate_directory(directory_base, temperature, temperature_unit):
"""
- temperature_name = "{:.1f}{}".format(temperature, "K" if temperature_unit == "KELVIN" else "C").replace(".","_")
+ temperature_name = "{:.1f}{}".format(
+ temperature, "K" if temperature_unit == "KELVIN" else "C"
+ ).replace(".", "_")
dir_path = pathlib.Path(directory_base) / temperature_name
- dir_path.mkdir(parents=True,exist_ok=True)
+ dir_path.mkdir(parents=True, exist_ok=True)
return dir_path.as_posix()
+
def run_fgip_analysis(solvent_filename, polynomial_filename_list, directory, **kwargs):
"""Run FGIP analysis for all solvents included in solvent file.
@@ -114,9 +127,14 @@ def run_fgip_analysis(solvent_filename, polynomial_filename_list, directory, **k
List of results of calculation outcomes, and latex text block for figures.
"""
- return fgipanalysis.create_solv_map_and_fgips_from_files(solvent_filename, polynomial_filename_list, directory, **kwargs)
+ return fgipanalysis.create_solv_map_and_fgips_from_files(
+ solvent_filename, polynomial_filename_list, directory, **kwargs
+ )
-def extract_solvents_and_generate_polynomials(solvent_filename, energy_xml_filename, directory):
+
+def extract_solvents_and_generate_polynomials(
+ solvent_filename, energy_xml_filename, directory
+):
"""Extract solvation binding energies and calculate binding polynomials per solvent.
Parameters
@@ -135,10 +153,17 @@ def extract_solvents_and_generate_polynomials(solvent_filename, energy_xml_filen
list of polynomial filenames.
"""
- energy_xml_filenames = solvextract.extract_and_write_energy_values_from_files(solvent_filename, energy_xml_filename, "binding", directory)
- return polyio.generate_polynomial_data_binding_energy_file_list(energy_xml_filenames)
+ energy_xml_filenames = solvextract.extract_and_write_energy_values_from_files(
+ solvent_filename, energy_xml_filename, "binding", directory
+ )
+ return polyio.generate_polynomial_data_binding_energy_file_list(
+ energy_xml_filenames
+ )
+
-def run_binding_energy_calculation(jar_path, output_filename, solvent_filename, **kwargs):
+def run_binding_energy_calculation(
+ jar_path, output_filename, solvent_filename, **kwargs
+):
"""Run solute solvation binding energy calculation.
Parameters
@@ -170,4 +195,6 @@ def run_binding_energy_calculation(jar_path, output_filename, solvent_filename,
result of system call.
"""
- return phaserun.run_phasetransfer_binding_energy(jar_path, output_filename, solvent_filename, **kwargs)
\ No newline at end of file
+ return phaserun.run_phasetransfer_binding_energy(
+ jar_path, output_filename, solvent_filename, **kwargs
+ )
diff --git a/phasecalculator/runners/phasecalculatorrunner.py b/phasecalculator/runners/phasecalculatorrunner.py
index fc6ff20..79d8861 100755
--- a/phasecalculator/runners/phasecalculatorrunner.py
+++ b/phasecalculator/runners/phasecalculatorrunner.py
@@ -51,14 +51,17 @@ def run_all_analysis(system_info, **kwargs):
None.
"""
- phase_filename, solvent_list = create_phase_and_solvent_xml_files(system_info, **kwargs)
+ phase_filename, solvent_list = create_phase_and_solvent_xml_files(
+ system_info, **kwargs
+ )
if system_info.calc_vle():
run_vle_analysis(system_info, phase_filename, **kwargs)
if system_info.calc_fgip():
run_fgip_analysis(system_info, solvent_list, **kwargs)
if system_info.calc_similarity():
run_similarity_analysis(system_info, solvent_list, **kwargs)
-
+
+
def run_fgip_analysis(system_info, solvent_filename_dict_list, **kwargs):
"""Run FGIP analysis.
@@ -92,14 +95,20 @@ def run_fgip_analysis(system_info, solvent_filename_dict_list, **kwargs):
directory_base = system_info.runtime_information.output_dir
temperature = solvent_filename_dict["temperature_value"]
temperature_unit = solvent_filename_dict["temperature_units"]
- results, latex_blocks = fgiprun.calc_energies_and_fgips(jar_path, energy_xml_filename,
- solvent_filename, directory_base,
- temperature=temperature,
- temperature_unit=temperature_unit,
- **kwargs)
+ results, latex_blocks = fgiprun.calc_energies_and_fgips(
+ jar_path,
+ energy_xml_filename,
+ solvent_filename,
+ directory_base,
+ temperature=temperature,
+ temperature_unit=temperature_unit,
+ **kwargs
+ )
combined_results.extend(results)
combined_latex_blocks += latex_blocks
return combined_results, combined_latex_blocks
+
+
def run_similarity_analysis(system_info, solvent_filename_dict, **kwargs):
"""Run similarity analysis.
@@ -129,18 +138,24 @@ def run_similarity_analysis(system_info, solvent_filename_dict, **kwargs):
temperature_unit = solv_dict["temperature_units"]
solv_dict["energy_filename"] = energy_filename
solvent_filename_dict_list.append(solv_dict)
- simrun.run_free_energy_calculation(jar_path, energy_filename,
- solvent_filename,
- temperature=temperature,
- temperature_unit=temperature_unit,
- **kwargs)
+ simrun.run_free_energy_calculation(
+ jar_path,
+ energy_filename,
+ solvent_filename,
+ temperature=temperature,
+ temperature_unit=temperature_unit,
+ **kwargs
+ )
output_dir = system_info.runtime_information.output_dir
output_type = system_info.output_information.similarity_output_type
- out_res, poly_filename_list = simrun.extract_all_solvents_and_generate_polynomials(solvent_filename_dict_list,
- output_dir)
- simrun.run_similarity_analysis(poly_filename_list, output_type, output_dir, **kwargs)
+ out_res, poly_filename_list = simrun.extract_all_solvents_and_generate_polynomials(
+ solvent_filename_dict_list, output_dir
+ )
+ simrun.run_similarity_analysis(
+ poly_filename_list, output_type, output_dir, **kwargs
+ )
+
-
def run_vle_analysis(system_info, phase_filename, **kwargs):
"""Run VLE phase calculation.
@@ -166,7 +181,10 @@ def run_vle_analysis(system_info, phase_filename, **kwargs):
"""
jar_path = system_info.runtime_information.phasetransfer_jar
output_filename = create_phase_output_filename(phase_filename)
- return vlerun.run_vle_calculation(jar_path, phase_filename, output_filename, **kwargs)
+ return vlerun.run_vle_calculation(
+ jar_path, phase_filename, output_filename, **kwargs
+ )
+
def create_output_dir(system_info):
"""Makes output directory for system calculation.
@@ -182,9 +200,10 @@ def create_output_dir(system_info):
"""
output_path = pathlib.Path(system_info.runtime_information.output_dir)
- output_path.mkdir(parents=True,exist_ok=True)
+ output_path.mkdir(parents=True, exist_ok=True)
return output_path.as_posix()
+
def create_free_energy_output_filename(solvent_filename):
"""Create free energy filename for solvent file.
@@ -199,7 +218,9 @@ def create_free_energy_output_filename(solvent_filename):
Output energy filename.
"""
- return solvent_filename.replace(".xml","free.xml")
+ return solvent_filename.replace(".xml", "free.xml")
+
+
def create_binding_energy_output_filename(solvent_filename):
"""Create binding energy filename for solvent file.
@@ -215,6 +236,8 @@ def create_binding_energy_output_filename(solvent_filename):
"""
return solvent_filename.replace(".xml", "binding.xml")
+
+
def create_phase_output_filename(phase_filename):
"""
@@ -231,6 +254,7 @@ def create_phase_output_filename(phase_filename):
"""
return phase_filename.replace(".xml", "calculated.xml")
+
def create_phase_and_solvent_xml_files(system_info, **kwargs):
"""Create solvent and phase files for given system.
@@ -257,4 +281,4 @@ def create_phase_and_solvent_xml_files(system_info, **kwargs):
"""
- return phasexmlrun.create_phase_and_solvent_files(system_info, **kwargs)
\ No newline at end of file
+ return phasexmlrun.create_phase_and_solvent_files(system_info, **kwargs)
diff --git a/phasecalculator/runners/phasetransferrunner.py b/phasecalculator/runners/phasetransferrunner.py
index 8973205..e707120 100755
--- a/phasecalculator/runners/phasetransferrunner.py
+++ b/phasecalculator/runners/phasetransferrunner.py
@@ -30,8 +30,6 @@ LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-
-
def run_vle_calculation(jar_path, phase_filename, output_filename, **kwargs):
"""Run VLE phase calculation.
@@ -58,12 +56,17 @@ def run_vle_calculation(jar_path, phase_filename, output_filename, **kwargs):
"""
if check_jar_exists(jar_path):
- vle_args = generate_vle_calc_args(jar_path, phase_filename, output_filename, **kwargs)
+ vle_args = generate_vle_calc_args(
+ jar_path, phase_filename, output_filename, **kwargs
+ )
return run_calculation(vle_args)
else:
raise FileNotFoundError("File does not exist: %s", jar_path)
-def run_phasetransfer_binding_energy(jar_path, output_filename, solvent_filename, **kwargs):
+
+def run_phasetransfer_binding_energy(
+ jar_path, output_filename, solvent_filename, **kwargs
+):
"""Run solute solvation binding energy calculation.
Parameters
@@ -96,12 +99,17 @@ def run_phasetransfer_binding_energy(jar_path, output_filename, solvent_filename
"""
if check_jar_exists(jar_path):
- phase_binding_args = generate_phasetransfer_binding_args(jar_path, output_filename, solvent_filename, **kwargs)
+ phase_binding_args = generate_phasetransfer_binding_args(
+ jar_path, output_filename, solvent_filename, **kwargs
+ )
return run_calculation(phase_binding_args)
else:
raise FileNotFoundError("File does not exist: %s", jar_path)
-def run_phasetransfer_free_energy(jar_path, output_filename, solvent_filename, **kwargs):
+
+def run_phasetransfer_free_energy(
+ jar_path, output_filename, solvent_filename, **kwargs
+):
"""Run solute solvation free energy calculation.
Parameters
@@ -133,11 +141,14 @@ def run_phasetransfer_free_energy(jar_path, output_filename, solvent_filename, *
"""
if check_jar_exists(jar_path):
- phase_free_args = generate_phasetransfer_free_args(jar_path, output_filename, solvent_filename, **kwargs)
+ phase_free_args = generate_phasetransfer_free_args(
+ jar_path, output_filename, solvent_filename, **kwargs
+ )
return run_calculation(phase_free_args)
else:
raise FileNotFoundError("File does not exist: %s", jar_path)
+
def run_calculation(arg_list):
"""Run calculation with given arguments.
@@ -153,7 +164,8 @@ def run_calculation(arg_list):
"""
return subprocess.run(arg_list)
-
+
+
def generate_vle_calc_args(jar_path, phase_filename, output_filename, **kwargs):
"""Generate full argument list for VLE phase calculation.
@@ -174,10 +186,14 @@ def generate_vle_calc_args(jar_path, phase_filename, output_filename, **kwargs):
argument list for phasetransfer jar call.
"""
- jar_args = make_java_arguments(jar_path,memory_req=kwargs.pop("memory_req",None))
+ jar_args = make_java_arguments(jar_path, memory_req=kwargs.pop("memory_req", None))
phase_calc_args = generate_phase_calc_args(phase_filename, output_filename)
return jar_args + phase_calc_args
-def generate_phasetransfer_free_args(jar_path, output_filename, solvent_filename, **kwargs):
+
+
+def generate_phasetransfer_free_args(
+ jar_path, output_filename, solvent_filename, **kwargs
+):
"""Generate full argument list for solute solvation free energy calculation call.
Parameters
@@ -203,12 +219,17 @@ def generate_phasetransfer_free_args(jar_path, output_filename, solvent_filename
argument list for phasetransfer jar call.
"""
- jar_args = make_java_arguments(jar_path,memory_req=kwargs.pop("memory_req",None))
+ jar_args = make_java_arguments(jar_path, memory_req=kwargs.pop("memory_req", None))
free_args = ["--energies", "solvationtotal"]
- solvent_args = generate_solvent_calc_args(output_filename, solvent_filename, **kwargs)
+ solvent_args = generate_solvent_calc_args(
+ output_filename, solvent_filename, **kwargs
+ )
return jar_args + free_args + solvent_args
-def generate_phasetransfer_binding_args(jar_path, output_filename, solvent_filename, **kwargs):
+
+def generate_phasetransfer_binding_args(
+ jar_path, output_filename, solvent_filename, **kwargs
+):
"""Generate full argument list for solute solvation binding energy calculation call.
Parameters
@@ -234,11 +255,14 @@ def generate_phasetransfer_binding_args(jar_path, output_filename, solvent_filen
argument list for phasetransfer jar call.
"""
- jar_args = make_java_arguments(jar_path,memory_req=kwargs.pop("memory_req",None))
+ jar_args = make_java_arguments(jar_path, memory_req=kwargs.pop("memory_req", None))
binding_args = ["--energies", "solvationbinding"]
- solvent_args = generate_solvent_calc_args(output_filename, solvent_filename, **kwargs)
+ solvent_args = generate_solvent_calc_args(
+ output_filename, solvent_filename, **kwargs
+ )
return jar_args + binding_args + solvent_args
-
+
+
def generate_phase_calc_args(phase_filename, output_filename):
"""Generate argument list for phasetransfer VLE phase call.
@@ -255,13 +279,26 @@ def generate_phase_calc_args(phase_filename, output_filename):
argument calls for jar file.
"""
- return ["--phaseOut", "--phaseCollectionList", "--conccalc",
- "--gascalc", "--calc", "--phaseFile", phase_filename,
- "-o", output_filename]
-
-def generate_solvent_calc_args(output_filename, solvent_filename,temperature=298.0,
- temperature_unit="KELVIN",
- solute_filename=pureinf.SINGLE_SSIP_SOLUTE_FILE):
+ return [
+ "--phaseOut",
+ "--phaseCollectionList",
+ "--conccalc",
+ "--gascalc",
+ "--calc",
+ "--phaseFile",
+ phase_filename,
+ "-o",
+ output_filename,
+ ]
+
+
+def generate_solvent_calc_args(
+ output_filename,
+ solvent_filename,
+ temperature=298.0,
+ temperature_unit="KELVIN",
+ solute_filename=pureinf.SINGLE_SSIP_SOLUTE_FILE,
+):
"""Generate list of arguments for solvation calculation.
for solvent/solute.
@@ -285,9 +322,22 @@ def generate_solvent_calc_args(output_filename, solvent_filename,temperature=298
list of arguments for calculation related to solvent calculation.
"""
- return ["--calc", "--conccalc", "-o", output_filename, "--solvent", solvent_filename,
- "--solute", solute_filename, "--temperatureUnit", temperature_unit, "-t", "{:.1f}".format(temperature)]
-
+ return [
+ "--calc",
+ "--conccalc",
+ "-o",
+ output_filename,
+ "--solvent",
+ solvent_filename,
+ "--solute",
+ solute_filename,
+ "--temperatureUnit",
+ temperature_unit,
+ "-t",
+ "{:.1f}".format(temperature),
+ ]
+
+
def make_java_arguments(jar_path, memory_req=None):
"""Create java runtime arguments.
@@ -306,9 +356,10 @@ def make_java_arguments(jar_path, memory_req=None):
"""
mem_options = []
if memory_req is not None:
- mem_options = ["-Xms{}".format(memory_req), "-Xmx{}".format(memory_req)]
+ mem_options = ["-Xms{}".format(memory_req), "-Xmx{}".format(memory_req)]
return ["java"] + mem_options + ["-jar", jar_path]
+
def check_jar_exists(jar_path):
"""Check to see if the jar_path given corresponds to a file.
@@ -324,4 +375,4 @@ def check_jar_exists(jar_path):
"""
jar_file_path = pathlib.Path(jar_path)
- return jar_file_path.exists()
\ No newline at end of file
+ return jar_file_path.exists()
diff --git a/phasecalculator/runners/phasexmlcreatorrunner.py b/phasecalculator/runners/phasexmlcreatorrunner.py
index ebc1aaf..0ab2360 100755
--- a/phasecalculator/runners/phasexmlcreatorrunner.py
+++ b/phasecalculator/runners/phasexmlcreatorrunner.py
@@ -29,7 +29,6 @@ LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-
def create_phase_and_solvent_files(system_info, filestem="system", **kwargs):
"""Create solvent and phase files for given system.
@@ -61,9 +60,10 @@ def create_phase_and_solvent_files(system_info, filestem="system", **kwargs):
if system_info.calc_vle():
phase_file = create_phase_file(system_info, filestem + "phase", **kwargs)
if system_info.calc_fgip() or system_info.calc_similarity():
- solvent_list = create_solvent_files(system_info, filestem +"solvent", **kwargs)
+ solvent_list = create_solvent_files(system_info, filestem + "solvent", **kwargs)
return phase_file, solvent_list
+
def create_phase_file(system_info, filestem, **kwargs):
"""Create phase file for input information.
@@ -86,11 +86,20 @@ def create_phase_file(system_info, filestem, **kwargs):
phase filename.
"""
- phase_filename = create_phase_filename(system_info.runtime_information.scratch_dir, filestem)
+ phase_filename = create_phase_filename(
+ system_info.runtime_information.scratch_dir, filestem
+ )
mole_fractions_by_temp_dict = system_info.get_phases_by_temp_list()
ssip_filename_list = system_info.get_ssip_file_locations()
- phasexmlcreate.create_phase_file(mole_fractions_by_temp_dict, phase_filename, ssip_filename_list=ssip_filename_list, **kwargs)
+ phasexmlcreate.create_phase_file(
+ mole_fractions_by_temp_dict,
+ phase_filename,
+ ssip_filename_list=ssip_filename_list,
+ **kwargs
+ )
return phase_filename
+
+
def create_solvent_files(system_info, filestem, **kwargs):
"""Create solvent files for input information.
@@ -117,15 +126,28 @@ def create_solvent_files(system_info, filestem, **kwargs):
ssip_filename_list = system_info.get_ssip_file_locations()
solvent_list = []
for temp_info, mole_fraction_dict_list in mole_fractions_by_temp_dict.items():
- solvent_filename = create_solvent_file(mole_fraction_dict_list,
- ssip_filename_list, temp_info,
- filestem,
- system_info.runtime_information.scratch_dir, **kwargs)
- solvent_list.append({"solvent_filename":solvent_filename, **temp_info.to_dict()})
+ solvent_filename = create_solvent_file(
+ mole_fraction_dict_list,
+ ssip_filename_list,
+ temp_info,
+ filestem,
+ system_info.runtime_information.scratch_dir,
+ **kwargs
+ )
+ solvent_list.append(
+ {"solvent_filename": solvent_filename, **temp_info.to_dict()}
+ )
return solvent_list
-
-def create_solvent_file(mole_fraction_dict_list, ssip_filename_list, temp_info, filestem, scratch_dir, **kwargs):
+
+def create_solvent_file(
+ mole_fraction_dict_list,
+ ssip_filename_list,
+ temp_info,
+ filestem,
+ scratch_dir,
+ **kwargs
+):
"""Create solvent file for input information.
Parameters
@@ -154,9 +176,15 @@ def create_solvent_file(mole_fraction_dict_list, ssip_filename_list, temp_info,
"""
solvent_filename = create_solvent_filename(scratch_dir, temp_info, filestem)
- phasexmlcreate.create_solvent_file(mole_fraction_dict_list, solvent_filename, ssip_filename_list=ssip_filename_list, **kwargs)
+ phasexmlcreate.create_solvent_file(
+ mole_fraction_dict_list,
+ solvent_filename,
+ ssip_filename_list=ssip_filename_list,
+ **kwargs
+ )
return solvent_filename
+
def create_scratch_dir(system_info):
"""Makes scratch directory for system calculation.
@@ -171,8 +199,9 @@ def create_scratch_dir(system_info):
"""
scratch_path = pathlib.Path(system_info.runtime_information.scratch_dir)
- scratch_path.mkdir(parents=True,exist_ok=True)
-
+ scratch_path.mkdir(parents=True, exist_ok=True)
+
+
def create_solvent_filename(scratch_dir, temp_info, filestem):
"""Create solvent filename.
@@ -191,11 +220,14 @@ def create_solvent_filename(scratch_dir, temp_info, filestem):
filename path including scratch directory.
"""
- temp_string = create_temperaturestring(temp_info.temperature, temp_info.temperature_unit)
+ temp_string = create_temperaturestring(
+ temp_info.temperature, temp_info.temperature_unit
+ )
filename = filestem + "_" + temp_string + ".xml"
path = (pathlib.Path(scratch_dir) / filename).as_posix()
return path
+
def create_phase_filename(scratch_dir, filestem):
"""Create filename for phase XML.
@@ -216,6 +248,7 @@ def create_phase_filename(scratch_dir, filestem):
path = (pathlib.Path(scratch_dir) / filename).as_posix()
return path
+
def create_temperaturestring(temperature, temperature_unit):
"""Write temperature information in formatted string for use in filenames.
@@ -232,4 +265,4 @@ def create_temperaturestring(temperature, temperature_unit):
temperature string.
"""
- return "{:.1f}{}".format(temperature, "K" if temperature_unit == "KELVIN" else "C")
\ No newline at end of file
+ return "{:.1f}{}".format(temperature, "K" if temperature_unit == "KELVIN" else "C")
diff --git a/phasecalculator/runners/similarityanalysisrunner.py b/phasecalculator/runners/similarityanalysisrunner.py
index a257364..54adef2 100755
--- a/phasecalculator/runners/similarityanalysisrunner.py
+++ b/phasecalculator/runners/similarityanalysisrunner.py
@@ -31,7 +31,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-def run_similarity_analysis(poly_filename_list, output_type, output_dir, output_filename="similaritymatrix.csv"):
+
+def run_similarity_analysis(
+ poly_filename_list, output_type, output_dir, output_filename="similaritymatrix.csv"
+):
"""Run similarity analysis.
Parameters
@@ -52,14 +55,20 @@ def run_similarity_analysis(poly_filename_list, output_type, output_dir, output_
"""
if output_type == "all":
- simanalysis.compare_all_solvents(poly_filename_list, output_dir, output_filename)
+ simanalysis.compare_all_solvents(
+ poly_filename_list, output_dir, output_filename
+ )
elif output_type == "mixturecomparison":
- simanalysis.compare_solvent_list(poly_filename_list, output_dir, output_filename)
+ simanalysis.compare_solvent_list(
+ poly_filename_list, output_dir, output_filename
+ )
elif output_type == "purecomparison":
simanalysis.compare_with_pure_solvents(poly_filename_list, output_dir)
-def extract_all_solvents_and_generate_polynomials(solv_energy_dict_list, directory_base):
+def extract_all_solvents_and_generate_polynomials(
+ solv_energy_dict_list, directory_base
+):
"""Extract results for all solvents, and partition results based on temperature.
Parameters
@@ -80,13 +89,21 @@ def extract_all_solvents_and_generate_polynomials(solv_energy_dict_list, directo
combined_out_res = []
combined_filename_list = []
for solv_energy_dict in solv_energy_dict_list:
- directory = generate_directory(directory_base, solv_energy_dict["temperature_value"], solv_energy_dict["temperature_units"])
+ directory = generate_directory(
+ directory_base,
+ solv_energy_dict["temperature_value"],
+ solv_energy_dict["temperature_units"],
+ )
solvent_filename = solv_energy_dict["solvent_filename"]
energy_xml_filename = solv_energy_dict["energy_filename"]
- out_res, filename_list = extract_solvents_and_generate_polynomials(solvent_filename, energy_xml_filename, directory)
+ out_res, filename_list = extract_solvents_and_generate_polynomials(
+ solvent_filename, energy_xml_filename, directory
+ )
combined_out_res.extend(out_res)
combined_filename_list.extend(filename_list)
return combined_out_res, combined_filename_list
+
+
def generate_directory(directory_base, temperature, temperature_unit):
"""Generate directory to put information based on temperature of simulation.
@@ -109,12 +126,17 @@ def generate_directory(directory_base, temperature, temperature_unit):
"""
- temperature_name = "{:.1f}{}".format(temperature, "K" if temperature_unit == "KELVIN" else "C").replace(".","_")
+ temperature_name = "{:.1f}{}".format(
+ temperature, "K" if temperature_unit == "KELVIN" else "C"
+ ).replace(".", "_")
dir_path = pathlib.Path(directory_base) / temperature_name
- dir_path.mkdir(parents=True,exist_ok=True)
+ dir_path.mkdir(parents=True, exist_ok=True)
return dir_path.as_posix()
-def extract_solvents_and_generate_polynomials(solvent_filename, energy_xml_filename, directory):
+
+def extract_solvents_and_generate_polynomials(
+ solvent_filename, energy_xml_filename, directory
+):
"""Extract solvation free energies and calculate free energy polynomials per solvent.
Parameters
@@ -133,9 +155,12 @@ def extract_solvents_and_generate_polynomials(solvent_filename, energy_xml_filen
list of polynomial filenames.
"""
- energy_xml_filenames = solvextract.extract_and_write_energy_values_from_files(solvent_filename, energy_xml_filename, "free", directory)
+ energy_xml_filenames = solvextract.extract_and_write_energy_values_from_files(
+ solvent_filename, energy_xml_filename, "free", directory
+ )
return polyio.generate_polynomial_data_free_energy_file_list(energy_xml_filenames)
+
def run_free_energy_calculation(jar_path, output_filename, solvent_filename, **kwargs):
"""Run solute solvation free energy calculation.
@@ -168,4 +193,6 @@ def run_free_energy_calculation(jar_path, output_filename, solvent_filename, **k
result of system call.
"""
- return phaserun.run_phasetransfer_free_energy(jar_path, output_filename, solvent_filename, **kwargs)
\ No newline at end of file
+ return phaserun.run_phasetransfer_free_energy(
+ jar_path, output_filename, solvent_filename, **kwargs
+ )
diff --git a/phasecalculator/runners/vleanalysisrunner.py b/phasecalculator/runners/vleanalysisrunner.py
index 472576c..de7b32c 100755
--- a/phasecalculator/runners/vleanalysisrunner.py
+++ b/phasecalculator/runners/vleanalysisrunner.py
@@ -27,6 +27,7 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
def run_vle_calculation(jar_path, phase_filename, output_filename, **kwargs):
"""Run VLE phase calculation.
@@ -52,4 +53,6 @@ def run_vle_calculation(jar_path, phase_filename, output_filename, **kwargs):
result of system call.
"""
- return phaserun.run_vle_calculation(jar_path, phase_filename, output_filename, **kwargs)
\ No newline at end of file
+ return phaserun.run_vle_calculation(
+ jar_path, phase_filename, output_filename, **kwargs
+ )
diff --git a/phasecalculator/test/analysistest/fgipanalysistest.py b/phasecalculator/test/analysistest/fgipanalysistest.py
index 1f2ebea..cbef618 100755
--- a/phasecalculator/test/analysistest/fgipanalysistest.py
+++ b/phasecalculator/test/analysistest/fgipanalysistest.py
@@ -30,8 +30,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class FGIPAnalysisTestCase(unittest.TestCase):
"""Test case for FGIP analysis methods."""
+
def setUp(self):
"""Set up for tests.
@@ -42,9 +44,20 @@ class FGIPAnalysisTestCase(unittest.TestCase):
"""
self.parent_directory = pathlib.Path(__file__).parents[1]
self.solvent_filename = (
- (self.parent_directory / "resources/expected_solvent.xml").absolute().as_posix()
+ (self.parent_directory / "resources/expected_solvent.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.poly_file = (
+ (
+ self.parent_directory
+ / "resources"
+ / "testfiles"
+ / "1-butanol0.165water0.835binding_poly_fit_split.csv"
+ )
+ .absolute()
+ .as_posix()
)
- self.poly_file = (self.parent_directory / "resources"/ "testfiles" / "1-butanol0.165water0.835binding_poly_fit_split.csv").absolute().as_posix()
self.matrix_file = "1-butanol0.165water0.835_solv_map.csv"
self.solvent_map = "1-butanol0.165water0.835_solv_map.svg"
self.fgip_file = "1-butanol0_165water0_835_FGIP.svg"
@@ -56,6 +69,7 @@ class FGIPAnalysisTestCase(unittest.TestCase):
\label{fig:1-butanol0_165water0_835solvationmap}
\end{figure}
"""
+
def tearDown(self):
"""Clean up after tests.
@@ -70,6 +84,7 @@ class FGIPAnalysisTestCase(unittest.TestCase):
os.remove(self.solvent_map)
if pathlib.Path(self.fgip_file).is_file():
os.remove(self.fgip_file)
+
def test_create_solv_map_and_fgips_from_files(self):
"""Test solvent map, FGIP and matrix are produced.
@@ -78,12 +93,15 @@ class FGIPAnalysisTestCase(unittest.TestCase):
None.
"""
- results, latex_blocks = fgipanalysis.create_solv_map_and_fgips_from_files(self.solvent_filename, [self.poly_file], "")
- self.assertListEqual([(0,0)], results)
+ results, latex_blocks = fgipanalysis.create_solv_map_and_fgips_from_files(
+ self.solvent_filename, [self.poly_file], ""
+ )
+ self.assertListEqual([(0, 0)], results)
self.assertMultiLineEqual(self.expected_latex, latex_blocks)
self.assertTrue(pathlib.Path(self.matrix_file).is_file())
self.assertTrue(pathlib.Path(self.solvent_map).is_file())
self.assertTrue(pathlib.Path(self.fgip_file).is_file())
+
def test_create_fgips_from_file_list(self):
"""Test FGIPs are created.
@@ -92,10 +110,17 @@ class FGIPAnalysisTestCase(unittest.TestCase):
None.
"""
- plot_outputs, filenames = fgipanalysis.create_solvation_plots_from_poly_files(fgipanalysis.EPSILON_I_LIST, fgipanalysis.EPSILON_J_LIST, self.solvent_filename, [self.poly_file], 8)
+ plot_outputs, filenames = fgipanalysis.create_solvation_plots_from_poly_files(
+ fgipanalysis.EPSILON_I_LIST,
+ fgipanalysis.EPSILON_J_LIST,
+ self.solvent_filename,
+ [self.poly_file],
+ 8,
+ )
latex_blocks = fgipanalysis.create_fgips_from_file_list(filenames)
self.assertMultiLineEqual(self.expected_latex, latex_blocks)
self.assertTrue(pathlib.Path(self.fgip_file).is_file())
+
def test_create_solvation_plots_from_poly_files(self):
"""Test expected solvation map and matrix file are created.
@@ -104,11 +129,18 @@ class FGIPAnalysisTestCase(unittest.TestCase):
None.
"""
- plot_outputs, filenames = fgipanalysis.create_solvation_plots_from_poly_files(fgipanalysis.EPSILON_I_LIST, fgipanalysis.EPSILON_J_LIST, self.solvent_filename, [self.poly_file], 8)
- self.assertListEqual([(0,0)], plot_outputs)
+ plot_outputs, filenames = fgipanalysis.create_solvation_plots_from_poly_files(
+ fgipanalysis.EPSILON_I_LIST,
+ fgipanalysis.EPSILON_J_LIST,
+ self.solvent_filename,
+ [self.poly_file],
+ 8,
+ )
+ self.assertListEqual([(0, 0)], plot_outputs)
self.assertEqual(["1-butanol0.165water0.835_solv_map.svg"], filenames)
self.assertTrue(pathlib.Path(self.matrix_file).is_file())
self.assertTrue(pathlib.Path(self.solvent_map).is_file())
+
def test_get_solvent_id_from_poly_filename(self):
"""Test expected solvent ID is extracted.
@@ -117,7 +149,11 @@ class FGIPAnalysisTestCase(unittest.TestCase):
None.
"""
- self.assertEqual("1-butanol0.165water0.835", fgipanalysis.get_solvent_id_from_poly_filename(self.poly_file))
+ self.assertEqual(
+ "1-butanol0.165water0.835",
+ fgipanalysis.get_solvent_id_from_poly_filename(self.poly_file),
+ )
+
def test_create_solvation_plot(self):
"""Test solvent map and matrix created.
@@ -126,9 +162,15 @@ class FGIPAnalysisTestCase(unittest.TestCase):
None.
"""
- solv_plot, matrix_res = fgipanalysis.create_solvation_plot(fgipanalysis.EPSILON_I_LIST, fgipanalysis.EPSILON_J_LIST, self.solvent_filename, "1-butanol0.165water0.835", self.poly_file, 8)
+ solv_plot, matrix_res = fgipanalysis.create_solvation_plot(
+ fgipanalysis.EPSILON_I_LIST,
+ fgipanalysis.EPSILON_J_LIST,
+ self.solvent_filename,
+ "1-butanol0.165water0.835",
+ self.poly_file,
+ 8,
+ )
self.assertEqual(0, matrix_res)
self.assertEqual(0, solv_plot)
self.assertTrue(pathlib.Path(self.matrix_file).exists())
self.assertTrue(pathlib.Path(self.solvent_map).exists())
-
\ No newline at end of file
diff --git a/phasecalculator/test/analysistest/similarityanalysistest.py b/phasecalculator/test/analysistest/similarityanalysistest.py
index 3fad217..20998aa 100755
--- a/phasecalculator/test/analysistest/similarityanalysistest.py
+++ b/phasecalculator/test/analysistest/similarityanalysistest.py
@@ -33,6 +33,7 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class SimilarityAnalysisTestCase(unittest.TestCase):
"""Test case for similarity analysis."""
@@ -45,15 +46,29 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
"""
parent_directory = pathlib.Path(__file__).parents[1]
- self.expected_free_poly = (parent_directory /"resources" / "expected_parsedfreepoly.csv").absolute().as_posix()
- self.expected_matrix_file = (parent_directory/ "resources"/ "expectd_matrix.csv").absolute().as_posix()
- self.example_poly_data = simanalysis.read_polynomial_files([self.expected_free_poly], suffix="freepoly.csv",
- temperature_dir=True)
- self.example_with_pure_data = {**simanalysis.PURE_SOLVENT_INFO,
- **self.example_poly_data}
- self.example_matrix = simanalysis.calculate_similarity_matrix(self.example_with_pure_data)
+ self.expected_free_poly = (
+ (parent_directory / "resources" / "expected_parsedfreepoly.csv")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_matrix_file = (
+ (parent_directory / "resources" / "expectd_matrix.csv")
+ .absolute()
+ .as_posix()
+ )
+ self.example_poly_data = simanalysis.read_polynomial_files(
+ [self.expected_free_poly], suffix="freepoly.csv", temperature_dir=True
+ )
+ self.example_with_pure_data = {
+ **simanalysis.PURE_SOLVENT_INFO,
+ **self.example_poly_data,
+ }
+ self.example_matrix = simanalysis.calculate_similarity_matrix(
+ self.example_with_pure_data
+ )
self.actual_matrix_file = "actual_matrix.csv"
self.actual_series_file = "resourcesexpected_parsedfreepoly.csv.csv"
+
def tearDown(self):
"""Clean up after tests.
@@ -72,6 +87,7 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
os.remove(self.actual_series_file)
del self.actual_matrix_file
del self.actual_series_file
+
def test_read_polynomial_files(self):
"""Test expected information is read.
@@ -80,26 +96,61 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
None.
"""
- expected_dict = {'resourcesexpected,parsed':{8: {'negative': {'RMSE': 0.0137444779,
- 'coefficients': np.array([-2.60836624e-01, 4.65295250e-01, 2.57637417e-01, 2.19491128e-01,
- 4.20087475e-02, 4.02289353e-03, 2.12247938e-04, 5.89243946e-06,
- 6.73443996e-08]),
- 'covar': 0.0379710451935,
- 'order': 8},
- 'positive': {'RMSE': 0.008907316,
- 'coefficients': np.array([-2.52075337e-01, -7.07009850e-01, 9.86359325e-01, -1.40859321e+00,
- 5.04060101e-01, -9.17970326e-02, 9.28812463e-03, -4.97458825e-04,
- 1.10198937e-05]),
- 'covar': 0.008013368123414,
- 'order': 8}}}}
+ expected_dict = {
+ "resourcesexpected,parsed": {
+ 8: {
+ "negative": {
+ "RMSE": 0.0137444779,
+ "coefficients": np.array(
+ [
+ -2.60836624e-01,
+ 4.65295250e-01,
+ 2.57637417e-01,
+ 2.19491128e-01,
+ 4.20087475e-02,
+ 4.02289353e-03,
+ 2.12247938e-04,
+ 5.89243946e-06,
+ 6.73443996e-08,
+ ]
+ ),
+ "covar": 0.0379710451935,
+ "order": 8,
+ },
+ "positive": {
+ "RMSE": 0.008907316,
+ "coefficients": np.array(
+ [
+ -2.52075337e-01,
+ -7.07009850e-01,
+ 9.86359325e-01,
+ -1.40859321e00,
+ 5.04060101e-01,
+ -9.17970326e-02,
+ 9.28812463e-03,
+ -4.97458825e-04,
+ 1.10198937e-05,
+ ]
+ ),
+ "covar": 0.008013368123414,
+ "order": 8,
+ },
+ }
+ }
+ }
actual_dict = self.example_poly_data
self.assertListEqual(list(expected_dict.keys()), list(actual_dict.keys()))
- for region, info_dict in actual_dict['resourcesexpected,parsed'][8].items():
+ for region, info_dict in actual_dict["resourcesexpected,parsed"][8].items():
for key, value in info_dict.items():
if key == "coefficients":
- np.testing.assert_allclose(value, expected_dict['resourcesexpected,parsed'][8][region][key])
+ np.testing.assert_allclose(
+ value, expected_dict["resourcesexpected,parsed"][8][region][key]
+ )
else:
- self.assertEqual(value, expected_dict['resourcesexpected,parsed'][8][region][key])
+ self.assertEqual(
+ value, expected_dict["resourcesexpected,parsed"][8][region][key]
+ )
+
def test_compare_all_solvents(self):
"""Test complete matrix is produced.
@@ -108,10 +159,15 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
None.
"""
- simanalysis.compare_all_solvents([self.expected_free_poly], "", self.actual_matrix_file)
+ simanalysis.compare_all_solvents(
+ [self.expected_free_poly], "", self.actual_matrix_file
+ )
self.assertTrue(pathlib.Path(self.actual_matrix_file).is_file())
- actual_dataframe = pandas.read_csv(self.actual_matrix_file, sep="\t",header=0,index_col=0)
- self.assertEqual((262,262), actual_dataframe.shape)
+ actual_dataframe = pandas.read_csv(
+ self.actual_matrix_file, sep="\t", header=0, index_col=0
+ )
+ self.assertEqual((262, 262), actual_dataframe.shape)
+
def test_compare_with_pure_solvents(self):
"""Test column matrix is produced.
@@ -122,8 +178,11 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
"""
simanalysis.compare_with_pure_solvents([self.expected_free_poly], "")
self.assertTrue(pathlib.Path(self.actual_series_file).is_file())
- actual_dataframe = pandas.read_csv(self.actual_series_file, sep="\t",header=0,index_col=0)
- self.assertEqual((261,1), actual_dataframe.shape)
+ actual_dataframe = pandas.read_csv(
+ self.actual_series_file, sep="\t", header=0, index_col=0
+ )
+ self.assertEqual((261, 1), actual_dataframe.shape)
+
def test_compare_solvent_list(self):
"""Test expected matrix is produced.
@@ -132,10 +191,15 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
None.
"""
- simanalysis.compare_solvent_list([self.expected_free_poly], "", self.actual_matrix_file)
+ simanalysis.compare_solvent_list(
+ [self.expected_free_poly], "", self.actual_matrix_file
+ )
self.assertTrue(pathlib.Path(self.actual_matrix_file).is_file())
- actual_dataframe = pandas.read_csv(self.actual_matrix_file, sep="\t",header=0,index_col=0)
- self.assertEqual((1,1), actual_dataframe.shape)
+ actual_dataframe = pandas.read_csv(
+ self.actual_matrix_file, sep="\t", header=0, index_col=0
+ )
+ self.assertEqual((1, 1), actual_dataframe.shape)
+
def test_write_frame_to_file(self):
"""Test expected file is exists.
@@ -146,6 +210,7 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
"""
simanalysis.write_frame_to_file(self.example_matrix, self.actual_matrix_file)
self.assertTrue(pathlib.Path(self.actual_matrix_file).is_file())
+
def test_extract_comparison_to_pure_solvents(self):
"""Test expected comparisons are produced.
@@ -154,14 +219,24 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
None.
"""
- extracted_data = simanalysis.extract_comparison_to_pure_solvents(self.example_matrix, "resourcesexpected,parsed")
- expected_top5 = pandas.Series(data={"formamide":0.07340402,
-"hydrogen peroxide": 0.12358179,
-"methanesulfonic acid": 0.12495022,
-"ethylene glycol": 0.13908444,
-"1,2-butanediol": 0.14388483}, name="resourcesexpected,parsed")
+ extracted_data = simanalysis.extract_comparison_to_pure_solvents(
+ self.example_matrix, "resourcesexpected,parsed"
+ )
+ expected_top5 = pandas.Series(
+ data={
+ "formamide": 0.07340402,
+ "hydrogen peroxide": 0.12358179,
+ "methanesulfonic acid": 0.12495022,
+ "ethylene glycol": 0.13908444,
+ "1,2-butanediol": 0.14388483,
+ },
+ name="resourcesexpected,parsed",
+ )
np.testing.assert_allclose(expected_top5.values, extracted_data[:5].values)
- self.assertListEqual(expected_top5.index.to_list(), extracted_data[:5].index.to_list())
+ self.assertListEqual(
+ expected_top5.index.to_list(), extracted_data[:5].index.to_list()
+ )
+
def test_calculate_similarity_matrix(self):
"""Test expected dataframe produced.
@@ -171,5 +246,4 @@ class SimilarityAnalysisTestCase(unittest.TestCase):
"""
actual_dataframe = self.example_matrix
- self.assertEqual((262,262), actual_dataframe.shape)
-
\ No newline at end of file
+ self.assertEqual((262, 262), actual_dataframe.shape)
diff --git a/phasecalculator/test/classestest/moleculetest.py b/phasecalculator/test/classestest/moleculetest.py
index 10a71aa..e697313 100755
--- a/phasecalculator/test/classestest/moleculetest.py
+++ b/phasecalculator/test/classestest/moleculetest.py
@@ -29,8 +29,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class MoleculeTestCase(unittest.TestCase):
"""Test case for Molecule class."""
+
def setUp(self):
"""Set up before tests.
@@ -39,7 +41,13 @@ class MoleculeTestCase(unittest.TestCase):
None.
"""
- self.molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml", 1.0)
+ self.molecule = Molecule(
+ "water",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml",
+ 1.0,
+ )
+
def tearDown(self):
"""Clean up after tests.
@@ -49,6 +57,7 @@ class MoleculeTestCase(unittest.TestCase):
"""
del self.molecule
+
def test_parse_xml(self):
"""Test expected molecule object is created.
@@ -59,6 +68,7 @@ class MoleculeTestCase(unittest.TestCase):
"""
actual_molecule = Molecule.parse_xml(self.molecule.write_to_xml())
self.assertEqual(self.molecule, actual_molecule)
+
def test_write_to_xml(self):
"""Test expected XML is produced.
@@ -70,5 +80,6 @@ class MoleculeTestCase(unittest.TestCase):
expected_xml = """<phasecalc:Molecule xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema" phasecalc:name="water" phasecalc:inChIKey="XLYOFNOQVPJJNP-UHFFFAOYSA-N" phasecalc:ssipFileLocation="XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml" phasecalc:molefraction="1.0000"/>
"""
actual_xml = self.molecule.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
-
\ No newline at end of file
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
diff --git a/phasecalculator/test/classestest/outputinformationtest.py b/phasecalculator/test/classestest/outputinformationtest.py
index 7e93fcf..479181f 100755
--- a/phasecalculator/test/classestest/outputinformationtest.py
+++ b/phasecalculator/test/classestest/outputinformationtest.py
@@ -29,8 +29,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class OutputInformationTestCase(unittest.TestCase):
"""Test case for OutputInformation class."""
+
def setUp(self):
"""Set up for tests.
@@ -40,6 +42,7 @@ class OutputInformationTestCase(unittest.TestCase):
"""
self.out_inf = OutputInformation(True, True, "all", True)
+
def tearDown(self):
"""Clean up after tests.
@@ -49,6 +52,7 @@ class OutputInformationTestCase(unittest.TestCase):
"""
del self.out_inf
+
def test_parse_xml(self):
"""Test expected information is parsed.
@@ -59,6 +63,7 @@ class OutputInformationTestCase(unittest.TestCase):
"""
actual_output = OutputInformation.parse_xml(self.out_inf.write_to_xml())
self.assertEqual(self.out_inf, actual_output)
+
def test_parse_fgip_output(self):
"""Test expected information is parsed.
@@ -69,6 +74,7 @@ class OutputInformationTestCase(unittest.TestCase):
"""
actual_output = OutputInformation.parse_fgip_output(self.out_inf.write_to_xml())
self.assertTrue(actual_output)
+
def test_parse_similarity_output(self):
"""Test expected information is parsed.
@@ -77,9 +83,12 @@ class OutputInformationTestCase(unittest.TestCase):
None.
"""
- actual_output, actual_type = OutputInformation.parse_similarity_output(self.out_inf.write_to_xml())
+ actual_output, actual_type = OutputInformation.parse_similarity_output(
+ self.out_inf.write_to_xml()
+ )
self.assertTrue(actual_output)
self.assertEqual("all", actual_type)
+
def test_parse_vle_output(self):
"""Test expected information is parsed.
@@ -90,6 +99,7 @@ class OutputInformationTestCase(unittest.TestCase):
"""
actual_output = OutputInformation.parse_vle_output(self.out_inf.write_to_xml())
self.assertTrue(actual_output)
+
def test_write_to_xml(self):
"""Test expected XML produced.
@@ -105,7 +115,10 @@ class OutputInformationTestCase(unittest.TestCase):
</phasecalc:OutputInformation>
"""
actual_xml = self.out_inf.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_write_fgip_output(self):
"""Test expected XML produced.
@@ -117,7 +130,10 @@ class OutputInformationTestCase(unittest.TestCase):
expected_xml = """<phasecalc:FGIPOutput xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema">true</phasecalc:FGIPOutput>
"""
actual_xml = self.out_inf.write_fgip_output()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_write_similarity_output(self):
"""Test expected XML produced.
@@ -129,7 +145,10 @@ class OutputInformationTestCase(unittest.TestCase):
expected_xml = """<phasecalc:SimilarityOutput xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema" phasecalc:outputType="all">true</phasecalc:SimilarityOutput>
"""
actual_xml = self.out_inf.write_similarity_output()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_write_vle_output(self):
"""Test expected XML produced.
@@ -141,5 +160,6 @@ class OutputInformationTestCase(unittest.TestCase):
expected_xml = """<phasecalc:VLEOutput xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema">true</phasecalc:VLEOutput>
"""
actual_xml = self.out_inf.write_vle_output()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
-
\ No newline at end of file
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
diff --git a/phasecalculator/test/classestest/phasestest.py b/phasecalculator/test/classestest/phasestest.py
index 2a30e70..87f5162 100755
--- a/phasecalculator/test/classestest/phasestest.py
+++ b/phasecalculator/test/classestest/phasestest.py
@@ -32,8 +32,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class PhasesTestCase(unittest.TestCase):
"""Test case for Phases class."""
+
def setUp(self):
"""Set up before tests.
@@ -43,9 +45,15 @@ class PhasesTestCase(unittest.TestCase):
"""
self.temperature = Temperature(298.0, "KELVIN")
- self.molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml", 1.0)
+ self.molecule = Molecule(
+ "water",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml",
+ 1.0,
+ )
self.phase = Phase([self.molecule], self.temperature)
self.phases = Phases([self.phase])
+
def tearDown(self):
"""Clean up after tests.
@@ -58,6 +66,7 @@ class PhasesTestCase(unittest.TestCase):
del self.molecule
del self.temperature
del self.phases
+
def test_parse_xml(self):
"""Test expected phases object is created.
@@ -68,6 +77,7 @@ class PhasesTestCase(unittest.TestCase):
"""
actual_phases = Phases.parse_xml(self.phases.write_to_xml())
self.assertEqual(self.phases, actual_phases)
+
def test_write_to_xml(self):
"""Test expected XML is produced.
@@ -84,7 +94,10 @@ class PhasesTestCase(unittest.TestCase):
</phasecalc:Phases>
"""
actual_xml = self.phases.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_get_phase_compositions_by_temperature(self):
"""Test expected dictionary produced.
@@ -96,6 +109,7 @@ class PhasesTestCase(unittest.TestCase):
expected_dict = {self.temperature: [self.phase]}
actual_dict = self.phases.get_phase_compositions_by_temperature()
self.assertDictEqual(expected_dict, actual_dict)
+
def test_get_phase_molefractions_by_temperature(self):
"""Test expected dictionary produced.
@@ -104,9 +118,10 @@ class PhasesTestCase(unittest.TestCase):
None.
"""
- expected_dict = {self.temperature: [{"water":1.0}]}
+ expected_dict = {self.temperature: [{"water": 1.0}]}
actual_dict = self.phases.get_phase_molefractions_by_temperature()
self.assertDictEqual(expected_dict, actual_dict)
+
def test_get_molefractions_by_molecule_list(self):
"""Test expected list is produced.
@@ -115,9 +130,10 @@ class PhasesTestCase(unittest.TestCase):
None.
"""
- expected_list = [{"water":1.0}]
+ expected_list = [{"water": 1.0}]
actual_list = self.phases.get_molefractions_by_molecule_list()
self.assertListEqual(expected_list, actual_list)
+
def test_get_ssip_file_locations(self):
"""Test expected set of file locations is returned.
@@ -128,4 +144,4 @@ class PhasesTestCase(unittest.TestCase):
"""
expected_set = {self.molecule.ssip_file_loc}
actual_set = self.phases.get_ssip_file_locations()
- self.assertSetEqual(expected_set, actual_set)
\ No newline at end of file
+ self.assertSetEqual(expected_set, actual_set)
diff --git a/phasecalculator/test/classestest/phasetest.py b/phasecalculator/test/classestest/phasetest.py
index 3bd1764..50ca4c3 100755
--- a/phasecalculator/test/classestest/phasetest.py
+++ b/phasecalculator/test/classestest/phasetest.py
@@ -31,8 +31,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class PhaseTestCase(unittest.TestCase):
"""Test case for Phase class."""
+
def setUp(self):
"""Set up before tests.
@@ -42,8 +44,14 @@ class PhaseTestCase(unittest.TestCase):
"""
self.temperature = Temperature(298.0, "KELVIN")
- self.molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml", 1.0)
+ self.molecule = Molecule(
+ "water",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml",
+ 1.0,
+ )
self.phase = Phase([self.molecule], self.temperature)
+
def tearDown(self):
"""Clean up after tests.
@@ -55,6 +63,7 @@ class PhaseTestCase(unittest.TestCase):
del self.phase
del self.molecule
del self.temperature
+
def test_parse_xml(self):
"""Test expected phase object is created.
@@ -65,6 +74,7 @@ class PhaseTestCase(unittest.TestCase):
"""
actual_phase = Phase.parse_xml(self.phase.write_to_xml())
self.assertEqual(self.phase, actual_phase)
+
def test_parse_molecules(self):
"""Test expected molecule list is created.
@@ -75,6 +85,7 @@ class PhaseTestCase(unittest.TestCase):
"""
actual_mol_list = Phase.parse_molecules(self.phase.write_to_xml())
self.assertListEqual([self.molecule], actual_mol_list)
+
def test_parse_temperature(self):
"""Test expected temperature object is created.
@@ -85,6 +96,7 @@ class PhaseTestCase(unittest.TestCase):
"""
actual_temp = Phase.parse_temperature(self.temperature.write_to_xml())
self.assertEqual(self.temperature, actual_temp)
+
def test_write_to_xml(self):
"""Test expected XML is produced.
@@ -99,7 +111,10 @@ class PhaseTestCase(unittest.TestCase):
</phasecalc:Phase>
"""
actual_xml = self.phase.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_get_molefractions_by_molecule(self):
"""Test expected molefractions are returned.
@@ -108,9 +123,10 @@ class PhaseTestCase(unittest.TestCase):
None.
"""
- expected_dict = {"water":1.0}
+ expected_dict = {"water": 1.0}
actual_dict = self.phase.get_molefractions_by_molecule()
self.assertDictEqual(expected_dict, actual_dict)
+
def test_get_ssip_file_locations(self):
"""Test expected SSIP file locations are returned.
@@ -121,4 +137,4 @@ class PhaseTestCase(unittest.TestCase):
"""
expected_list = [self.molecule.ssip_file_loc]
actual_list = self.phase.get_ssip_file_locations()
- self.assertListEqual(expected_list, actual_list)
\ No newline at end of file
+ self.assertListEqual(expected_list, actual_list)
diff --git a/phasecalculator/test/classestest/runtimeinformationtest.py b/phasecalculator/test/classestest/runtimeinformationtest.py
index 06f2e86..de1ae91 100755
--- a/phasecalculator/test/classestest/runtimeinformationtest.py
+++ b/phasecalculator/test/classestest/runtimeinformationtest.py
@@ -30,8 +30,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class RuntimeInformationTestCase(unittest.TestCase):
"""Test case for methods."""
+
def setUp(self):
"""Set up for tests.
@@ -42,7 +44,7 @@ class RuntimeInformationTestCase(unittest.TestCase):
"""
self.example_jar = "resources/example.jar"
self.runtime_inf = RuntimeInformation(self.example_jar, "scratch", "fgip")
-
+
def tearDown(self):
"""Clean up after tests.
@@ -53,6 +55,7 @@ class RuntimeInformationTestCase(unittest.TestCase):
"""
del self.example_jar
del self.runtime_inf
+
def test_parse_xml(self):
"""Test expected runtime information found.
@@ -63,6 +66,7 @@ class RuntimeInformationTestCase(unittest.TestCase):
"""
actual_inf = RuntimeInformation.parse_xml(self.runtime_inf.write_to_xml())
self.assertEqual(self.runtime_inf, actual_inf)
+
def test_parse_phasetransfer_jar(self):
"""Test expected Jar is found.
@@ -71,8 +75,11 @@ class RuntimeInformationTestCase(unittest.TestCase):
None.
"""
- actual_jar = RuntimeInformation.parse_phasetransfer_jar(self.runtime_inf.write_to_xml())
+ actual_jar = RuntimeInformation.parse_phasetransfer_jar(
+ self.runtime_inf.write_to_xml()
+ )
self.assertEqual(self.example_jar, actual_jar)
+
def test_parse_scratch_dir(self):
"""Test expected scratch directory is found.
@@ -82,8 +89,11 @@ class RuntimeInformationTestCase(unittest.TestCase):
"""
expected_dir = "scratch"
- actual_dir = RuntimeInformation.parse_scratch_dir(self.runtime_inf.write_to_xml())
+ actual_dir = RuntimeInformation.parse_scratch_dir(
+ self.runtime_inf.write_to_xml()
+ )
self.assertEqual(expected_dir, actual_dir)
+
def test_parse_output_dir(self):
"""Test expected output directory is found.
@@ -93,8 +103,11 @@ class RuntimeInformationTestCase(unittest.TestCase):
"""
expected_dir = "fgip"
- actual_dir = RuntimeInformation.parse_output_dir(self.runtime_inf.write_to_xml())
+ actual_dir = RuntimeInformation.parse_output_dir(
+ self.runtime_inf.write_to_xml()
+ )
self.assertEqual(expected_dir, actual_dir)
+
def test_write_to_xml(self):
"""Test expected XML produced.
@@ -110,7 +123,10 @@ class RuntimeInformationTestCase(unittest.TestCase):
</phasecalc:RuntimeInformation>
"""
actual_xml = self.runtime_inf.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_write_phasetransfer_jar_xml(self):
"""Test expected XML produced.
@@ -122,7 +138,10 @@ class RuntimeInformationTestCase(unittest.TestCase):
expected_xml = """<phasecalc:PhaseTransferJar xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema">resources/example.jar</phasecalc:PhaseTransferJar>
"""
actual_xml = self.runtime_inf.write_phasetransfer_jar_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_write_scratch_dir_xml(self):
"""Test scratch directory XML is produced.
@@ -134,7 +153,10 @@ class RuntimeInformationTestCase(unittest.TestCase):
expected_xml = """<phasecalc:ScratchDirectory xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema">scratch</phasecalc:ScratchDirectory>
"""
actual_xml = self.runtime_inf.write_scratch_dir_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_write_output_dir_xml(self):
"""Test output directory XML is produced.
@@ -146,4 +168,6 @@ class RuntimeInformationTestCase(unittest.TestCase):
expected_xml = """<phasecalc:OutputDirectory xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema">fgip</phasecalc:OutputDirectory>
"""
actual_xml = self.runtime_inf.write_output_dir_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
\ No newline at end of file
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
diff --git a/phasecalculator/test/classestest/systemtest.py b/phasecalculator/test/classestest/systemtest.py
index afd44fe..3cdae10 100755
--- a/phasecalculator/test/classestest/systemtest.py
+++ b/phasecalculator/test/classestest/systemtest.py
@@ -35,6 +35,7 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class SystemTestCase(unittest.TestCase):
"""System and system collection tests."""
@@ -48,7 +49,12 @@ class SystemTestCase(unittest.TestCase):
"""
self.maxDiff = None
self.temperature = Temperature(298.0, "KELVIN")
- self.molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml", 1.0)
+ self.molecule = Molecule(
+ "water",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml",
+ 1.0,
+ )
self.phase = Phase([self.molecule], self.temperature)
self.phases = Phases([self.phase])
self.example_jar = "resources/example.jar"
@@ -56,6 +62,7 @@ class SystemTestCase(unittest.TestCase):
self.out_inf = OutputInformation(True, True, "all", True)
self.system = System(self.phases, self.runtime_inf, self.out_inf)
self.system_collection = SystemCollection([self.system])
+
def tearDown(self):
"""Clean up after tests.
@@ -72,6 +79,7 @@ class SystemTestCase(unittest.TestCase):
del self.out_inf
del self.system
del self.system_collection
+
def test_coll_parse_xml(self):
"""Test expected system object is produced.
@@ -80,8 +88,11 @@ class SystemTestCase(unittest.TestCase):
None.
"""
- actual_collection = SystemCollection.parse_xml(self.system_collection.write_to_xml())
+ actual_collection = SystemCollection.parse_xml(
+ self.system_collection.write_to_xml()
+ )
self.assertEqual(self.system_collection, actual_collection)
+
def test_coll_write_to_xml(self):
"""Test expected XML is produced.
@@ -112,7 +123,10 @@ class SystemTestCase(unittest.TestCase):
</phasecalc:SystemCollection>
"""
actual_xml = self.system_collection.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_sys_parse_xml(self):
"""Test expected system object is produced.
@@ -123,6 +137,7 @@ class SystemTestCase(unittest.TestCase):
"""
actual_system = System.parse_xml(self.system.write_to_xml())
self.assertEqual(self.system, actual_system)
+
def test_sys_write_to_xml(self):
"""Test expected XML is produced.
@@ -151,7 +166,10 @@ class SystemTestCase(unittest.TestCase):
</phasecalc:System>
"""
actual_xml = self.system.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_sys_get_phase_compositions_by_temperature(self):
"""Test expected dictionary produced.
@@ -160,9 +178,10 @@ class SystemTestCase(unittest.TestCase):
None.
"""
- expected_dict = {self.temperature: [{"water":1.0}]}
+ expected_dict = {self.temperature: [{"water": 1.0}]}
actual_dict = self.system.get_phase_compositions_by_temperature()
self.assertDictEqual(expected_dict, actual_dict)
+
def test_get_phases_by_temp_list(self):
"""Test expected list produced.
@@ -171,10 +190,15 @@ class SystemTestCase(unittest.TestCase):
None.
"""
- expected_list = [[[{'temperature_units': 'KELVIN', 'temperature_value': 298.0}],
- [{"water":1.0}]]]
+ expected_list = [
+ [
+ [{"temperature_units": "KELVIN", "temperature_value": 298.0}],
+ [{"water": 1.0}],
+ ]
+ ]
actual_list = self.system.get_phases_by_temp_list()
self.assertListEqual(expected_list, actual_list)
+
def test_get_molefractions_by_molecule_list(self):
"""Test
@@ -183,9 +207,10 @@ class SystemTestCase(unittest.TestCase):
None.
"""
- expected_list = [{"water":1.0}]
+ expected_list = [{"water": 1.0}]
actual_list = self.system.get_molefractions_by_molecule_list()
self.assertListEqual(expected_list, actual_list)
+
def test_sys_get_ssip_file_locations(self):
"""Test expected set of file locations is returned.
@@ -197,6 +222,7 @@ class SystemTestCase(unittest.TestCase):
expected_set = {self.molecule.ssip_file_loc}
actual_set = self.system.get_ssip_file_locations()
self.assertSetEqual(expected_set, actual_set)
+
def test_calc_fgip(self):
"""Test expected bool returned.
@@ -206,6 +232,7 @@ class SystemTestCase(unittest.TestCase):
"""
self.assertTrue(self.system.calc_fgip())
+
def test_similarity(self):
"""Test expected bool returned.
@@ -215,6 +242,7 @@ class SystemTestCase(unittest.TestCase):
"""
self.assertTrue(self.system.calc_similarity())
+
def test_vle(self):
"""Test expected bool returned.
@@ -223,4 +251,4 @@ class SystemTestCase(unittest.TestCase):
None.
"""
- self.assertTrue(self.system.calc_vle())
\ No newline at end of file
+ self.assertTrue(self.system.calc_vle())
diff --git a/phasecalculator/test/classestest/temperaturetest.py b/phasecalculator/test/classestest/temperaturetest.py
index 47e882b..f8c802d 100755
--- a/phasecalculator/test/classestest/temperaturetest.py
+++ b/phasecalculator/test/classestest/temperaturetest.py
@@ -29,8 +29,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class TemperatureTestCase(unittest.TestCase):
"""Temperature class test case."""
+
def setUp(self):
"""Set up before tests.
@@ -40,6 +42,7 @@ class TemperatureTestCase(unittest.TestCase):
"""
self.temperature = Temperature(298.0, "KELVIN")
+
def tearDown(self):
"""Clean up after tests.
@@ -49,6 +52,7 @@ class TemperatureTestCase(unittest.TestCase):
"""
del self.temperature
+
def test_parse_xml(self):
"""Test expected temperature object is created.
@@ -59,6 +63,7 @@ class TemperatureTestCase(unittest.TestCase):
"""
actual_temp = Temperature.parse_xml(self.temperature.write_to_xml())
self.assertEqual(self.temperature, actual_temp)
+
def test_write_to_xml(self):
"""Test expected XML is produced.
@@ -70,7 +75,10 @@ class TemperatureTestCase(unittest.TestCase):
expected_xml = """<phasecalc:Temperature xmlns:phasecalc="http://www-hunter.ch.cam.ac.uk/PhaseCalculatorSchema" phasecalc:value="298.0" phasecalc:unit="KELVIN"/>
"""
actual_xml = self.temperature.write_to_xml()
- self.assertMultiLineEqual(expected_xml, etree.tounicode(actual_xml, pretty_print=True))
+ self.assertMultiLineEqual(
+ expected_xml, etree.tounicode(actual_xml, pretty_print=True)
+ )
+
def test_to_dict(self):
"""Test expected dict is returned.
@@ -79,7 +87,6 @@ class TemperatureTestCase(unittest.TestCase):
None.
"""
- expected_dict = {"temperature_value":298.0,
- "temperature_units":"KELVIN"}
+ expected_dict = {"temperature_value": 298.0, "temperature_units": "KELVIN"}
actual_dict = self.temperature.to_dict()
- self.assertDictEqual(expected_dict, actual_dict)
\ No newline at end of file
+ self.assertDictEqual(expected_dict, actual_dict)
diff --git a/phasecalculator/test/iotest/phasecsvconvertertest.py b/phasecalculator/test/iotest/phasecsvconvertertest.py
index b20ae45..faffc1b 100755
--- a/phasecalculator/test/iotest/phasecsvconvertertest.py
+++ b/phasecalculator/test/iotest/phasecsvconvertertest.py
@@ -33,8 +33,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class PhaseCSVConverterTestCase(unittest.TestCase):
"""Test case for phasecsvconverter methods."""
+
def setUp(self):
"""Set up for tests.
@@ -44,12 +46,20 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
"""
parent_directory = pathlib.Path(__file__).parents[1]
- self.example_csv = (parent_directory / "resources/examplephasecomp.csv").absolute().as_posix()
+ self.example_csv = (
+ (parent_directory / "resources/examplephasecomp.csv").absolute().as_posix()
+ )
self.csv_file_contents = phasecsv.read_csv_file(self.example_csv)
self.temperature = Temperature(298.0, "KELVIN")
- self.molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", phasecsv.INCHIKEY_SSIP_FILE_DICT["XLYOFNOQVPJJNP-UHFFFAOYSA-N"], 1.0)
+ self.molecule = Molecule(
+ "water",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N",
+ phasecsv.INCHIKEY_SSIP_FILE_DICT["XLYOFNOQVPJJNP-UHFFFAOYSA-N"],
+ 1.0,
+ )
self.phase = Phase([self.molecule], self.temperature)
self.phases = Phases([self.phase])
+
def tearDown(self):
"""Clean up after tests.
@@ -58,6 +68,7 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
None.
"""
+
def test_convert_csv_file_to_phases(self):
"""Test
@@ -68,6 +79,7 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
"""
actual_phases = phasecsv.convert_csv_file_to_phases(self.example_csv)
self.assertEqual(self.phases, actual_phases)
+
def test_read_csv_file(self):
"""Test
@@ -76,8 +88,9 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
None.
"""
- expected_list = [["298.0","water","1.0"]]
+ expected_list = [["298.0", "water", "1.0"]]
self.assertListEqual(expected_list, self.csv_file_contents)
+
def test_create_phases(self):
"""Test
@@ -88,6 +101,7 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
"""
actual_phases = phasecsv.create_phases(self.csv_file_contents)
self.assertEqual(self.phases, actual_phases)
+
def test_create_phase(self):
"""Test
@@ -96,8 +110,9 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
None.
"""
- actual_phase = phasecsv.create_phase(["298.0","water","1.0"])
+ actual_phase = phasecsv.create_phase(["298.0", "water", "1.0"])
self.assertEqual(self.phase, actual_phase)
+
def test_create_molecule(self):
"""Test
@@ -108,6 +123,7 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
"""
actual_molecule = phasecsv.create_molecule("water", 1.0)
self.assertEqual(self.molecule, actual_molecule)
+
def test_create_temperature(self):
"""Test
@@ -117,4 +133,4 @@ class PhaseCSVConverterTestCase(unittest.TestCase):
"""
actual_temperature = phasecsv.create_temperature(298.0)
- self.assertEqual(self.temperature, actual_temperature)
\ No newline at end of file
+ self.assertEqual(self.temperature, actual_temperature)
diff --git a/phasecalculator/test/iotest/phasetransferxmlcreatortest.py b/phasecalculator/test/iotest/phasetransferxmlcreatortest.py
index 6044178..aaa9a14 100755
--- a/phasecalculator/test/iotest/phasetransferxmlcreatortest.py
+++ b/phasecalculator/test/iotest/phasetransferxmlcreatortest.py
@@ -31,8 +31,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class PhasetransferXMLCreatorTestCase(unittest.TestCase):
"""Test case for phase transfer XML creator methods."""
+
def setUp(self):
"""Set up for tests.
@@ -142,23 +144,42 @@ class PhasetransferXMLCreatorTestCase(unittest.TestCase):
<ssip:SSIP ssip:value="-5.365217010700665" ssip:nearestAtomID="a5" cml:x3="-5.353424285394745" cml:y3="-1.7849561367024218" cml:z3="0.11271581239149799"/>
</ssip:SSIPs>
</ssip:SSIPMolecule>"""
- self.mol_info_list = [{"concentration_value":10.8702104695089,
- "inchikey":"LRHPLDYGYMQRHN-UHFFFAOYSA-N",
- "mole_fraction":0.16452830188679246,
- "ssip_molecule":self.expected_butanol_xml},
- {"concentration_value":55.3496115427303,
- "inchikey":"XLYOFNOQVPJJNP-UHFFFAOYSA-N",
- "mole_fraction":0.8354716981132075,
- "ssip_molecule":self.expected_water_xml,},
- ]
- self.mole_fraction_dict_list = [{"water":0.8354716981132075,
- "1-butanol":0.16452830188679246}]
- self.solvent_info_list = phasexmlmaker.generate_solv_info_list(self.mole_fraction_dict_list)
- self.expected_phase_file = (parent_directory /"resources" / "expected_phase.xml").absolute().as_posix()
- self.expected_solvent_file = (parent_directory /"resources" / "expected_solvent.xml").absolute().as_posix()
- self.temperature_info = [{"temperature_value": 298.0, "temperature_units": "KELVIN"}]
+ self.mol_info_list = [
+ {
+ "concentration_value": 10.8702104695089,
+ "inchikey": "LRHPLDYGYMQRHN-UHFFFAOYSA-N",
+ "mole_fraction": 0.16452830188679246,
+ "ssip_molecule": self.expected_butanol_xml,
+ },
+ {
+ "concentration_value": 55.3496115427303,
+ "inchikey": "XLYOFNOQVPJJNP-UHFFFAOYSA-N",
+ "mole_fraction": 0.8354716981132075,
+ "ssip_molecule": self.expected_water_xml,
+ },
+ ]
+ self.mole_fraction_dict_list = [
+ {"water": 0.8354716981132075, "1-butanol": 0.16452830188679246}
+ ]
+ self.solvent_info_list = phasexmlmaker.generate_solv_info_list(
+ self.mole_fraction_dict_list
+ )
+ self.expected_phase_file = (
+ (parent_directory / "resources" / "expected_phase.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_solvent_file = (
+ (parent_directory / "resources" / "expected_solvent.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.temperature_info = [
+ {"temperature_value": 298.0, "temperature_units": "KELVIN"}
+ ]
self.phase_filename = "actual_phase.xml"
self.solvent_filename = "actual_solvent.xml"
+
def tearDown(self):
"""Clean up after tests.
@@ -171,6 +192,7 @@ class PhasetransferXMLCreatorTestCase(unittest.TestCase):
os.remove(self.phase_filename)
if os.path.isfile(self.solvent_filename):
os.remove(self.solvent_filename)
+
def test_create_solvent_file(self):
"""Test expected file produced.
@@ -179,12 +201,15 @@ class PhasetransferXMLCreatorTestCase(unittest.TestCase):
None.
"""
- phasexmlmaker.create_solvent_file(self.mole_fraction_dict_list, self.solvent_filename)
+ phasexmlmaker.create_solvent_file(
+ self.mole_fraction_dict_list, self.solvent_filename
+ )
with open(self.solvent_filename, "r") as act_file:
actual_contents = act_file.read()
with open(self.expected_solvent_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_create_phase_file(self):
"""Test expected file produced.
@@ -193,12 +218,15 @@ class PhasetransferXMLCreatorTestCase(unittest.TestCase):
None.
"""
- phasexmlmaker.create_phase_file([[self.temperature_info, self.mole_fraction_dict_list]], self.phase_filename)
+ phasexmlmaker.create_phase_file(
+ [[self.temperature_info, self.mole_fraction_dict_list]], self.phase_filename
+ )
with open(self.phase_filename, "r") as act_file:
actual_contents = act_file.read()
with open(self.expected_phase_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_write_solvent_file(self):
"""Test expected file produced.
@@ -213,6 +241,7 @@ class PhasetransferXMLCreatorTestCase(unittest.TestCase):
with open(self.expected_solvent_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_write_phase_file(self):
"""Test expected file produced.
@@ -221,12 +250,15 @@ class PhasetransferXMLCreatorTestCase(unittest.TestCase):
None.
"""
- phasexmlmaker.write_phase_file([[self.temperature_info, self.solvent_info_list]], self.phase_filename)
+ phasexmlmaker.write_phase_file(
+ [[self.temperature_info, self.solvent_info_list]], self.phase_filename
+ )
with open(self.phase_filename, "r") as act_file:
actual_contents = act_file.read()
with open(self.expected_phase_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_generate_solv_info_list(self):
"""Test expected list produced.
@@ -255,9 +287,14 @@ class PhasetransferXMLCreatorTestCase(unittest.TestCase):
self.assertEqual(
expected_dict["inchikey"], information_dict["inchikey"]
)
- self.assertAlmostEqual(expected_dict["concentration_value"], information_dict["concentration_value"])
- self.assertAlmostEqual(expected_dict["mole_fraction"], information_dict["mole_fraction"])
+ self.assertAlmostEqual(
+ expected_dict["concentration_value"],
+ information_dict["concentration_value"],
+ )
+ self.assertAlmostEqual(
+ expected_dict["mole_fraction"], information_dict["mole_fraction"]
+ )
self.assertMultiLineEqual(
expected_dict["ssip_molecule"],
etree.tounicode(information_dict["ssip_molecule"]),
- )
\ No newline at end of file
+ )
diff --git a/phasecalculator/test/iotest/polynomialiotest.py b/phasecalculator/test/iotest/polynomialiotest.py
index b51a143..1b3febd 100755
--- a/phasecalculator/test/iotest/polynomialiotest.py
+++ b/phasecalculator/test/iotest/polynomialiotest.py
@@ -34,8 +34,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class PolynomialIOTestCase(unittest.TestCase):
"""Test case for polynomialio methods."""
+
def setUp(self):
"""Set up for tests.
@@ -46,12 +48,37 @@ class PolynomialIOTestCase(unittest.TestCase):
"""
self.maxDiff = None
parent_directory = pathlib.Path(__file__).parents[1]
- self.binding_file = (parent_directory / "resources"/ "expected_parsedbinding.xml").absolute().as_posix()
- self.expected_binding_poly = (parent_directory / "resources"/ "expected_bindingpoly.csv").absolute().as_posix()
- self.actual_binding_poly_file = (parent_directory / "resources/expected_parsedbinding_poly_fit_split.csv").absolute().as_posix()
- self.actual_free_poly_file = (parent_directory /"resources" / "expected_parsedfree_poly_fit_split.csv").absolute().as_posix()
- self.free_file = (parent_directory /"resources" / "expected_parsedfree.xml").absolute().as_posix()
- self.expected_free_poly = (parent_directory /"resources" / "expected_parsedfreepoly.csv").absolute().as_posix()
+ self.binding_file = (
+ (parent_directory / "resources" / "expected_parsedbinding.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_binding_poly = (
+ (parent_directory / "resources" / "expected_bindingpoly.csv")
+ .absolute()
+ .as_posix()
+ )
+ self.actual_binding_poly_file = (
+ (parent_directory / "resources/expected_parsedbinding_poly_fit_split.csv")
+ .absolute()
+ .as_posix()
+ )
+ self.actual_free_poly_file = (
+ (parent_directory / "resources" / "expected_parsedfree_poly_fit_split.csv")
+ .absolute()
+ .as_posix()
+ )
+ self.free_file = (
+ (parent_directory / "resources" / "expected_parsedfree.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_free_poly = (
+ (parent_directory / "resources" / "expected_parsedfreepoly.csv")
+ .absolute()
+ .as_posix()
+ )
+
def tearDown(self):
"""Clean up after tests.
@@ -64,6 +91,7 @@ class PolynomialIOTestCase(unittest.TestCase):
os.remove(self.actual_binding_poly_file)
if os.path.isfile(self.actual_free_poly_file):
os.remove(self.actual_free_poly_file)
+
def test_read_poly_data_to_dict(self):
"""Test expected_polynomial information read in.
@@ -72,27 +100,63 @@ class PolynomialIOTestCase(unittest.TestCase):
None.
"""
- expected_dict = {'resourcesexpected,parsed':{8: {'negative': {'RMSE': 0.0137444779,
- 'coefficients': np.array([-2.60836624e-01, 4.65295250e-01, 2.57637417e-01, 2.19491128e-01,
- 4.20087475e-02, 4.02289353e-03, 2.12247938e-04, 5.89243946e-06,
- 6.73443996e-08]),
- 'covar': 0.0379710451935,
- 'order': 8},
- 'positive': {'RMSE': 0.008907316,
- 'coefficients': np.array([-2.52075337e-01, -7.07009850e-01, 9.86359325e-01, -1.40859321e+00,
- 5.04060101e-01, -9.17970326e-02, 9.28812463e-03, -4.97458825e-04,
- 1.10198937e-05]),
- 'covar': 0.008013368123414,
- 'order': 8}}}}
- actual_dict = polyio.read_poly_data_to_dict([self.expected_free_poly], suffix="freepoly.csv",
- temperature_dir=True)
+ expected_dict = {
+ "resourcesexpected,parsed": {
+ 8: {
+ "negative": {
+ "RMSE": 0.0137444779,
+ "coefficients": np.array(
+ [
+ -2.60836624e-01,
+ 4.65295250e-01,
+ 2.57637417e-01,
+ 2.19491128e-01,
+ 4.20087475e-02,
+ 4.02289353e-03,
+ 2.12247938e-04,
+ 5.89243946e-06,
+ 6.73443996e-08,
+ ]
+ ),
+ "covar": 0.0379710451935,
+ "order": 8,
+ },
+ "positive": {
+ "RMSE": 0.008907316,
+ "coefficients": np.array(
+ [
+ -2.52075337e-01,
+ -7.07009850e-01,
+ 9.86359325e-01,
+ -1.40859321e00,
+ 5.04060101e-01,
+ -9.17970326e-02,
+ 9.28812463e-03,
+ -4.97458825e-04,
+ 1.10198937e-05,
+ ]
+ ),
+ "covar": 0.008013368123414,
+ "order": 8,
+ },
+ }
+ }
+ }
+ actual_dict = polyio.read_poly_data_to_dict(
+ [self.expected_free_poly], suffix="freepoly.csv", temperature_dir=True
+ )
self.assertListEqual(list(expected_dict.keys()), list(actual_dict.keys()))
- for region, info_dict in actual_dict['resourcesexpected,parsed'][8].items():
+ for region, info_dict in actual_dict["resourcesexpected,parsed"][8].items():
for key, value in info_dict.items():
if key == "coefficients":
- np.testing.assert_allclose(value, expected_dict['resourcesexpected,parsed'][8][region][key])
+ np.testing.assert_allclose(
+ value, expected_dict["resourcesexpected,parsed"][8][region][key]
+ )
else:
- self.assertEqual(value, expected_dict['resourcesexpected,parsed'][8][region][key])
+ self.assertEqual(
+ value, expected_dict["resourcesexpected,parsed"][8][region][key]
+ )
+
def test_generate_polynomial_data_free_energy_file_list(self):
"""Test expected polynomial data outputed.
@@ -101,7 +165,9 @@ class PolynomialIOTestCase(unittest.TestCase):
None.
"""
- results, filenames = polyio.generate_polynomial_data_free_energy_file_list([self.free_file])
+ results, filenames = polyio.generate_polynomial_data_free_energy_file_list(
+ [self.free_file]
+ )
self.assertListEqual([0], results)
exp_file = pandas.read_csv(
self.expected_free_poly,
@@ -110,7 +176,10 @@ class PolynomialIOTestCase(unittest.TestCase):
names=list(range(0, 9)),
)
act_file = pandas.read_csv(
- self.actual_free_poly_file, sep="\t", quoting=csv.QUOTE_NONE, names=list(range(0, 9))
+ self.actual_free_poly_file,
+ sep="\t",
+ quoting=csv.QUOTE_NONE,
+ names=list(range(0, 9)),
)
self.assertTrue(exp_file.columns.equals(act_file.columns))
self.assertTrue(exp_file.loc[0].equals(act_file.loc[0]))
@@ -120,6 +189,7 @@ class PolynomialIOTestCase(unittest.TestCase):
exp_file.loc[i, 2:].values.astype(float),
act_file.loc[i, 2:].values.astype(float),
)
+
def test_generate_polynomial_data_binding_energy_file_list(self):
"""Test expected polynomial data outputed.
@@ -128,7 +198,9 @@ class PolynomialIOTestCase(unittest.TestCase):
None.
"""
- results, filenames = polyio.generate_polynomial_data_binding_energy_file_list([self.binding_file])
+ results, filenames = polyio.generate_polynomial_data_binding_energy_file_list(
+ [self.binding_file]
+ )
self.assertListEqual([0], results)
exp_file = pandas.read_csv(
self.expected_binding_poly,
@@ -137,7 +209,10 @@ class PolynomialIOTestCase(unittest.TestCase):
names=list(range(0, 9)),
)
act_file = pandas.read_csv(
- self.actual_binding_poly_file, sep="\t", quoting=csv.QUOTE_NONE, names=list(range(0, 9))
+ self.actual_binding_poly_file,
+ sep="\t",
+ quoting=csv.QUOTE_NONE,
+ names=list(range(0, 9)),
)
self.assertTrue(exp_file.columns.equals(act_file.columns))
self.assertTrue(exp_file.loc[0].equals(act_file.loc[0]))
@@ -147,6 +222,7 @@ class PolynomialIOTestCase(unittest.TestCase):
exp_file.loc[i, 2:].values.astype(float),
act_file.loc[i, 2:].values.astype(float),
)
+
def test_generate_polynomial_filename(self):
"""Test expected filename is produced.
@@ -156,4 +232,4 @@ class PolynomialIOTestCase(unittest.TestCase):
"""
actual_filename = polyio.generate_polynomial_filename("freefile.xml")
- self.assertEqual("freefile_poly_fit.csv", actual_filename)
\ No newline at end of file
+ self.assertEqual("freefile_poly_fit.csv", actual_filename)
diff --git a/phasecalculator/test/iotest/solventextractortest.py b/phasecalculator/test/iotest/solventextractortest.py
index a1d34df..4846972 100755
--- a/phasecalculator/test/iotest/solventextractortest.py
+++ b/phasecalculator/test/iotest/solventextractortest.py
@@ -31,8 +31,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class SolventExtractorTestCase(unittest.TestCase):
"""Test case for solvent extractor methods."""
+
def setUp(self):
"""Set up for tests.
@@ -44,15 +46,20 @@ class SolventExtractorTestCase(unittest.TestCase):
self.maxDiff = None
parent_directory = pathlib.Path(__file__).parents[1]
self.binding_energy_filename = (
- (parent_directory / "resources/expected_bindingenergy.xml").absolute().as_posix()
+ (parent_directory / "resources/expected_bindingenergy.xml")
+ .absolute()
+ .as_posix()
)
self.expected_output_filename = (
- (parent_directory / "resources/expected_parsedbinding.xml").absolute().as_posix()
- )
+ (parent_directory / "resources/expected_parsedbinding.xml")
+ .absolute()
+ .as_posix()
+ )
self.output_filename = "1-butanol0.165water0.835binding.xml"
self.solvent_filename = (
(parent_directory / "resources/expected_solvent.xml").absolute().as_posix()
)
+
def tearDown(self):
"""Clean up after tests.
@@ -64,7 +71,7 @@ class SolventExtractorTestCase(unittest.TestCase):
if os.path.isfile(self.output_filename):
os.remove(self.output_filename)
del self.output_filename
-
+
def test_extract_and_write_energy_values_from_file(self):
"""Test extraction and writing of individual solvent energy values file.
@@ -73,10 +80,12 @@ class SolventExtractorTestCase(unittest.TestCase):
None.
"""
- filenames = solvextract.extract_and_write_energy_values_from_files(self.solvent_filename, self.binding_energy_filename, "binding", "")
+ filenames = solvextract.extract_and_write_energy_values_from_files(
+ self.solvent_filename, self.binding_energy_filename, "binding", ""
+ )
self.assertListEqual([self.output_filename], filenames)
with open(self.output_filename, "r") as actual_file:
actual_xml = actual_file.read()
with open(self.expected_output_filename) as expected_file:
expected_xml = expected_file.read()
- self.assertMultiLineEqual(expected_xml, actual_xml)
\ No newline at end of file
+ self.assertMultiLineEqual(expected_xml, actual_xml)
diff --git a/phasecalculator/test/iotest/systemcollectionprocessortest.py b/phasecalculator/test/iotest/systemcollectionprocessortest.py
index 378e368..4ebbe5e 100755
--- a/phasecalculator/test/iotest/systemcollectionprocessortest.py
+++ b/phasecalculator/test/iotest/systemcollectionprocessortest.py
@@ -38,8 +38,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class SystemCollectionProcessorTestCase(unittest.TestCase):
"""Test case for System Collection Processor methods."""
+
def setUp(self):
"""Set up before tests.
@@ -50,7 +52,12 @@ class SystemCollectionProcessorTestCase(unittest.TestCase):
"""
self.maxDiff = None
self.temperature = Temperature(298.0, "KELVIN")
- self.molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml", 1.0)
+ self.molecule = Molecule(
+ "water",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N",
+ "XLYOFNOQVPJJNP-UHFFFAOYSA-N_ssip.xml",
+ 1.0,
+ )
self.phase = Phase([self.molecule], self.temperature)
self.phases = Phases([self.phase])
self.example_jar = "resources/example.jar"
@@ -60,6 +67,7 @@ class SystemCollectionProcessorTestCase(unittest.TestCase):
self.system_collection = SystemCollection([self.system])
self.xml_filename = "syscollection.xml"
sysproc.write_system_collection_file(self.system_collection, self.xml_filename)
+
def tearDown(self):
"""Clean up after tests.
@@ -79,6 +87,7 @@ class SystemCollectionProcessorTestCase(unittest.TestCase):
if os.path.isfile(self.xml_filename):
os.remove(self.xml_filename)
del self.xml_filename
+
def test_read_system_collection_file(self):
"""Test expected collection is read in
@@ -89,6 +98,7 @@ class SystemCollectionProcessorTestCase(unittest.TestCase):
"""
actual_sys_collection = sysproc.read_system_collection_file(self.xml_filename)
self.assertEqual(self.system_collection, actual_sys_collection)
+
def test_write_system_collection_file(self):
"""Test file contents produced as expected.
@@ -122,4 +132,3 @@ class SystemCollectionProcessorTestCase(unittest.TestCase):
with open(self.xml_filename, "r") as actual_file:
actual_contents = actual_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
-
diff --git a/phasecalculator/test/phasecalculatortests.py b/phasecalculator/test/phasecalculatortests.py
index b1fae6c..f4bc491 100755
--- a/phasecalculator/test/phasecalculatortests.py
+++ b/phasecalculator/test/phasecalculatortests.py
@@ -25,17 +25,29 @@ This can also be used to run tests on the installed instance of the library.
import logging
import unittest
import sys
-from phasecalculator.test.iotest.phasetransferxmlcreatortest import PhasetransferXMLCreatorTestCase
+from phasecalculator.test.iotest.phasetransferxmlcreatortest import (
+ PhasetransferXMLCreatorTestCase,
+)
from phasecalculator.test.iotest.solventextractortest import SolventExtractorTestCase
-from phasecalculator.test.runnerstest.phasetransferrunnertest import PhasetransferRunnerTestCase
-from phasecalculator.test.runnerstest.fgipanalysisrunnertest import FGIPAnalysisRunnerTestCase
-from phasecalculator.test.runnerstest.vleanalysisrunnertest import VLEAnalysisRunnerTestCase
+from phasecalculator.test.runnerstest.phasetransferrunnertest import (
+ PhasetransferRunnerTestCase,
+)
+from phasecalculator.test.runnerstest.fgipanalysisrunnertest import (
+ FGIPAnalysisRunnerTestCase,
+)
+from phasecalculator.test.runnerstest.vleanalysisrunnertest import (
+ VLEAnalysisRunnerTestCase,
+)
from phasecalculator.test.analysistest.fgipanalysistest import FGIPAnalysisTestCase
from phasecalculator.test.classestest.moleculetest import MoleculeTestCase
-from phasecalculator.test.classestest.outputinformationtest import OutputInformationTestCase
+from phasecalculator.test.classestest.outputinformationtest import (
+ OutputInformationTestCase,
+)
from phasecalculator.test.classestest.phasestest import PhasesTestCase
from phasecalculator.test.classestest.phasetest import PhaseTestCase
-from phasecalculator.test.classestest.runtimeinformationtest import RuntimeInformationTestCase
+from phasecalculator.test.classestest.runtimeinformationtest import (
+ RuntimeInformationTestCase,
+)
from phasecalculator.test.classestest.systemtest import SystemTestCase
from phasecalculator.test.classestest.temperaturetest import TemperatureTestCase
@@ -43,24 +55,28 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
-IO_TEST_CASES = [PhasetransferXMLCreatorTestCase,
- SolventExtractorTestCase,]
+IO_TEST_CASES = [PhasetransferXMLCreatorTestCase, SolventExtractorTestCase]
-RUNNERS_TEST_CASES = [PhasetransferRunnerTestCase,
- FGIPAnalysisRunnerTestCase,
- VLEAnalysisRunnerTestCase]
+RUNNERS_TEST_CASES = [
+ PhasetransferRunnerTestCase,
+ FGIPAnalysisRunnerTestCase,
+ VLEAnalysisRunnerTestCase,
+]
-ANALYSIS_TEST_CASES = [FGIPAnalysisTestCase,]
+ANALYSIS_TEST_CASES = [FGIPAnalysisTestCase]
MODULE_TEST_CASES = []
-CLASSES_TEST_CASES = [MoleculeTestCase,
- OutputInformationTestCase,
- PhasesTestCase,
- PhaseTestCase,
- RuntimeInformationTestCase,
- SystemTestCase,
- TemperatureTestCase]
+CLASSES_TEST_CASES = [
+ MoleculeTestCase,
+ OutputInformationTestCase,
+ PhasesTestCase,
+ PhaseTestCase,
+ RuntimeInformationTestCase,
+ SystemTestCase,
+ TemperatureTestCase,
+]
+
def create_test_suite():
"""Create a test suite with all the tests from the package.
diff --git a/phasecalculator/test/runnerstest/fgipanalysisrunnertest.py b/phasecalculator/test/runnerstest/fgipanalysisrunnertest.py
index d052e1c..4cf9691 100755
--- a/phasecalculator/test/runnerstest/fgipanalysisrunnertest.py
+++ b/phasecalculator/test/runnerstest/fgipanalysisrunnertest.py
@@ -34,8 +34,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class FGIPAnalysisRunnerTestCase(unittest.TestCase):
"""Test case for fgip analysis runner methods."""
+
def setUp(self):
"""Set up before tests.
@@ -46,20 +48,36 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
"""
self.Popen = MockPopen()
self.r = Replacer()
- self.r.replace('phasecalculator.runners.phasetransferrunner.subprocess.call', self.Popen)
+ self.r.replace(
+ "phasecalculator.runners.phasetransferrunner.subprocess.call", self.Popen
+ )
self.addCleanup(self.r.restore)
-
+
self.parent_directory = pathlib.Path(__file__).parents[1]
self.solvent_filename = (
- (self.parent_directory / "resources/expected_solvent.xml").absolute().as_posix()
+ (self.parent_directory / "resources/expected_solvent.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.example_jar = (
+ (self.parent_directory / "resources" / "example.jar").absolute().as_posix()
+ )
+ self.binding_output_filename = (
+ (self.parent_directory / "resources" / "expected_bindingenergy.xml")
+ .absolute()
+ .as_posix()
)
- self.example_jar = (self.parent_directory / "resources" /"example.jar").absolute().as_posix()
- self.binding_output_filename = (self.parent_directory /"resources" / "expected_bindingenergy.xml").absolute().as_posix()
self.directory_base = "fgip"
- self.directory = fgiprunner.generate_directory(self.directory_base, 298.0, "KELVIN")
- self.out_res, self.filename_list = fgiprunner.extract_solvents_and_generate_polynomials(self.solvent_filename, self.binding_output_filename, self.directory)
+ self.directory = fgiprunner.generate_directory(
+ self.directory_base, 298.0, "KELVIN"
+ )
+ self.out_res, self.filename_list = fgiprunner.extract_solvents_and_generate_polynomials(
+ self.solvent_filename, self.binding_output_filename, self.directory
+ )
self.energy_xmlfile = "fgip/298_0K/1-butanol0.165water0.835binding.xml"
- self.poly_file = "fgip/298_0K/1-butanol0.165water0.835binding_poly_fit_split.csv"
+ self.poly_file = (
+ "fgip/298_0K/1-butanol0.165water0.835binding_poly_fit_split.csv"
+ )
self.matrix_file = "fgip/298_0K/1-butanol0.165water0.835_solv_map.csv"
self.solvent_map = "fgip/298_0K/1-butanol0.165water0.835_solv_map.svg"
self.fgip_file = "fgip/298_0K/1-butanol0_165water0_835_FGIP.svg"
@@ -71,6 +89,7 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
\label{fig:1-butanol0_165water0_835solvationmap}
\end{figure}
"""
+
def tearDown(self):
"""Clean up after tests.
@@ -87,9 +106,10 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
except Exception as e:
- LOGGER.error('Failed to delete %s. Reason: %s', file_path, e)
+ LOGGER.error("Failed to delete %s. Reason: %s", file_path, e)
if pathlib.Path(self.directory_base).is_dir():
os.rmdir(self.directory_base)
+
def test_calc_energies_and_fgips(self):
"""Test calculation and FGIP analysis is run.
@@ -98,12 +118,18 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
None.
"""
- results, latex_blocks = fgiprunner.calc_energies_and_fgips(self.example_jar, self.binding_output_filename, self.solvent_filename, self.directory_base)
- self.assertListEqual([(0,0)], results)
+ results, latex_blocks = fgiprunner.calc_energies_and_fgips(
+ self.example_jar,
+ self.binding_output_filename,
+ self.solvent_filename,
+ self.directory_base,
+ )
+ self.assertListEqual([(0, 0)], results)
self.assertMultiLineEqual(self.expected_latex, latex_blocks)
self.assertTrue(pathlib.Path(self.matrix_file).is_file())
self.assertTrue(pathlib.Path(self.solvent_map).is_file())
self.assertTrue(pathlib.Path(self.fgip_file).is_file())
+
def test_generate_directory(self):
"""Test directory is generated.
@@ -113,6 +139,7 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
"""
self.assertTrue(pathlib.Path(self.directory).is_dir())
+
def test_run_fgip_analysis(self):
"""Test FGIP analysis is run.
@@ -121,12 +148,15 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
None.
"""
- results, latex_blocks = fgiprunner.run_fgip_analysis(self.solvent_filename, self.filename_list, self.directory)
- self.assertListEqual([(0,0)], results)
+ results, latex_blocks = fgiprunner.run_fgip_analysis(
+ self.solvent_filename, self.filename_list, self.directory
+ )
+ self.assertListEqual([(0, 0)], results)
self.assertMultiLineEqual(self.expected_latex, latex_blocks)
self.assertTrue(pathlib.Path(self.matrix_file).is_file())
self.assertTrue(pathlib.Path(self.solvent_map).is_file())
self.assertTrue(pathlib.Path(self.fgip_file).is_file())
+
def test_extract_solvents_and_generate_polynomials(self):
"""Test expected solvent information is extracted and binding polynomial is produced.
@@ -137,6 +167,7 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
"""
self.assertListEqual([0], self.out_res)
self.assertListEqual([self.poly_file], self.filename_list)
+
def test_run_binding_energy_calculation(self):
"""Test expected system call is produced.
@@ -145,10 +176,26 @@ class FGIPAnalysisRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar, '--energies',
- 'solvationbinding', "--calc", "--conccalc",
- "-o", self.binding_output_filename,
- "--solvent", self.solvent_filename,
- "--solute", fgiprunner.phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE, "--temperatureUnit", "KELVIN", "-t", "298.0"]
- process = fgiprunner.run_binding_energy_calculation(self.example_jar, self.binding_output_filename, self.solvent_filename)
- self.assertListEqual(expected_args, process.args)
\ No newline at end of file
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--energies",
+ "solvationbinding",
+ "--calc",
+ "--conccalc",
+ "-o",
+ self.binding_output_filename,
+ "--solvent",
+ self.solvent_filename,
+ "--solute",
+ fgiprunner.phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE,
+ "--temperatureUnit",
+ "KELVIN",
+ "-t",
+ "298.0",
+ ]
+ process = fgiprunner.run_binding_energy_calculation(
+ self.example_jar, self.binding_output_filename, self.solvent_filename
+ )
+ self.assertListEqual(expected_args, process.args)
diff --git a/phasecalculator/test/runnerstest/phasecalculatorrunnertest.py b/phasecalculator/test/runnerstest/phasecalculatorrunnertest.py
index cb7aa6a..2966b80 100755
--- a/phasecalculator/test/runnerstest/phasecalculatorrunnertest.py
+++ b/phasecalculator/test/runnerstest/phasecalculatorrunnertest.py
@@ -48,6 +48,7 @@ LOGGER.setLevel(logging.WARN)
class PhaseCalculatorRunnerTestCase(unittest.TestCase):
"""Test case for phase calculator runner methods."""
+
def setUp(self):
"""Set up before tests.
@@ -60,28 +61,59 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
self.water_ssip = ssip_filenames["XLYOFNOQVPJJNP-UHFFFAOYSA-N"]
self.butanol_ssip = ssip_filenames["LRHPLDYGYMQRHN-UHFFFAOYSA-N"]
self.temperature = Temperature(298.0, "KELVIN")
- self.water_molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", self.water_ssip, 0.8354716981132075)
- self.butanol_molecule = Molecule("1-butanol", "LRHPLDYGYMQRHN-UHFFFAOYSA-N", self.butanol_ssip, 0.16452830188679246)
- self.phase = Phase([self.water_molecule, self.butanol_molecule], self.temperature)
+ self.water_molecule = Molecule(
+ "water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", self.water_ssip, 0.8354716981132075
+ )
+ self.butanol_molecule = Molecule(
+ "1-butanol",
+ "LRHPLDYGYMQRHN-UHFFFAOYSA-N",
+ self.butanol_ssip,
+ 0.16452830188679246,
+ )
+ self.phase = Phase(
+ [self.water_molecule, self.butanol_molecule], self.temperature
+ )
self.phases = Phases([self.phase])
parent_directory = pathlib.Path(__file__).parents[1]
- self.example_jar = (parent_directory / "resources/example.jar").absolute().as_posix()
+ self.example_jar = (
+ (parent_directory / "resources/example.jar").absolute().as_posix()
+ )
self.runtime_inf = RuntimeInformation(self.example_jar, "scratch", "fgip")
self.out_inf = OutputInformation(True, True, "all", True)
self.system = System(self.phases, self.runtime_inf, self.out_inf)
pcalcrun.phasexmlrun.create_scratch_dir(self.system)
self.directory_base = pcalcrun.create_output_dir(self.system)
-
- self.expected_phase_file = (parent_directory /"resources" / "expected_phase.xml").absolute().as_posix()
- self.expected_solvent_file = (parent_directory /"resources" / "expected_solvent.xml").absolute().as_posix()
- self.expected_binding_file = (parent_directory /"resources" / "expected_solventbinding.xml").absolute().as_posix()
- self.expected_free_file = (parent_directory /"resources" / "expected_solventfree.xml").absolute().as_posix()
+
+ self.expected_phase_file = (
+ (parent_directory / "resources" / "expected_phase.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_solvent_file = (
+ (parent_directory / "resources" / "expected_solvent.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_binding_file = (
+ (parent_directory / "resources" / "expected_solventbinding.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_free_file = (
+ (parent_directory / "resources" / "expected_solventfree.xml")
+ .absolute()
+ .as_posix()
+ )
self.phase_filename = "scratch/systemphase.xml"
- self.solv_energy_dict = {"solvent_filename":self.expected_solvent_file,
- "temperature_value":298.0,
- "temperature_units":"KELVIN"}
+ self.solv_energy_dict = {
+ "solvent_filename": self.expected_solvent_file,
+ "temperature_value": 298.0,
+ "temperature_units": "KELVIN",
+ }
self.energy_xmlfile = "fgip/298_0K/1-butanol0.165water0.835binding.xml"
- self.poly_file = "fgip/298_0K/1-butanol0.165water0.835binding_poly_fit_split.csv"
+ self.poly_file = (
+ "fgip/298_0K/1-butanol0.165water0.835binding_poly_fit_split.csv"
+ )
self.matrix_file = "fgip/298_0K/1-butanol0.165water0.835_solv_map.csv"
self.solvent_map = "fgip/298_0K/1-butanol0.165water0.835_solv_map.svg"
self.fgip_file = "fgip/298_0K/1-butanol0_165water0_835_FGIP.svg"
@@ -94,6 +126,7 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
\label{fig:1-butanol0_165water0_835solvationmap}
\end{figure}
"""
+
def tearDown(self):
"""Clean up after tests.
@@ -110,9 +143,10 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
except Exception as e:
- LOGGER.error('Failed to delete %s. Reason: %s', file_path, e)
+ LOGGER.error("Failed to delete %s. Reason: %s", file_path, e)
if pathlib.Path(self.directory_base).is_dir():
os.rmdir(self.directory_base)
+
def copy_intermediate_files(self):
"""Test fixture required for run all analysis test as intermediate
energy files are not produced during test as an SSIP jar is not present.
@@ -122,8 +156,11 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
None.
"""
- shutil.copyfile(self.expected_binding_file, "scratch/systemsolvent_298.0Kbinding.xml")
+ shutil.copyfile(
+ self.expected_binding_file, "scratch/systemsolvent_298.0Kbinding.xml"
+ )
shutil.copyfile(self.expected_free_file, "scratch/systemsolvent_298.0Kfree.xml")
+
def test_run_all_analysis(self):
"""Test
@@ -138,6 +175,7 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
self.assertTrue(pathlib.Path(self.solvent_map).is_file())
self.assertTrue(pathlib.Path(self.fgip_file).is_file())
self.assertTrue(pathlib.Path(self.similarity_file).is_file())
+
def test_run_fgip_analysis(self):
"""Test
@@ -146,12 +184,15 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
None.
"""
- results, latex_blocks = pcalcrun.run_fgip_analysis(self.system, [self.solv_energy_dict])
- self.assertListEqual([(0,0)], results)
+ results, latex_blocks = pcalcrun.run_fgip_analysis(
+ self.system, [self.solv_energy_dict]
+ )
+ self.assertListEqual([(0, 0)], results)
self.assertMultiLineEqual(self.expected_latex, latex_blocks)
self.assertTrue(pathlib.Path(self.matrix_file).is_file())
self.assertTrue(pathlib.Path(self.solvent_map).is_file())
self.assertTrue(pathlib.Path(self.fgip_file).is_file())
+
def test_run_similarity_analysis(self):
"""Test
@@ -162,6 +203,7 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
"""
pcalcrun.run_similarity_analysis(self.system, [self.solv_energy_dict])
self.assertTrue(pathlib.Path(self.similarity_file).is_file())
+
def test_run_vle_analysis(self):
"""Test
@@ -170,12 +212,23 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar,"--phaseOut",
- "--phaseCollectionList", "--conccalc",
- "--gascalc", "--calc", "--phaseFile", self.phase_filename,
- "-o", self.phase_filename.replace(".xml","calculated.xml")]
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--phaseOut",
+ "--phaseCollectionList",
+ "--conccalc",
+ "--gascalc",
+ "--calc",
+ "--phaseFile",
+ self.phase_filename,
+ "-o",
+ self.phase_filename.replace(".xml", "calculated.xml"),
+ ]
process = pcalcrun.run_vle_analysis(self.system, self.phase_filename)
self.assertListEqual(expected_args, process.args)
+
def test_create_output_dir(self):
"""Test
@@ -184,7 +237,10 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
None.
"""
- self.assertTrue(pathlib.Path(self.system.runtime_information.output_dir).is_dir())
+ self.assertTrue(
+ pathlib.Path(self.system.runtime_information.output_dir).is_dir()
+ )
+
def test_create_free_energy_output_filename(self):
"""Test
@@ -194,8 +250,11 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
"""
expected_filename = "solvent_filenamefree.xml"
- actual_filename = pcalcrun.create_free_energy_output_filename("solvent_filename.xml")
+ actual_filename = pcalcrun.create_free_energy_output_filename(
+ "solvent_filename.xml"
+ )
self.assertEqual(expected_filename, actual_filename)
+
def test_create_binding_energy_output_filename(self):
"""Test
@@ -205,8 +264,11 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
"""
expected_filename = "solvent_filenamebinding.xml"
- actual_filename = pcalcrun.create_binding_energy_output_filename("solvent_filename.xml")
+ actual_filename = pcalcrun.create_binding_energy_output_filename(
+ "solvent_filename.xml"
+ )
self.assertEqual(expected_filename, actual_filename)
+
def test_create_phase_output_filename(self):
"""Test
@@ -218,6 +280,7 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
expected_filename = "phase_filenamecalculated.xml"
actual_filename = pcalcrun.create_phase_output_filename("phase_filename.xml")
self.assertEqual(expected_filename, actual_filename)
+
def test_create_phase_and_solvent_xml_files(self):
"""Test
@@ -226,16 +289,22 @@ class PhaseCalculatorRunnerTestCase(unittest.TestCase):
None.
"""
- phase_filename, solvent_filename_list = pcalcrun.create_phase_and_solvent_xml_files(self.system)
+ phase_filename, solvent_filename_list = pcalcrun.create_phase_and_solvent_xml_files(
+ self.system
+ )
self.assertEqual("scratch/systemphase.xml", phase_filename)
with open(phase_filename, "r") as act_file:
actual_contents = act_file.read()
with open(self.expected_phase_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
- expected_list = [{"solvent_filename":"scratch/systemsolvent_298.0K.xml",
- 'temperature_units': 'KELVIN',
- 'temperature_value': 298.0}]
+ expected_list = [
+ {
+ "solvent_filename": "scratch/systemsolvent_298.0K.xml",
+ "temperature_units": "KELVIN",
+ "temperature_value": 298.0,
+ }
+ ]
self.assertListEqual(expected_list, solvent_filename_list)
solvent_filename = solvent_filename_list[0]["solvent_filename"]
with open(solvent_filename, "r") as act_file:
diff --git a/phasecalculator/test/runnerstest/phasetransferrunnertest.py b/phasecalculator/test/runnerstest/phasetransferrunnertest.py
index 3652a0f..8bbfb55 100755
--- a/phasecalculator/test/runnerstest/phasetransferrunnertest.py
+++ b/phasecalculator/test/runnerstest/phasetransferrunnertest.py
@@ -31,6 +31,7 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class PhasetransferRunnerTestCase(unittest.TestCase):
"""Test case for phasetransferrunner methods."""
@@ -44,15 +45,40 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
"""
self.Popen = MockPopen()
self.r = Replacer()
- self.r.replace('phasecalculator.runners.phasetransferrunner.subprocess.call', self.Popen)
+ self.r.replace(
+ "phasecalculator.runners.phasetransferrunner.subprocess.call", self.Popen
+ )
self.addCleanup(self.r.restore)
parent_directory = pathlib.Path(__file__).parents[1]
- self.example_jar = (parent_directory / "resources" /"example.jar").absolute().as_posix()
- self.phase_filename = (parent_directory /"resources" / "expected_phase.xml").absolute().as_posix()
- self.solvent_filename = (parent_directory /"resources" / "expected_solvent.xml").absolute().as_posix()
- self.free_output_filename = (parent_directory /"resources" / "expected_freeenergy.xml").absolute().as_posix()
- self.binding_output_filename = (parent_directory /"resources" / "expected_bindingenergy.xml").absolute().as_posix()
- self.phase_output_filename = (parent_directory /"resources" / "expected_phaseout.xml").absolute().as_posix()
+ self.example_jar = (
+ (parent_directory / "resources" / "example.jar").absolute().as_posix()
+ )
+ self.phase_filename = (
+ (parent_directory / "resources" / "expected_phase.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.solvent_filename = (
+ (parent_directory / "resources" / "expected_solvent.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.free_output_filename = (
+ (parent_directory / "resources" / "expected_freeenergy.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.binding_output_filename = (
+ (parent_directory / "resources" / "expected_bindingenergy.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.phase_output_filename = (
+ (parent_directory / "resources" / "expected_phaseout.xml")
+ .absolute()
+ .as_posix()
+ )
+
def tearDown(self):
"""Clean up after tests.
@@ -61,8 +87,8 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- #if pathlib.Path(self.example_jar).is_file():
-
+ # if pathlib.Path(self.example_jar).is_file():
+
def test_run_vle_calculation(self):
"""Test subprocess called with expected arguments.
@@ -71,12 +97,25 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar,"--phaseOut",
- "--phaseCollectionList", "--conccalc",
- "--gascalc", "--calc", "--phaseFile", self.phase_filename,
- "-o", self.phase_output_filename]
- process = phaserun.run_vle_calculation(self.example_jar, self.phase_filename, self.phase_output_filename)
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--phaseOut",
+ "--phaseCollectionList",
+ "--conccalc",
+ "--gascalc",
+ "--calc",
+ "--phaseFile",
+ self.phase_filename,
+ "-o",
+ self.phase_output_filename,
+ ]
+ process = phaserun.run_vle_calculation(
+ self.example_jar, self.phase_filename, self.phase_output_filename
+ )
self.assertListEqual(expected_args, process.args)
+
def test_run_phasetransfer_binding_energy(self):
"""Test subprocess called with expected arguments.
@@ -85,13 +124,30 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar, '--energies',
- 'solvationbinding', "--calc", "--conccalc",
- "-o", self.binding_output_filename,
- "--solvent", self.solvent_filename,
- "--solute", phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE, "--temperatureUnit", "KELVIN", "-t", "298.0"]
- process = phaserun.run_phasetransfer_binding_energy(self.example_jar, self.binding_output_filename, self.solvent_filename)
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--energies",
+ "solvationbinding",
+ "--calc",
+ "--conccalc",
+ "-o",
+ self.binding_output_filename,
+ "--solvent",
+ self.solvent_filename,
+ "--solute",
+ phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE,
+ "--temperatureUnit",
+ "KELVIN",
+ "-t",
+ "298.0",
+ ]
+ process = phaserun.run_phasetransfer_binding_energy(
+ self.example_jar, self.binding_output_filename, self.solvent_filename
+ )
self.assertListEqual(expected_args, process.args)
+
def test_run_phasetransfer_free_energy(self):
"""Test subprocess called with expected arguments.
@@ -100,13 +156,30 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar, '--energies',
- 'solvationtotal', "--calc", "--conccalc",
- "-o", self.free_output_filename,
- "--solvent", self.solvent_filename,
- "--solute", phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE, "--temperatureUnit", "KELVIN", "-t", "298.0"]
- process = phaserun.run_phasetransfer_free_energy(self.example_jar, self.free_output_filename, self.solvent_filename)
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--energies",
+ "solvationtotal",
+ "--calc",
+ "--conccalc",
+ "-o",
+ self.free_output_filename,
+ "--solvent",
+ self.solvent_filename,
+ "--solute",
+ phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE,
+ "--temperatureUnit",
+ "KELVIN",
+ "-t",
+ "298.0",
+ ]
+ process = phaserun.run_phasetransfer_free_energy(
+ self.example_jar, self.free_output_filename, self.solvent_filename
+ )
self.assertListEqual(expected_args, process.args)
+
def test_run_calculation(self):
"""Test subprocess called with expected arguments.
@@ -115,10 +188,10 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- self.Popen.set_command('ls ' +self.phase_filename, stdout=b'o', stderr=b'e')
+ self.Popen.set_command("ls " + self.phase_filename, stdout=b"o", stderr=b"e")
# testing of results
-
+
process = phaserun.run_calculation(["ls", self.phase_filename])
self.assertListEqual(["ls", self.phase_filename], process.args)
@@ -130,12 +203,25 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar,"--phaseOut",
- "--phaseCollectionList", "--conccalc",
- "--gascalc", "--calc", "--phaseFile", self.phase_filename,
- "-o", self.phase_output_filename]
- actual_args = phaserun.generate_vle_calc_args(self.example_jar, self.phase_filename, self.phase_output_filename)
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--phaseOut",
+ "--phaseCollectionList",
+ "--conccalc",
+ "--gascalc",
+ "--calc",
+ "--phaseFile",
+ self.phase_filename,
+ "-o",
+ self.phase_output_filename,
+ ]
+ actual_args = phaserun.generate_vle_calc_args(
+ self.example_jar, self.phase_filename, self.phase_output_filename
+ )
self.assertListEqual(expected_args, actual_args)
+
def test_generate_phasetransfer_free_args(self):
"""Test expected argument list produced.
@@ -144,13 +230,30 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar, '--energies',
- 'solvationtotal', "--calc", "--conccalc",
- "-o", self.free_output_filename,
- "--solvent", self.solvent_filename,
- "--solute", phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE, "--temperatureUnit", "KELVIN", "-t", "298.0"]
- actual_args = phaserun.generate_phasetransfer_free_args(self.example_jar, self.free_output_filename, self.solvent_filename)
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--energies",
+ "solvationtotal",
+ "--calc",
+ "--conccalc",
+ "-o",
+ self.free_output_filename,
+ "--solvent",
+ self.solvent_filename,
+ "--solute",
+ phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE,
+ "--temperatureUnit",
+ "KELVIN",
+ "-t",
+ "298.0",
+ ]
+ actual_args = phaserun.generate_phasetransfer_free_args(
+ self.example_jar, self.free_output_filename, self.solvent_filename
+ )
self.assertListEqual(expected_args, actual_args)
+
def test_generate_phasetransfer_binding_args(self):
"""Test expected argument list produced.
@@ -159,13 +262,30 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar, '--energies',
- 'solvationbinding', "--calc", "--conccalc",
- "-o", self.binding_output_filename,
- "--solvent", self.solvent_filename,
- "--solute", phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE, "--temperatureUnit", "KELVIN", "-t", "298.0"]
- actual_args = phaserun.generate_phasetransfer_binding_args(self.example_jar, self.binding_output_filename, self.solvent_filename)
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--energies",
+ "solvationbinding",
+ "--calc",
+ "--conccalc",
+ "-o",
+ self.binding_output_filename,
+ "--solvent",
+ self.solvent_filename,
+ "--solute",
+ phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE,
+ "--temperatureUnit",
+ "KELVIN",
+ "-t",
+ "298.0",
+ ]
+ actual_args = phaserun.generate_phasetransfer_binding_args(
+ self.example_jar, self.binding_output_filename, self.solvent_filename
+ )
self.assertListEqual(expected_args, actual_args)
+
def test_generate_phase_calc_args(self):
"""Test expected argument list produced.
@@ -174,11 +294,22 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["--phaseOut", "--phaseCollectionList", "--conccalc",
- "--gascalc", "--calc", "--phaseFile", self.phase_filename,
- "-o", self.phase_output_filename]
- actual_args = phaserun.generate_phase_calc_args(self.phase_filename, self.phase_output_filename)
+ expected_args = [
+ "--phaseOut",
+ "--phaseCollectionList",
+ "--conccalc",
+ "--gascalc",
+ "--calc",
+ "--phaseFile",
+ self.phase_filename,
+ "-o",
+ self.phase_output_filename,
+ ]
+ actual_args = phaserun.generate_phase_calc_args(
+ self.phase_filename, self.phase_output_filename
+ )
self.assertListEqual(expected_args, actual_args)
+
def test_generate_solvent_calc_args(self):
"""Test expected argument list produced.
@@ -187,11 +318,25 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["--calc", "--conccalc", "-o", self.free_output_filename,
- "--solvent", self.solvent_filename,
- "--solute", phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE, "--temperatureUnit", "KELVIN", "-t", "298.0"]
- actual_args = phaserun.generate_solvent_calc_args(self.free_output_filename, self.solvent_filename)
+ expected_args = [
+ "--calc",
+ "--conccalc",
+ "-o",
+ self.free_output_filename,
+ "--solvent",
+ self.solvent_filename,
+ "--solute",
+ phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE,
+ "--temperatureUnit",
+ "KELVIN",
+ "-t",
+ "298.0",
+ ]
+ actual_args = phaserun.generate_solvent_calc_args(
+ self.free_output_filename, self.solvent_filename
+ )
self.assertListEqual(expected_args, actual_args)
+
def test_make_java_arguments(self):
"""Test java call pattern matches expected pattern.
@@ -201,11 +346,14 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
"""
expected_args1 = ["java", "-jar", self.example_jar]
- actual_args1 = phaserun.make_java_arguments(self.example_jar)
+ actual_args1 = phaserun.make_java_arguments(self.example_jar)
self.assertListEqual(expected_args1, actual_args1)
expected_args2 = ["java", "-Xms12000m", "-Xmx12000m", "-jar", self.example_jar]
- actual_args2 = phaserun.make_java_arguments(self.example_jar, memory_req="12000m")
+ actual_args2 = phaserun.make_java_arguments(
+ self.example_jar, memory_req="12000m"
+ )
self.assertListEqual(expected_args2, actual_args2)
+
def test_check_jar_exists(self):
"""Test if file exists.
@@ -214,4 +362,4 @@ class PhasetransferRunnerTestCase(unittest.TestCase):
None.
"""
- self.assertTrue(phaserun.check_jar_exists(self.example_jar))
\ No newline at end of file
+ self.assertTrue(phaserun.check_jar_exists(self.example_jar))
diff --git a/phasecalculator/test/runnerstest/phasexmlcreatorrunnertest.py b/phasecalculator/test/runnerstest/phasexmlcreatorrunnertest.py
index e6b3aa4..717bd01 100755
--- a/phasecalculator/test/runnerstest/phasexmlcreatorrunnertest.py
+++ b/phasecalculator/test/runnerstest/phasexmlcreatorrunnertest.py
@@ -40,8 +40,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
"""Test case for phase XML creator runner methods."""
+
def setUp(self):
"""Set up for tests.
@@ -55,9 +57,18 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
self.water_ssip = ssip_filenames["XLYOFNOQVPJJNP-UHFFFAOYSA-N"]
self.butanol_ssip = ssip_filenames["LRHPLDYGYMQRHN-UHFFFAOYSA-N"]
self.temperature = Temperature(298.0, "KELVIN")
- self.water_molecule = Molecule("water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", self.water_ssip, 0.8354716981132075)
- self.butanol_molecule = Molecule("1-butanol", "LRHPLDYGYMQRHN-UHFFFAOYSA-N", self.butanol_ssip, 0.16452830188679246)
- self.phase = Phase([self.water_molecule, self.butanol_molecule], self.temperature)
+ self.water_molecule = Molecule(
+ "water", "XLYOFNOQVPJJNP-UHFFFAOYSA-N", self.water_ssip, 0.8354716981132075
+ )
+ self.butanol_molecule = Molecule(
+ "1-butanol",
+ "LRHPLDYGYMQRHN-UHFFFAOYSA-N",
+ self.butanol_ssip,
+ 0.16452830188679246,
+ )
+ self.phase = Phase(
+ [self.water_molecule, self.butanol_molecule], self.temperature
+ )
self.phases = Phases([self.phase])
self.example_jar = "resources/example.jar"
self.runtime_inf = RuntimeInformation(self.example_jar, "scratch", "fgip")
@@ -65,8 +76,17 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
self.system = System(self.phases, self.runtime_inf, self.out_inf)
phasecreaterun.create_scratch_dir(self.system)
parent_directory = pathlib.Path(__file__).parents[1]
- self.expected_phase_file = (parent_directory /"resources" / "expected_phase.xml").absolute().as_posix()
- self.expected_solvent_file = (parent_directory /"resources" / "expected_solvent.xml").absolute().as_posix()
+ self.expected_phase_file = (
+ (parent_directory / "resources" / "expected_phase.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.expected_solvent_file = (
+ (parent_directory / "resources" / "expected_solvent.xml")
+ .absolute()
+ .as_posix()
+ )
+
def tearDown(self):
"""Clean up after tests.
@@ -83,8 +103,9 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
except Exception as e:
- LOGGER.error('Failed to delete %s. Reason: %s', file_path, e)
+ LOGGER.error("Failed to delete %s. Reason: %s", file_path, e)
os.rmdir(self.runtime_inf.scratch_dir)
+
def test_create_phase_and_solvent_files(self):
"""Test
@@ -93,16 +114,22 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
None.
"""
- phase_filename, solvent_filename_list = phasecreaterun.create_phase_and_solvent_files(self.system)
+ phase_filename, solvent_filename_list = phasecreaterun.create_phase_and_solvent_files(
+ self.system
+ )
self.assertEqual("scratch/systemphase.xml", phase_filename)
with open(phase_filename, "r") as act_file:
actual_contents = act_file.read()
with open(self.expected_phase_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
- expected_list = [{"solvent_filename":"scratch/systemsolvent_298.0K.xml",
- 'temperature_units': 'KELVIN',
- 'temperature_value': 298.0}]
+ expected_list = [
+ {
+ "solvent_filename": "scratch/systemsolvent_298.0K.xml",
+ "temperature_units": "KELVIN",
+ "temperature_value": 298.0,
+ }
+ ]
self.assertListEqual(expected_list, solvent_filename_list)
solvent_filename = solvent_filename_list[0]["solvent_filename"]
with open(solvent_filename, "r") as act_file:
@@ -110,6 +137,7 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
with open(self.expected_solvent_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_create_phase_file(self):
"""Test
@@ -125,6 +153,7 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
with open(self.expected_phase_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_create_solvent_files(self):
"""Test
@@ -133,10 +162,16 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
None.
"""
- expected_list = [{"solvent_filename":"scratch/systemsolvent_298.0K.xml",
- 'temperature_units': 'KELVIN',
- 'temperature_value': 298.0}]
- solvent_filename_list = phasecreaterun.create_solvent_files(self.system, "systemsolvent")
+ expected_list = [
+ {
+ "solvent_filename": "scratch/systemsolvent_298.0K.xml",
+ "temperature_units": "KELVIN",
+ "temperature_value": 298.0,
+ }
+ ]
+ solvent_filename_list = phasecreaterun.create_solvent_files(
+ self.system, "systemsolvent"
+ )
self.assertListEqual(expected_list, solvent_filename_list)
solvent_filename = solvent_filename_list[0]["solvent_filename"]
with open(solvent_filename, "r") as act_file:
@@ -144,6 +179,7 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
with open(self.expected_solvent_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_create_solvent_file(self):
"""Test expected solvent XML created.
@@ -152,16 +188,25 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
None.
"""
- mole_fraction_dict_list = self.system.get_phase_compositions_by_temperature()[self.temperature]
+ mole_fraction_dict_list = self.system.get_phase_compositions_by_temperature()[
+ self.temperature
+ ]
temp_info = self.temperature
ssip_filename_list = self.system.get_ssip_file_locations()
- solvent_filename = phasecreaterun.create_solvent_file(mole_fraction_dict_list, ssip_filename_list, temp_info, "systemsolvent", "scratch")
+ solvent_filename = phasecreaterun.create_solvent_file(
+ mole_fraction_dict_list,
+ ssip_filename_list,
+ temp_info,
+ "systemsolvent",
+ "scratch",
+ )
self.assertEqual("scratch/systemsolvent_298.0K.xml", solvent_filename)
with open(solvent_filename, "r") as act_file:
actual_contents = act_file.read()
with open(self.expected_solvent_file, "r") as exp_file:
expected_contents = exp_file.read()
self.assertMultiLineEqual(expected_contents, actual_contents)
+
def test_create_scratch_dir(self):
"""Test scratch dir exists.
@@ -171,6 +216,7 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
"""
self.assertTrue(pathlib.Path("scratch").is_dir())
+
def test_create_solvent_filename(self):
"""Test expected string produced.
@@ -180,8 +226,11 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
"""
expected_filename = "scratch/systemsolvent_298.0K.xml"
- actual_filename = phasecreaterun.create_solvent_filename("scratch", self.temperature, "systemsolvent")
+ actual_filename = phasecreaterun.create_solvent_filename(
+ "scratch", self.temperature, "systemsolvent"
+ )
self.assertEqual(expected_filename, actual_filename)
+
def test_create_phase_filename(self):
"""Test expected string produced.
@@ -193,6 +242,7 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
expected_filename = "scratch/systemphase.xml"
actual_filename = phasecreaterun.create_phase_filename("scratch", "systemphase")
self.assertEqual(expected_filename, actual_filename)
+
def test_create_temperaturestring(self):
"""Test expected string produced.
@@ -203,4 +253,4 @@ class PhaseXMLCreatorRunnerTestCase(unittest.TestCase):
"""
expected_string = "298.0K"
actual_string = phasecreaterun.create_temperaturestring(298.0, "KELVIN")
- self.assertEqual(expected_string, actual_string)
\ No newline at end of file
+ self.assertEqual(expected_string, actual_string)
diff --git a/phasecalculator/test/runnerstest/similarityanalysisrunnertest.py b/phasecalculator/test/runnerstest/similarityanalysisrunnertest.py
index f95a0d8..3618b03 100755
--- a/phasecalculator/test/runnerstest/similarityanalysisrunnertest.py
+++ b/phasecalculator/test/runnerstest/similarityanalysisrunnertest.py
@@ -36,8 +36,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
"""Test case for similarity analysis."""
+
def setUp(self):
"""Set up before tests.
@@ -48,21 +50,42 @@ class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
"""
self.Popen = MockPopen()
self.r = Replacer()
- self.r.replace('phasecalculator.runners.phasetransferrunner.subprocess.call', self.Popen)
+ self.r.replace(
+ "phasecalculator.runners.phasetransferrunner.subprocess.call", self.Popen
+ )
self.addCleanup(self.r.restore)
parent_directory = pathlib.Path(__file__).parents[1]
- self.example_jar = (parent_directory / "resources" /"example.jar").absolute().as_posix()
- self.phase_filename = (parent_directory /"resources" / "expected_phase.xml").absolute().as_posix()
- self.solvent_filename = (parent_directory /"resources" / "expected_solvent.xml").absolute().as_posix()
- self.free_output_filename = (parent_directory /"resources" / "expected_freeenergy.xml").absolute().as_posix()
+ self.example_jar = (
+ (parent_directory / "resources" / "example.jar").absolute().as_posix()
+ )
+ self.phase_filename = (
+ (parent_directory / "resources" / "expected_phase.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.solvent_filename = (
+ (parent_directory / "resources" / "expected_solvent.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.free_output_filename = (
+ (parent_directory / "resources" / "expected_freeenergy.xml")
+ .absolute()
+ .as_posix()
+ )
self.directory = simrun.generate_directory("sim", 298.0, "KELVIN")
self.energy_xmlfile = "sim/298_0K/1-butanol0.165water0.835free.xml"
self.poly_file = "sim/298_0K/1-butanol0.165water0.835free_poly_fit_split.csv"
- self.out_res, self.filename_list = simrun.extract_solvents_and_generate_polynomials(self.solvent_filename, self.free_output_filename, self.directory)
- self.solv_energy_dict = {"solvent_filename":self.solvent_filename,
- "energy_filename":self.free_output_filename,
- "temperature_value":298.0,
- "temperature_units":"KELVIN"}
+ self.out_res, self.filename_list = simrun.extract_solvents_and_generate_polynomials(
+ self.solvent_filename, self.free_output_filename, self.directory
+ )
+ self.solv_energy_dict = {
+ "solvent_filename": self.solvent_filename,
+ "energy_filename": self.free_output_filename,
+ "temperature_value": 298.0,
+ "temperature_units": "KELVIN",
+ }
+
def tearDown(self):
"""Clean up after tests.
@@ -79,8 +102,9 @@ class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
except Exception as e:
- LOGGER.error('Failed to delete %s. Reason: %s', file_path, e)
+ LOGGER.error("Failed to delete %s. Reason: %s", file_path, e)
os.rmdir("sim")
+
def test_run_similarity_analysis(self):
"""Test
@@ -91,6 +115,7 @@ class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
"""
simrun.run_similarity_analysis([self.poly_file], "all", "sim")
self.assertTrue((pathlib.Path("sim") / "similaritymatrix.csv").is_file())
+
def test_extract_all_solvents_and_generate_polynomials(self):
"""Test
@@ -99,9 +124,12 @@ class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
None.
"""
- out_res, filename_list = simrun.extract_all_solvents_and_generate_polynomials([self.solv_energy_dict], "sim")
+ out_res, filename_list = simrun.extract_all_solvents_and_generate_polynomials(
+ [self.solv_energy_dict], "sim"
+ )
self.assertListEqual([0], out_res)
self.assertListEqual([self.poly_file], filename_list)
+
def test_generate_directory(self):
"""Test
@@ -111,6 +139,7 @@ class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
"""
self.assertTrue(pathlib.Path(self.directory).is_dir())
+
def test_extract_solvents_and_generate_polynomials(self):
"""Test
@@ -121,6 +150,7 @@ class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
"""
self.assertListEqual([0], self.out_res)
self.assertListEqual([self.poly_file], self.filename_list)
+
def test_run_free_energy_calculation(self):
"""Test
@@ -129,10 +159,26 @@ class SimilarityAnalysisRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar, '--energies',
- 'solvationtotal', "--calc", "--conccalc",
- "-o", self.free_output_filename,
- "--solvent", self.solvent_filename,
- "--solute", simrun.phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE, "--temperatureUnit", "KELVIN", "-t", "298.0"]
- process = simrun.run_free_energy_calculation(self.example_jar, self.free_output_filename, self.solvent_filename)
- self.assertListEqual(expected_args, process.args)
\ No newline at end of file
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--energies",
+ "solvationtotal",
+ "--calc",
+ "--conccalc",
+ "-o",
+ self.free_output_filename,
+ "--solvent",
+ self.solvent_filename,
+ "--solute",
+ simrun.phaserun.pureinf.SINGLE_SSIP_SOLUTE_FILE,
+ "--temperatureUnit",
+ "KELVIN",
+ "-t",
+ "298.0",
+ ]
+ process = simrun.run_free_energy_calculation(
+ self.example_jar, self.free_output_filename, self.solvent_filename
+ )
+ self.assertListEqual(expected_args, process.args)
diff --git a/phasecalculator/test/runnerstest/vleanalysisrunnertest.py b/phasecalculator/test/runnerstest/vleanalysisrunnertest.py
index 4e1b713..06d4f93 100755
--- a/phasecalculator/test/runnerstest/vleanalysisrunnertest.py
+++ b/phasecalculator/test/runnerstest/vleanalysisrunnertest.py
@@ -33,8 +33,10 @@ logging.basicConfig()
LOGGER = logging.getLogger(__name__)
LOGGER.setLevel(logging.WARN)
+
class VLEAnalysisRunnerTestCase(unittest.TestCase):
"""Test case for VLE analysis runner methods."""
+
def setUp(self):
"""Set up before tests.
@@ -45,12 +47,25 @@ class VLEAnalysisRunnerTestCase(unittest.TestCase):
"""
self.Popen = MockPopen()
self.r = Replacer()
- self.r.replace('phasecalculator.runners.phasetransferrunner.subprocess.call', self.Popen)
+ self.r.replace(
+ "phasecalculator.runners.phasetransferrunner.subprocess.call", self.Popen
+ )
self.addCleanup(self.r.restore)
self.parent_directory = pathlib.Path(__file__).parents[1]
- self.example_jar = (self.parent_directory / "resources" /"example.jar").absolute().as_posix()
- self.phase_filename = (self.parent_directory /"resources" / "expected_phase.xml").absolute().as_posix()
- self.phase_output_filename = (self.parent_directory /"resources" / "expected_phaseout.xml").absolute().as_posix()
+ self.example_jar = (
+ (self.parent_directory / "resources" / "example.jar").absolute().as_posix()
+ )
+ self.phase_filename = (
+ (self.parent_directory / "resources" / "expected_phase.xml")
+ .absolute()
+ .as_posix()
+ )
+ self.phase_output_filename = (
+ (self.parent_directory / "resources" / "expected_phaseout.xml")
+ .absolute()
+ .as_posix()
+ )
+
def tearDown(self):
"""Clean up after tests.
@@ -59,6 +74,7 @@ class VLEAnalysisRunnerTestCase(unittest.TestCase):
None.
"""
+
def test_run_vle_calculation(self):
"""Test expected system call is made.
@@ -67,9 +83,21 @@ class VLEAnalysisRunnerTestCase(unittest.TestCase):
None.
"""
- expected_args = ["java", "-jar", self.example_jar,"--phaseOut",
- "--phaseCollectionList", "--conccalc",
- "--gascalc", "--calc", "--phaseFile", self.phase_filename,
- "-o", self.phase_output_filename]
- process = vlerun.run_vle_calculation(self.example_jar, self.phase_filename, self.phase_output_filename)
- self.assertListEqual(expected_args, process.args)
\ No newline at end of file
+ expected_args = [
+ "java",
+ "-jar",
+ self.example_jar,
+ "--phaseOut",
+ "--phaseCollectionList",
+ "--conccalc",
+ "--gascalc",
+ "--calc",
+ "--phaseFile",
+ self.phase_filename,
+ "-o",
+ self.phase_output_filename,
+ ]
+ process = vlerun.run_vle_calculation(
+ self.example_jar, self.phase_filename, self.phase_output_filename
+ )
+ self.assertListEqual(expected_args, process.args)
--
GitLab