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

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

@@ -1,8 +1,8 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: osiris_utils
-Version: 1.1.1
+Version: 1.1.2
 Summary: Utilities to manipulate and visualize OSIRIS framework output data
-Author: ['João Pedro Ferreira Biu', 'João Cândido']
+Author: ['João Pedro Ferreira Biu', 'João Cândido', 'Diogo Carvalho']
 Author-email: ['joaopedrofbiu@tecnico.ulisboa.pt']
 License: MIT
 Project-URL: Issues Tracker, https://github.com/joaopedrobiu6/osiris_utils/issues
@@ -37,6 +37,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python

osiris_utils-1.1.2/osiris_utils/__init__.py

@@ -0,0 +1,15 @@
+from .utils import (time_estimation, filesize_estimation, transverse_average, integrate, animate_2D,
+                    save_data, read_data, courant2D)
+from .gui.gui import LAVA_Qt, LAVA
+from .data.data import OsirisGridFile, OsirisRawFile, OsirisData, OsirisHIST
+from .data.simulation import Simulation
+from .data.diagnostic import Diagnostic
+
+from .postprocessing.postprocess import PostProcess
+from .postprocessing.derivative import Derivative, Derivative_Diagnostic
+from .postprocessing.fft import FFT_Diagnostic, FastFourierTransform
+
+from .postprocessing.mean_field_theory_single import MFT_Single
+from .postprocessing.mean_field_theory import MeanFieldTheory_Diagnostic
+
+# true div not working because of rtruediv - division is not commutative

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

@@ -1,8 +1,8 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: osiris_utils
-Version: 1.1.1
+Version: 1.1.2
 Summary: Utilities to manipulate and visualize OSIRIS framework output data
-Author: ['João Pedro Ferreira Biu', 'João Cândido']
+Author: ['João Pedro Ferreira Biu', 'João Cândido', 'Diogo Carvalho']
 Author-email: ['joaopedrofbiu@tecnico.ulisboa.pt']
 License: MIT
 Project-URL: Issues Tracker, https://github.com/joaopedrobiu6/osiris_utils/issues
@@ -37,6 +37,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python

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

@@ -5,10 +5,6 @@ pyproject.toml
 requirements.txt
 setup.py
 osiris_utils/__init__.py
-osiris_utils/data.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.1.1 → osiris_utils-1.1.2}/setup.py

@@ -15,11 +15,11 @@ with open(os.path.join(here, 'requirements.txt'), encoding='utf-8') as f:
 
 setup(
     name='osiris_utils',
-    version='v1.1.1',
+    version='v1.1.2',
     description=('Utilities to manipulate and visualize OSIRIS framework output data'),
     long_description=long_description,
     long_description_content_type='text/x-rst',
-    author=['João Pedro Ferreira Biu', 'João Cândido'],
+    author=['João Pedro Ferreira Biu', 'João Cândido', 'Diogo Carvalho'],
     author_email=['joaopedrofbiu@tecnico.ulisboa.pt'],
     license='MIT',
     classifiers=[

osiris_utils-1.1.1/osiris_utils/__init__.py

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

osiris_utils-1.1.1/osiris_utils/data.py

@@ -1,418 +0,0 @@
-import numpy as np
-import pandas as pd
-import h5py
-
-class OsirisData():
-    """
-    Base class for handling OSIRIS simulation data files (HDF5 and HIST formats).
-
-    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 : 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._verbose = False
-
-        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'''
-        self._dt = float(f['SIMULATION'].attrs['DT'][0])
-        self._dim = int(f['SIMULATION'].attrs['NDIMS'][0])
-        self._time = [float(f.attrs['TIME'][0]), f.attrs['TIME UNITS'][0].decode('utf-8')]
-        self._iter = int(f.attrs['ITER'][0])
-        self._name = f.attrs['NAME'][0].decode('utf-8')
-        self._type = f.attrs['TYPE'][0].decode('utf-8')
-    
-    def verbose(self, verbose: bool = True):
-        '''
-        Set the verbosity of the class
-
-        Parameters
-        ----------
-        verbose : bool, optional
-            If True, the class will print messages, by default True when calling (False when not calling)
-        '''
-        self._verbose = verbose
-
-    def _open_file_hdf5(self, filename):
-        '''
-        Open the OSIRIS output file. Usually an HDF5 file or txt.
-
-        Parameters
-        ----------
-        filename : str
-            The path to the HDF5 file.
-        '''
-        if self._verbose: print(f'Opening file > {filename}')
-
-        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):
-        '''
-        Close the HDF5 file.
-        '''
-        if self._verbose: print('Closing file')
-        if self._file:
-            self._file.close()
-        
-    @property
-    def dt(self):
-        return self._dt
-    @property
-    def dim(self):
-        return self._dim
-    @property
-    def time(self):
-        return self._time
-    @property
-    def iter(self):
-        return self._iter
-    @property
-    def name(self):
-        return self._name
-    @property
-    def type(self):
-        return self._type
-
-class OsirisGridFile(OsirisData):
-    """
-    Handles structured grid data from OSIRIS HDF5 simulations, including electromagnetic fields.
-
-    Parameters
-    ----------
-    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)
-            
-        variable_key = self._get_variable_key(self._file)
-        
-        self._units = self._file.attrs['UNITS'][0].decode('utf-8')
-        self._label = self._file.attrs['LABEL'][0].decode('utf-8')
-        self._FFTdata = None
-        
-        data = np.array(self._file[variable_key][:])
-
-        axis = list(self._file['AXIS'].keys())
-        if len(axis) == 1:
-            self._grid = self._file['AXIS/' + axis[0]][()]
-            self._nx = len(data)
-            self._dx = (self.grid[1] - self.grid[0] ) / self.nx
-            self._x = np.arange(self.grid[0], self.grid[1], self.dx)
-        else: 
-            grid = []
-            for ax in axis: grid.append(self._file['AXIS/' + ax][()])
-            self._grid = np.array(grid)
-            self._nx = self._file[variable_key][()].transpose().shape
-            self._dx = (self.grid[:, 1] - self.grid[:, 0])/self.nx
-            self._x = [np.arange(self.grid[i, 0], self.grid[i, 1], self.dx[i]) for i in range(self.dim)]
-
-        self._axis = []
-        for ax in axis:
-            axis_data = {
-                'name': self._file['AXIS/'+ax].attrs['NAME'][0].decode('utf-8'),
-                'units': self._file['AXIS/'+ax].attrs['UNITS'][0].decode('utf-8'),
-                'long_name': self._file['AXIS/'+ax].attrs['LONG_NAME'][0].decode('utf-8'),
-                'type': self._file['AXIS/'+ax].attrs['TYPE'][0].decode('utf-8'),
-                'plot_label': rf'${self._file["AXIS/"+ax].attrs["LONG_NAME"][0].decode("utf-8")}$ $[{self._file["AXIS/"+ax].attrs["UNITS"][0].decode("utf-8")}]$',
-            }
-            self._axis.append(axis_data)
-        
-        self._data = np.ascontiguousarray(data.T)
-
-        self._close_file()
-
-    def _load_basic_attributes(self, f: h5py.File) -> None:
-        '''Load common attributes from HDF5 file'''
-        self._dt = float(f['SIMULATION'].attrs['DT'][0])
-        self._dim = int(f['SIMULATION'].attrs['NDIMS'][0])
-        self._time = [float(f.attrs['TIME'][0]), f.attrs['TIME UNITS'][0].decode('utf-8')]
-        self._iter = int(f.attrs['ITER'][0])
-        self._name = f.attrs['NAME'][0].decode('utf-8')
-        self._type = f.attrs['TYPE'][0].decode('utf-8')
-            
-    def _get_variable_key(self, f: h5py.File) -> str:
-        return next(k for k in f.keys() if k not in {'AXIS', 'SIMULATION'})
-    
-    
-
-    def _yeeToCellCorner1d(self, boundary):
-        '''
-        Converts 1d EM fields from a staggered Yee mesh to a grid with field values centered on the corner of the cell (the corner of the cell [1] has coordinates [1])
-        '''
-
-        if self.name.lower() in ['b2', 'b3', 'e1']:
-            if boundary == 'periodic': return 0.5 * (np.roll(self.data, shift=1) + self.data) 
-            else: return 0.5 * (self.data[1:] + self.data[:-1])
-        elif self.name.lower() in ['b1', 'e2', 'e3']:
-            if boundary == 'periodic': return self.data 
-            else: return  self.data[1:]
-        else: 
-            raise TypeError(f'This method expects magnetic or electric field grid data but received \'{self.name}\' instead')
-    
-
-    def _yeeToCellCorner2d(self, boundary):
-        '''
-        Converts 2d EM fields from a staggered Yee mesh to a grid with field values centered on the corner of the cell (the corner of the cell [1,1] has coordinates [1,1])
-        '''
-
-        if self.name.lower() in ['e1', 'b2']:
-            if boundary == 'periodic': return 0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)
-            else: return 0.5 * (self.data[1:, 1:] + self.data[:-1, 1:])
-        elif self.name.lower() in ['e2', 'b1']:
-            if boundary == 'periodic': return 0.5 * (np.roll(self.data, shift=1, axis=1) + self.data)
-            else: return 0.5 * (self.data[1:, 1:] + self.data[1:, :-1])
-        elif self.name.lower() in ['b3']:
-            if boundary == 'periodic': 
-               return 0.5 * (np.roll((0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)), shift=1, axis=1) + (0.5 * (np.roll(self.data, shift=1, axis=0) + self.data)))
-            else:
-                return 0.25 * (self.data[1:, 1:] + self.data[:-1, 1:] + self.data[1:, :-1] + self.data[:-1, :-1])
-        elif self.name.lower() in ['e3']:
-            if boundary == 'periodic': return self.data
-            else: return self.data[1:, 1:]
-        else:
-            raise TypeError(f'This method expects magnetic or electric field grid data but received \'{self.name}\' instead')
-        
-
-    def _yeeToCellCorner3d(self, boundary):
-        '''
-        Converts 3d EM fields from a staggered Yee mesh to a grid with field values centered on the corner of the cell (the corner of the cell [1,1,1] has coordinates [1,1,1])
-        '''
-        if boundary == 'periodic':
-            raise ValueError('Centering field from 3D simulations considering periodic boundary conditions is not implemented yet')
-        if self.name.lower() == 'b1':
-            return 0.25 * (self.data[1:, 1:, 1:] + self.data[1:, :-1, 1:] + self.data[1:, 1:, :-1] + self.data[1:, :-1, :-1])
-        elif self.name.lower() == 'b2':
-            return 0.25 * (self.data[1:, 1:, 1:] + self.data[:-1, 1:, 1:] + self.data[1:, 1:, :-1] + self.data[:-1, 1:, :-1])
-        elif self.name.lower() == 'b3':
-            return 0.25 * (self.data[1:, 1:, 1:] + self.data[:-1, 1:, 1:] + self.data[1:, :-1, 1:] + self.data[:-1, :-1, 1:])
-        elif self.name.lower() == 'e1':
-            return 0.5 * (self.data[1:, 1:, 1:] + self.data[:-1, 1:, 1:])
-        elif self.name.lower() == 'e2':
-            return 0.5 * (self.data[1:, 1:, 1:] + self.data[1:, :-1, 1:])
-        elif self.name.lower() == 'e3':
-            return 0.5 * (self.data[1:, 1:, 1:] + self.data[1:, 1:, :-1])
-        else:
-            raise TypeError(f'This method expects magnetic or electric field grid data but received \'{self.name}\' instead')
-        
-    def yeeToCellCorner(self, boundary=None):
-        ''''
-        Converts EM fields from a staggered Yee mesh to a grid with field values centered on the corner of the cell.'
-        Can be used for 1D, 2D and 3D simulations.'
-        Creates a new attribute `data_centered` with the centered data.'
-        '''
-        
-        cases = {'b1', 'b2', 'b3', 'e1', 'e2', 'e3'}
-        if self.name not in cases:
-            raise TypeError(f'This method expects magnetic or electric field grid data but received \'{self.name}\' instead')
-        
-        if self.dim == 1:
-            self.data_centered = self._yeeToCellCorner1d(boundary)
-            return self.data_centered
-        elif self.dim == 2:
-            self.data_centered = self._yeeToCellCorner2d(boundary)
-            return self.data_centered
-        elif self.dim == 3:
-            self.data_centered = self._yeeToCellCorner3d(boundary)
-            return self.data_centered
-        else:
-            raise ValueError(f'Dimension {self.dim} is not supported')
-        
-    def FFT(self, axis=(0, )):
-        '''
-        Computes the Fast Fourier Transform of the data along the specified axis and shifts the zero frequency to the center.
-        Transforms the data to the frequency domain. A(x, y, z) -> A(kx, ky, kz)
-        '''
-        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):
-    '''
-    Class to read the raw data from an OSIRIS HDF5 file.
-    
-    Input:
-        - filename: the path to the HDF5 file
-    
-    Attributes:
-        - axis - a dictionary where each key is a dataset name, and each value is another dictionary containing
-            name (str): The name of the quantity (e.g., r'x1', r'ene').
-            units (str): The units associated with that dataset in LaTeX (e.g., r'c/\\omega_p', r'm_e c^2').
-            long_name (str): The name of the quantity in LaTeX (e.g., r'x_1', r'En2').
-            dictionary of dictionaries
-        - data - a dictionary where each key is a dataset name, and each value is the data
-            dictionary of np.arrays
-        - dim - the number of dimensions
-            int
-        - dt - the time step
-            float
-        - grid - maximum and minimum coordinates of the box, for each axis 
-            numpy.ndarray(dim,2)
-        - iter - the iteration number
-            int
-        - name - the name of the species
-            str
-        - time - the time and its units
-            list [time, units]
-            list [float, str]
-        - type - type of data (particles in the case of raw files)
-            str
-
-    '''
-    
-    def __init__(self, filename):
-        super().__init__(filename)
-
-        self.grid = np.array([self._file['SIMULATION'].attrs['XMIN'], self._file['SIMULATION'].attrs['XMAX']]).T
-
-        self.data = {}
-        self.axis = {}
-        for key in self._file.keys():
-            if key == 'SIMULATION': continue
-
-            self.data[key] = np.array(self._file[key][()])
-
-            idx = np.where(self._file.attrs['QUANTS'] == str(key).encode('utf-8'))
-            axis_data = {
-                'name': self._file.attrs['QUANTS'][idx][0].decode('utf-8'),
-                'units': self._file.attrs['UNITS'][idx][0].decode('utf-8'),
-                '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/gui.py

@@ -1,266 +0,0 @@
-import sys
-import os
-from PySide6.QtWidgets import (QApplication, QMainWindow, QWidget, QPushButton, 
-                              QFileDialog, QMessageBox, QComboBox, QHBoxLayout,
-                              QVBoxLayout, QLabel, QLineEdit, QFrame, QDoubleSpinBox)
-from PySide6.QtCore import Qt
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-import matplotlib.pyplot as plt
-from matplotlib.colors import LogNorm
-import numpy as np
-from .data import OsirisGridFile  # Update import as needed
-from .utils import integrate, transverse_average  # Update import as needed
-
-class LAVA_Qt(QMainWindow):
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle('LAVA (LabAstro Visualization Assistant) - OSIRIS Data Grid Viewer')
-        self.setGeometry(100, 100, 1000, 600)
-        
-        # Initialize data
-        self.data_info = None
-        self.dims = 0
-        self.current_ax = None
-        self.current_folder = None
-        
-        # Main widget and layout
-        self.main_widget = QWidget()
-        self.setCentralWidget(self.main_widget)
-        self.main_layout = QVBoxLayout(self.main_widget)
-        
-        # Create UI elements
-        self.create_controls()
-        self.create_labels_section()
-        self.create_plot_area()
-
-    def create_controls(self):
-        # Control buttons frame
-        control_frame = QWidget()
-        control_layout = QHBoxLayout(control_frame)
-        
-        # Buttons
-        self.browse_btn = QPushButton('Browse Folder')
-        self.browse_btn.clicked.connect(self.load_folder)
-        self.save_btn = QPushButton('Save Plot')
-        self.save_btn.clicked.connect(self.save_plot)
-        
-        # File selector
-        self.file_selector = QComboBox()
-        self.file_selector.setPlaceholderText('Select file...')
-        self.file_selector.currentIndexChanged.connect(self.file_selection_changed)
-        self.file_selector.view().setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
-        self.file_selector.setSizeAdjustPolicy(QComboBox.AdjustToContents)
-        
-        # Plot type combo box
-        self.plot_combo = QComboBox()
-        self.plot_combo.addItem('Select Plot Type')
-        self.plot_combo.currentTextChanged.connect(self.plot_data)
-        
-        control_layout.addWidget(self.browse_btn)
-        control_layout.addWidget(self.save_btn)
-        control_layout.addWidget(QLabel('Files:'))
-        control_layout.addWidget(self.file_selector)
-        control_layout.addWidget(QLabel('Plot Type:'))
-        control_layout.addWidget(self.plot_combo)
-        self.main_layout.addWidget(control_frame)
-
-    def create_labels_section(self):
-        # Labels frame
-        labels_frame = QWidget()
-        labels_layout = QHBoxLayout(labels_frame)
-        
-        # Title and labels
-        self.title_edit = QLineEdit()
-        self.xlabel_edit = QLineEdit()
-        self.ylabel_edit = QLineEdit()
-        
-        # Connect text changes
-        self.title_edit.textChanged.connect(self.update_plot_labels)
-        self.xlabel_edit.textChanged.connect(self.update_plot_labels)
-        self.ylabel_edit.textChanged.connect(self.update_plot_labels)
-        
-        
-        labels_layout.addWidget(QLabel('Title:'))
-        labels_layout.addWidget(self.title_edit)
-        labels_layout.addWidget(QLabel('X Label:'))
-        labels_layout.addWidget(self.xlabel_edit)
-        labels_layout.addWidget(QLabel('Y Label:'))
-        labels_layout.addWidget(self.ylabel_edit)
-        
-        # define the size of the labels frame
-        self.main_layout.addWidget(labels_frame)
-
-    
-    def load_folder(self):
-        folder_dialog = QFileDialog()
-        folderpath = folder_dialog.getExistingDirectory(
-            self, 'Select Folder with HDF5 Files'
-        )
-        
-        if not folderpath:
-            return
-            
-        try:
-            self.current_folder = folderpath
-            self.file_selector.clear()
-            
-            # Find all .h5 files
-            h5_files = [f for f in os.listdir(folderpath) if f.endswith('.h5')]
-            # all the files end with xxxxxx.h5 so we can use this to order them by the number
-            def sort_key(filename):
-                try:
-                    # Split filename into parts and get the numeric portion
-                    base = os.path.splitext(filename)[0]  # Remove .h5
-                    numeric_part = base.split('-')[-1]    # Get last part after -
-                    return int(numeric_part)
-                except (IndexError, ValueError):
-                    return 0  # Fallback for malformed filenames
-
-            h5_files.sort(key=sort_key)
-            
-            if not h5_files:
-                raise ValueError('No HDF5 files found in selected folder')
-            
-            self.file_selector.addItems(h5_files)
-            self.file_selector.setCurrentIndex(0)
-            
-        except Exception as e:
-            QMessageBox.critical(self, 'Error', str(e))
-
-    def file_selection_changed(self, index):
-        '''Handle file selection change in the combo box'''
-        if index >= 0 and self.current_folder:
-            filename = self.file_selector.itemText(index)
-            self.process_file(filename)
-
-    def process_file(self, filename):
-        try:
-            filepath = os.path.join(self.current_folder, filename)
-            gridfile = OsirisGridFile(filepath)
-            self.dims = len(gridfile.axis)
-            self.type = gridfile.type
-            
-            if self.type == 'grid':
-                if self.dims == 1:
-                    x = np.arange(gridfile.grid[0], gridfile.grid[1], gridfile.dx)
-                    self.xlabel_edit.setText(r'$%s$ [$%s$]' % (gridfile.axis[0]['long_name'], gridfile.axis[0]['units']))
-                    self.ylabel_edit.setText(r'$%s$ [$%s$]' % (gridfile.label, gridfile.units))
-                    self.data_info = (x, gridfile.data)
-                elif self.dims == 2:
-                    x = np.arange(gridfile.grid[0][0], gridfile.grid[0][1], gridfile.dx[0])
-                    y = np.arange(gridfile.grid[1][0], gridfile.grid[1][1], gridfile.dx[1])
-                    self.xlabel_edit.setText(r'$%s$ [$%s$]' % (gridfile.axis[0]['long_name'], gridfile.axis[0]['units']))
-                    self.ylabel_edit.setText(r'$%s$ [$%s$]' % (gridfile.axis[1]['long_name'], gridfile.axis[1]['units']))
-                    self.data_info = (x, y, gridfile.data)
-                elif self.dims == 3:
-                    raise ValueError('3D not supported yet')
-                else:
-                    raise ValueError('Unsupported dimensionality')
-                
-                self.title_edit.setText(r'$%s$ [$%s$]' %( gridfile.label, gridfile.units))
-                self.update_plot_menu()
-                self.plot_data()
-                
-            else:
-                QMessageBox.information(self, 'Info', f'{self.type} data not supported yet')
-                
-        except Exception as e:
-            QMessageBox.critical(self, 'Error', str(e))
-
-    def create_plot_area(self):
-        # Matplotlib figure and canvas
-        self.figure = plt.figure(figsize=(8, 6))
-        self.canvas = FigureCanvas(self.figure)
-        self.main_layout.addWidget(self.canvas)
-
-    def update_plot_labels(self):
-        if self.current_ax:
-            self.current_ax.set_xlabel(self.xlabel_edit.text())
-            self.current_ax.set_ylabel(self.ylabel_edit.text())
-            self.figure.suptitle(self.title_edit.text())
-            self.canvas.draw()
-
-    def plot_data(self):
-        self.figure.clear()
-        if self.dims == 1:
-            self.plot_1d()
-        elif self.dims == 2:
-            self.plot_2d()
-        self.update_plot_labels()
-        self.canvas.draw()
-
-    def plot_1d(self):
-        x, data = self.data_info
-        self.current_ax = self.figure.add_subplot(111)
-        plot_type = self.plot_combo.currentText()
-        
-        if 'Line' in plot_type:
-            self.current_ax.plot(x, data)
-        elif 'Scatter' in plot_type:
-            self.current_ax.scatter(x, data)
-            
-        self.current_ax.set_xlabel(self.xlabel_edit.text())
-        self.current_ax.set_ylabel(self.ylabel_edit.text())
-        self.figure.suptitle(self.title_edit.text())
-
-    def plot_2d(self):
-        x, y, data = self.data_info
-        self.current_ax = self.figure.add_subplot(111)
-        plot_type = self.plot_combo.currentText()
-        
-        if 'Quantity' in plot_type:
-            img = self.current_ax.imshow(data.T, extent=(x[0], x[-1], y[0], y[-1]), origin='lower', aspect='auto')
-            self.figure.colorbar(img)
-        elif 'Integral' in plot_type:
-            avg = integrate(transverse_average(data), x[-1]/len(x))
-            self.current_ax.plot(x, avg)
-        elif 'Transverse' in plot_type:
-            avg = transverse_average(data)
-            self.current_ax.plot(x, avg)
-        elif 'Phase' in plot_type:
-            img = self.current_ax.imshow(np.abs(-data.T), extent=(x[0], x[-1], y[0], y[-1]), origin='lower', aspect='auto', norm=LogNorm())
-            self.figure.colorbar(img)
-        
-        self.current_ax.set_xlabel(self.xlabel_edit.text())
-        self.current_ax.set_ylabel(self.ylabel_edit.text())
-        self.figure.suptitle(self.title_edit.text())
-
-    def update_plot_menu(self):
-        
-        # Save current plot type before clearing
-        current_plot_type = self.plot_combo.currentText()
-        self.plot_combo.clear()
-        
-        # Determine items based on dimensions
-        if self.dims == 1:
-            items = ['Line Plot', 'Scatter Plot']
-        elif self.dims == 2:
-            items = ['Quantity Plot', 'T. Average Integral', 'Transverse Average', 'Phase Space']
-        else:
-            items = []
-        
-        self.plot_combo.addItems(items)
-    
-        # Restore previous selection if possible
-        if current_plot_type in items:
-            self.plot_combo.setCurrentText(current_plot_type)
-        else:
-            self.plot_combo.setCurrentIndex(0 if items else -1)
-
-    def save_plot(self):
-        file_dialog = QFileDialog()
-        filepath, _ = file_dialog.getSaveFileName(
-            self, 'Save Plot', '', 'PNG Files (*.png);;PDF Files (*.pdf)'
-        )
-        
-        if filepath:
-            self.figure.savefig(filepath, dpi=800, bbox_inches='tight')
-
-def LAVA():
-    app = QApplication(sys.argv)
-    window = LAVA_Qt()
-    window.show()
-    sys.exit(app.exec())
-
-if __name__ == '__main__':
-    LAVA()

osiris_utils-1.1.1/osiris_utils/mean_field_theory.py

@@ -1,52 +0,0 @@
-import numpy as np
-from .data import OsirisGridFile
-
-        
-class MeanFieldTheory(OsirisGridFile):
-    '''
-    Class to handle the mean field theory on data. Inherits from OsirisGridFile.
-    
-    Parameters
-    ----------
-    source : str or OsirisGridFile
-        The filename or an OsirisGridFile object.
-    axis : int
-        The axis to average over.
-    '''
-    def __init__(self, source, axis=1):
-        if isinstance(source, OsirisGridFile):
-            self.__dict__.update(source.__dict__)
-        else:
-            super().__init__(source)
-        self._compute_mean_field(axis=axis)
-
-    def _compute_mean_field(self, axis=1):
-        self._average = np.expand_dims(np.mean(self.data, axis=axis), axis=axis)
-        self._fluctuations = self.data - self._average
-
-    def __array__(self):
-        return self.data
-
-    @property
-    def average(self):
-        return self._average
-    
-    @property
-    def delta(self):
-        return self._fluctuations
-    
-    def __str__(self):
-        return super().__str__() + f'\nAverage: {self.average.shape}\nDelta: {self.delta.shape}'
-    
-    def derivative(self, field, axis=0):
-        '''
-        Compute the derivative of the average or the fluctuations.
-        
-        Parameters
-        ----------
-        field : MeanFieldTheory.average or MeanFieldTheory.delta
-            The field to compute the derivative.
-        axis : int
-            The axis to compute the derivative.
-        '''
-        return np.gradient(field, self.dx[axis], axis=0)

osiris_utils-1.1.1/osiris_utils/simulation_data.py

@@ -1,229 +0,0 @@
-"""
-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
-
-