pvfactors

https://sunpower.github.io/pvfactors/
Admin
pvfactors is an open-source Python library for calculating incident irradiance and view factors on...
Tokens:121,606
Snippets:798
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install pvfactors from source for contributing

Source: https://sunpower.github.io/pvfactors/installation/index.html

Install pvfactors from the root folder of the cloned repository using pip.

```bash
$ pip install .

```

--------------------------------

### Install pvfactors in editable mode

Source: https://sunpower.github.io/pvfactors/installation/index.html

Install pvfactors in editable mode for development.

```bash
$ pip install -e .

```

--------------------------------

### Install pvfactors with pip

Source: https://sunpower.github.io/pvfactors/installation/index.html

Install pvfactors using pip. Requires Python 3.6 or higher.

```bash
$ pip install pvfactors

```

--------------------------------

### Install shapely from conda-forge

Source: https://sunpower.github.io/pvfactors/installation/index.html

If pip installation of shapely fails with OSError: [WinError 126] The specified module could not be found, install shapely from conda-forge.

```bash
$ conda install -c conda-forge shapely

```

--------------------------------

### Import libraries and set up paths

Source: https://sunpower.github.io/pvfactors/tutorials/Account_for_AOI_losses.html

Sets up the environment for the tutorial: imports external libraries (os, numpy, matplotlib, datetime, pandas, warnings), configures plotting settings, and defines file paths for input data. Also sets the RUN_FIXED_TILT flag to True.

```python
# Import external libraries
import os
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
import pandas as pd
import warnings

# Settings
%matplotlib inline
np.set_printoptions(precision=3, linewidth=300)
warnings.filterwarnings('ignore')
plt.style.use('seaborn-whitegrid')
plt.rcParams.update({'font.size': 12})
# Paths
LOCAL_DIR = os.getcwd()
DATA_DIR = os.path.join(LOCAL_DIR, 'data')
filepath = os.path.join(DATA_DIR, 'test_df_inputs_MET_clearsky_tucson.csv')

RUN_FIXED_TILT = True
```

--------------------------------

### Create and fit PVEngine

Source: https://sunpower.github.io/pvfactors/tutorials/Account_for_AOI_losses.html

Create the PVEngine with the pvarray, vf_calculator, and irradiance_model, then fit it to the input data.

```python
# Create engine
engine = PVEngine(pvarray, vf_calculator=vf_calculator,
                  irradiance_model=irradiance_model)
# Fit engine to data
engine.fit(df_inputs.index, df_inputs.dni, df_inputs.dhi,
           df_inputs.solar_zenith, df_inputs.solar_azimuth,
           df_inputs.surface_tilt, df_inputs.surface_azimuth,
           albedo)

```

--------------------------------

### Import external libraries and configure settings

Source: https://sunpower.github.io/pvfactors/tutorials/Getting_started.html

Initializes the environment by importing necessary libraries and configuring matplotlib and numpy settings.

```python
# Import external libraries
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
import pandas as pd
import warnings
warnings.filterwarnings("ignore", category=RuntimeWarning)

# Settings
%matplotlib inline
np.set_printoptions(precision=3, linewidth=300)
```

--------------------------------

### PVGround.__init__

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvground.PVGround.html

Initializes the PV ground geometry with an optional list of PV segments and an optional original linestring.

```APIDOC
## PVGround.__init__

### Description
Initializes the PV ground geometry.

### Method
Constructor

### Signature
__init__(list_segments=None, original_linestring=None)

### Parameters
- **list_segments** (list of PVSegment, optional) - List of PV segments that will constitute the ground (Default = [])
- **original_linestring** (shapely.geometry.LineString, optional) - Full continuous linestring that the ground will be made of (Default = None)
```

--------------------------------

### TsLineCoords.at

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.timeseries.TsLineCoords.html

Get coordinates at a given index.

```APIDOC
## TsLineCoords.at

### Description
Get coordinates at a given index.

### Method
Method

### Parameters
- **idx** (int) - Required - Index to retrieve coordinates at
```

--------------------------------

### run_full_mode(fn_build_report=None)

Source: https://sunpower.github.io/pvfactors/_modules/pvfactors/engine.html

Run all simulation timesteps using the full mode, which calculates the equilibrium of reflections in the system, and returns a report that will be built by the function passed by the user.

```APIDOC
## run_full_mode(fn_build_report=None)

### Description
Run all simulation timesteps using the full mode, which calculates the equilibrium of reflections in the system, and returns a report that will be built by the function passed by the user.

### Parameters
- **fn_build_report** (function, optional) - Optional - Function that will build the report of the simulation (Default value = None)

### Returns
- **report** - Saved results from the simulation, as specified by user's report function. If no function is passed, nothing will be returned.
```

--------------------------------

### TsSurface.get_param

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.timeseries.TsSurface.html

Get timeseries parameter values of surface.

```APIDOC
## TsSurface.get_param

### Description
Get timeseries parameter values of surface.

### Method
Method

### Signature
get_param(param)

### Parameters
- **param** - The parameter name.

### Returns
Timeseries parameter values
```

--------------------------------

### TsSegment.get_param_weighted

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvrow.TsSegment.html

Gets timeseries parameter for the segment, after weighting by surface length.

```APIDOC
## TsSegment.get_param_weighted

### Description
Get timeseries parameter for the segment, after weighting by surface length.

### Method
get_param_weighted(param)

### Parameters
- **param** - Required - The parameter to retrieve.

### Returns
- Timeseries parameter weighted by surface length.
```

--------------------------------

### Imports and settings for full timeseries simulations

Source: https://sunpower.github.io/pvfactors/tutorials/Run_full_timeseries_simulations.html

Sets up the Python environment for the tutorial. Imports external libraries (os, numpy, matplotlib, datetime, pandas, warnings), enables inline plotting, sets numpy print options, ignores warnings, and defines local and data directory paths along with a filepath to a test CSV input file.

```python
# Import external libraries
import os
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
import pandas as pd
import warnings

# Settings
%matplotlib inline
np.set_printoptions(precision=3, linewidth=300)
warnings.filterwarnings('ignore')
# Paths
LOCAL_DIR = os.getcwd()
DATA_DIR = os.path.join(LOCAL_DIR, 'data')
filepath = os.path.join(DATA_DIR, 'test_df_inputs_MET_clearsky_tucson.csv')
```

--------------------------------

### PVSurface.__init__

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.base.PVSurface.html

Initializes a PV surface with optional coordinates, normal vector, shaded flag, index, parameter names, and parameters.

```APIDOC
## PVSurface.__init__

### Description
Initializes a PV surface object. The only difference from BaseSurface is that PV surfaces have a 'shaded' attribute.

### Method
Constructor

### Signature
PVSurface(coords=None, normal_vector=None, shaded=False, index=None, param_names=None, params=None)

### Parameters
- **coords** (list, optional) - List of linestring coordinates for the surface
- **normal_vector** (list, optional) - Normal vector for the surface (Default = None, so will be calculated)
- **shaded** (bool, optional) - Flag telling if surface is shaded or not (Default = False)
- **index** (int, optional) - Surface index (Default = None)
- **param_names** (list of str, optional) - Names of the surface parameters, eg reflectivity, total incident irradiance, temperature, etc. (Default = None)
- **params** (dict, optional) - Surface float parameters (Default = None)

### Returns
None
```

--------------------------------

### TsGround.get_param_weighted

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvground.TsGround.html

Get timeseries parameter for the ts ground, after weighting by surface length.

```APIDOC
## TsGround.get_param_weighted

### Description
Get timeseries parameter for the ts ground, after weighting by surface length.

### Method
Method

### Signature
`get_param_weighted(param)`

### Parameters
- **param** (str) - Required - Name of the parameter to retrieve.

### Returns
Weighted timeseries parameter values.
```

--------------------------------

### PVEngine class with rho initialization

Source: https://sunpower.github.io/pvfactors/_modules/pvfactors/engine.html

Defines the PVEngine class with its constructor and the with_rho_initialization classmethod. The constructor initializes the view factor calculator, irradiance model, and fast mode indices. The classmethod calculates front and back reflectivity using the VF calculator's rho_from_faoi_fn and initializes the irradiance model's rho values with defaults from pvfactors.config.

```python
"""This module contains the engine class that will run the complete
timeseries simulations."""

import numpy as np
from pvfactors.viewfactors import VFCalculator
from pvfactors.irradiance import HybridPerezOrdered
from pvfactors.config import DEFAULT_RHO_FRONT, DEFAULT_RHO_BACK



[docs]class PVEngine(object):
    """Class putting all of the calculations together into simple
    workflows.
    """


[docs]    def __init__(self, pvarray, vf_calculator=None, irradiance_model=None,
                 fast_mode_pvrow_index=None, fast_mode_segment_index=None):
        """Create pv engine class, and initialize timeseries parameters.

        Parameters
        ----------
        pvarray : BasePVArray (or child) object
            The initialized PV array object that will be used for calculations
        vf_calculator : vf calculator object, optional
            Calculator that will be used to calculate the view factor matrices,
            will use :py:class:`~pvfactors.viewfactors.calculator.VFCalculator`
            if None (Default = None)
        irradiance_model : irradiance model object, optional
            The irradiance model that will be applied to the PV array,
            will use
            :py:class:`~pvfactors.irradiance.models.HybridPerezOrdered`
            if None (Default = None)
        fast_mode_pvrow_index : int, optional
            If a pvrow index is passed, then the PVEngine fast mode
            will be activated and the engine calculation will be done only
            for the back surface of the pvrow with the corresponding
            index (Default = None)
        fast_mode_segment_index : int, optional
            If a segment index is passed, then the PVEngine fast mode
            will calculate back surface irradiance only for the
            selected segment of the selected back surface (Default = None)
        """
        # Initialize the attributes of the PV engine
        self.vf_calculator = vf_calculator or VFCalculator()
        self.irradiance = irradiance_model or HybridPerezOrdered()
        self.pvarray = pvarray
        # Save fast mode indices
        self.fast_mode_pvrow_index = fast_mode_pvrow_index
        self.fast_mode_segment_index = fast_mode_segment_index

        # These values will be updated at fitting time
        self.n_points = None
        self.skip_step = None


    @classmethod
    def with_rho_initialization(
            cls, pvarray, vf_calculator, irradiance_model,
            fast_mode_pvrow_index=None, fast_mode_segment_index=None):
        """Before creating the PV engine object, update the front and
        back reflectivity scalars using the faoi functions, if those values
        weren't passed originally

        Parameters
        ----------
        pvarray : :py:class:`~pvfactors.geometry.pvarray.OrderedPVArray`
            The initialized PV array object that will be used for calculations
        vf_calculator : \
        :py:class:`~pvfactors.viewfactors.calculator.VFCalculator`
            Calculator that will be used to calculate the view factor matrices,
            and AOI losses
        irradiance_model : irradiance model object
            The irradiance model that will be applied to the PV array,
            for instance
            :py:class:`~pvfactors.irradiance.models.HybridPerezOrdered`
        fast_mode_pvrow_index : int, optional
            If a pvrow index is passed, then the PVEngine fast mode
            will be activated and the engine calculation will be done only
            for the back surface of the pvrow with the corresponding
            index (Default = None)
        fast_mode_segment_index : int, optional
            If a segment index is passed, then the PVEngine fast mode
            will calculate back surface irradiance only for the
            selected segment of the selected back surface (Default = None)

        Returns
        -------
        PV engine
            PV engine where the rho values have been initialized
        """
        # Calculate global average reflectivity using VF calculator
        is_back = False
        rho_front_calculated = (vf_calculator.vf_aoi_methods
                                .rho_from_faoi_fn(is_back))
        is_back = True
        rho_back_calculated = (vf_calculator.vf_aoi_methods
                               .rho_from_faoi_fn(is_back))
        # Initialize rho values for irradiance model
        irradiance_model.rho_front = irradiance_model.initialize_rho(
            irradiance_model.rho_front, rho_front_calculated,
            DEFAULT_RHO_FRONT)
        irradiance_model.rho_back = irradiance_model.initialize_rho(
            irradiance_model.rho_back, rho_back_calculated,
            DEFAULT_RHO_BACK)

```

--------------------------------

### HybridPerezOrdered.get_full_modeling_vectors

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.irradiance.models.HybridPerezOrdered.html

Gets the modeling vectors used in matrix calculations of the mathematical model.

```APIDOC
## HybridPerezOrdered.get_full_modeling_vectors

### Description
Gets the modeling vectors used in matrix calculations of the mathematical model.

### Method
get_full_modeling_vectors(pvarray, idx)

### Parameters
- **pvarray** - The PV array object.
- **idx** - Index for the time step.

### Returns
Modeling vectors used in matrix calculations.
```

--------------------------------

### TsShadeCollection.get_param_weighted(param)

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.timeseries.TsShadeCollection.html

Gets timeseries parameter for the collection, after weighting by surface length.

```APIDOC
## TsShadeCollection.get_param_weighted(param)

### Description
Gets timeseries parameter for the collection, after weighting by surface length.

### Method
get_param_weighted

### Parameters
- **param** (type not specified) - Required - The parameter to retrieve.

### Returns
The weighted timeseries parameter.
```

--------------------------------

### Create and fit PVEngine with HybridPerezOrdered

Source: https://sunpower.github.io/pvfactors/tutorials/Account_for_AOI_losses.html

Creates a HybridPerezOrdered irradiance model with 3% front and 5% back reflection, then creates a PVEngine and fits it to the input data.

```python
from pvfactors.engine import PVEngine
from pvfactors.irradiance import HybridPerezOrdered
# Create irradiance model
irradiance_model = HybridPerezOrdered(rho_front=0.03, rho_back=0.05)
# Create engine
engine = PVEngine(pvarray, irradiance_model=irradiance_model)
# Fit engine to data
engine.fit(df_inputs.index, df_inputs.dni, df_inputs.dhi,
           df_inputs.solar_zenith, df_inputs.solar_azimuth,
           df_inputs.surface_tilt, df_inputs.surface_azimuth,
           albedo)

```

--------------------------------

### Prepare PV array parameters

Source: https://sunpower.github.io/pvfactors/tutorials/Create_discretized_pvarray.html

Define the dictionary of parameters required to initialize the PV array geometry.

```python
pvarray_parameters = {
    'n_pvrows': 3,            # number of pv rows
    'pvrow_height': 1,        # height of pvrows (measured at center / torque tube)
    'pvrow_width': 1,         # width of pvrows
    'axis_azimuth': 0.,       # azimuth angle of rotation axis
    'surface_tilt': 20.,      # tilt of the pv rows
    'surface_azimuth': 270.,   # azimuth of the pv rows front surface
    'solar_zenith': 40.,      # solar zenith angle
    'solar_azimuth': 150.,    # solar azimuth angle
    'gcr': 0.5,               # ground coverage ratio
}
```

--------------------------------

### TsSegment.surfaces_at_idx

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvrow.TsSegment.html

Gets all PV surface geometries in timeseries segment for a certain index.

```APIDOC
## TsSegment.surfaces_at_idx

### Description
Get all PV surface geometries in timeseries segment for a certain index.

### Method
surfaces_at_idx(idx)

### Parameters
- **idx** - Required - The index for which to retrieve the surfaces.

### Returns
- All PV surface geometries in the timeseries segment at the specified index.
```

--------------------------------

### Instantiate PVEngine and fit to data

Source: https://sunpower.github.io/pvfactors/tutorials/Run_fast_simulations.html

Creates an OrderedPVArray from parameters, instantiates a PVEngine with fast_mode_pvrow_index=1, and fits the engine to the timeseries data.

```python
# Import PVEngine and OrderedPVArray
from pvfactors.engine import PVEngine
from pvfactors.geometry import OrderedPVArray

# Instantiate PV array
pvarray = OrderedPVArray.init_from_dict(pvarray_parameters)
# Create PV engine, and specify the index of the PV row for fast mode
fast_mode_pvrow_index = 1  # look at the middle PV row
eng = PVEngine(pvarray, fast_mode_pvrow_index=fast_mode_pvrow_index)

# Fit PV engine to the timeseries data
eng.fit(df_inputs.index, df_inputs.dni, df_inputs.dhi,
        df_inputs.solar_zenith, df_inputs.solar_azimuth,
        df_inputs.surface_tilt, df_inputs.surface_azimuth,
        albedo)
```

--------------------------------

### ShadeCollection.get_param_weighted

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.base.ShadeCollection.html

Gets the parameter from the collection's surfaces, after weighting by surface length.

```APIDOC
## ShadeCollection.get_param_weighted

### Description
Gets the parameter from the collection's surfaces, after weighting by surface length.

### Method
get_param_weighted

### Parameters
- **param** (str) - The name of the parameter to retrieve.

### Returns
float - The weighted parameter value.
```

--------------------------------

### Create and fit PV array engine

Source: https://sunpower.github.io/pvfactors/tutorials/Getting_started.html

Initializes the PV array and engine, then fits the engine to the provided timeseries data.

```python
from pvfactors.engine import PVEngine
from pvfactors.geometry import OrderedPVArray

# Create an ordered PV array
pvarray = OrderedPVArray.init_from_dict(pvarray_parameters)
# Create engine using the PV array
engine = PVEngine(pvarray)
# Fit engine to data: which will update the pvarray object as well
engine.fit(df_inputs.index, df_inputs.dni, df_inputs.dhi,
           df_inputs.solar_zenith, df_inputs.solar_azimuth,
           df_inputs.surface_tilt, df_inputs.surface_azimuth,
           df_inputs.albedo)
```

--------------------------------

### TsGround.ts_surfaces_side_of_cut_point

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvground.TsGround.html

Get a list of all the ts ground surfaces an a request side of a cut point.

```APIDOC
## TsGround.ts_surfaces_side_of_cut_point

### Description
Get a list of all the ts ground surfaces an a request side of a cut point.

### Method
Method

### Signature
`ts_surfaces_side_of_cut_point(side, idx_cut_pt)`

### Parameters
- **side** (str) - Required - Side of the cut point (e.g., 'left' or 'right').
- **idx_cut_pt** (int) - Required - Index of the cut point.

### Returns
List of ts ground surfaces on the specified side.
```

--------------------------------

### BaseSurface.__init__

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.base.BaseSurface.html

Initializes a BaseSurface instance with linestring coordinates and optional normal vector, index, parameter names, and parameters.

```APIDOC
## BaseSurface.__init__

### Description
Create a surface using linestring coordinates. Normal vector can have two directions for a given LineString, so the user can provide it in order to be specific, otherwise it will be automatically calculated, but then the surface won't know if it was supposed to be pointing "up" or "down". If the surface is empty, the normal vector will take the default value.

### Parameters
- **coords** (list) - Required - List of linestring coordinates for the surface
- **normal_vector** (list, optional) - Normal vector for the surface (Default = None, so will be calculated)
- **index** (int, optional) - Surface index (Default = None)
- **param_names** (list of str, optional) - Names of the surface parameters, eg reflectivity, total incident irradiance, temperature, etc. (Default = None)
- **params** (dict, optional) - Surface float parameters (Default = None)
```

--------------------------------

### HybridPerezOrdered.get_summed_components

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.irradiance.models.HybridPerezOrdered.html

Gets the sum of irradiance components for the irradiance model, either absorbed or only incident.

```APIDOC
## HybridPerezOrdered.get_summed_components

### Description
Gets the sum of irradiance components for the irradiance model, either absorbed or only incident.

### Method
get_summed_components(pvarray, absorbed=False)

### Parameters
- **pvarray** - The PV array object.
- **absorbed** (bool, optional) - If True, returns absorbed irradiance; otherwise incident. Default = False.

### Returns
Summed irradiance components.
```

--------------------------------

### TsPVRow.surfaces_at_idx

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvrow.TsPVRow.html

Get all PV surface geometries in timeseries PV row for a certain index.

```APIDOC
## TsPVRow.surfaces_at_idx

### Description
Get all PV surface geometries in timeseries PV row for a certain index.

### Method
Method

### Signature
surfaces_at_idx(idx)

### Parameters
- **idx** - Required - The index for which to retrieve the surface geometries.
```

--------------------------------

### PVEngine.__init__

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.engine.PVEngine.html

Constructor for the PVEngine class. Initializes the engine with a PV array and optional configuration for view factor calculation, irradiance model, and fast mode settings.

```APIDOC
## PVEngine.__init__

### Description
Create pv engine class, and initialize timeseries parameters.

### Method
Constructor

### Signature
__init__(pvarray, vf_calculator=None, irradiance_model=None, fast_mode_pvrow_index=None, fast_mode_segment_index=None)

### Parameters
- **pvarray** (BasePVArray object) - Required - The initialized PV array object that will be used for calculations
- **vf_calculator** (vf calculator object, optional) - Optional - Calculator that will be used to calculate the view factor matrices, will use VFCalculator if None (Default = None)
- **irradiance_model** (irradiance model object, optional) - Optional - The irradiance model that will be applied to the PV array, will use HybridPerezOrdered if None (Default = None)
- **fast_mode_pvrow_index** (int, optional) - Optional - If a pvrow index is passed, then the PVEngine fast mode will be activated and the engine calculation will be done only for the back surface of the pvrow with the corresponding index (Default = None)
- **fast_mode_segment_index** (int, optional) - Optional - If a segment index is passed, then the PVEngine fast mode will calculate back surface irradiance only for the selected segment of the selected back surface (Default = None)
```

--------------------------------

### TsGround.shadow_coords_right_of_cut_point

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvground.TsGround.html

Get coordinates of shadows located on the right side of the cut point with given index.

```APIDOC
## TsGround.shadow_coords_right_of_cut_point

### Description
Get coordinates of shadows located on the right side of the cut point with given index.

### Method
Method

### Signature
`shadow_coords_right_of_cut_point(idx_cut_pt)`

### Parameters
- **idx_cut_pt** (int) - Required - Index of the cut point.

### Returns
Coordinates of shadows on the right side.
```

--------------------------------

### TsGround.shadow_coords_left_of_cut_point

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvground.TsGround.html

Get coordinates of shadows located on the left side of the cut point with given index.

```APIDOC
## TsGround.shadow_coords_left_of_cut_point

### Description
Get coordinates of shadows located on the left side of the cut point with given index.

### Method
Method

### Signature
`shadow_coords_left_of_cut_point(idx_cut_pt)`

### Parameters
- **idx_cut_pt** (int) - Required - Index of the cut point.

### Returns
Coordinates of shadows on the left side.
```

--------------------------------

### PVRow.__init__

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.pvrow.PVRow.html

Initializes a PV row with front and back sides, an index, and an optional original linestring.

```APIDOC
## PVRow.__init__

### Description
Initialize a PV row with front and back sides, an index, and an optional original linestring.

### Method
Constructor

### Signature
`__init__(front_side=<pvfactors.geometry.pvrow.PVRowSide object>, back_side=<pvfactors.geometry.pvrow.PVRowSide object>, index=None, original_linestring=None)`

### Parameters
- **front_side** (`PVRowSide`, optional) - Front side of the PV Row (Default = Empty PVRowSide)
- **back_side** (`PVRowSide`, optional) - Back side of the PV Row (Default = Empty PVRowSide)
- **index** (`int`, optional) - Index of PV row (Default = None)
- **original_linestring** (`shapely.geometry.LineString`, optional) - Full continuous linestring that the PV row will be made of (Default = None)

### Returns
None
```

--------------------------------

### TsShadeCollection.get_param_ww(param)

Source: https://sunpower.github.io/pvfactors/developer/generated/pvfactors.geometry.timeseries.TsShadeCollection.html

Gets timeseries parameter from the collection with weight, i.e. after multiplying by the surface lengths.

```APIDOC
## TsShadeCollection.get_param_ww(param)

### Description
Gets timeseries parameter from the collection with weight, i.e. after multiplying by the surface lengths.

### Method
get_param_ww

### Parameters
- **param** (type not specified) - Required - The parameter to retrieve.

### Returns
The weighted timeseries parameter.
```
Tokens:
Raw