Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
ME3255_FInalProject/README.md
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
214 lines (182 sloc)
6.73 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
# ME3255_FInalProject | |
I noticed that I was never assigned to a group so I did this project solo | |
## Part A | |
**Problem** | |
Create a central finite difference approximation of the gradient with 3-by-3 interior nodes of w for the given membrane solution in terms of P and T. [w]=membrane_solution3(T,P); The output w should be a vector, but the solution represents a 2D data set w(x,y). | |
**Approach** | |
First off for this part I created a matrix using analysis of the interior nodes of a 5x5 matrix. After that I created a vector for the Y direction, after which it is converted into a vector for the displacement of the nodes. The vector is then transformed to be the surface of the new matrix. | |
``` | |
function [w] = membrane_solution3(T,P) | |
od = ones(8,1); | |
od(3:3:end) = 0; | |
a = -4*diag(ones(9,1))+diag(ones(9-3,1),3)+diag(ones(9-3,1),-3)+diag(od,1)+diag(od,-1); | |
y = -(10/4)^2*(P/T)*ones(9,1); | |
w = a\y; | |
grid on | |
[x,y] = meshgrid(0:10/4:10,0:10/4:10); | |
z = zeros(size(x)); | |
z(2:end-1,2:end-1) = reshape(w,[3 3]); | |
surf(x,y,z) | |
title('Membrane Displacement') | |
xlabel('X (\muM)') | |
ylabel('Y (\muM)') | |
zlabel('Displacement (\muM)') | |
colormap jet | |
shading interp | |
disp(w) | |
end | |
``` | |
## Part B | |
**Problem** | |
Solve for w given a pressure, P=0.001 MPa and tension, T=0.006 uN/um. Plot the result with surf(X,Y,W) where X, Y, and W are the x-, y-, and z-coordinates of each point on the membrane from 0-10um. | |
``` | |
membrane_solution3(0.006,0.001) | |
``` | |
![](assets/README-20ed9cd0.png) | |
## Part C | |
**Problem** | |
Create a general central finite difference approximation of the gradient with n-by-n interior nodes of w for the given membrane solution in terms of P and T. [w]=membrane_solution(T,P,n); The output w should be a vector, but the solution represents a 2D data set w(x,y). | |
**Approach** | |
This part of the assignment was handled similarly to part A, as the only thing that changed from the two scripts was the ability of the user to input their own dimensions, which was done by altering the indexing in the function. | |
``` | |
function [w] = membrane_solution3(T,P) | |
od = ones(8,1); | |
od(3:3:end) = 0; | |
a = -4*diag(ones(9,1))+diag(ones(9-3,1),3)+diag(ones(9-3,1),-3)+diag(od,1)+diag(od,-1); | |
y = -(10/4)^2*(P/T)*ones(9,1); | |
w = a\y; | |
grid on | |
[x,y] = meshgrid(0:10/4:10,0:10/4:10); | |
z = zeros(size(x)); | |
z(2:end-1,2:end-1) = reshape(w,[3 3]); | |
surf(x,y,z) | |
title('Membrane Displacement') | |
xlabel('X (\muM)') | |
ylabel('Y (\muM)') | |
zlabel('Displacement (\muM)') | |
colormap jet | |
shading interp | |
disp(w) | |
end | |
``` | |
## Part D | |
**Problem** | |
Solve for w given a pressure, P=0.001 MPa and tension, T=0.006 uN/um with 10 interior nodes. Plot the result with surf(X,Y,W) where X, Y, and W are the x-, y-, and z-coordinates of each point on the membrane from 0-10um. Include the graph in your README. | |
``` | |
membrane_solution(0.006,0.001,10) | |
``` | |
![](assets/README-579fb915.png) | |
## Part E | |
**Problem** | |
Create a function SE_diff that calculates the difference in strain energy (right hand side Eq. 4) and work done by pressure (left hand side Eq. 4) for n-by-n elements. | |
[pw_se,w]=SE_diff(T,P,n) | |
Use the solution from part c to calculate w, then do a numerical integral over the elements to calculate work done and strain energy. | |
**Approach** | |
The first thing I did was pull the solution from membrane_solution.m, after which the average displacement of each node was calculated. This was done through taking the displacement at each corner, after which it was all averaged. The same was done for the left and right points (boundary conditions). | |
``` | |
function [pw_se,w]=SE_diff(T,P,n) | |
E = 1e6; | |
v = .31; | |
t = .0003; | |
h = 10/(n+1); | |
w = membrane_solution(T,P,n); | |
z = zeros(n+2); | |
z(2:end-1,2:end-1) = reshape(w,[n n]); | |
nt = n + 1; | |
wn = zeros(nt); | |
for i = 1:nt | |
for j = 1:nt | |
wn(i,j) = mean([z(i,j),z(i+1,j),z(i,j+1),z(i+1,j+1)]); | |
end | |
end | |
pw = sum(sum(wn.*h^2.*P)); | |
dwdx = zeros(nt); | |
dwdy = zeros(nt); | |
for i = 1:nt | |
for j = 1:nt | |
dwdx(i,j) = mean([z(i+1,j)-z(i,j),z(i+1,j+1)-z(i,j+1)]); | |
dwdy(i,j) = mean([z(i,j+1)-z(i,j),z(i+1,j+1)-z(i+1,j)]); | |
end | |
end | |
se = E*t*h^2/(2*(1-v^2))*sum(sum(0.25.*dwdx.^4+.25.*dwdy.^4+0.5.*(dwdx.*dwdy).^2)); | |
pw_se = pw-se; | |
``` | |
## Part F | |
**Problem** | |
Use a root-finding method to calculate the tension in the membrane given a pressure, P=0.001 MPa, and n=[20:5:40] interior nodes. | |
Show that the error in tension is decreasing with a table | |
**Approach** | |
Using previous knowledge of bisecting functions, as well as the outputs of the SE_diff function, the script ran every single iteration for the different amounts of nodes. The script then saves the values as a vector T, from which it is able to compare and output error from rel_error. | |
``` | |
function [root,fx,ea,iter]=bisect(func,xl,xu,es,maxit,varargin) | |
if nargin<3,error('at least 3 input arguments required'),end | |
test = func(xl,varargin{:})*func(xu,varargin{:}); | |
if nargin<4||isempty(es), es=0.0001;end | |
if nargin<5||isempty(maxit), maxit=50;end | |
iter = 0; xr = xl; ea = 100; | |
while (1) | |
xr_old = xr; | |
xr = (xl + xu)/2; | |
iter = iter + 1; | |
if xr ~= 0,ea = abs((xr - xr_old)/xr) * 100;end | |
test = func(xl,varargin{:})*func(xr,varargin{:}); | |
if test < 0 | |
xu = xr; | |
elseif test > 0 | |
xl = xr; | |
else | |
ea = 0; | |
end | |
if ea <= es || iter >= maxit,break,end | |
end | |
root = xr; fx = func(xr, varargin{:}); | |
``` | |
``` | |
function [T,ea] = tension_sol(P,n) | |
y =@(T) SE_diff(T,P,n); | |
[T,fx,ea,iter]=bisect(y,.01,1); | |
``` | |
``` | |
n=[3,20:5:40]; | |
P=0.001; | |
T = zeros(1,length(n)); | |
ea = zeros(1,length(n)); | |
for i = 1:length(n) | |
[T(i), ea(i)] = tension_sol(P,n(i)); | |
end | |
``` | |
|number of nodes|Tension (uN/um)| rel. error| | |
|---|---|---| | |
|3 |0.049 |n/a| | |
|20|0.0599|20.5%| | |
|25|0.0601|0.27%| | |
|30|0.0602|0.16%| | |
|35|0.0602|0.09%| | |
|40|0.0603|0.05%| | |
## Part G | |
**Problem** | |
Plot the Pressure vs maximum deflection (P (y-axis) vs max(w) (x-axis)) for P=linspace(0.001,0.01,10). Use a root-finding method to determine tension, T, at each pressure. Use a cubic best-fit to find A, where, P(x)=A*dw^3. State how many interior nodes were used for the graph. Plot the data and best-fit curve in your README. | |
**Approach** | |
Utilizing the previous tension_sol results, the script runs all the iterations of pressure and tension. After this it also calculates the maximum deflection of every single iteration. The results are plotted as a linear regression, and plotted on the chart pictured below. | |
``` | |
No = linspace(.001,.01,10); | |
n = 20; | |
T = zeros(1,length(No)); | |
wmax = zeros(1,length(No)); | |
for i = 1:length(No) | |
T(i) = tension_sol(No(i),n); | |
w = membrane_solution(T(i),No(i),n); | |
wmax(i) = max(w); | |
end | |
clf | |
x = wmax'; | |
y = No'; | |
Z=x.^3; | |
a=Z\y; | |
x_fcn=linspace(min(x),max(x)); | |
plot(x,y,'o',x_fcn,a*x_fcn.^3) | |
title('Pressure vs Maximum Deflection') | |
xlabel('Maximum Deflection (\muM)') | |
ylabel('Pressure (MPa)') | |
``` | |
![](assets/README-bbfc19b7.png) |