ExemplarySamples Namespace Reference

Description

Two boxes in particle composition rotated in X by 90 degrees.

Builds sample: 2D finite lattice of 2D finite lattices (superlattice).

Builds sample: 2D finite lattice with thermal disorder.

Builds sample: 2D lattice with different disorder (IsGISAXS example #6).

Builds sample: 2D lattice with arbitrary angle and different lattice length_1 and length_2.

Rotated box in 3 layers system.

Provides exactly the same sample as SLDSlicedCylindersBuilder, but with cylinders represented as homogeneous layers. SLD-based materials used. Assumed wavelength is 1.54 Angstrom.

Provides exactly the same sample as SlicedCylindersBuilder, but with sld-based materials. Assumed wavelength is 1.54 Angstrom.

Builds sample: cylinders on a silicon substrate.

Builds sample: spherical composition made of top+bottom spherical cups.

Builds sample: size spacing correlation approximation (IsGISAXS example #15).

Creates the sample demonstrating size distribution model in size space coupling approximation. Equivalent of Examples/Python/simulation/ex03_Interferences/ApproximationSSCA.py.

Creates the sample demonstrating size distribution model in local monodisperse approximation. Equivalent of Examples/Python/simulation/ex03_Interferences/ApproximationLMA.py.

Creates the sample demonstrating size distribution model in decoupling approximation. Equivalent of Examples/Python/simulation/ex03_Interferences/ApproximationDA.py.

Builds sample: Pyramids, rotated pyramids on top of substrate (IsGISAXS example #9)

Builds sample: triangular ripple within the 1D-paracrystal model (from PRB 85, 235415, 2012).

Builds sample: cosine ripple within the 1D-paracrystal model.

Builds sample: sample with Ti/Pt layers sequence.

Builds a sample with 10 interchanging homogeneous layers of Ti and Ni on silicone substrate. Ti is 70 angstroms thick, Ni is 30 angstroms thick.

Builds sample: cylinders with hard disk Percus-Yevick interference.

The ParticleInVacuumBuilder class generates a sample with single vacuum layer populated with particles of certain types.

Distribution of boxes with main parameter and two linked parameters.

Cones with the distribution applied to the angle and RealLimits defined.

Spherical particles with the distribution applied to the radius and RealLimits defined.

Rotated Pyramids with the distribution applied to the rotation angle.

Builds mixture of cylinder particles with different size distribution (IsGISAXS example #2)

Cylinders in BA with size distributions (IsGISAXS example #3, part II).

Builds sample: two layers of spheres at hex lattice.

Builds sample: 2D paracrystal lattice (IsGISAXS example #8).

Builds sample: cylinders with 2DDL structure factor (IsGISAXS example #4).

Builds sample: basic two-dimensional paracrystal with various probability distribution functions (PDF's). They are initialized via component service.

Builds sample: cylinders with 1DDL structure factor (IsGISAXS example #4).

Builds sample: mixture of cylinders and prisms without interference, using multiple particle layouts.

Builds sample: layers with correlated roughness.

Builds sample: cylindrical mesocrystal composed of spheres in a cubic lattice.

Builds sample: spheres with magnetization inside substrate.

Builds sample: cylinders with magnetic material and non-zero magnetic field.

Builds sample: cylinders with magnetic material and zero magnetic field.

Builds sample: rotated magnetic spheres in substrate layer with a unit magnetic field.

Builds sample: magnetic layer on a magnetic substrate with the fields rotated by 90°

Builds sample: magnetic spheres in a magnetized layer on a non-magnetized substrate.

Builds sample: ambient and one magnetized layer on a non-magnetized substrate.

Builds sample: spheres in substrate layer with a zero magnetic field.

The LayersWithAbsorptionBySLDBuilder class generates a sample with 3 layers with absorption (refractive index has imaginary part). //! The middle layer is populated with particles. MaterialBySLD is used to generate maaterials.

The LayersWithAbsorptionBuilder class generates a sample with 3 layers with absorption (refractive index has imaginary part).

Builds sample: cylinders with 1DDL structure factor.

Builds a sample with 10 interchanging homogeneous layers of Ti and Ni on silicone substrate. Ti is 70 angstroms thick, Ni is 30 angstroms thick. No absorption, no roughness, target wavelength is 1.54 angstroms.

Builds sample: mixture of cylinders and prisms without interference (IsGISAXS example #1).

Builds sample: mixture of different particles (IsGISAXS example #7).

Rotation and translation of core shell box particle in 3 layers system.

Builds sample: Core Shell Nanoparticles (IsGISAXS example #11).

Builds sample: square boxes in a square lattice.

Two different boxes are first rotated and then composed, composition is then rotated.

Two boxes in particle composition rotated in Z and Y by 90 degrees.

Two boxes in particle composition rotated in Z by 90 degrees.

Two boxes in particle composition rotated in Y by 90 degrees.

The middle layer is populated with particles.

Functions
MultiLayer *	createAsymRipple ()
MultiLayer *	createAveragedSlicedCylinders ()
MultiLayer *	createBasic2DLattice ()
MultiLayer *	createBasic2DParaCrystalWithFTDis (const IProfile2D *pdf2)
MultiLayer *	createBoxCompositionRotateX ()
MultiLayer *	createBoxCompositionRotateY ()
MultiLayer *	createBoxCompositionRotateZ ()
MultiLayer *	createBoxCompositionRotateZandY ()
MultiLayer *	createBoxesSquareLattice2D ()
MultiLayer *	createBoxStackComposition ()
MultiLayer *	createCenteredSquareLattice2D ()
MultiLayer *	createConesWithLimitsDistribution ()
MultiLayer *	createCoreShellBoxRotateZandY ()
MultiLayer *	createCoreShellParticle ()
MultiLayer *	createCosineRipple ()
MultiLayer *	createCustomMorphology ()
MultiLayer *	createCylindersAndPrisms ()
MultiLayer *	createCylindersInBA (double height=5, double radius=5)
	Builds sample: cylinder form factor in BA (IsGISAXS example #3, part II). More...
MultiLayer *	createCylindersInDWBA ()
	Builds sample: cylinder form factor in DWBA (IsGISAXS example #3, part I). More...
MultiLayer *	createCylindersInSSCA ()
MultiLayer *	createCylindersWithSizeDistribution ()
MultiLayer *	createFeNiBilayer ()
MultiLayer *	createFeNiBilayerNC ()
MultiLayer *	createFeNiBilayerSpinFlip ()
MultiLayer *	createFeNiBilayerSpinFlipNC ()
MultiLayer *	createFeNiBilayerSpinFlipTanh ()
MultiLayer *	createFeNiBilayerTanh ()
MultiLayer *	createFiniteSquareLattice2D ()
MultiLayer *	createHardDisk ()
MultiLayer *	createHexParaCrystal ()
MultiLayer *	createHomogeneousMultilayer ()
MultiLayer *	createLargeCylindersInDWBA (double height=1000, double radius=500)
	Builds sample with large cylinders for MC integration tests. More...
MultiLayer *	createLattice1D ()
MultiLayer *	createLayersWithAbsorptionBySLD ()
MultiLayer *	createLayersWithAbsorptionWithFF (const IFormFactor *)
MultiLayer *	createLinkedBoxDistribution ()
MultiLayer *	createMagneticCylinders ()
MultiLayer *	createMagneticLayer ()
MultiLayer *	createMagneticParticleZeroField ()
MultiLayer *	createMagneticRotation ()
MultiLayer *	createMagneticSpheres ()
MultiLayer *	createMagneticSubstrateZeroField ()
MultiLayer *	createMesoCrystal ()
MultiLayer *	createMultiLayerWithNCRoughness ()
MultiLayer *	createMultiLayerWithRoughness ()
MultiLayer *	createMultipleLayout ()
MultiLayer *	createParticleComposition ()
MultiLayer *	createParticleInVacuumWithFF (const IFormFactor *)
MultiLayer *	createPlainMultiLayerBySLD (int n_layers=10, double thick_ti=3.0)
MultiLayer *	createRadialParaCrystal ()
MultiLayer *	createRectParaCrystal ()
MultiLayer *	createResonator (double ti_thickness=13.0)
MultiLayer *	createRotatedPyramids ()
MultiLayer *	createRotatedPyramidsDistribution ()
MultiLayer *	createRotatedSquareLattice2D ()
MultiLayer *	createSimpleMagneticLayer ()
MultiLayer *	createSimpleMagneticRotationWithRoughness (const std::string &roughnessKey)
MultiLayer *	createSizeDistributionDAModel ()
MultiLayer *	createSizeDistributionLMAModel ()
MultiLayer *	createSizeDistributionSSCAModel ()
MultiLayer *	createSLDSlicedCylinders ()
MultiLayer *	createSlicedComposition ()
MultiLayer *	createSlicedCylinders ()
MultiLayer *	createSpheresWithLimitsDistribution ()
MultiLayer *	createSquareLattice2D ()
MultiLayer *	createSuperLattice ()
MultiLayer *	createThickAbsorptiveSample ()
MultiLayer *	createTransformBox ()
MultiLayer *	createTriangularRipple (double d=0)
MultiLayer *	createTwoTypesCylindersDistribution ()

Function Documentation

createAsymRipple()

MultiLayer * ExemplarySamples::createAsymRipple

(

)

Definition at line 71 of file RipplesBuilder.cpp.

{
    return ExemplarySamples::createTriangularRipple(-3);
}

References createTriangularRipple().

Here is the call graph for this function:

createAveragedSlicedCylinders()

MultiLayer * ExemplarySamples::createAveragedSlicedCylinders

(

)

Definition at line 95 of file SlicedCylindersBuilder.cpp.

{
    const auto par_surf_density = ParticleLayout().totalParticleSurfaceDensity();
 
    complex_t vacuum_sld{0.0, 0.0};
    Material vacuum_material = MaterialBySLD("Vacuum", vacuum_sld.real(), vacuum_sld.imag());
    complex_t sub_sld = getSLDFromN(wavelength, 6e-6, 2e-8);
    Material substrate_material = MaterialBySLD("Substrate", sub_sld.real(), sub_sld.imag());
 
    double eff_vol = par_surf_density * M_PI * radius * radius;
    complex_t par_sld = getSLDFromN(wavelength, 6e-4, 2e-8);
    complex_t avr_sld = averageSLD(par_sld, vacuum_sld, eff_vol);
    Material avr_material = MaterialBySLD("Avr", avr_sld.real(), avr_sld.imag());
 
    Layer vacuum_layer(vacuum_material);
    Layer avr_layer(avr_material, height / n_slices);
    Layer substrate_layer(substrate_material);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    for (size_t i = 0; i < n_slices; ++i)
        sample->addLayer(avr_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References M_PI, MaterialBySLD(), and ParticleLayout::totalParticleSurfaceDensity().

Here is the call graph for this function:

createBasic2DLattice()

MultiLayer * ExemplarySamples::createBasic2DLattice

(

)

Definition at line 31 of file TwoDimLatticeBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DLattice iff(BasicLattice2D(5.0, 10.0, 30.0 * deg, 10.0 * deg));
 
    Profile2DCauchy pdf(300.0 / 2.0 / M_PI, 100.0 / 2.0 / M_PI, 0);
    iff.setDecayFunction(pdf);
 
    // particles
    ParticleLayout particle_layout;
    Cylinder ff_cyl(5.0, 5.0);
    Particle particle(refMat::Particle, ff_cyl);
    particle_layout.addParticle(particle);
 
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), Units::deg, M_PI, refMat::Particle, Interference2DLattice::setDecayFunction(), ParticleLayout::setInterference(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createBasic2DParaCrystalWithFTDis()

MultiLayer * ExemplarySamples::createBasic2DParaCrystalWithFTDis

(

const IProfile2D *

pdf2

)

Definition at line 61 of file ParaCrystalBuilder.cpp.

{
    const Profile2DCauchy pdf1(0.1, 0.2, 0);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DParaCrystal iff(BasicLattice2D(10.0, 20.0, 30.0 * deg, 45.0 * deg), 1000.0,
                                  20.0 * Units::micrometer, 40.0 * Units::micrometer);
 
    iff.setProbabilityDistributions(pdf1, *pdf2);
 
    const Cylinder ff_cylinder(5.0, 5.0);
 
    Particle particle(refMat::Particle, ff_cylinder);
    ParticleLayout particle_layout(particle);
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer("Basic2DParaCrystal_" + pdf2->className());
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), INode::className(), Units::deg, Units::micrometer, refMat::Particle, ParticleLayout::setInterference(), Interference2DParaCrystal::setProbabilityDistributions(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createBoxCompositionRotateX()

MultiLayer * ExemplarySamples::createBoxCompositionRotateX

(

)

Definition at line 57 of file BoxCompositionBuilder.cpp.

{
    Particle box(particleMaterial, Box(length / 2.0, width, height));
    ParticleComposition composition;
    composition.addParticle(box, R3(0.0, 0.0, 0.0));
    composition.addParticle(box, R3(length / 2.0, 0.0, 0.0));
    composition.setRotation(RotationX(90.0 * deg));
    composition.setParticlePosition(R3(0.0, 0.0, -layer_thickness / 2.0));
    return finalizeMultiLayer(composition);
}

References ParticleComposition::addParticle(), Units::deg, IParticle::setParticlePosition(), and IParticle::setRotation().

Here is the call graph for this function:

createBoxCompositionRotateY()

MultiLayer * ExemplarySamples::createBoxCompositionRotateY

(

)

Definition at line 70 of file BoxCompositionBuilder.cpp.

{
    Particle box(particleMaterial, Box(length / 2.0, width, height));
    ParticleComposition composition;
    composition.addParticle(box, R3(0.0, 0.0, 0.0));
    composition.addParticle(box, R3(length / 2.0, 0.0, 0.0));
    composition.setRotation(RotationY(90.0 * deg));
    composition.setParticlePosition(R3(0.0, 0.0, -layer_thickness / 2.0 + length / 4.0));
    return finalizeMultiLayer(composition);
}

References ParticleComposition::addParticle(), Units::deg, IParticle::setParticlePosition(), and IParticle::setRotation().

Here is the call graph for this function:

createBoxCompositionRotateZ()

MultiLayer * ExemplarySamples::createBoxCompositionRotateZ

(

)

Definition at line 83 of file BoxCompositionBuilder.cpp.

{
    Particle box(particleMaterial, Box(length / 2.0, width, height));
    ParticleComposition composition;
    composition.addParticle(box, R3(0.0, 0.0, 0.0));
    composition.addParticle(box, R3(length / 2.0, 0.0, 0.0));
    composition.setRotation(RotationZ(90.0 * deg));
    composition.setParticlePosition(R3(0.0, 0.0, -layer_thickness / 2.0 - height / 2.0));
    return finalizeMultiLayer(composition);
}

References ParticleComposition::addParticle(), Units::deg, IParticle::setParticlePosition(), and IParticle::setRotation().

Here is the call graph for this function:

createBoxCompositionRotateZandY()

MultiLayer * ExemplarySamples::createBoxCompositionRotateZandY

(

)

Definition at line 96 of file BoxCompositionBuilder.cpp.

{
    Particle box(particleMaterial, Box(length / 2.0, width, height));
    ParticleComposition composition;
    composition.addParticle(box, R3(0.0, 0.0, 0.0));
    composition.addParticle(box, R3(length / 2.0, 0.0, 0.0));
    composition.setRotation(RotationZ(90.0 * deg));
    composition.rotate(RotationY(90.0 * deg));
    composition.setParticlePosition(R3(0.0, 0.0, -layer_thickness / 2.0));
    return finalizeMultiLayer(composition);
}

References ParticleComposition::addParticle(), Units::deg, IParticle::rotate(), IParticle::setParticlePosition(), and IParticle::setRotation().

Here is the call graph for this function:

createBoxesSquareLattice2D()

MultiLayer * ExemplarySamples::createBoxesSquareLattice2D

(

)

Definition at line 25 of file BoxesSquareLatticeBuilder.cpp.

{
    const double length = 5;
    const double height = 10;
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DLattice iff(SquareLattice2D(8, 0));
 
    Profile2DCauchy pdf(100.0, 100.0, 0);
    iff.setDecayFunction(pdf);
 
    // particles
    ParticleLayout particle_layout;
    Box ff_box(length, length, height);
    Particle particle(refMat::Particle, ff_box);
    particle_layout.addParticle(particle, 1.0);
 
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, Interference2DLattice::setDecayFunction(), ParticleLayout::setInterference(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createBoxStackComposition()

MultiLayer * ExemplarySamples::createBoxStackComposition

(

)

Definition at line 111 of file BoxCompositionBuilder.cpp.

{
    ParticleComposition composition;
 
    // box1 (20,50,5), rotatedZ
    const double box1_length = 20;
    const double box1_width = 50;
    const double box1_height = 5;
    Particle box1(particleMaterial, Box(box1_length, box1_width, box1_height));
    box1.setRotation(RotationZ(90. * deg));
 
    // box2 (5,20,50), rotatedY
    const double box2_length = 5.0;
    const double box2_width = 20.0;
    const double box2_height = 50.0;
    Particle box2(particleMaterial, Box(box2_length, box2_width, box2_height));
    box2.setRotation(RotationY(90. * deg));
    box2.setParticlePosition(R3(-box2_height / 2.0, 0.0, box2_length / 2.0));
 
    composition.addParticle(box1, R3(0.0, 0.0, 0.0));
    composition.addParticle(box2, R3(0.0, 0.0, box1_height));
    composition.setRotation(RotationY(90.0 * deg));
    composition.setParticlePosition(R3(0.0, 0.0, -layer_thickness / 2.));
 
    return finalizeMultiLayer(composition);
}

References ParticleComposition::addParticle(), Units::deg, IParticle::setParticlePosition(), and IParticle::setRotation().

Here is the call graph for this function:

createCenteredSquareLattice2D()

MultiLayer * ExemplarySamples::createCenteredSquareLattice2D

(

)

Definition at line 88 of file TwoDimLatticeBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DLattice interparticle(BasicLattice2D(10.0, 10.0, M_PI / 2.0, 0));
    Profile2DCauchy pdf(300.0 / 2.0 / M_PI, 100.0 / 2.0 / M_PI, 0);
    interparticle.setDecayFunction(pdf);
 
    Cylinder ff_cyl(5.0, 5.0);
    Particle cylinder(refMat::Particle, ff_cyl);
    std::vector<R3> positions;
    R3 position_1(0.0, 0.0, 0.0);
    R3 position_2(5.0, -5.0, 0.0);
    positions.push_back(position_1);
    positions.push_back(position_2);
    ParticleComposition basis;
    basis.addParticles(cylinder, positions);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(basis);
    particle_layout.setInterference(interparticle);
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), ParticleComposition::addParticles(), M_PI, refMat::Particle, Interference2DLattice::setDecayFunction(), ParticleLayout::setInterference(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createConesWithLimitsDistribution()

MultiLayer * ExemplarySamples::createConesWithLimitsDistribution

(

)

Definition at line 209 of file ParticleDistributionsBuilder.cpp.

{
    throw std::runtime_error(
        "This sample used ParticleDistribution which is not supported any more.");
 
    // #baRemoveParticleDistribution The following code is outdated. However, it is still kept,
    // since it may be useful once the new particle distribution approach is implemented.
    /*
    // particle
    Cone ff(10.0, 13.0, 60.0 * deg);
    Particle cone(refMat::Particle, ff);
 
    // particle collection
    DistributionGaussian gauss(60.0 * deg, 6.0 * deg);
    ParameterDistribution parameter_distr(
        "/Particle/Cone/Alpha", gauss, 5, 20.0,
        RealLimits::limited(55.0 * deg, 65.0 * deg));
 
    ParticleDistribution collection(cone, parameter_distr);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(collection);
 
    // Multi layer
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
    */
}

createCoreShellBoxRotateZandY()

MultiLayer * ExemplarySamples::createCoreShellBoxRotateZandY

(

)

Definition at line 59 of file CoreShellParticleBuilder.cpp.

{
    const double layer_thickness(100.0);
 
    // core shell particle
    const double shell_length(50.0);
    const double shell_width(20.0);
    const double shell_height(10.0);
    double core_length = shell_length / 2.0;
    double core_width = shell_width / 2.0;
    double core_height = shell_height / 2.0;
 
    Particle core(refMat::Ag, Box(core_length, core_width, core_height));
    Particle shell(refMat::AgO2, Box(shell_length, shell_width, shell_height));
    ParticleCoreShell coreshell(shell, core, R3(0.0, 0.0, (shell_height - core_height) / 2.0));
    coreshell.setRotation(RotationZ(90.0 * deg));
    coreshell.rotate(RotationY(90.0 * deg));
    coreshell.setParticlePosition(R3(0.0, 0.0, -layer_thickness / 2.0));
 
    ParticleLayout layout;
    layout.addParticle(coreshell);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer middle_layer(refMat::Teflon, layer_thickness);
    middle_layer.addLayout(layout);
    Layer substrate(refMat::Substrate2);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(middle_layer);
    sample->addLayer(substrate);
 
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Ag, refMat::AgO2, Units::deg, IParticle::rotate(), IParticle::setParticlePosition(), IParticle::setRotation(), refMat::Substrate2, refMat::Teflon, and refMat::Vacuum.

Here is the call graph for this function:

createCoreShellParticle()

MultiLayer * ExemplarySamples::createCoreShellParticle

(

)

Definition at line 30 of file CoreShellParticleBuilder.cpp.

{
    complex_t n_particle_shell(1.0 - 1e-4, 2e-8);
    complex_t n_particle_core(1.0 - 6e-5, 2e-8);
 
    Material shell_material = RefractiveMaterial("Shell", n_particle_shell);
    Material core_material = RefractiveMaterial("Core", n_particle_core);
 
    Layer vacuum_layer(refMat::Vacuum);
 
    Box ff_box1(16, 16, 8);
    Particle shell_particle(shell_material, ff_box1);
 
    Box ff_box2(12, 12, 7);
    Particle core_particle(core_material, ff_box2);
 
    R3 core_position(0.0, 0.0, 0.0);
    ParticleCoreShell particle(shell_particle, core_particle, core_position);
 
    ParticleLayout particle_layout(particle);
    vacuum_layer.addLayout(particle);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    return sample;
}

References Layer::addLayout(), RefractiveMaterial(), and refMat::Vacuum.

Here is the call graph for this function:

createCosineRipple()

MultiLayer * ExemplarySamples::createCosineRipple

(

)

Definition at line 26 of file RipplesBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    CosineRippleBox ff_ripple1(100.0, 20.0, 4.0);
    Particle ripple(refMat::Particle, ff_ripple1);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(ripple, 1.0);
    InterferenceRadialParaCrystal interparticle(20.0, 1e7);
    Profile1DGauss pdf(4.0);
    interparticle.setProbabilityDistribution(pdf);
    particle_layout.setInterference(interparticle);
 
    vacuum_layer.addLayout(particle_layout);
 
    Layer substrate_layer(refMat::Substrate);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, ParticleLayout::setInterference(), InterferenceRadialParaCrystal::setProbabilityDistribution(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createCustomMorphology()

MultiLayer * ExemplarySamples::createCustomMorphology

(

)

Definition at line 27 of file CustomMorphologyBuilder.cpp.

{
    Material mat_vacuum = refMat::Vacuum;
    Material mat_particle = refMat::Particle;
 
    Layer vacuum_layer(mat_vacuum);
    ParticleLayout particle_layout;
 
    // add particle number 1:
    Box ff1(2.0, 2.0, 1.0);
    R3 pos1(0.0, 0.0, 0.0);
    Particle p1(mat_particle, ff1);
    p1.setParticlePosition(pos1);
    particle_layout.addParticle(p1, 0.5);
    // add particle number 2:
    Box ff2(2.0, 4.0, 1.0);
    R3 pos2(5.0, 5.0, 0.0);
    RotationZ m2(10 * deg);
    Particle p2(mat_particle, ff2, m2);
    p2.setParticlePosition(pos2);
    particle_layout.addParticle(p2, 0.5);
    // add particle number 3:
    Box ff3(2.0, 6.0, 1.0);
    R3 pos3(-5.0, -5.0, 0.0);
    RotationZ m3(20 * deg);
    Particle p3(mat_particle, ff3, m3);
    p3.setParticlePosition(pos3);
    particle_layout.addParticle(p3, 0.5);
    // add particle number 4:
    Box ff4(2.0, 8.0, 1.0);
    R3 pos4(5.0, -5.0, 0.0);
    RotationZ m4(30 * deg);
    Particle p4(mat_particle, ff4, m4);
    p4.setParticlePosition(pos4);
    particle_layout.addParticle(p4, 0.5);
    // add particle number 5:
    Box ff5(2.0, 10.0, 1.0);
    R3 pos5(-5.0, 5.0, 0.0);
    RotationZ m5(40 * deg);
    Particle p5(mat_particle, ff5, m5);
    p5.setParticlePosition(pos5);
    particle_layout.addParticle(p5, 0.5);
    // add particle number 6:
    Box ff6(2.0, 2.0, 1.0);
    R3 pos6(0.0, 0.0, 0.0);
    RotationZ m6(50 * deg);
    Particle p6(mat_particle, ff6, m6);
    p6.setParticlePosition(pos6);
    particle_layout.addParticle(p6, 0.5);
    // add particle number 7:
    Box ff7(2.0, 4.0, 1.0);
    R3 pos7(5.0, 5.0, 0.0);
    RotationZ m7(60 * deg);
    Particle p7(mat_particle, ff7, m7);
    p7.setParticlePosition(pos7);
    particle_layout.addParticle(p7, 0.5);
    // add particle number 8:
    Box ff8(2.0, 6.0, 1.0);
    R3 pos8(-5.0, -5.0, 0.0);
    RotationZ m8(70 * deg);
    Particle p8(mat_particle, ff8, m8);
    p8.setParticlePosition(pos8);
    particle_layout.addParticle(p8, 0.5);
    // add particle number 9:
    Box ff9(2.0, 8.0, 1.0);
    R3 pos9(5.0, -5.0, 0.0);
    RotationZ m9(80 * deg);
    Particle p9(mat_particle, ff9, m9);
    p9.setParticlePosition(pos9);
    particle_layout.addParticle(p9, 0.5);
    // add particle number 10:
    Box ff10(2.0, 10.0, 1.0);
    R3 pos10(-5.0, 5.0, 0.0);
    RotationZ m10(90 * deg);
    Particle p10(mat_particle, ff10, m10);
    p10.setParticlePosition(pos10);
    particle_layout.addParticle(p10, 0.5);
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), Units::deg, refMat::Particle, IParticle::setParticlePosition(), and refMat::Vacuum.

Here is the call graph for this function:

createCylindersAndPrisms()

MultiLayer * ExemplarySamples::createCylindersAndPrisms

(

)

Definition at line 24 of file CylindersAndPrismsBuilder.cpp.

{
    auto* sample = new MultiLayer();
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    ParticleLayout particle_layout;
 
    Cylinder ff_cylinder(5.0, 5.0);
    Particle cylinder(refMat::Particle, ff_cylinder);
 
    Prism3 ff_prism3(10.0, 5.0);
    Particle prism3(refMat::Particle, ff_prism3);
 
    particle_layout.addParticle(cylinder, 0.5);
    particle_layout.addParticle(prism3, 0.5);
 
    vacuum_layer.addLayout(particle_layout);
 
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createCylindersInSSCA()

MultiLayer * ExemplarySamples::createCylindersInSSCA

(

)

Definition at line 145 of file SizeDistributionModelsBuilder.cpp.

{
    throw std::runtime_error(
        "This sample used ParticleDistribution which is not supported any more.");
 
    // #baRemoveParticleDistribution The following code is outdated. However, it is still kept,
    // since it may be useful once the new particle distribution approach is implemented.
    /*
    Layer vacuum_layer(refMat::Vacuum);
 
    InterferenceRadialParaCrystal interparticle(15.0, 1e3);
    Profile1DGauss pdf(5);
    interparticle.setProbabilityDistribution(pdf);
    interparticle.setKappa(4.02698);
    ParticleLayout particle_layout;
 
    Cylinder ff_cylinder(5.0, 5.0);
    Particle particle_prototype(refMat::Particle, ff_cylinder);
 
    DistributionGaussian gauss(5.0, 1.25);
    ParameterPattern pattern_radius;
    pattern_radius.add("Particle").add("Cylinder").add("Radius");
    ParameterDistribution par_distr(pattern_radius.toStdString(), gauss, 30, 3.0);
    ParameterPattern pattern_height;
    pattern_height.add("Particle").add("Cylinder").add("Height");
    par_distr.linkParameter(pattern_height.toStdString());
    ParticleDistribution particle_collection(particle_prototype, par_distr);
    particle_layout.addParticle(particle_collection);
 
    particle_layout.setInterference(interparticle);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    return sample;
    */
}

createCylindersWithSizeDistribution()

MultiLayer * ExemplarySamples::createCylindersWithSizeDistribution

(

)

Definition at line 28 of file ParticleDistributionsBuilder.cpp.

{
    throw std::runtime_error(
        "This sample used ParticleDistribution which is not supported any more.");
 
    // #baRemoveParticleDistribution The following code is outdated. However, it is still kept,
    // since it may be useful once the new particle distribution approach is implemented.
    /*
    const double height(5);
    const double radius(5);
 
    Layer vacuum_layer(refMat::Vacuum);
 
    ParticleLayout particle_layout;
    // preparing prototype of nano particle
    double sigma = 0.2 * radius;
    Cylinder p_ff_cylinder(radius, height);
    Particle nano_particle(refMat::Particle, p_ff_cylinder);
    // radius of nanoparticles will be sampled with gaussian probability
    int n_samples(100);
    // to get radius_min = average - 2.0*FWHM:
    double n_sigma = 2.0 * 2.0 * std::sqrt(2.0 * std::log(2.0));
    DistributionGaussian gauss(radius, sigma);
    ParameterPattern pattern;
    pattern.add("Particle").add("Cylinder").add("Radius");
    ParameterDistribution par_distr(pattern.toStdString(), gauss, static_cast<size_t>(n_samples),
                                    n_sigma);
    ParticleDistribution particle_collection(nano_particle, par_distr);
    particle_layout.addParticle(particle_collection);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    return sample;
    */
}

createFeNiBilayer()

MultiLayer * ExemplarySamples::createFeNiBilayer

(

)

Definition at line 162 of file FeNiBilayerBuilder.cpp.

{
    auto sample = FeNiBilayer{Options()};
    return sample.release();
}

createFeNiBilayerNC()

MultiLayer * ExemplarySamples::createFeNiBilayerNC

(

)

Definition at line 175 of file FeNiBilayerBuilder.cpp.

{
    auto sample = FeNiBilayer{
        Options().sigmaRoughness(2. * Units::angstrom).roughnessModel(RoughnessModel::NEVOT_CROCE)};
    return sample.release();
}

References Units::angstrom, and MultiLayer::roughnessModel().

Here is the call graph for this function:

createFeNiBilayerSpinFlip()

MultiLayer * ExemplarySamples::createFeNiBilayerSpinFlip

(

)

Definition at line 182 of file FeNiBilayerBuilder.cpp.

{
    auto sample = FeNiBilayer{Options().angle(38. * deg)};
    return sample.release();
}

References Units::deg.

createFeNiBilayerSpinFlipNC()

MultiLayer * ExemplarySamples::createFeNiBilayerSpinFlipNC

(

)

Definition at line 197 of file FeNiBilayerBuilder.cpp.

{
    auto sample = FeNiBilayer{Options()
                                  .angle(38 * deg)
                                  .sigmaRoughness(2. * Units::angstrom)
                                  .roughnessModel(RoughnessModel::NEVOT_CROCE)};
    return sample.release();
}

References Units::angstrom, Units::deg, and MultiLayer::roughnessModel().

Here is the call graph for this function:

createFeNiBilayerSpinFlipTanh()

MultiLayer * ExemplarySamples::createFeNiBilayerSpinFlipTanh

(

)

Definition at line 188 of file FeNiBilayerBuilder.cpp.

{
    auto sample = FeNiBilayer{Options()
                                  .angle(38 * deg)
                                  .sigmaRoughness(2. * Units::angstrom)
                                  .roughnessModel(RoughnessModel::TANH)};
    return sample.release();
}

References Units::angstrom, Units::deg, and MultiLayer::roughnessModel().

Here is the call graph for this function:

createFeNiBilayerTanh()

MultiLayer * ExemplarySamples::createFeNiBilayerTanh

(

)

Definition at line 168 of file FeNiBilayerBuilder.cpp.

{
    auto sample = FeNiBilayer{
        Options().sigmaRoughness(2. * Units::angstrom).roughnessModel(RoughnessModel::TANH)};
    return sample.release();
}

References Units::angstrom, and MultiLayer::roughnessModel().

Here is the call graph for this function:

createFiniteSquareLattice2D()

MultiLayer * ExemplarySamples::createFiniteSquareLattice2D

(

)

Definition at line 150 of file TwoDimLatticeBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    InterferenceFinite2DLattice iff(SquareLattice2D(10.0, 0.0), 40, 40);
    iff.setPositionVariance(1.0);
 
    // particles
    ParticleLayout particle_layout;
    Cylinder ff_cyl(5.0, 5.0);
    Particle particle(refMat::Particle, ff_cyl);
    particle_layout.addParticle(particle, 1.0);
 
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, ParticleLayout::setInterference(), IInterference::setPositionVariance(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createHardDisk()

MultiLayer * ExemplarySamples::createHardDisk

(

)

Definition at line 24 of file PercusYevickBuilder.cpp.

{
    const double m_cylinder_height(5);
    const double m_cylinder_radius(5);
    const double m_disk_radius(5);
    const double m_density(0.006);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Cylinder ff_cylinder(m_cylinder_radius, m_cylinder_height);
    Particle particle(refMat::Particle, ff_cylinder);
    ParticleLayout particle_layout(particle);
 
    InterferenceHardDisk interparticle(m_disk_radius, m_density);
    particle_layout.setInterference(interparticle);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), refMat::Particle, ParticleLayout::setInterference(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createHexParaCrystal()

MultiLayer * ExemplarySamples::createHexParaCrystal

(

)

Definition at line 91 of file ParaCrystalBuilder.cpp.

{
    const double m_peak_distance(20.0);
    const double m_corr_length(0.0);
    const double m_domain_size_1(20.0 * Units::micrometer);
    const double m_domain_size_2(20.0 * Units::micrometer);
    const double m_cylinder_height(5);
    const double m_cylinder_radius(5);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DParaCrystal iff(HexagonalLattice2D(m_peak_distance, 0.0), m_corr_length,
                                  m_domain_size_1, m_domain_size_2);
    iff.setIntegrationOverXi(true);
    Profile2DCauchy pdf(1.0, 1.0, 0);
    iff.setProbabilityDistributions(pdf, pdf);
 
    Cylinder ff_cylinder(m_cylinder_radius, m_cylinder_height);
    Particle cylinder(refMat::Particle, ff_cylinder);
 
    ParticleLayout particle_layout(cylinder);
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), Units::micrometer, refMat::Particle, Interference2DParaCrystal::setIntegrationOverXi(), ParticleLayout::setInterference(), Interference2DParaCrystal::setProbabilityDistributions(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createHomogeneousMultilayer()

MultiLayer * ExemplarySamples::createHomogeneousMultilayer

(

)

Definition at line 20 of file HomogeneousMultilayerBuilder.cpp.

{
    const size_t number_of_layers = 10;
    const double delta_ti = -7.36e-7;
    const double delta_ni = 3.557e-6;
    const double delta_si = 7.81e-7;
    const double thick_ti = 3.0; // nm
    const double thick_ni = 7.0; // nm
 
    Material vacuumaterial = Vacuum();
    Material substrate_material = RefractiveMaterial("Si_substrate", delta_si, 0.0);
    Material ni_material = RefractiveMaterial("Ni", delta_ni, 0.0);
    Material ti_material = RefractiveMaterial("Ti", delta_ti, 0.0);
 
    Layer vacuulayer(vacuumaterial, 0);
    Layer ni_layer(ni_material, thick_ni);
    Layer ti_layer(ti_material, thick_ti);
    Layer substrate_layer(substrate_material, 0);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuulayer);
    for (size_t i = 0; i < number_of_layers; ++i) {
        sample->addLayer(ti_layer);
        sample->addLayer(ni_layer);
    }
    sample->addLayer(substrate_layer);
    return sample;
}

References RefractiveMaterial(), and refMat::Vacuum.

Here is the call graph for this function:

createLattice1D()

MultiLayer * ExemplarySamples::createLattice1D

(

)

Definition at line 29 of file LatticeBuilder.cpp.

{
    const double length(20.0);
    const double xi(10.0 * deg);
    const double corr_length(1000.0);
    const double cylinder_height(5);
    const double cylinder_radius(5);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference1DLattice interparticle(length, xi);
    Profile1DCauchy pdf(corr_length);
    interparticle.setDecayFunction(pdf);
 
    Cylinder ff_cylinder(cylinder_radius, cylinder_height);
    Particle cylinder(refMat::Particle, ff_cylinder);
 
    ParticleLayout particle_layout(cylinder);
    particle_layout.setInterference(interparticle);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), Units::deg, refMat::Particle, Interference1DLattice::setDecayFunction(), ParticleLayout::setInterference(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createLayersWithAbsorptionBySLD()

MultiLayer * ExemplarySamples::createLayersWithAbsorptionBySLD

(

)

Definition at line 29 of file LayersWithAbsorptionBySLDBuilder.cpp.

{
    Material ambience_mat = MaterialBySLD("Vacuum", 0.0, 0.0);
    Material middle_mat = MaterialBySLD("Teflon", 4.7573e-6, 1.6724e-12);
    Material substrate_mat = MaterialBySLD("Substrate", 2.0728e-06, 2.3747e-11);
    Material particle_mat = MaterialBySLD("Ag", 3.4682e-06, 1.0309e-08);
 
    Sphere ff(5.0);
 
    Particle particle(particle_mat, ff);
    particle.setRotation(RotationZ(10.0 * deg));
    particle.rotate(RotationY(10.0 * deg));
    particle.rotate(RotationX(10.0 * deg));
    particle.setParticlePosition(R3(0.0, 0.0, -middle_layer_thickness / 2.0));
 
    ParticleLayout layout;
    layout.addParticle(particle);
 
    Layer vacuum_layer(ambience_mat);
    Layer middle_layer(middle_mat, middle_layer_thickness);
    Layer substrate(substrate_mat);
 
    middle_layer.addLayout(layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(middle_layer);
    sample->addLayer(substrate);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), Units::deg, MaterialBySLD(), middle_layer_thickness(), IParticle::rotate(), IParticle::setParticlePosition(), and IParticle::setRotation().

Here is the call graph for this function:

createLayersWithAbsorptionWithFF()

MultiLayer * ExemplarySamples::createLayersWithAbsorptionWithFF

(

const IFormFactor *

ff

)

Definition at line 27 of file LayersWithAbsorptionBuilder.cpp.

{
    const double middle_layer_thickness(60.0);
 
    Particle particle(refMat::Ag, *ff);
    particle.setRotation(RotationZ(10.0 * deg));
    particle.rotate(RotationY(10.0 * deg));
    particle.rotate(RotationX(10.0 * deg));
    particle.setParticlePosition(R3(0.0, 0.0, -middle_layer_thickness / 2.0));
 
    ParticleLayout layout;
    layout.addParticle(particle);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer middle_layer(refMat::Teflon, middle_layer_thickness);
    Layer substrate(refMat::Substrate2);
 
    middle_layer.addLayout(layout);
 
    auto* sample = new MultiLayer(ff->shapeName());
    sample->addLayer(vacuum_layer);
    sample->addLayer(middle_layer);
    sample->addLayer(substrate);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Ag, Units::deg, middle_layer_thickness(), IParticle::rotate(), IParticle::setParticlePosition(), IParticle::setRotation(), refMat::Substrate2, refMat::Teflon, and refMat::Vacuum.

Here is the call graph for this function:

createLinkedBoxDistribution()

MultiLayer * ExemplarySamples::createLinkedBoxDistribution

(

)

Definition at line 245 of file ParticleDistributionsBuilder.cpp.

{
    throw std::runtime_error(
        "This sample used ParticleDistribution which is not supported any more.");
 
    // #baRemoveParticleDistribution The following code is outdated. However, it is still kept,
    // since it may be useful once the new particle distribution approach is implemented.
    /*
    // particle
    Box ff(40.0, 30.0, 10.0);
    Particle box(refMat::Particle, ff);
 
    // particle collection
    DistributionGate gate(10.0, 70.0);
    ParameterDistribution parameter_distr("/Particle/Box/Length", gate, 3, 0.0,
                                          RealLimits::limited(1.0, 200.0));
    parameter_distr.linkParameter("/Particle/Box/Width").linkParameter("/Particle/Box/Height");
 
    ParticleDistribution collection(box, parameter_distr);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(collection);
    particle_layout.setTotalParticleSurfaceDensity(1e-4);
 
    // Multi layer
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
    */
}

createMagneticCylinders()

MultiLayer * ExemplarySamples::createMagneticCylinders

(

)

Definition at line 60 of file MagneticParticlesBuilder.cpp.

{
    const double m_cylinder_radius(5);
    const double m_cylinder_height(5);
 
    Material vacuum_material = RefractiveMaterial("Vacuum", 0.0, 0.0);
    Material substrate_material = RefractiveMaterial("Substrate", 15e-6, 0.0);
    R3 magnetization(0.0, 1e6, 0.0);
    Material particle_material = RefractiveMaterial("MagParticle2", 5e-6, 0.0, magnetization);
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
 
    Cylinder ff_cylinder(m_cylinder_radius, m_cylinder_height);
 
    Particle particle(particle_material, ff_cylinder);
    ParticleLayout particle_layout(particle);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), and RefractiveMaterial().

Here is the call graph for this function:

createMagneticLayer()

MultiLayer * ExemplarySamples::createMagneticLayer

(

)

Definition at line 92 of file MagneticLayersBuilder.cpp.

{
    auto* sample = new MultiLayer();
 
    R3 layer_field = R3(0.0, 0.0, 1e6);
    R3 particle_field(1e6, 0.0, 0.0);
    Material vacuum_material = RefractiveMaterial("Vacuum0", 0.0, 0.0);
    Material layer_material = RefractiveMaterial("Vacuum1", 0.0, 0.0, layer_field);
    Material substrate_material = RefractiveMaterial("Substrate", 7e-6, 2e-8);
    Material particle_material = RefractiveMaterial("MagParticle", 6e-4, 2e-8, particle_field);
 
    ParticleLayout particle_layout;
    Sphere ff_sphere(sphere_radius);
    Particle particle(particle_material, ff_sphere);
    particle_layout.addParticle(particle);
 
    Layer vacuum_layer(vacuum_material);
    vacuum_layer.addLayout(particle_layout);
    Layer substrate_layer(substrate_material);
 
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), and RefractiveMaterial().

Here is the call graph for this function:

createMagneticParticleZeroField()

MultiLayer * ExemplarySamples::createMagneticParticleZeroField

(

)

Definition at line 30 of file MagneticParticlesBuilder.cpp.

{
    const double m_cylinder_radius(5);
    const double m_cylinder_height(5);
 
    Material vacuum_material = RefractiveMaterial("Vacuum", 0.0, 0.0);
    Material substrate_material = RefractiveMaterial("Substrate", 6e-6, 2e-8);
    R3 magnetic_field(0.0, 0.0, 0.0);
    Material particle_material = RefractiveMaterial("MagParticle", 6e-4, 2e-8, magnetic_field);
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
 
    Cylinder ff_cylinder(m_cylinder_radius, m_cylinder_height);
 
    Particle particle(particle_material, ff_cylinder);
    ParticleLayout particle_layout(particle);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), and RefractiveMaterial().

Here is the call graph for this function:

createMagneticRotation()

MultiLayer * ExemplarySamples::createMagneticRotation

(

)

Definition at line 146 of file MagneticLayersBuilder.cpp.

{
    auto* sample = new MultiLayer();
 
    R3 substr_field = R3(0.0, 1e6, 0.0);
    R3 particle_field(1e6, 0.0, 0.0);
    Material vacuum_material = RefractiveMaterial("Vacuum", 0.0, 0.0);
    Material substrate_material = RefractiveMaterial("Substrate", 7e-6, 2e-8, substr_field);
    Material particle_material = RefractiveMaterial("MagParticle", 6e-4, 2e-8, particle_field);
 
    ParticleLayout particle_layout;
    R3 position(0.0, 0.0, -10.0);
    Sphere ff_sphere(sphere_radius);
    Particle particle(particle_material, ff_sphere);
    RotationZ rot_z(90 * deg);
    particle.rotate(rot_z);
    particle.translate(position);
    particle_layout.addParticle(particle);
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
    substrate_layer.addLayout(particle_layout);
 
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), Units::deg, RefractiveMaterial(), IParticle::rotate(), and IParticle::translate().

Here is the call graph for this function:

createMagneticSpheres()

MultiLayer * ExemplarySamples::createMagneticSpheres

(

)

Definition at line 90 of file MagneticParticlesBuilder.cpp.

{
    const double m_sphere_radius(5);
 
    R3 magnetization(0.0, 0.0, 1e7);
    Material particle_material = RefractiveMaterial("Particle", 2e-5, 4e-7, magnetization);
    Material vacuum_material = RefractiveMaterial("Vacuum", 0.0, 0.0);
    Material substrate_material = RefractiveMaterial("Substrate", 7e-6, 1.8e-7);
 
    Sphere ff_sphere(m_sphere_radius);
    Particle particle(particle_material, ff_sphere);
    R3 position(0.0, 0.0, -2.0 * m_sphere_radius);
    particle.translate(position);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(particle);
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
    substrate_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), RefractiveMaterial(), and IParticle::translate().

Here is the call graph for this function:

createMagneticSubstrateZeroField()

MultiLayer * ExemplarySamples::createMagneticSubstrateZeroField

(

)

Definition at line 44 of file MagneticLayersBuilder.cpp.

{
    R3 substr_field(0.0, 0.0, 0.0);
    R3 particle_field(0.1, 0.0, 0.0);
    Material vacuum_material = RefractiveMaterial("Vacuum", 0.0, 0.0);
    Material substrate_material = RefractiveMaterial("Substrate", 7e-6, 2e-8, substr_field);
    Material particle_material = RefractiveMaterial("MagParticle", 6e-4, 2e-8, particle_field);
 
    ParticleLayout particle_layout;
    R3 position(0.0, 0.0, -10.0);
    Sphere ff_sphere(sphere_radius);
    Particle particle(particle_material, ff_sphere);
    particle.translate(position);
    particle_layout.addParticle(particle);
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
    substrate_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), RefractiveMaterial(), and IParticle::translate().

Here is the call graph for this function:

createMesoCrystal()

MultiLayer * ExemplarySamples::createMesoCrystal

(

)

Definition at line 27 of file MesoCrystalBuilder.cpp.

{
    // mesocrystal lattice
    R3 lattice_basis_a(5.0, 0.0, 0.0);
    R3 lattice_basis_b(0.0, 5.0, 0.0);
    R3 lattice_basis_c(0.0, 0.0, 5.0);
    Lattice3D lattice(lattice_basis_a, lattice_basis_b, lattice_basis_c);
 
    // spherical particle that forms the base of the mesocrystal
    Sphere sphere_ff(2.0);
    Particle sphere(refMat::Particle, sphere_ff);
 
    // crystal structure
    Crystal crystal(sphere, lattice);
 
    // mesocrystal
    Cylinder meso_ff(20.0, 50.0);
    MesoCrystal meso(crystal, meso_ff);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(meso);
 
    Layer vacuum_layer(refMat::Vacuum);
    vacuum_layer.addLayout(particle_layout);
    Layer substrate_layer(refMat::Substrate);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createMultiLayerWithNCRoughness()

MultiLayer * ExemplarySamples::createMultiLayerWithNCRoughness

(

)

Definition at line 19 of file MultiLayerWithNCRoughnessBuilder.cpp.

{
    auto* sample = createMultiLayerWithRoughness();
    sample->setRoughnessModel(RoughnessModel::NEVOT_CROCE);
    return sample;
}

References createMultiLayerWithRoughness().

Here is the call graph for this function:

createMultiLayerWithRoughness()

MultiLayer * ExemplarySamples::createMultiLayerWithRoughness

(

)

Definition at line 21 of file MultiLayerWithRoughnessBuilder.cpp.

{
    const double thicknessA(2.5);
    const double thicknessB(5.0);
    const double sigma(1.0);
    const double hurst(0.3);
    const double lateralCorrLength(5.0);
    const double crossCorrLength(10.0);
 
    Material vacuum_material = RefractiveMaterial("Vacuum", 0., 0.);
    Material substrate_material = RefractiveMaterial("Substrate", 15e-6, 0.0);
    Material part_a_material = RefractiveMaterial("PartA", 5e-6, 0.0);
    Material part_b_material = RefractiveMaterial("PartB", 10e-6, 0.0);
 
    Layer vacuum_layer(vacuum_material, 0);
    Layer partA_layer(part_a_material, thicknessA);
    Layer partB_layer(part_b_material, thicknessB);
    Layer substrate_layer(substrate_material, 0);
 
    LayerRoughness roughness(sigma, hurst, lateralCorrLength);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    for (int i = 0; i < 5; ++i) {
        sample->addLayerWithTopRoughness(partA_layer, roughness);
        sample->addLayerWithTopRoughness(partB_layer, roughness);
    }
    sample->addLayerWithTopRoughness(substrate_layer, roughness);
    sample->setCrossCorrLength(crossCorrLength);
    return sample;
}

References RefractiveMaterial().

Referenced by createMultiLayerWithNCRoughness().

Here is the call graph for this function:

createMultipleLayout()

MultiLayer * ExemplarySamples::createMultipleLayout

(

)

Definition at line 24 of file MultipleLayoutBuilder.cpp.

{
    const double cylinder_height(5);
    const double cylinder_radius(5);
    const double prisheight(5);
    const double prislength(10);
    const double cylinder_weight(0.5);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    ParticleLayout particle_layout_1;
    ParticleLayout particle_layout_2;
 
    Cylinder ff_cylinder(cylinder_radius, cylinder_height);
    Particle cylinder(refMat::Particle, ff_cylinder);
 
    Prism3 ff_prism3(prislength, prisheight);
    Particle prism3(refMat::Particle, ff_prism3);
 
    particle_layout_1.addParticle(cylinder, cylinder_weight);
    particle_layout_2.addParticle(prism3, 1.0 - cylinder_weight);
 
    vacuum_layer.addLayout(particle_layout_1);
    vacuum_layer.addLayout(particle_layout_2);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createParticleComposition()

MultiLayer * ExemplarySamples::createParticleComposition

(

)

Definition at line 28 of file ParticleCompositionBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    double radius(10.0);
    Sphere sphere_ff(radius);
    Particle sphere(refMat::Particle, sphere_ff);
    ParticleLayout particle_layout;
 
    std::vector<R3> positions = {{},
                                 {radius, radius / std::sqrt(3.0), std::sqrt(8.0 / 3.0) * radius}};
 
    ParticleComposition basis;
 
    basis.addParticles(sphere, positions);
    particle_layout.addParticle(basis);
 
    Interference2DLattice iff(HexagonalLattice2D(radius * 2.0, 0));
    Profile2DCauchy pdf(10, 10, 0);
    iff.setDecayFunction(pdf);
 
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), ParticleComposition::addParticles(), refMat::Particle, Interference2DLattice::setDecayFunction(), ParticleLayout::setInterference(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createParticleInVacuumWithFF()

MultiLayer * ExemplarySamples::createParticleInVacuumWithFF

(

const IFormFactor *

ff

)

Definition at line 25 of file ParticleInVacuumBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
 
    Particle particle(refMat::Particle, *ff);
    ParticleLayout particle_layout(particle);
    vacuum_layer.addLayout(particle_layout);
 
    auto* result = new MultiLayer("ParticleInVacuum_" + ff->shapeName());
    result->addLayer(vacuum_layer);
    return result;
}

References Layer::addLayout(), refMat::Particle, and refMat::Vacuum.

Here is the call graph for this function:

createPlainMultiLayerBySLD()

MultiLayer * ExemplarySamples::createPlainMultiLayerBySLD	(	int	n_layers = 10,
		double	thick_ti = 3.0
	)

Definition at line 34 of file PlainMultiLayerBySLDBuilder.cpp.

{
    double thick_ni(7.0);
 
    Material vacuum_material = MaterialBySLD();
    Material substrate_material = MaterialBySLD("Si_substrate", m_si.sld_real, m_si.sld_imag);
    Material ni_material = MaterialBySLD("Ni", m_ni.sld_real, m_ni.sld_imag);
    Material ti_material = MaterialBySLD("Ti", m_ti.sld_real, m_ti.sld_imag);
 
    Layer vacuum_layer(vacuum_material);
    Layer ni_layer(ni_material, thick_ni);
    Layer ti_layer(ti_material, thick_ti);
    Layer substrate_layer(substrate_material);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    for (int i = 0; i < n_layers; ++i) {
        sample->addLayer(ti_layer);
        sample->addLayer(ni_layer);
    }
    sample->addLayer(substrate_layer);
    return sample;
}

References MaterialBySLD().

Here is the call graph for this function:

createRadialParaCrystal()

MultiLayer * ExemplarySamples::createRadialParaCrystal

(

)

Definition at line 29 of file ParaCrystalBuilder.cpp.

{
    const double m_corr_peak_distance(20.0);
    const double m_corr_width(7);
    const double m_corr_length(1e3);
    const double m_cylinder_height(5);
    const double m_cylinder_radius(5);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    InterferenceRadialParaCrystal iff(m_corr_peak_distance, m_corr_length);
    Profile1DGauss pdf(m_corr_width);
    iff.setProbabilityDistribution(pdf);
    Cylinder ff_cylinder(m_cylinder_radius, m_cylinder_height);
 
    Particle particle(refMat::Particle, ff_cylinder);
    ParticleLayout particle_layout(particle);
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), refMat::Particle, ParticleLayout::setInterference(), InterferenceRadialParaCrystal::setProbabilityDistribution(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createRectParaCrystal()

MultiLayer * ExemplarySamples::createRectParaCrystal

(

)

Definition at line 127 of file ParaCrystalBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DParaCrystal iff(SquareLattice2D(10), 0, 0, 0);
    iff.setIntegrationOverXi(true);
    iff.setDomainSizes(20.0 * Units::micrometer, 20.0 * Units::micrometer);
    Profile2DCauchy pdf1(0.5, 2.0, 0);
    Profile2DCauchy pdf2(0.5, 2.0, 0);
    iff.setProbabilityDistributions(pdf1, pdf2);
 
    Cylinder ff_cylinder(5.0, 5.0);
 
    Particle particle(refMat::Particle, ff_cylinder);
    ParticleLayout particle_layout(particle);
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), Units::micrometer, refMat::Particle, Interference2DParaCrystal::setDomainSizes(), Interference2DParaCrystal::setIntegrationOverXi(), ParticleLayout::setInterference(), Interference2DParaCrystal::setProbabilityDistributions(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createResonator()

MultiLayer * ExemplarySamples::createResonator

(

double

ti_thickness = 13.0

)

Definition at line 23 of file ResonatorBuilder.cpp.

{
    auto* result = new MultiLayer;
 
    Material m_Si = RefractiveMaterial("Si", 8.25218379931e-06, 0.0);
    Material m_Ti = RefractiveMaterial("Ti", -7.6593316363e-06, 3.81961616312e-09);
    Material m_TiO2 = RefractiveMaterial("TiO2", 1.04803530026e-05, 2.03233519385e-09);
    Material m_Pt = RefractiveMaterial("Pt", 2.52936993309e-05, 7.54553992473e-09);
    Material m_D2O = RefractiveMaterial("D2O", 2.52897204573e-05, 4.5224432814e-13);
 
    Layer l_TiO2(m_TiO2, 3.0);
    Layer l_Ti_top(m_Ti, 10.0);
    Layer l_Ti(m_Ti, ti_thickness);
    Layer l_Si(m_Si);
    Layer l_Pt(m_Pt, 32.0);
    Layer l_D2O(m_D2O);
 
    LayerRoughness roughness(2.0, 0.8, 1e4);
 
    result->addLayer(l_Si);
 
    const int nlayers = 3;
    for (size_t i = 0; i < nlayers; ++i) {
        result->addLayerWithTopRoughness(l_Ti, roughness);
        result->addLayerWithTopRoughness(l_Pt, roughness);
    }
 
    result->addLayerWithTopRoughness(l_Ti_top, roughness);
    result->addLayerWithTopRoughness(l_TiO2, roughness);
    result->addLayerWithTopRoughness(l_D2O, roughness);
 
    result->setCrossCorrLength(400);
 
    return result;
}

References RefractiveMaterial().

Here is the call graph for this function:

createRotatedPyramids()

MultiLayer * ExemplarySamples::createRotatedPyramids

(

)

Definition at line 27 of file RotatedPyramidsBuilder.cpp.

{
    const double m_length(10);
    const double m_height(5);
    const double m_alpha(Units::deg2rad(54.73));
    const double m_zangle(45. * deg);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Pyramid4 ff_pyramid(m_length, m_height, m_alpha);
 
    Particle pyramid(refMat::Particle, ff_pyramid);
 
    RotationZ z_rotation(m_zangle);
    pyramid.rotate(z_rotation);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(pyramid);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), Units::deg, Units::deg2rad(), refMat::Particle, IParticle::rotate(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createRotatedPyramidsDistribution()

MultiLayer * ExemplarySamples::createRotatedPyramidsDistribution

(

)

Definition at line 129 of file ParticleDistributionsBuilder.cpp.

{
    throw std::runtime_error(
        "This sample used ParticleDistribution which is not supported any more.");
 
    // #baRemoveParticleDistribution The following code is outdated. However, it is still kept,
    // since it may be useful once the new particle distribution approach is implemented.
    /*
    double m_length(10);
    double m_height(5);
    double m_alpha(Units::deg2rad(54.73));
    double m_zangle(45. * deg);
 
    // particle
    Pyramid4 ff_pyramid(m_length, m_height, m_alpha);
    Particle pyramid(refMat::Particle, ff_pyramid);
    pyramid.setRotation(RotationZ(m_zangle));
 
    // particle collection
    DistributionGate gate(35.0 * deg, 55.0 * deg);
    ParameterDistribution parameter_distr("/Particle/ZRotation/Angle", gate, 10, 2.0);
 
    ParticleDistribution collection(pyramid, parameter_distr);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(collection);
 
    // Multi layer
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
    */
}

createRotatedSquareLattice2D()

MultiLayer * ExemplarySamples::createRotatedSquareLattice2D

(

)

Definition at line 121 of file TwoDimLatticeBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DLattice iff(SquareLattice2D(10.0, 30.0 * deg));
    Profile2DCauchy pdf(300.0 / 2.0 / M_PI, 100.0 / 2.0 / M_PI, 30.0 * deg);
    iff.setDecayFunction(pdf);
 
    ParticleLayout particle_layout;
    // particle
    Cylinder ff_cyl(5.0, 5.0);
    R3 position(0.0, 0.0, 0.0);
    Particle p(refMat::Particle, ff_cyl);
    p.setParticlePosition(position);
    particle_layout.addParticle(p);
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), Units::deg, M_PI, refMat::Particle, Interference2DLattice::setDecayFunction(), ParticleLayout::setInterference(), IParticle::setParticlePosition(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createSimpleMagneticLayer()

MultiLayer * ExemplarySamples::createSimpleMagneticLayer

(

)

Definition at line 71 of file MagneticLayersBuilder.cpp.

{
    auto* sample = new MultiLayer();
 
    R3 layer_field = R3(0.0, 1e8, 0.0);
    Material vacuum_material = MaterialBySLD("Vacuum", 0.0, 0.0);
    Material layer_material = MaterialBySLD("MagLayer", 1e-4, 1e-8, layer_field);
    Material substrate_material = MaterialBySLD("Substrate", 7e-5, 2e-6);
 
    Layer vacuum_layer(vacuum_material);
    Layer intermediate_layer(layer_material, 10.0); // 10 nm layer thickness
    Layer substrate_layer(substrate_material);
 
    sample->addLayer(vacuum_layer);
    sample->addLayer(intermediate_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References MaterialBySLD().

Here is the call graph for this function:

createSimpleMagneticRotationWithRoughness()

MultiLayer * ExemplarySamples::createSimpleMagneticRotationWithRoughness

(

const std::string &

roughnessKey

)

Definition at line 120 of file MagneticLayersBuilder.cpp.

{
    const auto& [sigmaRoughness, roughnessModel] = RoughnessCases.at(roughnessKey);
    auto* sample = new MultiLayer();
 
    R3 substr_field = R3(0.0, 1e6, 0.0);
    R3 layer_field = R3(1e6, 1e6, 0.0);
    Material vacuum_material = RefractiveMaterial("Vacuum", 0.0, 0.0);
    Material substrate_material = RefractiveMaterial("Substrate", 7e-6, 2e-8, substr_field);
    Material layer_material = RefractiveMaterial("MagLayer", 6e-4, 2e-8, layer_field);
 
    auto roughness = LayerRoughness();
    roughness.setSigma(sigmaRoughness * Units::angstrom);
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
    Layer layer(layer_material, 200 * Units::angstrom);
    sample->addLayer(vacuum_layer);
    sample->addLayerWithTopRoughness(layer, roughness);
    sample->addLayerWithTopRoughness(substrate_layer, roughness);
    sample->setRoughnessModel(roughnessModel);
    return sample;
}

References Units::angstrom, and RefractiveMaterial().

Here is the call graph for this function:

createSizeDistributionDAModel()

MultiLayer * ExemplarySamples::createSizeDistributionDAModel

(

)

Definition at line 25 of file SizeDistributionModelsBuilder.cpp.

{
    // cylindrical particle 1
    double radius1(5);
    double height1 = radius1;
    Cylinder cylinder_ff1(radius1, height1);
    Particle cylinder1(refMat::Particle, cylinder_ff1);
 
    // cylindrical particle 2
    double radius2(8);
    double height2(radius2);
    Cylinder cylinder_ff2(radius2, height2);
    Particle cylinder2(refMat::Particle, cylinder_ff2);
 
    // interference function
    InterferenceRadialParaCrystal interference(18.0, 1e3);
    Profile1DGauss pdf(3);
    interference.setProbabilityDistribution(pdf);
 
    // assembling the sample
    ParticleLayout particle_layout;
    particle_layout.addParticle(cylinder1, 0.8);
    particle_layout.addParticle(cylinder2, 0.2);
    particle_layout.setInterference(interference);
 
    Layer vacuum_layer(refMat::Vacuum);
    vacuum_layer.addLayout(particle_layout);
    Layer substrate_layer(refMat::Substrate);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, ParticleLayout::setInterference(), InterferenceRadialParaCrystal::setProbabilityDistribution(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createSizeDistributionLMAModel()

MultiLayer * ExemplarySamples::createSizeDistributionLMAModel

(

)

Definition at line 62 of file SizeDistributionModelsBuilder.cpp.

{
    // cylindrical particle 1
    double radius1(5);
    double height1 = radius1;
    Cylinder cylinder_ff1(radius1, height1);
    Particle cylinder1(refMat::Particle, cylinder_ff1);
 
    // cylindrical particle 2
    double radius2(8);
    double height2(radius2);
    Cylinder cylinder_ff2(radius2, height2);
    Particle cylinder2(refMat::Particle, cylinder_ff2);
 
    // interference function1
    InterferenceRadialParaCrystal interference1(16.8, 1e3);
    Profile1DGauss pdf(3);
    interference1.setProbabilityDistribution(pdf);
 
    // interference function2
    InterferenceRadialParaCrystal interference2(22.8, 1e3);
    interference2.setProbabilityDistribution(pdf);
 
    // assembling the sample
    ParticleLayout particle_layout1;
    particle_layout1.addParticle(cylinder1, 0.8);
    particle_layout1.setInterference(interference1);
 
    ParticleLayout particle_layout2;
    particle_layout2.addParticle(cylinder2, 0.2);
    particle_layout2.setInterference(interference2);
 
    Layer vacuum_layer(refMat::Vacuum);
    vacuum_layer.addLayout(particle_layout1);
    vacuum_layer.addLayout(particle_layout2);
    Layer substrate_layer(refMat::Substrate);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, ParticleLayout::setInterference(), InterferenceRadialParaCrystal::setProbabilityDistribution(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createSizeDistributionSSCAModel()

MultiLayer * ExemplarySamples::createSizeDistributionSSCAModel

(

)

Definition at line 107 of file SizeDistributionModelsBuilder.cpp.

{
    // cylindrical particle 1
    double radius1(5);
    double height1 = radius1;
    Cylinder cylinder_ff1(radius1, height1);
    Particle cylinder1(refMat::Particle, cylinder_ff1);
 
    // cylindrical particle 2
    double radius2(8);
    double height2(radius2);
    Cylinder cylinder_ff2(radius2, height2);
    Particle cylinder2(refMat::Particle, cylinder_ff2);
 
    // interference function
    InterferenceRadialParaCrystal interference(18.0, 1e3);
    Profile1DGauss pdf(3);
    interference.setProbabilityDistribution(pdf);
    interference.setKappa(1.0);
 
    // assembling the sample
    ParticleLayout particle_layout;
    particle_layout.addParticle(cylinder1, 0.8);
    particle_layout.addParticle(cylinder2, 0.2);
    particle_layout.setInterference(interference);
 
    Layer vacuum_layer(refMat::Vacuum);
    vacuum_layer.addLayout(particle_layout);
    Layer substrate_layer(refMat::Substrate);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, ParticleLayout::setInterference(), InterferenceRadialParaCrystal::setKappa(), InterferenceRadialParaCrystal::setProbabilityDistribution(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createSLDSlicedCylinders()

MultiLayer * ExemplarySamples::createSLDSlicedCylinders

(

)

Definition at line 70 of file SlicedCylindersBuilder.cpp.

{
    Material vacuum_material = MaterialBySLD("Vacuum", 0.0, 0.0);
    complex_t sub_sld = getSLDFromN(wavelength, 6e-6, 2e-8);
    Material substrate_material = MaterialBySLD("Substrate", sub_sld.real(), sub_sld.imag());
    complex_t par_sld = getSLDFromN(wavelength, 6e-4, 2e-8);
    Material particle_material = MaterialBySLD("Particle", par_sld.real(), par_sld.imag());
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
 
    Cylinder ff_cylinder(radius, height);
 
    Particle particle(particle_material, ff_cylinder);
    ParticleLayout particle_layout(particle);
 
    vacuum_layer.addLayout(particle_layout);
    vacuum_layer.setNumberOfSlices(n_slices);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), MaterialBySLD(), and Layer::setNumberOfSlices().

Here is the call graph for this function:

createSlicedComposition()

MultiLayer * ExemplarySamples::createSlicedComposition

(

)

Definition at line 28 of file SlicedCompositionBuilder.cpp.

{
    const double sphere_radius = 10.0;
    const double bottom_cup_height = 4.0;
    const double composition_shift = bottom_cup_height;
 
    Particle topCup(refMat::Ag,
                    TruncatedSphere(sphere_radius, sphere_radius * 2 - bottom_cup_height, 0));
    Particle bottomCup(refMat::Teflon, TruncatedSphere(sphere_radius, bottom_cup_height, 0));
    bottomCup.setRotation(RotationX(180 * deg));
 
    ParticleComposition composition;
    composition.addParticle(topCup, R3(0.0, 0.0, bottom_cup_height));
    composition.addParticle(bottomCup, R3(0.0, 0.0, bottom_cup_height));
    composition.setParticlePosition(0, 0, -composition_shift);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(composition);
 
    Layer vacuum_layer(refMat::Vacuum);
    vacuum_layer.addLayout(particle_layout);
 
    Layer substrate_layer(refMat::Substrate2);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleComposition::addParticle(), ParticleLayout::addParticle(), refMat::Ag, Units::deg, IParticle::setParticlePosition(), IParticle::setRotation(), refMat::Substrate2, refMat::Teflon, and refMat::Vacuum.

Here is the call graph for this function:

createSlicedCylinders()

MultiLayer * ExemplarySamples::createSlicedCylinders

(

)

Definition at line 47 of file SlicedCylindersBuilder.cpp.

{
    Material vacuum_material = RefractiveMaterial("Vacuum", 0.0, 0.0);
    Material substrate_material = RefractiveMaterial("Substrate", 6e-6, 2e-8);
    Material particle_material = RefractiveMaterial("Particle", 6e-4, 2e-8);
 
    Layer vacuum_layer(vacuum_material);
    Layer substrate_layer(substrate_material);
 
    Cylinder ff_cylinder(radius, height);
 
    Particle particle(particle_material, ff_cylinder);
    ParticleLayout particle_layout(particle);
 
    vacuum_layer.addLayout(particle_layout);
    vacuum_layer.setNumberOfSlices(n_slices);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), RefractiveMaterial(), and Layer::setNumberOfSlices().

Here is the call graph for this function:

createSpheresWithLimitsDistribution()

MultiLayer * ExemplarySamples::createSpheresWithLimitsDistribution

(

)

Definition at line 171 of file ParticleDistributionsBuilder.cpp.

{
    throw std::runtime_error(
        "This sample used ParticleDistribution which is not supported any more.");
 
    // #baRemoveParticleDistribution The following code is outdated. However, it is still kept,
    // since it may be useful once the new particle distribution approach is implemented.
    /*
    // particle
    Sphere ff(3.0);
    Particle sphere(refMat::Particle, ff);
 
    // particle collection
    DistributionGaussian gauss(3.0, 1.0);
    ParameterDistribution parameter_distr("/Particle/Sphere/Radius", gauss, 10, 20.0,
                                          RealLimits::limited(2.0, 4.0));
 
    ParticleDistribution collection(sphere, parameter_distr);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(collection);
 
    // Multi layer
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
 
    return sample;
    */
}

createSquareLattice2D()

MultiLayer * ExemplarySamples::createSquareLattice2D

(

)

Definition at line 60 of file TwoDimLatticeBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DLattice iff(SquareLattice2D(10.0, 0));
    Profile2DCauchy pdf(300.0 / 2.0 / M_PI, 100.0 / 2.0 / M_PI, 0);
    iff.setDecayFunction(pdf);
 
    // particles
    ParticleLayout particle_layout;
    Cylinder ff_cyl(5.0, 5.0);
    Particle particle(refMat::Particle, ff_cyl);
    particle_layout.addParticle(particle);
 
    particle_layout.setInterference(iff);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), M_PI, refMat::Particle, Interference2DLattice::setDecayFunction(), ParticleLayout::setInterference(), refMat::Substrate, and refMat::Vacuum.

Here is the call graph for this function:

createSuperLattice()

MultiLayer * ExemplarySamples::createSuperLattice

(

)

Definition at line 177 of file TwoDimLatticeBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    Layer substrate_layer(refMat::Substrate);
 
    Interference2DSuperLattice iff(SquareLattice2D(200.0, 0.0), 40, 40);
    InterferenceFinite2DLattice substructure(SquareLattice2D(10.0, 0.0), 10, 10);
    iff.setSubstructureIFF(substructure);
    iff.setPositionVariance(1.0);
 
    // particles
    ParticleLayout particle_layout;
    Cylinder ff_cyl(5.0, 10.0);
    Particle particle(refMat::Vacuum, ff_cyl);
    particle.translate(R3(0.0, 0.0, -10.0));
    particle_layout.addParticle(particle);
 
    particle_layout.setInterference(iff);
    particle_layout.setTotalParticleSurfaceDensity(100.0 / 4e4);
 
    substrate_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), ParticleLayout::setInterference(), IInterference::setPositionVariance(), Interference2DSuperLattice::setSubstructureIFF(), ParticleLayout::setTotalParticleSurfaceDensity(), refMat::Substrate, IParticle::translate(), and refMat::Vacuum.

Here is the call graph for this function:

createThickAbsorptiveSample()

MultiLayer * ExemplarySamples::createThickAbsorptiveSample

(

)

Definition at line 21 of file ThickAbsorptiveSampleBuilder.cpp.

{
    Material vacuum_material = MaterialBySLD("Vacuum", 0.0, 0.0);
    Material au_material = MaterialBySLD("Au", 3.48388057043e-05, 1.79057609656e-05);
    Material si_material = MaterialBySLD("Si", 3.84197565094e-07, 6.28211531498e-07);
 
    Layer vacuum_layer(vacuum_material);
    Layer au_layer(au_material, 200.0);
    Layer vacuum_layer_2(vacuum_material, 10.0);
    Layer substrate_layer(si_material);
 
    LayerRoughness rough(5.0, 0.5, 10.0);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(au_layer);
    sample->addLayer(vacuum_layer_2);
    sample->addLayerWithTopRoughness(substrate_layer, rough);
    return sample;
}

References MaterialBySLD().

Here is the call graph for this function:

createTransformBox()

MultiLayer * ExemplarySamples::createTransformBox

(

)

Definition at line 27 of file TransformationsBuilder.cpp.

{
    const double layer_thickness(100);
    const double length(50);
    const double width(20);
    const double height(10);
 
    Particle box(refMat::Ag, Box(length, width, height));
    box.setRotation(RotationZ(90. * deg));
    box.rotate(RotationY(90. * deg));
    box.setParticlePosition(R3(0, 0, -layer_thickness / 2.));
 
    ParticleLayout layout;
    layout.addParticle(box);
 
    Layer vacuum_layer(refMat::Vacuum);
    Layer middle_layer(refMat::Teflon, layer_thickness);
    middle_layer.addLayout(layout);
    Layer substrate(refMat::Substrate2);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(middle_layer);
    sample->addLayer(substrate);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Ag, Units::deg, IParticle::rotate(), IParticle::setParticlePosition(), IParticle::setRotation(), refMat::Substrate2, refMat::Teflon, and refMat::Vacuum.

Here is the call graph for this function:

createTriangularRipple()

MultiLayer * ExemplarySamples::createTriangularRipple

(

double

d = 0

)

Definition at line 49 of file RipplesBuilder.cpp.

{
    Layer vacuum_layer(refMat::Vacuum);
    SawtoothRippleBox ff_ripple2(100.0, 20.0, 4.0, d);
    Particle ripple(refMat::Particle, ff_ripple2);
 
    ParticleLayout particle_layout;
    particle_layout.addParticle(ripple, 1.0);
    InterferenceRadialParaCrystal interparticle(20.0, 1e7);
    Profile1DGauss pdf(4.0);
    interparticle.setProbabilityDistribution(pdf);
    particle_layout.setInterference(interparticle);
 
    vacuum_layer.addLayout(particle_layout);
    Layer substrate_layer(refMat::Substrate);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    sample->addLayer(substrate_layer);
    return sample;
}

References Layer::addLayout(), ParticleLayout::addParticle(), refMat::Particle, ParticleLayout::setInterference(), InterferenceRadialParaCrystal::setProbabilityDistribution(), refMat::Substrate, and refMat::Vacuum.

Referenced by createAsymRipple().

Here is the call graph for this function:

createTwoTypesCylindersDistribution()

MultiLayer * ExemplarySamples::createTwoTypesCylindersDistribution

(

)

Definition at line 70 of file ParticleDistributionsBuilder.cpp.

{
    throw std::runtime_error(
        "This sample used ParticleDistribution which is not supported any more.");
 
    // #baRemoveParticleDistribution The following code is outdated. However, it is still kept,
    // since it may be useful once the new particle distribution approach is implemented.
    /*
 
    double m_radius1(5);
    double m_radius2(10);
    double m_height1(5);
    double m_height2(10);
    double m_sigma1_ratio(0.2);
    double m_sigma2_ratio(0.02);
 
    Layer vacuum_layer(refMat::Vacuum);
 
    ParticleLayout particle_layout;
 
    // preparing nano particles prototypes for seeding layer's particle_layout
    Cylinder p_ff_cylinder1(m_radius1, m_height1);
    Particle cylinder1(refMat::Particle, p_ff_cylinder1);
 
    Cylinder p_ff_cylinder2(m_radius2, m_height2);
    Particle cylinder2(refMat::Particle, p_ff_cylinder2);
 
    // radius of nanoparticles will be sampled with gaussian probability
    int nbins = 150;
    double sigma1 = m_radius1 * m_sigma1_ratio;
    double sigma2 = m_radius2 * m_sigma2_ratio;
    // to have xmin=average-3*sigma
    double n_sigma = 3.0;
    DistributionGaussian gauss1(m_radius1, sigma1);
    DistributionGaussian gauss2(m_radius2, sigma2);
 
    // building distribution of nano particles
    ParameterPattern pattern1;
    pattern1.add("Particle").add("Cylinder").add("Radius");
    ParameterDistribution par_distr1(pattern1.toStdString(), gauss1, nbins, n_sigma);
    ParticleDistribution particle_collection1(cylinder1, par_distr1);
    particle_layout.addParticle(particle_collection1, 0.95);
    ParameterPattern pattern2;
    pattern2.add("Particle").add("Cylinder").add("Radius");
    ParameterDistribution par_distr2(pattern2.toStdString(), gauss2, static_cast<size_t>(nbins),
                                     n_sigma);
    ParticleDistribution particle_collection2(cylinder2, par_distr2);
    particle_layout.addParticle(particle_collection2, 0.05);
 
    vacuum_layer.addLayout(particle_layout);
 
    auto* sample = new MultiLayer();
    sample->addLayer(vacuum_layer);
    return sample;
    */
}