All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
TPCChannelmapping.h
Go to the documentation of this file.
1 // -------------------------------------------------
2 // This is the first pass to this script
3 // It will improve gradually as we move on
4 // Also coding style will gradually improve.
5 //
6 //
7 // Author : Biswaranjan Behera @ 02 April 2020
8 // email : bishu@colostate.edu
9 //-------------------------------------------------
10 
11 #include "wda.h"
12 
13 #include <time.h>
14 #include <vector>
15 #include <string>
16 #include <iostream>
17 #include <stdio.h>
18 
19 namespace database
20 {
21 
22  // -----------------------------------------------------
23  // This Function does the basic information retrieval
24  // One passes in the type of data requested and a reference to the data holder
25  // The function connects via the libwda function to recover the
26  // data and checks to insure there were not connection errors.
27  // The function returns the error status, if null then success
28  //-----------------------------------------------------
29 
30  inline int GetDataset(const std::string name, const std::string url, const std::string& dataType, Dataset& dataSet)
31  {
32  const int timeout(200);
33  std::string dburl = url + "&t=" + dataType;
34 
35  int error(0);
36 
37  dataSet = getDataWithTimeout(dburl.data(),name.data(),timeout,&error);
38 
39  if (error)
40  {
41  std::string errorMsg = "Database access GetDataset failed with error " + std::to_string(error) + "\nDB url: "
42  + dburl + ", name: " + name + ", type: " + dataType;
43  std::cout << "****> Database retrieval error, code: " << error << std::endl;
44  throw std::runtime_error(errorMsg);
45  }
46 
47  return error;
48  }
49 
50  // -----------------------------------------------------
51  // The aim of this function is to build a map between the
52  // TPC Fragment IDs and the readout board IDs. Here we
53  // expect there will be some number of boards per Fragment
54  //-----------------------------------------------------
55 
56  using ReadoutIDVec = std::vector<unsigned int>;
57  using CrateNameReadoutIDPair = std::pair<std::string,ReadoutIDVec>;
58  using TPCFragmentIDToReadoutIDMap = std::map<unsigned int, CrateNameReadoutIDPair>;
59 
60  inline int BuildTPCFragmentIDToReadoutIDMap(TPCFragmentIDToReadoutIDMap& fragmentBoardMap)
61  {
62  const unsigned int tpcIdentifier(0x00001000);
63  const std::string name("icarus_hw_readoutboard");
64  const std::string dburl("https://dbdata0vm.fnal.gov:9443/QE/hw/app/SQ/query?dbname=icarus_hardware_dev");
65  const std::string dataType("readout_boards");
66  Dataset dataset;
67 
68  // Recover the data from the database
69  int error = GetDataset(name,dburl,dataType,dataset);
70 
71  // Include a by hand mapping of fragement ID to crate
72  using FlangeIDToCrateMap = std::map<size_t,std::string>;
73 
74  FlangeIDToCrateMap flangeIDToCrateMap;
75 
76  flangeIDToCrateMap[19] = "WW01T";
77  flangeIDToCrateMap[68] = "WW01M";
78  flangeIDToCrateMap[41] = "WW01B";
79  flangeIDToCrateMap[11] = "WW02";
80  flangeIDToCrateMap[17] = "WW03";
81  flangeIDToCrateMap[36] = "WW04";
82  flangeIDToCrateMap[18] = "WW05";
83  flangeIDToCrateMap[58] = "WW06";
84  flangeIDToCrateMap[71] = "WW07";
85  flangeIDToCrateMap[14] = "WW08";
86  flangeIDToCrateMap[25] = "WW09";
87  flangeIDToCrateMap[34] = "WW10";
88  flangeIDToCrateMap[67] = "WW11";
89  flangeIDToCrateMap[33] = "WW12";
90  flangeIDToCrateMap[87] = "WW13";
91  flangeIDToCrateMap[10] = "WW14";
92  flangeIDToCrateMap[59] = "WW15";
93  flangeIDToCrateMap[95] = "WW16";
94  flangeIDToCrateMap[22] = "WW17";
95  flangeIDToCrateMap[91] = "WW18";
96  flangeIDToCrateMap[61] = "WW19";
97  flangeIDToCrateMap[55] = "WW20T";
98  flangeIDToCrateMap[97] = "WW20M";
99  flangeIDToCrateMap[100] = "WW20B";
100  flangeIDToCrateMap[83] = "WE01T";
101  flangeIDToCrateMap[85] = "WE01M";
102  flangeIDToCrateMap[7] = "WE01B";
103  flangeIDToCrateMap[80] = "WE02";
104  flangeIDToCrateMap[52] = "WE03";
105  flangeIDToCrateMap[32] = "WE04";
106  flangeIDToCrateMap[70] = "WE05";
107  flangeIDToCrateMap[74] = "WE06";
108  flangeIDToCrateMap[46] = "WE07";
109  flangeIDToCrateMap[81] = "WE08";
110  flangeIDToCrateMap[63] = "WE09";
111  flangeIDToCrateMap[30] = "WE10";
112  flangeIDToCrateMap[51] = "WE11";
113  flangeIDToCrateMap[90] = "WE12";
114  flangeIDToCrateMap[23] = "WE13";
115  flangeIDToCrateMap[93] = "WE14";
116  flangeIDToCrateMap[92] = "WE15";
117  flangeIDToCrateMap[88] = "WE16";
118  flangeIDToCrateMap[73] = "WE17";
119  flangeIDToCrateMap[1] = "WE18";
120  flangeIDToCrateMap[66] = "WE19";
121  flangeIDToCrateMap[48] = "WE20T";
122  flangeIDToCrateMap[13] = "WE20M";
123  flangeIDToCrateMap[56] = "WE20B";
124  flangeIDToCrateMap[94] = "EW01T";
125  flangeIDToCrateMap[77] = "EW01M";
126  flangeIDToCrateMap[72] = "EW01B";
127  flangeIDToCrateMap[65] = "EW02";
128  flangeIDToCrateMap[4] = "EW03";
129  flangeIDToCrateMap[89] = "EW04";
130  flangeIDToCrateMap[37] = "EW05";
131  flangeIDToCrateMap[76] = "EW06";
132  flangeIDToCrateMap[49] = "EW07";
133  flangeIDToCrateMap[60] = "EW08";
134  flangeIDToCrateMap[21] = "EW09";
135  flangeIDToCrateMap[6] = "EW10";
136  flangeIDToCrateMap[62] = "EW11";
137  flangeIDToCrateMap[2] = "EW12";
138  flangeIDToCrateMap[29] = "EW13";
139  flangeIDToCrateMap[44] = "EW14";
140  flangeIDToCrateMap[9] = "EW15";
141  flangeIDToCrateMap[31] = "EW16";
142  flangeIDToCrateMap[98] = "EW17";
143  flangeIDToCrateMap[38] = "EW18";
144  flangeIDToCrateMap[99] = "EW19";
145  flangeIDToCrateMap[53] = "EW20T";
146  flangeIDToCrateMap[82] = "EW20M";
147  flangeIDToCrateMap[35] = "EW20B";
148  flangeIDToCrateMap[96] = "EE01T";
149  flangeIDToCrateMap[28] = "EE01M";
150  flangeIDToCrateMap[16] = "EE01T";
151  flangeIDToCrateMap[69] = "EE02";
152  flangeIDToCrateMap[20] = "EE02";
153  flangeIDToCrateMap[79] = "EE02";
154  flangeIDToCrateMap[50] = "EE02";
155  flangeIDToCrateMap[45] = "EE02";
156  flangeIDToCrateMap[84] = "EE02";
157  flangeIDToCrateMap[42] = "EE02";
158  flangeIDToCrateMap[39] = "EE02";
159  flangeIDToCrateMap[26] = "EE02";
160  flangeIDToCrateMap[64] = "EE02";
161  flangeIDToCrateMap[43] = "EE02";
162  flangeIDToCrateMap[47] = "EE02";
163  flangeIDToCrateMap[15] = "EE02";
164  flangeIDToCrateMap[3] = "EE02";
165  flangeIDToCrateMap[27] = "EE02";
166  flangeIDToCrateMap[24] = "EE02";
167  flangeIDToCrateMap[40] = "EE02";
168  flangeIDToCrateMap[75] = "EE02";
169  flangeIDToCrateMap[86] = "EE20T";
170  flangeIDToCrateMap[54] = "EE20M";
171  flangeIDToCrateMap[8] = "EE20B";
172 
173  // If there was an error the function above would have printed a message so bail out
174  if (error) throw(std::exception());
175 
176  // Loop through the data to recover the channels
177  // NOTE that we skip the first row because that is just the labels
178  for(int row = 1; row < getNtuples(dataset); row++)
179  {
180  // Recover the row
181  Tuple tuple = getTuple(dataset, row);
182 
183  if (tuple != NULL)
184  {
185  // Note that the fragment ID is stored in the database as a string which reads as a hex number
186  // Meaning we have to read back as a string and decode to get the numerical value.
187  char fragmentBuffer[16];
188 
189  getStringValue(tuple, 8, fragmentBuffer, sizeof(fragmentBuffer), &error);
190 
191  if (error) throw std::runtime_error("Encountered error in trying to recover FragmentID from database");
192 
193  std::string fragmentIDString(fragmentBuffer,4);
194 
195  unsigned int fragmentID = std::stol(fragmentIDString,nullptr,16);
196 
197  if (!(fragmentID & tpcIdentifier)) continue;
198 
199  if (fragmentBoardMap.find(fragmentID) == fragmentBoardMap.end())
200  {
201  unsigned int flangeID = getLongValue(tuple, 1, &error);
202 
203  if (error) throw std::runtime_error("Encountered error in trying to recover Board Flange ID from database");
204 
205  fragmentBoardMap[fragmentID].first = flangeIDToCrateMap[flangeID];
206  }
207 
208  unsigned int readoutID = getLongValue(tuple, 0, &error);
209 
210  if (error) throw std::runtime_error("Encountered error in trying to recover Board ReadoutID from database");
211 
212  fragmentBoardMap[fragmentID].second.emplace_back(readoutID);
213 
214  releaseTuple(tuple);
215  }
216  }
217 
218  return error;
219  }
220 
221  // -----------------------------------------------------
222  // The aim of this function is to build a map between the
223  // TPC readout board IDs and the associated channels. So for
224  // each readout board ID we expect a number of channels back
225  // from the data base. So the returned data structure will
226  // be a map of readout ID to a vector of channels
227  //-----------------------------------------------------
228 
229  using ChannelPlanePair = std::pair<unsigned int, unsigned int>;
230  using ChannelPlanePairVec = std::vector<ChannelPlanePair>;
231  using SlotChannelVecPair = std::pair<unsigned int, ChannelPlanePairVec>;
232  using TPCReadoutBoardToChannelMap = std::map<unsigned int, SlotChannelVecPair>;
233 
234  const unsigned int CHANNELSPERBOARD = 64;
235 
236  inline int BuildTPCReadoutBoardToChannelMap(TPCReadoutBoardToChannelMap& rbChanMap)
237  {
238  const std::string name("icarus_hardware_dev");
239  const std::string dburl("https://dbdata0vm.fnal.gov:9443/QE/hw/app/SQ/query?dbname=icarus_hardware_dev");
240  const std::string dataType("daq_channels");
241  Dataset dataset;
242 
243  // Recover the data from the database
244  int error = GetDataset(name,dburl,dataType,dataset);
245 
246  // If there was an error the function above would have printed a message so bail out
247  if (error) throw std::runtime_error("Encountered error accessing the database with GetDataset");
248 
249  // Loop through the data to recover the channels, making sure to skip the first (header) row
250  for(int row = 1; row < getNtuples(dataset); row++)
251  {
252  // Recover the row
253  Tuple tuple = getTuple(dataset, row);
254 
255  if (tuple != NULL)
256  {
257  unsigned int readoutBoardID = getLongValue(tuple, 2, &error);
258 
259  if (error) throw std::runtime_error("Encountered error when trying to read Board ReadoutID");
260 
261  if (rbChanMap.find(readoutBoardID) == rbChanMap.end())
262  {
263  unsigned int readoutBoardSlot = getLongValue(tuple, 4, &error);
264 
265  if (error) throw std::runtime_error("Encountered error when trying to read Board Readout slot");
266 
267  rbChanMap[readoutBoardID].first = readoutBoardSlot;
268  rbChanMap[readoutBoardID].second.resize(CHANNELSPERBOARD);
269  }
270 
271  unsigned int channelNum = getLongValue(tuple, 5, &error);
272 
273  if (error) throw std::runtime_error("Encountered error when trying to read channel number");
274 
275  unsigned int channelID = getLongValue(tuple, 0, &error);
276 
277  if (error) throw std::runtime_error("Encountered error when recovering the channel ID list");
278 
279  // Recover the plane identifier
280  char fragmentBuffer[16];
281 
282  getStringValue(tuple, 10, fragmentBuffer, sizeof(fragmentBuffer), &error);
283 
284  if (error) throw std::runtime_error("Encountered error when trying to read plane type");
285 
286  // Make sure lower case... (sigh...)
287  for(size_t charIdx = 0; charIdx < sizeof(fragmentBuffer); charIdx++) fragmentBuffer[charIdx] = tolower(fragmentBuffer[charIdx]);
288 
289  unsigned int plane(3);
290 
291  if (strstr(fragmentBuffer,"collection")) plane = 2;
292  else if (strstr(fragmentBuffer,"induction 2")) plane = 1;
293  else if (strstr(fragmentBuffer,"induction 1")) plane = 0;
294 
295  if (plane > 2) std::cout << "YIKES!!! Plane is " << plane << " for channel " << channelID << " with type " << std::string(fragmentBuffer) << std::endl;
296 
297  rbChanMap[readoutBoardID].second[channelNum] = ChannelPlanePair(channelID,plane);
298  }
299  }
300 
301  return error;
302  }
303 
304  // -------------------------------------------------
305  // This Function returns Fragment_ID.
306  // input : readout_board_id
307  //-------------------------------------------------
308 
309  inline char* Fragment_ID(int readout_board_ID)
310  {
311  Dataset ds;
312  const std::string name("icarus_hw_readoutboard");
313  const std::string dburl("https://dbdata0vm.fnal.gov:9443/QE/hw/app/SQ/query?dbname=icarus_hardware_dev");
314  const std::string dataType = "readout_boards";
315 
316  int error = GetDataset(name,dburl,dataType, ds);
317 
318  if (error)
319  { // Check for curl library errors
320  fprintf(stderr, "error code=%d\n", error); perror("error message");
321  }
322  if (getHTTPstatus(ds) != 200)
323  { // Check for HTTP error
324  fprintf(stderr, "HTTP code=%ld, message: '%s'\n", getHTTPstatus(ds), getHTTPmessage(ds));
325  }
326 
327  char ss[10];
328  int err;
329  int readoutboard_id;
330  int nrows = getNtuples(ds);
331  Tuple tup;
332  for (int rows = 0; rows < nrows; rows++ ){
333  tup = getTuple(ds, rows); // Get the row with double array
334 
335  if (tup != NULL) {
336  //int nc = getNfields(tup);
337  //for (i = 0; i < nc; i++) {
338  //len = getStringValue(tup, i ,8, sizeof (ss), &err);
339  //fprintf(stderr, "[%d]: l=%d, s='%s'\n", i, len, ss);
340  //fprintf(stderr, "[4]: v=%i\n", getStringValue(tup, i ,ss, sizeof (ss), &err));
341  // }
342  readoutboard_id = (int)getDoubleValue(tup, 0, &err);
343  if (readoutboard_id == readout_board_ID){
344  getStringValue(tup, 8 ,ss, sizeof (ss), &err);
345  }
346  releaseTuple(tup);
347  }
348  }
349  char* fragment_id = new char[4];
350  std::strcpy(fragment_id, ss);
351  return fragment_id;
352  }
353 
354  // -------------------------------------------------
355  // This Function returns vector of Channel_ID,
356  // As One read out board contains 64 channels.
357  // input : readout_board_id
358  //-------------------------------------------------
359 
360  inline std::vector<int> Channel_ID(int readout_board_ID)
361  {
362  Dataset ds;
363  const std::string name("icarus_hardware_dev");
364  const std::string dburl("https://dbdata0vm.fnal.gov:9443/QE/hw/app/SQ/query?dbname=icarus_hardware_dev");
365  const std::string dataType = "daq_channels";
366 
367  int error = GetDataset(name,dburl,dataType, ds);
368 
369  if (error) { // Check for curl library errors
370  fprintf(stderr, "error code=%d\n", error); perror("error message");
371  }
372  if (getHTTPstatus(ds) != 200) { // Check for HTTP error
373  fprintf(stderr, "HTTP code=%ld, message: '%s'\n", getHTTPstatus(ds), getHTTPmessage(ds));
374  }
375 
376  int channel_id;
377  std::vector<int> channelidvec;
378  int nrows = getNtuples(ds);
379  for (int rows = 0; rows < nrows; rows++ ){
380  Tuple tu = getTuple(ds, rows); // Get the row with double array
381 
382  // If we get the names print them
383  if (tu != NULL) {
384  int err(0);
385  // If everything is OK
386  int readoutboardid = (int)getDoubleValue(tu, 2, &err);
387 
388  if (readoutboardid == readout_board_ID){
389  channel_id = (int)getDoubleValue(tu, 0, &err);
390  channelidvec.push_back(channel_id);
391  }
392  releaseTuple(tu);
393  }
394  }
395  return channelidvec;
396  }
397 
398 
399  //******************* PMT Channel Mapping ***********************
400 
401  // Ultimately, we want to map between Fragment IDs and a pair of numbers - the channel in the fragment and the LArSoft channel ID
402  using DigitizerChannelChannelIDPair = std::pair<size_t,size_t>;
403  using DigitizerChannelChannelIDPairVec = std::vector<DigitizerChannelChannelIDPair>;
404  using FragmentToDigitizerChannelMap = std::map<size_t,DigitizerChannelChannelIDPairVec>;
405 
406  inline int BuildFragmentToDigitizerChannelMap(FragmentToDigitizerChannelMap& fragmentToDigitizerChannelMap)
407  {
408  // clearing is cleansing
409  fragmentToDigitizerChannelMap.clear();
410 
411  // Recover the information from the database on the mapping
412  const std::string name("Pmt_placement");
413  const std::string dburl("https://dbdata0vm.fnal.gov:9443/QE/hw/app/SQ/query?dbname=icarus_hardware_dev");
414  const std::string dataType("pmt_placements");
415  Dataset dataset;
416 
417  // Recover the data from the database
418  int error = GetDataset(name,dburl,dataType,dataset);
419 
420  // If there was an error the function above would have printed a message so bail out
421  if (error) throw(std::exception());
422 
423  // Ok, now we can start extracting the information
424  // We do this by looping through the database and building the map from that
425  for(int row = 1; row < getNtuples(dataset); row++)
426  {
427  // Recover the row
428  Tuple tuple = getTuple(dataset, row);
429 
430  if (tuple != NULL)
431  {
432  char digitizerBuffer[10];
433 
434  // Recover the digitizer label first
435  getStringValue(tuple, 8, digitizerBuffer, sizeof(digitizerBuffer), &error);
436 
437  if (error) throw std::runtime_error("Encountered error when trying to recover the PMT digitizer label");
438 
439  std::string digitizerLabel(digitizerBuffer, 8); //sizeof(digitizerBuffer));
440 
441  // Recover the fragment id
442  unsigned fragmentID = getLongValue(tuple, 18, &error);
443 
444  if (error) throw std::runtime_error("Encountered error when trying to recover the PMT fragment id");
445 
446  // Now recover the digitizer channel number
447  unsigned int digitizerChannelNo = getLongValue(tuple, 9, &error);
448 
449  if (error) throw std::runtime_error("Encountered error when trying to recover the PMT digitizer channel number");
450 
451  // Finally, get the LArsoft channel ID
452  unsigned int channelID = getLongValue(tuple, 17, &error);
453 
454  if (error) throw std::runtime_error("Encountered error when trying to recover the PMT channel ID");
455 
456  // Fill the map
457  fragmentToDigitizerChannelMap[fragmentID].emplace_back(digitizerChannelNo,channelID);
458 
459  releaseTuple(tuple);
460  }
461  }
462 
463  return error;
464  }
465 
466  //---------------------------------------------------------------
467  // The aim of this function is to build a map between the
468  // Larsoft PMT Channel ID and the physical location of PMT ID
469  //---------------------------------------------------------------
470 
471  inline int PMTChannelIDFromPhysicalPMTPositionID(unsigned int pmtid)
472  {
473  const std::string name("icarus_hw_readoutboard");
474  const std::string dburl("https://dbdata0vm.fnal.gov:9443/QE/hw/app/SQ/query?dbname=icarus_hardware_dev");
475  const std::string dataType("pmt_placements");
476  Dataset dataset;
477 
478  // Recover the data from the database
479  int error = GetDataset(name,dburl,dataType,dataset);
480 
481  // If there was an error the function above would have printed a message so bail out
482  if (error) throw(std::exception());
483 
484  unsigned int PhysicalPMTPositionID;
485  unsigned int PMTChannelID;
486 
487  // Loop through the data to recover the channels
488  // NOTE that we skip the first row because that is just the labels
489  for(int row = 1; row < getNtuples(dataset); row++)
490  {
491  // Recover the row
492  Tuple tuple = getTuple(dataset, row);
493 
494  if (tuple != NULL)
495  {
496 
497  PhysicalPMTPositionID = getLongValue(tuple, 0, &error);
498 
499  if (error) throw std::runtime_error("Encountered error when trying to read Physical PMT Position ID from database");
500 
501  if (PhysicalPMTPositionID == pmtid) {
502 
503  PMTChannelID = getLongValue(tuple, 17, &error);
504 
505  if (error) throw std::runtime_error("Encountered error in trying to recover Larsoft PMT Channel ID from database");
506 
507  }else continue;
508 
509  releaseTuple(tuple);
510  }
511  }
512 
513  return PMTChannelID;
514  }
515 
516  //-----------------------------------------------------------------------------
517  // The aim of this function is to build a map between the
518  // Larsoft PMT Channel ID and the Digitizer channel number and Digitizer label
519  //-----------------------------------------------------------------------------
520 
521  inline int PMTChannelIDFromDigitizer(std::string digitizerlabel, int digitizerchannelnumber)
522  {
523  const std::string name("icarus_hw_readoutboard");
524  const std::string dburl("https://dbdata0vm.fnal.gov:9443/QE/hw/app/SQ/query?dbname=icarus_hardware_dev");
525  const std::string dataType("pmt_placements");
526  Dataset dataset;
527 
528  // Recover the data from the database
529  int error = GetDataset(name,dburl,dataType,dataset);
530 
531  // If there was an error the function above would have printed a message so bail out
532  if (error) throw(std::exception());
533 
534  unsigned int PMTChannelID;
535 
536  // Loop through the data to recover the channels
537  // NOTE that we skip the first row because that is just the labels
538  for(int row = 1; row < getNtuples(dataset); row++)
539  {
540  // Recover the row
541  Tuple tuple = getTuple(dataset, row);
542 
543  if (tuple != NULL)
544  {
545  char digitizerBuffer[10];
546 
547  getStringValue(tuple, 8, digitizerBuffer, sizeof(digitizerBuffer), &error);
548  std::string digitizerLabel(digitizerBuffer, sizeof(digitizerBuffer));
549 
550  int digitizerChannelNumber = getDoubleValue(tuple, 9, &error);
551 
552 
553  int matchedcharacter = digitizerLabel.compare(digitizerlabel);
554 
555  // Not sure what I am doing wrong why 2 is coming for matchedcharacter,
556  // but I have tried a simple compare string with same name it is 0.
557  // std::string s1("EE-BOT-B");
558  // std::string s2("EE-BOT-B");
559  // int compare = s1.compare(s2);
560  // if (compare == 0) std::cout << "strings are equal" << std::endl;
561 
562  if(matchedcharacter == 2 && digitizerChannelNumber == digitizerchannelnumber){
563 
564  PMTChannelID = getLongValue(tuple, 17, &error);
565 
566  if (error) throw std::runtime_error("Encountered error in trying to recover Larsoft PMT Channel ID from database");
567 
568  }else continue;
569 
570  releaseTuple(tuple);
571  }
572  }
573 
574  return PMTChannelID;
575 
576  }
577 
578  // -------------------------------------------------
579  // This is the main Function
580  //-------------------------------------------------
581 
582  //int main()
583  //{
584  // std::vector<int> ch_id_vec = Channel_ID(854);
585  // for(std::vector<int>::iterator it = ch_id_vec.begin(); it != ch_id_vec.end(); it++) {
586  // std::cout << "channel_id: \t" << *it << std::endl;
587  // }
588  //
589  // std ::cout << Fragment_ID(89) << std::endl;
590  //
591  // std ::cout << Fragment_ID(854) << std::endl;
592  //
593  // return 0;
594  //}
595 
596 } // end of namespace
database::GetDataset
int GetDataset(const std::string name, const std::string url, const std::string &dataType, Dataset &dataSet)
Definition: TPCChannelmapping.h:30
database::PMTChannelIDFromDigitizer
int PMTChannelIDFromDigitizer(std::string digitizerlabel, int digitizerchannelnumber)
Definition: TPCChannelmapping.h:521
test_msg.error
error
Definition: larcorealg/test/GeoAlgo/test_msg.py:32
database::TPCFragmentIDToReadoutIDMap
std::map< unsigned int, CrateNameReadoutIDPair > TPCFragmentIDToReadoutIDMap
Definition: TPCChannelmapping.h:58
database::BuildTPCFragmentIDToReadoutIDMap
int BuildTPCFragmentIDToReadoutIDMap(TPCFragmentIDToReadoutIDMap &fragmentBoardMap)
Definition: TPCChannelmapping.h:60
database::Channel_ID
std::vector< int > Channel_ID(int readout_board_ID)
Definition: TPCChannelmapping.h:360
evd::err
EResult err(const char *call)
Definition: WebEVDServer.cxx:140
database::DigitizerChannelChannelIDPairVec
std::vector< DigitizerChannelChannelIDPair > DigitizerChannelChannelIDPairVec
Definition: TPCChannelmapping.h:403
database::Fragment_ID
char * Fragment_ID(int readout_board_ID)
Definition: TPCChannelmapping.h:309
database::DigitizerChannelChannelIDPair
std::pair< size_t, size_t > DigitizerChannelChannelIDPair
Definition: TPCChannelmapping.h:402
lariov::Tuple
void * Tuple
Definition: DBFolder.h:13
database::ChannelPlanePair
std::pair< unsigned int, unsigned int > ChannelPlanePair
Definition: TPCChannelmapping.h:229
database::ReadoutIDVec
std::vector< unsigned int > ReadoutIDVec
Definition: TPCChannelmapping.h:56
database::FragmentToDigitizerChannelMap
std::map< size_t, DigitizerChannelChannelIDPairVec > FragmentToDigitizerChannelMap
Definition: TPCChannelmapping.h:404
database::PMTChannelIDFromPhysicalPMTPositionID
int PMTChannelIDFromPhysicalPMTPositionID(unsigned int pmtid)
Definition: TPCChannelmapping.h:471
database::BuildFragmentToDigitizerChannelMap
int BuildFragmentToDigitizerChannelMap(FragmentToDigitizerChannelMap &fragmentToDigitizerChannelMap)
Definition: TPCChannelmapping.h:406
lariov::Dataset
void * Dataset
Definition: DBFolder.h:12
icarus::trigger::to_string
std::string to_string(WindowPattern const &pattern)
Definition: WindowPattern.h:115
database::CrateNameReadoutIDPair
std::pair< std::string, ReadoutIDVec > CrateNameReadoutIDPair
Definition: TPCChannelmapping.h:57
name
then echo fcl name
Definition: sbndpoms_genfclwithrunnumber_maker.sh:220
database::CHANNELSPERBOARD
const unsigned int CHANNELSPERBOARD
Definition: TPCChannelmapping.h:234
database::SlotChannelVecPair
std::pair< unsigned int, ChannelPlanePairVec > SlotChannelVecPair
Definition: TPCChannelmapping.h:231
database::TPCReadoutBoardToChannelMap
std::map< unsigned int, SlotChannelVecPair > TPCReadoutBoardToChannelMap
Definition: TPCChannelmapping.h:232
database::ChannelPlanePairVec
std::vector< ChannelPlanePair > ChannelPlanePairVec
Definition: TPCChannelmapping.h:230
cout
BEGIN_PROLOG could also be cout
Definition: messageservice.fcl:10
database::BuildTPCReadoutBoardToChannelMap
int BuildTPCReadoutBoardToChannelMap(TPCReadoutBoardToChannelMap &rbChanMap)
Definition: TPCChannelmapping.h:236
Generated by   doxygen 1.8.5