mesh.meshers

Module Contents

Classes

BeamMesh
CamberSurface
CamberSurfaceDict
OneDBoxBeam
OneDBoxBeamDict
RotorDiscretization
RotorDiscretizationDict
RotorMeshes
ShellDiscretization
ShellMesh
VLMMesh

Functions

cosine_spacing(num_pts[, spanwise_points, ...])
import_shell_mesh(file_name, geometry[, plot, ...])	Create a shell mesh for a component using a mesh file
make_1d_box_beam(→ OneDBoxBeam)	Create a 1-D box beam mesh for a wing-like component. It is NOT intended
make_mesh_symmetric(quantity, num_spanwise[, ...])
make_rotor_mesh(→ RotorDiscretization)
make_vlm_surface(→ CamberSurface)	Make a VLM camber surface mesh for wing-like components. This method is NOT

class mesh.meshers.BeamMesh

Bases: CADDEE_alpha.core.mesh.mesh.SolverMesh

discretizations: dict[OneDBoxBeam]

class mesh.meshers.CamberSurface

Bases: CADDEE_alpha.core.mesh.mesh.Discretization

_LE_points_para

_TE_points_para

_airfoil_lower_para

_airfoil_upper_para

_chordwise_spacing

_geom

_lower_wireframe_para

_num_chord_wise

_num_spanwise

_upper_wireframe_para

alpha_ML_mid_panel

embedded_airfoil_model_Cd

embedded_airfoil_model_Cl

embedded_airfoil_model_Cp

embedded_airfoil_model_alpha_stall

mid_panel_chord_length

reynolds_number

_update()

copy() → CamberSurface

project_airfoil_points(num_points: int = 120, spacing: str = 'sin', grid_search_density: int = 10, plot: bool = False, oml_geometry=None)

class mesh.meshers.CamberSurfaceDict

Bases: CADDEE_alpha.core.mesh.mesh.DiscretizationsDict

__getitem__(key) → CamberSurface

__setitem__(key, value: CamberSurface)

class mesh.meshers.OneDBoxBeam

Bases: CADDEE_alpha.core.mesh.mesh.Discretization

_LE_points_parametric

_TE_points_parametric

_aft_points_parametric

_bottom_grid_parametric

_fore_points_parametric

_front_grid_parametric

_front_spar_geom

_geom: lsdo_geo.Geometry

_half_wing = False

_material_properties

_node_bottom_parametric

_node_top_parametric

_norm_beam_width

_norm_node_center

_rear_grid_parametric

_rear_spar_geom

_spar_geom

_top_grid_parametric

beam_height: csdl_alpha.Variable

beam_width: csdl_alpha.Variable

bottom_skin_thickness: csdl_alpha.Variable

num_beam_nodes: int

shear_web_thickness: csdl_alpha.Variable

top_skin_thickness: csdl_alpha.Variable

_update()

class mesh.meshers.OneDBoxBeamDict

Bases: CADDEE_alpha.core.mesh.mesh.DiscretizationsDict

__getitem__(key) → OneDBoxBeam

class mesh.meshers.RotorDiscretization

Bases: CADDEE_alpha.core.mesh.mesh.Discretization

_disk_parametric

_geom

_p1

_p2

_p3

_p4

chord_profile: Union[numpy.ndarray, csdl_alpha.Variable, None]

disk_mesh: Union[csdl_alpha.Variable, numpy.ndarray, None]

norm_hub_radius: float = 0.2

num_azimuthal: Union[int, None]

num_blades: Union[int, None]

num_radial: Union[int, None]

radius: Union[float, int, csdl_alpha.Variable, None]

thrust_origin: Union[numpy.ndarray, csdl_alpha.Variable, None]

thrust_vector: Union[numpy.ndarray, csdl_alpha.Variable, None]

twist_profile: Union[numpy.ndarray, csdl_alpha.Variable, None]

_update()

class mesh.meshers.RotorDiscretizationDict

Bases: CADDEE_alpha.core.mesh.mesh.DiscretizationsDict

__getitem__(key) → RotorDiscretization

class mesh.meshers.RotorMeshes

Bases: CADDEE_alpha.core.mesh.mesh.SolverMesh

discretizations: dict[RotorDiscretization]

class mesh.meshers.ShellDiscretization

Bases: CADDEE_alpha.core.mesh.mesh.Discretization

connectivity: csdl_alpha.Variable

geometry: csdl_alpha.Variable

nodes_parametric: csdl_alpha.Variable

_update()

class mesh.meshers.ShellMesh

Bases: CADDEE_alpha.core.mesh.mesh.SolverMesh

class mesh.meshers.VLMMesh

Bases: CADDEE_alpha.core.mesh.mesh.SolverMesh

discretizations: dict[CamberSurface]

mesh.meshers.cosine_spacing(num_pts, spanwise_points=None, chord_surface=None, num_chordwise=None, flip=False)

mesh.meshers.import_shell_mesh(file_name: str, geometry, plot=False, rescale=[1, 1, 1], grid_search_n=1, priority_inds=None, priority_eps=0.0001, force_reprojection=False)

Create a shell mesh for a component using a mesh file

mesh.meshers.make_1d_box_beam(wing_comp, num_beam_nodes: int, norm_node_center: float, norm_beam_width: float = 0.5, spacing: str = 'linear', plot: bool = False, grid_search_density: int = 10, project_spars: bool = False, make_half_beam: bool = False, LE_TE_interp: str = None, one_side_geometry: lsdo_function_spaces.FunctionSet = None, spar_search_names=['0', '1']) → OneDBoxBeam

Create a 1-D box beam mesh for a wing-like component. It is NOT intended to work for creating beam-mesh of fuselage-like or vertical tail like components.

Parameters

wing_compWing

instance of a ‘Wing’ component

num_beam_nodesint

must be an odd number (ensures beam node at center)

norm_node_centerfloat

normalized node center w.r.t. the leading edge (0 at the leading edge); Note that the beam height is determined based on the node center

norm_beam_widthfloat, optional

normalized beam width (i.e., distance between the front and rear spar), cannot be greater than 1 and should usually not be greater than 0.5, by default 0.5

spacingstr, optional

set spacing for the beam nodes - “linear” and “cosine” are allowed where “cosine” skews the nodes toward the wing tip, by default “linear”

plotbool, optional

plot the projections, by default False

grid_search_densityint, optional

parameter to refine the quality of projections (note that the higher this parameter the longer the projections will take;

project_sparsbool, optional

project onto the spars to get the beam width and shear web thickness, by default False

Returns

OneDBoxBeam

collection of variables including beam node locations, thickness, and width

Raises

ValueError

if number of nodes is even

mesh.meshers.make_mesh_symmetric(quantity, num_spanwise, spanwise_index=0)

mesh.meshers.make_rotor_mesh(rotor_comp, num_radial: int, num_azimuthal: int = 1, num_blades: int = 2, blade_comps=None, plot: bool = False, do_disk_projections: bool = False) → RotorDiscretization

mesh.meshers.make_vlm_surface(wing_comp, num_spanwise: int, num_chordwise: int, spacing_spanwise: str = 'linear', spacing_chordwise: str = 'linear', chord_wise_points_for_airfoil=None, ignore_camber: bool = False, plot: bool = False, grid_search_density: int = 10, LE_interp: Union[str, None] = None, TE_interp: Union[str, None] = None) → CamberSurface

Make a VLM camber surface mesh for wing-like components. This method is NOT intended for vertically oriented lifting surfaces like a vertical tail.

Parameters

wing_compWing

instance of a ‘Wing’ component

num_spanwiseint

number of span-wise panels (note that if odd, central panel will be larger)

num_chordwiseint

number of chord-wise panels

spacing_spanwisestr, optional

spacing of the span-wise panels (linear or cosine currently supported), by default ‘linear’

spacing_chordwisestr, optional

spacing of the chord-wise panels (linear or cosine currently supported), by default ‘linear’

plotbool, optional

plot the projections, by default False

grid_search_densityint, optional

parameter to refine the quality of projections (note that the higher this parameter the longer the projections will take; for finer meshes, especially with cosine spacing, a value of 40-50 is recommended), by default 10

Returns

VLMMesh: csdl.VariableGroup

data class storing the mesh coordinates and mesh velocities (latter will be set later)