Temporal Reconstruction from Proper Orthogonal Decomposition


This treatment computes the temporal evolution of modes from a POD decomposition of a given input Base.


  • base_pod: Base

    The input base resulting from a treatment antares.treatment.TreatmentPOD, or having the same structure.

  • base_mesh: Base

    The input base containing the mesh of the domain used in the POD treatment. This base must only contain one zone.

  • mode: int, default= 0

    The POD mode number that has to be reconstructed in time. The first mode is the mode 0 and has the highest eigenvalue (largest energy content).

  • variables: list(str), default= []

    The variable names considered for the temporal reconstruction.

  • coordinates: list(str)

    The variable names that define the set of coordinates. If no value is given, the default coordinate system of the base base_mesh is used (see Base.coordinate_names).


The input base base must be issued from the antares.treatment.TreatmentPOD treatment, or it must respect the same structure as the output base of this treatment.

The input base base_mesh must only contain one zone.


The output base will contain one zone for the given mode.

The output base contains the coordinates of base_mesh and the instants that have been reconstructed from the POD mode considered.


import antares
myt = antares.Treatment('PODtoTemporal')
myt['base_pod'] = POD_base
myt['base_mesh'] = mesh_base
myt['mode'] = 0
myt['variables'] = ['psta']
output_base = myt.execute()

Main functions

class antares.treatment.TreatmentPODtoTemporal.TreatmentPODtoTemporal

Compute the temporal evolution of the considered POD mode.


The base with reconstructed instants.

Return type



This example illustrates the Proper Orthogonal Decomposition.
import os
import numpy as np
import antares

if not os.path.isdir('OUTPUT'):

# Create the input Base
time_step = 0.0003
nb_snapshot = 50
nb_space_points = 100

base = antares.Base()
zone = base['zone_0'] = antares.Zone()
for snapshot_idx in range(nb_snapshot):
    instant_name = 'snapshot_%s' % snapshot_idx
    inst = zone[instant_name] = antares.Instant()
    inst['pressure'] = 25.4 * np.cos(2 * np.pi * 250 * snapshot_idx * time_step + np.linspace(0, 2.5 * np.pi, nb_space_points))
    # constant pressure over the space domain evolving in time
    # base[0][instant_name]['pressure'] = np.cos(2 * np.pi * 0.01 * snapshot_idx * 2 + np.zeros((nb_space_points,)))

# ------------------
# Compute the POD
# ------------------
treatment = antares.Treatment('POD')
treatment['base'] = base
treatment['tolerance'] = 0.99
treatment['dim_max'] = 100
treatment['POD_vectors'] = True
treatment['variables'] = ['pressure']
result = treatment.execute()
# ------------------
# Get some results
# ------------------
print("POD modes: ", result[0]['modes'][0])
print("POD parameters: ")
for k, v in result.attrs.items():
    print(k, v)

base_mesh = antares.Base()
base_mesh[0][0]['x'] = range(nb_space_points)

t = antares.Treatment('PODtoTemporal')
t['base_mesh'] = base_mesh
t['base_pod'] = result
t['variable'] = ['pressure']
t['mode'] = 0
t['coordinates'] = ['x']
base_pod_temporal = t.execute()

writer = antares.Writer('bin_tp')
writer['base'] = base_pod_temporal
writer['filename'] = os.path.join('OUTPUT', 'ex_mode_0_reconstructed_temporal.plt')