GTS/TFndGtsMon.cxx

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

//                                          //
//               TFndGtsMon                 //
//                                          //
//  Consumer histograms and shared memories //          
//  Don't create objects of this class if   //
//  you use the TFndGtsMonFrame class,      //
//  otherwise you would open twice the file //
//                                          //

#include <Riostream.h>
#include <TROOT.h>
#include <TSystem.h>
#include <TDirectory.h>
//#include <TObjArray.h>

//#include "FROOT.h"
#include "TFndRun.h"
#include "TFndGtsMon.h"

#include "TFndGtsMon.h"

ClassImp(TFndGtsMon)

  // TClonesArray *TFndGtsMon::fgHisNam = 0;

//___________________________________________
TFndGtsMon::TFndGtsMon(const TString &fmode):
  shmflg(),fout(),fgts(),fGtsMapFile(),
  fHMaluPattern(),fHMaluMult(),fHPU_cont(),fHPU_mult(),fHTrigSel(),
  fHTofinoLow_MT_Patt(),fHTofinoHigh_MT_Patt(),fHTofinoLow_MT_Mult(),fHTofinoHigh_MT_Mult(),
  fHTofone_MT_Patt(),fHTofone_MT_Mult(),
  fMustRecoverHistos(kFALSE),fSharedMemName(),fSharedFileName()
{
  // this the constructor for histogram producer:
  // All histograms are created here, since they must
  // be stored inside the TMapFile pointed by the fGtsMapFile data member
  
  Init();
  OpenSharedFiles(fmode);
  InitHistos();
}

//___________________________________________
TFndGtsMon::TFndGtsMon():
  shmflg(),fout(),fgts(),fGtsMapFile(),
  fHMaluPattern(),fHMaluMult(),fHPU_cont(),fHPU_mult(),fHTrigSel(),
  fHTofinoLow_MT_Patt(),fHTofinoHigh_MT_Patt(),fHTofinoLow_MT_Mult(),fHTofinoHigh_MT_Mult(),
  fHTofone_MT_Patt(),fHTofone_MT_Mult(),
  fMustRecoverHistos(kFALSE),fSharedMemName(),fSharedFileName()
{
  // This constructor was used by the consumer,
  // but now there is no need to open the shared memory
  // in read/update mode here... commented all (Diego - 03/03/2005)

  Init();
  
}

//___________________________________________
TFndGtsMon::TFndGtsMon(TString *filename):
  shmflg(),fout(),fgts(),fGtsMapFile(),
  fHMaluPattern(),fHMaluMult(),fHPU_cont(),fHPU_mult(),fHTrigSel(),
  fHTofinoLow_MT_Patt(),fHTofinoHigh_MT_Patt(),fHTofinoLow_MT_Mult(),fHTofinoHigh_MT_Mult(),
  fHTofone_MT_Patt(),fHTofone_MT_Mult(),
  fMustRecoverHistos(kFALSE),fSharedMemName(),fSharedFileName()
{
  // Start Monitor in read-mode (from a produced ".root" file)
  // You need to use this constructor only if you want to use
  // saved histograms without using thr standard froot GUI.
  // Don't call this constructor if you use the TFndGtsMonFrame class,
  // otherwise you would open twice the file

  Init();  
  fgts = new TFile(filename->Data());

}

//___________________________________________
TFndGtsMon::~TFndGtsMon() {

  //   fHistoNames->Delete();
  //   delete fgHisNam; fgHisNam = 0;
  
  delete fHMaluPattern;
  delete fHMaluMult;
  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    delete fHPU_cont[i];
    delete fHPU_mult[i];
  }
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++) delete fHTrigSel[i];
  
  if(fgts) fgts->Close();
  delete fgts;
  
  if(fout) fout->Close(); 
  delete fout;
  
  if(fGtsMapFile){ fGtsMapFile->Close(); fGtsMapFile = 0; }
  else delete fGtsMapFile;
}

//___________________________________________
void TFndGtsMon::Init(){
  
  fSharedMemName = FROOT::ExpandPathName("$FND_SHR/gts.map");
  fSharedFileName = FROOT::ExpandPathName("./gts.file.map");
}

//___________________________________________
void TFndGtsMon::OpenSharedFiles(const TString &fmode){
  
  TString fhist = "_gts.root";
  
  shmflg = fndrun->Onlflg();
  cout << "Gts Shm flag is " << shmflg << endl;
  
  TString gtsnam_str = (fmode.IsNull()) ? "ONLM": fmode;
  gtsnam_str+=fhist;
  
  fgts = new TFile(gtsnam_str.Data(),"RECREATE","Gts Histogram File");   
  if(shmflg) {
#if defined _FND_ONL_USE_MAP_FILES_
    fGtsMapFile = TMapFile::Create(fSharedMemName,"RECREATE",(Int_t)(1048576*FROOT::K_GtsMapSize),"Gts memory mapped file with histograms");
    fGtsMapFile->Print();    
#elif defined _FND_ONL_USE_SHARED_FILES_
    if(gSystem->AccessPathName(fSharedFileName)){
      cout << "Shared file missing: creating it now..." << endl;
      fGtsMapFile = new TFile(fSharedFileName,"RECREATE");
    }
    else{
      cout << "Shared file found: histograms will be recovered..." << endl;
      fGtsMapFile = TFile::Open(fSharedFileName,"UPDATE");
      fMustRecoverHistos = kTRUE;
      //fGtsMapFile->ls();
    }  
#endif
  }
  
}

//___________________________________________
void TFndGtsMon::InitHistos(){
  
  if(shmflg && !fGtsMapFile){
    Warning("InitHistos","fGtsMapFile not available: exiting method");
    return;
  }
  TString hname;
  TString htitle;

  if(shmflg) fGtsMapFile->cd();
  
  hname = "GtsHist_MaluPattern";
  htitle = "Malu TOF Pattern";
  fHMaluPattern = (fMustRecoverHistos) ?
    ((TH1F*) (fGtsMapFile->Get(hname))) :
    new TH1F(hname,htitle,72,0.5,72.5);
  
  hname = "GtsHist_MaluMultiplicity";
  htitle = "Malu TOF Multiplicity";
  fHMaluMult = (fMustRecoverHistos) ?
    ((TH1F*) (fGtsMapFile->Get(hname))) :
    new TH1F(hname,htitle,72,0.5,72.5);
  
  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    hname.Form("GtsHist_PU_cont_%d",i+1);
    htitle.Form("Pattern Unit %d (bits content)",i+1);
    fHPU_cont[i] = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
      new TH1F(hname,htitle,18,-0.5,17.5);
    
    hname.Form("GtsHist_PU_mult_%d",i+1);
    htitle.Form("Pattern Unit %d (multiplicity)",i+1);
    fHPU_mult[i] =  (fMustRecoverHistos) ?
      ((TH1F*) (fGtsMapFile->Get(hname))) :
      new TH1F(hname,htitle,16,-0.5,15.5);
  }
  
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++){
    hname.Form("GtsHist_TrigSel_%d",i+1);
    htitle.Form("Trigger Selector %d",i+1);
    fHTrigSel[i] = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
      new TH1F(hname,htitle,16,-0.5,15.5);
  }
  //--- 
  // histograms from TOF

  hname  = "GtsHist_TofinoLow_MT_Patt";
  htitle = "TOFINO Mean-timer patt (low th)";
  fHTofinoLow_MT_Patt = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
       new TH1F(hname,htitle,14,-0.5,13.5);

  hname  = "GtsHist_TofinoHigh_MT_Patt";
  htitle = "TOFINO Mean-timer patt (high th)";
  fHTofinoHigh_MT_Patt = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
        new TH1F(hname,htitle,14,-0.5,13.5);

  hname  = "GtsHist_TofinoLow_MT_Mult";
  htitle = "TOFINO Mean-timer mult (low th)";
  fHTofinoLow_MT_Mult = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
         new TH1F(hname,htitle,13,-0.5,12.5);

  hname  = "GtsHist_TofinoHigh_MT_Mult";
  htitle = "TOFINO Mean-timer mult (high th)";
  fHTofinoHigh_MT_Mult = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
         new TH1F(hname,htitle,13,-0.5,12.5);

  hname  = "GtsHist_Tofone_MT_Patt";
  htitle = "TOFONE Mean-timer patt";
  fHTofone_MT_Patt = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
         new TH1F(hname,htitle,74,-0.5,73.5);

  hname  = "GtsHist_Tofone_MT_Mult";
  htitle = "TOFONE Mean-timer mult";
  fHTofone_MT_Mult = (fMustRecoverHistos) ? 
      ((TH1F*) (fGtsMapFile->Get(hname))) :
         new TH1F(hname,htitle,73,-0.5,72.5);
  
  //--- 

}

//___________________________________________
void TFndGtsMon::Fill() {
  
  TFndTrig *fTrig = fndrun->GetCurrentHdt()->GetGts();
  if(fTrig) Fill(fTrig);

  TClonesArray *cl = fndrun->GetCurrentHdt()->GetTofHits();
  if(cl) Fill(*cl);

}

//___________________________________________
void TFndGtsMon::Fill(TFndTrig *fTrig) {
  
  Int_t malu_mult = 0;
  Int_t x_id = 0;
  for(Int_t mnum=0;mnum<K_N_GTS_MALU;mnum++){
    if(x_id > 72) break;
    for(Int_t bit=0;bit<32;bit++){
      x_id = 1 + mnum*32+bit; // slabs numbering starts from 1
      if(x_id > 72) break;
      Short_t content = fTrig->GetMalu_bit(mnum,bit);
      if(content > 0) malu_mult++;
      fHMaluPattern->Fill(x_id,content);
    }
  }
  fHMaluMult->Fill(malu_mult);
  
  Int_t pu_mult[K_N_GTS_P_UNITS] = {0};
  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    for(Int_t bit=0;bit<16;bit++){
      Short_t content = fTrig->GetPU_cont_bit(i,bit);
      fHPU_cont[i]->Fill(bit+1,content);
      if(content > 0) pu_mult[i]++;
    }
    //      fHPU_mult[i]->Fill(fTrig->GetPU_mult(i));
    fHPU_mult[i]->Fill(pu_mult[i]);
  }
  // ---
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++){
    //    for(Int_t bit=0;bit<16;bit++) fHTrigSel[i]->Fill(bit,fTrig->GetTriggerSelector_bit(i,bit));
    fHTrigSel[i]->Fill(fTrig->GetTriggerSelector(i)); // fill with the word content
  }  
}

//___________________________________________
void TFndGtsMon::Fill(const TClonesArray &TofHits){
  // Fill Monitor histograms (from TOF hits)
  
  Int_t sladiv = 12;
  Int_t nhtof = TofHits.GetEntries();
  
  Int_t MT_MulLowFino = 0;
  Int_t MT_MulHighFino = 0;

  Int_t MT_MulFone = 0;

  for (Int_t j=0; j<nhtof; j++) {
    if(nhtof>84) cout << "TFndGtsMon WARNING: TOF number of hits= " << nhtof << " (greater than 84)!!!" << endl;
    TFndHTof *htof = (TFndHTof*) TofHits[j];
    Float_t slb = htof->GetChannel();
    if(slb==0){
      Warning("TFndTofMon","slab out of range...skipping hit");
      continue;
    }
    // --- filling from TOF  
    if(slb <= K_N_TOFINO_SLABS){ // tofino MT
      if(htof->GetLowMeanTimer() > 0){
        fHTofinoLow_MT_Patt->Fill(slb);
        MT_MulLowFino++;
      }
      if(htof->GetHighMeanTimer() > 0){
        fHTofinoHigh_MT_Patt->Fill(slb);
        MT_MulHighFino++;
      }
      
    }
    else if(slb >100 && slb <= 100 + K_N_TOFONE_SLABS){ // tofone MT
      if(htof->GetLowMeanTimer() > 0){
        MT_MulFone++;
        fHTofone_MT_Patt->Fill(slb-100);
      }
    }
    
    //
  }// tof hits loop completed
  fHTofinoLow_MT_Mult->Fill(MT_MulLowFino);
  fHTofinoHigh_MT_Mult->Fill(MT_MulHighFino);
  fHTofone_MT_Mult->Fill(MT_MulFone);
}

//___________________________________________
void TFndGtsMon::Update(Bool_t purge) {
  // Method used by the producer to update
  // the shared memories content (not needed by the consumer)
  
  //  fGtsMapFile->Print();
#if defined _FND_ONL_USE_MAP_FILES_
  if(fGtsMapFile && fGtsMapFile->IsWritable() ) fGtsMapFile->Update();
#elif defined _FND_ONL_USE_SHARED_FILES_
  WriteToFile(0,kTRUE);
  fGtsMapFile->cd();
  if(purge) fGtsMapFile->Purge();
  fGtsMapFile->Flush();
  TString comm_cp = "";
  comm_cp.Form("cp ./gts.file.map %s",FROOT::ExpandPathName("$FND_SHR/gts.file.map").Data());
  gSystem->Exec(comm_cp);

#endif

  Info("Update","GTS histograms updated (producer)");

}

//___________________________________________
void TFndGtsMon::ResetHistos(){
  
  if(fHMaluPattern) fHMaluPattern->Reset();
  if(fHMaluMult) fHMaluMult->Reset();
  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    if(fHPU_cont[i]) fHPU_cont[i]->Reset();
    if(fHPU_mult[i]) fHPU_mult[i]->Reset();
  }
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++) if(fHTrigSel[i]) fHTrigSel[i]->Reset();

  fHTofinoLow_MT_Patt->Reset();
  fHTofinoHigh_MT_Patt->Reset();
  fHTofinoLow_MT_Mult->Reset();
  fHTofinoHigh_MT_Mult->Reset();

  fHTofone_MT_Patt->Reset();
  fHTofone_MT_Mult->Reset();
}

//___________________________________________
void TFndGtsMon::WriteToFile(TString filename,Bool_t IsShared) {
  // IsShared is used to provide support for shared files instead of shared memories
  if(IsShared){
    //    Info("TFndGtsMon::WriteToFile","Writing histograms in on-line mode");
    fGtsMapFile->cd();
  }
  else{
    if(filename.IsNull()) 
      fgts->cd();
    else {
      fout = new TFile(filename.Data(),"RECREATE","Gts Histogram File");
      fout->cd();
    }  
  }

  if(fHMaluPattern) fHMaluPattern->Write();
  if(fHMaluMult) fHMaluMult->Write();
  for(Int_t i=0;i < K_N_GTS_P_UNITS ; i++){
    if(fHPU_cont[i]) fHPU_cont[i]->Write();
    if(fHPU_mult[i]) fHPU_mult[i]->Write();
  }
  for(Int_t i=0;i < K_N_GTS_SELECTORS ; i++) if(fHTrigSel[i]) fHTrigSel[i]->Write();

  fHTofinoLow_MT_Patt->Write();
  fHTofinoHigh_MT_Patt->Write();
  fHTofinoLow_MT_Mult->Write();
  fHTofinoHigh_MT_Mult->Write();

  fHTofone_MT_Patt->Write();
  fHTofone_MT_Mult->Write();
  
}

//___________________________________________
void TFndGtsMon::Add(TFndGtsMon *gtsmon) {
  // If the object has been created in read-mode (TString ctor)
  // you can use this method to sum histograms of different files

  cout << "adding new gtsmon" << endl;

}

---