honeybee-radiance 1.66.190__py3-none-any.whl

honeybee_radiance/postprocess/en17037.py

@@ -0,0 +1,261 @@
+"""Functions for post-processing EN 17037 daylight outputs."""
+import json
+import os
+
+from .annual import filter_schedule_by_hours, _process_input_folder
+
+
+def _daylight_autonomy(values, occ_pattern, threshold, total_hours):
+    """Calculate annual daylight autonomy for a sensor.
+
+    Args:
+        values: Hourly illuminance values as numbers.
+        occ_pattern: A list of 0 and 1 values for hours of occupancy.
+        threshold: Threshold value for daylight autonomy.
+        total_hours: An integer for the total number of occupied hours,
+            which can be used to avoid having to sum occ pattern each time.
+
+    Returns:
+        daylight autonomy
+    """
+    da = 0
+    for is_occ, value in zip(occ_pattern, values):
+        if is_occ == 0:
+            continue
+        if value > threshold:
+            da += 1
+
+    return round(100.0 * da / total_hours, 2)
+
+
+def en17037_metrics_to_files(
+    ill_file, occ_pattern, output_folder, grid_name=None, total_hours=None
+):
+    """Compute annual EN 17037 metrics for an ill file and write the results to a folder.
+
+    This function generates 6 different files for daylight autonomy based on the varying
+    level of recommendation in EN 17037.
+
+    Args:
+        ill_file: Path to an ill file generated by Radiance. The ill file should be
+            tab separated and shot NOT have a header. The results for each sensor point
+            should be available in a row and and each column should be the illuminance
+            value for a sun_up_hour. The number of columns should match the number of
+            sun up hours.
+        occ_pattern: A list of 0 and 1 values for hours of occupancy.
+        output_folder: An output folder where the results will be written to. The folder
+            will be created if not exist.
+        grid_name: An optional name for grid name which will be used to name the output
+            files. If None the name of the input file will be used.
+        total_hours: An integer for the total number of occupied hours in the
+            occupancy schedule. If None, it will be assumed that all of the
+            occupied hours are sun-up hours and are already accounted for
+            in the the occ_pattern.
+    """
+    if not os.path.isdir(output_folder):
+        os.makedirs(output_folder)
+
+    recommendations = {
+        'minimum_illuminance': {
+            'minimum': 100,
+            'medium': 300,
+            'high': 500
+        },
+        'target_illuminance': {
+            'minimum': 300,
+            'medium': 500,
+            'high': 750
+        }
+    }
+
+    grid_name = grid_name or os.path.split(ill_file)[-1][-4:]
+    da_folders = []
+
+    for target_type, thresholds in recommendations.items():
+        type_folder = os.path.join(output_folder, target_type)
+        if not os.path.isdir(type_folder):
+            os.makedirs(type_folder)
+
+        for level, threshold in thresholds.items():
+            level_folder = os.path.join(type_folder, level)
+            if not os.path.isdir(level_folder):
+                os.makedirs(level_folder)
+
+            da_file = os.path.join(
+                level_folder, 'da', '%s.da' % grid_name).replace('\\', '/')
+            folder = os.path.dirname(da_file)
+            if not os.path.isdir(folder):
+                os.makedirs(folder)
+            sda_file = os.path.join(
+                level_folder, 'sda', '%s.sda' % grid_name).replace('\\', '/')
+            folder = os.path.dirname(sda_file)
+            if not os.path.isdir(folder):
+                os.makedirs(folder)
+
+            da = []
+            with open(ill_file) as results, open(da_file, 'w') as daf:
+                for pt_res in results:
+                    values = (float(res) for res in pt_res.split())
+                    dar = _daylight_autonomy(values, occ_pattern, threshold, total_hours)
+                    daf.write(str(dar) + '\n')
+                    da.append(dar)
+
+            space_target = 50 if target_type == 'target_illuminance' else 95
+            pass_fail = [int(val > space_target) for val in da]
+
+            sda = sum(pass_fail) / len(pass_fail)
+            with open(sda_file, 'w') as sdaf:
+                sdaf.write(str(sda))
+
+            da_folders.append(os.path.join(level_folder, 'da'))
+
+    return da_folders
+
+
+# TODO - support a list of schedules/schedule folder to match the input grids
+def en17037_to_folder(
+    results_folder, schedule, grids_filter='*', sub_folder='metrics'
+        ):
+    """Compute annual EN 17037 metrics in a folder and write them in a subfolder.
+
+    This folder is an output folder of annual daylight recipe. Folder should include
+    grids_info.json and sun-up-hours.txt - the script uses the list in grids_info.json
+    to find the result files for each sensor grid.
+
+    Args:
+        results_folder: Results folder.
+        schedule: An annual schedule for 8760 hours of the year as a list of values. This
+            should be a daylight hours schedule.
+        grids_filter: A pattern to filter the grids. By default all the grids will be
+            processed.
+        sub_folder: An optional relative path for subfolder to copy results files.
+            Default: metrics
+
+    Returns:
+        str -- Path to results folder.
+
+    """
+    grids, sun_up_hours = _process_input_folder(results_folder, grids_filter)
+    occ_pattern, total_occ, sun_down_occ_hours = \
+        filter_schedule_by_hours(sun_up_hours=sun_up_hours, schedule=schedule)
+
+    if total_occ != 4380:
+        raise ValueError(
+            'There are %s occupied hours in the schedule. According to EN 17037 the '
+            'schedule must consist of the daylight hours which is defined '
+            'as the half of the year with the largest quantity of daylight' % total_occ)
+
+    metrics_folder = os.path.join(results_folder, sub_folder)
+    if not os.path.isdir(metrics_folder):
+        os.makedirs(metrics_folder)
+
+    for grid in grids:
+        ill_file = os.path.join(results_folder, '%s.ill' % grid['full_id'])
+        da_folders = en17037_metrics_to_files(
+            ill_file, occ_pattern, metrics_folder, grid['full_id'], total_occ
+        )
+
+    # copy info.json to all results folders
+    for folder_name in da_folders:
+        grid_info = os.path.join(metrics_folder, folder_name, 'grids_info.json')
+        with open(grid_info, 'w') as outf:
+            json.dump(grids, outf, indent=2)
+
+    # create info for available results. This file will be used by honeybee-vtk for
+    # results visualization
+    config_file = os.path.join(metrics_folder, 'config.json')
+
+    cfg = _annual_daylight_en17037_config()
+
+    with open(config_file, 'w') as outf:
+        json.dump(cfg, outf)
+
+    return metrics_folder
+
+
+def _annual_daylight_en17037_config():
+    """Return vtk-config for annual daylight EN 17037. """
+    cfg = {
+        "data": [
+            {
+                "identifier": "Daylight Autonomy - target 300 lux",
+                "object_type": "grid",
+                "unit": "Percentage",
+                "path": "target_illuminance/minimum/da",
+                "hide": False,
+                "legend_parameters": {
+                    "hide_legend": False,
+                    "min": 0,
+                    "max": 100,
+                    "color_set": "nuanced",
+                },
+            },
+            {
+                "identifier": "Daylight Autonomy - target 500 lux",
+                "object_type": "grid",
+                "unit": "Percentage",
+                "path": "target_illuminance/medium/da",
+                "hide": False,
+                "legend_parameters": {
+                    "hide_legend": False,
+                    "min": 0,
+                    "max": 100,
+                    "color_set": "nuanced",
+                },
+            },
+            {
+                "identifier": "Daylight Autonomy - target 750 lux",
+                "object_type": "grid",
+                "unit": "Percentage",
+                "path": "target_illuminance/high/da",
+                "hide": False,
+                "legend_parameters": {
+                    "hide_legend": False,
+                    "min": 0,
+                    "max": 100,
+                    "color_set": "nuanced",
+                },
+            },
+            {
+                "identifier": "Daylight Autonomy - minimum 100 lux",
+                "object_type": "grid",
+                "unit": "Percentage",
+                "path": "minimum_illuminance/minimum/da",
+                "hide": False,
+                "legend_parameters": {
+                    "hide_legend": False,
+                    "min": 0,
+                    "max": 100,
+                    "color_set": "nuanced",
+                },
+            },
+            {
+                "identifier": "Daylight Autonomy - minimum 300 lux",
+                "object_type": "grid",
+                "unit": "Percentage",
+                "path": "minimum_illuminance/medium/da",
+                "hide": False,
+                "legend_parameters": {
+                    "hide_legend": False,
+                    "min": 0,
+                    "max": 100,
+                    "color_set": "nuanced",
+                },
+            },
+            {
+                "identifier": "Daylight Autonomy - minimum 500 lux",
+                "object_type": "grid",
+                "unit": "Percentage",
+                "path": "minimum_illuminance/high/da",
+                "hide": False,
+                "legend_parameters": {
+                    "hide_legend": False,
+                    "min": 0,
+                    "max": 100,
+                    "color_set": "nuanced",
+                },
+            },
+        ]
+    }
+
+    return cfg

honeybee_radiance/postprocess/leed.py

@@ -0,0 +1,304 @@
+"""Functions for post-processing LEED daylight outputs."""
+import json
+import os
+import shutil
+import math
+
+from honeybee.model import Model
+from honeybee.units import conversion_factor_to_meters
+from ..writer import _filter_by_pattern
+
+
+def _process_input_folder(folder, filter_pattern):
+    """Process and input annual daylight results folder."""
+    info = os.path.join(folder, 'grids_info.json')
+    with open(info) as data_f:
+        data = json.load(data_f)
+    grids = _filter_by_pattern(data, filter=filter_pattern)
+    return grids
+
+
+def ill_pass_fail_from_folder(
+        results_folder, glare_control=True, grids_filter='*'):
+    """Compute a list of LEED pass/fail values from a list of illuminance results.
+
+    Args:
+        results_folder: Folder containing illuminance result (.res) files for
+            a single irradiance simulation.
+        glare_control: A boolean for whether the model has "view-preserving automatic
+            (with manual override) glare-control devices," which means that illuminance
+            only needs to be above 300 lux and not between 300 and 3000 lux.
+        grids_filter: A pattern to filter the grids. By default all the grids will be
+            processed.
+
+    Returns:
+        A list of lists where each sub-list represents a sensor grid and contains
+        zero/one values for whether each sensor fails/passes the LEED illuminance
+        criteria.
+    """
+    pass_fail = []
+    grids = _process_input_folder(results_folder, grids_filter)
+    for grid in grids:
+        res_file = os.path.join(results_folder, '%s.res' % grid['full_id'])
+        with open(res_file) as inf:
+            values = [float(line) for line in inf]
+        grid_pf = []
+        for val in values:
+            if val > 300:
+                pf = 1 if glare_control or val < 3000 else 0
+                grid_pf.append(pf)
+            else:
+                grid_pf.append(0)
+        pass_fail.append(grid_pf)
+    return pass_fail
+
+
+def _pass_fail_to_files(
+        folder, sub_folder, pass_fail_comb, pass_fail_9, pass_fail_3, filter_pattern):
+    """Write pass/fail matrices into files that can be loaded and visualized later.
+
+    Args:
+        folder: Project folder for a LEED daylight illuminance simulation.
+        sub_folder: Relative path for a subfolder to write the pass/fail files for
+            each sensor grid.
+        pass_fail_comb: Matrix of ones/zeros for combined pass/failing.
+        pass_fail_9: Matrix of ones/zeros for 9AM pass/failing.
+        pass_fail_3:  Matrix of ones/zeros for 3PM pass/failing.
+        filter_pattern: Pattern used to filter the grids.
+    """
+    # get the grids_info.json and determine which grids we are working with
+    res_folder_9 = os.path.join(folder, '9AM', 'results')
+    info_json = os.path.join(res_folder_9, 'grids_info.json')
+    with open(info_json) as data_f:
+        data = json.load(data_f)
+    grids = _filter_by_pattern(data, filter=filter_pattern)
+
+    # create the directories into which the files will be written
+    output_folder = os.path.join(folder, sub_folder)
+    folder_comb = os.path.join(output_folder, 'combined')
+    folder_9 = os.path.join(output_folder, '9AM')
+    folder_3 = os.path.join(output_folder, '3PM')
+    for sub_dir in (folder_comb, folder_9, folder_3):
+        if not os.path.isdir(sub_dir):
+            os.makedirs(sub_dir)
+        shutil.copyfile(info_json, os.path.join(sub_dir, 'grids_info.json'))
+
+    # loop through each grid and write the results into files
+    for g_d, res_c, res_9, res_3 in zip(grids, pass_fail_comb, pass_fail_9, pass_fail_3):
+        g_file_name = '%s.res' % g_d['full_id']
+        file_c = os.path.join(folder_comb, g_file_name)
+        file_9 = os.path.join(folder_9, g_file_name)
+        file_3 = os.path.join(folder_3, g_file_name)
+
+        with open(file_c, 'w') as fc, open(file_9, 'w') as f9, open(file_3, 'w') as f3:
+            for rc, r9, r3 in zip(res_c, res_9, res_3):
+                fc.write(str(rc) + '\n')
+                f9.write(str(r9) + '\n')
+                f3.write(str(r3) + '\n')
+
+
+def _sum_passing_area(pass_fails, grid_areas):
+    """Compute the sum of passing area given aligned pass_fail and grid_area matrices.
+    """
+    area_passing = 0
+    for pf, ga in zip(pass_fails, grid_areas):
+        if pf == 1:
+            area_passing += ga
+    return area_passing
+
+
+def _sum_all_passing_area(pass_fails, grid_areas):
+    """Compute the sum of passing area given aligned pass_fail and grid_area matrices.
+    """
+    area_passing = 0
+    for p_fails, g_areas in zip(pass_fails, grid_areas):
+        for pf, ga in zip(p_fails, g_areas):
+            if pf == 1:
+                area_passing += ga
+    return area_passing
+
+
+def _space_by_space_summary(
+        folder, sub_folder, grid_areas, units_conversion,
+        pass_fail_comb, pass_fail_9, pass_fail_3, filter_pattern):
+    """Write a CSV with space-by-space information for the percentage of sensors passing.
+
+    Args:
+        folder: Project folder for a LEED daylight illuminance simulation.
+        sub_folder: Relative path for a subfolder to write the pass/fail files for
+            each sensor grid.
+        grid_areas: A matrix of numbers for the area occupied by each sensor.
+        units_conversion: A number for the conversion factor from the grid_areas units
+            to Meters.
+        pass_fail_comb: Matrix of ones/zeros for combined pass/failing.
+        pass_fail_9: Matrix of ones/zeros for 9AM pass/failing.
+        pass_fail_3:  Matrix of ones/zeros for 3PM pass/failing.
+        filter_pattern: Pattern used to filter the grids.
+    """
+     # get the grids_info.json and determine which grids we are working with
+    res_folder_9 = os.path.join(folder, '9AM', 'results')
+    info_json = os.path.join(res_folder_9, 'grids_info.json')
+    with open(info_json) as data_f:
+        data = json.load(data_f)
+    grids = _filter_by_pattern(data, filter=filter_pattern)
+
+    # define the header row of the CSV
+    csv_data = [['Space Name', 'Sensor Count']]
+    if len(grid_areas) == len(pass_fail_9):  # compute passing floor area for each grid
+        csv_data[0].extend(['Area (m2)', 'Area (ft2)', 'Spacing (m)'])
+    csv_data[0].extend(['% Passing 9AM', '% Passing 3PM', '% Passing Combined'])
+
+    # loop through each grid and get the rows of the CSV
+    if len(grid_areas) == len(pass_fail_9):
+        all_data = zip(grids, grid_areas, pass_fail_comb, pass_fail_9, pass_fail_3)
+        for gr, gr_a, res_c, res_9, res_3 in all_data:
+            csv_row = [gr['name'], gr['count']]
+            total_a = sum(gr_a)
+            csv_row.append(round(total_a * units_conversion, 3))
+            csv_row.append(round(csv_row[2] / 0.305, 3))
+            csv_row.append(round(math.sqrt(csv_row[2] / csv_row[1]), 3))
+            csv_row.append(round(100 * (_sum_passing_area(res_9, gr_a) / total_a), 2))
+            csv_row.append(round(100 * (_sum_passing_area(res_3, gr_a) / total_a), 2))
+            csv_row.append(round(100 * (_sum_passing_area(res_c, gr_a) / total_a), 2))
+            csv_data.append(csv_row)
+    else:
+        all_data = zip(grids, pass_fail_comb, pass_fail_9, pass_fail_3)
+        for gr, res_c, res_9, res_3 in all_data:
+            csv_row = [gr['name'], gr['count']]
+            total_count = csv_row[1]
+            csv_row.append(round(100 * (sum(res_9) / total_count), 2))
+            csv_row.append(round(100 * (sum(res_3) / total_count), 2))
+            csv_row.append(round(100 * (sum(res_c) / total_count), 2))
+            csv_data.append(csv_row)
+
+    # write the results into a CSV
+    output_file = os.path.join(folder, sub_folder, 'space_summary.csv')
+    with open(output_file, 'w') as of:
+        for row in csv_data:
+            of.write(','.join((str(v) for v in row)) + '\n')
+
+
+def leed_illuminance_to_folder(
+        folder, glare_control=True, grids_filter='*', sub_folder=None):
+    """Estimate LEED daylight credits from two point-in-time illuminance folders.
+
+    Args:
+        folder: Project folder for a LEED illuminance simulation. It should contain
+            a HBJSON model and two sub-folders of complete point-in-time illuminance
+            simulations labeled "9AM" and "3PM". These two sub-folders should each
+            have results folders that include a grids_info.json and .res files with
+            illuminance values for each sensor. If Meshes are found for the sensor
+            grids in the HBJSON file, they will be used to compute percentages
+            of occupied floor area that pass vs. fail. Otherwise, all sensors will
+            be assumed to represent an equal amount of floor area.
+        glare_control: A boolean for whether the model has "view-preserving automatic
+            (with manual override) glare-control devices," which means that illuminance
+            only needs to be above 300 lux and not between 300 and 3000 lux.
+        grids_filter: A pattern to filter the grids. By default all the grids will be
+            processed.
+        sub_folder: Relative path for a subfolder to write the pass/fail files for
+            each sensor grid and a space-by-space summary CSV. If None, the files
+            will not be written and only the summary dictionary will be calculated.
+
+    Returns:
+        A dictionary with a summary of LEED credits in the format below. All
+        percentages are between 0 and 100 and the floor areas are in the units system
+        of the HBJSON model. If no sensor grid meshes were found in the HBJSON
+        model and no areas could be associated with each mesh face, the output
+        will not contain floor_area keys and each sensor will be assumed to
+        occupy a similar area.
+
+    .. code-block:: python
+
+        {
+            "credits": 2,
+            "percentage_passing": 76.2,
+            "percentage_passing_9AM": 78.5,
+            "percentage_passing_3PM": 82.4,
+            "sensor_count_passing": 762,
+            "sensor_count_passing_9AM": 785,
+            "sensor_count_passing_3PM": 824,
+            "total_sensor_count": 1000,
+            "floor_area_passing": 762.0,
+            "floor_area_passing_9AM": 785.0,
+            "floor_area_passing_3PM": 824.0,
+            "total_floor_area": 1000.0
+        }
+    """
+    # first load the results into pass/fail matrices of ones/zeros
+    res_folder_9 = os.path.join(folder, '9AM', 'results')
+    res_folder_3 = os.path.join(folder, '3PM', 'results')
+    pass_fail_9 = ill_pass_fail_from_folder(res_folder_9, glare_control, grids_filter)
+    pass_fail_3 = ill_pass_fail_from_folder(res_folder_3, glare_control, grids_filter)
+
+    # determine which sensors pass for both hours
+    pass_fail_comb = []
+    for p_fails9, p_fails3 in zip(pass_fail_9, pass_fail_3):
+        p_fails_comb = []
+        for pf9, pf3 in zip(p_fails9, p_fails3):
+            if pf9 == 1 and pf3 == 1:
+                p_fails_comb.append(1)
+            else:
+                p_fails_comb.append(0)
+        pass_fail_comb.append(p_fails_comb)
+
+    # next, check to see if there is a HBJSON with sensor grid meshes for areas
+    grid_areas, units_conversion = [], 1
+    for base_file in os.listdir(folder):
+        if base_file.endswith('.hbjson') or base_file.endswith('.hbpkl'):
+            hb_model = Model.from_file(os.path.join(folder, base_file))
+            units_conversion = conversion_factor_to_meters(hb_model.units)
+            filt_grids = _filter_by_pattern(
+                hb_model.properties.radiance.sensor_grids, filter=grids_filter)
+            for s_grid in filt_grids:
+                if s_grid.mesh is not None:
+                    grid_areas.append(s_grid.mesh.face_areas)
+
+    # write the pass/fail criteria into the sub-directory if specified
+    if sub_folder:
+        _pass_fail_to_files(
+            folder, sub_folder, pass_fail_comb, pass_fail_9, pass_fail_3, grids_filter)
+        _space_by_space_summary(
+            folder, sub_folder, grid_areas, units_conversion,
+            pass_fail_comb, pass_fail_9, pass_fail_3, grids_filter)
+
+    # setup the summary dictionary with the results
+    summary_dict = {
+        'sensor_count_passing': sum(sum(pf) for pf in pass_fail_comb),
+        'sensor_count_passing_9AM': sum(sum(pf9) for pf9 in pass_fail_9),
+        'sensor_count_passing_3PM': sum(sum(pf3) for pf3 in pass_fail_3),
+        'total_sensor_count': sum(len(pf9) for pf9 in pass_fail_9)
+    }
+
+    # determine the percentage passing from either mesh areas or sensor counts
+    if len(grid_areas) == len(pass_fail_9):  # compute passing floor area for each grid
+        area_pass_comb = _sum_all_passing_area(pass_fail_comb, grid_areas)
+        area_pass_9 = _sum_all_passing_area(pass_fail_9, grid_areas)
+        area_pass_3 = _sum_all_passing_area(pass_fail_3, grid_areas)
+        area_total = sum(sum(sar) for sar in grid_areas)
+        summary_dict['floor_area_passing'] = area_pass_comb
+        summary_dict['floor_area_passing_9AM'] = area_pass_9
+        summary_dict['floor_area_passing_3PM'] = area_pass_3
+        summary_dict['total_floor_area'] = area_total
+        pct_pass = (area_pass_comb / area_total) * 100
+        pct_pass_9 = (area_pass_9 / area_total) * 100
+        pct_pass_3 = (area_pass_3 / area_total) * 100
+    else:
+        total_count = summary_dict['total_sensor_count']
+        pct_pass = (summary_dict['sensor_count_passing'] / total_count) * 100
+        pct_pass_9 = (summary_dict['sensor_count_passing_9AM'] / total_count) * 100
+        pct_pass_3 = (summary_dict['sensor_count_passing_3PM'] / total_count) * 100
+
+    # lastly, estimate the number of LEED credits from the percentage passing
+    summary_dict['percentage_passing'] = pct_pass
+    summary_dict['percentage_passing_9AM'] = pct_pass_9
+    summary_dict['percentage_passing_3PM'] = pct_pass_3
+    if pct_pass >= 90:
+        summary_dict['credits'] = 3
+    elif pct_pass >= 75:
+        summary_dict['credits'] = 2
+    elif pct_pass >= 55:
+        summary_dict['credits'] = 1
+    else:
+        summary_dict['credits'] = 0
+    return summary_dict

honeybee_radiance/postprocess/solartracking.py

@@ -0,0 +1,90 @@
+"""Functions for post-processing results of dynamic objects that track the sun."""
+import os
+import json
+import shutil
+import math
+
+from ladybug_geometry.geometry3d.pointvector import Vector3D
+from ladybug.sunpath import Sunpath
+
+
+def post_process_solar_tracking(
+        result_folders, sun_up_file, location, north=0, tracking_increment=5,
+        destination_folder=None):
+    """Postprocess a list of result folders to account for dynamic solar tracking.
+
+    This function essentially takes .ill files for each state of a dynamic tracking
+    system and produces a single .ill file that models the tracking behavior.
+
+    Args:
+        result_folders: A list of folders containing .ill files and each representing
+            a state of the dynamic solar tracking system. These file should be
+            ordered from eastern-most to wester-most, tracing the path of the
+            tracking system over the day. The names of the .ill files should be
+            the same in each folder (representing the same sensor grid in a
+            different state).
+        sun_up_file: Path to a sun-up-hours.txt that contains the sun-up hours of
+            the simulation.
+        location: A Ladybug Location object to be used to generate sun poisitions.
+        north_: A number between -360 and 360 for the counterclockwise difference
+            between the North and the positive Y-axis in degrees. (Default: 0).
+        tracking_increment: An integer for the increment angle of each state in
+            degrees. (Default: 5).
+        destination_folder: A path to a destination folder where the final .ill
+            files of the dynamic tracking system will be written. If None, all
+            files will be written into the directory above the first result_folder.
+            (Default: None).
+    """
+    # get the orientation angles of the panels for each model
+    st_angle = int(90 - (len(result_folders) * tracking_increment / 2)) + 1
+    end_angle = int(90 + (len(result_folders) * tracking_increment / 2))
+    angles = list(range(st_angle, end_angle, tracking_increment))
+
+    # create a sun path ang get the sun-up hours to be used to get solar positions
+    sp = Sunpath.from_location(location, north)
+    with open(sun_up_file) as suh_file:
+        sun_up_hours = [float(hour) for hour in suh_file.readlines()]
+
+    # for each hour of the sun_up_hours, figure out which file is the one to use
+    mtx_to_use, ground_vec = [], Vector3D(1, 0, 0)
+    for hoy in sun_up_hours:
+        sun = sp.calculate_sun_from_hoy(hoy)
+        vec = Vector3D(sun.sun_vector_reversed.x, 0, sun.sun_vector_reversed.z)
+        orient = math.degrees(ground_vec.angle(vec))
+        for i, ang in enumerate(angles):
+            if ang > orient:
+                mtx_to_use.append(i)
+                break
+        else:
+            mtx_to_use.append(-1)
+
+    # parse the grids_info in the first folder to understand the sensor grids
+    grids_info_file = os.path.join(result_folders[0], 'grids_info.json')
+    with open(grids_info_file) as gi_file:
+        grids_data = json.load(gi_file)
+    grid_ids = [g['full_id'] for g in grids_data]
+
+    # prepare the destination folder and copy the grids_info to it
+    if destination_folder is None:
+        destination_folder = os.path.dirname(result_folders[0])
+    if not os.path.isdir(destination_folder):
+        os.mkdir(destination_folder)
+    shutil.copyfile(grids_info_file, os.path.join(destination_folder, 'grids_info.json'))
+
+    # convert the .ill files of each sensor grid into a single .ill file
+    for grid_id in grid_ids:
+        grid_mtx = []
+        for i, model in enumerate(result_folders):
+            grid_file = os.path.join(model, '{}.ill'.format(grid_id))
+            with open(grid_file) as ill_file:
+                grid_mtx.append([lin.split() for lin in ill_file])
+        grid_ill = []
+        for i, hoy_mtx in enumerate(mtx_to_use):
+            hoy_vals = []
+            for pt in range(len(grid_mtx[0])):
+                hoy_vals.append(grid_mtx[hoy_mtx][pt][i])
+            grid_ill.append(hoy_vals)
+        dest_file = os.path.join(destination_folder, '{}.ill'.format(grid_id))
+        with open(dest_file, 'w') as ill_file:
+            for row in zip(*grid_ill):
+                ill_file.write('  '.join(row) + '\n')