[u/mrichter/AliRoot.git] / PHOS / macros / Pedestals / Pedestals.C

#if !defined(__CINT__) || defined(__MAKECINT__)
  #include <TStopwatch.h>
  #include <TStyle.h>
  #include <TFile.h>
  #include <TH1F.h>
  #include <TH2F.h>
  #include <TString.h>
  #include <TCanvas.h>
  #include "TSystem.h"
  #include "TGrid.h"
  #include "AliRawReader.h"
  #include "AliCaloRawStreamV3.h"
  #include "AliLog.h"
  #include "iostream"
using namespace std;

#endif

void Pedestals(const TString rawFile=0)
{
  // Read raw data, decode it to samples,
  // calculate pedestals from presamples, 
  // evaluate the signal amplitude as a maximum sample, 
  // and fill histograms with pedestals and amplitudes
  // This script should be compiled to speed up the data processing:
  // .L Pedestals.C++
  //___
  // Yuri Kharlov. 6 September 2007

  TStopwatch stopwatch;
  stopwatch.Start();
  
  if (rawFile.BeginsWith("alien://")) {
    gSystem->Exec("source /tmp/gclient_env_$UID");
    TGrid::Connect("alien://");
  }

  AliRawReader *reader = AliRawReader::Create(rawFile);
  reader->Reset();

  TStopwatch timer;
  timer.Start();

  AliCaloRawStreamV3 *stream = new AliCaloRawStreamV3(reader,"PHOS");

  TString baseNamePed ="hPed";
  TString baseTitlePed="Ped in cell (";
  const char* sgain[3]={"LG","HG", "TRU"};

  const Int_t caloFlagMax=3,modMax=5,cellXMax=64,cellZMax=56;
  TH1F *hPed[5][3][64][56];
  for (Int_t mod=2; mod<=4; mod++) {
    for (Int_t caloFlag=0; caloFlag<caloFlagMax; caloFlag++) {
      for (Int_t mod=0; mod<modMax; mod++) {
	for (Int_t cellX=0; cellX<cellXMax; cellX++) {
	  for (Int_t cellZ=0; cellZ<cellZMax; cellZ++) {
	    hPed[mod][caloFlag][cellX][cellZ] = 0;
	  }
	}
      }
    }
  }
  TH1F *hPedHiMean1m2 = new TH1F("hPedHiMean1m2","Mean pedestals in module 2, high gain" ,100,0.,100.);
  TH1F *hPedHiRMS1m2  = new TH1F("hPedHiRMS1m2" ,"RMS pedestals in module 2, high gain"  ,100,0.,50.);
  TH1F *hPedLoMean1m2 = new TH1F("hPedLoMean1m2","Mean pedestals in module 2, low gain"  ,100,0.,100.);
  TH1F *hPedLoRMS1m2  = new TH1F("hPedLoRMS1m2" ,"RMS pedestals in module 2, low gain"   ,100,0.,50.);
  TH1F *hPedTRUMean1m2 = new TH1F("hPedTRUMean1m2","Mean pedestals in module 2, TRU"     ,1000,0.,1000.);
  TH1F *hPedTRURMS1m2  = new TH1F("hPedTRURMS1m2" ,"RMS pedestals in module 2, TRU"      ,100,0.,50.);

  TH1F *hPedHiMean1m3 = new TH1F("hPedHiMean1m3","Mean pedestals in module 3, high gain" ,100,0.,100.);
  TH1F *hPedHiRMS1m3  = new TH1F("hPedHiRMS1m3" ,"RMS pedestals in module 3, high gain"  ,100,0.,50.);
  TH1F *hPedLoMean1m3 = new TH1F("hPedLoMean1m3","Mean pedestals in module 3, low gain"  ,100,0.,100.);
  TH1F *hPedLoRMS1m3  = new TH1F("hPedLoRMS1m3" ,"RMS pedestals in module 3, low gain"   ,100,0.,50.);
  TH1F *hPedTRUMean1m3 = new TH1F("hPedTRUMean1m3","Mean pedestals in module 3, TRU"     ,1000,0.,1000.);
  TH1F *hPedTRURMS1m3  = new TH1F("hPedTRURMS1m3" ,"RMS pedestals in module 3, TRU"      ,100,0.,50.);

  TH1F *hPedHiMean1m4 = new TH1F("hPedHiMean1m4","Mean pedestals in module 4, high gain" ,100,0.,100.);
  TH1F *hPedHiRMS1m4  = new TH1F("hPedHiRMS1m4" ,"RMS pedestals in module 4, high gain"  ,100,0.,50.);
  TH1F *hPedLoMean1m4 = new TH1F("hPedLoMean1m4","Mean pedestals in module 4, low gain"  ,100,0.,100.);
  TH1F *hPedLoRMS1m4  = new TH1F("hPedLoRMS1m4" ,"RMS pedestals in module 4, low gain"   ,100,0.,50.);
  TH1F *hPedTRUMean1m4 = new TH1F("hPedTRUMean1m4","Mean pedestals in module 4, TRU"     ,1000,0.,1000.);
  TH1F *hPedTRURMS1m4  = new TH1F("hPedTRURMS1m4" ,"RMS pedestals in module 4, TRU"      ,100,0.,50.);

  hPedHiMean1m2->Sumw2();
  hPedHiRMS1m2 ->Sumw2();
  hPedLoMean1m2->Sumw2();
  hPedLoRMS1m2 ->Sumw2();
  hPedTRUMean1m2->Sumw2();
  hPedTRURMS1m2 ->Sumw2();
  hPedHiMean1m3->Sumw2();
  hPedHiRMS1m3 ->Sumw2();
  hPedLoMean1m3->Sumw2();
  hPedLoRMS1m3 ->Sumw2();
  hPedTRUMean1m3->Sumw2();
  hPedTRURMS1m3 ->Sumw2();
  hPedHiMean1m4->Sumw2();
  hPedHiRMS1m4 ->Sumw2();
  hPedLoMean1m4->Sumw2();
  hPedLoRMS1m4 ->Sumw2();
  hPedTRUMean1m4->Sumw2();
  hPedTRURMS1m4 ->Sumw2();

  TH2F *hPedHiMeanm2  = new TH2F("hPedHiMeanm2","Mean pedestals in module 2, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedHiRMSm2   = new TH2F("hPedHiRMSm2" ,"R.M.S. of pedestals in module 2, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedHiNumm2   = new TH2F("hPedHiNumm2" ,"Number of pedestals in module 2, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoMeanm2  = new TH2F("hPedLoMeanm2","Mean pedestals in module 2, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoRMSm2   = new TH2F("hPedLoRMSm2" ,"R.M.S. of pedestals in module 2, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoNumm2   = new TH2F("hPedLoNumm2" ,"Number of pedestals in module 2, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);

  TH2F *hPedHiMeanm3  = new TH2F("hPedHiMeanm3","Mean pedestals in module 3, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedHiRMSm3   = new TH2F("hPedHiRMSm3" ,"R.M.S. of pedestals in module 3, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedHiNumm3   = new TH2F("hPedHiNumm3" ,"Number of pedestals in module 3, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoMeanm3  = new TH2F("hPedLoMeanm3","Mean pedestals in module 3, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoRMSm3   = new TH2F("hPedLoRMSm3" ,"R.M.S. of pedestals in module 3, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoNumm3   = new TH2F("hPedLoNumm3" ,"Number of pedestals in module 3, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);

  TH2F *hPedHiMeanm4  = new TH2F("hPedHiMeanm4","Mean pedestals in module 4, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedHiRMSm4   = new TH2F("hPedHiRMSm4" ,"R.M.S. of pedestals in module 4, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedHiNumm4   = new TH2F("hPedHiNumm4" ,"Number of pedestals in module 4, high gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoMeanm4  = new TH2F("hPedLoMeanm4","Mean pedestals in module 4, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoRMSm4   = new TH2F("hPedLoRMSm4" ,"R.M.S. of pedestals in module 4, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
  TH2F *hPedLoNumm4   = new TH2F("hPedLoNumm4" ,"Number of pedestals in module 4, low gain",
			       cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);

  TH1I *hNBunches = new TH1I("hNBunches","Number of bunches",10,0,10);
  TH2I *hHWaddr   = new TH2I("hHWaddr","DDL is vs HW addr",216,0,216,4096,0,4096);
  TH1I *hModule   = new TH1I("hModule" ,"Module number", 5,0.,5);

  Int_t iEvent=0;
  Int_t runNum=0;
  Int_t module,cellX,cellZ,caloFlag;

  while (reader->NextEvent()) {
    runNum = reader->GetRunNumber();
    AliInfoGeneral("",Form("Reading event %d\n",iEvent++));
    while (stream->NextDDL()) {
      while (stream->NextChannel()) {
	module   = stream->GetModule();
	cellX    = stream->GetCellX();
	cellZ    = stream->GetCellZ();
	caloFlag = stream->GetCaloFlag();
// 	if (caloFlag!=0 && caloFlag!=1) continue;

	hHWaddr->Fill(stream->GetDDLNumber(),stream->GetHWAddress());
	hModule->Fill(module);
	if (!hPed[module][caloFlag][cellX][cellZ]) {
	  TString name  = baseNamePed;
	  TString title = baseTitlePed;
	  name +="_g"; name +=caloFlag;
	  name +="_m"; name +=module;
	  name +="_x"; name +=cellX;
	  name +="_z"; name +=cellZ;

	  title +=module; title +=",";
	  title +=cellX; title +=",";
	  title +=cellZ; title +="), ";
	  title +=sgain[caloFlag];

	  Int_t nx,xmin,xmax;
	  if (caloFlag==0 || caloFlag==1) {
	    nx=100;
	    xmin=0.;
	    xmax=100.;
	  }
	  else {
	    nx=1000;
	    xmin=0.;
	    xmax=1000.;
	  }
	  hPed[module][caloFlag][cellX][cellZ] = new TH1F(name,title,100,0.,100.);
	  hPed[module][caloFlag][cellX][cellZ]->Sumw2();
	  hPed[module][caloFlag][cellX][cellZ]->SetMarkerStyle(20);
	  hPed[module][caloFlag][cellX][cellZ]->SetOption("eph");
	}

	Int_t nBunches = 0;
	while (stream->NextBunch()) {
	  nBunches++;
	  const UShort_t *sig = stream->GetSignals();
	  Int_t sigLength = stream->GetBunchLength();
// 	  for (Int_t i = sigLength-70; i < sigLength; i++) {
	  for (Int_t i = 0; i < sigLength; i++) {
	    hPed[module][caloFlag][cellX][cellZ]->Fill(sig[i]);
	  }
	}
	hNBunches->Fill(nBunches);
      } // end of NextChannel()

    } // end of NextDDL()
  } // end of nextEvent()

  // Fill 2-dim histograms for mean, rms and n pedestals

  for (Int_t mod=2; mod<=4; mod++) {
    for (Int_t caloFlag=0; caloFlag<2; caloFlag++) {
      for (Int_t cellX=0; cellX<cellXMax; cellX++) {
	for (Int_t cellZ=0; cellZ<cellZMax; cellZ++) {
	  if (hPed[mod][caloFlag][cellX][cellZ] != 0) {
	    if      (caloFlag == 0) {
	      if (mod==2) {
		hPedLoMean1m2->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedLoRMS1m2 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
		hPedLoMeanm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean()    );
		hPedLoRMSm2  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS()     );
		hPedLoNumm2  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
	      }
	      else if (mod==3) {
		hPedLoMean1m3->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedLoRMS1m3 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
		hPedLoMeanm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean()    );
		hPedLoRMSm3  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS()     );
		hPedLoNumm3  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
	      }
	      else if (mod==4) {
		hPedLoMean1m4->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedLoRMS1m4 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
		hPedLoMeanm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean()    );
		hPedLoRMSm4  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS()     );
		hPedLoNumm4  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
	      }
	    }
	    else if (caloFlag == 1) {
	      if (mod==2) {
		hPedHiMean1m2->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedHiRMS1m2 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
		hPedHiMeanm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean()    );
		hPedHiRMSm2  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS()     );
		hPedHiNumm2  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
	      }
	      if (mod==3) {
		hPedHiMean1m3->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedHiRMS1m3 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
		hPedHiMeanm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean()    );
		hPedHiRMSm3  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS()     );
		hPedHiNumm3  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
	      }
	      if (mod==4) {
		hPedHiMean1m4->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedHiRMS1m4 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
		hPedHiMeanm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean()    );
		hPedHiRMSm4  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS()     );
		hPedHiNumm4  ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
	      }
	    }
	    else if (caloFlag == 2) {
	      if (mod==2) {
		hPedTRUMean1m2->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedTRURMS1m2 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
	      }
	      if (mod==3) {
		hPedTRUMean1m3->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedTRURMS1m3 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
	      }
	      if (mod==4) {
		hPedTRUMean1m4->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
		hPedTRURMS1m4 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
	      }
	    }
	  }
	}
      }
    }
  }

  // Write existing histograms to a root file

  TString fileName = "ped";
  fileName += runNum;
  fileName += ".root";
  TFile *file = new TFile(fileName,"RECREATE");

  for (Int_t mod=2; mod<=3; mod++) {
    for (Int_t caloFlag=0; caloFlag<caloFlagMax; caloFlag++) {
      for (Int_t mod=0; mod<modMax; mod++) {
	for (Int_t cellX=0; cellX<cellXMax; cellX++) {
	  for (Int_t cellZ=0; cellZ<cellZMax; cellZ++) {
	    if (hPed[mod][caloFlag][cellX][cellZ] != 0)
	      hPed[mod][caloFlag][cellX][cellZ]->Write();
	  }
	}
      }
    }
  }

  hPedHiMean1m2->Write();
  hPedHiRMS1m2 ->Write();
  hPedLoMean1m2->Write();
  hPedLoRMS1m2 ->Write();
  hPedHiMeanm2 ->Write();
  hPedHiRMSm2  ->Write();
  hPedHiNumm2  ->Write();
  hPedLoMeanm2 ->Write();
  hPedLoRMSm2  ->Write();
  hPedLoNumm2  ->Write();
  hPedTRUMean1m2->Write();
  hPedTRURMS1m2 ->Write();
  
  hPedHiMean1m3->Write();
  hPedHiRMS1m3 ->Write();
  hPedLoMean1m3->Write();
  hPedLoRMS1m3 ->Write();
  hPedHiMeanm3 ->Write();
  hPedHiRMSm3  ->Write();
  hPedHiNumm3  ->Write();
  hPedLoMeanm3 ->Write();
  hPedLoRMSm3  ->Write();
  hPedLoNumm3  ->Write();
  hPedTRUMean1m3->Write();
  hPedTRURMS1m3 ->Write();

  hPedHiMean1m4->Write();
  hPedHiRMS1m4 ->Write();
  hPedLoMean1m4->Write();
  hPedLoRMS1m4 ->Write();
  hPedHiMeanm4 ->Write();
  hPedHiRMSm4  ->Write();
  hPedHiNumm4  ->Write();
  hPedLoMeanm4 ->Write();
  hPedLoRMSm4  ->Write();
  hPedLoNumm4  ->Write();
  hPedTRUMean1m4->Write();
  hPedTRURMS1m4 ->Write();

  hNBunches  ->Write();
  hHWaddr    ->Write();
  hModule    ->Write();
  
  file->Close();
  stopwatch.Print();
}
Commit	Line	Data
e8f49998	1	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	2	#include <TStopwatch.h>
	3	#include <TStyle.h>
	4	#include <TFile.h>
	5	#include <TH1F.h>
	6	#include <TH2F.h>
	7	#include <TString.h>
	8	#include <TCanvas.h>
	9	#include "TSystem.h"
	10	#include "TGrid.h"
	11	#include "AliRawReader.h"
	12	#include "AliCaloRawStreamV3.h"
	13	#include "AliLog.h"
	14	#include "iostream"
	15	using namespace std;
	16
	17	#endif
	18
	19	void Pedestals(const TString rawFile=0)
	20	{
	21	// Read raw data, decode it to samples,
	22	// calculate pedestals from presamples,
	23	// evaluate the signal amplitude as a maximum sample,
	24	// and fill histograms with pedestals and amplitudes
	25	// This script should be compiled to speed up the data processing:
	26	// .L Pedestals.C++
	27	//___
	28	// Yuri Kharlov. 6 September 2007
	29
	30	TStopwatch stopwatch;
	31	stopwatch.Start();
	32
	33	if (rawFile.BeginsWith("alien://")) {
	34	gSystem->Exec("source /tmp/gclient_env_$UID");
	35	TGrid::Connect("alien://");
	36	}
	37
	38	AliRawReader *reader = AliRawReader::Create(rawFile);
	39	reader->Reset();
	40
	41	TStopwatch timer;
	42	timer.Start();
	43
	44	AliCaloRawStreamV3 *stream = new AliCaloRawStreamV3(reader,"PHOS");
	45
	46	TString baseNamePed ="hPed";
	47	TString baseTitlePed="Ped in cell (";
	48	const char* sgain[3]={"LG","HG", "TRU"};
	49
	50	const Int_t caloFlagMax=3,modMax=5,cellXMax=64,cellZMax=56;
	51	TH1F *hPed[5][3][64][56];
	52	for (Int_t mod=2; mod<=4; mod++) {
	53	for (Int_t caloFlag=0; caloFlag<caloFlagMax; caloFlag++) {
	54	for (Int_t mod=0; mod<modMax; mod++) {
	55	for (Int_t cellX=0; cellX<cellXMax; cellX++) {
	56	for (Int_t cellZ=0; cellZ<cellZMax; cellZ++) {
	57	hPed[mod][caloFlag][cellX][cellZ] = 0;
	58	}
	59	}
	60	}
	61	}
	62	}
	63	TH1F *hPedHiMean1m2 = new TH1F("hPedHiMean1m2","Mean pedestals in module 2, high gain" ,100,0.,100.);
	64	TH1F *hPedHiRMS1m2 = new TH1F("hPedHiRMS1m2" ,"RMS pedestals in module 2, high gain" ,100,0.,50.);
65	TH1F *hPedLoMean1m2 = new TH1F("hPedLoMean1m2","Mean pedestals in module 2, low gain" ,100,0.,100.);
66	TH1F *hPedLoRMS1m2 = new TH1F("hPedLoRMS1m2" ,"RMS pedestals in module 2, low gain" ,100,0.,50.);
67	TH1F *hPedTRUMean1m2 = new TH1F("hPedTRUMean1m2","Mean pedestals in module 2, TRU" ,1000,0.,1000.);
68	TH1F *hPedTRURMS1m2 = new TH1F("hPedTRURMS1m2" ,"RMS pedestals in module 2, TRU" ,100,0.,50.);
69
70	TH1F *hPedHiMean1m3 = new TH1F("hPedHiMean1m3","Mean pedestals in module 3, high gain" ,100,0.,100.);
71	TH1F *hPedHiRMS1m3 = new TH1F("hPedHiRMS1m3" ,"RMS pedestals in module 3, high gain" ,100,0.,50.);
72	TH1F *hPedLoMean1m3 = new TH1F("hPedLoMean1m3","Mean pedestals in module 3, low gain" ,100,0.,100.);
73	TH1F *hPedLoRMS1m3 = new TH1F("hPedLoRMS1m3" ,"RMS pedestals in module 3, low gain" ,100,0.,50.);
74	TH1F *hPedTRUMean1m3 = new TH1F("hPedTRUMean1m3","Mean pedestals in module 3, TRU" ,1000,0.,1000.);
75	TH1F *hPedTRURMS1m3 = new TH1F("hPedTRURMS1m3" ,"RMS pedestals in module 3, TRU" ,100,0.,50.);
76
77	TH1F *hPedHiMean1m4 = new TH1F("hPedHiMean1m4","Mean pedestals in module 4, high gain" ,100,0.,100.);
78	TH1F *hPedHiRMS1m4 = new TH1F("hPedHiRMS1m4" ,"RMS pedestals in module 4, high gain" ,100,0.,50.);
79	TH1F *hPedLoMean1m4 = new TH1F("hPedLoMean1m4","Mean pedestals in module 4, low gain" ,100,0.,100.);
80	TH1F *hPedLoRMS1m4 = new TH1F("hPedLoRMS1m4" ,"RMS pedestals in module 4, low gain" ,100,0.,50.);
81	TH1F *hPedTRUMean1m4 = new TH1F("hPedTRUMean1m4","Mean pedestals in module 4, TRU" ,1000,0.,1000.);
82	TH1F *hPedTRURMS1m4 = new TH1F("hPedTRURMS1m4" ,"RMS pedestals in module 4, TRU" ,100,0.,50.);
83
84	hPedHiMean1m2->Sumw2();
85	hPedHiRMS1m2 ->Sumw2();
86	hPedLoMean1m2->Sumw2();
87	hPedLoRMS1m2 ->Sumw2();
88	hPedTRUMean1m2->Sumw2();
89	hPedTRURMS1m2 ->Sumw2();
90	hPedHiMean1m3->Sumw2();
91	hPedHiRMS1m3 ->Sumw2();
92	hPedLoMean1m3->Sumw2();
93	hPedLoRMS1m3 ->Sumw2();
94	hPedTRUMean1m3->Sumw2();
95	hPedTRURMS1m3 ->Sumw2();
96	hPedHiMean1m4->Sumw2();
97	hPedHiRMS1m4 ->Sumw2();
98	hPedLoMean1m4->Sumw2();
99	hPedLoRMS1m4 ->Sumw2();
100	hPedTRUMean1m4->Sumw2();
101	hPedTRURMS1m4 ->Sumw2();
102
103	TH2F *hPedHiMeanm2 = new TH2F("hPedHiMeanm2","Mean pedestals in module 2, high gain",
104	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
105	TH2F *hPedHiRMSm2 = new TH2F("hPedHiRMSm2" ,"R.M.S. of pedestals in module 2, high gain",
106	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
107	TH2F *hPedHiNumm2 = new TH2F("hPedHiNumm2" ,"Number of pedestals in module 2, high gain",
108	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
109	TH2F *hPedLoMeanm2 = new TH2F("hPedLoMeanm2","Mean pedestals in module 2, low gain",
110	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
111	TH2F *hPedLoRMSm2 = new TH2F("hPedLoRMSm2" ,"R.M.S. of pedestals in module 2, low gain",
112	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
113	TH2F *hPedLoNumm2 = new TH2F("hPedLoNumm2" ,"Number of pedestals in module 2, low gain",
114	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
115
116	TH2F *hPedHiMeanm3 = new TH2F("hPedHiMeanm3","Mean pedestals in module 3, high gain",
117	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
118	TH2F *hPedHiRMSm3 = new TH2F("hPedHiRMSm3" ,"R.M.S. of pedestals in module 3, high gain",
119	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
120	TH2F *hPedHiNumm3 = new TH2F("hPedHiNumm3" ,"Number of pedestals in module 3, high gain",
121	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
122	TH2F *hPedLoMeanm3 = new TH2F("hPedLoMeanm3","Mean pedestals in module 3, low gain",
123	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
124	TH2F *hPedLoRMSm3 = new TH2F("hPedLoRMSm3" ,"R.M.S. of pedestals in module 3, low gain",
125	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
126	TH2F *hPedLoNumm3 = new TH2F("hPedLoNumm3" ,"Number of pedestals in module 3, low gain",
127	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
128
129	TH2F *hPedHiMeanm4 = new TH2F("hPedHiMeanm4","Mean pedestals in module 4, high gain",
130	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
131	TH2F *hPedHiRMSm4 = new TH2F("hPedHiRMSm4" ,"R.M.S. of pedestals in module 4, high gain",
132	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
133	TH2F *hPedHiNumm4 = new TH2F("hPedHiNumm4" ,"Number of pedestals in module 4, high gain",
134	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
135	TH2F *hPedLoMeanm4 = new TH2F("hPedLoMeanm4","Mean pedestals in module 4, low gain",
136	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
137	TH2F *hPedLoRMSm4 = new TH2F("hPedLoRMSm4" ,"R.M.S. of pedestals in module 4, low gain",
138	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
139	TH2F *hPedLoNumm4 = new TH2F("hPedLoNumm4" ,"Number of pedestals in module 4, low gain",
140	cellXMax,0.,cellXMax, cellZMax,0.,cellZMax);
141
142	TH1I *hNBunches = new TH1I("hNBunches","Number of bunches",10,0,10);
143	TH2I *hHWaddr = new TH2I("hHWaddr","DDL is vs HW addr",216,0,216,4096,0,4096);
144	TH1I *hModule = new TH1I("hModule" ,"Module number", 5,0.,5);
145
146	Int_t iEvent=0;
147	Int_t runNum=0;
148	Int_t module,cellX,cellZ,caloFlag;
149
150	while (reader->NextEvent()) {
151	runNum = reader->GetRunNumber();
152	AliInfoGeneral("",Form("Reading event %d\n",iEvent++));
153	while (stream->NextDDL()) {
154	while (stream->NextChannel()) {
155	module = stream->GetModule();
156	cellX = stream->GetCellX();
157	cellZ = stream->GetCellZ();
158	caloFlag = stream->GetCaloFlag();
159	// if (caloFlag!=0 && caloFlag!=1) continue;
160
161	hHWaddr->Fill(stream->GetDDLNumber(),stream->GetHWAddress());
162	hModule->Fill(module);
163	if (!hPed[module][caloFlag][cellX][cellZ]) {
164	TString name = baseNamePed;
165	TString title = baseTitlePed;
166	name +="_g"; name +=caloFlag;
167	name +="_m"; name +=module;
168	name +="_x"; name +=cellX;
169	name +="_z"; name +=cellZ;
170
171	title +=module; title +=",";
172	title +=cellX; title +=",";
173	title +=cellZ; title +="), ";
174	title +=sgain[caloFlag];
175
176	Int_t nx,xmin,xmax;
177	if (caloFlag==0 \|\| caloFlag==1) {
178	nx=100;
179	xmin=0.;
180	xmax=100.;
181	}
182	else {
183	nx=1000;
184	xmin=0.;
185	xmax=1000.;
186	}
187	hPed[module][caloFlag][cellX][cellZ] = new TH1F(name,title,100,0.,100.);
188	hPed[module][caloFlag][cellX][cellZ]->Sumw2();
189	hPed[module][caloFlag][cellX][cellZ]->SetMarkerStyle(20);
190	hPed[module][caloFlag][cellX][cellZ]->SetOption("eph");
191	}
192
193	Int_t nBunches = 0;
194	while (stream->NextBunch()) {
195	nBunches++;
196	const UShort_t *sig = stream->GetSignals();
197	Int_t sigLength = stream->GetBunchLength();
198	// for (Int_t i = sigLength-70; i < sigLength; i++) {
199	for (Int_t i = 0; i < sigLength; i++) {
200	hPed[module][caloFlag][cellX][cellZ]->Fill(sig[i]);
201	}
202	}
203	hNBunches->Fill(nBunches);
204	} // end of NextChannel()
205
206	} // end of NextDDL()
207	} // end of nextEvent()
208
209	// Fill 2-dim histograms for mean, rms and n pedestals
210
211	for (Int_t mod=2; mod<=4; mod++) {
212	for (Int_t caloFlag=0; caloFlag<2; caloFlag++) {
213	for (Int_t cellX=0; cellX<cellXMax; cellX++) {
214	for (Int_t cellZ=0; cellZ<cellZMax; cellZ++) {
215	if (hPed[mod][caloFlag][cellX][cellZ] != 0) {
216	if (caloFlag == 0) {
217	if (mod==2) {
218	hPedLoMean1m2->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
219	hPedLoRMS1m2 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
220	hPedLoMeanm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean() );
221	hPedLoRMSm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
222	hPedLoNumm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
223	}
224	else if (mod==3) {
225	hPedLoMean1m3->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
226	hPedLoRMS1m3 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
227	hPedLoMeanm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean() );
228	hPedLoRMSm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
229	hPedLoNumm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
230	}
231	else if (mod==4) {
232	hPedLoMean1m4->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
233	hPedLoRMS1m4 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
234	hPedLoMeanm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean() );
235	hPedLoRMSm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
236	hPedLoNumm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
237	}
238	}
239	else if (caloFlag == 1) {
240	if (mod==2) {
241	hPedHiMean1m2->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
242	hPedHiRMS1m2 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
243	hPedHiMeanm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean() );
244	hPedHiRMSm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
245	hPedHiNumm2 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
246	}
247	if (mod==3) {
248	hPedHiMean1m3->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
249	hPedHiRMS1m3 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
250	hPedHiMeanm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean() );
251	hPedHiRMSm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
252	hPedHiNumm3 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
253	}
254	if (mod==4) {
255	hPedHiMean1m4->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
256	hPedHiRMS1m4 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
257	hPedHiMeanm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetMean() );
258	hPedHiRMSm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
259	hPedHiNumm4 ->Fill( cellX, cellZ, hPed[mod][caloFlag][cellX][cellZ]->GetEntries() );
260	}
261	}
262	else if (caloFlag == 2) {
263	if (mod==2) {
264	hPedTRUMean1m2->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
265	hPedTRURMS1m2 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
266	}
267	if (mod==3) {
268	hPedTRUMean1m3->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
269	hPedTRURMS1m3 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
270	}
271	if (mod==4) {
272	hPedTRUMean1m4->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetMean());
273	hPedTRURMS1m4 ->Fill( hPed[mod][caloFlag][cellX][cellZ]->GetRMS() );
274	}
275	}
276	}
277	}
278	}
279	}
280	}
281
282	// Write existing histograms to a root file
283
284	TString fileName = "ped";
285	fileName += runNum;
286	fileName += ".root";
287	TFile *file = new TFile(fileName,"RECREATE");
288
289	for (Int_t mod=2; mod<=3; mod++) {
290	for (Int_t caloFlag=0; caloFlag<caloFlagMax; caloFlag++) {
291	for (Int_t mod=0; mod<modMax; mod++) {
292	for (Int_t cellX=0; cellX<cellXMax; cellX++) {
293	for (Int_t cellZ=0; cellZ<cellZMax; cellZ++) {
294	if (hPed[mod][caloFlag][cellX][cellZ] != 0)
295	hPed[mod][caloFlag][cellX][cellZ]->Write();
296	}
297	}
298	}
299	}
300	}
301
302	hPedHiMean1m2->Write();
303	hPedHiRMS1m2 ->Write();
304	hPedLoMean1m2->Write();
305	hPedLoRMS1m2 ->Write();
306	hPedHiMeanm2 ->Write();
307	hPedHiRMSm2 ->Write();
308	hPedHiNumm2 ->Write();
309	hPedLoMeanm2 ->Write();
310	hPedLoRMSm2 ->Write();
311	hPedLoNumm2 ->Write();
312	hPedTRUMean1m2->Write();
313	hPedTRURMS1m2 ->Write();
314
315	hPedHiMean1m3->Write();
316	hPedHiRMS1m3 ->Write();
317	hPedLoMean1m3->Write();
318	hPedLoRMS1m3 ->Write();
319	hPedHiMeanm3 ->Write();
320	hPedHiRMSm3 ->Write();
321	hPedHiNumm3 ->Write();
322	hPedLoMeanm3 ->Write();
323	hPedLoRMSm3 ->Write();
324	hPedLoNumm3 ->Write();
325	hPedTRUMean1m3->Write();
326	hPedTRURMS1m3 ->Write();
327
328	hPedHiMean1m4->Write();
329	hPedHiRMS1m4 ->Write();
330	hPedLoMean1m4->Write();
331	hPedLoRMS1m4 ->Write();
332	hPedHiMeanm4 ->Write();
333	hPedHiRMSm4 ->Write();
334	hPedHiNumm4 ->Write();
335	hPedLoMeanm4 ->Write();
336	hPedLoRMSm4 ->Write();
337	hPedLoNumm4 ->Write();
338	hPedTRUMean1m4->Write();
339	hPedTRURMS1m4 ->Write();
340
341	hNBunches ->Write();
342	hHWaddr ->Write();
343	hModule ->Write();
344
345	file->Close();
346	stopwatch.Print();
347	}