bluemath_tk.teslakit package

Subpackages

Submodules

bluemath_tk.teslakit.alr module

class bluemath_tk.teslakit.alr.ALR_WRP(p_base)[source]

Bases: object

AutoRegressive Logistic Model Wrapper

FitModel(max_iter=1000)[source]: Fits ARL model using sklearn

GenerateALRTerms(d_terms_settings, bmus, time, cluster_size, time2yfrac=False)[source]: Generate ALR terms from user terms settings

GetFracYears(time)[source]: Returns time in custom year decimal format

LoadBmus_Fit()[source]: Load bmus - fit

LoadBmus_Sim()[source]: Load bmus - sim

LoadModel()[source]: Load fitted model (and fitting terms)

Report_Fit(terms_fit=False, summary=False, show=True)[source]: Report containing model fitting info

Report_Sim(py_month_ini=1, persistences_hists=False, persistences_table=False, show=True)[source]

Report that Compare fitting to simulated bmus

py_month_ini - start month for PerpetualYear bmus comparison

Report_Sim_Log(n_sim=0, t_slice=None, show=True)[source]

Interactive plot for simulation log

n_sim - simulation log to plot

Report_Terms_Fit(show=True)[source]: Plot terms used for model fitting

SaveBmus_Fit()[source]: Saves bmus - fit for future use

SaveBmus_Sim()[source]: Saves bmus - sim for future use

SaveModel()[source]: Saves fitted model (and fitting terms) for future use

SetFitData(cluster_size, xds_bmus_fit, d_terms_settings)[source]

Sets data needed for ALR fitting

cluster_size - number of clusters in classification xds_bmus_fit - xarray.Dataset vars: bmus, dims: time d_terms_settings - terms settings. See “SetFittingTerms”

SetFittingTerms(d_terms_settings)[source]: Set terms settings that will be used for fitting

Simulate(num_sims, time_sim, xds_covars_sim=None, log_sim=False, overfit_filter=False, of_probs=0.98, of_pers=5)[source]

Launch ARL model simulations

num_sims - number of simulations to compute time_sim - time array to solve

xds_covars_sim - xr.Dataset (time,), cov_values: Covariates used at simulation, compatible with “n_sim” dimension (“n_sim” dimension (optional) will be iterated with each simulation)

log_sim - Store a .nc file with all simulation detailed information.

filters for exceptional ALR overfit probabilities situation and patch:

overfit_filter - overfit filter activation of_probs - overfit filter probabilities activation of_pers - overfit filter persistences activation

bluemath_tk.teslakit.alr.tqdm(*args, **kwargs)[source]

bluemath_tk.teslakit.alr_AIC module

class bluemath_tk.teslakit.alr_AIC.AutoLogisticRegression(cluster_size: int)[source]

Bases: object

Auto-Regressive Logistic (ALR) model for categorical time series modeling.

This implementation focuses on statsmodels with AIC-based covariate selection. The model simulates transitions between discrete states (weather types, climate patterns, etc.) accounting for: - Markov dependencies (previous states) - Seasonality - Long-term trends - External covariates

cluster_size

Number of discrete states or clusters in the model

Type:: int

model

Fitted multinomial logistic regression model

Type:: statsmodels.MNLogit

terms_fit

Dictionary of terms used for model fitting

Type:: dict

terms_fit_names

Names of the terms used for model fitting

Type:: list

fit(bmus: ndarray, time: ndarray, mk_order: int = 0, use_constant: bool = True, use_long_term: bool = False, seasonality: Tuple[bool, List[int]] = (False, []), covariates: Dataset | None = None, cov_seasonality: bool = False, max_iter: int = 1000) → None[source]

Fit the ALR model to data.

Parameters:

bmus (np.ndarray) – Array of categorical states (1-indexed)
time (np.ndarray) – Array of datetime objects
mk_order (int, optional) – Markov chain order (number of previous states to include)
use_constant (bool, optional) – Include intercept term
use_long_term (bool, optional) – Include long-term trend
seasonality (tuple(bool, list), optional) – Tuple of (use_seasonality, [phases])
covariates (xr.Dataset, optional) – Dataset with covariates
cov_seasonality (bool, optional) – Include seasonal modulation of covariates
max_iter (int, optional) – Maximum iterations for model fitting

generate_terms(bmus: ndarray, time: ndarray, mk_order: int = 0, use_constant: bool = True, use_long_term: bool = False, seasonality: Tuple[bool, List[int]] = (False, []), covariates: Dataset | None = None, cov_seasonality: bool = False) → Tuple[OrderedDict, List[str]][source]

Generate design matrix terms for the ALR model.

Parameters:

bmus (np.ndarray) – Array of categorical states (1-indexed)
time (np.ndarray) – Array of datetime objects
mk_order (int, optional) – Markov chain order (number of previous states to include)
use_constant (bool, optional) – Include intercept term
use_long_term (bool, optional) – Include long-term trend
seasonality (tuple(bool, list), optional) – Tuple of (use_seasonality, [phases]). Example: (True, [1, 2]) for annual and semi-annual cycles
covariates (xr.Dataset, optional) – Dataset with covariates. Should have dimensions (time, cov_names) and variable cov_values
cov_seasonality (bool, optional) – Include seasonal modulation of covariates

Returns:

OrderedDict – Dictionary of design matrix terms
list – List of term names

get_summary() → DataFrame[source]

Get model summary statistics.

Returns:: DataFrame with parameter estimates, p-values, etc.
Return type:: pd.DataFrame

get_year_fraction(time_array)[source]

Convert datetime array to fractional year representation.

Parameters:: time_array (array-like) – Array of datetime objects
Returns:: Array of year fractions (0-1 for position within the year)
Return type:: np.ndarray

select_covariates_by_aic(bmus: ndarray, time: ndarray, covariates: Dataset, base_config: dict = None) → Tuple[List[str], float][source]

Select optimal covariates using AIC criterion.

Parameters:

bmus (np.ndarray) – Array of categorical states (1-indexed)
time (np.ndarray) – Array of datetime objects
covariates (xr.Dataset) – Dataset with all potential covariates
base_config (dict, optional) – Base configuration for other terms (mk_order, seasonality, etc.)

Returns:

list – List of selected covariate names
float – AIC of the best model

simulate(time_sim: ndarray, num_sims: int = 1, covariates_sim: Dataset | None = None) → ndarray[source]

Generate simulations from the fitted ALR model.

Parameters:

time_sim (np.ndarray) – Array of datetime objects for simulation
num_sims (int, optional) – Number of simulations to generate
covariates_sim (xr.Dataset, optional) – Covariates for simulation period

Returns:

Array of simulated states with shape (time, num_sims)

Return type:

np.ndarray

bluemath_tk.teslakit.climate_emulator module

bluemath_tk.teslakit.climate_emulator.ChromMatrix(vs)[source]: Return chromosome matrix for np.array vs (n x nvars)

class bluemath_tk.teslakit.climate_emulator.Climate_Emulator(p_base)[source]

Bases: object

KMA - DWTs Climate Emulator

Fit Waves extremes model (GEV, Gumbel, Weibull distributions) and DWTs series Simulate (probabilistic) a new dataset of Waves from a custom DWTs series

This custom emulator uses Waves data divided by families (sea, swell_1, swell_2, …), each family is defined by 3 variables: Hs, Tp, Dir

Some configuration parameters:

A chromosomes methodology for statistical fit is available, it will handle on/off probabilities for each different waves family combination.

Aditional variables, outside of waves families, can be given to the emulator.

A variable has to be selected as the PROXY to calculate storms max. (default: AWL)

User can manually set a variable for an empircal / weibull / gev distribution.

AllOn_Chromosomes(xds_KMA_MS)[source]

Generate Fake chromosomes and probabilities from KMA.bmus data in order to use only all-on chromosome combination

Returns xarray.Dataset vars: chrom, chrom_probs. dims: WT, wave_family

CDF_Distribution(vn, vv, xds_GEV_Par, d_shape, i_wt)[source]

Switch function: GEV / Empirical / Weibull

Check variable distribution and calculates CDF

vn - var name vv - var value i_wt - Weather Type index xds_GEV_Par , d_shape: GEV data used in sigma correlation

Calc_Chromosomes(xds_KMA_MS, xds_WVS_MS)[source]

Calculate chromosomes and probabilities from KMA.bmus data

Returns xarray.Dataset vars: chrom, chrom_probs. dims: WT, wave_family

Calc_GEVParams(xds_KMA_MS, xds_WVS_MS)[source]

Fits each WT (KMA.bmus) waves families data to a GEV distribtion Requires KMA and WVS families at storms max. TWL

Returns xarray.Dataset with GEV shape, location and scale parameters

Calc_SigmaCorrelation(xds_KMA_MS, xds_WVS_MS, xds_GEV_Par)[source]: Calculate Sigma Pearson correlation for each WT-chromosome combo

Calc_SigmaCorrelation_AllOn_Chromosomes(xds_KMA_MS, xds_WVS_MS, xds_GEV_Par)[source]: Calculate Sigma Pearson correlation for each WT, all on chrom combo

Calc_StormsDates(xds_KMA)[source]: Returns list of tuples with each storm start and end times

Calc_StormsMaxProxy(wvs_PROXY, lt_storm_dates)[source]: Returns xarray.Dataset with max. PROXY variable value and time

ConfigVariables(config)[source]

Set waves families names Set optional extra variables names Set variables distribution: GEV, Empirical, Weibull Activate / Deactivate chromosomes methodology (if False, all-on combo)

config = {

‘waves_families’: [‘sea’, ‘swell_1’, …], ‘extra_variables’: [‘wind’, ‘slp’, …] ‘distribution’: [

(‘sea_Tp’, ‘Empirical’), (‘wind’, ‘Weibull’), …

}, ‘do_chromosomes’: True,

}

FitExtremes(KMA, WVS, config, proxy='AWL')[source]

GEV extremes fitting. Input data (waves vars series and bmus) shares time dimension

KMA - xarray.Dataset, vars: bmus (time,), cenEOFs(n_clusters, n_features) WVS - xarray.Dataset: (time,), Hs, Tp, Dir, TC_category

(time,), fam_V, {fam: sea, swell_1, … V: Hs, Tp, Dir} (time,), extra_var1, extra_var2, …

config - configuration dictionary: view self.ConfigVariables() proxy - variable used to get DWTs max. storms (default AWL).

proxy variable has to be inside WVS xarray.Dataset

GEV_Parameters_Sampling(n_sims)[source]

Sample new GEV/GUMBELL parameters using GEV/GUMBELL asymptotic variances

num_sims - number of GEV parameters to sample

GenerateTCs(n_clusters, DWT, DWT_time, TCs_params, TCs_simulation, prob_TCs, MU_WT, TAU_WT, xds_wvs_sim, extra_vars_update=[])[source]

Climate Emulator DWTs TCs simulation

n_clusters - KMA number of clusters DWT - np.array with DWT bmus sim series (dims: time,)

TCs_params - xr.Dataset. vars(storm): pressure_min TCs_simulation - xr.Dataset. vars(storm): mu, hs, ss, tp, dir prob_TCs - cumulative probabilities of TC category change MU_WT, TAU_WT - intradaily hidrographs for each WT xds_wvs_sim - xr.Dataset, waves simulated without TCs (for updating)

extra_vars_update - list(string), optional extra variables to update with value from “TCs_simulation”

returns xarray.Datasets with updated Waves and simulated TCs data

vars waves:: fam*_*vn (fam: sea, swell_1, swell_2 …, vn: Hs, Tp, Dir),
vars TCS:: mu, tau, ss

dims: storm

GenerateWaves(bmus, n_clusters, chrom, chrom_probs, sigma, xds_WVS_MS, xds_WVS_TCs, xds_GEV_Par_Sampled, DWT, DWT_time, filters={'hs': False, 'tp': False, 'ws': False})[source]

Climate Emulator DWTs waves simulation

bmus - KMA max. storms bmus series n_clusters - KMA number of clusters chrom, chrom_probs - chromosomes and probabilities sigma - pearson correlation for each WT xds_GEV_Par_Sampled - GEV/GUMBELL parameters sampled for simulation DWT - np.array with DWT bmus sim series (dims: time,) filters - filter simulated waves by hs, tp, and/or wave setpness

Returns xarray.Dataset with simulated storm data

vars:: fam*_*vn (fam: sea, swell_1, swell_2, vn: Hs, Tp, Dir), DWT_sim

dims: storm

ICDF_Distribution(vn, vv, pb, xds_GEV_Par, i_wt)[source]

Switch function: GEV / Empirical / Weibull

Check variable distribution and calculates ICDF

vn - var name vv - var value pb - var simulation probs i_wt - Weather Type index xds_GEV_Par: GEV parameters

Load()[source]: Loads fitted climate emulator data

LoadSim(n_sim=0)[source]: Load waves and TCs simulations

LoadSim_All(n_sim_ce=0, TCs=True)[source]

Load all waves and TCs (1 DWT -> 1 output) simulations.

Each max. storm simulation has a different time dimension, returns a pandas.DataFrame with added columns ‘time’ and ‘n_sim’

output will merge WVS_upd and TCs_sim data variables

a unique n_sim_ce (inner climate emulator simulation) has to be chosen.

TCs - True / False. Load WVS (TCs updated) + TCs / WVS (without TCs) simulations

Report_Fit(vns_GEV=['Hs'], show=True, plot_chrom=True, plot_sigma=True)[source]

Report for extremes model fitting

GEV parameters for vns_GEV
chromosomes probabilities
sigma correlation

Report_Gev(vn='Hs', show=True)[source]: Plot vn variable GEV parameters for each WT. variables: Hs, Tp

Report_Sim_QQplot(WVS_sim, vn, n_sim=0, show=True)[source]: QQplot for variable vn

Save()[source]: Saves fitted climate emulator data

SaveSim(WVS_sim, TCs_sim, WVS_upd, n_sim)[source]: Store waves and TCs simulation

Set_Simulation_Folder(p_sim, copy_WAVES_noTCs=False)[source]

Modifies climate emulator default simulation path

p_sim - new simulation path copy_WAVES_noTCs - copies simulated waves (no TCs) from original path

Simulate_TCs(xds_DWT, WVS_sims, xds_TCs_params, xds_TCs_simulation, prob_change_TCs, MU_WT, TAU_WT, extra_vars_update=[])[source]

Climate Emulator DWTs TCs simulation

xds_DWT - xarray.Dataset, vars: evbmus_sims (time,) WVS_sim - xarray.Dataset, output from Simulate_Waves()

xds_TCs_params - xr.Dataset. vars(storm): pressure_min xds_TCs_simulation - xr.Dataset. vars(storm): mu, hs, ss, tp, dir prob_change_TCs - cumulative probabilities of TC category change MU_WT, TAU_WT - intradaily hidrographs for each WT

extra_vars_update - list(string), optional extra variables to update with value from “xds_TCs_simulation”

Simulate_Waves(xds_DWT, n_sims=1, filters={'hs': False, 'tp': False, 'ws': False})[source]

Climate Emulator DWTs waves simulation

xds_DWT - xarray.Dataset, vars: evbmus_sims (time,) n_sims - number of simulations to compute filters - filter simulated waves by hs, tp, and/or wave setpness

bluemath_tk.teslakit.climate_emulator.tqdm(*args, **kwargs)[source]

bluemath_tk.teslakit.database module

class bluemath_tk.teslakit.database.Database(data_folder)[source]

Bases: object

Teslakit database

CheckInputFiles()[source]: Checks teslakit required input files availability

Generate_HIST_Covariates()[source]

Load, fix, and resample (hourly) all historical covariates:: AWTs, DWTs, MJO, MMSL, AT

Generate_SIM_Covariates(total_sims=None)[source]

Load_AWAC_buoy()[source]

Load_AWTs_DWTs_Plots_hist()[source]: Load data needed for WT-WT Probs plot

Load_AWTs_DWTs_Plots_sim(n_sim=0)[source]: Load data needed for WT-WT Probs plot

Load_ESTELA_DWT_sim()[source]

Load_ESTELA_KMA()[source]

Load_ESTELA_SLP()[source]

Load_ESTELA_coast()[source]

Load_ESTELA_data()[source]

Load_HIST_NEARSHORE(vns=[], decode_times=False, use_cftime=False)[source]

Load_HIST_OFFSHORE(vns=[], decode_times=False, use_cftime=False)[source]

Load_HYCREWW()[source]: Load RBF coefficients and hycreww sims. max and min values

Load_MJO_DWTs_Plots_hist()[source]: Load data needed for WT-WT Probs plot

Load_MJO_DWTs_Plots_sim(n_sim=0)[source]: Load data needed for WT-WT Probs plot

Load_MJO_hist()[source]

Load_MJO_sim()[source]

Load_MU_TAU_hydrograms()[source]

Load_RCP85()[source]

Load RCP85 longitude, latitude and ocurrence

# lon -> (0.5 , 359.5) dlon = 1º # lat -> (-89.5, 89.5) dlat = 1º

Load_SIM_NEARSHORE(n_sim, vns=[], decode_times=False, use_cftime=False)[source]

Load_SIM_NEARSHORE_all(vns=[], decode_times=False, use_cftime=False)[source]

Load_SIM_OFFSHORE(n_sim, vns=[], decode_times=False, use_cftime=False)[source]

Load_SIM_OFFSHORE_all(vns=[], decode_times=False, use_cftime=False)[source]

Load_SST()[source]

Load_SST_AWT_sim()[source]

Load_SST_KMA()[source]

Load_SST_PCA()[source]

Load_SST_PCs_fit_rnd()[source]

Load_SST_PCs_sim_d()[source]

Load_SST_PCs_sim_m()[source]

Load_SeaLevelRise()[source]

Load_TCs_Nakajo()[source]

Load_TCs_noaa()[source]

Load_TCs_probs_synth()[source]

Load_TCs_r1_hist()[source]

Load_TCs_r2_hist()[source]

Load_TCs_r2_mda_Simulations()[source]

Load_TCs_r2_mda_Simulations_hytc()[source]

Load_TCs_r2_mda_params()[source]

Load_TCs_r2_sim_params()[source]

Load_TCs_sim_r2_rbf_output()[source]

Load_TIDE_gauge()[source]

Load_TIDE_hist_astro()[source]

Load_TIDE_hist_mmsl()[source]

Load_TIDE_mmsl_params()[source]

Load_TIDE_sim_astro()[source]

Load_TIDE_sim_mmsl()[source]

Load_WAVES_hist()[source]

Load_WAVES_partitions()[source]

Load_WAVES_partitions_GOW()[source]

Load_WAVES_spectra()[source]

MakeNewSite(site_name)[source]: Makes all directories and .ini files needed for a new teslakit project site

Save_ESTELA_DWT_sim(xds)[source]

Save_HIST_NEARSHORE(xds)[source]

Save_HIST_OFFSHORE(xds)[source]

Save_MJO_sim(xds)[source]

Save_MU_TAU_hydrograms(l_xds)[source]

Save_SIM_NEARSHORE(xds, n_sim)[source]

Save_SIM_OFFSHORE(xds, n_sim)[source]

Save_SST_AWT_sim(xds)[source]

Save_SST_KMA(xds)[source]

Save_SST_PCA(xds)[source]

Save_SST_PCs_fit_rnd(d_PCs_fit, d_PCs_rnd)[source]

Save_SST_PCs_sim(xds)[source]

Save_TCs_probs_synth(xds)[source]

Save_TCs_r1_hist(xds_tcs, xds_params)[source]

Save_TCs_r1_mda_params(xds)[source]

Save_TCs_r1_sim_params(xds)[source]

Save_TCs_r2_hist(xds_tcs, xds_params)[source]

Save_TCs_r2_mda_Simulations_hytc(xds)[source]

Save_TCs_r2_mda_params(xds)[source]

Save_TCs_r2_sim_params(xds)[source]

Save_TCs_sim_r2_rbf_output(xds)[source]

Save_TIDE_hist_astro(xds)[source]

Save_TIDE_hist_mmsl(xds)[source]

Save_TIDE_mmsl_params(xds)[source]

Save_TIDE_sim_astro(xds)[source]

Save_TIDE_sim_mmsl(xds)[source]

Save_WAVES_hist(xds)[source]

Save_WAVES_partitions(xds)[source]

SetSite(site_name)[source]: Sets current site

class bluemath_tk.teslakit.database.PathControl(p_data)[source]

Bases: object

auxiliar object for handling teslakit files paths

FilesSummary()[source]: return detailed database and site files summary

SetSite(site_name)[source]: Sets dictionary with site files

class bluemath_tk.teslakit.database.SplitStorage(p_storage)[source]

Bases: object

Handles teslakit hourly data split in multiple netCDF4 files

Load(vns=[], decode_times=False, use_cftime=False)[source]

Save(xds, safe_time=False)[source]

class bluemath_tk.teslakit.database.atdict[source]

Bases: dict

modified dictionary that works using “.key”

bluemath_tk.teslakit.database.clean_files(l_files)[source]: remove files at list

bluemath_tk.teslakit.database.fill_metadata(xds, set_source=False)[source]

for each variable in xarray.Dataset xds, attributes will be set using resources/variables_attrs.json

set_source - True for adding package source and institution metadata

class bluemath_tk.teslakit.database.hyswan_db(p_base)[source]

Bases: object

database for MDA-SWAN-RBF methodology

Load(key)[source]

Save(key, pd_data)[source]

bluemath_tk.teslakit.database.save_nc(xds, p_save, safe_time=False)[source]

(SECURE) exports xarray.Dataset to netcdf file format.

fills dataset with teslakit variables and source metadata

avoids overwritting problems

set safe_time=True if dataset contains dates beyond 2262

bluemath_tk.teslakit.estela module

class bluemath_tk.teslakit.estela.Predictor(p_store)[source]

Bases: object

tesla-kit custom dataset handler

used for 3D dataset (lon,lat,time) and related statistical classification calculations and figures.

Calc_KMA_regressionguided(num_clusters, xds_waves, waves_vars, alpha, min_group_size=None, repres=0.95)[source]: KMA regression guided with waves data

Calc_MU_TAU_Hydrographs(xds_WAVES)[source]

Calculates TWL hydrographs

returns list of xarray.Dataset with TWL hydrographs MU,TAU arrays for each WT

Calc_PCA_EstelaPred(var_name, xds_estela)[source]: Principal components analysis using estela predictor

Load()[source]

Mod_KMA_AddStorms(storm_dates, storm_categories)[source]: Modify KMA bmus series adding storm category (6 new groups)

Plot_DWT_PCs(n=3, show=True)[source]: Plot Daily Weather Types PCs using 2D axis

Plot_DWTs(var_name, kind='mean', show=True)[source]

Plot KMA clusters generated in PCA_EstelaPred (DWTs)

kind = mean / anom

uses database means/anomalies at cluster location (bmus corrected)

Plot_DWTs_Probs(show=True, field='sorted_bmus', n_clusters=None)[source]

Plot DWTs bmus probabilities

histogram for ocurrences
probs. all series
probs by month
probs by 3month

Plot_EOFs_EstelaPred(n_plot=3, show=True)[source]: Plot EOFs generated in PCA_EstelaPred

Plot_PCs_3D(show=True)[source]: Plots Predictor first 3 PCs

Save()[source]

bluemath_tk.teslakit.estela.dynamic_estela_predictor(xdset, var_name, estela_D)[source]

Generate dynamic predictor using estela

xdset:: (time, latitude, longitude), var_name, mask
returns similar xarray.Dataset with variables:: (time, latitude, longitude), var_name_comp (time, latitude, longitude), var_name_gradient_comp

bluemath_tk.teslakit.estela.mask_from_poly(xdset, ls_poly, name_mask='mask')[source]

Generate mask from list of tuples (lon, lat)

xdset dimensions:: (longitude, latitude, )

returns xdset with new variable “mask”

bluemath_tk.teslakit.estela.spatial_gradient(xdset, var_name)[source]

Calculate spatial gradient

xdset:: (longitude, latitude, time), var_name

returns xdset with new variable “var_name_gradient”

bluemath_tk.teslakit.extremes module

bluemath_tk.teslakit.extremes.ACOV(f, theta, x)[source]

Returns asyntotyc variance matrix using Fisher Information matrix inverse Generalized functions, parameters and data.

f - function to evaluate: GEV, GUMBELL, … theta - function parameters: for GEV (shape, location, scale) x - data used for function evaluation

Second derivative evaluation - variance and covariance dxx = (f(x+dt_x) - 2f(x) + f(x-dt_x)) / (dt_x**2) dxy = (f(x,y) - f(x-dt_x,y) - f(x,y-dt_y) + f(x-dt_x, u-dt_y)) / (dt_x*dt_y)

bluemath_tk.teslakit.extremes.FitGEV_KMA_Frechet(bmus, n_clusters, var)[source]

Returns stationary GEV/Gumbel_L params for KMA bmus and varible series

bmus - KMA bmus (time series of KMA centroids) n_clusters - number of KMA clusters var - time series of variable to fit to GEV/Gumbel_L

returns np.array (n_clusters x parameters). parameters = (shape, loc, scale) for gumbel distributions shape value will be ~0 (0.0000000001)

bluemath_tk.teslakit.extremes.Peaks_Over_Threshold(xds, var_name, percentile=99, threshold=None, window_days=3)[source]

Peaks Over Threshold methodology to find extreme values.

xds - xarray.Dataset (time dim) var_name - variable to apply POT percentile - if threshold not given, calculate it with this percentile threshold - optional, threshold to apply POT window_days - minimum number of days between consecutive independent peaks

returns xarray.Dataset (‘time’, ) vars: peaks, excedeence, area, and duration

bluemath_tk.teslakit.extremes.Smooth_GEV_Shape(cenEOFs, param)[source]

Smooth GEV shape parameter (for each KMA cluster) by promediation with neighbour EOFs centroids

cenEOFs - (n_clusters, n_features) KMA centroids param - GEV shape parameter for each KMA cluster

returns smoothed GEV shape parameter as a np.array (n_clusters)

bluemath_tk.teslakit.intradaily module

bluemath_tk.teslakit.intradaily.Calculate_Hydrographs(xds_BMUS, xds_WAVES)[source]

Calculates intradaily hydrographs

xds_BMUS: (time) bmus xds_WAVES: (time) hs, tp, dir

returns dictionary of Hydrograph objects for each WT and list of xarray.Datasets containing MU and TAU

class bluemath_tk.teslakit.intradaily.Hydrograph[source]

Bases: object

Stores hydrograph data

bluemath_tk.teslakit.kma module

bluemath_tk.teslakit.kma.ChangeProbabilities(series, set_values)[source]: return series transition count and probabilities

bluemath_tk.teslakit.kma.ClusterProbabilities(series, set_values)[source]: return series probabilities for each item at set_values

bluemath_tk.teslakit.kma.KMA_regression_guided(xds_PCA, xds_Yregres, num_clusters, repres=0.95, alpha=0.5, min_group_size=None)[source]

KMeans Classification for PCA data: regression guided

xds_PCA:: (n_components, n_components) PCs (n_components, n_features) EOFs (n_components, ) variance
xds_Yregres:: (time, vars) Ym

num_clusters repres

bluemath_tk.teslakit.kma.KMA_simple(xds_PCA, num_clusters, repres=0.95)[source]

KMeans Classification for PCA data

xds_PCA:: (n_components, n_components) PCs (n_components, n_features) EOFs (n_components, ) variance

num_clusters repres

returns a xarray.Dataset containing KMA data

bluemath_tk.teslakit.kma.Persistences(series)[source]: Return series persistences for each element

bluemath_tk.teslakit.kma.SimpleMultivariateRegressionModel(xds_PCA, xds_WAVES, name_vars)[source]

Regression model between daily predictor and predictand

xds_PCA: predictor: SLP GRD PCAS: (n_components, n_components) PCs (n_components, n_features) EOFs (n_components, ) variance
xds_WAVES: predictand waves data: name_vars will be used as predictand (ex: [‘hs’,’t02’]) dim: time

returns a xarray.Dataset

bluemath_tk.teslakit.kma.sort_cluster_gen_corr_end(centers, dimdim)[source]: SOMs alternative

bluemath_tk.teslakit.mda module

bluemath_tk.teslakit.mda.DeNormalize(data_norm, ix_scalar, ix_directional, minis, maxis)[source]

DeNormalize data subset for MaxDiss algorithm

data - data to normalize, data variables at columns. ix_scalar - scalar columns indexes ix_directional - directional columns indexes

bluemath_tk.teslakit.mda.MaxDiss_Simplified_NoThreshold(data, num_centers, ix_scalar, ix_directional)[source]

Normalize data and calculate centers using maxdiss simplified no-threshold algorithm

data - data to apply maxdiss algorithm, data variables at columns num_centers - number of centers to calculate ix_scalar - scalar columns indexes ix_directional - directional columns indexes

bluemath_tk.teslakit.mda.Normalize(data, ix_scalar, ix_directional, minis=[], maxis=[])[source]

Normalize data subset - norm = val - min) / (max - min)

data - data to normalize, data variables at columns. ix_scalar - scalar columns indexes ix_directional - directional columns indexes

bluemath_tk.teslakit.mda.Normalized_Distance(M, D, ix_scalar, ix_directional)[source]

Normalized distance between rows in M and D

M - numpy array D - numpy array ix_scalar - scalar columns indexes ix_directional - directional columns indexes

bluemath_tk.teslakit.mda.nearest_indexes(data_q, data, ix_scalar, ix_directional)[source]

for each row in data_q, find nearest point in data and store index.

Returns array of indexes of each nearest point to all entries in data_q

bluemath_tk.teslakit.mjo module

bluemath_tk.teslakit.mjo.MJO_Categories(rmm1, rmm2, phase)[source]

Divides MJO data in 25 categories.

rmm1, rmm2, phase - MJO parameters

returns array with categories time series and corresponding rmm

bluemath_tk.teslakit.mjo.MJO_Phases(rmm1, rmm2)[source]: calculates and returns MJO phases (1-8) and degrees

bluemath_tk.teslakit.pca module

bluemath_tk.teslakit.pca.PCA_EstelaPred(xds, pred_name)[source]

Principal component analysis method: custom for estela predictor

xds:: (time, latitude, longitude), pred_name_comp | pred_name_gradient_comp

returns a xarray.Dataset containing PCA data: PCs, EOFs, variance

bluemath_tk.teslakit.pca.PCA_LatitudeAverage(xds, var_name, y1, y2, m1, m2)[source]

Principal component analysis method: remove monthly running mean and latitude average

xds:: (longitude, latitude, time), pred_name | pred_name_runavg

returns a xarray.Dataset containing PCA data: PCs, EOFs, variance

bluemath_tk.teslakit.pca.RunnningMean_Monthly(xds, var_name, window=5)[source]

Calculate running average grouped by months

xds:: (longitude, latitude, time) variables: var_name

returns xds with new variable “var_name_runavg”

bluemath_tk.teslakit.pca.running_mean(x, N, mode_str='mean')[source]

computes a running mean (also known as moving average) on the elements of the vector X. It uses a window of 2*M+1 datapoints

As always with filtering, the values of Y can be inaccurate at the edges. RUNMEAN(…, MODESTR) determines how the edges are treated. MODESTR can be one of the following strings:

‘edge’X is padded with first and last values along dimension
DIM (default)

‘zeros’ : X is padded with zeros ‘ones’ : X is padded with ones ‘mean’ : X is padded with the mean along dimension DIM

X should not contains NaNs, yielding an all NaN result.

bluemath_tk.teslakit.rbf module

bluemath_tk.teslakit.rbf.CalcRBF_Coeff(ep, x, y)[source]

bluemath_tk.teslakit.rbf.CostEps(ep, x, y)[source]

bluemath_tk.teslakit.rbf.RBF_Assemble(x, phi, const, smooth)[source]

bluemath_tk.teslakit.rbf.RBF_Interpolation(rbf_constant, rbf_coeff, nodes, x)[source]

bluemath_tk.teslakit.rbf.RBF_Reconstruction(subset, ix_scalar_subset, ix_directional_subset, target, ix_scalar_target, ix_directional_target, dataset)[source]

Radial Basis Function (Gaussian) interpolator.

subset - subset used for fitting RBF (dim_input) ix_scalar_subset - scalar columns indexes for subset ix_directional_subset - directional columns indexes for subset target - target used for fitting RBF (dim_output) ix_scalar_target - scalar columns indexes for target ix_directional_target - directional columns indexes for target dataset - dataset used for RBF interpolation (dim_input)

bluemath_tk.teslakit.rbf.RBF_Validation(subset, ix_scalar_subset, ix_directional_subset, target, ix_scalar_target, ix_directional_target, n_splits=3, shuffle=False)[source]

Radial Basis Function (Gaussian) k-fold mean squared error

subset - subset used for fitting RBF (dim_input) ix_scalar_subset - scalar columns indexes for subset ix_directional_subset - directional columns indexes for subset target - target used for fitting RBF (dim_output) ix_scalar_target - scalar columns indexes for target ix_directional_target - directional columns indexes for target

bluemath_tk.teslakit.rbf.rbfphi_cubic(r, const)[source]

bluemath_tk.teslakit.rbf.rbfphi_gaussian(r, const)[source]

bluemath_tk.teslakit.rbf.rbfphi_linear(r, const)[source]

bluemath_tk.teslakit.rbf.rbfphi_multiquadratic(r, const)[source]

bluemath_tk.teslakit.rbf.rbfphi_thinplate(r, const)[source]

bluemath_tk.teslakit.statistical module

bluemath_tk.teslakit.statistical.CopulaSimulation(U_data, kernels, num_sim)[source]

Fill statistical space using copula simulation

U_data: 2D nump.array, each variable in a column kernels: list of kernels for each column at U_data (KDE | GPareto) num_sim: number of simulations

bluemath_tk.teslakit.statistical.Empirical_CDF(x)[source]: Returns empirical cumulative probability function at x.

bluemath_tk.teslakit.statistical.Empirical_ICDF(x, p)[source]: Returns inverse empirical cumulative probability function at p points

bluemath_tk.teslakit.statistical.GeneralizedPareto_CDF(x)[source]: Generalized Pareto fit Returns cumulative probability function at x.

bluemath_tk.teslakit.statistical.GeneralizedPareto_ICDF(x, p)[source]: Generalized Pareto fit Returns inverse cumulative probability function at p points

bluemath_tk.teslakit.statistical.copulafit(u, family='gaussian')[source]: Fit copula to data. Returns correlation matrix and degrees of freedom for t student

bluemath_tk.teslakit.statistical.copularnd(family, rhohat, n)[source]: Random vectors from a copula

bluemath_tk.teslakit.statistical.ksdensity_CDF(x)[source]: Kernel smoothing function estimate. Returns cumulative probability function at x.

bluemath_tk.teslakit.statistical.ksdensity_ICDF(x, p)[source]: Returns Inverse Kernel smoothing function at p points

bluemath_tk.teslakit.statistical.runmean(X, m, modestr)[source]: parsed runmean function from original matlab codes.

bluemath_tk.teslakit.storms module

bluemath_tk.teslakit.storms.Extract_Circle(xds_TCs, p_lon, p_lat, r, d_vns)[source]

Extracts TCs inside circle - used with NWO or Nakajo databases

xds_TCs: tropical cyclones track database: lon, lat, pressure variables storm dimension
circle defined by:: p_lon, p_lat - circle center r - circle radius (degree)

d_vns: dictionary to set longitude, latitude, time and pressure varnames

Returns:: selection of xds_TCs inside circle xds_inside: contains TCs custom data inside circle
Return type:: xds_area

bluemath_tk.teslakit.storms.GeoAzimuth(lat1, lon1, lat2, lon2)[source]: Returns geodesic azimuth between point1 and point2

bluemath_tk.teslakit.storms.GeoDistance(lat1, lon1, lat2, lon2)[source]: Returns great circle distance between points in degrees

bluemath_tk.teslakit.storms.GetCategoryChangeProbs(xds_r1, xds_r2)[source]: Calculates category change probabilities from r1 to r2

bluemath_tk.teslakit.storms.GetStormCategory(pres_min)[source]: Returns storm category (int 5-0)

bluemath_tk.teslakit.storms.SortCategoryCount(np_categ, nocat=9)[source]: Sort category change - count matrix np_categ = [[category1, category2, count], …]

bluemath_tk.teslakit.tides module

bluemath_tk.teslakit.tides.Calculate_MMSL(xda_tide, year_ini, year_end)[source]

Calculate monthly mean sea level

xda_tide - xarray.DataArray (time,)

bluemath_tk.teslakit.waves module

bluemath_tk.teslakit.waves.AWL(hs, tp)[source]: Returns Atmospheric Water Level

bluemath_tk.teslakit.waves.Aggregate_WavesFamilies(wvs_fams, a_tp='quadratic')[source]

Aggregate Hs, Tp and Dir from waves families data

wvs_fams (waves families):: xarray.Dataset (time,), fam1_Hs, fam1_Tp, fam1_Dir, … {any number of families}

a_tp = ‘quadratic’ / ‘max_energy’, Tp aggregation formulae

returns Hs, Tp, Dir (numpy.array)

bluemath_tk.teslakit.waves.GetDistribution_gow(xds_wps, swell_sectors, n_partitions=5)[source]

Separates wave partitions (0-n_partitions) into families. Default: sea, swl1, swl2

compatible with GOW.mat file

xds_wps (waves partitionss):: xarray.Dataset (time,), phs, pspr, pwfrac… {0-5 partitions}

sectors: list of degrees to cut wave energy [(a1, a2), (a2, a3), (a3, a1)]

returns: xarray.Dataset (time,), fam_V, {fam: sea,swell_1,swell2. V: Hs,Tp,Dir}

bluemath_tk.teslakit.waves.GetDistribution_ws(xds_wps, swell_sectors, n_partitions=5)[source]

Separates wave partitions (0-5) into families. Default: sea, swl1, swl2

Compatible with wavespectra partitions

xds_wps (waves partitionss):: xarray.Dataset (time,), phs, pspr, pwfrac… {0-5 partitions}

sectors: list of degrees to cut wave energy [(a1, a2), (a2, a3), (a3, a1)]

returns: xarray.Dataset (time,), fam_V, {fam: sea,swell_1,swell2. V: Hs,Tp,Dir}

bluemath_tk.teslakit.waves.Intradaily_Hydrograph(xds_wvs, xds_tcs)[source]

Calculates intradaily hydrograph (hourly) from a time series of storms. storms waves data (hs, tp, dir) and TCs data (mu, tau, ss) is needed.

xds_wvs (waves aggregated):: xarray.Dataset (time,), Hs, Tp, Dir
xds_tcs (TCs):: xarray.Dataset (time,), mu, tau, ss

returns xarray.Dataset (time,), Hs, Tp, Dir, SS (hourly)

bluemath_tk.teslakit.waves.Snell_Propagation(T, H_I, dir_I, Prof_I, Prof_E, OrientBati)[source]

[H_E,dir_E]=PropagacionSNELL(T,H_I,dir_I,Prof_I,Prof_E,OrientBati) [H_E,dir_E,L_E,L_I]=PropagacionSNELL(T,H_I,dir_I,Prof_I,Prof_E,OrientBati) [H_E,dir_E,L_E,L_I,Ks,Kr]=PropagacionSNELL(T,H_I,dir_I,Prof_I,Prof_E,OrientBati)

Descripci?n: Funci?n que propaga el oleaje por SNELL con batimetr?a recta y paralela.

Entradas:

T: Periodo. Segundos. H_I: Altura de ola en el punto inicial. Metros. dir_I: Direcci?n del oleaje inicial. Rumbo (0 en el N) prof_I: Profundidad inicial. Metros. prof_E: Profundidad final. Metros. OrientBati: Orientaci?n de la perpendicular a la batimetria. Rumbo (0 en el N)

Salidas:

H_E: Altura de ola en el punto final. Metros. dir_E: Direccion del oleaje final. Rumbo (0 en el N) L_E: Longitud de onda final. Metros L_I: Longitud de onda inicial. Metros Ks: Coeficiente de asomeramiento (shoaling). Kr: Coeficiente de refraccion (Snell batimetria recta y paralela).

Autor:

Versi?n:Ene/19

Basada en el script de: Soledad Requejo Landeira & Jos? Antonio ?lvarez Antol?nez

bluemath_tk.teslakit.waves.TWL(awl, ss, at, mmsl)[source]: Returns Total Water Level

bluemath_tk.teslakit.waves.dispersionLonda(T, h)[source]

Module contents

Project: BlueMath_tk Sub-Module: teslakit Author: GeoOcean Research Group, Universidad de Cantabria Repository: https://github.com/GeoOcean/BlueMath_tk.git Status: OLD VERSION WORKING (MUST be updated soon)