fairyfly-therm 0.3.1__py3-none-any.whl

fairyfly_therm/config.py

@@ -0,0 +1,315 @@
+"""Fairyfly_therm configurations.
+
+Import this into every module where access configurations are needed.
+
+Usage:
+
+.. code-block:: python
+
+    from fairyfly_therm.config import folders
+    print(folders.lbnl_data_path)
+    folders.lbnl_data_path = "C:/Users/Person/LBNL"
+"""
+import os
+import json
+import ladybug.config as lb_config
+
+
+class Folders(object):
+    """Fairyfly_therm folders.
+
+    Args:
+        config_file: The path to the config.json file from which folders are loaded.
+            If None, the config.json module included in this package will be used.
+            Default: None.
+        mute: If False, the paths to the various folders will be printed as they
+            are found. If True, no printing will occur upon initialization of this
+            class. Default: True.
+
+    Properties:
+        * therm_path
+        * therm_exe
+        * therm_version
+        * therm_version_str
+        * lbnl_data_path
+        * therm_settings_path
+        * therm_lib_path
+        * material_lib_file
+        * gas_lib_file
+        * bc_steady_state_lib_file
+        * config_file
+        * mute
+    """
+    THERM_VERSION = (8, 1, 30)
+
+    def __init__(self, config_file=None, mute=True):
+        self.mute = bool(mute)  # set the mute value
+        self.config_file = config_file  # load paths from the config JSON file
+
+    @property
+    def therm_path(self):
+        """Get or set the path to Therm installation folder.
+
+        This is typically the folder within the lbnl program files directory
+        that starts with THERM and contains executables and dlls.
+        """
+        return self._therm_path
+
+    @therm_path.setter
+    def therm_path(self, t_path):
+        exe_name = 'THERM{}.exe'.format(self.THERM_VERSION[0])
+        if not t_path:  # check the default installation location
+            t_path = self._find_therm_folder()
+        therm_exe_file = os.path.join(t_path, exe_name) if t_path is not None else None
+
+        # if the executable exists, set the variables
+        if t_path and os.path.isfile(therm_exe_file):
+            self._therm_path = t_path
+            self._therm_exe = therm_exe_file
+            self._therm_version = self.THERM_VERSION
+            self._therm_version_str = '.'.join(str(i) for i in self.THERM_VERSION)
+            if not self.mute:
+                print("Path to Therm is set to: %s" % self._therm_path)
+        else:
+            if t_path:
+                msg = '{} is not a valid path to a Therm installation.'.format(t_path)
+                print(msg)
+            self._therm_path = None
+            self._therm_exe = None
+            self._therm_version = None
+            self._therm_version_str = None
+
+    @property
+    def therm_exe(self):
+        """Get the path to Therm executable.
+
+        Will be none if no Therm installation was found.
+        """
+        return self._therm_exe
+
+    @property
+    def therm_version(self):
+        """Get a tuple for the version of therm (eg. (8, 1, 30)).
+
+        This will be None if the version could not be sensed or if no Therm
+        installation was found.
+        """
+        return self._therm_version
+
+    @property
+    def therm_version_str(self):
+        """Get text for the full version of therm (eg."8.1.30").
+
+        This will be None if the version could not be sensed or if no Therm
+        installation was found.
+        """
+        return self._therm_version_str
+
+    @property
+    def lbnl_data_path(self):
+        """Get or set the path to the folder containing the LBNL data.
+
+        This folder typically exists under the User profile and contains sub-folders
+        for all installed versions of LBNL THERM and WINDOW. The THERM sub-folder
+        contains a lib sub-folder with XML files for all materials, boundary
+        conditions, etc.
+        """
+        return self._lbnl_data_path
+
+    @lbnl_data_path.setter
+    def lbnl_data_path(self, path):
+        if not path:  # check the default locations of the template library
+            path = self._find_lbnl_data_folder()
+
+        # gather all of the sub folders underneath the master folder
+        if path and os.path.isdir(path):
+            self._lbnl_data_path = path
+            self._therm_settings_path = self._check_therm_settings(path)
+            self._material_lib_file = self._check_therm_lib_file(path, 'Materials.xml')
+            self._gas_lib_file = self._check_therm_lib_file(path, 'Gases.xml')
+            self._bc_steady_state_lib_file = self._check_therm_lib_file(
+                path, 'BoundaryConditionsSteadyState.xml')
+            if not self.mute:
+                print('Path to LBNL data is set to: {}'.format(self._lbnl_data_path))
+        else:
+            if path:
+                msg = '{} is not a valid path to a LBNL data folder.'.format(path)
+                print(msg)
+            self._lbnl_data_path = None
+            self._therm_settings_path = None
+            self._material_lib_file = None
+            self._gas_lib_file = None
+            self._bc_steady_state_lib_file = None
+
+    @property
+    def therm_settings_path(self):
+        """Get the path to the .ini file with THERM settings.
+
+        Will be None if no LBNL data folder was found.
+        """
+        return self._therm_settings_path
+
+    @property
+    def therm_lib_path(self):
+        """Get or set the path to the folder from which therm materials are loaded.
+
+        This will be the therm folder within within the user's standards folder
+        if it exists.
+        """
+        return self._therm_lib_path
+
+    @therm_lib_path.setter
+    def therm_lib_path(self, path):
+        if not path:  # check the default locations of the template library
+            path = self._find_therm_lib()
+
+        # gather all of the sub folders underneath the master folder
+        if path and os.path.isdir(path):
+            self._therm_lib_path = path
+            if not self.mute:
+                print('Path to THERM library is set to: {}'.format(self._lbnl_data_path))
+        else:
+            if path:
+                msg = '{} is not a valid path to a THERM standards library.'.format(path)
+                print(msg)
+            self._therm_lib_path = None
+
+    @property
+    def material_lib_file(self):
+        """Get the path to the material library file."""
+        return self._material_lib_file
+
+    @property
+    def gas_lib_file(self):
+        """Get the path to the gas library file."""
+        return self._gas_lib_file
+
+    @property
+    def bc_steady_state_lib_file(self):
+        """Get the path to the modifierset library in the standards_data_folder."""
+        return self._bc_steady_state_lib_file
+
+    @property
+    def config_file(self):
+        """Get or set the path to the config.json file from which folders are loaded.
+
+        Setting this to None will result in using the config.json module included
+        in this package.
+        """
+        return self._config_file
+
+    @config_file.setter
+    def config_file(self, cfg):
+        if cfg is None:
+            cfg = os.path.join(os.path.dirname(__file__), 'config.json')
+        self._load_from_file(cfg)
+        self._config_file = cfg
+
+    def _load_from_file(self, file_path):
+        """Set all of the the properties of this object from a config JSON file.
+
+        Args:
+            file_path: Path to a JSON file containing the file paths. A sample of this
+                JSON is the config.json file within this package.
+        """
+        # check the default file path
+        assert os.path.isfile(str(file_path)), \
+            ValueError('No file found at {}'.format(file_path))
+
+        # set the default paths to be all blank
+        default_path = {
+            "therm_path": r'',
+            "lbnl_data_path": r'',
+            "therm_lib_path": r''
+        }
+
+        with open(file_path, 'r') as cfg:
+            try:
+                paths = json.load(cfg)
+            except Exception as e:
+                print('Failed to load paths from {}.\n{}'.format(file_path, e))
+            else:
+                for key, p in paths.items():
+                    if not key.startswith('__') and p.strip():
+                        default_path[key] = p.strip()
+
+        # set paths for therm installations
+        self.therm_path = default_path["therm_path"]
+        self.lbnl_data_path = default_path["lbnl_data_path"]
+        self.therm_lib_path = default_path["therm_lib_path"]
+
+    @staticmethod
+    def _find_therm_folder():
+        """Find the Therm installation in its default location.
+
+        This method will first attempt to return the path of a standalone Therm
+        installation.
+
+        Returns:
+            File directory and full path to executable in case of success.
+            None, None in case of failure.
+        """
+        # first check if there's a version installed in the ladybug_tools folder
+        # note that this option is not likely to be used because of the THERM license
+        lb_install = lb_config.folders.ladybug_tools_folder
+        thm_path = None
+        if os.path.isdir(lb_install):
+            test_path = os.path.join(lb_install, 'THERM')
+            thm_path = test_path if os.path.isdir(test_path) else None
+
+        # then check for the default location where standalone Therm is installed
+        if thm_path is not None:
+            pass  # we found a version of therm in the ladybug_tools folder
+        elif os.name == 'nt':  # search the C:/ drive on Windows
+            major, minor, _ = Folders.THERM_VERSION
+            test_path = 'C:/Program Files (x86)/lbnl/THERM{}.{}'.format(major, minor)
+            thm_path = test_path if os.path.isdir(test_path) else None
+
+        return thm_path
+
+    @staticmethod
+    def _find_lbnl_data_folder():
+        """Find the the LBNL data folder in its default location."""
+        # then check the default location where the LBNL installer puts it
+        lib_folder = None
+        if os.name == 'nt':  # search the C:/ drive on Windows
+            test_path = 'C:/Users/Public/LBNL/'
+            if os.path.isdir(test_path):
+                lib_folder = test_path
+        return lib_folder
+
+    @staticmethod
+    def _check_therm_settings(path):
+        """Check that a settings file exists within the LBNL data folder."""
+        if not path:  # first check that a path exists
+            return None
+        major, minor, _ = Folders.THERM_VERSION
+        settings_dir = os.path.join(path, 'Settings')
+        set_file = os.path.join(settings_dir, 'therm{}.{}.ini'.format(major, minor))
+        if os.path.isfile(set_file):
+            return set_file
+
+    @staticmethod
+    def _find_therm_lib():
+        """Find the the LBNL data folder in its default location."""
+        # first check if there's a user-defined folder in AppData
+        app_folder = os.getenv('APPDATA')
+        if app_folder is not None:
+            lib_folder = os.path.join(app_folder, 'ladybug_tools', 'standards', 'therm')
+            if os.path.isdir(lib_folder):
+                return lib_folder
+
+    @staticmethod
+    def _check_therm_lib_file(path, lib_file):
+        """Check that a XML file exists within the LBNL therm library."""
+        if not path:  # first check that a path exists
+            return None
+        if os.name == 'nt':
+            major, minor, _ = Folders.THERM_VERSION
+            lib_path = os.path.join(path, 'THERM{}.{}/lib'.format(major, minor), lib_file)
+            if os.path.isfile(lib_path):
+                return lib_path
+
+
+"""Object possesing all key folders within the configuration."""
+folders = Folders(mute=True)

fairyfly_therm/lib/__init__.py

@@ -0,0 +1 @@
+"""Library of materials and conditions."""

fairyfly_therm/lib/_loadconditions.py

@@ -0,0 +1,87 @@
+"""Load all conditions from the LBNL XML files and JSON libraries."""
+import os
+import json
+
+from fairyfly_therm.config import folders
+from fairyfly_therm.condition.comprehensive import ComprehensiveCondition
+
+# empty dictionaries to hold loaded conditions
+_conditions = {}
+
+# ensure that there is always a generic indoor and outdoor conditions
+exterior_dict = {
+    'type': 'ComprehensiveCondition',
+    'identifier': 'de5cfad3-8a58-48b7-8583-b31a2650bc80',
+    'temperature': -18.0,
+    'film_coefficient': 26.0,
+    'display_name': 'Generic Exterior',
+    'protected': True,
+    'color': '#0080c0'
+}
+exterior = ComprehensiveCondition.from_dict(exterior_dict)
+exterior.lock()
+_conditions[exterior.display_name] = exterior
+
+interior_dict = {
+    'type': 'ComprehensiveCondition',
+    'identifier': '7eba559e-ebbc-4dc4-82a7-266a888fe5a5',
+    'temperature': 21.0,
+    'film_coefficient': 3.12,
+    'display_name': 'Generic Interior',
+    'protected': True,
+    'color': '#ff8040'
+}
+interior = ComprehensiveCondition.from_dict(interior_dict)
+interior.lock()
+_conditions[interior.display_name] = interior
+
+
+# load the conditions from the LBNL library if they exist
+if folders.bc_steady_state_lib_file is not None:
+    conds = ComprehensiveCondition.extract_all_from_xml_file(folders.bc_steady_state_lib_file)
+    for con in conds:
+        con.lock()
+        _conditions[con.display_name] = con
+
+
+def check_and_add_condition(con):
+    """Check that a condition is not overwriting a default and add it."""
+    con.lock()
+    if con.display_name not in ('Generic Exterior', 'Generic Interior'):
+        if isinstance(con, ComprehensiveCondition):
+            _conditions[con.display_name] = con
+
+
+def load_conditions_from_folder(lib_folder):
+    """Load all of the condition objects from a therm standards folder.
+
+    Args:
+        lib_folder: Path to a sub-folder within a honeybee standards folder.
+    """
+    for f in os.listdir(lib_folder):
+        f_path = os.path.join(lib_folder, f)
+        if os.path.isfile(f_path):
+            if f_path.endswith('.xml'):
+                conds = ComprehensiveCondition.extract_all_from_xml_file(f_path)
+                for c in conds:
+                    check_and_add_condition(c)
+            elif f_path.endswith('.json'):
+                with open(f_path) as json_file:
+                    data = json.load(json_file)
+                if 'type' in data:  # single object
+                    if data['type'] == 'ComprehensiveCondition':
+                        check_and_add_condition(ComprehensiveCondition.from_dict(data))
+                else:  # a collection of several objects
+                    for m_id in data:
+                        try:
+                            m_dict = data[m_id]
+                            if m_dict['type'] == 'ComprehensiveCondition':
+                                check_and_add_condition(
+                                    ComprehensiveCondition.from_dict(m_dict))
+                        except (TypeError, KeyError):
+                            pass  # not an acceptable JSON; possibly a comment
+
+
+# load therm gases from a user folder if we are not using the official THERM lib
+if folders.therm_lib_path is not None:
+    load_conditions_from_folder(folders.therm_lib_path)

fairyfly_therm/lib/_loadgases.py

@@ -0,0 +1,98 @@
+"""Load all gases from the standards library."""
+from fairyfly_therm.config import folders
+from fairyfly_therm.material.gas import PureGas, Gas
+
+import os
+import json
+
+
+# empty dictionary to hold loaded gases
+_pure_gases = {}
+_gases = {}
+
+# first load the gasses from the LBNL library if they exist
+if folders.gas_lib_file is not None:
+    gs, pgs = Gas.extract_all_from_xml_file(folders.gas_lib_file)
+    for pg in pgs:
+        pg.lock()
+        _pure_gases[pg.display_name] = pg
+    for g in gs:
+        g.lock()
+        _gases[g.display_name] = g
+else:  # if not, at least make sure that we have an Air gas
+    air_dict = {
+        'type': 'PureGas',
+        'identifier': '8d33196f-f052-46e6-8353-bccb9a779f9c',
+        'conductivity_coeff_a': 0.002873,
+        'viscosity_coeff_a': 3.723e-06,
+        'specific_heat_coeff_a': 1002.737,
+        'conductivity_coeff_b': 7.76e-05,
+        'viscosity_coeff_b': 4.94e-08,
+        'specific_heat_coeff_b': 0.012324,
+        'conductivity_coeff_c': 0.0,
+        'viscosity_coeff_c': 0.0,
+        'specific_heat_coeff_c': 0.0,
+        'specific_heat_ratio': 1.4,
+        'molecular_weight': 28.97,
+        'display_name': 'Air',
+        'protected': True,
+        'color': '#556d11'
+    }
+    pure_air = PureGas.from_dict(air_dict)
+    pure_air.lock()
+    _pure_gases['Air'] = pure_air
+    air_gas = Gas(
+        [pure_air], [1], identifier='6c2409e9-5296-46c1-be11-9029b59a549b'
+    )
+    air_gas.display_name = 'Air'
+    air_gas.protected = True
+    air_gas.lock()
+    _gases['Air'] = air_gas
+
+
+def check_and_add_gas(gas):
+    """Check that a gas is not overwriting a default and add it."""
+    gas.lock()
+    if gas.display_name != 'Air':
+        if isinstance(gas, PureGas):
+            _pure_gases[gas.display_name] = gas
+        elif isinstance(gas, Gas):
+            _gases[gas.display_name] = gas
+
+
+def load_gases_from_folder(lib_folder):
+    """Load all of the gas objects from a therm standards folder.
+
+    Args:
+        lib_folder: Path to a sub-folder within a honeybee standards folder.
+    """
+    for f in os.listdir(lib_folder):
+        f_path = os.path.join(lib_folder, f)
+        if os.path.isfile(f_path):
+            if f_path.endswith('.xml'):
+                gs, pgs = Gas.extract_all_from_xml_file(f_path)
+                for g in pgs + gs:
+                    check_and_add_gas(g)
+            elif f_path.endswith('.json'):
+                with open(f_path) as json_file:
+                    data = json.load(json_file)
+                if 'type' in data:  # single object
+                    if data['type'] == 'PureGas':
+                        check_and_add_gas(PureGas.from_dict(data))
+                    elif data['type'] == 'Gas':
+                        check_and_add_gas(Gas.from_dict(data))
+                else:  # a collection of several objects
+                    for g_id in data:
+                        try:
+                            g_dict = data[g_id]
+                            if g_dict['type'] == 'PureGas':
+                                check_and_add_gas(PureGas.from_dict(g_dict))
+                            elif g_dict['type'] == 'Gas':
+                                check_and_add_gas(Gas.from_dict(g_dict))
+                        except (TypeError, KeyError):
+                            pass  # not an acceptable JSON; possibly a comment
+
+
+# load therm gases from a user folder if we are not using the official THERM lib
+if folders.therm_lib_path is not None:
+    load_gases_from_folder(folders.therm_lib_path)

fairyfly_therm/lib/_loadmaterials.py

@@ -0,0 +1,98 @@
+"""Load all materials from the LBNL XML files and JSON libraries."""
+import os
+import json
+
+from fairyfly_therm.config import folders
+from fairyfly_therm.material.solid import SolidMaterial
+from fairyfly_therm.material.cavity import CavityMaterial
+from fairyfly_therm.material.xmlutil import extract_all_materials_from_xml_file
+from ._loadgases import _gases
+
+# empty dictionaries to hold loaded materials
+_solid_materials = {}
+_cavity_materials = {}
+
+# ensure that there is always a concrete material
+concrete_dict = {
+    'type': 'SolidMaterial',
+    'identifier': '6442842d-7c8f-4231-a9b3-64302e3b2bc4',
+    'display_name': 'Generic HW Concrete',
+    'conductivity': 1.95,
+    'emissivity': 0.9,
+    'emissivity_back': 0.9,
+    'density': 2240,
+    'porosity': 0.24,
+    'specific_heat': 900,
+    'vapor_diffusion_resistance': 19,
+    'color': '#808080',
+    'protected': True
+}
+concrete = SolidMaterial.from_dict(concrete_dict)
+concrete.lock()
+_solid_materials[concrete.display_name] = concrete
+
+# ensure that we always have an air cavity material
+air_mat = CavityMaterial(identifier='0b46bbd7-0dbc-c148-3afe-87431bf0f66f')
+air_mat.display_name = 'Frame Cavity - CEN Simplified'
+air_mat.protected = True
+air_mat.lock()
+_cavity_materials[air_mat.display_name] = air_mat
+
+
+# load the materials from the LBNL library if they exist
+if folders.material_lib_file is not None:
+    solid, cavit = extract_all_materials_from_xml_file(folders.material_lib_file, _gases)
+    for sol in solid:
+        sol.lock()
+        _solid_materials[sol.display_name] = sol
+    for cav in cavit:
+        cav.lock()
+        _cavity_materials[cav.display_name] = cav
+
+
+def check_and_add_material(mat):
+    """Check that a mat is not overwriting a default and add it."""
+    mat.lock()
+    if mat.display_name not in ('Generic HW Concrete', 'Frame Cavity - CEN Simplified'):
+        if isinstance(mat, SolidMaterial):
+            _solid_materials[mat.display_name] = mat
+        elif isinstance(mat, CavityMaterial):
+            _cavity_materials[mat.display_name] = mat
+
+
+def load_materials_from_folder(lib_folder):
+    """Load all of the material objects from a therm standards folder.
+
+    Args:
+        lib_folder: Path to a sub-folder within a honeybee standards folder.
+    """
+    for f in os.listdir(lib_folder):
+        f_path = os.path.join(lib_folder, f)
+        if os.path.isfile(f_path):
+            if f_path.endswith('.xml'):
+                solid, cavity = extract_all_materials_from_xml_file(f_path, _gases)
+                for m in solid + cavity:
+                    check_and_add_material(m)
+            elif f_path.endswith('.json'):
+                with open(f_path) as json_file:
+                    data = json.load(json_file)
+                if 'type' in data:  # single object
+                    if data['type'] == 'SolidMaterial':
+                        check_and_add_material(SolidMaterial.from_dict(data))
+                    elif data['type'] == 'CavityMaterial':
+                        check_and_add_material(CavityMaterial.from_dict(data))
+                else:  # a collection of several objects
+                    for m_id in data:
+                        try:
+                            m_dict = data[m_id]
+                            if m_dict['type'] == 'SolidMaterial':
+                                check_and_add_material(SolidMaterial.from_dict(m_dict))
+                            elif m_dict['type'] == 'CavityMaterial':
+                                check_and_add_material(CavityMaterial.from_dict(m_dict))
+                        except (TypeError, KeyError):
+                            pass  # not an acceptable JSON; possibly a comment
+
+
+# load therm gases from a user folder if we are not using the official THERM lib
+if folders.therm_lib_path is not None:
+    load_materials_from_folder(folders.therm_lib_path)

fairyfly_therm/lib/conditions.py

@@ -0,0 +1,24 @@
+"""Establish the default conditions within the fairyfly_therm library."""
+from ._loadconditions import _conditions
+
+
+# establish variables for the default materials used across the library
+exterior = _conditions['Generic Exterior']
+interior = _conditions['Generic Interior']
+
+
+# make lists of condition names to look up items in the library
+CONDITIONS = tuple(_conditions.keys())
+
+
+def condition_by_name(condition_name):
+    """Get a solid condition from the library given the condition name.
+
+    Args:
+        condition_name: A text string for the display_name of the condition.
+    """
+    try:  # first check the default data
+        return _conditions[condition_name]
+    except KeyError:
+        raise ValueError(
+            '"{}" was not found in the solid condition library.'.format(condition_name))

fairyfly_therm/lib/gases.py

@@ -0,0 +1,36 @@
+"""Gas library."""
+from ._loadgases import _pure_gases, _gases
+
+
+# establish variables for the default gasess used across the library
+pure_air = _pure_gases['Air']
+air = _gases['Air']
+
+# make lists of gases to look up items in the library
+PURE_GASES = tuple(_pure_gases.keys())
+GASES = tuple(_gases.keys())
+
+
+def gas_by_name(gas_name):
+    """Get a gas from the library given its name.
+
+    Args:
+        gas_name: A text string for the display_name of the gas.
+    """
+    try:
+        return _gases[gas_name]
+    except KeyError:
+        raise ValueError('"{}" was not found in the gas library.'.format(gas_name))
+
+
+def pure_gas_by_name(pure_gas_name):
+    """Get a pure gas from the library given its name.
+
+    Args:
+        gas_name: A text string for the display_name of the pure gas.
+    """
+    try:
+        return _pure_gases[pure_gas_name]
+    except KeyError:
+        raise ValueError('"{}" was not found in the pure gas '
+                         'library.'.format(pure_gas_name))