コード例 #1
0
   virtual void SetUp()
   {
      f_vector_2d_t momentumVec(n_sections, f_vector_t(N_t + 1));
      for (auto &v : momentumVec)
         mymath::linspace(v.data(), p_i, p_f, N_t + 1);

      f_vector_2d_t alphaVec(n_sections , f_vector_t(alpha_order+1, alpha));

      f_vector_t CVec(n_sections, C);

      f_vector_2d_t hVec(n_sections , f_vector_t(N_t + 1, h));

      f_vector_2d_t voltageVec(n_sections , f_vector_t(N_t + 1, V));

      f_vector_2d_t dphiVec(n_sections , f_vector_t(N_t + 1, dphi));


	   Context::GP = new GeneralParameters(N_t, CVec, alphaVec, alpha_order, momentumVec,
                                 proton);

	   Context::Beam = new Beams(N_p, N_b);

	   Context::RfP = new RfParameters(n_sections, hVec, voltageVec, dphiVec);


      longitudinal_bigaussian(tau_0 / 4, 0, -1, false);

	   Context::Slice = new Slices(N_slices);

   }
コード例 #2
0
TEST_F(testFullRing, constructor1)
{
    auto Beam = Context::Beam;
    auto GP = Context::GP;
    auto RfP = Context::RfP;
    auto epsilon = 1e-8;
    auto params = std::string(TEST_FILES "/FullRing/constructor1/");

    longitudinal_bigaussian(GP, RfP, Beam, 200e-9, 1e6, -1, false);

    auto long_tracker = new RingAndRfSection(RfP);
    auto fullRing = new FullRingAndRf({long_tracker, long_tracker});

    f_vector_t v;
    util::read_vector_from_file(v, params + "ring_radius.txt");

    ASSERT_EQ(v.size(), 1);
    for (uint i = 0; i < v.size(); ++i) {
        auto ref = v[i];
        auto real = fullRing->fRingRadius;
        ASSERT_NEAR(ref, real, epsilon * std::max(std::abs(ref), std::abs(real)))
                << "Testing of ring_radius failed on i " << i << std::endl;
    }

    delete long_tracker;
    delete fullRing;
}
コード例 #3
0
TEST_F(testPLSPS_RL, track2)
{

   longitudinal_bigaussian(200e-9, 100e6, 42321, false);

   auto sps = new SPS_RL(25e-6, 0, 5e-6);
   sps->reference = 1e-6;


   auto params = std::string("../unit-tests/references/")
                 + "PL/SPS_RL/track2/";

	Context::Slice->track();
   f_vector_t domega_RF;

   for (uint i = 0; i < N_t; ++i) {
      sps->track();
      domega_RF.push_back(sps->domega_RF);
	   Context::RfP->counter++;
   }

   f_vector_t v;

   util::read_vector_from_file(v, params + "domega_RF_mean.txt");
   // util::dump(domega_RF, "domega_RF");
   auto epsilon = 1e-2;
   auto ref = v[0];
   auto real = mymath::mean(domega_RF.data(), domega_RF.size());
   // std::cout << real << "\n";
   ASSERT_NEAR(ref, real, epsilon * std::max(fabs(ref), fabs(real)))
         << "Testing of domega_RF_mean failed\n";

   v.clear();
   util::read_vector_from_file(v, params + "domega_RF_std.txt");
   epsilon = 1e-2;
   ref = v[0];
   real = mymath::standard_deviation(domega_RF.data(), domega_RF.size());
   // std::cout << real << "\n";
   ASSERT_NEAR(ref, real, epsilon * std::max(fabs(ref), fabs(real)))
         << "Testing of domega_RF_std failed\n";


   delete sps;
}
コード例 #4
0
    virtual void SetUp()
    {
        omp_set_num_threads(1);

        f_vector_2d_t momentumVec(n_sections, f_vector_t(N_t + 1));
        for (auto &v : momentumVec)
            mymath::linspace(v.data(), p_i, 1.01 * p_i, N_t + 1);

        f_vector_2d_t alphaVec(n_sections, f_vector_t(alpha_order, alpha));

        f_vector_t CVec(n_sections, C);

        f_vector_2d_t hVec(n_sections, f_vector_t(N_t + 1, h));

        f_vector_2d_t voltageVec(n_sections, f_vector_t(N_t + 1, V));

        f_vector_2d_t dphiVec(n_sections, f_vector_t(N_t + 1, dphi));

        Context::GP = new GeneralParameters(N_t, CVec, alphaVec,
                                             momentumVec,
                                            GeneralParameters::particle_t::proton);

        // Context::Beam = new Beams(N_p, N_b);

        auto GP = Context::GP;
        auto Beam = Context::Beam = new Beams(GP, N_p, N_b);

        auto RfP = Context::RfP = new RfParameters(GP, n_sections, hVec,
                voltageVec, dphiVec);


        // RingAndRfSection *long_tracker = new RingAndRfSection();

        longitudinal_bigaussian(GP, RfP, Beam, tau_0 / 4, 0, -1, false);
        Context::Slice = new Slices(RfP, Beam, N_slices);
    }
コード例 #5
0
TEST_F(testFullRing, track2)
{
    auto Beam = Context::Beam;
    auto GP = Context::GP;
    auto RfP = Context::RfP;

    auto epsilon = 1e-8;
    auto params = std::string(TEST_FILES "/FullRing/track2/");

    longitudinal_bigaussian(GP, RfP, Beam, 200e-9, 1e6, -1, false);

    auto fullRing = new FullRingAndRf({long_tracker1, long_tracker2});

    for (uint i = 0; i < N_t; ++i) fullRing->track();

    f_vector_t v;
    util::read_vector_from_file(v, params + "dE.txt");
    ASSERT_EQ(v.size(), Beam->dE.size());
    for (uint i = 0; i < v.size(); ++i) {
        auto ref = v[i];
        auto real = Beam->dE[i];
        ASSERT_NEAR(ref, real, epsilon * std::max(std::abs(ref), std::abs(real)))
                << "Testing of dE failed on i " << i << std::endl;
    }

    util::read_vector_from_file(v, params + "dt.txt");
    ASSERT_EQ(v.size(), Beam->dt.size());
    for (uint i = 0; i < v.size(); ++i) {
        auto ref = v[i];
        auto real = Beam->dt[i];
        ASSERT_NEAR(ref, real, epsilon * std::max(std::abs(ref), std::abs(real)))
                << "Testing of dt failed on i " << i << std::endl;
    }

    delete fullRing;
}