artist.scenario

Bundle all classes relevant for the scenario in ARTIST.

Submodules

• artist.scenario.configuration_classes
• artist.scenario.h5_scenario_generator
• artist.scenario.scenario
• artist.scenario.surface_generator

Classes

ActuatorConfig	Initialize the actuator configuration.
ActuatorListConfig	Initialize the actuator list configuration.
ActuatorParameters	Initialize the actuator parameters.
ActuatorPrototypeConfig	Initialize the actuator list prototype configuration.
FacetConfig	Initialize the facet configuration.
HeliostatConfig	Initialize the single heliostat configuration.
HeliostatListConfig	Initialize the heliostat list configuration.
KinematicConfig	Initialize the kinematic configuration.
KinematicDeviations	Initialize the kinematic deviations.
KinematicLoadConfig	Initialize the kinematic configuration for loading in ARTIST.
KinematicPrototypeConfig	Initialize the kinematic prototype configuration.
LightSourceConfig	Initialize the light source configuration.
LightSourceListConfig	Initialize the light source list configuration.
PowerPlantConfig	Initialize the power plant configuration.
PrototypeConfig	Initialize the prototype configuration.
SurfaceConfig	Initialize the surface configuration.
SurfacePrototypeConfig	Initialize the surface prototype configuration.
TargetAreaConfig	Initialize the target area configuration.
TargetAreaListConfig	Initialize the target area list configuration.
H5ScenarioGenerator	Initialize the scenario generator.
Scenario	Initialize the scenario.
SurfaceGenerator	Initialize the surface generator.

Package Contents

class artist.scenario.ActuatorConfig(key: str, type: str, clockwise_axis_movement: bool, min_max_motor_positions: list[float], parameters: ActuatorParameters | None = None)

Initialize the actuator configuration.

Parameters

keystr

The name or descriptor of the actuator.

typestr

The type of actuator to use, e.g. linear or ideal.

clockwise_axis_movementbool

Boolean indicating if the actuator operates in a clockwise or counterclockwise manner.

min_max_motor_positionslist[float]

The minimum and maximum motor positions.

parametersActuatorParameters | None

The parameters of the actuator.

key

type

clockwise_axis_movement

min_max_motor_positions

parameters = None

create_actuator_dict() → dict[str, Any]

Create a dictionary containing the actuator configuration.

Returns

dict[str, Any]

A dictionary containing the actuator configuration.

class artist.scenario.ActuatorListConfig(actuator_list: list[ActuatorConfig])

Initialize the actuator list configuration.

Parameters

actuator_listlist[ActuatorConfig]

A list of actuator configurations.

actuator_list

create_actuator_list_dict() → dict[str, Any]

Create a dictionary containing a list of actuator configurations.

Returns

dict[str, Any]

A dictionary containing a list of actuator configurations.

class artist.scenario.ActuatorParameters(increment: torch.Tensor | None = None, initial_stroke_length: torch.Tensor | None = None, offset: torch.Tensor | None = None, pivot_radius: torch.Tensor | None = None, initial_angle: torch.Tensor | None = None)

Initialize the actuator parameters.

Parameters

incrementtorch.Tensor | None

The increment for the actuator

initial_stroke_lengthtorch.Tensor | None

The initial stroke length.

offsettorch.Tensor | None

The initial actuator offset.

pivot_radiustorch.Tensor | None

The pivot radius of the considered joint.

initial_angletorch.Tensor | None

The initial angle of the actuator.

increment = None

initial_stroke_length = None

offset = None

pivot_radius = None

initial_angle = None

create_actuator_parameters_dict() → dict[str, torch.Tensor]

Create a dictionary containing the parameters for the actuator.

Returns

dict[str, torch.Tensor]

A dictionary containing the configuration parameters for the actuator.

class artist.scenario.ActuatorPrototypeConfig(actuator_list: list[ActuatorConfig])

Bases: ActuatorListConfig

Initialize the actuator list prototype configuration.

Parameters

actuator_listlist[ActuatorConfig]

A list of actuator configurations.

class artist.scenario.FacetConfig(facet_key: str, control_points: torch.Tensor, degrees: torch.Tensor, translation_vector: torch.Tensor, canting: torch.Tensor)

Initialize the facet configuration.

Parameters

facet_keystr

The key used to identify the facet in the HDF5 file.

control_pointstorch.Tensor

The NURBS control points.

degreestorch.Tensor

The NURBS degree in the east and north direction.

translation_vectortorch.Tensor

The translation_vector of the facet.

canting: torch.Tensor

The canting vectors in the east and north direction.

facet_key

control_points

degrees

translation_vector

canting

create_facet_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for a facet.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the facet.

class artist.scenario.HeliostatConfig(name: str, id: int, position: torch.Tensor, surface: SurfaceConfig | None = None, kinematic: KinematicConfig | None = None, actuators: ActuatorListConfig | None = None)

Initialize the single heliostat configuration.

Parameters

namestr

The name used to identify the heliostat in the HDF5 file.

idint

The numerical ID of the heliostat.

positiontorch.Tensor

The position of the heliostat.

surfaceSurfaceConfig | None

An optional individual surface config for the heliostat.

kinematicKinematicConfig | None

An optional kinematic config for the heliostat.

actuatorsActuatorListConfig | None

An optional actuator list config for the heliostat.

name

id

position

surface = None

kinematic = None

actuators = None

create_heliostat_config_dict() → dict[str, Any]

Create a dictionary containing the heliostat configuration parameters.

Returns

dict[str, Any]

A dictionary containing the heliostat configuration parameters.

class artist.scenario.HeliostatListConfig(heliostat_list: list[HeliostatConfig])

Initialize the heliostat list configuration.

Parameters

heliostat_listlist[HeliostatConfig]

The list of heliostats to include.

heliostat_list

create_heliostat_list_dict() → dict[str, Any]

Create a dictionary containing the heliostat list configuration parameters.

Returns

dict[str, Any]

A dictionary containing the heliostat list configuration parameters.

class artist.scenario.KinematicConfig(type: str, initial_orientation: torch.Tensor, deviations: KinematicDeviations | None = None)

Initialize the kinematic configuration.

Parameters

typestr

The type of kinematic used.

initial_orientationtorch.Tensor

The initial orientation of the kinematic configuration.

deviationsKinematicDeviations | None

The kinematic deviations.

type

initial_orientation

deviations = None

create_kinematic_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the kinematic.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the kinematic.

class artist.scenario.KinematicDeviations(first_joint_translation_e: torch.Tensor | None = None, first_joint_translation_n: torch.Tensor | None = None, first_joint_translation_u: torch.Tensor | None = None, first_joint_tilt_n: torch.Tensor | None = None, first_joint_tilt_u: torch.Tensor | None = None, second_joint_translation_e: torch.Tensor | None = None, second_joint_translation_n: torch.Tensor | None = None, second_joint_translation_u: torch.Tensor | None = None, second_joint_tilt_e: torch.Tensor | None = None, second_joint_tilt_n: torch.Tensor | None = None, concentrator_translation_e: torch.Tensor | None = None, concentrator_translation_n: torch.Tensor | None = None, concentrator_translation_u: torch.Tensor | None = None)

Initialize the kinematic deviations.

Parameters

first_joint_translation_etorch.Tensor | None

The first joint translation in the east direction.

first_joint_translation_ntorch.Tensor | None

The first joint translation in the north direction.

first_joint_translation_utorch.Tensor | None

The first joint translation in the up direction.

first_joint_tilt_ntorch.Tensor | None

The first joint tilt in the north direction.

first_joint_tilt_utorch.Tensor | None

The first joint tilt in the up direction.

second_joint_translation_etorch.Tensor | None

The second joint translation in the east direction.

second_joint_translation_ntorch.Tensor | None

The second joint translation in the north direction.

second_joint_translation_utorch.Tensor | None

The second joint translation in the up direction.

second_joint_tilt_etorch.Tensor | None

The second joint tilt in the east direction.

second_joint_tilt_ntorch.Tensor | None

The second joint tilt in the north direction.

concentrator_translation_etorch.Tensor | None

The concentrator translation in the east direction.

concentrator_translation_ntorch.Tensor | None

The concentrator translation in the north direction.

concentrator_translation_utorch.Tensor | None

The concentrator translation in the up direction.

first_joint_translation_e = None

first_joint_translation_n = None

first_joint_translation_u = None

first_joint_tilt_n = None

first_joint_tilt_u = None

second_joint_translation_e = None

second_joint_translation_n = None

second_joint_translation_u = None

second_joint_tilt_e = None

second_joint_tilt_n = None

concentrator_translation_e = None

concentrator_translation_n = None

concentrator_translation_u = None

create_kinematic_deviations_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the kinematic deviations.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the kinematic deviations.

class artist.scenario.KinematicLoadConfig(type: str, initial_orientation: torch.Tensor, deviations: KinematicDeviations)

Initialize the kinematic configuration for loading in ARTIST.

Parameters

typestr

The type of kinematic used.

initial_orientationtorch.Tensor

The initial orientation of the kinematic configuration.

deviationsKinematicDeviations

The kinematic deviations.

type

initial_orientation

deviations

class artist.scenario.KinematicPrototypeConfig(type: str, initial_orientation: torch.Tensor, deviations: KinematicDeviations | None = None)

Bases: KinematicConfig

Initialize the kinematic prototype configuration.

Parameters

typestr

The type of kinematic used.

initial_orientationtorch.Tensor

The initial orientation of the kinematic configuration.

deviationsKinematicDeviations | None

The kinematic deviations.

class artist.scenario.LightSourceConfig(light_source_key: str, light_source_type: str, number_of_rays: int, distribution_type: str, mean: float | None = None, covariance: float | None = None)

Initialize the light source configuration.

Parameters

light_source_keystr

The key used to identify the light source in the HDF5 file.

light_source_type:

The type of light source used, e.g. a sun.

number_of_raysint

The number of rays generated by the light source.

distribution_typestr

The distribution type used to model the light source.

meanfloat | None

The mean used for modeling the light source.

covariancefloat | None

The covariance used for modeling the light source.

Raises

ValueError

If the specified light source distribution type is unknown.

light_source_key

light_source_type

number_of_rays

distribution_type

create_light_source_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the light source.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the light source.

class artist.scenario.LightSourceListConfig(light_source_list: list[LightSourceConfig])

Initialize the light source list configuration.

Parameters

light_source_listlist[LightSourceConfig]

The list of light source configs to be included in the scenario.

light_source_list

create_light_source_list_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the light source list.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the light source list.

class artist.scenario.PowerPlantConfig(power_plant_position: torch.Tensor)

Initialize the power plant configuration.

Parameters

power_plant_positiontorch.Tensor

The position of the power plant as latitude, longitude, altitude.

power_plant_position

create_power_plant_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the power plant.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the power plant.

class artist.scenario.PrototypeConfig(surface_prototype: SurfacePrototypeConfig, kinematic_prototype: KinematicPrototypeConfig, actuators_prototype: ActuatorPrototypeConfig)

Initialize the prototype configuration.

Parameters

surface_prototypeSurfacePrototypeConfig

The prototype for the surface.

kinematic_prototypeKinematicPrototypeConfig

The prototype for the kinematic.

actuators_prototypeActuatorPrototypeConfig

The prototype for the actuators.

surface_prototype

kinematic_prototype

actuators_prototype

create_prototype_dict() → dict[str, Any]

Create a dictionary containing the prototypes.

Returns

dict[str, Any]

A dictionary containing the prototypes.

class artist.scenario.SurfaceConfig(facet_list: list[FacetConfig])

Initialize the surface configuration.

Parameters

facet_listlist[FacetsConfig]

The list of facets to be used for the surface of the heliostat.

facet_list

create_surface_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the surface.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the surface.

class artist.scenario.SurfacePrototypeConfig(facet_list: list[FacetConfig])

Bases: SurfaceConfig

Initialize the surface prototype configuration.

Parameters

facet_listlist[FacetsConfig]

The list of facets to be used for the surface of the heliostat prototype.

class artist.scenario.TargetAreaConfig(target_area_key: str, geometry: str, center: torch.Tensor, normal_vector: torch.Tensor, plane_e: float, plane_u: float, curvature_e: float | None = None, curvature_u: float | None = None)

Initialize the target area configuration.

Parameters

target_area_keystr

The ID string used to identify the target area in the HDF5 file.

geometrystr

The type of target area, e.g., planar.

centertorch.Tensor

The position of the target area’s center.

normal_vectortorch.Tensor

The normal vector to the target plane.

plane_efloat

The size of the target area in the east direction.

plane_ufloat

The size of the target area in the up direction.

curvature_e: float | None

The curvature of the target area in the east direction.

curvature_u: float | None

The curvature of the target area in the up direction.

target_area_key

geometry

center

normal_vector

plane_e

plane_u

curvature_e = None

curvature_u = None

create_target_area_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the target area.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the target area.

class artist.scenario.TargetAreaListConfig(target_area_list: list[TargetAreaConfig])

Initialize the target area list configuration.

Parameters

target_area_listlist[TargetAreaConfig]

The list of target area configurations included in the scenario.

target_area_list

create_target_area_list_dict() → dict[str, Any]

Create a dictionary containing the configuration parameters for the list of target areas.

Returns

dict[str, Any]

A dictionary containing the configuration parameters for the list of target areas.

class artist.scenario.H5ScenarioGenerator(file_path: pathlib.Path, power_plant_config: artist.scenario.configuration_classes.PowerPlantConfig, target_area_list_config: artist.scenario.configuration_classes.TargetAreaListConfig, light_source_list_config: artist.scenario.configuration_classes.LightSourceListConfig, heliostat_list_config: artist.scenario.configuration_classes.HeliostatListConfig, prototype_config: artist.scenario.configuration_classes.PrototypeConfig, version: float = 1.0)

Initialize the scenario generator.

Scenarios in ARTIST describe the whole environment and all the components of a solar tower power plant. The scenario generator creates the scenarios. A scenario encompasses the tower target area(s), the light source(s), prototypes, and the heliostat(s). The generated scenarios are then saved in HDF5 files.

Parameters

file_pathpathlib.Path

File path to the HDF5 to be saved.

power_plant_configPowerPlantConfig

The power plant configuration object.

target_area_list_configTargetAreaListConfig

The target area list configuration object.

light_source_list_configLightSourceListConfig

The light source list configuration object.

heliostat_list_configHeliostatListConfig

The heliostat_list configuration object.

prototype_configPrototypeConfig

The prototype configuration object.

versionfloat

The version of the scenario generator being used (default is 1.0).

file_path

power_plant_config

target_area_list_config

light_source_list_config

heliostat_list_config

prototype_config

version = 1.0

_get_number_of_heliostat_groups() → int

Get the number of heliostat groups in the scenario.

Returns

int

Number of heliostat groups in the scenario.

_check_equal_facet_numbers()

Check that each heliostat has the same number of facets.

Raises

ValueError

If at least one heliostat has a different number of facets.

_flatten_dict(dictionary: collections.abc.MutableMapping, parent_key: str = '', sep: str = '/') → dict[str, Any]

Flatten nested dictionaries to first-level keys.

Parameters

dictionaryMutableMapping

Original nested dictionary to flatten.

parent_keystr

The parent key of nested dictionaries. Should be empty upon initialization.

sepstr

The separator used to separate keys in nested dictionaries.

Returns

dict[str, Any]

A flattened version of the original dictionary.

_flatten_dict_gen(d: collections.abc.MutableMapping, parent_key: str, sep: str) → Generator

static _include_parameters(file: h5py.File, prefix: str, parameters: dict) → None

Include the parameters from a parameter dictionary.

Parameters

fileh5py.File

The HDF5 file to write to.

prefixstr

The prefix used for naming the parameters.

parametersdict

The parameters to be included into the HFD5 file.

generate_scenario() → None

Generate the scenario and save it as an HDF5 file.

class artist.scenario.Scenario(power_plant_position: torch.Tensor, target_areas: artist.field.tower_target_areas.TowerTargetAreas, light_sources: artist.scene.light_source_array.LightSourceArray, heliostat_field: artist.field.heliostat_field.HeliostatField)

Initialize the scenario.

A scenario defines the physical objects and scene to be used by ARTIST. Therefore, a scenario contains at least one target area that is a receiver, at least one light source and at least one heliostat in a heliostat field. ARTIST also supports scenarios that contain multiple target areas, multiple light sources, and multiple heliostats. (Note: Currently only a single light source can be provided.)

Parameters

power_plant_positiontorch.Tensor,

The position of the power plant as latitude, longitude and altitude. Tensor of shape [3].

target_areasTargetAreaArray

A list of tower target areas included in the scenario.

light_sourcesLightSourceArray

A list of light sources included in the scenario. Currently only a single light source can be provided.

heliostat_fieldHeliostatField

A field of heliostats included in the scenario.

power_plant_position

target_areas

light_sources

heliostat_field

static get_number_of_heliostat_groups_from_hdf5(scenario_path: pathlib.Path) → int

Get the number of heliostat groups to initiate distributed setup from the HDF5 scenario file.

Parameters

scenario_pathpathlib.Path

File path to the HDF5 scenario file.

Returns

int

Number of heliostat groups to initiate distributed setup.

classmethod load_scenario_from_hdf5(scenario_file: h5py.File, number_of_surface_points_per_facet: torch.Tensor = torch.tensor([50, 50]), change_number_of_control_points_per_facet: torch.Tensor | None = None, device: torch.device | None = None) → typing_extensions.Self

Class method to load the scenario from an HDF5 file.

Parameters

scenario_fileh5py.File

The config file containing all the information about the scenario being loaded.

number_of_surface_points_per_facettorch.Tensor

The number of sampling points along each direction of each 2D facet (default is torch.tensor([50,50])). Tensor of shape [2].

change_number_of_control_points_per_facettorch.Tensor | None

The updated number of control points along each direction of each 2D facet (default is None). Providing this parameter should be done with caution. In a scenario with surfaces generated by deflectometry, this parameter should be None, otherwise the deflectometry surface will be overwritten and become ideal. For ideal surfaces this parameter can be used to change the number of control points specified in the .h5 scenario. Tensor of shape [2].

devicetorch.device | None

The device on which to perform computations or load tensors and models (default is None). If None, ARTIST will automatically select the most appropriate device (CUDA or CPU) based on availability and OS.

Returns

Scenario

The ARTIST scenario loaded from the HDF5 file.

index_mapping(heliostat_group: artist.field.heliostat_group.HeliostatGroup, string_mapping: list[tuple[str, str, torch.Tensor]] | None = None, single_incident_ray_direction: torch.Tensor = torch.tensor([0.0, 1.0, 0.0, 0.0]), single_target_area_index: int = 0, device: torch.device | None = None) → tuple[torch.Tensor, torch.Tensor, torch.Tensor]

Create an index mapping from heliostat names, target area names and incident ray directions.

If no mapping is provided, a default mapping for all heliostats within this group will be created. The default mapping will map all heliostats to the default single_incident_ray_direction, which simulates a light source positioned in the south and the default single_target_area_index, which is 0. To overwrite these defaults, please provide a single_incident_ray_direction or a single_target_area_index.

Parameters

heliostat_groupHeliostatGroup

The current heliostat group.

string_mappinglist[tuple[str, str, torch.Tensor]] | None

Strings that map heliostats to target areas and incident ray direction tensors (default is None).

single_incident_ray_directiontorch.Tensor

The default incident ray direction (default is torch.tensor([0.0, 1.0, 0.0, 0.0])). Tensor of shape [4].

single_target_area_indexint

The default target area index (default is 0).

devicetorch.device | None

The device on which to perform computations or load tensors and models (default is None). If None, ARTIST will automatically select the most appropriate device (CUDA or CPU) based on availability and OS.

Returns

torch.Tensor

The mask specifying which heliostat is selected and how many times. Tensor of shape [number_of_heliostats_in_group].

torch.Tensor

The indices of target areas for all selected heliostats in order. Tensor of shape [number_of_active_heliostats_in_group].

torch.Tensor

The incident ray directions for the selected heliostats in order. Tensor of shape [number_of_active_heliostats_in_group, 4].

set_number_of_rays(number_of_rays: int) → None

Set the number of rays simulated by the light source.

Parameters

number_of_raysint

The new number of rays simulated by the light source.

__repr__() → str

Return a string representation of the scenario.

class artist.scenario.SurfaceGenerator(number_of_control_points: torch.Tensor = torch.tensor([10, 10]), degrees: torch.Tensor = torch.tensor([3, 3]), device: torch.device | None = None)

Initialize the surface generator.

Heliostat data, including information regarding their surfaces and structure, can be generated via STRAL and exported to a binary file or downloaded from PAINT. The data formats are different depending on their source. To convert this data into a surface configuration format suitable for ARTIST, this converter first loads the data and then learns or creates NURBS surfaces based on the data. Finally, the converter returns a list of facets that can be used directly in an ARTIST scenario.

Parameters

number_of_control_pointstorch.Tensor

The number of NURBS control points along each direction of each 2D facet (default is torch.tensor([10,10])). Tensor of shape [2].

degreestorch.Tensor

Degree of the NURBS along each direction of each 2D facet (default is torch.tensor([3,3])). Tensor of shape [2].

devicetorch.device | None

The device on which to perform computations or load tensors and models (default is None). If None, ARTIST will automatically select the most appropriate device (CUDA or CPU) based on availability and OS.

number_of_control_points

degrees

fit_nurbs(surface_points: torch.Tensor, surface_normals: torch.Tensor, optimizer: torch.optim.Optimizer, scheduler: torch.optim.lr_scheduler.LRScheduler | None = None, fit_method: str = config_dictionary.fit_nurbs_from_normals, tolerance: float = 1e-10, max_epoch: int = 400, device: torch.device | None = None) → artist.util.nurbs.NURBSSurfaces

Fit a NURBS surface.

The surface points are first normalized and shifted to the range (0,1) to be compatible with the knot vector of the NURBS surface. The NURBS surface is then initialized with the correct number of control points, degrees, and knots. The origin of the control points is set based on the width and height of the point cloud. The control points are then fitted to the surface points or surface normals using the provided optimizer.

Parameters

surface_pointstorch.Tensor

The surface points. Tensor of shape [number_of_surface_points, 4].

surface_normalstorch.Tensor

The surface normals. Tensor of shape [number_of_surface_points, 4].

optimizertorch.optim.Optimizer

The optimizer.

schedulertorch.optim.lr_scheduler.LRScheduler | None

The learning rate scheduler (default is None).

fit_methodstr

The method used to fit the NURBS, either from deflectometry points or normals (default is config_dictionary.fit_nurbs_from_normals).

tolerancefloat

The tolerance value used for fitting NURBS surfaces (default is 1e-10).

max_epochint

The maximum number of epochs for the NURBS fit (default is 400).

devicetorch.device | None

The device on which to perform computations or load tensors and models (default is None). If None, ARTIST will automatically select the most appropriate device (CUDA or CPU) based on availability and OS.

Raises

NotImplementedError

If the NURBS fit method is unknown.

Returns

NURBSSurfaces

A fitted NURBS surface.

generate_fitted_surface_config(heliostat_name: str, facet_translation_vectors: torch.Tensor, canting: torch.Tensor, surface_points_with_facets_list: list[torch.Tensor], surface_normals_with_facets_list: list[torch.Tensor], optimizer: torch.optim.Optimizer, scheduler: torch.optim.lr_scheduler.LRScheduler | None = None, deflectometry_step_size: int = 100, fit_method: str = config_dictionary.fit_nurbs_from_normals, tolerance: float = 1e-10, max_epoch: int = 400, device: torch.device | None = None) → artist.scenario.configuration_classes.SurfaceConfig

Generate a fitted surface configuration.

The fitted surface configuration is composed of separate facets. Each facet is defined by fitted control points, meaning the control points are fitted to measured point cloud or surface normals data. Initializing a surface from this configuration results in an imperfect heliostat surface with dents or bulges, reflecting real-world conditions. The surface can be fitted to deflectometry data or any other provided point cloud data.

Parameters

heliostat_namestr

The heliostat name, used for logging.

facet_translation_vectorstorch.Tensor

Translation vectors for each facet from heliostat origin to relative position. Tensor of shape [number_of_facets, 4].

cantingtorch.Tensor

The canting vectors per facet in east and north directions Tensor of shape [number_of_facets, 2, 4].

surface_points_with_facets_listlist[torch.Tensor]

A list of facetted surface points. Points per facet may vary. Tensors in list of shape [number_of_points, 3].

surface_normals_with_facets_listlist[torch.Tensor]

A list of facetted surface normals. Points per facet may vary. Tensors in list of shape [number_of_points, 3].

optimizertorch.optim.Optimizer

The optimizer.

schedulertorch.optim.lr_scheduler.LRScheduler | None

The learning rate scheduler (default is None).

deflectometry_step_sizeint

The step size used to reduce the number of deflectometry points and normals for compute efficiency (default is 100).

fit_methodstr

The method used to fit the NURBS, either from deflectometry points or normals (default is config_dictionary.fit_nurbs_from_normals).

tolerancefloat

The tolerance value used for fitting NURBS surfaces (default is 1e-10).

max_epochint

The maximum number of epochs for the NURBS fit (default is 400).

devicetorch.device | None

The device on which to perform computations or load tensors and models (default is None). If None, ARTIST will automatically select the most appropriate device (CUDA or CPU) based on availability and OS.

Returns

SurfaceConfig

A surface configuration.

generate_ideal_surface_config(facet_translation_vectors: torch.Tensor, canting: torch.Tensor, device: torch.device | None = None) → artist.scenario.configuration_classes.SurfaceConfig

Generate an ideal surface configuration.

The ideal surface configuration is composed of separate facets. Each facet is defined by ideal control points, meaning the control points start as 3D points on a flat, equidistant grid around the origin. These control points are then canted (rotated) and translated to the facet positions. Initializing a surface from this configuration results in an ideal heliostat surface without dents or bulges but with canting. This ideal heliostat surface can be used as a starting point for a surface reconstruction based on measured flux distributions.

Parameters

facet_translation_vectorstorch.Tensor

Translation vector for each facet from heliostat origin to relative position. Tensor of shape [number_of_facets, 4].

cantingtorch.Tensor

The canting vector per facet in east and north direction. Tensor of shape [number_of_facets, 2, 4].

devicetorch.device | None

The device on which to perform computations or load tensors and models (default is None). If None, ARTIST will automatically select the most appropriate device (CUDA or CPU) based on availability and OS.

Returns

SurfaceConfig

A surface configuration.