STB/TFndStbMon.cxx

// @(#)fROOT/STB:$Name:  $:$Id: TFndStbMon.cxx,v 1.27 2007/09/24 07:32:41 Diego_Faso Exp $
// Revision Author: Diego Faso <mailto:faso@to.infn.it>, 2005/06/24
// Original Author: Piergiorgio Cerello <mailto:cerello@to.infn.it>, 2001

//                                                //
//                 TFnsStbMon                     //
//                                                //
//  Base Class for the STB monitoring             //
//   - histograms collection and filling          //
//   - shared memories management                 //
//                                                //
//  (see GTS relative class for descriptions)     //
//                                                //
//                                                //

#include <Riostream.h>
#include <TDirectory.h>
#include <TSystem.h>
#include "TApplication.h"

#include "TFndRun.h"
#include "TFndHStb.h"
#include "TFndHdt.h"
#include "TFndStbMon.h"

ClassImp(TFndStbMon)

//_____________________________________________
TFndStbMon::TFndStbMon(const TString &fmode,Int_t stb_tdc_bins,Double_t stb_tdc_min,Double_t stb_tdc_max):
  shmflg(),fout(),fstb(),
  fShmStbMain(),fShmStbTdc(),
  fMustRecoverHistos(),
  fSharedMemName_Main(),fSharedMemName_Tdc(),fSharedFileName_Main(),fSharedFileName_Tdc(),
  stbmult(),stbmaptdc(),
  stb_pattern(),stbtdc(),stb1d(),stb2d(),fLine()
{
  
  Init();
  OpenSharedFiles(fmode);
  InitHistos(stb_tdc_bins,stb_tdc_min,stb_tdc_max);  







  
}

//_____________________________________________
TFndStbMon::TFndStbMon():
  shmflg(),fout(),fstb(),
  fShmStbMain(),fShmStbTdc(),
  fMustRecoverHistos(),
  fSharedMemName_Main(),fSharedMemName_Tdc(),fSharedFileName_Main(),fSharedFileName_Tdc(),
  stbmult(),stbmaptdc(),
  stb_pattern(),stbtdc(),stb1d(),stb2d(),fLine()
{
  // This constructor was used by the consumer,
  // but now there is no need to open the shared memory
  // in read/update mode here... (Diego - 03/03/2005)
  Init();

}

//_____________________________________________
TFndStbMon::TFndStbMon(TString *filename):
  shmflg(),fout(),fstb(),
  fShmStbMain(),fShmStbTdc(),
  fMustRecoverHistos(),
  fSharedMemName_Main(),fSharedMemName_Tdc(),fSharedFileName_Main(),fSharedFileName_Tdc(),
  stbmult(),stbmaptdc(),
  stb_pattern(),stbtdc(),stb1d(),stb2d(),fLine()
{

  Init();

  fstb = new TFile(filename->Data());
  TString hname;
  hname = "stbmult";
  stbmult = (TH1F *) fstb->Get(hname); 
  hname = "stbmaptdc";
  stbmaptdc = (TH2F *) fstb->Get(hname); 

  for(Int_t i=0;i<K_N_STB_CROWNS;i++) {
    hname = "stb_pattern_";
    hname+=i+1;
    stb_pattern[i] = (TH1F *) fstb->Get(hname);
    for(Int_t j=0;j<K_N_STB_TUBES;j++) {
      hname = "stbtdc_";
      hname+=i+1;
      hname+="_";
      hname+=j+1;
      stbtdc[i][j] = (TH1F *) fstb->Get(hname);
    }
  }

}

//_____________________________________________
TFndStbMon::~TFndStbMon() {
    
  delete fLine;
  delete stb1d;
  delete stb2d;
  delete stbmult;
  delete stbmaptdc;

  for(Int_t i=0;i<K_N_STB_CROWNS;i++) {
    for(Int_t j=0;j<K_N_STB_TUBES;j++) {
      delete stbtdc[i][j];
    }
  }
  
  if(! shmflg){
    if(fstb && fstb->IsOpen()) fstb->Close();
    delete fstb;
  }
    
  if(fout) fout->Close();
  delete fout;

  if(fShmStbMain){ fShmStbMain->Close(); fShmStbMain = 0; }
  else delete fShmStbMain;

  for(Int_t si=0;si<K_N_STB_CROWNS;si++){
    if(fShmStbTdc[si]){ fShmStbTdc[si]->Close(); fShmStbTdc[si] = 0; }
    else delete fShmStbTdc[si];
  }
  
}
//_____________________________________________
void TFndStbMon::Init(){
  
  fSharedMemName_Main   = FROOT::ExpandPathName("$FND_SHR/stb.map");
  fSharedMemName_Tdc[0] = FROOT::ExpandPathName("$FND_SHR/stb_tdc_1.map");
  fSharedMemName_Tdc[1] = FROOT::ExpandPathName("$FND_SHR/stb_tdc_2.map");
  fSharedMemName_Tdc[2] = FROOT::ExpandPathName("$FND_SHR/stb_tdc_3.map");
  fSharedMemName_Tdc[3] = FROOT::ExpandPathName("$FND_SHR/stb_tdc_4.map");
  fSharedMemName_Tdc[4] = FROOT::ExpandPathName("$FND_SHR/stb_tdc_5.map");
  fSharedMemName_Tdc[5] = FROOT::ExpandPathName("$FND_SHR/stb_tdc_6.map");
  
  fSharedFileName_Main   = FROOT::ExpandPathName("stb.file.map");
  fSharedFileName_Tdc[0] = FROOT::ExpandPathName("stb_tdc_1.file.map");
  fSharedFileName_Tdc[1] = FROOT::ExpandPathName("stb_tdc_2.file.map");
  fSharedFileName_Tdc[2] = FROOT::ExpandPathName("stb_tdc_3.file.map");
  fSharedFileName_Tdc[3] = FROOT::ExpandPathName("stb_tdc_4.file.map");
  fSharedFileName_Tdc[4] = FROOT::ExpandPathName("stb_tdc_5.file.map");
  fSharedFileName_Tdc[5] = FROOT::ExpandPathName("stb_tdc_6.file.map");
}

//_____________________________________________
void TFndStbMon::OpenSharedFiles(const TString &fmode){


  TString fhist = "_stb.root";
  shmflg = fndrun->Onlflg();
  cout << "Stb Shm flag is " << shmflg << endl;
  
  TString stbnam_str = (fmode.IsNull())? "ONLM" : fmode;
  stbnam_str+=fhist;
  
  fstb = new TFile(stbnam_str.Data(),"RECREATE","Stb Histogram File");   
  
  if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
    fShmStbMain = TMapFile::Create(fSharedMemName_Main,"RECREATE",(Int_t)(1048576*FROOT::K_StbMapSize),"Stb memory mapped file with histograms");
    fShmStbMain->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
    if(gSystem->AccessPathName(fSharedFileName_Main)){
      Printf("Shared file missing: creating it now...");
      fShmStbMain = new TFile(fSharedFileName_Main,"RECREATE");
    }
    else{
      Printf("Shared file found: histograms will be recovered...");
      fShmStbMain = TFile::Open(fSharedFileName_Main,"UPDATE");
      fMustRecoverHistos = kTRUE;
      //fShmStbMain->ls();
    }
#endif
    
    //   STB   TDC Crowns
    for(Int_t si=0;si<K_N_STB_CROWNS;si++){
#if defined _FND_ONL_USE_MAP_FILES_
      fShmStbTdc[si] = TMapFile::Create(fSharedMemName_Tdc[si],"RECREATE",(Int_t)(1048576*FROOT::K_StbC1MapSize),"Stb memory mapped file with TDC histograms (Crown 1)");
      fShmStbTdc[si]->Print();
#elif defined _FND_ONL_USE_SHARED_FILES_
      if( gSystem->AccessPathName(fSharedFileName_Tdc[si]) && fMustRecoverHistos == kTRUE){
        Printf("Shared file missing: creating it now...");
        fShmStbTdc[si] = new TFile(fSharedFileName_Tdc[si],"RECREATE");
        fMustRecoverHistos = kFALSE;
      }
      else{
        Printf("Shared file found: histograms will be recovered...");
        fShmStbTdc[si] = TFile::Open(fSharedFileName_Tdc[si],"UPDATE");
        //fShmStbTdc[si]->ls();
      }
#endif
    }
  }
  
}

//_____________________________________________
void TFndStbMon::InitHistos(const Int_t &stb_tdc_bins,const Double_t &stb_tdc_min,const Double_t &stb_tdc_max){
  
  TString hnam = "";
  TString htit = "";
  
  if(shmflg) fShmStbMain->cd();
  
  hnam = "stbmult";
  htit = "Stb multiplicity";
  stbmult = (fMustRecoverHistos) ? 
    ((TH1F*) (fShmStbMain->Get(hnam))) :
    new TH1F(hnam,htit,50,-0.5,49.5);
  
  hnam = "stbmaptdc";
  htit = "Stb TDC pattern (Crown vs Tube)";
  stbmaptdc = (fMustRecoverHistos) ? 
    ((TH2F*) (fShmStbMain->Get(hnam))) :
    new TH2F(hnam,htit,K_N_STB_TUBES,0.5,K_N_STB_TUBES + 0.5,K_N_STB_CROWNS,0.5,K_N_STB_CROWNS + 0.5);   
  
  // Define Histogram Parameters

  for (Int_t ll=0;ll<K_N_STB_CROWNS;ll++) {
    hnam.Form("stb_pattern_%d",ll+1);
    htit.Form("Hit Pattern for Crown: %d",ll+1);
    stb_pattern[ll] = (fMustRecoverHistos) ? 
      ((TH1F*) (fShmStbMain->Get(hnam))) :
      new TH1F(hnam,htit,K_N_STB_TUBES,0.5,0.5+K_N_STB_TUBES);
    stb_pattern[ll]->SetFillColor(4); 
  }
  
  //   STB   TDC Crown 1
  for(Int_t si=0;si<K_N_STB_CROWNS;si++){
    if(shmflg) fShmStbTdc[si]->cd();
    
    for (Int_t l=0;l<K_N_STB_TUBES;l++) {
      hnam.Form("stbtdc_%d_%d",si+1,l+1);
      htit.Form("TDC  for Crown: %d Tube: %d",si+1,l+1);
      stbtdc[si][l] = (fMustRecoverHistos) ? 
        ((TH1F*) (fShmStbTdc[si]->Get(hnam))) :
        new TH1F(hnam,htit,stb_tdc_bins,stb_tdc_min,stb_tdc_max);
      stbtdc[si][l]->SetFillColor(6); 
    }
  }

}


//_____________________________________________
void TFndStbMon::Fill() {
  
  TClonesArray *cl = fndrun->GetCurrentHdt()->GetStbHits();
  Fill(*cl);
}

//_____________________________________________
void TFndStbMon::Fill(const TClonesArray &StbHit) {

  Int_t nhstb = StbHit.GetEntries();
  stbmult->Fill((Float_t) nhstb);
  
  for (Int_t j=0; j<nhstb; j++) {
    TFndHStb *hstb = (TFndHStb*) StbHit[j];
    Int_t crown = hstb->GetCrown();
    Int_t tube =  hstb->GetTube();
    Float_t tdc = (Float_t) hstb->GetTdc();

    if(tdc <0) continue;
    
    stbmaptdc->Fill((Float_t ) tube,(Float_t ) crown);
    stbtdc[crown-1][tube-1]->Fill(tdc);
    stb_pattern[crown-1]->Fill((Float_t) tube);
    
  }
}

//_____________________________________________
void TFndStbMon::Update(Bool_t purge) {

  if(!shmflg) return; 
  
#if defined _FND_ONL_USE_MAP_FILES_
  Info("TFndStbMon::Update","1");
  if( fShmStbMain && fShmStbMain->IsWritable() ) fShmStbMain->Update();


  for(Int_t si=0;si<K_N_STB_CROWNS;si++){
    if( fShmStbTdc[si] && fShmStbTdc[si]->IsWritable() ) fShmStbTdc[si]->Update();
  }
#elif defined _FND_ONL_USE_SHARED_FILES_
  WriteToFile(0,kTRUE);
  
  fShmStbMain->cd();
  if(purge) fShmStbMain->Purge();
  fShmStbMain->Flush();
  //
  for(Int_t si=0;si<K_N_STB_CROWNS;si++){
    fShmStbTdc[si]->cd();
    if(purge) fShmStbTdc[si]->Purge();
    fShmStbTdc[si]->Flush();
  }

  // --- copy shared files from here to shared directory
  //     (NFS safe)
  TString comm_cp = "";
  comm_cp.Form("cp ./stb.file.map %s",FROOT::ExpandPathName("$FND_SHR/stb.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./stb_tdc_1.file.map %s",FROOT::ExpandPathName("$FND_SHR/stb_tdc_1.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./stb_tdc_2.file.map %s",FROOT::ExpandPathName("$FND_SHR/stb_tdc_2.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./stb_tdc_3.file.map %s",FROOT::ExpandPathName("$FND_SHR/stb_tdc_3.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./stb_tdc_4.file.map %s",FROOT::ExpandPathName("$FND_SHR/stb_tdc_4.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./stb_tdc_5.file.map %s",FROOT::ExpandPathName("$FND_SHR/stb_tdc_5.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./stb_tdc_6.file.map %s",FROOT::ExpandPathName("$FND_SHR/stb_tdc_6.file.map").Data());
  gSystem->Exec(comm_cp);


#endif  
  
  Info("Update","STB histograms updated (producer)");
  
}

//_____________________________________________
void TFndStbMon::ResetHistos(){

  stbmult->Reset();
  stbmaptdc->Reset();

  for(Int_t i=0; i<K_N_STB_CROWNS; i++) {
    stb_pattern[i]->Reset();
    for(Int_t j=0; j<K_N_STB_TUBES; j++) {
      stbtdc[i][j]->Reset();
    }
  }

}

//_____________________________________________
void TFndStbMon::WriteToFile(TString file,Bool_t IsShared) {

  if(IsShared){
    fShmStbMain->cd();
  }
  else{
    if(file.IsNull()) 
      fstb->cd();
    else {
      fout = new TFile(file.Data(),"RECREATE","Lmd Histogram File");
      fout->cd();
    }
  }
  
  stbmult->Write();
  stbmaptdc->Write();
  for(Int_t i=0; i<K_N_STB_CROWNS; i++) stb_pattern[i]->Write();


  
  for(Int_t i=0; i<K_N_STB_CROWNS; i++) {
    if(IsShared){
      fShmStbTdc[i]->cd();
    }
    for(Int_t j=0; j<K_N_STB_TUBES; j++) {
      stbtdc[i][j]->Write();
    }
  }
  if(!file.IsNull()) fout->Close();
  delete fout; fout = 0;
}

//_____________________________________________
void TFndStbMon::Add(TFndStbMon *stbmon) {

  stbmult->Add((const TH1 *) stbmon->StbMult()); // STB multiplicity
  stbmaptdc->Add((const TH2 *) stbmon->StbMapTdc());  // STB TDC pattern
  for (Int_t i=0;i<K_N_STB_CROWNS;i++) {    
    stb_pattern[i]->Add((const TH1 *) stbmon->StbPattern(i+1)); // hit pattern for various crowns
    for (Int_t j=0;j<K_N_STB_TUBES;j++) {     
      stbtdc[i][j]->Add((const TH1 *) stbmon->StbTdc(i+1,j+1)); // TDCs 
    } 
  }
}

//_____________________________________________
// void TFndStbMon::TimeCalibration(){
//   cout << " ...calibrating t0..." << endl;
//   for(Int_t i=1; i<=K_N_STB_CROWNS; i++) TimeCalibration(i);
//   cout << " ...calibration completed..." << endl;
// }

//_____________________________________________
// void TFndStbMon::TimeCalibration(Int_t crown){
//   for(Int_t i=1; i<=K_N_STB_TUBES; i++) TimeCalibration(crown,i);
// }

//_____________________________________________
// void TFndStbMon::TimeCalibration(Int_t crown, Int_t tube){
//   Int_t flagSum = 0;
//   Int_t flagDesc = 0;
//   if(crown < 1 || crown > K_N_STB_CROWNS) {
//     cout << "Wrong crown number" << endl;
//     return;
//   }
//   if(tube < 1 || tube > K_N_STB_TUBES) {
//     cout << "Wrong tube number" << endl;
//     return;
//   }
//   ZeroTime[crown-1][tube-1] = 0.;

//   Int_t stb_tdc_bins = stbtdc[crown-1][tube-1]->GetNbinsX();
//   Float_t Entries = stbtdc[crown-1][tube-1]->GetEntries();
//   //Float_t binsize = stbtdc[crown-1][tube-1]->GetBinWidth(1);
//   //  Float_t stb_tdc_min = stbtdc[crown-1][tube-1]->GetBinLowEdge(1);
//   //  Float_t stb_tdc_max = stbtdc[crown-1][tube-1]->GetBinLowEdge(stb_tdc_bins) + binsize;

//   Int_t max = 0;
//   Float_t tmax = 0.;
//   Int_t bmax = 0;
//   for(Int_t nb=0; nb<stb_tdc_bins; nb++) {
//     Int_t cont = (Int_t) stbtdc[crown-1][tube-1]->GetBinContent(nb+1);
//     if(cont >= max) { 
//       max = cont; 
//       bmax = nb+1; 
//       tmax = stbtdc[crown-1][tube-1]->GetBinCenter(nb+1); 
//     }
//   }
//   Float_t tflex = 0.;
//   Stat_t flexbincont = 0;
//   Stat_t dndtmin = 0; 
//   for(Int_t n=bmax+1; n<stb_tdc_bins-3; n++) {
//     Stat_t dndt = (Int_t) stbtdc[crown-1][tube-1]->GetBinContent(n+1) - stbtdc[crown-1][tube-1]->GetBinContent(n-1);
//     if(dndt <= dndtmin) {
//       dndtmin = dndt;
//       tflex =  stbtdc[crown-1][tube-1]->GetBinCenter(n);
//       flexbincont = stbtdc[crown-1][tube-1]->GetBinContent(n); 
      
//       Stat_t sumdown = 0;
//       Stat_t sumup = 0;
//       for(Int_t i=0;i<100;i++){
//      sumdown = sumdown + stbtdc[crown-1][tube-1]->GetBinContent(n-i);
//      sumup = sumup + stbtdc[crown-1][tube-1]->GetBinContent(n+i+1);

// //        Stat_t sumdown = stbtdc[crown-1][tube-1]->GetBinContent(n-6) + stbtdc[crown-1][tube-1]->GetBinContent(n-5)+ stbtdc[crown-1][tube-1]->GetBinContent(n-4) + stbtdc[crown-1][tube-1]->GetBinContent(n-3) + stbtdc[crown-1][tube-1]->GetBinContent(n-2) + stbtdc[crown-1][tube-1]->GetBinContent(n-1) + stbtdc[crown-1][tube-1]->GetBinContent(n);
// //        Stat_t sumup = stbtdc[crown-1][tube-1]->GetBinContent(n+1) + stbtdc[crown-1][tube-1]->GetBinContent(n+2) + stbtdc[crown-1][tube-1]->GetBinContent(n+3) + stbtdc[crown-1][tube-1]->GetBinContent(n+4) + stbtdc[crown-1][tube-1]->GetBinContent(n+5) + stbtdc[crown-1][tube-1]->GetBinContent(n+6) + stbtdc[crown-1][tube-1]->GetBinContent(n+7) ;
//       }
//       if(flexbincont != 0 && sumup > sumdown) {
//      flagSum = 1;
//      dndtmin = 0;
//      flexbincont =0;
//      tflex = 0;
//       }
      
//       for(Int_t i=2;i<3;i++){
//      if(stbtdc[crown-1][tube-1]->GetBinContent(n+i) > stbtdc[crown-1][tube-1]->GetBinContent(n+1)) {
//        dndtmin = 0;
//        flexbincont =0;
//        tflex = 0;
//        flagDesc = 1;
//      } 
//       }
//     }
//   }
//   if(Entries < 150){
//     tflex = 0;
//     //  cout << " Low entries for " << crown << " - " << tube << endl;
//   }  
//   //  if(flagSum) cout << " sumup > sumdown for " << crown << " - " << tube << endl;
//   //  if(flagDesc) cout << " No descending for " << crown << " - " << tube << endl;
//   ZeroTime[crown-1][tube-1] = tflex;
//   cout << "Crown: " << crown << ", Tube: " << tube << ", TZero: " << ZeroTime[crown-1][tube-1] << endl;
// }
/*
  TH1F *TFndStbMon::TimeMap() {
  
  char hname[20];
  char htitle[80];
  
  sprintf(hname,"Stb_Time_Map");
  sprintf(htitle,"TDC Calibration for stb:");
  
  TH1F *pattern = new TH1F(hname,htitle,4,0.5,4.5);
  pattern->SetFillColor(4);
  
  for(Int_t j=0; j<2; j++) 
  for (Int_t i=0; i<2 ; i++) 
  pattern->Fill(j+1+i*2,ZeroTime[j][i]);    
  return pattern;
  }
*/

//_____________________________________________
// void TFndStbMon::WriteTimeToMsql(){
//   TString *stb_cal_file = new TString("stb_calibration.msql");
//   cout << "Write Stb Msql Calibration file" << endl;
//   FILE *fstbcal;
//   fstbcal = fopen(stb_cal_file->Data(),"w+");
//   fprintf(fstbcal,"# Host: localhost    Database: stbdb\n");
//   fprintf(fstbcal,"# Table structure for table 'time_cal'\n");
//   fprintf(fstbcal,"CREATE TABLE time_cal (\n");
//   fprintf(fstbcal,"  w INT,\n");
//   fprintf(fstbcal,"  A INT,\n");
//   fprintf(fstbcal,"  Z INT,\n");
//   fprintf(fstbcal,"  t0_ue FLOAT,\n");
//   fprintf(fstbcal,"  t0_uo FLOAT,\n");
//   fprintf(fstbcal,"  t0_de FLOAT,\n");
//   fprintf(fstbcal,"  t0_do FLOAT,\n");
//   fprintf(fstbcal,") g\n");
//   fprintf(fstbcal,"# Dumping data for table 'time_cal'\n");

//   Int_t start_time = 11111;
//   Int_t stop_time = 2000000000;
  
//   for(Int_t i=0; i<K_N_STB_CROWNS;i++){ 
//     for(Int_t j=0; j<K_N_STB_TUBES;j++){ 
//       TString line_start = TString("INSERT INTO time_cal VALUES (");
//       Int_t tube = 1000*(i+1)+j+1;
      
//       line_start+=tube;
//       line_start+=",";
//       line_start+=start_time;
//       line_start+=",";
//       line_start+=stop_time;
//       line_start+=",";
//       line_start+=ZeroTime[i][j];
//       line_start+=",";
//       line_start+=ZeroTime[i][j];
//       line_start+=",";
//       line_start+=ZeroTime[i][j];
//       line_start+=",";
//       line_start+=ZeroTime[i][j];
//       line_start+=")g";
//       fprintf(fstbcal,"%s\n",line_start.Data());
//     }
//   }
//   fclose(fstbcal);
// }

---