turbo-design 1.3.8__py3-none-any.whl → 1.3.10__py3-none-any.whl

turbo_design-1.3.8.dist-info/RECORD

@@ -1,33 +0,0 @@
-turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
-turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
-turbodesign/bladerow.py,sha256=Uad3UUnaRqCaEQBV1mHD04eU_lkz-BWr4n1vjFsX-eA,25472
-turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
-turbodesign/compressorspool.py,sha256=z8ZVczJ-EdZvIqqZArC6UdwC5MbU2SZh_MT2CGq5avY,2600
-turbodesign/coolant.py,sha256=evDtUFOYhfZKTVAsDWzxRzUX20gTvfjj0uybaWg4CsI,427
-turbodesign/enums.py,sha256=WC6VPmHw3UF1zR1SLjj8z00gIWSNso66MShFGoYRY4U,1164
-turbodesign/inlet.py,sha256=5uja906IA-_gca4FJykZvFLJ1he6HRy5pZDNQE1D2_g,7945
-turbodesign/isentropic.py,sha256=YLTmNx69e_M5fTuLOmk_KvaQ6ABv0aZsityfBihJOmI,2003
-turbodesign/loss/__init__.py,sha256=jltNIIbUntGKq2IfX3EKUNEajIcHdOB7pWuj5tLtmGw,66
-turbodesign/loss/compressor/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-turbodesign/loss/losstype.py,sha256=ViUf1ue3DZ3qFAhLUP3ps2fyygNH6udekAr53vEzrY8,1776
-turbodesign/loss/turbine/TD2.py,sha256=evyTG4K6s56NGdjxrZFD3G7zsB8_2lJTBOxT3Ju2uG8,5207
-turbodesign/loss/turbine/__init__.py,sha256=d1UrbiIicO60FhDlOemo_irYW2asUaYoqlXUz-UG9zk,285
-turbodesign/loss/turbine/ainleymathieson.py,sha256=uTl1wXcJZmNjeerGTYDYCs0vJhyMPjG_0C9xlvSKYqY,5911
-turbodesign/loss/turbine/craigcox.py,sha256=2dydHVvxTKhmJsRHO7Vf2JFKM6xaUSeT_CPxf8PCtWs,9942
-turbodesign/loss/turbine/fixedefficiency.py,sha256=JJv4GUS5q9pvuf3akjBtlcHOykRYmRVFfDDrdWqH6S4,774
-turbodesign/loss/turbine/fixedpressureloss.py,sha256=sgkm6uQwz6Qz2LDCEmir46aJRSPLAdCKpDyR1hNdgQ8,682
-turbodesign/loss/turbine/kackerokapuu.py,sha256=TQkTKG6ZdpsdEp1-qJfacQR8EEZSQ1qjUmOTf3t7mws,7263
-turbodesign/loss/turbine/traupel.py,sha256=8KDjalPgBW3GoZUL7jgsyPFoDwNfcQhzmeRNrsZA0XA,4369
-turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
-turbodesign/outlet.py,sha256=MaZJ-mDuLvh19AashnMQLx2XlR-Rk1r0HQS4kE0OxeI,2191
-turbodesign/passage.py,sha256=RZ8giKMcpJI7EnO4SEnbGYcPFmKdGyzWC0UZTXHnS6g,12181
-turbodesign/radeq.py,sha256=LEqYxZZocCZyVPhY09MNFTnAkEXM740-SR6QxXW8Ssg,6522
-turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
-turbodesign/solve_radeq.py,sha256=nLYlRtXElPgHaoUP9jwMulRmYKTJs_uQ1eCulk2V59I,1938
-turbodesign/spool.py,sha256=81UFbBi5JKm0RJ_hjB40bKWeCXx0V2lt0b2VAwOtTDU,14376
-turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
-turbodesign/td_math.py,sha256=aL5lbRl7nB8hQA6HyyFTtNpAbJ1ybn1s8iybXIfqiO8,17549
-turbodesign/turbinespool.py,sha256=REA5QmpRE58o-3cf4dtVS1ChCoriCcQmzCOssv9CYvc,25259
-turbo_design-1.3.8.dist-info/METADATA,sha256=9XmBcAOWQZPo5yR2zQVkL-rVxLK8YKjkOQI-CGtaFjU,785
-turbo_design-1.3.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-turbo_design-1.3.8.dist-info/RECORD,,

turbodesign/compressorspool.py

@@ -1,60 +0,0 @@
-from typing import List
-from cantera import composite
-from cantera.composite import Solution
-from .bladerow import BladeRow,RowType
-from .spool import Spool
-import json
-
-class CompressorSpool(Spool):
-    def __init__(self,rhub:List[float],xhub:List[float],
-                 rshroud:List[float],xshroud:List[float],
-                 massflow:float,rows=List[BladeRow],
-                 num_streamlines:int=3,
-                 fluid:Solution=Solution('air.yaml'),rpm:float=-1):
-        """Initializes a Compressor Spool
-
-        Args:
-            rhub (List[float]): hub radius. Units meters
-            xhub (List[float]): x location of each hub radius station. Units meters
-            rshroud (List[float]): shroud radius. Units meters
-            xshroud (List[float]): x location of each shroud radius. Units meters
-            massflow (float): massflow at spool inlet 
-            rows (List[BladeRow], optional): List of blade rows. Defaults to List[BladeRow].
-            num_streamlines (int, optional): number of streamlines. Defaults to 3.
-            gas (ct.Solution, optional): cantera gas solution. Defaults to ct.Solution('air.yaml').
-            rpm (float, optional): RPM for the entire spool Optional, you can also set rpm of the blade rows individually. Defaults to -1.
-            power_target (float, optional): Sets a target power in kW
-        """
-        super().__init__(rhub, xhub, rshroud, xshroud, massflow, rows,num_streamlines, fluid, rpm)
-        
-        pass
-    
-    def export_properties(self,filename:str="compressor_spool.json"):
-        """Export the spool object to json 
-
-        Args:
-            filename (str, optional): name of export file. Defaults to "spool.json".
-        """
-        blade_rows = list()
-        total_total_efficiency = list() 
-
-        for indx,row in enumerate(self.blade_rows):
-            blade_rows.append(row.to_dict()) # Appending data 
-            if row.row_type == RowType.Stator:
-                pass
-        
-        data = {            
-            "blade_rows": blade_rows,
-            "massflow":self.massflow,
-            "rpm":self.rpm,
-            "r_streamline":self.r_streamline.tolist(),
-            "x_streamline":self.x_streamline.tolist(),
-            "rhub":self.rhub.tolist(),
-            "rshroud":self.rshroud.tolist(),
-            "xhub":self.xhub.tolist(),
-            "xshroud":self.xshroud.tolist(),
-            "num_streamlines":self.num_streamlines,
-        }
-        # Dump all the Python objects into a single JSON file.
-        with open(filename, "w") as f:
-            json.dump(data, f, indent=4)

turbodesign/loss/turbine/fixedpressureloss.py

@@ -1,25 +0,0 @@
-from ...bladerow import BladeRow
-from ..losstype import LossBaseClass
-from ...enums import LossType
-
-class FixedPressureLoss(LossBaseClass):
-    pressure_loss:float
-    
-    def __init__(self,pressure_loss:float):
-        """Fixed Pressure Loss
-        """
-        super().__init__(LossType.Pressure)
-        self.pressure_loss = pressure_loss
-    
-    
-    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
-        """Outputs the fixed Pressure Loss
-        
-        Args:
-            upstream (BladeRow): Upstream blade row
-            row (BladeRow): downstream blade row
-
-        Returns:
-            float: Pressure Loss
-        """
-        return self.pressure_loss

turbodesign/rotor.py

@@ -1,38 +0,0 @@
-from dataclasses import dataclass, field
-from .enums import RowType
-from .bladerow import BladeRow
-from .arrayfuncs import convert_to_ndarray
-import numpy as np 
-
-class Rotor(BladeRow):
-    """Station defined at rotor exit
-
-    Inherits:
-        (BladeRow): Defines the properties of the blade row
-    """
-
-    beta2:np.ndarray = field(default_factory=lambda: np.array([72]))    # Degrees   
-    M_rel:np.ndarray = field(default_factory=lambda: np.array([1.2]))   # Relative mach number
-    power:float = 0         # Watts
-
-    def __init__(self,power:float=50000):
-        """Initialize the Rotor
-
-        Args:
-            coolant_P0 (float, optional): Coolant massflow used to cool the rotor internal cooling, tip leakage, hub disk leakage. Defaults to 0.
-            coolant_T0 (float, optional): _description_. Defaults to 500.
-            power (float, optional): _description_. Defaults to 50000.
-        """
-        self.row_type = RowType.RotorExit
-        self.power = power
-        super().__init__(self)
-
-    def initialize_rotor_exit(self,beta:float,M_exit:float):
-        """Uses the beta and exit mach number to predict a value for Vm
-
-        Args:
-            beta (float): exit relative flow angle
-            M_exit (float): exit relative mach number
-        """
-        self.beta2 = convert_to_ndarray(beta)
-        self.M_rel = convert_to_ndarray(M_exit)

turbodesign/spool.py

@@ -1,317 +0,0 @@
-# type: ignore[arg-type, reportUnknownArgumentType]
-from dataclasses import field
-import json
-from typing import Dict, List, Union, Optional
-import matplotlib.pyplot as plt
-from .bladerow import BladeRow
-import numpy as np
-import numpy.typing as npt
-from .enums import RowType, MassflowConstraint
-from cantera.composite import Solution
-from .loss.turbine import TD2
-from pyturbo.helper import line2D
-from scipy.interpolate import interp1d
-from .passage import Passage
-from .inlet import Inlet
-from .outlet import Outlet 
-
-class Spool:
-    blade_rows:List[BladeRow]=[]
-    massflow:float=0
-    rpm:float = 0
-    
-    passage:Passage
-    t_streamline: npt.NDArray = field(default_factory=lambda: np.zeros((10,)))
-    num_streamlines:int=0
-    
-    # Fluid entering the spool
-    _fluid: Solution = Solution("air.yaml")
-
-    massflow_constraint: MassflowConstraint
-    _adjust_streamlines:bool = True
-    
-    # Inlet Conditions 
-    def __init__(self,passage:Passage,
-                 massflow:float,rows:List[BladeRow],
-                 num_streamlines:int=3,
-                 fluid:Solution=None,
-                 rpm:float=-1,
-                 massflow_constraint:MassflowConstraint=MassflowConstraint.MatchMassFlow):
-        """Initializes a Spool
-
-
-        Note:
-            When it comes to massflow, the exit angle of the blade rows along with the upstream total pressure is used to set the massflow through the spool. If turning is too high then massflow is limited and cannot. 
-            This code gives you the option of setting a massflow and varying the exit angles to match that particular massflow. (MatchMassflow)
-            Or keeping the exit angle and modifying the inlet condition to set a specific massflow through the stage. (BalanceMassflow)
-            
-        Args:
-            passage (Passage): Passage defining hub and shroud
-            massflow (float): massflow at spool inlet 
-            rows (List[BladeRow], optional): List of blade rows. Defaults to List[BladeRow].
-            num_streamlines (int, optional): number of streamlines. Defaults to 3.
-            fluid (ct.Solution, optional): cantera gas solution. Defaults to None, fluid is set by bladerow cp
-            rpm (float, optional): RPM for the entire spool Optional, you can also set rpm of the blade rows individually. Defaults to -1.
-            massflow_constraint (MassflowConstraint, optional): MatchMassflow - Matches the massflow defined in the spool. BalanceMassflow - Balances the massflow between BladeRows, matches the lowest massflow.
-        """
-        self.passage = passage
-        self.fluid = fluid
-        self.massflow = massflow
-        self.num_streamlines = num_streamlines
-        self.blade_rows = rows
-        self.massflow_constraint = massflow_constraint
-        
-        self.rpm = rpm
-        
-        for i in range(len(self.blade_rows)):
-            '''Defining RPM in the bladerows
-                There's 2 ways of setting the RPM. 
-                1. Conventional: Stator-Rotor-Stator-Rotor-etc. Set the RPM equally across all
-                2. Counter Rotation: We either use the RPM already persecribed for each blade row.
-            '''    
-            self.blade_rows[i].id = i
-            if (type(self.blade_rows[i]) != Inlet) and (type(self.blade_rows[i]) != Outlet):
-                self.blade_rows[i].rpm = rpm
-                self.blade_rows[i].axial_chord = self.blade_rows[i].location * self.passage.hub_length
-            
-
-    @property
-    def fluid(self) -> Optional[Solution]:
-        return self._fluid
-
-    @fluid.setter
-    def fluid(self,newFluid:Solution):
-        """Change the type of gas used in the spool
-
-        Args:
-            new_gas (ct.Solution.Solution): New gas mixture
-        """
-        self._fluid = newFluid
-        for i in range(len(self.blade_rows)):
-            self.blade_rows[i].fluid = self.fluid
-
-    @property
-    def adjust_streamlines(self) -> bool:
-        """Variable that determines whether or not to try and adjust the streamlines to balance massflow
-        This can be a source of failure. Setting it to false may help with debugging. 
-
-        Returns:
-            bool: True = streamlines are adjusted after calculation; False = No changes in streamlines
-        """
-        return self._adjust_streamlines
-    
-    @adjust_streamlines.setter
-    def adjust_streamlines(self,val:bool):
-        """Variable that determines whether or not to try and adjust the streamlines to balance massflow
-        This can be a source of failure. Setting it to false may help with debugging. 
-        """
-        self._adjust_streamlines = val
-    
-
-    def set_blade_row_rpm(self,index:int,rpm:float):
-        """sets the rpm of a particular blade row"""    
-        self.blade_rows[index].rpm = rpm
-        
-    def set_blade_row_type(self,blade_row_index:int,rowType:RowType):
-        """Sets a blade row to be a different type.
-
-        Args:
-            blade_row_index (int): Index of blade row. Keep in mind Blade row 0 is inlet, -1 = outlet
-        """
-        self.blade_rows[blade_row_index].row_type = rowType
-
-    def set_blade_row_exit_angles(self,radius:Dict[int,List[float]],beta:Dict[int,List[float]],IsSupersonic:bool=False):
-        """Set the intended exit flow angles for the spool. 
-
-            Useful if you already have a geometry that you want to simulate
-            
-            You can set the values for each blade row or simply the inlet and exit
- 
-        Args:
-            radius (np.ndarray): Matrix containing [[r1,r2,r3],[r1,r2,r3]] blade_rows x radial locations
-            beta (Dict[int,List[float]]): Metal Angle of the geometry, it is assumed that the fluid will leave at this angle.
-            IsSupersonic(bool): if solution is supersonic at spool exit
-
-        Example: 
-            # Station 0 has angles of [73.1,74.2,75.4] 
-            # Station 5 has angles of [69,69,69] 
-            beta =  {0: [73.1,74.2,75.4], 5: [69,69,69]}
-
-        """
-        for k,v in radius.items():                                   
-            self.blade_rows[k].radii_geom = v 
-        for k,v in beta.items():                                   
-            self.blade_rows[k].beta_geom = v 
-            self.blade_rows[k].beta_fixed = True
-        for br in self.blade_rows:
-            if not IsSupersonic:
-                br.solution_type = SolutionType.subsonic
-            else:
-                br.solution_type = SolutionType.supersonic
-        
-    
-    def initialize_streamlines(self):
-        """Initialize streamline and compute the curvature. 
-            This function is called once
-        """
-             
-        for row in self.blade_rows: 
-            row.phi = np.zeros((self.num_streamlines,))
-            row.rm = np.zeros((self.num_streamlines,))
-            row.r = np.zeros((self.num_streamlines,))
-            row.m = np.zeros((self.num_streamlines,))
-            
-            t_radial = np.linspace(0,1,self.num_streamlines)
-            self.calculate_streamline_curvature(row,t_radial)
-            
-            # Set the loss function if it's not set
-            if (type(row)!= Inlet and type(row) != Outlet):  
-                if row.loss_function == None:
-                    row.loss_function = TD2()
-            
-    def calculate_streamline_curvature(self,row:BladeRow,t_radial:Union[List[float],npt.NDArray]):
-        """Called to calculate new streamline curvature
-
-        Args:
-            row (BladeRow): blade row
-            t_radial (Union[List[float],npt.NDArray]): normalized streamline radial locations
-        """
-        for i,tr in enumerate(t_radial):
-            t_streamline, x_streamline, r_streamline = self.passage.get_streamline(tr)                
-            phi, rm, r = self.passage.streamline_curvature(x_streamline,r_streamline)
-            row.phi[i] = float(interp1d(t_streamline,phi)(row.location))
-            row.rm[i] = float(interp1d(t_streamline,rm)(row.location))
-            row.r[i] = float(interp1d(t_streamline,r)(row.location))
-            row.m[i] = float(interp1d(t_streamline,self.passage.get_m(tr,resolution=len(t_streamline)))(row.location))
-          
-    def solve(self):
-        raise NotImplementedError('Solve is not implemented')
-
-    
-    def plot(self):
-        """Plots the hub, shroud, and all the streamlines
-        """
-        plt.figure(num=1,clear=True,dpi=150,figsize=(15,10))
-        plt.plot(self.passage.xhub_pts,self.passage.rhub_pts,label='hub',linestyle='solid',linewidth=2,color='black')
-        plt.plot(self.passage.xshroud_pts,self.passage.rshroud_pts,label='shroud',linestyle='solid',linewidth=2,color='black')
-        
-        hub_length = np.sum(np.sqrt(np.diff(self.passage.xhub_pts)**2 + np.diff(self.passage.rhub_pts)**2))
-        # Populate the streamlines 
-        x_streamline = np.zeros((self.num_streamlines,len(self.blade_rows)))
-        r_streamline = np.zeros((self.num_streamlines,len(self.blade_rows)))
-        for i in range(len(self.blade_rows)):
-            x_streamline[:,i] = self.blade_rows[i].x
-            r_streamline[:,i] = self.blade_rows[i].r
-        
-        for i in range(1,len(self.blade_rows)-1): # plot dashed lines for each steamline
-            plt.plot(x_streamline[:,i],r_streamline[:,i],'--b',linewidth=1.5)
-        
-        for i in range(len(self.blade_rows)):
-            
-            row = self.blade_rows[i]
-            plt.plot(row.x,row.r,linestyle='dashed',linewidth=1.5,color='blue',alpha=0.4)
-            plt.plot(x_streamline[:,i],r_streamline[:,i],'or')
-            
-            if i == 0: 
-                pass # Inlet 
-            else:  # i>0
-                upstream = self.blade_rows[i-1]
-                if upstream.row_type== RowType.Inlet:
-                    cut_line1,_,_ = self.passage.get_cutting_line((row.location*hub_length +(0.5*row.blade_to_blade_gap*row.axial_chord) - row.axial_chord)/hub_length)
-                else:
-                    cut_line1,_,_ = self.passage.get_cutting_line((upstream.location*hub_length)/hub_length)
-                cut_line2,_,_ = self.passage.get_cutting_line((row.location*hub_length-(0.5*row.blade_to_blade_gap*row.axial_chord))/hub_length)
-                
-            if self.blade_rows[i].row_type == RowType.Stator:
-                x1,r1 = cut_line1.get_point(np.linspace(0,1,10))
-                plt.plot(x1,r1,'m')
-                x2,r2 = cut_line2.get_point(np.linspace(0,1,10))
-                plt.plot(x2,r2,'m')
-                x_text = (x1+x2)/2; r_text = (r1+r2)/2
-                plt.text(x_text.mean(),r_text.mean(),"Stator",fontdict={"fontsize":"xx-large"})
-            elif self.blade_rows[i].row_type == RowType.Rotor:
-                x1,r1 = cut_line1.get_point(np.linspace(0,1,10))
-                plt.plot(x1,r1,color='brown')
-                x2,r2 = cut_line2.get_point(np.linspace(0,1,10))
-                plt.plot(x2,r2,color='brown')
-                x_text = (x1+x2)/2; r_text = (r1+r2)/2
-                plt.text(x_text.mean(),r_text.mean(),"Rotor",fontdict={"fontsize":"xx-large"})
-        plt.axis('scaled')
-        plt.savefig(f"Meridional.png",transparent=False,dpi=150)
-        plt.show()
-        
-    def plot_velocity_triangles(self):
-        """Plots the velocity triangles for each blade row
-            Made for turbines 
-        """
-        prop = dict(arrowstyle="-|>,head_width=0.4,head_length=0.8",
-            shrinkA=0,shrinkB=0)
-        
-        
-        for j in range(self.num_streamlines):
-            x_start = 0
-            y_max = 0; y_min = 0
-            plt.figure(num=1,clear=True)
-            for i in range(1,len(self.blade_rows)-1): # Don't plot inlet or outlet 
-                row = self.blade_rows[i]
-                x_end = x_start + row.Vm.mean()
-                dx = x_end - x_start
-                
-                Vt = row.Vt[j]
-                Wt = row.Wt[j]
-                U = row.U[j]
-
-                y_max = (Vt if Vt>y_max else y_max)
-                y_max = (Wt if Wt>y_max else y_max)
-                
-                y_min = (Vt if Vt<y_min else y_min)
-                y_min = (Wt if Wt<y_min else y_min)
-                
-                # V 
-                plt.annotate("", xy=(x_end,Vt), xytext=(x_start,0), arrowprops=prop)
-                plt.text((x_start+x_end)/2,Vt/2*1.1,"V",fontdict={"fontsize":"xx-large"})
-                
-                # W
-                plt.annotate("", xy=(x_end,Wt), xytext=(x_start,0), arrowprops=prop)
-                plt.text((x_start+x_end)/2,Wt/2*1.1,"W",fontdict={"fontsize":"xx-large"})
-                
-                if (abs(row.Vt[j]) > abs(row.Wt[j])):
-                    # Shift Vt to right just a bit so we can see it
-                    plt.annotate("", xy=(x_end,Wt), xytext=(x_end,0), arrowprops=prop) # Wt
-                    plt.text(x_end+dx*0.1,Wt/2,"Wt",fontdict={"fontsize":"xx-large"})
-
-                    plt.annotate("", xy=(x_end,U+Wt), xytext=(x_end,Wt), arrowprops=prop) # U
-                    plt.text(x_end+dx*0.1,(Wt+U)/2,"U",fontdict={"fontsize":"xx-large"})
-                else:
-                    # Shift Wt to right just a bit so we can see it
-                    plt.annotate("", xy=(x_end,Vt), xytext=(x_end,0), arrowprops=prop) # Vt
-                    plt.text(x_end+dx*0.1,Vt/2,"Vt",fontdict={"fontsize":"xx-large"})
-
-                    plt.annotate("", xy=(x_end,Wt+U), xytext=(x_end,Wt), arrowprops=prop) # U
-                    plt.text(x_end+dx*0.1,Wt+U/2,"U",fontdict={"fontsize":"xx-large"})
-
-                if -np.sign(Vt)>0:
-                    y = y_min 
-                else:
-                    y = y_max
-                plt.text((x_start+x_end)/2,-np.sign(Vt)*y*0.95,row.row_type.name,fontdict={"fontsize":"xx-large"})
-                x_start += row.Vm[j]
-                plt.axis([0,x_end+dx, y_min, y_max])
-            plt.ylabel("Tangental Velocity [m/s]")
-            plt.xlabel("Vm [m/s]")
-            plt.title(f"Velocity Triangles for Streamline {j}")
-            plt.savefig(f"streamline_{j:04d}.png",transparent=False,dpi=150)
-    
-
-
-   
-    
-def JSON_to_Spool(filename:str="spool.json"):
-    """Reads a JSON file with the properties 
-    #! Need to instantiate and return spool. Fluid isn't loaded fyi 
-
-    Args:
-        filename (str, optional): json filename with properties . Defaults to "spool.json".
-    """
-    with open(filename, "r") as f:
-        data = json.load(f)