Foam Conductivity

//One universal basic required here to get things going once loaded
window.onload = function () {
    //restoreDefaultValues(); //Un-comment this if you want to start with defaults
    Main();
};

//Main() is hard wired as THE place to start calculating when inputs change
//It does no calculations itself, it merely sets them up, sends off variables, gets results and, if necessary, plots them.
function Main() {
    //Save settings every time you calculate, so they're always ready on a reload
    saveSettings();

    //Send all the inputs as a structured object
    //If you need to convert to, say, SI units, do it here!
    const inputs = {
        Kgas: sliders.SlideKgas.value, //keep in mW
//        rhorel: sliders.Sliderhorel.value,              
        Fdens: sliders.SlideFdens.value,
        Ksolid: sliders.SlideKsolid.value, //keep in mW
        kabs: sliders.Slidekabs.value * 100, //to m-1
        dgas: sliders.Slidedgas.value*1e-12, //from pm to m
        fs: sliders.Slidefs.value,
        //phiCell: sliders.SlidephiCell.value,
        T: sliders.SlideT.value + 273, //to K
        rhoSolid: sliders.SliderhoSolid.value,
        Asym: sliders.SlideAsym.value,
        phimax: sliders.Slidephimax.value,
        LinearPlot: document.getElementById('LinearPlot').checked,
    };

    //Send inputs off to CalcIt where the names are instantly available
    //Get all the resonses as an object, result


    const result = CalcIt(inputs);

    //Set all the text box outputs
   // document.getElementById('phiStrut').value = result.phiStrut; 
    document.getElementById('rhorel').value = result.rhorel; 
   // document.getElementById('Solid').value = result.sInfo;
    //Do all relevant plots by calling plotIt - if there's no plot, nothing happens
    //plotIt is part of the app infrastructure in app.new.js
    if (result.plots) {
        for (let i = 0; i < result.plots.length; i++) {
            plotIt(result.plots[i], result.canvas[i]);
        }
    }

    //You might have some other stuff to do here, but for most apps that's it for Main!
}

//Here's the app calculation
//The inputs are just the names provided - their order in the curly brackets is unimportant!
//By convention the input values are provided with the correct units within Main
function CalcIt({ Kgas,Ksolid,kabs,Fdens,dgas,fs,rhoSolid,Asym, T, phimax,LinearPlot }) {
    const g=2/3-fs/3
    const rhorel=Fdens/rhoSolid
    const Ks=g*Ksolid*rhorel*Math.sqrt(Asym)*(0.2060*T + 115.5811)/(0.2060*298 + 115.5811)
    Kgas*=(0.07411*T + 3.40294)/(0.07411*298 + 3.40294)
    const n=1+0.4*rhorel
    const kB=1.38e-23,SB=5.67e-8,xsi=1.64,ri2=n*n
    const P=100000 //Not bothering with variable T and P input
    const Lambda=kB*T/(1.414*Math.PI*dgas*dgas*P)
    const Kabs=kabs*rhorel
    const KN1=1.82E-02,	KN2=0.771646381,KN3=0.006352564,KN4=2121.269214
    //Output real foam density
    //const rhoFoam=rhorel*rhoSolid
    
    //Strut calcs in μm from Glicksman
    //const Lv=8.6/(phiCell*phiCell)
    //const a=Math.sqrt(fs*rhorel/(0.29*Lv))
    //const phiStrut=Math.sqrt(4*0.29/Math.PI*a*a)

    let phinm=10, inc=10,phi=0,Kn=0,Kg=0,Kr=0,Kt,N=0,KoverN=0,Kscat=0,HiTerm=0
    let pKs=[],pKg=[],pKr=[],pKt=[]
    while (phinm<=1000*phimax){ //nm steps for convenience
        phi=phinm/1e9
        Kn=Lambda/phi
        Kg=Kgas/(1+2*xsi*Kn)*(1-rhorel)
        N=Math.pow(6/(Math.PI*Math.pow(phi,3))*(1-rhorel),0.3333)
        //The crude fitting function
        KoverN=KN1*Math.pow(phinm,KN2)*KN3*(1-Math.exp(-phinm/KN4))
        Kscat=N*KoverN
        Kradtot=Kscat+Kabs
         //The Bernados formula
        //Kradtot=rhorel*(5.6712e6*Math.pow(phi,0.4264))
        //Need a T-dependent term for HiTerm
        const Tterm=25000*(1+(223-T)/20)
        HiTerm=phinm < Tterm?0:0.03*(phinm-Tterm)/1000*0.03/Math.max(rhorel,0.015) //An adhoc fix for high Kr at large cell sizes        
        //HiTerm=0.03*phinm/1000*0.03/Math.max(rhorel,0.015) //An adhoc fix for high Kr at large cell sizes

        Kr=1000*16*ri2*SB*Math.pow(T,3)/(3*Kradtot)+HiTerm
        Kt=Ks+Kg+Kr
        pKs.push({x:phinm/1000,y:Ks})
        pKg.push({x:phinm/1000,y:Kg})
        pKr.push({x:phinm/1000,y:Kr})
        pKt.push({x:phinm/1000,y:Kt})
        phinm+=inc
        if (phinm>=10*inc) inc*=10
    }
//Now set up all the graphing data.
//We use the amazing Open Source Chart.js, https://www.chartjs.org/
//A lot of the sophistication is addressed directly here
//But if you need something more, read the Chart.js documentation or search Stack Overflow
const plotData=[pKs,pKg,pKr,pKt]
const lineLabels=["Solid","Gas","Radiative","Total"]
const myColors=["gray","blue","orange","red"]

//Now set up all the graphing data detail by detail.
const prmap = {
    plotData: plotData, //An array of 1 or more datasets
    lineLabels: lineLabels, //An array of labels for each dataset
    colors: myColors, //An array of colors for each dataset
    hideLegend: false,
    borderWidth: [2, 2, 2 ,3],
    xLabel: 'φ&μm', //Label for the x axis, with an & to separate the units
    yLabel: 'K&mW/mK', //Label for the y axis, with an & to separate the units
    y2Label: null, //Label for the y2 axis, null if not needed
    yAxisL1R2: [], //Array to say which axis each dataset goes on. Blank=Left=1
    logX: !LinearPlot, //Is the x-axis in log form?
    xTicks: function(value, index, ticks) {if (value.toPrecision(2).includes("1") || value.toPrecision(2).includes("5")) {if (value>=1) {return value.toFixed(0)} else {return value.toPrecision(1)} } else {return ""}; },
    logY: false, //Is the y-axis in log form?
    yTicks: undefined, //We can define a tick function if we're being fancy
    legendPosition: 'top', //Where we want the legend - top, bottom, left, right
    xMinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
    yMinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
    y2MinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
    xSigFigs: 'P1', //These are the sig figs for the Tooltip readout. A wide choice!
    ySigFigs: 'F1', //F for Fixed, P for Precision, E for exponential
};

//Now we return everything - text boxes, plot and the name of the canvas, which is 'canvas' for a single plot
return {
    plots: [prmap],
    canvas: ['canvas'],
    //phiStrut: (phiStrut).toPrecision(2),
    rhorel: (rhorel*100).toFixed(2),
};
}
            

A typical insulating panel for a house or a refrigerator will be made from polyurethane (PU) foam containing a gas which might be air, CO2 or something like pentane (chloro/fluoro gases are very efficient but have obvious environmental downsides). Because gases are poor conductors, one essential is to have the lowest relative density `ρ_(rel)=ρ_(foam)/ρ_(solid)` which might be 0.025, which, for a PU with a solid density of 1200 kg/m³ means a foam of 30 kg/m³. Obviously a low ρ_rel is equivalent to a high porosity φ.

The thermal conductivity (in mw/mK) of the gas, k_gas, varies from air ~26 through CO2~17 to the pentanes in the 10-12 range, so that's another input to the app. But the big way to reduce the conductivity is to trap the gas inside cells comparable to the mean free path of the gas (here we assume 298K and 1 atm pressure). In practice this means that foam cells below 1μm are less conductive. This leads to the idea that nano-foams (such as aerogels) will be the ultimate insulation. However, there are two big problems:

1. It is very hard to make a high expansion foam (low ρ_rel) at these small cell sizes
2. Radiative transfer of heat through the foam increases significantly below 1μm. This is because the MID-IR radiation of normal heat (black body radiation peaking at ~8 μm) is not scattered by small cells. So at least some of the gains from going to smaller cells are lost by this increase of radiative losses.

As there are no easy wins, the best approach is to manage the various properties as best you can, aiming to get the lowest overall conductivity while meeting targets for production throughput, cost, environment, etc. Although a simple app cannot capture all the complexity with precision, it is a good starting point for intelligent discussion.

The calculations

To see all these factors in action we start with the standard approach of Glicksman which tells us that the solid conductivity K_s is given by the following where, for low ρ foams that interest us, the factor g and the conductivity of the bulk solid is k_solid:

`K_s=gK_"solid"ρ_(rel)"Asym"^0.5`

First, the Asymmetry term tells us that elongation in the rise direction increases the conductivity. This is because the heat has a more direct path through the struts. The standard assumption is that this is a square root effect, so if the cells are 2x longer in the rise direction then the conductivity is 1.4 higher.

What is "g"? For a solid it is 1 because the heat can flow straight from one side to another. For a highly porous foam it is 1/3 because most of the solid exists as struts (Plateau Borders) and on average only 1/3 of the struts conduct heat across the gap. For fairly porous foams the standard value is 2/3. An interesting paper² from the Smith group at U Limoges covers cases including porous ceramics and other formulae such as Landauer or Hashin Shtrikman can be used, with Landauer giving exceptionally low conductivities at high porosities because the method assumes breaks in the conductive path (poor percolation). That paper calls the 1/3 case the Ashby formula. As the Landauer and H&S formulae package solid and gas into one value, irrespective of Knudsen effects, they aren't modelled here.

After trying various schemes the best seemed to be to use f_s the fraction of the solid which is in the struts (rather than cell walls). So `g=2/3-f_s/3`, which, for a typical f_s of 0.8 means that g=0.4

To calculate the conductivty of the gas we need first to calculate the Knudsen number K_N which is the ratio of the gas mean path, Λ, to the cell size φ at pressure P and temperature T. Where kB is the Boltzmann constant, the mean path, which depends on the gas molecular diameter, d_gas, is given by:

`Λ=(kB.T)/(1.414πd_"gas"^2P`

Typical values for d_gas are: N2:364, CO2:330, Pentane: 500.

We now calculate K_N:

`K_N=Λ/φ`

And the conductivity through the gas, which has a bulk conductivity of k_gas is given, using a constant ξ=1.64, by:

`K_g=k_(gas)/(1+2ξK_N)(1-ρ_(rel))`

The radiative conductivity, K_r, is the well-known Rosseland equation based on an effective refractive index n (here assumed to be 1+0.4*rho_rel), the Stefan-Bolzmann constant σ, T and an extinction coefficient k_e,R:

`K_r=(16n^2σT^3)/(3k_(e,R))`

Calculating k_e,R

The extinction coefficient is a mixture of absorption, easily calculated from the average absorption coefficient in the mid IR, k_abs as:

`k_(e,Rabs)=k_(abs)ρ_(rel)`

An obvious strategy to reduce radiative heat loss is to make the foam material more absorbing. The calculations of the radiative portion uses the work of Bernardo et al at Cellmat¹. The Bernardo paper says that PU foam has an absorption coefficient of 600 cm^-1 while something neutral like PE has a value of 140 cm^-1. While it might sound easy to add something like carbon black or graphene oxide, in practice getting enough into the walls and struts of the foam to make a difference, while not messing up the foaming process, is rather hard.

In practice, most of the reduction of Mid-IR energy loss is via scattering, and the problem is that calculating this is some mixture of Rayleigh and Mie theory which needs some heavy computational resources. Fortunately the Bernardo paper helps us avoid all that. First, they found some experimental values over a range of cell sizes. Next, they provided the key insight that these values are a combination of the per-cell value k_e,Rscat and the number of cells per unit distance, N, calculated as:

`N=(6/(πφ^3)(1-ρ_(rel)))^(1/3)`

The paper found a fit for k_e,Rscat/N (i.e. the per-cell value) as:

`k_(e,Rscat)/N=5e^(-8)φ^1.68`

This works well in the sub-micron area of interest to the paper but doesn't asymptote to the "Mie limit" (which they are well aware of). This limit applies to the larger φ values of common commercial foams, meaning that the actual k_e,Rscat falls at large φ because N is small. In the app I have used an alternative fitting function (you can find it in the code) which has an asymptote.

So now we have a total extinction coefficient, k_e,R:

`k_(e,R)=k_(e,Rabs)+k_(e,Rscat)`

Examining data at more classical cell sizes (up to 100μm) it is clear that the formula underestimates the values. An ad hoc extra term has been added to give values that match the 2-4 mW/mK typically found in the literature in this range.

So all 3 conductivity terms are now known and you can play with the parameters to see how best to create a low total conductivity foam. Of course, even when you know what you want from the theory you still have the challenge of making it. But that's not a topic for this app.

Temperature Effects

A paper³ from a similar team from U Valladolid and CellMatt continued the work cited earlier and introduces some clever ideas to determine k_abs and g using the change of conductivity with temperature (typically 27->30 mW/mK) over the range of 10->40°. Temperature affects solid, gas and radiative conductivities. The first is via the, say, 4% change in k_solid over that range, the second is the well-known ~10% change in k_gas over that range and the third is the 1/T³ term in the radiative transfer. Using the paper's linear correlations for the thermal conductivities and scaling them to 25°C as the base value, the general effects, if not the precise details, are shown.

Bi-modal foams

A recent trend has been to explore the possibility of bi-modal foams, maybe achieving an optimum not attainable otherwise. Happily, another paper from the Bernardo team⁴ shows what is possible. To the level of accuracy of this app, making a simple weighted average of the values at two different cell sizes is acceptable. That paper was published before the one containing the radiative terms but it seems reasonable to me to continue to use the simple average. The app can always be updated if a more sophisticated approach is required.