Compute::Slicing Namespace Reference

Functions
ParticleInSlice	createParticleInSlice (const IParticle *particle, const ZLimits &)
std::vector< ZLimits >	particleRegions (const MultiLayer &sample, bool use_slicing)
	Calculate z-admixtures occupied by particles. More...
ZLimits	zSpan (const IParticle *particle)

Function Documentation

createParticleInSlice()

ParticleInSlice Compute::Slicing::createParticleInSlice	(	const IParticle *	particle,
		const ZLimits &	limits
	)

Definition at line 251 of file Slicer.cpp.

{
    if (const auto* p = dynamic_cast<const Particle*>(particle)) {
        ASSERT(p->formfactor_at_bottom());
        std::unique_ptr<ReParticle> particleSlice(createParticleSlice(
            p->formfactor_at_bottom(), limits, p->rotation(), p->particlePosition()));
        if (!particleSlice)
            return {};
        double volume = particleSlice->volume();
        Material transformed_material(
            p->rotation() ? p->material()->rotatedMaterial(p->rotation()->rotMatrix())
                          : *p->material());
        particleSlice->setMaterial(transformed_material);
        return {std::move(particleSlice), {{{volume, transformed_material}}}};
 
    } else if (const auto* p = dynamic_cast<const ParticleCoreShell*>(particle)) {
        const Particle* core = p->coreParticle();
        const Particle* shell = p->shellParticle();
        ASSERT(core && shell);
 
        // core
        std::unique_ptr<Particle> P_core(core->clone());
        if (p->rotation())
            P_core->rotate(*p->rotation());
        P_core->translate(p->particlePosition());
        ParticleInSlice sliced_core = createParticleInSlice(P_core.get(), limits);
 
        // shell
        std::unique_ptr<Particle> P_shell(shell->clone());
        if (p->rotation())
            P_shell->rotate(*p->rotation());
        P_shell->translate(p->particlePosition());
        ParticleInSlice sliced_shell = createParticleInSlice(P_shell.get(), limits);
        if (!sliced_shell.particleSlice)
            return {};
 
        ParticleInSlice result;
        // if core out of limits, return sliced shell
        if (!sliced_core.particleSlice) {
            result.particleSlice.reset(std::move(sliced_shell.particleSlice.get()));
            result.admixtures.push_back(sliced_shell.admixtures.back());
            return result;
        }
 
        // set core ambient material
        if (sliced_shell.admixtures.size() != 1)
            return {};
        auto shell_material = sliced_shell.admixtures[0].material;
        sliced_core.particleSlice->setAmbientMaterial(shell_material);
 
        // construct sliced particle
        sliced_shell.admixtures.back().fraction -= sliced_core.admixtures.back().fraction;
        result.particleSlice.reset(new ReCoreShell(sliced_core.particleSlice.release(),
                                                   sliced_shell.particleSlice.release()));
        result.admixtures.push_back(sliced_core.admixtures.back());
        result.admixtures.push_back(sliced_shell.admixtures.back());
 
        return result;
 
    } else if (dynamic_cast<const ParticleComposition*>(particle)) {
        throw std::runtime_error("ParticleComposition does not yet support slicing");
 
    } else if (const auto* p = dynamic_cast<const MesoCrystal*>(particle)) {
        const Crystal* crystal = &p->particleStructure();
        const IFormFactor* meso_formfactor = p->outerShape();
        ASSERT(crystal && meso_formfactor);
 
        double unit_cell_volume = crystal->lattice()->unitCellVolume();
        if (unit_cell_volume <= 0)
            return {};
 
        ParticleInSlice result;
 
        std::unique_ptr<ReParticle> new_shape(
            createParticleSlice(meso_formfactor, limits, p->rotation(), p->particlePosition()));
 
        const std::unique_ptr<Crystal> new_crystal(
            crystal->transformed(p->rotation(), p->particlePosition()));
 
        const std::unique_ptr<IReParticle> new_basis(processBasis(new_crystal->basis()));
 
        result.particleSlice.reset(new ReMesocrystal(*new_crystal->lattice(), *new_basis,
                                                     *new_shape, new_crystal->position_variance()));
 
        Admixtures& regions = result.admixtures;
        ASSERT(regions.empty());
        for (const auto& particle : crystal->basis()->decompose()) {
            ParticleInSlice pis = createParticleInSlice(particle.get(), {});
            regions.insert(regions.end(), pis.admixtures.begin(), pis.admixtures.end());
        }
        for (auto& region : regions)
            region.fraction *= meso_formfactor->volume() / unit_cell_volume;
 
        return result;
 
    } else
        ASSERT(0);
}

References ParticleInSlice::admixtures, ASSERT, Crystal::basis(), Particle::clone(), IParticle::decompose(), Crystal::lattice(), ParticleInSlice::particleSlice, Crystal::transformed(), Lattice3D::unitCellVolume(), and IFormFactor::volume().

Referenced by zSpan().

Here is the call graph for this function:

particleRegions()

std::vector< ZLimits > Compute::Slicing::particleRegions	(	const MultiLayer &	sample,
		bool	use_slicing
	)

Calculate z-admixtures occupied by particles.

Definition at line 157 of file ParticleRegions.cpp.

{
    const std::vector<double> bottom_coords = bottomLayerCoordinates(sample);
    LayerFillLimits layer_fill_limits(bottom_coords);
    if (use_slicing) {
        for (size_t i = 0; i < sample.numberOfLayers(); ++i) {
            const Layer* layer = sample.layer(i);
            const double offset = (i == 0) ? 0 : bottom_coords[i - 1];
            for (const auto* layout : layer->layouts())
                for (const IParticle* particle : layout->particles())
                    layer_fill_limits.update(Compute::Slicing::zSpan(particle), offset);
        }
    }
    return layer_fill_limits.layerZLimits();
}

References MultiLayer::layer(), Layer::layouts(), MultiLayer::numberOfLayers(), and zSpan().

Here is the call graph for this function:

zSpan()

ZLimits Compute::Slicing::zSpan

(

const IParticle *

particle

)

Definition at line 351 of file Slicer.cpp.

{
    if (const auto* p = dynamic_cast<const ParticleComposition*>(particle)) {
        const auto subparticles = p->decompose();
        ASSERT(subparticles.size() > 0);
        ZLimits result = zSpan(subparticles[0].get());
        for (const auto& subparticle : subparticles)
            result = ZLimits::enclosingInterval(result, zSpan(subparticle.get()));
        return result;
    }
    const ParticleInSlice pis = createParticleInSlice(particle, ZLimits{});
    const double bot = pis.particleSlice->bottomZ(nullptr);
    const double top = pis.particleSlice->topZ(nullptr);
    return {bot, top};
}

References ASSERT, createParticleInSlice(), ZLimits::enclosingInterval(), and ParticleInSlice::particleSlice.

Referenced by particleRegions().

Here is the call graph for this function: