diff --git a/GUI/Model/FromCore/ItemizeSample.cpp b/GUI/Model/FromCore/ItemizeSample.cpp
index 2d30f92ed91a4ef1fd6610d7643af74c0d1b09de..a76a12522e29aa26068c599e61a94b1ec59864ed 100644
--- a/GUI/Model/FromCore/ItemizeSample.cpp
+++ b/GUI/Model/FromCore/ItemizeSample.cpp
@@ -44,33 +44,33 @@ using NodeUtils::OnlyChildOfType;
namespace {
-void setPDF1D(InterferenceRadialParacrystalItem* item, const IProfile1D* ipdf)
+void setPDF1D(InterferenceRadialParacrystalItem* parent, const IProfile1D* ipdf)
{
if (const auto* pdf = dynamic_cast<const Profile1DCauchy*>(ipdf)) {
- auto* pdfItem = new Profile1DCauchyItem();
- pdfItem->omega().set(pdf->omega());
- item->setPDFType(pdfItem);
+ auto* item = new Profile1DCauchyItem();
+ item->omega().set(pdf->omega());
+ parent->setPDFType(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DGauss*>(ipdf)) {
- auto* pdfItem = new Profile1DGaussItem();
- pdfItem->omega().set(pdf->omega());
- item->setPDFType(pdfItem);
+ auto* item = new Profile1DGaussItem();
+ item->omega().set(pdf->omega());
+ parent->setPDFType(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DGate*>(ipdf)) {
- auto* pdfItem = new Profile1DGateItem();
- pdfItem->omega().set(pdf->omega());
- item->setPDFType(pdfItem);
+ auto* item = new Profile1DGateItem();
+ item->omega().set(pdf->omega());
+ parent->setPDFType(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DTriangle*>(ipdf)) {
- auto* pdfItem = new Profile1DTriangleItem();
- pdfItem->omega().set(pdf->omega());
- item->setPDFType(pdfItem);
+ auto* item = new Profile1DTriangleItem();
+ item->omega().set(pdf->omega());
+ parent->setPDFType(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DCosine*>(ipdf)) {
- auto* pdfItem = new Profile1DCosineItem();
- pdfItem->omega().set(pdf->omega());
- item->setPDFType(pdfItem);
+ auto* item = new Profile1DCosineItem();
+ item->omega().set(pdf->omega());
+ parent->setPDFType(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DVoigt*>(ipdf)) {
- auto* pdfItem = new Profile1DVoigtItem();
- pdfItem->omega().set(pdf->omega());
- pdfItem->eta().set(pdf->eta());
- item->setPDFType(pdfItem);
+ auto* item = new Profile1DVoigtItem();
+ item->omega().set(pdf->omega());
+ item->eta().set(pdf->eta());
+ parent->setPDFType(item);
} else
throw Error("GUI::Transform::FromCore::setPDF1D: -> Error");
}
@@ -79,131 +79,131 @@ void setPDF1D(InterferenceRadialParacrystalItem* item, const IProfile1D* ipdf)
template <class T>
struct SetterPDF1Type {
- T* operator()(Interference2DParacrystalItem* item)
+ T* operator()(Interference2DParacrystalItem* parent)
{
auto* p = new T();
- item->setPDF1Type(p);
+ parent->setPDF1Type(p);
return p;
}
};
template <class T>
struct SetterPDF2Type {
- T* operator()(Interference2DParacrystalItem* item)
+ T* operator()(Interference2DParacrystalItem* parent)
{
auto* p = new T();
- item->setPDF2Type(p);
+ parent->setPDF2Type(p);
return p;
}
};
template <template <class T> class setType>
-void setPDF2D(Interference2DParacrystalItem* item, const IProfile2D* pdf)
+void setPDF2D(Interference2DParacrystalItem* parent, const IProfile2D* pdf)
{
if (const auto* pdf_cauchy = dynamic_cast<const Profile2DCauchy*>(pdf)) {
- Profile2DCauchyItem* pdfItem = setType<Profile2DCauchyItem>()(item);
- pdfItem->setOmegaX(pdf_cauchy->omegaX());
- pdfItem->setOmegaY(pdf_cauchy->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_cauchy->gamma()));
+ Profile2DCauchyItem* item = setType<Profile2DCauchyItem>()(parent);
+ item->setOmegaX(pdf_cauchy->omegaX());
+ item->setOmegaY(pdf_cauchy->omegaY());
+ item->setGamma(Units::rad2deg(pdf_cauchy->gamma()));
} else if (const auto* pdf_gauss = dynamic_cast<const Profile2DGauss*>(pdf)) {
- Profile2DGaussItem* pdfItem = setType<Profile2DGaussItem>()(item);
- pdfItem->setOmegaX(pdf_gauss->omegaX());
- pdfItem->setOmegaY(pdf_gauss->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_gauss->gamma()));
+ Profile2DGaussItem* item = setType<Profile2DGaussItem>()(parent);
+ item->setOmegaX(pdf_gauss->omegaX());
+ item->setOmegaY(pdf_gauss->omegaY());
+ item->setGamma(Units::rad2deg(pdf_gauss->gamma()));
} else if (const auto* pdf_gate = dynamic_cast<const Profile2DGate*>(pdf)) {
- Profile2DGateItem* pdfItem = setType<Profile2DGateItem>()(item);
- pdfItem->setOmegaX(pdf_gate->omegaX());
- pdfItem->setOmegaY(pdf_gate->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_gate->gamma()));
+ Profile2DGateItem* item = setType<Profile2DGateItem>()(parent);
+ item->setOmegaX(pdf_gate->omegaX());
+ item->setOmegaY(pdf_gate->omegaY());
+ item->setGamma(Units::rad2deg(pdf_gate->gamma()));
} else if (const auto* pdf_cone = dynamic_cast<const Profile2DCone*>(pdf)) {
- Profile2DConeItem* pdfItem = setType<Profile2DConeItem>()(item);
- pdfItem->setOmegaX(pdf_cone->omegaX());
- pdfItem->setOmegaY(pdf_cone->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_cone->gamma()));
+ Profile2DConeItem* item = setType<Profile2DConeItem>()(parent);
+ item->setOmegaX(pdf_cone->omegaX());
+ item->setOmegaY(pdf_cone->omegaY());
+ item->setGamma(Units::rad2deg(pdf_cone->gamma()));
} else if (const auto* pdf_voigt = dynamic_cast<const Profile2DVoigt*>(pdf)) {
- Profile2DVoigtItem* pdfItem = setType<Profile2DVoigtItem>()(item);
- pdfItem->setOmegaX(pdf_voigt->omegaX());
- pdfItem->setOmegaY(pdf_voigt->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_voigt->gamma()));
- pdfItem->setEta(pdf_voigt->eta());
+ Profile2DVoigtItem* item = setType<Profile2DVoigtItem>()(parent);
+ item->setOmegaX(pdf_voigt->omegaX());
+ item->setOmegaY(pdf_voigt->omegaY());
+ item->setGamma(Units::rad2deg(pdf_voigt->gamma()));
+ item->setEta(pdf_voigt->eta());
} else
throw Error("GUI::Transform::FromCore::setPDF2D: -> Error");
}
-void setDecayFunction1D(Interference1DLatticeItem* item, const IProfile1D* ipdf)
+void setDecayFunction1D(Interference1DLatticeItem* parent, const IProfile1D* ipdf)
{
if (const auto* pdf = dynamic_cast<const Profile1DCauchy*>(ipdf)) {
- auto* pdfItem = new Profile1DCauchyItem();
- pdfItem->omega().set(pdf->omega());
- item->setDecayFunction(pdfItem);
+ auto* item = new Profile1DCauchyItem();
+ item->omega().set(pdf->omega());
+ parent->setDecayFunction(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DGauss*>(ipdf)) {
- auto* pdfItem = new Profile1DGaussItem();
- pdfItem->omega().set(pdf->omega());
- item->setDecayFunction(pdfItem);
+ auto* item = new Profile1DGaussItem();
+ item->omega().set(pdf->omega());
+ parent->setDecayFunction(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DTriangle*>(ipdf)) {
- auto* pdfItem = new Profile1DTriangleItem();
- pdfItem->omega().set(pdf->omega());
- item->setDecayFunction(pdfItem);
+ auto* item = new Profile1DTriangleItem();
+ item->omega().set(pdf->omega());
+ parent->setDecayFunction(item);
} else if (const auto* pdf = dynamic_cast<const Profile1DVoigt*>(ipdf)) {
- auto* pdfItem = new Profile1DVoigtItem();
- pdfItem->omega().set(pdf->omega());
- pdfItem->eta().set(pdf->eta());
- item->setDecayFunction(pdfItem);
+ auto* item = new Profile1DVoigtItem();
+ item->omega().set(pdf->omega());
+ item->eta().set(pdf->eta());
+ parent->setDecayFunction(item);
} else
throw Error("GUI::Transform::FromCore::setDecayFunction1D: -> Error");
}
-void setDecayFunction2D(Interference2DLatticeItem* item, const IProfile2D* pdf)
+void setDecayFunction2D(Interference2DLatticeItem* parent, const IProfile2D* pdf)
{
if (const auto* pdf_cauchy = dynamic_cast<const Profile2DCauchy*>(pdf)) {
- auto* pdfItem = new Profile2DCauchyItem();
- pdfItem->setOmegaX(pdf_cauchy->omegaX());
- pdfItem->setOmegaY(pdf_cauchy->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_cauchy->gamma()));
- item->setDecayFunctionType(pdfItem);
+ auto* item = new Profile2DCauchyItem();
+ item->setOmegaX(pdf_cauchy->omegaX());
+ item->setOmegaY(pdf_cauchy->omegaY());
+ item->setGamma(Units::rad2deg(pdf_cauchy->gamma()));
+ parent->setDecayFunctionType(item);
} else if (const auto* pdf_gauss = dynamic_cast<const Profile2DGauss*>(pdf)) {
- auto* pdfItem = new Profile2DGaussItem();
- pdfItem->setOmegaX(pdf_gauss->omegaX());
- pdfItem->setOmegaY(pdf_gauss->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_gauss->gamma()));
- item->setDecayFunctionType(pdfItem);
+ auto* item = new Profile2DGaussItem();
+ item->setOmegaX(pdf_gauss->omegaX());
+ item->setOmegaY(pdf_gauss->omegaY());
+ item->setGamma(Units::rad2deg(pdf_gauss->gamma()));
+ parent->setDecayFunctionType(item);
} else if (const auto* pdf_voigt = dynamic_cast<const Profile2DVoigt*>(pdf)) {
- auto* pdfItem = new Profile2DVoigtItem();
- pdfItem->setOmegaX(pdf_voigt->omegaX());
- pdfItem->setOmegaY(pdf_voigt->omegaY());
- pdfItem->setGamma(Units::rad2deg(pdf_voigt->gamma()));
- pdfItem->setEta(pdf_voigt->eta());
- item->setDecayFunctionType(pdfItem);
+ auto* item = new Profile2DVoigtItem();
+ item->setOmegaX(pdf_voigt->omegaX());
+ item->setOmegaY(pdf_voigt->omegaY());
+ item->setGamma(Units::rad2deg(pdf_voigt->gamma()));
+ item->setEta(pdf_voigt->eta());
+ parent->setDecayFunctionType(item);
} else
throw Error("GUI::Transform::FromCore::setDecayFunction2D: -> Error");
}
-void set2DLatticeParameters(Interference2DAbstractLatticeItem* item, const Lattice2D& lattice)
+void set2DLatticeParameters(Interference2DAbstractLatticeItem* parent, const Lattice2D& lattice)
{
- Lattice2DItem* latticeItem(nullptr);
+ Lattice2DItem* item(nullptr);
if (lattice.className() == "SquareLattice2D") {
auto* squareLatticeItem = new SquareLattice2DItem();
squareLatticeItem->setLatticeLength(lattice.length1());
- latticeItem = squareLatticeItem;
+ item = squareLatticeItem;
} else if (lattice.className() == "HexagonalLattice2D") {
auto* hexLatticeItem = new HexagonalLattice2DItem();
hexLatticeItem->setLatticeLength(lattice.length1());
- latticeItem = hexLatticeItem;
+ item = hexLatticeItem;
} else {
auto* basicLatticeItem = new BasicLattice2DItem();
basicLatticeItem->setLatticeLength1(lattice.length1());
basicLatticeItem->setLatticeLength2(lattice.length2());
basicLatticeItem->setLatticeAngle(Units::rad2deg(lattice.latticeAngle()));
- latticeItem = basicLatticeItem;
+ item = basicLatticeItem;
}
- latticeItem->setLatticeRotationAngle(Units::rad2deg(lattice.rotationAngle()));
- item->setLatticeType(latticeItem);
+ item->setLatticeRotationAngle(Units::rad2deg(lattice.rotationAngle()));
+ parent->setLatticeType(item);
}
-void setPositionVariance(InterferenceItem* item, const IInterference& iff)
+void setPositionVariance(InterferenceItem* parent, const IInterference& iff)
{
double pos_var = iff.positionVariance();
- item->positionVariance().set(pos_var);
+ parent->positionVariance().set(pos_var);
}
template <typename T>
@@ -215,76 +215,76 @@ T* addFormFactorItem(std::variant<ParticleItem*, MesocrystalItem*> parent)
return std::get<MesocrystalItem*>(parent)->setOuterShapeType<T>();
}
-void set1DLatticeItem(Interference1DLatticeItem* item, const Interference1DLattice& sample)
+void set1DLatticeItem(Interference1DLatticeItem* parent, const Interference1DLattice& sample)
{
- item->length().set(sample.length());
- item->rotationAngle().set(Units::rad2deg(sample.xi()));
+ parent->length().set(sample.length());
+ parent->rotationAngle().set(Units::rad2deg(sample.xi()));
const auto* pdf = OnlyChildOfType<IProfile1D>(sample);
- setDecayFunction1D(item, pdf);
- setPositionVariance(item, sample);
+ setDecayFunction1D(parent, pdf);
+ setPositionVariance(parent, sample);
}
-void set2DLatticeItem(Interference2DLatticeItem* item, const Interference2DLattice& sample)
+void set2DLatticeItem(Interference2DLatticeItem* parent, const Interference2DLattice& sample)
{
- set2DLatticeParameters(item, sample.lattice());
+ set2DLatticeParameters(parent, sample.lattice());
- item->setXiIntegration(sample.integrationOverXi());
+ parent->setXiIntegration(sample.integrationOverXi());
const auto* p_pdf = OnlyChildOfType<IProfile2D>(sample);
- setDecayFunction2D(item, p_pdf);
- setPositionVariance(item, sample);
+ setDecayFunction2D(parent, p_pdf);
+ setPositionVariance(parent, sample);
}
-void set2DParacrystalItem(Interference2DParacrystalItem* item,
+void set2DParacrystalItem(Interference2DParacrystalItem* parent,
const Interference2DParacrystal& sample)
{
- set2DLatticeParameters(item, sample.lattice());
+ set2DLatticeParameters(parent, sample.lattice());
- item->setDampingLength(sample.dampingLength());
- item->setDomainSize1(sample.domainSizes()[0]);
- item->setDomainSize2(sample.domainSizes()[1]);
- item->setXiIntegration(sample.integrationOverXi());
+ parent->setDampingLength(sample.dampingLength());
+ parent->setDomainSize1(sample.domainSizes()[0]);
+ parent->setDomainSize2(sample.domainSizes()[1]);
+ parent->setXiIntegration(sample.integrationOverXi());
auto pdfs = ChildNodesOfType<IProfile2D>(sample);
if (!pdfs.empty()) {
- setPDF2D<SetterPDF1Type>(item, pdfs[0]);
+ setPDF2D<SetterPDF1Type>(parent, pdfs[0]);
if (pdfs.size() >= 2)
- setPDF2D<SetterPDF2Type>(item, pdfs[1]);
+ setPDF2D<SetterPDF2Type>(parent, pdfs[1]);
}
- setPositionVariance(item, sample);
+ setPositionVariance(parent, sample);
}
-void setFinite2DLatticeItem(InterferenceFinite2DLatticeItem* item,
+void setFinite2DLatticeItem(InterferenceFinite2DLatticeItem* parent,
const InterferenceFinite2DLattice& sample)
{
- set2DLatticeParameters(item, sample.lattice());
+ set2DLatticeParameters(parent, sample.lattice());
- item->setDomainSize1(sample.numberUnitCells1());
- item->setDomainSize2(sample.numberUnitCells2());
- item->setXiIntegration(sample.integrationOverXi());
- setPositionVariance(item, sample);
+ parent->setDomainSize1(sample.numberUnitCells1());
+ parent->setDomainSize2(sample.numberUnitCells2());
+ parent->setXiIntegration(sample.integrationOverXi());
+ setPositionVariance(parent, sample);
}
-void setHardDiskItem(InterferenceHardDiskItem* item, const InterferenceHardDisk& sample)
+void setHardDiskItem(InterferenceHardDiskItem* parent, const InterferenceHardDisk& sample)
{
- item->radius().set(sample.radius());
- item->density().set(sample.density());
- setPositionVariance(item, sample);
+ parent->radius().set(sample.radius());
+ parent->density().set(sample.density());
+ setPositionVariance(parent, sample);
}
-void setRadialParacrystalItem(InterferenceRadialParacrystalItem* item,
+void setRadialParacrystalItem(InterferenceRadialParacrystalItem* parent,
const InterferenceRadialParacrystal& sample)
{
- item->peakDistance().set(sample.peakDistance());
- item->dampingLength().set(sample.dampingLength());
- item->domainSize().set(sample.domainSize());
- item->kappa().set(sample.kappa());
+ parent->peakDistance().set(sample.peakDistance());
+ parent->dampingLength().set(sample.dampingLength());
+ parent->domainSize().set(sample.domainSize());
+ parent->kappa().set(sample.kappa());
const auto* ipdf = OnlyChildOfType<IProfile1D>(sample);
- setPDF1D(item, ipdf);
- setPositionVariance(item, sample);
+ setPDF1D(parent, ipdf);
+ setPositionVariance(parent, sample);
}
//! Returns true if given roughness is non-zero roughness
@@ -298,234 +298,234 @@ bool isValidRoughness(const LayerRoughness* roughness)
return true;
}
-void setRoughnessItem(LayerBasicRoughnessItem* item, const LayerRoughness& sample)
+void setRoughnessItem(LayerBasicRoughnessItem* parent, const LayerRoughness& sample)
{
- item->sigma().set(sample.sigma());
- item->hurst().set(sample.hurst());
- item->lateralCorrelationLength().set(sample.lateralCorrLength());
+ parent->sigma().set(sample.sigma());
+ parent->hurst().set(sample.hurst());
+ parent->lateralCorrelationLength().set(sample.lateralCorrLength());
}
-void setLayerItem(LayerItem* layerItem, const Layer* layer, const LayerInterface* top_interface)
+void setLayerItem(LayerItem* parent, const Layer* layer, const LayerInterface* top_interface)
{
- layerItem->thickness().set(layer->thickness());
- layerItem->clearRoughness();
- layerItem->numSlices().set(layer->numberOfSlices());
+ parent->thickness().set(layer->thickness());
+ parent->clearRoughness();
+ parent->numSlices().set(layer->numberOfSlices());
if (top_interface) {
const LayerRoughness* roughness = top_interface->roughness();
if (isValidRoughness(roughness)) {
- layerItem->setBasicRoughness();
- setRoughnessItem(layerItem->roughness().currentItem(), *roughness);
+ parent->setBasicRoughness();
+ setRoughnessItem(parent->roughness().currentItem(), *roughness);
}
}
}
-void setRotation(ItemWithParticles* item, const IRotation* rotation)
+void setRotation(ItemWithParticles* parent, const IRotation* rotation)
{
if (!rotation)
- item->setRotation(nullptr);
+ parent->setRotation(nullptr);
else if (const auto* r = dynamic_cast<const RotationX*>(rotation)) {
- auto* rotationItem = new XRotationItem();
- rotationItem->angle().set(Units::rad2deg(r->angle()));
- item->setRotation(rotationItem);
+ auto* item = new XRotationItem();
+ item->angle().set(Units::rad2deg(r->angle()));
+ parent->setRotation(item);
} else if (const auto* r = dynamic_cast<const RotationY*>(rotation)) {
- auto* rotationItem = new YRotationItem();
- rotationItem->angle().set(Units::rad2deg(r->angle()));
- item->setRotation(rotationItem);
+ auto* item = new YRotationItem();
+ item->angle().set(Units::rad2deg(r->angle()));
+ parent->setRotation(item);
} else if (const auto* r = dynamic_cast<const RotationZ*>(rotation)) {
- auto* rotationItem = new ZRotationItem();
- rotationItem->angle().set(Units::rad2deg(r->angle()));
- item->setRotation(rotationItem);
+ auto* item = new ZRotationItem();
+ item->angle().set(Units::rad2deg(r->angle()));
+ parent->setRotation(item);
} else if (const auto* r = dynamic_cast<const RotationEuler*>(rotation)) {
- auto* rotationItem = new EulerRotationItem();
- rotationItem->alpha().set(Units::rad2deg(r->alpha()));
- rotationItem->beta().set(Units::rad2deg(r->beta()));
- rotationItem->gamma().set(Units::rad2deg(r->gamma()));
- item->setRotation(rotationItem);
+ auto* item = new EulerRotationItem();
+ item->alpha().set(Units::rad2deg(r->alpha()));
+ item->beta().set(Units::rad2deg(r->beta()));
+ item->gamma().set(Units::rad2deg(r->gamma()));
+ parent->setRotation(item);
}
}
-void setInterference(ParticleLayoutItem* layoutItem, const IInterference* interference)
+void setInterference(ParticleLayoutItem* parent, const IInterference* interference)
{
if (!interference)
- layoutItem->removeInterference();
+ parent->removeInterference();
else if (const auto* itf = dynamic_cast<const Interference1DLattice*>(interference)) {
- auto* itfItem = new Interference1DLatticeItem();
- set1DLatticeItem(itfItem, *itf);
- layoutItem->setInterference(itfItem);
+ auto* item = new Interference1DLatticeItem();
+ set1DLatticeItem(item, *itf);
+ parent->setInterference(item);
} else if (const auto* itf = dynamic_cast<const Interference2DLattice*>(interference)) {
- auto* itfItem = new Interference2DLatticeItem();
- set2DLatticeItem(itfItem, *itf);
- layoutItem->setInterference(itfItem);
+ auto* item = new Interference2DLatticeItem();
+ set2DLatticeItem(item, *itf);
+ parent->setInterference(item);
} else if (const auto* itf = dynamic_cast<const Interference2DParacrystal*>(interference)) {
- auto* itfItem = new Interference2DParacrystalItem();
- set2DParacrystalItem(itfItem, *itf);
- layoutItem->setInterference(itfItem);
+ auto* item = new Interference2DParacrystalItem();
+ set2DParacrystalItem(item, *itf);
+ parent->setInterference(item);
} else if (const auto* itf = dynamic_cast<const InterferenceFinite2DLattice*>(interference)) {
- auto* itfItem = new InterferenceFinite2DLatticeItem();
- setFinite2DLatticeItem(itfItem, *itf);
- layoutItem->setInterference(itfItem);
+ auto* item = new InterferenceFinite2DLatticeItem();
+ setFinite2DLatticeItem(item, *itf);
+ parent->setInterference(item);
} else if (const auto* itf = dynamic_cast<const InterferenceHardDisk*>(interference)) {
- auto* itfItem = new InterferenceHardDiskItem();
- setHardDiskItem(itfItem, *itf);
- layoutItem->setInterference(itfItem);
+ auto* item = new InterferenceHardDiskItem();
+ setHardDiskItem(item, *itf);
+ parent->setInterference(item);
} else if (const auto* itf = dynamic_cast<const InterferenceRadialParacrystal*>(interference)) {
- auto* itfItem = new InterferenceRadialParacrystalItem();
- setRadialParacrystalItem(itfItem, *itf);
- layoutItem->setInterference(itfItem);
+ auto* item = new InterferenceRadialParacrystalItem();
+ setRadialParacrystalItem(item, *itf);
+ parent->setInterference(item);
} else
ASSERT(false); // missing implementation for interference type
}
void setFormFactor(std::variant<ParticleItem*, MesocrystalItem*> parent,
- const IFormFactor* iFormFactor)
+ const IFormFactor* ff)
{
- if (const auto* formfactor = dynamic_cast<const Pyramid2*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<Pyramid2Item>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
- } else if (const auto* formfactor = dynamic_cast<const BarGauss*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<BarGaussItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const BarLorentz*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<BarLorentzItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Box*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<BoxItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Cone*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<ConeItem>(parent);
- formfactorItem->setRadius(formfactor->radius());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
- } else if (const auto* formfactor = dynamic_cast<const Pyramid6*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<Pyramid6Item>(parent);
- formfactorItem->setBaseEdge(formfactor->baseEdge());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
- } else if (const auto* formfactor = dynamic_cast<const Bipyramid4*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<Bipyramid4Item>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setHeightRatio(formfactor->heightRatio());
- formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
- } else if (const auto* formfactor = dynamic_cast<const Cylinder*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<CylinderItem>(parent);
- formfactorItem->setRadius(formfactor->radius());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Dodecahedron*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<DodecahedronItem>(parent);
- formfactorItem->setEdge(formfactor->edge());
- } else if (const auto* formfactor = dynamic_cast<const EllipsoidalCylinder*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<EllipsoidalCylinderItem>(parent);
- formfactorItem->setRadiusX(formfactor->radiusX());
- formfactorItem->setRadiusY(formfactor->radiusY());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Sphere*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<SphereItem>(parent);
- formfactorItem->setRadius(formfactor->radius());
- } else if (const auto* formfactor = dynamic_cast<const Spheroid*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<SpheroidItem>(parent);
- formfactorItem->setRadius(formfactor->radius());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Icosahedron*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<IcosahedronItem>(parent);
- formfactorItem->setEdge(formfactor->edge());
- } else if (const auto* formfactor = dynamic_cast<const HemiEllipsoid*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<HemiEllipsoidItem>(parent);
- formfactorItem->setRadiusX(formfactor->radiusX());
- formfactorItem->setRadiusY(formfactor->radiusY());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Prism3*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<Prism3Item>(parent);
- formfactorItem->setBaseEdge(formfactor->baseEdge());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Prism6*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<Prism6Item>(parent);
- formfactorItem->setBaseEdge(formfactor->baseEdge());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const Pyramid4*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<Pyramid4Item>(parent);
- formfactorItem->setBaseEdge(formfactor->baseEdge());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
- } else if (const auto* formfactor = dynamic_cast<const CosineRippleBox*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<CosineRippleBoxItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const CosineRippleGauss*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<CosineRippleGaussItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const CosineRippleLorentz*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<CosineRippleLorentzItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleBox*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<SawtoothRippleBoxItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAsymmetry(formfactor->asymmetry());
- } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleGauss*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<SawtoothRippleGaussItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAsymmetry(formfactor->asymmetry());
- } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleLorentz*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<SawtoothRippleLorentzItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setWidth(formfactor->width());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAsymmetry(formfactor->asymmetry());
- } else if (const auto* formfactor = dynamic_cast<const Pyramid3*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<Pyramid3Item>(parent);
- formfactorItem->setBaseEdge(formfactor->baseEdge());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setAlpha(Units::rad2deg(formfactor->alpha()));
- } else if (const auto* formfactor = dynamic_cast<const TruncatedCube*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<TruncatedCubeItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setRemovedLength(formfactor->removedLength());
- } else if (const auto* formfactor = dynamic_cast<const TruncatedSphere*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<TruncatedSphereItem>(parent);
- formfactorItem->setRadius(formfactor->radius());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setRemovedTop(formfactor->removedTop());
- } else if (const auto* formfactor = dynamic_cast<const TruncatedSpheroid*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<TruncatedSpheroidItem>(parent);
- formfactorItem->setRadius(formfactor->radius());
- formfactorItem->setHeight(formfactor->height());
- formfactorItem->setHeightFlattening(formfactor->heightFlattening());
- formfactorItem->setRemovedTop(formfactor->removedTop());
- } else if (const auto* formfactor = dynamic_cast<const CantellatedCube*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<CantellatedCubeItem>(parent);
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setRemovedLength(formfactor->removedLength());
- } else if (const auto* formfactor = dynamic_cast<const HorizontalCylinder*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<HorizontalCylinderItem>(parent);
- formfactorItem->setRadius(formfactor->radius());
- formfactorItem->setLength(formfactor->length());
- formfactorItem->setSliceBottom(formfactor->slice_bottom());
- formfactorItem->setSliceTop(formfactor->slice_top());
- } else if (const auto* formfactor = dynamic_cast<const PlatonicOctahedron*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<PlatonicOctahedronItem>(parent);
- formfactorItem->setEdge(formfactor->edge());
- } else if (const auto* formfactor = dynamic_cast<const PlatonicTetrahedron*>(iFormFactor)) {
- auto* formfactorItem = addFormFactorItem<PlatonicTetrahedronItem>(parent);
- formfactorItem->setEdge(formfactor->edge());
+ if (const auto* formfactor = dynamic_cast<const Pyramid2*>(ff)) {
+ auto* item = addFormFactorItem<Pyramid2Item>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ item->setAlpha(Units::rad2deg(formfactor->alpha()));
+ } else if (const auto* formfactor = dynamic_cast<const BarGauss*>(ff)) {
+ auto* item = addFormFactorItem<BarGaussItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const BarLorentz*>(ff)) {
+ auto* item = addFormFactorItem<BarLorentzItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Box*>(ff)) {
+ auto* item = addFormFactorItem<BoxItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Cone*>(ff)) {
+ auto* item = addFormFactorItem<ConeItem>(parent);
+ item->setRadius(formfactor->radius());
+ item->setHeight(formfactor->height());
+ item->setAlpha(Units::rad2deg(formfactor->alpha()));
+ } else if (const auto* formfactor = dynamic_cast<const Pyramid6*>(ff)) {
+ auto* item = addFormFactorItem<Pyramid6Item>(parent);
+ item->setBaseEdge(formfactor->baseEdge());
+ item->setHeight(formfactor->height());
+ item->setAlpha(Units::rad2deg(formfactor->alpha()));
+ } else if (const auto* formfactor = dynamic_cast<const Bipyramid4*>(ff)) {
+ auto* item = addFormFactorItem<Bipyramid4Item>(parent);
+ item->setLength(formfactor->length());
+ item->setHeight(formfactor->height());
+ item->setHeightRatio(formfactor->heightRatio());
+ item->setAlpha(Units::rad2deg(formfactor->alpha()));
+ } else if (const auto* formfactor = dynamic_cast<const Cylinder*>(ff)) {
+ auto* item = addFormFactorItem<CylinderItem>(parent);
+ item->setRadius(formfactor->radius());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Dodecahedron*>(ff)) {
+ auto* item = addFormFactorItem<DodecahedronItem>(parent);
+ item->setEdge(formfactor->edge());
+ } else if (const auto* formfactor = dynamic_cast<const EllipsoidalCylinder*>(ff)) {
+ auto* item = addFormFactorItem<EllipsoidalCylinderItem>(parent);
+ item->setRadiusX(formfactor->radiusX());
+ item->setRadiusY(formfactor->radiusY());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Sphere*>(ff)) {
+ auto* item = addFormFactorItem<SphereItem>(parent);
+ item->setRadius(formfactor->radius());
+ } else if (const auto* formfactor = dynamic_cast<const Spheroid*>(ff)) {
+ auto* item = addFormFactorItem<SpheroidItem>(parent);
+ item->setRadius(formfactor->radius());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Icosahedron*>(ff)) {
+ auto* item = addFormFactorItem<IcosahedronItem>(parent);
+ item->setEdge(formfactor->edge());
+ } else if (const auto* formfactor = dynamic_cast<const HemiEllipsoid*>(ff)) {
+ auto* item = addFormFactorItem<HemiEllipsoidItem>(parent);
+ item->setRadiusX(formfactor->radiusX());
+ item->setRadiusY(formfactor->radiusY());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Prism3*>(ff)) {
+ auto* item = addFormFactorItem<Prism3Item>(parent);
+ item->setBaseEdge(formfactor->baseEdge());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Prism6*>(ff)) {
+ auto* item = addFormFactorItem<Prism6Item>(parent);
+ item->setBaseEdge(formfactor->baseEdge());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const Pyramid4*>(ff)) {
+ auto* item = addFormFactorItem<Pyramid4Item>(parent);
+ item->setBaseEdge(formfactor->baseEdge());
+ item->setHeight(formfactor->height());
+ item->setAlpha(Units::rad2deg(formfactor->alpha()));
+ } else if (const auto* formfactor = dynamic_cast<const CosineRippleBox*>(ff)) {
+ auto* item = addFormFactorItem<CosineRippleBoxItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const CosineRippleGauss*>(ff)) {
+ auto* item = addFormFactorItem<CosineRippleGaussItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const CosineRippleLorentz*>(ff)) {
+ auto* item = addFormFactorItem<CosineRippleLorentzItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleBox*>(ff)) {
+ auto* item = addFormFactorItem<SawtoothRippleBoxItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ item->setAsymmetry(formfactor->asymmetry());
+ } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleGauss*>(ff)) {
+ auto* item = addFormFactorItem<SawtoothRippleGaussItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ item->setAsymmetry(formfactor->asymmetry());
+ } else if (const auto* formfactor = dynamic_cast<const SawtoothRippleLorentz*>(ff)) {
+ auto* item = addFormFactorItem<SawtoothRippleLorentzItem>(parent);
+ item->setLength(formfactor->length());
+ item->setWidth(formfactor->width());
+ item->setHeight(formfactor->height());
+ item->setAsymmetry(formfactor->asymmetry());
+ } else if (const auto* formfactor = dynamic_cast<const Pyramid3*>(ff)) {
+ auto* item = addFormFactorItem<Pyramid3Item>(parent);
+ item->setBaseEdge(formfactor->baseEdge());
+ item->setHeight(formfactor->height());
+ item->setAlpha(Units::rad2deg(formfactor->alpha()));
+ } else if (const auto* formfactor = dynamic_cast<const TruncatedCube*>(ff)) {
+ auto* item = addFormFactorItem<TruncatedCubeItem>(parent);
+ item->setLength(formfactor->length());
+ item->setRemovedLength(formfactor->removedLength());
+ } else if (const auto* formfactor = dynamic_cast<const TruncatedSphere*>(ff)) {
+ auto* item = addFormFactorItem<TruncatedSphereItem>(parent);
+ item->setRadius(formfactor->radius());
+ item->setHeight(formfactor->height());
+ item->setRemovedTop(formfactor->removedTop());
+ } else if (const auto* formfactor = dynamic_cast<const TruncatedSpheroid*>(ff)) {
+ auto* item = addFormFactorItem<TruncatedSpheroidItem>(parent);
+ item->setRadius(formfactor->radius());
+ item->setHeight(formfactor->height());
+ item->setHeightFlattening(formfactor->heightFlattening());
+ item->setRemovedTop(formfactor->removedTop());
+ } else if (const auto* formfactor = dynamic_cast<const CantellatedCube*>(ff)) {
+ auto* item = addFormFactorItem<CantellatedCubeItem>(parent);
+ item->setLength(formfactor->length());
+ item->setRemovedLength(formfactor->removedLength());
+ } else if (const auto* formfactor = dynamic_cast<const HorizontalCylinder*>(ff)) {
+ auto* item = addFormFactorItem<HorizontalCylinderItem>(parent);
+ item->setRadius(formfactor->radius());
+ item->setLength(formfactor->length());
+ item->setSliceBottom(formfactor->slice_bottom());
+ item->setSliceTop(formfactor->slice_top());
+ } else if (const auto* formfactor = dynamic_cast<const PlatonicOctahedron*>(ff)) {
+ auto* item = addFormFactorItem<PlatonicOctahedronItem>(parent);
+ item->setEdge(formfactor->edge());
+ } else if (const auto* formfactor = dynamic_cast<const PlatonicTetrahedron*>(ff)) {
+ auto* item = addFormFactorItem<PlatonicTetrahedronItem>(parent);
+ item->setEdge(formfactor->edge());
} else
ASSERT(false);
}
@@ -536,92 +536,92 @@ MaterialItem* findMaterialItem(MaterialItems& matItems, const ISampleNode* node)
QString materialName = QString::fromStdString(material->materialName());
- MaterialItem* materialItem = matItems.materialFromName(materialName);
- if (materialItem)
- return materialItem;
+ MaterialItem* result = matItems.materialFromName(materialName);
+ if (result)
+ return result;
complex_t material_data = material->materialData();
if (material->typeID() == MATERIAL_TYPES::RefractiveMaterial) {
- materialItem = matItems.addRefractiveMaterial(materialName, material_data.real(),
+ result = matItems.addRefractiveMaterial(materialName, material_data.real(),
material_data.imag());
} else if (material->typeID() == MATERIAL_TYPES::MaterialBySLD) {
- materialItem =
+ result =
matItems.addSLDMaterial(materialName, material_data.real(), material_data.imag());
} else
ASSERT(0);
- materialItem->setMagnetization(material->magnetization());
+ result->setMagnetization(material->magnetization());
- return materialItem;
+ return result;
}
-void copyParticleItem(ParticleItem* particleItem, MaterialItems& matItems, const Particle* particle)
+void copyParticleItem(ParticleItem* parent, MaterialItems& matItems, const Particle* particle)
{
- particleItem->setAbundance(particle->abundance());
- particleItem->setPosition(particle->particlePosition());
- particleItem->setMaterial(findMaterialItem(matItems, particle));
- setRotation(particleItem, particle->rotation());
- setFormFactor(particleItem, particle->formfactor_at_bottom());
+ parent->setAbundance(particle->abundance());
+ parent->setPosition(particle->particlePosition());
+ parent->setMaterial(findMaterialItem(matItems, particle));
+ setRotation(parent, particle->rotation());
+ setFormFactor(parent, particle->formfactor_at_bottom());
}
void copyParticle(const IParticle* iparticle, MaterialItems& matItems,
std::function<void(ItemWithParticles*)> addToParent)
{
if (const auto* particle = dynamic_cast<const Particle*>(iparticle)) {
- auto* particle_item = new ParticleItem(&matItems);
- copyParticleItem(particle_item, matItems, particle);
- addToParent(particle_item);
+ auto* item = new ParticleItem(&matItems);
+ copyParticleItem(item, matItems, particle);
+ addToParent(item);
} else if (const auto* coreshell = dynamic_cast<const CoreAndShell*>(iparticle)) {
if (!coreshell->coreParticle())
throw std::runtime_error("core/shell particle has no core particle.");
if (!coreshell->shellParticle())
throw std::runtime_error("core/shell particle has no shell particle.");
- auto* coreShellItem = new CoreAndShellItem(&matItems);
- coreShellItem->setAbundance(coreshell->abundance());
- coreShellItem->setPosition(coreshell->particlePosition());
- setRotation(coreShellItem, coreshell->rotation());
+ auto* item = new CoreAndShellItem(&matItems);
+ item->setAbundance(coreshell->abundance());
+ item->setPosition(coreshell->particlePosition());
+ setRotation(item, coreshell->rotation());
if (const Particle* p = coreshell->coreParticle()) {
- coreShellItem->createCore(&matItems);
- copyParticleItem(coreShellItem->core(), matItems, p);
+ item->createCore(&matItems);
+ copyParticleItem(item->core(), matItems, p);
}
if (const Particle* p = coreshell->shellParticle()) {
- coreShellItem->createShell(&matItems);
- copyParticleItem(coreShellItem->shell(), matItems, p);
+ item->createShell(&matItems);
+ copyParticleItem(item->shell(), matItems, p);
}
- addToParent(coreShellItem);
+ addToParent(item);
} else if (const auto* meso = dynamic_cast<const Mesocrystal*>(iparticle)) {
if (!meso->particleStructure().basis())
throw std::runtime_error("Meso crystal has no basis.");
- auto* mesoItem = new MesocrystalItem(&matItems);
- mesoItem->setAbundance(meso->abundance());
- mesoItem->setPosition(meso->particlePosition());
- setFormFactor(mesoItem, meso->outerShape());
- setRotation(mesoItem, meso->rotation());
+ auto* item = new MesocrystalItem(&matItems);
+ item->setAbundance(meso->abundance());
+ item->setPosition(meso->particlePosition());
+ setFormFactor(item, meso->outerShape());
+ setRotation(item, meso->rotation());
const Lattice3D* lattice = meso->particleStructure().lattice();
- mesoItem->setRawDataVectorA(lattice->basisVectorA());
- mesoItem->setRawDataVectorB(lattice->basisVectorB());
- mesoItem->setRawDataVectorC(lattice->basisVectorC());
- addToParent(mesoItem);
+ item->setRawDataVectorA(lattice->basisVectorA());
+ item->setRawDataVectorB(lattice->basisVectorB());
+ item->setRawDataVectorC(lattice->basisVectorC());
+ addToParent(item);
copyParticle(meso->particleStructure().basis(), matItems,
- [=](ItemWithParticles* p) { mesoItem->setBasis(p); });
+ [=](ItemWithParticles* p) { item->setBasis(p); });
} else if (const auto* particleComposition = dynamic_cast<const Compound*>(iparticle)) {
- auto* particleCompositionItem = new CompoundItem(&matItems);
+ auto* item = new CompoundItem(&matItems);
- particleCompositionItem->setAbundance(particleComposition->abundance());
- particleCompositionItem->setPosition(particleComposition->particlePosition());
- setRotation(particleCompositionItem, particleComposition->rotation());
- addToParent(particleCompositionItem);
+ item->setAbundance(particleComposition->abundance());
+ item->setPosition(particleComposition->particlePosition());
+ setRotation(item, particleComposition->rotation());
+ addToParent(item);
for (const auto* p : particleComposition->particles())
copyParticle(p, matItems,
- [=](ItemWithParticles* p) { particleCompositionItem->addParticle(p); });
+ [=](ItemWithParticles* p) { item->addParticle(p); });
}
}