/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/src/analyse/root/monitoring.cpp File Reference

#include <iostream>
#include <stdlib.h>
#include <map>
#include <string>
#include <TFile.h>
#include <TTree.h>
#include <TKey.h>
#include <TH1I.h>
#include <TH2I.h>
#include <TText.h>
#include <TCanvas.h>
#include <TPaveLabel.h>
#include "Run.hh"
#include "Detector.hh"
#include "XMLTool.hh"
#include "Toolbox.hh"
#include "MicroException.hh"
#include "Log.hh"
#include "root/MTRun.hh"
#include "root/MTEvent.hh"
#include "root/MTChannel.hh"
#include "root/MTChamber.hh"
#include "root/MTDetector.hh"
#include "tools/Arguments.hh"

Include dependency graph for monitoring.cpp:

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

---

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 44 of file monitoring.cpp.

                                {


  FILELog::ReportingLevel() = FILELog::FromString(INFO);

  Arguments arg(argc,argv,"monitoring inputFile outputFile -l evtNum");
  if (arg.getNbOfArgs() != 2 ) { arg.usage() ; exit(-1);}
  string rootName = arg.getArgument(1);
  string outputFileName = arg.getArgument(2);

   
  vector<TH1I* > dtVec;

 map<unsigned int, TH1F* > tempAsu1Map; // key is DifId
 map<unsigned int, TH1F* > tempAsu2Map; // key is DifId
 map<unsigned int, TH1F* > tempDifMap; // key is DifId


  UInt_t eventLimit = 0;
  if ( arg.getOption("-l").size() != 0 )
  {
    eventLimit = atoi(arg.getOption("-l").c_str());
  }

  // XY histos
  std::map<ui16,TH2I*> xyKeyChamber; // key is chamberId
  bool construct = false;

  TFile f(rootName.c_str());

  UInt_t nBoarderEvt = 0;
  UInt_t nCRCError = 0;
  UInt_t nBadChipId = 0;
  UInt_t nUnknowError = 0;
  UInt_t nNotValidEvent = 0;
 

  TH2I* xy = NULL;
  TIter nextkey(f.GetListOfKeys());
  TKey *key;
  while (key = (TKey*)nextkey()) 
  {
    TTree *tree = (TTree*)key->ReadObj();
    FILE_LOG(logINFO  ) << "New TTree [" << tree->GetName() << endl;
    MTRun *run=NULL;
    try
    {
      run=dynamic_cast<MTRun *>(tree->GetUserInfo()->First());
      if (construct == false)
      {
        MTDetector* det = run->GetDetector();
        if ( det == NULL ) { exit(-1);}
        // loop over chamber config
        const std::map<UInt_t,MTChamber*>& chambers = det->GetChambers();
        for( std::map<UInt_t,MTChamber*>::const_iterator ii=chambers.begin(); ii!=chambers.end(); ++ii)
        {
          const MTChamber& chamber= *((*ii).second);
          
          string xyname("hxy_");
          Toolbox::addIntToString(xyname,chamber.GetId());

          string  xytitle("XY distribution of hits in chamber ");
          Toolbox::addIntToString(xytitle,chamber.GetId());

          
          // create histogram
          if ( chamber.GetId() >=48 ) // MICROMEGAS
          {                                                   // 1 m -> 1 000 000 um
            xy = new TH2I(xyname.c_str(),xytitle.c_str(),193,0,965000,194,0,970000);
          }
          else // RPC
          {
            Int_t max = 10400*96; // 10400 micro * 96 pad
            xy = new TH2I(xyname.c_str(),xytitle.c_str(),96,0,max,96,0,max);
          }

          xy->SetXTitle("y");
          xy->SetYTitle("x");
          //cout << "Create XY dist for " << xytitle << endl;

          // store it to the map
          xyKeyChamber.insert(make_pair(chamber.GetId(),xy));
        }
      construct = true;
      }
    }
    catch (MicroException e) {}

    MTEvent *evt =  new MTEvent();
    TBranch *branch= tree->GetBranch("MTEvent");
    branch->SetAddress(&evt);
    MTChannel* channel =NULL;
    int nbEntries = tree->GetEntries();
    if ( eventLimit == 0 ) { eventLimit = nbEntries; }
    unsigned int interval = (unsigned int) eventLimit / 10;
    if (interval == 0) interval = 1;
    for ( int evtNum = 0; evtNum <eventLimit ; evtNum++)
    {
      tree->GetEntry(evtNum);
 
/*
    const map<unsigned int , float>& tempDif = evt->GetTemperatureDif();
    for ( map<unsigned int , float>::const_iterator it = tempDif.begin() ; it != tempDif.end(); it++)
    {
      if ( != 0) { asu1TempHist->Fill(evt->GetTemperatureAsu1()); } 
      cout << "    temperature dif: " << it->first << " dif:" << it->second <<endl;
    }
      if ( evt->GetTemperatureAsu2() != 0) { asu2TempHist->Fill(evt->GetTemperatureAsu2()); } 
      if ( evt->GetTemperatureDif() != 0) { difTempHist->Fill(evt->GetTemperatureDif()); } 
*/
      
      UInt_t nbPads=100;     // input   2/3 du nombre de pad format le cadre d'un asu 1 ASU -> ( 6 chips * 8 pads * 2 cotes + 4 chips * 8 pad * 2 cote ) / 3 * 2
      UInt_t asu;            // output
      UInt_t abs_time;       // output
      UInt_t chamber;       // output

      if ( evt->IsSquare(nbPads,asu,abs_time, chamber) == true ) { nBoarderEvt++; } 
      if ( evt->GetCrcIsCorrect() == false ) {nCRCError++; } 
      if ( (evt->GetValidFlag() && UNKNOW_NOT_VALID) ==  UNKNOW_NOT_VALID ) { nUnknowError++; }
      if ( (evt->GetValidFlag() && BAD_CHIP_ID) ==  BAD_CHIP_ID ) { nBadChipId++; }
      if ( ! evt->IsValid() ) { nNotValidEvent++; }




      map<UInt_t, UInt_t> dtMap; // key is BcId_Dif() - BcId_Hit. Value is number of entry
      UInt_t maxDt = 0;
      UInt_t minDt = 0xFFFFFFFF;

      int nbChannel = evt->GetNchannel();
      for(int i=0;i<nbChannel  ;i++)
      {
        channel = (MTChannel*)evt->GetChannels()->UncheckedAt(i);
        UInt_t t2 = channel->GetBcId_Dif();
        UInt_t t3 = channel->GetBcId_Hit();
        UInt_t dt = t2 - t3;
        if ( dt > maxDt ) { maxDt = dt ; }
        if ( dt < minDt ) { minDt = dt ; }


        if (dtMap.find(dt) == dtMap.end())
        { //if this dt doesn't exist yet
          dtMap.insert(make_pair(dt,1));
        }
        else
        { //if this abs time already exist
          dtMap[dt] = dtMap[dt]++;
        }

  

        TH2I *hist = xyKeyChamber[channel->GetChamberId()];
        if ( hist ) 
        {
          if ( channel->GetChamberId() >=48 ) // MICROMEGAS
          {
              hist->Fill(channel->GetY() + 2500,channel->GetX()+2500,channel->GetDigitalValue());
              hist->Fill(channel->GetY()+2500,channel->GetX()-2500,channel->GetDigitalValue());
              hist->Fill(channel->GetY()-2500,channel->GetX()+2500,channel->GetDigitalValue());
              hist->Fill(channel->GetY()-2500,channel->GetX()-2500,channel->GetDigitalValue());
          }
          else  //RPC
          { 
              hist->Fill(channel->GetY(),channel->GetX(),channel->GetDigitalValue());
          }

        }
      }
      
      if ( evtNum % interval == 0 )
      {
        //cout << "Min Dt[" << minDt <<  "], maxDt[" << maxDt << "]" << flush;
        string name = "dt_" ;
        name = name + tree->GetName();
        Toolbox::addIntToString(name,evtNum);
        string title = "BcId_Dif - BcId_Hit";
        TH1I *dtHist = new TH1I(name.c_str(),title.c_str(), maxDt-minDt,  0 ,maxDt);
        
        name = "dt_projection";
        name = name + tree->GetName();
        Toolbox::addIntToString(name,evtNum);

        TH1I *dtProjHist = new TH1I(name.c_str(),title.c_str(), nbChannel,  0 ,nbChannel);
        for ( map<UInt_t ,UInt_t>::const_iterator iterC = dtMap.begin(); iterC != dtMap.end(); iterC++)
        {
          Int_t val = (*iterC).second;
          dtHist->Fill((*iterC).first,val);
          dtProjHist->Fill(val);
        }
        dtVec.push_back(dtHist);
        dtVec.push_back(dtProjHist);
      }

      // Asu1, 2 and Dif temperature
      const map<unsigned int , float>& tempAsu1 = evt->GetTemperatureAsu1();
      for ( map<unsigned int , float>::const_iterator it = tempAsu1.begin() ; it != tempAsu1.end(); it++)
      {
        unsigned int difId = it->first ;
        float temp = it->second;
        TH1F* foo = NULL;
        if ( tempAsu1Map.find(difId) == tempAsu1Map.end())
        {
          string name; 
          std::ostringstream oss;
          oss << "Dif_" << difId;
          name = name + oss.str();
          name = name + "_Asu1_temp" ;
          
          foo = new TH1F(name.c_str(), "Asu1 temperature", 100,  0 ,100);
          tempAsu1Map.insert(make_pair(difId,foo));
        }
        else
        {
          foo = tempAsu1Map.find(difId)->second;
        }
        foo->Fill(temp);
      }

      const map<unsigned int , float>& tempDif = evt->GetTemperatureDif();
      for ( map<unsigned int , float>::const_iterator it = tempDif.begin() ; it != tempDif.end(); it++)
      {       
        unsigned int difId = it->first ;
        float temp = it->second;
        TH1F* foo = NULL;
        if ( tempDifMap.find(difId) == tempDifMap.end())
        { 
          string name;
          std::ostringstream oss;
          oss << "Dif_" << difId;
          name = name + oss.str();
          name = name + "_Dif_temp" ;
       
          foo = new TH1F(name.c_str(), "Dif temperature", 100,  0 ,100);
          tempDifMap.insert(make_pair(difId,foo));
        }
        else
        {
          foo = tempDifMap.find(difId)->second;
        }
        foo->Fill(temp);
      } 

      const map<unsigned int , float>& tempAsu2 = evt->GetTemperatureAsu2();
      for ( map<unsigned int , float>::const_iterator it = tempAsu2.begin() ; it != tempAsu2.end(); it++)
      {       
        unsigned int difId = it->first ;
        float temp = it->second;
        TH1F* foo = NULL;
        if ( tempAsu2Map.find(difId) == tempAsu2Map.end())
        { 
          string name;
          std::ostringstream oss;
          oss << "Dif_" << difId;
          name = name + oss.str();
          name = name + "_Asu2_temp" ;
       
          foo = new TH1F(name.c_str(), "Asu2 temperature", 100,  0 ,100);
          tempAsu2Map.insert(make_pair(difId,foo));
        }
        else
        {
          foo = tempAsu2Map.find(difId)->second;
        }
        foo->Fill(temp);
      } 

      
      FILE_LOG(logINFO  ) << "Write Event[" << evtNum << "] \t\t\t\t\t\t\t\t\t\t\t\r" << flush;
    }
 }


  TFile output(outputFileName.c_str(),"RECREATE");




   TCanvas *statistic = new TCanvas("statistic", "statistic",100,10,700,500);
   statistic->Range(0,0,20,24);
   statistic->SetFillColor(10);
   statistic->SetBorderSize(2);

   TPaveLabel *pl = new TPaveLabel(3,22,17,23.7, "Monitoring result","br");
   pl->SetFillColor(18);
   pl->Draw();

   TText t(0,0,"a");
   t.SetTextFont(62);
   t.SetTextSize(0.025);
   t.SetTextAlign(12);

   string msg = "Total of not valid Event: ";
   Toolbox::addIntToString(msg,   nNotValidEvent); msg = msg + ( " / "); Toolbox::addIntToString(msg,   eventLimit );
   float p = float(float(nNotValidEvent) / float( eventLimit) * 100 );
   msg = msg + ( "-> "); Toolbox::addFloatToString(msg,  p ); msg = msg + ( "% ");
   t.DrawText(2,20,msg.c_str());

   msg = "Number of Event with CRC incorrect: ";
   Toolbox::addIntToString(msg,   nCRCError); msg = msg + ( " / "); Toolbox::addIntToString(msg,   eventLimit );
   p = float(float(nCRCError) / float( eventLimit) * 100 );
   msg = msg + ( "-> "); Toolbox::addFloatToString(msg, p ); msg = msg + ( "% ");
   t.DrawText(2,18,msg.c_str());
   
   msg = "Number of not valid Event because of  bad chip id: ";
   Toolbox::addIntToString(msg,   nBadChipId); msg = msg + ( " / "); Toolbox::addIntToString(msg,   eventLimit );
   p = float(float(nBadChipId) / float( eventLimit) * 100 );
   msg = msg + ( "-> "); Toolbox::addFloatToString(msg,  p ); msg = msg + ( "% ");
   t.DrawText(2,16,msg.c_str());

   msg = "Number of not valid Event because of unknow error: ";
   Toolbox::addIntToString(msg,   nUnknowError); msg = msg + ( " / "); Toolbox::addIntToString(msg,   eventLimit );
   p = float(float(nUnknowError) / float( eventLimit) * 100 );
   msg = msg + ( "-> "); Toolbox::addFloatToString(msg,  p ); msg = msg + ( "% ");
   t.DrawText(2,14,msg.c_str());

   msg = "Number of boarder Event (with  a least 100 boarder pad): ";
   Toolbox::addIntToString(msg,   nBoarderEvt); msg = msg + ( " / "); Toolbox::addIntToString(msg,   eventLimit );
   p = float(float(nBoarderEvt) / float( eventLimit) * 100 );
   msg = msg + ( "-> "); Toolbox::addFloatToString(msg,  p ); msg = msg + ( "% ");
   t.DrawText(2,10,msg.c_str());

   statistic->cd();
   statistic->Write();

  for ( map<ui16,TH2I*>::const_iterator iterC = xyKeyChamber.begin(); iterC != xyKeyChamber.end(); iterC++)
  {
    TH2I *hist = (*iterC).second;
    if ( hist )  
    {  
      hist->Write();
    } 
  }

 
  TCanvas deltaT("deltatT");
  double racine = sqrt(dtVec.size());
  UInt_t intSqrt = (UInt_t)(racine+1);

  deltaT.Divide(intSqrt,intSqrt);
  
  UInt_t index = 1;

  for (vector<TH1I* >::const_iterator iterC = dtVec.begin(); iterC != dtVec.end(); iterC++)
  {
    TH1I *hist = *iterC;
    if ( hist )
    { 
      if ( index % 2 == 0) deltaT.GetPad(index)->SetLogx();
      deltaT.GetPad(index)->SetLogy();
      deltaT.cd(index);
      index++;
      hist->Draw();
    }
  }
  deltaT.Write();


  for ( map<unsigned int,TH1F*>::const_iterator iterC = tempAsu1Map.begin(); iterC != tempAsu1Map.end(); iterC++)
  {
    UInt_t difId = (*iterC).first;
    string title("temperature_dif_");
    Toolbox::addIntToString(title,difId);
    TCanvas temperature(title.c_str());
    temperature.Divide(3);

    TH1F *asu1 = (*iterC).second;
    TH1F *asu2 = tempAsu2Map.find(difId)->second;
    TH1F *dif = tempDifMap.find(difId)->second;
    
    if ( asu1 )  { temperature.cd(1); asu1->Draw(); } 
    if ( asu2 )  {  temperature.cd(2); asu2->Draw(); } 
    if ( dif )  {  temperature.cd(3); dif->Draw(); } 
    temperature.Write();
  }


  output.Close();
  f.Close(); 
   

  cout <<endl << endl << "Done" << endl;
  
return 0;
}

---