Belle II Software  release-05-01-25
PedeResult.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2015 Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Tadeas Bilka *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <alignment/PedeResult.h>
12 
13 #include <fstream>
14 #include <iostream>
15 #include <sstream>
16 
17 using namespace std;
18 
19 namespace Belle2 {
24  namespace alignment {
25 
26  // ----------
27  // PedeResult
28  // ----------
29  int PedeResult::getParameterIndex(int parameterLabel)
30  {
31  auto index = labelIndices.find(parameterLabel);
32  if (index != labelIndices.end())
33  return index->second;
34  else
35  return -1;
36  }
37  void PedeResult::readEigenFile(string filename)
38  {
39  if (!valid)
40  return;
41 
42  string line;
43  ifstream file(filename);
44 
45  if (!file.is_open())
46  return;
47 
48  int eigenPairIndex = -1;
49 
50  for (auto& pData : data) {
51  pData.eigenweights.clear();
52  pData.eigenweights.reserve(20);
53  }
54 
55  while (getline(file, line)) {
56  cout << line << endl;
57  stringstream ss;
58  ss << line;
59  string tmp1, tmp2, tmp3;
60  int eigenPairNumber;
61  double eigenvalue;
62  ss >> tmp1 >> eigenPairNumber >> tmp2 >> tmp3 >> eigenvalue;
63  cout << tmp1 << " " << tmp2 << " " << tmp3 << " " << eigenPairNumber << " " << eigenvalue << endl;
64  if (tmp1 == "Eigenvector")
65  ++eigenPairIndex;
66  else
67  continue;
68 
69  // Read elements
70  vector<pair<int, double>> elements;
71  while (getline(file, line) && line.length() > 2) {
72  int lab1 = 0;
73  int lab2 = 0;
74  int lab3 = 0;
75  double w1, w2, w3;
76  stringstream triplet;
77  triplet << line;
78  triplet >> lab1 >> w1 >> lab2 >> w2 >> lab3 >> w3;
79  if (lab1) elements.push_back({lab1, w1});
80  if (lab2) elements.push_back({lab2, w2});
81  if (lab3) elements.push_back({lab3, w3});
82  //cout << lab1 << w1 << lab2 << w2 << lab3 << w3 << endl;
83  }
84  for (auto& pData : data) {
85  pData.eigenweights.push_back(0.);
86  }
87  for (auto el : elements) {
88  int index = getParameterIndex(el.first);
89  if (index >= 0)
90  data[index].eigenweights[eigenPairIndex] = el.second;
91  }
92  eigenNumbers.push_back(eigenvalue);
93  }
94 
95 
96  }
97  void PedeResult::read(string filename)
98  {
99  string line;
100  ifstream res(filename);
101  // skip comment line
102  getline(res, line);
103 
104  noDeterminedParams = 0;
105  data.clear();
106  labelIndices.clear();
107  int index(-1);
108 
109  while (getline(res, line)) {
110  ++index;
111  int label = -1;
112  double param = 0.;
113  double presigma = 0.;
114  double differ = 0.;
115  double error = 0.;
116  stringstream ss;
117  ss << line;
118  ss >> label >> param >> presigma >> differ >> error;
119  data.push_back(parameterData(index, label, param, error, presigma));
120  labelIndices.insert(make_pair(label, index));
121  if (isParameterDetermined(index))
122  ++noDeterminedParams;
123  }
124 
125  if (data.size() > 0)
126  valid = true;
127  }
128  PedeResult::PedeResult(const string& filename): data(), eigenNumbers(), valid(false), labelIndices()
129  {
130  read(filename);
131  }
132 
133  unsigned int PedeResult::getParameterLabel(unsigned int parameterIndex)
134  {
135  if (outOfBounds(parameterIndex)) return 0;
136  return data[parameterIndex].label;
137  }
138  double PedeResult::getParameterCorrection(unsigned int parameterIndex)
139  {
140  if (outOfBounds(parameterIndex)) return 0.;
141  return data[parameterIndex].correction;
142  }
143  double PedeResult::getParameterError(unsigned int parameterIndex)
144  {
145  if (outOfBounds(parameterIndex)) return 0.;
146  return data[parameterIndex].error;
147  }
148  double PedeResult::getParameterPresigma(unsigned int parameterIndex)
149  {
150  if (outOfBounds(parameterIndex)) return 0.;
151  return data[parameterIndex].presigma;
152  }
153  bool PedeResult::isParameterFixed(unsigned int parameterIndex)
154  {
155  if (outOfBounds(parameterIndex)) return false;
156  return data[parameterIndex].presigma < 0;
157  }
158  bool PedeResult::isParameterDetermined(unsigned int parameterIndex)
159  {
160  if (outOfBounds(parameterIndex)) return false;
161  return !isParameterFixed(parameterIndex) && data[parameterIndex].correction != 0. && data[parameterIndex].error != 0.;
162  }
163  double PedeResult::getEigenNumber(unsigned int eigenPairIndex)
164  {
165  if (eigenPairIndex >= eigenNumbers.size()) return 0.;
166  return eigenNumbers[eigenPairIndex];
167  }
168  double PedeResult::getEigenVectorElement(unsigned int eigenPairIndex, unsigned int parameterIndex)
169  {
170  if (outOfBounds(parameterIndex))
171  return 0.;
172  parameterData& element = data[parameterIndex];
173  if (eigenPairIndex >= element.eigenweights.size())
174  return 0.;
175 
176  return data[parameterIndex].eigenweights[eigenPairIndex];
177  }
179  {
180  for (auto pdata : data) {
181  std::cout << pdata.index << " : " << pdata.label << " corr: " << pdata.correction << " err: " << pdata.error << " presigma: " <<
182  pdata.presigma << endl;
183  }
184  }
185  }
187 }
188 
189 
Belle2::alignment::PedeResult::getEigenNumber
double getEigenNumber(unsigned int eigenPairIndex)
Get eigennumber at given index.
Definition: PedeResult.cc:163
Belle2::alignment::PedeResult::dump
void dump()
Dump the content to std::cout.
Definition: PedeResult.cc:178
Belle2::alignment::PedeResult::isParameterFixed
bool isParameterFixed(unsigned int parameterIndex)
Is parameter at given index fixed?
Definition: PedeResult.cc:153
Belle2::alignment::PedeResult::data
std::vector< parameterData > data
Vector with all the parameter data.
Definition: PedeResult.h:111
Belle2::alignment::PedeResult::getParameterCorrection
double getParameterCorrection(unsigned int parameterIndex)
Get determined correction of parameter at index.
Definition: PedeResult.cc:138
Belle2::alignment::PedeResult::getParameterLabel
unsigned int getParameterLabel(unsigned int parameterIndex)
Get label of parameter at index.
Definition: PedeResult.cc:133
Belle2::alignment::PedeResult::isParameterDetermined
bool isParameterDetermined(unsigned int parameterIndex)
Is parameter at given index determined?
Definition: PedeResult.cc:158
Belle2::alignment::PedeResult::getParameterPresigma
double getParameterPresigma(unsigned int parameterIndex)
Get presigma of parameter at index.
Definition: PedeResult.cc:148
Belle2::alignment::PedeResult::read
void read(std::string filename="millepede.res")
Reads the result file and inits the object.
Definition: PedeResult.cc:97
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::alignment::PedeResult::getParameterError
double getParameterError(unsigned int parameterIndex)
Get correction error of parameter at index.
Definition: PedeResult.cc:143
Belle2::alignment::PedeResult::eigenNumbers
std::vector< double > eigenNumbers
Vector of loaded eigennumbers.
Definition: PedeResult.h:113
Belle2::alignment::PedeResult::getEigenVectorElement
double getEigenVectorElement(unsigned int eigenPairIndex, unsigned int parameterIndex)
Get eigenvector at given index.
Definition: PedeResult.cc:168
Belle2::alignment::PedeResult::parameterData
Struct to hold data for a parameter.
Definition: PedeResult.h:78
Belle2::alignment::PedeResult::outOfBounds
bool outOfBounds(int iparam)
Is index out of valid range?
Definition: PedeResult.h:74