Belle II Software  release-05-01-25
PlainMatrix.test.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2014 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Oliver Frost <oliver.frost@desy.de> *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 #include <tracking/trackFindingCDC/numerics/PlainMatrixUtil.h>
11 #include <tracking/trackFindingCDC/numerics/PlainMatrix.h>
12 
13 #include <tracking/trackFindingCDC/numerics/EigenView.h>
14 
15 #include <gtest/gtest.h>
16 
17 using namespace Belle2;
18 using namespace TrackFindingCDC;
19 
20 
21 TEST(TrackFindingCDCTest, PlainMatrix_zero)
22 {
24  {
25  PlainMatrix<double, 5, 5> result{{}};
26  for (int i = 0; i < result.rows(); ++i) {
27  for (int j = 0; j < result.cols(); ++j) {
28  EXPECT_EQ(0, (result(i, j)));
29  }
30  }
31  }
32 
34  {
35  auto result = PlainMatrix<double, 5, 5>::Zero();
36  for (int i = 0; i < result.rows(); ++i) {
37  for (int j = 0; j < result.cols(); ++j) {
38  EXPECT_EQ(0, (result(i, j)));
39  }
40  }
41  }
42 }
43 
44 
45 TEST(TrackFindingCDCTest, PlainMatrix_id)
46 {
48  for (int i = 0; i < result.rows(); ++i) {
49  for (int j = 0; j < result.cols(); ++j) {
50  if (i == j) {
51  EXPECT_EQ(1, (result(i, j)));
52  } else {
53  EXPECT_EQ(0, (result(i, j)));
54  }
55  }
56  }
57 }
58 
59 
60 TEST(TrackFindingCDCTest, PlainMatrix_diag)
61 {
62  PlainMatrix<double, 5, 1> diagElements{{0, 1, 2, 3, 4}};
63  auto result = PlainMatrixUtil::Diag(diagElements);
64 
65  EXPECT_EQ(5, result.cols());
66  EXPECT_EQ(5, result.rows());
67 
68  for (int i = 0; i < result.rows(); ++i) {
69  for (int j = 0; j < result.cols(); ++j) {
70  if (i == j) {
71  EXPECT_EQ(i, result(i, j));
72  } else {
73  EXPECT_EQ(0, result(i, j));
74  }
75  }
76  }
77 }
78 
79 
80 TEST(TrackFindingCDCTest, PlainMatrix_constant)
81 {
82  auto result = PlainMatrix<double, 5, 5>::Constant(3);
83  for (int i = 0; i < result.rows(); ++i) {
84  for (int j = 0; j < result.cols(); ++j) {
85  EXPECT_EQ(3, (result(i, j)));
86  }
87  }
88 }
89 
90 
91 TEST(TrackFindingCDCTest, PlainMatrix_aggregate_initialization)
92 {
93  auto result = PlainMatrix<double, 2, 1>({ -1.0, 1.0});
94  EXPECT_EQ(-1, result(0, 0));
95  EXPECT_EQ(1, result(1, 0));
96 
97  auto result2 = []() {
98  return PlainMatrix<double, 2, 1>({ -1.0, 1.0});
99  }();
100 
101  EXPECT_EQ(-1, result2(0, 0));
102  EXPECT_EQ(1, result2(1, 0));
103 }
104 
105 
106 TEST(TrackFindingCDCTest, PlainMatrix_vstack)
107 {
108 
109  auto a = PlainMatrix<double, 2, 1>({1, 2});
110  auto b = PlainMatrix<double, 3, 1>({3, 4, 5});
111 
112  auto result = PlainMatrixUtil::VStack(a, b);
113 
114  EXPECT_EQ(1, result.cols());
115  EXPECT_EQ(5, result.rows());
116 
117  EXPECT_EQ(1, result(0, 0));
118  EXPECT_EQ(2, result(1, 0));
119  EXPECT_EQ(3, result(2, 0));
120  EXPECT_EQ(4, result(3, 0));
121  EXPECT_EQ(5, result(4, 0));
122 }
123 
124 TEST(TrackFindingCDCTest, PlainMatrix_hstack)
125 {
126 
127  auto a = PlainMatrix<double, 2, 1>({1, 2});
128  auto b = PlainMatrix<double, 2, 1>({3, 4});
129 
130  auto result = PlainMatrixUtil::HStack(a, b);
131 
132  EXPECT_EQ(2, result.cols());
133  EXPECT_EQ(2, result.rows());
134 
135  EXPECT_EQ(1, result(0, 0));
136  EXPECT_EQ(2, result(1, 0));
137  EXPECT_EQ(3, result(0, 1));
138  EXPECT_EQ(4, result(1, 1));
139 }
140 
141 
142 
143 TEST(TrackFindingCDCTest, PlainMatrix_blockstack)
144 {
145 
146  auto a = PlainMatrix<double, 2, 1>({1, 2});
147  auto b = PlainMatrix<double, 3, 1>({3, 4, 5});
148 
149  auto result = PlainMatrixUtil::BlockStack(a, b);
150 
151  EXPECT_EQ(2, result.cols());
152  EXPECT_EQ(5, result.rows());
153  EXPECT_EQ(1, result(0, 0));
154  EXPECT_EQ(2, result(1, 0));
155  EXPECT_EQ(0, result(2, 0));
156  EXPECT_EQ(0, result(3, 0));
157  EXPECT_EQ(0, result(4, 0));
158 
159  EXPECT_EQ(0, result(0, 1));
160  EXPECT_EQ(0, result(1, 1));
161  EXPECT_EQ(3, result(2, 1));
162  EXPECT_EQ(4, result(3, 1));
163  EXPECT_EQ(5, result(4, 1));
164 }
165 
166 TEST(TrackFindingCDCTest, PlainMatrix_element_access)
167 {
169  a(0, 0) = 1;
170  a(1, 0) = 2;
171  a[2] = 3;
172 
173  EXPECT_EQ(1, a[0]);
174  EXPECT_EQ(2, a(1, 0));
175  EXPECT_EQ(3, a(2));
176 }
177 
178 TEST(TrackFindingCDCTest, PlainMatrix_minus)
179 {
180  auto a = PlainMatrix<double, 2, 1>({1, 2});
181  auto b = PlainMatrix<double, 2, 1>({2, 3});
182 
183  auto result = b - a;
184  for (int i = 0; i < result.rows(); ++i) {
185  for (int j = 0; j < result.cols(); ++j) {
186  EXPECT_EQ(1 , result(i, j));
187  }
188  }
189 }
190 
191 TEST(TrackFindingCDCTest, PlainMatrix_plus)
192 {
193  auto a = PlainMatrix<double, 2, 1>({1, 2});
194  auto b = PlainMatrix<double, 2, 1>({2, 1});
195 
196  auto result = b + a;
197  for (int i = 0; i < result.rows(); ++i) {
198  for (int j = 0; j < result.cols(); ++j) {
199  EXPECT_EQ(3, result(i, j));
200  }
201  }
202 }
203 
204 TEST(TrackFindingCDCTest, PlainMatrix_divide)
205 {
206  auto a = PlainMatrix<double, 2, 1>({2, 2});
207 
208  auto result = a / 2.0;
209  for (int i = 0; i < result.rows(); ++i) {
210  for (int j = 0; j < result.cols(); ++j) {
211  EXPECT_EQ(1, result(i, j));
212  }
213  }
214 }
215 
216 
217 TEST(TrackFindingCDCTest, PlainMatrix_inverse_divide)
218 {
219  auto a = PlainMatrix<double, 2, 1>({2, 2});
220 
221  auto result = 2.0 / a;
222  for (int i = 0; i < result.rows(); ++i) {
223  for (int j = 0; j < result.cols(); ++j) {
224  EXPECT_EQ(1, result(i, j));
225  }
226  }
227 }
228 
229 TEST(TrackFindingCDCTest, PlainMatrix_muliplication)
230 {
231  auto a = PlainMatrix<double, 2, 1>({2, 2});
232  auto b = PlainMatrix<double, 1, 2>({1.0 / 4.0, 1.0 / 4.0});
233 
234  auto result = b * a;
235 
236  EXPECT_EQ(1, result.cols());
237  EXPECT_EQ(1, result.rows());
238 
239  EXPECT_EQ(1, result(0, 0));
240 
241  auto result2 = a * b;
242 
243  EXPECT_EQ(2, result2.cols());
244  EXPECT_EQ(2, result2.rows());
245 
246  EXPECT_EQ(1.0 / 2.0, result2(0, 0));
247  EXPECT_EQ(1.0 / 2.0, result2(1, 0));
248  EXPECT_EQ(1.0 / 2.0, result2(0, 1));
249  EXPECT_EQ(1.0 / 2.0, result2(1, 1));
250 }
251 
252 TEST(TrackFindingCDCTest, PlainMatrix_block)
253 {
254  auto a = PlainMatrix<double, 2, 1>({1, 2});
255  auto b = PlainMatrix<double, 3, 1>({3, 4, 5});
256 
257  auto result = PlainMatrixUtil::BlockStack(a, b);
258 
259  auto aNew = result.block<2, 1>(0, 0);
260  auto bNew = result.block<3, 1>(2, 1);
261 
262  EXPECT_TRUE(std::equal(a.data(), a.data() + a.size(), aNew.data()));
263  EXPECT_TRUE(std::equal(b.data(), b.data() + b.size(), bNew.data()));
264 }
265 
266 TEST(TrackFindingCDCTest, PlainMatrixEigenMap_mapToEigen)
267 {
268  auto a = PlainMatrix<double, 2, 1>({1, 2});
269  auto b = PlainMatrix<double, 3, 1>({3, 4, 5});
270 
271  auto result = PlainMatrixUtil::BlockStack(a, b);
272  auto eigenMap = mapToEigen(result);
273 
274  for (int i = 0; i < result.rows(); ++i) {
275  for (int j = 0; j < result.cols(); ++j) {
276  EXPECT_EQ(result(i, j) , eigenMap(i, j));
277  }
278  }
279 
280  // Test write-through
281  eigenMap(0, 0) = 0;
282  EXPECT_EQ(0, eigenMap(0, 0)) << "write back test " << 0 << ", " << 0;
283  EXPECT_EQ(0, result(0, 0)) << "write back test " << 0 << ", " << 0;
284 
285  eigenMap = Eigen::Matrix<double, 5, 2>::Zero();
286 
287  for (int i = 0; i < result.rows(); ++i) {
288  for (int j = 0; j < result.cols(); ++j) {
289  EXPECT_EQ(0, result(i, j)) << "write back test " << i << ", " << j;
290  }
291  }
292 }
293 
294 TEST(TrackFindingCDCTest, PlainMatrixEigenMap_output_operator)
295 {
296  auto a = PlainMatrix<double, 2, 1>({1, 2});
297  std::stringstream oss;
298  oss << a;
299 }
Belle2::TrackFindingCDC::PlainMatrixUtil::VStack
static PlainMatrix< T, K+M, N > VStack(const PlainMatrix< T, K, N > &a, const PlainMatrix< T, M, N > &b)
Construct a matrix from two independent blocks stacked vertically.
Definition: PlainMatrixUtil.h:74
Belle2::TrackFindingCDC::PlainMatrix::Zero
static PlainMatrix< T, M, N > Zero()
Construct a matrix initialized with zeros.
Definition: PlainMatrix.h:77
Belle2::TrackFindingCDC::PlainMatrixUtil::BlockStack
static PlainMatrix< T, K+M, L+N > BlockStack(const PlainMatrix< T, K, L > &a, const PlainMatrix< T, M, N > &b)
Construct a matrix from two independent blocks stacked along the diagonal.
Definition: PlainMatrixUtil.h:45
Belle2::TrackFindingCDC::PlainMatrixUtil::HStack
static PlainMatrix< T, M, L+N > HStack(const PlainMatrix< T, M, L > &a, const PlainMatrix< T, M, N > &b)
Construct a matrix from two independent blocks stacked horizontally.
Definition: PlainMatrixUtil.h:98
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TrackFindingCDC::PlainMatrix::Constant
static PlainMatrix< T, M, N > Constant(T t)
Construct a matrix with all elements set to a constant.
Definition: PlainMatrix.h:93
Belle2::TEST
TEST(TestgetDetectorRegion, TestgetDetectorRegion)
Test Constructors.
Definition: utilityFunctions.cc:18
Belle2::TrackFindingCDC::PlainMatrixUtil::Diag
static PlainMatrix< T, M, M > Diag(const PlainMatrix< T, M, 1 > &diagEntries)
Construct a diagonal matrix - currently private as it is unused.
Definition: PlainMatrixUtil.h:34
Belle2::TrackFindingCDC::PlainMatrix::Identity
static PlainMatrix< T, M, N > Identity()
Construct an identity matrix.
Definition: PlainMatrix.h:84