RealSpaceBuilder Class Reference

Description

Definition at line 37 of file RealSpaceBuilder.h.

Collaboration diagram for RealSpaceBuilder:

Public Types
using	ItemForRealSpace = std::variant< MultiLayerItem *, LayerItem *, ParticleLayoutItem *, ItemWithParticles * >
	Defines the item types this class can handle. More...

Public Member Functions
	RealSpaceBuilder (std::function< QColor(const QString &)> fnColorFromMaterialName)
void	populate (RealSpace::Model *model, ItemForRealSpace item, const SceneGeometry &sceneGeometry, const RealSpace::Camera::Position &cameraPosition=RealSpace::Camera::Position(RealSpace::Vector3D(0, -200, 120), RealSpace::Vector3D(0, 0, 0), RealSpace::Vector3D::_z)) const
void	populateParticleFromParticle3DContainer (RealSpace::Model *model, const Particle3DContainer &particle3DContainer, const QVector3D &lattice_position={}) const

Private Member Functions
void	populateLayer (RealSpace::Model *model, const LayerItem &layerItem, const SceneGeometry &sceneGeometry, const QVector3D &origin={}, bool isTopLayer=false) const
void	populateLayout (RealSpace::Model *model, const ParticleLayoutItem &layoutItem, const SceneGeometry &sceneGeometry, const QVector3D &origin={}) const
void	populateMultiLayer (RealSpace::Model *model, const MultiLayerItem &mlayerItem, const SceneGeometry &sceneGeometry, const QVector3D &origin={}) const
void	populateParticleFromParticleItem (RealSpace::Model *model, const ItemWithParticles &particleItem) const

Private Attributes
std::unique_ptr< RealSpace::BuilderUtils >	m_builderUtils

Member Typedef Documentation

ItemForRealSpace

using RealSpaceBuilder::ItemForRealSpace = std::variant<MultiLayerItem*, LayerItem*, ParticleLayoutItem*, ItemWithParticles*>

Defines the item types this class can handle.

Definition at line 41 of file RealSpaceBuilder.h.

Constructor & Destructor Documentation

RealSpaceBuilder()

RealSpaceBuilder::RealSpaceBuilder

(

std::function< QColor(const QString &)>

fnColorFromMaterialName

)

Definition at line 66 of file RealSpaceBuilder.cpp.

{
    m_builderUtils = std::make_unique<RealSpace::BuilderUtils>(fnColorFromMaterialName);
}

References m_builderUtils.

Member Function Documentation

populate()

void RealSpaceBuilder::populate	(	RealSpace::Model *	model,
		ItemForRealSpace	item,
		const SceneGeometry &	sceneGeometry,
		const RealSpace::Camera::Position &	cameraPosition = RealSpace::Camera::Position(RealSpace::Vector3D(0, -200, 120),                                                   RealSpace::Vector3D(0, 0, 0),                                                        RealSpace::Vector3D::_z)
	)		const

Definition at line 71 of file RealSpaceBuilder.cpp.

{
    // default value of cameraPosition is in RealSpaceBuilder.h
    model->defCamPos = cameraPosition;
 
    if (const auto* p = std::get_if<MultiLayerItem*>(&item))
        populateMultiLayer(model, **p, sceneGeometry);
    else if (const auto* p = std::get_if<LayerItem*>(&item))
        populateLayer(model, **p, sceneGeometry);
    else if (const auto* p = std::get_if<ParticleLayoutItem*>(&item))
        populateLayout(model, **p, sceneGeometry);
    else if (const auto* p = std::get_if<ItemWithParticles*>(&item))
        populateParticleFromParticleItem(model, **p);
}

References GUI::RealSpace::Model::defCamPos, populateLayer(), populateLayout(), populateMultiLayer(), and populateParticleFromParticleItem().

Referenced by RealSpaceCanvas::updateScene().

Here is the call graph for this function:

populateLayer()

void RealSpaceBuilder::populateLayer ( RealSpace::Model *  model, const LayerItem &  layerItem, const SceneGeometry &  sceneGeometry, const QVector3D &  origin = {}, bool  isTopLayer = false  ) const

private

Definition at line 107 of file RealSpaceBuilder.cpp.

{
    auto layer = GUI::View::TransformTo3D::createLayer(layerItem, sceneGeometry, origin);
    if (layer && !isTopLayer)
        model->addBlend(layer.release());
 
    for (ParticleLayoutItem* layout : layerItem.layouts())
        populateLayout(model, *layout, sceneGeometry, origin);
}

References GUI::RealSpace::Model::addBlend(), GUI::View::TransformTo3D::createLayer(), LayerItem::layouts(), and populateLayout().

Referenced by populate(), and populateMultiLayer().

Here is the call graph for this function:

populateLayout()

void RealSpaceBuilder::populateLayout ( RealSpace::Model *  model, const ParticleLayoutItem &  layoutItem, const SceneGeometry &  sceneGeometry, const QVector3D &  origin = {}  ) const

private

Definition at line 119 of file RealSpaceBuilder.cpp.

{
    // If there is no particle to populate
    if (layoutItem.particles().empty())
        return;
 
    double layer_size = sceneGeometry.layerSize;
    double total_density = layoutItem.totalDensity();
 
    auto particle3DContainer_vector = m_builderUtils->particle3DContainerVector(layoutItem, origin);
 
    const auto latticePositions = generatePositions(layoutItem, layer_size, total_density);
    m_builderUtils->populateParticlesAtLatticePositions(
        latticePositions, particle3DContainer_vector, model, sceneGeometry, this);
}

References GUI::RealSpace::Paracrystal2D::latticePositions(), SceneGeometry::layerSize, m_builderUtils, ParticleLayoutItem::particles(), and ParticleLayoutItem::totalDensity().

Referenced by populate(), and populateLayer().

Here is the call graph for this function:

populateMultiLayer()

void RealSpaceBuilder::populateMultiLayer ( RealSpace::Model *  model, const MultiLayerItem &  mlayerItem, const SceneGeometry &  sceneGeometry, const QVector3D &  origin = {}  ) const

private

Definition at line 88 of file RealSpaceBuilder.cpp.

{
    double total_height(0.0);
    int index(0);
    for (LayerItem* layer : mlayerItem.layers()) {
        bool isTopLayer = index == 0;
        populateLayer(model, *layer, sceneGeometry,
                      QVector3D(0, 0, static_cast<float>(-total_height)), isTopLayer);
 
        if (index != 0)
            total_height += GUI::View::TransformTo3D::visualLayerThickness(*layer, sceneGeometry);
 
        ++index;
    }
}

References MultiLayerItem::layers(), populateLayer(), and GUI::View::TransformTo3D::visualLayerThickness().

Referenced by populate().

Here is the call graph for this function:

populateParticleFromParticle3DContainer()

void RealSpaceBuilder::populateParticleFromParticle3DContainer	(	RealSpace::Model *	model,
		const Particle3DContainer &	particle3DContainer,
		const QVector3D &	lattice_position = {}
	)		const

Definition at line 169 of file RealSpaceBuilder.cpp.

{
    if (particle3DContainer.containerSize()) {
        for (size_t i = 0; i < particle3DContainer.containerSize(); ++i) {
            auto particle3D = particle3DContainer.createParticle(i);
            particle3D->addTranslation(lattice_position);
            if (particle3D) {
                if (!particle3DContainer.particle3DBlend(i))
                    model->add(particle3D.release());
                else
                    model->addBlend(particle3D.release()); // use addBlend() for transparent object
            }
        }
    }
}

References GUI::RealSpace::Model::add(), GUI::RealSpace::Model::addBlend(), Particle3DContainer::containerSize(), Particle3DContainer::createParticle(), and Particle3DContainer::particle3DBlend().

Referenced by populateParticleFromParticleItem(), and GUI::RealSpace::BuilderUtils::populateParticlesAtLatticePositions().

Here is the call graph for this function:

populateParticleFromParticleItem()

void RealSpaceBuilder::populateParticleFromParticleItem ( RealSpace::Model *  model, const ItemWithParticles &  particleItem  ) const

private

Definition at line 138 of file RealSpaceBuilder.cpp.

{
    Particle3DContainer particle3DContainer;
    if (const auto* pItem = dynamic_cast<const ParticleItem*>(&particleItem)) {
        auto particle = pItem->createParticle();
        particle3DContainer = m_builderUtils->singleParticle3DContainer(*particle);
    } else if (const auto* particleCoreShellItem =
                   dynamic_cast<const ParticleCoreShellItem*>(&particleItem)) {
        // If there is no CORE or SHELL to populate inside ParticleCoreShellItem
        if (!particleCoreShellItem->core() || !particleCoreShellItem->shell())
            return;
        auto particleCoreShell = particleCoreShellItem->createParticleCoreShell();
        particle3DContainer = m_builderUtils->particleCoreShell3DContainer(*particleCoreShell);
    } else if (const auto* particleCompositionItem =
                   dynamic_cast<const ParticleCompositionItem*>(&particleItem)) {
        // If there is no particle to populate inside ParticleCompositionItem
        if (!particleCompositionItem->particles().empty())
            return;
        auto particleComposition = particleCompositionItem->createParticleComposition();
        particle3DContainer = m_builderUtils->particleComposition3DContainer(*particleComposition);
    } else if (const auto* mesoCrystalItem = dynamic_cast<const MesoCrystalItem*>(&particleItem)) {
        // If there is no particle to populate inside MesoCrystalItem
        if (!mesoCrystalItem->basisParticle())
            return;
        particle3DContainer = m_builderUtils->mesoCrystal3DContainer(*mesoCrystalItem);
    }
 
    populateParticleFromParticle3DContainer(model, particle3DContainer);
}

References Particle3DContainer::createParticle(), m_builderUtils, and populateParticleFromParticle3DContainer().

Referenced by populate().

Here is the call graph for this function:

Member Data Documentation

m_builderUtils

std::unique_ptr<RealSpace::BuilderUtils> RealSpaceBuilder::m_builderUtils

private

Definition at line 74 of file RealSpaceBuilder.h.

Referenced by RealSpaceBuilder(), populateLayout(), and populateParticleFromParticleItem().

---

The documentation for this class was generated from the following files:

• /home/build/builds/o5h8MZZm/0/mlz/bornagain/GUI/View/Realspace/RealSpaceBuilder.h
• /home/build/builds/o5h8MZZm/0/mlz/bornagain/GUI/View/Realspace/RealSpaceBuilder.cpp