wolfhece.wolfresults_2D

Author: HECE - University of Liege, Pierre Archambeau Date: 2024

Copyright (c) 2024 University of Liege. All rights reserved.

This script and its content are protected by copyright law. Unauthorized copying or distribution of this file, via any medium, is strictly prohibited.

Module Contents

wolfhece.wolfresults_2D.msg

wolfhece.wolfresults_2D.s

wolfhece.wolfresults_2D.outside_domain(val)

Test if a value is outside the calculated domain

wolfhece.wolfresults_2D.q_splitting(q_left, q_right)

Splitting of the normal flow between two nodes

wolfhece.wolfresults_2D.u_splitting(q_left, q_right, h_left, h_right)

Splitting of the normal flow velocity between two nodes

class wolfhece.wolfresults_2D.Props_Res_2D(parent: Wolfresults_2D, mapviewer=None)

Bases: wx.Frame

Fenêtre de propriétésd’un Wolfresults_2D

get_mapviewer()

Retourne une instance WolfMapViewer

get_linked_arrays()

Pour compatibilité avec la gestion de vecteur et WolfMapViewer

set_GUI()

Set the wx GUI

OnDefault_cmap(event: wx.MouseEvent)

Load a default colormap

onclose(event: wx.CloseEvent)

Hide the window instead of closing/detsroy it

onshow(event: wx.ShowEvent)

Update the GUI when the window is shown

OnApplyTools(event: wx.MouseEvent)

Apply modifications in the textctrl

update_palette()

Update the colormap grid and plot

Onsavepal(event: wx.MouseEvent)

Save the colormap to a file

Onloadpal(event)

Read the colormap from a file

Onloaddefaultpal(event: wx.MouseEvent)

Load default palette

Onpalimage(event)

Export the colormap to an image

Onpaldistribute(event)

Distribute uniformly the colormap values

Onupdatepal(event)

Update the colormap from the grid

OnClickHistoUpdate(event: wx.MouseEvent)

Click to update the histogram

OnClickColorPal(event: wx.MouseEvent)

Click to open the color dialog box

select_node_by_node()

class wolfhece.wolfresults_2D.views_2D

Bases: enum.Enum

Generic enumeration.

Derive from this class to define new enumerations.

WATERDEPTH

WATERLEVEL

TOPOGRAPHY

QX

QY

QNORM

UX

UY

UNORM

HEAD

FROUDE

KINETIC_ENERGY

EPSILON

TURB_VISC_2D

TURB_VISC_3D

VECTOR_FIELD_Q

VECTOR_FIELD_U

U_SHEAR

SHIELDS_NUMBER

CRITICAL_DIAMETER_SHIELDS

CRITICAL_DIAMETER_IZBACH

CRITICAL_DIAMETER_SUSPENSION_50

CRITICAL_DIAMETER_SUSPENSION_100

QNORM_FIELD

UNORM_FIELD

WL_Q

WD_Q

WL_U

WD_U

T_WL_Q

T_WD_Q

T_WD_U

classmethod get_view(value)

wolfhece.wolfresults_2D.VIEWS_SEDIMENTARY

wolfhece.wolfresults_2D.VIEWS_COMPLEX

wolfhece.wolfresults_2D.VIEWS_VECTOR_FIELD

class wolfhece.wolfresults_2D.OneWolfResult(idx: int = 0, parent=None)

Stockage des résultats d’un bloc de modèle WOLF2D

property SelectionData: wolfhece.wolf_array.SelectionDataMB

Return the data of the selection

property sediment_diameter

Diamètre des particules de sédiment [m]

property sediment_density

Densité des particules de sédiment [-]

property current

Vue courante

property min_field_size

set_linkedvec(link: wolfhece.PyVertexvectors.vector)

Set the linked vecteor – used for masking outside the vector

set_epsilon(eps: float)

Définit la valeur de l’epsilon pour le masquage des données.

Toute valeur de waterdepth inférieure à eps sera masquée. see “filter_inundation”

Parameters:

eps – valeur de l’epsilon

filter_inundation()

Apply filter on array :

• mask data below eps

• mask data outisde linkedvec

filter_independent_zones(n_largest: int = 1)

Apply filter on array : mask data outside n_largest independant zones

set_current(which: views_2D)

Définition de la vue courante

Parameters:

which – vue courante (voir enum views_2D)

set_opacity(alpha: float)

Set the transparency of the array

get_norm_max()

update_zoom_2(newzoom)

update_zoom_vectorfield(factor)

update_arrowpixelsize_vectorfield(factor)

update_pal(curpal: wolfhece.PyPalette.wolfpalette, graypal=None, bluepal=None)

Mise à jour de la palette

Parameters:

• curpal – palette courante

• graypal – palette grise

• bluepal – palette bleue

get_critdiam(which: int) → wolfhece.wolf_array.WolfArray

Calcul du dimètre critique

:param which : 0 = Shields ; 1 = Izbach

get_u_shear() → wolfhece.wolf_array.WolfArray

Calcul de la vitesse de cisaillement

get_shieldsnumber() → wolfhece.wolf_array.WolfArray

Calcul du nombre de Shields

get_critsusp(which: int = 50)

plot(sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None)

Affichage des résultats

get_values_labels(i: int, j: int)

Récupération des valeurs et labels pour affichage

delete_lists()

Reset des listes OpenGL de la matrice/vue courante

class wolfhece.wolfresults_2D.Wolfresults_2D(fname: str = None, mold=None, eps=0.0, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False, loader=None)

Bases: wolfhece.drawing_obj.Element_To_Draw

Manipulation des résultats d’un modèle WOLF2D en multiblocs

La classe hérite de ‘Element_To_Draw’ afin d’être sûr de disposer des informations pour un éventuel affichage dans un viewer ‘WolfMapViewer’

ATTENTION :

• la classe contient un dictionnaire ‘myblocks’ d’objets ‘OneWolfResult’

• les clés du dictionnaire sont de type ‘block1’, ‘block2’… ‘blockn’ –> voir fonction ‘getkeyblock’

• les entrées ne sont PAS des matrices multiblocks ‘WolfArrayMB’ mais une classe ‘OneWolfResult’ contient plusieurs matrices pour chaque type de résultat (water depth, dischargeX, dischargeY, …)

• la classe se comporte donc un peu comme une généralisation d’une matrice ‘WolfArrayMB’ mais il ne s’agit pas d’une extension par polymorphisme

• on retrouve cependant plusieurs routines similaires afin de faciliter l’intégration dans un viewer WX

property all_dt

property all_mostly_dry_mesh

property all_clock_time

property all_wet_meshes

property SelectionData: wolfhece.wolf_array.SelectionDataMB

Return the data of the selection

property common_mask_MB: list[numpy.ndarray]

Common mask for multiblock arrays

property active_blocks: list[wolfhece.wolf_array.WolfArray]

Return the active blocks

property step_interval_results

property nullvalue

Get nullvalue from the first block

property alpha

property shading

property altitudehill

property azimuthhill

property shaded

property nb_blocks

Nombre de blocs

property sediment_diameter

property sediment_density

myblocks: dict[str, OneWolfResult]

head_blocks: dict[str, wolfhece.wolf_array.header_wolf]

myparam: wolfhece.mesh2d.wolf2dprev.prev_parameters_simul

myblocfile: wolfhece.mesh2d.wolf2dprev.blocks_file

mymnap: wolfhece.wolf_array.WolfArrayMNAP

set_opacity(alpha: float)

Set the transparency of the array

default16()

Mise à jour de la palette par défaut

defaultblue()

Mise à jour de la palette par défaut

defaultgrey()

Mise à jour de la palette par défaut

get_bounds(abs=True)

Return bounds in coordinates

:param abs = if True, add translation to (x, y) (coordinate to global space) :return : tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])

check_bounds_ij(i: int, j: int)

Check if i and j are inside the array bounds

check_bounds_xy(x: float, y: float)

Check if i and j are inside the array bounds

show_properties()

Affichage des propriétés de la matrice

set_properties()

Create :

• Props_Res_2D (GUI) if mapviewer is not None

get_header(abs=True) → wolfhece.wolf_array.header_wolf

Récupération de l’entête de la matrice

as_WolfArray(copyarray: bool = True, force_mb=False) → wolfhece.wolf_array.WolfArray | wolfhece.wolf_array.WolfArrayMB

Récupération d’une matrice MB ou Mono sur base du résultat courant

:param copyarray : si True alors on copie les données :param force_mb : if True then return a WolfArrayMB even if there is only one block

load_default_colormap(which: str)

Lecture d’une palette disponible dans le répertoire “models”

get_times_steps(nb: int = None)

Récupération des temps réels et des pas de calcul de chaque résultat sur disque

:param nb : nombre de résultats à lire - si None alors on lit tous les résultats :return : tuple (liste des temps, liste des pas de calcul)

find_minmax(update=False)

Find spatial bounds

get_norm_max()

Retourne la norme maximale du champ de débit ou de vitesse

update_zoom_2(newzoom)

update_zoom_factor()

update_arrowpixelsize_vectorfield(factor)

get_dxdy_min()

Return the minimal size into blocks

get_dxdy_max()

Return the maximal size into blocks

read_param_simul()

Read simulation parameters from files

get_currentview()

Return the current view

filter_inundation(eps: float = None, linkedvec: wolfhece.PyVertexvectors.vector = None)

Apply filtering on array

:param eps : mask data below eps :param linkedvec : mask data outside linkedvec

filter_independent_zones(n_largest: int = 1)

Apply filtering on array

set_currentview(which=None, force_wx=False, force_updatepal: bool = False)

Set the current view –> see ‘views_2D’ for supported values

:param which : view to set :param force_wx : if True, a wx dialog will be shown to set the minimum size of the vector field :param force_updatepal : if True, the palette will be updated

allocate_ressources()

Allocation de l’espace mémoire utile pour le stockage des résultats de chaque bloc

read_topography()

Lecture de la topographie de modélisation

read_ini_mb()

Lecture des conditions initiales

read_roughness_param()

Lecture du frottement de modélisation

get_nbresults(force_update_timessteps=True)

Récupération du nombre de pas sauvegardés –> utilisation de la librairie Fortran

read_oneblockresult_withoutmask(which_step: int = -1, whichblock: int = -1)

Lecture d’un résultat pour un bloc spécifique –> utilisation de la librairie Fortran

:param which_step : timestep ; 0-based; -1 == last one :param whichblock : block index

_read_oneblockresult_withoutmask_only_h(which_step: int = -1, whichblock: int = -1)

Lecture d’un résultat pour un bloc spécifique –> utilisation de la librairie Fortran

:param which_step : timestep ; 0-based; -1 == last one :param whichblock : block index

read_oneblockresult(which_step: int = -1, whichblock: int = -1)

Lecture d’un résultat pour un bloc spécifique et application d’un masque sur base d’nu epsilon de hauteur d’eau

which_step: result number to read ; 0-based; -1 == last one whichblock : block index ; 1-based

_read_oneblockresult_only_h(which_step: int = -1, whichblock: int = -1)

Lecture d’un résultat pour un bloc spécifique et application d’un masque sur base d’nu epsilon de hauteur d’eau

which_step: result number to read ; 0-based; -1 == last one whichblock : block index ; 1-based

read_oneresult(which: int = -1)

Lecture d’un pas de sauvegarde

Parameters:

which – result number to read; 0-based; -1 == last one

_read_oneresult_only_h(which: int = -1)

Lecture d’un pas de sauvegarde

Parameters:

which – result number to read; 0-based; -1 == last one

read_next()

Lecture du pas suivant

_sanitize_result_step(which_step: int = -1)

Sanitize result step index – 0-based

_update_result_view()

set_hqxqy_as_initial_conditions(idx: int = None, as_multiblocks: bool = True)

Set the result as IC

:param idx : 0-based index

set_keps_as_initial_conditions(idx: int = None, as_multiblocks: bool = True)

Set the turbulent result as IC

:param idx : 0-based index

read_previous()

Lecture du pas suivant

get_h_for_block(block: int | str) → wolfhece.wolf_array.WolfArray

Retourne la matrice de hauteur d’eau pour un bloc spécifique

block : numéro du bloc; 1-based;

get_top_for_block(block: int | str) → wolfhece.wolf_array.WolfArray

Retourne la matrice de topographie pour un bloc spécifique

block : numéro du bloc; 1-based;

get_qx_for_block(block: int | str) → wolfhece.wolf_array.WolfArray

Retourne la matrice de débit selon X pour un bloc spécifique

block : numéro du bloc; 1-based;

get_qy_for_block(block: int | str) → wolfhece.wolf_array.WolfArray

Retourne la matrice de débit selon Y pour un bloc spécifique

block : numéro du bloc; 1-based;

get_values_as_wolf(i: int, j: int, which_block: int = 1)

Retourne les valeurs associées à des indices (i,j) et un numéro de block

which_block : numéro du bloc; 1-based;

*** ATTENTION :

Les indices sont passés comme WOLF –> en numérotation Fortran (démarrage à 1 et non à 0)

***

get_values_turb_as_wolf(i: int, j: int, which_block: int = 1)

Retourne les valeurs de turbulence associées à des indices (i,j) et un numéro de block

which_block : numéro du bloc; 1-based;

ATTENTION : Les indices sont passés comme WOLF –> en numérottaion Fortran (démarrage à 1 et non à 0)

get_header_block(which_block=1) → wolfhece.wolf_array.header_wolf

Obtention du header_wolf d’un block

which_block : numéro du bloc; 1-based;

get_xy_infootprint_vect(myvect: wolfhece.PyVertexvectors.vector, which_block=1) → tuple[numpy.ndarray, numpy.ndarray]

:return numpy array content les coordonnées (x,y) des mailles dans l’empreinte du vecteur

get_ij_infootprint_vect(myvect: wolfhece.PyVertexvectors.vector, which_block=1) → numpy.ndarray

Returns:

numpy array content les indices ij des mailles dans l’empreinte du vecteur

get_xy_inside_polygon(myvect: wolfhece.PyVertexvectors.vector, usemask=True)

Obtention des coordonnées contenues dans un polygone

usemask = restreint les éléments aux éléments non masqués de la matrice

get_xy_under_polyline(myvect: wolfhece.PyVertexvectors.vector) → dict[str, int, int]

Obtention des coordonnées (x,y) sous une polyligne avec séparation des points par bloc

usemask = restreint les éléments aux éléments non masqués de la matrice

get_values_insidepoly(myvect: wolfhece.PyVertexvectors.vector, usemask: bool = True, agglo: bool = True, getxy: bool = False)

Retourne les valeurs des mailles contenues dans un polygone Traite la matrice courante et l’altitude de fond si on est en vue ‘views_2D.WATERLEVEL’

:param myvect : polygone :param usemask (optional) restreint les éléments aux éléments non masqués de la matrice :param agglo (optional) agglomère le résultat en une seule liste plutôt que d’avoir autant de liste que de blocs :param getxy (optional) retourne en plus les coordonnées des points

:return myvalues : valeurs des mailles

get_all_values_insidepoly(myvect: wolfhece.PyVertexvectors.vector, usemask=True, agglo=True, getxy=False)

Récupération de toutes les valeurs dans un polygone

usemask (optional) restreint les éléments aux éléments non masqués de la matrice getxy (optional) retourne en plus les coordonnées des points

get_all_values_underpoly(myvect: wolfhece.PyVertexvectors.vector, usemask=True, agglo=True, getxy=False, integrate_q=False)

Récupération de toutes les valeurs sous la polyligne Les valeurs retrounées sont identiques à la fonction “get_values_from_xy” soit (h,qx,qy,vx,vy,vabs,fr,h+top,top),(i+1,j+1,curblock.idx+1)

usemask (optional) restreint les éléments aux éléments non masqués de la matrice getxy (optional) retourne en plus les coordonnées des points agglo (optional) agglomère le résultat en une seule liste plutôt que d’avoir autant de liste que de blocs

get_q_alongpoly(myvect: wolfhece.PyVertexvectors.vector, x_or_y: str = 'x', to_sum=True)

alias

get_q_underpoly(myvect: wolfhece.PyVertexvectors.vector, x_or_y: str = 'x', to_sum=True)

Récupération du débit sous un vecteur

to_sum pour sommer les valeurs et multiplier par la taille de maille

get_q_alongpoly_with_neighbor(myvect: wolfhece.PyVertexvectors.vector, x_or_y: str = 'x', to_sum=True)

Récupération du débit sous un vecteur mais uniquement si un voisin existe dans la direction d’intégration

to_sum pour sommer les valeurs et multiplier par la taille de maille

get_q_alongpoly_raster_splitting(myvect: wolfhece.PyVertexvectors.vector, to_sum=True, to_rasterize=True)

Récupération du débit sous un vecteur après avoir rasterisé selon les bords et appliqué le splitting WOLF aux flux

Forcage préalable du vecteur slon la grille de calcul

:param myvect : wolf polyline :param to_sum : pour sommer les valeurs et multiplier par la taille de maille :param to_rasterize : pour rasteriser le vecteur selon la grille de calcul

_plot_one_q(vect: wolfhece.PyVertexvectors.vector, x_or_y: str = 'x', absolute=True) → float

_plot_one_q_raster_splitting(vect: wolfhece.PyVertexvectors.vector, absolute=True, to_rasterize=True) → float

setup_cache(start_idx: int, end_idx: int = -1, only_h: bool = False)

Setup cache for results

#FIXME : not implemented for général 2D results – just for GPU Defined here for compatibility

clear_cache()

Clear cache

#FIXME : not implemented for général 2D results – just for GPU Defined here for compatibility

get_hydrographs(vect: wolfhece.PyVertexvectors.vector | list[wolfhece.PyVertexvectors.vector] | wolfhece.PyVertexvectors.zone, progress_callback=None)

Get hydrograph across a vector

Parameters:

• vect – wolf polyline or list of wolf polylines or zone

• progress_callback – optional callback to update progress

export_hydrographs(vect: wolfhece.PyVertexvectors.vector | list[wolfhece.PyVertexvectors.vector] | wolfhece.PyVertexvectors.zone, filename: str | pathlib.Path, progress_callback=None)

Export hydrograph across a vector as CSV file

Parameters:

• vect – wolf polyline or list of wolf polylines or zone

• filename – output filename

• progress_callback – optional callback to update progress

plot_q(vect: wolfhece.PyVertexvectors.vector | list[wolfhece.PyVertexvectors.vector], x_or_y: str | list[str] = 'border', toshow=False, absolute=True, figax=None)

Plot discharge along vector

:param vector : wolf polyline – will be splitted according to spatial step size :param x_or_y : ‘x’ for qx, ‘y’ for qy - integration axis or ‘border’ for q normal at border :param toshow : show the plot :param absolute : plot absolute value of discharge :param figax : tuple of matplotlib figure and axis

plot_h(xy: list[float] | wolfhece.PyVertexvectors.vector, h_or_z: Literal[h, z, head], toshow=False, figax=None)

Plot water depth at one or multiple coordinates

:param xy : list of coordinates :param h_or_z : ‘h’ for water depth, ‘z’ for bed elevation, ‘head’ for water head :param toshow : show the plot :param figax : tuple of matplotlib figure and axis

get_values_from_xy(x: float, y: float, aswolf=True, integrate_q=False)

Retrouve les valeurs sur base de la coordonnée (x,y)

aswolf : (optional) si True alors ajoute 1 à i et j pour se retrouver en numérotation VB6/Fortran

get_values_turb_from_xy(x: float, y: float, aswolf=True)

Retrouve les valeurs de turbulence sur base de la coordonnée (x,y)

aswolf : (optional) si True alors ajoute 1 à i et j pour se retrouver en numérotation VB6/Fortran

get_value(x: float, y: float, nullvalue=-1)

Return the value of the current array at (X,Y) position

get_values_labels(x: float, y: float)

Return the values and labels of the current view at (X,Y) position

get_value_elevation(x: float, y: float, nullvalue=-1)

Return the value of the bed elevation at (X,Y) position

get_xy_from_ij(i: int, j: int, which_block: int = 1, aswolf: bool = False, abs: bool = True)

Retourne les coordonnées (x,y) depuis les indices (i,j) et le numéro de block

Parameters:

• i – i index

• j – j index

• which_block – block number; 1-based;

• aswolf – True to add 1 to i and j to match the VB6/Fortran numbering format

• abs – True to return absolute coordinates

get_ij_from_xy(x: float, y: float, which_block: int = 1, aswolf=False, abs=True)

Retrouve les indices d’un point (x,y) dans un bloc spécifique

Utilise la routine du même nom dans la martrice ‘waterdepth’

Parameters:

• x – x coordinate

• y – y coordinate

• which_block – block number; 1-based;

• aswolf – True to add 1 to i and j to match the VB6/Fortran numbering format

• abs – True to return absolute coordinates

_test_bounds_block(x: float, y: float, curblock: OneWolfResult)

Teste les bornes d’un bloc versus les coordonnées (x,y) d’un point

enum_block_xy(x: float, y: float, aswolf=False, abs=True)

Enumération des blocs contenant la coordonnée (x,y)

aswolf : True ajoute 1 à i et j pour corresppondre au format de numérotation VB6/Fortran

get_blockij_from_xy(x: float, y: float, abs=True, aswolf=True)

Retourne les indices i,j et le numéro du block depuis les coordonnées (x,y)

aswolf : True ajoute 1 à i et j pour corresppondre au format de numérotation VB6/Fortran

check_plot()

L’objet est coché/à traiter dans une fenêtre graphique ‘WolfMapViewer’

uncheck_plot(unload=False)

L’objet est décoché/pas à traiter dans une fenêtre graphique ‘WolfMapViewer’

link_palette()

Applique la même palette de couleur/colormap à tous les blocs

get_min_max(which: Literal[views_2D, views_2D, current])

Retourne la valeur min et max de la topo, de la hauteur d’eau ou de la matrice courante

get_working_array(onzoom=[])

Délimitation d’une portion de matrice sur base de bornes

onzoom : Liste Python de type [xmin, xmax, ymin, ymax]

updatepalette(which=0, onzoom=[])

Mise à jour des palettes de couleur/colormaps

palgray : niveaux de gris palblue : niveaux de bleu mypal : coloration paramétrique

Parameters:

• which – 0

• onzoom – Liste Python de type [xmin, xmax, ymin, ymax]

delete_lists()

Reset des listes OpenGL de la matrice courante

mimic_plotdata(plotting=False)

Force la mise à jour de paramètres entre tous les blocs

plot(sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None)

Dessin OpenGL

fillonecellgrid(curscale, loci, locj, force=False)

Dessin d’une fraction de la matrice pour tous les blocs

set_current(which)

Change le type de résultat à présenter/traiter

Parameters:

which – mode de visualisation –> see ‘views_2D’ for supported values

next_result()

Lecture du pas suivant

reset_plot(whichpal=0)

Reset du dessin

danger_map(start: int = 0, end: int = -1, every: int = 1) → tuple[wolfhece.wolf_array.WolfArray, wolfhece.wolf_array.WolfArray, wolfhece.wolf_array.WolfArray, wolfhece.wolf_array.WolfArray] | tuple[wolfhece.wolf_array.WolfArrayMB, wolfhece.wolf_array.WolfArrayMB, wolfhece.wolf_array.WolfArrayMB, wolfhece.wolf_array.WolfArrayMB]

Create Danger Maps

Parameters:

• start – start time step - 0-based

• end – end time step - 0-based

• every – step interval

:return : tuple of WolfArray or WolfArrayMB - H, U_norm, Q_norm, Z

danger_map_only_h(start: int = 0, end: int = -1, every: int = 1) → wolfhece.wolf_array.WolfArray

Create Danger Maps

Parameters:

• start – start time step - 0-based

• end – end time step - 0-based

• every – step interval

:return : tuple of WolfArray or WolfArrayMB - H, U_norm, Q_norm

export_as(outdir: str, fields: list[views_2D], which: Literal[geotiff, shape, numpy], multiband: bool = True)

Export as geotiff or shapefile or numpy

export_as_shape(outdir: str = '', fn: str = '', myarrays: list[wolfhece.wolf_array.WolfArray] = [], descr: list[str] = [], mask: wolfhece.wolf_array.WolfArray = None)

Export multiple arrays to shapefile

Parameters:

• outdir – output directory

• fn – filename – .shp will be added if not present

• myarrays – list of Wolfarrays to export

• descr – list of descriptions

• mask – mask array – export only where mask > 0

export_as_geotif(outdir: str = '', fn: str = '', myarrays: list[wolfhece.wolf_array.WolfArray] = [], descr: list[str] = [], multiband: bool = True)

Export results as geotiff

Parameters:

• outdir – output directory

• fn – filename – .tif will be added if not present

• myarrays – list of Wolfarrays to export

• descr – list of descriptions – Bands names