TransformFromDomain Namespace Reference

Functions
bool	isValidRoughness (const LayerRoughness *roughness)
	Returns true if given roughness is non-zero roughness. More...
void	set1DLatticeItem (SessionItem *item, const InterferenceFunction1DLattice &sample)
void	set2DLatticeItem (SessionItem *item, const InterferenceFunction2DLattice &sample)
void	set2DParaCrystalItem (SessionItem *item, const InterferenceFunction2DParaCrystal &sample)
void	setAxisItem (SessionItem *item, const IAxis &axis, double factor=1.0)
void	setBackground (InstrumentItem *instrument_item, const ISimulation &simulation)
void	setDetector (Instrument2DItem *instrument_item, const ISimulation2D &simulation)
void	setDetectorGeometry (Instrument2DItem *instrument_item, const IDetector &detector)
void	setDetectorMasks (DetectorItem *detector_item, const ISimulation &simulation)
void	setDetectorProperties (DetectorItem *detector_item, const IDetector &detector)
void	setDetectorResolution (DetectorItem *detector_item, const IDetector &detector)
void	setFinite2DLatticeItem (SessionItem *item, const InterferenceFunctionFinite2DLattice &sample)
void	setFootprintFactor (const IFootprintFactor *footprint, SpecularBeamItem *beam_item)
void	setGISASBeamItem (BeamItem *beam_item, const GISASSimulation &simulation)
void	setHardDiskItem (SessionItem *item, const InterferenceFunctionHardDisk &sample)
void	setItemFromSample (BeamDistributionItem *beam_distribution_item, const ParameterDistribution &parameter_distribution)
void	setLayerItem (SessionItem *layer_item, const Layer *layer, const LayerInterface *top_interface)
void	setMaskContainer (MaskContainerItem *container_item, const IDetector &detector, double scale)
void	setOffSpecularBeamItem (BeamItem *beam_item, const OffSpecularSimulation &simulation)
void	setParticleDistributionItem (SessionItem *item, const ParticleDistribution &sample)
	Initialization of ParticleDistributionItem. More...
void	setRadialParaCrystalItem (SessionItem *item, const InterferenceFunctionRadialParaCrystal &sample)
void	setRectangularDetector (RectangularDetectorItem *detector_item, const RectangularDetector &detector)
void	setRoughnessItem (SessionItem *item, const LayerRoughness &sample)
void	setSpecularBeamItem (SpecularBeamItem *beam_item, const SpecularSimulation &simulation)
void	setSphericalDetector (SphericalDetectorItem *detector_item, const SphericalDetector &detector)

Function Documentation

isValidRoughness()

bool TransformFromDomain::isValidRoughness

(

const LayerRoughness *

roughness

)

Returns true if given roughness is non-zero roughness.

Definition at line 228 of file TransformFromDomain.cpp.

{
    if (!roughness)
        return false;
    if (roughness->getSigma() == 0 && roughness->getHurstParameter() == 0.0
        && roughness->getLatteralCorrLength() == 0.0)
        return false;
    return true;
}

References LayerRoughness::getHurstParameter(), LayerRoughness::getLatteralCorrLength(), and LayerRoughness::getSigma().

Referenced by setLayerItem().

Here is the call graph for this function:

set1DLatticeItem()

void TransformFromDomain::set1DLatticeItem	(	SessionItem *	item,
		const InterferenceFunction1DLattice &	sample
	)

Definition at line 88 of file TransformFromDomain.cpp.

{
    item->setItemValue(InterferenceFunction1DLatticeItem::P_LENGTH, sample.getLength());
    item->setItemValue(InterferenceFunction1DLatticeItem::P_ROTATION_ANGLE,
                       Units::rad2deg(sample.getXi()));
 
    auto pdf = OnlyChildOfType<IFTDecayFunction1D>(sample);
    QString group_name = InterferenceFunction1DLatticeItem::P_DECAY_FUNCTION;
    SetDecayFunction1D(item, pdf, group_name);
    setPositionVariance(item, sample);
}

References InterferenceFunction1DLattice::getLength(), InterferenceFunction1DLattice::getXi(), InterferenceFunction1DLatticeItem::P_DECAY_FUNCTION, InterferenceFunction1DLatticeItem::P_LENGTH, InterferenceFunction1DLatticeItem::P_ROTATION_ANGLE, Units::rad2deg(), and SessionItem::setItemValue().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

set2DLatticeItem()

void TransformFromDomain::set2DLatticeItem	(	SessionItem *	item,
		const InterferenceFunction2DLattice &	sample
	)

Definition at line 101 of file TransformFromDomain.cpp.

{
    set2DLatticeParameters(item, sample.lattice());
 
    item->setItemValue(InterferenceFunction2DLatticeItem::P_XI_INTEGRATION,
                       sample.integrationOverXi());
 
    auto p_pdf = OnlyChildOfType<IFTDecayFunction2D>(sample);
    QString group_name = InterferenceFunction2DLatticeItem::P_DECAY_FUNCTION;
    SetDecayFunction2D(item, p_pdf, group_name);
    setPositionVariance(item, sample);
}

References InterferenceFunction2DLattice::integrationOverXi(), InterferenceFunction2DLattice::lattice(), InterferenceFunction2DLatticeItem::P_DECAY_FUNCTION, InterferenceFunction2DLatticeItem::P_XI_INTEGRATION, and SessionItem::setItemValue().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

set2DParaCrystalItem()

void TransformFromDomain::set2DParaCrystalItem	(	SessionItem *	item,
		const InterferenceFunction2DParaCrystal &	sample
	)

Definition at line 115 of file TransformFromDomain.cpp.

{
    set2DLatticeParameters(item, sample.lattice());
 
    item->setItemValue(InterferenceFunction2DParaCrystalItem::P_DAMPING_LENGTH,
                       sample.dampingLength());
    item->setItemValue(InterferenceFunction2DParaCrystalItem::P_DOMAIN_SIZE1,
                       sample.domainSizes()[0]);
    item->setItemValue(InterferenceFunction2DParaCrystalItem::P_DOMAIN_SIZE2,
                       sample.domainSizes()[1]);
    item->setItemValue(InterferenceFunction2DParaCrystalItem::P_XI_INTEGRATION,
                       sample.integrationOverXi());
 
    auto pdfs = ChildNodesOfType<IFTDistribution2D>(sample);
    QStringList group_names;
    group_names << InterferenceFunction2DParaCrystalItem::P_PDF1
                << InterferenceFunction2DParaCrystalItem::P_PDF2;
    for (unsigned i = 0; i < pdfs.size(); ++i)
        setPDF2D(item, pdfs[i], group_names[i]);
    setPositionVariance(item, sample);
}

References InterferenceFunction2DParaCrystal::dampingLength(), InterferenceFunction2DParaCrystal::domainSizes(), InterferenceFunction2DParaCrystal::integrationOverXi(), InterferenceFunction2DParaCrystal::lattice(), InterferenceFunction2DParaCrystalItem::P_DAMPING_LENGTH, InterferenceFunction2DParaCrystalItem::P_DOMAIN_SIZE1, InterferenceFunction2DParaCrystalItem::P_DOMAIN_SIZE2, InterferenceFunction2DParaCrystalItem::P_PDF1, InterferenceFunction2DParaCrystalItem::P_PDF2, InterferenceFunction2DParaCrystalItem::P_XI_INTEGRATION, and SessionItem::setItemValue().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

setAxisItem()

void TransformFromDomain::setAxisItem	(	SessionItem *	item,
		const IAxis &	axis,
		double	factor = 1.0
	)

Definition at line 615 of file TransformFromDomain.cpp.

{
    if (item->modelType() != "BasicAxis")
        throw GUIHelpers::Error("TransformFromDomain::setAxisItem() -> Error. Unexpected item.");
 
    if (!dynamic_cast<const FixedBinAxis*>(&axis))
        throw GUIHelpers::Error("TransformFromDomain::setAxisItem() -> Error. Unexpected axis");
 
    item->setItemValue(BasicAxisItem::P_NBINS, static_cast<int>(axis.size()));
    item->setItemValue(BasicAxisItem::P_MIN_DEG, factor * axis.lowerBound());
    item->setItemValue(BasicAxisItem::P_MAX_DEG, factor * axis.upperBound());
    item->setItemValue(BasicAxisItem::P_TITLE, QString::fromStdString(axis.getName()));
}

References IAxis::getName(), IAxis::lowerBound(), SessionItem::modelType(), BasicAxisItem::P_MAX_DEG, BasicAxisItem::P_MIN_DEG, BasicAxisItem::P_NBINS, BasicAxisItem::P_TITLE, SessionItem::setItemValue(), IAxis::size(), and IAxis::upperBound().

Referenced by setSpecularBeamItem().

Here is the call graph for this function:

setBackground()

void TransformFromDomain::setBackground	(	InstrumentItem *	instrument_item,
		const ISimulation &	simulation
	)

Definition at line 583 of file TransformFromDomain.cpp.

{
    auto p_bg = simulation.background();
    if (auto p_constant_bg = dynamic_cast<const ConstantBackground*>(p_bg)) {
        auto constant_bg_item =
            instrument_item->setGroupProperty(InstrumentItem::P_BACKGROUND, "ConstantBackground");
        double value = p_constant_bg->backgroundValue();
        constant_bg_item->setItemValue(ConstantBackgroundItem::P_VALUE, value);
    } else if (dynamic_cast<const PoissonNoiseBackground*>(p_bg)) {
        instrument_item->setGroupProperty(InstrumentItem::P_BACKGROUND, "PoissonNoiseBackground");
    }
}

References ISimulation::background(), InstrumentItem::P_BACKGROUND, ConstantBackgroundItem::P_VALUE, SessionItem::setGroupProperty(), and SessionItem::setItemValue().

Here is the call graph for this function:

setDetector()

void TransformFromDomain::setDetector	(	Instrument2DItem *	instrument_item,
		const ISimulation2D &	simulation
	)

Definition at line 311 of file TransformFromDomain.cpp.

{
    const IDetector* p_detector = simulation.getDetector();
    setDetectorGeometry(instrument_item, *p_detector);
 
    auto detector_item = instrument_item->detectorItem();
 
    setDetectorResolution(detector_item, *p_detector);
    setDetectorProperties(detector_item, *p_detector);
    setDetectorMasks(detector_item, simulation);
}

References Instrument2DItem::detectorItem(), ISimulation::getDetector(), setDetectorGeometry(), setDetectorMasks(), setDetectorProperties(), and setDetectorResolution().

Here is the call graph for this function:

setDetectorGeometry()

void TransformFromDomain::setDetectorGeometry	(	Instrument2DItem *	instrument_item,
		const IDetector &	detector
	)

Definition at line 324 of file TransformFromDomain.cpp.

{
    if (auto det = dynamic_cast<const SphericalDetector*>(&detector)) {
        instrument_item->setDetectorGroup("SphericalDetector");
        auto item = dynamic_cast<SphericalDetectorItem*>(instrument_item->detectorItem());
        setSphericalDetector(item, *det);
    } else if (auto det = dynamic_cast<const RectangularDetector*>(&detector)) {
        instrument_item->setDetectorGroup("RectangularDetector");
        auto item = dynamic_cast<RectangularDetectorItem*>(instrument_item->detectorItem());
        setRectangularDetector(item, *det);
    } else {
        throw GUIHelpers::Error(
            "TransformFromDomain::setDetectorGeometry() -> Unknown detector type.");
    }
}

References Instrument2DItem::detectorItem(), Instrument2DItem::setDetectorGroup(), setRectangularDetector(), and setSphericalDetector().

Referenced by setDetector().

Here is the call graph for this function:

setDetectorMasks()

void TransformFromDomain::setDetectorMasks	(	DetectorItem *	detector_item,
		const ISimulation &	simulation
	)

Definition at line 464 of file TransformFromDomain.cpp.

{
    const IDetector* detector = simulation.getDetector();
    if ((detector->detectorMask() && detector->detectorMask()->numberOfMasks())
        || detector->regionOfInterest()) {
        detector_item->createMaskContainer();
 
        double scale(1.0);
        if (detector_item->modelType() == "SphericalDetector")
            scale = 1. / Units::deg;
 
        setMaskContainer(detector_item->maskContainerItem(), *detector, scale);
    }
}

References DetectorItem::createMaskContainer(), Units::deg, IDetector::detectorMask(), ISimulation::getDetector(), DetectorItem::maskContainerItem(), SessionItem::modelType(), DetectorMask::numberOfMasks(), IDetector::regionOfInterest(), and setMaskContainer().

Referenced by setDetector().

Here is the call graph for this function:

setDetectorProperties()

void TransformFromDomain::setDetectorProperties	(	DetectorItem *	detector_item,
		const IDetector &	detector
	)

Definition at line 371 of file TransformFromDomain.cpp.

{
    double total_transmission = detector.detectionProperties().analyzerTotalTransmission();
    if (total_transmission <= 0.0)
        return;
 
    kvector_t analyzer_dir = detector.detectionProperties().analyzerDirection();
    double efficiency = detector.detectionProperties().analyzerEfficiency();
    detector_item->item<VectorItem>(DetectorItem::P_ANALYZER_DIRECTION)->setVector(analyzer_dir);
    detector_item->setItemValue(DetectorItem::P_ANALYZER_EFFICIENCY, efficiency);
    detector_item->setItemValue(DetectorItem::P_ANALYZER_TOTAL_TRANSMISSION, total_transmission);
}

References DetectionProperties::analyzerDirection(), DetectionProperties::analyzerEfficiency(), DetectionProperties::analyzerTotalTransmission(), IDetector::detectionProperties(), SessionItem::item(), DetectorItem::P_ANALYZER_DIRECTION, DetectorItem::P_ANALYZER_EFFICIENCY, DetectorItem::P_ANALYZER_TOTAL_TRANSMISSION, and SessionItem::setItemValue().

Referenced by setDetector().

Here is the call graph for this function:

setDetectorResolution()

void TransformFromDomain::setDetectorResolution	(	DetectorItem *	detector_item,
		const IDetector &	detector
	)

Definition at line 341 of file TransformFromDomain.cpp.

{
    const IDetectorResolution* p_resfunc = detector.detectorResolution();
 
    if (!p_resfunc)
        return;
 
    if (auto p_convfunc = dynamic_cast<const ConvolutionDetectorResolution*>(p_resfunc)) {
        if (auto resfunc = dynamic_cast<const ResolutionFunction2DGaussian*>(
                p_convfunc->getResolutionFunction2D())) {
            SessionItem* item = detector_item->setGroupProperty(DetectorItem::P_RESOLUTION_FUNCTION,
                                                                "ResolutionFunction2DGaussian");
            double scale(1.0);
            if (detector_item->modelType() == "SphericalDetector")
                scale = 1. / Units::deg;
            item->setItemValue(ResolutionFunction2DGaussianItem::P_SIGMA_X,
                               scale * resfunc->getSigmaX());
            item->setItemValue(ResolutionFunction2DGaussianItem::P_SIGMA_Y,
                               scale * resfunc->getSigmaY());
        } else {
            throw GUIHelpers::Error("TransformFromDomain::setDetectorResolution() -> Error. "
                                    "Unknown detector resolution function");
        }
    } else {
        throw GUIHelpers::Error("TransformFromDomain::setDetectorResolution() -> Error. "
                                "Not a ConvolutionDetectorResolution function");
    }
}

References Units::deg, IDetector::detectorResolution(), SessionItem::modelType(), DetectorItem::P_RESOLUTION_FUNCTION, ResolutionFunction2DGaussianItem::P_SIGMA_X, ResolutionFunction2DGaussianItem::P_SIGMA_Y, SessionItem::setGroupProperty(), and SessionItem::setItemValue().

Referenced by setDetector().

Here is the call graph for this function:

setFinite2DLatticeItem()

void TransformFromDomain::setFinite2DLatticeItem	(	SessionItem *	item,
		const InterferenceFunctionFinite2DLattice &	sample
	)

Definition at line 138 of file TransformFromDomain.cpp.

{
    set2DLatticeParameters(item, sample.lattice());
 
    item->setItemValue(InterferenceFunctionFinite2DLatticeItem::P_DOMAIN_SIZE_1,
                       sample.numberUnitCells1());
    item->setItemValue(InterferenceFunctionFinite2DLatticeItem::P_DOMAIN_SIZE_2,
                       sample.numberUnitCells2());
    item->setItemValue(InterferenceFunctionFinite2DLatticeItem::P_POSITION_VARIANCE,
                       sample.positionVariance());
    item->setItemValue(InterferenceFunctionFinite2DLatticeItem::P_XI_INTEGRATION,
                       sample.integrationOverXi());
    setPositionVariance(item, sample);
}

References InterferenceFunctionFinite2DLattice::integrationOverXi(), InterferenceFunctionFinite2DLattice::lattice(), InterferenceFunctionFinite2DLattice::numberUnitCells1(), InterferenceFunctionFinite2DLattice::numberUnitCells2(), InterferenceFunctionFinite2DLatticeItem::P_DOMAIN_SIZE_1, InterferenceFunctionFinite2DLatticeItem::P_DOMAIN_SIZE_2, InterferenceFunctionItem::P_POSITION_VARIANCE, InterferenceFunctionFinite2DLatticeItem::P_XI_INTEGRATION, IInterferenceFunction::positionVariance(), and SessionItem::setItemValue().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

setFootprintFactor()

void TransformFromDomain::setFootprintFactor	(	const IFootprintFactor *	footprint,
		SpecularBeamItem *	beam_item
	)

Definition at line 597 of file TransformFromDomain.cpp.

{
    if (!footprint)
        return;
    if (const auto gaussian_fp = dynamic_cast<const FootprintGauss*>(footprint)) {
        auto gaussian_fp_item =
            beam_item->setGroupProperty(SpecularBeamItem::P_FOOPTPRINT, "GaussianFootrpint");
        const double value = gaussian_fp->widthRatio();
        gaussian_fp_item->setItemValue(FootprintGaussianItem::P_VALUE, value);
    } else if (const auto square_fp = dynamic_cast<const FootprintSquare*>(footprint)) {
        auto square_fp_item =
            beam_item->setGroupProperty(SpecularBeamItem::P_FOOPTPRINT, "SquareFootprint");
        const double value = square_fp->widthRatio();
        square_fp_item->setItemValue(FootprintSquareItem::P_VALUE, value);
    }
}

References SpecularBeamItem::P_FOOPTPRINT, FootprintGaussianItem::P_VALUE, FootprintSquareItem::P_VALUE, SessionItem::setGroupProperty(), and SessionItem::setItemValue().

Referenced by setSpecularBeamItem().

Here is the call graph for this function:

setGISASBeamItem()

void TransformFromDomain::setGISASBeamItem	(	BeamItem *	beam_item,
		const GISASSimulation &	simulation
	)

Definition at line 238 of file TransformFromDomain.cpp.

{
    ASSERT(beam_item);
    Beam beam = simulation.beam();
 
    beam_item->setIntensity(beam.intensity());
    beam_item->setWavelength(beam.wavelength());
    beam_item->setInclinationAngle(Units::rad2deg(beam.direction().alpha()));
    beam_item->setAzimuthalAngle(Units::rad2deg(beam.direction().phi()));
 
    // distribution parameters
    const DistributionHandler::Distributions_t distributions =
        simulation.getDistributionHandler().getDistributions();
    for (size_t i = 0; i < distributions.size(); ++i) {
        addDistributionToBeamItem("Wavelength", BeamItem::P_WAVELENGTH, distributions[i],
                                  beam_item);
        addDistributionToBeamItem("InclinationAngle", BeamItem::P_INCLINATION_ANGLE,
                                  distributions[i], beam_item);
        addDistributionToBeamItem("AzimuthalAngle", BeamItem::P_AZIMUTHAL_ANGLE, distributions[i],
                                  beam_item);
    }
 
    // polarization parameters
    beam_item->item<VectorItem>(BeamItem::P_POLARIZATION)->setVector(beam.getBlochVector());
}

References Direction::alpha(), ASSERT, ISimulation::beam(), Beam::direction(), Beam::getBlochVector(), ISimulation::getDistributionHandler(), DistributionHandler::getDistributions(), Beam::intensity(), SessionItem::item(), BeamItem::P_AZIMUTHAL_ANGLE, BeamItem::P_INCLINATION_ANGLE, BeamItem::P_POLARIZATION, BeamItem::P_WAVELENGTH, Direction::phi(), Units::rad2deg(), BeamItem::setAzimuthalAngle(), BeamItem::setInclinationAngle(), BeamItem::setIntensity(), BeamItem::setWavelength(), and Beam::wavelength().

Here is the call graph for this function:

setHardDiskItem()

void TransformFromDomain::setHardDiskItem	(	SessionItem *	item,
		const InterferenceFunctionHardDisk &	sample
	)

Definition at line 154 of file TransformFromDomain.cpp.

{
    item->setItemValue(InterferenceFunctionHardDiskItem::P_RADIUS, sample.radius());
    item->setItemValue(InterferenceFunctionHardDiskItem::P_DENSITY, sample.density());
    setPositionVariance(item, sample);
}

References InterferenceFunctionHardDisk::density(), InterferenceFunctionHardDiskItem::P_DENSITY, InterferenceFunctionHardDiskItem::P_RADIUS, InterferenceFunctionHardDisk::radius(), and SessionItem::setItemValue().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

setItemFromSample()

void TransformFromDomain::setItemFromSample	(	BeamDistributionItem *	beam_distribution_item,
		const ParameterDistribution &	parameter_distribution
	)

Definition at line 566 of file TransformFromDomain.cpp.

{
    ASSERT(beam_distribution_item);
 
    if (parameter_distribution.getMinValue() < parameter_distribution.getMaxValue()) {
        throw GUIHelpers::Error(
            "TransformFromDomain::setItemFromSample(BeamDistributionItem* beamDistributionItem,"
            "const ParameterDistribution& parameterDistribution) -> Error. ParameterDistribution "
            "with defined min,max are not yet implemented in GUI");
    }
 
    const double unit_factor = 1.0 / beam_distribution_item->scaleFactor();
    QString group_name = BeamDistributionItem::P_DISTRIBUTION;
    setDistribution(beam_distribution_item, parameter_distribution, group_name, unit_factor);
}

References ASSERT, ParameterDistribution::getMaxValue(), ParameterDistribution::getMinValue(), BeamDistributionItem::P_DISTRIBUTION, and BeamDistributionItem::scaleFactor().

Here is the call graph for this function:

setLayerItem()

void TransformFromDomain::setLayerItem	(	SessionItem *	layer_item,
		const Layer *	layer,
		const LayerInterface *	top_interface
	)

Definition at line 179 of file TransformFromDomain.cpp.

{
    layerItem->setItemValue(LayerItem::P_THICKNESS, layer->thickness());
    layerItem->setGroupProperty(LayerItem::P_ROUGHNESS, "LayerZeroRoughness");
    layerItem->setItemValue(LayerItem::P_NSLICES, (int)layer->numberOfSlices());
 
    if (top_interface) {
        const LayerRoughness* roughness = top_interface->getRoughness();
        if (TransformFromDomain::isValidRoughness(roughness)) {
            SessionItem* roughnessItem =
                layerItem->setGroupProperty(LayerItem::P_ROUGHNESS, "LayerBasicRoughness");
            TransformFromDomain::setRoughnessItem(roughnessItem, *roughness);
        }
    }
}

References LayerInterface::getRoughness(), isValidRoughness(), Layer::numberOfSlices(), LayerItem::P_NSLICES, LayerItem::P_ROUGHNESS, LayerItem::P_THICKNESS, SessionItem::setGroupProperty(), SessionItem::setItemValue(), setRoughnessItem(), and Layer::thickness().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

setMaskContainer()

void TransformFromDomain::setMaskContainer	(	MaskContainerItem *	container_item,
		const IDetector &	detector,
		double	scale
	)

Definition at line 480 of file TransformFromDomain.cpp.

{
    auto detectorMask = detector.detectorMask();
    for (size_t i_mask = 0; i_mask < detectorMask->numberOfMasks(); ++i_mask) {
        bool mask_value(false);
        const IShape2D* shape = detectorMask->getMaskShape(i_mask, mask_value);
 
        if (const Ellipse* ellipse = dynamic_cast<const Ellipse*>(shape)) {
            EllipseItem* ellipseItem = new EllipseItem();
            ellipseItem->setItemValue(EllipseItem::P_XCENTER, scale * ellipse->getCenterX());
            ellipseItem->setItemValue(EllipseItem::P_YCENTER, scale * ellipse->getCenterY());
            ellipseItem->setItemValue(EllipseItem::P_XRADIUS, scale * ellipse->getRadiusX());
            ellipseItem->setItemValue(EllipseItem::P_YRADIUS, scale * ellipse->getRadiusY());
            ellipseItem->setItemValue(EllipseItem::P_ANGLE, scale * ellipse->getTheta());
            ellipseItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
            container_item->insertItem(0, ellipseItem);
        }
 
        else if (const Rectangle* rectangle = dynamic_cast<const Rectangle*>(shape)) {
            RectangleItem* rectangleItem = new RectangleItem();
            rectangleItem->setItemValue(RectangleItem::P_XLOW, scale * rectangle->getXlow());
            rectangleItem->setItemValue(RectangleItem::P_YLOW, scale * rectangle->getYlow());
            rectangleItem->setItemValue(RectangleItem::P_XUP, scale * rectangle->getXup());
            rectangleItem->setItemValue(RectangleItem::P_YUP, scale * rectangle->getYup());
            rectangleItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
            container_item->insertItem(0, rectangleItem);
 
        }
 
        else if (const Polygon* polygon = dynamic_cast<const Polygon*>(shape)) {
            PolygonItem* polygonItem = new PolygonItem();
            std::vector<double> xpos, ypos;
            polygon->getPoints(xpos, ypos);
            for (size_t i_point = 0; i_point < xpos.size(); ++i_point) {
                PolygonPointItem* pointItem = new PolygonPointItem();
                pointItem->setItemValue(PolygonPointItem::P_POSX, scale * xpos[i_point]);
                pointItem->setItemValue(PolygonPointItem::P_POSY, scale * ypos[i_point]);
                polygonItem->insertItem(-1, pointItem);
            }
 
            polygonItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
            polygonItem->setItemValue(PolygonItem::P_ISCLOSED, true);
 
            container_item->insertItem(0, polygonItem);
        }
 
        else if (const VerticalLine* vline = dynamic_cast<const VerticalLine*>(shape)) {
            VerticalLineItem* lineItem = new VerticalLineItem();
            lineItem->setItemValue(VerticalLineItem::P_POSX, scale * vline->getXpos());
            lineItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
            container_item->insertItem(0, lineItem);
        }
 
        else if (const HorizontalLine* hline = dynamic_cast<const HorizontalLine*>(shape)) {
            HorizontalLineItem* lineItem = new HorizontalLineItem();
            lineItem->setItemValue(HorizontalLineItem::P_POSY, scale * hline->getYpos());
            lineItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
            container_item->insertItem(0, lineItem);
        }
 
        else if (const InfinitePlane* plane = dynamic_cast<const InfinitePlane*>(shape)) {
            Q_UNUSED(plane);
            MaskAllItem* planeItem = new MaskAllItem();
            planeItem->setItemValue(MaskItem::P_MASK_VALUE, mask_value);
            container_item->insertItem(-1, planeItem);
        }
 
        else {
            throw GUIHelpers::Error("TransformFromDomain::setDetectorMasks() -> Error. "
                                    "Unknown shape");
        }
    }
 
    if (detector.regionOfInterest()) {
        RegionOfInterestItem* roiItem = new RegionOfInterestItem();
        roiItem->setItemValue(RectangleItem::P_XLOW,
                              scale * detector.regionOfInterest()->getXlow());
        roiItem->setItemValue(RectangleItem::P_YLOW,
                              scale * detector.regionOfInterest()->getYlow());
        roiItem->setItemValue(RectangleItem::P_XUP, scale * detector.regionOfInterest()->getXup());
        roiItem->setItemValue(RectangleItem::P_YUP, scale * detector.regionOfInterest()->getYup());
        container_item->insertItem(-1, roiItem);
    }
}

References IDetector::detectorMask(), RegionOfInterest::getXlow(), RegionOfInterest::getXup(), RegionOfInterest::getYlow(), RegionOfInterest::getYup(), SessionItem::insertItem(), EllipseItem::P_ANGLE, PolygonItem::P_ISCLOSED, MaskItem::P_MASK_VALUE, PolygonPointItem::P_POSX, VerticalLineItem::P_POSX, PolygonPointItem::P_POSY, HorizontalLineItem::P_POSY, EllipseItem::P_XCENTER, RectangleItem::P_XLOW, EllipseItem::P_XRADIUS, RectangleItem::P_XUP, EllipseItem::P_YCENTER, RectangleItem::P_YLOW, EllipseItem::P_YRADIUS, RectangleItem::P_YUP, IDetector::regionOfInterest(), and SessionItem::setItemValue().

Referenced by setDetectorMasks().

Here is the call graph for this function:

setOffSpecularBeamItem()

void TransformFromDomain::setOffSpecularBeamItem	(	BeamItem *	beam_item,
		const OffSpecularSimulation &	simulation
	)

Definition at line 264 of file TransformFromDomain.cpp.

{
    Beam beam = simulation.beam();
 
    beam_item->setIntensity(beam.intensity());
    beam_item->setWavelength(beam.wavelength());
    beam_item->setInclinationAngle(Units::rad2deg(beam.direction().alpha()));
    beam_item->setAzimuthalAngle(Units::rad2deg(beam.direction().phi()));
    // TODO implement beam divergence
}

References Direction::alpha(), ISimulation::beam(), Beam::direction(), Beam::intensity(), Direction::phi(), Units::rad2deg(), BeamItem::setAzimuthalAngle(), BeamItem::setInclinationAngle(), BeamItem::setIntensity(), BeamItem::setWavelength(), and Beam::wavelength().

Here is the call graph for this function:

setParticleDistributionItem()

void TransformFromDomain::setParticleDistributionItem	(	SessionItem *	item,
		const ParticleDistribution &	sample
	)

Initialization of ParticleDistributionItem.

Definition at line 205 of file TransformFromDomain.cpp.

{
    ParticleDistributionItem* distItem = dynamic_cast<ParticleDistributionItem*>(item);
    ASSERT(distItem);
 
    distItem->setItemValue(ParticleItem::P_ABUNDANCE, sample.abundance());
 
    ParameterDistribution par_distr = sample.parameterDistribution();
    QString main_distr_par_name = QString::fromStdString(par_distr.getMainParameterName());
    QStringList linked_pars = GUIHelpers::fromStdStrings(par_distr.getLinkedParameterNames());
 
    distItem->setDomainCacheNames(main_distr_par_name, linked_pars);
 
    double unit_factor(1.0);
    if (sample.mainUnits() == "rad")
        unit_factor = 1. / Units::deg;
 
    QString group_name = ParticleDistributionItem::P_DISTRIBUTION;
    setDistribution(distItem, par_distr, group_name, unit_factor);
}

References IAbstractParticle::abundance(), ASSERT, Units::deg, GUIHelpers::fromStdStrings(), ParameterDistribution::getLinkedParameterNames(), ParameterDistribution::getMainParameterName(), ParticleDistribution::mainUnits(), ParticleItem::P_ABUNDANCE, ParticleDistributionItem::P_DISTRIBUTION, ParticleDistribution::parameterDistribution(), ParticleDistributionItem::setDomainCacheNames(), and SessionItem::setItemValue().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

setRadialParaCrystalItem()

void TransformFromDomain::setRadialParaCrystalItem	(	SessionItem *	item,
		const InterferenceFunctionRadialParaCrystal &	sample
	)

Definition at line 162 of file TransformFromDomain.cpp.

{
    item->setItemValue(InterferenceFunctionRadialParaCrystalItem::P_PEAK_DISTANCE,
                       sample.peakDistance());
    item->setItemValue(InterferenceFunctionRadialParaCrystalItem::P_DAMPING_LENGTH,
                       sample.dampingLength());
    item->setItemValue(InterferenceFunctionRadialParaCrystalItem::P_DOMAIN_SIZE,
                       sample.domainSize());
    item->setItemValue(InterferenceFunctionRadialParaCrystalItem::P_KAPPA, sample.kappa());
 
    auto ipdf = OnlyChildOfType<IFTDistribution1D>(sample);
    QString group_name = InterferenceFunctionRadialParaCrystalItem::P_PDF;
    SetPDF1D(item, ipdf, group_name);
    setPositionVariance(item, sample);
}

References InterferenceFunctionRadialParaCrystal::dampingLength(), InterferenceFunctionRadialParaCrystal::domainSize(), InterferenceFunctionRadialParaCrystal::kappa(), InterferenceFunctionRadialParaCrystalItem::P_DAMPING_LENGTH, InterferenceFunctionRadialParaCrystalItem::P_DOMAIN_SIZE, InterferenceFunctionRadialParaCrystalItem::P_KAPPA, InterferenceFunctionRadialParaCrystalItem::P_PDF, InterferenceFunctionRadialParaCrystalItem::P_PEAK_DISTANCE, InterferenceFunctionRadialParaCrystal::peakDistance(), and SessionItem::setItemValue().

Referenced by GUIDomainSampleVisitor::visit().

Here is the call graph for this function:

setRectangularDetector()

void TransformFromDomain::setRectangularDetector	(	RectangularDetectorItem *	detector_item,
		const RectangularDetector &	detector
	)

Definition at line 403 of file TransformFromDomain.cpp.

{
    // Axes
    auto xAxisItem = detector_item->xAxisItem();
    xAxisItem->setBinCount(detector.getNbinsX());
    xAxisItem->setUpperBound(detector.getWidth());
 
    auto yAxisItem = detector_item->yAxisItem();
    yAxisItem->setBinCount((int)detector.getNbinsY());
    yAxisItem->setUpperBound(detector.getHeight());
 
    if (detector.getDetectorArrangment() == RectangularDetector::GENERIC) {
        detector_item->setDetectorAlignment("Generic");
 
        kvector_t normal = detector.getNormalVector();
        detector_item->item<VectorItem>(RectangularDetectorItem::P_NORMAL)->setVector(normal);
 
        kvector_t direction = detector.getDirectionVector();
        detector_item->item<VectorItem>(RectangularDetectorItem::P_DIRECTION)->setVector(direction);
 
        detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
        detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
    }
 
    else if (detector.getDetectorArrangment() == RectangularDetector::PERPENDICULAR_TO_SAMPLE) {
        detector_item->setDetectorAlignment("Perpendicular to sample x-axis");
        detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
        detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
        detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
 
    } else if (detector.getDetectorArrangment()
               == RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM) {
        detector_item->setDetectorAlignment("Perpendicular to direct beam");
        detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
        detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_U0, detector.getU0());
        detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_V0, detector.getV0());
 
    } else if (detector.getDetectorArrangment()
               == RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM) {
        detector_item->setDetectorAlignment("Perpendicular to reflected beam");
        detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
        detector_item->setItemValue(RectangularDetectorItem::P_U0, detector.getU0());
        detector_item->setItemValue(RectangularDetectorItem::P_V0, detector.getV0());
 
    } else if (detector.getDetectorArrangment()
               == RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS) {
        detector_item->setDetectorAlignment("Perpendicular to reflected beam (dpos)");
        detector_item->setItemValue(RectangularDetectorItem::P_DISTANCE, detector.getDistance());
        detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_U0,
                                    detector.getDirectBeamU0());
        detector_item->setItemValue(RectangularDetectorItem::P_DBEAM_V0,
                                    detector.getDirectBeamV0());
 
    } else {
        throw GUIHelpers::Error(
            "TransformFromDomain::setItemFromSample(RectangularDetectorItem* detectorItem "
            "Error. Unknown detector arrangement");
    }
}

References RectangularDetector::GENERIC, RectangularDetector::getDetectorArrangment(), RectangularDetector::getDirectBeamU0(), RectangularDetector::getDirectBeamV0(), RectangularDetector::getDirectionVector(), RectangularDetector::getDistance(), RectangularDetector::getHeight(), RectangularDetector::getNbinsX(), RectangularDetector::getNbinsY(), RectangularDetector::getNormalVector(), RectangularDetector::getU0(), RectangularDetector::getV0(), RectangularDetector::getWidth(), SessionItem::item(), RectangularDetectorItem::P_DBEAM_U0, RectangularDetectorItem::P_DBEAM_V0, RectangularDetectorItem::P_DIRECTION, RectangularDetectorItem::P_DISTANCE, RectangularDetectorItem::P_NORMAL, RectangularDetectorItem::P_U0, RectangularDetectorItem::P_V0, RectangularDetector::PERPENDICULAR_TO_DIRECT_BEAM, RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM, RectangularDetector::PERPENDICULAR_TO_REFLECTED_BEAM_DPOS, RectangularDetector::PERPENDICULAR_TO_SAMPLE, BasicAxisItem::setBinCount(), RectangularDetectorItem::setDetectorAlignment(), SessionItem::setItemValue(), RectangularDetectorItem::xAxisItem(), and RectangularDetectorItem::yAxisItem().

Referenced by setDetectorGeometry().

Here is the call graph for this function:

setRoughnessItem()

void TransformFromDomain::setRoughnessItem	(	SessionItem *	item,
		const LayerRoughness &	sample
	)

Definition at line 196 of file TransformFromDomain.cpp.

{
    item->setItemValue(LayerBasicRoughnessItem::P_SIGMA, sample.getSigma());
    item->setItemValue(LayerBasicRoughnessItem::P_HURST, sample.getHurstParameter());
    item->setItemValue(LayerBasicRoughnessItem::P_LATERAL_CORR_LENGTH,
                       sample.getLatteralCorrLength());
}

References LayerRoughness::getHurstParameter(), LayerRoughness::getLatteralCorrLength(), LayerRoughness::getSigma(), LayerBasicRoughnessItem::P_HURST, LayerBasicRoughnessItem::P_LATERAL_CORR_LENGTH, LayerBasicRoughnessItem::P_SIGMA, and SessionItem::setItemValue().

Referenced by setLayerItem().

Here is the call graph for this function:

setSpecularBeamItem()

void TransformFromDomain::setSpecularBeamItem	(	SpecularBeamItem *	beam_item,
		const SpecularSimulation &	simulation
	)

Definition at line 276 of file TransformFromDomain.cpp.

{
    const Beam& beam = simulation.beam();
 
    beam_item->setIntensity(beam.intensity());
    beam_item->setWavelength(beam.wavelength());
    beam_item->setInclinationAngle(0.0); // inclination angle is hardcoded
    beam_item->setAzimuthalAngle(0.0);   // azimuthal angle is hardcoded
 
    auto axis_item = beam_item->currentInclinationAxisItem();
    TransformFromDomain::setAxisItem(axis_item, *simulation.coordinateAxis(), 1. / Units::deg);
 
    setFootprintFactor(simulation.footprintFactor(), beam_item);
 
    const AngularSpecScan* scan = dynamic_cast<const AngularSpecScan*>(simulation.dataHandler());
    if (!scan)
        return;
 
    auto resolution = scan->wavelengthResolution();
    if (!resolution->empty()) {
        double mean = scan->wavelength();
        double std_dev = resolution->stdDevs(mean, 1).front();
        addRangedDistributionToItem(beam_item->getItem(SpecularBeamItem::P_WAVELENGTH),
                                    *resolution->distribution(), mean, std_dev);
    }
 
    resolution = scan->angleResolution();
    if (resolution && !resolution->empty()) {
        double std_dev = resolution->stdDevs(0.0, 1).front();
        addRangedDistributionToItem(beam_item->getItem(SpecularBeamItem::P_INCLINATION_ANGLE),
                                    *resolution->distribution(), 0.0, std_dev);
    }
}

References AngularSpecScan::angleResolution(), ISimulation::beam(), SpecularSimulation::coordinateAxis(), SpecularBeamItem::currentInclinationAxisItem(), SpecularSimulation::dataHandler(), Units::deg, SpecularSimulation::footprintFactor(), SessionItem::getItem(), Beam::intensity(), BeamItem::P_INCLINATION_ANGLE, BeamItem::P_WAVELENGTH, setAxisItem(), BeamItem::setAzimuthalAngle(), setFootprintFactor(), SpecularBeamItem::setInclinationAngle(), BeamItem::setIntensity(), BeamItem::setWavelength(), ScanResolution::stdDevs(), AngularSpecScan::wavelength(), Beam::wavelength(), and AngularSpecScan::wavelengthResolution().

Here is the call graph for this function:

setSphericalDetector()

void TransformFromDomain::setSphericalDetector	(	SphericalDetectorItem *	detector_item,
		const SphericalDetector &	detector
	)

Definition at line 385 of file TransformFromDomain.cpp.

{
    // Axes
    const IAxis& phi_axis = detector.axis(0);
    const IAxis& alpha_axis = detector.axis(1);
 
    auto phiAxisItem = detector_item->phiAxisItem();
    phiAxisItem->setBinCount(phi_axis.size());
    phiAxisItem->setLowerBound(Units::rad2deg(phi_axis.lowerBound()));
    phiAxisItem->setUpperBound(Units::rad2deg(phi_axis.upperBound()));
 
    auto alphaAxisItem = detector_item->alphaAxisItem();
    alphaAxisItem->setBinCount(alpha_axis.size());
    alphaAxisItem->setLowerBound(Units::rad2deg(alpha_axis.lowerBound()));
    alphaAxisItem->setUpperBound(Units::rad2deg(alpha_axis.upperBound()));
}

References SphericalDetectorItem::alphaAxisItem(), IDetector::axis(), IAxis::lowerBound(), SphericalDetectorItem::phiAxisItem(), Units::rad2deg(), BasicAxisItem::setBinCount(), IAxis::size(), and IAxis::upperBound().

Referenced by setDetectorGeometry().

Here is the call graph for this function: