NREL-reV 0.14.4__tar.gz → 0.14.5__tar.gz

{nrel_rev-0.14.4 → nrel_rev-0.14.5/NREL_reV.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NREL-reV
-Version: 0.14.4
+Version: 0.14.5
 Summary: National Renewable Energy Laboratory's (NREL's) Renewable Energy Potential(V) Model: reV
 Author-email: Galen Maclaurin <galen.maclaurin@nrel.gov>
 Maintainer-email: Grant Buster <gbuster@nrel.gov>, Paul Pinchuk <ppinchuk@nrel.gov>

{nrel_rev-0.14.4/NREL_reV.egg-info → nrel_rev-0.14.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: NREL-reV
-Version: 0.14.4
+Version: 0.14.5
 Summary: National Renewable Energy Laboratory's (NREL's) Renewable Energy Potential(V) Model: reV
 Author-email: Galen Maclaurin <galen.maclaurin@nrel.gov>
 Maintainer-email: Grant Buster <gbuster@nrel.gov>, Paul Pinchuk <ppinchuk@nrel.gov>

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/bespoke/bespoke.py

@@ -310,7 +310,24 @@ class BespokeSinglePlant:
                   cost ($) as evaluated by
                   `balance_of_system_cost_function`
                 - ``self.wind_plant``: the SAM wind plant object,
-                  through which all SAM variables can be accessed
+                  through which all SAM variables can be accessed.
+
+                  .. IMPORTANT::
+                     When using the `self.wind_plant` variable,
+                     DO NOT include quotes around variable names (keys).
+
+                        - ❌ Wrong: ``self.wind_plant["annual_energy"]``
+                        - ✅ Correct: ``self.wind_plant[annual_energy]``
+
+                  .. IMPORTANT::
+                     It's possible for SAM wind plant variables to be
+                     ``None``, especially if something went wrong while
+                     optimizing the wind plant layout. In this case,
+                     your objective function may fail to evaluate and
+                     terminate the program entirely. To avoid this, add
+                     a default value for the variable in your objective
+                     function, like so:
+                     ``(self.wind_plant[annual_energy] or 0)``
 
         capital_cost_function : str
             The plant capital cost function as a string, must return the total
@@ -1265,6 +1282,14 @@ class BespokeSinglePlant:
             for k, v in plant.outputs.items():
                 self._outputs[k + "-{}".format(year)] = v
 
+        self._compute_output_means()
+        self._add_extra_meta_columns()
+        logger.debug("Timeseries analysis complete!")
+
+        return self.outputs
+
+    def _compute_output_means(self):
+        """Compute time series means and store them in the outputs dict"""
         means = {}
         for k1, v1 in self._outputs.items():
             if isinstance(v1, Number) and parse_year(k1, option="boolean"):
@@ -1277,6 +1302,9 @@ class BespokeSinglePlant:
 
         self._outputs.update(means)
 
+    def _add_extra_meta_columns(self):
+        """Copy over some non-temporal datasets to meta"""
+
         self._meta[SupplyCurveField.MEAN_RES] = self.res_df["windspeed"].mean()
         self._meta[SupplyCurveField.MEAN_CF_DC] = np.nan
         self._meta[SupplyCurveField.MEAN_CF_AC] = np.nan
@@ -1302,10 +1330,6 @@ class BespokeSinglePlant:
                 self.outputs["annual_wake_loss_internal_percent-means"]
             )
 
-        logger.debug("Timeseries analysis complete!")
-
-        return self.outputs
-
     def run_plant_optimization(self):
         """Run the wind plant layout optimization and export outputs
         to outputs property.
@@ -1626,7 +1650,24 @@ class BespokeWindPlants(BaseAggregation):
                   cost ($) as evaluated by
                   `balance_of_system_cost_function`
                 - ``self.wind_plant``: the SAM wind plant object,
-                  through which all SAM variables can be accessed
+                  through which all SAM variables can be accessed.
+
+                  .. IMPORTANT::
+                     When using the `self.wind_plant` variable,
+                     DO NOT include quotes around variable names (keys).
+
+                        - ❌ Wrong: ``self.wind_plant["annual_energy"]``
+                        - ✅ Correct: ``self.wind_plant[annual_energy]``
+
+                  .. IMPORTANT::
+                     It's possible for SAM wind plant variables to be
+                     ``None``, especially if something went wrong while
+                     optimizing the wind plant layout. In this case,
+                     your objective function may fail to evaluate and
+                     terminate the program entirely. To avoid this, add
+                     a default value for the variable in your objective
+                     function, like so:
+                     ``(self.wind_plant[annual_energy] or 0)``
 
         capital_cost_function : str
             The plant capital cost function written out as a string.

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/bespoke/place_turbines.py

@@ -3,6 +3,7 @@
 """
 place turbines for bespoke wind plants
 """
+import re
 from functools import wraps
 
 import numpy as np
@@ -96,7 +97,24 @@ class PlaceTurbines:
                   cost ($) as evaluated by
                   `balance_of_system_cost_function`
                 - ``self.wind_plant``: the SAM wind plant object,
-                  through which all SAM variables can be accessed
+                  through which all SAM variables can be accessed.
+
+                  .. IMPORTANT::
+                     When using the `self.wind_plant` variable,
+                     DO NOT include quotes around variable names (keys).
+
+                        - ❌ Wrong: ``self.wind_plant["annual_energy"]``
+                        - ✅ Correct: ``self.wind_plant[annual_energy]``
+
+                  .. IMPORTANT::
+                     It's possible for SAM wind plant variables to be
+                     ``None``, especially if something went wrong while
+                     optimizing the wind plant layout. In this case,
+                     your objective function may fail to evaluate and
+                     terminate the program entirely. To avoid this, add
+                     a default value for the variable in your objective
+                     function, like so:
+                     ``(self.wind_plant[annual_energy] or 0)``
 
         capital_cost_function : str
             The plant capital cost function as a string, must return the
@@ -133,13 +151,15 @@ class PlaceTurbines:
         # inputs
         self.wind_plant = wind_plant
 
-        self.capital_cost_function = capital_cost_function
-        self.fixed_operating_cost_function = fixed_operating_cost_function
-        self.variable_operating_cost_function = \
-            variable_operating_cost_function
-        self.balance_of_system_cost_function = balance_of_system_cost_function
+        self.capital_cost_function = _fix_wp_keys(capital_cost_function)
+        self.fixed_operating_cost_function = _fix_wp_keys(
+            fixed_operating_cost_function)
+        self.variable_operating_cost_function = _fix_wp_keys(
+            variable_operating_cost_function)
+        self.balance_of_system_cost_function = _fix_wp_keys(
+            balance_of_system_cost_function)
 
-        self.objective_function = objective_function
+        self.objective_function = _fix_wp_keys(objective_function)
         self.include_mask = include_mask
         self.pixel_side_length = pixel_side_length
         self.min_spacing = min_spacing
@@ -158,7 +178,6 @@ class PlaceTurbines:
         self.safe_polygons = None
         self._optimized_nn_conn_dist_m = None
 
-        self.ILLEGAL = ('import ', 'os.', 'sys.', '.__', '__.', 'eval', 'exec')
         self._preflight(self.objective_function)
         self._preflight(self.capital_cost_function)
         self._preflight(self.fixed_operating_cost_function)
@@ -167,7 +186,10 @@ class PlaceTurbines:
 
     def _preflight(self, eqn):
         """Run preflight checks on the equation string."""
-        for substr in self.ILLEGAL:
+        _illegal_substr = ('import ', 'os.', 'sys.', '.__', '__.', 'eval',
+                           'exec')
+
+        for substr in _illegal_substr:
             if substr in str(eqn):
                 msg = ('Will not evaluate string which contains "{}": {}'
                        .format(substr, eqn))
@@ -656,3 +678,10 @@ def _compute_nn_conn_dist(x_coords, y_coords):
         left_to_connect.mask[next_connection] = 1
 
     return total_dist
+
+
+def _fix_wp_keys(eqn):
+    """Surround key of `self.wind_plant` in quotes"""
+    pattern = r'(self\.wind_plant\[\s*)([^\]]+?)(\s*\])'
+    replacement = r'\1"\2"\3'
+    return re.sub(pattern, replacement, str(eqn))

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/cli.py

@@ -10,7 +10,8 @@ from reV.generation.cli_gen import gen_command
 from reV.econ.cli_econ import econ_command
 from reV.handlers.cli_collect import collect_command
 from reV.handlers.cli_multi_year import my_command
-from reV.supply_curve.cli_sc_aggregation import sc_agg_command
+from reV.supply_curve.cli_sc_aggregation import (sc_agg_command,
+                                                 sc_col_descriptions)
 from reV.supply_curve.cli_supply_curve import sc_command
 from reV.supply_curve.cli_tech_mapping import tm_command
 from reV.rep_profiles.cli_rep_profiles import rep_profiles_command
@@ -31,6 +32,7 @@ commands = [bespoke_command, gen_command, econ_command, collect_command,
 main = make_cli(commands, info={"name": "reV", "version": __version__})
 main.add_command(qa_qc_extra)
 main.add_command(project_points)
+main.add_command(sc_col_descriptions)
 
 # export GAPs commands to namespace for documentation
 batch = main.commands["batch"]

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/config/project_points.py

@@ -627,10 +627,14 @@ class ProjectPoints:
         # pylint: disable=no-member
         if SiteDataField.CONFIG not in df.columns:
             df[SiteDataField.CONFIG] = None
+        df[SiteDataField.CONFIG] = (df[SiteDataField.CONFIG]
+                                    .replace({np.nan: None}))
 
         # pylint: disable=no-member
         if SiteDataField.CURTAILMENT not in df.columns:
             df[SiteDataField.CURTAILMENT] = None
+        df[SiteDataField.CURTAILMENT] = (df[SiteDataField.CURTAILMENT]
+                                         .replace({np.nan: None}))
 
         gids = df[SiteDataField.GID].values
         if not np.array_equal(np.sort(gids), gids):

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/supply_curve/cli_sc_aggregation.py

@@ -2,16 +2,21 @@
 """
 reV Supply Curve Aggregation CLI utility functions.
 """
-import os
 import logging
+from pathlib import Path
 
+import click
+import pandas as pd
+from rex import init_logger
 from rex.multi_file_resource import MultiFileResource
 from rex.utilities.utilities import check_res_file
 from gaps.cli import as_click_command, CLICommandFromClass
 
+from reV import __version__
 from reV.supply_curve.sc_aggregation import SupplyCurveAggregation
 from reV.utilities import ModuleName
-from reV.utilities.cli_functions import parse_from_pipeline
+from reV.utilities.cli_functions import (parse_from_pipeline,
+                                         compile_descriptions)
 from reV.utilities.exceptions import ConfigError
 
 
@@ -103,6 +108,38 @@ sc_agg_command = CLICommandFromClass(SupplyCurveAggregation, method="run",
 main = as_click_command(sc_agg_command)
 
 
+@click.command()
+@click.version_option(version=__version__)
+@click.option('--sc_fpath', '-sc', type=click.Path(), default=None,
+              help='Supply curve CSV file path used to subset the columns')
+@click.option('--out_fp', '-of', default=None, type=click.Path(),
+              help='Output CSV file for the column descriptions')
+@click.pass_context
+def sc_col_descriptions(ctx, sc_fpath, out_fp):
+    """Generate reV supply curve column descriptions"""
+    if ctx.obj.get('VERBOSE', False):
+        log_level = 'DEBUG'
+    else:
+        log_level = 'INFO'
+
+    init_logger('reV', log_level=log_level)
+
+    cols = []
+    if sc_fpath:
+        cols = pd.read_csv(sc_fpath, nrows=0).columns.tolist()
+
+    if not out_fp:
+        if sc_fpath:
+            sc_name = Path(sc_fpath).stem
+            out_fp = Path(sc_fpath).parent / f"{sc_name}_column_lookup.csv"
+        else:
+            out_fp = "rev_supply_curve_column_lookup.csv"
+
+    columns = compile_descriptions(cols)
+    columns.to_csv(out_fp, index=False)
+    logger.info("Column descriptions saved to %s", out_fp)
+
+
 if __name__ == '__main__':
     try:
         main(obj={})

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/supply_curve/exclusions.py

@@ -3,6 +3,7 @@
 Generate reV inclusion mask from exclusion layers
 """
 import logging
+import fnmatch
 from warnings import warn
 
 import numpy as np
@@ -132,10 +133,10 @@ class LayerMask:
             layer is equal to 1, 2, 3, 4, or 5**. Outside of these
             regions (i.e. outside of federal park regions), the viewshed
             exclusion is **NOT** applied. If the extent mask created by
-            these options is not boolean, an error is thrown (i.e. do
-            not specify `weight` or `use_as_weights`).
-            By default ``None``, which applies the original layer mask
-            to the full extent.
+            these options is not boolean, an error is thrown (in other
+            words, do not specify `weight` or `use_as_weights` or else
+            you will run into errors). By default ``None``, which
+            applies the original layer mask to the full extent.
         **kwargs
             Optional inputs to maintain legacy kwargs of ``inclusion_*``
             instead of ``include_*``.
@@ -600,19 +601,7 @@ class ExclusionMask:
         self._check_layers = check_layers
 
         if layers is not None:
-            if not isinstance(layers, list):
-                layers = [layers]
-
-            missing = [layer.name for layer in layers
-                       if layer.name not in self.excl_layers]
-            if any(missing):
-                msg = ("ExclusionMask layers {} are missing from: {}"
-                       .format(missing, self._excl_h5))
-                logger.error(msg)
-                raise KeyError(msg)
-
-            for layer in layers:
-                self.add_layer(layer)
+            self._add_many_layers(layers)
 
         if kernel in ["queen", "rook"]:
             self._min_area = min_area
@@ -623,6 +612,22 @@ class ExclusionMask:
         else:
             raise KeyError('kernel must be "queen" or "rook"')
 
+    def _add_many_layers(self, layers):
+        """Add multiple layers (with check for missing layers)"""
+        if not isinstance(layers, list):
+            layers = [layers]
+
+        missing = [layer.name for layer in layers
+                   if layer.name not in self.excl_layers]
+        if any(missing):
+            msg = ("ExclusionMask layers {} are missing from: {}"
+                   .format(missing, self._excl_h5))
+            logger.error(msg)
+            raise KeyError(msg)
+
+        for layer in layers:
+            self.add_layer(layer)
+
     def __enter__(self):
         return self
 
@@ -1113,7 +1118,7 @@ class ExclusionMaskFromDict(ExclusionMask):
         excl_h5 : str | list | tuple
             Path to one or more exclusions .h5 files
         layers_dict : dict | NoneType
-            Dictionary of LayerMask arugments {layer: {kwarg: value}}
+            Dictionary of LayerMask arguments {layer: {kwarg: value}}
         min_area : float | NoneType
             Minimum required contiguous area in sq-km
         kernel : str
@@ -1125,16 +1130,34 @@ class ExclusionMaskFromDict(ExclusionMask):
             Run a pre-flight check on each layer to ensure they contain
             un-excluded values
         """
-        if layers_dict is not None:
-            layers = []
-            for layer, kwargs in layers_dict.items():
-                layers.append(LayerMask(layer, **kwargs))
-        else:
-            layers = None
-
-        super().__init__(excl_h5, layers=layers, min_area=min_area,
+        super().__init__(excl_h5, layers=layers_dict, min_area=min_area,
                          kernel=kernel, hsds=hsds, check_layers=check_layers)
 
+    def _add_many_layers(self, layers):
+        """Add multiple layers (with check for missing layers)"""
+        missing = set()
+        final_layers = {}
+
+        # sort pattern-first so that users can overwrite specific layers
+        sorted_layers = sorted(layers, key=_unix_patterns_first)
+        for layer_pattern in sorted_layers:
+            kwargs = layers[layer_pattern]
+            layer_names = fnmatch.filter(self.excl_layers, layer_pattern)
+            if not layer_names:
+                missing.add(layer_pattern)
+
+            for layer in layer_names:
+                final_layers[layer] = LayerMask(layer, **kwargs)
+
+        if any(missing):
+            msg = ("ExclusionMask layers {} are missing from: {}"
+                   .format(missing, self._excl_h5))
+            logger.error(msg)
+            raise KeyError(msg)
+
+        for layer in final_layers.values():
+            self.add_layer(layer)
+
     @classmethod
     def extract_inclusion_mask(cls, excl_fpath, tm_dset, excl_dict=None,
                                area_filter_kernel='queen', min_area=None):
@@ -1295,3 +1318,9 @@ class FrictionMask(ExclusionMask):
             mask = f.mask
 
         return mask
+
+
+def _unix_patterns_first(layer_name):
+    """Key that will put layer names with unix patterns first"""
+    special_chars = {"?", "*", "!", "[", "]"}
+    return -1 * any(char in layer_name for char in special_chars), layer_name

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/supply_curve/points.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# pylint: disable=anomalous-backslash-in-string
 """
 reV supply curve points frameworks.
 """
@@ -1452,8 +1453,12 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
     """Supply curve point summary framework that ties a reV SC point to its
     respective generation and resource data."""
 
-    # technology-dependent power density estimates in MW/km2
     POWER_DENSITY = {"pv": 36, "wind": 3}
+    """Technology-dependent power density estimates (in MW/km\ :sup:`2`).
+
+    The PV power density is a \**DC power density*\*, while the wind power
+    density is an \**AC power density*\*.
+    """
 
     def __init__(
         self,
@@ -2116,7 +2121,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             `None` for solar runs with "dc_ac_ratio" dataset in the
             generation file
         """
-        if self.power_density_ac is None:
+        if "dc_ac_ratio" not in self.gen.datasets:
             return None
 
         return self.area * self.power_density_ac
@@ -2138,7 +2143,7 @@ class GenerationSupplyCurvePoint(AggregationSupplyCurvePoint):
             `None` for solar runs with "dc_ac_ratio" dataset in the
             generation file
         """
-        if self.power_density_ac is None:
+        if "dc_ac_ratio" not in self.gen.datasets:
             return None
 
         return self.area * self.power_density

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/supply_curve/sc_aggregation.py

@@ -245,6 +245,7 @@ class SupplyCurveAggFileHandler(AbstractAggFileHandler):
 class SupplyCurveAggregation(BaseAggregation):
     """SupplyCurveAggregation"""
 
+    # pylint: disable=line-too-long
     def __init__(self, excl_fpath, tm_dset, econ_fpath=None,
                  excl_dict=None, area_filter_kernel='queen', min_area=None,
                  resolution=64, excl_area=None, res_fpath=None, gids=None,
@@ -334,6 +335,12 @@ class SupplyCurveAggregation(BaseAggregation):
                         "exclude_nodata": True,
                         "nodata_value": -1
                     },
+                    "wildcard*exclusion": {
+                        "exclude_values": 1,
+                    },
+                    "wildcard_unique_exclusion": {
+                        "exclude_values": [1, 2, 3],
+                    },
                     "partial_setback": {
                         "use_as_weights": True
                     },
@@ -359,9 +366,24 @@ class SupplyCurveAggregation(BaseAggregation):
                     ...
                 }
 
-            Note that all the keys given in this dictionary should be
-            datasets of the `excl_fpath` file. If ``None`` or empty
-            dictionary, no exclusions are applied. By default, ``None``.
+            Note that all the keys given in this dictionary must be
+            datasets of the `excl_fpath` file or you will get an error.
+            You *may* include Unix-style wildcards (i.e. ``*``, ``?``,
+            or ``[]``) in the keys, but note that the same exclusion
+            configuration will be applied to **all** datasets that match
+            the wildcard pattern unless you explicitly override it for a
+            specific layer. For example, in the configuration above,
+            **all** of the layers matching the pattern
+            ``wildcard*exclusion`` will be used as exclusions where the
+            respective layer values equal ``1``, **except** for the
+            ``wildcard_unique_exclusion`` layer, which will be used as
+            an exclusion wherever that particular layer values equal
+            ``1``, ``2``, or ``3``. You can use this strategy to
+            "exclude" layers from the wildcard match - simply set the
+            ``exclude_values`` key to a value that does not exist in
+            that layer and it will be effectively ignored. If ``None``
+            or empty dictionary, no exclusions are applied.
+            By default, ``None``.
         area_filter_kernel : {"queen", "rook"}, optional
             Contiguous area filter method to use on final exclusions
             mask. The filters are defined as::
@@ -484,16 +506,36 @@ class SupplyCurveAggregation(BaseAggregation):
             The ``"output_layer_name"`` is the column name under which
             the aggregated data will appear in the output CSV file. The
             ``"output_layer_name"`` does not have to match the ``dset``
-            input value. The latter should match the layer name in the
+            input value. The ``dset`` should match the layer name in the
             HDF5 from which the data to aggregate should be pulled. The
-            ``method`` should be one of
-            ``{"mode", "mean", "min", "max", "sum", "category"}``,
-            describing how the high-resolution data should be aggregated
-            for each supply curve point. ``fpath`` is an optional key
-            that can point to an HDF5 file containing the layer data. If
-            left out, the data is assumed to exist in the file(s)
-            specified by the `excl_fpath` input. If ``None``, no data
-            layer aggregation is performed. By default, ``None``
+            ``method`` key should be one of the following:
+
+                - ``"mode"``: Output values will be the numerical mode
+                  of the non-excluded high resolution data layer cell
+                  values
+                - ``"mean"``: Output values will be the arithmetic mean
+                  of the non-excluded high resolution data layer cell
+                  values
+                - ``"min"``: Output values will be the numerical minimum
+                  value of the non-excluded high resolution data layer
+                  cell values
+                - ``"max"``: Output values will be the numerical maximum
+                  value of the non-excluded high resolution data layer
+                  cell values
+                - ``"sum"``: Output values will be the sum of the
+                  non-excluded high resolution data layer cell values
+                - ``"category"``: Output values will be a string
+                  representation of a dictionary where the keys are the
+                  unique values of the non-excluded high resolution data
+                  layer cells and the values are the *total
+                  high-resolution pixel area* corresponding to that data
+                  layer value
+
+            ``fpath`` is an optional key that can point to an HDF5 file
+            containing the layer data. If left out, the data is assumed
+            to exist in the file(s) specified by the `excl_fpath` input.
+            If ``None``, no data layer aggregation is performed.
+            By default, ``None``
         power_density : float | str, optional
             Power density value (in MW/km\ :sup:`2`) or filepath to
             variable power density CSV file containing the following
@@ -503,8 +545,15 @@ class SupplyCurveAggregation(BaseAggregation):
                 - ``power_density`` : power density value (in
                   MW/km\ :sup:`2`)
 
-            If ``None``, a constant power density is inferred from the
-            generation meta data technology. By default, ``None``.
+            If you are running reV for PV (more specifically, you have a
+            `dc_ac_ratio` in your generation file), then this input
+            should represent the \**DC power density*\*. For all other
+            technologies (wind, geothermal, etc), this input should
+            represent the \**AC power density*\*. If ``None``, a
+            constant power density value is pulled from
+            :obj:`~reV.supply_curve.points.GenerationSupplyCurvePoint.POWER_DENSITY`
+            by looking up the technology from the generation meta data.
+            By default, ``None``.
         friction_fpath : str, optional
             Filepath to friction surface data (cost based exclusions).
             Must be paired with the `friction_dset` input below. The
@@ -1218,7 +1267,7 @@ class SupplyCurveAggregation(BaseAggregation):
                                          .format(gid, zone_id))
                         else:
                             pointsum['res_class'] = ri
-                            pointsum['zone_id'] = zone_id
+                            pointsum[SupplyCurveField.ZONE_ID] = zone_id
 
                             summary.append(pointsum)
                             logger.debug(

{nrel_rev-0.14.4 → nrel_rev-0.14.5}/reV/supply_curve/tech_mapping.py

@@ -32,6 +32,7 @@ class TechMapping:
 
     def __init__(self, excl_fpath, sc_resolution=1200):
         """
+
         Parameters
         ----------
         excl_fpath : str
@@ -44,9 +45,9 @@ class TechMapping:
             map the exclusion pixels in 1200x1200 pixel chunks.
 
             .. Note:: This parameter does not affect the exclusion to resource
-            (tech) mapping, which deviates from how the effect of the
-            ``sc_resolution`` parameter works in other functionality within
-            ``reV``.
+                      (tech) mapping, which deviates from how the effect of the
+                      ``sc_resolution`` parameter works in other functionality
+                      within ``reV``.
 
         """
         self._excl_fpath = excl_fpath
@@ -433,7 +434,7 @@ class TechMapping:
             techmap (exclusions-to-resource mapping data) will be saved.
 
             .. Important:: If this dataset already exists in the h5 file,
-              it will be overwritten.
+                           it will be overwritten.
 
         sc_resolution : int | None, optional
             Defines how many exclusion pixels are mapped at a time. Units
@@ -442,9 +443,9 @@ class TechMapping:
             map the exclusion pixels in 1200x1200 pixel chunks.
 
             .. Note:: This parameter does not affect the exclusion to resource
-            (tech) mapping, which deviates from how the effect of the
-            ``sc_resolution`` parameter works in other functionality within
-            ``reV``.
+                      (tech) mapping, which deviates from how the effect of the
+                      ``sc_resolution`` parameter works in other functionality
+                      within ``reV``.
 
         dist_margin : float, optional
             Extra margin to multiply times the computed distance between