← Back to branch summary

~cheid001/maus/SingleSationDistro

« back to all changes in this revision

Viewing changes to tests/cpp_unit/FieldTools/DerivativesSolenoidTest.cc

merging with trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/cpp_unit/FieldTools/DerivativesSolenoidTest.cc
 
1
/* This file is part of MAUS: http://micewww.pp.rl.ac.uk/projects/maus
 
2
 *
 
3
 * MAUS is free software: you can redistribute it and/or modify
 
4
 * it under the terms of the GNU General Public License as published by
 
5
 * the Free Software Foundation, either version 3 of the License, or
 
6
 * (at your option) any later version.
 
7
 *
 
8
 * MAUS is distributed in the hope that it will be useful,
 
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
 * GNU General Public License for more details.
 
12
 *
 
13
 * You should have received a copy of the GNU General Public License
 
14
 * along with MAUS.  If not, see <http://www.gnu.org/licenses/>.
 
15
 *
 
16
 */
 
17
 
 
18
#include "gtest/gtest.h"
 
19
 
 
20
#include "src/common_cpp/FieldTools/DerivativesSolenoid.hh"
 
21
 
 
22
namespace MAUS {
 
23
EndFieldModel* test_end_field() {
 
24
    return new BTMultipole::TanhEndField(1., 0.1, 3);
 
25
}
 
26
 
 
27
TEST(DerivativesSolenoidTest, TestConstructorDestructor) {
 
28
    DerivativesSolenoid sol_default;
 
29
    EXPECT_EQ(sol_default.GetPeakField(), 0.);
 
30
    EXPECT_EQ(sol_default.GetRMax(), 0.);
 
31
    EXPECT_EQ(sol_default.GetZMax(), 0.);
 
32
    EXPECT_EQ(sol_default.GetHighestOrder(), 0);
 
33
    EXPECT_EQ
 
34
            (sol_default.GetEndFieldModel(), static_cast<EndFieldModel*>(NULL));
 
35
 
 
36
    DerivativesSolenoid sol_null(2., 10., 11., 3, NULL);
 
37
    EXPECT_EQ(sol_null.GetPeakField(), 2.);
 
38
    EXPECT_EQ(sol_null.GetRMax(), 10.);
 
39
    EXPECT_EQ(sol_null.GetZMax(), 11.);
 
40
    EXPECT_EQ(sol_null.GetHighestOrder(), 3);
 
41
    EXPECT_EQ(sol_null.GetEndFieldModel(), static_cast<EndFieldModel*>(NULL));
 
42
 
 
43
    EndFieldModel* end = test_end_field();
 
44
    DerivativesSolenoid sol_value(2., 10., 11., 3, end);
 
45
    EXPECT_EQ(sol_value.GetPeakField(), 2.);
 
46
    EXPECT_EQ(sol_value.GetRMax(), 10.);
 
47
    EXPECT_EQ(sol_value.GetZMax(), 11.);
 
48
    EXPECT_EQ(sol_value.GetHighestOrder(), 3);
 
49
    EXPECT_EQ(sol_value.GetEndFieldModel(), end);
 
50
}
 
51
 
 
52
// all
 
53
TEST(DerivativesSolenoidTest, TestNullCopyConstructorCloneEquality) {
 
54
    DerivativesSolenoid sol_null;
 
55
    DerivativesSolenoid sol_null_copy(sol_null);
 
56
    EXPECT_EQ(sol_null.GetPeakField(), sol_null_copy.GetPeakField());
 
57
    EXPECT_EQ(sol_null.GetRMax(), sol_null_copy.GetRMax());
 
58
    EXPECT_EQ(sol_null.GetZMax(), sol_null_copy.GetZMax());
 
59
    EXPECT_EQ(sol_null.GetHighestOrder(), sol_null_copy.GetHighestOrder());
 
60
    EXPECT_EQ(sol_null.GetEndFieldModel(), sol_null_copy.GetEndFieldModel());
 
61
 
 
62
    DerivativesSolenoid sol_null_equ;  // force gcc not to use copy ctor
 
63
    EXPECT_EQ(sol_null_equ.GetHighestOrder(), 0);
 
64
    sol_null_equ = sol_null;
 
65
    EXPECT_EQ(sol_null.GetPeakField(), sol_null_equ.GetPeakField());
 
66
    EXPECT_EQ(sol_null.GetRMax(), sol_null_equ.GetRMax());
 
67
    EXPECT_EQ(sol_null.GetZMax(), sol_null_equ.GetZMax());
 
68
    EXPECT_EQ(sol_null.GetHighestOrder(), sol_null_equ.GetHighestOrder());
 
69
    EXPECT_EQ(sol_null.GetEndFieldModel(), sol_null_equ.GetEndFieldModel());
 
70
 
 
71
    DerivativesSolenoid& sol_null_clone = *sol_null.Clone();
 
72
    EXPECT_EQ(sol_null.GetPeakField(), sol_null_clone.GetPeakField());
 
73
    EXPECT_EQ(sol_null.GetRMax(), sol_null_clone.GetRMax());
 
74
    EXPECT_EQ(sol_null.GetZMax(), sol_null_clone.GetZMax());
 
75
    EXPECT_EQ(sol_null.GetHighestOrder(), sol_null_clone.GetHighestOrder());
 
76
    EXPECT_EQ(sol_null.GetEndFieldModel(), sol_null_clone.GetEndFieldModel());
 
77
}
 
78
 
 
79
// In all these checks, I only check that copying end_field produces something,
 
80
// never check that it is right
 
81
TEST(DerivativesSolenoidTest, TestCopyConstructorCloneEquality) {
 
82
    EndFieldModel* end = test_end_field();
 
83
    DerivativesSolenoid sol(2., 10., 11., 3, end);
 
84
 
 
85
    DerivativesSolenoid sol_copy(sol);
 
86
    EXPECT_EQ(sol.GetPeakField(), sol_copy.GetPeakField());
 
87
    EXPECT_EQ(sol.GetRMax(), sol_copy.GetRMax());
 
88
    EXPECT_EQ(sol.GetZMax(), sol_copy.GetZMax());
 
89
    EXPECT_EQ(sol.GetHighestOrder(), sol_copy.GetHighestOrder());
 
90
    EXPECT_NE(sol.GetEndFieldModel(), sol_copy.GetEndFieldModel());
 
91
    EXPECT_NE(sol_copy.GetEndFieldModel(), static_cast<EndFieldModel*>(NULL));
 
92
 
 
93
    DerivativesSolenoid sol_equ;  // force gcc not to use copy ctor
 
94
    EXPECT_EQ(sol_equ.GetHighestOrder(), 0);
 
95
    sol_equ = sol;
 
96
    EXPECT_EQ(sol.GetPeakField(), sol_equ.GetPeakField());
 
97
    EXPECT_EQ(sol.GetRMax(), sol_equ.GetRMax());
 
98
    EXPECT_EQ(sol.GetZMax(), sol_equ.GetZMax());
 
99
    EXPECT_EQ(sol.GetHighestOrder(), sol_equ.GetHighestOrder());
 
100
    EXPECT_NE(sol.GetEndFieldModel(), sol_equ.GetEndFieldModel());
 
101
    EXPECT_NE(sol_equ.GetEndFieldModel(), static_cast<EndFieldModel*>(NULL));
 
102
 
 
103
    DerivativesSolenoid& sol_clone = *sol.Clone();
 
104
    EXPECT_EQ(sol.GetPeakField(), sol_clone.GetPeakField());
 
105
    EXPECT_EQ(sol.GetRMax(), sol_clone.GetRMax());
 
106
    EXPECT_EQ(sol.GetZMax(), sol_clone.GetZMax());
 
107
    EXPECT_EQ(sol.GetHighestOrder(), sol_clone.GetHighestOrder());
 
108
    EXPECT_NE(sol.GetEndFieldModel(), sol_clone.GetEndFieldModel());
 
109
    EXPECT_NE(sol_clone.GetEndFieldModel(), static_cast<EndFieldModel*>(NULL));
 
110
}
 
111
 
 
112
std::vector<double> test_get_field_value
 
113
                      (DerivativesSolenoid& sol, double x, double y, double z) {
 
114
    double point[4] = {x, y, z, 0};
 
115
    std::vector<double> field(6);
 
116
    for (size_t i = 0; i < 6; ++i) {
 
117
        field[i] = 0.;
 
118
    }
 
119
    sol.GetFieldValue(point, &field[0]);
 
120
    return field;
 
121
}
 
122
 
 
123
TEST(DerivativesSolenoidTest, TestBoundingBox) {
 
124
    EndFieldModel* end = test_end_field();
 
125
    DerivativesSolenoid sol(2., 2., 1., 3, end);
 
126
    // centre
 
127
    EXPECT_NEAR(test_get_field_value(sol, 0., 0., 0.)[2], 2., 1e-6);
 
128
    // in bounding box
 
129
    EXPECT_GT(test_get_field_value(sol, 2.-1e-9, 0., 1.-1e-9)[2], 1e-3);
 
130
    EXPECT_GT(test_get_field_value(sol, 2.-1e-9, 0., 1.-1e-9)[0], 1e-3);
 
131
    // out of bounding box
 
132
    EXPECT_NEAR(test_get_field_value(sol, 2.-1e-9, 0., 1.+1e-9)[0], 0., 1e-12);
 
133
    EXPECT_NEAR(test_get_field_value(sol, 2.-1e-9, 0., 1.+1e-9)[2], 0., 1e-12);
 
134
    // out of bounding box
 
135
    EXPECT_NEAR(test_get_field_value(sol, 2.+1e-9, 0., 1.-1e-9)[0], 0., 1e-12);
 
136
    EXPECT_NEAR(test_get_field_value(sol, 2.+1e-9, 0., 1.-1e-9)[2], 0., 1e-12);
 
137
}
 
138
 
 
139
TEST(DerivativesSolenoidTest, TestFieldOnAxis) {
 
140
    EndFieldModel* end = test_end_field();
 
141
    DerivativesSolenoid sol(2., 2., 10., 3, end);
 
142
    for (double z = -10.; z < 10.; z+= 0.1)
 
143
      EXPECT_NEAR(
 
144
        test_get_field_value(sol, 0., 0., z)[2], end->Function(z, 0)*2., 1e-9);
 
145
}
 
146
 
 
147
TEST(DerivativesSolenoidTest, TestFieldMaxwellianness) {
 
148
    EndFieldModel* end = test_end_field();
 
149
    DerivativesSolenoid sol(2., 1.e9, 1.e9, 3, end);
 
150
    double dr = 0.001;
 
151
    double z = 1.;
 
152
    for (double r = 0.; r < 0.1; r+= dr) {
 
153
        double dbxdx = (test_get_field_value(sol, r+dr/2., 0.,     z)[0]
 
154
                       -test_get_field_value(sol, r-dr/2., 0.,     z)[0]);
 
155
        double dbydy = (test_get_field_value(sol, r,       +dr/2., z)[1]
 
156
                       -test_get_field_value(sol, r,       -dr/2., z)[1]);
 
157
        double dbzdz = (test_get_field_value(sol, r,       0.,     z+dr/2.)[2]
 
158
                       -test_get_field_value(sol, r,       0.,     z-dr/2.)[2]);
 
159
        double div_b = dbxdx+dbydy+dbzdz;
 
160
        double sum_delta_b = fabs(dbxdx)+fabs(dbydy)+fabs(dbzdz);
 
161
        // std::cerr << r << " ** " << dbxdx << " " << dbydy << " " << dbzdz
 
162
        //           << " ** " << div_b << std::endl;
 
163
        EXPECT_LT(fabs(div_b), 1e-4*sum_delta_b);
 
164
    }
 
165
}
 
166
}
 
167