Scattering_Matrix.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ad7a90a5",
   "metadata": {},
   "source": [
    "# Scattering Matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8908eac8",
   "metadata": {},
   "source": [
    "In this code, we implement the Scattering Matrix formalism to obtain the transmission and emission of multilayered systems."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0274bcd9",
   "metadata": {},
   "source": [
    "## General imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8be10cdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Libraries needed to import for this example\n",
    "\n",
    "import numpy as np                    # Basic numerical python library\n",
    "import scipy as sci                   # Algorithms for scientific computing\n",
    "import matplotlib.pyplot as plt       # Plotting library for python\n",
    "\n",
    "# Silica permittivity\n",
    "\n",
    "real_epsilon_SiO2 = np.genfromtxt('Datasets/epsilon_real_SiO2.dat') # Real part of silica permittivity\n",
    "imag_epsilon_SiO2 = np.genfromtxt('Datasets/epsilon_imag_SiO2.dat') # Imaginary part of silica permittivity\n",
    "\n",
    "wSiO2_raw = real_epsilon_SiO2[:,0]/(6.58*10**(-16)*10**14) # Sampling frequencies for silica permittivity raw, 10^14 rad/s\n",
    "eps_SiO2_raw = real_epsilon_SiO2[:,1]+1j*imag_epsilon_SiO2[:,1] # Full silica permittivity raw\n",
    "\n",
    "wSiO2 = np.linspace(0.2,3-0.0001,200) # Sampling frequencies for silica permittivity, 10^14 rad/s\n",
    "eps_SiO2 = np.interp(wSiO2,wSiO2_raw,eps_SiO2_raw) # Full silica permittivity\n",
    "\n",
    "# Silver permittivity\n",
    "\n",
    "Ag_raw = np.genfromtxt('Datasets/Ag_data.txt') # File containing all the Ag data\n",
    "\n",
    "wAg_raw = 10**(-14)*(2*np.pi)*3*10**8/(Ag_raw[:,1]*10**(-6)); # Sampling frequencies for silver permittivity raw, 10^14 rad/s\n",
    "eps_Ag_raw = Ag_raw[:,4] + 1j*Ag_raw[:,5] # Full silver permittivity raw\n",
    "\n",
    "wAg = np.linspace(0.76,69,1500) # Sampling frequencies for silver permittivity, 10^14 rad/s\n",
    "eps_Ag = np.interp(wAg,wAg_raw,eps_Ag_raw) # Full silver permittivity\n",
    "\n",
    "# Silica permittivity for infrarred\n",
    "\n",
    "SiO2_infrarred_wavelength_raw = np.genfromtxt('Datasets/Eps_SiO2_infrarred_wavelength.dat')\n",
    "SiO2_infrarred_real_raw = np.genfromtxt('Datasets/Eps_SiO2_infrarred_real.dat')\n",
    "SiO2_infrarred_imag_raw = np.genfromtxt('Datasets/Eps_SiO2_infrarred_imag.dat')\n",
    "\n",
    "wSiO2_infrarred = 10**(-14)*(2*np.pi)*3*10**8/(SiO2_infrarred_wavelength_raw*10**(-6)) # Sampling frequencies for silica permittivity raw, 10^14 rad/s\n",
    "epsSiO2_infrarred = np.interp(wAg,wSiO2_infrarred,SiO2_infrarred_real_raw+1j*SiO2_infrarred_imag_raw) # Full silica permittivity\n",
    "\n",
    "# Permittivity of Drude metal\n",
    "\n",
    "e_inf = 1 # Metal parameter e_inf\n",
    "wp = 2.5 # Metal parameter wp (10**14 rad/s)\n",
    "gamm = 0.01 # Metal para meter gamma (10**14 rad/s)\n",
    "\n",
    "w_metal = wSiO2 # Sampling frequencies for metal permittivity, 10^14 rad/s\n",
    "\n",
    "eps_metal = np.zeros((wSiO2.shape[0],)).astype('complex') # Will hold the metal permittivity values\n",
    "\n",
    "for i in range(wSiO2.shape[0]):\n",
    "    \n",
    "    eps_metal[i] = e_inf - (wp**2)/(w_metal[i]*(w_metal[i]+1j*gamm))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e961298",
   "metadata": {},
   "source": [
    "## Unpatterned multilayered system: NFRHT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d312af6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defines the thermal derivative of the mean thermal energy of a mode of frequency wu\n",
    "\n",
    "def thet(TT,wu):\n",
    "    \n",
    "    # Inputs\n",
    "    \n",
    "    # TT: temperature in SI\n",
    "    # wu: frequency in SI\n",
    "    \n",
    "    # Parameters\n",
    "    \n",
    "    h = 6.626*10**(-34) # SI\n",
    "    hbar = h/(2*np.pi) # SI\n",
    "    kB = 1.381*10**(-23) # SI\n",
    "    \n",
    "    T_exp = np.exp((hbar*wu)/(kB*TT))\n",
    "    \n",
    "    values = (hbar**2*wu**2)/(4*np.pi**2*kB*TT**2)\n",
    "    \n",
    "    return (values*T_exp)/(T_exp-1)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4da88944",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform all calculations for the transmission of the system using Scattering Matrix\n",
    "\n",
    "def k_funct(ku,NN,wu,epsss,ddd,gapd):\n",
    "    \n",
    "    # Inputs\n",
    "    \n",
    "    # ku: k value for the calculations\n",
    "    # NN: number of material layers, the full vector has 2 extra components\n",
    "    # wu: frequency for the calculations\n",
    "    # epsss: material parameter vector, 2 components longer than NN\n",
    "    # ddd: widths parameters, one extra 0 on each side\n",
    "    # gapd: separation between the systems\n",
    "    \n",
    "    # Outputs\n",
    "    \n",
    "    # ktau: transmission times k value\n",
    "    \n",
    "    # Parameters\n",
    "    \n",
    "    c = 3*10**8 \n",
    "    \n",
    "    # Initialization\n",
    "    \n",
    "    fn = 0\n",
    "    fn1 = 0\n",
    "    D = 0\n",
    "    \n",
    "    I11 = np.zeros((2,2))\n",
    "    I12 = np.zeros((2,2))\n",
    "    I21 = np.zeros((2,2))\n",
    "    I22 = np.zeros((2,2))\n",
    "    \n",
    "    S011 = np.eye(2)\n",
    "    S012 = np.zeros((2,2))\n",
    "    S021 = np.zeros((2,2))\n",
    "    S022 = np.eye(2)\n",
    "    \n",
    "    S111 = np.zeros((2,2))\n",
    "    S112 = np.zeros((2,2))\n",
    "    S121 = np.zeros((2,2))\n",
    "    S122 = np.zeros((2,2))\n",
    "    \n",
    "    wu = wu*10**14\n",
    "    ku = ku*10**14\n",
    "        \n",
    "    # Main loop\n",
    "        \n",
    "    for n in range(NN+1):\n",
    "        \n",
    "        qn = np.sqrt(epsss[n]*wu**2-ku**2 + 0j)\n",
    "        qn1 = np.sqrt(epsss[n+1]*wu**2-ku**2 + 0j)\n",
    "        \n",
    "        if np.imag(qn) < 0:\n",
    "            \n",
    "            qn = qn*(-1)\n",
    "                \n",
    "        if np.imag(qn+1) < 0:\n",
    "            \n",
    "            qn1 = qn1*(-1)\n",
    "                \n",
    "        D = qn/qn1\n",
    "        \n",
    "        fn = np.exp(1j*qn/c*ddd[n]*10**(-9))\n",
    "        fn1 = np.exp(1j*qn1/c*ddd[n+1]*10**(-9))\n",
    "        \n",
    "        I11 = np.array([[D+1, 0.0],[0.0, epsss[n]/(D*epsss[n+1])+1]])/2\n",
    "        I12 = np.array([[1-D, 0.0],[0.0, 1-epsss[n]/(D*epsss[n+1])]])/2\n",
    "        I21 = I12\n",
    "        I22 = I11\n",
    "                \n",
    "        S111 = fn*np.matmul(S011,np.linalg.inv(I11-fn*np.matmul(S012,I21)))\n",
    "        S121 = np.matmul(S022,np.matmul(I21,S111))+S021\n",
    "        S112 = np.matmul((fn*np.matmul(S012,I22)-I12)*fn1,np.linalg.inv(I11-fn*np.matmul(S012,I21)))\n",
    "        S122 = np.matmul(S022,(np.matmul(I21,S112)+I22*fn1))\n",
    "        \n",
    "        S011 = S111\n",
    "        S012 = S112\n",
    "        S021 = S121\n",
    "        S022 = S122\n",
    "        \n",
    "    rp = S121[1,1]*(-1)\n",
    "    Rp = np.abs(S121[1,1])**2\n",
    "    rs = S121[0,0]*(-1)\n",
    "    Rs = np.abs(S121[0,0])**2\n",
    "    \n",
    "    qinter = np.sqrt(wu**2 - ku**2 + 0j)\n",
    "    Ds = np.abs(1-rs*rs*np.exp(2*1j*qinter/c*gapd*10**(-9)))**2\n",
    "    Dp = np.abs(1-rp*rp*np.exp(2*1j*qinter/c*gapd*10**(-9)))**2\n",
    "    \n",
    "    if ku < wu:\n",
    "        \n",
    "        taus = (1-Rs)**2/Ds\n",
    "        taup = (1-Rp)**2/Dp\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        taus = 4*np.imag(rs)**2*np.exp(-2*np.abs(qinter)/c*gapd*10**(-9))/Ds\n",
    "        taup = 4*np.imag(rp)**2*np.exp(-2*np.abs(qinter)/c*gapd*10**(-9))/Dp\n",
    "        \n",
    "    ktau = (taus+taup)*ku\n",
    "    \n",
    "    return ktau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8960cd78",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Consider the multilayer hyperbolic metamaterial\n",
    "\n",
    "# Pre-allocations and constants\n",
    "\n",
    "T = 300 # Temperature of the system, K\n",
    "\n",
    "Nl = 8 # Number of layers to consider\n",
    "Nw = wSiO2.shape[0] # Number of frequency points\n",
    "\n",
    "epsd = 1 # Dielectric permittivty, we consider vacuum\n",
    "\n",
    "c = 3*10**8 # Speed of light in SI\n",
    "\n",
    "d0 = 10 # Width of the gap, nm\n",
    "d_l = 10 # Width of each layer, nm. We assume all layers the same, we could change then individually if wanted\n",
    "\n",
    "d = np.zeros((Nl+2)) # Width of all layers, including the infinite on above and below. THey have width 0.\n",
    "\n",
    "for i in range(Nl):\n",
    "    \n",
    "    d[i+1] = d0\n",
    "    \n",
    "eps_layer = np.zeros((Nl+2,Nw)).astype('complex') # Permittivty of all layers\n",
    "\n",
    "for i in range(Nl+2):\n",
    "    \n",
    "    for j in range(Nw):\n",
    "        \n",
    "        if np.mod(i,2) == 0:\n",
    "            \n",
    "            eps_layer[i,j] = epsd # Dielectric layer\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            eps_layer[i,j] = eps_metal[j] # Metallic layer\n",
    "            \n",
    "spectral_HTC = np.zeros((Nw,)) # Will hold the HTC spectra\n",
    "            \n",
    "# Calculations\n",
    "\n",
    "for i in range(Nw):\n",
    "    \n",
    "    eps_part = eps_layer[:,i] # Permittivties at current frequency\n",
    "    \n",
    "    part = sci.integrate.quad(lambda x: k_funct(x,Nl,wSiO2[i],eps_part,d,d0), 0, np.inf, limit = 10000, epsrel = 10**(-4)) # Integrate over k\n",
    "    \n",
    "    spectral_HTC[i] = thet(T,wSiO2[i]*10**14)*part[0]*10**14/c**2 \n",
    "    \n",
    "HTC = np.trapz(spectral_HTC,wSiO2*10**14) # HTC of this system"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60affef0",
   "metadata": {},
   "source": [
    "## Emissivty of a patterned system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f631d71",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We consider a patterned silica layer with a silver thin layer below\n",
    "# We consider a square lattice of circular holes\n",
    "\n",
    "# Pre-allocations and constants\n",
    "\n",
    "c=3*10**8 # Speed of light, SI\n",
    "h=6.626*10**(-34) # Planck's constant, SI\n",
    "hbar = h/(2*np.pi)\n",
    "kB=1.381*10**(-23) # Boltzmann constant, SI\n",
    "\n",
    "Ntheta = 100 # Number of angles to consider\n",
    "Nw = wAg.shape[0] # Number of frequency points to consider\n",
    "Nl = 4 # Number of layers in the system, +2 infinite ones (above and below)\n",
    "\n",
    "NGG = 5 # Number of G vectors to consider per value\n",
    "NG = NGG**2 # Total number of G vectors to consider\n",
    "\n",
    "dSiO2 = 500 # Width of the silica layer in microns\n",
    "dAg = 0.12 # Width of the silver layer in microns\n",
    "\n",
    "a = 0.3 # Lattice parameter in microns\n",
    "R = 0.03 # Hole radius in microns\n",
    "beta = np.pi*(R/a)**2 # Filling factor\n",
    "\n",
    "theta = np.linspace(0,np.pi/2-0.0001,Ntheta) # Angles to consider for the calculation\n",
    "d = np.array([0,dSiO2,dAg,0]) # All layer widths in the system\n",
    "\n",
    "a0 = np.zeros((2*NG,1)).astype('complex'); # Field amplitudes\n",
    "b0 = np.zeros((2*NG,1)).astype('complex'); \n",
    "aN = np.zeros((2*NG,1)).astype('complex');\n",
    "\n",
    "eps1 = np.concatenate((np.reshape(eps_Ag,(Nw,1)),np.ones((Nw,1))),axis=1)\n",
    "eps2 = np.concatenate((np.reshape(epsSiO2_infrarred,(Nw,1)),eps1),axis=1)\n",
    "eps = np.concatenate((np.ones((Nw,1)),eps2),axis=1) # Permittivity of the ful system for all frequencies\n",
    "\n",
    "G = np.zeros((2*NGG,NGG)) # G vectors matrix, each pair of columns holds the (x,y) elements of the vectors\n",
    "\n",
    "emissivity = np.zeros((Nw,Ntheta)) # Will hold all the emissivity components\n",
    "\n",
    "# Calculations\n",
    "\n",
    "# Obtain all the G vectors (no units)\n",
    "\n",
    "for i in range(NGG):\n",
    "    \n",
    "    for j in range(NGG):\n",
    "        \n",
    "        G[2*j,i] = j - np.floor(NGG/2)\n",
    "        G[2*j+1,i] = i - np.floor(NGG/2)\n",
    "        \n",
    "G = G*(2*np.pi)/(a*10**(-6)) # Add units to the G vectors\n",
    "\n",
    "for i in range(Nw): # Frequency loop\n",
    "    \n",
    "    k0 = wAg[i]/c*10**14 # Vacuum wavevector\n",
    "    \n",
    "    epse=np.zeros((NG,NG)).astype('complex') # Fourier of the permittivity\n",
    "    \n",
    "    # Obtain the Fourier transform of the permittivity, using the analytical solution\n",
    "    \n",
    "    for j in range(NG):\n",
    "        \n",
    "        for k in range(NG):\n",
    "            \n",
    "            GGGx = G[int(2*np.floor(j/NGG)),int(np.mod(j,NGG))] - G[int(2*np.floor(k/NGG)),int(np.mod(k,NGG))]\n",
    "            GGGy = G[int(2*np.floor(j/NGG))+1,int(np.mod(j,NGG))] - G[int(2*np.floor(k/NGG))+1,int(np.mod(k,NGG))]\n",
    "            \n",
    "            GGG = np.sqrt(GGGx**2+GGGy**2)\n",
    "            \n",
    "            RR = R*10**(-6) # Radius with units\n",
    "            \n",
    "            if j == k:\n",
    "                \n",
    "                epse[j,k] = epsSiO2_infrarred[i] - beta*(epsSiO2_infrarred[i]-1)\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                epse[j,k] = (4*epsSiO2_infrarred[i]*np.sin(GGGx*a)*np.sin(GGGy*a))/(a**2*(GGGx+GGGy*10**(-6))*(GGGy+GGGx*10**(-6))) - \\\n",
    "                (epsSiO2_infrarred[i]-1)/(a**2)*(0.5*np.pi*RR*sci.special.j1(GGG*RR)*sci.special.struve(0,GGG*RR)+\n",
    "                                                0.5*sci.special.j0(GGG*RR)*(2*RR - np.pi*RR*sci.special.struve(1,GGG*RR))) \n",
    "                \n",
    "    nu = np.linalg.inv(epse) # Inverse of permittivty, Fourier\n",
    "\n",
    "    for th in range(Ntheta): # Angle loop\n",
    "        \n",
    "        kx=np.zeros((NG,NG)) # K matrices\n",
    "        ky=np.zeros((NG,NG))\n",
    "        \n",
    "        Q = np.zeros((2*NG,2*NG)).astype('complex') # Q values\n",
    "        \n",
    "        f = np.zeros((2*NG,2*NG,Nl)).astype('complex') # f matrix\n",
    "        \n",
    "        M = np.zeros((4*NG,4*NG,Nl)).astype('complex') # Material matrices\n",
    "        M1 = np.zeros((4*NG,4*NG,Nl)).astype('complex')\n",
    "        \n",
    "        S11 = np.zeros((2*NG,2*NG,Nl)).astype('complex') # Scattering matrices \n",
    "        S12 = np.zeros((2*NG,2*NG,Nl)).astype('complex')\n",
    "        S21 = np.zeros((2*NG,2*NG,Nl)).astype('complex') \n",
    "        S22 = np.zeros((2*NG,2*NG,Nl)).astype('complex')\n",
    "        \n",
    "        # Obtain k matrices\n",
    "    \n",
    "        kxx=k0*np.sin(theta[th])\n",
    "        kyy=k0*np.sin(theta[th])\n",
    "        \n",
    "        for j in range(NG):\n",
    "                                \n",
    "            kx[j,j]=kxx+G[int(2*np.floor(j/NGG)),int(np.mod(j,NGG))]\n",
    "            ky[j,j]=kyy+G[int(2*np.floor(j/NGG))+1,int(np.mod(j,NGG))]\n",
    "            \n",
    "        # Solve the system to obtain the Q values\n",
    "        \n",
    "        W = k0**2*np.eye(2*NG)\n",
    "        A2 = np.block([[nu, np.zeros((NG,NG)).astype('complex')], [np.zeros((NG,NG)).astype('complex'), nu]])\n",
    "        A0 = (np.block([[np.matmul(ky,np.matmul(nu,ky)),-np.matmul(ky,np.matmul(nu,kx))],[-np.matmul(kx,np.matmul(nu,ky)),np.matmul(kx,np.matmul(nu,kx))]])\n",
    "              +np.matmul(A2,np.block([[np.matmul(kx,kx),np.matmul(kx,ky)],[np.matmul(ky,kx),np.matmul(ky,ky)]]))-W)\n",
    "        \n",
    "        AAA,BBB = sci.linalg.eig(A0,-A2)\n",
    "        \n",
    "        for j in range(2*NG):\n",
    "            \n",
    "            val = np.sqrt(AAA[j])\n",
    "            \n",
    "            if np.imag(val) < 0:\n",
    "                \n",
    "                val = -val\n",
    "                \n",
    "            Q[j,j] = val\n",
    "            \n",
    "        # Obtain the f and M matrices\n",
    "        \n",
    "        for j in range(2*NG):\n",
    "            \n",
    "            for k in range(Nl):\n",
    "                882\n",
    "                f[j,j,k] = np.exp(1j*Q[j,j]*d[k]*10**(-6))\n",
    "                \n",
    "        for j in range(Nl):\n",
    "            \n",
    "            if j == 1:\n",
    "                \n",
    "                A0b = np.matmul(A2,np.block([[np.matmul(kx,kx),np.matmul(kx,ky)],[np.matmul(ky,kx),np.matmul(ky,ky)]]))\n",
    "                G_not = np.matmul(A0b,np.matmul(BBB,np.linalg.inv(Q)))+np.matmul(A2,np.matmul(BBB,Q))\n",
    "                M[:,:,j] = np.block([[G_not,-G_not],[BBB,BBB]])\n",
    "                M1[:,:,j] = M[:,:,j]\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                G1 = 1/(wAg[i]*10**14/c*np.sqrt(eps[i,j]-np.sin(theta[th])**2))*np.block([[(wAg[i]*10**14/c)**2*np.eye(NG),np.zeros((NG,NG)).astype('complex')],\n",
    "                                                                                       [np.zeros((NG,NG)).astype('complex'),(wAg[i]*10**14/c*np.sqrt(eps[i,j]-np.sin(theta[th])**2))**2*np.eye(NG)]])\n",
    "                M[:,:,j] = (wAg[i]*10**14/c)*np.block([[G1,-G1],[np.eye(2*NG),np.eye(2*NG)]])\n",
    "                M1[:,:,j] = np.block([[np.linalg.inv(G1),np.eye(2*NG)],[-np.linalg.inv(G1),np.eye(2*NG)]])/(2*wAg[i]*10**14/c)\n",
    "                \n",
    "        # Obtain the scattering matrix\n",
    "            \n",
    "        for j in range(Nl-1):\n",
    "                \n",
    "            I = np.matmul(M1[:,:,j],M[:,:,j+1])\n",
    "                \n",
    "            index1row,index1col = np.indices([2*NG,2*NG])\n",
    "            index2row,index2col = np.indices([2*NG,2*NG])\n",
    "            index3row,index3col = np.indices([2*NG,2*NG])\n",
    "            index4row,index4col = np.indices([2*NG,2*NG])\n",
    "            \n",
    "            index2col = index2col+2*NG\n",
    "            index3row = index3row+2*NG\n",
    "            index4row = index4row+2*NG\n",
    "            index4col = index4col+2*NG\n",
    "                \n",
    "            I11 = I[index1row,index1col]\n",
    "            I12 = I[index2row,index2col]\n",
    "            I21 = I[index3row,index3col]\n",
    "            I22 = I[index4row,index4col]\n",
    "                \n",
    "            S11[:,:,j+1]=np.matmul(np.linalg.inv(I11-np.matmul(f[:,:,j],np.matmul(S12[:,:,j],I21))),np.matmul(f[:,:,j],S11[:,:,j]));\n",
    "            S12[:,:,j+1]=np.matmul(np.linalg.inv(I11-np.matmul(f[:,:,j],np.matmul(S12[:,:,j],I21))),np.matmul((np.matmul(f[:,:,j],np.matmul(S12[:,:,j],I22))-I12),f[:,:,j+1]));\n",
    "            S21[:,:,j+1]=np.matmul(S22[:,:,j],np.matmul(I21,S11[:,:,j+1]))+S21[:,:,j];\n",
    "            S22[:,:,j+1]=np.matmul(S22[:,:,j],np.matmul(I21,S12[:,:,j+1]))+np.matmul(S22[:,:,j],np.matmul(I22,f[:,:,j+1]));\n",
    "            \n",
    "            \n",
    "        DN = np.sqrt(eps[i,Nl-1]-eps[i,0]*np.sin(theta[th]))/np.sqrt(eps[i,0]*np.cos(theta[th])**2)\n",
    "        \n",
    "        l_ind = int((NG+1)/2-1)\n",
    "        v_ind = int((3*NG+1)/2-1)\n",
    "        \n",
    "        rot = np.array([[np.cos(theta[th]),0],[0,1]])\n",
    "        \n",
    "        # P-polarized components\n",
    "        \n",
    "        a0[v_ind] = 1.0+1j*0.0\n",
    "        a0[l_ind] = -(M[l_ind,v_ind,0])/(M[l_ind,l_ind,0])*a0[v_ind]\n",
    "        a00 = np.array([a0[l_ind],a0[v_ind]])\n",
    "        a00 = np.matmul(rot,a00)\n",
    "        a0[l_ind] = a00[0]\n",
    "        a0[v_ind] = a00[1]\n",
    "        \n",
    "        b01 = np.matmul(S21[:,:,Nl-1],a0)\n",
    "        aN1 = np.matmul(S11[:,:,Nl-1],a0)\n",
    "        \n",
    "        b0[l_ind] = b01[l_ind]\n",
    "        b0[v_ind] = b01[v_ind]\n",
    "        \n",
    "        aN[l_ind] = aN1[l_ind]\n",
    "        aN[v_ind] = aN1[v_ind]\n",
    "        \n",
    "        div = np.real(np.matmul(np.transpose(np.conj(a0)),np.matmul(np.conj(np.transpose(M[index3row,index3col,0])),np.matmul(M[index1row,index1col,0],a0))))\n",
    "        rp = -np.matmul(np.real(np.matmul(np.transpose(np.conj(b0)),np.matmul(np.conj(np.transpose(M[index4row,index4col,0])),np.matmul(M[index2row,index2col,0],b0)))),np.linalg.inv(div))\n",
    "        tp = np.matmul(np.real(np.matmul(np.transpose(np.conj(aN)),np.matmul(np.conj(np.transpose(M[index3row,index3col,0])),np.matmul(M[index1row,index1col,0],aN)))),np.linalg.inv(div))\n",
    "\n",
    "        # S-polarized components\n",
    "        \n",
    "        a0[l_ind] = 1.0+1j*0.0\n",
    "        a0[v_ind] = -(M[v_ind,l_ind,0])/(M[v_ind,v_ind,0])*a0[l_ind]\n",
    "        a00 = np.array([a0[l_ind],a0[v_ind]])\n",
    "        a00 = np.matmul(rot,a00)\n",
    "        a0[l_ind] = a00[0]\n",
    "        a0[v_ind] = a00[1]\n",
    "        \n",
    "        b01 = np.matmul(S21[:,:,Nl-1],a0)\n",
    "        aN1 = np.matmul(S11[:,:,Nl-1],a0)\n",
    "        \n",
    "        b0[l_ind] = b01[l_ind]\n",
    "        b0[v_ind] = b01[v_ind]\n",
    "        \n",
    "        aN[l_ind] = aN1[l_ind]\n",
    "        aN[v_ind] = aN1[v_ind]\n",
    "        \n",
    "        div = np.real(np.matmul(np.transpose(np.conj(a0)),np.matmul(np.conj(np.transpose(M[index3row,index3col,0])),np.matmul(M[index1row,index1col,0],a0))))\n",
    "        rs = -np.matmul(np.real(np.matmul(np.transpose(np.conj(b0)),np.matmul(np.conj(np.transpose(M[index4row,index4col,0])),np.matmul(M[index2row,index2col,0],b0)))),np.linalg.inv(div))\n",
    "        ts = np.matmul(np.real(np.matmul(np.transpose(np.conj(aN)),np.matmul(np.conj(np.transpose(M[index3row,index3col,0])),np.matmul(M[index1row,index1col,0],aN)))),np.linalg.inv(div))\n",
    "\n",
    "        # Obtain finally the emissivity\n",
    "        \n",
    "        emissivity[i,th] = (2-np.abs(rs)**2-np.abs(ts)**2-np.abs(rp)**2-np.abs(tp)**2)/2\n",
    "    "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}