Materials

Classes
class	BaseMaterialImpl
class	MagneticMaterialImpl
class	Material
class	MaterialBySLDImpl
class	RefractiveMaterialImpl

Functions
Material	HomogeneousMaterial ()
Material	HomogeneousMaterial (const std::string &name, double delta, double beta, kvector_t magnetization={})
Material	HomogeneousMaterial (const std::string &name, complex_t refractive_index, kvector_t magnetization={})
Material	MaterialBySLD ()
Material	MaterialBySLD (const std::string &name, double sld_real, double sld_imag, kvector_t magnetization={})
Material	createAveragedMaterial (const Material &layer_mat, const std::vector< HomogeneousRegion > &regions)
std::vector< complex_t >	MaterialProfile (const MultiLayer &multilayer, int n_points, double z_min, double z_max)

Detailed Description

Classes and functions to describe magnetic and non-magnetic materials.

Function Documentation

HomogeneousMaterial() [1/3]

Material HomogeneousMaterial

(

)

Definition at line 37 of file MaterialFactoryFuncs.cpp.

{
    return HomogeneousMaterial("vacuum", 0.0, 0.0, kvector_t{});
}

References HomogeneousMaterial().

Here is the call graph for this function:

HomogeneousMaterial() [2/3]

Material HomogeneousMaterial	(	const std::string &	name,
		double	delta,
		double	beta,
		kvector_t	magnetization = {}
	)

Definition at line 27 of file MaterialFactoryFuncs.cpp.

{
    std::unique_ptr<RefractiveMaterialImpl> mat_impl(
        new RefractiveMaterialImpl(name, delta, beta, magnetization));
    return Material(std::move(mat_impl));
}

HomogeneousMaterial() [3/3]

Material HomogeneousMaterial	(	const std::string &	name,
		complex_t	refractive_index,
		kvector_t	magnetization = {}
	)

Constructs a material with name, refractive_index and magnetization (in A/m).

Alternatively, and for refractive index can be passed directly. With no parameters given, constructs default (vacuum) material with and zero magnetization.

Definition at line 21 of file MaterialFactoryFuncs.cpp.

{
    const double delta = 1.0 - refractive_index.real();
    const double beta = refractive_index.imag();
    return HomogeneousMaterial(name, delta, beta, magnetization);
}

Referenced by CoreShellParticleBuilder::buildSample(), HomogeneousMultilayerBuilder::buildSample(), MagneticSubstrateZeroFieldBuilder::buildSample(), MagneticLayerBuilder::buildSample(), MagneticRotationBuilder::buildSample(), MagneticParticleZeroFieldBuilder::buildSample(), MagneticCylindersBuilder::buildSample(), MagneticSpheresBuilder::buildSample(), MultiLayerWithRoughnessBuilder::buildSample(), ResonatorBuilder::buildSample(), SlicedCylindersBuilder::buildSample(), createAveragedMaterial(), HomogeneousMaterial(), and anonymous_namespace{MagneticLayersBuilder.cpp}::parametricBuild().

MaterialBySLD() [1/2]

Material MaterialBySLD

(

)

Definition at line 42 of file MaterialFactoryFuncs.cpp.

{
    return MaterialBySLD("vacuum", 0.0, 0.0, kvector_t{});
}

Referenced by anonymous_namespace{FeNiBilayerBuilder.cpp}::FeNiBilayer::constructSample(), and createAveragedMaterial().

MaterialBySLD() [2/2]

Material MaterialBySLD	(	const std::string &	name,
		double	sld_real,
		double	sld_imag,
		kvector_t	magnetization = {}
	)

Constructs a wavelength-independent material with a given complex-valued scattering length density (SLD).

SLD values for a wide variety of materials can be found on https://sld-calculator.appspot.com/ and https://www.ncnr.nist.gov/resources/activation/ By convention, SLD imaginary part is treated as negative by default, which corresponds to attenuation of the signal. With no parameters given, MaterialBySLD constructs default (vacuum) material with zero sld and zero magnetization.

Parameters

name	material name
sld_real	real part of the scattering length density, inverse square angstroms
sld_imag	imaginary part of the scattering length density, inverse square angstroms
magnetization	magnetization (in A/m)

Definition at line 27 of file MaterialFactoryFuncs.cpp.

{
    constexpr double inv_sq_angstroms = 1.0 / (Units::angstrom * Units::angstrom);
    std::unique_ptr<MaterialBySLDImpl> mat_impl(new MaterialBySLDImpl(
        name, sld_real * inv_sq_angstroms, sld_imag * inv_sq_angstroms, magnetization));
    return Material(std::move(mat_impl));
}

createAveragedMaterial()

Material createAveragedMaterial	(	const Material &	layer_mat,
		const std::vector< HomogeneousRegion > &	regions
	)

Creates averaged material.

Square refractive index of returned material is arithmetic mean over regions and layer_mat. Magnetization (if present) is averaged linearly.

Definition at line 38 of file HomogeneousRegion.cpp.

{
    // determine the type of returned material
    std::vector<const Material*> materials(regions.size() + 1);
    materials[0] = &layer_mat;
    for (size_t i = 0, regions_size = regions.size(); i < regions_size; ++i)
        materials[i + 1] = &regions[i].m_material;
    const MATERIAL_TYPES avr_material_type = MaterialUtils::checkMaterialTypes(materials);
    if (avr_material_type == MATERIAL_TYPES::InvalidMaterialType)
        throw std::runtime_error("Error in createAveragedMaterial(): non-default materials of "
                                 "different types used simultaneously.");
 
    // create the name of returned material
    const std::string avr_mat_name = layer_mat.getName() + "_avg";
 
    // calculate averaged magnetization
    const kvector_t mag_avr = averageData<kvector_t>(
        layer_mat, regions, [](const Material& mat) { return mat.magnetization(); });
 
    if (avr_material_type == MATERIAL_TYPES::RefractiveMaterial) {
        // avrData returns (1 - mdc)^2 - 1, where mdc is material data conjugate
        auto avrData = [](const Material& mat) -> complex_t {
            const complex_t mdc = std::conj(mat.materialData());
            return mdc * mdc - 2.0 * mdc;
        };
        const complex_t avr_mat_data =
            std::conj(1.0 - std::sqrt(1.0 + averageData<complex_t>(layer_mat, regions, avrData)));
        return HomogeneousMaterial(avr_mat_name, avr_mat_data.real(), avr_mat_data.imag(), mag_avr);
    } else if (avr_material_type == MATERIAL_TYPES::MaterialBySLD) {
        complex_t (*avrData)(const Material&) = [](const Material& mat) {
            return mat.materialData();
        };
        const complex_t avr_mat_data = averageData<complex_t>(layer_mat, regions, avrData);
        return MaterialBySLD(avr_mat_name, avr_mat_data.real(), avr_mat_data.imag(), mag_avr);
    } else
        throw std::runtime_error("Error in CalculateAverageMaterial: unknown material type.");
}

References MaterialUtils::checkMaterialTypes(), Material::getName(), HomogeneousMaterial(), InvalidMaterialType, Material::magnetization(), MaterialBySLD, Material::materialData(), and RefractiveMaterial.

Referenced by anonymous_namespace{ProcessedSample.cpp}::CreateAverageMaterialSlices().

Here is the call graph for this function:

MaterialProfile()

std::vector<complex_t> MaterialProfile	(	const MultiLayer &	multilayer,
		int	n_points,
		double	z_min,
		double	z_max
	)

Calculate average material profile for given multilayer

Definition at line 20 of file MultiLayerFuncs.cpp.

{
    SimulationOptions options;
    options.setUseAvgMaterials(true);
    ProcessedSample sample(multilayer, options);
    ProfileHelper helper(sample);
    std::vector<double> z_values = GenerateZValues(n_points, z_min, z_max);
    return helper.calculateProfile(z_values);
}

References ProfileHelper::calculateProfile(), GenerateZValues(), and SimulationOptions::setUseAvgMaterials().

Here is the call graph for this function: