SIL/TFndSilMon.cxx

// @(#)fROOT/SIL:$Name:  $:$Id: TFndSilMon.cxx,v 1.31 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>, 2002

//                                             //
//                 TFndSilMon                  //
//                                             //
// Base class fir of the Sil  online monitor   //
//   - Histograms collection and filling       //
//   - Shared memories management              //
//                                             //
//  see GTS relative class for documentation   //
//                                             //

//#include <math.h>
#include <Riostream.h>

#include "TFndHdt.h"
#include "TFndSilMon.h"

ClassImp(TFndSilMon)

  //________________________________
  TFndSilMon::TFndSilMon():
    shmflg(),fout(),fDet(),fsil(),msil(),
    fMustRecoverHistos(),fSharedMemName(),fSharedFileName(),
    fH_Sil_Noise(),fH_Sil_Mult(),fH_Sil_ClCh(),fH_Sil_CMsigma(),fH_Sil_CMmean(),
    fH_Sil_CleanMult(),fH_Sil_ClChClean(),fH_Sil_dEdx(),fH_Sil_dEdx_PvsZ(),fH_Sil_Pos_PvsZ()
{
  //
  Init();

}

//________________________________
TFndSilMon::TFndSilMon(const TString &fmode, Int_t det):
  shmflg(),fout(),fDet(det),fsil(),msil(),
  fMustRecoverHistos(),fSharedMemName(),fSharedFileName(),
  fH_Sil_Noise(),fH_Sil_Mult(),fH_Sil_ClCh(),fH_Sil_CMsigma(),fH_Sil_CMmean(),
  fH_Sil_CleanMult(),fH_Sil_ClChClean(),fH_Sil_dEdx(),fH_Sil_dEdx_PvsZ(),fH_Sil_Pos_PvsZ()
{
  
  //  fDet = det;
  Init();
  OpenSharedFiles(fmode);
  InitHistos();

}

//________________________________
TFndSilMon::~TFndSilMon() {

  // delete histo;
  for(Int_t lay =0 ; lay <=1 ; lay ++){
    for(Int_t mod = 0; mod < K_N_Sil_Modules; mod++){
      for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
        delete fH_Sil_Noise[lay][mod][sid];
        delete fH_Sil_Mult[lay][mod][sid];
        delete fH_Sil_ClCh[lay][mod][sid];
        delete fH_Sil_CMsigma[lay][mod][sid];
        delete fH_Sil_CMmean[lay][mod][sid];
        if(sid<2){
          delete fH_Sil_CleanMult[lay][mod][sid];
          delete fH_Sil_ClChClean[lay][mod][sid];
          delete fH_Sil_dEdx[lay][mod][sid];
        }
      }
      delete fH_Sil_dEdx_PvsZ[lay][mod];
      delete fH_Sil_Pos_PvsZ[lay][mod];
    }
  }
  
  // all histos deleted

  if(! shmflg) {
    if(fsil && fsil->IsOpen()) fsil->Close();
    delete fsil;
  }
  
  if(fout && fout->IsOpen()) fsil->Close();
  delete fout;

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

//________________________________
void TFndSilMon::Init() {

  fSharedMemName[0] = FROOT::ExpandPathName("$FND_SHR/ism.map");
  fSharedMemName[1] = FROOT::ExpandPathName("$FND_SHR/osm.map");
  fSharedFileName[0]= FROOT::ExpandPathName("ism.file.map");
  fSharedFileName[1]= FROOT::ExpandPathName("osm.file.map");
  
}

//________________________________
void TFndSilMon::OpenSharedFiles(const TString &fmode) {
  
  shmflg = fndrun->Onlflg();
  cout << "Sil Shm flag is " << shmflg << endl;
  
  TString fsilnam =  (fmode.IsNull())? "ONLM" : fmode;
  if(fDet == (Int_t) E_FIN_INNER_LAYER) fsilnam+="_ism.root";
  else if(fDet == (Int_t) E_FIN_OUTER_LAYER) fsilnam+="_osm.root";
  else cout << "Wrong detector number" << endl;
  fsil = new TFile(fsilnam.Data(),"RECREATE","Sil Histogram File");   
  
  // ---
  if(shmflg) {
    cout << "create shared memory" << endl;    
    switch(fDet){
    case (Int_t) E_FIN_INNER_LAYER: // isim
#if defined _FND_ONL_USE_MAP_FILES_
      msil = TMapFile::Create(fSharedMemName[0],"RECREATE",(Int_t)(1048576*FROOT::K_IsimMapSize),"Isim memory mapped file with histograms"); 
#elif defined _FND_ONL_USE_SHARED_FILES_
      if(gSystem->AccessPathName(fSharedFileName[0])){
        cout << "Shared file missing: creating it now..." << endl;
        msil = new TFile(fSharedFileName[0],"RECREATE");
      }
      else{
        cout << "Shared file found: histograms will be recovered..." << endl;
        msil = TFile::Open(fSharedFileName[0],"UPDATE");
        fMustRecoverHistos = kTRUE;
        //msil->ls();
      }
#endif
      break;
    case (Int_t) E_FIN_OUTER_LAYER: // osim
#if defined _FND_ONL_USE_MAP_FILES_
      msil = TMapFile::Create(fSharedMemName[1],"RECREATE",(Int_t)(1048576*FROOT::K_OsimMapSize),"Osim memory mapped file with histograms"); 
#elif defined _FND_ONL_USE_SHARED_FILES_
      if(gSystem->AccessPathName(fSharedFileName[1])){
        cout << "Shared file missing: creating it now..." << endl;
        msil = new TFile(fSharedFileName[1],"RECREATE");
      }
      else{
        cout << "Shared file found: histograms will be recovered..." << endl;
        msil = TFile::Open(fSharedFileName[1],"UPDATE");
        fMustRecoverHistos = kTRUE;
        //msil->ls();
      }
#endif
      break;
    default:    
      Error("","Wrong detector number (%d)",fDet);
      msil = 0;
      TerminateFroot();
    }
    if(msil) msil->Print();
  }

}

//________________________________
void TFndSilMon::InitHistos() {

  TString hnam = "";  
  TString htit = "";
  
  Float_t patt_edges[2] = { -0.5 , 1023.5}; // limits for pattern/multiplicity histos
  Float_t clus_edges[2] = { -0.5 , 1023.5}; // limits for cluster histos
  Float_t CM_edges[2]   = { -0.5 ,    7.5}; // limits for common-mode histos
  //--- now relative bins
  Int_t patt_bins = (Int_t)( patt_edges[1] - patt_edges[0] );
  Int_t clus_bins = (Int_t)( clus_edges[1] - clus_edges[0] ); 
  Int_t CM_bins   = (Int_t)(   CM_edges[1] -   CM_edges[0] ); 
  
  if(shmflg) msil->cd();
  // Define Histograms
  TString CluHNam = "";
  TString CluHTit = "";
  
  TString det_nam = "";
  Int_t lay_idx  = 0;
  if(fDet == (Int_t) E_FIN_INNER_LAYER ){
    lay_idx  = 0;
    det_nam = "Isim";
  }
  else{
    lay_idx  = 1;
    det_nam = "Osim"; 
  }
  //
  for(Int_t mod = 0; mod < K_N_Sil_Modules; mod++){
    if(fDet == (Int_t) E_FIN_INNER_LAYER && mod > 7) break; // this is ISIM
    for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
      
      hnam.Form("%sNoise_%d_%s",det_nam.Data(),mod+1,SilSide_Name(sid).Data());
      htit.Form("%s Noise (mod %d, side %s)",det_nam.Data(),mod+1,SilSide_Name(sid).Data());
      fH_Sil_Noise[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
        ((TH1F*) (msil->Get(hnam))) :
        new TH1F(hnam,htit,patt_bins,patt_edges[0],patt_edges[1]);

      hnam.Replace(4,5,"Mult");
      htit.Replace(5,5,"Mult");
      fH_Sil_Mult[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
        ((TH1F*) (msil->Get(hnam))) :
        new TH1F(hnam,htit,patt_bins,patt_edges[0],patt_edges[1]);

      hnam.Replace(4,4,"ClustCharge");
      htit.Replace(5,4,"Clust-Charge");
      fH_Sil_ClCh[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
        ((TH1F*) (msil->Get(hnam))) :
        new TH1F(hnam,htit,clus_bins,clus_edges[0],clus_edges[1]);
        
      hnam.Replace(4,11,"CM_sigma");
      htit.Replace(5,12,"CM sigma");
      fH_Sil_CMsigma[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
        ((TH1F*) (msil->Get(hnam))) :
        new TH1F(hnam,htit,CM_bins,CM_edges[0],CM_edges[1]);

      hnam.Replace(4,8,"CM_mean");
      htit.Replace(5,8,"CM mean");
      fH_Sil_CMmean[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
        ((TH1F*) (msil->Get(hnam))) :
        new TH1F(hnam,htit,CM_bins,CM_edges[0],CM_edges[1]);
      
      if(sid < 2){//fH_Sil_CleanMult
        TString sidnam = ( sid == 0 ) ? "PHI" : "Z";
        //
        CluHNam.Form("%s_CleanMult_%d_%s",det_nam.Data(),mod+1,sidnam.Data() );
        CluHTit.Form("%s Clean Mult. (mod %d, side %s)",det_nam.Data(),mod+1,sidnam.Data() );
        fH_Sil_CleanMult[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
          ((TH1F*) (msil->Get(CluHNam))) :
          new TH1F(CluHNam,CluHTit,clus_bins,clus_edges[0], ( (sid+1) * clus_edges[1]) + (sid * 0.5) );
          
        CluHNam.Form("%s_ClustChClean_%d_%s",det_nam.Data(),mod+1,sidnam.Data() );
        CluHTit.Form("%s Clust.Charge Clean (mod %d, side %s)",det_nam.Data(),mod+1,sidnam.Data() );
        fH_Sil_ClChClean[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
          ((TH1F*) (msil->Get(CluHNam))) :
          new TH1F(CluHNam,CluHTit,clus_bins,clus_edges[0],clus_edges[1] );
          
        CluHNam.Form("%s_dEdx_%d_%s",det_nam.Data(),mod+1,sidnam.Data() );
        CluHTit.Form("%s dEdx (mod %d, side %s)",det_nam.Data(),mod+1,sidnam.Data() );
        fH_Sil_dEdx[lay_idx][mod][sid] = (fMustRecoverHistos) ? 
          ((TH1F*) (msil->Get(CluHNam))) :
          new TH1F(CluHNam,CluHTit,clus_bins,clus_edges[0],clus_edges[1]);
      }
        
      if(sid == 0){
        CluHNam.Form("%s_dEdx_PvsZ_%d",det_nam.Data(),mod+1 );
        CluHTit.Form("%s dEdx PvsZ (mod %d)",det_nam.Data(),mod+1 );
        fH_Sil_dEdx_PvsZ[lay_idx][mod] = (fMustRecoverHistos) ? 
          ((TH2F*) (msil->Get(CluHNam))) :
          new TH2F(CluHNam,CluHTit,200,clus_edges[0],clus_edges[1],200,clus_edges[0],clus_edges[1]);    

        CluHNam.Form("%s_Pos_PvsZ_%d",det_nam.Data(),mod+1 );
        CluHTit.Form("%s Pos PvsZ (mod %d)",det_nam.Data(),mod+1 );

        fH_Sil_Pos_PvsZ[lay_idx][mod] = (fMustRecoverHistos) ? 
          ((TH2F*) (msil->Get(CluHNam))) :
          new TH2F(CluHNam,CluHTit,982,-9.82,9.82,526,-2.63,2.63);      
      }


    }
  }
  
  //
  // Reset Common Mode
  //
  if(fDet == (Int_t) E_FIN_INNER_LAYER){  //ISIM
    for(Int_t nchip = 0; nchip < (Int_t) K_N_Sil_AdcChips; nchip++)
      for(Int_t nside = 0; nside < (Int_t) K_N_Sil_Sides; nside++)
        for(Int_t nmod = 1; nmod < (Int_t) K_N_Sil_Modules+1; nmod++)
          SetZeroCommonMode(nchip,nside,nmod,1);
  } else if(fDet == (Int_t) E_FIN_OUTER_LAYER) {  //OSIM
    for(Int_t nchip = 0; nchip < (Int_t) K_N_Sil_AdcChips; nchip++)
      for(Int_t nside = 0; nside < (Int_t) K_N_Sil_Sides; nside++)
        for(Int_t nmod = 1; nmod < (Int_t) K_N_Sil_Modules+1; nmod++)
          SetZeroCommonMode(nchip,nside,nmod,2);
  }

}

//________________________________
void TFndSilMon::Fill() {

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

} 

//________________________________
void TFndSilMon::Fill(const TClonesArray &SilClus) {

  Int_t nhits = SilClus.GetEntries();
  //  
  if(fDet == (Int_t) E_FIN_INNER_LAYER){  //ISIM
    for(Int_t mod = 0; mod < 8; mod++){
      for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
        //Printf("value:  lay %d mod %d sid %d", fDet, mod, sid);
        // loop on adc channels
        for (Int_t bina=1; bina <= fH_Sil_Noise[0][mod][sid]->GetNbinsX(); bina++)  {
          fH_Sil_Noise[0][mod][sid]->SetBinContent(bina,((TFndRun::fgFinHdt->GetSilNoise(bina-1,sid,mod+1,1) != 0) ? ((Double_t) TFndRun::fgFinHdt->GetSilNoise(bina-1,sid,mod+1,1) / (Double_t) K_N_Sil_MulNoise) : 0 ));
          //fH_Sil_Noise[0][mod][sid]->SetBinContent(bina,(Double_t) 1.0);
        }
        // loop on chips
        for (Int_t bina=1; bina <= fH_Sil_CMsigma[0][mod][sid]->GetNbinsX(); bina++)  {
          FillCommonMode(bina-1,sid,mod+1,1,TFndRun::fgFinHdt->GetIntSilComMod_mean(bina-1,sid,mod+1,1)) ;
          fH_Sil_CMsigma[0][mod][sid]->SetBinContent(bina, GetSigmaCommonMode(bina-1,sid,mod+1,1));
          fH_Sil_CMmean[0][mod][sid]->SetBinContent(bina, GetMeanCommonMode(bina-1,sid,mod+1,1));
        }
      }
    } 
    // --- ISIM filling completed (clusters will follow)   
  }
  //
  else if(fDet == (Int_t) E_FIN_OUTER_LAYER){  //OSIM
    for(Int_t mod = 0; mod < K_N_Sil_Modules; mod++){
      for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
        //      Printf("value:  lay %d mod %d sid %d", 1, mod, sid);
        // loop on adc channels
        for (Int_t bina=1; bina <= fH_Sil_Noise[1][mod][sid]->GetNbinsX(); bina++)  {
          fH_Sil_Noise[1][mod][sid]->SetBinContent(bina,((TFndRun::fgFinHdt->GetSilNoise(bina-1,sid,mod+1,2) != 0) ? ((Double_t) TFndRun::fgFinHdt->GetSilNoise(bina-1,sid,mod+1,2) / (Double_t) K_N_Sil_MulNoise) : 0 ));
          //fH_Sil_Noise[1][mod][sid]->SetBinContent(bina,(Double_t) 1.0);
        }
        // loop on chips
        for (Int_t bina=1; bina <= fH_Sil_CMsigma[1][mod][sid]->GetNbinsX(); bina++)  {
          FillCommonMode(bina-1,sid,mod+1,2,TFndRun::fgFinHdt->GetIntSilComMod_mean(bina-1,sid,mod+1,2)) ;
          fH_Sil_CMsigma[1][mod][sid]->SetBinContent(bina, GetSigmaCommonMode(bina-1,sid,mod+1,2));
          fH_Sil_CMmean[1][mod][sid]->SetBinContent(bina, GetMeanCommonMode(bina-1,sid,mod+1,2));
        }
      }
    } 
    // --- OSIM filling completed (clusters will follow)
  }
  //
  else{ // must not occur
    Error("Fill","Wrong layer selected");
    TerminateFroot();
  }
 
  // CLUSTERS //

  TFndHSilCluster *hsil = 0;
  for (Int_t j=0; j<nhits; j++) {
    hsil = (TFndHSilCluster*) SilClus[j];
    //    hsil->PrintHit(3);
    
    // remember not to fill ISIM histos with OSIM clusters
    //  or vice-versa ( see next line )
    if(fDet != hsil->GetLayer()) continue;

    // Now fill histograms using "hsil"    
    if(fDet == (Int_t) E_FIN_INNER_LAYER){  //ISIM
      // --- fill ISIM cluster histos
      // Printf("value fill histos:  lay %d mod %d ", hsil->GetLayer(), hsil->GetModNum());
      //
      if (hsil->GetPhiClusterSignal() > -1.)  fH_Sil_ClCh[0][hsil->GetModNum() - 1][0]->Fill(hsil->GetPhiClusterSignal());
      if (hsil->GetZetaClusterSignal() > -1.) fH_Sil_ClCh[0][hsil->GetModNum() - 1][( hsil->GetClusterZetaAdcCh() < (Float_t) K_N_Sil_AdcCha) ? 1 : 2]->Fill(hsil->GetZetaClusterSignal()) ;
      if (hsil->GetClusterPhiAdcCh() > -1.)   fH_Sil_Mult[0][hsil->GetModNum() - 1][0]->Fill(hsil->GetClusterPhiAdcCh()) ;
      if (hsil->GetClusterZetaAdcCh() > -1.)  fH_Sil_Mult[0][hsil->GetModNum() - 1][( hsil->GetClusterZetaAdcCh() < (Float_t) K_N_Sil_AdcCha) ? 1 : 2]->Fill(( hsil->GetClusterZetaAdcCh() < (Float_t) K_N_Sil_AdcCha) ? hsil->GetClusterZetaAdcCh()  : hsil->GetClusterZetaAdcCh()  - (Float_t) K_N_Sil_AdcCha) ;
      // --- after clusters control
      if(hsil->GetGoodCl() == 1){
        fH_Sil_CleanMult[0][hsil->GetModNum() - 1][0]->Fill( hsil->GetClusterPhiAdcCh()  );
        fH_Sil_CleanMult[0][hsil->GetModNum() - 1][1]->Fill( hsil->GetClusterZetaAdcCh()  );
        fH_Sil_ClChClean[0][hsil->GetModNum() - 1][0]->Fill( hsil->GetPhiClusterSignal()  );
        fH_Sil_ClChClean[0][hsil->GetModNum() - 1][1]->Fill( hsil->GetZetaClusterSignal() ) ;
        fH_Sil_dEdx[0][hsil->GetModNum() - 1][0] ->Fill( hsil->GetDEDxPhi()  );
        fH_Sil_dEdx[0][hsil->GetModNum() - 1][1] ->Fill( hsil->GetDEDxZeta() ) ;
        fH_Sil_dEdx_PvsZ[0][hsil->GetModNum() - 1] ->Fill( hsil->GetDEDxZeta(),hsil->GetDEDxPhi() );
        fH_Sil_Pos_PvsZ[0][hsil->GetModNum() - 1] ->Fill( hsil->GetLocal_Z(),hsil->GetLocal_Y() );
      }

    }
    else if(fDet == (Int_t) E_FIN_OUTER_LAYER){  //OSIM
      // --- fill OSIM cluster histos
      if (hsil->GetPhiClusterSignal() > -1.)  fH_Sil_ClCh[1][hsil->GetModNum() - 1][0]->Fill(hsil->GetPhiClusterSignal());
      if (hsil->GetZetaClusterSignal() > -1.) fH_Sil_ClCh[1][hsil->GetModNum() - 1][( hsil->GetClusterZetaAdcCh() < (Float_t) K_N_Sil_AdcCha) ? 1 : 2]->Fill(hsil->GetZetaClusterSignal()) ;
      if (hsil->GetClusterPhiAdcCh() > -1.)   fH_Sil_Mult[1][hsil->GetModNum() - 1][0]->Fill(hsil->GetClusterPhiAdcCh()) ;
      if (hsil->GetClusterZetaAdcCh() > -1.)  fH_Sil_Mult[1][hsil->GetModNum() - 1][( hsil->GetClusterZetaAdcCh() < (Float_t) K_N_Sil_AdcCha) ? 1 : 2]->Fill(( hsil->GetClusterZetaAdcCh() < (Float_t) K_N_Sil_AdcCha) ? hsil->GetClusterZetaAdcCh()  : hsil->GetClusterZetaAdcCh()  - (Float_t) K_N_Sil_AdcCha) ;
      // --- after clusters control
      if(hsil->GetGoodCl() == 1){
        fH_Sil_CleanMult[1][hsil->GetModNum() - 1][0]->Fill( hsil->GetClusterPhiAdcCh()  );
        fH_Sil_CleanMult[1][hsil->GetModNum() - 1][1]->Fill( hsil->GetClusterZetaAdcCh()  );
        fH_Sil_ClChClean[1][hsil->GetModNum() - 1][0]->Fill( hsil->GetPhiClusterSignal()  );
        fH_Sil_ClChClean[1][hsil->GetModNum() - 1][1]->Fill( hsil->GetZetaClusterSignal() ) ;
        fH_Sil_dEdx[1][hsil->GetModNum() - 1][0] ->Fill( hsil->GetDEDxPhi()  );
        fH_Sil_dEdx[1][hsil->GetModNum() - 1][1] ->Fill( hsil->GetDEDxZeta() ) ;
        fH_Sil_dEdx_PvsZ[1][hsil->GetModNum() - 1] ->Fill( hsil->GetDEDxZeta(),hsil->GetDEDxPhi() );
        fH_Sil_Pos_PvsZ[1][hsil->GetModNum() - 1] ->Fill( hsil->GetLocal_Z(),hsil->GetLocal_Y() );
      }
    }
    else{ // must not occur
      Error("Fill","Wrong layer selected");
      TerminateFroot();
    }
    
  }
  
}

//________________________________
void TFndSilMon::Update(Bool_t purge) {
  if(!shmflg) return;
#if defined _FND_ONL_USE_MAP_FILES_
  if( msil && msil->IsWritable() ) msil->Update();
#elif defined _FND_ONL_USE_SHARED_FILES_
  //  Info("TFndSilMon::Update","writing");
  WriteToFile(0,kTRUE);
  //  Info("TFndSilMon::Update","cd-ing");
  msil->cd();
  //  Info("TFndSilMon::Update","purging");
  if(purge) msil->Purge();
  //  Info("TFndSilMon::Update","flushing");
  msil->Flush();
  //  Info("TFndSilMon::Update","done");


  // --- copy shared files from here to shared directory
  //     (NFS safe)
  TString comm_cp = "";
  comm_cp.Form("cp ./ism.file.map %s",FROOT::ExpandPathName("$FND_SHR/ism.file.map").Data());
  gSystem->Exec(comm_cp);
  comm_cp.Form("cp ./osm.file.map %s",FROOT::ExpandPathName("$FND_SHR/osm.file.map").Data());
  gSystem->Exec(comm_cp);
#endif 

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

}

//________________________________
void TFndSilMon::ResetHistos(){
  //
  // while resetting osim, every isim histogram is
  // initialized to zero
  for(Int_t lay =0 ; lay <=1 ; lay ++){
    for(Int_t mod = 0; mod < K_N_Sil_Modules; mod++){
      for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
        if(fH_Sil_Noise[lay][mod][sid])   fH_Sil_Noise[lay][mod][sid]->Reset();
        if(fH_Sil_Mult[lay][mod][sid])    fH_Sil_Mult[lay][mod][sid]->Reset();
        if(fH_Sil_ClCh[lay][mod][sid])    fH_Sil_ClCh[lay][mod][sid]->Reset();
        if(fH_Sil_CMsigma[lay][mod][sid]) fH_Sil_CMsigma[lay][mod][sid]->Reset();
        if(fH_Sil_CMmean[lay][mod][sid])  fH_Sil_CMmean[lay][mod][sid]->Reset();
        if(sid<2){
          if(fH_Sil_CleanMult[lay][mod][sid])    fH_Sil_CleanMult[lay][mod][sid]->Reset();
          if(fH_Sil_ClChClean[lay][mod][sid])    fH_Sil_ClChClean[lay][mod][sid]->Reset();
          if(fH_Sil_dEdx[lay][mod][sid])    fH_Sil_dEdx[lay][mod][sid]->Reset();
        }
      
      }
      if(fH_Sil_dEdx_PvsZ[lay][mod]) fH_Sil_dEdx_PvsZ[lay][mod]->Reset();
      if(fH_Sil_Pos_PvsZ[lay][mod]) fH_Sil_Pos_PvsZ[lay][mod]->Reset();
    }
  }
  
  
  //
  // Reset Common Mode
  //
  if(fDet == (Int_t) E_FIN_INNER_LAYER){  //ISIM
    for(Int_t nchip = 0; nchip < (Int_t) K_N_Sil_AdcChips; nchip++)
      for(Int_t nside = 0; nside < (Int_t) K_N_Sil_Sides; nside++)
        for(Int_t nmod = 1; nmod < (Int_t) K_N_Sil_Modules+1; nmod++)
          SetZeroCommonMode(nchip,nside,nmod,1);
  } else if(fDet == (Int_t) E_FIN_OUTER_LAYER) {  //OSIM
    for(Int_t nchip = 0; nchip < (Int_t) K_N_Sil_AdcChips; nchip++)
      for(Int_t nside = 0; nside < (Int_t) K_N_Sil_Sides; nside++)
        for(Int_t nmod = 1; nmod < (Int_t) K_N_Sil_Modules+1; nmod++)
          SetZeroCommonMode(nchip,nside,nmod,2);
  }
}

//________________________________
void TFndSilMon::WriteToFile(TString file,Bool_t IsShared) {

  //  cout << "TFndSilMon::WriteToFile called" << endl;

  if(IsShared){
    //    Info("TFndSilMon::WriteToFile","Writing histograms in on-line mode");
    msil->cd();
  }
  else{
    if(file.IsNull()) fsil->cd();
    else {
      fout = new TFile(file.Data(),"RECREATE","Sil Histogram File");
      fout->cd();
    }  
  }

  // while resetting osim, every isim histogram is
  // initialized to zero
  for(Int_t lay =0 ; lay <=1 ; lay ++){
    for(Int_t mod = 0; mod < K_N_Sil_Modules; mod++){
      for(Int_t sid = 0; sid < K_N_Sil_Sides; sid++){
        if(fH_Sil_Noise[lay][mod][sid])   fH_Sil_Noise[lay][mod][sid]->Write();
        if(fH_Sil_Mult[lay][mod][sid])    fH_Sil_Mult[lay][mod][sid]->Write();
        if(fH_Sil_ClCh[lay][mod][sid])    fH_Sil_ClCh[lay][mod][sid]->Write();
        if(fH_Sil_CMsigma[lay][mod][sid]) fH_Sil_CMsigma[lay][mod][sid]->Write();
        if(fH_Sil_CMmean[lay][mod][sid])  fH_Sil_CMmean[lay][mod][sid]->Write();
        if(sid<2){
          if(fH_Sil_CleanMult[lay][mod][sid])    fH_Sil_CleanMult[lay][mod][sid]->Write();
          if(fH_Sil_ClChClean[lay][mod][sid])    fH_Sil_ClChClean[lay][mod][sid]->Write();
          if(fH_Sil_dEdx[lay][mod][sid])    fH_Sil_dEdx[lay][mod][sid]->Write();
        }
      }
      if(fH_Sil_dEdx_PvsZ[lay][mod]) fH_Sil_dEdx_PvsZ[lay][mod]->Write();
      if(fH_Sil_Pos_PvsZ[lay][mod]) fH_Sil_Pos_PvsZ[lay][mod]->Write();
    }
  }
  
  if(!file.IsNull()) fout->Close();
  delete fout; fout = 0;
  
}

---