pyregen 0.1.0__py3-none-any.whl

pyregen/__init__.py

@@ -0,0 +1,3 @@
+from .core import Regenerator, RegenState, RegenSolver, RegenError
+
+__version__ = "0.1.0"

pyregen/core.py

@@ -0,0 +1,903 @@
+import numpy as np
+import CoolProp.CoolProp as CP
+import scipy.integrate as integrate
+import scipy.linalg as la
+
+class RegenError(Exception):
+    "Custom Exception for if this library screws up"
+    pass
+
+def helium_properties(Pressure: float | np.ndarray,
+                      Temperature: float | np.ndarray,
+                      Hydraulic_Diameter: float | np.ndarray,
+                      Ideal_Gas: bool = False,
+                      Isotope: int = 4) -> dict:
+    """
+    Pressure (Pa)
+    Temperature (K)
+    Hydraulic Diameter (m)
+    """
+    
+    if Isotope not in (3, 4):
+        raise ValueError(f"Isotope must be 3 or 4. Got {Isotope}")
+    
+    if np.any(Temperature <= 0):
+        raise ValueError(f"Temperature ({Temperature} K) cannot be negative.")
+    
+    fluid = 'Helium' if Isotope == 4 else 'Helium3'
+    
+    if Ideal_Gas:
+        if Isotope == 3:
+            Gas_Constant = 2756.6313
+            Cp = 6891.3715
+            Cv = 4134.7402
+        else:
+            Gas_Constant = 2077.1499
+            Cp = 5192.7190
+            Cv = 3115.5691
+        
+        Density = Pressure / (Gas_Constant * Temperature)
+        Internal_Energy = Cv * Temperature
+        Enthalpy = Cp * Temperature
+        
+        Cp = np.full_like(Temperature, Cp) if isinstance(Temperature, np.ndarray) else Cp
+        
+        Viscosity = CP.PropsSI('V', 'T', Temperature, 'P', Pressure, fluid)
+        Thermal_Conductivity = (Viscosity * Cp) / 0.67 
+        
+    else:
+        Density = CP.PropsSI('D', 'T', Temperature, 'P', Pressure, fluid)
+        Internal_Energy = CP.PropsSI('U', 'T', Temperature, 'P', Pressure, fluid)
+        Enthalpy = CP.PropsSI('H', 'T', Temperature, 'P', Pressure, fluid)
+        Cp = CP.PropsSI('C', 'T', Temperature, 'P', Pressure, fluid)
+        Viscosity = CP.PropsSI('V', 'T', Temperature, 'P', Pressure, fluid)
+        Thermal_Conductivity = CP.PropsSI('L', 'T', Temperature, 'P', Pressure, fluid)
+    
+    Heat_Transfer_Base = (Viscosity * Cp * (Thermal_Conductivity)**2)**(1/3) / Hydraulic_Diameter
+    Friction_Base = (2.0 * Viscosity**2) / (Hydraulic_Diameter**3 * Density)
+    
+    return {'Density': Density, # kg/m3
+            'Internal Energy': Internal_Energy, #J/kg
+            'Enthalpy': Enthalpy, #J/kg
+            'Cp': Cp, #J/KgK
+            'Viscosity': Viscosity, #kg/ms
+            'Thermal Conductivity': Thermal_Conductivity, # W/mK
+            'Heat Transfer Base': Heat_Transfer_Base, # W/m2K
+            'Friction Base': Friction_Base # Pa/m
+            }
+
+def material_properties(Material_Name: str,
+                        Temperature: float | np.ndarray,
+                        Cp_Factor: float = 1.0,
+                        Conductivity_Factor:float = 1.0) -> dict:
+    
+    '''
+    Temperature (K)
+    '''
+    
+    if np.any(Temperature <= 0):
+        raise ValueError(f'Temperature ({Temperature} K) cannot be negative.')
+    
+    Temperature = np.asarray(Temperature)
+    
+    match Material_Name.strip().lower():
+        case 'stainless steel' | 'ss':
+            Temperature_samples = [0.0, 3.0, 4.0, 6.0, 8.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40.0, 50.0, 60.0, 80.0, 100.0, 150.0, 200.0, 1000.0]
+            Cp_samples = [0.0, 0.0117, 0.0151, 0.0221, 0.0311, 0.0411, 0.067, 0.104, 0.160, 0.226, 0.442, 0.759, 1.11, 1.710, 2.09, 2.91, 3.29, 7.05]
+            Conductivity_Samples = [0.0, 0.00182, 0.00270, 0.00475, 0.00675, 0.00895, 0.0152, 0.0216, 0.0273, 0.0340, 0.0457, 0.0565, 0.0665, 0.081, 0.090, 0.108, 0.123, 0.315]
+
+            Raw_Volumetric_Heating_Capacity = np.interp(Temperature, Temperature_samples, Cp_samples)
+            Raw_Thermal_Conductivity = np.interp(Temperature, Temperature_samples, Conductivity_Samples)
+        case 'lead' | 'pb':
+            Temperature_samples =  [0.0, 3.0, 4.0, 6.0, 8.0, 10.0, 15.0, 20.0, 25.0, 30.0, 40.0, 50.0, 60.0, 80.0, 100.0, 150.0, 200.0, 1000.0]
+            Cp_samples = [0.0, 0.0035, 0.0079, 0.0340, 0.0828, 0.155, 0.380, 0.602, 0.772, 0.903, 1.070, 1.168, 1.224, 1.293, 1.338, 1.383, 1.418, 1.834]
+            Conductivity_Samples =  [0.0, 0.020, 0.028, 0.045, 0.061, 0.074, 0.104, 0.122, 0.140, 0.155, 0.176, 0.188, 0.204, 0.222, 0.230, 0.256, 0.270, 0.414]
+            
+            Raw_Volumetric_Heating_Capacity = np.interp(Temperature, Temperature_samples, Cp_samples)
+            Raw_Thermal_Conductivity = np.interp(Temperature, Temperature_samples, Conductivity_Samples)
+        case 'er3-ni' | 'er3ni':
+            
+            sample_conditions = [
+                Temperature > 30.0,
+                Temperature > 20.0,
+                Temperature > 7.136,
+                Temperature > 4.0,
+                Temperature <= 4.0
+            ]
+            
+            Cp_samples = [
+                1.5792 - 23.1297 / Temperature,
+                0.04257 + 0.02552 * Temperature,
+                1.0832 - 0.1667 * Temperature + 0.01117 * Temperature**2 - 0.0002082 * Temperature**3,
+                -0.225 + 0.08574 * Temperature,
+                10 ** (2.5 * np.log10(Temperature) - 2.436)
+            ]
+            
+            Raw_Volumetric_Heating_Capacity = np.select(sample_conditions, Cp_samples)
+
+            sample_conditions_conductivity = [Temperature > 20.7, Temperature <= 20.7]
+            
+            Conductivity_Samples = [
+                0.009246 + 0.001488 * Temperature**0.5 - 1.6426 / Temperature**2,
+                np.exp(-8.079 + 1.2116 * np.log(Temperature))
+            ]
+            
+            Raw_Thermal_Conductivity = np.select(sample_conditions_conductivity, Conductivity_Samples)
+            
+        case _:
+            raise NotImplementedError(f"Material '{Material_Name}' not yet implemented.")
+        
+        
+    Raw_Volumetric_Heating_Capacity *= 1.0e6 
+    Raw_Thermal_Conductivity *= 100.0 
+        
+            
+    return {
+        'Volumetric Heat Capacity': Raw_Volumetric_Heating_Capacity * Cp_Factor, # J/m3K
+        'Thermal Conductivity': Raw_Thermal_Conductivity * Conductivity_Factor # W/mK
+    }
+
+def Flow_Properties(Geometry: str,
+                    Hydraulic_Diameter: float | np.ndarray,
+                    Porosity: float | np.ndarray,
+                    Density: float | np.ndarray,
+                    Viscosity: float | np.ndarray,
+                    Velocity: float | np.ndarray,
+                    Heat_Transfer_Base: float | np.ndarray,
+                    Friction_Base: float | np.ndarray,
+                    Gas_Temperature: float | np.ndarray,
+                    Matrix_Temperature: float | np.ndarray,
+                    Heat_Transfer_Factor: float = 1.0,
+                    Pressure_Gradient_Factor: float = 1.0) -> dict:
+    
+    '''
+    Hydraulic_Diameter (m)
+    Density (kg/m3)
+    Viscosity (kg/ms)
+    Velocity (m/s)
+    Heat_Transfer_Base (W/m2K)
+    Friction_Base (Pa/m)
+    Gas_Temperature (K)
+    '''
+    
+    is_scalar = np.isscalar(Velocity)
+    
+    Porosity = np.atleast_1d(Porosity)
+    Density = np.atleast_1d(Density)
+    Viscosity = np.atleast_1d(Viscosity)
+    Velocity = np.atleast_1d(Velocity)
+    Heat_Transfer_Base = np.atleast_1d(Heat_Transfer_Base)
+    Friction_Base = np.atleast_1d(Friction_Base)
+    Gas_Temperature = np.atleast_1d(Gas_Temperature)
+    Matrix_Temperature = np.atleast_1d(Matrix_Temperature)
+    
+    Reynolds = np.maximum(1e-10, (Hydraulic_Diameter * Density * np.abs(Velocity)) / Viscosity)
+    
+    Geometry_Correleation_Factor = 0.0
+    Friction_Modifier = 0.0
+    Modified_Stanton_Number = 0.0
+    Heat_Transfer_Coefficient = 0.0
+    
+    match Geometry.strip().lower():
+        case 'parallel plates' | '1':
+            Friction_Modifier = 0.33 + 0.09 / (1.0 + np.exp((3500.0 - Reynolds) / 1500.0))
+            
+            laminar_mask = Reynolds <= 2000.0
+            turbulent_mask = ~laminar_mask
+            
+            Heat_Transfer_Coefficient = np.zeros_like(Reynolds)
+            Modified_Stanton_Number = np.zeros_like(Reynolds)
+            
+            Heat_Transfer_Coefficient[laminar_mask] = Heat_Transfer_Base[laminar_mask]* 8.5
+            Modified_Stanton_Number[laminar_mask] = 8.5 * Reynolds[laminar_mask]
+            
+            Heat_Transfer_Coefficient[turbulent_mask] = Heat_Transfer_Base[turbulent_mask] * (3.4e-3 * Reynolds[turbulent_mask] + 2.72e13*Reynolds[turbulent_mask]**-4)
+            Modified_Stanton_Number[turbulent_mask] = (3.4e-3 * Reynolds[turbulent_mask]**2 + 2.72e13 * Reynolds[turbulent_mask]**-3)
+            
+        case 'tubes' | '2':
+            Friction_Modifier = 0.27 + 0.16 / (1.0 + np.exp((5500.0 - Reynolds) / 2000.0))            
+
+            laminar_mask = Reynolds <= 2000.0
+            turbulent_mask = ~laminar_mask
+            
+            Heat_Transfer_Coefficient = np.zeros_like(Reynolds)
+            Modified_Stanton_Number = np.zeros_like(Reynolds)
+            
+            Heat_Transfer_Coefficient[laminar_mask] = Heat_Transfer_Base[laminar_mask]* 4.2
+            Modified_Stanton_Number[laminar_mask] = 4.2 * Reynolds[laminar_mask]
+            
+            Heat_Transfer_Coefficient[turbulent_mask] = Heat_Transfer_Base[turbulent_mask] * (1.68e-3 * Reynolds[turbulent_mask] + 1.344e13*Reynolds[turbulent_mask]**-4)
+            Modified_Stanton_Number[turbulent_mask] = (1.68e-3 * Reynolds[turbulent_mask]**2 + 1.344e13 * Reynolds[turbulent_mask]**-3)
+            
+        case 'screens' | '4':
+            Geometry_Correleation_Factor = 0.715 * (5.6 + Porosity * (-16.363 + 13.928 * Porosity))
+            Friction_Modifier = np.zeros_like(Reynolds)
+            Friction_Modifier[Reynolds < 10.0] = 0.0074 * Reynolds[Reynolds < 10.0]
+
+            mask_mid = (Reynolds >= 10.0) & (Reynolds < 3000.0)
+            friction_mid = np.log(Reynolds[mask_mid] / 200.0)
+            Friction_Modifier[mask_mid] = 0.129 - 0.0058 * friction_mid**2
+            
+            mask_high = Reynolds >= 3000.0
+            friction_high = np.log(Reynolds[mask_high] / 200.0)
+            Friction_Modifier[mask_high] = 0.1498 - 0.0239 * friction_high
+            
+            heat_transfer_alpha = 0.04
+            heat_transfer_gamma = 2.0
+            beta = 0.43
+            alpha = 1.0 - beta
+            
+            blend = np.exp(-np.minimum(50.0, heat_transfer_alpha*Reynolds**2))
+            expr = np.exp(alpha*np.log(Reynolds))
+            
+            Heat_Transfer_Coefficient = Geometry_Correleation_Factor * Heat_Transfer_Base * (heat_transfer_gamma*blend+(1.0-blend)*expr)
+            Modified_Stanton_Number = Geometry_Correleation_Factor * Reynolds * expr
+        
+        case _:
+            raise NotImplementedError(f"Geometry '{Geometry}' not yet implemented.")
+        
+    Pressure_Gradient = -np.sign(Velocity) * Friction_Base * Modified_Stanton_Number / Friction_Modifier
+    Pressure_Gradient *= Pressure_Gradient_Factor
+    
+    Heat_Transfer_Rate = 4.0 * Heat_Transfer_Factor * Heat_Transfer_Coefficient * (Matrix_Temperature - Gas_Temperature) / Hydraulic_Diameter
+    
+    if is_scalar:
+        Pressure_Gradient = Pressure_Gradient.item()
+        Heat_Transfer_Rate = Heat_Transfer_Rate.item()
+        Reynolds = Reynolds.item()
+            
+    return {
+        'Pressure Gradient': Pressure_Gradient, # Pa/m
+        'Heat Transfer Rate': Heat_Transfer_Rate, # W/m3
+        'Reynolds Number': Reynolds
+    }
+    
+class RegenState:
+    def __init__(self, 
+                 Number_of_Nodes: int, 
+                 Length: float, 
+                 Area: float, 
+                 Porosity: float,
+                 Hydraulic_Diameter: float,
+                 bdy_order: int = 1):
+        
+        '''
+        Length (m)
+        Area (m2)
+        Hydraulic Diameter (m)
+        '''
+        
+        self.bdy_order = bdy_order
+        
+        self.length = Length
+        self.porosity = Porosity
+        self.hydraulic_diameter = Hydraulic_Diameter
+        
+        
+        self.num_nodes = Number_of_Nodes
+        self.num_nodes_mid = Number_of_Nodes - 1
+        
+        self.x_endpoints = np.linspace(0.0, Length, Number_of_Nodes)
+        self.dz = Length / (Number_of_Nodes - 1)
+        
+        self.x_midpoints = np.zeros(Number_of_Nodes + 1)
+        self.x_midpoints[0] = 0.0
+        self.x_midpoints[Number_of_Nodes] = Length
+        self.x_midpoints[1:Number_of_Nodes] = 0.5 * (self.x_endpoints[1:] + self.x_endpoints[:-1])
+        
+        self.dxs = np.zeros(Number_of_Nodes)
+        self.dxs[1:Number_of_Nodes] = self.x_endpoints[1:] - self.x_endpoints[:-1]
+
+        self.area_mid = np.full(Number_of_Nodes + 1, Area)
+        self.porosity_mid = np.full(Number_of_Nodes + 1, Porosity)
+        self.hydra_diam_mid = np.full(Number_of_Nodes + 1, Hydraulic_Diameter)
+        
+        self.porosity_area_mid = self.porosity_mid * self.area_mid
+        self.solid_area_mid = (1.0 - self.porosity_mid) * self.area_mid
+        
+        self.porosity_area_nodes = np.zeros(Number_of_Nodes)
+        self.porosity_area_nodes[1:-1] = 0.5 * (self.porosity_area_mid[1:-2] + self.porosity_area_mid[2:-1])
+        self.porosity_area_nodes[0] = self.porosity_area_mid[0]
+        self.porosity_area_nodes[-1] = self.porosity_area_mid[-1]
+
+        self.mass_flux_nodes = np.zeros((Number_of_Nodes, 3))      
+        self.pressure_nodes = np.zeros((Number_of_Nodes, 3))       
+        self.matrix_temp_mid = np.zeros((Number_of_Nodes + 1, 3))  
+        self.gas_temp_mid = np.zeros((Number_of_Nodes + 1, 3))
+
+        self.gas_density_mid = np.zeros((Number_of_Nodes + 1, 3))
+        self.gas_energy_vol_mid = np.zeros((Number_of_Nodes + 1, 3)) 
+        self.gas_mass_flux_mid = np.zeros((Number_of_Nodes + 1, 3))    
+        self.matrix_enthalpy_mid = np.zeros((Number_of_Nodes + 1, 3))  
+        
+        self.time_rev_hot = 0.0
+        self.time_rev_cold = 0.0
+        self.temp_rev_hot = 0.0
+        self.temp_rev_cold = 0.0
+
+    def get_matrix_enthalpy(self, material_name: str, temp_array: np.ndarray, cp_factor: float = 1.0) -> np.ndarray:
+            if not hasattr(self, '_enthalpy_T_table'):
+                self._enthalpy_T_table = np.logspace(-2, 3, 5000) 
+                cp_array = material_properties(material_name, self._enthalpy_T_table, cp_factor)['Volumetric Heat Capacity']
+                
+                self._enthalpy_H_table = integrate.cumulative_trapezoid(cp_array, self._enthalpy_T_table, initial=0.0)
+                
+            return np.interp(temp_array, self._enthalpy_T_table, self._enthalpy_H_table)
+
+    def extrap_left(self, array_mid: np.ndarray) -> float:
+        if self.bdy_order == 0:
+            return array_mid[1]
+        elif self.bdy_order == 1:
+            return 1.5 * array_mid[1] - 0.5 * array_mid[2]
+        else:
+            return (15.0 * array_mid[1] - 10.0 * array_mid[2] + 3.0 * array_mid[3]) / 8.0
+
+    def extrap_right(self, array_mid: np.ndarray) -> float:
+        n = self.num_nodes
+        if self.bdy_order == 0:
+            return array_mid[n-1]
+        elif self.bdy_order == 1:
+            return 1.5 * array_mid[n-1] - 0.5 * array_mid[n-2]
+        else:
+            return (15.0 * array_mid[n-1] - 10.0 * array_mid[n-2] + 3.0 * array_mid[n-3]) / 8.0
+
+    def derivative_left(self, array_mid: np.ndarray) -> float:
+        if self.bdy_order == 1:
+            return (array_mid[2] - array_mid[1]) / self.dz
+        else:
+            return (-2.0 * array_mid[1] + 3.0 * array_mid[2] - array_mid[3]) / self.dz
+
+    def derivative_right(self, array_mid: np.ndarray) -> float:
+        n = self.num_nodes
+        if self.bdy_order == 1:
+            return (array_mid[n-1] - array_mid[n-2]) / self.dz
+        else:
+            return (2.0 * array_mid[n-1] - 3.0 * array_mid[n-2] + array_mid[n-3]) / self.dz
+        
+
+class RegenSolver:
+    def __init__(self, state, 
+                 Geometry: str, 
+                 Material: str,
+                 Frequency: float,
+                 Mass_Flux_Hot: float,
+                 Mass_Flux_Cold: float,
+                 Mass_Phase_Deg: float,
+                 Gas_Temp_Hot: float,
+                 Gas_Temp_Cold: float,
+                 Decay_Time: float = 0.05,
+                 Use_Advection: bool = True,
+                 Gas_Isotope: int = 4,
+                 Ideal_Gas: bool = False,
+                 Time_Step: float = 0.001,
+                 cp_factor: float = 1.0,
+                 cond_factor: float = 1.0,
+                 eps_newton: float = 1e-6,
+                 max_newton_iters: int = 4,
+                 mflux_dc: float = 0.0
+                 ):
+        
+        self.state = state
+        self.geometry = Geometry
+        self.material = Material
+        self.isotope = Gas_Isotope
+        self.ideal_gas = Ideal_Gas
+        self.dt = Time_Step
+        
+        self.frequency = Frequency
+        self.omega = 2.0 * np.pi * Frequency
+        self.mass_flux_hot = Mass_Flux_Hot
+        self.mass_flux_cold = Mass_Flux_Cold
+        self.mass_phase_rad = np.radians(Mass_Phase_Deg)
+        self.gas_temp_hot = Gas_Temp_Hot
+        self.gas_temp_cold = Gas_Temp_Cold
+        self.decay = Decay_Time
+        self.use_advec = 1.0 if Use_Advection else 0.0
+        
+        self.cp_factor = cp_factor
+        self.cond_factor = cond_factor
+        self.eps_newton = eps_newton
+        self.max_newton_iters = max_newton_iters
+        self.mflux_dc = mflux_dc
+        
+        self.nvars = 4
+        self.neqn = self.nvars * self.state.num_nodes - 2
+        
+    def calculate_residuals(self, 
+                            guess_array: np.ndarray, 
+                            time: float, 
+                            method_order: int = 2) -> np.ndarray:
+        
+        nx = self.state.num_nodes
+        dz = self.state.dz
+        dxs = np.diff(self.state.x_endpoints) 
+        
+        mfxi = guess_array[0::4] 
+        prsi = guess_array[1::4] 
+        mtph = guess_array[2::4] 
+        gtph = guess_array[3::4] 
+        
+        mtph_padded = np.zeros(nx + 1)
+        gtph_padded = np.zeros(nx + 1)
+        mtph_padded[1:nx] = mtph
+        gtph_padded[1:nx] = gtph
+        
+        if mfxi[0] >= 1e-8:
+            decay_factor = np.exp(-(time - self.state.time_rev_hot) * self.frequency / self.decay)
+            gtph_padded[0] = self.gas_temp_hot + (self.state.temp_rev_hot - self.gas_temp_hot) * decay_factor
+        else:
+            gtph_padded[0] = self.state.extrap_left(gtph_padded)
+            
+        if mfxi[-1] <= -1e-8:
+            decay_factor = np.exp(-(time - self.state.time_rev_cold) * self.frequency / self.decay)
+            gtph_padded[nx] = self.gas_temp_cold + (self.state.temp_rev_cold - self.gas_temp_cold) * decay_factor
+        else:
+            gtph_padded[nx] = max(1.0, self.state.extrap_right(gtph_padded))
+            
+        mtph_padded[0] = self.state.extrap_left(mtph_padded)
+        mtph_padded[nx] = max(1.0, self.state.extrap_right(mtph_padded))
+
+        prsi_padded = np.zeros(nx + 1)
+        prsi_padded[1:nx] = 0.5 * (prsi[:-1] + prsi[1:])
+        prsi_padded[0] = prsi[0]
+        prsi_padded[-1] = prsi[-1]
+        
+        gas_props = helium_properties(
+            Pressure=prsi_padded, 
+            Temperature=gtph_padded,
+            Hydraulic_Diameter=self.state.hydra_diam_mid,
+            Ideal_Gas=self.ideal_gas,
+            Isotope=self.isotope
+        )
+        
+        solid_props = material_properties(self.material, mtph_padded, self.cp_factor, self.cond_factor)
+        matrix_enthalpy = self.state.get_matrix_enthalpy(self.material, mtph_padded, self.cp_factor)
+        
+        den_endpoints = np.zeros(nx)
+        den_endpoints[1:-1] = 0.5 * (gas_props['Density'][1:-2] + gas_props['Density'][2:-1])
+        den_endpoints[0] = gas_props['Density'][0]
+        den_endpoints[-1] = gas_props['Density'][-1]
+        
+        vel_endpoints = mfxi / (self.state.porosity_area_nodes * den_endpoints)
+        
+        vel_midpoints_padded = np.zeros(nx + 1)
+        vel_midpoints_padded[1:nx] = 0.5 * (mfxi[:-1] + mfxi[1:]) / (self.state.porosity_area_mid[1:nx] * gas_props['Density'][1:nx])
+        vel_midpoints_padded[0] = mfxi[0] / (self.state.porosity_area_mid[0] * gas_props['Density'][0])
+        vel_midpoints_padded[-1] = mfxi[-1] / (self.state.porosity_area_mid[-1] * gas_props['Density'][-1])
+        
+        flow_props = Flow_Properties(
+            Geometry=self.geometry,
+            Hydraulic_Diameter=self.state.hydra_diam_mid[1:nx],
+            Porosity=self.state.porosity_mid[1:nx],
+            Density=gas_props['Density'][1:nx],
+            Viscosity=gas_props['Viscosity'][1:nx],
+            Velocity=vel_midpoints_padded[1:nx],
+            Heat_Transfer_Base=gas_props['Heat Transfer Base'][1:nx],
+            Friction_Base=gas_props['Friction Base'][1:nx],
+            Gas_Temperature=gtph_padded[1:nx],
+            Matrix_Temperature=mtph_padded[1:nx]
+        )
+        
+        kA_solid = solid_props['Thermal Conductivity'] * self.state.solid_area_mid
+        mcdi = 2.0 * kA_solid[1:-2] * kA_solid[2:-1] / (dxs[1:] * kA_solid[1:-2] + dxs[:-1] * kA_solid[2:-1])
+        hfx_internal = -mcdi * (mtph[1:] - mtph[:-1])
+        hfx_0 = -kA_solid[0] * self.state.derivative_left(mtph_padded)
+        hfx_L = -kA_solid[-1] * self.state.derivative_right(mtph_padded)
+        hfx = np.concatenate(([hfx_0], hfx_internal, [hfx_L]))
+        
+        kA_gas = gas_props['Thermal Conductivity'] * self.state.porosity_area_mid
+        gcdi = 2.0 * kA_gas[1:-2] * kA_gas[2:-1] / (dxs[1:] * kA_gas[1:-2] + dxs[:-1] * kA_gas[2:-1])
+        gfx_internal = -gcdi * (gtph[1:] - gtph[:-1])
+        gfx_0 = -kA_gas[0] * self.state.derivative_left(gtph_padded)
+        gfx_L = -kA_gas[-1] * self.state.derivative_right(gtph_padded)
+        gfx = np.concatenate(([gfx_0], gfx_internal, [gfx_L]))
+        
+        enti = np.zeros(nx)
+        enti[1:-1] = 0.5 * (gas_props['Enthalpy'][1:-2] + gas_props['Enthalpy'][2:-1])
+        enti[0] = gas_props['Enthalpy'][0]
+        enti[-1] = gas_props['Enthalpy'][-1]
+        eng_flux = mfxi * (enti + 0.5 * vel_endpoints**2) + gfx
+
+        gas_energy_vol = gas_props['Density'] * gas_props['Internal Energy'] + 0.5 * gas_props['Density'] * vel_midpoints_padded**2
+
+        if method_order == 1:
+            c3, c2, c1 = 1.0, -1.0, 0.0
+        else:
+            c3, c2, c1 = 1.5, -2.0, 0.5
+            
+        dt_mtp = (c3 * matrix_enthalpy[1:nx] + 
+                  c2 * self.state.matrix_enthalpy_mid[1:nx, 1] + 
+                  c1 * self.state.matrix_enthalpy_mid[1:nx, 0]) / self.dt
+        dt_den = (c3 * gas_props['Density'][1:nx] + c2 * self.state.gas_density_mid[1:nx, 1] + c1 * self.state.gas_density_mid[1:nx, 0]) / self.dt
+        dt_eng = (c3 * gas_energy_vol[1:nx] + c2 * self.state.gas_energy_vol_mid[1:nx, 1] + c1 * self.state.gas_energy_vol_mid[1:nx, 0]) / self.dt
+        
+        mfxh = 0.5 * (mfxi[:-1] + mfxi[1:])
+        dt_adv = (c3 * mfxh + c2 * self.state.gas_mass_flux_mid[1:nx, 1] + c1 * self.state.gas_mass_flux_mid[1:nx, 0]) / self.dt
+        advec = dz * dt_adv + vel_endpoints[1:] * mfxi[1:] - vel_endpoints[:-1] * mfxi[:-1]
+
+        res = np.zeros_like(guess_array)
+        
+        res[0::4][:-1] = self.state.porosity_area_mid[1:nx] * (prsi[1:] - prsi[:-1] - dz * flow_props['Pressure Gradient']) + (advec * self.use_advec)
+        
+        res[3::4] = dz * (self.state.porosity_area_mid[1:nx] * dt_den) + (mfxi[1:] - mfxi[:-1])
+        
+        res[2::4] = dz * (self.state.solid_area_mid[1:nx] * dt_mtp + self.state.porosity_area_mid[1:nx] * flow_props['Heat Transfer Rate']) + (hfx[1:] - hfx[:-1])
+        
+        res[1::4][1:] = dz * (self.state.porosity_area_mid[1:nx] * dt_eng - self.state.porosity_area_mid[1:nx] * flow_props['Heat Transfer Rate']) + (eng_flux[1:] - eng_flux[:-1])
+        
+        res[1::4][0] = mfxi[0] - self.mass_flux_hot * np.sin(self.omega * time) - self.mflux_dc
+        res[0::4][-1] = mfxi[-1] - self.mass_flux_cold * np.sin(self.omega * time + self.mass_phase_rad) - self.mflux_dc
+
+        return res[:self.neqn]
+    
+    def _compute_jacobian_banded(self, guess_array: np.ndarray, time: float, method_order: int) -> tuple[np.ndarray, np.ndarray]:
+        
+        ml = 2 * self.nvars - 1
+        mu = 2 * self.nvars - 1
+        
+        jac_banded = np.zeros((ml + mu + 1, self.neqn))
+        epsjac = 1e-6  
+        
+        f0 = self.calculate_residuals(guess_array, time, method_order)
+        
+        for j in range(self.neqn):
+
+            delta = max(abs(guess_array[j]) * epsjac, epsjac)
+            
+            guess_pert = guess_array.copy()
+            guess_pert[j] += delta
+            
+            f_pert = self.calculate_residuals(guess_pert, time, method_order)
+            df = (f_pert - f0) / delta
+            
+            i_min = max(0, j - mu)
+            i_max = min(self.neqn, j + ml + 1)
+            for i in range(i_min, i_max):
+                row_index = mu + i - j
+                jac_banded[row_index, j] = df[i]
+                
+        return jac_banded, f0
+
+    def advance_timestep(self, time: float, method_order: int = 2) -> bool:
+
+        guess_array = np.zeros(self.neqn)
+        
+        for i in range(self.state.num_nodes):
+            guess_array[0 + i*4] = self.state.mass_flux_nodes[i, 1] + (self.state.mass_flux_nodes[i, 1] - self.state.mass_flux_nodes[i, 0])
+            guess_array[1 + i*4] = self.state.pressure_nodes[i, 1] + (self.state.pressure_nodes[i, 1] - self.state.pressure_nodes[i, 0])
+            
+            if i < self.state.num_nodes - 1:
+                guess_array[2 + i*4] = self.state.matrix_temp_mid[i+1, 1] + (self.state.matrix_temp_mid[i+1, 1] - self.state.matrix_temp_mid[i+1, 0])
+                guess_array[3 + i*4] = self.state.gas_temp_mid[i+1, 1] + (self.state.gas_temp_mid[i+1, 1] - self.state.gas_temp_mid[i+1, 0])
+        
+        guess_array = guess_array[:self.neqn]
+
+        max_iters = self.max_newton_iters
+        eps_newton = self.eps_newton
+        
+        ml = 2 * self.nvars - 1
+        mu = 2 * self.nvars - 1
+
+        for iteration in range(max_iters):
+            
+            jac_banded, res = self._compute_jacobian_banded(guess_array, time, method_order)
+            
+            row_max = np.zeros(self.neqn)
+            for j in range(self.neqn):
+                i_min = max(0, j - mu)
+                i_max = min(self.neqn, j + ml + 1)
+                for i in range(i_min, i_max):
+                    val = abs(jac_banded[mu + i - j, j])
+                    if val > row_max[i]:
+                        row_max[i] = val
+                        
+            row_max[row_max == 0.0] = 1.0
+            res_scaled = res / row_max
+            
+            err = np.sqrt(np.mean(res_scaled**2))
+            if err < eps_newton:
+                break 
+                
+            try:
+                del_w = la.solve_banded((ml, mu), jac_banded, -res)
+            except la.LinAlgError:
+                print(f"Linear algebra error at time {time}. Jacobian is singular.")
+                return False
+            
+            guess_array += del_w
+            
+            res_new = self.calculate_residuals(guess_array, time, method_order)
+            err_new = np.sqrt(np.mean((res_new / row_max)**2))
+            
+            if err_new < eps_newton:
+                break
+                
+        else:
+            print(f"Newton solver failed to converge at time {time}. Error stuck at {err_new:.3e}")
+            return False
+
+        self.state.mass_flux_nodes[:, 0] = self.state.mass_flux_nodes[:, 1]
+        self.state.mass_flux_nodes[:, 1] = self.state.mass_flux_nodes[:, 2]
+        
+        self.state.pressure_nodes[:, 0] = self.state.pressure_nodes[:, 1]
+        self.state.pressure_nodes[:, 1] = self.state.pressure_nodes[:, 2]
+        
+        self.state.matrix_temp_mid[:, 0] = self.state.matrix_temp_mid[:, 1]
+        self.state.matrix_temp_mid[:, 1] = self.state.matrix_temp_mid[:, 2]
+        
+        self.state.gas_temp_mid[:, 0] = self.state.gas_temp_mid[:, 1]
+        self.state.gas_temp_mid[:, 1] = self.state.gas_temp_mid[:, 2]
+        
+        self.state.mass_flux_nodes[:, 2] = guess_array[0::4]
+        self.state.pressure_nodes[:, 2] = guess_array[1::4]
+        
+        mtph = guess_array[2::4]
+        gtph = guess_array[3::4]
+        self.state.matrix_temp_mid[1:self.state.num_nodes, 2] = mtph
+        self.state.gas_temp_mid[1:self.state.num_nodes, 2] = gtph
+        
+        mfxi_old = self.state.mass_flux_nodes[:, 1]
+        mfxi_new = self.state.mass_flux_nodes[:, 2]
+        
+        if (mfxi_old[0] <= 0.0 and mfxi_new[0] > 0.0) or (mfxi_old[0] < 0.0 and mfxi_new[0] >= 0.0):
+            self.state.time_rev_hot = time
+            self.state.temp_rev_hot = self.state.gas_temp_mid[0, 1]
+            
+        if (mfxi_old[-1] >= 0.0 and mfxi_new[-1] < 0.0) or (mfxi_old[-1] > 0.0 and mfxi_new[-1] <= 0.0):
+            self.state.time_rev_cold = time
+            self.state.temp_rev_cold = self.state.gas_temp_mid[-1, 1]
+
+        if mfxi_new[0] >= 1e-8:
+            decay_factor = np.exp(-(time - self.state.time_rev_hot) * self.frequency / self.decay)
+            self.state.gas_temp_mid[0, 2] = self.gas_temp_hot + (self.state.temp_rev_hot - self.gas_temp_hot) * decay_factor
+        else:
+            self.state.gas_temp_mid[0, 2] = self.state.extrap_left(self.state.gas_temp_mid[:, 2])
+            
+        if mfxi_new[-1] <= -1e-8:
+            decay_factor = np.exp(-(time - self.state.time_rev_cold) * self.frequency / self.decay)
+            self.state.gas_temp_mid[-1, 2] = self.gas_temp_cold + (self.state.temp_rev_cold - self.gas_temp_cold) * decay_factor
+        else:
+            self.state.gas_temp_mid[-1, 2] = max(1.0, self.state.extrap_right(self.state.gas_temp_mid[:, 2]))
+            
+        self.state.matrix_temp_mid[0, 2] = self.state.extrap_left(self.state.matrix_temp_mid[:, 2])
+        self.state.matrix_temp_mid[-1, 2] = max(1.0, self.state.extrap_right(self.state.matrix_temp_mid[:, 2]))
+        
+        return True
+    
+class Regenerator:
+
+    def __init__(self, 
+                 gas_temp_cold: float,
+                 gas_temp_hot: float,
+                 herz: float,
+                 hydra_diam: float,
+                 mass_flux_cold: float,
+                 mass_flux_hot: float,
+                 mass_phase: float,
+                 material: str,
+                 porosity: float,
+                 pres_initial: float,
+                 rg_area: float,
+                 rg_length: float,
+                 geometry: str = '1',
+                 mid_temp_ratio: float = 0.5,
+                 num_points_x: int = 21,
+                 num_steps_cyc: int = 80,
+                 ideal_gas: bool = False,
+                 gas_isotope: int = 4,
+                 cp_factor: float = 1.0,         
+                 cond_factor: float = 1.0,       
+                 decay_time: float = 0.05,       
+                 use_advection: bool = True,     
+                 bdy_order: int = 1,             
+                 eps_newton: float = 1e-6,       
+                 max_newton_iters: int = 4,      
+                 mflux_dc: float = 0.0):
+        
+        self._validate_inputs(gas_temp_cold, gas_temp_hot, herz, hydra_diam, porosity, rg_area, rg_length, pres_initial)
+        
+        self.gas_temp_cold = gas_temp_cold
+        self.gas_temp_hot = gas_temp_hot
+        self.herz = herz
+        self.num_steps_cyc = num_steps_cyc
+        self.pres_initial = pres_initial
+        self.mid_temp_ratio = mid_temp_ratio
+        
+        self.dt = 1.0 / (num_steps_cyc * herz)
+        self.time = 0.0
+        self.step_count = 0
+        
+        self.state = RegenState(
+            Number_of_Nodes=num_points_x, 
+            Area=rg_area, 
+            Length=rg_length, 
+            Porosity=porosity,
+            Hydraulic_Diameter=hydra_diam
+        )
+        
+        self.solver = RegenSolver(
+            state=self.state,
+            Geometry=geometry,
+            Material=material,
+            Frequency=herz,
+            Mass_Flux_Hot=mass_flux_hot,
+            Mass_Flux_Cold=mass_flux_cold,
+            Mass_Phase_Deg=mass_phase,
+            Gas_Temp_Hot=gas_temp_hot,
+            Gas_Temp_Cold=gas_temp_cold,
+            Gas_Isotope=gas_isotope,
+            Ideal_Gas=ideal_gas,
+            Time_Step=self.dt,
+            Decay_Time=decay_time,
+            Use_Advection=use_advection,
+            cp_factor=cp_factor,
+            cond_factor=cond_factor,
+            eps_newton=eps_newton,
+            max_newton_iters=max_newton_iters,
+            mflux_dc=mflux_dc
+        )
+        
+        self._initialize_conditions()
+        
+        self.history = {
+            'Time': [],
+            'Cycle': [],
+            'X_Midpoints': self.state.x_midpoints.copy(),
+            'X_Endpoints': self.state.x_endpoints.copy(),
+            'Gas_Temperature': [],
+            'Matrix_Temperature': [],
+            'Pressure': [],
+            'Mass_Flux': []
+        }
+
+    def _validate_inputs(self, tc, th, hz, hd, por, area, length, p_init):
+        if tc <= 0 or th <= 0: raise ValueError("Temperatures must be > 0 K.")
+        if hz <= 0: raise ValueError("Frequency (herz) must be > 0.")
+        if hd <= 0 or area <= 0 or length <= 0: raise ValueError("Dimensions must be > 0.")
+        if por <= 0 or por >= 1: raise ValueError("Porosity must be between 0 and 1.")
+        if p_init <= 0: raise ValueError("Initial pressure must be > 0 Pa.")
+
+    def _initialize_conditions(self):
+        zlen = self.state.length
+        gtplft = self.gas_temp_hot
+        gtprht = self.gas_temp_cold
+        
+        self.state.pressure_nodes[:, :] = self.pres_initial
+        
+        gtpmid = self.mid_temp_ratio * (gtplft - gtprht) + gtprht
+        xh = self.state.x_midpoints
+        parabola_mid = (
+            (0.5 * zlen - xh) * (zlen - xh) * 2.0 * gtplft +
+            xh * (zlen - xh) * 4.0 * gtpmid +
+            xh * (xh - 0.5 * zlen) * 2.0 * gtprht
+        ) / (zlen ** 2)
+
+        gas_props = helium_properties(
+            Pressure=np.full_like(xh, self.pres_initial),
+            Temperature=parabola_mid,
+            Hydraulic_Diameter=self.state.hydra_diam_mid,
+            Ideal_Gas=self.solver.ideal_gas,
+            Isotope=self.solver.isotope
+        )
+        matrix_enthalpy = self.state.get_matrix_enthalpy(self.solver.material, parabola_mid)
+        gas_energy_vol = gas_props['Density'] * gas_props['Internal Energy']
+
+        for level in range(3):
+            self.state.gas_temp_mid[:, level] = parabola_mid
+            self.state.matrix_temp_mid[:, level] = parabola_mid
+            
+            self.state.gas_density_mid[:, level] = gas_props['Density']
+            self.state.gas_energy_vol_mid[:, level] = gas_energy_vol
+            self.state.matrix_enthalpy_mid[:, level] = matrix_enthalpy
+            self.state.gas_mass_flux_mid[:, level] = 0.0
+            self.state.mass_flux_nodes[:, level] = 0.0
+
+    def advance(self) -> dict:
+
+        order = 1 if self.step_count < 2 else 2
+        
+        success = self.solver.advance_timestep(self.time + self.dt, method_order=order)
+        
+        if not success:
+            raise RegenError(f"Simulation failed to converge at Step {self.step_count + 1} (Time: {self.time + self.dt:.5f} s).")
+            
+        self.time += self.dt
+        self.step_count += 1
+        current_cycle = self.time * self.herz
+        
+        current_data = {
+            'Time': self.time,
+            'Cycle': current_cycle,
+            'Gas_Temperature': self.state.gas_temp_mid[:, 2].copy(),
+            'Matrix_Temperature': self.state.matrix_temp_mid[:, 2].copy(),
+            'Pressure': self.state.pressure_nodes[:, 2].copy(),
+            'Mass_Flux': self.state.mass_flux_nodes[:, 2].copy()
+        }
+        
+        self.history['Time'].append(current_data['Time'])
+        self.history['Cycle'].append(current_data['Cycle'])
+        self.history['Gas_Temperature'].append(current_data['Gas_Temperature'])
+        self.history['Matrix_Temperature'].append(current_data['Matrix_Temperature'])
+        self.history['Pressure'].append(current_data['Pressure'])
+        self.history['Mass_Flux'].append(current_data['Mass_Flux'])
+        
+        return current_data
+
+    def results(self) -> dict:
+        return {
+            'Time': np.array(self.history['Time']),
+            'Cycle': np.array(self.history['Cycle']),
+            'X_Midpoints': self.history['X_Midpoints'],
+            'X_Endpoints': self.history['X_Endpoints'],
+            'Gas_Temperature': np.array(self.history['Gas_Temperature']),
+            'Matrix_Temperature': np.array(self.history['Matrix_Temperature']),
+            'Pressure': np.array(self.history['Pressure']),
+            'Mass_Flux': np.array(self.history['Mass_Flux']),
+        }
+
+    def save_to_csv(self, filename: str = "regen_output_data.csv"):
+        import csv
+        
+        if len(self.history['Time']) == 0:
+            print("No data to save yet!")
+            return
+            
+        with open(filename, 'w', newline='') as f:
+            writer = csv.writer(f)
+            
+            for i in range(len(self.history['Time'])):
+                cycle_num = self.history['Cycle'][i]
+                writer.writerow([f"GAS & MATRIX TEMP AT CYCLE= {cycle_num:.3f}"])
+                writer.writerow(["X", "TGAS-a", "TMAT-b"])
+                
+                x_mid = self.history['X_Midpoints']
+                tgas = self.history['Gas_Temperature'][i]
+                tmat = self.history['Matrix_Temperature'][i]
+                
+                for x, tg, tm in zip(x_mid, tgas, tmat):
+                    writer.writerow([f"{x:.5E}", f"{tg:.5E}", f"{tm:.5E}"])
+                writer.writerow([])
+                
+        print(f"Data successfully exported to {filename}")
+
+
+if __name__ == "__main__":
+    
+    my_regen = Regenerator(
+        gas_temp_cold=80.0,
+        gas_temp_hot=330.0,
+        herz=13.0,
+        hydra_diam=4.14e-5,
+        mass_flux_cold=4.32e-3,
+        mass_flux_hot=4.32e-3,
+        mass_phase=30.0,
+        material='stainless steel',
+        porosity=0.62,
+        pres_initial=1.75e6,
+        rg_area=7.92e-4,
+        rg_length=0.11,
+        geometry='screens',
+        num_points_x=21,
+        num_steps_cyc=80
+    )
+    
+    cold_end_mass_fluxes = []
+    
+    target_cycles = 10
+    total_steps = target_cycles * my_regen.num_steps_cyc
+    
+    print(f"Starting Engine: Running {total_steps} steps...")
+    
+    for step in range(total_steps):
+        
+        current_data = my_regen.advance()
+        
+        cold_end_mass_fluxes.append(current_data['Mass_Flux'][-1])
+        
+        if (step + 1) % my_regen.num_steps_cyc == 0:
+            print(f"Cycle {current_data['Cycle']:.1f} completed.")
+            
+    full_history = my_regen.results()
+    print(f"\nFinal Gas Temp at cold end: {full_history['Gas_Temperature'][-1, -1]:.2f} K")
+    
+    my_regen.save_to_csv("my_custom_run.csv")

pyregen-0.1.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: pyregen
+Version: 0.1.0
+Summary: A Python port of the NIST REGEN3.3 cryogenic regenerator model.
+Author-email: Kishorekumar S <kishoresathishkumar@gmail.com>
+Project-URL: Homepage, https://github.com/Kiesh628/pyRegen
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: CoolProp>=6.4.1
+
+# pyregen
+
+**pyregen** is a Python-based port of NIST **REGEN3.3** cryogenic regenerator model. 
+
+It evaluates the fluid dynamics and heat transfer of oscillating helium flow through porous media at cryogenic temperatures. By replacing Fortran structures with a Object-Oriented Python architecture, `pyregen` acts as a fast, flexible engine.
+
+
+## Installation
+
+pip install pyregen
+
+## Quick Start
+
+`pyregen` is designed to act as a state-machine engine. You initialize the regenerator with your physical parameters, and then drive it forward in a loop.
+
+```python
+from pyregen import Regenerator
+
+my_regen = Regenerator(
+    gas_temp_cold=80.0,           # Cold end temperature (K)
+    gas_temp_hot=300.0,           # Hot end temperature (K)
+    herz=60.0,                    # Operating frequency (Hz)
+    hydra_diam=50e-6,             # Hydraulic diameter (m)
+    mass_flux_cold=0.01,          # Mass flux at cold end (kg/s)
+    mass_flux_hot=0.01,           # Mass flux at hot end (kg/s)
+    mass_phase=30.0,              # Phase shift (degrees)
+    material='stainless steel',   # Matrix material
+    porosity=0.68,                # Matrix porosity
+    pres_initial=2.5e6,           # Average pressure (Pa)
+    rg_area=0.002,                # Cross-sectional area (m^2)
+    rg_length=0.05,               # Regenerator length (m)
+    geometry='screens',           # Matrix geometry
+    num_points_x=21,              # Number of spatial nodes
+    num_steps_cyc=80              # Number of time steps per cycle
+)
+
+target_cycles = 10
+total_steps = target_cycles * my_regen.num_steps_cyc
+
+print(f"Starting Engine: Running {total_steps} steps...")
+
+for step in range(total_steps):
+    
+    current_data = my_regen.advance()
+    
+    if (step + 1) % my_regen.num_steps_cyc == 0:
+        print(f"Cycle {current_data['Cycle']:.1f} completed.")
+
+full_history = my_regen.results()
+final_gas_temp = full_history['Gas_Temperature'][-1, -1]
+print(f"\nFinal Gas Temp at the cold boundary: {final_gas_temp:.2f} K")
+
+my_regen.save_to_csv("my_simulation_run.csv")
+```
+
+## Supported Materials & Geometries
+
+**Materials:**
+* `stainless steel` (or `ss`)
+* `lead` (or `pb`)
+* `er3-ni` (or `er3ni`)
+* *(More materials can be easily added via the `material_properties` function)*
+
+**Geometries:**
+* `parallel plates` (or `1`)
+* `tubes` (or `2`)
+* `screens` (or `4`)
+
+## License
+
+This project is licensed under the MIT License.

pyregen-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+pyregen/__init__.py,sha256=QH-q4iNeWwwmuhUsGkzknwZZgF8GT5D8fgpIEffjr-A,91
+pyregen/core.py,sha256=ks19J2-scLamfQYmU3VSIKhdfznYXRUmjYPWc6oA9ro,39644
+pyregen-0.1.0.dist-info/METADATA,sha256=zLfxkMvL6qXBSvd3FXVW1OxggXUOvCxbTMK89ryAvNg,3092
+pyregen-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyregen-0.1.0.dist-info/top_level.txt,sha256=TnnoHlmvSZP8pKi38oS-BLtho41Sqp0fsfmB02N7MYY,8
+pyregen-0.1.0.dist-info/RECORD,,

pyregen-0.1.0.dist-info/WHEEL

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

pyregen-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyregen