Free CAD, FeniCS or paraview

Structural Optimization in Additive Manufacturing

II

Project Colder-Power-Chip

Bindu Saranya Krovi

Uday Sai Kiran Chitturi

Soma N V R M Pujari

1. OBJECTIVE

The aim of the project is to perform a study on a microchip where different sections are emitting different amount of heat, followed by designing an effective heat exchanger to allow a lightweight electronic device without active ventilation. The power maybe increased more than that of an Apple M1 chip, hence it is used as a reference.

2. DIMENSIONS AND HEAT GENERATION

The Apple M1 chip, a system-on-a-chip measuring around 121mm2 is known for its performance and efficiency. It contains an 8-core GPU and CPU, a 16-core Neural Engine and over 16 billion transistors, typically made of silicon. The approximated dimensions and power generated according to the available sources have been given in Table1. The dimensions of the different components have been shown in Figure 2.1 and 2.2. The material properties of silicon have been used.

Figure 2.1. Apple M1 chip inside (in mm)

The heat generated in microchips is a critical aspect of their operation, often posing significant challenges in design and efficiency. While operating, it is the CPU and GPU which contribute

to most of the heat as they are the workhorses of computing, performing vast numbers of calculations, rendering complex graphics and other tasks. Apart from these two, components such as the secure enclave, which is present to handle cryptographic operations related to security functions, the Neural engine, present to accelerate machine learning tasks, and the DRAM, which stores data temporarily, generate less heat comparatively. The heat data is given in table 2.1.

Figure 2.2. Parts inside the chip (in mm)

Sl no. Component Dimensions (mm) Heat (W)

1 CPU 3x2 10

2 GPU 3x3 15

3 Neural engine 1.5x2 6

4 Secure Enclave 3x1 4

5 DRAM (each) 2.6125x5.225 1

Table 2.1: Dimensions & Heat generation data of microchip.

3. TOPOLOGY OPTIMISATION

Topology optimization in the chip stated above in the problem minimizes the material by selectively adding or subtracting, which is used to facilitate adequate distribution of heat without using a fan on it. An electronic chip is typically made of silicon. The temperature had to be minimized using the best topology, which can be seen as the minimum weight. To obtain this, the density distribution should be minimized. But the heat distribution is directly related to the amount of material. Thus, the cost function has been modified with a minimized gradient of density distribution which defines the inverse problem. The cost function is:

C=∫(T+𝜌,i𝜌,i)dV 𝛺

The problem parameters such as geometry, nesh size, boundary conditions and material properties are defined. Finite element spaces are set up for the unknowns, temperature, and density. The direct problem is solved using Newton solver for the nonlinear system to find temperature distribution. The optimization problem of the objective function is set up using adjoint method, where the volume fraction is a constraint, and is solved using Interior Point Optimizer defined by IPOPT solver. The code implemented using Python is attached in appendix.

4. RESULT

The figure 4.1 shows the optimization result after 150 iterations of the microchip with the normalized mass density shown. The colour red indicates the regions of high heat generation and blue has lower.

Figure 4.1: Result of optimization after 150 iterations.

5. DESIGN OF THE COOLING SYSTEM

The motivation of optimizing the microchip was to design an efficient heat sink. Among the electronic cooling systems like liquid cooling, air cooling, thermoelectric, refrigeration, the air cooling is the foremost selected as it is straightforward and low cost [1]. Common types of heat sinks are Plate fin type, square pin type, round pin inline type and round pin staggered type. Using the optimized solution in the figure, two heat sinks were designed.

The first one, shown in figure 5.1a is a combination of plate fins and perforated structure. Initially, the image of the optimized heat sink was inserted on a 2mm slab and the regions with high heat liberation were extruded. It is on this, that the rectangular slot was done, which can be seen in figure 5.1b. This combines the advantage of both perforated and plate fin arrangement by providing more surface area for heat transfer [2] and the rectangular slots also have better thermal performance in comparison to the circular ones [3].

Figure 5.1: a) The heat sink design option 1, b) the Perforations. The other design option is the staggered pin arrangement as shown in figure 5.2. According to Bilen et al, the staggered pin arrangement sink is 33% superior in comparison to inline arrangement [4]. So, by importing the result of optimization, the pins were selectively placed on the red regions, while randomly arranging them in other regions.

Figure 5.2: Staggered pin heat sink.

REFERENCES

[1] Z. Khattak & H.M.Ali,(2018), Air cooled heat sink geometries subjected to forced flow: A critical review. International Journal of Heat and Mass Transfer,141-161. https://doi.org/10.1016/j.ijheatmasstransfer.2018.08.048

[2] M. Shaeri, M. Yaghoubi, Numerical analysis of turbulent convection heat transfer from an array of perforated fins, Int. J. Heat Fluid Flow 30 (2) (2009) 218–228. https://doi.org/10.1016/j.ijheatfluidflow.2008.12.011

[3] A. Al-Damook, N. Kapur, J. Summers, H. Thompson, Computational design and optimisation of pin fin heat sinks with rectangular perforations, Appl. Therm. Eng. 105 (2016) 691–703. https://doi.org/10.1016/j.applthermaleng.2016.03.070

[4] K. Bilen, U. Akyol, S. Yapici, Heat transfer and friction correlations and thermal performance analysis for a finned surface, Energy Convers. Manage. 42 (9) (2001) 1071– 1083. http://dx.doi.org/10.1016/S0196-8904(00)00119-9

APPENDIX- PYTHON CODE

from dolfin import * from dolfin_adjoint

import * import ufl

parameters["std_out_all_processes"] = False

krylov_params = parameters["krylov_solver"]

krylov_params["relative_tolerance"] = 1E-6

krylov_params["absolute_tolerance"] = 1E-7

krylov_params["maximum_iterations"] = 100000

krylov_params["monitor_convergence"] = False

krylov_params["error_on_nonconvergence"] = True

krylov_params["report"] = False

newton_parameters = {"nonlinear_solver": "newton",

"newton_solver":{"linear_solver": "mumps",

"convergence_criterion": "incremental",

"relative_tolerance": 1E-7,

"absolute_tolerance": 1E-8,

"krylov_solver": krylov_params,

"relaxation_parameter":1.0,

"maximum_iterations":100,

"error_on_nonconvergence": True

}

}

# initial geometry and optimization parameters

xlength, ylength = 11., 11. #in mm volfrac =

0.4

penal = 5.0 alpha

= 2.6E-6

def

theta(rho):

return rho ** penal

kappa = 2.3 #in mW/(mm K)

h = 10.*1E-3 #in mW/(mm2 K)

Tamb = 300. #in K

mesh = RectangleMesh(MPI.comm_world, Point(0.0, 0.0), Point(xlength,ylength),

100, 100)

Dim = mesh.topology().dim() cells_mesh =

MeshFunction("size_t", mesh, Dim, 0) facets_mesh =

MeshFunction("size_t", mesh, Dim-1, 0)

# integral measures, volume and surface of the continuum body dA =

Measure('ds', domain=mesh, subdomain_data=facets_mesh,

metadata={'quadrature_degree': 2, "quadrature_scheme": "uflacs"}) dV =

Measure('dx', domain=mesh, subdomain_data=cells_mesh,

metadata={'quadrature_degree': 2, "quadrature_scheme": "uflacs"})

p1 = CompiledSubDomain('1.8 < x[0] && x[0] < 3.8 && 4.5 < x[1] && x[1] <

7.5') p1.mark(cells_mesh, 1) p2 = CompiledSubDomain('3.8 < x[0] && x[0] < 6.8

&& 5 < x[1] && x[1] < 8') p2.mark(cells_mesh, 2) p3 = CompiledSubDomain('1.8 <

x[0] && x[0] < 3.8 && 3 < x[1] && x[1] < 4.5') p3.mark(cells_mesh, 3)

p4 = CompiledSubDomain('3.8 < x[0] && x[0] < 6.8 && 4 < x[1] && x[1] < 5')

p4.mark(cells_mesh, 4)

p5 = CompiledSubDomain('8.2375 < x[0] && x[0] < 10.85 && 5.625 < x[1] && x[1]

< 10.85') p5.mark(cells_mesh, 5) p6 = CompiledSubDomain('8.2375 < x[0] && x[0]

< 10.85 && 0.15 < x[1] && x[1] <

5.375')

p6.mark(cells_mesh, 6)

cells_file =

File("output_fourier/cells.pvd") cells_file

<< cells_mesh

Scalar1 = FunctionSpace(mesh, "P", 1)

Scalar2 = FunctionSpace(mesh, "P", 1)

#one chip of size 10mm x 10m is 30mW power1

= (11.8*1000.)/(2.*3.) #in mW/mm3 #another

chip of size 5mm x 5mm is 10mW power2 =

(11.8*1000.)/(3.*3.) #in mW/mm3 #another

chip of size 15mm x 5mm is 20mW power3 =

9*1000./(1.5*2.) #in mW/mm3 power4 =

2.8*1000/(3.*1.) power5 =

1000/(5.225*2.6125) power6 =

1000/(5.225*2.6125)

i,j = ufl.indices(2)

delta = Identity(Dim)

def directproblem(rho):

T = interpolate(Constant(Tamb), Scalar1)

dT = TrialFunction(Scalar1) del_T =

TestFunction(Scalar1)

Form = theta(rho)*kappa*T.dx(i)*del_T.dx(i)*dV - power1*del_T*dV(1) -

power2*del_T*dV(2) - power3*del_T*dV(3) - power4*del_T*dV(4) -

power5*del_T*dV(5) - power6*del_T*dV(6) + h*(T-Tamb)*del_T*dA

Jacobian = derivative(Form,T,dT)

problem_direct = NonlinearVariationalProblem(Form, T, bcs=[], J=Jacobian)

solver_direct = NonlinearVariationalSolver(problem_direct)

solver_direct.parameters.update(newton_parameters)

solver_direct.solve()

return T

rho = interpolate(Constant(volfrac), Scalar2)

T = directproblem(rho)

T_file = File("output_fourier/T.pvd")

T_file << T

rho_file = File("output_fourier/rho.pvd")

rho_viz = Function(Scalar1, name=r"$\rho$")

def eval_cb(j, rho): assign(rho_viz,

rho) rho_file << rho_viz

cost = assemble( ( T + rho.dx(i)*rho.dx(i) ) * dV) p =

Control(rho) gain = ReducedFunctional(cost, p,

eval_cb_post=eval_cb)

lb =

0.0 ub =

1.0

goal =

Constant

(volfrac

)

volume_c

onstrain

t =

UFLInequ

alityCon

straint(

( goal -

rho)*dx,

p)

problem_inverse = MinimizationProblem(gain, bounds=(lb, ub),

constraints=volume_constraint)

solver_inverse = IPOPTSolver(problem_inverse,

parameters={'maximum_iterations': 150}) solver_inverse.solve()