ReParticle.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Resample/Particle/ReParticle.cpp
//! @brief     Implements interface class ReParticle.
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "Resample/Particle/ReParticle.h"
#include "Base/Vector/RotMatrix.h"
#include "Base/Vector/WavevectorInfo.h" // debug
#include "Sample/Material/Material.h"
#include "Sample/Material/MaterialFactoryFuncs.h"
#include "Sample/Particle/IFormFactor.h"
#include "Sample/Scattering/Rotations.h"
 
ReParticle::ReParticle(IFormFactor* ff, const Material* material, const Material* ambient_material,
                       const R3* position, const RotMatrix* rotMatrix)
    : m_ff(std::move(ff))
    , m_material(std::move(material))
    , m_ambient_material(std::move(ambient_material))
    , m_position(std::move(position))
    , m_rotMatrix(std::move(rotMatrix))
{
}
 
ReParticle::ReParticle(const IFormFactor& ff)
    : ReParticle(ff.clone(), nullptr, nullptr, nullptr, nullptr)
{
}
 
ReParticle::~ReParticle() = default;
 
ReParticle* ReParticle::clone() const
{
    return new ReParticle(m_ff->clone(), m_material ? new Material(*m_material) : nullptr,
                          m_ambient_material ? new Material(*m_ambient_material) : nullptr,
                          m_position ? new R3(*m_position) : nullptr,
                          m_rotMatrix ? new RotMatrix(*m_rotMatrix) : nullptr);
}
 
 
ReParticle* ReParticle::createTransformedFormFactor(const IFormFactor& formfactor,
                                                    const IRotation* rot, R3 translation)
{
    auto* result = new ReParticle(formfactor);
    if (rot && !rot->isIdentity())
        result->setRotMatrix(rot->rotMatrix());
    if (translation != R3())
        result->setPosition(translation);
    return result;
}
 
void ReParticle::setMaterial(const Material& material)
{
    m_material = std::make_unique<Material>(material);
}
 
void ReParticle::setAmbientMaterial(const Material& ambient_material)
{
    m_ambient_material = std::make_unique<Material>(ambient_material);
}
 
void ReParticle::setPosition(const R3& position)
{
    m_position = std::make_unique<R3>(position);
}
 
void ReParticle::setRotMatrix(const RotMatrix& rotMatrix)
{
    m_rotMatrix = std::make_unique<RotMatrix>(rotMatrix);
}
 
double ReParticle::volume() const
{
    return m_ff->volume();
}
 
double ReParticle::radialExtension() const
{
    return m_ff->radialExtension();
}
 
const IFormFactor* ReParticle::formfactor_at_bottom() const
{
    return m_ff.get();
}
 
complex_t ReParticle::formfactor_at_bottom(C3 q) const
{
    return m_ff->formfactor_at_bottom(q);
}
 
complex_t ReParticle::theFF(const WavevectorInfo& wavevectors) const
{
    WavevectorInfo wavevectors2 =
        m_rotMatrix ? wavevectors.transformed(m_rotMatrix->Inverse()) : wavevectors;
    complex_t result = m_ff->theFF(wavevectors2);
    if (m_material && m_ambient_material)
        result = (m_material->scalarSubtrSLD(wavevectors2)
                  - m_ambient_material->scalarSubtrSLD(wavevectors2))
                 * result;
    if (m_position)
        result *= exp_I(m_position->dot(wavevectors.getQ()));
    return result;
}
 
SpinMatrix ReParticle::thePolFF(const WavevectorInfo& wavevectors) const
{
    WavevectorInfo wavevectors2 =
        m_rotMatrix ? wavevectors.transformed(m_rotMatrix->Inverse()) : wavevectors;
    SpinMatrix result = m_ff->thePolFF(wavevectors2);
    if (m_material && m_ambient_material) {
        // the conjugated linear part of time reversal operator T
        // (T=UK with K complex conjugate operator and U is linear)
        SpinMatrix time_reverse_conj(0, 1, -1, 0);
        // the interaction and time reversal taken together:
        SpinMatrix V_eff = time_reverse_conj
                           * (m_material->polarizedSubtrSLD(wavevectors2)
                              - m_ambient_material->polarizedSubtrSLD(wavevectors2));
        result *= V_eff;
    }
    if (m_position)
        return result *= exp_I(m_position->dot(wavevectors.getQ()));
    return result;
}
 
double ReParticle::bottomZ(const IRotation* rotation) const
{
    RotMatrix transform = rotation ? rotation->rotMatrix() : RotMatrix();
    if (m_rotMatrix)
        transform = transform * *m_rotMatrix;
    std::unique_ptr<const IRotation> total_rotation(IRotation::createRotation(transform));
    double result = m_ff->bottomZ(total_rotation.get());
    if (m_position)
        result += (rotation ? rotation->transformed(*m_position) : *m_position).z();
    return result;
}
 
double ReParticle::topZ(const IRotation* rotation) const
{
    RotMatrix transform = rotation ? rotation->rotMatrix() : RotMatrix();
    if (m_rotMatrix)
        transform = transform * *m_rotMatrix;
    std::unique_ptr<const IRotation> total_rotation(IRotation::createRotation(transform));
    double result = m_ff->topZ(total_rotation.get());
    if (m_position)
        result += (rotation ? rotation->transformed(*m_position) : *m_position).z();
    return result;
}