JFirmware.cc File Reference

#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <map>
#include <algorithm>
#include "TROOT.h"
#include "TFile.h"
#include "TGraph.h"
#include "TH2D.h"
#include "JROOT/JRootToolkit.hh"
#include "JSystem/JGlob.hh"
#include "JDB/JUPI_t.hh"
#include "JDetector/JLocation.hh"
#include "JLang/JVectorize.hh"
#include "JTools/JRange.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)
	Auxiliary program to plot firmware versions.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Auxiliary program to plot firmware versions.

Author

mdejong

Definition at line 33 of file JFirmware.cc.

{
  using namespace std;
  using namespace JPP;
 
  vector<string> inputFile;
  string         outputFile;
  int            debug;
 
  try {
 
    JParser<> zap("Auxiliary program to plot firmware versions.");
 
    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(outputFile)    = "firmware.root";
    zap['d'] = make_field(debug)         = 2;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  const char SEPARATOR = '.';
 
  inputFile = getFilenames(inputFile);
 
  //
  // stable index of firmware version
  //
  struct :
    public vector<string>
  {
    int operator()(const string& firmware)
    {
      using namespace std;
 
      iterator p = find(this->begin(), this->end(), firmware);
 
      if (p == this->end()) {
 
        this->push_back(firmware);
 
        p = this->rbegin().base();
      }
 
      return distance(this->begin(), p);
    }
  } version;
 
 
  struct pair_type {
    int run;
    int version;
  };
 
 
  map<JLocation, vector<pair_type> > data;
 
  JRange<int> range = JRange<int>::DEFAULT_RANGE();
 
 
  for (const string& i : inputFile) {
 
    STATUS(i << '\r'); DEBUG(endl);
 
    int run;
 
    {
      string::size_type pos = i.find(SEPARATOR);
 
      if (pos != string::npos)
        istringstream(i.substr(0,pos)) >> run;
      else
        continue;
    }
 
    range.include(run);
 
    ifstream in(i);
 
    string buffer;
    string location;
    string upi;
    string firmware;
 
    while (in >> buffer >> location >> upi && getline(in, firmware)) {
 
      string::size_type pos = location.find(SEPARATOR);
 
      if (pos != string::npos) {
 
        const int index = version(firmware);
 
        int string, floor;
 
        istringstream(location.substr(0,pos)) >> string;
        istringstream(location.substr(pos+1)) >> floor;
      
        DEBUG(FILL(4,'0') << string << '.' << FILL(2,'0') << floor << ' ' << firmware << endl);
 
        data[JLocation(string,floor)].push_back({run,index});
        
      } else
        continue;
    }
 
    in.close();
  }
  STATUS(endl);
 
 
  for (size_t i = 0; i != version.size(); ++i) {
    cout << setw(2) << i << ' ' << version[i] << endl;
  }
 
 
  TH2D h2("H2", NULL,
          range.getLength() + 1, range.getLowerLimit(), range.getUpperLimit() + 1.0,
          data .size()         , 0                    , data. size()          + 0.0);
  {
    int iy = 1;
 
    for (const auto& i : data) {
 
      //h2.GetYaxis()->SetBinLabel(iy, MAKE_CSTRING(getLabel(i.first)));
 
      if (i.first.getFloor() == 0) {
        h2.GetYaxis()->SetBinLabel(iy, MAKE_CSTRING(i.first.getString()));
      }
 
      for (const auto& fs : i.second) {
 
        const int    ix = fs.run - range.getLowerLimit() + 1;
        const double z  = fs.version;
 
        h2.SetBinContent(ix, iy, z);
      }
 
      iy += 1;
    }
  }
 
 
  TFile out(outputFile.c_str(), "recreate");
 
  for (const auto& i : data) {
 
    const auto X = make_array(i.second.begin(), i.second.end(), &pair_type::run);
    const auto Y = make_array(i.second.begin(), i.second.end(), &pair_type::version);
    
    TGraph g1(i.second.size(), X.data(), Y.data());
 
    g1.SetName(MAKE_CSTRING(getLabel(i.first)));
 
    out << g1;
  }
 
  out << h2;
  
  out.Write();
  out.Close();
}