OrigamiSimulator

https://github.com/zzhuyii/origamisimulator
Admin
OrigamiSimulator is a MATLAB package for realistic simulation of active origami structures that...
Tokens:7,878
Snippets:47
Trust Score:8.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Newton-Raphson Loading Setup

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Uses the standard Newton-Raphson force-controlled loading method. Applies incremental loads and solves for equilibrium using Newton-Raphson iterations.

```matlab
% Create Newton-Raphson loading controller
nr = ControllerNRLoading;

% Define boundary conditions
nr.supp = [1, 1, 1, 1;    % Fully fixed nodes
           2, 1, 1, 1;
           3, 0, 1, 1];   % Node 3: free in x, fixed in y,z

% Define applied loads
loadMag = 0.5;  % Load magnitude (N)
nr.load = [10, 0, 0, -loadMag;   % Downward load on node 10
           12, 0, 0, -loadMag];

% Solver parameters
nr.increStep = 50;    % Number of load increments
nr.tol = 1e-6;        % Convergence tolerance
nr.iterMax = 30;      % Maximum iterations

% Optional: elastic support
nr.nonRigidSupport = 1;  % Enable elastic supports
nr.suppElastic = [5, 3, 1000;   % Node 5, z-direction, stiffness 1000
                  6, 3, 1000];

% Visualization
nr.videoOpen = 1;     % Enable animation

% Assign and solve
ori.loadingController{1} = {"NR", nr};
ori.Solver_Solve();

% Plot results
ori.Plot_DeformedHis(ori.newNode, nr.Uhis);
```

--------------------------------

### Displacement Controlled Loading Setup

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Applies loads using a displacement-controlled method with a reference displacement. Useful for capturing snap-through behavior and bistable transitions.

```matlab
% Create displacement-controlled loading controller
dc = ControllerDCLoading;

% Define boundary conditions: [node, x_fixed, y_fixed, z_fixed]
% 1 = fixed, 0 = free
dc.supp = [1, 1, 1, 1;    % Node 1: fully fixed
           2, 1, 1, 1;    % Node 2: fully fixed
           3, 1, 1, 1;    % Node 3: fully fixed
           4, 1, 1, 1];   % Node 4: fully fixed

% Define applied loads: [node, Fx, Fy, Fz]
loadForce = 3;  % Force magnitude (N)
dc.load = [29, 0, 0, loadForce;   % Load on node 29 in z-direction
           30, 0, 0, loadForce;
           31, 0, 0, loadForce;
           32, 0, 0, loadForce];

% Solver parameters
dc.increStep = 50;         % Number of incremental steps
dc.tol = 1e-6;             % Convergence tolerance
dc.iterMax = 30;           % Maximum iterations per step
dc.lambdaBar = 1;          % Load scaling factor
dc.selectedRefDisp = [29, 3]; % Reference: node 29, z-direction

% Visualization options
dc.plotOpen = 1;           % Show final deformed shape
dc.videoOpen = 0;          % Disable animation

% Assign to solver and solve
ori.loadingController{1} = {"DC", dc};
ori.Solver_Solve();

% Access results
Uhis = dc.Uhis;                % Displacement history
strainEnergy = dc.strainEnergyHis; % Strain energy history
```

--------------------------------

### Mechanical Properties Setup

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Configures material and geometric properties for panels and creases, essential for accurate mechanical simulations.

```APIDOC
## Mechanical Properties Setup

### Description
Configure material properties for panels and creases including Young's modulus, Poisson's ratio, and thickness values. These properties are essential for accurate mechanical simulation.

### Method
MATLAB Property Assignment

### Endpoint
N/A (Property Assignment)

### Parameters
N/A

### Request Example
```matlab
% Panel mechanical properties
ori.panelE = 2852e6;          % Young's modulus of panel (Pa)
ori.creaseE = 25e6;           % Young's modulus of creases (Pa)
ori.panelPoisson = 0.4;       % Poisson's ratio of panel
ori.creasePoisson = 0.4;      % Poisson's ratio of crease

% Panel thickness vector (one per panel)
ori.panelThickVec = [2.2e-3; 2.2e-3; 2.2e-3; 2.2e-3];

% Crease thickness vector (one per crease)
ori.creaseThickVec = zeros(ori.oldCreaseNum, 1);
ori.creaseThickVec(1) = 1e-3;
ori.creaseThickVec(2) = 1e-3;

% Panel width for bending stiffness calculation
ori.panelW = 6e-3;

% Diagonal rate factor (controls diagonal spring stiffness)
ori.diagonalRate = 4;  % Default value
```

### Response
N/A (Property Assignment)

### Response Example
N/A
```

--------------------------------

### Modified Generalized Displacement Controlled Method Setup

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

An advanced loading method for applying external forces while controlling generalized displacement. Useful for tracing complex equilibrium paths and snap-through phenomena.

```matlab
% Create MGDCM loading controller
mgdcm = ControllerMGDCMLoading;

% Define boundary conditions
mgdcm.supp = [1, 1, 1, 1;
              2, 1, 0, 0;    % Fixed in x, free in y,z
              3, 1, 0, 1];

% Define loads
loadForce = 0.2;
mgdcm.load = [10, -loadForce, 0, 0;   % Load in negative x
              12, -loadForce, 0, 0];

% Solver parameters
mgdcm.increStep = 70;
mgdcm.tol = 1e-6;
mgdcm.iterMax = 50;
mgdcm.lambdaBar = 1;  % Initial load parameter

% Assign and solve
ori.loadingController{1} = {"MGDCM", mgdcm};
ori.Solver_Solve();
```

--------------------------------

### Setup Mechanical Properties for Origami Simulation

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Configures essential mechanical properties for panels and creases, including Young's modulus, Poisson's ratio, thickness, and panel width. These parameters are crucial for accurate mechanical simulations.

```matlab
% Panel mechanical properties
ori.panelE = 2852e6;          % Young's modulus of panel (Pa)
ori.creaseE = 25e6;           % Young's modulus of creases (Pa)
ori.panelPoisson = 0.4;       % Poisson's ratio of panel
ori.creasePoisson = 0.4;      % Poisson's ratio of crease

% Panel thickness vector (one per panel)
ori.panelThickVec = [2.2e-3; 2.2e-3; 2.2e-3; 2.2e-3];

% Crease thickness vector (one per crease)
ori.creaseThickVec = zeros(ori.oldCreaseNum, 1);
ori.creaseThickVec(1) = 1e-3;
ori.creaseThickVec(2) = 1e-3;

% Panel width for bending stiffness calculation
ori.panelW = 6e-3;

% Diagonal rate factor (controls diagonal spring stiffness)
ori.diagonalRate = 4;  % Default value
```

--------------------------------

### Configure Sequential Loading Controllers

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Sets up and executes a series of loading controllers in sequence for complex simulations. The output state of one controller serves as the input for the next.

```matlab
ori = OrigamiSolver;
% ... define geometry and properties ...

% Step 1: Self-folding to initial configuration
selfFold = ControllerSelfFolding;
selfFold.targetRotZeroStrain = pi * ones(ori.oldCreaseNum, 1);
selfFold.targetRotZeroStrain(3) = pi + 0.3*pi;
selfFold.supp = [1, 0, 0, 1; 2, 0, 0, 1; 4, 1, 1, 1];
selfFold.increStep = 80;
selfFold.videoOpen = 0;

% Step 2: Apply gravity loading
nr = ControllerNRLoading;
nr.supp = [1, 0, 0, 1; 2, 0, 0, 1; 4, 1, 1, 1];
nr.load = [5, 0, 0, -1e-6; 6, 0, 0, -1e-6];
nr.increStep = 50;
nr.videoOpen = 0;

% Step 3: Thermal actuation
thermal = ControllerElectroThermalFolding;
thermal.supp = [1, 0, 0, 1; 2, 0, 0, 1; 4, 1, 1, 1];
thermal.targetCreaseHeating = [3, 0.1];  % 100mW
thermal.thermalStep = 500;
thermal.deltaAlpha = zeros(ori.oldCreaseNum, 1);
thermal.deltaAlpha(3) = 38e-6;
% ... set other thermal properties ...

% Assign all controllers in sequence
ori.loadingController{1} = {"SelfFold", selfFold};
ori.loadingController{2} = {"NR", nr};
ori.loadingController{3} = {"ElectroThermal", thermal};

% Solve all steps
ori.Solver_Solve();

% Combine displacement histories for animation
UhisTotal = cat(1, selfFold.Uhis, nr.Uhis, thermal.Uhis);
ori.Plot_DeformedHis(ori.newNode, UhisTotal);

```

--------------------------------

### OrigamiSolver Class Initialization

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Initializes the main solver class and sets up basic geometry and meshing for the origami structure.

```APIDOC
## OrigamiSolver Class Initialization

### Description
The main solver class that handles all origami simulation. It stores geometry, material properties, thermal properties, contact settings, and loading controllers. Initialize this class first before defining any origami simulation.

### Method
MATLAB Class Initialization

### Endpoint
N/A (Class Initialization)

### Parameters
N/A

### Request Example
```matlab
% Initialize the origami solver
ori = OrigamiSolver;

% Define geometry: node coordinates and panel connectivity
ori.node0 = [0 0 0;           % Node 1
             50e-3 0 0;        % Node 2
             50e-3 50e-3 0;    % Node 3
             0 50e-3 0];       % Node 4

ori.panel0{1} = [1 2 3 4];    % Panel 1 connects nodes 1-2-3-4

% Analyze the original pattern (required before meshing)
ori.Mesh_AnalyzeOriginalPattern();

% Define crease widths for compliant crease model
ori.creaseWidthVec = zeros(ori.oldCreaseNum, 1);
ori.creaseWidthVec(1) = 6e-3;  % Set width for crease 1

% Generate the meshed geometry
ori.Mesh_Mesh();

% Visualize the origami
ori.Plot_UnmeshedOrigami();   % Plot original pattern
ori.Plot_MeshedOrigami();     % Plot meshed geometry
```

### Response
N/A (Class Initialization)

### Response Example
N/A
```

--------------------------------

### Perform Dynamic Simulation with ControllerDynamics

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Sets up and runs a dynamic simulation using the Newmark-beta method. Configure external forces, stress-free angle changes, and visualization settings.

```matlab
% Set density properties for mass calculation
ori.densityCrease = 1200;  % Crease density (kg/m³)
ori.densityPanel = 1200;   % Panel density (kg/m³)

% Create dynamics controller
dynamics = ControllerDynamics;

% Define boundary conditions
dynamics.supp = [1, 1, 1, 1;
                 4, 1, 1, 1;
                 9, 1, 1, 1];

% Time parameters
dynamics.dt = 1e-5;  % Time step (seconds)
step = 10000;        % Total number of steps

% External force history: [step, node, direction]
dynamics.Fext = zeros(step, 18, 3);  % 18 nodes, 3 directions
dynamics.Fext(:, 6, 3) = 1e-7;       % Constant z-force on node 6
dynamics.Fext(:, 7, 3) = 1e-7;       % Constant z-force on node 7

% Self-folding angle history
dynamics.rotTargetAngle = pi * ones(step, 11);  % 11 creases
dynamics.rotTargetAngle(:, 3) = pi + pi/4;      % Step change in crease 3

% Rayleigh damping coefficients
dynamics.alpha = 0.0001;
dynamics.beta = 0.0001;

% Visualization
dynamics.videoOpen = 1;
dynamics.videoCropRate = 100;  % Only save every 100th frame

% Assign and solve
ori.loadingController{1} = {"Dynamics", dynamics};
ori.Solver_Solve();

% Plot tip displacement history
Uhis = dynamics.Uhis;
tipDisp = squeeze(Uhis(:, 6, 3));  % Node 6, z-direction
figure; plot((1:step)*dynamics.dt, tipDisp);
xlabel('Time (s)'); ylabel('Displacement (m)');

```

--------------------------------

### Initialize OrigamiSolver and Define Geometry

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Initializes the OrigamiSolver, defines the initial geometry (nodes and panels), analyzes the pattern, sets crease widths, meshes the geometry, and visualizes the origami structure. This is the foundational step for any simulation.

```matlab
% Initialize the origami solver
ori = OrigamiSolver;

% Define geometry: node coordinates and panel connectivity
ori.node0 = [0 0 0;           % Node 1
             50e-3 0 0;        % Node 2
             50e-3 50e-3 0;    % Node 3
             0 50e-3 0];       % Node 4

ori.panel0{1} = [1 2 3 4];    % Panel 1 connects nodes 1-2-3-4

% Analyze the original pattern (required before meshing)
ori.Mesh_AnalyzeOriginalPattern();

% Define crease widths for compliant crease model
ori.creaseWidthVec = zeros(ori.oldCreaseNum, 1);
ori.creaseWidthVec(1) = 6e-3;  % Set width for crease 1

% Generate the meshed geometry
ori.Mesh_Mesh();

% Visualize the origami
ori.Plot_UnmeshedOrigami();   % Plot original pattern
ori.Plot_MeshedOrigami();     % Plot meshed geometry
```

--------------------------------

### Configure and Plot Origami Simulation Results

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Set viewing parameters and figure properties before calling specific plotting methods for geometry, deformation, and history data.

```matlab
% Set viewing parameters
ori.viewAngle1 = 45;           % Azimuth angle
ori.viewAngle2 = 30;           % Elevation angle
ori.displayRange = 100e-3;      % Axis range (m)
ori.displayRangeRatio = 0.5;   % Ratio for negative axis

% Plot appearance
ori.faceColorAnimation = 'yellow';
ori.faceAlphaAnimation = 1;     % Opacity (0-1)
ori.plotBars = 0;               % Show bar elements
ori.plotUndeformedShape = 1;    % Show undeformed overlay

% Figure size
ori.x0 = 10; ori.y0 = 10;
ori.width = 500; ori.height = 500;

% Static plots
ori.Plot_UnmeshedOrigami();     % Original pattern
ori.Plot_MeshedOrigami();       % Meshed geometry

% Deformed shape
ori.Plot_DeformedShape(ori.newNode, ori.newNode + ori.currentU);

% Deformed shape with temperature
ori.Plot_DeformedShapeTemp(thermal, ori.newNode, ...
    ori.newNode + ori.currentU, thermal.temperatureHis(end,:));

% Animation of loading history
ori.Plot_DeformedHis(ori.newNode, dc.Uhis);

% Detailed results
ori.Plot_LoadHis(dc.loadHis, dc.Uhis);           % Load history
ori.Plot_Energy(dc.Uhis, dc.strainEnergyHis);    % Energy history
ori.Plot_BarStrain(dc);                          % Bar strains
```

--------------------------------

### Enable and Configure Panel Contact Simulation

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Activates inter-panel contact detection for simulations involving self-contact. Requires setting contact parameters like stiffness and distance thresholds.

```matlab
% Enable panel contact
ori.contactOpen = 1;

% Contact parameters
ori.ke = 0.002;          % Contact stiffness scaling factor
ori.d0edge = 1e-3;       % Contact distance for edge points (m)
ori.d0center = 1e-3;     % Contact distance for center points (m)

% Example: Locking linkage with contact
ori = OrigamiSolver;

% Define geometry with multiple panels that may contact
ori.node0 = [...];  % Define nodes
ori.panel0 = {...}; % Define panels
ori.Mesh_AnalyzeOriginalPattern();
ori.Mesh_Mesh();

% Enable contact
ori.contactOpen = 1;
ori.ke = 0.002;
ori.d0edge = 1e-3;
ori.d0center = 1e-3;

% Setup loading and solve
selfFold = ControllerSelfFolding;
selfFold.targetRotZeroStrain = pi * ones(ori.oldCreaseNum, 1);
selfFold.supp = [1, 1, 1, 1; 2, 1, 1, 1];
selfFold.increStep = 30;

ori.loadingController{1} = {"SelfFold", selfFold};
ori.Solver_Solve();

```

--------------------------------

### Simulate Self-Folding Behavior

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Use ControllerSelfFolding to simulate self-folding by altering stress-free folding angles. This models active materials without external mechanical loads. Ensure 'ori' object is initialized.

```matlab
% Create self-folding controller
selfFold = ControllerSelfFolding;

% Define boundary conditions
selfFold.supp = [1, 1, 1, 1;
                 2, 1, 1, 1;
                 13, 0, 0, 1;   % Free in x,y, fixed in z
                 14, 0, 0, 1];

% Set target stress-free angles for each crease
% pi = flat (180 degrees), pi+ratio*pi = mountain fold
% pi-ratio*pi = valley fold
selfFold.targetRotZeroStrain = pi * ones(ori.oldCreaseNum, 1);

ratio = 0.5;  % Folding ratio (0 to 1)
selfFold.targetRotZeroStrain(1) = pi + ratio*pi;  % Mountain fold
selfFold.targetRotZeroStrain(2) = pi - ratio*pi;  % Valley fold
selfFold.targetRotZeroStrain(3) = pi + ratio*pi;

% Solver parameters
selfFold.increStep = 30;
selfFold.tol = 1e-6;
selfFold.iterMax = 50;
selfFold.videoOpen = 1;

% Assign and solve
ori.loadingController{1} = {"SelfFold", selfFold};
ori.Solver_Solve();
```

--------------------------------

### Simulate Environmental Temperature Changes

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Use ControllerChangingTemperature to simulate origami behavior under varying ambient temperatures. This models thermal expansion and contraction. Ensure 'ori' object is initialized.

```matlab
% Create changing temperature controller
tempCtrl = ControllerChangingTemperature;

% Define boundary conditions
tempCtrl.supp = [1, 1, 1, 1;
                 4, 1, 1, 1];

% Set target ambient temperature (Celsius)
tempCtrl.targetAmbientTemperature = 80;

% Bimorph properties for thermal actuation
tempCtrl.deltaAlpha = zeros(ori.oldCreaseNum, 1);
tempCtrl.deltaAlpha(1) = 50e-6;  % CTE difference for crease 1

tempCtrl.Emat1 = 70e9;
tempCtrl.Emat2 = 2e9;
tempCtrl.tmat1 = 0.5e-6;
tempCtrl.tmat2 = 1e-6;

% Solver parameters
tempCtrl.thermalStep = 200;
tempCtrl.tol = 1e-5;

% Assign and solve
ori.loadingController{1} = {"ChangingTemp", tempCtrl};
ori.Solver_Solve();
```

--------------------------------

### Simulate Electro-Thermal Folding

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Use ControllerElectroThermalFolding to simulate electro-thermal actuation via Joule heating. This models coupled electro-thermo-mechanical behavior. Thermal properties must be set before creating the controller. Ensure 'ori' object is initialized.

```matlab
% Set thermal properties first
ori.panelThermalConductVec = [1.3; 0.3; 1.3];  % Thermal conductivity (W/m·K)
ori.creaseThermalConduct = 0.3;
ori.envThermalConduct = 0.6;       % Environment conductivity
ori.t2RT = 750e-6;                 % Environment thickness at RT (m)

% Create electro-thermal controller
thermal = ControllerElectroThermalFolding;

% Define boundary conditions
thermal.supp = [1, 0, 0, 1;
                2, 0, 0, 1;
                3, 0, 1, 1;
                4, 1, 1, 1];

% Thermal boundary panels (act as heat sinks)
thermal.thermalBoundaryPanelVec = [3];
thermal.roomTempNode = [1; 4];  % Nodes held at room temperature

% Bimorph material properties (Timoshenko model)
thermal.deltaAlpha = zeros(ori.oldCreaseNum, 1);
thermal.deltaAlpha(3) = (52-14)*1e-6;  % CTE difference

thermal.Emat1 = 39.5e9;  % Young's modulus material 1 (Pa)
thermal.Emat2 = 2e9;     % Young's modulus material 2 (Pa)
thermal.tmat1 = 0.1e-6;  % Thickness material 1 (m)
thermal.tmat2 = 0.4e-6;  % Thickness material 2 (m)

% Crease heating: [crease_number, power_watts]
qload = 100;  % Power in mW
thermal.targetCreaseHeating = [3, qload/1000];

% Solver parameters
thermal.thermalStep = 500;
thermal.tol = 5e-7;
thermal.videoOpen = 1;

% Assign and solve
ori.loadingController{1} = {"ElectroThermal", thermal};
ori.Solver_Solve();

% Access temperature history
temperatureHis = thermal.temperatureHis;
```

--------------------------------

### Generate Miura Tube Geometry

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Generates Miura tube geometry with customizable dimensions and folding sequence. Supports alternating patterns for complex tubular structures.

```matlab
% Parameters for Miura tube generation
a = 50e-3;            % Panel dimension (m)
b1 = 30e-3;           % First b dimension (m)
b2 = 40e-3;           % Second b dimension (m)
gama1 = 70*pi/180;    % First sector angle (radians)
gama2 = 75*pi/180;    % Second sector angle (radians)
N = 4;                % Number of unit cells
sequence = [1,2,1,2]; % Alternating pattern sequence
Extension = 0.9;      % Extension ratio

% Generate Miura tube geometry
[node0, panel0] = GenerateMiuraTube(a, b1, b2, gama1, gama2, N, sequence, Extension);

% Assign to solver
ori = OrigamiSolver;
ori.node0 = node0;
ori.panel0 = panel0;
```

--------------------------------

### GenerateYoshimuraSheet - Yoshimura Pattern Generator

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Generates the geometry for a Yoshimura origami pattern, known for its cylindrical folding characteristics.

```APIDOC
## GenerateYoshimuraSheet - Yoshimura Pattern Generator

### Description
Generates the geometry of a Yoshimura origami pattern, characterized by triangular facets that form a cylindrical folding pattern. Both m and n parameters should be even numbers.

### Method
MATLAB Function Call

### Endpoint
N/A (Function Call)

### Parameters
N/A

### Request Example
```matlab
% Parameters for Yoshimura sheet generation
a = 50e-3;    % Panel dimension (m)
b = 50e-3;    % Panel dimension (m)
m = 4;        % Number of panels (must be even)
n = 6;        % Number of panels (must be even)
Ext = 0.8;    % Extension ratio

% Generate Yoshimura sheet geometry
[node0, panel0] = GenerateYoshimuraSheet(a, b, m, n, Ext);

% Assign to solver
ori = OrigamiSolver;
ori.node0 = node0;
ori.panel0 = panel0;
ori.Mesh_AnalyzeOriginalPattern();
```

### Response
N/A (Function Call)

### Response Example
N/A
```

--------------------------------

### Generate Miura-Ori Sheet Geometry

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Generates the geometric definition for a Miura-ori origami pattern. This function is useful for creating standard Miura-ori structures with specified dimensions and folding parameters, then assigning them to the solver.

```matlab
% Parameters for Miura sheet generation
a = 50e-3;        % Panel dimension a (m)
b = 50e-3;        % Panel dimension b (m)
gama = 80*pi/180; % Sector angle gamma (radians)
m = 3;            % Number of panels in one direction
n = 2;            % Number of panels in other direction
Ext = 0.99929813; % Extension ratio (0 to 1, 1 = flat)

% Generate Miura sheet geometry
[node0, panel0] = GenerateMiuraSheet(a, b, gama, m, n, Ext);

% Assign to solver
ori = OrigamiSolver;
ori.node0 = node0;
ori.panel0 = panel0;
ori.Mesh_AnalyzeOriginalPattern();
ori.Mesh_Mesh()
```

--------------------------------

### GenerateMiuraSheet - Miura-Ori Pattern Generator

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Generates the geometry for a Miura-ori sheet pattern, a common structure in origami engineering.

```APIDOC
## GenerateMiuraSheet - Miura-Ori Pattern Generator

### Description
Generates the geometry of a Miura-ori sheet pattern, commonly used in origami engineering applications. Returns node coordinates and panel connectivity for specified dimensions and folding parameters.

### Method
MATLAB Function Call

### Endpoint
N/A (Function Call)

### Parameters
N/A

### Request Example
```matlab
% Parameters for Miura sheet generation
a = 50e-3;        % Panel dimension a (m)
b = 50e-3;        % Panel dimension b (m)
gama = 80*pi/180; % Sector angle gamma (radians)
m = 3;            % Number of panels in one direction
n = 2;            % Number of panels in other direction
Ext = 0.99929813; % Extension ratio (0 to 1, 1 = flat)

% Generate Miura sheet geometry
[node0, panel0] = GenerateMiuraSheet(a, b, gama, m, n, Ext);

% Assign to solver
ori = OrigamiSolver;
ori.node0 = node0;
ori.panel0 = panel0;
ori.Mesh_AnalyzeOriginalPattern();
ori.Mesh_Mesh();
```

### Response
N/A (Function Call)

### Response Example
N/A
```

--------------------------------

### Generate Yoshimura Sheet Geometry

Source: https://context7.com/zzhuyii/origamisimulator/llms.txt

Generates the geometric definition for a Yoshimura origami pattern. This function is suitable for creating Yoshimura patterns, which are characterized by triangular facets, with specified dimensions and folding parameters. Note that 'm' and 'n' must be even.

```matlab
% Parameters for Yoshimura sheet generation
a = 50e-3;    % Panel dimension (m)
b = 50e-3;    % Panel dimension (m)
m = 4;        % Number of panels (must be even)
n = 6;        % Number of panels (must be even)
Ext = 0.8;    % Extension ratio

% Generate Yoshimura sheet geometry
[node0, panel0] = GenerateYoshimuraSheet(a, b, m, n, Ext);

% Assign to solver
ori = OrigamiSolver;
ori.node0 = node0;
ori.panel0 = panel0;
ori.Mesh_AnalyzeOriginalPattern()
```
Tokens:
Raw