osiris-utils 1.0.9__tar.gz → 1.1.1__tar.gz

{osiris_utils-1.0.9/osiris_utils.egg-info → osiris_utils-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: osiris_utils
-Version: 1.0.9
+Version: 1.1.1
 Summary: Utilities to manipulate and visualize OSIRIS framework output data
 Author: ['João Pedro Ferreira Biu', 'João Cândido']
 Author-email: ['joaopedrofbiu@tecnico.ulisboa.pt']
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.11
-Description-Content-Type: text/markdown
+Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: numpy
 Requires-Dist: matplotlib
@@ -33,6 +33,7 @@ Requires-Dist: tqdm
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
+Dynamic: description
 Dynamic: description-content-type
 Dynamic: keywords
 Dynamic: license
@@ -40,3 +41,30 @@ Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
+
+OSIRIS_UTILS
+============
+|Pypi|
+
+This package contains a set of utilities to open and analyze OSIRIS output files, using Python. All the methods implemented are fully integrated with `NumPy`, and use `np.ndarray` as the main data structure.
+
+How to install it?
+------------------
+
+To install this package, you can use `pip`::
+
+    pip install osiris_utils
+
+To install it from source, you can clone this repository and run (in the folder containing ``setup.py``)::
+
+    pip install -e .
+
+Documentation
+-------------
+
+The documentation is available at https://osiris-utils.readthedocs.io or via this link: `osiris-utils.readthedocs.io <https://osiris-utils.readthedocs.io>`_.
+
+.. |Pypi| image:: https://img.shields.io/pypi/v/osiris-utils
+    :target: https://pypi.org/project/osiris-utils/
+    :alt: Pypi
+

{osiris_utils-1.0.9 → osiris_utils-1.1.1}/osiris_utils/__init__.py

@@ -1,6 +1,6 @@
 from .utils import (time_estimation, filesize_estimation, transverse_average, integrate, animate_2D,
                     save_data, read_data, courant2D)
-from .data_readers import open1D, open2D, open3D, read_osiris_file
 from .gui import LAVA_Qt, LAVA
-from .data import OsirisGridFile, OsirisRawFile, OsirisData
-from .mean_field_theory import MeanFieldTheory
+from .data import OsirisGridFile, OsirisRawFile, OsirisData, OsirisHIST
+from .mean_field_theory import MeanFieldTheory
+from .simulation_data import OsirisSimulation

{osiris_utils-1.0.9 → osiris_utils-1.1.1}/osiris_utils/data.py

@@ -1,43 +1,53 @@
 import numpy as np
+import pandas as pd
 import h5py
 
 class OsirisData():
-    '''
-    Parent class for Osiris data files.
+    """
+    Base class for handling OSIRIS simulation data files (HDF5 and HIST formats).
 
-    Input:
-    ------
-        - filename: the path to the HDF5 file
-    Attributes:
+    This class provides common functionality for reading and managing basic attributes
+    from OSIRIS output files. It serves as the parent class for specialized data handlers.
+
+    Parameters
     ----------
-        - filename - the path to the HDF5 file
-            str
-        - file - the HDF5 file
-            h5py.File
-        - verbose - if True, the class will print messages
-            bool
-        - dt - the time step
-            float
-        - dim - the number of dimensions
-            int
-        - time - the time and its units
-            list [time, units]
-            list [float, str]
-        - iter - the iteration number
-            int
-        - name - the name of the data
-            str
-        - type - the type of data
-            str
-    '''
+    filename : str
+        Path to the data file. Supported formats:
+        - HDF5 files (.h5 extension)
+        - HIST files (ending with _ene)
+
+    Attributes
+    ----------
+    dt : float
+        Time step of the simulation [simulation units]
+    dim : int
+        Number of dimensions in the simulation (1, 2, or 3)
+    time : list[float, str]
+        Current simulation time and units as [value, unit_string]
+    iter : int
+        Current iteration number
+    name : str
+        Name identifier of the data field
+    type : str
+        Type of data (e.g., 'grid', 'particles')
+    verbose : bool
+        Verbosity flag controlling diagnostic messages (default: False)
+    """
+
     def __init__(self, filename):
         self._filename = filename
-        self._file = None
+        # self._file = None
 
         self._verbose = False
 
-        self._open_file(self._filename)
-        self._load_basic_attributes(self._file)
+        if self._filename.endswith('.h5'):
+            self._open_file_hdf5(self._filename)
+            self._load_basic_attributes(self._file)
+        elif self._filename.endswith('_ene'):
+            self._open_hist_file(self._filename)
+        else:
+            raise ValueError('The file should be an HDF5 file with the extension .h5, or a HIST file ending with _ene.')
+        
         
     def _load_basic_attributes(self, f: h5py.File) -> None:
         '''Load common attributes from HDF5 file'''
@@ -59,9 +69,9 @@ class OsirisData():
         '''
         self._verbose = verbose
 
-    def _open_file(self, filename):
+    def _open_file_hdf5(self, filename):
         '''
-        Open the HDF5 file.
+        Open the OSIRIS output file. Usually an HDF5 file or txt.
 
         Parameters
         ----------
@@ -69,7 +79,14 @@ class OsirisData():
             The path to the HDF5 file.
         '''
         if self._verbose: print(f'Opening file > {filename}')
-        self._file = h5py.File(self._filename, 'r')
+
+        if filename.endswith('.h5'):
+            self._file = h5py.File(filename, 'r')
+        else:
+            raise ValueError('The file should be an HDF5 file with the extension .h5')
+            
+    def _open_hist_file(self, filename):
+        self._df = pd.read_csv(filename, sep=r'\s+', comment='!', header=0, engine='python')
 
     def _close_file(self):
         '''
@@ -81,103 +98,59 @@ class OsirisData():
         
     @property
     def dt(self):
-        '''
-        Returns
-        -------
-        float
-            The time step
-        '''
         return self._dt
     @property
     def dim(self):
-        '''
-        Returns
-        -------
-        int
-            The number of dimensions
-        '''
         return self._dim
     @property
     def time(self):
-        '''
-        Returns
-        -------
-        list
-            The time and its units
-        '''
         return self._time
     @property
     def iter(self):
-        '''
-        Returns
-        -------
-        int
-            The iteration number
-        '''
         return self._iter
     @property
     def name(self):
-        '''
-        Returns
-        -------
-        str
-            The name of the data
-        '''
         return self._name
     @property
     def type(self):
-        '''
-        Returns
-        -------
-        str
-            The type of data
-        '''
         return self._type
 
 class OsirisGridFile(OsirisData):
-    '''
-    Class to read the grid data from an OSIRIS HDF5 file.
-    
-    Input:
-    -----
-        - filename: the path to the HDF5 file
-        
-    Attributes:
+    """
+    Handles structured grid data from OSIRIS HDF5 simulations, including electromagnetic fields.
+
+    Parameters
     ----------
-        - filename - the path to the HDF5 file
-            str
-        - file - the HDF5 file
-            h5py.File
-        - verbose - if True, the class will print messages
-            bool
-        - dt - the time step
-            float
-        - dim - the number of dimensions
-            int
-        - time - the time and its units
-            list [time, units]
-            list [float, str]
-        - iter - the iteration number
-            int
-        - name - the name of the data
-            str
-        - type - the type of data
-            str
-        - grid - the grid data ((x1.min, x1.max), (x2.min, x2.max), (x3.min, x3.max))
-            numpy.ndarray
-        - nx - the number of grid points (nx1, nx2, nx3)
-            numpy.ndarray
-        - dx - the grid spacing (dx1, dx2, dx3)
-            numpy.ndarray
-        - axis - the axis data [(name_x1, units_x1, long_name_x1, type_x1), ...]
-            list of dictionaries
-        - data: the data (numpy array) with shape (nx1, nx2, nx3) (Transpose to use `plt.imshow`)
-            numpy.ndarray
-        - units - the units of the data
-            str
-        - label - the label of the data (LaTeX formatted)
-        
-    '''
+    filename : str
+        Path to OSIRIS HDF5 grid file (.h5 extension)
+
+    Attributes
+    ----------
+    grid : np.ndarray
+        Grid boundaries as ((x1_min, x1_max), (x2_min, x2_max), ...)
+    nx : tuple
+        Number of grid points per dimension (nx1, nx2, nx3)
+    dx : np.ndarray
+        Grid spacing per dimension (dx1, dx2, dx3)
+    x : list[np.ndarray]
+        Spatial coordinates arrays for each dimension
+    axis : list[dict]
+        Axis metadata with keys:
+        - 'name': Axis identifier (e.g., 'x1')
+        - 'units': Physical units (LaTeX formatted)
+        - 'long_name': Descriptive name (LaTeX formatted)
+        - 'type': Axis type (e.g., 'SPATIAL')
+        - 'plot_label': Combined label for plotting
+    data : np.ndarray
+        Raw field data array (shape depends on simulation dimensions)
+    units : str
+        Field units (LaTeX formatted)
+    label : str
+        Field label/name (LaTeX formatted, e.g., r'$E_x$')
+    FFTdata : np.ndarray
+        Fourier-transformed data (available after calling FFT())
+    """
+
     def __init__(self, filename):
         super().__init__(filename)
             
@@ -230,105 +203,6 @@ class OsirisGridFile(OsirisData):
     def _get_variable_key(self, f: h5py.File) -> str:
         return next(k for k in f.keys() if k not in {'AXIS', 'SIMULATION'})
     
-    # Getters
-    @property
-    def grid(self):
-        '''
-        Returns
-        -------
-        numpy.ndarray
-            The grid data ((x1.min, x1.max), (x2.min, x2.max), (x3.min, x3.max
-        '''
-        return self._grid
-    @property
-    def nx(self):
-        '''
-        Returns
-        -------
-        numpy.ndarray
-            The number of grid points (nx1, nx2, nx3)
-        '''
-        return self._nx
-    @property
-    def dx(self):
-        '''
-        Returns
-        -------
-        numpy.ndarray
-            The grid spacing (dx1, dx2, dx3)
-        '''
-        return self._dx
-    @property
-    def x(self):
-        '''
-        Returns
-        -------
-        numpy.ndarray
-            The grid points in each axis
-        '''
-        return self._x
-    @property
-    def axis(self):
-        '''
-        Returns
-        -------
-        list of dictionaries
-            The axis data [(name_x1, units_x1, long_name_x1, type_x1), ...]
-        '''
-        return self._axis   
-    @property
-    def data(self):
-        '''
-        Returns
-        -------
-        numpy.ndarray
-            The data (numpy array) with shape (nx1, nx2, nx3) (Transpose to use `plt.imshow`)
-        '''
-        return self._data
-    @property
-    def units(self):
-        '''
-        Returns
-        -------
-        str
-            The units of the data (LaTeX formatted)
-        '''
-        return self._units
-    @property
-    def label(self):
-        '''
-        Returns
-        -------
-        str
-            The label of the data (LaTeX formatted)
-        '''
-        return self._label
-    @property
-    def FFTdata(self):
-        '''
-        Returns
-        -------
-        numpy.ndarray
-            The FFT of the data
-        '''
-        if self._FFTdata is None:
-            raise ValueError('The FFT of the data has not been computed yet. Compute it using the FFT method.')
-        return self._FFTdata
-    # Setters
-    @data.setter
-    def data(self, data):
-        '''
-        Set the data attribute
-        '''
-        self._data = data
-
-    def __str__(self):
-        # write me a template to print with the name, label, units, time, iter, grid, nx, dx, axis, dt, dim in a logical way
-        return rf'{self.name}' + f'\n' + rf'Time: [{self.time[0]} {self.time[1]}], dt = {self.dt}' + f'\n' + f'Iteration: {self.iter}' + f'\n' + f'Grid: {self.grid}' + f'\n' + f'dx: {self.dx}' + f'\n' + f'Dimensions: {self.dim}D'
-    
-
-    def __array__(self):
-        return np.asarray(self.data)
     
 
     def _yeeToCellCorner1d(self, boundary):
@@ -421,6 +295,48 @@ class OsirisGridFile(OsirisData):
         datafft = np.fft.fftn(self.data, axes=axis)
         self._FFTdata = np.fft.fftshift(datafft, axes=axis)
 
+    # Getters
+    @property
+    def grid(self):
+        return self._grid
+    @property
+    def nx(self):
+        return self._nx
+    @property
+    def dx(self):
+        return self._dx
+    @property
+    def x(self):
+        return self._x
+    @property
+    def axis(self):
+        return self._axis   
+    @property
+    def data(self):
+        return self._data
+    @property
+    def units(self):
+        return self._units
+    @property
+    def label(self):
+        return self._label
+    @property
+    def FFTdata(self):
+        if self._FFTdata is None:
+            raise ValueError('The FFT of the data has not been computed yet. Compute it using the FFT method.')
+        return self._FFTdata
+    # Setters
+    @data.setter
+    def data(self, data):
+        self._data = data
+
+    def __str__(self):
+        # write me a template to print with the name, label, units, time, iter, grid, nx, dx, axis, dt, dim in a logical way
+        return rf'{self.name}' + f'\n' + rf'Time: [{self.time[0]} {self.time[1]}], dt = {self.dt}' + f'\n' + f'Iteration: {self.iter}' + f'\n' + f'Grid: {self.grid}' + f'\n' + f'dx: {self.dx}' + f'\n' + f'Dimensions: {self.dim}D'
+    
+
+    def __array__(self):
+        return np.asarray(self.data)
 
 
 class OsirisRawFile(OsirisData):
@@ -475,3 +391,28 @@ class OsirisRawFile(OsirisData):
                 'long_name': self._file.attrs['LABELS'][idx][0].decode('utf-8'),
             }
             self.axis[key] = axis_data
+
+class OsirisHIST(OsirisData):
+    ''''
+    Class to read the data from an OSIRIS HIST file.'
+
+    Input:
+        - filename: the path to the HIST file
+
+    Attributes:
+        - filename - the path to the file
+            str
+        - verbose - if True, the class will print messages
+            bool
+        - df - the data in a pandas DataFrame
+            pandas.DataFrame
+    '''
+    def __init__(self, filename):
+        super().__init__(filename)
+
+    @property
+    def df(self):
+        """
+        Returns the data in a pandas DataFrame
+        """
+        return self._df

osiris_utils-1.1.1/osiris_utils/simulation_data.py

@@ -0,0 +1,229 @@
+"""
+The utilities on data.py are cool but not useful when you want to work with whole data of a simulation instead
+of just a single file. This is what this file is for - deal with ''folders'' of data.
+
+Took some inspiration from Diogo and Madox's work.
+
+This would be awsome to compute time derivatives. 
+"""
+
+import numpy as np
+import os
+from .data import OsirisGridFile, OsirisRawFile, OsirisHIST
+import tqdm
+import itertools
+import multiprocessing as mp
+
+class OsirisSimulation:
+    def __init__(self, simulation_folder):
+        self._simulation_folder = simulation_folder
+        if not os.path.isdir(simulation_folder):
+            raise FileNotFoundError(f"Simulation folder {simulation_folder} not found.")
+    
+    def get_moment(self, species, moment):
+        self._path = f"{self._simulation_folder}/MS/UDIST/{species}/{moment}/"
+        self._file_template = os.listdir(self._path)[0][:-9]
+        self._load_attributes(self._file_template)
+    
+    def get_field(self, field, centered=False):
+        if centered:
+            self._path = f"{self._simulation_folder}/MS/FLD/{field}/"
+        self._path = f"{self._simulation_folder}/MS/FLD/{field}/"
+        self._file_template = os.listdir(self._path)[0][:-9]
+        self._load_attributes(self._file_template)
+        
+    def get_density(self, species, quantity):
+        self._path = f"{self._simulation_folder}/MS/DENSITY/{species}/{quantity}/"
+        self._file_template = os.listdir(self._path)[0][:-9]
+        self._load_attributes(self._file_template)
+
+    def _load_attributes(self, file_template):
+        path_file1 = os.path.join(self._path, file_template + "000001.h5")
+        dump1 = OsirisGridFile(path_file1)
+        self._dx = dump1.dx
+        self._nx = dump1.nx
+        self._x = dump1.x
+        self._dt = dump1.dt
+        self._grid = dump1.grid
+        self._axis = dump1.axis
+        self._units = dump1.units
+        self._name = dump1.name
+        self._dim = dump1.dim
+        self._ndump = dump1.iter
+    
+    def _data_generator(self, index):
+            file = os.path.join(self._path, self._file_template + f"{index:06d}.h5")
+            data_object = OsirisGridFile(file)
+            if self._current_centered:
+                data_object.yeeToCellCorner(boundary="periodic")
+            yield data_object.data_centered if self._current_centered else data_object.data
+    
+    def load_all(self, centered=False):
+        self._current_centered = centered
+        size = len(sorted(os.listdir(self._path)))
+        self._data = np.stack([self[i] for i in tqdm.tqdm(range(size), desc="Loading data")])
+
+    def load_all_parallel(self, centered=False, processes=None):
+        self._current_centered = centered
+        files = sorted(os.listdir(self._path))
+        size = len(files)
+        
+        if processes is None:
+            processes = mp.cpu_count()
+            print(f"Using {processes} CPUs for parallel loading")
+        
+        with mp.Pool(processes=processes) as pool:
+            data = list(tqdm.tqdm(pool.imap(self.__getitem__, range(size)), total=size, desc="Loading data"))
+        
+        self._data = np.stack(data)
+    
+    def load(self, index, centered=False):
+        self._current_centered = centered
+        self._data = next(self._data_generator(index))
+
+    def __getitem__(self, index):
+        return next(self._data_generator(index))
+    
+    def __iter__(self):
+        for i in itertools.count():
+            yield next(self._data_generator(i))
+
+    def derivative(self, point, type, axis=None):
+        if point == "all":
+            if type == "t":
+                self._deriv_t = np.gradient(self.data, self.dt, axis=0, edge_order=2)
+            elif type == "x1":
+                if self._dim == 1:
+                    self._deriv_x1 = np.gradient(self.data, self.dx, axis=1, edge_order=2)
+                else:
+                    self._deriv_x1 = np.gradient(self.data, self.dx[0], axis=1, edge_order=2)
+            elif type == "x2":
+                self._deriv_x1 = np.gradient(self.data, self.dx[0], axis=2, edge_order=2)
+            elif type == "x3":
+                self._deriv_x2 = np.gradient(self.data, self.dx[0], axis=3, edge_order=2)
+            elif type == "xx":
+                if len(axis) != 2:
+                    raise ValueError("Axis must be a tuple with two elements.")
+                self._deriv_xx = np.gradient(np.gradient(self.data, self.dx[axis[0]], axis=axis[0], edge_order=2), self.dx[axis[1]], axis=axis[1], edge_order=2)
+            elif type == "xt":
+                if not isinstance(axis, int):
+                    raise ValueError("Axis must be an integer.")
+                self._deriv_xt = np.gradient(np.gradient(self.data, self.dt, axis=0, edge_order=2), self.dx[axis], axis=axis, edge_order=2)
+            elif type == "tx":
+                if not isinstance(axis, int):
+                    raise ValueError("Axis must be an integer.")
+                self._deriv_tx = np.gradient(np.gradient(self.data, self.dx[axis], axis=axis, edge_order=2), self.dt, axis=axis, edge_order=2)
+            else:
+                raise ValueError("Invalid type.")
+        else:
+            try:
+                if type == "x1":
+                    if self._dim == 1:
+                        return np.gradient(self[point], self._dx, axis=0)
+                    else:
+                        return np.gradient(self[point], self._dx[0], axis=0)
+                
+                elif type == "x2":
+                    return np.gradient(self[point], self._dx[1], axis=1)
+                
+                elif type == "x3":
+                    return np.gradient(self[point], self._dx[2], axis=2)
+                    
+                elif type == "t":
+                    if point == 0:
+                        return (-3 * self[point] + 4 * self[point + 1] - self[point + 2]) / (2 * self._dt)
+                    # derivate at last point not implemented yet
+                    # elif self[point + 1] is None:
+                    #     return (3 * self[point] - 4 * self[point - 1] + self[point - 2]) / (2 * self._dt)
+                    else:
+                        return (self[point + 1] - self[point - 1]) / (2 * self._dt)
+                else:
+                    raise ValueError("Invalid derivative type. Use 'x1', 'x2' or 't'.")
+                    
+            except Exception as e:
+                raise ValueError(f"Error computing derivative at point {point}: {str(e)}")
+    
+    # Getters
+    @property
+    def data(self):
+        if self._data is None:
+            raise ValueError("Data not loaded into memory. Use get_* method with load_all=True or access via generator/index.")
+        return self._data
+    
+    @property
+    def time(self):
+        return self._time
+    
+    @property
+    def dx(self):
+        return self._dx
+    
+    @property
+    def nx(self):
+        return self._nx
+    
+    @property
+    def x(self):
+        return self._x
+    
+    @property
+    def dt(self):
+        return self._dt
+    
+    @property
+    def grid(self):
+        return self._grid
+    
+    @property
+    def axis(self):
+        return self._axis
+    
+    @property
+    def units(self):
+        return self._units
+    
+    @property
+    def name(self):
+        return self._name
+    
+    @property
+    def dim(self):
+        return self._dim
+    
+    @property
+    def path(self):
+        return self
+    
+    @property
+    def simulation_folder(self):
+        return self._simulation_folder
+    
+    @property
+    def ndump(self):
+        return self._ndump
+    
+    @property
+    def deriv_t(self):
+        return self._deriv_t
+    
+    @property
+    def deriv_x1(self):
+        return self._deriv_x1
+    
+    @property
+    def deriv_x2(self):
+        return self._deriv_x2
+    
+    @property
+    def deriv_xx(self):
+        return self._deriv_xx
+    
+    @property
+    def deriv_xt(self):
+        return self._deriv_xt
+    
+    @property
+    def deriv_tx(self):
+        return self._deriv_tx
+
+        

{osiris_utils-1.0.9 → osiris_utils-1.1.1}/osiris_utils/utils.py

@@ -2,7 +2,6 @@ import numpy as np
 import h5py  
 import matplotlib.pyplot as plt
 import matplotlib.animation as animation
-from .data_readers import *
 import scipy 
 import pandas as pd
 

{osiris_utils-1.0.9 → osiris_utils-1.1.1/osiris_utils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: osiris_utils
-Version: 1.0.9
+Version: 1.1.1
 Summary: Utilities to manipulate and visualize OSIRIS framework output data
 Author: ['João Pedro Ferreira Biu', 'João Cândido']
 Author-email: ['joaopedrofbiu@tecnico.ulisboa.pt']
@@ -20,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.11
-Description-Content-Type: text/markdown
+Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 Requires-Dist: numpy
 Requires-Dist: matplotlib
@@ -33,6 +33,7 @@ Requires-Dist: tqdm
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
+Dynamic: description
 Dynamic: description-content-type
 Dynamic: keywords
 Dynamic: license
@@ -40,3 +41,30 @@ Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
+
+OSIRIS_UTILS
+============
+|Pypi|
+
+This package contains a set of utilities to open and analyze OSIRIS output files, using Python. All the methods implemented are fully integrated with `NumPy`, and use `np.ndarray` as the main data structure.
+
+How to install it?
+------------------
+
+To install this package, you can use `pip`::
+
+    pip install osiris_utils
+
+To install it from source, you can clone this repository and run (in the folder containing ``setup.py``)::
+
+    pip install -e .
+
+Documentation
+-------------
+
+The documentation is available at https://osiris-utils.readthedocs.io or via this link: `osiris-utils.readthedocs.io <https://osiris-utils.readthedocs.io>`_.
+
+.. |Pypi| image:: https://img.shields.io/pypi/v/osiris-utils
+    :target: https://pypi.org/project/osiris-utils/
+    :alt: Pypi
+

{osiris_utils-1.0.9 → osiris_utils-1.1.1}/osiris_utils.egg-info/SOURCES.txt

@@ -6,9 +6,9 @@ requirements.txt
 setup.py
 osiris_utils/__init__.py
 osiris_utils/data.py
-osiris_utils/data_readers.py
 osiris_utils/gui.py
 osiris_utils/mean_field_theory.py
+osiris_utils/simulation_data.py
 osiris_utils/utils.py
 osiris_utils.egg-info/PKG-INFO
 osiris_utils.egg-info/SOURCES.txt

{osiris_utils-1.0.9 → osiris_utils-1.1.1}/setup.py

@@ -7,18 +7,18 @@ from setuptools import find_packages, setup
 here = os.path.abspath(os.path.dirname(__file__))
 
 
-# with open(os.path.join(here, 'README.md'), encoding='utf-8') as f:
-#     long_description = f.read()
+with open(os.path.join(here, 'README.rst'), encoding='utf-8') as f:
+    long_description = f.read()
 
 with open(os.path.join(here, 'requirements.txt'), encoding='utf-8') as f:
     requirements = f.read().splitlines()
 
 setup(
     name='osiris_utils',
-    version='v1.0.9',
+    version='v1.1.1',
     description=('Utilities to manipulate and visualize OSIRIS framework output data'),
-    # long_description=long_description,
-    long_description_content_type='text/markdown',
+    long_description=long_description,
+    long_description_content_type='text/x-rst',
     author=['João Pedro Ferreira Biu', 'João Cândido'],
     author_email=['joaopedrofbiu@tecnico.ulisboa.pt'],
     license='MIT',

osiris_utils-1.0.9/osiris_utils/data_readers.py

@@ -1,119 +0,0 @@
-'''
-This file contains methods to create datasets to train the neural network.
-'''
-
-import numpy as np
-from .utils import *
-import os
-import h5py
-
-def read_osiris_file(filename, pressure = False):
-    f = h5py.File(filename, 'r+')
-    atr = f.attrs
-    k = [key for key in f.keys()]
-    if 'SIMULATION' in k:
-        attrs1 = atr
-        attrs2 = f['SIMULATION'].attrs
-        attrs = {}
-        for i in range(len(attrs1)):
-            attrs[[key for key in attrs1][i]] = [value for value in attrs1.values()][i]
-        for i in range(len(attrs2)):
-            attrs[[key for key in attrs2][i]] = [value for value in attrs2.values()][i]
-    ax = f.get([key for key in f.keys()][0])
-    leanx = len(ax)
-    axis = []
-    for i in range(leanx):
-        axis.append(ax.get([key for key in ax.keys()][i]))
-    if 'SIMULATION' in k and pressure == False:
-        data = f.get([key for key in f.keys()][2])
-        data.attrs['UNITS'] = attrs1['UNITS']
-        data.attrs['LONG_NAME'] = attrs1['LABEL']
-    elif 'SIMULATION' in k and pressure == True:
-        data = f.get([key for key in f.keys()][1])
-        data.attrs['UNITS'] = attrs1['UNITS']
-        data.attrs['LONG_NAME'] = attrs1['LABEL']
-    else:
-        data = f.get([key for key in f.keys()][1])
-    
-    return attrs, axis, data
-
-def open1D(filename, pressure = False):
-    ''' 
-    Open a 1D OSIRIS file and return the x axis and the data array.
-
-    Parameters
-    ----------
-    filename : str
-        The path to the file.
-    
-    Returns
-    -------
-    x : numpy.ndarray
-        The x axis.
-    data_array : numpy.ndarray
-        The data array.
-    '''
-    attrs, axes, data = read_osiris_file(filename, pressure)
-    datash = data.shape
-    ax1 = axes[0]
-    x = np.linspace(ax1[0], ax1[1], datash[0])
-    data_array = data[:]
-    return x, data_array, [attrs, axes, data]
-
-def open2D(filename, pressure = False):
-    '''
-    Open a 2D OSIRIS file and return the x and y axes and the data array.
-
-    Parameters
-    ----------
-    filename : str
-        The path to the file.
-    
-    Returns
-    -------
-    x : numpy.ndarray
-        The x axis.
-    y : numpy.ndarray
-        The y axis.
-    data_array : numpy.ndarray
-        The data array.
-    '''
-    attrs, axes, data = read_osiris_file(filename, pressure)
-    datash = data.shape
-    ax1 = axes[0]
-    ax2 = axes[1]
-    x = np.linspace(ax1[0], ax1[1], datash[-1])
-    y = np.linspace(ax2[0], ax2[1], datash[-2])
-    data_array = data[:]
-    return x, y, data_array, [attrs, axes, data]
-
-def open3D(filename):
-    '''
-    Open a 3D OSIRIS file and return the x, y and z axes and the data array.
-
-    Parameters
-    ----------
-    filename : str
-        The path to the file.
-
-    Returns
-    -------
-    x : numpy.ndarray
-        The x axis.
-    y : numpy.ndarray
-        The y axis.
-    z : numpy.ndarray
-        The z axis.
-    data_array : numpy.ndarray
-        The data array.
-    '''
-    attrs, axes, data = read_osiris_file(filename)
-    datash = data.shape
-    ax1 = axes[0]
-    ax2 = axes[1]
-    ax3 = axes[2]
-    x = np.linspace(ax1[0], ax1[1], datash[-1])
-    y = np.linspace(ax2[0], ax2[1], datash[-2])
-    z = np.linspace(ax3[0], ax3[1], datash[-3])
-    data_array = data[:]
-    return x, y, z, data_array, [attrs, axes, data]