[u/mrichter/AliRoot.git] / PMD / AliPMDCalibGain.cxx

//////////////////////////////////////////////////////////////////////////////
//
// * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
// *                                                                        *
// * Author: The ALICE Off-line Project.                                    *
// * Contributors are mentioned in the code where appropriate.  	    *
// *									    *
// * Permission to use, copy, modify and distribute this software and its   *
// * documentation strictly for non-commercial purposes is hereby granted   *
// * without fee, provided that the above copyright notice appears in all   *
// * copies and that both the copyright notice and this permission notice   *
// * appear in the supporting documentation. The authors make no claims     *
// * about the suitability of this software for any purpose. It is	    *
// * provided "as is" without express or implied warranty.		    *
// **************************************************************************/
//
//////////////////////////////////////////////////////////////////////////////

#include "Riostream.h"
#include "TF1.h"
#include "TFile.h"
#include "TObjString.h"
#include "TROOT.h"
#include "TClonesArray.h"
#include "TH1F.h"
#include "TObjArray.h"
#include "TTree.h"
#include "TMath.h"

// --- Standard library ---

// --- AliRoot header files ---
#include "AliDAQ.h"
#include "AliLog.h"
#include "AliRawReader.h"
#include "AliPMDRawStream.h"
#include "AliPMDddldata.h"
#include "AliPMDCalibGain.h"

ClassImp(AliPMDCalibGain)

AliPMDCalibGain::AliPMDCalibGain():
  TObject(),
  fpw(NULL)
{
  // Standard Constructor
  for(Int_t idet = 0; idet < kDet; idet++)
    {
      for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	{
	  fSMIso[idet][ismn]   = 0.;
	  fSMCount[idet][ismn] = 0.;
	  fCountSm[idet][ismn]=0.;
	  fTempnhit[idet][ismn]=0.;
	  fTempnhitSq[idet][ismn]=0.;
	  for(Int_t jrow = 0; jrow < kMaxRow; jrow++)
	    {
	      for(Int_t kcol = 0; kcol < kMaxCol; kcol++)
		{
		  fCellIso[idet][ismn][jrow][kcol]    = 0.;
		  fCellCount[idet][ismn][jrow][kcol]  = 0.;
		  fNhitCell[idet][ismn][jrow][kcol]   = 0.;
		  fPedMeanRMS[idet][ismn][jrow][kcol] = 0.;
		  fHotFlag[idet][ismn][jrow][kcol]    = 0.;
		  
		}
	    }
	}
    }
  
}
// ------------------------------------------------------------------------ //
AliPMDCalibGain::AliPMDCalibGain(const AliPMDCalibGain &pmdcalibgain):
  TObject(pmdcalibgain),
  fpw(NULL)
{
  for(Int_t idet = 0; idet < kDet; idet++)
    {
      for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	{
	  fSMIso[idet][ismn] = pmdcalibgain.fSMIso[idet][ismn] ;
	  fSMCount[idet][ismn] = pmdcalibgain.fSMCount[idet][ismn] ;
	  fCountSm[idet][ismn] = pmdcalibgain.fCountSm[idet][ismn];
	  fTempnhit[idet][ismn] = pmdcalibgain.fTempnhit[idet][ismn];
	  fTempnhitSq[idet][ismn] = pmdcalibgain.fTempnhitSq[idet][ismn];
	  for(Int_t jrow = 0; jrow < kMaxRow; jrow++)
	    {
	      for(Int_t kcol = 0; kcol < kMaxCol; kcol++)
		{
		  fCellIso[idet][ismn][jrow][kcol] = pmdcalibgain.fCellIso[idet][ismn][jrow][kcol];
		  fCellCount[idet][ismn][jrow][kcol] = pmdcalibgain.fCellCount[idet][ismn][jrow][kcol];
		  fNhitCell[idet][ismn][jrow][kcol] = pmdcalibgain.fNhitCell[idet][ismn][jrow][kcol];
		  fPedMeanRMS[idet][ismn][jrow][kcol] = pmdcalibgain.fPedMeanRMS[idet][ismn][jrow][kcol];
		  fHotFlag[idet][ismn][jrow][kcol] = pmdcalibgain.fHotFlag[idet][ismn][jrow][kcol];
		  
		}
	    }
	}
    }
  
}
// ------------------------------------------------------------------------ //
AliPMDCalibGain &AliPMDCalibGain::operator=(const AliPMDCalibGain &pmdcalibgain)
{
  if(this != &pmdcalibgain)
    {
      this->fpw = pmdcalibgain.fpw;
      for(Int_t idet = 0; idet < kDet; idet++)
	{
	  for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	    {
	      fSMIso[idet][ismn]      = pmdcalibgain.fSMIso[idet][ismn];
	      fSMCount[idet][ismn]    = pmdcalibgain.fSMCount[idet][ismn];
	      fCountSm[idet][ismn]    = pmdcalibgain.fCountSm[idet][ismn];
	      fTempnhit[idet][ismn]   = pmdcalibgain.fTempnhit[idet][ismn];
	      fTempnhitSq[idet][ismn] = pmdcalibgain.fTempnhitSq[idet][ismn];
	      for(Int_t jrow = 0; jrow < kMaxRow;jrow++)
		{
		  for(Int_t kcol = 0; kcol < kMaxCol; kcol++)
		    {
		      fCellIso[idet][ismn][jrow][kcol] = pmdcalibgain.fCellIso[idet][ismn][jrow][kcol];
		      fCellCount[idet][ismn][jrow][kcol] = pmdcalibgain.fCellCount[idet][ismn][jrow][kcol];
		      fNhitCell[idet][ismn][jrow][kcol] = pmdcalibgain.fNhitCell[idet][ismn][jrow][kcol]; //za 
		      fPedMeanRMS[idet][ismn][jrow][kcol] = pmdcalibgain.fPedMeanRMS[idet][ismn][jrow][kcol];
		      fHotFlag[idet][ismn][jrow][kcol] = pmdcalibgain.fHotFlag[idet][ismn][jrow][kcol];
		      
		    }
		}
	    }
	}
    }
  return *this;
}
// ------------------------------------------------------------------------ //
AliPMDCalibGain::~AliPMDCalibGain()
{
  // dtor
}

// ------------------------------------------------------------------------ //

Int_t AliPMDCalibGain::ExtractPedestal(const Char_t *rootFile)
{
  // Pedestal extraction from the PMD_PED.root file
  // To be called once at the beginning
  
  Int_t   det=0, sm=0, row=0, col=0;
  Float_t mean=0., rms=0.;
  
  TFile *pedfile = new TFile(rootFile);
  
  if(!pedfile)
    {
      printf("ERROR --- NO PEDESTAL (PMD_PED1.root) FILE IS FOUND --- STOP GAIN DA\n");
      return -3;
    }


  TTree *ped =(TTree*)pedfile->Get("ped");

  ped->SetBranchAddress("det",&det);
  ped->SetBranchAddress("sm",&sm);
  ped->SetBranchAddress("row",&row);
  ped->SetBranchAddress("col",&col);
  ped->SetBranchAddress("mean",&mean);
  ped->SetBranchAddress("rms",&rms);

  Int_t nentries = (Int_t)ped->GetEntries();

  for (Int_t ient = 0; ient < nentries; ient++)
    {
      ped->GetEntry(ient);
      fPedMeanRMS[det][sm][row][col] = mean + 3.*rms;
      //printf("Mean= %f, RMS= %f, PedMeanRMS=%f\n",mean,rms,fPedMeanRMS[det][sm][row][col]);

    }

  pedfile->Close();
  delete pedfile;
  pedfile = 0x0;

  return 1;
}
//------------------------------------------------------------------------------------------------

Int_t AliPMDCalibGain::ExtractHotChannel(const Char_t *rootFile)
{
  // HotChannel extraction from the PMD_HOT.root file
  // To be called once at the beginning

  Int_t   det=0, sm=0, row=0, col=0;
  Float_t flag=0.;

  TFile *hotmapfile = new TFile(rootFile);

  if(!hotmapfile)
    {
      printf(" NO HOTCHANNEL MAP (PMD_HOT.root) FILE IS FOUND \n");

      for (Int_t idet = 0; idet < kDet; idet++)
	{
	  for (Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	    {
	      for (Int_t irow = 0; irow < kMaxRow; irow++)
		{
		  for (Int_t icol = 0; icol < kMaxCol; icol++)
		    {
		      fHotFlag[idet][kMaxSMN][kMaxRow][kMaxCol] = 0.;
		    }
		}
	    }
	}
    }


  TTree *hot =(TTree*)hotmapfile->Get("hot");
  
  hot->SetBranchAddress("det",&det);
  hot->SetBranchAddress("sm",&sm);
  hot->SetBranchAddress("row",&row);
  hot->SetBranchAddress("col",&col);
  hot->SetBranchAddress("flag",&flag);
  
  Int_t nentries = (Int_t)hot->GetEntries();
  
  for (Int_t ient = 0; ient < nentries; ient++)
    {
      hot->GetEntry(ient);
      fHotFlag[det][sm][row][col] = flag;

      //printf(" HotFlag=%f\n",fHotFlag[det][sm][row][col]);
    }

  hotmapfile->Close();
  delete hotmapfile;
  hotmapfile = 0x0;
  
  return 1;
}


// ------------------------------------------------------------------------ //

void AliPMDCalibGain::ReadTempFile(const Char_t *tempFile)
{
  // Read the variables from the file
  
  //  fpw = fopen(tempFile,"r");
  
  ifstream intmpfile;
  intmpfile.open(tempFile);

  Float_t smcount = 0., smiso = 0.;
  Float_t cellcount = 0., celliso = 0.;


  for (Int_t idet = 0; idet < kDet; idet++)
    {
      for (Int_t ism = 0; ism < kMaxSMN; ism++)
	{
	  //fscanf(fpw,"%d %d %f %f",&idet,&ism,&smcount,&smiso);
	  intmpfile >> idet >> ism >> smcount >> smiso;
	  fSMCount[idet][ism] = smcount;
	  fSMIso[idet][ism]   = smiso;
	}
    }

  for (Int_t idet = 0; idet < kDet; idet++)
    {
      for (Int_t ism = 0; ism < kMaxSMN; ism++)
	{
	  for (Int_t irow = 0; irow < kMaxRow; irow++)
	    {
	      for (Int_t icol = 0; icol < kMaxCol; icol++)
		{
		  //fscanf(fpw,"%d %d %d %d %f %f",&idet,&ism,&irow,&icol,
		  //	 &cellcount,&celliso);
		  intmpfile >> idet >> ism >> irow >> icol 
			    >> cellcount >> celliso;
		  fCellCount[idet][ism][irow][icol] = cellcount;
		  fCellIso[idet][ism][irow][icol]   = celliso;
		}
	    }
	}
    }
  
  //fclose(fpw);
  intmpfile.close();

}
// ------------------------------------------------------------------------ //
void AliPMDCalibGain::WriteTempFile(const Char_t *tempFile)
{
  // Write the Temporary file if the required statics is not achieved


  /*
    Following variables to be written to a file
    fDetIso[idet] ;
    fSMIso[idet][ismn]; 
    fCellIso[idet][ismn][irow][icol]; 
    
    fDetCount[idet];
    fSMCount[idet][ismn];
    fCellCount[idet][ismn][irow][icol];
  */				  


  fpw = fopen(tempFile,"w+");
  
  for (Int_t idet = 0; idet < kDet; idet++)
    {
     // fprintf(fpw,"%d %f %f\n",idet,fDetCount[idet],fDetIso[idet]);
    }
  
  for (Int_t idet = 0; idet < kDet; idet++)
    {
      for (Int_t ism = 0; ism < kMaxSMN; ism++)
	{
	  fprintf(fpw,"%d %d %f %f\n",idet,ism, fSMCount[idet][ism],fSMIso[idet][ism]);
	}
    }
  
  for (Int_t idet = 0; idet < kDet; idet++)
    {
      for (Int_t ism = 0; ism < kMaxSMN; ism++)
	{
	  for (Int_t irow = 0; irow < kMaxRow; irow++)
	    {
	      for (Int_t icol = 0; icol < kMaxCol; icol++)
		{
		  fprintf(fpw,"%d %d %d %d %f %f\n",idet,ism,irow,icol,
			  fCellCount[idet][ism][irow][icol],
			  fCellIso[idet][ism][irow][icol]);
		}
	    }
	}
    }
  
  fclose(fpw);
  
}

// ------------------------------------------------------------------------ //

Bool_t AliPMDCalibGain::ProcessEvent(AliRawReader *rawReader, TObjArray *pmdddlcont)
{
  // Calculates the ADC of isolated cell
  
  const Int_t kDDL           = AliDAQ::NumberOfDdls("PMD");
  const Int_t kCellNeighbour = 6;
  Int_t neibx[6] = {1,0,-1,-1,0,1};
  Int_t neiby[6] = {0,1,1,0,-1,-1};
  
  Int_t id1 = 0,jd1 = 0;  //neighbour row/col
  Int_t isocount = 0;     //number of neighbours with 0 signal

  Float_t d1[kDet][kMaxSMN][kMaxRow][kMaxCol];
  
  for(Int_t idet = 0; idet < kDet; idet++)
    {
      for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
        {
	  for(Int_t irow = 0; irow < kMaxRow; irow++)
            {
              for(Int_t icol = 0; icol < kMaxCol; icol++)
                {
		  d1[idet][ismn][irow][icol] = 0.;
                }
	    }
	}
    }
  
  AliPMDRawStream rawStream(rawReader);

  Int_t iddl = -1;
  
  Int_t numberofDDLs = 0;

  while ((iddl = rawStream.DdlData(pmdddlcont)) >=0) {
    numberofDDLs++;
    
    Int_t ientries = pmdddlcont->GetEntries();
    
    for (Int_t ient = 0; ient < ientries; ient++)
      {
	AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont->UncheckedAt(ient);
	
	Int_t idet = pmdddl->GetDetector();
	Int_t ismn = pmdddl->GetSMN();
	Int_t mcm = pmdddl->GetMCM();
	//Int_t ichno = pmdddl->GetChannel();
	Int_t irow = pmdddl->GetRow();
	Int_t icol = pmdddl->GetColumn();
	Int_t isig = pmdddl->GetSignal();
	
	// This is the protection not to crash the code 
	
	if(mcm == 0) continue;
	if (irow < 0 || icol < 0 || irow > 47 || icol > 95) continue;
	
	// Pedestal subtraction
	if(fHotFlag[idet][ismn][irow][icol] == 1.0) isig = 0;
	
	if (isig>0)
	  {
	    d1[idet][ismn][irow][icol] =
	      (Float_t) isig - fPedMeanRMS[idet][ismn][irow][icol];
	    
	    //printf("Signal_ped_subtracted=%f, pedestal=%f\n",d1[idet][ismn][irow][icol]),fPedMeanRMS[idet][ismn][irow][icol];
	    
	    fNhitCell[idet][ismn][irow][icol]++;     //cell hit frequency
	  }
	

      }
    pmdddlcont->Delete();
    }
  
  for(Int_t idet=0; idet < kDet; idet++)
    {
      for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	{
	  for(Int_t irow = 0; irow < kMaxRow; irow++)
	    {
	      for(Int_t icol = 0; icol < kMaxCol; icol++)
		{
		  if(d1[idet][ismn][irow][icol] > 0)
		    {
		      isocount = 0;
		      for(Int_t ii = 0; ii < kCellNeighbour; ii++)
			{
			  id1 = irow + neibx[ii];
			  jd1 = icol + neiby[ii];
			  if (id1 < 0) id1 = 0;
			  if (id1 > kMaxRow-1) id1 = kMaxRow - 1;
			  if (jd1 < 0) jd1 = 0;
			  if (jd1 > kMaxCol-1) jd1 = kMaxCol - 1;
			  if(d1[idet][ismn][id1][jd1] == 0)
			    {
			      isocount++;
			      if(isocount == kCellNeighbour)
				{
				  //fDetIso[idet] += d1[idet][ismn][irow][icol];
				  fSMIso[idet][ismn] += d1[idet][ismn][irow][icol];
				  fCellIso[idet][ismn][irow][icol] += d1[idet][ismn][irow][icol];
				  //fDetCount[idet]++;
				  fSMCount[idet][ismn]++;
				  fCellCount[idet][ismn][irow][icol]++;
				  
				}
			    }
			}  // neigh cell cond.
		    }     // d>0 cond.
		}
	    }
	}
    }
  
  for(Int_t idet=0; idet < kDet; idet++)
    {
      for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	{
	  for(Int_t irow = 0; irow < kMaxRow; irow++)
	    {
	      for(Int_t icol = 0; icol < kMaxCol; icol++)
		{
		  if(fNhitCell[idet][ismn][irow][icol]>0)
		    {
		      fCountSm[idet][ismn]  += 1;
		      fTempnhit[idet][ismn] += fNhitCell[idet][ismn][irow][icol];
		      fTempnhitSq[idet][ismn] += fNhitCell[idet][ismn][irow][icol]
			*fNhitCell[idet][ismn][irow][icol];
		    }
		}
	    }
	}
    }
  
  if (numberofDDLs < kDDL) return kFALSE;
  return kTRUE;
  
}
// ------------------------------------------------------------------------ //
void AliPMDCalibGain::Analyse(TTree *gaintree, TTree *meantree)
{
  // Calculates the mean
  Int_t   det = 0, sm = 0, row = 0, col = 0;
  Float_t gain = 0.;
  Float_t cellmean = 0.;

  Float_t modmean[2][24];

  for (Int_t idet=0; idet < 2; idet++)
    {
      for (Int_t ism = 0; ism < 24; ism++)
	{
	  modmean[idet][ism] = 0.;
	}
    }

  gaintree->Branch("det",&det,"det/I");
  gaintree->Branch("sm",&sm,"sm/I");
  gaintree->Branch("row",&row,"row/I");
  gaintree->Branch("col",&col,"col/I");
  gaintree->Branch("gain",&gain,"gain/F");
  
  for(Int_t idet = 0; idet < kDet; idet++)
    {
      for(Int_t ism = 0; ism < kMaxSMN; ism++)
	{
	  if (fSMCount[idet][ism] > 0)
	    modmean[idet][ism] = fSMIso[idet][ism]/fSMCount[idet][ism];
	  for(Int_t irow = 0; irow < kMaxRow; irow++)
	    {
	      for(Int_t icol = 0; icol < kMaxCol; icol++)
		{
		  if (fCellCount[idet][ism][irow][icol] > 0.)
		    {
		      cellmean = fCellIso[idet][ism][irow][icol]/fCellCount[idet][ism][irow][icol];
		    }
		  det      = idet;
		  sm       = ism;
		  row      = irow;
		  col      = icol;
		  if (cellmean > 0.0 && fCellCount[idet][ism][irow][icol]>0.)
		    {
		      gain = cellmean/modmean[idet][ism];
		    }
		  else
		    {
		      gain = 0.;
		    }
		  //if(fCellCount[idet][ism][irow][icol]>0.) printf("CellCount =%f, gain= %f\n",fCellCount[idet][ism][irow][icol],gain);
		  gaintree->Fill();
		}
	    }
	}
    }

  Float_t smmean;

  // Writing each module mean value
  meantree->Branch("det",&det,"det/I");
  meantree->Branch("sm",&sm,"sm/I");
  meantree->Branch("smmean",&smmean,"row/F");
  
  for(Int_t idet = 0; idet < kDet; idet++)
    {
      for (Int_t ism = 0; ism < kMaxSMN; ism++)
	{
	  det    = idet;
	  sm     = ism;
	  smmean = modmean[idet][ism];
	  meantree->Fill();
	}
    }

}
// ------------------------------------------------------------------------ //
void AliPMDCalibGain::FindHotCell(TTree *hottree, Float_t xvar)
{
  // Calculates the mean
  Int_t   det = 0, sm = 0, row = 0, col = 0;
  Float_t flag = 0.;
  Float_t meannhit = 0.;
  Float_t meanSqnhit = 0.;
  Float_t sigmanhit = 0.,nhitcut = 0.;

  //Float_t xvar = 5.;

  hottree->Branch("det",&det,"det/I");
  hottree->Branch("sm",&sm,"sm/I");
  hottree->Branch("row",&row,"row/I");
  hottree->Branch("col",&col,"col/I");
  hottree->Branch("flag",&flag,"flag/F");
  
  for(Int_t idet = 0; idet < kDet; idet++)
    {
      for(Int_t ism = 0; ism < kMaxSMN; ism++)
	{
	  if (fCountSm[idet][ism]> 0)
	    {
	      meannhit   = fTempnhit[idet][ism]/fCountSm[idet][ism];
	      meanSqnhit = fTempnhitSq[idet][ism]/fCountSm[idet][ism];
	      sigmanhit  = sqrt(meanSqnhit-(meannhit*meannhit));
	      nhitcut    = meannhit + xvar*sigmanhit;

	      for(Int_t irow = 0; irow < kMaxRow; irow++)
		{
		  for(Int_t icol = 0; icol < kMaxCol; icol++)
		    {
		      det      = idet;
		      sm       = ism;
		      row      = irow;
		      col      = icol;
		      
		      if(fNhitCell[idet][ism][irow][icol] > nhitcut)
			{
			  flag  = 1.0;
			}
		      else
			{
			  flag = 0.;
			}
		      hottree->Fill();
		    }
		  
		}
	    }
	}
    }
}
Commit	Line	Data
4fc06b3a	1	//////////////////////////////////////////////////////////////////////////////
	2	//
	3	// * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	// * *
	5	// * Author: The ALICE Off-line Project. *
	6	// * Contributors are mentioned in the code where appropriate. *
	7	// * *
	8	// * Permission to use, copy, modify and distribute this software and its *
	9	// * documentation strictly for non-commercial purposes is hereby granted *
	10	// * without fee, provided that the above copyright notice appears in all *
	11	// * copies and that both the copyright notice and this permission notice *
	12	// * appear in the supporting documentation. The authors make no claims *
	13	// * about the suitability of this software for any purpose. It is *
	14	// * provided "as is" without express or implied warranty. *
	15	// **************************************************************************/
	16	//
	17	//////////////////////////////////////////////////////////////////////////////
	18
4e2efa25	19	#include "Riostream.h"
4fc06b3a	20	#include "TF1.h"
	21	#include "TFile.h"
	22	#include "TObjString.h"
	23	#include "TROOT.h"
	24	#include "TClonesArray.h"
	25	#include "TH1F.h"
	26	#include "TObjArray.h"
	27	#include "TTree.h"
7c11ad1f	28	#include "TMath.h"
4fc06b3a	29
	30	// --- Standard library ---
	31
	32	// --- AliRoot header files ---
	33	#include "AliDAQ.h"
	34	#include "AliLog.h"
	35	#include "AliRawReader.h"
	36	#include "AliPMDRawStream.h"
	37	#include "AliPMDddldata.h"
	38	#include "AliPMDCalibGain.h"
	39
	40	ClassImp(AliPMDCalibGain)
	41
1da50520	42	AliPMDCalibGain::AliPMDCalibGain():
	43	TObject(),
	44	fpw(NULL)
4fc06b3a	45	{
4fc06b3a	46	// Standard Constructor
7c11ad1f	47	for(Int_t idet = 0; idet < kDet; idet++)
4fc06b3a	48	{
7c11ad1f	49	for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
4fc06b3a	50	{
7c11ad1f	51	fSMIso[idet][ismn] = 0.;
	52	fSMCount[idet][ismn] = 0.;
	53	fCountSm[idet][ismn]=0.;
	54	fTempnhit[idet][ismn]=0.;
	55	fTempnhitSq[idet][ismn]=0.;
	56	for(Int_t jrow = 0; jrow < kMaxRow; jrow++)
4fc06b3a	57	{
7c11ad1f	58	for(Int_t kcol = 0; kcol < kMaxCol; kcol++)
4fc06b3a	59	{
7c11ad1f	60	fCellIso[idet][ismn][jrow][kcol] = 0.;
	61	fCellCount[idet][ismn][jrow][kcol] = 0.;
	62	fNhitCell[idet][ismn][jrow][kcol] = 0.;
	63	fPedMeanRMS[idet][ismn][jrow][kcol] = 0.;
	64	fHotFlag[idet][ismn][jrow][kcol] = 0.;
	65
4fc06b3a	66	}
	67	}
	68	}
	69	}
7c11ad1f	70
4fc06b3a	71	}
	72	// ------------------------------------------------------------------------ //
	73	AliPMDCalibGain::AliPMDCalibGain(const AliPMDCalibGain &pmdcalibgain):
1da50520	74	TObject(pmdcalibgain),
1da50520	75	fpw(NULL)
4fc06b3a	76	{
7c11ad1f	77	for(Int_t idet = 0; idet < kDet; idet++)
4fc06b3a	78	{
7c11ad1f	79	for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
4fc06b3a	80	{
7c11ad1f	81	fSMIso[idet][ismn] = pmdcalibgain.fSMIso[idet][ismn] ;
	82	fSMCount[idet][ismn] = pmdcalibgain.fSMCount[idet][ismn] ;
	83	fCountSm[idet][ismn] = pmdcalibgain.fCountSm[idet][ismn];
	84	fTempnhit[idet][ismn] = pmdcalibgain.fTempnhit[idet][ismn];
	85	fTempnhitSq[idet][ismn] = pmdcalibgain.fTempnhitSq[idet][ismn];
	86	for(Int_t jrow = 0; jrow < kMaxRow; jrow++)
4fc06b3a	87	{
7c11ad1f	88	for(Int_t kcol = 0; kcol < kMaxCol; kcol++)
4fc06b3a	89	{
7c11ad1f	90	fCellIso[idet][ismn][jrow][kcol] = pmdcalibgain.fCellIso[idet][ismn][jrow][kcol];
	91	fCellCount[idet][ismn][jrow][kcol] = pmdcalibgain.fCellCount[idet][ismn][jrow][kcol];
	92	fNhitCell[idet][ismn][jrow][kcol] = pmdcalibgain.fNhitCell[idet][ismn][jrow][kcol];
	93	fPedMeanRMS[idet][ismn][jrow][kcol] = pmdcalibgain.fPedMeanRMS[idet][ismn][jrow][kcol];
	94	fHotFlag[idet][ismn][jrow][kcol] = pmdcalibgain.fHotFlag[idet][ismn][jrow][kcol];
	95
4fc06b3a	96	}
	97	}
	98	}
	99	}
7c11ad1f	100
4fc06b3a	101	}
	102	// ------------------------------------------------------------------------ //
	103	AliPMDCalibGain &AliPMDCalibGain::operator=(const AliPMDCalibGain &pmdcalibgain)
	104	{
7c11ad1f	105	if(this != &pmdcalibgain)
4fc06b3a	106	{
1da50520	107	this->fpw = pmdcalibgain.fpw;
7c11ad1f	108	for(Int_t idet = 0; idet < kDet; idet++)
4fc06b3a	109	{
7c11ad1f	110	for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
4fc06b3a	111	{
7c11ad1f	112	fSMIso[idet][ismn] = pmdcalibgain.fSMIso[idet][ismn];
	113	fSMCount[idet][ismn] = pmdcalibgain.fSMCount[idet][ismn];
	114	fCountSm[idet][ismn] = pmdcalibgain.fCountSm[idet][ismn];
	115	fTempnhit[idet][ismn] = pmdcalibgain.fTempnhit[idet][ismn];
	116	fTempnhitSq[idet][ismn] = pmdcalibgain.fTempnhitSq[idet][ismn];
	117	for(Int_t jrow = 0; jrow < kMaxRow;jrow++)
4fc06b3a	118	{
7c11ad1f	119	for(Int_t kcol = 0; kcol < kMaxCol; kcol++)
	120	{
	121	fCellIso[idet][ismn][jrow][kcol] = pmdcalibgain.fCellIso[idet][ismn][jrow][kcol];
	122	fCellCount[idet][ismn][jrow][kcol] = pmdcalibgain.fCellCount[idet][ismn][jrow][kcol];
	123	fNhitCell[idet][ismn][jrow][kcol] = pmdcalibgain.fNhitCell[idet][ismn][jrow][kcol]; //za
	124	fPedMeanRMS[idet][ismn][jrow][kcol] = pmdcalibgain.fPedMeanRMS[idet][ismn][jrow][kcol];
	125	fHotFlag[idet][ismn][jrow][kcol] = pmdcalibgain.fHotFlag[idet][ismn][jrow][kcol];
	126
4fc06b3a	127	}
	128	}
	129	}
	130	}
	131	}
7c11ad1f	132	return *this;
4fc06b3a	133	}
	134	// ------------------------------------------------------------------------ //
	135	AliPMDCalibGain::~AliPMDCalibGain()
	136	{
7c11ad1f	137	// dtor
1da50520	138	}
	139
	140	// ------------------------------------------------------------------------ //
	141
d31b0352	142	Int_t AliPMDCalibGain::ExtractPedestal(const Char_t *rootFile)
1da50520	143	{
	144	// Pedestal extraction from the PMD_PED.root file
	145	// To be called once at the beginning
7c11ad1f	146
be8b7039	147	Int_t det=0, sm=0, row=0, col=0;
be8b7039	148	Float_t mean=0., rms=0.;
7c11ad1f	149
d31b0352	150	TFile *pedfile = new TFile(rootFile);
7c11ad1f	151
1da50520	152	if(!pedfile)
	153	{
	154	printf("ERROR --- NO PEDESTAL (PMD_PED1.root) FILE IS FOUND --- STOP GAIN DA\n");
	155	return -3;
	156	}
	157
	158
	159	TTree ped =(TTree)pedfile->Get("ped");
	160
	161	ped->SetBranchAddress("det",&det);
	162	ped->SetBranchAddress("sm",&sm);
	163	ped->SetBranchAddress("row",&row);
	164	ped->SetBranchAddress("col",&col);
	165	ped->SetBranchAddress("mean",&mean);
	166	ped->SetBranchAddress("rms",&rms);
	167
	168	Int_t nentries = (Int_t)ped->GetEntries();
	169
	170	for (Int_t ient = 0; ient < nentries; ient++)
	171	{
	172	ped->GetEntry(ient);
	173	fPedMeanRMS[det][sm][row][col] = mean + 3.*rms;
	174	//printf("Mean= %f, RMS= %f, PedMeanRMS=%f\n",mean,rms,fPedMeanRMS[det][sm][row][col]);
	175
	176	}
	177
	178	pedfile->Close();
	179	delete pedfile;
	180	pedfile = 0x0;
	181
	182	return 1;
	183	}
7c11ad1f	184	//------------------------------------------------------------------------------------------------
	185
	186	Int_t AliPMDCalibGain::ExtractHotChannel(const Char_t *rootFile)
	187	{
	188	// HotChannel extraction from the PMD_HOT.root file
	189	// To be called once at the beginning
	190
be8b7039	191	Int_t det=0, sm=0, row=0, col=0;
be8b7039	192	Float_t flag=0.;
7c11ad1f	193
	194	TFile *hotmapfile = new TFile(rootFile);
	195
	196	if(!hotmapfile)
	197	{
637f01e6	198	printf(" NO HOTCHANNEL MAP (PMD_HOT.root) FILE IS FOUND \n");
	199
	200	for (Int_t idet = 0; idet < kDet; idet++)
	201	{
4e2efa25	202	for (Int_t ismn = 0; ismn < kMaxSMN; ismn++)
637f01e6	203	{
4e2efa25	204	for (Int_t irow = 0; irow < kMaxRow; irow++)
637f01e6	205	{
4e2efa25	206	for (Int_t icol = 0; icol < kMaxCol; icol++)
637f01e6	207	{
	208	fHotFlag[idet][kMaxSMN][kMaxRow][kMaxCol] = 0.;
	209	}
	210	}
	211	}
	212	}
7c11ad1f	213	}
	214
	215
	216	TTree hot =(TTree)hotmapfile->Get("hot");
	217
	218	hot->SetBranchAddress("det",&det);
	219	hot->SetBranchAddress("sm",&sm);
	220	hot->SetBranchAddress("row",&row);
	221	hot->SetBranchAddress("col",&col);
	222	hot->SetBranchAddress("flag",&flag);
	223
	224	Int_t nentries = (Int_t)hot->GetEntries();
	225
	226	for (Int_t ient = 0; ient < nentries; ient++)
	227	{
	228	hot->GetEntry(ient);
	229	fHotFlag[det][sm][row][col] = flag;
	230
	231	//printf(" HotFlag=%f\n",fHotFlag[det][sm][row][col]);
	232	}
	233
	234	hotmapfile->Close();
	235	delete hotmapfile;
	236	hotmapfile = 0x0;
	237
	238	return 1;
	239	}
	240
	241
1da50520	242	// ------------------------------------------------------------------------ //
1da50520	243
d31b0352	244	void AliPMDCalibGain::ReadTempFile(const Char_t *tempFile)
1da50520	245	{
	246	// Read the variables from the file
	247
4e2efa25	248	// fpw = fopen(tempFile,"r");
7c11ad1f	249
4e2efa25	250	ifstream intmpfile;
	251	intmpfile.open(tempFile);
	252
be8b7039	253	Float_t smcount = 0., smiso = 0.;
be8b7039	254	Float_t cellcount = 0., celliso = 0.;
1da50520	255
1da50520	256
	257	for (Int_t idet = 0; idet < kDet; idet++)
	258	{
	259	for (Int_t ism = 0; ism < kMaxSMN; ism++)
	260	{
4e2efa25	261	//fscanf(fpw,"%d %d %f %f",&idet,&ism,&smcount,&smiso);
4e2efa25	262	intmpfile >> idet >> ism >> smcount >> smiso;
1da50520	263	fSMCount[idet][ism] = smcount;
	264	fSMIso[idet][ism] = smiso;
	265	}
	266	}
	267
	268	for (Int_t idet = 0; idet < kDet; idet++)
	269	{
	270	for (Int_t ism = 0; ism < kMaxSMN; ism++)
	271	{
	272	for (Int_t irow = 0; irow < kMaxRow; irow++)
	273	{
	274	for (Int_t icol = 0; icol < kMaxCol; icol++)
	275	{
4e2efa25	276	//fscanf(fpw,"%d %d %d %d %f %f",&idet,&ism,&irow,&icol,
	277	// &cellcount,&celliso);
	278	intmpfile >> idet >> ism >> irow >> icol
	279	>> cellcount >> celliso;
1da50520	280	fCellCount[idet][ism][irow][icol] = cellcount;
	281	fCellIso[idet][ism][irow][icol] = celliso;
	282	}
	283	}
	284	}
	285	}
7c11ad1f	286
4e2efa25	287	//fclose(fpw);
4e2efa25	288	intmpfile.close();
1da50520	289
4fc06b3a	290	}
4fc06b3a	291	// ------------------------------------------------------------------------ //
d31b0352	292	void AliPMDCalibGain::WriteTempFile(const Char_t *tempFile)
1da50520	293	{
d31b0352	294	// Write the Temporary file if the required statics is not achieved
1da50520	295
1da50520	296
1da50520	297	/*
d31b0352	298	Following variables to be written to a file
1da50520	299	fDetIso[idet] ;
	300	fSMIso[idet][ismn];
	301	fCellIso[idet][ismn][irow][icol];
	302
	303	fDetCount[idet];
	304	fSMCount[idet][ismn];
	305	fCellCount[idet][ismn][irow][icol];
	306	*/
	307
d31b0352	308
d31b0352	309	fpw = fopen(tempFile,"w+");
7c11ad1f	310
1da50520	311	for (Int_t idet = 0; idet < kDet; idet++)
1da50520	312	{
7c11ad1f	313	// fprintf(fpw,"%d %f %f\n",idet,fDetCount[idet],fDetIso[idet]);
1da50520	314	}
7c11ad1f	315
1da50520	316	for (Int_t idet = 0; idet < kDet; idet++)
	317	{
	318	for (Int_t ism = 0; ism < kMaxSMN; ism++)
	319	{
	320	fprintf(fpw,"%d %d %f %f\n",idet,ism, fSMCount[idet][ism],fSMIso[idet][ism]);
	321	}
	322	}
7c11ad1f	323
1da50520	324	for (Int_t idet = 0; idet < kDet; idet++)
	325	{
	326	for (Int_t ism = 0; ism < kMaxSMN; ism++)
	327	{
	328	for (Int_t irow = 0; irow < kMaxRow; irow++)
	329	{
	330	for (Int_t icol = 0; icol < kMaxCol; icol++)
	331	{
	332	fprintf(fpw,"%d %d %d %d %f %f\n",idet,ism,irow,icol,
	333	fCellCount[idet][ism][irow][icol],
	334	fCellIso[idet][ism][irow][icol]);
	335	}
	336	}
	337	}
	338	}
7c11ad1f	339
1da50520	340	fclose(fpw);
7c11ad1f	341
1da50520	342	}
	343
	344	// ------------------------------------------------------------------------ //
	345
338c285a	346	Bool_t AliPMDCalibGain::ProcessEvent(AliRawReader rawReader, TObjArray pmdddlcont)
4fc06b3a	347	{
4fc06b3a	348	// Calculates the ADC of isolated cell
7c11ad1f	349
4fc06b3a	350	const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
4fc06b3a	351	const Int_t kCellNeighbour = 6;
4fc06b3a	352	Int_t neibx[6] = {1,0,-1,-1,0,1};
	353	Int_t neiby[6] = {0,1,1,0,-1,-1};
	354
be8b7039	355	Int_t id1 = 0,jd1 = 0; //neighbour row/col
be8b7039	356	Int_t isocount = 0; //number of neighbours with 0 signal
4fc06b3a	357
0ab3a530	358	Float_t d1[kDet][kMaxSMN][kMaxRow][kMaxCol];
7c11ad1f	359
4fc06b3a	360	for(Int_t idet = 0; idet < kDet; idet++)
	361	{
	362	for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	363	{
7c11ad1f	364	for(Int_t irow = 0; irow < kMaxRow; irow++)
4fc06b3a	365	{
	366	for(Int_t icol = 0; icol < kMaxCol; icol++)
	367	{
7c11ad1f	368	d1[idet][ismn][irow][icol] = 0.;
4fc06b3a	369	}
	370	}
	371	}
	372	}
7c11ad1f	373
4fc06b3a	374	AliPMDRawStream rawStream(rawReader);
4fc06b3a	375
1da50520	376	Int_t iddl = -1;
7c11ad1f	377
722ccc67	378	Int_t numberofDDLs = 0;
722ccc67	379
7c11ad1f	380	while ((iddl = rawStream.DdlData(pmdddlcont)) >=0) {
	381	numberofDDLs++;
	382
	383	Int_t ientries = pmdddlcont->GetEntries();
	384
	385	for (Int_t ient = 0; ient < ientries; ient++)
4fc06b3a	386	{
7c11ad1f	387	AliPMDddldata pmdddl = (AliPMDddldata)pmdddlcont->UncheckedAt(ient);
	388
	389	Int_t idet = pmdddl->GetDetector();
	390	Int_t ismn = pmdddl->GetSMN();
	391	Int_t mcm = pmdddl->GetMCM();
	392	//Int_t ichno = pmdddl->GetChannel();
	393	Int_t irow = pmdddl->GetRow();
	394	Int_t icol = pmdddl->GetColumn();
	395	Int_t isig = pmdddl->GetSignal();
	396
	397	// This is the protection not to crash the code
	398
	399	if(mcm == 0) continue;
	400	if (irow < 0 \|\| icol < 0 \|\| irow > 47 \|\| icol > 95) continue;
	401
	402	// Pedestal subtraction
	403	if(fHotFlag[idet][ismn][irow][icol] == 1.0) isig = 0;
	404
	405	if (isig>0)
	406	{
	407	d1[idet][ismn][irow][icol] =
	408	(Float_t) isig - fPedMeanRMS[idet][ismn][irow][icol];
	409
	410	//printf("Signal_ped_subtracted=%f, pedestal=%f\n",d1[idet][ismn][irow][icol]),fPedMeanRMS[idet][ismn][irow][icol];
	411
	412	fNhitCell[idet][ismn][irow][icol]++; //cell hit frequency
	413	}
	414
1da50520	415
4fc06b3a	416	}
7c11ad1f	417	pmdddlcont->Delete();
7c11ad1f	418	}
4fc06b3a	419
4fc06b3a	420	for(Int_t idet=0; idet < kDet; idet++)
7c11ad1f	421	{
4fc06b3a	422	for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
7c11ad1f	423	{
4fc06b3a	424	for(Int_t irow = 0; irow < kMaxRow; irow++)
7c11ad1f	425	{
4fc06b3a	426	for(Int_t icol = 0; icol < kMaxCol; icol++)
7c11ad1f	427	{
4fc06b3a	428	if(d1[idet][ismn][irow][icol] > 0)
7c11ad1f	429	{
4fc06b3a	430	isocount = 0;
4fc06b3a	431	for(Int_t ii = 0; ii < kCellNeighbour; ii++)
7c11ad1f	432	{
4fc06b3a	433	id1 = irow + neibx[ii];
4fc06b3a	434	jd1 = icol + neiby[ii];
d55d21ef	435	if (id1 < 0) id1 = 0;
	436	if (id1 > kMaxRow-1) id1 = kMaxRow - 1;
	437	if (jd1 < 0) jd1 = 0;
	438	if (jd1 > kMaxCol-1) jd1 = kMaxCol - 1;
4fc06b3a	439	if(d1[idet][ismn][id1][jd1] == 0)
7c11ad1f	440	{
4fc06b3a	441	isocount++;
4fc06b3a	442	if(isocount == kCellNeighbour)
7c11ad1f	443	{
7c11ad1f	444	//fDetIso[idet] += d1[idet][ismn][irow][icol];
0ab3a530	445	fSMIso[idet][ismn] += d1[idet][ismn][irow][icol];
0ab3a530	446	fCellIso[idet][ismn][irow][icol] += d1[idet][ismn][irow][icol];
7c11ad1f	447	//fDetCount[idet]++;
0ab3a530	448	fSMCount[idet][ismn]++;
	449	fCellCount[idet][ismn][irow][icol]++;
	450
7c11ad1f	451	}
	452	}
	453	} // neigh cell cond.
	454	} // d>0 cond.
	455	}
	456	}
	457	}
	458	}
	459
	460	for(Int_t idet=0; idet < kDet; idet++)
	461	{
	462	for(Int_t ismn = 0; ismn < kMaxSMN; ismn++)
	463	{
	464	for(Int_t irow = 0; irow < kMaxRow; irow++)
	465	{
	466	for(Int_t icol = 0; icol < kMaxCol; icol++)
	467	{
	468	if(fNhitCell[idet][ismn][irow][icol]>0)
	469	{
	470	fCountSm[idet][ismn] += 1;
	471	fTempnhit[idet][ismn] += fNhitCell[idet][ismn][irow][icol];
	472	fTempnhitSq[idet][ismn] += fNhitCell[idet][ismn][irow][icol]
	473	*fNhitCell[idet][ismn][irow][icol];
	474	}
	475	}
	476	}
	477	}
	478	}
	479
	480	if (numberofDDLs < kDDL) return kFALSE;
722ccc67	481	return kTRUE;
7c11ad1f	482
4fc06b3a	483	}
4fc06b3a	484	// ------------------------------------------------------------------------ //
9d1486e3	485	void AliPMDCalibGain::Analyse(TTree gaintree, TTree meantree)
4fc06b3a	486	{
7c11ad1f	487	// Calculates the mean
be8b7039	488	Int_t det = 0, sm = 0, row = 0, col = 0;
be8b7039	489	Float_t gain = 0.;
7c11ad1f	490	Float_t cellmean = 0.;
7c11ad1f	491
9d1486e3	492	Float_t modmean[2][24];
	493
	494	for (Int_t idet=0; idet < 2; idet++)
	495	{
	496	for (Int_t ism = 0; ism < 24; ism++)
	497	{
	498	modmean[idet][ism] = 0.;
	499	}
	500	}
	501
7c11ad1f	502	gaintree->Branch("det",&det,"det/I");
	503	gaintree->Branch("sm",&sm,"sm/I");
	504	gaintree->Branch("row",&row,"row/I");
	505	gaintree->Branch("col",&col,"col/I");
	506	gaintree->Branch("gain",&gain,"gain/F");
	507
	508	for(Int_t idet = 0; idet < kDet; idet++)
	509	{
	510	for(Int_t ism = 0; ism < kMaxSMN; ism++)
	511	{
	512	if (fSMCount[idet][ism] > 0)
9d1486e3	513	modmean[idet][ism] = fSMIso[idet][ism]/fSMCount[idet][ism];
7c11ad1f	514	for(Int_t irow = 0; irow < kMaxRow; irow++)
	515	{
	516	for(Int_t icol = 0; icol < kMaxCol; icol++)
	517	{
	518	if (fCellCount[idet][ism][irow][icol] > 0.)
	519	{
	520	cellmean = fCellIso[idet][ism][irow][icol]/fCellCount[idet][ism][irow][icol];
	521	}
	522	det = idet;
	523	sm = ism;
	524	row = irow;
	525	col = icol;
	526	if (cellmean > 0.0 && fCellCount[idet][ism][irow][icol]>0.)
	527	{
9d1486e3	528	gain = cellmean/modmean[idet][ism];
7c11ad1f	529	}
	530	else
	531	{
	532	gain = 0.;
	533	}
	534	//if(fCellCount[idet][ism][irow][icol]>0.) printf("CellCount =%f, gain= %f\n",fCellCount[idet][ism][irow][icol],gain);
	535	gaintree->Fill();
	536	}
	537	}
	538	}
	539	}
9d1486e3	540
	541	Float_t smmean;
	542
	543	// Writing each module mean value
	544	meantree->Branch("det",&det,"det/I");
	545	meantree->Branch("sm",&sm,"sm/I");
	546	meantree->Branch("smmean",&smmean,"row/F");
7c11ad1f	547
9d1486e3	548	for(Int_t idet = 0; idet < kDet; idet++)
	549	{
	550	for (Int_t ism = 0; ism < kMaxSMN; ism++)
	551	{
	552	det = idet;
	553	sm = ism;
	554	smmean = modmean[idet][ism];
	555	meantree->Fill();
	556	}
	557	}
	558
4fc06b3a	559	}
4fc06b3a	560	// ------------------------------------------------------------------------ //
9d1486e3	561	void AliPMDCalibGain::FindHotCell(TTree *hottree, Float_t xvar)
7c11ad1f	562	{
7c11ad1f	563	// Calculates the mean
be8b7039	564	Int_t det = 0, sm = 0, row = 0, col = 0;
	565	Float_t flag = 0.;
	566	Float_t meannhit = 0.;
	567	Float_t meanSqnhit = 0.;
	568	Float_t sigmanhit = 0.,nhitcut = 0.;
9d1486e3	569
	570	//Float_t xvar = 5.;
	571
7c11ad1f	572	hottree->Branch("det",&det,"det/I");
	573	hottree->Branch("sm",&sm,"sm/I");
	574	hottree->Branch("row",&row,"row/I");
	575	hottree->Branch("col",&col,"col/I");
	576	hottree->Branch("flag",&flag,"flag/F");
	577
	578	for(Int_t idet = 0; idet < kDet; idet++)
	579	{
	580	for(Int_t ism = 0; ism < kMaxSMN; ism++)
	581	{
	582	if (fCountSm[idet][ism]> 0)
	583	{
	584	meannhit = fTempnhit[idet][ism]/fCountSm[idet][ism];
	585	meanSqnhit = fTempnhitSq[idet][ism]/fCountSm[idet][ism];
	586	sigmanhit = sqrt(meanSqnhit-(meannhit*meannhit));
9d1486e3	587	nhitcut = meannhit + xvar*sigmanhit;
7c11ad1f	588
	589	for(Int_t irow = 0; irow < kMaxRow; irow++)
	590	{
	591	for(Int_t icol = 0; icol < kMaxCol; icol++)
	592	{
	593	det = idet;
	594	sm = ism;
	595	row = irow;
	596	col = icol;
	597
	598	if(fNhitCell[idet][ism][irow][icol] > nhitcut)
	599	{
	600	flag = 1.0;
	601	}
	602	else
	603	{
	604	flag = 0.;
	605	}
	606	hottree->Fill();
	607	}
	608
	609	}
	610	}
	611	}
	612	}
	613	}
	614