Effective thermal conductivity#
Usually, after the design of the circuitry, the empty space on chips gets filled with equally spaced small rectangles in each layer. Optically, these structures are supposed to be far enough away that their influence on the structures can be neglected. But for thermal considerations, those fill structures can have an impact on the temperature distribution on the chip and thus e.g. on the crosstalk between thermal phase shifters. As it’s computationally challenging to include all the small cuboids in the model (which is especially for the meshing a major challenge), a preferable approach is to consider the filled area as a homogenous area of higher thermal conductivity. For this, we calculate the effective thermal conductivity of the filled area by examining a single unit cell.
To have an intuitively understandable problem, we consider half of the unit cell to be filled with a highly thermally conductive material (metal/silicon) surrounded by a material with low thermal conductance (e.g. silicon dioxide) Let’s start with the mesh!
unitcell_width = 0.8
unitcell_length = 0.8
unitcell_thickness = 0.387
fill_width = 0.4
fill_length = 0.4
fill_thickness = 0.22
0.22
PyError (PyImport_ImportModule
The Python package meshwell.model could not be imported by pyimport. Usually this means
that you did not install meshwell.model in the Python version being used by PyCall.
PyCall is currently configured to use the Python version at:
/home/runner/miniconda3/bin/python3
and you should use whatever mechanism you usually use (apt-get, pip, conda,
etcetera) to install the Python package containing the meshwell.model module.
One alternative is to re-configure PyCall to use a different Python
version on your system: set ENV["PYTHON"] to the path/name of the python
executable you want to use, run Pkg.build("PyCall"), and re-launch Julia.
Another alternative is to configure PyCall to use a Julia-specific Python
distribution via the Conda.jl package (which installs a private Anaconda
Python distribution), which has the advantage that packages can be installed
and kept up-to-date via Julia. As explained in the PyCall documentation,
set ENV["PYTHON"]="", run Pkg.build("PyCall"), and re-launch Julia. Then,
To install the meshwell.model module, you can use `pyimport_conda("meshwell.model", PKG)`,
where PKG is the Anaconda package that contains the module meshwell.model,
or alternatively you can use the Conda package directly (via
`using Conda` followed by `Conda.add` etcetera).
) <class 'ModuleNotFoundError'>
ModuleNotFoundError("No module named 'meshwell.model'")
Stacktrace:
[1] pyimport(name::String)
@ PyCall ~/.julia/packages/PyCall/1gn3u/src/PyCall.jl:558
[2] top-level scope
@ In[2]:8
For simplicity, we define the thermal conductivity of the unitcell to be 1 and the thermal conductivity of the fill to be 100, which is almost negligible in comparison.
thermal_conductivities = ["unitcell" => 1.4, "fill" => 400]
model = GmshDiscreteModel("mesh.msh")
Ω = Triangulation(model)
dΩ = Measure(Ω, 1)
labels = get_face_labeling(model)
tags = get_face_tag(labels, num_cell_dims(model))
τ = CellField(tags, Ω)
thermal_conductivities =
Dict(get_tag_from_name(labels, u) => v for (u, v) in thermal_conductivities)
ϵ_conductivities(tag) = thermal_conductivities[tag]
We define the temperatures at both sides of the unitcell to define the direction in which we want to estimate the thermal conductivity. In other directions the boundaries are considered to be insulating/mirroring.
We start with calculating the temperature distribution. From this, we calculate, analog to how we calculate resistances for electrical simulations first the integral $\int σ \left|\frac{\mathrm{d}T}{\mathrm{d}\vec{x}}\right|^2 dA which gives an equivalent of the power and calculate from this the effective thermal conductivity. We expect the thermal conductivity almost twice as high as the thermal conductivity of the material with lower thermal conductivity.
boundary_temperatures = Dict("left___unitcell" => 100.0, "right___unitcell" => 0.0)
T0 = calculate_temperature(
ϵ_conductivities ∘ τ,
CellField(x -> 0, Ω),
boundary_temperatures,
order = 2,
)
temperature_difference = abs(sum(values(boundary_temperatures) .* [-1, 1]))
power = abs(
sum(
∫(gradient(temperature(T0)) ⋅ (ϵ_conductivities ∘ τ) ⋅ gradient(temperature(T0)))dΩ,
),
)
println(
"Effective thermal conductivity: ",
(power / temperature_difference^2) /
((unitcell_thickness * unitcell_width) / unitcell_length),
)
boundary_temperatures = Dict("above___unitcell" => 100.0, "below___unitcell" => 0.0)
T0 = calculate_temperature(
ϵ_conductivities ∘ τ,
CellField(x -> 0, Ω),
boundary_temperatures,
order = 2,
)
temperature_difference = abs(sum(values(boundary_temperatures) .* [-1, 1]))
power = abs(
sum(
∫(gradient(temperature(T0)) ⋅ (ϵ_conductivities ∘ τ) ⋅ gradient(temperature(T0)))dΩ,
),
)
println(
"Effective thermal conductivity: ",
(power / temperature_difference^2) /
((unitcell_length * unitcell_width) / unitcell_thickness),
)