TestSinusoidalTimeDependence.cpp

Go to the documentation of this file.

//
// Tests for SinusoidalTimeDependence
//
// Copyright (c) 2025, Jon Thompson, STFC Rutherford Appleton Laboratory, Didcot, UK
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL.  If not, see <https://www.gnu.org/licenses/>.
//
#include "Algorithms/AbstractTimeDependence.h"
#include "Algorithms/SinusoidalTimeDependence.h"
#include "Ippl.h"
#include "Utilities/GeneralOpalException.h"
#include "gtest/gtest.h"
 
TEST(TestSinusoidalTimeDependence, SinusoidalTimeDependenceTest) {
    // Check empty coefficients always returns 0.
    SinusoidalTimeDependence time_dependence_1({}, {}, {}, {});
    EXPECT_DOUBLE_EQ(time_dependence_1.getValue(0.1), 0.0);
 
    // Check a sine wave value
    SinusoidalTimeDependence time_dependence_2({8.0}, {}, {}, {});
    EXPECT_DOUBLE_EQ(time_dependence_2.getValue(0.1), -0.47552825814757682);
 
    // Check the amplitude
    SinusoidalTimeDependence time_dependence_3({8.0}, {}, {2.0}, {});
    EXPECT_DOUBLE_EQ(time_dependence_3.getValue(0.1), -0.95105651629515364);
 
    // Check the phase offset
    SinusoidalTimeDependence time_dependence_4({8.0}, {0.1}, {2.0}, {});
    EXPECT_DOUBLE_EQ(time_dependence_4.getValue(0.1), -0.91545497277810161);
 
    // Check the DC offset
    SinusoidalTimeDependence time_dependence_5({8.0}, {0.1}, {2.0}, {-1.0});
    EXPECT_DOUBLE_EQ(time_dependence_5.getValue(0.1), -1.91545497277810161);
 
    // Check clone produces same result
    SinusoidalTimeDependence* time_dependence_clone = time_dependence_5.clone();
    EXPECT_DOUBLE_EQ(time_dependence_clone->getValue(0.1), -1.91545497277810161);
    delete time_dependence_clone;
}
 
TEST(TestSinusoidalTimeDependence, TDMapTest) {
    // throw on empty value
    EXPECT_THROW(AbstractTimeDependence::getTimeDependence("name"), GeneralOpalException);
 
    // set/get time dependence
    SinusoidalTimeDependence time_dep({}, {}, {}, {});
    std::shared_ptr<SinusoidalTimeDependence> td1(time_dep.clone());
    AbstractTimeDependence::setTimeDependence("td1", td1);
    EXPECT_EQ(AbstractTimeDependence::getTimeDependence("td1"), td1);
    std::shared_ptr<SinusoidalTimeDependence> td2(time_dep.clone());
    AbstractTimeDependence::setTimeDependence("td2", td2);
    EXPECT_EQ(AbstractTimeDependence::getTimeDependence("td2"), td2);
    EXPECT_EQ(AbstractTimeDependence::getTimeDependence("td1"), td1);
    // set time dependence overwriting existing time dependence
    // should overwrite, without memory leak
    std::shared_ptr<SinusoidalTimeDependence> td3(time_dep.clone());
    AbstractTimeDependence::setTimeDependence("td1", td3);
    EXPECT_EQ(AbstractTimeDependence::getTimeDependence("td1"), td3);
}
 
TEST(TestSinusoidalTimeDependence, TDMapNameLookupTest) {
    EXPECT_THROW(AbstractTimeDependence::getName(nullptr), GeneralOpalException);
    SinusoidalTimeDependence time_dep({}, {}, {}, {});
    std::shared_ptr<SinusoidalTimeDependence> td1(time_dep.clone());
    std::shared_ptr<SinusoidalTimeDependence> td2(time_dep.clone());
    std::shared_ptr<SinusoidalTimeDependence> td3(time_dep.clone());
    AbstractTimeDependence::setTimeDependence("td1", td1);
    AbstractTimeDependence::setTimeDependence("td2", td2);
    AbstractTimeDependence::setTimeDependence("td3", td2);
    std::string name1 = AbstractTimeDependence::getName(td1);
    EXPECT_EQ(name1, "td1");
    std::string name2 = AbstractTimeDependence::getName(td2);
    EXPECT_TRUE(name2 == "td2" || name2 == "td3");
    EXPECT_THROW(AbstractTimeDependence::getName(td3), GeneralOpalException);
}
 
TEST(TestSinusoidalTimeDependence, Integral) {
    // Check empty coefficients always returns 0.
    SinusoidalTimeDependence time_dependence_1({}, {}, {}, {});
    EXPECT_NEAR(time_dependence_1.getIntegral(0.1), 0.0, 0.000001);
 
    // Check a sine wave value
    SinusoidalTimeDependence time_dependence_2({8.0}, {}, {}, {});
    EXPECT_NEAR(time_dependence_2.getIntegral(0.1), 0.013746670117215259, 0.000001);
 
    // Check the amplitude
    SinusoidalTimeDependence time_dependence_3({8.0}, {}, {2.0}, {});
    EXPECT_NEAR(time_dependence_3.getIntegral(0.1), 0.013746670117215259 * 2, 0.000001);
 
    // Check the phase offset
    SinusoidalTimeDependence time_dependence_4({8.0}, {0.1}, {2.0}, {});
    EXPECT_NEAR(time_dependence_4.getIntegral(0.1), 0.02357815814417235, 0.000001);
 
    // Check the DC offset
    SinusoidalTimeDependence time_dependence_5({8.0}, {0.1}, {2.0}, {-1.0});
    EXPECT_NEAR(time_dependence_5.getIntegral(0.1), 0.02357815814417235 - 0.1, 0.000001);
}
 
TEST(TestSinusoidalTimeDependence, Print) {
    int argc    = 0;
    char** argv = nullptr;
    ippl::initialize(argc, argv);
    std::stringstream ss;
    Inform inform("Test", ss);
    inform.setOutputLevel(5);
    SinusoidalTimeDependence timeDep({8.0, 9.0}, {0.1, 0.2}, {2.0, 3.0}, {-1.0, -2.0});
    inform << timeDep << endl;
    EXPECT_STREQ(
            "Test> f=[8.000000e+00, 9.000000e+00], p=[1.000000e-01, 2.000000e-01], "
            "a=[2.000000e+00, 3.000000e+00], o=[-1.000000e+00, -2.000000e+00\nTest> \n",
            ss.str().c_str());
    ippl::finalize();
}