Materials

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

Classes
class	BaseMaterialImpl
	Interface for material implementation classes. More...
class	MagneticMaterialImpl
	Basic implementation for magnetized material. More...
class	Material
	A wrapper for underlying material implementation. More...
class	MaterialBySLDImpl
	Material implementation based on wavelength-independent data (valid for a range of wavelengths) More...
class	RefractiveMaterialImpl
	Material implementation based on refractive coefficiencts (valid for one wavelength value only) More...

Functions
Material	createAveragedMaterial (const Material &layer_mat, const std::vector< HomogeneousRegion > &regions)
	Creates averaged material. More...
Material	HomogeneousMaterial ()
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). More...
Material	HomogeneousMaterial (const std::string &name, double delta, double beta, kvector_t magnetization={})
Material	MaterialBySLD ()
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). More...

Detailed Description

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

Function Documentation

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 37 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.

Here is the call graph for this function:

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,
		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);
}

References RealSpace::Particles::name().

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(), MaterialItem::createMaterial(), and HomogeneousMaterial().

Here is the call graph for this function:

HomogeneousMaterial() [3/3]

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

Definition at line 31 of file MaterialFactoryFuncs.cpp.

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

References RealSpace::Particles::name().

Here is the call graph for this function:

MaterialBySLD() [1/2]

Material MaterialBySLD

(

)

Definition at line 42 of file MaterialFactoryFuncs.cpp.

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

Referenced by createAveragedMaterial(), and gui2::Utils::createBornAgainSlices().

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 31 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));
}