mklein mae239 termpaper 20mar2013

7/29/2019 MKlein MAE239 TermPaper 20Mar2013

1/17

UNIVERSITY OF CALIFORNIA, DAVIS

Transient 2d Heat Transfer with

Convective Boundary Conditions using

the Finite Element MethodThe 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 and to act as a tool for Dr.

Parks Green Transportation Lab in conducting battery pack thermal managementresearch.


2/17

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 then the cell dimensions,

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

power and long term life. Thus highest level goal of this research is 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 and be of realistic magnitude for a term project.

BACKGROUND AND OBJECTIVES

Figure 1, Figure 2, and Figure 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 development


3/17

of a FEM code that models the temperature distribution in two dimensions within a cell as an

introductory learning example.

Figure 1 - Exploded view of the battery module chill plate

Figure 2 - Assembled battery module in CAD


4/17

Figure 3 - Exploded view of the full battery module

Typically a Finite Element Method package will contain three main sections: 1) Pre-proccesor, 2)

Solver, and 3) Post-processor. In the course lecture setting most attention is paid on section 2, the

solving and developing 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 and an appropriate place to start, 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 the users problem, 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 very watered down 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


5/17

generation and the convection coefficient as a function of time will be added as well to study the

temperature gradients 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 albeit a streamlined

version of the story. The intent here is for it to possibly serve as a learning tool for future others

that may be working on a similar project.

METHOD

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);end

end

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

See Figure 4 for an example of the numbering scheme and the coordinate directions used here.

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_xk=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


6/17

Figure 4 - Numbering scheme used for this code. The numbers around the edges of the elements are the nodal

numbers and the numbers near the middle of the elements in bold letters of a slightly larger font are the element

numbers.

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

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. See Figure 5 for an example of the separation of which element is which.

Figure 5 - This figure shows an example of how the elements are broken up. The blue box highlights the "core"

elements. The green boxes highlight the "boundary" elements and those are either bottom, right, top or left.

Finally, those left white are the "corner elements.

x

y


7/17

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_elems

top_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.


8/17

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);


9/17

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);

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


10/17

This simplifies to:

where,


11/17

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 and then the linear

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

and NTN matrix are 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);


12/17


13/17

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% elementFg = 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


14/17

% Linear shape function system time steppingfor k=2:length(time_s)

Tls(:,k) = Cg\(Fgs+Ggs*Tls(:,k-1));end

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 an animation:

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:


15/17

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.

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

6 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 7

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

distribution over the entire domain.


16/17

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

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


17/17

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 Dr. Parks 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 an 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

mklein mae239 termpaper 20mar2013

Documents