mae 239-termpaper-20mar2013-mklein

7/29/2019 MAE 239-TermPaper-20Mar2013-MKlein

1/16

UNIVERSITY OF CALIFORNIA, DAVIS

Transient 2d Heat Transfer with

Convective Boundary Conditions using

the Finite Element Method

The development of a MATLAB code

Matthew Klein

3/20/2013

This paper will discuss the development of a MATLAB based code that uses the Finite Element

Method to solve a 2d transient heat conduction problem with convective boundary conditions. It

was specifically developed to meet the course requirements of MAE 239 as well as act as a tool for

Dr. Parks Green Transportation Lab in conducting battery pack thermal management studies.


2/16

INTRODUCTION

Electrochemical devices have characteristics that are greatly temperature dependent. This includes

both the instantaneous electrical performance as well as the long term lifetime performance. For

lithium ion batteries generally low temperature cycling and high temperature storage accelerate

degradation. Thus the lithium ion battery packs in electric vehicles require thermal management

systems in order to control the power capability, lifetime, and of greatest importance to maintain

safe operation. The thermal properties of the batteries and heat transfer system must be

thoroughly analyzed in order to optimize the design and control strategies used to maintain the

proper temperature of the battery at all times. A commonly shared convention in this field is to

control the battery such that the largest temperature difference within the battery pack is 2 C.

This value is selected based on the temperature sensitivity of the performance of lithium batteries

and is likely to be highly conservative, therefore leaving much room for optimization. Pouch cells

are a popular choice for many reasons and are typically stacked and compressed into modules.

This only leaves the edges open for cooling and will then create temperature gradients along the

face of the cell. If one were to understand how that affects performance the cell dimensions and

control strategies and heat transfer system could be optimized for the best instantaneous vehicle

power and long term life. Thus it is the goal of my research to shed new light on understanding the

performance effects of an electric vehicles battery based on how the heat is removed from the cells

(i.e. cell temperature gradient to performance relationship) and how that also couples into the long

term performance. As a start to that end a 2d transient FEM model will be developed here to aid in

system characterization.

BACKGROUND AND OBJECTIVES

Figure 1,Figure 2Figure 3 show different views of the particular battery module under

investigation. In Figure 1 the chill plate that is used to transfer heat to/from the module is shown in

an exploded view. Of primary interest with the design of the chill plate is its capability to transfer

heat with an even temperature distribution across its surface in order to achieve a balanced

temperature distribution within the electrochemical cells (to maintain balanced electrical

performance). The goal here will be to learn how to create a thermal FE model to quantify the heat

transfer capabilities of the cells based on temperature gradient limitations. In the end a model

containing the coupled electrochemical-thermal effects within the cell and the coupled thermal-

fluid effects between the module and the chill plate will be needed, but as a project of this

magnitude is infeasible for a quarter long term project it was decided to focus on the temperature


3/16

distribution in two dimensions within a cell as an introductory learning example of the

development of a FEM code.

Figure 1 - Exploded view of the battery module chill plate

Figure 2 - Assembled battery module in CAD


4/16

Figure 3 - Exploded view of the full battery module

Typically a FEM package will contain three main sections: 1) Pre-proccesor, 2) Solver, and 3) Post-

processor. In a class setting most attention is paid on section 2, the solving of the FEM equations,

e.g. solving the Differential Equation in a discretized domain using shape functions of varying

orders and applying Galerkins approach to the Method of Weighted Residuals. However, as

important as this is obviously, a good code is really nothing without proper attention being paid to

sections 1 and 3 as well. And before actually developing ones own code it is difficult to fully

understand how much attention does need to be paid there. In all actuality those are likely to be

the largest areas of focus for a company developing a package for industry. Think of it this way, it is

the job of a company creating a commercial package to disconnect the user as much as possible

from the gritty details and allow for them as intuitively as possible to solve their problem. Thus

large amounts of work must be done behind the scenes to take their part, create an advanced mesh,

create the global equations for that mesh, solve the system and then present those results in a clear

and understandable fashion. Certainly no easy task and thus the reason why companies like ANSYS,

COMSOL, etc., are able to charge so much for their products.

Here a relatively simple example is undertaken to begin to get a flavor of what it takes to create a

FEM package from scratch. Thus, the final objective here will be to create a code in MATLAB that

can solve for the temperature distribution in a 2d, time dependent heat conduction problem that

has convective boundary conditions. The capability to control the internal heat generation and the

convection coefficient as a function of time will be added as well to study the temperature gradients


5/16

as a function of the control strategy being used. Additionally, this paper will be written in a way

that walks the reader through the development process, in an albeit streamlined version of the

story. The intent here is for it to possibly serve as a learning tool for future generations of students

working on a similar project.

METHODS

SYSTEM GENERATION CODE

PRE-PROCESSING

The resulting code that was developed to meet this projects objective has two main parts. The first

m-file has an initial section which is dedicated to the insertion of material parameters as well as the

number of elements that are to be used for the rectangular mesh. Following that the convective

boundary coefficients and temperatures are defined. After all inputs are defined the elemental

matrices are computed. First the x,y coordinates for all of the nodes are determined. This is done

by the function called elementCoordsand is shown below:

function [n_coords] = elementCoords(n_ele_x,n_ele_y,dx,dy)

n_coords = zeros((n_ele_x+1)*(n_ele_y+1),2);for j = 1:(n_ele_y+1)

for i = 1:(n_ele_x+1)n_coords(i+(j-1)*(n_ele_x+1),1) = dx*(i-1);n_coords(i+(j-1)*(n_ele_x+1),2) = dy*(j-1);

endend

The key to that function is the determination of the index based on the nodal numbering scheme.

Next the nodal numbers that apply to each element are located. This is commonly referred to as the

element connectivity. This utilizes the function findElemNodes, which is displayed below:

function [elem_nodes] = findElemNodes(n_ele_x,n_ele_y)

elem_nodes = zeros(n_ele_x*n_ele_y,4);for j = 1:n_ele_y

for i = 1:n_ele_x

k=i+(j-1)*n_ele_x;elem_nodes(k,1) = k+(j-1);elem_nodes(k,2) = (k+1)+(j-1);elem_nodes(k,3) = (k+(n_ele_x+2))+(j-1);elem_nodes(k,4) = (k+(n_ele_x+1))+(j-1);

endend

After this, based on the entered number of x- and y-elements a function determines which elements

fall into one of three categories: 1) Core elements, 2) Corner elements and 3) Boundary elements.

For the boundary elements those are refined further into which are bottom, right, top and left. The


6/16

elements are separated as such to allow for proper boundary condition application. Hence the core

elements have no external B.C. being applied, the corners take in two different B.C.s and the

boundaries take in a single B.C. on one of its sides based on whether that is located on the bottom,

right, etc. The function findElemsfollows:

function [core_elems,corner_elems,bott_elems,top_elems,right_elems,left_elems] =findElems(n_ele_x,n_ele_y)

% Core elementsnum_core_elems = (n_ele_x-2)*(n_ele_y-2);core_elems = zeros(num_core_elems,1);for j = 1:(n_ele_y-2)

for i = 1:(n_ele_x-2)k=i+(j-1)*(n_ele_x-2);core_elems(k) = (n_ele_x+2) + (i-1) + (j-1)*n_ele_x;

endend% Corner elements%num_corner_elems = 4; % fixed at four as this is a simple rectangular mesh and thus

must have four cornerscorner_elems(1) = 1; % bottom left cornercorner_elems(2) = n_ele_x; % bottom right cornercorner_elems(3) = n_ele_x*n_ele_y; % top right cornercorner_elems(4) = n_ele_x*n_ele_y - (n_ele_x-1); % top left corner

% Bottom elementsnum_bott_elems = (n_ele_x - 2);bott_elems = zeros(num_bott_elems,1);for i = 1:num_bott_elems

bott_elems(i) = 1+i;end

% Top elementsnum_top_elems = (n_ele_x - 2);

top_elems = zeros(num_top_elems,1);for i = 1:num_top_elemstop_elems(i) = (n_ele_x*n_ele_y - (n_ele_x-2))+(i-1);

end

% Right elementsnum_right_elems = (n_ele_y - 2);right_elems = zeros(num_right_elems,1);for i = 1:num_right_elems

right_elems(i) = 2*n_ele_x + (i-1)*n_ele_x;end

% Left elementsnum_left_elems = (n_ele_y - 2);left_elems = zeros(num_left_elems,1);for i = 1:num_left_elems

left_elems(i) = n_ele_x+1 + (i-1)*n_ele_x;end

%--------------------------------------------------------------------------

All of this preliminary work described above essentially develops the mesh and prepares which

elements will get which boundary conditions as well as who is connected to who.


7/16

ELEMENTEQUATIONFORMULATION

Finally, with the completion of the above it is now time to assemble the global system of equations

to prepare it for time-stepping. The equation below describes the general differential equation

being solved here and is used in the application of MWR via Galerkins approach. This is the general

D.E. for transient two-dimensional heat conduction with internal heat generation Q.

(

)

(

)

The equations are derived for a 4-noded rectangular element using linear shape functions. Here a

function was developed using MATLABs built in symbolic function solver to do the error prone

work of integrating the set of equations developed through the use of the MWR. An example of the

code is below:

% This code is currently written to symbolically create the matrices% derived using Galerkin's method on the MWR function for a 2-d square% element heat transfer problem. The boundaries are currently set with% convection and one of the edges has dramatically larger convection due to% the chill plate.function [C,Ktot,Rtot] = SymbolicEqns_LinearShape(dx,dy,h,Tamb,rho,cp)% clc;close;clear;% rho = 2250;% cp = 980;% h=[5 0 0 0];% Tamb = [298 0 0 0];% dx = .1; %m% dy = .1; %m

xc = dx/2;

yc = dy/2;y1 = 0;x1 = 0;y2 = dy;x2 = dx;% rho = 2200; %kg/m^3, average density of the lithium battery% cp = 980; %J/(kg-K), average specific heat of the lithium battery

kx = 25; %W/(m-K), thermal conductivity of the Li-batt in the x-directionky = 25; %W/(m-K), thermal conductivity of the Li-batt in the y-direction

h1 = h(1); %W/(m^2-K), heat transfer coefficient at the bottom edge of the cellh2 = h(2); %W/(m^2-K), heat transfer coefficient at the right edge of the cellh3 = h(3); %W/(m^2-K), heat transfer coefficient at the top edge of the cellh4 = h(4); %W/(m^2-K), heat transfer coefficient at the left edge of the cell

Te1 = Tamb(1);Te2 = Tamb(2);Te3 = Tamb(3);Te4 = Tamb(4);

% Shape functionssyms xypsi = 2*(x-xc)/dx; eta = 2*(y-yc)/dy;N1 = .25*(1-psi)*(1-eta);N2 = .25*(1+psi)*(1-eta);N3 = .25*(1+psi)*(1+eta);


8/16

N4 = .25*(1-psi)*(1+eta);

% derviatives of the shape functions to be used for temperature gradient% interpolationdN1_dx = diff(N1,x);dN2_dx = diff(N2,x);dN3_dx = diff(N3,x);dN4_dx = diff(N4,x);dN1_dy = diff(N1,y);dN2_dy = diff(N2,y);dN3_dy = diff(N3,y);dN4_dy = diff(N4,y);

% Create matrices of the shape functions and the derivatives

N_row = [N1 N2 N3 N4];N_mat = N_row'*N_row;

B_mat = [dN1_dx dN2_dx dN3_dx dN4_dx; dN1_dy dN2_dy dN3_dy dN4_dy];

BT_B = B_mat'*B_mat;

%% Perform integration in order to get element matrices C and K

% Get [C] matrixC1 = int(N_mat,x,x1,x2);C = rho*cp*int(C1,y,y1,y2);

% Get [Kcond] matrix

D = [kx 0;0 ky];BT_Bcond = B_mat'*D*B_mat;

Kc = int(int(BT_Bcond,x,x1,x2),y,y1,y2);

% Get the [Kconv] matrices; there's one for each boundary (four for the squareelement)Kh1 = h1*int(subs(N_mat,y,y1),x,x1,x2);Kh2 = h2*int(subs(N_mat,x,x2),y,y1,y2);Kh3 = h3*int(subs(N_mat,y,y2),x,x1,x2);Kh4 = h4*int(subs(N_mat,x,x1),y,y1,y2);

Ktot = Kc + (Kh1 + Kh2 + Kh3 + Kh4);

%% Finally the right side vectors are to be derived

% Internal heat generationQ = 0;R_Q1 = int(N_row',x,x1,x2);R_Q = int(R_Q1,y,y1,y2);R_Q = Q*R_Q;

% Convective resistance termR_h1 = h1*Te1*int(subs(N_row',y,y1),x,x1,x2);R_h2 = h2*Te2*int(subs(N_row',x,x2),y,y1,y2);R_h3 = h3*Te3*int(subs(N_row',y,y2),x,x1,x2);R_h4 = h4*Te4*int(subs(N_row',x,x1),y,y1,y2);

Rtot = R_Q + (R_h1 + R_h2 + R_h3 + R_h4);


9/16

The general form of the resulting equation from the MWR is as follows:

This simplifies to:

where,


10/16

This is the general equation for three-dimensions and includes constant temperature, heat fluxes

and radiative heat loads, however in this case the additional loads mentioned here are done away

with as well as the third z-dimension. Thus as can be seen in the above code (function:

SymbolicEqns_LinearShape) first some parameter initialization is performed, then the linear

shape functions are created and then differentiated with respect to each spatial dimension. The N

vector and NTN matrix is generated as well as the B and BTB matrices. Finally, once these matrices

are constructed from the shape functions and there partial spatial derivatives the C, K and R

matrices and vector may be computed through integration. Again for the integration the MATLAB

symbolic function is applied.

SYSTEMEQUATIONASSEMBLY

The three outputs from the symbolic element solver are sent to the assemblefunction which

performs the scattering of the elemental values to the respective locations in the globally sized

matrix based on the nodal values for each element. That code is shown below for the core

elements:

function [Kcores1,Ccores1,Rcores1] =assemble(Ktot_core,Ctot_core,Rtot_core,core_elems,dof,elem_nodes,Kcores1,Ccores1,Rcores1)

for i = 1:length(core_elems)nodes = elem_nodes(core_elems(i),:);name = ['K_' num2str(i)];Kcores.(name) = zeros(dof,dof);Kcores.(name)(nodes(1),nodes(1)) = Ktot_core(1,1);Kcores.(name)(nodes(1),nodes(2)) = Ktot_core(1,2);Kcores.(name)(nodes(1),nodes(3)) = Ktot_core(1,3);Kcores.(name)(nodes(1),nodes(4)) = Ktot_core(1,4);Kcores.(name)(nodes(2),nodes(1)) = Ktot_core(2,1);Kcores.(name)(nodes(2),nodes(2)) = Ktot_core(2,2);Kcores.(name)(nodes(2),nodes(3)) = Ktot_core(2,3);Kcores.(name)(nodes(2),nodes(4)) = Ktot_core(2,4);Kcores.(name)(nodes(3),nodes(1)) = Ktot_core(3,1);Kcores.(name)(nodes(3),nodes(2)) = Ktot_core(3,2);Kcores.(name)(nodes(3),nodes(3)) = Ktot_core(3,3);Kcores.(name)(nodes(3),nodes(4)) = Ktot_core(3,4);Kcores.(name)(nodes(4),nodes(1)) = Ktot_core(4,1);Kcores.(name)(nodes(4),nodes(2)) = Ktot_core(4,2);Kcores.(name)(nodes(4),nodes(3)) = Ktot_core(4,3);Kcores.(name)(nodes(4),nodes(4)) = Ktot_core(4,4);

Kcores1 = Kcores.(name) + Kcores1;

Ccores.(name) = zeros(dof,dof);Ccores.(name)(nodes(1),nodes(1)) = Ctot_core(1,1);Ccores.(name)(nodes(1),nodes(2)) = Ctot_core(1,2);Ccores.(name)(nodes(1),nodes(3)) = Ctot_core(1,3);Ccores.(name)(nodes(1),nodes(4)) = Ctot_core(1,4);Ccores.(name)(nodes(2),nodes(1)) = Ctot_core(2,1);Ccores.(name)(nodes(2),nodes(2)) = Ctot_core(2,2);Ccores.(name)(nodes(2),nodes(3)) = Ctot_core(2,3);Ccores.(name)(nodes(2),nodes(4)) = Ctot_core(2,4);Ccores.(name)(nodes(3),nodes(1)) = Ctot_core(3,1);


11/16

Ccores.(name)(nodes(3),nodes(2)) = Ctot_core(3,2);Ccores.(name)(nodes(3),nodes(3)) = Ctot_core(3,3);Ccores.(name)(nodes(3),nodes(4)) = Ctot_core(3,4);Ccores.(name)(nodes(4),nodes(1)) = Ctot_core(4,1);Ccores.(name)(nodes(4),nodes(2)) = Ctot_core(4,2);Ccores.(name)(nodes(4),nodes(3)) = Ctot_core(4,3);Ccores.(name)(nodes(4),nodes(4)) = Ctot_core(4,4);

Ccores1 = Ccores.(name) + Ccores1;

Rcores.(name) = zeros(dof,1);Rcores.(name)(nodes(1)) = Rtot_core(1);Rcores.(name)(nodes(2)) = Rtot_core(2);Rcores.(name)(nodes(3)) = Rtot_core(3);Rcores.(name)(nodes(4)) = Rtot_core(4);

Rcores1 = Rcores.(name) + Rcores1;end

In that function it loops through based on the number of the type of elements it is working on.

Shown for example is for the core elements and hence it uses the number of core elements. It is

computing the globally sized matrix for each element and then simply adding that to the previously

calculated matrix to assemble the full system. This is then performed for all of the different sets of

elements. Finally, after the global matrix is generated for each set of elements those are all summed

together to create the truly full system of equations. This finally finishes the system generation

code and this information is then saved to be loaded by the time-stepping code and then finally the

data must be visualized in some useful manner.

SOLVING:TIME-STEPPING SCHEME

Here a simple Euler forward time stepping scheme was employed. Below is the basic Eulerequation as well as it shown in a simplified form to compute the new temperatures:

[]

[] []

[][[] [] ]Where C, K, and fn are equivalent to the C, K, and R computed for the system, respectively. This

equation is iterated on for as long as one would like to perform a simulation. For thermal systems

selection of the time step size is rather important. If the step size is too large the data will be

complete garbage. Here the following equation was used to compute the necessary step size based

on the systems physical parameters.


12/16

It was found here that the actual time step needed to be much smaller for the system to run.

clc;close;clear;

load('GlobalSys_6by6_030713.mat');

n_ele_x = 6;n_ele_y = 6;dof = (n_ele_x+1)*(n_ele_y+1);%% Numerical Integration of system% Initial uniform domain temperatureTinC = 45;Tinit = 273.1+TinC;% Parameters used to create the time vectorstart_time = 0;k = 25;rho = 2169;

cp = 980;alpha = k/rho/cp;L = .1;lamM = 12*alpha/L^2;dt_crit = 2/lamM;dt = 1/100*dt_crit;end_minutes = 30;end_time = 60*end_minutes;time = start_time:dt:end_time;% Initialize a temperature matrix for the four node linear rectangular% elementTl = zeros(dof,length(time));Tl(:,1) = Tinit*ones(length(dof),1);% Create Euler time stepping system using the linear shape function% element

Fg = dt*Rg;Gg = Cg - dt*Kg;% Linear shape function system time stepping%for i=2:length(time)RT = 25;room_temp = 273.1+RT;i=2;while mean(Tl(:,i-1))>room_temp && i


13/16

The code shown above is the portion that performs the times-stepping. For this particular

simulation a while loop was run until a certain mean temperature was met. This was followed by

inserting the last temperature values as the initial conditions to a second for loop to complete the

simulation. That was run for a fixed amount of time.

POST-PROCESSINGHere the post processing that was completed consisted of creating animations since this data was a

transient set. For that the WriteVideo function of MATLAB was used. The following code is an

example of how to create a simulation:

xmin = 0;xmax = L;ymin = 295; ymax = 320;name2 = 'Cool_6by6_midTemps_Comparison.avi';vid = VideoWriter(name2);vid.Quality = 100;vid.FrameRate = 15;open(vid);n=3;

for j=1:10:length(Ttot(1,:))figure(3)h=plot(x,Ttot(22:28,j),'-*',xbg,Tmc(:,j),'-.');set(h,'LineWidth', n);set(gca,'FontSize',14);axis([xmin xmax ymin ymax]);xlabel('Cell Width, [m]');ylabel('Temperature, [K]');title(['Cool-down from ' num2str(TinC) ' ^oC to ' num2str(RT) ' ^oC, Total Time =

' num2str(((i-1)*dt/60)+end_minutes_s) ' minutes']);legend('FEM','Bond Graph');writeVideo(vid, getframe(gcf));

endclose(vid);winopen(name2);

First a set of limits is set for the plotting axes followed by a name that the video file will take. Then

the video file is started using the VideoWriter function and the quality and frame rate are set. The

vid is opened and finally the for-loop that will step through the time data is begun. It steps through

the length of time and the stepping amount is changed depending on how long one wants the

generated animation to be. Then, within the loop the typical plotting is peformed as well as any

modifications one may want to make to the figure. Finally, the writeVideo/getframe command is

used to tell each figure to become a frame of the video. This then loops through the length of the

time vector and then closes the vid file. Winopen may be used as an option to tell Windows to open

the *.avi file post loop completion.

Additionally, a heat map may be generated nicely using the pcolor plotting function in MATLAB.

The code used here looks like so:


14/16

name1 = 'test1_15minCool_6by6.avi';vid = VideoWriter(name1);vid.Quality = 100;vid.FrameRate = 15;open(vid);% Create an animation and set the color axes to stay fixed based on the% scaling in the initial pcolor plot created belowT = [Tinit, 277, 275;Tinit,278,276;Tinit,277,274];pcolor(T); shading interp; colorbar; caxis manual;set(gca,'nextplot','replacechildren');% run the loop to plot the temp map through time and get the movie framesx = n_coords(:,1); y = n_coords(:,2);for i = 1:(10/dt*dt):length(time)

for j = 1:(n_ele_y+1)for k = 1:(n_ele_x+1)

T(j,k) = Tl(((dof-n_ele_x)+(k-1)-((j-1)*(n_ele_x+1))),i);end

endpcolor(T);shading interp;colorbar;writeVideo(vid, getframe(gcf));

endclose(vid);winopen(name1);

The nested for-loops are used to take the vector of nodal temperatures and generate a matrix in the

shape of the physical object, in this case a 2d grid.

RESULTSShow in the two figures below are screen-shot examples of the data generated by this code. Figure

4 shows the temperature profile along the center line of the 2d grid in the x-direction. Additionally,

shown in this same figure the data from a section of a 3d lumped thermal model of the same battery

module that was generated using the Bond Graph modeling technique is shown for comparison. A

side motivation for generating this code was to use it to validate the BG model that had been

developed in our lab earlier in the year. It turns out that the results are quite similar and this is due

to the proper number of lumps being used and the relatively slow heat transfer rates. Figure 5

shows a screen-shot of the heat map animation that was generated to visualize the temperature

distribution over the entire domain.


15/16

Figure 4 - A screen-shot of the animation that was generated using the first example of the animation code.

Figure 5 - A screen-shot of the animation shown in the second example code for creating animations.


16/16

CONCLUSIONSMuch learning was done in the creation of this code. It proved very useful as an educational tool in

understanding how one may actually use this thing called the Finite Element Method to solve a

differential equation. That was really the core objective here, but as stated in the background

section it was also to make a tool that was useful to the battery thermal management researchbeing conducted in my lab. A 2d transient heat conduction problem with convection boundary

conditions can be solved using this code and this allows for the start of its application to the labs

research. Moving forward, taking what was learned here as a stepping point, developing the

expanded capability of solving a coupled electrochemical-thermal problem as well as the coupled

thermal-fluid problem of the actual battery system will provide the greatest benefit to the labs

research. This work here certainly provided that initial momentum.

REFERENCESNikishkov, Gennadly. (2010). Programming Finite Elements in JavaTM. London: Springer-Verlag.

The main equations shown above were used from Chapter 2.

Chessa, J. 2002. Programming the Finite Element Method with MATLAB.

Website:http://www.math.mcmaster.ca/~bprotas/MATH745b/matlab_fem.pdf

This source was useful to understand someone elses process for developing a similar code.

Cailletaud, G. Finite Element: Matrix Formulation. PowerPoint. Unkown date of publication. Firstviewed 25 February 2013.

http://mms2.ensmp.fr/msi_paris/deformation/transparents/e_ElemFormulation.pdf.

This served useful in wrapping my head around the matrix formulation for one element into

the global size.
http://www.math.mcmaster.ca/~bprotas/MATH745b/matlab_fem.pdfhttp://www.math.mcmaster.ca/~bprotas/MATH745b/matlab_fem.pdfhttp://www.math.mcmaster.ca/~bprotas/MATH745b/matlab_fem.pdfhttp://mms2.ensmp.fr/msi_paris/deformation/transparents/e_ElemFormulation.pdfhttp://mms2.ensmp.fr/msi_paris/deformation/transparents/e_ElemFormulation.pdfhttp://mms2.ensmp.fr/msi_paris/deformation/transparents/e_ElemFormulation.pdfhttp://www.math.mcmaster.ca/~bprotas/MATH745b/matlab_fem.pdf

mae 239-termpaper-20mar2013-mklein

Documents