Home > SPlaC v1_0 > Plane > PlnSinglePlaneDecayRateEFs.m

PlnSinglePlaneDecayRateEFs

PURPOSE ^

Computes the total and radiative decay rate enhancement factors for a dipole emitting close to a single planar interface.

SYNOPSIS ^

function stAllM=PlnSinglePlaneDecayRateEFs(epsilonM,lambda,epsilon,d,nNbStep)

DESCRIPTION ^

 Computes the total and radiative decay rate enhancement factors for a dipole emitting close to a single planar interface.
 See Sec. 4.4.3 for a definition of these decay rate EFs.
 The dipole must be in a non-absorbing dielectric (with epsilonM) at a
 distance d (in nm) from the interace with another material characterized by
 its dielectric function epsilon (in general complex for metals).
 Note that if the second region is also non-absorbing, the returned MRad
 only account for emission in the half-plane containing the dipole.
 
 Parameters:
 - epsilonM:   scalar
               relative epsilon of dielectric containing dipole
 - lambda:     scalar or column vector [L x 1]
 - epsilon:    scalar or column vectors [L x 1], must be same size as lambda
               dielectric function epsilon(lambda) for second region
 - d:          scalar
               distance of dipole from interface (in NANOMETERS, nm)
 - nNbStep:    scalar
               Number of steps for integration (in each intervals)

 Returns:      structure with 6 fields, each a column vector[L x 1].
               They contain the computed total, radiative, and total in the ESA, decay rate
               EFs for dipoles perpendicular and parallel to the interface
               for each wavelength
 - stAllM.MTotPerp
 - stAllM.MTotPara
 - stAllM.MRadPerp
 - stAllM.MRadPara
 - stAllM.MTotPerpESA
 - stAllM.MTotParaESA

 This file is part of the SPlaC v1.0 package (copyright 2008)
 Check the README file for further information

EXAMPLE OF OUTPUT ^

Example figure output

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SOURCE CODE ^

0001 
0002 disp (['PlnSinglePlaneDecayRateEFs: computing decay rate EFs (d=' num2str(d) 'nm)...']);
0003 
0004 nNbLambda=length(lambda);
0005 
0006 zerolambda=0*lambda; % [L x 1]
0007 
0008 epsilon2Vec=zerolambda+epsilon; % to make it [L x 1] if scalar
0009 epsilon1Vec=zerolambda+epsilonM; % to make it [L x 1] if scalar
0010 
0011 stAllM.MTotPerp=zerolambda;
0012 stAllM.MTotPara=zerolambda;
0013 stAllM.MRadPerp=zerolambda;
0014 stAllM.MRadPara=zerolambda;
0015 
0016 k0=2*pi./lambda; % [L x 1]
0017 k1=k0.*sqrt(epsilon1Vec); % [L x 1]
0018 k2=k0.*sqrt(epsilon2Vec); % [L x 1]
0019 
0020 % Carry out integrations in three intervals with varying steps
0021 % First: [0,1] (only one for MRad)
0022 % Second: [1,sMid]
0023 % where sMid=max(2,|sqrt(epsilonIn)/sqrt(epsilonM)|)]
0024 % Third: [max(1,|sqrt(epsilonIn)/sqrt(epsilonM)|) sMax]
0025 % where sMax=max(50+sMid, 10/(k1*d))
0026 % This leads to good convergence properties, but additional
0027 % tests must be carried out when necessary.
0028 sStep1=1/nNbStep; % scalar, same for all
0029 sVec01=0:sStep1:(1-sStep1+0.5*sStep1); % [1 x N]
0030 indStep=1:nNbStep;
0031 % the 0.5*sStep1 is used to avoid numerical problems leading to a [1 x N-1]
0032 % vector rather than [1 x N]
0033 
0034 % Loop through lambda to avoid memory problems for large nNbStep and
0035 % nNbLambda
0036 for ll=1:nNbLambda
0037     sMid=max(2, abs(k2(ll))./abs(k1(ll))); % [1 x 1]
0038     sStep2=(sMid-1)*sStep1; % [1 x 1]
0039 
0040     sVec1mid=(1+sStep2):sStep2:(sMid+0.5*sStep2); % [1 x N]
0041 
0042     sMax=max(50+sMid, 10/(k1(ll)*d)); % [1 x 1]
0043     sStep3=(sMax-sMid)*sStep1; % [1 x 1]
0044 
0045     sVecMidMax=(sMid+sStep3):sStep3:(sMax+0.5*sStep3); % [1 x N]
0046     sVec=[sVec01 sVec1mid, sVecMidMax]; % [1 x 3N]
0047 
0048 
0049     AuxInt3=sVec ./sqrt(1-sVec.^2); % [1 x 3N]
0050     AuxInt1=sVec.^2 .* AuxInt3; % [1 x 3N]
0051     AuxInt2= exp(2*i*d * (k1(ll) * sqrt(1-sVec.^2))); % [1 x 3N]
0052 
0053     k1z=sqrt( (k1(ll)^2) * (1-sVec.^2) ); % [1 x 3N]
0054     k2z=sqrt( (k2(ll)^2) - k1(ll)^2 * sVec.^2); % [1 x 3N]
0055 
0056     rP=(epsilon2Vec(ll)*k1z-epsilon1Vec(ll)*k2z)./ ...
0057         (epsilon2Vec(ll)*k1z+epsilon1Vec(ll)*k2z); % [1 x 3N]
0058 
0059     rS=(k1z-k2z)./(k1z+k2z); % [1 x 3N]
0060 
0061     PerpIntVec=real( AuxInt1 .*  rP .* AuxInt2 ); % [1 x 3N]
0062     PerpInt1=3/2*sStep1*sum(PerpIntVec(indStep)); % scalar
0063     PerpInt2=3/2*sStep2*sum(PerpIntVec(indStep+nNbStep)); % scalar
0064     PerpInt3=3/2*sStep3*sum(PerpIntVec(indStep+2*nNbStep)); % scalar
0065     stAllM.MTotPerp(ll)=1.0+PerpInt1+PerpInt2+PerpInt3;
0066     
0067     ParaIntVec=real( AuxInt3 .* (rS-(1-sVec.^2).*rP) .* AuxInt2 ); % matrix
0068 
0069     ParaInt1=3/4*sStep1*sum(ParaIntVec(indStep)); % scalar
0070     ParaInt2=3/4*sStep2*sum(ParaIntVec(indStep+nNbStep)); % scalar
0071     ParaInt3=3/4*sStep3*sum(ParaIntVec(indStep+2*nNbStep)); % scalar
0072 
0073     stAllM.MTotPara(ll)=1.0+ParaInt1+ParaInt2+ParaInt3;
0074 
0075     PerpIntRadVec=AuxInt1(indStep).*abs(rP(indStep)).^2; % [1 x N]
0076     PerpIntRad1=3/4*sStep1*sum(PerpIntRadVec); % scalar
0077     
0078     stAllM.MRadPerp(ll)=0.5+PerpIntRad1+PerpInt1; 
0079 
0080     ParaIntRadVec=sVec01.*(sqrt(1-sVec01.^2)) .* ...
0081         abs(rP(indStep)).^2+ AuxInt3(indStep).*abs(rS(indStep)).^2; % matrix
0082     ParaIntRad1=3/8*sStep1*sum(ParaIntRadVec); % scalar
0083 
0084     stAllM.MRadPara(ll)=0.5+ParaIntRad1+ParaInt1;
0085 
0086 
0087 end
0088 
0089 % Also calculates M_{Tot}^{Perp} and M_{Tot}^{Para} within the
0090 % electrostatics approximation, following Eq. 6.13
0091 % Get betaP from Eq. 6.8
0092 betaP=(epsilon2Vec-epsilon1Vec)./(epsilon2Vec+epsilon1Vec); % [L x 1]
0093 
0094 tmp=3/16 ./ (k1*d).^3 .* imag(betaP); % [L x 1]
0095 
0096 stAllM.MTotPerpESA=1+2*tmp;
0097 stAllM.MTotParaESA=1+tmp;
0098 
0099 disp 'PlnSinglePlaneDecayRateEFs: done.'
0100

This web page is part of the SPlaC package © 2008. Contact: Eric Le Ru
Generated on Wed 03-Dec-2008 11:10:14 by m2html © 2003 (adapted)