modulo-vki 2.0.7__py3-none-any.whl → 2.1.1__py3-none-any.whl

modulo_vki/utils/_utils.py

@@ -25,11 +25,11 @@ def Bound_EXT(S, Ex, boundaries):
     # Ex=int((Nf-1)/2) # Extension on each size
     size_Ext = 2 * Ex + len(S)  # Compute the size of the extended signal
     S_extend = np.zeros((int(size_Ext)))  # Initialize extended signal
-    S_extend[Ex:int((size_Ext - Ex))] = S;  # Assign the Signal on the zeroes
+    S_extend[Ex:int((size_Ext - Ex))] = S  # Assign the Signal on the zeroes
 
     if boundaries == "reflect":
         LEFT = np.flip(S[0:Ex])  # Prepare the reflection on the left
-        RIGHT = np.flip(S[len(S) - Ex:len(S)])  # Prepare the reflectino on the right
+        RIGHT = np.flip(S[len(S) - Ex:len(S)])  # Prepare the reflection on the right
         S_extend[0:Ex] = LEFT
         S_extend[len(S_extend) - Ex:len(S_extend)] = RIGHT
     elif boundaries == "nearest":
@@ -90,6 +90,23 @@ def conv_m(K, h, Ex, boundaries):
         # K_F=K_F1+K_F2
     return K_F2
 
+def conv_m_2D(K, h, Ex, boundaries):
+
+    # Extended K
+    K_ext = np.pad(K, Ex, mode=boundaries)
+
+    # Filtering matrix
+    h_mat = np.outer(np.atleast_2d(h).T, np.atleast_2d(h))
+
+    # Filtering
+    K_filt = signal.fftconvolve(K_ext, h_mat, mode='valid')
+
+    # Interior K
+    Ex1 = int((len(K_filt) - len(K)) / 2)
+    K_F2 = K_filt[Ex1:(len(K_filt) - Ex1), Ex1:(len(K_filt) - Ex1)]
+
+    return K_F2
+
 
 def _loop_gemm(a, b, c=None, chunksize=100):
     size_i = a.shape[0]

modulo_vki/utils/others.py

@@ -201,7 +201,7 @@ def Plot_2D_CFD_Cyl(Xg,Yg,U,V,k=10,CL=16,Name='', verbose=False):
     V_g=V[:,k].reshape(n_y,n_x).T
     # Prepare the plot        
     fig, ax = plt.subplots(figsize=(6, 3)) # This creates the figure
-    plt.contourf(Xg,Yg,np.sqrt(U_g**2+V_g**2),30)
+    contour = plt.contourf(Xg,Yg,np.sqrt(U_g**2+V_g**2),30)
     # plt.quiver(Xg,Yg,U_g,V_g,scale=10000)
     ax.set_aspect('equal') # Set equal aspect ratio
     ax.set_xlabel('$x[mm]$',fontsize=13)
@@ -229,7 +229,7 @@ def Plot_2D_CFD_Cyl(Xg,Yg,U,V,k=10,CL=16,Name='', verbose=False):
     return 
 
 
-def Animation_2D_CFD_Cyl(Giff_NAME,D,Xg,Yg,In,Fin,Step):
+def Animation_2D_CFD_Cyl(Giff_NAME,D,Xg,Yg,In,Fin,Step,verbose=False):
     """
     The gif file is created from the provided data snapshot
     """
@@ -243,17 +243,22 @@ def Animation_2D_CFD_Cyl(Giff_NAME,D,Xg,Yg,In,Fin,Step):
     Fol_Out = 'Gif_Images_temporary'
     if not os.path.exists(Fol_Out):
         os.mkdir(Fol_Out)
-    # Loop to produce the Gifs    
+    # Loop to produce the Gifs
+    if not verbose:
+        print('Exporting images...')
     for k in range(1,n_t,Step):
      NameOUT = Fol_Out + os.sep + 'Im%03d' % (k) + '.png'
-     Plot_2D_CFD_Cyl(Xg,Yg,U,V,k=k+In,CL=16,Name=NameOUT)
+     Plot_2D_CFD_Cyl(Xg,Yg,U,V,k=k+In,CL=16,Name=NameOUT,verbose=verbose)
 
     import imageio  # This used for the animation
     images = []
 
+    if not verbose:
+        print('Preparing images...')
     for k in range(1,n_t,Step):
-        MEX = 'Preparing Im ' + str(k)
-        print(MEX)
+        if verbose:
+            MEX = 'Preparing Im ' + str(k)
+            print(MEX)
         NameOUT = Fol_Out + os.sep + 'Im%03d' % (k) + '.png'
         images.append(imageio.imread(NameOUT))
 
@@ -266,7 +271,7 @@ def Animation_2D_CFD_Cyl(Giff_NAME,D,Xg,Yg,In,Fin,Step):
 
 
 
-def Plot_Field_TEXT_Cylinder(File,Name_Mesh,Name_FIG):  
+def Plot_Field_TEXT_Cylinder(File,Name_Mesh,Name_FIG, show=False):  
    """
    This function plots the vector field from the TR-PIV in Exercise 4.
       
@@ -314,8 +319,12 @@ def Plot_Field_TEXT_Cylinder(File,Name_Mesh,Name_FIG):
    circle = plt.Circle((0,0),2.5,fill=True,color='r',edgecolor='k',alpha=0.5)
    plt.gcf().gca().add_artist(circle)
    plt.tight_layout()   
-   plt.savefig(Name_FIG, dpi=200) 
-   plt.show()
+   plt.savefig(Name_FIG, dpi=200)
+   
+   if show: 
+    plt.show()
+   
+   plt.close()
    print(Name_FIG+' printed')
    return n_s, Xg, Yg, Vxg, Vyg, X_S, Y_S
 

{modulo_vki-2.0.7.dist-info → modulo_vki-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: modulo_vki
-Version: 2.0.7
+Version: 2.1.1
 Summary: MODULO (MODal mULtiscale pOd) is a software developed at the von Karman Institute to perform Multiscale Modal Analysis of numerical and experimental data.
 Home-page: https://github.com/mendezVKI/MODULO/tree/master/modulo_python_package/
 Author: ['R. Poletti', 'L. Schena', 'D. Ninni', 'M. A. Mendez']
@@ -21,27 +21,42 @@ Requires-Dist: ipython
 Requires-Dist: ipython-genutils
 Requires-Dist: ipywidgets
 Requires-Dist: matplotlib
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 
 MODULO: a python toolbox for data-driven modal decomposition
------------------------------------------------------------
+------------------------------------------------------------
 
 .. image:: https://readthedocs.org/projects/modulo/badge/?version=latest
     :target: https://modulo.readthedocs.io/en/latest/?badge=latest
     :alt: Documentation Status
 
-.. raw:: html
+|DOI| |PyPI| 
 
-   <div style="text-align: center;">
-       <img src="https://modulo.readthedocs.io/en/latest/_images/modulo_logo.png" alt="Modulo Logo" width="500"/>
-   </div>
+.. |DOI| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.13939519.svg
+   :target: https://doi.org/10.5281/zenodo.13939519
 
-**MODULO** is a modal decomposition package developed at the von Karman Institute for Fluid Dynamics (VKI). 
-It offers a wide range of decomposition techniques, enabling users to select the most suitable method based 
-on the specific physics of their problem and their desired outcomes. MODULO can natively handle large
-datasets efficiently, featuring a memory-saving option that partitions the data and computes the decomposition in 
-chunks (ninni2020modulo). Additionally, it supports non-uniform meshes through its weighted inner product formulation.
+.. |PyPI| image:: https://img.shields.io/pypi/v/modulo_vki
+    :target: https://pypi.org/project/modulo_vki/
+	
+.. image:: https://modulo.readthedocs.io/en/latest/_images/modulo_logo.png
+   :alt: MODULO logo
+   :width: 500px
+   :align: center
+
+
+**MODULO** is a modal decomposition package developed at the von Karman Institute for Fluid Dynamics (VKI). It offers a wide range of decomposition techniques, allowing users to choose the most appropriate method for their specific problem. MODULO can efficiently handle large datasets natively, thanks to a memory-saving feature that partitions the data and processes the decomposition in chunks (ninni2020modulo). Moreover, it supports non-uniform meshes through a weighted inner product formulation. Currently, MODULO heavily relies on NumPy routines and does not offer additional parallel computing capabilities beyond those naturally provided by NumPy.
 
 While the discontinued MATLAB version of MODULO (ninni2020modulo) is accessible in the “Old_Matlab_Implementation” branch, 
 it is no longer maintained. The latest decomposition techniques are exclusively available in the current Python version.
@@ -49,75 +64,52 @@ it is no longer maintained. The latest decomposition techniques are exclusively
 As a part of the MODULO project, we provide a series of lectures on data-driven modal decomposition, and its applications.
 These are available at the `MODULO YouTube channel <https://www.youtube.com/@modulompod5682>`_.
 
-
 .. contents:: Table of contents
 
 Modal decompositions
 --------------------
 Modal decompositions aim to describe the data as a linear combination of *modes*, obtained by projecting the data 
-onto a suitable set of basis. For instance, consider a matrix $D(x, t)$, where $x$ and $t$ are the spatial and temporal
-coordinates, respectively, the modal decomposition can be written as:
-
-$D(x_i, t_k) = \\phi(x_i) \\Sigma \\psi(t_k)^T$
-
-where $\\phi(x_i)$ is the spatial basis, $\\psi(t_k)$ is the temporal basis, and $\\Sigma$ is the modal coefficients. 
-Different decompositions employ different basis, such as prescribed Fourier basis ($\\psi_\\mathcal{F}$) for 
+onto a suitable set of basis. Different decompositions employ different bases, such as prescribed Fourier basis for 
 the Discrete Fourier Transform (DFT), or data-driven basis, i.e. tailored on the dataset at hand, 
-for the Proper Orthogonal Decomposition (POD). 
-
-We refer to (mendez2022statistical, mendez2022generalizedmultiscalemodalanalysis, Mendez_2023) for an introduction to the topic.
-
+for the Proper Orthogonal Decomposition (POD). We refer to `Mendez (2022) <https://doi.org/10.48550/arXiv.2201.03847>`_, `Mendez (2023) <https://doi.org/10.1017/9781108896214.013>`_, and `Mendez et al. (2023) <https://arxiv.org/abs/2208.07746>`_,  for an introduction to the topic. 
 MODULO currently features the following decompositions: 
-- Discrete Fourier Transform (DFT) (briggs1995dft)
-- Proper Orthogonal Decomposition (POD) (sirovich1987turbulence, berkooz1993proper)
-- Multi-Scale Proper Orthogonal Decomposition (mPOD) (mendez2019multi)
-- Dynamic Mode Decomposition (DMD) (schmid2010dynamic)
-- Spectral Proper Orthogonal Decomposition (SPOD) (csieber2016spectral, towne2018spectral), note that the two are 
-different formulations, and both are available in MODULO.
-- Kernel Proper Orthogonal Decomposition (KPOD) (mika1998kernel)
+
+- Discrete Fourier Transform (DFT) (`Briggs et al. (1997) <https://epubs.siam.org/doi/book/10.1137/1.9781611971514>`_)
+- Proper Orthogonal Decomposition (POD) (`Sirovich et al. (1987) <https://www.ams.org/journals/qam/1987-45-03/S0033-569X-1987-0910464-1/S0033-569X-1987-0910464-1.pdf>`_ , `Berkooz et al. (1993) <https://doi.org/10.1146/annurev.fl.25.010193.002543>`_)
+- Multi-Scale Proper Orthogonal Decomposition (mPOD) (`Mendez et al. (2019) <https://arxiv.org/abs/1804.09646>`_)
+- Dynamic Mode Decomposition (DMD) (`Schmid (2010) <https://doi.org/10.1017/S0022112010001217>`_)
+- Spectral Proper Orthogonal Decomposition (SPOD) (`Sieber et al. (2016) <https://doi.org/10.48550/arXiv.1508.04642>`_, `Towne et al. (2018) <https://doi.org/10.48550/arXiv.1708.04393>`_), 
+  note that the two are different formulations, and both are available in MODULO.
+- Kernel Proper Orthogonal Decomposition (KPOD) (`Mika et al. (1998) <https://proceedings.neurips.cc/paper_files/paper/1998/file/226d1f15ecd35f784d2a20c3ecf56d7f-Paper.pdf>`_)
 
 We remind the curious reader to the respective references for a detailed description of each decomposition, and to the
 documentation for a practical guide on how to use them in MODULO.
 
-
 Release Notes
 -------------
-The latest version of MODULO (v2.0) includes the following updates:
-
-1. **Faster EIG/SVD algorithms**, using powerful randomized svd solvers from scikit_learn 
-    (see `here<https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.TruncatedSVD.html>`_ 
-    and `here <https://scikit-learn.org/stable/modules/generated/sklearn.utils.extmath.randomized_svd.html>`_.) 
-    It is now possible to select various options as "eig_solver" and "svd_solver", 
-    offering different trade-offs in terms of accuracy vs computational time.
+This version of MODULO includes the following updates:
 
-2. **Computation the POD directly via SVD**, using any of the four "svd_solver" options.
-This is generally faster but requires more memory.
+1. **mPOD bug fix:** the previous version of mPOD was skipping the last scale of the frequency splitting vector. Fixed in this version.
 
-1. **Faster subscale estimators for the mPOD:** the previous version used the rank of the correlation matrix in each scale to define 
-the number of modes to be computed in each portion of the splitting vector before assembling the full basis. 
-This is computationally very demanding. This estimation has been replaced by a 
-frequency-based threshold (i.e. based on the frequency bins within each portion) since one can show that the 
-frequency-based estimator is always more "conservative" than the rank-based estimator.
+2. **SPOD parallelisation:** CSD - SPOD can now be parallelized, leveraging `joblib`. The user needs just to pass the argument `n_processes` for the computation to be
+   split between different workers.
+   
+3. **Simplified decomposition interface:** the interface of the decomposition methods has been simplified to improve user experience. 
 
-1. **Major improvement on the memory saving option**: the previous version of modulo always required in input the matrix D. 
-Then, if the memory saving option was active, the matrix was partitioned and stored locally to free the RAM before computing the 
-correlation matrix (see [this tutorial by D. Ninni](https://www.youtube.com/watch?v=LclxO1WTuao)). 
-In the new version, it is possible to initialize a modulo object *without* the matrix D (see exercise 5 in the examples). 
-Instead, one can create the partitions without loading the matrix D.
+4. **Enhanced POD selection:** the POD function has been redesigned, allowing users to easily choose between different POD methods.  
+   
+5. **Improved computational efficiency:** the code of the decomposition functions has been optimised, resulting in reduced computation time. mPOD now includes two additional optional arguments to enable faster filtering and to avoid recomputing the Sigmas after QR polishing. 
+	
+6. **Extended documentation:** the documentation has been significantly enriched, now including theoretical foundations for all the supported modal decomposition techniques. 
 
-1. **Implementation of Dynamic Mode Decomposition (DMD)** from (Schmid, P.J 2010)
-
-2. **Implementation of the two Spectral POD formulations**, namely the one from (Sieber et al 2016), 
-   and the one from (Towne et al 2018).
-
-3. **Implementation of a kernel version of the POD**, in which the correlation matrix is replaced by a kernel matrix. 
-This is described in Lecture 15 of the course `Hands on Machine Learning for Fluid dynamics 2023 <https://www.vki.ac.be/index.php/events-ls/events/eventdetail/552/-/online-on-site-hands-on-machine-learning-for-fluid-dynamics-2023>`_. 
-We refer also to: `https://arxiv.org/abs/2208.07746`. 
-
-1. **Implementation of a formulation for non-uniform meshes**, using a weighted matrix for all the relevant inner products. 
-This is currently available only for POD and mPOD but allows for handling data produced from CFD simulation without resampling on a uniform grid (see exercise 4). 
-It can be used both with and without the memory-saving option.
+	
+Documentation
+-------------
 
+The documentation of MODULO is available `here <https://lorenzoschena.github.io/MODULO/intro.html>`_. It 
+contains a comprehensive guide on how to install and use the package, as well as a detailed description of the
+decompositions required inputs and outputs. A `list of YouTube videos <https://www.youtube.com/@modulompod5682>`_ 
+is also available to guide the introduce the user to modal decomposition and MODULO.
 
 Installation
 -------------
@@ -151,14 +143,6 @@ or, if you have pip installed in your environment,
     $ pip install .
 
 
-Documentation
--------------
-
-The documentation of MODULO is available `here <https://modulo.readthedocs.io/en/latest/intro.html>`_. It 
-contains a comprehensive guide on how to install and use the package, as well as a detailed description of the
-decompositions required inputs and outputs. A `list of YouTube videos<https://www.youtube.com/@modulompod5682>`_ 
-is also available to guide the introduce the user to modal decomposition and MODULO.
-
 Example 
 -------------
 
@@ -179,7 +163,7 @@ The following example illustrates how to decompose a data set (D) using the POD
     m = ModuloVKI(D) 
 
     # Compute the POD decomposition
-    phi_POD, Sigma_POD, psi_POD = m.Compute_POD_K()
+    phi_POD, Sigma_POD, psi_POD = m.POD()
 
 which returns the spatial basis ($\phi$), the temporal basis ($\psi$), and the modal 
 amplitudes ($\Sigma$) of the POD decomposition. 
@@ -202,7 +186,7 @@ by the user (refer to `examples/ex_04_Memory_Saving.py`).
     m = ModuloVKI(D, N_PARTITIONS=10) 
 
     # Compute the POD decomposition
-    phi_POD, Sigma_POD, psi_POD = m.Compute_POD_K()
+    phi_POD, Sigma_POD, psi_POD = m.POD()
 
 Example 3: non-uniform grid
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -230,16 +214,25 @@ you can use the weighted inner product formulation (refer to `examples/ex_05_non
     m = ModuloVKI(D, weights=weights) 
 
     # Compute the POD decomposition
-    phi_POD, Sigma_POD, psi_POD = m.Compute_POD_K()
-
-
-
+    phi_POD, Sigma_POD, psi_POD = m.POD()
+	
 Community guidelines
 ---------------------
 
 Contributing to MODULO
 ^^^^^^^^^^^^^^^^^^^^^^^
-We welcome contributions to MODULO. To create a new feature, please submit a pull request, specifying the proposed changes and 
+We welcome contributions to MODULO. 
+
+It is recommended to perform a shallow clone of the repository to avoid downloading the entire history of the project:
+
+.. code-block:: bash
+
+    $ git clone --depth 1 https://github.com/mendezVKI/MODULO.git
+
+This will download only the latest version of the repository, which is sufficient for contributing to the project, and will save 
+you time and disk space.
+
+To create a new feature, please submit a pull request, specifying the proposed changes and 
 providing an example of how to use the new feature (that will be included in the `examples/` folder).
 
 The pull request will be reviewed by the MODULO team before being merged into the main branch, and your contribution duly acknowledged.
@@ -250,14 +243,39 @@ If you find a bug, or you encounter unexpected behaviour, please open an issue o
 
 Ask for help
 ^^^^^^^^^^^^
+If you have troubles using MODULO, or you need help with a specific decomposition, please open an issue on the MODULO GitHub repository.
 
 Citation
----------
+--------
+
 If you use MODULO in your research, please cite it as follows:
 
-``Ninni, D., & Mendez, M. A. (2020). MODULO: A software for Multiscale Proper Orthogonal Decomposition of data. SoftwareX, 12, 100622.``
+Poletti, R., Schena, L., Ninni, D., Mendez, M. A. (2024).  
+*MODULO: A Python toolbox for data-driven modal decomposition*.  
+Journal of Open Source Software, 9(102), 6753. https://doi.org/10.21105/joss.06753
+
+.. code-block:: text
+
+    @article{Poletti2024, 
+      doi = {10.21105/joss.06753}, 
+      url = {https://doi.org/10.21105/joss.06753}, 
+      year = {2024},
+      publisher = {The Open Journal}, 
+      volume = {9}, 
+      number = {102}, 
+      pages = {6753},
+      author = {R. Poletti and L. Schena and D. Ninni and M. A. Mendez}, 
+      title = {MODULO: A Python toolbox for data-driven modal decomposition},
+      journal = {Journal of Open Source Software}
+    }
+	
+and 
+
+Ninni, D., & Mendez, M. A. (2020).  
+*MODULO: A software for Multiscale Proper Orthogonal Decomposition of data*.  
+SoftwareX, 12, 100622. https://doi.org/10.1016/j.softx.2020.100622
 
-.. code-block:: text 
+.. code-block:: text
 
     @article{ninni2020modulo,
         title={MODULO: A software for Multiscale Proper Orthogonal Decomposition of data},
@@ -269,7 +287,6 @@ If you use MODULO in your research, please cite it as follows:
         publisher={Elsevier}
     }
 
-We are currently working on a Journal of Open Source article that will be available soon.
 
 References
 ----------
@@ -302,3 +319,8 @@ There are also decomposition-specific projects, some of which are listed below:
 - Ichinaga, Andreuzzi, Demo, Tezzele, Lapo, Rozza, Brunton, Kutz. PyDMD: A Python package for robust dynamic mode decomposition. arXiv preprint, 2024.
 - Rogowski, Marcin, et al. "Unlocking massively parallel spectral proper orthogonal decompositions in the PySPOD package." Computer Physics Communications 302 (2024): 109246.
 
+
+
+
+
+

modulo_vki-2.1.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+modulo_vki/__init__.py,sha256=AOjmeFjHj69m45iZzfTHM6-SLUelgKdGeu3VdSg9hIo,39
+modulo_vki/modulo.py,sha256=OYMLteELmAHyhfByCoy2Vqg4h7bUMsgbmIDF7jUXf3A,38261
+modulo_vki/modulo_old.py,sha256=3r_BBYQfbmZWGDyPukyJTVYVVcAVuEE0CmREEJkzsxU,59413
+modulo_vki/core/__init__.py,sha256=y9mIqtmSg3o8TXMqFxoiMCoMSle6mK0LBrvNJCVM1Zg,226
+modulo_vki/core/_dft.py,sha256=W98vC4HR1fivZjYRQXrFKV7RBa-O3RSRwq-nCKoxqjQ,4374
+modulo_vki/core/_dmd_s.py,sha256=f3DKFlWdUS33-MrCFuL93nvI3VDVwD9DrEiDpCrNKwI,2934
+modulo_vki/core/_k_matrix.py,sha256=ECDau3hh80gmSTCvp7-GXtLn0QBThYz5b-A3dgHHZiY,7004
+modulo_vki/core/_mpod_space.py,sha256=0Om-kMQV5n5oI67Ef5ZuXtvBDaRePMVBQYfhJ-_hK0E,7327
+modulo_vki/core/_mpod_time.py,sha256=-QhLyOEAKW-E8JPhPgQETfd153Xzc-TASiJyfH-VdG0,9848
+modulo_vki/core/_pod_space.py,sha256=A3dfv4Nzs9fx3qwOdlJR5HwyyfI-QcVer8P83xqa_C4,6983
+modulo_vki/core/_pod_time.py,sha256=JtiFGYFV-tBKTWHWHW8zynMoLt2q8bD1bd1LP9pyvjo,2169
+modulo_vki/core/_spod_s.py,sha256=rxXSsNdSTLv3sjvlUErw3xjHk0eF8H7IkSJr5nMQ8Vo,4149
+modulo_vki/core/_spod_t.py,sha256=csftCPRSqs-OghQa8l0mRDL7cy5eXXSCnW8O4pnXTCY,3866
+modulo_vki/core/spatial_structures.py,sha256=65xh3zD3ekjRYUeRd2KcOYzPurpua7qDf0AysY-X8hE,14712
+modulo_vki/core/temporal_structures.py,sha256=0DQEdE9ssTnnfIC86VZPsNlym6fsjRAboPHHnv-9CI4,10645
+modulo_vki/core/utils.py,sha256=Ac9Im9knlbZRByP6Qgv-LCDt5zEC8PbyidqXzVdeYtQ,17889
+modulo_vki/utils/__init__.py,sha256=F5yy5R19dONK9oaBEpKzylorVJNcjT2kiJ5Og-ZX1ek,94
+modulo_vki/utils/_plots.py,sha256=m43t08cVq-TY0BW0YPqT71hN-54hBphIYKZEn8Kw16E,1453
+modulo_vki/utils/_utils.py,sha256=WFD7nwjSzVHpevVwTEvMdjAmcbeqwoXT9M48tIIniJw,14355
+modulo_vki/utils/others.py,sha256=26ES5EmsLhwkvcXTwNhDMkblGrxoWepX5c9TXeLTRWg,17336
+modulo_vki/utils/read_db.py,sha256=lJFauxJxS0_mYoxrbn-43UqZjOkr-qb9f6RTUq4IxZU,15149
+modulo_vki-2.1.1.dist-info/licenses/LICENSE,sha256=5TivriXFErrYrJgBq3M72kHNHqtSiCft3xESM1zHc0k,1091
+modulo_vki-2.1.1.dist-info/METADATA,sha256=MGJRX_sOUGm4_18AnPXzz3lT8PKi7KxPhbHZ9yiQEVQ,14933
+modulo_vki-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+modulo_vki-2.1.1.dist-info/top_level.txt,sha256=4PA4AmafKU6M7us7gvt_Q976Khx3qjNUEThRRM5zxeA,11
+modulo_vki-2.1.1.dist-info/RECORD,,

{modulo_vki-2.0.7.dist-info → modulo_vki-2.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

modulo_vki-2.0.7.dist-info/RECORD

@@ -1,22 +0,0 @@
-modulo_vki/__init__.py,sha256=wKu93pAmJcEzH5iKpXZ6rguM43RdI9C-4W4r8frvpc0,594
-modulo_vki/modulo.py,sha256=j6cdcDcHR8omT9i-FSKzRSwh_dT4PbKM1RN35NnVmU0,37654
-modulo_vki/core/__init__.py,sha256=y9mIqtmSg3o8TXMqFxoiMCoMSle6mK0LBrvNJCVM1Zg,226
-modulo_vki/core/_dft.py,sha256=Sq-vH8DlypAjHEGfWBAzBZp7DqKMCQ9G82QwdbYo-vs,2285
-modulo_vki/core/_dmd_s.py,sha256=lD7COE1Zinxyjd4IZl0MxT4XtqKM9JtXLL4U26MbtFc,2678
-modulo_vki/core/_k_matrix.py,sha256=SxS5esKl8ifMtTYWWeX437UWADKB3fW4ozKGryxVHpM,3687
-modulo_vki/core/_mpod_space.py,sha256=0Om-kMQV5n5oI67Ef5ZuXtvBDaRePMVBQYfhJ-_hK0E,7327
-modulo_vki/core/_mpod_time.py,sha256=ItlFTEl-uhj76aIpHpq8U2-vokTnPiE3PL60RKHUYlM,8498
-modulo_vki/core/_pod_space.py,sha256=l-Fbcg0JdnOMb_jyKwFyM8YeanXxWa8EvwEdOs5QV6U,6960
-modulo_vki/core/_pod_time.py,sha256=xWEOX6pO7Cpx1Vm7vF7X4YSORMNuAOpJyfpJiG-foTI,2144
-modulo_vki/core/_spod_s.py,sha256=rxXSsNdSTLv3sjvlUErw3xjHk0eF8H7IkSJr5nMQ8Vo,4149
-modulo_vki/core/_spod_t.py,sha256=csftCPRSqs-OghQa8l0mRDL7cy5eXXSCnW8O4pnXTCY,3866
-modulo_vki/utils/__init__.py,sha256=F5yy5R19dONK9oaBEpKzylorVJNcjT2kiJ5Og-ZX1ek,94
-modulo_vki/utils/_plots.py,sha256=m43t08cVq-TY0BW0YPqT71hN-54hBphIYKZEn8Kw16E,1453
-modulo_vki/utils/_utils.py,sha256=5-keBtdW6Z-QmUvgX2ITWOIddsdn0svHudynUXkc3ag,13935
-modulo_vki/utils/others.py,sha256=4VOfB5Xf-lYYdh2qFDXK3Oy7u4xgvjzTgidNTlg2qg0,17101
-modulo_vki/utils/read_db.py,sha256=lJFauxJxS0_mYoxrbn-43UqZjOkr-qb9f6RTUq4IxZU,15149
-modulo_vki-2.0.7.dist-info/LICENSE,sha256=5TivriXFErrYrJgBq3M72kHNHqtSiCft3xESM1zHc0k,1091
-modulo_vki-2.0.7.dist-info/METADATA,sha256=6CuUQwoompNn5fy8b2dfI7xRN31xtfItgYGo9HbMqQo,14572
-modulo_vki-2.0.7.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-modulo_vki-2.0.7.dist-info/top_level.txt,sha256=4PA4AmafKU6M7us7gvt_Q976Khx3qjNUEThRRM5zxeA,11
-modulo_vki-2.0.7.dist-info/RECORD,,