osiris-utils 1.1.4__py3-none-any.whl → 1.1.6__py3-none-any.whl

osiris_utils/postprocessing/heatflux_correction.py

@@ -0,0 +1,193 @@
+from ..utils import *
+from ..data.simulation import Simulation
+from .postprocess import PostProcess
+from ..data.diagnostic import Diagnostic
+
+from .pressure_correction import *
+
+OSIRIS_H = ["q1", "q2", "q3"]
+
+class HeatfluxCorrection_Simulation(PostProcess):
+    def __init__(self, simulation):
+        super().__init__(f"HeatfluxCorrection Simulation")
+        """
+        Class to correct pressure tensor components by subtracting Reynolds stress.
+
+        Parameters
+        ----------
+        sim : Simulation
+            The simulation object.
+        heatflux : str
+            The heatflux component to center.
+        """
+        if not isinstance(simulation, Simulation):
+            raise ValueError("Simulation must be a Simulation object.")
+        self._simulation = simulation
+        self._heatflux_corrected = {}
+        self._species_handler = {}
+
+    def __getitem__(self, key):
+        if key in self._simulation._species:
+            if key not in self._species_handler:
+                self._species_handler[key] = HeatfluxCorrection_Species_Handler(self._simulation[key], self._simulation)
+            return self._species_handler[key]
+        if key not in OSIRIS_H:
+            raise ValueError(f"Invalid heatflux component {key}. Supported: {OSIRIS_H}.")
+        if key not in self._heatflux_corrected:
+            print("Weird that it got here - heatflux is always species dependent on OSIRIS")
+            self._heatflux_corrected[key] = HeatfluxCorrection_Diagnostic(self._simulation[key], self._simulation)
+        return self._heatflux_corrected[key]
+
+    
+    def delete_all(self):
+        self._heatflux_corrected = {}
+
+    def delete(self, key):
+        if key in self._heatflux_corrected:
+            del self._heatflux_corrected[key]
+        else:
+            print(f"Heatflux {key} not found in simulation")
+    
+    def process(self, diagnostic):
+        """Apply heatflux correction to a diagnostic"""
+        return HeatfluxCorrection_Diagnostic(diagnostic, self._simulation)
+    
+class HeatfluxCorrection_Diagnostic(Diagnostic):
+    def __init__(self, diagnostic, vfl_i, Pjj_list, vfl_j_list, Pji_list):
+
+        """
+        Class to correct the pressure in the simulation.
+
+        Parameters
+        ----------
+        diagnostic : Diagnostic
+            The diagnostic object.
+        """
+        if hasattr(diagnostic, '_species'):
+            super().__init__(simulation_folder=diagnostic._simulation_folder if hasattr(diagnostic, '_simulation_folder') else None, 
+                             species=diagnostic._species)
+        else:
+            super().__init__(None)
+        
+        self.postprocess_name = "HFL_CORR"
+
+        if diagnostic._name not in OSIRIS_H:
+            raise ValueError(f"Invalid heatflux component {diagnostic._name}. Supported: {OSIRIS_H}")
+        
+        self._diag = diagnostic
+
+        # The density and velocities are now passed as arguments (so it can doesn't depend on the simulation)
+        self._vfl_i = vfl_i
+        self._Pjj_list = Pjj_list
+        self._vfl_j_list = vfl_j_list
+        self._Pji_list = Pji_list
+
+        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter', '_type']:
+            if hasattr(diagnostic, attr):
+                setattr(self, attr, getattr(diagnostic, attr))
+
+        self._original_name = diagnostic._name
+        self._name = diagnostic._name + "_corrected"
+
+        self._data = None
+        self._all_loaded = False
+
+    def load_all(self):
+        if self._data is not None:
+            return self._data
+        
+        if not hasattr(self._diag, '_data') or self._diag._data is None:
+            self._diag.load_all()
+
+        print(f"Loading {self._species._name} {self._original_name} diagnostic")
+        
+        self._vfl_i.load_all()
+        
+
+        for vfl_j in self._vfl_j_list:
+            vfl_j.load_all()
+        for Pji in self._Pji_list:
+            Pji.load_all()
+        for Pjj in self._Pjj_list:
+            Pjj.load_all()
+
+        q = self._diag.data
+        vfl_i = self._vfl_i.data
+        
+        trace_P = sum(Pjj.data for Pjj in self._Pjj_list)
+
+        # Sum over j: vfl_j * Pji
+        vfl_dot_Pji = sum(vfl_j.data * Pji.data for vfl_j, Pji in zip(self._vfl_j_list, self._Pji_list))
+
+        self._data = 2 * q - 0.5 * vfl_i * trace_P - vfl_dot_Pji
+        self._all_loaded = True
+
+
+        return self._data
+    
+    def __getitem__(self, index):
+        """Get data at a specific index"""
+        if self._all_loaded and self._data is not None:
+            return self._data[index]
+        
+        if isinstance(index, int):
+            return next(self._data_generator(index))
+        elif isinstance(index, slice):
+            start = 0 if index.start is None else index.start
+            step = 1 if index.step is None else index.step
+            stop = self._diag._maxiter if index.stop is None else index.stop
+            return np.array([next(self._data_generator(i)) for i in range(start, stop, step)])
+        else:
+            raise ValueError("Invalid index type. Use int or slice.")
+
+    def _data_generator(self, index):
+        q = self._diag[index]
+        vfl_i = self._vfl_i[index]
+        trace_P = sum(Pjj[index] for Pjj in self._Pjj_list)
+        vfl_dot_Pji = sum(vfl_j[index] * Pji[index] for vfl_j, Pji in zip(self._vfl_j_list, self._Pji_list))
+        yield 2 * q - 0.5 * vfl_i * trace_P - vfl_dot_Pji
+        
+class HeatfluxCorrection_Species_Handler:
+    """
+    Class to handle heatflux correction for a species.
+    Acts as a wrapper for the HeatfluxCorrection_Diagnostic class.
+
+    Not intended to be used directly, but through the HeatfluxCorrection_Simulation class.
+
+    Parameters
+    ----------
+    species_handler : Species_Handler
+        The species handler object.
+    simulation : Simulation
+        The simulation object.
+    """
+    def __init__(self, species_handler, simulation):
+        self._species_handler = species_handler
+        self._simulation = simulation
+        self._heatflux_corrected = {}
+
+    def __getitem__(self, key):
+        if key not in self._heatflux_corrected:
+            diag = self._species_handler[key]
+
+            # Velocities alwayes depend on the species so this can be done here
+
+            i = int(key[-1])  # Get i from 'q1', 'q2', etc.
+            
+            vfl_i = self._species_handler[f"vfl{i}"]
+
+            # Load trace(P): sum over Pjj
+            Pjj_list = [self._species_handler[f"P{j}{j}"] for j in range(1, diag._dim + 1)]
+
+            # Compute quantities for vfl_j * P_{ji}
+            vfl_j_list = [self._species_handler[f"vfl{j}"] for j in range(1, diag._dim + 1)]
+            Pji_list = [PressureCorrection_Simulation(self._simulation)[diag._species._name][f"P{j}{i}"] for j in range(1, diag._dim + 1)]
+
+            self._heatflux_corrected[key] = HeatfluxCorrection_Diagnostic(
+                diag,
+                vfl_i,
+                Pjj_list,
+                vfl_j_list,
+                Pji_list
+            )
+        return self._heatflux_corrected[key]

osiris_utils/postprocessing/mft.py

@@ -15,11 +15,6 @@ class MeanFieldTheory_Simulation(PostProcess):
     mft_axis : int
         The axis to compute the mean field theory.
 
-    Example
-    -------
-    >>> sim = Simulation('electrons', 'path/to/simulation')
-    >>> mft = MeanFieldTheory(sim, 1)
-    >>> mft_e1 = mft['e1']
     """
 
     def __init__(self, simulation, mft_axis=None):
@@ -65,19 +60,14 @@ class MFT_Diagnostic(Diagnostic):
     mft_axis : int
         The axis to compute mean field theory along.
 
-    Example
-    -------
-    >>> sim = Simulation('electrons', 'path/to/simulation')
-    >>> diag = sim['e1']
-    >>> mft = MFT_Diagnostic(diag, 1)
-    >>> avg = mft['avg']
-    >>> delta = mft['delta']
+
     """
 
     def __init__(self, diagnostic, mft_axis):
         # Initialize using parent's __init__ with the same species
         if hasattr(diagnostic, '_species'):
-            super().__init__(species=diagnostic._species)
+            super().__init__(simulation_folder=diagnostic._simulation_folder if hasattr(diagnostic, '_simulation_folder') else None, 
+                             species=diagnostic._species)
         else:
             super().__init__(None)
             
@@ -91,7 +81,7 @@ class MFT_Diagnostic(Diagnostic):
         self._components = {}
         
         # Copy all relevant attributes from diagnostic
-        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter']:
+        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter', '_tunits', '_type']:
             if hasattr(diagnostic, attr):
                 setattr(self, attr, getattr(diagnostic, attr))
 
@@ -152,23 +142,21 @@ class MFT_Diagnostic_Average(Diagnostic):
     mft_axis : int
         The axis to compute the mean field theory.
 
-    Example
-    -------
-    >>> sim = Simulation('electrons', 'path/to/simulation')
-    >>> diag = sim['e1']
-    >>> avg = MFT_Diagnostic_Average(diag, 1)
     """
 
     def __init__(self, diagnostic, mft_axis):
         # Initialize with the same species as the diagnostic
         if hasattr(diagnostic, '_species'):
-            super().__init__(species=diagnostic._species)
+            super().__init__(simulation_folder=diagnostic._simulation_folder if hasattr(diagnostic, '_simulation_folder') else None, 
+                             species=diagnostic._species)
         else:
             super().__init__(None)
             
         if mft_axis is None:
             raise ValueError("Mean field theory axis must be specified.")
         
+        self.postprocess_name = f"MFT_AVG"
+
         self._name = f"MFT_avg[{diagnostic._name}, {mft_axis}]"
         self._diag = diagnostic
         self._mft_axis = mft_axis
@@ -176,7 +164,7 @@ class MFT_Diagnostic_Average(Diagnostic):
         self._all_loaded = False
 
         # Copy all relevant attributes from diagnostic
-        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter']:
+        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter', '_type']:
             if hasattr(diagnostic, attr):
                 setattr(self, attr, getattr(diagnostic, attr))
 
@@ -237,23 +225,21 @@ class MFT_Diagnostic_Fluctuations(Diagnostic):
     mft_axis : int
         The axis to compute the mean field theory.
 
-    Example
-    -------
-    >>> sim = Simulation('electrons', 'path/to/simulation')
-    >>> diag = sim['e1']
-    >>> delta = MFT_Diagnostic_Fluctuations(diag, 1)
     """
     
     def __init__(self, diagnostic, mft_axis):
         # Initialize with the same species as the diagnostic
         if hasattr(diagnostic, '_species'):
-            super().__init__(species=diagnostic._species)
+            super().__init__(simulation_folder=diagnostic._simulation_folder if hasattr(diagnostic, '_simulation_folder') else None, 
+                             species=diagnostic._species)
         else:
             super().__init__(None)
             
         if mft_axis is None:
             raise ValueError("Mean field theory axis must be specified.")
         
+        self.postprocess_name = f"MFT_FLT"
+
         self._name = f"MFT_delta[{diagnostic._name}, {mft_axis}]"
         self._diag = diagnostic
         self._mft_axis = mft_axis
@@ -261,7 +247,7 @@ class MFT_Diagnostic_Fluctuations(Diagnostic):
         self._all_loaded = False
 
         # Copy all relevant attributes from diagnostic
-        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter']:
+        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter', '_type']:
             if hasattr(diagnostic, attr):
                 setattr(self, attr, getattr(diagnostic, attr))
 

osiris_utils/postprocessing/pressure_correction.py

@@ -0,0 +1,171 @@
+from ..utils import *
+from ..data.simulation import Simulation
+from .postprocess import PostProcess
+from ..data.diagnostic import Diagnostic
+
+OSIRIS_P = ["P11", "P12", "P13", "P21", "P22", "P23", "P31", "P32", "P33"]
+
+class PressureCorrection_Simulation(PostProcess):
+    def __init__(self, simulation):
+        super().__init__(f"PressureCorrection Simulation")
+        """
+        Class to correct pressure tensor components by subtracting Reynolds stress.
+
+        Parameters
+        ----------
+        sim : Simulation
+            The simulation object.
+        pressure : str
+            The pressure component to center.
+        """
+        if not isinstance(simulation, Simulation):
+            raise ValueError("Simulation must be a Simulation object.")
+        self._simulation = simulation
+        self._pressure_corrected = {}
+        self._species_handler = {}
+
+    def __getitem__(self, key):
+        if key in self._simulation._species:
+            if key not in self._species_handler:
+                self._species_handler[key] = PressureCorrection_Species_Handler(self._simulation[key])
+            return self._species_handler[key]
+        if key not in OSIRIS_P:
+            raise ValueError(f"Invalid pressure component {key}. Supported: {OSIRIS_P}.")
+        if key not in self._pressure_corrected:
+            print("Weird that it got here - pressure is always species dependent on OSIRIS")
+            self._pressure_corrected[key] = PressureCorrection_Diagnostic(self._simulation[key], self._simulation)
+        return self._pressure_corrected[key]
+
+    
+    def delete_all(self):
+        self._pressure_corrected = {}
+
+    def delete(self, key):
+        if key in self._pressure_corrected:
+            del self._pressure_corrected[key]
+        else:
+            print(f"Pressure {key} not found in simulation")
+    
+    def process(self, diagnostic):
+        """Apply pressure correction to a diagnostic"""
+        return PressureCorrection_Diagnostic(diagnostic, self._simulation)
+    
+class PressureCorrection_Diagnostic(Diagnostic):
+    def __init__(self, diagnostic, n, ufl_j, vfl_k):
+
+        """
+        Class to correct the pressure in the simulation.
+
+        Parameters
+        ----------
+        diagnostic : Diagnostic
+            The diagnostic object.
+        """
+        if hasattr(diagnostic, '_species'):
+            super().__init__(simulation_folder=diagnostic._simulation_folder if hasattr(diagnostic, '_simulation_folder') else None, 
+                             species=diagnostic._species)
+        else:
+            super().__init__(None)
+        
+        self.postprocess_name = "P_CORR"
+
+        if diagnostic._name not in OSIRIS_P:
+            raise ValueError(f"Invalid pressure component {diagnostic._name}. Supported: {OSIRIS_P}")
+        
+        self._diag = diagnostic
+
+        # The density and velocities are now passed as arguments (so it can doesn't depend on the simulation)
+        self._n = n
+        self._ufl_j = ufl_j
+        self._vfl_k = vfl_k
+
+        for attr in ['_dt', '_dx', '_ndump', '_axis', '_nx', '_x', '_grid', '_dim', '_maxiter', '_type']:
+            if hasattr(diagnostic, attr):
+                setattr(self, attr, getattr(diagnostic, attr))
+
+        self._original_name = diagnostic._name
+        self._name = diagnostic._name + "_corrected"
+
+        self._data = None
+        self._all_loaded = False
+
+    def load_all(self):
+        if self._data is not None:
+            return self._data
+        
+        if not hasattr(self._diag, '_data') or self._diag._data is None:
+            self._diag.load_all()
+
+        print(f"Loading {self._species._name} {self._original_name} diagnostic")
+        self._n.load_all()
+        self._ufl_j.load_all()
+        self._vfl_k.load_all()
+
+        # Then access the data
+        n = self._n.data
+        u = self._ufl_j.data
+        v = self._vfl_k.data
+        
+        self._data = self._diag.data - n * v * u
+        self._all_loaded = True
+
+        # Unload the data to save memory
+        # self._n.unload()
+        # self._ufl_j.unload()
+        # self._vfl_k.unload()
+
+        return self._data
+    
+    def __getitem__(self, index):
+        """Get data at a specific index"""
+        if self._all_loaded and self._data is not None:
+            return self._data[index]
+        
+        if isinstance(index, int):
+            return next(self._data_generator(index))
+        elif isinstance(index, slice):
+            start = 0 if index.start is None else index.start
+            step = 1 if index.step is None else index.step
+            stop = self._diag._maxiter if index.stop is None else index.stop
+            return np.array([next(self._data_generator(i)) for i in range(start, stop, step)])
+        else:
+            raise ValueError("Invalid index type. Use int or slice.")
+
+    def _data_generator(self, index):
+        yield self._diag[index] - self._n[index] * self._vfl_k[index] * self._ufl_j[index]
+        
+class PressureCorrection_Species_Handler:
+    """
+    Class to handle pressure correction for a species.
+    Acts as a wrapper for the PressureCorrection_Diagnostic class.
+
+    Not intended to be used directly, but through the PressureCorrection_Simulation class.
+
+    Parameters
+    ----------
+    species_handler : Species_Handler
+        The species handler object.
+    type : str
+        The type of derivative to compute. Options are: 't', 'x1', 'x2', 'x3', 'xx', 'xt' and 'tx'.
+    axis : int or tuple
+        The axis to compute the derivative. Only used for 'xx', 'xt' and 'tx' types.
+    """
+    def __init__(self, species_handler):
+        self._species_handler = species_handler
+        self._pressure_corrected = {}
+
+    def __getitem__(self, key):
+        if key not in self._pressure_corrected:
+            diag = self._species_handler[key]
+
+            # Density and velocities alwayes depend on the species so this can be done here
+
+            n = self._species_handler["n"]
+            self._j, self._k = key[-2], key[-1]
+            try:
+                ufl = self._species_handler[f"ufl{self._j}"]
+            except:
+                ufl = self._species_handler[f"vfl{self._j}"]
+            vfl = self._species_handler[f"vfl{self._k}"]
+            self._pressure_corrected[key] = PressureCorrection_Diagnostic(diag, n, ufl, vfl)
+        return self._pressure_corrected[key]

osiris_utils/utils.py

@@ -4,6 +4,7 @@ import matplotlib.pyplot as plt
 import matplotlib.animation as animation
 import scipy 
 import pandas as pd
+from datetime import datetime
 
 def courant2D(dx, dy):
     '''
@@ -141,4 +142,142 @@ def read_data(filename, option='numpy'):
         Dim: 2D.
         The data.
     '''
-    return np.loadtxt(filename) if option == 'numpy' else pd.read_csv(filename).values
+    return np.loadtxt(filename) if option == 'numpy' else pd.read_csv(filename).values
+
+
+def convert_tracks(filename_in):
+    '''
+   Converts a new OSIRIS track file aka IDL-formatted aka tracks-2 to an older format that is more human-readable.  
+   In the old format, each particle is stored in a separate folder, with datasets for each quantity.  
+   The function reads data from the input file, processes it, and writes it to a new file with the suffix "-v2".
+
+    code from https://github.com/GoLP-IST/RaDi-x/blob/main/tools/convert_idl_tracks_py3.py 
+
+    Parameters
+    ----------
+    filename_in : str
+        The path to the trackfile.
+
+    Returns
+    -------
+    The output file will be in the same folder as the input file with the same name with \"v2\" added
+    
+    '''
+
+    try:
+        file_in = h5py.File(filename_in, 'r')
+    except IOError:
+        print('cannot open ' + filename_in)
+        exit()
+
+    # read data from file
+    data = file_in['data'][:]
+    itermap = file_in['itermap'][:]
+    ntracks = file_in.attrs['NTRACKS'][0]
+    niter = file_in.attrs['NITER'][0]
+    quants = file_in.attrs['QUANTS'][:]
+    file_in_attr_keys = file_in.attrs.keys()
+    sim_attr_keys = file_in['SIMULATION'].attrs.keys()
+    nquants = len(quants)
+
+	# construct file out for new format
+    filename_out = filename_in[:-3] + '-v2' + filename_in[-3:]
+    file_out = h5py.File(filename_out,'w')
+
+	# copy attrs from file_in
+    for item in file_in_attr_keys:
+        file_out.attrs[item] = file_in.attrs[item]
+    for item in sim_attr_keys:
+        file_out.attrs[item] = file_in['SIMULATION'].attrs[item]
+
+    # first pass -- find total size of each track
+    #----------------------------------------#
+    sizes = np.zeros(ntracks)
+
+    itermapshape = itermap.shape
+    for i in range(itermapshape[0]):
+        part_number,npoints,nstart = itermap[i,:]
+        sizes[part_number-1] += npoints
+
+    # initialize ordered data buffer
+    #----------------------------------------#
+    ordered_data = []
+    for i in range(ntracks):
+        ordered_data.append(np.zeros((int(sizes[i]),nquants)))
+    #----------------------------------------#
+
+
+
+    # assign tracks to ordered data from file_in data
+    #----------------------------------------#
+    track_indices = np.zeros(ntracks)
+    data_index = 0
+
+    for i in range(itermapshape[0]):
+        part_number,npoints,nstart = itermap[i,:]
+        track_index =  int(track_indices[part_number-1])
+
+
+        ordered_data[part_number-1][track_index : track_index + npoints,0] \
+        = nstart + np.arange(npoints) * niter
+
+        ordered_data[part_number-1][track_index : track_index + npoints,1:] \
+        = data[data_index:data_index + npoints ,:]
+
+        data_index += npoints
+        track_indices[part_number-1] += npoints
+
+	#----------------------------------------#
+
+	# write to file out
+    for i in range(ntracks):
+        group = file_out.create_group(str(i+1))
+        for j in range(nquants):
+            if(j==0):
+                group.create_dataset(quants[j], data=np.array(ordered_data[i][:, j], dtype=int))
+            else:
+                group.create_dataset(quants[j], data=ordered_data[i][:, j])
+
+    file_out.close()
+    file_in.close()
+    print("Track file converted to the old, more readable format: ", filename_out)
+    return filename_out
+
+def create_file_tags(filename, tags_array):
+    '''
+    Function to write a file_tags file from a (number_of_tags, 2) NumPy array of tags.
+    this file is used to choose particles for the OSIRIS track diagnostic.
+
+    Parameters
+    ----------
+    filename : str
+        Path to the output file where tags will be stored.
+    tags_array: np.ndarray
+        shape (number_of_tags, 2), containing particle tags
+    
+    Returns
+    -------
+    file_tags file with path \"filename\" to be used for the OSIRIS track diagnostic.
+    
+    Notes
+    ------
+    The first element of the tag of a particle that is already being tracked is negative,
+        so we apply the absolute function when generating the file
+    
+    '''
+
+    # In case the particles chosen were already being tracked
+    tags_array[:, 0] = np.abs(tags_array[:, 0])
+    tags_array = tags_array[np.lexsort((tags_array[:, 1], tags_array[:, 0]))]
+    num_tags = tags_array.shape[0]
+    
+    with open(filename, 'w') as file:
+        file.write("! particle tag list\n")
+        file.write(f"! generated on {datetime.now().strftime('%a %b %d %H:%M:%S %Y')}\n")
+        file.write("! number of tags\n")
+        file.write(f"       {num_tags}\n")
+        file.write("! particle tag list\n")
+        
+        for i in range(num_tags):
+            file.write(f"         {tags_array[i, 0]:<6}{tags_array[i, 1]:>6}\n")
+    return filename

{osiris_utils-1.1.4.dist-info → osiris_utils-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osiris_utils
-Version: 1.1.4
+Version: 1.1.6
 Summary: Utilities to manipulate and visualize OSIRIS framework output data
 Author: ['João Pedro Ferreira Biu', 'João Cândido', 'Diogo Carvalho']
 Author-email: ['joaopedrofbiu@tecnico.ulisboa.pt']

osiris_utils-1.1.6.dist-info/RECORD

@@ -0,0 +1,25 @@
+osiris_utils/__init__.py,sha256=vnmri235UkoAxKZMf9111dMb94a4z05XAkszbGSyKgo,1191
+osiris_utils/utils.py,sha256=zg-5pOVOieVHXYeNWtCq921Q4PmXVArLInJMd8JURpY,8137
+osiris_utils/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osiris_utils/data/data.py,sha256=u-0qcPXyTK187j8kGHNgTBgJKX90_YA8jUYno87q9n0,25619
+osiris_utils/data/diagnostic.py,sha256=d9xfTTMFq4p5kVirw94Leq2Jak_gGMjw6PHG2PmRUtE,49179
+osiris_utils/data/simulation.py,sha256=bvJ6UHIzUNUWlWqZbeg60i-Dscl7x6MRZXGfsy8xkWE,6878
+osiris_utils/decks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osiris_utils/decks/decks.py,sha256=Ug1_fSfZL9iJwn7dnTvHM0k1Zc4kGpI427QvO0V2pwg,10173
+osiris_utils/decks/species.py,sha256=uZA1oMSltofc2m1s3rK__wjxXfTAQ_3wB2aKRG_PmKo,1066
+osiris_utils/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osiris_utils/gui/gui.py,sha256=s4not0GzHI3CrA4uQVnjt9jFavkVAeGbQ6rJpM4jir4,10538
+osiris_utils/postprocessing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osiris_utils/postprocessing/derivative.py,sha256=p1jhy0Ey8w-AYLVBVGgjpYw19cmLPYV_gdRMHtNSR7w,9602
+osiris_utils/postprocessing/fft.py,sha256=Hif7nQN9RcnpnD_MKxvK5K6DgmINSjgmgYcktIrKdo8,9037
+osiris_utils/postprocessing/field_centering.py,sha256=1i6Fue9PhuED2VxBUq1ggHO3MTSlXjhkFvqh1pb_-Y0,6788
+osiris_utils/postprocessing/heatflux_correction.py,sha256=5_XaDGdB5xP8gDJF9MVIlHN5tggbYHWBgetQvEmAnKQ,7055
+osiris_utils/postprocessing/mft.py,sha256=Ryx0DW8Mb7f0ikf2HfM_T_m2WqrCgcEkMJNZBLZ5qAY,12399
+osiris_utils/postprocessing/mft_for_gridfile.py,sha256=ZaLgwsND9nbD-v-JfCZYxh7-dz3RA-IILwBjZnZGCiE,1522
+osiris_utils/postprocessing/postprocess.py,sha256=f2ZXLnAvLpsLFd-Pygb_sYxwkU4zn1OoF_byVKYAPII,1115
+osiris_utils/postprocessing/pressure_correction.py,sha256=9ZK6BTaGAa8W1ltpXsQf6aTH-xfYJ38076gJToxUFgQ,6345
+osiris_utils-1.1.6.dist-info/licenses/LICENSE.txt,sha256=Cawy2v7wKc7n8yL8guFu-cH9sQw9r1gll1pEFPFAB-Q,1084
+osiris_utils-1.1.6.dist-info/METADATA,sha256=hLLfQtRh4ZEoqt8-LlDHiRg7hU6dWyx65guAXVDu6Fc,3070
+osiris_utils-1.1.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+osiris_utils-1.1.6.dist-info/top_level.txt,sha256=mM-_dX5fjzIKB7te655PhZOrPACVY-bJmiASCqW1eOA,13
+osiris_utils-1.1.6.dist-info/RECORD,,