pyLOM

Subpackages

• pyLOM.DMD
  • Module contents
    • run()
    • frequency_damping()
    • reconstruction_jovanovic()
    • extract_modes()
    • save()
    • load()
    • plotMode()
    • ritzSpectrum()
    • amplitudeFrequency()
    • dampingFrequency()
    • plotResidual()
    • plotSnapshot()
• pyLOM.GPOD
  • Module contents
    • GappyPOD
      • GappyPOD.__init__()
      • GappyPOD.fit()
      • GappyPOD.predict()
      • GappyPOD.reconstruct_full_set()
    • set_random_elements_to_zero()
    • delete_snapshot()
• pyLOM.GPR
  • Module contents
• pyLOM.MANIFOLD
  • Module contents
    • isomap()
    • mds()
• pyLOM.NN
  • Subpackages
    • pyLOM.NN.architectures
      • Module contents
  • Module contents
    • plotSnapshot()
    • plotModalErrorBars()
    • plotTimeSeries()
    • Pipeline
      • Pipeline.model
      • Pipeline.run()
    • Dataset
      • Dataset.shape
      • Dataset.num_parameters
      • Dataset.__getitem__()
      • Dataset.__setitem__()
      • Dataset.__add__()
      • Dataset.concatenate()
      • Dataset.crop()
      • Dataset.pad()
      • Dataset.get_splits()
      • Dataset.get_splits_by_parameters()
      • Dataset.load()
      • Dataset.map()
      • Dataset.filter()
      • Dataset.remove_column()
    • MinMaxScaler
      • MinMaxScaler.is_fitted
      • MinMaxScaler.fit()
      • MinMaxScaler.transform()
      • MinMaxScaler.fit_transform()
      • MinMaxScaler.inverse_transform()
      • MinMaxScaler.save()
      • MinMaxScaler.load()
    • select_device()
    • betaLinearScheduler
      • betaLinearScheduler.getBeta()
    • create_results_folder()
    • set_seed()
    • OptunaOptimizer
      • OptunaOptimizer.optimization_params
      • OptunaOptimizer.optimize()
    • RegressionEvaluator
      • RegressionEvaluator.tolerance
      • RegressionEvaluator.mean_squared_error()
      • RegressionEvaluator.mean_absolute_error()
      • RegressionEvaluator.mean_relative_error()
      • RegressionEvaluator.ae_q()
      • RegressionEvaluator.l2_error()
      • RegressionEvaluator.R2()
      • RegressionEvaluator.print_metrics()
      • RegressionEvaluator.__call__()
    • EarlyStopper
      • EarlyStopper.early_stop()
    • MLP
      • MLP.forward()
      • MLP.fit()
      • MLP.predict()
      • MLP.save()
      • MLP.load()
      • MLP.create_optimized_model()
    • KAN
      • KAN.forward()
      • KAN.fit()
      • KAN.predict()
      • KAN.save()
      • KAN.load()
      • KAN.create_optimized_model()
    • ChebyshevLayer
      • ChebyshevLayer.forward()
    • JacobiLayer
      • JacobiLayer.forward()
    • Autoencoder
      • Autoencoder.forward()
      • Autoencoder.fit()
      • Autoencoder.reconstruct()
      • Autoencoder.latent_space()
      • Autoencoder.decode()
    • VariationalAutoencoder
      • VariationalAutoencoder.forward()
      • VariationalAutoencoder.fit()
      • VariationalAutoencoder.reconstruct()
      • VariationalAutoencoder.correlation()
      • VariationalAutoencoder.modes()
      • VariationalAutoencoder.latent_space()
      • VariationalAutoencoder.fine_tune()
      • VariationalAutoencoder.decode()
    • Encoder2D
      • Encoder2D.forward()
    • Decoder2D
      • Decoder2D.forward()
    • Encoder3D
      • Encoder3D.forward()
    • Decoder3D
      • Decoder3D.forward()
    • ShallowDecoder
      • ShallowDecoder.forward()
    • PINN
      • PINN.__call__()
      • PINN.bc_data_loss()
      • PINN.compute_loss()
      • PINN.fit()
      • PINN.predict()
      • PINN.__repr__()
      • PINN.plot_training_logs()
      • PINN.pde_loss()
      • PINN.save()
      • PINN.load()
    • BurgersPINN
      • BurgersPINN.pde_loss()
    • Euler2DPINN
      • Euler2DPINN.GAMMA
      • Euler2DPINN.pde_loss()
    • NavierStokesIncompressible2DPINN
      • NavierStokesIncompressible2DPINN.pde_loss()
    • BoundaryCondition
      • BoundaryCondition.loss()
      • BoundaryCondition.points
    • SHRED
      • SHRED.forward()
      • SHRED.freeze()
      • SHRED.unfreeze()
      • SHRED.fit()
      • SHRED.save()
    • tanh()
    • relu()
    • elu()
    • sigmoid()
    • leakyRelu()
    • silu()
• pyLOM.POD
  • Module contents
    • run()
    • truncate()
    • reconstruct()
    • extract_modes()
    • save()
    • load()
    • plotMode()
    • plotResidual()
    • plotSnapshot()
• pyLOM.SPOD
  • Module contents
    • run()
    • extract_modes()
    • save()
    • load()
    • plotMode()
    • plotSpectra()
• pyLOM.io
  • Module contents
    • h5_append_dset()
    • h5_load_DMD()
    • h5_load_POD()
    • h5_load_SPOD()
    • h5_load_dset()
    • h5_load_mesh()
    • h5_save_DMD()
    • h5_save_POD()
    • h5_save_SPOD()
    • h5_save_VAE()
    • h5_save_dset()
    • h5_save_mesh()
    • pkl_load()
    • pkl_save()
    • pv_writer()
    • vtkh5_link_mesh()
    • vtkh5_save_field()
    • vtkh5_save_mesh()
• pyLOM.utils
  • Module contents
    • raiseError()
    • raiseWarning()
    • round()
    • cr()
    • cr_nvtx()
    • cr_start()
    • cr_stop()
    • cr_info()
    • nvtxp()
    • mem()
    • mem_start()
    • mem_stop()
    • mem_info()
    • worksplit()
    • writesplit()
    • is_rank_or_serial()
    • pprint()
    • mpi_barrier()
    • mpi_send()
    • mpi_recv()
    • mpi_sendrecv()
    • mpi_scatter()
    • mpi_gather()
    • mpi_reduce()
    • mpi_bcast()
    • gpu_device()
    • gpu_to_cpu()
    • cpu_to_gpu()
    • ascontiguousarray()
• pyLOM.math
  • Module contents
    • MAE()
    • MRE_array()
    • RMSE()
    • argsort()
    • cellCenters()
    • cholesky()
    • compute_truncation_residual()
    • conj()
    • data_splitting()
    • diag()
    • eigen()
    • energy()
    • euclidean_d()
    • fft()
    • find_random_sensors()
    • flip()
    • hammwin()
    • init_qr_streaming()
    • inv()
    • least_squares()
    • matmul()
    • matmulp()
    • normals()
    • polar()
    • qr()
    • r2()
    • randomized_qr()
    • randomized_svd()
    • ridge_regresion()
    • subtract_mean()
    • svd()
    • temporal_mean()
    • time_delay_embedding()
    • transpose()
    • tsqr()
    • tsqr_svd()
    • update_qr_streaming()
    • vandermonde()
    • vandermondeTime()
    • vecmat()
    • vector_mean()
    • vector_norm()
    • vector_sum()

Module contents

class pyLOM.Dataset(xyz=None, ptable=None, vars=None, order=None, point=True, **kwargs)

Bases: object

The Dataset class wraps the position of the nodes and the time instants with the number of variables and relates them so that the operations in parallel are easier.

__init__(xyz=None, ptable=None, vars=None, order=None, point=True, **kwargs)

Class constructor

Inputs:

> xyz: coordinates of the points. > ptable: partition table used. > vars: dictionary containing the variable name and values as

as a python dictionary.

> order: ordering of the points (automatically created if none) > point: True if point data, False if cell data. > kwags: dictionary containing the field name and values as a

python dictionary.

__str__()

String representation

__getitem__(key)

Dataset[key]

Recover the value of a field given its key

__setitem__(key, value)

Dataset[key] = value

Set the field of a variable given its key

rename(new, old)

Rename a variable inside a field.

delete(varname)

Delete a variable inside a field.

get_variable(key: str)

Recover the value of a variable given its key

Parameters:

key (str) – name of the variable

Returns:

value of the variable

Return type:

(np.ndarray)

set_variable(key, value)

Recover the value of a variable given its key

get_dim(var, idim)

Recover the value of a variable for a given dimension

info(var)

Returns the information for a certain variable

to_gpu(fields=None)

Send field data to the GPU

to_cpu(fields=None)

Send field data to the CPU

add_field(varname, ndim, var)

Add a field to the dataset

add_variable(varname, idim, var)

Add a variable to the dataset

split_data(var, mode='reconstruct')

Generate random training, validation and test masks for a dataset of Nt samples.

Parameters:

• variable (str) – variable which will be splitted in different samples

• mode (str, optional) – type of splitting to perform (default, 'reconstruct'). In reconstruct mode all three datasets have samples along all the data range.

Returns:

List of arrays containing the identifiers of the training, validation and test samples.

Return type:

[(np.ndarray), (np.ndarray), (np.ndarray)]

mask_field(key, mask)

Mask a field over a defined variable

append_variable(varname, var, **fieldict)

Appends new timesteps to the dataset

select_random_sensors(nsensors, bounds, VARLIST, seed=-1)

Generates a set of coordinats of nsensors random sensors inside the region defined by bounds. Then for each sensor finds the nearest point from the dataset to get its coordinates and dataset value. It creates a new dataset containing all the sensor coordinates and values

reshape(field, info)

Reshape a field for a single variable according to the info

X(*args)

Return the X matrix for the selected fields

save(fname, **kwargs)

Store the field in various formats.

classmethod load(fname, **kwargs)

Load a field from various formats

property xyz

x()

property y

property z

property ordering

property point

property partition_table

property vars

property varnames

property fields

property fieldnames

class pyLOM.PartitionTable(nparts, ids, elements, points, has_master=False)

Bases: object

The partition table class contains information on the partition used for the given dataset or it can generate a new partition

__init__(nparts, ids, elements, points, has_master=False)

Class constructor

partition_bounds(rank, ndim=1, points=True)

Compute the partition bounds for a given rank

create_partition_points(conec)

Find which nodes this partition has

partition_points(npoints, ndim=1)

Compute the points to be read for this partition

reorder_points(xyz, conectivity)

Reorder the points array so that in matches with the partition table, in serial algorithm.

update_points(npoints_new)

Update the number of points on the table

check_split()

See if a table has the same number of subdomains than the number of mpi ranks

classmethod new(nparts, nelems, npoints, has_master=False)

Create a new partition table, in serial algorithm.

classmethod from_pyQvarsi(ptable, porder=1, ndime=3, has_master=False)

Create a partition table from a partition table coming from pyQvarsi

property n_partitions

property Ids

property Elements

property Points

property has_master

property nodes

class pyLOM.Mesh(mtype, xyz, connectivity, eltype, cellOrder, pointOrder, ptable)

Bases: object

The Mesh class wraps the mesh details of the case.

__init__(mtype, xyz, connectivity, eltype, cellOrder, pointOrder, ptable)

Class constructor

__str__()

String representation

find_point(xyz: array)

Return all the points where self._xyz == xyz

find_cell(eltype: int)

Return all the elements where self._elemList == elem

find_point_in_cell(inode: int)

Return all the elements where the node is

size(pointData: bool)

Return the size accoding to the type of data

cellcenters()

Computes and returns the cell centers

reshape_var(var: str, info: dict)

Reshape a variable according to the mesh

save(fname: str, **kwargs)

Store the mesh in various formats.

classmethod load(fname: str, **kwargs)

Load a mesh from various formats

classmethod new_struct2D(nx: int, ny: int, x: float, y: float, dimsx: float, dimsy: float, ptable=None)

classmethod new_struct3D(nx: int, ny: int, nz: int, x: float, y: float, z: float, dimsx: float, dimsy: float, dimsz: float, ptable=None)

classmethod from_pyQvarsi(mesh, ptable=None, sod: bool = False)

Create the mesh structure from a pyQvarsi mesh structure

property type

property npoints

property npointsG

property npointsG2

property ndim

property ncells

property ncellsG

property ncellsG2

property nnodcell

property xyz

property x

property y

property z

property xyzc

property normal

property connectivity

property cellOrder

property pointOrder

property partition_table

property eltype

property eltype2VTK

property eltype2ENSI

pyLOM.cr(ch_name, suff=0)

CR decorator

pyLOM.cr_nvtx(ch_name, suff=0, color='green')

CR NVTX decorator

pyLOM.cr_start(ch_name, suff)

Start the chrono of a channel

pyLOM.cr_stop(ch_name, suff)

Stop the chrono of a channel

pyLOM.cr_reset()

Delete all channels and start again

pyLOM.cr_info(rank=-1)

Print information - order by major sum

pyLOM.nvtxp(ch_name, color='blue')

CR NVTX decorator

pyLOM.pprint(rank, *args, **kwargs)

Print alternative for parallel codes. It works as python’s print with the rank variable, which can be negative for everyone to print or equal to the rank that should print.

pyLOM.show_plots()

Wrapper to matplotlib.pyplot.show()

pyLOM.close_plots()

Wrapper to matplotlib.pyplot.close()

pyLOM.style_plots(styleDict=DEFAULTSTYLE)

Define a common plot style in the scripts

pyLOM.gpu_device(id=MPI_RANK, gpu_per_node=4)

Setup the GPU to be used