TestLaser.cpp

Go to the documentation of this file.

#include "Algorithms/DefaultVisitor.h"
#include "Algorithms/ParallelTracker.h"
#include "Attributes/Attributes.h"
#include "BeamlineCore/LaserRep.h"
#include "BeamlineCore/RBendRep.h"
#include "BeamlineCore/SBendRep.h"
#include "Beamlines/FlaggedElmPtr.h"
#include "Beamlines/TBeamline.h"
#include "Elements/OpalLaser.h"
#include "Physics/Physics.h"
#include "Utilities/LogicalError.h"
#include "Utilities/OpalException.h"
 
#include "gtest/gtest.h"
 
#include <cmath>
 
namespace {
    void setValidLaserAttributes(OpalLaser& laser) {
        Attributes::setReal(laser.itsAttr[OpalLaser::WAVELENGTH], 1.03e-6);
        Attributes::setReal(laser.itsAttr[OpalLaser::PULSEENERGY], 1.0);
        Attributes::setReal(laser.itsAttr[OpalLaser::PULSELENGTH], 2.0e-12);
        Attributes::setReal(laser.itsAttr[OpalLaser::WAISTX], 5.0e-6);
        Attributes::setReal(laser.itsAttr[OpalLaser::WAISTY], 6.0e-6);
        Attributes::setRealArray(laser.itsAttr[OpalLaser::DIR], {0.0, 0.0, -2.0});
    }
 
    class DispatchRecordingVisitor : public DefaultVisitor {
    public:
        explicit DispatchRecordingVisitor(const Beamline& beamline)
            : DefaultVisitor(beamline, false, false) {}
 
        void visitComponent(const Component&) override { sawComponent = true; }
        void visitLaser(const Laser&) override { sawLaser = true; }
        void visitSBend(const SBend&) override { sawSBend = true; }
        void visitRBend(const RBend&) override { sawRBend = true; }
 
        bool sawComponent = false;
        bool sawLaser     = false;
        bool sawSBend     = false;
        bool sawRBend     = false;
    };
}  // namespace
 
TEST(TestLaser, UpdateStoresValidatedParameters) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setReal(laser.itsAttr[OpalElement::LENGTH], 0.01);
    Attributes::setRealArray(laser.itsAttr[OpalLaser::STOKES], {0.0, 0.0, 1.0});
 
    EXPECT_NO_THROW(laser.update());
 
    auto* rep = dynamic_cast<LaserRep*>(laser.getElement());
    ASSERT_NE(rep, nullptr);
    EXPECT_DOUBLE_EQ(rep->getElementLength(), 0.01);
    EXPECT_DOUBLE_EQ(rep->getWavelength(), 1.03e-6);
    EXPECT_DOUBLE_EQ(rep->getPulseEnergy(), 1.0);
    EXPECT_DOUBLE_EQ(rep->getPulseLength(), 2.0e-12);
    EXPECT_DOUBLE_EQ(rep->getWaistX(), 5.0e-6);
    EXPECT_DOUBLE_EQ(rep->getWaistY(), 6.0e-6);
    EXPECT_NEAR(rep->getDirection()(0), 0.0, 1.0e-15);
    EXPECT_NEAR(rep->getDirection()(1), 0.0, 1.0e-15);
    EXPECT_NEAR(rep->getDirection()(2), -1.0, 1.0e-15);
    EXPECT_DOUBLE_EQ(rep->getStokes()(2), 1.0);
}
 
TEST(TestLaser, UpdateDefaultsStokesToZero) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
 
    EXPECT_NO_THROW(laser.update());
 
    auto* rep = dynamic_cast<LaserRep*>(laser.getElement());
    ASSERT_NE(rep, nullptr);
    EXPECT_DOUBLE_EQ(rep->getStokes()(0), 0.0);
    EXPECT_DOUBLE_EQ(rep->getStokes()(1), 0.0);
    EXPECT_DOUBLE_EQ(rep->getStokes()(2), 0.0);
}
 
TEST(TestLaser, UpdateRequiresWavelength) {
    OpalLaser laser;
    Attributes::setReal(laser.itsAttr[OpalLaser::PULSEENERGY], 1.0);
    Attributes::setReal(laser.itsAttr[OpalLaser::PULSELENGTH], 2.0e-12);
    Attributes::setReal(laser.itsAttr[OpalLaser::WAISTX], 5.0e-6);
    Attributes::setReal(laser.itsAttr[OpalLaser::WAISTY], 6.0e-6);
    Attributes::setRealArray(laser.itsAttr[OpalLaser::DIR], {0.0, 0.0, -2.0});
 
    EXPECT_THROW(laser.update(), OpalException);
}
 
TEST(TestLaser, UpdateRejectsNonPositivePulseEnergy) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setReal(laser.itsAttr[OpalLaser::PULSEENERGY], 0.0);
 
    EXPECT_THROW(laser.update(), OpalException);
}
 
TEST(TestLaser, UpdateRejectsBadDirectionSize) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setRealArray(laser.itsAttr[OpalLaser::DIR], {0.0, 1.0});
 
    EXPECT_THROW(laser.update(), OpalException);
}
 
TEST(TestLaser, UpdateRejectsZeroDirection) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setRealArray(laser.itsAttr[OpalLaser::DIR], {0.0, 0.0, 0.0});
 
    EXPECT_THROW(laser.update(), OpalException);
}
 
TEST(TestLaser, UpdateRejectsBadStokesSize) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setRealArray(laser.itsAttr[OpalLaser::STOKES], {0.0, 1.0});
 
    EXPECT_THROW(laser.update(), OpalException);
}
 
TEST(TestLaser, UpdateRejectsStokesNormAboveOne) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setRealArray(laser.itsAttr[OpalLaser::STOKES], {1.0, 1.0, 0.0});
 
    EXPECT_THROW(laser.update(), OpalException);
}
 
TEST(TestLaser, UpdateRejectsNegativeLength) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setReal(laser.itsAttr[OpalElement::LENGTH], -1.0);
 
    EXPECT_THROW(laser.update(), OpalException);
}
 
TEST(TestLaser, LinearComptonForwardPhotonEnergyMatchesExactNinetyDegreeKinematics) {
    OpalLaser laser;
    setValidLaserAttributes(laser);
    Attributes::setRealArray(laser.itsAttr[OpalLaser::DIR], {1.0, 0.0, 0.0});
 
    ASSERT_NO_THROW(laser.update());
 
    auto* rep = dynamic_cast<LaserRep*>(laser.getElement());
    ASSERT_NE(rep, nullptr);
 
    Vector_t<double, 3> beamDirection(0.0);
    beamDirection(2) = 1.0;
 
    const double electronTotalEnergyGeV = 1.0;
    const double laserPhotonEnergyGeV   = rep->getPhotonEnergyGeV();
    const double electronMomentumGeV    = std::sqrt(
            electronTotalEnergyGeV * electronTotalEnergyGeV - Physics::m_e * Physics::m_e);
    const double expectedInvariantX =
            2.0 * laserPhotonEnergyGeV * electronTotalEnergyGeV / (Physics::m_e * Physics::m_e);
    const double stableEnergyMinusMomentum =
            Physics::m_e * Physics::m_e / (electronTotalEnergyGeV + electronMomentumGeV);
    const double expectedForwardPhotonEnergyGeV =
            laserPhotonEnergyGeV * electronTotalEnergyGeV
            / (stableEnergyMinusMomentum + laserPhotonEnergyGeV);
 
    EXPECT_NEAR(
            rep->getLinearComptonInvariantX(electronTotalEnergyGeV, beamDirection),
            expectedInvariantX, expectedInvariantX * 1.0e-12);
    EXPECT_NEAR(
            rep->getLinearComptonForwardPhotonEnergyGeV(electronTotalEnergyGeV, beamDirection),
            expectedForwardPhotonEnergyGeV, expectedForwardPhotonEnergyGeV * 1.0e-12);
}
 
TEST(TestLaser, BeamlineVisitorDispatchesLaserAndBendsToSpecificHooks) {
    TBeamline<FlaggedElmPtr> beamline("LINE");
 
    {
        DispatchRecordingVisitor visitor(beamline);
        LaserRep laser("LASER");
        laser.accept(visitor);
        EXPECT_TRUE(visitor.sawLaser);
        EXPECT_FALSE(visitor.sawSBend);
        EXPECT_FALSE(visitor.sawRBend);
        EXPECT_FALSE(visitor.sawComponent);
    }
 
    {
        DispatchRecordingVisitor visitor(beamline);
        SBendRep sbend("SBEND");
        sbend.accept(visitor);
        EXPECT_FALSE(visitor.sawLaser);
        EXPECT_TRUE(visitor.sawSBend);
        EXPECT_FALSE(visitor.sawRBend);
        EXPECT_FALSE(visitor.sawComponent);
    }
 
    {
        DispatchRecordingVisitor visitor(beamline);
        RBendRep rbend("RBEND");
        rbend.accept(visitor);
        EXPECT_FALSE(visitor.sawLaser);
        EXPECT_FALSE(visitor.sawSBend);
        EXPECT_TRUE(visitor.sawRBend);
        EXPECT_FALSE(visitor.sawComponent);
    }
}