MesoCrystalItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Sample/MesoCrystalItem.cpp
//! @brief     Implements class MesoCrystalItem
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2021
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Sample/MesoCrystalItem.h"
#include "GUI/Model/CatSample/FormFactorItemCatalog.h"
#include "GUI/Model/CatSample/ItemWithParticlesCatalog.h"
#include "GUI/Model/CatSample/RotationItemCatalog.h"
#include "GUI/Model/Sample/FormFactorItems.h"
#include "GUI/Model/Sample/ParticleCompositionItem.h"
#include "GUI/Model/Sample/ParticleCoreShellItem.h"
#include "GUI/Model/Sample/ParticleItem.h"
#include "GUI/Support/XML/Serialize.h"
#include "GUI/Util/Error.h"
#include "Sample/Particle/Crystal.h"
#include "Sample/Particle/IFormFactor.h"
#include "Sample/Particle/MesoCrystal.h"
#include "Sample/Particle/Particle.h"
#include "Sample/Particle/ParticleCoreShell.h"
#include "Sample/Scattering/Rotations.h"
 
namespace {
 
const QString abundance_tooltip = "Proportion of this type of mesocrystal normalized to the \n"
                                  "total number of particles in the layout";
 
const QString position_tooltip = "Relative position of the mesocrystal's reference point \n"
                                 "in the coordinate system of the parent (nm)";
 
} // namespace
 
MesoCrystalItem::MesoCrystalItem(const MaterialItems* materials)
    : ItemWithParticles(abundance_tooltip, position_tooltip)
    , m_materials(materials)
{
    m_vectorA.init("First lattice vector", "Coordinates of the first lattice vector",
                   Unit::nanometer, "vectorA");
    m_vectorB.init("Second lattice vector", "Coordinates of the second lattice vector",
                   Unit::nanometer, "vectorB");
    m_vectorC.init("Third lattice vector", "Coordinates of the third lattice vector",
                   Unit::nanometer, "vectorC");
 
    m_outerShape.init<FormFactorItemCatalog>("Outer Shape", "", "outerShape");
    m_basisParticle.init<ItemWithParticlesCatalog>("Basis", "", "basis", materials);
}
 
void MesoCrystalItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_abundance);
    Serialize::rwProperty(s, m_position);
    Serialize::rwSelected<RotationItemCatalog>(s, m_rotation);
    Serialize::rwProperty(s, m_vectorA);
    Serialize::rwProperty(s, m_vectorB);
    Serialize::rwProperty(s, m_vectorC);
    Serialize::rwSelected<FormFactorItemCatalog>(s, m_outerShape);
    Serialize::rwSelected<ItemWithParticlesCatalog>(s, m_basisParticle, m_materials);
}
 
std::unique_ptr<MesoCrystal> MesoCrystalItem::createMesoCrystal() const
{
    const Lattice3D& lattice = getLattice();
    if (!(lattice.unitCellVolume() > 0.0))
        throw Error("MesoCrystalItem::createMesoCrystal(): "
                    "Lattice volume not strictly positive");
    std::unique_ptr<IParticle> basis = getBasis();
    if (!basis)
        throw Error("MesoCrystalItem::createMesoCrystal(): "
                    "No basis particle defined");
    Crystal crystal(*basis, lattice);
 
    std::unique_ptr<IFormFactor> ff = getOuterShape();
    if (!ff)
        throw Error("MesoCrystalItem::createMesoCrystal(): "
                    "No outer shape defined");
 
    auto result = std::make_unique<MesoCrystal>(crystal, *ff);
    result->setParticlePosition(position());
    if (auto r = createRotation(); r && !r->isIdentity())
        result->setRotation(*r);
 
    return result;
}
 
Lattice3D MesoCrystalItem::getLattice() const
{
    return Lattice3D(m_vectorA, m_vectorB, m_vectorC);
}
 
std::unique_ptr<IParticle> MesoCrystalItem::getBasis() const
{
    if (auto* p = dynamic_cast<ParticleItem*>(m_basisParticle.get()))
        return p->createParticle();
 
    if (auto* p = dynamic_cast<ParticleCoreShellItem*>(m_basisParticle.get()))
        return p->createParticleCoreShell();
 
    if (auto* p = dynamic_cast<ParticleCompositionItem*>(m_basisParticle.get()))
        return p->createParticleComposition();
 
    if (auto* p = dynamic_cast<MesoCrystalItem*>(m_basisParticle.get()))
        return p->createMesoCrystal();
 
    return {};
}
 
std::unique_ptr<IFormFactor> MesoCrystalItem::getOuterShape() const
{
    return m_outerShape->createFormFactor();
}
 
SelectionDescriptor<FormFactorItem*> MesoCrystalItem::outerShape() const
{
    return m_outerShape;
}
 
void MesoCrystalItem::setOuterShape(FormFactorItem* p)
{
    m_outerShape.set(p);
}
 
ItemWithParticles* MesoCrystalItem::basisParticle() const
{
    return m_basisParticle.get();
}
 
void MesoCrystalItem::setBasis(ItemWithParticles* basis)
{
    m_basisParticle.set(basis);
}
 
void MesoCrystalItem::setRawDataVectorA(const R3& v)
{
    m_vectorA.set(v);
}
 
void MesoCrystalItem::setRawDataVectorB(const R3& v)
{
    m_vectorB.set(v);
}
 
void MesoCrystalItem::setRawDataVectorC(const R3& v)
{
    m_vectorC.set(v);
}
 
VectorDescriptor MesoCrystalItem::vectorA() const
{
    return m_vectorA;
}
 
VectorDescriptor MesoCrystalItem::vectorB() const
{
    return m_vectorB;
}
 
VectorDescriptor MesoCrystalItem::vectorC() const
{
    return m_vectorC;
}
 
QVector<ItemWithParticles*> MesoCrystalItem::containedItemsWithParticles() const
{
    QVector<ItemWithParticles*> result;
    if (basisParticle())
        result << basisParticle() << basisParticle()->containedItemsWithParticles();
    return result;
}