diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Beam.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Beam.md new file mode 100644 index 0000000000..1100524ea5 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Beam.md @@ -0,0 +1,117 @@ + +# class `Beam` +Continuous material linking two nodes. + +### method `Beam.__init__` + +```python +__init__( + start: ansys.codefest.mapdl.mechanics.core.Node, + end: ansys.codefest.mapdl.mechanics.core.Node, + section: ansys.codefest.mapdl.mechanics.core.CrossSection = CrossSection(shape=, dimensions=[0.01]), + material: ansys.codefest.mapdl.constants.Material = Material(name='Steel', density=7850.0, elastic_modulus=210000000000.0, poissons_ratio=0.29, yield_strength=330000000.0, price_per_kg=1.2, id=1), + number: int = None, + stress: float = 0.0 +) → None +``` + + + + + + +--- + +### property Beam.cost + +Return Beam cost + + + +**Returns:** + beam cost as a float, in dollarydoos + +--- + +### property Beam.cross_section_area + +Return beam cross-section area. + + + +**Returns:** + beam area as a float + +--- + +### property Beam.length + +Return beam length + + + +**Returns:** + beam length as float + +--- + +### property Beam.mass + +Return Beam mass + + + +**Returns:** + beam mass ass a float + + + +--- + +## method `Beam.has_been_broken` + +```python +has_been_broken() → bool +``` + +Return True if the beam has experienced stress >= its yield. + + + +**Returns:** + True if any of the bridge has exceeded the equivalent yield stress + +--- + +## method `Beam.is_beam_allowed` + +```python +is_beam_allowed() → tuple[bool, list[str]] +``` + +Return True if beam is allowed by the environment. + +Difference between 'allowed' and 'valid'. All allowed beams are valid but not all valid beams are allowed. + + + +**Returns:** + answer to function question as well as feedback + +--- + +## method `Beam.is_valid` + +```python +is_valid() → tuple[bool, list[str]] +``` + +Return True if this instance of Beam is valid. + +list tuple will contain feedback on why False, or will be empty when True. + + + +**Returns:** + answer to the question posed by the function name as well as feedback + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.BeamXn.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.BeamXn.md new file mode 100644 index 0000000000..80ded29801 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.BeamXn.md @@ -0,0 +1,36 @@ + +# class `BeamXn` +Beam cross-section enum. + +In PyMAPDL the beam cross-sections correspond to the following sectypes. + +* RECT = RECTANGLE = 1 + +* HREC = RECTANGLETUBE = 4 + +* CSOLID = CIRCLE = 2 + +* CTUBE = CYLINDER = 3 + +Dimensions structure for each cross-section shown below: + +RECTANGLE - [width, height] + +RECTANGLETUBE - [total_width, total_height, left_wall_thickness, right_wall_thickness, bottom_wall_thickness, top_wall_thickness] + +CIRCLE - [radius] + +CYLINDER - [inner_radius, outer_radius] + + + +**Examples:** + ```python-repl + >>> import ansys.codefest.mapdl as acf + >>> acf.BeamXn.RECTANGLE + +``` + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Blueprint.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Blueprint.md new file mode 100644 index 0000000000..e378fc199c --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Blueprint.md @@ -0,0 +1,116 @@ + +# class `Blueprint` +The Plan/Blueprint for a simulation. Contains nodes, beams and BCs. + +### method `Blueprint.__init__` + +```python +__init__( + nodes: list[ansys.codefest.mapdl.mechanics.core.Node], + beams: list[ansys.codefest.mapdl.mechanics.core.Beam] +) → None +``` + + + + + + +--- + +### property Blueprint.cost + +Return total cost of material in the blueprint. + + + +**Returns:** + cost of the material in dollary doos + +--- + +### property Blueprint.grid_lims + +Return the populated grid limits. + + + +**Returns:** + the resulting grid limits + +--- + +### property Blueprint.mass + +Return total mass of material in the blueprint. + + + +**Returns:** + mass of material as a float + + + +--- + +## method `Blueprint.is_valid` + +```python +is_valid() → tuple[bool, str] +``` + +Returns True if this Blueprint instance is ready to be converted to a sim. + +A blueprint must contain a list of nodes, a list of beams, a load path (going from node 1 to node 2 via nodes connected by beams), a beam cross-section value and the dimensions of that cross-section. + + + +**Returns:** + answer to function question as well as feedback + +--- + +## method `Blueprint.save_as` + +```python +save_as(file_path: pathlib.Path = WindowsPath('input.txt')) → None +``` + +save blueprint to specified file path. + +Defaults to "input.txt" in your current working directory. + + + +**Args:** + + - `file_path`: path to where you wish to save the file + + + +**Returns:** + None + +--- + +## method `Blueprint.with_challenge_attempt_geometry` + +```python +with_challenge_attempt_geometry( + attempt: ansys.codefest.mapdl.constants.Submission +) → None +``` + +Add challenge attempt geometry to blueprint. + + + +**Args:** + + - `attempt`: design dictionary for this attempt + + + +**Returns:** + None + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.BlueprintConstructionException.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.BlueprintConstructionException.md new file mode 100644 index 0000000000..f30a54986e --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.BlueprintConstructionException.md @@ -0,0 +1,7 @@ + +# class `BlueprintConstructionException` +Exception raised when a blueprint is transformed into a simulation and an error is encountered. + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.BooleanVector.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.BooleanVector.md new file mode 100644 index 0000000000..597cb8a223 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.BooleanVector.md @@ -0,0 +1,85 @@ + +# class `BooleanVector` +3D Boolean vector dataclass. + +Simple 3D vector class for simple boolean operations. Typically used for vectors where components are optional. + +The components are explicitly refewrred to as x, y and z. + + + +**Examples:** + ```python-repl + >>> import ansys.codefest.mapdl as acf + >>> bv = acf.BooleanVector(True, False, True) + >>> bv.y + False + >>> bv.z + True +``` + +### method `BooleanVector.__init__` + +```python +__init__(x: bool, y: bool, z: bool) → None +``` + + + + + + +--- + +### property BooleanVector.false + +If the vector is False in all components return True. + + + +**Returns:** + True if all components are False, otherwise False + +--- + +### property BooleanVector.true + +If the vector is True in all components return True. + + + +**Returns:** + True if all components are True, otherwise False + + + +--- + +## classmethod `BooleanVector.all_false` + +```python +all_false() → BooleanVector +``` + +Return an instance of BooleanVector which is False in all components + + + +**Returns:** + a BooleanVector with all False properties + +--- + +## classmethod `BooleanVector.all_true` + +```python +all_true() → BooleanVector +``` + +Return an instance of BooleanVector which is True in all components + + + +**Returns:** + a BooleanVector with all True properties + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Bridge.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Bridge.md new file mode 100644 index 0000000000..88d6305fa0 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Bridge.md @@ -0,0 +1,64 @@ + +# class `Bridge` +Bridge class returned after a simulation has been executed. + +Possesses a few simple post-processing methods for simulations. + +### method `Bridge.__init__` + +```python +__init__( + simulation: ansys.codefest.mapdl.mechanics.core.Simulation, + design: ansys.codefest.mapdl.constants.Submission +) → None +``` + + + + + + + + +--- + +## method `Bridge.assess_for_breaks` + +```python +assess_for_breaks( + display: bool = False +) → tuple[bool, str, list[ansys.codefest.mapdl.mechanics.core.Beam]] +``` + +Assess which beams have broken, if any, and return a report. + +Returns a bool to say if the bridge was successful or not, as well as the feedback as a string and a list of beam objects containing the stresses of each beam. + + + + + +**Args:** + + - `display`: defaults to False + + + +**Returns:** + tuple of the success, details by beam (as a string), and a list of Beam objects + +--- + +## method `Bridge.plot` + +```python +plot() → tuple[matplotlib.figure.Figure, matplotlib.axes._axes.Axes, matplotlib.colorbar.Colorbar] +``` + +Plot the simulation's stresses and return the figure, axes, and colorbar objects. + + + +**Returns:** + the figure, axes and colorbar of the plot, respectively + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.BuildyMcBuildFace.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.BuildyMcBuildFace.md new file mode 100644 index 0000000000..8697dcdaeb --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.BuildyMcBuildFace.md @@ -0,0 +1,214 @@ + +# class `BuildyMcBuildFace` +Instance of the bridge-building machine: BuildyMcBuildFace. + +You can submit attempts and look at the challenge input via this class. Instances of this class should NOT be created directly, but should be created by one of the `Start` methods. + +### method `BuildyMcBuildFace.__init__` + +```python +__init__( + _blueprint: ansys.codefest.mapdl.mechanics.core.Blueprint, + _challenge: ansys.codefest.mapdl.tools.Challenge, + _mapdl_loc: pathlib.Path = None, + _server: ansys.codefest.mapdl.tools.Server = None, + _BuildyMcBuildFace__log_path: pathlib.Path = WindowsPath('.attempt_logs') +) → None +``` + + + + + + +--- + +### property BuildyMcBuildFace.has_suggestion + +Returns True if this challenge has a suggestion, otherwise, False. + + + +**Returns:** + if the instance has a suggested design available + + + +--- + +## method `BuildyMcBuildFace.build_bridge` + +```python +build_bridge( + design: ansys.codefest.mapdl.constants.Submission, + mapdl_version: int = None +) → Bridge +``` + +Construct bridge from a design. + +Depending on the design this step may take time. The method does three things in this order: + + + +1. Validate the design can be used to create a simulation 2. Create a simulation blueprint from the design 3. Create a simulation from the blueprint and execute it 4. Create a Bridge object with the simulation and return it + +Steps 1 and 2 are typically very fast, but 3 can take significantly longer depending on the complexity of your design. + +If your submission does not pass the validation step, it does not count as an attempt. Include plot=True as an arg if you'd like matplotlib to plot the result as well. + + + +**Examples:** + ```python-repl + >>> import ansys.codefest.mapdl as acf + >>> example = acf.Start.builtin_challenge('1a') + >>> design = example.suggest_a_design() + >>> bridge = example.build_bridge(design, mapdl_version=231) + >>> success, feedback, beams = bridge.assess_for_breaks() + >>> success + False + >>> feedback + "..." +``` In the following example we do the same again but connect to a remote instance of MAPDL via the `Server` object. + +```python-repl + >>> import ansys.codefest.mapdl as acf + >>> example = acf.Start.builtin_challenge('1a', + server=acf.Server()) + >>> design = example.suggest_a_design() + >>> bridge = example.build_bridge(design) + >>> success, feedback, beams = bridge.assess_for_breaks() + >>> success + False + >>> feedback + "..." +``` + +Materials can optionally be included in the design as a list of IDs (integers) that correspond to the list of beams. See all the materials available (and their IDs) by accessing the `acf.MATERIALS` dict. + + + +**Args:** + + - `design`: the design you wish to build from + - `mapdl_version`: mapdl version to use (when multiple available and not remote) + + + +**Returns:** + instantiated Bridge object, which can be used to gather results + +--- + +## method `BuildyMcBuildFace.calculate_design_cost` + +```python +calculate_design_cost(design: ansys.codefest.mapdl.constants.Submission) → float +``` + +Calculate how much the provided design would cost + +This does not perform a simulation and the result is returned as a float in dollars. + + + +**Args:** + + - `design`: design dictionary to be used for the calculation + + + +**Returns:** + the cost of the design in dollarydoos + +--- + +## method `BuildyMcBuildFace.display_problem` + +```python +display_problem() → None +``` + +Print the summary text of the challenge. + + + +**Returns:** + None + +--- + +## method `BuildyMcBuildFace.get_fixed_nodes` + +```python +get_fixed_nodes() → list[list[int]] +``` + +Get a list of the fixed nodes (rocks + start + end). + +Returns a list of all rock nodes as well as the start and end nodes. A "node" in this list is a list of 3 integers: + +`[node_number, x_coord, y_coord]` + + + + + +**Notes:** + +> Rock node numbers start at N + 1, where N is the id_ of nodes on the problem square. E.g. if your problem square is 23 x 23, then N = 23^2 N = 529, so the first rock node id_ will be 530, the second 531, and so on. +>The Start and End nodes are ALWAYS numbered 1 and 2, respectively. +> + +**Returns:** + A list of the fixed nodes ordered [number, x, y] + +--- + +## method `BuildyMcBuildFace.plot_design` + +```python +plot_design( + design: ansys.codefest.mapdl.constants.Submission +) → tuple[matplotlib.figure.Figure, matplotlib.axes._axes.Axes, matplotlib.colorbar.Colorbar] +``` + +Plot a bridge design using matplotlib, return fig, ax, and colorbar. + +Optionally you can include the list of beams with results to plot the stresses on each as well. + + + +**Args:** + + - `design`: the design you wish to plot + - `beams`: list of beam objects. Must be in same order (and quantity) as those in `design` + + + +**Returns:** + the figure, axes and colorbar of the plot + +--- + +## method `BuildyMcBuildFace.suggest_a_design` + +```python +suggest_a_design() → Submission +``` + +Return a working design that solves the problem if one is available. + +If a design is not available, then an empty dictionary is returned and a warning raised. + + + +**Notes:** + +> This design will work, but it will not be optimal and may be extremely inefficient and/or costly. It is meant as an example and a starting point. +> + +**Returns:** + the suggested design, if it is available + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Challenge.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Challenge.md new file mode 100644 index 0000000000..4a1f5999f2 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Challenge.md @@ -0,0 +1,226 @@ + +# class `Challenge` +Instance of a challenge. + +Stores the geometry file path and the equivalent suggestion & story paths, IF they exist. A suggestion does not need to exist and can be None. If no story is given, + +### method `Challenge.__init__` + +```python +__init__( + _geometry_filename: Union[pathlib.Path, importlib.resources.abc.Traversable], + _story_filename: Union[pathlib.Path, importlib.resources.abc.Traversable], + _suggestion_filename: Union[pathlib.Path, importlib.resources.abc.Traversable] = None +) → None +``` + + + + + + +--- + +### property Challenge.geometry_filename + +The geometry file path. + + + +**Returns:** + ` the location of the geometry file as a pathlib Path + +--- + +### property Challenge.has_suggestion + +True if this challenge has an available suggestion. + + + +**Returns:** + True/False depending on the presence of an available suggestion. + +--- + +### property Challenge.is_available + +Does the geometry file path point to a file? + + + +**Returns:** + If the geometry file path points to a file. + +--- + +### property Challenge.story_filename + +The file path to the story file. + + + +**Returns:** + ` the location of the story file as a pathlib Path + +--- + +### property Challenge.suggestion_filename + +The suggestion file path. + + + +**Returns:** + ` the location of the suggestion json file as a pathlib Path + + + +--- + +## method `Challenge.choose_story_type` + +```python +choose_story_type(story_type) +``` + +Get the correct story file based on the chosen type. + + + +**Args:** + + - `story_type`: enum of which story type you have chosen + + + +**Returns:** + file path to the chosen story + +--- + +## classmethod `Challenge.create_challenge` + +```python +create_challenge( + path_to_level: pathlib.Path, + path_to_suggestion: pathlib.Path = None, + story_type: ansys.codefest.mapdl.constants.StoryType = +) +``` + +Create a Challenge instance from scratch. + + + +**Args:** + + - `path_to_level`: path to where the level file should go + - `path_to_suggestion`: path to where the suggestion file should go + - `story_type`: what sort of instructions should be added to the challenge + + + +**Returns:** + ` The new challenge instance + +--- + +## classmethod `Challenge.create_example` + +```python +create_example( + number: str, + story_type: ansys.codefest.mapdl.constants.StoryType = +) +``` + +Create a Challenge instance from a built-in an example. + + + +**Args:** + + - `number`: aka ID. This will be something like `'8'` or `'1a'` + - `story_type`: what sort of instructions should be added to the challenge + + + +**Returns:** + ` The new challenge instance + +--- + +## method `Challenge.get_available_example_ids` + +```python +get_available_example_ids() → list[str] +``` + +Return all available example IDs as a list. + + + +**Returns:** + list of IDs as strings. + +--- + +## method `Challenge.get_available_suggestion_ids` + +```python +get_available_suggestion_ids() +``` + +Get available example IDs which also have associated suggestions. + + + +**Returns:** + list of IDs as strings. + +--- + +## method `Challenge.get_fixed_nodes` + +```python +get_fixed_nodes() → list[list[int]] +``` + +Get list of fixed nodes for this example + + + +**Returns:** + list of fixed nodes as [number, x, y] + +--- + +## method `Challenge.get_suggestion` + +```python +get_suggestion() → Submission +``` + +Get suggested design dictionary (if available) + + + +**Returns:** + suggested design dictionary + +--- + +## method `Challenge.get_text` + +```python +get_text() → str +``` + +Get contents of story file as a string without the problem. + + + +**Returns:** + string of this challenge's story file + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.ChallengeError.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.ChallengeError.md new file mode 100644 index 0000000000..b271193171 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.ChallengeError.md @@ -0,0 +1,7 @@ + +# class `ChallengeError` +Exception raised when an error is encountered in the creation or use of a Challenge object. + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.CrossSection.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.CrossSection.md new file mode 100644 index 0000000000..b016a52359 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.CrossSection.md @@ -0,0 +1,50 @@ + +# class `CrossSection` +Beam cross-section details. + +There are 4 cross-sections available: RECT - BeamXn.RECTANGLE HREC - BeamXn.RECTANGLETUBE CSOLID - BeamXn.CIRCLE CTUBE - BeamXn.CYLINDER + +### method `CrossSection.__init__` + +```python +__init__( + shape: ansys.codefest.mapdl.constants.BeamXn, + dimensions: list[float] +) → None +``` + + + + + + +--- + +### property CrossSection.area + +Return the cross-sectional area of the beam. + + + +**Returns:** + Beam area as a float + + + +--- + +## method `CrossSection.is_valid` + +```python +is_valid() → tuple[bool, list[str]] +``` + +Return True if this instance of CrossSection has valid param values. + +If it is not valid, feedback will be a list of strings explaining why the Node is invalid. + + + +**Returns:** + answer to question posed by function name as well as feedback. + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Material.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Material.md new file mode 100644 index 0000000000..d6f41eabe6 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Material.md @@ -0,0 +1,27 @@ + +# class `Material` +Dataclass designed to hold material information. + +Instances are immutable + +### method `Material.__init__` + +```python +__init__( + name: str, + density: float, + elastic_modulus: float, + poissons_ratio: float, + yield_strength: float, + price_per_kg: float, + id: int +) → None +``` + + + + + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.NodalBoundaryCondition.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.NodalBoundaryCondition.md new file mode 100644 index 0000000000..a6b01aab55 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.NodalBoundaryCondition.md @@ -0,0 +1,163 @@ + +# class `NodalBoundaryCondition` +Dataclass storing the boundary conditions at a node. + +Warp freedom currently ignored. + +### method `NodalBoundaryCondition.__init__` + +```python +__init__( + force: ansys.codefest.mapdl.mechanics.core.Vector, + translational_freedoms: ansys.codefest.mapdl.mechanics.core.BooleanVector = BooleanVector(x=True, y=True, z=True), + rotational_freedoms: ansys.codefest.mapdl.mechanics.core.BooleanVector = BooleanVector(x=True, y=True, z=True) +) → None +``` + + + + + + + + +--- + +## method `NodalBoundaryCondition.add_rotational_freedoms` + +```python +add_rotational_freedoms() → None +``` + +Add all rotational degrees of freedom to the node + + + +**Returns:** + None + +--- + +## method `NodalBoundaryCondition.add_translation_freedoms` + +```python +add_translation_freedoms() → None +``` + +Add all translational degrees of freedom to the node + + + +**Returns:** + None + +--- + +## classmethod `NodalBoundaryCondition.fixed_point` + +```python +fixed_point( + force: ansys.codefest.mapdl.mechanics.core.Vector = Vector(x=0.0, y=0.0, z=0.0) +) → NodalBoundaryCondition +``` + +Create a fixed point boundary condition with no degrees of freedom + +optionally, you can also supply a force to be applied to the node. + + + +**Args:** + + - `force`: a vector of the force to be applied to the node + + + +**Returns:** + The nodal boundary condition + +--- + +## classmethod `NodalBoundaryCondition.free_point` + +```python +free_point( + force: ansys.codefest.mapdl.mechanics.core.Vector = Vector(x=0.0, y=0.0, z=0.0) +) → NodalBoundaryCondition +``` + +Create a free point boundary condition with all degrees of freedom + +optionally, you can also supply a force to be applied to the node. + + + +**Args:** + + - `force`: a vector of the force to be applied to the node + + + +**Returns:** + The nodal boundary condition + +--- + +## method `NodalBoundaryCondition.has_applied_force` + +```python +has_applied_force() → bool +``` + +If any force has been applied to the node, return True, else False. + + + +**Returns:** + True if force has been applied, False if not. + +--- + +## method `NodalBoundaryCondition.remove_all_freedoms` + +```python +remove_all_freedoms() → None +``` + +Remove all degrees of freedom from the node + + + +**Returns:** + None + +--- + +## method `NodalBoundaryCondition.remove_rotational_freedoms` + +```python +remove_rotational_freedoms() → None +``` + +Remove all rotational degrees of freedom from the node + + + +**Returns:** + None + +--- + +## method `NodalBoundaryCondition.remove_translation_freedoms` + +```python +remove_translation_freedoms() → None +``` + +Remove all translational degrees of freedom from the node + + + +**Returns:** + None + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Node.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Node.md new file mode 100644 index 0000000000..9565edf79a --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Node.md @@ -0,0 +1,142 @@ + +# class `Node` +Point used to join beams together and specify BCs. + +### method `Node.__init__` + +```python +__init__( + number: int, + position: ansys.codefest.mapdl.mechanics.core.Vector, + _boundary_condition: ansys.codefest.mapdl.mechanics.core.NodalBoundaryCondition = None, + type: ansys.codefest.mapdl.mechanics.core.TypeNode = +) → None +``` + + + + + + +--- + +### property Node.boundary_condition + +Getter & setter for the nodal boundary condition. + + + +**Returns:** + The nodal boundary condition + + + +--- + +## classmethod `Node.constructed_node` + +```python +constructed_node(coord: list[typing.Union[int, float]], num: int) → Node +``` + +Create a 'constructed' node. AKA a node from a design. + +Unlike start and end nodes which have fixed node numbers constructed nodes must have a node id_ specified. This can not be an id_ in-use elsewhere. + + + +**Args:** + + - `coord`: x,y coordinate + - `num`: node number + + + +**Returns:** + The created node object + +--- + +## classmethod `Node.end_node` + +```python +end_node(coord: list[typing.Union[int, float]]) → Node +``` + +Create an instance of an 'end' node at a given coordinate. + + + +**Args:** + + - `coord`: x,y coordinate + + + +**Returns:** + The created node object + +--- + +## method `Node.is_valid` + +```python +is_valid() → tuple[bool, list[str]] +``` + +Returns (True, feedback) if this Node instance is valid for use. + +If not valid feedback will be a list of strings explaining why the Node is invalid. + + + +**Returns:** + result and feedback. + +--- + +## classmethod `Node.rock_node` + +```python +rock_node(coord: list[typing.Union[int, float]], num: int) → Node +``` + +Create an instance of a 'rock' node at a given coordinate. + +AKA a fixed point node. + +Unlike start and end nodes which have fixed node numbers the rock node must have a node id_ specified. This can not be a id_ in-use elsewhere. + + + +**Args:** + + - `coord`: x,y coordinate + - `num`: node number + + + +**Returns:** + The created node object + +--- + +## classmethod `Node.start_node` + +```python +start_node(coord: list[typing.Union[int, float]]) → Node +``` + +Create an instance of a 'start' node at a given coordinate. + + + +**Args:** + + - `coord`: x,y coordinate + + + +**Returns:** + The created node object + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.PhysicalLimits.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.PhysicalLimits.md new file mode 100644 index 0000000000..c00ddb9897 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.PhysicalLimits.md @@ -0,0 +1,19 @@ + +# class `PhysicalLimits` +Dataclass to store the physical limits that can be encountered. + +Instances are immutable. + +### method `PhysicalLimits.__init__` + +```python +__init__(smallest: float, largest: float) → None +``` + + + + + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Server.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Server.md new file mode 100644 index 0000000000..4a0b95c96b --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Server.md @@ -0,0 +1,24 @@ + +# class `Server` +Dataclass storing server information for a remote MAPDL connection. + + + +**Args:** + + - `ip`: ip address of the server as a string, defaults to LOCALHOST, usually 127.0.0.1 + - `port`: port of the server as a string, defaults to MAPDL_DEFAULT_PORT, usually "50052". + +### method `Server.__init__` + +```python +__init__(ip: str = '127.0.0.1', port: str = 50052) → None +``` + + + + + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Simulation.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Simulation.md new file mode 100644 index 0000000000..10c87f5a79 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Simulation.md @@ -0,0 +1,236 @@ + +# class `Simulation` +Simulation class. Consumes 1 blueprint instance in order to perform = + +### method `Simulation.__init__` + +```python +__init__( + blueprint: ansys.codefest.mapdl.mechanics.core.Blueprint, + nodes: list[ansys.codefest.mapdl.mechanics.core.Node] = None, + beams: list[ansys.codefest.mapdl.mechanics.core.Beam] = None, + mapdl: ansys.mapdl.core.mapdl.MapdlBase = None, + mapdl_version: int = None, + mapdl_loc: pathlib.Path = None, + server: ansys.codefest.mapdl.tools.Server = None +) → None +``` + + + + + + + + +--- + +## method `Simulation.apply_force` + +```python +apply_force(gravity: bool = True) → None +``` + +Apply forces to nodes as dictated by the blueprint + + + +**Returns:** + None + +--- + +## method `Simulation.assess_for_breaks` + +```python +assess_for_breaks() → tuple[bool, str] +``` + +Assess which beams have broken, if any, and return a report. + +The result will be printed to screen, but, the success and the description of what happened will be returned together as a tuple of a bool and a string. + + + +**Returns:** + tuple[bool, str] + +--- + +## method `Simulation.constrain_dof` + +```python +constrain_dof() → None +``` + +Constrain the simulation's nodes as dictated by the blueprint + + + +**Returns:** + None + +--- + +## method `Simulation.construct_beams` + +```python +construct_beams() → None +``` + +Construct the simulation's beams/elements as dictated by the blueprint + + + +**Returns:** + None + +--- + +## method `Simulation.construct_nodes` + +```python +construct_nodes() → None +``` + +Construct the simulation's nodes as dictated by the blueprint + + + +**Returns:** + None + +--- + +## method `Simulation.execute` + +```python +execute() → None +``` + +Run the entire Simulation script in order. + + + +**Returns:** + None + +--- + +## method `Simulation.fetch_beam_stresses` + +```python +fetch_beam_stresses() → list[tuple[int, float]] +``` + +Fetch the stresses on each beam, and include the beam id_. + +Returns a list of tuples containing the beam id_ and the stress that beam experienced. + + + +**Returns:** + list of all beams, their numbers and their stresses + +--- + +## method `Simulation.plot_result` + +```python +plot_result() → tuple[matplotlib.figure.Figure, matplotlib.axes._axes.Axes, matplotlib.colorbar.Colorbar] +``` + +Plot the simulation's stresses and return the fig, ax, cb objects + + + +**Returns:** + plotting material + +--- + +## method `Simulation.post_process` + +```python +post_process() → None +``` + +Process the results of the simulation. + +Extract and store the max equivalent stress on each beam. + + + +**Returns:** + None + +--- + +## method `Simulation.set_cross_section` + +```python +set_cross_section( + section: ansys.codefest.mapdl.mechanics.core.CrossSection +) → None +``` + +Set the cross-section for all subsequent beams. + + + +**Args:** + + - `section`: CrossSection object + + + +**Returns:** + None + +--- + +## method `Simulation.set_materials` + +```python +set_materials() → None +``` + +Set the materials as dictated by the blueprint + + + +**Returns:** + None + +--- + +## method `Simulation.setup` + +```python +setup() → MapdlBase +``` + +Run the standard MAPDL set up commands and return mapdl namespace. + + + +**Returns:** + MapdlBase + +--- + +## method `Simulation.solve` + +```python +solve() → None +``` + +Run the simulation + +Executes the APDL simulation. + + + +**Returns:** + None + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Start.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Start.md new file mode 100644 index 0000000000..068b0ddd53 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Start.md @@ -0,0 +1,91 @@ + +# class `Start` +Collection of codefest-starting methods. + +Loading built in challenges requires a level id_, but it is also possible to use custom challenges as well, provided they are in the correct format. + +Make sure you are tackling the correct challenge! + +You can easily check which ids are available by calling `acf.Challenge.get_available_example_ids()` to get them as a list of strings. + +or you can create your own challenge/load an external one. + + + +**Examples:** + ```python-repl + >>> import ansys.codefest.mapdl as acf + >>> builder = acf.Start.builtin_challenge(id_='1a') + >>> builder = acf.Start.load_challenge(your_geometry_filepath, + suggestion_file=your_corresponding_suggestion_filepath) +``` + + + + +--- + +## method `Start.builtin_challenge` + +```python +builtin_challenge( + id_: str, + story_type: ansys.codefest.mapdl.constants.StoryType = , + mapdl_loc: pathlib.Path = None, + server: ansys.codefest.mapdl.tools.Server = None +) → BuildyMcBuildFace +``` + +Begin a builtin challenge, using a given id. + +You can also specify the story type. The concise version is the default but a minimalist and verbose version are both available as well. + + + +**Args:** + + - `id_`: ID of challenge to be loaded, e.g. '1' or '11a' etc. + - `story_type`: enum, acf.StoryType + - `mapdl_loc`: path to alternative mapdl executable + - `server`: Optional Server object containing connection details. If present a remote connection will be attempted. + + + +**Returns:** + BuildyMcBuildFace + +--- + +## method `Start.load_challenge` + +```python +load_challenge( + geometry_file: pathlib.Path, + story_type: ansys.codefest.mapdl.constants.StoryType = , + suggestion_file: pathlib.Path = None, + mapdl_loc: pathlib.Path = None, + server: ansys.codefest.mapdl.tools.Server = None +) → BuildyMcBuildFace +``` + +Load an external or custom challenge. + +If you have a corresponding suggestion dictionary it must be included here. + +You can also specify the story type. The concise version is the default but a minimalist and verbose version are both available as well. + + + +**Args:** + + - `geometry_file`: path to the geometry json file + - `story_type`: enum acf.StoryType + - `suggestion_file`: path to suggestion json file + - `mapdl_loc`: path to alternative mapdl executable + - `server`: Optional Server object containing connection details. If present a remote connection will be attempted. + + + +**Returns:** + BuildyMcBuildFace + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.StoryType.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.StoryType.md new file mode 100644 index 0000000000..1e147f14e1 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.StoryType.md @@ -0,0 +1,7 @@ + +# class `StoryType` +The three types of story presentation ranging from least to most verbose. + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Submission.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Submission.md new file mode 100644 index 0000000000..e7f2e69106 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Submission.md @@ -0,0 +1,55 @@ + +# class `Submission` +Challenge submission dictionary schema type. + +This class is a `typing.TypedDict` class that specifies the schema all dictionary submissions should follow to be valid when submitted. All entries can be any order, except where explicitly stated. + + + +**Notes:** + +> The submission should contain details of all the material *to be built* in the challenge. It should not contain any material that has already been constructed by the challenge, unless it is required in order to specify a new object. For example, the start and end nodes (numbered 1 and 2) should NOT be redefined in a submission, however they *can* be used to create beam elements in the `beams` property. All rocks follow similar logic. +> + +**Args:** + + - `nodes`: list of node numbers + - `beams`: list of beams represented by pairs of node numbers + - `load_path`: list of continuous connected nodes, in order, leading from 1 through to 2. + - `cross_section`: list of BeamXn enum objects. This order corresponds to the order of values in the `beams`. + - `dimensions`: list of dimensions for each cross-section. Corresponds to the order of values in the `beams`. + - `materials`: list of materials for each beam, represented as integers. Corresponds to the order of values in the `beams`. + + + +**Examples:** + + +The suggested design for example 1a is shown below. ```python + design = {"nodes": [[3, -2, 1], + [4, -1, 1], + [5, 0, 1], + [6, 1, 1], + [7, 2, 1], + [8, 0, 0], + [9, 0, -1]], + "beams": [[1, 3], + [3, 4], + [4, 5], + [5, 6], + [6, 7], + [7, 2], + [5, 8], + [8, 9], + [9, 59]], + "load_path": [1, 3, 4, 5, 6, 7, 2], + "cross_section": [2, 2, 2, 2, 2, 2, 2, 2, 2], + "dimensions": [[0.025], [0.025], [0.025], [0.025], + [0.025], [0.025], [0.025], [0.025], + [0.025]], + "materials": [1, 1, 1, 1, 1, 1, 3, 3, 3]} +``` + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.TypeNode.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.TypeNode.md new file mode 100644 index 0000000000..42f1af61a0 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.TypeNode.md @@ -0,0 +1,18 @@ + +# class `TypeNode` +Enum for the type a node can be. + +START nodes are those at which you enter a cavern. END nodes are the exit nodes for the caverns. CONSTRUCTED nodes are built by yourself or your machine. ROCK nodes are fixed nodes that are pre-existing in the caverns. + + + +**Examples:** + ```python-repl + >>> new = TypeNode.START + >>> new + +``` + + + + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.Vector.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.Vector.md new file mode 100644 index 0000000000..734dc306b1 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.Vector.md @@ -0,0 +1,57 @@ + +# class `Vector` +3D Float vector dataclass + +Simple 3D vector class for simple operations. Typically used for position, velocity, force, etc. The z-value can be assumed to be 0 because this framework deals only with 2D problems for now. + + + +**Examples:** + ```python-repl + >>> import ansys.codefest.mapdl as acf + >>> v = acf.Vector(1., 2., 3.) +``` + +### method `Vector.__init__` + +```python +__init__(x: float, y: float, z: float = 0.0) → None +``` + + + + + + + + +--- + +## method `Vector.is_non_zero` + +```python +is_non_zero() → bool +``` + +Return True if any component in the vector is non-zero. + + + +**Returns:** + True if any value is non-zero, else False + +--- + +## classmethod `Vector.zero` + +```python +zero() → Vector +``` + +Class method to generate a zero-vector + + + +**Returns:** + all-zero Vector + diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.calc_distance_between_vectors.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.calc_distance_between_vectors.md new file mode 100644 index 0000000000..252ddfcddf --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.calc_distance_between_vectors.md @@ -0,0 +1,23 @@ + +# function `calc_distance_between_vectors` + +```python +calc_distance_between_vectors( + v1: ansys.codefest.mapdl.mechanics.core.Vector, + v2: ansys.codefest.mapdl.mechanics.core.Vector +) → float +``` + +Calculate the distance between 2 cartesian vectors. + + + +**Args:** + + - `v1`: Vector 1 + - `v2`: Vector 2 + + + +**Returns:** + float diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.degrees_to_radians.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.degrees_to_radians.md new file mode 100644 index 0000000000..2de3709498 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.degrees_to_radians.md @@ -0,0 +1,19 @@ + +# function `degrees_to_radians` + +```python +degrees_to_radians(theta: float) → float +``` + +Convert degrees to radians. + + + +**Parameters:** + + - `theta`: angle in degrees + + + +**Returns:** + angle in radians diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.rotate_coordinates.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.rotate_coordinates.md new file mode 100644 index 0000000000..84fb9560b9 --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.rotate_coordinates.md @@ -0,0 +1,22 @@ + +# function `rotate_coordinates` + +```python +rotate_coordinates(nodes: list[list[int]], rotation: float) → list[list[int]] +``` + +Rotate coordinates in the x-y plane about the origin by degrees. + +Works on nodes with any dimension greater than or equal to two. + + + +**Args:** + + - `nodes`: list of x, y coordinates. node number NOT included. + - `rotation`: degrees rotation anti-clockwise from the horizontal + + + +**Returns:** + the rotated node list diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.save_pymapdl_script.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.save_pymapdl_script.md new file mode 100644 index 0000000000..ec4858c4ba --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.save_pymapdl_script.md @@ -0,0 +1,27 @@ + +# function `save_pymapdl_script` + +```python +save_pymapdl_script( + save_path: pathlib.Path = WindowsPath('pymapdl_bridge_simulator.py') +) → None +``` + +Save the PyMAPDL script version of the builder to file. + +This package comes with a pre-built example PyMAPDL script that can be used to streamline testing using pure PyMAPDL and bypassing the codefest library entirely. This function lets you access it. + +In order to get this script to work you will have to provide a design dictionary and set of fixed nodes yourself. + +Defaults to your local directory. + + + +**Args:** + + - `save_path`: path to be saved to. Must end in a `.py` file + + + +**Returns:** + None diff --git a/Markdown/ansys_codefest/ansys.codefest.mapdl.save_simple_pymapdl_script.md b/Markdown/ansys_codefest/ansys.codefest.mapdl.save_simple_pymapdl_script.md new file mode 100644 index 0000000000..12d0232fbd --- /dev/null +++ b/Markdown/ansys_codefest/ansys.codefest.mapdl.save_simple_pymapdl_script.md @@ -0,0 +1,27 @@ + +# function `save_simple_pymapdl_script` + +```python +save_simple_pymapdl_script( + save_path: pathlib.Path = WindowsPath('pymapdl_simple.py') +) → None +``` + +Save a super-simple PyMAPDL example bridge script to file. + +This package comes with a pre-built example PyMAPDL script that can be used to streamline testing using pure PyMAPDL and bypassing the codefest library entirely. This function lets you access it. This version is a simpler pymapdl script. + +This example has been tailored to be as simple as possible whilst still running and does not require additional input to work. + +Defaults to your local directory. + + + +**Args:** + + - `save_path`: path to be saved to. Must end in a `.py` file + + + +**Returns:** + None diff --git a/Markdown/ansys_codefest/docfx.json b/Markdown/ansys_codefest/docfx.json new file mode 100644 index 0000000000..e26ba8df99 --- /dev/null +++ b/Markdown/ansys_codefest/docfx.json @@ -0,0 +1,13 @@ +{ + "build": { + "globalMetadata": { + "title": "Ansys CodeFest package documentation", + "summary": "Ansys CodeFest companion library documentation", + "version": "0.2.0", + "product": "None", + "programming language": "Python", + "product collection": "Structures", + "physics": "Mechanical" + } + } +} \ No newline at end of file diff --git a/Markdown/ansys_codefest/index.md b/Markdown/ansys_codefest/index.md new file mode 100644 index 0000000000..80acf6f662 --- /dev/null +++ b/Markdown/ansys_codefest/index.md @@ -0,0 +1,94 @@ +# Introduction + +Ansys Codefest Companion Library + +## Getting Started + +## Package Information + +- Name - ansys-codefest +- Version - 0.2.0 +- Author-email - "ANSYS, Inc." +- Maintainer-email - "ANSYS, Inc." +- Requires-Python - >=3.11,<4 +- Description-Content-Type - text/markdown +- Classifier - Development Status :: 4 - Beta +- Classifier - Intended Audience :: Science/Research +- Classifier - Topic :: Scientific/Engineering :: Information Analysis +- Classifier - License :: OSI Approved :: MIT License +- Classifier - Operating System :: OS Independent +- Classifier - Programming Language :: Python :: 3.11 +- Classifier - Programming Language :: Python :: 3.12 +- Classifier - Programming Language :: Python :: 3.13 +- Requires-Dist - Markdown>=3.6 +- Requires-Dist - matplotlib>=3.9.0 +- Requires-Dist - ipython>=8.10.0 +- Requires-Dist - ansys-mapdl-core>0.68.0 +- Requires-Dist - jupyter>=1.0.0 + +# Ansys CodeFest Companion Library + +This package is a companion library to Ansys CodeFests. The challenges have varying storylines and contexts, +however, they all have the same common framework. For example, to access the PyMAPDL structures challenges, +execute the following code. + +```python +import ansys.codefest.mapdl as acf + +# Challenge ids are *always* strings because some contain letters as well as numbers. +challenge = acf.Start.builtin_challenge('1a') +challenge.display_problem() +``` + +Then, once the specific challenge has been detailed, you can submit solution attempts using the following commands. + +```python +import ansys.codefest.mapdl as acf + +# Challenge ids are *always* strings because some contain letters as well as numbers. +challenge = acf.Start.builtin_challenge('1a') +design = challenge.suggest_a_design() +bridge = challenge.build_bridge(design) +success, feedback, beams = bridge.assess_for_breaks() +print(f'Bridge costs ${challenge.calculate_design_cost(design)} dollarydoos') +bridge.plot() +``` + +The program will then test your attempt and provide feedback about what you did wrong (if anything). +Finally, it will give a breakdown of all the elements you used and how close to the yield strength they came as +percentages. + + + +## Reference + +* [Beam](ansys.codefest.mapdl.Beam.md) +* [BeamXn](ansys.codefest.mapdl.BeamXn.md) +* [Blueprint](ansys.codefest.mapdl.Blueprint.md) +* [BlueprintConstructionException](ansys.codefest.mapdl.BlueprintConstructionException.md) +* [BooleanVector](ansys.codefest.mapdl.BooleanVector.md) +* [Bridge](ansys.codefest.mapdl.Bridge.md) +* [BuildyMcBuildFace](ansys.codefest.mapdl.BuildyMcBuildFace.md) +* [Challenge](ansys.codefest.mapdl.Challenge.md) +* [ChallengeError](ansys.codefest.mapdl.ChallengeError.md) +* [CrossSection](ansys.codefest.mapdl.CrossSection.md) +* [Material](ansys.codefest.mapdl.Material.md) +* [NodalBoundaryCondition](ansys.codefest.mapdl.NodalBoundaryCondition.md) +* [Node](ansys.codefest.mapdl.Node.md) +* [PhysicalLimits](ansys.codefest.mapdl.PhysicalLimits.md) +* [Server](ansys.codefest.mapdl.Server.md) +* [Simulation](ansys.codefest.mapdl.Simulation.md) +* [Start](ansys.codefest.mapdl.Start.md) +* [StoryType](ansys.codefest.mapdl.StoryType.md) +* [Submission](ansys.codefest.mapdl.Submission.md) +* [TypeNode](ansys.codefest.mapdl.TypeNode.md) +* [Vector](ansys.codefest.mapdl.Vector.md) +* [calc_distance_between_vectors](ansys.codefest.mapdl.calc_distance_between_vectors.md) +* [degrees_to_radians](ansys.codefest.mapdl.degrees_to_radians.md) +* [rotate_coordinates](ansys.codefest.mapdl.rotate_coordinates.md) +* [save_pymapdl_script](ansys.codefest.mapdl.save_pymapdl_script.md) +* [save_simple_pymapdl_script](ansys.codefest.mapdl.save_simple_pymapdl_script.md) + + +This reference documentation was automatically generated using [lazydocs](https://github.com/ml-tooling/lazydocs). + \ No newline at end of file diff --git a/Markdown/ansys_codefest/toc.yml b/Markdown/ansys_codefest/toc.yml new file mode 100644 index 0000000000..4c43ce16f6 --- /dev/null +++ b/Markdown/ansys_codefest/toc.yml @@ -0,0 +1,57 @@ + +- name: Introduction + href: index.md +- name: Reference + items: + - name: Beam + href: ansys.codefest.mapdl.Beam.md + - name: BeamXn + href: ansys.codefest.mapdl.BeamXn.md + - name: Blueprint + href: ansys.codefest.mapdl.Blueprint.md + - name: BlueprintConstructionException + href: ansys.codefest.mapdl.BlueprintConstructionException.md + - name: BooleanVector + href: ansys.codefest.mapdl.BooleanVector.md + - name: Bridge + href: ansys.codefest.mapdl.Bridge.md + - name: BuildyMcBuildFace + href: ansys.codefest.mapdl.BuildyMcBuildFace.md + - name: Challenge + href: ansys.codefest.mapdl.Challenge.md + - name: ChallengeError + href: ansys.codefest.mapdl.ChallengeError.md + - name: CrossSection + href: ansys.codefest.mapdl.CrossSection.md + - name: Material + href: ansys.codefest.mapdl.Material.md + - name: NodalBoundaryCondition + href: ansys.codefest.mapdl.NodalBoundaryCondition.md + - name: Node + href: ansys.codefest.mapdl.Node.md + - name: PhysicalLimits + href: ansys.codefest.mapdl.PhysicalLimits.md + - name: Server + href: ansys.codefest.mapdl.Server.md + - name: Simulation + href: ansys.codefest.mapdl.Simulation.md + - name: Start + href: ansys.codefest.mapdl.Start.md + - name: StoryType + href: ansys.codefest.mapdl.StoryType.md + - name: Submission + href: ansys.codefest.mapdl.Submission.md + - name: TypeNode + href: ansys.codefest.mapdl.TypeNode.md + - name: Vector + href: ansys.codefest.mapdl.Vector.md + - name: calc_distance_between_vectors + href: ansys.codefest.mapdl.calc_distance_between_vectors.md + - name: degrees_to_radians + href: ansys.codefest.mapdl.degrees_to_radians.md + - name: rotate_coordinates + href: ansys.codefest.mapdl.rotate_coordinates.md + - name: save_pymapdl_script + href: ansys.codefest.mapdl.save_pymapdl_script.md + - name: save_simple_pymapdl_script + href: ansys.codefest.mapdl.save_simple_pymapdl_script.md