DomainObjectBuilder Namespace Reference

Functions
std::unique_ptr< Instrument >	buildInstrument (const InstrumentItem &instrumentItem)
std::unique_ptr< IInterferenceFunction >	buildInterferenceFunction (const SessionItem &item)
std::unique_ptr< Layer >	buildLayer (const SessionItem &item)
std::unique_ptr< MultiLayer >	buildMultiLayer (const SessionItem &multilayer_item)
std::unique_ptr< ParticleLayout >	buildParticleLayout (const SessionItem &item)
std::unique_ptr< IUnitConverter >	createUnitConverter (const InstrumentItem *instrumentItem)
	Creates a unit converter corresponding to the given instrument item. More...

Function Documentation

buildInstrument()

std::unique_ptr< Instrument > DomainObjectBuilder::buildInstrument

(

const InstrumentItem &

instrumentItem

)

Definition at line 128 of file DomainObjectBuilder.cpp.

{
    return instrumentItem.createInstrument();
}

References InstrumentItem::createInstrument().

Here is the call graph for this function:

buildInterferenceFunction()

std::unique_ptr< IInterferenceFunction > DomainObjectBuilder::buildInterferenceFunction

(

const SessionItem &

item

)

Definition at line 120 of file DomainObjectBuilder.cpp.

{
    auto iffItem = dynamic_cast<const InterferenceFunctionItem*>(&item);
    ASSERT(iffItem);
    return iffItem->createInterferenceFunction();
}

References ASSERT.

Referenced by buildParticleLayout().

buildLayer()

std::unique_ptr< Layer > DomainObjectBuilder::buildLayer

(

const SessionItem &

item

)

Definition at line 54 of file DomainObjectBuilder.cpp.

{
    auto P_layer = TransformToDomain::createLayer(item);
    QVector<SessionItem*> children = item.children();
    for (int i = 0; i < children.size(); ++i) {
        if (children[i]->modelType() == "ParticleLayout") {
            auto P_layout = buildParticleLayout(*children[i]);
            if (P_layout) {
                P_layer->addLayout(*P_layout);
            }
        }
    }
    return P_layer;
}

References buildParticleLayout(), SessionItem::children(), and TransformToDomain::createLayer().

Referenced by buildMultiLayer().

Here is the call graph for this function:

buildMultiLayer()

std::unique_ptr< MultiLayer > DomainObjectBuilder::buildMultiLayer

(

const SessionItem &

multilayer_item

)

Definition at line 32 of file DomainObjectBuilder.cpp.

{
    auto P_multilayer = TransformToDomain::createMultiLayer(multilayer_item);
    QVector<SessionItem*> children = multilayer_item.children();
    for (int i = 0; i < children.size(); ++i) {
        if (children[i]->modelType() == "Layer") {
            auto P_layer = buildLayer(*children[i]);
            auto roughnessItem = children[i]->getGroupItem(LayerItem::P_ROUGHNESS);
            ASSERT(roughnessItem);
            auto P_roughness = TransformToDomain::createLayerRoughness(*roughnessItem);
            if (P_layer) {
                if (P_roughness) {
                    P_multilayer->addLayerWithTopRoughness(*P_layer, *P_roughness);
                } else {
                    P_multilayer->addLayer(*P_layer);
                }
            }
        }
    }
    return P_multilayer;
}

References ASSERT, buildLayer(), SessionItem::children(), TransformToDomain::createLayerRoughness(), TransformToDomain::createMultiLayer(), and LayerItem::P_ROUGHNESS.

Referenced by DomainSimulationBuilder::createSimulation(), and PySampleWidget::generateCodeSnippet().

Here is the call graph for this function:

buildParticleLayout()

std::unique_ptr< ParticleLayout > DomainObjectBuilder::buildParticleLayout

(

const SessionItem &

item

)

Definition at line 69 of file DomainObjectBuilder.cpp.

{
    auto P_layout = TransformToDomain::createParticleLayout(item);
    QVector<SessionItem*> children = item.getItems();
    for (int i = 0; i < children.size(); ++i) {
        auto P_particle = TransformToDomain::createIParticle(*children[i]);
        if (P_particle) {
            P_layout->addParticle(*P_particle);
            continue;
        }
        if (children[i]->modelType() == "ParticleDistribution") {
            auto prop = children[i]
                            ->getItemValue(ParticleDistributionItem::P_DISTRIBUTED_PARAMETER)
                            .value<ComboProperty>();
            QString par_name = prop.getValue();
            if (par_name == ParticleDistributionItem::NO_SELECTION) {
                auto grandchildren = children[i]->getItems();
                if (grandchildren.empty()) {
                    continue;
                }
                if (grandchildren.size() > 1) {
                    throw GUIHelpers::Error("DomainObjectBuilder::buildParticleLayout()"
                                            " -> Error! Too many particles defined"
                                            " in ParticleDistribution");
                }
                auto P_particle = TransformToDomain::createIParticle(*grandchildren[0]);
                if (P_particle) {
                    P_layout->addParticle(*P_particle);
                }
            } else {
                auto P_part_distr = TransformToDomain::createParticleDistribution(*children[i]);
                if (P_part_distr) {
                    P_layout->addParticle(*P_part_distr);
                }
            }
        } else {
            throw GUIHelpers::Error("DomainObjectBuilder::buildParticleLayout()"
                                    " -> Error! Not implemented");
        }
    }
    QVector<SessionItem*> interferences = item.getItems(ParticleLayoutItem::T_INTERFERENCE);
    for (int i = 0; i < interferences.size(); i++) {
        auto P_interference = buildInterferenceFunction(*interferences[i]);
        if (P_interference) {
            P_layout->setInterferenceFunction(*P_interference);
        }
    }
    return P_layout;
}

References buildInterferenceFunction(), TransformToDomain::createIParticle(), TransformToDomain::createParticleDistribution(), TransformToDomain::createParticleLayout(), SessionItem::getItems(), ComboProperty::getValue(), ParticleDistributionItem::NO_SELECTION, ParticleDistributionItem::P_DISTRIBUTED_PARAMETER, and ParticleLayoutItem::T_INTERFERENCE.

Referenced by buildLayer().

Here is the call graph for this function:

createUnitConverter()

std::unique_ptr< IUnitConverter > DomainObjectBuilder::createUnitConverter

(

const InstrumentItem *

instrumentItem

)

Creates a unit converter corresponding to the given instrument item.

Definition at line 134 of file DomainObjectBuilder.cpp.

{
    if (auto specular_instrument = dynamic_cast<const SpecularInstrumentItem*>(instrumentItem))
        return specular_instrument->createUnitConverter();
    else if (auto depth_instrument = dynamic_cast<const DepthProbeInstrumentItem*>(instrumentItem))
        return depth_instrument->createUnitConverter();
 
    const auto instrument = instrumentItem->createInstrument();
    instrument->initDetector();
 
    if (instrumentItem->is<GISASInstrumentItem>())
        return UnitConverterUtils::createConverterForGISAS(*instrument);
 
    if (instrumentItem->is<OffSpecularInstrumentItem>()) {
        auto axis_item =
            instrumentItem->item<BasicAxisItem>(OffSpecularInstrumentItem::P_ALPHA_AXIS);
        const auto detector2d = dynamic_cast<const IDetector2D*>(instrument->getDetector());
        return std::make_unique<OffSpecularConverter>(*detector2d, instrument->beam(),
                                                      *axis_item->createAxis(Units::deg));
    }
 
    throw GUIHelpers::Error(
        "Error in DomainObjectBuilder::createUnitConverter: unknown instrument type.");
}

References BasicAxisItem::createAxis(), UnitConverterUtils::createConverterForGISAS(), InstrumentItem::createInstrument(), Units::deg, SessionItem::is(), SessionItem::item(), and OffSpecularInstrumentItem::P_ALPHA_AXIS.

Referenced by JobItemUtils::createDefaultDetectorMap(), JobModelFunctions::initDataView(), JobItemUtils::setIntensityItemAxesUnits(), and JobItemUtils::updateDataAxes().

Here is the call graph for this function: