TransformToDomain Namespace Reference

Functions
void	addBeamDivergencesToScan (const SessionItem &beam_item, AngularSpecScan &simulation)
void	addDistributionParametersToSimulation (const SessionItem &beam_item, GISASSimulation &simulation)
	adds DistributionParameters to the ISimulation More...
std::unique_ptr< Material >	createDomainMaterial (const SessionItem &item)
std::unique_ptr< IParticle >	createIParticle (const SessionItem &item)
std::unique_ptr< Layer >	createLayer (const SessionItem &item)
std::unique_ptr< LayerRoughness >	createLayerRoughness (const SessionItem &item)
std::unique_ptr< MultiLayer >	createMultiLayer (const SessionItem &item)
std::unique_ptr< ParticleDistribution >	createParticleDistribution (const SessionItem &item)
std::unique_ptr< ParticleLayout >	createParticleLayout (const SessionItem &item)
void	setBeamDistribution (const std::string &parameter_name, const BeamDistributionItem &item, ISimulation &simulation)
void	setPositionInfo (IParticle *result, const SessionItem &item)
void	setRotationInfo (IParticle *result, const SessionItem &item)
void	setSimulationOptions (ISimulation *simulation, const SessionItem &item)
void	setTransformationInfo (IParticle *result, const SessionItem &item)

Function Documentation

addBeamDivergencesToScan()

void TransformToDomain::addBeamDivergencesToScan	(	const SessionItem &	beam_item,
		AngularSpecScan &	simulation
	)

Definition at line 163 of file TransformToDomain.cpp.

{
    if (beam_item.modelType() != "SpecularBeam") {
        ASSERT(beam_item.modelType() == "SpecularBeam");
        return;
    }
 
    auto resolution = createScanResolution(beam_item.getItem(SpecularBeamItem::P_WAVELENGTH));
    if (resolution)
        scan.setWavelengthResolution(*resolution);
    resolution = createScanResolution(beam_item.getItem(SpecularBeamItem::P_INCLINATION_ANGLE));
    if (resolution)
        scan.setAngleResolution(*resolution);
}

References ASSERT, SessionItem::getItem(), SessionItem::modelType(), BeamItem::P_INCLINATION_ANGLE, BeamItem::P_WAVELENGTH, AngularSpecScan::setAngleResolution(), and AngularSpecScan::setWavelengthResolution().

Here is the call graph for this function:

addDistributionParametersToSimulation()

void TransformToDomain::addDistributionParametersToSimulation	(	const SessionItem &	beam_item,
		GISASSimulation &	simulation
	)

adds DistributionParameters to the ISimulation

Definition at line 147 of file TransformToDomain.cpp.

{
    if (beam_item.modelType() != "GISASBeam") {
        ASSERT(beam_item.modelType() == "GISASBeam");
        return;
    }
 
    setParameterDistributionToSimulation<BeamWavelengthItem>(
        "Wavelength", beam_item.getItem(BeamItem::P_WAVELENGTH), simulation);
    setParameterDistributionToSimulation<BeamInclinationAngleItem>(
        "InclinationAngle", beam_item.getItem(BeamItem::P_INCLINATION_ANGLE), simulation);
    setParameterDistributionToSimulation<BeamAzimuthalAngleItem>(
        "AzimuthalAngle", beam_item.getItem(BeamItem::P_AZIMUTHAL_ANGLE), simulation);
}

References ASSERT, SessionItem::getItem(), SessionItem::modelType(), BeamItem::P_AZIMUTHAL_ANGLE, BeamItem::P_INCLINATION_ANGLE, and BeamItem::P_WAVELENGTH.

Here is the call graph for this function:

createDomainMaterial()

std::unique_ptr< Material > TransformToDomain::createDomainMaterial

(

const SessionItem &

item

)

Definition at line 64 of file TransformToDomain.cpp.

{
    auto parent_job = JobModelFunctions::findJobItem(&item);
    const MaterialItemContainer* container =
        parent_job ? parent_job->materialContainerItem() : nullptr;
    QString tag = MaterialItemUtils::materialTag(item);
    ExternalProperty property = item.getItemValue(tag).value<ExternalProperty>();
    return container ? MaterialItemUtils::createDomainMaterial(property, *container)
                     : MaterialItemUtils::createDomainMaterial(property);
}

References MaterialItemUtils::createDomainMaterial(), JobModelFunctions::findJobItem(), SessionItem::getItemValue(), and MaterialItemUtils::materialTag().

Referenced by createLayer(), and ParticleItem::createParticle().

Here is the call graph for this function:

createIParticle()

std::unique_ptr< IParticle > TransformToDomain::createIParticle

(

const SessionItem &

item

)

Definition at line 119 of file TransformToDomain.cpp.

{
    std::unique_ptr<IParticle> P_particle;
    if (item.modelType() == "Particle") {
        auto& particle_item = static_cast<const ParticleItem&>(item);
        P_particle = particle_item.createParticle();
    } else if (item.modelType() == "ParticleCoreShell") {
        auto& particle_coreshell_item = static_cast<const ParticleCoreShellItem&>(item);
        P_particle = particle_coreshell_item.createParticleCoreShell();
    } else if (item.modelType() == "ParticleComposition") {
        auto& particle_composition_item = static_cast<const ParticleCompositionItem&>(item);
        P_particle = particle_composition_item.createParticleComposition();
    } else if (item.modelType() == "MesoCrystal") {
        auto& mesocrystal_item = static_cast<const MesoCrystalItem&>(item);
        P_particle = mesocrystal_item.createMesoCrystal();
    }
    return P_particle;
}

References MesoCrystalItem::createMesoCrystal(), ParticleItem::createParticle(), ParticleCompositionItem::createParticleComposition(), ParticleCoreShellItem::createParticleCoreShell(), and SessionItem::modelType().

Referenced by DomainObjectBuilder::buildParticleLayout(), and ParticleDistributionItem::createParticleDistribution().

Here is the call graph for this function:

createLayer()

std::unique_ptr< Layer > TransformToDomain::createLayer

(

const SessionItem &

item

)

Definition at line 86 of file TransformToDomain.cpp.

{
    auto P_layer = std::make_unique<Layer>(*createDomainMaterial(item),
                                           item.getItemValue(LayerItem::P_THICKNESS).toDouble());
    P_layer->setNumberOfSlices(item.getItemValue(LayerItem::P_NSLICES).toUInt());
    return P_layer;
}

References createDomainMaterial(), SessionItem::getItemValue(), LayerItem::P_NSLICES, and LayerItem::P_THICKNESS.

Referenced by DomainObjectBuilder::buildLayer().

Here is the call graph for this function:

createLayerRoughness()

std::unique_ptr< LayerRoughness > TransformToDomain::createLayerRoughness

(

const SessionItem &

item

)

Definition at line 95 of file TransformToDomain.cpp.

{
    if (roughnessItem.modelType() == "LayerZeroRoughness") {
        return nullptr;
    } else if (roughnessItem.modelType() == "LayerBasicRoughness") {
        return std::make_unique<LayerRoughness>(
            roughnessItem.getItemValue(LayerBasicRoughnessItem::P_SIGMA).toDouble(),
            roughnessItem.getItemValue(LayerBasicRoughnessItem::P_HURST).toDouble(),
            roughnessItem.getItemValue(LayerBasicRoughnessItem::P_LATERAL_CORR_LENGTH).toDouble());
    } else {
        throw GUIHelpers::Error("TransformToDomain::createLayerRoughness() -> Error.");
    }
}

References SessionItem::getItemValue(), SessionItem::modelType(), LayerBasicRoughnessItem::P_HURST, LayerBasicRoughnessItem::P_LATERAL_CORR_LENGTH, and LayerBasicRoughnessItem::P_SIGMA.

Referenced by DomainObjectBuilder::buildMultiLayer().

Here is the call graph for this function:

createMultiLayer()

std::unique_ptr< MultiLayer > TransformToDomain::createMultiLayer

(

const SessionItem &

item

)

Definition at line 75 of file TransformToDomain.cpp.

{
    auto P_multilayer = std::make_unique<MultiLayer>();
    auto cross_corr_length = item.getItemValue(MultiLayerItem::P_CROSS_CORR_LENGTH).toDouble();
    if (cross_corr_length > 0)
        P_multilayer->setCrossCorrLength(cross_corr_length);
    auto external_field = item.item<VectorItem>(MultiLayerItem::P_EXTERNAL_FIELD)->getVector();
    P_multilayer->setExternalField(external_field);
    return P_multilayer;
}

References SessionItem::getItemValue(), SessionItem::item(), MultiLayerItem::P_CROSS_CORR_LENGTH, and MultiLayerItem::P_EXTERNAL_FIELD.

Referenced by DomainObjectBuilder::buildMultiLayer().

Here is the call graph for this function:

createParticleDistribution()

std::unique_ptr< ParticleDistribution > TransformToDomain::createParticleDistribution

(

const SessionItem &

item

)

Definition at line 139 of file TransformToDomain.cpp.

{
    auto& particle_distribution = static_cast<const ParticleDistributionItem&>(item);
    auto P_part_distr = particle_distribution.createParticleDistribution();
    return P_part_distr;
}

References ParticleDistributionItem::createParticleDistribution().

Referenced by DomainObjectBuilder::buildParticleLayout().

Here is the call graph for this function:

createParticleLayout()

std::unique_ptr< ParticleLayout > TransformToDomain::createParticleLayout

(

const SessionItem &

item

)

Definition at line 109 of file TransformToDomain.cpp.

{
    auto P_layout = std::make_unique<ParticleLayout>();
    auto total_density = item.getItemValue(ParticleLayoutItem::P_TOTAL_DENSITY).value<double>();
    auto layout_weight = item.getItemValue(ParticleLayoutItem::P_WEIGHT).value<double>();
    P_layout->setTotalParticleSurfaceDensity(total_density);
    P_layout->setWeight(layout_weight);
    return P_layout;
}

References SessionItem::getItemValue(), ParticleLayoutItem::P_TOTAL_DENSITY, and ParticleLayoutItem::P_WEIGHT.

Referenced by DomainObjectBuilder::buildParticleLayout().

Here is the call graph for this function:

setBeamDistribution()

void TransformToDomain::setBeamDistribution	(	const std::string &	parameter_name,
		const BeamDistributionItem &	item,
		ISimulation &	simulation
	)

Definition at line 179 of file TransformToDomain.cpp.

{
    ParameterPattern parameter_pattern;
    parameter_pattern.beginsWith("*").add("Beam").add(parameter_name);
 
    auto P_par_distr = item.getParameterDistributionForName(parameter_pattern.toStdString());
    if (P_par_distr)
        simulation.addParameterDistribution(*P_par_distr);
}

References ParameterPattern::add(), ISimulation::addParameterDistribution(), ParameterPattern::beginsWith(), BeamDistributionItem::getParameterDistributionForName(), and ParameterPattern::toStdString().

Referenced by DepthProbeInstrumentItem::createSimulation().

Here is the call graph for this function:

setPositionInfo()

void TransformToDomain::setPositionInfo	(	IParticle *	result,
		const SessionItem &	item
	)

Definition at line 214 of file TransformToDomain.cpp.

{
    kvector_t pos = item.item<VectorItem>(ParticleItem::P_POSITION)->getVector();
    result->setPosition(pos.x(), pos.y(), pos.z());
}

References SessionItem::item(), ParticleItem::P_POSITION, IParticle::setPosition(), BasicVector3D< T >::x(), BasicVector3D< T >::y(), and BasicVector3D< T >::z().

Referenced by setTransformationInfo().

Here is the call graph for this function:

setRotationInfo()

void TransformToDomain::setRotationInfo	(	IParticle *	result,
		const SessionItem &	item
	)

Definition at line 220 of file TransformToDomain.cpp.

{
    QVector<SessionItem*> children = item.children();
    for (int i = 0; i < children.size(); ++i) {
        if (children[i]->modelType() == "Rotation") {
            auto& rot_item = children[i]->groupItem<RotationItem>(TransformationItem::P_ROT);
            auto rotation = rot_item.createRotation();
            if (rotation)
                result->setRotation(*rotation);
            break;
        }
    }
}

References SessionItem::children(), RotationItem::createRotation(), TransformationItem::P_ROT, and IParticle::setRotation().

Referenced by setTransformationInfo().

Here is the call graph for this function:

setSimulationOptions()

void TransformToDomain::setSimulationOptions	(	ISimulation *	simulation,
		const SessionItem &	item
	)

Definition at line 191 of file TransformToDomain.cpp.

{
    ASSERT(item.modelType() == "SimulationOptions");
 
    if (auto optionItem = dynamic_cast<const SimulationOptionsItem*>(&item)) {
        simulation->getOptions().setNumberOfThreads(optionItem->getNumberOfThreads());
        if (optionItem->getComputationMethod() == "Monte-Carlo Integration") {
            simulation->getOptions().setMonteCarloIntegration(
                true, optionItem->getNumberOfMonteCarloPoints());
        }
        if (optionItem->getFresnelMaterialMethod() == "Average Layer Material")
            simulation->getOptions().setUseAvgMaterials(true);
        if (optionItem->getIncludeSpecularPeak() == "Yes")
            simulation->getOptions().setIncludeSpecular(true);
    }
}

References ASSERT, ISimulation::getOptions(), SessionItem::modelType(), SimulationOptions::setIncludeSpecular(), SimulationOptions::setMonteCarloIntegration(), SimulationOptions::setNumberOfThreads(), and SimulationOptions::setUseAvgMaterials().

Here is the call graph for this function:

setTransformationInfo()

void TransformToDomain::setTransformationInfo	(	IParticle *	result,
		const SessionItem &	item
	)

Definition at line 208 of file TransformToDomain.cpp.

{
    setPositionInfo(result, item);
    setRotationInfo(result, item);
}

References setPositionInfo(), and setRotationInfo().

Referenced by MesoCrystalItem::createMesoCrystal(), ParticleItem::createParticle(), ParticleCompositionItem::createParticleComposition(), and ParticleCoreShellItem::createParticleCoreShell().

Here is the call graph for this function: