Implements an tanh transition function to model roughness in a scaler computation. More...

Inheritance diagram for SpecularScalarTanhStrategy:

Collaboration diagram for SpecularScalarTanhStrategy:

Public Types
using	coefficient_pointer_type = std::unique_ptr< const coefficient_type >

using	coefficient_type = ScalarRTCoefficients

using	coeffs_t = std::vector< coefficient_pointer_type >

Public Member Functions
virtual std::variant< complex_t, Eigen::Matrix2cd >	computeTopLayerR (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const override
	Computes the Fresnel R coefficient for the top layer only Introduced in order to speed up pure reflectivity computations. More...

virtual ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const kvector_t &k) const override
	Computes refraction angles and transmission/reflection coefficients for given coherent wave propagation in a multilayer. More...

virtual ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const override

Private Member Functions
void	calculateUpFromLayer (std::vector< ScalarRTCoefficients > &coeff, const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const

std::vector< ScalarRTCoefficients >	computeTR (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const

virtual std::pair< complex_t, complex_t >	transition (complex_t kzi, complex_t kzi1, double sigma) const override
	Roughness is modelled by tanh profile [see e.g. Phys. Rev. B, vol. 47 (8), p. 4385 (1993)]. More...

Static Private Member Functions
static void	setZeroBelow (std::vector< ScalarRTCoefficients > &coeff, size_t current_layer)

Detailed Description

Implements an tanh transition function to model roughness in a scaler computation.

Implements the transition function that includes the analytical roughness model of an tanh interface transition in the computation of the coefficients for coherent wave propagation in a multilayer by applying modified Fresnel coefficients.

Definition at line 34 of file SpecularScalarTanhStrategy.h.

Member Typedef Documentation

◆ coefficient_pointer_type

using SpecularScalarStrategy::coefficient_pointer_type = std::unique_ptr<const coefficient_type>

inherited

Definition at line 43 of file SpecularScalarStrategy.h.

◆ coefficient_type

using SpecularScalarStrategy::coefficient_type = ScalarRTCoefficients

inherited

Definition at line 42 of file SpecularScalarStrategy.h.

◆ coeffs_t

using SpecularScalarStrategy::coeffs_t = std::vector<coefficient_pointer_type>

inherited

Definition at line 44 of file SpecularScalarStrategy.h.

Member Function Documentation

◆ calculateUpFromLayer()

void SpecularScalarStrategy::calculateUpFromLayer	(	std::vector< ScalarRTCoefficients > &	coeff,
		const std::vector< Slice > &	slices,
		const std::vector< complex_t > &	kz
	)		const

privateinherited

Definition at line 116 of file SpecularScalarStrategy.cpp.

 {
     auto N = slices.size();
  
     coeff.back().t_r(0) = 1.0;
     coeff.back().t_r(1) = 0.0;
     std::vector<complex_t> factors(N - 1);
     for (int i = N - 2; i >= 0; i--) {
         double sigma = 0.0;
         if (const auto roughness = GetBottomRoughness(slices, i))
             sigma = roughness->getSigma();
  
         const auto [mp, mm] = transition(kz[i], kz[i + 1], sigma);
  
         const complex_t delta = exp_I(kz[i] * slices[i].thickness());
  
         complex_t S = mp + mm * coeff[i + 1].t_r(1);
         S = 1. / S * delta;
         factors[i] = S;
  
         coeff[i].t_r(1) = delta * (mm + mp * coeff[i + 1].t_r(1)) * S;
     }
  
     // now correct all amplitudes by dividing the with the remaining factors in forward direction
     // at some point this divison underflows, which is the point when all further amplitudes are set
     // to zero
     complex_t dumpingFactor = 1;
     for (size_t j = 1; j < N; ++j) {
         dumpingFactor = dumpingFactor * factors[j - 1];
  
         coeff[j].t_r(0) = dumpingFactor;
         coeff[j].t_r(1) *= dumpingFactor;
     }
 }

References exp_I(), and SpecularScalarStrategy::transition().

Referenced by SpecularScalarStrategy::computeTR().

Here is the call graph for this function:

◆ computeTopLayerR()

std::variant< complex_t, Eigen::Matrix2cd > SpecularScalarStrategy::computeTopLayerR	(	const std::vector< Slice > &	slices,
		const std::vector< complex_t > &	kz
	)		const

overridevirtualinherited

Computes the Fresnel R coefficient for the top layer only Introduced in order to speed up pure reflectivity computations.

Implements ISpecularStrategy.

Definition at line 49 of file SpecularScalarStrategy.cpp.

 {
     if (slices.size() != kz.size())
         throw std::runtime_error("Number of slices does not match the size of the kz-vector");
  
     auto N = slices.size();
  
     if (N == 1) { // If only one layer present, there's nothing left to calculate
         return 0.;
     }else if (kz[0] == 0.)
         return -1.;
  
     complex_t R_i1 = 0.;
  
     for (int i = N - 2; i >= 0; i--) {
         double sigma = 0.0;
         if (const auto roughness = GetBottomRoughness(slices, i))
             sigma = roughness->getSigma();
  
         const auto [mp, mm] = transition(kz[i], kz[i + 1], sigma);
  
         const complex_t delta = exp_I(kz[i] * slices[i].thickness());
  
         complex_t S = mp + mm * R_i1;
         S = 1. / S * delta;
  
         R_i1 = delta * (mm + mp * R_i1) * S;
     }
  
     return R_i1;
 }

References exp_I(), and SpecularScalarStrategy::transition().

Here is the call graph for this function:

◆ computeTR()

std::vector< ScalarRTCoefficients > SpecularScalarStrategy::computeTR	(	const std::vector< Slice > &	slices,
		const std::vector< complex_t > &	kz
	)		const

privateinherited

Definition at line 83 of file SpecularScalarStrategy.cpp.

 {
     const size_t N = slices.size();
     std::vector<ScalarRTCoefficients> coeff(N);
  
     for (size_t i = 0; i < N; ++i)
         coeff[i].kz = kz[i];
  
     if (N == 1) { // If only one layer present, there's nothing left to calculate
         coeff[0].t_r = {1.0, 0.0};
         return coeff;
     } else if (kz[0] == 0.0) { // If kz in layer 0 is zero, R0 = -T0 and all others equal to 0
         coeff[0].t_r = {1.0, -1.0};
         for (size_t i = 1; i < N; ++i)
             coeff[i].t_r.setZero();
         return coeff;
     }
  
     // Calculate transmission/refraction coefficients t_r for each layer, from bottom to top.
     calculateUpFromLayer(coeff, slices, kz);
     return coeff;
 }

References SpecularScalarStrategy::calculateUpFromLayer().

Referenced by SpecularScalarStrategy::Execute().

Here is the call graph for this function:

◆ Execute() [1/2]

ISpecularStrategy::coeffs_t SpecularScalarStrategy::Execute	(	const std::vector< Slice > &	slices,
		const kvector_t &	k
	)		const

overridevirtualinherited

Computes refraction angles and transmission/reflection coefficients for given coherent wave propagation in a multilayer.

Implements ISpecularStrategy.

Definition at line 28 of file SpecularScalarStrategy.cpp.

 {
     std::vector<complex_t> kz = KzComputation::computeReducedKz(slices, k);
     return Execute(slices, kz);
 }

References KzComputation::computeReducedKz().

Here is the call graph for this function:

◆ Execute() [2/2]

ISpecularStrategy::coeffs_t SpecularScalarStrategy::Execute	(	const std::vector< Slice > &	slices,
		const std::vector< complex_t > &	kz
	)		const

overridevirtualinherited

Implements ISpecularStrategy.

Definition at line 35 of file SpecularScalarStrategy.cpp.

 {
     if (slices.size() != kz.size())
         throw std::runtime_error("Number of slices does not match the size of the kz-vector");
  
     ISpecularStrategy::coeffs_t result;
     for (auto& coeff : computeTR(slices, kz))
         result.push_back(std::make_unique<ScalarRTCoefficients>(coeff));
  
     return result;
 }

References SpecularScalarStrategy::computeTR().

Here is the call graph for this function:

◆ setZeroBelow()

void SpecularScalarStrategy::setZeroBelow	(	std::vector< ScalarRTCoefficients > &	coeff,
		size_t	current_layer
	)

staticprivateinherited

Definition at line 107 of file SpecularScalarStrategy.cpp.

 {
     size_t N = coeff.size();
     for (size_t i = current_layer + 1; i < N; ++i) {
         coeff[i].t_r.setZero();
     }
 }

◆ transition()

std::pair< complex_t, complex_t > SpecularScalarTanhStrategy::transition	(	complex_t	kzi,
		complex_t	kzi1,
		double	sigma
	)		const

overrideprivatevirtual

Roughness is modelled by tanh profile [see e.g. Phys. Rev. B, vol. 47 (8), p. 4385 (1993)].

Implements SpecularScalarStrategy.

Definition at line 25 of file SpecularScalarTanhStrategy.cpp.

 {
     complex_t roughness = 1;
     if (sigma > 0.0) {
         const double sigeff = pi2_15 * sigma;
         roughness = std::sqrt(Math::tanhc(sigeff * kzi1) / Math::tanhc(sigeff * kzi));
     }
     const complex_t inv_roughness = 1.0 / roughness;
     const complex_t kz_ratio = kzi1 / kzi * roughness;
  
     const complex_t a00 = 0.5 * (inv_roughness + kz_ratio);
     const complex_t a01 = 0.5 * (inv_roughness - kz_ratio);
  
     return {a00, a01};
 }

References Math::tanhc().

Here is the call graph for this function:

The documentation for this class was generated from the following files:

/home/www/ba/Sample/Specular/SpecularScalarTanhStrategy.h
/home/www/ba/Sample/Specular/SpecularScalarTanhStrategy.cpp

Public Types

Public Member Functions

Private Member Functions

Static Private Member Functions

Detailed Description

Member Typedef Documentation

◆ coefficient_pointer_type

◆ coefficient_type

◆ coeffs_t

Member Function Documentation

◆ calculateUpFromLayer()

◆ computeTopLayerR()

◆ computeTR()

◆ Execute() [1/2]

◆ Execute() [2/2]

◆ setZeroBelow()

◆ transition()