honeybee-radiance-postprocess 0.4.555__py3-none-any.whl

honeybee_radiance_postprocess/cli/viewfactor.py

@@ -0,0 +1,157 @@
+"""Commands to compute view factors to geometry."""
+import click
+import os
+import sys
+import logging
+import math
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
+
+from honeybee_radiance.config import folders
+
+from honeybee_radiance_command.rcontrib import Rcontrib, RcontribOptions
+from honeybee_radiance_command._command_util import run_command
+
+from ladybug.futil import preparedir
+
+from honeybee_radiance_postprocess.reader import binary_to_array
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands to compute view factors to geometry.')
+def view_factor():
+    pass
+
+
+@view_factor.command('contrib')
+@click.argument(
+    'octree', type=click.Path(exists=True, file_okay=True, resolve_path=True)
+)
+@click.argument(
+    'sensor-grid', type=click.Path(exists=True, file_okay=True, resolve_path=True)
+)
+@click.argument(
+    'modifiers', type=click.Path(exists=True, file_okay=True, resolve_path=True)
+)
+@click.option(
+    '--ray-count', type=click.INT, default=6, show_default=True,
+    help='The number of rays to be equally distributed over a sphere to compute '
+    'the view factor for each of the input sensors.'
+)
+@click.option(
+    '--rad-params', show_default=True, help='Radiance parameters.'
+)
+@click.option(
+    '--rad-params-locked', show_default=True, help='Protected Radiance parameters. '
+    'These values will overwrite user input rad parameters.'
+)
+@click.option(
+    '--folder', default='.', help='Output folder into which the modifier and '
+    'octree files will be written.'
+)
+@click.option(
+    '--name', default='view_factor', help='File name of the view factor file.'
+)
+def rcontrib_command_with_view_postprocess(
+        octree, sensor_grid, modifiers, ray_count, rad_params, rad_params_locked,
+        folder, name
+):
+    """Run rcontrib to get spherical view factors from a sensor grid.
+
+    This command is similar to the one in honeybee-radiance, but the
+    post-processing is using NumPy.
+
+    \b
+    Args:
+        octree: Path to octree file.
+        sensor-grid: Path to sensor grid file.
+        modifiers: Path to modifiers file.
+    """
+    try:
+        # create the directory if it's not there
+        if not os.path.isdir(folder):
+            preparedir(folder)
+
+        # generate the ray vectors to be used in the view factor calculation
+        if ray_count == 6:
+            rays = ((1, 0, 0), (0, 1, 0), (0, 0, 1), (-1, 0, 0), (0, -1, 0), (0, 0, -1))
+        else:
+            rays = _fibonacci_spiral(ray_count)
+        ray_str = [' {} {} {}\n'.format(*ray) for ray in rays]
+
+        # create a new .pts file with the view vectors
+        ray_file = os.path.abspath(os.path.join(folder, '{}.pts'.format(name)))
+        total_rays = 0
+        with open(sensor_grid) as sg_file:
+            with open(ray_file, 'w') as r_file:
+                for line in sg_file:
+                    for ray in ray_str:
+                        try:
+                            r_file.write(' '.join(line.split()[:3]) + ray)
+                            total_rays += 1
+                        except Exception:
+                            pass  # we are at the end of the file
+
+        # set up the Rcontrib options
+        options = RcontribOptions()
+        if rad_params:  # parse input radiance parameters
+            options.update_from_string(rad_params.strip())
+        if rad_params_locked:  # overwrite input values with protected ones
+            options.update_from_string(rad_params_locked.strip())
+        # overwrite specific options that would otherwise break the command
+        options.M = modifiers
+        options.update_from_string('-I -V- -y {}'.format(total_rays))
+
+        # create the rcontrib command and run it
+        mtx_file = os.path.abspath(os.path.join(folder, '{}.mtx'.format(name)))
+        rcontrib = Rcontrib(options=options, octree=octree, sensors=ray_file)
+        cmd = rcontrib.to_radiance().replace('\\', '/')
+        cmd = '{} | rmtxop -ff - -c .333 .333 .334 > "{}"'.format(cmd, mtx_file.replace('\\', '/'))
+        run_command(cmd, env=folders.env)
+
+        # load the resulting matrix and process the results into view factors
+        array = binary_to_array(mtx_file)
+        view_fac_mtx = []
+        for i in range(0, len(array), ray_count):
+            sens_chunk = array[i:i+ray_count]
+            s_facs = np.sum(sens_chunk, axis=0) / (math.pi * ray_count)
+            view_fac_mtx.append(s_facs)
+
+        view_fac_mtx = np.stack(view_fac_mtx)
+
+        np.save(os.path.join(folder, '{}'.format(name)), view_fac_mtx)
+
+    except Exception:
+        _logger.exception('Failed to compute view factor contributions.')
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+def _fibonacci_spiral(point_count=24):
+    """Get points distributed uniformly across a unit spherical surface.
+
+    Args:
+        point_count: Integer for the number of points to be distributed.
+
+    Returns:
+        List of tuple, each with 3 values representing the XYZ coordinates of
+        the points that were generated.
+    """
+    points = []
+    phi = math.pi * (3. - math.sqrt(5.))
+
+    for i in range(point_count):
+        y = 1 - (i / float(point_count - 1)) * 2
+        radius = math.sqrt(1 - y * y)
+        theta = phi * i
+        x = math.cos(theta) * radius
+        z = math.sin(theta) * radius
+        points.append((x, y, z))
+
+    return points

honeybee_radiance_postprocess/cli/well.py

@@ -0,0 +1,110 @@
+"""honeybee-radiance-postprocess WELL commands."""
+import sys
+import logging
+import json
+import os
+import click
+
+from ladybug.color import Color
+from ladybug.datatype.generic import GenericType
+from ladybug.legend import LegendParameters
+
+from ..well.well import well_annual_daylight
+
+_logger = logging.getLogger(__name__)
+
+
+@click.group(help='Commands for WELL post-processing of Radiance results.')
+def well():
+    pass
+
+
+@well.command('well-annual-daylight')
+@click.argument(
+    'folder',
+    type=click.Path(exists=True, file_okay=False, dir_okay=True, resolve_path=True)
+)
+@click.argument(
+    'daylight-hours',
+    type=click.Path(exists=True, file_okay=True, dir_okay=False, resolve_path=True)
+)
+@click.option(
+    '--grids-filter', '-gf', help='A pattern to filter the grids.', default='*',
+    show_default=True
+)
+@click.option(
+    '--sub-folder', '-sf', help='Relative path for subfolder to write output '
+    'files.', default='well_summary', show_default=True
+)
+def well_daylight(
+    folder, daylight_hours, grids_filter, sub_folder
+):
+    """Calculate credits for WELL L06.
+
+    Use the shade-transmittance option to set a shade transmittance values for
+    aperture groups. The shade-transmittance-file option takes precedence over
+    the shade-transmittance, however, if any aperture groups are missing in the
+    JSON file given to the shade-transmittance-file option, the value from
+    shade-transmittance will be used for those aperture groups.
+
+    \b
+    Args:
+        folder: Results folder. This folder is an output folder of annual daylight
+            recipe. The daylight simulation must include aperture groups.
+        daylight_hours: Daylight hours schedule for EN 17037.
+    """
+    with open(daylight_hours) as hourly_schedule:
+        daylight_hours = [int(float(v)) for v in hourly_schedule]
+
+    try:
+        well_annual_daylight(
+            folder, daylight_hours, grids_filter=grids_filter, sub_folder=sub_folder
+        )
+    except Exception:
+        _logger.exception('Failed to generate WELL summary.')
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+
+@well.command('well-daylight-vis-metadata')
+@click.option(
+    '--output-folder', '-o', help='Output folder for vis metadata files.',
+    type=click.Path(exists=False, file_okay=False, dir_okay=True, resolve_path=True),
+    default='visualization', show_default=True
+)
+def well_daylight_vis(output_folder):
+    """Write visualization metadata files for WELL Daylight."""
+    colors = [Color(220, 0, 0), Color(0, 220, 0)]
+    pass_fail_lpar = \
+        LegendParameters(min=0, max=1, colors=colors, segment_count=2, title='Pass/Fail')
+    pass_fail_lpar.ordinal_dictionary = {0: "Fail", 1: "Pass"}
+
+    metric_info_dict = {
+        'L01': {
+            'type': 'VisualizationMetaData',
+            'data_type': GenericType('sDA200,40%', '').to_dict(),
+            'unit': '',
+            'legend_parameters': pass_fail_lpar.to_dict()
+        },
+        'L06': {
+            'type': 'VisualizationMetaData',
+            'data_type': GenericType('sDA300,50%', '').to_dict(),
+            'unit': '',
+            'legend_parameters': pass_fail_lpar.to_dict()
+        }
+    }
+    try:
+        if not os.path.exists(output_folder):
+            os.mkdir(output_folder)
+        for metric, data in metric_info_dict.items():
+            if not os.path.exists(os.path.join(output_folder, metric)):
+                os.mkdir(os.path.join(output_folder, metric))
+            file_path = os.path.join(output_folder, metric, 'vis_metadata.json')
+            with open(file_path, 'w') as fp:
+                json.dump(data, fp, indent=4)
+    except Exception:
+        _logger.exception('Failed to write the visualization metadata files.')
+        sys.exit(1)
+    else:
+        sys.exit(0)

honeybee_radiance_postprocess/data_type.py

@@ -0,0 +1,102 @@
+"""Functions for NumPy data type (dtype)."""
+from typing import Tuple
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
+
+
+def smallest_integer_dtype(array: np.ndarray) -> np.signedinteger:
+    """Return the smallest possible integer dtype.
+
+    Args:
+        array: NumPy array.
+    
+    Returns:
+        A NumPy integer dtype.
+    """
+    if np.all(array >= np.iinfo(np.int8).min) and \
+        np.all(array <= np.iinfo(np.int8).max):
+        return np.int8
+    elif np.all(array >= np.iinfo(np.int16).min) and \
+        np.all(array <= np.iinfo(np.int16).max):
+        return np.int16
+    elif np.all(array >= np.iinfo(np.int32).min) and \
+        np.all(array <= np.iinfo(np.int32).max):
+        return np.int32
+    elif np.all(array >= np.iinfo(np.int64).min) and \
+        np.all(array <= np.iinfo(np.int64).max):
+        return np.int64
+
+
+def smallest_float_dtype(array: np.ndarray, rtol: float = 1e-5,
+                         atol: float = 1e-5) -> np.floating:
+    """Return the smallest possible float dtype.
+
+    The allclose function is used to check if a certain floating-point precision
+    can be used without losing accuracy.
+
+    Args:
+        array: NumPy array.
+        rtol: The relative tolerance parameter for `np.allclose`. The default
+            is 1e-5.
+        atol: The absolute tolerance parameter for `np.allclose`. The default
+            is 1e-5.
+    
+    Returns:
+        A NumPy floating dtype.
+    """
+    if np.all((array >= np.finfo(np.float16).min) & \
+                (array <= np.finfo(np.float16).max)):
+        if np.allclose(array, array.astype(np.float16), rtol=rtol, atol=atol):
+            return np.float16
+    if np.all((array >= np.finfo(np.float32).min) & \
+                (array <= np.finfo(np.float32).max)):
+        if np.allclose(array, array.astype(np.float32), rtol=rtol, atol=atol):
+            return np.float32
+    if np.all((array >= np.finfo(np.float64).min) & \
+                (array <= np.finfo(np.float64).max)):
+        if np.allclose(array, array.astype(np.float64), rtol=rtol, atol=atol):
+            return np.float64
+
+
+def smallest_dtype(array: np.ndarray, rtol: float = 1e-5, atol: float = 1e-5
+                   ) -> Tuple[np.signedinteger, np.floating]:
+    """Return the smallest possible dtype.
+
+    Args:
+        array: NumPy array.
+        rtol: The relative tolerance parameter for `np.allclose`. The default
+            is 1e-5. This is also used if the dtype of the array is np.floating.
+        atol: The absolute tolerance parameter for `np.allclose`. The default
+            is 1e-5. This is also used if the dtype of the array is np.floating.
+    
+    Returns:
+        A NumPy dtype.
+    """
+    if np.issubdtype(array.dtype, np.integer):
+        return smallest_integer_dtype(array)
+    elif np.issubdtype(array.dtype, np.floating):
+        return smallest_float_dtype(array, rtol=rtol, atol=atol)
+    else:
+        raise TypeError(f'Expected integer or floating dtype. Got {array.dtype}')
+
+
+def set_smallest_dtype(array: np.ndarray, rtol: float = 1e-5,
+                       atol: float = 1e-5) -> np.ndarray:
+    """Return a NumPy array with the smallest possible dtype.
+    
+    Args:
+        array: NumPy array.
+        rtol: The relative tolerance parameter for `np.allclose`. The default
+            is 1e-5. This is also used if the dtype of the array is np.floating.
+        atol: The absolute tolerance parameter for `np.allclose`. The default
+            is 1e-5. This is also used if the dtype of the array is np.floating.
+    
+    Returns:
+        A new NumPy array with a smaller dtype.
+    """
+    dtype = smallest_dtype(array, rtol=rtol, atol=atol)
+    return array.astype(dtype)

honeybee_radiance_postprocess/dynamic.py

@@ -0,0 +1,273 @@
+"""Post-processing classes for dynamic schedules."""
+import json
+import os
+import sys
+from itertools import islice, cycle
+
+from honeybee.config import folders
+
+
+class ApertureGroupSchedule(object):
+    """ApertureGroupSchedule.
+
+    This class contains the dynamic states schedule of a single ApertureGroup.
+
+    Args:
+        identifier: Identifier of the ApertureGroup.
+        schedule: A list or tuple of integer values.
+
+    Properties:
+        * identifier
+        * schedule
+        * is_static
+    """
+    __slots__ = ('_identifier', '_schedule', '_is_static')
+
+    def __init__(self, identifier, schedule, is_static=None):
+        """Initialize ApertureGroupSchedule."""
+        self._identifier = identifier
+        self.schedule = schedule
+        self.is_static = is_static
+
+    @classmethod
+    def from_dict(cls, data):
+        """Initialize a ApertureGroupSchedule from a dictionary.
+
+        Args:
+            data: A dictionary representation of an ApertureGroupSchedule
+                object.
+        """
+        identifier = data['identifier']
+        schedule = data['schedule']
+        is_static = data['is_static'] if 'is_static' in data else None
+        return cls(identifier, schedule, is_static)
+
+    @property
+    def identifier(self):
+        """Return identifier."""
+        return self._identifier
+
+    @property
+    def schedule(self):
+        """Return ApertureGroup schedule."""
+        return self._schedule
+
+    @schedule.setter
+    def schedule(self, schedule):
+        assert isinstance(schedule, (list, tuple)), \
+            ('Failed to add schedule. Received input of type: '
+            '%s. Expected input of type: list or tuple.' % type(schedule))
+        if isinstance(schedule, tuple):
+            schedule = list(schedule)
+        if len(schedule) < 8760:
+            schedule = list(islice(cycle(schedule), 8760))
+        elif len(schedule) > 8760:
+            error_message = (
+                'The light path %s has %s values in '
+                'its states schedule. Maximum allowed number of values '
+                'is 8760.' % (self.identifier, len(schedule))
+            )
+            raise ValueError(error_message)
+        self._schedule = schedule
+
+    @property
+    def is_static(self):
+        """Return True if schedule is static."""
+        return self._is_static
+
+    @is_static.setter
+    def is_static(self, value):
+        if value is not None:
+            assert isinstance(value, bool)
+            self._is_static = value
+        else:
+            if len(set(self.schedule)) == 1:
+                self._is_static = True
+            else:
+                self._is_static = False
+
+    def to_dict(self):
+        """Return ApertureGroupSchedule as a dictionary."""
+        base = {}
+        base['identifier'] = self.identifier
+        base['schedule'] = self.schedule
+        base['is_static'] = self.is_static
+        return base
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __repr__(self):
+        return '{}: {}'.format(self.__class__.__name__, self.identifier)
+
+
+class DynamicSchedule(object):
+    """DynamicSchedule.
+
+    This class contains a single property (dynamic_schedule). This property is
+    a dictionary where keys are ApertureGroup identifiers and the value for
+    each key is the dynamic schedule for the ApertureGroup.
+
+    Args:
+        dynamic_schedule: A dictionary of ApertureGroup identifier and
+            schedules.
+
+    Properties:
+        * dynamic_schedule
+    """
+    __slots__ = ('_dynamic_schedule',)
+
+    def __init__(self, dynamic_schedule = None):
+        self.dynamic_schedule = dynamic_schedule
+
+    @classmethod
+    def from_group_schedules(cls, group_schedules):
+        """Initialize a DynamicSchedule from a list of ApertureGroupSchedules.
+
+        The method will automatically sense if there are duplicated groups in
+        the list and ensure the group schedule only appears once.
+
+        Args:
+            data: A dictionary representation of a DynamicSchedule objects.
+        """
+        dyn_sch = cls()
+        dyn_sch_ids = set()
+        for _ap_group in group_schedules:
+            assert isinstance(_ap_group, ApertureGroupSchedule), \
+                'Expected Aperture Group Schedule. Got {}'.format(type(_ap_group))
+            if _ap_group.identifier not in dyn_sch_ids:
+                dyn_sch_ids.add(_ap_group.identifier)
+                dyn_sch.add_aperture_group_schedule(_ap_group)
+        return dyn_sch
+
+    @classmethod
+    def from_dict(cls, data):
+        """Initialize a DynamicSchedule from a dictionary.
+
+        Args:
+            data: A dictionary representation of a DynamicSchedule objects.
+        """
+        dynamic_schedule = {}
+        for identifier, group in data.items():
+            dynamic_schedule[identifier] = ApertureGroupSchedule.from_dict(group)
+        return cls(dynamic_schedule)
+
+    @classmethod
+    def from_json(cls, json_file):
+        """Initialize a DynamicSchedule from a JSON file.
+
+        Args:
+            json_file: Path to JSON file.
+        """
+        assert os.path.isfile(json_file), 'Failed to find %s' % json_file
+        if sys.version_info < (3, 0):
+            with open(json_file) as inf:
+                data = json.load(inf)
+        else:
+            with open(json_file, encoding='utf-8') as inf:
+                data = json.load(inf)
+        return cls.from_dict(data)
+
+    @property
+    def dynamic_schedule(self):
+        """Return dynamic schedule as a dictionary."""
+        return self._dynamic_schedule
+
+    @dynamic_schedule.setter
+    def dynamic_schedule(self, dynamic_schedule):
+        if not dynamic_schedule:
+            dynamic_schedule = {}
+        assert isinstance(dynamic_schedule, dict), \
+            'Expected dictionary. Got %s.' % type(dynamic_schedule)
+        self._dynamic_schedule = dynamic_schedule
+
+    def add_aperture_group_schedule(self, aperture_group_schedule):
+        """Add an ApertureGroupSchedule to the DynamicSchedule instance.
+
+        Args:
+            aperture_group_schedule: An ApertureGroupSchedule object.
+        """
+        assert isinstance(aperture_group_schedule, ApertureGroupSchedule), \
+            ('Failed to add ApertureGroupSchedule. Received input of type: '
+            '%s. Expected input of type: ApertureGroupSchedule.' \
+            % type(aperture_group_schedule))
+        identifier = aperture_group_schedule.identifier
+        self.dynamic_schedule[identifier] = aperture_group_schedule
+
+    def filter_by_identifiers(self, identifiers):
+        """Filter the DynamicSchedule by identifiers.
+
+        This method returns a filtered DynamicSchedule object.
+
+        Args:
+            identifiers: A list of identifiers.
+
+        Returns:
+            A filtered DynamicSchedule object.
+        """
+        filter_dyn_sch = DynamicSchedule()
+        for identifier in identifiers:
+            if identifier in self.dynamic_schedule:
+                filter_dyn_sch.add_aperture_group_schedule(
+                    self.dynamic_schedule[identifier]
+                )
+            else:
+                filter_dyn_sch.add_aperture_group_schedule(
+                    ApertureGroupSchedule(identifier, [0])
+                )
+        return filter_dyn_sch
+
+    def to_dict(self, simplified=False):
+        """Return DynamicSchedule as a dictionary."""
+        base = {}
+        for identifier, group in self.dynamic_schedule.items():
+            if not simplified:
+                base[identifier] = group.to_dict()
+            else:
+                base[identifier] = group.to_dict()['schedule']
+        return base
+
+    def to_json(self, folder=None, file_name=None, indent=None, simplified=False):
+        """Write a DynamicSchedule to JSON.
+
+        Args:
+            folder: A text string for the directory where the JSON file will be
+                written. If unspecified, the default simulation folder will be
+                used. This is usually at "C:\\Users\\USERNAME\\simulation."
+            file_name: _description_. Defaults to None.
+            indent: A positive integer to set the indentation used in the
+                resulting JSON file. (Default: None).
+
+        Returns:
+            json_file: Path to JSON file.
+        """
+        # create dictionary of the DynamicSchedule
+        dyn_sch_dict = self.to_dict(simplified=simplified)
+
+        # set up name and folder for the JSON
+        file_name = file_name if file_name else 'dynamic_schedule'
+        if not file_name.endswith('.json'):
+            file_name += '.json'
+        folder = folder if folder is not None else folders.default_simulation_folder
+        json_file = os.path.join(folder, file_name)
+
+        # write JSON
+        with open(json_file, 'w') as fp:
+            json.dump(dyn_sch_dict, fp, indent=indent)
+        return json_file
+
+    def duplicate(self):
+        """Get a copy of this object."""
+        return self.__copy__()
+
+    def ToString(self):
+        """Overwrite .NET ToString."""
+        return self.__repr__()
+
+    def __copy__(self):
+        new_dyn_sch = DynamicSchedule(self.dynamic_schedule)
+        return new_dyn_sch
+
+    def __repr__(self):
+        return '{}'.format(self.__class__.__name__)

honeybee_radiance_postprocess/electriclight.py

@@ -0,0 +1,24 @@
+"""Functions for post-processing daylight outputs into electric lighting schedules."""
+from typing import List
+try:
+    import cupy as np
+    is_gpu = True
+except ImportError:
+    is_gpu = False
+    import numpy as np
+
+
+def array_to_dimming_fraction(
+        array: np.ndarray, su_pattern: List[int], setpt: float, m_pow: float,
+        m_lgt: float, off_m: float) -> list:
+    """Compute hourly dimming fractions for a given result file."""
+    fract_dim = (setpt - array) / (setpt - m_lgt)
+    par_dim = fract_dim + ((1 - fract_dim) * m_pow)
+    su_values = np.where(array > setpt, 0 if off_m else m_pow,
+                            (np.where(array <= m_lgt, 1, par_dim))).sum(axis=0)
+    su_values = su_values / array.shape[0]
+
+    dim_fract = np.ones(8760)
+    dim_fract[su_pattern] = su_values
+
+    return dim_fract