diff --git a/reco/L1/CMakeLists.txt b/reco/L1/CMakeLists.txt
index f7feafae4d384c188fd91ea8fb3752054179e46a..2740dfcbd1b2b9009e11f518206685a81e331f69 100644
--- a/reco/L1/CMakeLists.txt
+++ b/reco/L1/CMakeLists.txt
@@ -141,7 +141,10 @@ L1Algo/L1EventMatch.cxx
L1Algo/L1MCEvent.cxx
L1Algo/L1Fit.cxx
CbmL1MCTrack.cxx
+L1Algo/L1MaterialInfo.cxx
+L1Algo/L1UMeasurementInfo.cxx
L1Algo/L1XYMeasurementInfo.cxx
+L1Algo/L1Field.cxx
L1Algo/L1CAIteration.cxx
L1Algo/L1BaseStationInfo.cxx
L1Algo/L1InitManager.cxx
diff --git a/reco/L1/L1Algo/L1Algo.cxx b/reco/L1/L1Algo/L1Algo.cxx
index 5b2a9dbfb08c5c3e9220fd7768aeb3b24d233a45..0fd6b67e52ce42ccbdecdf80357a5721894cfe07 100644
--- a/reco/L1/L1Algo/L1Algo.cxx
+++ b/reco/L1/L1Algo/L1Algo.cxx
@@ -212,7 +212,7 @@ void L1Algo::Init(const L1Vector<fscal>& geo, const bool UseHitErrors, const Tra
fvec By = vStations[i].fieldSlice.cy[0];
Sy += dz * sy + dz * dz * By / 2.;
sy += dz * By;
- st.Sy = Sy;
+ //st.Sy = Sy; // commented, because is not used in the code (S.Zharko)
z0 = st.z;
}
}
@@ -246,65 +246,39 @@ void L1Algo::Init(const L1Vector<fscal>& geo, const bool UseHitErrors, const Tra
fInitManager.TransferL1StationArray(fStationsNew);
- LOG(debug) << "**********************************************************************";
- LOG(debug) << "* New L1Algo initialization cross check (tmp log, to be removed!) *";
- LOG(debug) << "**********************************************************************";
- LOG(debug) << "** Number of stations (origial) **";
- LOG(debug) << "\tTotal: " << NStations;
- LOG(debug) << "\tMVD: " << NMvdStations;
- LOG(debug) << "\tSTS: " << NStsStations;
- LOG(debug) << "\tField: " << fNfieldStations;
- LOG(debug) << "** Number of stations (new) **";
- LOG(debug) << "\tTotal: " << NStationsNew;
- LOG(debug) << "\tMVD: " << NMvdStationsNew;
- LOG(debug) << "\tSTS: " << NStsStationsNew;
- LOG(debug) << "\tField: " << NfieldStationsNew;
-
- LOG(debug) << "** Magnetic field near target (original)**";
- LOG(debug) << "\tField Value: " << vtxFieldValue.x[0] << ' ' << vtxFieldValue.y[0] << ' ' << vtxFieldValue.z[0];
- LOG(debug) << "\tField Region:";
- LOG(debug) << "\t\tcx0: " << vtxFieldRegion.cx0[0];
- LOG(debug) << "\t\tcx1: " << vtxFieldRegion.cx1[0];
- LOG(debug) << "\t\tcx2: " << vtxFieldRegion.cx2[0];
- LOG(debug) << "\t\tcy0: " << vtxFieldRegion.cy0[0];
- LOG(debug) << "\t\tcy1: " << vtxFieldRegion.cy1[0];
- LOG(debug) << "\t\tcy2: " << vtxFieldRegion.cy2[0];
- LOG(debug) << "\t\tcz0: " << vtxFieldRegion.cz0[0];
- LOG(debug) << "\t\tcz1: " << vtxFieldRegion.cz1[0];
- LOG(debug) << "\t\tcz2: " << vtxFieldRegion.cz2[0];
- LOG(debug) << "\t\tz0: " << vtxFieldRegion.z0[0];
-
-
- LOG(debug) << "** Magnetic field near target (new)**";
- LOG(debug) << "\tField Value: " << vtxFieldValueNew.x[0] << ' ' << vtxFieldValueNew.y[0] << ' '
- << vtxFieldValueNew.z[0];
- LOG(debug) << "\tField Region:";
- LOG(debug) << "\t\tcx0: " << vtxFieldRegionNew.cx0[0];
- LOG(debug) << "\t\tcx1: " << vtxFieldRegionNew.cx1[0];
- LOG(debug) << "\t\tcx2: " << vtxFieldRegionNew.cx2[0];
- LOG(debug) << "\t\tcy0: " << vtxFieldRegionNew.cy0[0];
- LOG(debug) << "\t\tcy1: " << vtxFieldRegionNew.cy1[0];
- LOG(debug) << "\t\tcy2: " << vtxFieldRegionNew.cy2[0];
- LOG(debug) << "\t\tcz0: " << vtxFieldRegionNew.cz0[0];
- LOG(debug) << "\t\tcz1: " << vtxFieldRegionNew.cz1[0];
- LOG(debug) << "\t\tcz2: " << vtxFieldRegionNew.cz2[0];
- LOG(debug) << "\t\tz0: " << vtxFieldRegionNew.z0[0];
-
- LOG(debug) << "** Original L1Station array content **";
+ LOG(info) << "**********************************************************************";
+ LOG(info) << "* New L1Algo initialization cross check (tmp log, to be removed!) *";
+ LOG(info) << "**********************************************************************";
+ LOG(info) << "** Number of stations (origial) **";
+ LOG(info) << "\tTotal: " << NStations;
+ LOG(info) << "\tMVD: " << NMvdStations;
+ LOG(info) << "\tSTS: " << NStsStations;
+ LOG(info) << "\tField: " << fNfieldStations;
+ LOG(info) << "** Number of stations (new) **";
+ LOG(info) << "\tTotal: " << NStationsNew;
+ LOG(info) << "\tMVD: " << NMvdStationsNew;
+ LOG(info) << "\tSTS: " << NStsStationsNew;
+ LOG(info) << "\tField: " << NfieldStationsNew;
+
+ LOG(info) << "** Magnetic field near target (original)**";
+ LOG(info) << "\tField Value: " << '\n' << vtxFieldValue.ToString(/*indent = */ 1) << '\n';
+ LOG(info) << "\tField Region: " << '\n' << vtxFieldRegion.ToString(/*indent = */ 1) << '\n';
+
+ LOG(info) << "** Magnetic field near target (new)**";
+ LOG(info) << "\tField Value: " << '\n' << vtxFieldValueNew.ToString(/*indent = */ 1) << '\n';
+ LOG(info) << "\tField Region: " << '\n' << vtxFieldRegionNew.ToString(/*indent = */ 1) << '\n';
+
+ LOG(info) << "** Original L1Station array content **";
int nStations = fInitManager.GetStationsNumber();
- for (const auto& aStation : vStations) {
- int idx = &aStation - vStations;
- if (idx == nStations) { break; }
- LOG(debug) << "Station Global No: " << idx;
- aStation.Print();
+ for (int iSt = 0; iSt < nStations; ++iSt) {
+ LOG(info) << "Station Global No: " << iSt;
+ LOG(info) << '\n' << vStations[iSt].ToString(/*verbosity = */ 3);
}
- LOG(debug) << "** New L1Station array content **";
+ LOG(info) << "** New L1Station array content **";
nStations = fInitManager.GetStationsNumber();
- for (const auto& aStation : fStationsNew) {
- int idx = &aStation - &fStationsNew.front();
- if (idx == nStations) { break; }
- LOG(debug) << "Station Global No: " << idx;
- aStation.Print();
+ for (int iSt = 0; iSt < nStations; ++iSt) {
+ LOG(info) << "Station Global No: " << iSt;
+ LOG(info) << '\n' << fStationsNew[iSt].ToString(/*verbosity = */ 3);
}
}
diff --git a/reco/L1/L1Algo/L1BaseStationInfo.cxx b/reco/L1/L1Algo/L1BaseStationInfo.cxx
index 5025369a6c74186189d2a5379afd0cb8fa2c5594..81ebddd8ad04253ef964b0b490af4879dfc50287 100644
--- a/reco/L1/L1Algo/L1BaseStationInfo.cxx
+++ b/reco/L1/L1Algo/L1BaseStationInfo.cxx
@@ -23,6 +23,7 @@
// C++ STL
#include <iomanip>
+#include <sstream>
#include <utility>
//
@@ -428,3 +429,28 @@ void L1BaseStationInfo::SetYmax(double aSize)
fYmax = aSize;
fInitFlags[keYmax] = true;
}
+
+//----------------------------------------------------------------------------------------------------------------------//
+//
+std::string L1BaseStationInfo::ToString(int verbosityLevel, int indentLevel) const
+{
+ std::stringstream aStream {};
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+
+ if (verbosityLevel == 0) {
+ aStream << indent << "L1BaseStationInfo object: {stationID, detectorID, address} = {" << fStationID << ", "
+ << static_cast<int>(fDetectorID) << ", " << this << '}';
+ }
+ else if (verbosityLevel > 0) {
+ aStream << indent << "L1BaseStationInfo object: at " << this << '\n';
+ aStream << indent << indentChar << "Station ID: " << fStationID << '\n';
+ aStream << indent << indentChar << "Detector ID: " << static_cast<int>(fDetectorID) << '\n';
+ aStream << indent << indentChar << "L1Station object:" << '\n';
+ aStream << fL1Station.ToString(verbosityLevel - 1, indentLevel + 1) << '\n';
+ aStream << indent << indentChar << "Additional fields:\n";
+ aStream << indent << indentChar << indentChar << "Xmax: " << fXmax << '\n';
+ aStream << indent << indentChar << indentChar << "Ymax: " << fYmax << '\n';
+ }
+ return aStream.str();
+}
diff --git a/reco/L1/L1Algo/L1BaseStationInfo.h b/reco/L1/L1Algo/L1BaseStationInfo.h
index 5c81b707cc8f1e0b4fa8df7a55ccb4d4adb12671..17f511e2548216dc9b6b061024c55998bcef2b5e 100644
--- a/reco/L1/L1Algo/L1BaseStationInfo.h
+++ b/reco/L1/L1Algo/L1BaseStationInfo.h
@@ -18,6 +18,7 @@
// C++ std
#include <bitset>
#include <functional>
+#include <string>
#include "L1Station.h"
@@ -187,6 +188,9 @@ public:
void SetXmax(double aSize);
/// Sets maximum distance between station center and its edge in y direction
void SetYmax(double aSize);
+ /// String representation of class contents
+ /// \param indentLevel number of indent characters in the output
+ std::string ToString(int verbosityLevel = 0, int indentLevel = 0) const;
private:
L1DetectorID fDetectorID {static_cast<L1DetectorID>(0)}; ///< Detector ID
diff --git a/reco/L1/L1Algo/L1Field.cxx b/reco/L1/L1Algo/L1Field.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..c7c3f83c0b127f2a86c4360de8d08e3e30a95ab2
--- /dev/null
+++ b/reco/L1/L1Algo/L1Field.cxx
@@ -0,0 +1,297 @@
+/* Copyright (C) 2007-2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Sergey Gorbunov, Sergei Zharko [committer] */
+
+#include "L1Field.h"
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+//
+// L1FieldValue methods
+//
+
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldValue::Combine(L1FieldValue& B, fvec w)
+{
+ x += w * (B.x - x);
+ y += w * (B.y - y);
+ z += w * (B.z - z);
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO:
+std::string L1FieldValue::ToString(int indentLevel) const
+{
+ std::stringstream aStream {};
+ // TODO: possibly it is better to place the indentChar into L1Parameters (S.Zharko)
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ aStream << indent << "Bx [kG]: " << std::setw(12) << std::setfill(' ') << x[0] << '\n';
+ aStream << indent << "By [kG]: " << std::setw(12) << std::setfill(' ') << y[0] << '\n';
+ aStream << indent << "Bz [kG]: " << std::setw(12) << std::setfill(' ') << z[0];
+ return aStream.str();
+}
+
+std::ostream& operator<<(std::ostream& out, const L1FieldValue& B)
+{
+ return out << B.x[0] << " | " << B.y[0] << " | " << B.z[0];
+};
+
+//
+// L1FieldSlice methods
+//
+
+//----------------------------------------------------------------------------------------------------------------------
+//
+L1FieldSlice::L1FieldSlice() noexcept
+{
+ for (int i = 0; i < L1Parameters::kMaxNFieldApproxCoefficients; ++i) {
+ cx[i] = 0.f;
+ cy[i] = 0.f;
+ cz[i] = 0.f;
+ }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldSlice::GetFieldValue(const fvec& x, const fvec& y, L1FieldValue& B) const
+{
+ fvec x2 = x * x;
+ fvec y2 = y * y;
+ fvec xy = x * y;
+
+ fvec x3 = x2 * x;
+ fvec y3 = y2 * y;
+ fvec xy2 = x * y2;
+ fvec x2y = x2 * y;
+
+ fvec x4 = x3 * x;
+ fvec y4 = y3 * y;
+ fvec xy3 = x * y3;
+ fvec x2y2 = x2 * y2;
+ fvec x3y = x3 * y;
+
+ fvec x5 = x4 * x;
+ fvec y5 = y4 * y;
+ fvec xy4 = x * y4;
+ fvec x2y3 = x2 * y3;
+ fvec x3y2 = x3 * y2;
+ fvec x4y = x4 * y;
+
+ B.x = cx[0] + cx[1] * x + cx[2] * y + cx[3] * x2 + cx[4] * xy + cx[5] * y2 + cx[6] * x3 + cx[7] * x2y + cx[8] * xy2
+ + cx[9] * y3 + cx[10] * x4 + cx[11] * x3y + cx[12] * x2y2 + cx[13] * xy3 + cx[14] * y4 + cx[15] * x5
+ + cx[16] * x4y + cx[17] * x3y2 + cx[18] * x2y3 + cx[19] * xy4 + cx[20] * y5;
+
+ B.y = cy[0] + cy[1] * x + cy[2] * y + cy[3] * x2 + cy[4] * xy + cy[5] * y2 + cy[6] * x3 + cy[7] * x2y + cy[8] * xy2
+ + cy[9] * y3 + cy[10] * x4 + cy[11] * x3y + cy[12] * x2y2 + cy[13] * xy3 + cy[14] * y4 + cy[15] * x5
+ + cy[16] * x4y + cy[17] * x3y2 + cy[18] * x2y3 + cy[19] * xy4 + cy[20] * y5;
+
+ B.z = cz[0] + cz[1] * x + cz[2] * y + cz[3] * x2 + cz[4] * xy + cz[5] * y2 + cz[6] * x3 + cz[7] * x2y + cz[8] * xy2
+ + cz[9] * y3 + cz[10] * x4 + cz[11] * x3y + cz[12] * x2y2 + cz[13] * xy3 + cz[14] * y4 + cz[15] * x5
+ + cz[16] * x4y + cz[17] * x3y2 + cz[18] * x2y3 + cz[19] * xy4 + cz[20] * y5;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+//
+std::string L1FieldSlice::ToString(int indentLevel) const
+{
+ std::stringstream aStream {};
+ // TODO: possibly it is better to place the indentChar into L1Parameters (S.Zharko)
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ aStream << indent << "idx CX CY CZ";
+ for (int i = 0; i < L1Parameters::kMaxNFieldApproxCoefficients; ++i) {
+ aStream << '\n' << indent;
+ aStream << std::setw(3) << std::setfill(' ') << i << ' ';
+ aStream << std::setw(12) << std::setfill(' ') << cx[i][0] << ' ';
+ aStream << std::setw(12) << std::setfill(' ') << cy[i][0] << ' ';
+ aStream << std::setw(12) << std::setfill(' ') << cz[i][0];
+ }
+ return aStream.str();
+}
+
+//
+// L1FieldRegion methdos
+//
+
+//----------------------------------------------------------------------------------------------------------------------
+//
+L1FieldRegion::L1FieldRegion(float reg[10]) noexcept
+ : cx0(reg[0])
+ , cx1(reg[1])
+ , cx2(reg[2])
+ , cy0(reg[3])
+ , cy1(reg[4])
+ , cy2(reg[5])
+ , cz0(reg[6])
+ , cz1(reg[7])
+ , cz2(reg[8])
+ , z0(reg[9])
+{
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+L1FieldValue L1FieldRegion::Get(const fvec z)
+{
+ fvec dz = (z - z0);
+ fvec dz2 = dz * dz;
+ L1FieldValue B;
+ B.x = cx0 + cx1 * dz + cx2 * dz2;
+ B.y = cy0 + cy1 * dz + cy2 * dz2;
+ B.z = cz0 + cz1 * dz + cz2 * dz2;
+ return B;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldRegion::Get(const fvec z_, fvec* B) const
+{
+ fvec dz = (z_ - z0);
+ fvec dz2 = dz * dz;
+ B[0] = cx0 + cx1 * dz + cx2 * dz2;
+ B[1] = cy0 + cy1 * dz + cy2 * dz2;
+ B[2] = cz0 + cz1 * dz + cz2 * dz2;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldRegion::Set(const L1FieldValue& b0, const fvec b0z, const L1FieldValue& b1, const fvec b1z,
+ const L1FieldValue& b2, const fvec b2z)
+{
+ z0 = b0z;
+ fvec dz1 = b1z - b0z, dz2 = b2z - b0z;
+ fvec det = rcp(fvec(dz1 * dz2 * (dz2 - dz1)));
+ fvec w21 = -dz2 * det;
+ fvec w22 = dz1 * det;
+ fvec w11 = -dz2 * w21;
+ fvec w12 = -dz1 * w22;
+
+ fvec db1 = b1.x - b0.x;
+ fvec db2 = b2.x - b0.x;
+ cx0 = b0.x;
+ cx1 = db1 * w11 + db2 * w12;
+ cx2 = db1 * w21 + db2 * w22;
+
+ db1 = b1.y - b0.y;
+ db2 = b2.y - b0.y;
+ cy0 = b0.y;
+ cy1 = db1 * w11 + db2 * w12;
+ cy2 = db1 * w21 + db2 * w22;
+
+ db1 = b1.z - b0.z;
+ db2 = b2.z - b0.z;
+ cz0 = b0.z;
+ cz1 = db1 * w11 + db2 * w12;
+ cz2 = db1 * w21 + db2 * w22;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldRegion::Set(const L1FieldValue& b0, const fvec b0z, const L1FieldValue& b1, const fvec b1z)
+{
+ z0 = b0z[0];
+ fvec dzi = rcp(fvec(b1z - b0z));
+ cx0 = b0.x;
+ cy0 = b0.y;
+ cz0 = b0.z;
+ cx1 = (b1.x - b0.x) * dzi;
+ cy1 = (b1.y - b0.y) * dzi;
+ cz1 = (b1.z - b0.z) * dzi;
+ cx2 = 0.f;
+ cy2 = 0.f;
+ cz2 = 0.f;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldRegion::Shift(fvec z)
+{
+ fvec dz = z - z0;
+ fvec cx2dz = cx2 * dz;
+ fvec cy2dz = cy2 * dz;
+ fvec cz2dz = cz2 * dz;
+ z0 = z[0];
+ cx0 += (cx1 + cx2dz) * dz;
+ cy0 += (cy1 + cy2dz) * dz;
+ cz0 += (cz1 + cz2dz) * dz;
+ cx1 += cx2dz + cx2dz;
+ cy1 += cy2dz + cy2dz;
+ cz1 += cz2dz + cz2dz;
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldRegion::SetOneEntry(const int i0, const L1FieldRegion& f1, const int i1)
+{
+ cx0[i0] = f1.cx0[i1];
+ cx1[i0] = f1.cx1[i1];
+ cx2[i0] = f1.cx2[i1];
+ cy0[i0] = f1.cy0[i1];
+ cy1[i0] = f1.cy1[i1];
+ cy2[i0] = f1.cy2[i1];
+ cz0[i0] = f1.cz0[i1];
+ cz1[i0] = f1.cz1[i1];
+ cz2[i0] = f1.cz2[i1];
+ z0[i0] = f1.z0[i1];
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldRegion::SetOneEntry(const L1FieldRegion& f1, const int i1)
+{
+ cx0 = f1.cx0[i1];
+ cx1 = f1.cx1[i1];
+ cx2 = f1.cx2[i1];
+ cy0 = f1.cy0[i1];
+ cy1 = f1.cy1[i1];
+ cy2 = f1.cy2[i1];
+ cz0 = f1.cz0[i1];
+ cz1 = f1.cz1[i1];
+ cz2 = f1.cz2[i1];
+ z0 = f1.z0[i1];
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+// TODO: Should it be inline? (S.Zharko)
+void L1FieldRegion::GetOneEntry(float reg[10], const int iVec)
+{
+ reg[0] = cx0[iVec];
+ reg[1] = cx1[iVec];
+ reg[2] = cx2[iVec];
+ reg[3] = cy0[iVec];
+ reg[4] = cy1[iVec];
+ reg[5] = cy2[iVec];
+ reg[6] = cz0[iVec];
+ reg[7] = cz1[iVec];
+ reg[8] = cz2[iVec];
+ reg[9] = z0[iVec];
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+//
+std::string L1FieldRegion::ToString(int indentLevel) const
+{
+ std::stringstream aStream {};
+ // TODO: possibly it is better to place the indentChar into L1Parameters (S.Zharko)
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ aStream << indent << "Bx(z) [kG] components: " << '\n';
+ aStream << indent << indentChar << "cx0: " << cx0 << '\n';
+ aStream << indent << indentChar << "cx1: " << cx1 << '\n';
+ aStream << indent << indentChar << "cx2: " << cx2 << '\n';
+ aStream << indent << "By(z) [kG] components: " << '\n';
+ aStream << indent << indentChar << "cy0: " << cy0 << '\n';
+ aStream << indent << indentChar << "cy1: " << cy1 << '\n';
+ aStream << indent << indentChar << "cy2: " << cy2 << '\n';
+ aStream << indent << "Bz(z) [kG] components: " << '\n';
+ aStream << indent << indentChar << "cz0: " << cz0 << '\n';
+ aStream << indent << indentChar << "cz1: " << cz1 << '\n';
+ aStream << indent << indentChar << "cz2: " << cz2 << '\n';
+ aStream << indent << "z0 [cm]: " << z0;
+ return aStream.str();
+}
diff --git a/reco/L1/L1Algo/L1Field.h b/reco/L1/L1Algo/L1Field.h
index c417dd86ce56cab3d0978de3720d0e368348bcae..3c0527548a6205d4570815696a4695f9c2ab51f4 100644
--- a/reco/L1/L1Algo/L1Field.h
+++ b/reco/L1/L1Algo/L1Field.h
@@ -5,234 +5,126 @@
#ifndef L1Field_h
#define L1Field_h 1
-#include <iostream>
+#include <string>
#include "L1Def.h"
#include "L1Parameters.h"
-using std::cout;
-using std::endl;
-using std::ostream;
-
-
class L1FieldValue {
-
-
public:
- L1FieldValue() : x(0), y(0), z(0) {};
-
- fvec x, y, z;
-
- void Combine(L1FieldValue& B, fvec w)
- {
- x += w * (B.x - x);
- y += w * (B.y - y);
- z += w * (B.z - z);
- }
-
- friend ostream& operator<<(ostream& out, L1FieldValue& B)
- {
- return out << B.x[0] << " | " << B.y[0] << " | " << B.z[0];
- };
+ fvec x {0.f}; //< x-component of the field
+ fvec y {0.f}; //< y-component of the field
+ fvec z {0.f}; //< z-component of the field
+
+ /// Combines the magnetic field with another field value object using weight
+ /// \param B other field value to combine with
+ /// \param w weight from 0 to 1 // TODO: Do we need any checks here? (S.Zharko)
+ void Combine(L1FieldValue& B, fvec w); // TODO: Shouldn't the B parameter be const? (S.Zharko)
+ /// Operator << overloading
+ friend std::ostream& operator<<(std::ostream& out, const L1FieldValue& B);
+ /// String representation of class contents
+ /// \param indentLevel number of indent characters in the output
+ std::string ToString(int indentLevel) const;
} _fvecalignment;
+/// Class represents a set of magnetic field approximation coefficients
+///
+// TODO: Crosscheck the default content (S.Zharko)
class L1FieldSlice {
-
public:
- fvec cx[L1Parameters::kMaxNFieldApproxCoefficients];
- fvec cy[L1Parameters::kMaxNFieldApproxCoefficients];
- fvec cz[L1Parameters::kMaxNFieldApproxCoefficients]; // polinom coeff.
+ L1FieldSlice() noexcept;
+ /// Gets field value from (x, y) fvec point
+ /// \param x x-coordinate of input
+ /// \param y y-coordinate of input
+ /// \param B the L1FieldValue output
+ void GetFieldValue(const fvec& x, const fvec& y, L1FieldValue& B) const;
+ /// String representation of class contents
+ /// \param indentLevel number of indent characters in the output
+ std::string ToString(int indentLevel = 0) const;
- L1FieldSlice()
- {
- for (int i = 0; i < L1Parameters::kMaxNFieldApproxCoefficients; ++i)
- cx[i] = cy[i] = cz[i] = 0;
- }
-
- void GetFieldValue(const fvec& x, const fvec& y, L1FieldValue& B) const
- {
- fvec x2 = x * x;
- fvec y2 = y * y;
- fvec xy = x * y;
-
- fvec x3 = x2 * x;
- fvec y3 = y2 * y;
- fvec xy2 = x * y2;
- fvec x2y = x2 * y;
-
- fvec x4 = x3 * x;
- fvec y4 = y3 * y;
- fvec xy3 = x * y3;
- fvec x2y2 = x2 * y2;
- fvec x3y = x3 * y;
-
- fvec x5 = x4 * x;
- fvec y5 = y4 * y;
- fvec xy4 = x * y4;
- fvec x2y3 = x2 * y3;
- fvec x3y2 = x3 * y2;
- fvec x4y = x4 * y;
-
- B.x = cx[0] + cx[1] * x + cx[2] * y + cx[3] * x2 + cx[4] * xy + cx[5] * y2 + cx[6] * x3 + cx[7] * x2y + cx[8] * xy2
- + cx[9] * y3 + cx[10] * x4 + cx[11] * x3y + cx[12] * x2y2 + cx[13] * xy3 + cx[14] * y4 + cx[15] * x5
- + cx[16] * x4y + cx[17] * x3y2 + cx[18] * x2y3 + cx[19] * xy4 + cx[20] * y5;
-
- B.y = cy[0] + cy[1] * x + cy[2] * y + cy[3] * x2 + cy[4] * xy + cy[5] * y2 + cy[6] * x3 + cy[7] * x2y + cy[8] * xy2
- + cy[9] * y3 + cy[10] * x4 + cy[11] * x3y + cy[12] * x2y2 + cy[13] * xy3 + cy[14] * y4 + cy[15] * x5
- + cy[16] * x4y + cy[17] * x3y2 + cy[18] * x2y3 + cy[19] * xy4 + cy[20] * y5;
-
- B.z = cz[0] + cz[1] * x + cz[2] * y + cz[3] * x2 + cz[4] * xy + cz[5] * y2 + cz[6] * x3 + cz[7] * x2y + cz[8] * xy2
- + cz[9] * y3 + cz[10] * x4 + cz[11] * x3y + cz[12] * x2y2 + cz[13] * xy3 + cz[14] * y4 + cz[15] * x5
- + cz[16] * x4y + cz[17] * x3y2 + cz[18] * x2y3 + cz[19] * xy4 + cz[20] * y5;
- }
+public:
+ // NOTE: We don't use an initialization of arrays here because we cannot be sure
+ // if the underlying type (fvec) has a default constructor, but
+ // we are sure, that it can be initialized with a float. (S.Zharko)
+ fvec cx[L1Parameters::kMaxNFieldApproxCoefficients]; ///< Polynomial coefficients for x-component of the field value
+ fvec cy[L1Parameters::kMaxNFieldApproxCoefficients]; ///< Polynomial coefficients for y-component of the field value
+ fvec cz[L1Parameters::kMaxNFieldApproxCoefficients]; ///< Polynomial coefficients for z-component of the field value
} _fvecalignment;
class L1FieldRegion {
-
public:
- L1FieldRegion() : cx0(0), cx1(0), cx2(0), cy0(0), cy1(0), cy2(0), cz0(0), cz1(0), cz2(0), z0(0) {}
-
- L1FieldRegion(float reg[10])
- : cx0(reg[0])
- , cx1(reg[1])
- , cx2(reg[2])
- , cy0(reg[3])
- , cy1(reg[4])
- , cy2(reg[5])
- , cz0(reg[6])
- , cz1(reg[7])
- , cz2(reg[8])
- , z0(reg[9])
- {
- }
-
- fvec cx0, cx1, cx2; // Bx(z) = cx0 + cx1*(z-z0) + cx2*(z-z0)^2
- fvec cy0, cy1, cy2; // By(z) = cy0 + cy1*(z-z0) + cy2*(z-z0)^2
- fvec cz0, cz1, cz2; // Bz(z) = cz0 + cz1*(z-z0) + cz2*(z-z0)^2
- fvec z0;
-
- L1FieldValue Get(const fvec z)
- {
- fvec dz = (z - z0);
- fvec dz2 = dz * dz;
- L1FieldValue B;
- B.x = cx0 + cx1 * dz + cx2 * dz2;
- B.y = cy0 + cy1 * dz + cy2 * dz2;
- B.z = cz0 + cz1 * dz + cz2 * dz2;
- return B;
- }
-
- void Get(const fvec z_, fvec* B) const
- {
- fvec dz = (z_ - z0);
- fvec dz2 = dz * dz;
- B[0] = cx0 + cx1 * dz + cx2 * dz2;
- B[1] = cy0 + cy1 * dz + cy2 * dz2;
- B[2] = cz0 + cz1 * dz + cz2 * dz2;
- }
-
+ // NOTE: When a custom constructor is defined, default constructor also should be provided (S.Zharko)
+ L1FieldRegion() = default;
+ L1FieldRegion(float reg[10]) noexcept;
+
+ /// Gets the field vector at z
+ // TODO: Probably we need a const specifier here, because the method does not change the fields
+ L1FieldValue Get(const fvec z);
+ /// Gets the field vector and writes it into B pointer
+ /// \param z_ z-coordinate of the point to calculate the field
+ /// \param B pointer to the output fvec array of the magnetic field
+ void Get(const fvec z_, fvec* B) const;
+ /// Interpolates the magnetic field by three nodal points and sets the result to this L1FieldRegion object
+ /// The result is a quadratic interpolation of the field as a function of z
+ /// \param b0 field value in the first nodal point
+ /// \param b0z z-coordinate of the first nodal point
+ /// \param b1 field value in the second nodal point
+ /// \param b1z z-coordinate of the second nodal point
+ /// \param b2 field value in the third nodal point
+ /// \param b2z z-coordinate of the third nodal point
+ /// TODO: does the sequence of b0z, b1z and b2z matter? If yes, probalby we need an assertion (S.Zharko)
void Set(const L1FieldValue& b0, const fvec b0z, const L1FieldValue& b1, const fvec b1z, const L1FieldValue& b2,
- const fvec b2z)
- {
- z0 = b0z;
- fvec dz1 = b1z - b0z, dz2 = b2z - b0z;
- fvec det = rcp(fvec(dz1 * dz2 * (dz2 - dz1)));
- fvec w21 = -dz2 * det;
- fvec w22 = dz1 * det;
- fvec w11 = -dz2 * w21;
- fvec w12 = -dz1 * w22;
-
- fvec db1 = b1.x - b0.x;
- fvec db2 = b2.x - b0.x;
- cx0 = b0.x;
- cx1 = db1 * w11 + db2 * w12;
- cx2 = db1 * w21 + db2 * w22;
-
- db1 = b1.y - b0.y;
- db2 = b2.y - b0.y;
- cy0 = b0.y;
- cy1 = db1 * w11 + db2 * w12;
- cy2 = db1 * w21 + db2 * w22;
+ const fvec b2z);
+ /// Interpolates the magnetic field by thwo nodal points and sets the result to this L1FieldRegion object.
+ /// The result is a linear interpolation of the field as a function of z
+ /// \param b0 field value in the first nodal point
+ /// \param b0z z-coordinate of the first nodal point
+ /// \param b1 field value in the second nodal point
+ /// \param b1z z-coordinate of the second nodal point
+ /// TODO: does the sequence of b0z and b1z matter? If yes, probalby we need an assertion (S.Zharko)
+ void Set(const L1FieldValue& b0, const fvec b0z, const L1FieldValue& b1, const fvec b1z);
+ /// Shifts the coefficients to new central point
+ /// \param z z-coordinate of the new central point
+ void Shift(fvec z);
+ /// Replaces the selected layer of the coefficients with one from another
+ /// L1FieldRegion object
+ /// \param i0 the index of the fvect layer in this L1FieldRegion object
+ /// \param fl the other L1FieldRegion object, which layer is going to be replaced
+ /// \param i1 the index of the source fvect layer to copy
+ void SetOneEntry(const int i0, const L1FieldRegion& f1, const int i1);
+ /// Replaces all the layers of the coefficients with one selected layer from another
+ /// L1FieldRegion object
+ /// \param fl the other L1FieldRegion object, which layer is going to be replaced
+ /// \param i1 the index of the source fvect layer to copy
+ void SetOneEntry(const L1FieldRegion& f1, const int i1);
+ /// Saves the contents of the particular layer of the coefficients into an array of floats
+ /// \param reg output array of 10 floats
+ /// \param iVec index of the input
+ // TODO: Probably, it would be better to rename "reg" into "output" and make it the second
+ // parameter of this function (S.Zharko)
+ // TODO: Probably we need a const specifier here, because the method does not change the fields
+ void GetOneEntry(float reg[10], const int iVec);
+ /// String representation of class contents
+ /// \param indentLevel number of indent characters in the output
+ std::string ToString(int indentLevel = 0) const;
- db1 = b1.z - b0.z;
- db2 = b2.z - b0.z;
- cz0 = b0.z;
- cz1 = db1 * w11 + db2 * w12;
- cz2 = db1 * w21 + db2 * w22;
- }
-
- void Set(const L1FieldValue& b0, const fvec b0z, const L1FieldValue& b1, const fvec b1z)
- {
- z0 = b0z[0];
- fvec dzi = rcp(fvec(b1z - b0z));
- cx0 = b0.x;
- cy0 = b0.y;
- cz0 = b0.z;
- cx1 = (b1.x - b0.x) * dzi;
- cy1 = (b1.y - b0.y) * dzi;
- cz1 = (b1.z - b0.z) * dzi;
- cx2 = cy2 = cz2 = 0;
- }
-
- void Shift(fvec z)
- {
- fvec dz = z - z0;
- fvec cx2dz = cx2 * dz;
- fvec cy2dz = cy2 * dz;
- fvec cz2dz = cz2 * dz;
- z0 = z[0];
- cx0 += (cx1 + cx2dz) * dz;
- cy0 += (cy1 + cy2dz) * dz;
- cz0 += (cz1 + cz2dz) * dz;
- cx1 += cx2dz + cx2dz;
- cy1 += cy2dz + cy2dz;
- cz1 += cz2dz + cz2dz;
- }
-
- void SetOneEntry(const int i0, const L1FieldRegion& f1, const int i1)
- {
- cx0[i0] = f1.cx0[i1];
- cx1[i0] = f1.cx1[i1];
- cx2[i0] = f1.cx2[i1];
- cy0[i0] = f1.cy0[i1];
- cy1[i0] = f1.cy1[i1];
- cy2[i0] = f1.cy2[i1];
- cz0[i0] = f1.cz0[i1];
- cz1[i0] = f1.cz1[i1];
- cz2[i0] = f1.cz2[i1];
- z0[i0] = f1.z0[i1];
- }
-
- void SetOneEntry(const L1FieldRegion& f1, const int i1)
- {
- cx0 = f1.cx0[i1];
- cx1 = f1.cx1[i1];
- cx2 = f1.cx2[i1];
- cy0 = f1.cy0[i1];
- cy1 = f1.cy1[i1];
- cy2 = f1.cy2[i1];
- cz0 = f1.cz0[i1];
- cz1 = f1.cz1[i1];
- cz2 = f1.cz2[i1];
- z0 = f1.z0[i1];
- }
-
- void GetOneEntry(float reg[10], const int iVec)
- {
- reg[0] = cx0[iVec];
- reg[1] = cx1[iVec];
- reg[2] = cx2[iVec];
- reg[3] = cy0[iVec];
- reg[4] = cy1[iVec];
- reg[5] = cy2[iVec];
- reg[6] = cz0[iVec];
- reg[7] = cz1[iVec];
- reg[8] = cz2[iVec];
- reg[9] = z0[iVec];
- }
+public:
+ // TODO: Probably it's better to have arrays instead of separate fvec values? (S.Zharko)
+ // Bx(z) = cx0 + cx1*(z-z0) + cx2*(z-z0)^2
+ fvec cx0 {0.f};
+ fvec cx1 {0.f};
+ fvec cx2 {0.f};
+ // By(z) = cy0 + cy1*(z-z0) + cy2*(z-z0)^2
+ fvec cy0 {0.f};
+ fvec cy1 {0.f};
+ fvec cy2 {0.f};
+ // Bz(z) = cz0 + cz1*(z-z0) + cz2*(z-z0)^2
+ fvec cz0 {0.f};
+ fvec cz1 {0.f};
+ fvec cz2 {0.f};
+ fvec z0 {0.f}; ///< z-coordinate of the field region central point
} _fvecalignment;
-
#endif
diff --git a/reco/L1/L1Algo/L1InitManager.cxx b/reco/L1/L1Algo/L1InitManager.cxx
index 8fa77643efebb317e95782519a30c387115d28ab..9a867b145fe2a77bf0b4d686cac7f4145c20d2cb 100644
--- a/reco/L1/L1Algo/L1InitManager.cxx
+++ b/reco/L1/L1Algo/L1InitManager.cxx
@@ -51,7 +51,7 @@ void L1InitManager::AddStation(const L1BaseStationInfo& inStation)
if (!isStationInitialized) {
LOG(debug) << "L1InitManager::AddStation: station init flags (original)" << inStation.GetInitFlags();
LOG(debug) << "L1InitManager::AddStation: station init flags (copy) " << inStation.GetInitFlags();
- LOG(error) << "L1InitManager::AddStation: Trying to add incompletely initialized object with detectorID = "
+ LOG(error) << "L1InitManager::AddStation: attempt to add incompletely initialized object with detectorID = "
<< static_cast<int>(inStationCopy.GetDetectorID())
<< " and stationID = " << inStationCopy.GetStationID();
assert((isStationInitialized));
diff --git a/reco/L1/L1Algo/L1MaterialInfo.cxx b/reco/L1/L1Algo/L1MaterialInfo.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..6c778f20fab3cd8f8dc586f9c8d78ad2b8efe7ac
--- /dev/null
+++ b/reco/L1/L1Algo/L1MaterialInfo.cxx
@@ -0,0 +1,22 @@
+/* Copyright (C) 2007-2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+ SPDX-License-Identifier: GPL-3.0-only
+ Authors: Sergey Gorbunov, Sergei Zharko [committer] */
+
+#include "L1MaterialInfo.h"
+
+#include <iomanip>
+#include <sstream>
+#include <vector>
+
+std::string L1MaterialInfo::ToString(int indentLevel) const
+{
+ std::stringstream aStream {};
+ // TODO: possibly it is better to place indentChar into L1Parameters (S.Zharko)
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ aStream << indent << "Thickness (X) [??]: " << std::setw(12) << std::setfill(' ') << thick[0] << '\n';
+ aStream << indent << "Radiational length (X0) [??]:" << std::setw(12) << std::setfill(' ') << RL[0] << '\n';
+ aStream << indent << "X/X0: " << std::setw(12) << std::setfill(' ') << RadThick[0] << '\n';
+ aStream << indent << "log(X/X0): " << std::setw(12) << std::setfill(' ') << logRadThick[0];
+ return aStream.str();
+}
diff --git a/reco/L1/L1Algo/L1MaterialInfo.h b/reco/L1/L1Algo/L1MaterialInfo.h
index 7eb96b76dc00629eaed506ca03a471c23dafed28..c8e15067826e3375ed49eb55acf453ac470b9cd8 100644
--- a/reco/L1/L1Algo/L1MaterialInfo.h
+++ b/reco/L1/L1Algo/L1MaterialInfo.h
@@ -5,6 +5,8 @@
#ifndef L1MaterialInfo_h
#define L1MaterialInfo_h
+#include <iomanip>
+#include <sstream>
#include <string>
#include <vector>
@@ -17,10 +19,16 @@ public:
fvec RadThick {0};
fvec logRadThick {0};
- std::string
+ /// String representation of class contents
+ /// \param indentLevel number of indent characters in the output
+ std::string ToString(int indentLevel = 0) const;
} _fvecalignment;
+// TODO: Probably one should refactor this class:
+// 1) Make MBins and RMax private
+// 2) Replace std::vector<std::vector<float>> with std::vector<float> (using recalculation of (i,j) into one idx)
+// (S.Zharko)
class L1Material {
public:
L1Material() : table(0), NBins(0), RMax(0.), iD(0.) {};
diff --git a/reco/L1/L1Algo/L1Station.cxx b/reco/L1/L1Algo/L1Station.cxx
index ed52627737337b91d2c5798cc7df83945fcf7088..24195990585b5be2e041992e793e1cb05066866b 100644
--- a/reco/L1/L1Algo/L1Station.cxx
+++ b/reco/L1/L1Algo/L1Station.cxx
@@ -7,6 +7,7 @@
#include <FairLogger.h>
#include <iomanip>
+#include <sstream>
// TODO: Improve log style (S.Zh.)
void L1Station::Print(int verbosity) const
@@ -54,3 +55,38 @@ void L1Station::Print(int verbosity) const
LOG(info) << "\t\t\t\tsigma2: " << yInfo.sigma2[0];
}
}
+
+std::string L1Station::ToString(int verbosityLevel, int indentLevel) const
+{
+ std::stringstream aStream {};
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ if (verbosityLevel > 1) {
+ // TODO: probably we can have verbosity level and address for each underlying object (S.Zharko)
+ aStream << indent << "Address: " << this << '\n';
+ }
+ aStream << indent << "Station type ID: " << std::setw(12) << std::setfill(' ') << type << '\n';
+ aStream << indent << "If time info used: " << std::setw(12) << std::setfill(' ') << timeInfo << '\n';
+ aStream << indent << "z position [cm]: " << std::setw(12) << std::setfill(' ') << z[0] << '\n';
+ if (verbosityLevel > 0) {
+ aStream << indent << "Rmin [cm]: " << std::setw(12) << std::setfill(' ') << Rmin[0] << '\n';
+ aStream << indent << "Rmax [cm]: " << std::setw(12) << std::setfill(' ') << Rmax[0] << '\n';
+ aStream << materialInfo.ToString(indentLevel) << '\n';
+ if (verbosityLevel > 1) {
+ aStream << indent << "Field approcimation coefficients:\n";
+ aStream << fieldSlice.ToString(indentLevel + 1) << '\n';
+ }
+ aStream << indent << "Strips geometry:\n";
+ aStream << indent << indentChar << "Front:\n";
+ aStream << frontInfo.ToString(indentLevel + 2) << '\n';
+ aStream << indent << indentChar << "Back:\n";
+ aStream << backInfo.ToString(indentLevel + 2) << '\n';
+ aStream << indent << indentChar << "XY cov matrix:\n";
+ aStream << XYInfo.ToString(indentLevel + 2) << '\n';
+ aStream << indent << indentChar << "X layer:\n";
+ aStream << xInfo.ToString(indentLevel + 2) << '\n';
+ aStream << indent << indentChar << "Y layer:\n";
+ aStream << xInfo.ToString(indentLevel + 2) << '\n';
+ }
+ return aStream.str();
+}
diff --git a/reco/L1/L1Algo/L1Station.h b/reco/L1/L1Algo/L1Station.h
index 74c2e790171ee051b8ec5603b0766420523f701a..d422382cd6488e26d512c38ea434a434132bf6f0 100644
--- a/reco/L1/L1Algo/L1Station.h
+++ b/reco/L1/L1Algo/L1Station.h
@@ -5,6 +5,8 @@
#ifndef L1Station_h
#define L1Station_h 1
+#include <string>
+
#include "L1Field.h"
#include "L1MaterialInfo.h"
#include "L1UMeasurementInfo.h"
@@ -19,11 +21,11 @@ public:
//L1Station & operator=(L1Station &&) = default;
int type {0};
- int timeInfo {0};
- fvec z {0};
- fvec Rmin {0};
- fvec Rmax {0};
- fvec Sy {0};
+ int timeInfo {0}; ///< flag: if time information can be used
+ fvec z {0}; ///< z position of station
+ fvec Rmin {0}; ///< min radius of the station
+ fvec Rmax {0}; ///< max radius of the station
+ //fvec Sy {0}; // commented because is not used in the code (S.Zharko)
fvec dt {0};
L1MaterialInfo materialInfo {};
L1FieldSlice fieldSlice {};
@@ -35,6 +37,9 @@ public:
/// Prints object fields
void Print(int verbosity = 0) const;
+ /// String representation of class contents
+ /// \param indentLevel number of indent characters in the output
+ std::string ToString(int verbosityLevel = 0, int indentLevel = 0) const;
} _fvecalignment;
diff --git a/reco/L1/L1Algo/L1UMeasurementInfo.cxx b/reco/L1/L1Algo/L1UMeasurementInfo.cxx
index 52b54f6a2b0dfa8fbefd32e9352cfea5e59cd0ff..2b23128b2ad624a6e222695318a4e03a596d04af 100644
--- a/reco/L1/L1Algo/L1UMeasurementInfo.cxx
+++ b/reco/L1/L1Algo/L1UMeasurementInfo.cxx
@@ -3,3 +3,18 @@
Authors: Sergey Gorbunov, Sergei Zharko */
#include "L1UMeasurementInfo.h"
+
+#include <iomanip>
+#include <sstream>
+
+std::string L1UMeasurementInfo::ToString(int indentLevel) const
+{
+ std::stringstream aStream {};
+ // TODO: possibly it is better to place the indentChar into L1Parameters (S.Zharko)
+ constexpr char indentChar = '\t';
+ std::string indent(indentLevel, indentChar);
+ aStream << indent << "cos(phi): " << std::setw(12) << std::setfill(' ') << cos_phi[0] << '\n';
+ aStream << indent << "sin(phi): " << std::setw(12) << std::setfill(' ') << sin_phi[0] << '\n';
+ aStream << indent << "sigma2 [??]: " << std::setw(12) << std::setfill(' ') << sigma2[0];
+ return aStream.str();
+}
diff --git a/reco/L1/L1Algo/L1UMeasurementInfo.h b/reco/L1/L1Algo/L1UMeasurementInfo.h
index bcdf46ee0da92710edbc90a17ae459086355f2bc..3e3423eaf2fd9413120471fdfdebaca0f117b6f5 100644
--- a/reco/L1/L1Algo/L1UMeasurementInfo.h
+++ b/reco/L1/L1Algo/L1UMeasurementInfo.h
@@ -5,15 +5,19 @@
#ifndef L1UMeasurementInfo_h
#define L1UMeasurementInfo_h 1
-#include "L1Def.h"
+#include <string>
+#include "L1Def.h"
class L1UMeasurementInfo {
public:
- L1UMeasurementInfo() : cos_phi(0), sin_phi(0), sigma2(0) {}
-
- fvec cos_phi, sin_phi, sigma2;
+ fvec cos_phi {0.f};
+ fvec sin_phi {0.f};
+ fvec sigma2 {0.f};
+ /// String representation of class contents
+ /// \param indentLevel number of indent characters in the output
+ std::string ToString(int indentLevel = 0) const;
} _fvecalignment;
diff --git a/reco/L1/L1Algo/L1XYMeasurementInfo.cxx b/reco/L1/L1Algo/L1XYMeasurementInfo.cxx
index 89de9e1dfc9778eec608ae9e249bc6cf7ba69c98..07e3cdc92ed670d75aedfa79d5b5b82a8fb6245a 100644
--- a/reco/L1/L1Algo/L1XYMeasurementInfo.cxx
+++ b/reco/L1/L1Algo/L1XYMeasurementInfo.cxx
@@ -4,6 +4,7 @@
#include "L1XYMeasurementInfo.h"
+#include <iomanip>
#include <sstream> // for stringstream
std::string L1XYMeasurementInfo::ToString(int indentLevel) const
@@ -12,8 +13,8 @@ std::string L1XYMeasurementInfo::ToString(int indentLevel) const
// TODO: possibly is better to be place indentChar into L1Parameters (S.Zharko)
constexpr char indentChar = '\t';
std::string indent(indentLevel, indentChar);
- aStream << indent << "C00: " << std::setw(12) << std::setfill(' ') << C00 << '\n';
- aStream << indent << "C10: " << std::setw(12) << std::setfill(' ') << C10 << '\n';
- aStream << indent << "C11: " << std::setw(12) << std::setfill(' ') << C11;
+ aStream << indent << "C00: " << std::setw(12) << std::setfill(' ') << C00[0] << '\n';
+ aStream << indent << "C10: " << std::setw(12) << std::setfill(' ') << C10[0] << '\n';
+ aStream << indent << "C11: " << std::setw(12) << std::setfill(' ') << C11[0];
return aStream.str();
}
diff --git a/reco/L1/L1Algo/L1XYMeasurementInfo.h b/reco/L1/L1Algo/L1XYMeasurementInfo.h
index 08bfc35a4cd9190559866d9fdb9e85a7df04407e..569a80d6a2757eeea51ccab5a08641af4385a505 100644
--- a/reco/L1/L1Algo/L1XYMeasurementInfo.h
+++ b/reco/L1/L1Algo/L1XYMeasurementInfo.h
@@ -5,8 +5,9 @@
#ifndef L1XYMeasurementInfo_h
#define L1XYMeasurementInfo_h 1
-#include "L1Def.h"
+#include <string>
+#include "L1Def.h"
class L1XYMeasurementInfo {
diff --git a/reco/L1/L1Algo/utils/L1AlgoDraw.cxx b/reco/L1/L1Algo/utils/L1AlgoDraw.cxx
index 0bd92cc6366fe5e6fb2698bdb4f5fd30658caac3..5427fc419695e4a0987db16519e81f0429b04100 100644
--- a/reco/L1/L1Algo/utils/L1AlgoDraw.cxx
+++ b/reco/L1/L1Algo/utils/L1AlgoDraw.cxx
@@ -25,6 +25,11 @@
#include "L1Algo.h"
+// NOTE: using std::cout, std::endl were removed from one of the headers, and it
+// caused errors. Please, don't use "using" in headers
+using std::cout;
+using std::endl;
+
L1AlgoDraw::L1AlgoDraw()
{
diff --git a/reco/L1/vectors/P4_F32vec4.h b/reco/L1/vectors/P4_F32vec4.h
index 6cf8ba662acb2489a937280e818188bbc1159495..cefaa3dc7c16c7b49bb8f19636a29bd54f499eba 100644
--- a/reco/L1/vectors/P4_F32vec4.h
+++ b/reco/L1/vectors/P4_F32vec4.h
@@ -5,6 +5,7 @@
#ifndef L1Algo_F32vec4P4_H
#define L1Algo_F32vec4P4_H
+#include <iomanip>
#include <iostream>
#include <cmath>
@@ -210,7 +211,12 @@ public:
friend std::ostream& operator<<(std::ostream& strm, const F32vec4& a)
{
- strm << "[" << a[0] << " " << a[1] << " " << a[2] << " " << a[3] << "]";
+ //strm << "[" << a[0] << " " << a[1] << " " << a[2] << " " << a[3] << "]";
+ strm << '[';
+ strm << std::setw(12) << std::setfill(' ') << a[0] << ' ';
+ strm << std::setw(12) << std::setfill(' ') << a[1] << ' ';
+ strm << std::setw(12) << std::setfill(' ') << a[2] << ' ';
+ strm << std::setw(12) << std::setfill(' ') << a[3] << ']';
return strm;
}