Belle II Software  release-05-01-25
TrgEclDatabaseImporter.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2016 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Makoto Uchida *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 // Own include
12 #include <trg/ecl/dbobjects/TrgEclDatabaseImporter.h>
13 
14 // framework - Database
15 #include <framework/database/DBObjPtr.h>
16 #include <framework/database/IntervalOfValidity.h>
17 #include <framework/database/DBImportArray.h>
18 
19 // framework aux
20 #include <framework/logging/Logger.h>
21 
22 // DB objects
23 #include "trg/ecl/dbobjects/TRGECLFAMPara.h"
24 #include "trg/ecl/dbobjects/TRGECLTMMPara.h"
25 #include "trg/ecl/dbobjects/TRGECLETMPara.h"
26 #include "trg/ecl/dbobjects/TRGECLBadRun.h"
27 
28 #include "trg/ecl/TrgEclMapping.h"
29 
30 #include <iostream>
31 #include <fstream>
32 
33 using namespace std;
34 namespace Belle2 {
40  TrgEclDatabaseImporter::TrgEclDatabaseImporter(): startExp(0), startRun(0), endExp(-1), endRun(-1)
41  {}
42 
43  void TrgEclDatabaseImporter::importFAMParameter(std::string InputFileName, std::string InputFileSignalPDF,
44  std::string InputFileNoise)
45  {
46  std::ifstream stream;
47  stream.open(InputFileName.c_str());
48  if (!stream) {
49  B2ERROR("openFile: " << InputFileName << " *** failed to open");
50  return;
51  }
52  std::ifstream stream1;
53  stream1.open(InputFileSignalPDF.c_str());
54  if (!stream1) {
55  B2ERROR("openFile: " << InputFileSignalPDF << " *** failed to open");
56  return;
57  }
58 
59  std::ifstream stream2;
60  stream2.open(InputFileNoise.c_str());
61  if (!stream2) {
62  B2ERROR("openFile: " << InputFileNoise << " *** failed to open");
63  return;
64  }
65 
66  TrgEclMapping* _map = new TrgEclMapping();
67 
68 
69  DBImportArray<TRGECLFAMPara> fampara;
70  // fampara.construct();
71 
72  std::vector<int> FPGAversion;
73  std::vector<int> TCId;
74  std::vector<int> FAMId;
75  std::vector<int> ChannelId;
76  std::vector<int> TEreconstruction;
77  std::vector<int> Threshold;
78  std::vector<double> Conversionfactor;
79  std::vector<int> Toffset;
80  std::vector<int> Wavemean;
81  std::vector<int> Wavesigma;
82  FPGAversion.clear();
83  TCId.clear();
84  FAMId.clear();
85  ChannelId.clear();
86  TEreconstruction.clear();
87  Threshold.clear();
88  Conversionfactor.clear();
89  Toffset.clear();
90  Wavemean.clear();
91  Wavesigma.clear();
92 
93  FPGAversion.resize(624, 0);
94  TCId.resize(624, 0);
95  FAMId.resize(624, 0);
96  ChannelId.resize(624, 0);
97  TEreconstruction.resize(624, 0);
98  Threshold.resize(624, 0);
99  Conversionfactor.resize(624, 0);
100  Toffset.resize(624, 0);
101 
102  Wavemean.resize(624, 0);
103  Wavesigma.resize(624, 0);
104 
105 
106  std::vector<std::vector<double> > SignalPDF;
107  SignalPDF.clear();
108  std::vector<std::vector<double> > NoiseCovarianceMatrix;
109  NoiseCovarianceMatrix.clear();
110  SignalPDF.resize(624, std::vector<double>(8, 0));
111  NoiseCovarianceMatrix.resize(624, std::vector<double>(78, 0));
112 
113  int Id = 0;
114  while (!stream.eof()) {
115  stream >> FAMId[Id] >> ChannelId[Id] >> FPGAversion [Id] >> TEreconstruction[Id] >> Threshold[Id] >> Conversionfactor[Id] >>
116  Toffset[Id] >> Wavemean[Id] >> Wavesigma[Id];
117  TCId[Id] = _map -> getTCIdFromFAMChannel(FAMId[Id], ChannelId[Id]);
118  Id++;
119  }
120  stream.close();
121  Id = 0;
122  int line = 0;
123 
124  while (!stream1.eof()) {
125  stream1 >> SignalPDF[Id][line];
126  line++;
127  if (line == 8) {
128  line = 0;
129  Id++;
130  }
131 
132  }
133  stream1.close();
134 
135  Id = 0;
136  line = 0;
137  while (!stream2.eof()) {
138  stream2 >> NoiseCovarianceMatrix[Id][line];
139  line++;
140  if (line == 78) {
141  line = 0;
142  Id++;
143  }
144 
145  }
146  stream2.close();
147 
148 
149  //Import to DB
150  for (int iTCId = 0; iTCId < 624; iTCId++) {
151  fampara.appendNew(FPGAversion[iTCId],
152  TCId[iTCId],
153  FAMId[iTCId],
154  ChannelId[iTCId],
155  TEreconstruction[iTCId],
156  Conversionfactor[iTCId],
157  Toffset[iTCId],
158  Threshold[iTCId],
159  Wavemean[iTCId],
160  Wavesigma[iTCId],
161  SignalPDF[iTCId],
162  NoiseCovarianceMatrix[iTCId]
163  );
164  }
165 
166  IntervalOfValidity iov(startExp, startRun, endExp, endRun);
167 
168  fampara.import(iov);
169 
170  delete _map ;
171  B2RESULT("FAM parameters are imported to database.");
172 
173  }
174  //
175  //
176  void TrgEclDatabaseImporter::importTMMParameter(std::string InputFileName)
177  {
178  std::ifstream stream;
179  stream.open(InputFileName.c_str());
180  if (!stream) {
181  B2ERROR("openFile: " << InputFileName << " *** failed to open");
182  return;
183  }
184 
185  DBImportArray<TRGECLTMMPara> tmmpara;
186 
187  int FPGAversion;
188  stream >> FPGAversion ;
189  tmmpara.appendNew(FPGAversion);
190  stream.close();
191  //Import to DB
192  IntervalOfValidity iov(startExp, startRun, endExp, endRun);
193 
194  tmmpara.import(iov);
195 
196  B2RESULT("TMM parameters are imported to database.");
197 
198  }
199 
200 
201  void TrgEclDatabaseImporter::importETMParameter(std::string InputFileName)
202  {
203  std::ifstream stream;
204  stream.open(InputFileName.c_str());
205  if (!stream) {
206  B2ERROR("openFile: " << InputFileName << " *** failed to open");
207  return;
208  }
209 
210  DBImportArray<TRGECLETMPara> etmpara;
211 
212  int FPGAversion;
213  double ADCto100MeV;
214  int ELow;
215  int EHigh;
216  int ELum;
217  int FWD2DBhabha[14];
218  int BWD2DBhabha[14];
219  int Bhabha3DSelectionThreshold[2];
220  int Bhabha3DVetoThreshold[2];
221  int Bhabha3DSelectionAngle[4];
222  int Bhabha3DVetoAngle[4];
223  int mumuThreshold;
224  int mumuAngle[4];
225  int LowMultiThreshold[4];
226  int Prescalefactor[3];
227  int TriggerLatency;
228  int ETMDelay;
229  int n300MeVCluster;
230  int ECLBurstThreshold;
231 
232  stream >> FPGAversion
233  >> ADCto100MeV
234  >> ELum
235  >> EHigh
236  >> ELow
237  >> FWD2DBhabha[0] >> BWD2DBhabha[0]
238  >> FWD2DBhabha[1] >> BWD2DBhabha[1]
239  >> FWD2DBhabha[2] >> BWD2DBhabha[2]
240  >> FWD2DBhabha[3] >> BWD2DBhabha[3]
241  >> FWD2DBhabha[4] >> BWD2DBhabha[4]
242  >> FWD2DBhabha[5] >> BWD2DBhabha[5]
243  >> FWD2DBhabha[6] >> BWD2DBhabha[6]
244  >> FWD2DBhabha[7] >> BWD2DBhabha[7]
245  >> FWD2DBhabha[8] >> BWD2DBhabha[8]
246  >> FWD2DBhabha[9] >> BWD2DBhabha[9]
247  >> FWD2DBhabha[10] >> BWD2DBhabha[10]
248  >> FWD2DBhabha[11] >> BWD2DBhabha[11]
249  >> FWD2DBhabha[12] >> BWD2DBhabha[12]
250  >> FWD2DBhabha[13] >> BWD2DBhabha[13]
251  >> Bhabha3DSelectionThreshold[0]
252  >> Bhabha3DSelectionThreshold[1]
253  >> Bhabha3DVetoThreshold[0]
254  >> Bhabha3DVetoThreshold[1]
255  >> Bhabha3DSelectionAngle[0]
256  >> Bhabha3DSelectionAngle[1]
257  >> Bhabha3DSelectionAngle[2]
258  >> Bhabha3DSelectionAngle[3]
259  >> Bhabha3DVetoAngle[0]
260  >> Bhabha3DVetoAngle[1]
261  >> Bhabha3DVetoAngle[2]
262  >> Bhabha3DVetoAngle[3]
263  >> mumuThreshold
264  >> mumuAngle[0]
265  >> mumuAngle[1]
266  >> mumuAngle[2]
267  >> mumuAngle[3]
268  >> LowMultiThreshold[0]
269  >> LowMultiThreshold[1]
270  >> LowMultiThreshold[2]
271  >> LowMultiThreshold[3]
272  >> Prescalefactor[0]
273  >> Prescalefactor[1]
274  >> Prescalefactor[2]
275  >> TriggerLatency
276  >> ETMDelay
277  >> n300MeVCluster
278  >> ECLBurstThreshold;
279 
280 
281  etmpara.appendNew(FPGAversion, ADCto100MeV, ELow, EHigh, ELum, FWD2DBhabha, BWD2DBhabha, Bhabha3DSelectionThreshold,
282  Bhabha3DVetoThreshold, Bhabha3DSelectionAngle, Bhabha3DVetoAngle, mumuThreshold, mumuAngle, LowMultiThreshold,
283  Prescalefactor, TriggerLatency, ETMDelay, n300MeVCluster, ECLBurstThreshold);
284 
285  stream.close();
286  //Import to DB
287  IntervalOfValidity iov(startExp, startRun, endExp, endRun);
288 
289  etmpara.import(iov);
290 
291  B2RESULT("ETM Parameters are imported to database.");
292 
293  }
294 
295  void TrgEclDatabaseImporter::importBadRunNumber(std::string InputFileName)
296  {
297  std::ifstream stream;
298  stream.open(InputFileName.c_str());
299  if (!stream) {
300  B2ERROR("openFile: " << InputFileName << " *** failed to open");
301  return;
302  }
303 
304  DBImportArray<TRGECLBadRun> badrun;
305 
306  int BadRunNumber;
307  while (!stream.eof()) {
308 
309  stream >> BadRunNumber ;
310  badrun.appendNew(BadRunNumber);
311  }
312  stream.close();
313  //Import to DB
314  IntervalOfValidity iov(startExp, startRun, endExp, endRun);
315 
316  badrun.import(iov);
317 
318  B2RESULT("BadRunList are imported to database.");
319 
320  }
321 
322  void TrgEclDatabaseImporter::printTCThreshold()
323  {
324 
325  DBObjPtr<TRGECLFAMPara> para ;
326 
327  para->Dump();
328 
329  }
331 }
Belle2::IntervalOfValidity
A class that describes the interval of experiments/runs for which an object in the database is valid.
Definition: IntervalOfValidity.h:35
Belle2::TrgEclDatabaseImporter::printTCThreshold
void printTCThreshold()
Print TC energy Threshold.
Definition: TrgEclDatabaseImporter.cc:322
Belle2::DBImportArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: DBImportArray.h:77
Belle2::TrgEclDatabaseImporter::startExp
int startExp
Start Experiment Number.
Definition: TrgEclDatabaseImporter.h:63
Belle2::TrgEclDatabaseImporter::endRun
int endRun
End Run Number.
Definition: TrgEclDatabaseImporter.h:69
Belle2::DBImportBase::import
bool import(const IntervalOfValidity &iov)
Import the object to database.
Definition: DBImportBase.cc:38
Belle2::TrgEclDatabaseImporter::importBadRunNumber
void importBadRunNumber(std::string)
Import Bad Run Number.
Definition: TrgEclDatabaseImporter.cc:295
Belle2::TrgEclMapping
A class of TC Mapping.
Definition: TrgEclMapping.h:31
Belle2::DBObjPtr
Class for accessing objects in the database.
Definition: DBObjPtr.h:31
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TrgEclDatabaseImporter::importFAMParameter
void importFAMParameter(std::string, std::string, std::string)
Import FAM Parameters.
Definition: TrgEclDatabaseImporter.cc:43
Belle2::TrgEclDatabaseImporter::startRun
int startRun
Start Run Number.
Definition: TrgEclDatabaseImporter.h:65
Belle2::TrgEclDatabaseImporter::endExp
int endExp
End Experiment Number.
Definition: TrgEclDatabaseImporter.h:67
Belle2::TrgEclDatabaseImporter::importTMMParameter
void importTMMParameter(std::string)
Import TMM Parameters.
Definition: TrgEclDatabaseImporter.cc:176
Belle2::TrgEclDatabaseImporter::importETMParameter
void importETMParameter(std::string)
Import ETM Parameters.
Definition: TrgEclDatabaseImporter.cc:201
Belle2::DBImportArray
Class for importing array of objects to the database.
Definition: DBImportArray.h:35