Containers¶
Container components house the electrode assembly. Each cell format has its own encapsulation class that groups the canister, lid, terminals, and other packaging parts.
Cylindrical¶
Cylindrical canisters, lid assemblies, terminal connectors, and encapsulation.
Cylindrical cell container components (canister, lid, terminal connectors, encapsulation).
Classes¶
CylindricalTerminalConnector(material: PrismaticContainerMaterial, thickness: float, radius: float = None, fill_factor: float = 0.7, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Cylindrical Terminal Connector')
Bases: _CylindricalComponent
A cylindrical terminal connector with triangular tab cutouts.
The CylindricalTerminalConnector creates a circular footprint with triangular cutouts at the edges to accommodate terminal tabs. The main body maintains a circular profile while providing precise cutout geometries for tab connections.
The footprint consists of:
- Main circular body (approximately 94.2% arc coverage)
- Two precise triangular cutouts positioned symmetrically
- Closed path suitable for 3D extrusion and area calculations
All coordinate calculations maintain millimeter precision for manufacturing compatibility.
Initialize a cylindrical terminal connector.
Creates a terminal connector with circular footprint and triangular tab cutouts. All bulk properties and coordinates are calculated if radius is provided, otherwise calculations are deferred until radius is set.
Parameters¶
material : PrismaticContainerMaterial Container material for physical properties thickness : float Component thickness in mm. Must be positive. radius : float, optional Component radius in mm. Must be positive when provided. If None, bulk properties and coordinates won't be calculated until set. fill_factor : float, default=0.7 Material density factor for calculations. Must be between 0.0 and 1.0. datum : Tuple[float, float, float], default=(0.0, 0.0, 0.0) Center position in mm as (x, y, z) coordinates name : str, default="Cylindrical Terminal Connector" Component identifier name
Raises¶
ValueError If fill_factor not in [0.0, 1.0] or radius/thickness <= 0 when provided TypeError If material is not a PrismaticContainerMaterial instance
CylindricalLidAssembly(material: PrismaticContainerMaterial, thickness: float, radius: float = None, fill_factor: float = 0.7, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Cylindrical Lid Assembly')
Bases: _CylindricalComponent
A cylindrical lid assembly with circular footprint.
This class represents a circular lid assembly for cylindrical containers. Unlike the terminal connector, the lid has a simple circular footprint without visible cutouts, though it still respects the fill factor for material calculations.
The lid assembly maintains structural simplicity while allowing for material optimization through the fill factor parameter.
Initialize a cylindrical lid assembly.
Creates a lid assembly with simple circular footprint. All bulk properties and coordinates are calculated if radius is provided, otherwise calculations are deferred until radius is set.
Parameters¶
material : PrismaticContainerMaterial Container material for physical properties thickness : float Component thickness in mm. Must be positive. radius : float, optional Component radius in mm. Must be positive when provided. If None, bulk properties and coordinates won't be calculated until set. fill_factor : float, default=0.7 Material density factor for calculations. Must be between 0.0 and 1.0. datum : Tuple[float, float, float], default=(0.0, 0.0, 0.0) Center position in mm as (x, y, z) coordinates name : str, default="Cylindrical Lid Assembly" Component identifier name
Raises¶
ValueError If fill_factor not in [0.0, 1.0] or radius/thickness <= 0 when provided TypeError If material is not a PrismaticContainerMaterial instance
CylindricalCanister(material: PrismaticContainerMaterial, outer_radius: float, height: float, wall_thickness: float, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Cylindrical Canister')
Bases: CoordinateMixin, DatumMixin, ValidationMixin, PropagationMixin, SerializerMixin, PlotterMixin, DunderMixin
A cylindrical can with concentric circular walls.
This class represents a cylindrical container with walls defined by two concentric circles. The footprint shows both the outer perimeter and inner cavity, separated by the wall thickness. Unlike other components, the radius parameter is required and cannot be None.
The footprint consists of: - Outer circular wall at the specified radius - Inner circular cavity at (radius - wall_thickness) - Closed paths for both outer and inner boundaries
The height parameter defines the vertical extent of the can, while wall_thickness defines the radial wall thickness.
Initialize a cylindrical can.
Creates a cylindrical can with concentric walls. The radius parameter is required and must be greater than the wall thickness.
Parameters¶
material : PrismaticContainerMaterial Container material for physical properties outer_radius : float Outer radius of the can in mm. Must be positive and greater than wall_thickness. height : float Height of the can in mm. Must be positive. wall_thickness : float Radial wall thickness in mm. Must be positive and less than radius. datum : Tuple[float, float, float], default=(0.0, 0.0, 0.0) Center position in mm as (x, y, z) coordinates name : str, default="Cylindrical Can" Component identifier name
Raises¶
ValueError If fill_factor not in [0.0, 1.0], radius <= 0, height <= 0, wall_thickness <= 0, or wall_thickness >= radius TypeError If material is not a PrismaticContainerMaterial instance
Attributes¶
property
¶
Get side cross-section coordinates of the can in mm.
property
¶
Get side cross-section trace for plotting (x-y plane).
property
¶
Get top-down view coordinates of the can in mm.
property
¶
Get top-down view trace for plotting (x-y plane).
property
¶
Valid outer radius range in mm, rounded to 2 decimal places.
property
¶
Hard limits for outer radius in mm, rounded to 2 decimal places.
property
¶
Valid height range in mm, rounded to 2 decimal places.
property
¶
Hard limits for height in mm, rounded to 2 decimal places.
property
¶
Valid inner height range in mm (height_range minus wall thickness).
property
¶
Valid wall thickness range in mm, rounded to 2 decimal places.
Methods:¶
Generate a top-down view plot of the can.
Generate a side cross-section plot of the can.
CylindricalEncapsulation(cathode_terminal_connector: CylindricalTerminalConnector, anode_terminal_connector: CylindricalTerminalConnector, lid_assembly: CylindricalLidAssembly, canister: CylindricalCanister, name: str = 'Cylindrical Encapsulation', datum: Tuple[float, float, float] = (0.0, 0.0, 0.0))
Bases: _Container, DatumMixin
Complete cylindrical cell encapsulation combining canister, lid assembly, and terminal connectors.
Manages the overall cylindrical geometry and provides mass/cost breakdowns.
Attributes¶
property
writable
¶
Internal radius available for cell contents in mm.
property
¶
Valid internal radius range in mm.
property
¶
Get the cost breakdown of the encapsulation.
:return: Dictionary containing the cost breakdown.
property
¶
Get the mass breakdown of the encapsulation.
:return: Dictionary containing the mass breakdown.
property
¶
Valid height range in mm based on canister.
property
¶
Hard limits for height in mm based on canister.
Methods:¶
classmethod
¶
from_prismatic(prismatic_encapsulation) -> CylindricalEncapsulation
Create a CylindricalEncapsulation from a PrismaticEncapsulation.
Converts a prismatic (rectangular) encapsulation to cylindrical form by calculating an equivalent radius that preserves internal volume. The conversion uses the formula r = sqrt(width × length / π) to maintain the same cross-sectional area, and maps height directly from prismatic to cylindrical.
Parameters¶
prismatic_encapsulation : PrismaticEncapsulation The prismatic encapsulation to convert
Returns¶
CylindricalEncapsulation A new cylindrical encapsulation with equivalent internal volume
Notes¶
- Internal volume is preserved through equivalent cross-sectional area conversion
- Height maps directly from prismatic to cylindrical
- Materials and thicknesses are transferred from the prismatic components
- Terminal connectors and lid are auto-sized to fit the new canister (90% inner radius)
Examples¶
prismatic_enc = PrismaticEncapsulation(...) cylindrical_enc = CylindricalEncapsulation.from_prismatic(prismatic_enc)
classmethod
¶
from_pouch(pouch_encapsulation) -> CylindricalEncapsulation
Create a CylindricalEncapsulation from a PouchEncapsulation.
Converts a pouch encapsulation to cylindrical form by calculating an equivalent radius from the pouch dimensions and creating rigid container components with default aluminum material. This conversion is useful for comparing flexible pouch designs with rigid cylindrical implementations.
Parameters¶
pouch_encapsulation : PouchEncapsulation The pouch encapsulation to convert
Returns¶
CylindricalEncapsulation A new cylindrical encapsulation with aluminum components
Notes¶
Default parameters for rigid components:
- Canister material: Aluminum (from database)
- Wall thickness: 1.0 mm
- Terminal thickness: 0.5 mm
- Lid thickness: 0.5 mm
- Fill factor: 0.7 (standard)
The conversion calculates equivalent radius using r = sqrt(width × thickness / π) and maps pouch height to cylindrical height. Since pouches lack rigid components, all structural parts are created with aluminum defaults.
Examples¶
pouch_enc = PouchEncapsulation(...) cylindrical_enc = CylindricalEncapsulation.from_pouch(pouch_enc)
Set the internal radius to fit an electrode assembly's radius dimension.
Parameters¶
assembly : WoundJellyRoll The electrode assembly to fit clearance : float, optional Additional clearance in mm (default: 0)
Set the internal height to fit an electrode assembly's height dimension.
Parameters¶
assembly : WoundJellyRoll The electrode assembly to fit clearance : float, optional Additional clearance in mm (default: 0)
Adjust all encapsulation dimensions to fit a given electrode assembly.
Resizes the canister's inner dimensions to accommodate the electrode assembly with a specified clearance margin. Calls fit_radius and fit_height.
Parameters¶
assembly : WoundJellyRoll The electrode assembly to fit the encapsulation to clearance : float, optional Additional clearance in mm around the assembly (default: 0)
Prismatic¶
Prismatic hard-case canisters, lid assemblies, terminal connectors, and encapsulation.
Prismatic cell container components (canister, lid, terminal connectors, encapsulation).
Classes¶
Bases: Enum
Orientation options for electrode layups.
PrismaticTerminalConnector(material: PrismaticContainerMaterial, thickness: float, width: float = None, length: float = None, fill_factor: float = DEFAULT_FILL_FACTOR, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Prismatic Terminal Connector')
Bases: _PrismaticComponent
A prismatic terminal connector with rectangular footprint.
The PrismaticTerminalConnector creates a rectangular footprint for terminal connections in prismatic battery cells. The connector is positioned under the lid assembly.
Initialize a prismatic terminal connector.
Parameters¶
material : PrismaticContainerMaterial Container material for physical properties thickness : float Component thickness in mm. Must be positive. width : float, optional Component width in mm. Must be positive when provided. length : float, optional Component length in mm. Must be positive when provided. fill_factor : float, default=0.7 Material density factor for calculations. Must be between 0.0 and 1.0. datum : Tuple[float, float, float], default=(0.0, 0.0, 0.0) Center position in mm as (x, y, z) coordinates name : str, default="Prismatic Terminal Connector" Component identifier name
Attributes¶
property
¶
Valid width range in mm, bounded by the canister it sits in.
In a longitudinal encapsulation the two connectors sit side by side
along the canister's inner width, so each is capped at half of it; in a
transverse one they sit on opposite faces and the cap is the inner
length. See PrismaticEncapsulation.connector_dimension_limits.
property
¶
Same as width_range: a geometric limit has no softer version.
property
¶
Valid length range in mm, bounded by the canister it sits in.
property
¶
Same as length_range: a geometric limit has no softer version.
PrismaticLidAssembly(material: PrismaticContainerMaterial, thickness: float, width: float = None, length: float = None, fill_factor: float = DEFAULT_FILL_FACTOR, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Prismatic Lid Assembly')
Bases: _PrismaticComponent
A prismatic lid assembly with rectangular footprint.
This class represents a rectangular lid assembly for prismatic containers. The lid has a simple rectangular footprint and sits on top of the canister.
Initialize a prismatic lid assembly.
Parameters¶
material : PrismaticContainerMaterial Container material for physical properties thickness : float Component thickness in mm. Must be positive. width : float, optional Component width in mm. Must be positive when provided. length : float, optional Component length in mm. Must be positive when provided. fill_factor : float, default=0.7 Material density factor for calculations. Must be between 0.0 and 1.0. datum : Tuple[float, float, float], default=(0.0, 0.0, 0.0) Center position in mm as (x, y, z) coordinates name : str, default="Prismatic Lid Assembly" Component identifier name
PrismaticCanister(material: PrismaticContainerMaterial, width: float, length: float, height: float, wall_thickness: float, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Prismatic Canister')
Bases: CoordinateMixin, DatumMixin, PropagationMixin, SerializerMixin, ValidationMixin, PlotterMixin, DunderMixin
A prismatic (rectangular) container with walls.
This class represents a rectangular container with walls defined by inner and outer dimensions. The container has a base and four walls, forming a rectangular box shape.
Initialize a prismatic canister.
Parameters¶
material : PrismaticContainerMaterial Container material for physical properties width : float Outer width of the canister in mm. Must be positive. length : float Outer length of the canister in mm. Must be positive. height : float Height of the canister in mm. Must be positive. wall_thickness : float Wall thickness in mm. Must be positive and less than half of outer dimensions. datum : Tuple[float, float, float], default=(0.0, 0.0, 0.0) Center position in mm as (x, y, z) coordinates name : str, default="Prismatic Canister" Component identifier name
Attributes¶
property
¶
Get right-left view coordinates in mm.
property
¶
Get top-down view coordinates in mm.
property
¶
Valid outer width range in mm, rounded to 2 decimal places.
property
¶
Hard limits for outer width in mm, rounded to 2 decimal places.
property
¶
Valid outer length range in mm, rounded to 2 decimal places.
property
¶
Hard limits for outer length in mm, rounded to 2 decimal places.
property
¶
Valid height range in mm, rounded to 2 decimal places.
property
¶
Hard limits for height in mm, rounded to 2 decimal places.
property
¶
Valid wall thickness range in mm, rounded to 2 decimal places.
property
writable
¶
Whether the canister has been rotated around the z-axis.
Methods:¶
Generate a top-down view plot of the canister.
Generate a right-left view plot of the canister.
Set datum position, triggering coordinate recalculation.
PrismaticEncapsulation(cathode_terminal_connector: PrismaticTerminalConnector, anode_terminal_connector: PrismaticTerminalConnector, lid_assembly: PrismaticLidAssembly, canister: PrismaticCanister, connector_orientation: ConnectorOrientation = LONGITUDINAL, cathode_terminal_connector_position: float = None, anode_terminal_connector_position: float = None, name: str = 'Prismatic Encapsulation', datum: Tuple[float, float, float] = (0.0, 0.0, 0.0))
Bases: _Container, DatumMixin
A prismatic encapsulation with rectangular geometry.
This class combines a rectangular canister with a lid assembly and two terminal connectors (cathode and anode) positioned under the lid. Unlike the cylindrical encapsulation where connectors are at opposite ends, both connectors are under the lid in the prismatic design.
Initialize a prismatic encapsulation.
Parameters¶
cathode_terminal_connector : PrismaticTerminalConnector Cathode terminal connector component anode_terminal_connector : PrismaticTerminalConnector Anode terminal connector component lid_assembly : PrismaticLidAssembly Lid assembly component canister : PrismaticCanister Rectangular canister body connector_orientation : ConnectorOrientation, default=ConnectorOrientation.LONGITUDINAL Orientation of the terminal connectors cathode_terminal_connector_position : float, optional Position of cathode terminal connector from left edge of lid in mm (longitudinal mode only). If None, uses default centered position. anode_terminal_connector_position : float, optional Position of anode terminal connector from left edge of lid in mm (longitudinal mode only). If None, uses default centered position. name : str, default="Prismatic Encapsulation" Name identifier for the encapsulation datum : Tuple[float, float, float], default=(0.0, 0.0, 0.0) Center position in mm as (x, y, z) coordinates
Attributes¶
property
writable
¶
Internal height available for cell contents in mm.
property
¶
Valid internal height range in mm.
property
writable
¶
Internal width available for cell contents in mm.
property
writable
¶
Internal length available for cell contents in mm.
property
¶
Valid internal width range in mm, rounded to 2 decimal places.
property
¶
Valid width range in mm, rounded to 2 decimal places.
property
¶
Valid height range in mm, rounded to 2 decimal places.
property
¶
Valid internal length range in mm, rounded to 2 decimal places.
property
¶
Get the cost breakdown of the encapsulation.
property
¶
Get the mass breakdown of the encapsulation.
property
¶
Valid outer length range of the encapsulation in mm, rounded to 2 decimal places.
property
writable
¶
Position of cathode terminal connector from left edge in mm (longitudinal mode).
property
writable
¶
Position of anode terminal connector from left edge in mm (longitudinal mode).
property
¶
Positions that keep the whole cathode connector inside the canister.
property
¶
Positions that keep the whole anode connector inside the canister.
Methods:¶
classmethod
¶
from_cylindrical(cylindrical_encapsulation) -> PrismaticEncapsulation
Create a PrismaticEncapsulation from a CylindricalEncapsulation.
Converts a cylindrical encapsulation to prismatic (rectangular) form by calculating equivalent width and length that preserve internal volume. The conversion uses a 2:3 aspect ratio (width:length) which is common for prismatic battery cells.
Parameters¶
cylindrical_encapsulation : CylindricalEncapsulation The cylindrical encapsulation to convert
Returns¶
PrismaticEncapsulation A new prismatic encapsulation with equivalent internal volume
Notes¶
- Internal volume is preserved through equivalent cross-sectional area conversion
- Aspect ratio is 2:3 (width:length), common for prismatic cells
- Conversion formulas:
- width = radius × sqrt(2π/3)
- length = radius × sqrt(3π/2)
- Height maps directly from cylindrical to prismatic
- Materials and thicknesses are transferred from the cylindrical components
- Connector orientation defaults to LONGITUDINAL
Examples¶
cylindrical_enc = CylindricalEncapsulation(...) prismatic_enc = PrismaticEncapsulation.from_cylindrical(cylindrical_enc)
classmethod
¶
from_pouch(pouch_encapsulation) -> PrismaticEncapsulation
Create a PrismaticEncapsulation from a PouchEncapsulation.
Converts a pouch encapsulation to prismatic form by creating rigid container components with default aluminum material. The pouch dimensions map to prismatic dimensions while adding structural rigidity.
Parameters¶
pouch_encapsulation : PouchEncapsulation The pouch encapsulation to convert
Returns¶
PrismaticEncapsulation A new prismatic encapsulation with aluminum components
Notes¶
Default parameters for rigid components: - Canister material: Aluminum (from database) - Wall thickness: 1.0 mm - Terminal thickness: 0.5 mm - Lid thickness: 0.5 mm - Fill factor: 0.7 (standard) - Connector orientation: LONGITUDINAL
The conversion maps pouch dimensions as follows: - pouch width → prismatic width - pouch thickness → prismatic length - pouch height → prismatic height
Since pouches lack rigid components, all structural parts are created with aluminum defaults.
Examples¶
pouch_enc = PouchEncapsulation(...) prismatic_enc = PrismaticEncapsulation.from_pouch(pouch_enc)
Return the largest (width, length) a terminal connector may take, in mm.
Which canister dimension bounds which connector dimension depends on the orientation, because the two orientations lay the connectors out differently:
LONGITUDINALseats both connectors side by side along the canister's inner width, at plus/minus a quarter of it, so they share that span -- each may be at most half of it. Their length then runs along the inner length.TRANSVERSEseats them on opposite inner faces, separated by the inner width and each onlythicknessdeep, so they never compete for room. Width then runs along the inner length, while length runs down from the lid along the inner height -- so the lid's own thickness comes off that span, whichinner_heightalone does not account for.
Single source of truth for the geometry: the defaults, the clamping and
the connectors' own width_range / length_range all read it.
Plot mass breakdown as sunburst chart.
Plot cost breakdown as sunburst chart.
Generate a side view plot showing all components.
Generate a top-down view plot showing all components.
Set the internal height to fit an electrode assembly's height dimension.
For stacks: uses layup.height + cathode current collector tab height For FlatWoundJellyRoll: uses jelly_roll.height (= layup.width)
Parameters¶
assembly : FlatWoundJellyRoll | ZFoldStack | PunchedStack The electrode assembly to fit clearance : float, optional Additional clearance in mm (default: 0)
Set the internal width to fit an electrode assembly's width dimension.
For stacks: uses layup.width For FlatWoundJellyRoll: uses jelly_roll.width (racetrack X span)
Parameters¶
assembly : FlatWoundJellyRoll | ZFoldStack | PunchedStack The electrode assembly to fit clearance : float, optional Additional clearance in mm (default: 0)
Set the internal length to fit electrode assembly thickness.
For all assembly types: uses assembly.thickness × n_electrode_assembly
Parameters¶
assembly : FlatWoundJellyRoll | ZFoldStack | PunchedStack The electrode assembly to fit clearance : float, optional Additional clearance in mm (default: 0) n_electrode_assembly : int, optional Number of electrode assemblies to fit (default: 1). The total length will be assembly_thickness × n_electrode_assembly + clearance.
Adjust all encapsulation dimensions to fit a given electrode assembly.
Resizes the canister's inner dimensions to accommodate the electrode assembly with a specified clearance margin.
Parameters¶
assembly : FlatWoundJellyRoll | ZFoldStack | PunchedStack The electrode assembly to fit the encapsulation to clearance : float, optional Additional clearance in mm around the assembly (default: 0)
Notes¶
Dimension mapping:
For stacked assemblies (ZFoldStack, PunchedStack): - encapsulation width ← layup.width - encapsulation length ← assembly.thickness - encapsulation height ← layup.height
For FlatWoundJellyRoll
- encapsulation width ← jelly_roll.width (racetrack X span)
- encapsulation length ← jelly_roll.thickness
- encapsulation height ← jelly_roll.height (= layup.width)
The connector_orientation affects how internal dimensions map to canister dimensions (TRANSVERSE rotates the canister 90°), but does not change the assembly→encapsulation dimension mapping.
Set datum position, triggering coordinate recalculation.
Functions:¶
Pouch¶
Pouch laminate sheets, terminals, and encapsulation.
Pouch cell container components (laminate sheets, terminals, encapsulation).
Classes¶
LaminateSheet(areal_cost: float, density: float, thickness: float, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Laminate Sheet')
Bases: CoordinateMixin, DatumMixin, ValidationMixin, PropagationMixin, DunderMixin, PlotterMixin, SerializerMixin, SchematicPlotMixin
Laminate film sheet for pouch cell packaging.
Provides geometry, coordinates, and visualization traces for top and bottom laminate layers.
Initialize an object that represents a laminate sheet
Parameters¶
areal_cost : float Areal cost of the laminate in $/m². density : float Density of the laminate in g/cm^3. thickness : float Thickness of the laminate in um. datum : Tuple[float, float, float], optional Reference point (x, y, z) in mm. Defaults to (0.0, 0.0, 0.0). name : str, optional Name of the laminate sheet. Defaults to 'Laminate Sheet'.
Attributes¶
property
¶
Get the top-down coordinates in mm.
Returns coordinates as a DataFrame with 'x' and 'y' columns.
property
¶
Get the right-left (side) cross-section coordinates in mm.
Returns coordinates as a DataFrame with 'y' and 'z' columns.
property
¶
Get the bottom-up cross-section coordinates in mm.
Returns coordinates as a DataFrame with 'x' and 'z' columns.
property
¶
Get a Plotly Scatter trace for the right-left (side) view.
Returns a go.Scatter trace showing the cross-section of the laminate sheet.
property
¶
Get a Plotly Scatter trace for the bottom-up view.
Returns a go.Scatter trace showing the cross-section of the laminate sheet.
property
¶
Get a Plotly Scatter trace for the top-down view.
Returns a go.Scatter trace showing the laminate sheet footprint.
Methods:¶
Plotly Figure showing the top-down view (x-y) of the laminate sheet.
Plotly Figure showing the right-left (y-z) cross-section of the laminate sheet.
Plotly Figure showing the bottom-up (x-z) cross-section of the laminate sheet.
PouchTerminal(material, width: float, length: float, thickness: float, datum: Tuple[float, float, float] = (0.0, 0.0, 0.0), name: str = 'Pouch Terminal')
Bases: CoordinateMixin, DatumMixin, ValidationMixin, PropagationMixin, DunderMixin, PlotterMixin, SerializerMixin
A pouch terminal connector component with rectangular prismatic geometry.
The PouchTerminal represents a terminal tab that extends from a pouch cell, typically made from metal materials like aluminum or copper. It has a rectangular cross-section defined by width, length, and height.
Initialize a pouch terminal connector.
Parameters¶
material : PrismaticContainerMaterial Material for the terminal (typically metal). width : float Width of the terminal in mm. Must be positive. length : float Length of the terminal in mm. Must be positive. thickness : float Thickness of the terminal in mm. Must be positive. datum : Tuple[float, float, float], optional Center position in mm as (x, y, z) coordinates. Defaults to (0.0, 0.0, 0.0). name : str, optional Component identifier name. Defaults to "Pouch Terminal".
Raises¶
ValueError If width, length, or thickness <= 0 when provided.
Attributes¶
property
¶
Get the right-left coordinates in mm.
Returns coordinates as a DataFrame with 'x' and 'z' columns.
property
¶
Get a Plotly Scatter trace for the right-left view.
Returns a go.Scatter trace showing the terminal cross-section.
property
¶
Get the top-down coordinates in mm.
Returns coordinates as a DataFrame with 'x' and 'y' columns.
property
¶
Get a Plotly Scatter trace for the top-down view.
Returns a go.Scatter trace showing the terminal footprint.
Methods:¶
PouchEncapsulation(cathode_terminal: PouchTerminal, anode_terminal: PouchTerminal, top_laminate: LaminateSheet, bottom_laminate: LaminateSheet, width: float = None, height: float = None, thickness: float = None, name: str = 'Pouch Encapsulation', datum: Tuple[float, float, float] = (0.0, 0.0, 0.0))
Bases: _Container, DatumMixin
Complete pouch cell encapsulation combining top/bottom laminate sheets and terminals.
Manages pouch geometry, hot-pressing cavity formation, and provides mass/cost breakdowns.
Attributes¶
Methods:¶
Get a Plotly Figure showing the side view of the pouch encapsulation.
Get a Plotly Figure showing the top view of the pouch encapsulation.
classmethod
¶
from_prismatic(prismatic_encapsulation, terminal_width: float = None, terminal_length: float = None, terminal_thickness: float = None, laminate_areal_cost: float = 0.06, laminate_density: float = 0.92, laminate_thickness: float = 50.0)
Create a PouchEncapsulation from a PrismaticEncapsulation.
Converts a prismatic encapsulation to pouch format by removing rigid structure and creating flexible laminate packaging. Dimensions are mapped to preserve internal volume: - pouch width = prismatic width - pouch height = prismatic length - pouch thickness = prismatic internal height
Parameters¶
prismatic_encapsulation : PrismaticEncapsulation The prismatic encapsulation to convert from. terminal_width : float, optional Width of pouch terminals in mm. Defaults to pouch_width / 6 if not specified. terminal_length : float, optional Length of pouch terminals in mm. Defaults to pouch_height / 10 if not specified. terminal_thickness : float, optional Thickness of pouch terminals in mm. Defaults to 1.0 if not specified. laminate_areal_cost : float, optional Areal cost of laminate sheets in $/m². Defaults to 0.06. laminate_density : float, optional Density of laminate sheets in g/cm³. Defaults to 0.92. laminate_thickness : float, optional Thickness of laminate sheets in µm. Defaults to 50.0.
Returns¶
PouchEncapsulation A new pouch encapsulation with dimensions mapped from prismatic.
Raises¶
TypeError If prismatic_encapsulation is not a PrismaticEncapsulation instance.
Examples¶
from steer_opencell_design.Components.Containers.Prismatic import PrismaticEncapsulation prismatic = PrismaticEncapsulation(...) pouch = PouchEncapsulation.from_prismatic(prismatic)
classmethod
¶
from_cylindrical(cylindrical_encapsulation, terminal_width: float = None, terminal_length: float = None, terminal_thickness: float = None, laminate_areal_cost: float = 0.06, laminate_density: float = 0.92, laminate_thickness: float = 50.0)
Create a PouchEncapsulation from a CylindricalEncapsulation.
Converts a cylindrical encapsulation to pouch format by removing rigid structure and creating flexible laminate packaging. Dimensions are mapped to preserve internal volume: - pouch width = 2 × radius (cylinder diameter) - pouch height = cylinder height - pouch thickness = 2 × radius (cylinder diameter)
Parameters¶
cylindrical_encapsulation : CylindricalEncapsulation The cylindrical encapsulation to convert from. terminal_width : float, optional Width of pouch terminals in mm. Defaults to pouch_width / 6 if not specified. terminal_length : float, optional Length of pouch terminals in mm. Defaults to pouch_height / 10 if not specified. terminal_thickness : float, optional Thickness of pouch terminals in mm. Defaults to 1.0 if not specified. laminate_areal_cost : float, optional Areal cost of laminate sheets in $/m². Defaults to 0.06. laminate_density : float, optional Density of laminate sheets in g/cm³. Defaults to 0.92. laminate_thickness : float, optional Thickness of laminate sheets in µm. Defaults to 50.0.
Returns¶
PouchEncapsulation A new pouch encapsulation with dimensions mapped from cylindrical.
Raises¶
TypeError If cylindrical_encapsulation is not a CylindricalEncapsulation instance.
Examples¶
from steer_opencell_design.Components.Containers.Cylindrical import CylindricalEncapsulation cylindrical = CylindricalEncapsulation(...) pouch = PouchEncapsulation.from_cylindrical(cylindrical)
Flex-Frame¶
Flex-frame housing for solid-state cell designs.
Flex-frame cell container components.
Classes¶
FlexFrame(material: FlexFrameMaterial, width: float, height: float, border_thickness: float, thickness: float, cutout_height: float, datum: tuple = (0, 0, 0), name: str = 'Flex Frame')
Bases: CoordinateMixin, DatumMixin, ValidationMixin, PropagationMixin, SerializerMixin, DunderMixin, PlotterMixin
Rigid polymer frame for flex-frame cell designs.
Provides a border structure with a central cutout for the electrode stack.
Flex frame container for flex frame cells.
Parameters¶
material : FlexFrameMaterial Material of the flex frame. width : float Width of the flex frame in mm. height : float Height of the flex frame in mm. border_thickness : float Thickness of the flex frame border in mm. thickness : float Thickness of the flex frame in mm. cutout_height : float Height of the cutout in mm. datum : tuple, optional Datum point for coordinates calculation, by default (0, 0, 0). name : str, optional Name of the flex frame, by default "Flex Frame".
FlexFrameEncapsulation(flex_frame: FlexFrame, laminate_sheet: LaminateSheet, cathode_terminal: PouchTerminal, anode_terminal: PouchTerminal, name: str = 'Flex Frame Encapsulation', datum: tuple = (0, 0, 0))
Bases: _Container, DatumMixin
Complete flex-frame cell encapsulation combining the flex frame, laminate sheet, and terminals.
Initialize flex-frame encapsulation.
Parameters¶
flex_frame : FlexFrame Rigid polymer flex frame. laminate_sheet : LaminateSheet Laminate sheet used for top/bottom/side coverage. cathode_terminal : PouchTerminal Cathode terminal connection. anode_terminal : PouchTerminal Anode terminal connection. name : str, optional Display name. datum : tuple, optional Reference position (x, y, z) in mm.