mcr/SCC/PlotSilCurrents.C

// @(#)fROOT/mcr/SCC:$Name:  $:$Id: PlotSilCurrents.C,v 1.4 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2007/09/18

#ifndef FROOT_TFndSccSilPlot
#define FROOT_TFndSccSilPlot

#include <Riostream.h>
#include "TFile.h"
#include "TFndGraphs.h"
#include "TCanvas.h"
#include "TButton.h"
#include "TDatime.h"

const Int_t ntotmodules = 18;
const Int_t nisimodules =  8;

// interpreter/class shared variables
TFndGraph *fGraphs[ntotmodules];
TFndMultiGraph *fCurMultiGraphs;

TCanvas *fShowCanvas;
TPad *fButPad;
TPad *fDisplayPad;

TButton *fModBut[ntotmodules];
TButton *fAllBut[2]; // for displaying all modules (ISIM or OSIM)


class TFndSccSilPlot : public TNamed
{
private:
  TDatime fCurTime;
  TDatime fStartTime;
  TDatime fStopTime;
  FILE *fRawFile;
  TString fCurFileName; // raw-filename
  
  Int_t fNskip;

  Int_t fReadTime;
  Float_t fReadCur[ntotmodules];
  Int_t fReadInfo[2];
  Float_t fLastInfo;

  Int_t fGRCOL[ntotmodules];

public:
  TFndSccSilPlot(Int_t nskip=0);
  ~TFndSccSilPlot();

  TDatime GetCurTime() { return fCurTime; }
  TDatime GetStartTime() { return fStartTime; }
  TDatime GetStopTime()  { return fStopTime; }
  void SetStartTime(Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec)
  { fStartTime.Set(year,month,day,hour,min,sec); }
  void SetStopTime(Int_t year, Int_t month, Int_t day, Int_t hour, Int_t min, Int_t sec)
  { fStopTime.Set(year,month,day,hour,min,sec) ; }

  void BuildRawFileName();

  void Loop();
  void ScanFile();
  void FillGraphs();
  void PrintBuffers();

  void InitGraphs();

  // --- GUI
  void DisplayModule(const Int_t &mod);
  void DisplayAllModules(const Int_t &lay);
  void DrawShowCanvas();
  void UpdateGUI();

  void ResetDisplay(){
    if(fDisplayPad) fDisplayPad->Clear();
    if(fCurMultiGraphs) fCurMultiGraphs->Reset();
    else fCurMultiGraphs = new TFndMultiGraph("cur_multigraph","");
    //
    fDisplayPad->cd();
  }  

ClassDef(TFndSccSilPlot,1)
};
TFndSccSilPlot *gFndSilPlot;

#endif // FROOT_TFndSccSilPlot

ClassImp(TFndSccSilPlot)

//_______________________________
TFndSccSilPlot::TFndSccSilPlot(Int_t nskip):
  fCurTime(),fStartTime(),fStopTime(),
  fRawFile(),fCurFileName(),
  fNskip(nskip),
  fReadTime(),fReadCur(),fReadInfo(),fLastInfo(),
  fGRCOL()
{
  
  gFndSilPlot = this;
  //  SetName("FinudaSilPlot");
  cout << "ctor called" << endl;
  InitGraphs();
}

//_______________________________
TFndSccSilPlot::~TFndSccSilPlot(){

  cout << "dtor called" << endl;
}

//_______________________________
void TFndSccSilPlot::InitGraphs(){

  fGRCOL[ 0] = kBlack;
  fGRCOL[ 1] = kBlue - 7;
  fGRCOL[ 2] = kBlue;
  fGRCOL[ 3] = kGreen ;
  fGRCOL[ 4] = kGreen -7 ;
  fGRCOL[ 5] = kOrange ;
  fGRCOL[ 6] = kOrange + 10 ;
  fGRCOL[ 7] = kRed -2;
  fGRCOL[ 8] = kRed;
  fGRCOL[ 9] = kTeal + 10;
  //
  fGRCOL[10] = kBlack;
  fGRCOL[11] = kBlue;
  fGRCOL[12] = kGreen;
  fGRCOL[13] = kGreen -7;
  fGRCOL[14] = kOrange;
  fGRCOL[15] = kOrange + 10;
  fGRCOL[16] = kRed -2;
  fGRCOL[17] = kRed;

  TString gnam = "";
  TString gtit = "";
  
  for(Int_t i=0;i<ntotmodules;i++){
    if(i<nisimodules){
      gnam.Form("ISIM_%d",i+1);
      gtit.Form("ISIM %d",i+1);
    }
    else{
      gnam.Form("OSIM_%d",i-7); 
      gtit.Form("OSIM %d",i-7);
    }
    fGraphs[i] = new TFndGraph(gnam,gtit);
    fGraphs[i]->SetMarkerColor(fGRCOL[i]);
    fGraphs[i]->GetXaxis()->SetNdivisions(3);
    fGraphs[i]->GetXaxis()->SetLabelSize(0.02);
  }
  
  fCurMultiGraphs = 0;
  
}

//_______________________________
void TFndSccSilPlot::BuildRawFileName(){

  TString dnam=""; // date used for filename

  dnam=fCurTime.AsSQLString();
  dnam.Resize(10);
  dnam.Remove(4,1);
  dnam.Remove(6,1);
  dnam.Remove(8,1);
  
  //     cout << "fCurTime: " << fCurTime.AsSQLString();
  //     cout << " ( " << dnam << " )." << endl;
  
  fCurFileName.Form("%s/%scur.raw",
            gSystem->ExpandPathName("$FND_SCC_SILCUR"),
            dnam.Data()
            );
  
}

//_______________________________
void TFndSccSilPlot::Loop(){
  
  cout << "Starting loop..." << endl;
  
  fCurTime = fStartTime;
  while (fCurTime.Convert() < fStopTime.Convert()){
    BuildRawFileName();
    cout << "Looking for file: " << fCurFileName.Data() << endl;
    
    if(gSystem->AccessPathName(fCurFileName.Data()) ==0 ){
      cout << "reading file..." << endl;
      fRawFile = fopen(fCurFileName.Data(),"r");
      ScanFile();
      // ---
      fclose(fRawFile);
    }
    else cout << "file not found" << endl;
    // ---
    fCurTime.Set(fCurTime.Convert() + 86400);
  }
  
  
}

//_______________________________
void TFndSccSilPlot::ScanFile(){

  cout << "Scanning file." << endl;
  

  Int_t res = 1;
  Int_t ncols=0;
  while (1){
    fReadTime = 0;
    bzero(fReadCur,sizeof(fReadCur));
    bzero(fReadInfo,sizeof(fReadInfo));
    fLastInfo = 0;  
    //
    res = fscanf(fRawFile,
                 "%d %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %d %d %f",
                 &fReadTime,
                 &fReadCur[0],&fReadCur[1],&fReadCur[2],&fReadCur[3],&fReadCur[4],&fReadCur[5],
                 &fReadCur[6],&fReadCur[7],&fReadCur[8],&fReadCur[9],&fReadCur[10],&fReadCur[11],
                 &fReadCur[12],&fReadCur[13],&fReadCur[14],&fReadCur[15],&fReadCur[16],&fReadCur[17],
                 &fReadInfo[0],&fReadInfo[1],&fLastInfo);
    //
    ncols++;
    
    //    cout << "RES: " << res << endl;
    if(ncols > 500000){
      cout << "MORE THAN 500000 lines: skipping" << endl;
      break;
    }
    if(res < 0) break;
    // --- debug
    //    cout << "ncols: " << ncols << endl;
    if(fNskip != 0 && ncols!=0 && ncols%(fNskip+1) != 0 ) continue;
    FillGraphs();
    //    PrintBuffers();   cout << endl;
    // ---

  }
  
}

//_______________________________
void TFndSccSilPlot::FillGraphs(){

  //  cout << fReadTime << " ";
  for(Int_t i=0;i<ntotmodules;i++){
    // cout << fReadCur[i] << " " ;
    fGraphs[i]->AddPoint(fReadTime,fReadCur[i]);
  }
  //  for(Int_t i=0;i<2;i++) cout << fReadInfo[i] << " ";
}

//_______________________________
void TFndSccSilPlot::PrintBuffers(){
  cout << fReadTime << " ";
  for(Int_t i=0;i<ntotmodules;i++) cout << fReadCur[i] << " " ;
  for(Int_t i=0;i<2;i++) cout << fReadInfo[i] << " ";
  cout << fLastInfo << endl;
}

//_______________________________
void TFndSccSilPlot::DrawShowCanvas(){

  fShowCanvas = new TCanvas("ShowCanvas","Show Canvas",10,10,1400,770);

  fButPad = new TPad("ButPad","Button Pad",0,0,.203,1,20,1,1);
  fDisplayPad = new TPad("DisplayPad","Display Pad",.207,0,1,1,42,1,1);

  fButPad->Draw();
  fDisplayPad->Draw();
    
  // Buttons
  fButPad->cd();

  TString bnam = "";
  TString cmdstr = "";
  Double_t start = 0.01;
  Double_t height = 0.04;
  Double_t gap = 0.003;
  for(Int_t i=0;i<ntotmodules;i++){
    if(i<nisimodules) bnam.Form("ISIM_%d",i+1);
    else{
      if(i==nisimodules) start+=0.04;
      bnam.Form("OSIM_%d",i-7);
    }
    cmdstr.Form("gFndSilPlot->DisplayModule(%d)",i);
    fModBut[i] = new TButton(bnam,cmdstr,0.1,start,0.9,start+height);
    fModBut[i]->Draw();
    start+=(height+gap);
  }
  //
  start+=0.04;
  for(Int_t i=0;i<2;i++){
    bnam = (i==0)? "ALL_ISIM" : "ALL_OSIM";
    cmdstr.Form("gFndSilPlot->DisplayAllModules(%d)",i);
    fAllBut[i] = new TButton(bnam,cmdstr,0.1,start,0.9,start+height);
    fAllBut[i]->Draw();
    start+=(height+gap);
  }  
  // ---
  UpdateGUI();
}

//_______________________________
void TFndSccSilPlot::DisplayModule(const Int_t &mod){

  if(! fGraphs[mod] ){
    cerr << "ERROR: required graph is a NULL pointer!" << endl;
    return;
  }
  if( fGraphs[mod]->GetN() < 2){
    cerr << "WARNING: required graph is empty (less than 2 points)." << endl;
    return;
  }
  

  ResetDisplay();
  
  //   cout << "Displaying module (ID): " << mod << endl;
  //   cout << "============> " <<  fGraphs[mod] << endl;
  //   cout << "============> " <<  fDisplayPad << endl;


  // drawing a multigraph is faster
  // than drawing a graph: enable it if needed
  fCurMultiGraphs->AddFndGraph(fGraphs[mod],"P");
  fCurMultiGraphs->DrawDefaults(kTRUE);
  
  UpdateGUI();
}

//_______________________________
void TFndSccSilPlot::DisplayAllModules(const Int_t &lay){

  cout << "Displaying all modules for layer: " << lay << endl;

  ResetDisplay();
  
  Int_t mod_start = (lay==0) ?           0 : nisimodules;
  Int_t mod_stop  = (lay==0) ? nisimodules : ntotmodules;
    
  for(Int_t mod=mod_start;mod<mod_stop;mod++) fCurMultiGraphs->AddFndGraph(fGraphs[mod],"P");
  fCurMultiGraphs->DrawDefaults(kTRUE);

  UpdateGUI();
}

//_______________________________
void TFndSccSilPlot::UpdateGUI(){

  cout << "Updating GUI..." << endl;

  if(fCurMultiGraphs && fCurMultiGraphs->GetHistogram()){
    fCurMultiGraphs->GetHistogram()->GetXaxis()->SetNdivisions(5);
    fCurMultiGraphs->GetHistogram()->GetXaxis()->SetLabelSize(0.02);
    fCurMultiGraphs->GetHistogram()->GetYaxis()->SetLabelSize(0.03);
  }

  fDisplayPad->cd();
  gPad->Modified();
  gPad->Update();

}

//_______________________________
//_______________________________
//_______________________________
void PlotSilCurrents(const Int_t &y0,const Int_t &m0,const Int_t &d0,const Int_t &y1,const Int_t &m1,const Int_t &d1,Int_t nskip=10){
  // nskip: number of data to be skipped
  //        (fill plot every "nskip" data)
  //
  // examples:
  //        nskip =   0 ===>  6 sec
  //        nskip =  10 ===>  1 min
  //        nskip = 100 ===> 10 min
  //        nskip = 600 ===>  1 hour

  TFndSccSilPlot *silplot = new TFndSccSilPlot(nskip);
  //
  silplot->SetStartTime(y0,m0,d0,0,0,0);
  silplot->SetStopTime(y1,m1,d1,0,0,0);
  
  cout << silplot->GetStartTime().AsString() << endl;
  cout << silplot->GetStopTime().AsString() << endl;
  
  silplot->Loop();

  // --- GUI
  silplot->DrawShowCanvas();
  // ---
  delete silplot;
}

---