]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - TPC/AliTPCclustererKr.cxx
Memory leak corrected. (D. Perrino)
[u/mrichter/AliRoot.git] / TPC / AliTPCclustererKr.cxx
index 738ab930a98b413254880ad4533a9dbfc31d6273..d4e6eb0b9fb157149201c3ccc3fd1e1b85a9a08c 100644 (file)
-/**************************************************************************\r
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
- *                                                                        *\r
- * Author: The ALICE Off-line Project.                                    *\r
- * Contributors are mentioned in the code where appropriate.              *\r
- *                                                                        *\r
- * Permission to use, copy, modify and distribute this software and its   *\r
- * documentation strictly for non-commercial purposes is hereby granted   *\r
- * without fee, provided that the above copyright notice appears in all   *\r
- * copies and that both the copyright notice and this permission notice   *\r
- * appear in the supporting documentation. The authors make no claims     *\r
- * about the suitability of this software for any purpose. It is          *\r
- * provided "as is" without express or implied warranty.                  *\r
- **************************************************************************/\r
-\r
-/* $Id: AliTPCclustererKr.cxx,v 1.7 2008/02/06 17:24:53 matyja Exp $ */\r
-\r
-//-----------------------------------------------------------------\r
-//           Implementation of the TPC Kr cluster class\r
-//\r
-// Origin: Adam Matyja, INP PAN, adam.matyja@ifj.edu.pl\r
-//-----------------------------------------------------------------\r
-\r
-/*\r
-Instruction - how to use that:\r
-There are two macros prepared. One is for preparing clusters from MC \r
-samples:  FindKrClusters.C. The output is kept in TPC.RecPoints.root.\r
-The other macro is prepared for data analysis: FindKrClustersRaw.C. \r
-The output is created for each processed file in root file named adc.root. \r
-For each data subsample the same named file is created. So be careful \r
-do not overwrite them. \r
-\r
-*\r
-**** MC ****\r
-*\r
-\r
-To run clusterizaton for MC type:\r
-.x FindKrClusters.C\r
-\r
-If you don't want to use the standard selection criteria then you \r
-have to do following:\r
-\r
-// load the standard setup\r
-AliRunLoader* rl = AliRunLoader::Open("galice.root");\r
-AliTPCLoader *tpcl = (AliTPCLoader*)rl->GetLoader("TPCLoader");\r
-tpcl->LoadDigits();\r
-rl->LoadgAlice();\r
-gAlice=rl->GetAliRun();\r
-TDirectory *cwd = gDirectory;\r
-AliTPCv4 *tpc = (AliTPCv4*)gAlice->GetDetector("TPC");\r
-Int_t ver = tpc->IsVersion();\r
-rl->CdGAFile();\r
-AliTPCParam *param=(AliTPCParamSR *)gDirectory->Get("75x40_100x60_150x60");\r
-AliTPCDigitsArray *digarr=new AliTPCDigitsArray;\r
-digarr->Setup(param);\r
-cwd->cd();\r
-\r
-//loop over events\r
-Int_t nevmax=rl->GetNumberOfEvents();\r
-for(Int_t nev=0;nev<nevmax ;nev++){\r
-  rl->GetEvent(nev);\r
-  TTree* input_tree= tpcl->TreeD();//load tree with digits\r
-  digarr->ConnectTree(input_tree);\r
-  TTree *output_tree =tpcl->TreeR();//load output tree\r
-\r
-  AliTPCclustererKr *clusters = new AliTPCclustererKr();\r
-  clusters->SetParam(param);\r
-  clusters->SetInput(input_tree);\r
-  clusters->SetOutput(output_tree);\r
-  clusters->SetDigArr(digarr);\r
-  \r
-//If you want to change the cluster finder parameters for MC there are \r
-//several of them:\r
-\r
-//1. signal threshold (everything below the given number is treated as 0)\r
-  clusters->SetMinAdc(3);\r
-\r
-//2. number of neighbouring timebins to be considered\r
-  clusters->SetMinTimeBins(2);\r
-\r
-//3. distance of the cluster center to the center of a pad in pad-padrow plane \r
-//(in cm). Remenber that this is still quantified by pad size.\r
-  clusters->SetMaxPadRangeCm(2.5);\r
-\r
-//4. distance of the cluster center to the center of a padrow in pad-padrow \r
-//plane (in cm). Remenber that this is still quantified by pad size.\r
-  clusters->SetMaxRowRangeCm(3.5);\r
-\r
-//5. distance of the cluster center to the max time bin on a pad (in tackts)\r
-//ie. fabs(centerT - time)<7\r
-  clusters->SetMaxTimeRange(7);\r
-\r
-//6. cut reduce peak at 0. There are noises which appear mostly as two \r
-//timebins on one pad.\r
-  clusters->SetValueToSize(3.5);\r
-\r
-\r
-  clusters->finderIO();\r
-  tpcl->WriteRecPoints("OVERWRITE");\r
-}\r
-delete rl;//cleans everything\r
-\r
-*\r
-********* DATA *********\r
-*\r
-\r
-To run clusterizaton for DATA for file named raw_data.root type:\r
-.x FindKrClustersRaw.C("raw_data.root")\r
-\r
-If you want to change some criteria do the following:\r
-\r
-//\r
-// remove Altro warnings\r
-//\r
-AliLog::SetClassDebugLevel("AliTPCRawStream",-5);\r
-AliLog::SetClassDebugLevel("AliRawReaderDate",-5);\r
-AliLog::SetClassDebugLevel("AliTPCAltroMapping",-5);\r
-AliLog::SetModuleDebugLevel("RAW",-5);\r
-\r
-//\r
-// Get database with noises\r
-//\r
-//  char *ocdbpath = gSystem->Getenv("OCDB_PATH");\r
-char *ocdbpath ="local:///afs/cern.ch/alice/tpctest/OCDB";\r
-if (ocdbpath==0){\r
-ocdbpath="alien://folder=/alice/data/2007/LHC07w/OCDB/";\r
-}\r
-AliCDBManager * man = AliCDBManager::Instance();\r
-man->SetDefaultStorage(ocdbpath);\r
-man->SetRun(0);\r
-AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();\r
-AliTPCAltroMapping** mapping =AliTPCcalibDB::Instance()->GetMapping();\r
-\r
-//define tree\r
-TFile *hfile=new TFile("adc.root","RECREATE","ADC file");\r
-// Create a ROOT Tree\r
-TTree *mytree = new TTree("Kr","Krypton cluster tree");\r
-\r
-//define infput file\r
-const char *fileName="data.root";\r
-AliRawReader *reader = new AliRawReaderRoot(fileName);\r
-//AliRawReader *reader = new AliRawReaderDate(fileName);\r
-reader->Reset();\r
-AliAltroRawStreamFast* stream = new AliAltroRawStreamFast(reader);\r
-stream->SelectRawData("TPC");\r
-\r
-//one general output\r
-AliTPCclustererKr *clusters = new AliTPCclustererKr();\r
-clusters->SetOutput(mytree);\r
-clusters->SetRecoParam(0);//standard reco parameters\r
-AliTPCParamSR *param=new AliTPCParamSR();\r
-clusters->SetParam(param);//TPC parameters(sectors, timebins, etc.)\r
-\r
-//set cluster finder parameters (from data):\r
-//1. zero suppression parameter\r
-  clusters->SetZeroSup(param->GetZeroSup());\r
-\r
-//2. first bin\r
-  clusters->SetFirstBin(60);\r
-\r
-//3. last bin\r
-  clusters->SetLastBin(950);\r
-\r
-//4. maximal noise\r
-  clusters->SetMaxNoiseAbs(2);\r
-\r
-//5. maximal amount of sigma of noise\r
-  clusters->SetMaxNoiseSigma(3);\r
-\r
-//The remaining parameters are the same paramters as for MC (see MC section \r
-//points 1-6)\r
-  clusters->SetMinAdc(3);\r
-  clusters->SetMinTimeBins(2);\r
-  clusters->SetMaxPadRangeCm(2.5);\r
-  clusters->SetMaxRowRangeCm(3.5);\r
-  clusters->SetMaxTimeRange(7);\r
-  clusters->SetValueToSize(3.5);\r
-\r
-while (reader->NextEvent()) {\r
-  clusters->FinderIO(reader);\r
-}\r
-\r
-hfile->Write();\r
-hfile->Close();\r
-delete stream;\r
-\r
-\r
-*/\r
-\r
-#include "AliTPCclustererKr.h"\r
-#include "AliTPCclusterKr.h"\r
-//#include <vector>\r
-#include <list>\r
-#include "TObject.h"\r
-#include "AliPadMax.h"\r
-#include "AliSimDigits.h"\r
-#include "AliTPCv4.h"\r
-#include "AliTPCParam.h"\r
-#include "AliTPCDigitsArray.h"\r
-#include "AliTPCvtpr.h"\r
-#include "AliTPCClustersRow.h"\r
-#include "TTree.h"\r
-#include "TH1F.h"\r
-#include "TH2F.h"\r
-\r
-//used in raw data finder\r
-#include "AliTPCROC.h"\r
-#include "AliTPCCalPad.h"\r
-#include "AliTPCAltroMapping.h"\r
-#include "AliTPCcalibDB.h"\r
-#include "AliTPCRawStream.h"\r
-#include "AliTPCRecoParam.h"\r
-#include "AliTPCReconstructor.h"\r
-#include "AliRawReader.h"\r
-#include "AliTPCCalROC.h"\r
-\r
-ClassImp(AliTPCclustererKr)\r
-\r
-\r
-AliTPCclustererKr::AliTPCclustererKr()\r
-  :TObject(),\r
-  fRawData(kFALSE),\r
-  fRowCl(0),\r
-  fInput(0),\r
-  fOutput(0),\r
-  fParam(0),\r
-  fDigarr(0),\r
-  fRecoParam(0),\r
-  fZeroSup(2),\r
-  fFirstBin(60),\r
-  fLastBin(950),\r
-  fMaxNoiseAbs(2),\r
-  fMaxNoiseSigma(3),\r
-  fMinAdc(3),\r
-  fMinTimeBins(2),\r
-//  fMaxPadRange(4),\r
-//  fMaxRowRange(3),\r
-  fMaxTimeRange(7),\r
-  fValueToSize(3.5),\r
-  fMaxPadRangeCm(2.5),\r
-  fMaxRowRangeCm(3.5),\r
-  fDebugLevel(-1),\r
-  fHistoRow(0),\r
-  fHistoPad(0),\r
-  fHistoTime(0),\r
-  fHistoRowPad(0)\r
-{\r
-//\r
-// default constructor\r
-//\r
-}\r
-\r
-AliTPCclustererKr::AliTPCclustererKr(const AliTPCclustererKr &param)\r
-  :TObject(),\r
-  fRawData(kFALSE),\r
-  fRowCl(0),\r
-  fInput(0),\r
-  fOutput(0),\r
-  fParam(0),\r
-  fDigarr(0),\r
-  fRecoParam(0),\r
-  fZeroSup(2),\r
-  fFirstBin(60),\r
-  fLastBin(950),\r
-  fMaxNoiseAbs(2),\r
-  fMaxNoiseSigma(3),\r
-  fMinAdc(3),\r
-  fMinTimeBins(2),\r
-//  fMaxPadRange(4),\r
-//  fMaxRowRange(3),\r
-  fMaxTimeRange(7),\r
-  fValueToSize(3.5),\r
-  fMaxPadRangeCm(2.5),\r
-  fMaxRowRangeCm(3.5),\r
-  fDebugLevel(-1),\r
-  fHistoRow(0),\r
-  fHistoPad(0),\r
-  fHistoTime(0),\r
-  fHistoRowPad(0)\r
-{\r
-//\r
-// copy constructor\r
-//\r
-  fParam = param.fParam;\r
-  fRecoParam = param.fRecoParam;\r
-  fRawData = param.fRawData;\r
-  fRowCl  = param.fRowCl ;\r
-  fInput  = param.fInput ;\r
-  fOutput = param.fOutput;\r
-  fDigarr = param.fDigarr;\r
-  fZeroSup       = param.fZeroSup       ;\r
-  fFirstBin     = param.fFirstBin      ;\r
-  fLastBin      = param.fLastBin       ;\r
-  fMaxNoiseAbs  = param.fMaxNoiseAbs   ;\r
-  fMaxNoiseSigma = param.fMaxNoiseSigma ;\r
-  fMinAdc = param.fMinAdc;\r
-  fMinTimeBins = param.fMinTimeBins;\r
-//  fMaxPadRange  = param.fMaxPadRange ;\r
-//  fMaxRowRange  = param.fMaxRowRange ;\r
-  fMaxTimeRange = param.fMaxTimeRange;\r
-  fValueToSize  = param.fValueToSize;\r
-  fMaxPadRangeCm = param.fMaxPadRangeCm;\r
-  fMaxRowRangeCm = param.fMaxRowRangeCm;\r
-  fDebugLevel = param.fDebugLevel;\r
-  fHistoRow    = param.fHistoRow   ;\r
-  fHistoPad    = param.fHistoPad  ;\r
-  fHistoTime   = param.fHistoTime;\r
-  fHistoRowPad = param.fHistoRowPad;\r
-\r
-} \r
-\r
-AliTPCclustererKr & AliTPCclustererKr::operator = (const AliTPCclustererKr & param)\r
-{\r
-  //\r
-  // assignment operator\r
-  //\r
-  fParam = param.fParam;\r
-  fRecoParam = param.fRecoParam;\r
-  fRawData = param.fRawData;\r
-  fRowCl  = param.fRowCl ;\r
-  fInput  = param.fInput ;\r
-  fOutput = param.fOutput;\r
-  fDigarr = param.fDigarr;\r
-  fZeroSup       = param.fZeroSup       ;\r
-  fFirstBin     = param.fFirstBin      ;\r
-  fLastBin      = param.fLastBin       ;\r
-  fMaxNoiseAbs  = param.fMaxNoiseAbs   ;\r
-  fMaxNoiseSigma = param.fMaxNoiseSigma ;\r
-  fMinAdc = param.fMinAdc;\r
-  fMinTimeBins = param.fMinTimeBins;\r
-//  fMaxPadRange  = param.fMaxPadRange ;\r
-//  fMaxRowRange  = param.fMaxRowRange ;\r
-  fMaxTimeRange = param.fMaxTimeRange;\r
-  fValueToSize  = param.fValueToSize;\r
-  fMaxPadRangeCm = param.fMaxPadRangeCm;\r
-  fMaxRowRangeCm = param.fMaxRowRangeCm;\r
-  fDebugLevel = param.fDebugLevel;\r
-  fHistoRow    = param.fHistoRow   ;\r
-  fHistoPad    = param.fHistoPad  ;\r
-  fHistoTime   = param.fHistoTime;\r
-  fHistoRowPad = param.fHistoRowPad;\r
-  return (*this);\r
-}\r
-\r
-AliTPCclustererKr::~AliTPCclustererKr()\r
-{\r
-  //\r
-  // destructor\r
-  //\r
-}\r
-\r
-void AliTPCclustererKr::SetRecoParam(AliTPCRecoParam *recoParam)\r
-{\r
-  //\r
-  // set reconstruction parameters\r
-  //\r
-  if (recoParam) {\r
-    fRecoParam = recoParam;\r
-  }else{\r
-    //set default parameters if not specified\r
-    fRecoParam = AliTPCReconstructor::GetRecoParam();\r
-    if (!fRecoParam)  fRecoParam = AliTPCRecoParam::GetLowFluxParam();\r
-  }\r
-  return;\r
-}\r
-\r
-\r
-////____________________________________________________________________________\r
-////       I/O\r
-void AliTPCclustererKr::SetInput(TTree * tree)\r
-{\r
-  //\r
-  // set input tree with digits\r
-  //\r
-  fInput = tree;  \r
-  if  (!fInput->GetBranch("Segment")){\r
-    cerr<<"AliTPCclusterKr::FindClusterKr(): no proper input tree !\n";\r
-    fInput=0;\r
-    return;\r
-  }\r
-}\r
-\r
-void AliTPCclustererKr::SetOutput(TTree * tree) \r
-{\r
-  //\r
-  // set output\r
-  //\r
-  fOutput= tree;  \r
-  AliTPCClustersRow clrow;\r
-  AliTPCClustersRow *pclrow=&clrow;  \r
-  clrow.SetClass("AliTPCclusterKr");\r
-  clrow.SetArray(1); // to make Clones array\r
-  fOutput->Branch("Segment","AliTPCClustersRow",&pclrow,32000,200);    \r
-}\r
-\r
-////____________________________________________________________________________\r
-//// with new I/O\r
-Int_t AliTPCclustererKr::FinderIO()\r
-{\r
-  // Krypton cluster finder for simulated events from MC\r
-\r
-  if (!fInput) { \r
-    Error("Digits2Clusters", "input tree not initialised");\r
-    return 10;\r
-  }\r
-  \r
-  if (!fOutput) {\r
-    Error("Digits2Clusters", "output tree not initialised");\r
-    return 11;\r
-  }\r
-\r
-  FindClusterKrIO();\r
-  return 0;\r
-}\r
-\r
-Int_t AliTPCclustererKr::FinderIO(AliRawReader* rawReader)\r
-{\r
-  // Krypton cluster finder for the TPC raw data\r
-  //\r
-  // fParam must be defined before\r
-\r
-  if(rawReader)fRawData=kTRUE; //set flag to data\r
-\r
-  if (!fOutput) {\r
-    Error("Digits2Clusters", "output tree not initialised");\r
-    return 11;\r
-  }\r
-\r
-  fParam->SetMaxTBin(fRecoParam->GetLastBin());//set number of timebins from reco -> param\r
-  //   used later for memory allocation\r
-\r
-  Bool_t isAltro=kFALSE;\r
-\r
-  AliTPCROC * roc = AliTPCROC::Instance();\r
-  AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();\r
-  AliTPCAltroMapping** mapping =AliTPCcalibDB::Instance()->GetMapping();\r
-  //\r
-  AliTPCRawStream input(rawReader,(AliAltroMapping**)mapping);\r
-\r
-  const Int_t kNIS = fParam->GetNInnerSector();//number of inner sectors\r
-  const Int_t kNOS = fParam->GetNOuterSector();//number of outer sectors\r
-  const Int_t kNS = kNIS + kNOS;//all sectors\r
-\r
-//  //set cluster finder parameters\r
-//  SetZeroSup(fParam->GetZeroSup());//zero suppression parameter\r
-//  SetFirstBin(60);\r
-//  SetLastBin(950);\r
-//  SetMaxNoiseAbs(2);\r
-//  SetMaxNoiseSigma(3);\r
-\r
-  //crate TPC view\r
-  AliTPCDigitsArray *digarr=new AliTPCDigitsArray(kFALSE);//data not sim\r
-  digarr->Setup(fParam);//as usually parameters\r
-\r
-  //\r
-  // Loop over sectors\r
-  //\r
-  for(Int_t iSec = 0; iSec < kNS; iSec++) {\r
-    AliTPCCalROC * noiseROC;\r
-    if(noiseTPC==0x0){\r
-      noiseROC =new AliTPCCalROC(iSec);//noise=0\r
-    }\r
-    else{\r
-      noiseROC = noiseTPC->GetCalROC(iSec);  // noise per given sector\r
-    }\r
-    Int_t nRows = 0; //number of rows in sector\r
-    Int_t nDDLs = 0; //number of DDLs\r
-    Int_t indexDDL = 0; //DDL index\r
-    if (iSec < kNIS) {\r
-      nRows = fParam->GetNRowLow();\r
-      nDDLs = 2;\r
-      indexDDL = iSec * 2;\r
-    }else {\r
-      nRows = fParam->GetNRowUp();\r
-      nDDLs = 4;\r
-      indexDDL = (iSec-kNIS) * 4 + kNIS * 2;\r
-    }\r
-\r
-    //\r
-    // Load the raw data for corresponding DDLs\r
-    //\r
-    rawReader->Reset();\r
-    rawReader->Select("TPC",indexDDL,indexDDL+nDDLs-1);\r
-\r
-    if(input.Next()) {\r
-      isAltro=kTRUE;\r
-      // Allocate memory for rows in sector (pads(depends on row) x timebins)\r
-      for(Int_t iRow = 0; iRow < nRows; iRow++) {\r
-       digarr->CreateRow(iSec,iRow);\r
-      }//end loop over rows\r
-    }\r
-    rawReader->Reset();\r
-    rawReader->Select("TPC",indexDDL,indexDDL+nDDLs-1);\r
-\r
-    //\r
-    // Begin loop over altro data\r
-    //\r
-    while (input.Next()) {\r
-\r
-      //check sector consistency\r
-      if (input.GetSector() != iSec)\r
-       AliFatal(Form("Sector index mismatch ! Expected (%d), but got (%d) !",iSec,input.GetSector()));\r
-      \r
-      Short_t iRow = input.GetRow();\r
-      Short_t iPad = input.GetPad();\r
-      Short_t iTimeBin = input.GetTime();\r
-\r
-      if(fDebugLevel==72){\r
-       fHistoRow->Fill(iRow);\r
-       fHistoPad->Fill(iPad);\r
-       fHistoTime->Fill(iTimeBin);\r
-       fHistoRowPad->Fill(iPad,iRow);\r
-      }else if(fDebugLevel>=0&&fDebugLevel<72){\r
-       if(iSec==fDebugLevel){\r
-         fHistoRow->Fill(iRow);\r
-         fHistoPad->Fill(iPad);\r
-         fHistoTime->Fill(iTimeBin);\r
-         fHistoRowPad->Fill(iPad,iRow);\r
-       }\r
-      }else if(fDebugLevel==73){\r
-       if(iSec<36){\r
-         fHistoRow->Fill(iRow);\r
-         fHistoPad->Fill(iPad);\r
-         fHistoTime->Fill(iTimeBin);\r
-         fHistoRowPad->Fill(iPad,iRow);\r
-       }\r
-      }else if(fDebugLevel==74){\r
-       if(iSec>=36){\r
-         fHistoRow->Fill(iRow);\r
-         fHistoPad->Fill(iPad);\r
-         fHistoTime->Fill(iTimeBin);\r
-         fHistoRowPad->Fill(iPad,iRow);\r
-       }\r
-      }\r
-\r
-      //check row consistency\r
-      if (iRow < 0 || iRow >= nRows){\r
-       AliError(Form("Pad-row index (%d) outside the range (%d -> %d) !",\r
-                     iRow, 0, nRows -1));\r
-       continue;\r
-      }\r
-\r
-      //check pad consistency\r
-      if (iPad < 0 || iPad >= (Short_t)(roc->GetNPads(iSec,iRow))) {\r
-       AliError(Form("Pad index (%d) outside the range (%d -> %d) !",\r
-                     iPad, 0, roc->GetNPads(iSec,iRow) ));\r
-       continue;\r
-      }\r
-\r
-      //check time consistency\r
-      if ( iTimeBin < fRecoParam->GetFirstBin() || iTimeBin >= fRecoParam->GetLastBin()){\r
-       //cout<<iTimeBin<<endl;\r
-       continue;\r
-       AliFatal(Form("Timebin index (%d) outside the range (%d -> %d) !",\r
-                     iTimeBin, 0, fRecoParam->GetLastBin() -1));\r
-      }\r
-\r
-      //signal\r
-      Int_t signal = input.GetSignal();\r
-      if (signal <= fZeroSup || \r
-         iTimeBin < fFirstBin ||\r
-         iTimeBin > fLastBin\r
-         ) {\r
-       digarr->GetRow(iSec,iRow)->SetDigitFast(0,iTimeBin,iPad);\r
-       continue;\r
-      }\r
-      if (!noiseROC) continue;\r
-      Double_t noiseOnPad = noiseROC->GetValue(iRow,iPad);//noise on given pad and row in sector\r
-      if (noiseOnPad > fMaxNoiseAbs){\r
-       digarr->GetRow(iSec,iRow)->SetDigitFast(0,iTimeBin,iPad);\r
-       continue; // consider noisy pad as dead\r
-      }\r
-      if(signal <= fMaxNoiseSigma * noiseOnPad){\r
-       digarr->GetRow(iSec,iRow)->SetDigitFast(0,iTimeBin,iPad);\r
-       continue;\r
-      }\r
-\r
-      digarr->GetRow(iSec,iRow)->SetDigitFast(signal,iTimeBin,iPad);\r
-\r
-    }//end of loop over altro data\r
-  }//end of loop over sectors\r
-  \r
-  SetDigArr(digarr);\r
-  if(isAltro) FindClusterKrIO();\r
-  delete digarr;\r
-\r
-  return 0;\r
-}\r
-\r
-////____________________________________________________________________________\r
-Int_t AliTPCclustererKr::FindClusterKrIO()\r
-{\r
-  //fParam and  fDigarr must be set to run this method\r
-\r
-//  //set parameters \r
-//  SetMinAdc(3);//usually is 3 \r
-//  SetMinTimeBins(2);//should be 2 - the best result of shape in MC\r
-////  SetMaxPadRange(4);\r
-////  SetMaxRowRange(3);\r
-//  SetMaxTimeRange(7);\r
-//  SetValueToSize(3.5);//3.5\r
-//  SetMaxPadRangeCm(2.5);\r
-//  SetMaxRowRangeCm(3.5);\r
-\r
-  Int_t clusterCounter=0;\r
-  const Short_t nTotalSector=fParam->GetNSector();//number of sectors\r
-  for(Short_t iSec=0; iSec<nTotalSector; ++iSec){\r
-    \r
-    //vector of maxima for each sector\r
-    //std::vector<AliPadMax*> maximaInSector;\r
-    TObjArray *maximaInSector=new TObjArray();//to store AliPadMax*\r
-\r
-    //\r
-    //  looking for the maxima on the pad\r
-    //\r
-\r
-    const Short_t kNRows=fParam->GetNRow(iSec);//number of rows in sector\r
-    for(Short_t iRow=0; iRow<kNRows; ++iRow){\r
-      AliSimDigits *digrow;\r
-      if(fRawData){\r
-       digrow = (AliSimDigits*)fDigarr->GetRow(iSec,iRow);//real data\r
-      }else{\r
-       digrow = (AliSimDigits*)fDigarr->LoadRow(iSec,iRow);//MC\r
-      }\r
-      if(digrow){//if pointer exist\r
-       digrow->ExpandBuffer(); //decrunch\r
-       const Short_t kNPads = digrow->GetNCols();  // number of pads\r
-       const Short_t kNTime = digrow->GetNRows(); // number of timebins\r
-       for(Short_t iPad=0;iPad<kNPads;iPad++){\r
-         \r
-         Short_t timeBinMax=-1;//timebin of maximum \r
-         Short_t valueMaximum=-1;//value of maximum in adc\r
-         Short_t increaseBegin=-1;//timebin when increase starts\r
-         Short_t sumAdc=0;//sum of adc on the pad in maximum surrounding\r
-         bool ifIncreaseBegin=true;//flag - check if increasing started\r
-         bool ifMaximum=false;//flag - check if it could be maximum\r
-\r
-         for(Short_t iTimeBin=0;iTimeBin<kNTime;iTimeBin++){\r
-           Short_t adc = digrow->GetDigitFast(iTimeBin,iPad);\r
-           if(adc<fMinAdc){//standard was 3\r
-             if(ifMaximum){\r
-               if(iTimeBin-increaseBegin<fMinTimeBins){//at least 2 time bins\r
-                 timeBinMax=-1;\r
-                 valueMaximum=-1;\r
-                 increaseBegin=-1;\r
-                 sumAdc=0;\r
-                 ifIncreaseBegin=true;\r
-                 ifMaximum=false;\r
-                 continue;\r
-               }\r
-               //insert maximum, default values and set flags\r
-               Double_t xCord,yCord;\r
-               GetXY(iSec,iRow,iPad,xCord,yCord);\r
-               AliPadMax *oneMaximum = new AliPadMax(AliTPCvtpr(valueMaximum,\r
-                                                                timeBinMax,\r
-                                                                iPad,\r
-                                                                iRow,\r
-                                                                xCord,\r
-                                                                yCord,\r
-                                                                timeBinMax),\r
-                                                     increaseBegin,\r
-                                                     iTimeBin-1,\r
-                                                     sumAdc);\r
-               //maximaInSector.push_back(oneMaximum);\r
-               maximaInSector->AddLast(oneMaximum);\r
-               \r
-               timeBinMax=-1;\r
-               valueMaximum=-1;\r
-               increaseBegin=-1;\r
-               sumAdc=0;\r
-               ifIncreaseBegin=true;\r
-               ifMaximum=false;\r
-             }\r
-             continue;\r
-           }\r
-           \r
-           if(ifIncreaseBegin){\r
-             ifIncreaseBegin=false;\r
-             increaseBegin=iTimeBin;\r
-           }\r
-           \r
-           if(adc>valueMaximum){\r
-             timeBinMax=iTimeBin;\r
-             valueMaximum=adc;\r
-             ifMaximum=true;\r
-           }\r
-           sumAdc+=adc;\r
-           if(iTimeBin==kNTime-1 && ifMaximum && kNTime-increaseBegin>fMinTimeBins){//on the edge\r
-             //at least 3 timebins\r
-             //insert maximum, default values and set flags\r
-             Double_t xCord,yCord;\r
-             GetXY(iSec,iRow,iPad,xCord,yCord);\r
-             AliPadMax *oneMaximum = new AliPadMax(AliTPCvtpr(valueMaximum,\r
-                                                              timeBinMax,\r
-                                                              iPad,\r
-                                                              iRow,\r
-                                                              xCord,\r
-                                                              yCord,\r
-                                                              timeBinMax),\r
-                                                   increaseBegin,\r
-                                                   iTimeBin-1,\r
-                                                   sumAdc);\r
-             //maximaInSector.push_back(oneMaximum);\r
-             maximaInSector->AddLast(oneMaximum);\r
-               \r
-             timeBinMax=-1;\r
-             valueMaximum=-1;\r
-             increaseBegin=-1;\r
-             sumAdc=0;\r
-             ifIncreaseBegin=true;\r
-             ifMaximum=false;\r
-             continue;\r
-           }\r
-           \r
-         }//end loop over timebins\r
-       }//end loop over pads\r
-//      }else{\r
-//     cout<<"Pointer does not exist!!"<<endl;\r
-      }//end if poiner exists\r
-    }//end loop over rows\r
-\r
-    //    cout<<"EF" <<maximaInSector->GetEntriesFast()<<" E "<<maximaInSector->GetEntries()<<" "<<maximaInSector->GetLast()<<endl;\r
-    maximaInSector->Compress();\r
-    // GetEntriesFast() - liczba wejsc w array of maxima\r
-    //cout<<"EF" <<maximaInSector->GetEntriesFast()<<" E"<<maximaInSector->GetEntries()<<endl;\r
-\r
-    //\r
-    // Making clusters\r
-    //\r
-\r
-    Short_t maxDig=0;\r
-    Short_t maxSumAdc=0;\r
-    Short_t maxTimeBin=0;\r
-    Short_t maxPad=0;\r
-    Short_t maxRow=0;\r
-    Double_t maxX=0;\r
-    Double_t maxY=0;\r
-    \r
-//    for( std::vector<AliPadMax*>::iterator mp1  = maximaInSector.begin();\r
-//      mp1 != maximaInSector.end(); ++mp1 ) {\r
-    for(Int_t it1 = 0; it1 < maximaInSector->GetEntriesFast(); ++it1 ) {\r
-\r
-      AliPadMax *mp1=(AliPadMax *)maximaInSector->At(it1);\r
-      AliTPCclusterKr *tmp=new AliTPCclusterKr();\r
-      \r
-      Short_t nUsedPads=1;\r
-      Int_t clusterValue=0;\r
-      clusterValue+=(mp1)->GetSum();\r
-      list<Short_t> nUsedRows;\r
-      nUsedRows.push_back((mp1)->GetRow());\r
-\r
-      maxDig      =(mp1)->GetAdc() ;\r
-      maxSumAdc   =(mp1)->GetSum() ;\r
-      maxTimeBin  =(mp1)->GetTime();\r
-      maxPad      =(mp1)->GetPad() ;\r
-      maxRow      =(mp1)->GetRow() ;\r
-      maxX        =(mp1)->GetX();\r
-      maxY        =(mp1)->GetY();\r
-\r
-      AliSimDigits *digrowTmp;\r
-      if(fRawData){\r
-       digrowTmp = (AliSimDigits*)fDigarr->GetRow(iSec,(mp1)->GetRow());\r
-      }else{\r
-       digrowTmp = (AliSimDigits*)fDigarr->LoadRow(iSec,(mp1)->GetRow());\r
-      }\r
-\r
-      digrowTmp->ExpandBuffer(); //decrunch\r
-\r
-      for(Short_t itb=(mp1)->GetBegin(); itb<((mp1)->GetEnd())+1; itb++){\r
-       Short_t adcTmp = digrowTmp->GetDigitFast(itb,(mp1)->GetPad());\r
-       AliTPCvtpr *vtpr=new AliTPCvtpr(adcTmp,itb,(mp1)->GetPad(),(mp1)->GetRow(),(mp1)->GetX(),(mp1)->GetY(),itb);\r
-       //tmp->fCluster.push_back(vtpr);\r
-       tmp->AddDigitToCluster(vtpr);\r
-      }\r
-      tmp->SetCenter();//set centr of the cluster\r
-      \r
-      //maximaInSector.erase(mp1);\r
-      //mp1--;\r
-      //cout<<maximaInSector->GetEntriesFast()<<" ";\r
-      maximaInSector->RemoveAt(it1);\r
-      maximaInSector->Compress();\r
-      it1--;\r
-      //     cout<<maximaInSector->GetEntriesFast()<<" "<<endl;\r
-\r
-//      for( std::vector<AliPadMax*>::iterator mp2  = maximaInSector.begin();\r
-//        mp2 != maximaInSector.end(); ++mp2 ) {\r
-      for(Int_t it2 = 0; it2 < maximaInSector->GetEntriesFast(); ++it2 ) {\r
-       AliPadMax *mp2=(AliPadMax *)maximaInSector->At(it2);\r
-\r
-//     if(abs(maxRow - (*mp2)->GetRow()) < fMaxRowRange && //3\r
-//         abs(maxPad - (*mp2)->GetPad()) < fMaxPadRange && //4\r
-         \r
-       if(TMath::Abs(tmp->GetCenterX() - (mp2)->GetX()) < fMaxPadRangeCm &&\r
-          TMath::Abs(tmp->GetCenterY() - (mp2)->GetY()) < fMaxRowRangeCm &&\r
-          TMath::Abs(tmp->GetCenterT() - (mp2)->GetT()) < fMaxTimeRange){//7\r
-         \r
-         clusterValue+=(mp2)->GetSum();\r
-\r
-         nUsedPads++;\r
-         nUsedRows.push_back((mp2)->GetRow());\r
-\r
-         AliSimDigits *digrowTmp1;\r
-         if(fRawData){\r
-           digrowTmp1 = (AliSimDigits*)fDigarr->GetRow(iSec,(mp2)->GetRow());\r
-         }else{\r
-           digrowTmp1 = (AliSimDigits*)fDigarr->LoadRow(iSec,(mp2)->GetRow());\r
-         }\r
-         digrowTmp1->ExpandBuffer(); //decrunch\r
-         \r
-         for(Short_t itb=(mp2)->GetBegin(); itb<(mp2)->GetEnd()+1; itb++){\r
-           Short_t adcTmp = digrowTmp1->GetDigitFast(itb,(mp2)->GetPad());\r
-           AliTPCvtpr *vtpr=new AliTPCvtpr(adcTmp,itb,(mp2)->GetPad(),(mp2)->GetRow(),(mp2)->GetX(),(mp2)->GetY(),itb);\r
-           //tmp->fCluster.push_back(vtpr);\r
-           tmp->AddDigitToCluster(vtpr);\r
-         }\r
-         \r
-         tmp->SetCenter();//set center of the cluster\r
-\r
-         //which one is bigger\r
-         if( (mp2)->GetAdc() > maxDig ){\r
-           maxDig      =(mp2)->GetAdc() ;\r
-           maxSumAdc   =(mp2)->GetSum() ;\r
-           maxTimeBin  =(mp2)->GetTime();\r
-           maxPad      =(mp2)->GetPad() ;\r
-           maxRow      =(mp2)->GetRow() ;\r
-           maxX        =(mp2)->GetX() ;\r
-           maxY        =(mp2)->GetY() ;\r
-         } else if ( (mp2)->GetAdc() == maxDig ){\r
-           if( (mp2)->GetSum() > maxSumAdc){\r
-             maxDig      =(mp2)->GetAdc() ;\r
-             maxSumAdc   =(mp2)->GetSum() ;\r
-             maxTimeBin  =(mp2)->GetTime();\r
-             maxPad      =(mp2)->GetPad() ;\r
-             maxRow      =(mp2)->GetRow() ;\r
-             maxX        =(mp2)->GetX() ;\r
-             maxY        =(mp2)->GetY() ;\r
-           }\r
-         }\r
-         maximaInSector->RemoveAt(it2);\r
-         maximaInSector->Compress();\r
-         it2--;\r
-\r
-         //maximaInSector.erase(mp2);\r
-         //mp2--;\r
-       }\r
-      }//inside loop\r
-\r
-      tmp->SetSize();\r
-      //through out ADC=6,7 on 1 pad, 2 tb and ADC=12 on 2 pads,2 tb\r
-      //if(nUsedPads==1 && clusterValue/tmp->fCluster.size()<3.6)continue;\r
-      //if(nUsedPads==2 && clusterValue/tmp->fCluster.size()<3.1)continue;\r
-\r
-      //through out clusters on the edge and noise\r
-      //if(clusterValue/tmp->fCluster.size()<fValueToSize)continue;\r
-      if(clusterValue/(tmp->GetSize())<fValueToSize)continue;\r
-\r
-      tmp->SetADCcluster(clusterValue);\r
-      tmp->SetNPads(nUsedPads);\r
-      tmp->SetMax(AliTPCvtpr(maxDig,maxTimeBin,maxPad,maxRow,maxX,maxY,maxTimeBin));\r
-      tmp->SetSec(iSec);\r
-      tmp->SetSize();\r
-\r
-      nUsedRows.sort();\r
-      nUsedRows.unique();\r
-      tmp->SetNRows(nUsedRows.size());\r
-      tmp->SetCenter();\r
-\r
-      clusterCounter++;\r
-      \r
-\r
-      //save each cluster into file\r
-\r
-      AliTPCClustersRow *clrow= new AliTPCClustersRow();\r
-      fRowCl=clrow;\r
-      clrow->SetClass("AliTPCclusterKr");\r
-      clrow->SetArray(1);\r
-      fOutput->GetBranch("Segment")->SetAddress(&clrow);\r
-\r
-      Int_t tmpCluster=0;\r
-      TClonesArray * arr = fRowCl->GetArray();\r
-      AliTPCclusterKr * cl = new ((*arr)[tmpCluster]) AliTPCclusterKr(*tmp);\r
-      \r
-      fOutput->Fill(); \r
-      delete clrow;\r
-      //end of save each cluster into file adc.root\r
-    }//outer loop\r
-\r
-  }//end sector for\r
-  cout<<"Number of clusters in event: "<<clusterCounter<<endl;\r
-\r
-  return 0;\r
-}\r
-\r
-////____________________________________________________________________________\r
-\r
-\r
-void AliTPCclustererKr::GetXY(Short_t sec,Short_t row,Short_t pad,Double_t& xGlob,Double_t& yGlob){\r
-  //\r
-  //gives global XY coordinate of the pad\r
-  //\r
-\r
-  Double_t yLocal = fParam->GetPadRowRadii(sec,row);//radius of row in sector in cm\r
-\r
-  Short_t padmax = fParam->GetNPads(sec,row);//number of pads in a given row\r
-  Float_t padXSize;\r
-  if(sec<fParam->GetNInnerSector())padXSize=0.4;\r
-  else padXSize=0.6;\r
-  Double_t xLocal=(pad+0.5-padmax/2.)*padXSize;//x-value of the center of pad\r
-\r
-  Float_t sin,cos;\r
-  fParam->AdjustCosSin((Int_t)sec,cos,sin);//return sinus and cosinus of the sector\r
-\r
-  Double_t xGlob1 =  xLocal * cos + yLocal * sin;\r
-  Double_t yGlob1 = -xLocal * sin + yLocal * cos;\r
-\r
-\r
-  Double_t rot=0;\r
-  rot=TMath::Pi()/2.;\r
-\r
-  xGlob =  xGlob1 * TMath::Cos(rot) + yGlob1 * TMath::Sin(rot);\r
-  yGlob = -xGlob1 * TMath::Sin(rot) + yGlob1 * TMath::Cos(rot);\r
-\r
-   yGlob=-1*yGlob;\r
-   if(sec<18||(sec>=36&&sec<54)) xGlob =-1*xGlob;\r
-\r
-\r
-  return;\r
-}\r
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/* $Id: AliTPCclustererKr.cxx,v 1.7 2008/02/06 17:24:53 matyja Exp $ */
+
+//-----------------------------------------------------------------
+//           Implementation of the TPC Kr cluster class
+//
+// Origin: Adam Matyja, INP PAN, adam.matyja@ifj.edu.pl
+//-----------------------------------------------------------------
+
+/*
+Instruction - how to use that:
+There are two macros prepared. One is for preparing clusters from MC 
+samples:  FindKrClusters.C. The output is kept in TPC.RecPoints.root.
+The other macro is prepared for data analysis: FindKrClustersRaw.C. 
+The output is created for each processed file in root file named adc.root. 
+For each data subsample the same named file is created. So be careful 
+do not overwrite them. 
+
+Additional selection criteria to select the GOLD cluster
+Example:
+// open  file with clusters
+TFile f("Krypton.root");
+TTree * tree = (TTree*)f.Get("Kr")
+TCut cutR0("cutR0","fADCcluster/fSize<100");        // adjust it according v seetings - 
+TCut cutR1("cutR1","fADCcluster/fSize>7");          // cosmic tracks and noise removal
+TCut cutR2("cutR2","fMax.fAdc/fADCcluster<0.2");    // digital noise removal
+TCut cutR3("cutR3","fMax.fAdc/fADCcluster>0.01");   // noise removal
+TCut cutS1("cutS1","fSize<200");    // adjust it according v seetings - cosmic tracks
+TCut cutAll = cutR0+cutR1+cutR2+cutR3+cutS1;
+This values are typical values to be applied in selectors
+
+
+*
+**** MC ****
+*
+
+To run clusterizaton for MC type:
+.x FindKrClusters.C
+
+If you don't want to use the standard selection criteria then you 
+have to do following:
+
+// load the standard setup
+AliRunLoader* rl = AliRunLoader::Open("galice.root");
+AliTPCLoader *tpcl = (AliTPCLoader*)rl->GetLoader("TPCLoader");
+tpcl->LoadDigits();
+rl->LoadgAlice();
+gAlice=rl->GetAliRun();
+TDirectory *cwd = gDirectory;
+AliTPCv4 *tpc = (AliTPCv4*)gAlice->GetDetector("TPC");
+Int_t ver = tpc->IsVersion();
+rl->CdGAFile();
+AliTPCParam *param=(AliTPCParamSR *)gDirectory->Get("75x40_100x60_150x60");
+AliTPCDigitsArray *digarr=new AliTPCDigitsArray;
+digarr->Setup(param);
+cwd->cd();
+
+//loop over events
+Int_t nevmax=rl->GetNumberOfEvents();
+for(Int_t nev=0;nev<nevmax ;nev++){
+  rl->GetEvent(nev);
+  TTree* input_tree= tpcl->TreeD();//load tree with digits
+  digarr->ConnectTree(input_tree);
+  TTree *output_tree =tpcl->TreeR();//load output tree
+
+  AliTPCclustererKr *clusters = new AliTPCclustererKr();
+  clusters->SetParam(param);
+  clusters->SetInput(input_tree);
+  clusters->SetOutput(output_tree);
+  clusters->SetDigArr(digarr);
+  
+//If you want to change the cluster finder parameters for MC there are 
+//several of them:
+
+//1. signal threshold (everything below the given number is treated as 0)
+  clusters->SetMinAdc(3);
+
+//2. number of neighbouring timebins to be considered
+  clusters->SetMinTimeBins(2);
+
+//3. distance of the cluster center to the center of a pad in pad-padrow plane 
+//(in cm). Remenber that this is still quantified by pad size.
+  clusters->SetMaxPadRangeCm(2.5);
+
+//4. distance of the cluster center to the center of a padrow in pad-padrow 
+//plane (in cm). Remenber that this is still quantified by pad size.
+  clusters->SetMaxRowRangeCm(3.5);
+
+//5. distance of the cluster center to the max time bin on a pad (in tackts)
+//ie. fabs(centerT - time)<7
+  clusters->SetMaxTimeRange(7);
+
+//6. cut reduce peak at 0. There are noises which appear mostly as two 
+//timebins on one pad.
+  clusters->SetValueToSize(3.5);
+
+
+  clusters->finderIO();
+  tpcl->WriteRecPoints("OVERWRITE");
+}
+delete rl;//cleans everything
+
+*
+********* DATA *********
+*
+
+To run clusterizaton for DATA for file named raw_data.root type:
+.x FindKrClustersRaw.C("raw_data.root")
+
+If you want to change some criteria do the following:
+
+//
+// remove Altro warnings
+//
+AliLog::SetClassDebugLevel("AliTPCRawStream",-5);
+AliLog::SetClassDebugLevel("AliRawReaderDate",-5);
+AliLog::SetClassDebugLevel("AliTPCAltroMapping",-5);
+AliLog::SetModuleDebugLevel("RAW",-5);
+
+//
+// Get database with noises
+//
+//  char *ocdbpath = gSystem->Getenv("OCDB_PATH");
+char *ocdbpath ="local:///afs/cern.ch/alice/tpctest/OCDB";
+if (ocdbpath==0){
+ocdbpath="alien://folder=/alice/data/2007/LHC07w/OCDB/";
+}
+AliCDBManager * man = AliCDBManager::Instance();
+man->SetDefaultStorage(ocdbpath);
+man->SetRun(0);
+AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();
+AliTPCAltroMapping** mapping =AliTPCcalibDB::Instance()->GetMapping();
+
+//define tree
+TFile *hfile=new TFile("adc.root","RECREATE","ADC file");
+// Create a ROOT Tree
+TTree *mytree = new TTree("Kr","Krypton cluster tree");
+
+//define infput file
+const char *fileName="data.root";
+AliRawReader *reader = new AliRawReaderRoot(fileName);
+//AliRawReader *reader = new AliRawReaderDate(fileName);
+reader->Reset();
+AliAltroRawStreamFast* stream = new AliAltroRawStreamFast(reader);
+stream->SelectRawData("TPC");
+
+//one general output
+AliTPCclustererKr *clusters = new AliTPCclustererKr();
+clusters->SetOutput(mytree);
+clusters->SetRecoParam(0);//standard reco parameters
+AliTPCParamSR *param=new AliTPCParamSR();
+clusters->SetParam(param);//TPC parameters(sectors, timebins, etc.)
+
+//set cluster finder parameters (from data):
+//1. zero suppression parameter
+  clusters->SetZeroSup(param->GetZeroSup());
+
+//2. first bin
+  clusters->SetFirstBin(60);
+
+//3. last bin
+  clusters->SetLastBin(950);
+
+//4. maximal noise
+  clusters->SetMaxNoiseAbs(2);
+
+//5. maximal amount of sigma of noise
+  clusters->SetMaxNoiseSigma(3);
+
+//The remaining parameters are the same paramters as for MC (see MC section 
+//points 1-6)
+  clusters->SetMinAdc(3);
+  clusters->SetMinTimeBins(2);
+  clusters->SetMaxPadRangeCm(2.5);
+  clusters->SetMaxRowRangeCm(3.5);
+  clusters->SetMaxTimeRange(7);
+  clusters->SetValueToSize(3.5);
+
+while (reader->NextEvent()) {
+  clusters->FinderIO(reader);
+}
+
+hfile->Write();
+hfile->Close();
+delete stream;
+
+
+*/
+
+#include "AliTPCclustererKr.h"
+#include "AliTPCclusterKr.h"
+//#include <vector>
+#include <list>
+#include "TObject.h"
+#include "AliPadMax.h"
+#include "AliSimDigits.h"
+#include "AliTPCv4.h"
+#include "AliTPCParam.h"
+#include "AliTPCDigitsArray.h"
+#include "AliTPCvtpr.h"
+#include "AliTPCClustersRow.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TTreeStream.h"
+
+#include "AliTPCTransform.h"
+
+//used in raw data finder
+#include "AliTPCROC.h"
+#include "AliTPCCalPad.h"
+#include "AliTPCAltroMapping.h"
+#include "AliTPCcalibDB.h"
+#include "AliTPCRawStream.h"
+#include "AliTPCRecoParam.h"
+#include "AliTPCReconstructor.h"
+#include "AliRawReader.h"
+#include "AliTPCCalROC.h"
+
+ClassImp(AliTPCclustererKr)
+
+
+AliTPCclustererKr::AliTPCclustererKr()
+  :TObject(),
+  fRawData(kFALSE),
+  fInput(0),
+  fOutput(0),
+  fParam(0),
+  fDigarr(0),
+  fRecoParam(0),
+  fZeroSup(2),
+  fFirstBin(60),
+  fLastBin(950),
+  fMaxNoiseAbs(2),
+  fMaxNoiseSigma(3),
+  fMinAdc(3),
+  fMinTimeBins(2),
+//  fMaxPadRange(4),
+//  fMaxRowRange(3),
+  fMaxTimeRange(7),
+  fValueToSize(3.5),
+  fMaxPadRangeCm(2.5),
+  fMaxRowRangeCm(3.5),
+  fDebugLevel(-1),
+  fHistoRow(0),
+  fHistoPad(0),
+  fHistoTime(0),
+  fHistoRowPad(0)
+{
+//
+// default constructor
+//
+}
+
+AliTPCclustererKr::AliTPCclustererKr(const AliTPCclustererKr &param)
+  :TObject(),
+  fRawData(kFALSE),
+  fInput(0),
+  fOutput(0),
+  fParam(0),
+  fDigarr(0),
+  fRecoParam(0),
+  fZeroSup(2),
+  fFirstBin(60),
+  fLastBin(950),
+  fMaxNoiseAbs(2),
+  fMaxNoiseSigma(3),
+  fMinAdc(3),
+  fMinTimeBins(2),
+//  fMaxPadRange(4),
+//  fMaxRowRange(3),
+  fMaxTimeRange(7),
+  fValueToSize(3.5),
+  fMaxPadRangeCm(2.5),
+  fMaxRowRangeCm(3.5),
+  fDebugLevel(-1),
+  fHistoRow(0),
+  fHistoPad(0),
+  fHistoTime(0),
+  fHistoRowPad(0)
+{
+//
+// copy constructor
+//
+  fParam = param.fParam;
+  fRecoParam = param.fRecoParam;
+  fRawData = param.fRawData;
+  fInput  = param.fInput ;
+  fOutput = param.fOutput;
+  fDigarr = param.fDigarr;
+  fZeroSup       = param.fZeroSup       ;
+  fFirstBin     = param.fFirstBin      ;
+  fLastBin      = param.fLastBin       ;
+  fMaxNoiseAbs  = param.fMaxNoiseAbs   ;
+  fMaxNoiseSigma = param.fMaxNoiseSigma ;
+  fMinAdc = param.fMinAdc;
+  fMinTimeBins = param.fMinTimeBins;
+//  fMaxPadRange  = param.fMaxPadRange ;
+//  fMaxRowRange  = param.fMaxRowRange ;
+  fMaxTimeRange = param.fMaxTimeRange;
+  fValueToSize  = param.fValueToSize;
+  fMaxPadRangeCm = param.fMaxPadRangeCm;
+  fMaxRowRangeCm = param.fMaxRowRangeCm;
+  fDebugLevel = param.fDebugLevel;
+  fHistoRow    = param.fHistoRow   ;
+  fHistoPad    = param.fHistoPad  ;
+  fHistoTime   = param.fHistoTime;
+  fHistoRowPad = param.fHistoRowPad;
+
+} 
+
+AliTPCclustererKr & AliTPCclustererKr::operator = (const AliTPCclustererKr & param)
+{
+  //
+  // assignment operator
+  //
+  fParam = param.fParam;
+  fRecoParam = param.fRecoParam;
+  fRawData = param.fRawData;
+  fInput  = param.fInput ;
+  fOutput = param.fOutput;
+  fDigarr = param.fDigarr;
+  fZeroSup       = param.fZeroSup       ;
+  fFirstBin     = param.fFirstBin      ;
+  fLastBin      = param.fLastBin       ;
+  fMaxNoiseAbs  = param.fMaxNoiseAbs   ;
+  fMaxNoiseSigma = param.fMaxNoiseSigma ;
+  fMinAdc = param.fMinAdc;
+  fMinTimeBins = param.fMinTimeBins;
+//  fMaxPadRange  = param.fMaxPadRange ;
+//  fMaxRowRange  = param.fMaxRowRange ;
+  fMaxTimeRange = param.fMaxTimeRange;
+  fValueToSize  = param.fValueToSize;
+  fMaxPadRangeCm = param.fMaxPadRangeCm;
+  fMaxRowRangeCm = param.fMaxRowRangeCm;
+  fDebugLevel = param.fDebugLevel;
+  fHistoRow    = param.fHistoRow   ;
+  fHistoPad    = param.fHistoPad  ;
+  fHistoTime   = param.fHistoTime;
+  fHistoRowPad = param.fHistoRowPad;
+  return (*this);
+}
+
+AliTPCclustererKr::~AliTPCclustererKr()
+{
+  //
+  // destructor
+  //
+  delete fOutput;
+}
+
+void AliTPCclustererKr::SetRecoParam(AliTPCRecoParam *recoParam)
+{
+  //
+  // set reconstruction parameters
+  //
+  if (recoParam) {
+    fRecoParam = recoParam;
+  }else{
+    //set default parameters if not specified
+    fRecoParam = AliTPCReconstructor::GetRecoParam();
+    if (!fRecoParam)  fRecoParam = AliTPCRecoParam::GetLowFluxParam();
+  }
+  return;
+}
+
+
+////____________________________________________________________________________
+////       I/O
+void AliTPCclustererKr::SetInput(TTree * tree)
+{
+  //
+  // set input tree with digits
+  //
+  fInput = tree;  
+  if  (!fInput->GetBranch("Segment")){
+    cerr<<"AliTPCclusterKr::FindClusterKr(): no proper input tree !\n";
+    fInput=0;
+    return;
+  }
+}
+
+void AliTPCclustererKr::SetOutput(TTree * /*tree*/) 
+{
+  //
+  //dummy
+  //
+  fOutput = new TTreeSRedirector("Krypton.root");
+}
+
+////____________________________________________________________________________
+//// with new I/O
+Int_t AliTPCclustererKr::FinderIO()
+{
+  // Krypton cluster finder for simulated events from MC
+
+  if (!fInput) { 
+    Error("Digits2Clusters", "input tree not initialised");
+    return 10;
+  }
+  
+  if (!fOutput) {
+    Error("Digits2Clusters", "output tree not initialised");
+    return 11;
+  }
+
+  FindClusterKrIO();
+  return 0;
+}
+
+Int_t AliTPCclustererKr::FinderIO(AliRawReader* rawReader)
+{
+  // Krypton cluster finder for the TPC raw data
+  //
+  // fParam must be defined before
+
+  if(rawReader)fRawData=kTRUE; //set flag to data
+
+  if (!fOutput) {
+    Error("Digits2Clusters", "output tree not initialised");
+    return 11;
+  }
+
+  fParam->SetMaxTBin(fRecoParam->GetLastBin());//set number of timebins from reco -> param
+  //   used later for memory allocation
+
+  Bool_t isAltro=kFALSE;
+
+  AliTPCROC * roc = AliTPCROC::Instance();
+  AliTPCCalPad * noiseTPC = AliTPCcalibDB::Instance()->GetPadNoise();
+  AliTPCAltroMapping** mapping =AliTPCcalibDB::Instance()->GetMapping();
+  //
+  AliTPCRawStream input(rawReader,(AliAltroMapping**)mapping);
+
+  const Int_t kNIS = fParam->GetNInnerSector();//number of inner sectors
+  const Int_t kNOS = fParam->GetNOuterSector();//number of outer sectors
+  const Int_t kNS = kNIS + kNOS;//all sectors
+
+
+  //crate TPC view
+  AliTPCDigitsArray *digarr=new AliTPCDigitsArray(kFALSE);//data not sim
+  digarr->Setup(fParam);//as usually parameters
+
+  //
+  // Loop over sectors
+  //
+  for(Int_t iSec = 0; iSec < kNS; iSec++) {
+    AliTPCCalROC * noiseROC;
+    if(noiseTPC==0x0){
+      noiseROC =new AliTPCCalROC(iSec);//noise=0
+    }
+    else{
+      noiseROC = noiseTPC->GetCalROC(iSec);  // noise per given sector
+    }
+    Int_t nRows = 0; //number of rows in sector
+    Int_t nDDLs = 0; //number of DDLs
+    Int_t indexDDL = 0; //DDL index
+    if (iSec < kNIS) {
+      nRows = fParam->GetNRowLow();
+      nDDLs = 2;
+      indexDDL = iSec * 2;
+    }else {
+      nRows = fParam->GetNRowUp();
+      nDDLs = 4;
+      indexDDL = (iSec-kNIS) * 4 + kNIS * 2;
+    }
+
+    //
+    // Load the raw data for corresponding DDLs
+    //
+    rawReader->Reset();
+    rawReader->Select("TPC",indexDDL,indexDDL+nDDLs-1);
+
+    if(input.Next()) {
+      isAltro=kTRUE;
+      // Allocate memory for rows in sector (pads(depends on row) x timebins)
+      for(Int_t iRow = 0; iRow < nRows; iRow++) {
+       digarr->CreateRow(iSec,iRow); 
+      }//end loop over rows
+    }
+    rawReader->Reset();
+    rawReader->Select("TPC",indexDDL,indexDDL+nDDLs-1);
+
+    //
+    // Begin loop over altro data
+    //
+    while (input.Next()) {
+      
+      //check sector consistency
+      if (input.GetSector() != iSec)
+       AliFatal(Form("Sector index mismatch ! Expected (%d), but got (%d) !",iSec,input.GetSector()));
+      
+      Int_t iRow = input.GetRow();
+      Int_t iPad = input.GetPad();
+      Int_t iTimeBin = input.GetTime();
+
+      //
+      if(fDebugLevel==72){
+       fHistoRow->Fill(iRow);
+       fHistoPad->Fill(iPad);
+       fHistoTime->Fill(iTimeBin);
+       fHistoRowPad->Fill(iPad,iRow);
+      }else if(fDebugLevel>=0&&fDebugLevel<72){
+       if(iSec==fDebugLevel){
+         fHistoRow->Fill(iRow);
+         fHistoPad->Fill(iPad);
+         fHistoTime->Fill(iTimeBin);
+         fHistoRowPad->Fill(iPad,iRow);
+       }
+      }else if(fDebugLevel==73){
+       if(iSec<36){
+         fHistoRow->Fill(iRow);
+         fHistoPad->Fill(iPad);
+         fHistoTime->Fill(iTimeBin);
+         fHistoRowPad->Fill(iPad,iRow);
+       }
+      }else if(fDebugLevel==74){
+       if(iSec>=36){
+         fHistoRow->Fill(iRow);
+         fHistoPad->Fill(iPad);
+         fHistoTime->Fill(iTimeBin);
+         fHistoRowPad->Fill(iPad,iRow);
+       }
+      }
+
+      //check row consistency
+      if (iRow < 0 ) continue;
+      if (iRow < 0 || iRow >= nRows){
+       AliError(Form("Pad-row index (%d) outside the range (%d -> %d) !",
+                     iRow, 0, nRows -1));
+       continue;
+      }
+
+      //check pad consistency
+      if (iPad < 0 || iPad >= (Int_t)(roc->GetNPads(iSec,iRow))) {
+       AliError(Form("Pad index (%d) outside the range (%d -> %d) !",
+                     iPad, 0, roc->GetNPads(iSec,iRow) ));
+       continue;
+      }
+
+      //check time consistency
+      if ( iTimeBin < fRecoParam->GetFirstBin() || iTimeBin >= fRecoParam->GetLastBin()){
+       //cout<<iTimeBin<<endl;
+       continue;
+       AliFatal(Form("Timebin index (%d) outside the range (%d -> %d) !",
+                     iTimeBin, 0, fRecoParam->GetLastBin() -1));
+      }
+
+      //signal
+      Int_t signal = input.GetSignal();
+      if (signal <= fZeroSup || 
+         iTimeBin < fFirstBin ||
+         iTimeBin > fLastBin
+         ) {
+       digarr->GetRow(iSec,iRow)->SetDigitFast(0,iTimeBin,iPad);
+       continue;
+      }
+      if (!noiseROC) continue;
+      Double_t noiseOnPad = noiseROC->GetValue(iRow,iPad);//noise on given pad and row in sector
+      if (noiseOnPad > fMaxNoiseAbs){
+       digarr->GetRow(iSec,iRow)->SetDigitFast(0,iTimeBin,iPad);
+       continue; // consider noisy pad as dead
+      }
+      if(signal <= fMaxNoiseSigma * noiseOnPad){
+       digarr->GetRow(iSec,iRow)->SetDigitFast(0,iTimeBin,iPad);
+       continue;
+      }
+      digarr->GetRow(iSec,iRow)->SetDigitFast(signal,iTimeBin,iPad);      
+    }//end of loop over altro data
+  }//end of loop over sectors
+  
+  SetDigArr(digarr);
+  if(isAltro) FindClusterKrIO();
+  delete digarr;
+
+  return 0;
+}
+
+////____________________________________________________________________________
+Int_t AliTPCclustererKr::FindClusterKrIO()
+{
+
+  //
+  //fParam and  fDigarr must be set to run this method
+  //
+
+  Int_t clusterCounter=0;
+  const Int_t nTotalSector=fParam->GetNSector();//number of sectors
+  for(Int_t iSec=0; iSec<nTotalSector; ++iSec){
+    
+    //vector of maxima for each sector
+    //std::vector<AliPadMax*> maximaInSector;
+    TObjArray *maximaInSector=new TObjArray();//to store AliPadMax*
+
+    //
+    //  looking for the maxima on the pad
+    //
+
+    const Int_t kNRows=fParam->GetNRow(iSec);//number of rows in sector
+    for(Int_t iRow=0; iRow<kNRows; ++iRow){
+      AliSimDigits *digrow;
+      if(fRawData){
+       digrow = (AliSimDigits*)fDigarr->GetRow(iSec,iRow);//real data
+      }else{
+       digrow = (AliSimDigits*)fDigarr->LoadRow(iSec,iRow);//MC
+      }
+      if(digrow){//if pointer exist
+       digrow->ExpandBuffer(); //decrunch
+       const Int_t kNPads = digrow->GetNCols();  // number of pads
+       const Int_t kNTime = digrow->GetNRows(); // number of timebins
+       for(Int_t iPad=0;iPad<kNPads;iPad++){
+         
+         Int_t timeBinMax=-1;//timebin of maximum 
+         Int_t valueMaximum=-1;//value of maximum in adc
+         Int_t increaseBegin=-1;//timebin when increase starts
+         Int_t sumAdc=0;//sum of adc on the pad in maximum surrounding
+         bool ifIncreaseBegin=true;//flag - check if increasing started
+         bool ifMaximum=false;//flag - check if it could be maximum
+         Short_t* val = digrow->GetDigitsColumn(iPad);
+         for(Int_t iTimeBin=1;iTimeBin<kNTime-1;iTimeBin++){
+           if (!ifMaximum)  {
+             if (val[iTimeBin]==-1) break;   // 0 until the end
+             for( ; iTimeBin<kNTime-2&&val[iTimeBin]<fMinAdc ;iTimeBin++);
+           }
+           //
+           Short_t adc = val[iTimeBin];
+           if(adc<fMinAdc){//standard was 3
+             if(ifMaximum){
+               if(iTimeBin-increaseBegin<fMinTimeBins){//at least 2 time bins
+                 timeBinMax=-1;
+                 valueMaximum=-1;
+                 increaseBegin=-1;
+                 sumAdc=0;
+                 ifIncreaseBegin=true;
+                 ifMaximum=false;
+                 continue;
+               }
+               //insert maximum, default values and set flags
+               //Double_t xCord,yCord;
+               //GetXY(iSec,iRow,iPad,xCord,yCord);
+               Double_t x[]={iRow,iPad,iTimeBin};
+               Int_t i[]={iSec};
+               AliTPCTransform trafo;
+               trafo.Transform(x,i,0,1);
+               
+               AliPadMax *oneMaximum = new AliPadMax(AliTPCvtpr(valueMaximum,
+                                                                timeBinMax,
+                                                                iPad,
+                                                                iRow,
+                                                                x[0],//xCord,
+                                                                x[1],//yCord,
+                                                                x[2]/*timeBinMax*/),
+                                                     increaseBegin,
+                                                     iTimeBin-1,
+                                                     sumAdc);
+               maximaInSector->AddLast(oneMaximum);
+               
+               timeBinMax=-1;
+               valueMaximum=-1;
+               increaseBegin=-1;
+               sumAdc=0;
+               ifIncreaseBegin=true;
+               ifMaximum=false;
+             }
+             continue;
+           }
+           
+           if(ifIncreaseBegin){
+             ifIncreaseBegin=false;
+             increaseBegin=iTimeBin;
+           }
+           
+           if(adc>valueMaximum){
+             timeBinMax=iTimeBin;
+             valueMaximum=adc;
+             ifMaximum=true;
+           }
+           sumAdc+=adc;
+           if(iTimeBin==kNTime-1 && ifMaximum && kNTime-increaseBegin>fMinTimeBins){//on the edge
+             //at least 3 timebins
+             //insert maximum, default values and set flags
+             //Double_t xCord,yCord;
+             //GetXY(iSec,iRow,iPad,xCord,yCord);
+             Double_t x[]={iRow,iPad,iTimeBin};
+             Int_t i[]={iSec};
+             AliTPCTransform trafo;
+             trafo.Transform(x,i,0,1);
+             AliPadMax *oneMaximum = new AliPadMax(AliTPCvtpr(valueMaximum,
+                                                              timeBinMax,
+                                                              iPad,
+                                                              iRow,
+                                                              x[0],//xCord,
+                                                              x[1],//yCord,
+                                                              x[2]/*timeBinMax*/),
+                                                   increaseBegin,
+                                                   iTimeBin-1,
+                                                   sumAdc);
+             maximaInSector->AddLast(oneMaximum);
+               
+             timeBinMax=-1;
+             valueMaximum=-1;
+             increaseBegin=-1;
+             sumAdc=0;
+             ifIncreaseBegin=true;
+             ifMaximum=false;
+             continue;
+           }
+           
+         }//end loop over timebins
+       }//end loop over pads
+//      }else{
+//     cout<<"Pointer does not exist!!"<<endl;
+      }//end if poiner exists
+    }//end loop over rows
+
+    MakeClusters(maximaInSector,iSec,clusterCounter);
+    //
+    maximaInSector->SetOwner(kTRUE);
+    maximaInSector->Delete();
+    delete maximaInSector;
+  }//end sector for
+  cout<<"Number of clusters in event: "<<clusterCounter<<endl;
+  return 0;
+}
+
+void AliTPCclustererKr::MakeClusters(TObjArray * maximaInSector, Int_t iSec, Int_t &clusterCounter){
+  //
+  // Make clusters
+  //
+
+  Int_t maxDig=0;
+  Int_t maxSumAdc=0;
+  Int_t maxTimeBin=0;
+  Int_t maxPad=0;
+  Int_t maxRow=0;
+  Double_t maxX=0;
+  Double_t maxY=0;
+  Double_t maxT=0;
+  Int_t entriesArr = maximaInSector->GetEntriesFast();
+  for(Int_t it1 = 0; it1 < entriesArr; ++it1 ) {
+    
+    AliPadMax *mp1=(AliPadMax *)maximaInSector->UncheckedAt(it1);
+    if (!mp1) continue;
+    AliTPCclusterKr clusterKr;
+    
+    Int_t nUsedPads=1;
+    Int_t clusterValue=0;
+    clusterValue+=(mp1)->GetSum();
+    list<Int_t> nUsedRows;
+    nUsedRows.push_back((mp1)->GetRow());
+    
+    maxDig      =(mp1)->GetAdc() ;
+    maxSumAdc   =(mp1)->GetSum() ;
+    maxTimeBin  =(mp1)->GetTime();
+    maxPad      =(mp1)->GetPad() ;
+    maxRow      =(mp1)->GetRow() ;
+    maxX        =(mp1)->GetX();
+    maxY        =(mp1)->GetY();
+    maxT        =(mp1)->GetT();
+    
+    AliSimDigits *digrowTmp;
+    if(fRawData){
+      digrowTmp = (AliSimDigits*)fDigarr->GetRow(iSec,(mp1)->GetRow());
+    }else{
+      digrowTmp = (AliSimDigits*)fDigarr->LoadRow(iSec,(mp1)->GetRow());
+    }
+    
+    digrowTmp->ExpandBuffer(); //decrunch
+    
+    for(Int_t itb=(mp1)->GetBegin(); itb<((mp1)->GetEnd())+1; itb++){
+      Int_t adcTmp = digrowTmp->GetDigitUnchecked(itb,(mp1)->GetPad());
+      AliTPCvtpr *vtpr=new AliTPCvtpr(adcTmp,itb,(mp1)->GetPad(),(mp1)->GetRow(),(mp1)->GetX(),(mp1)->GetY(),(mp1)->GetT());
+      clusterKr.AddDigitToCluster(vtpr);
+    }
+    clusterKr.SetCenter();//set centr of the cluster
+    
+    for(Int_t it2 = it1+1; it2 < entriesArr; ++it2 ) {
+      AliPadMax *mp2=(AliPadMax *)maximaInSector->UncheckedAt(it2);
+      if (!mp2) continue;
+      if (TMath::Abs(clusterKr.GetCenterX() - (mp2)->GetX())>fMaxPadRangeCm) continue;
+      if (TMath::Abs(clusterKr.GetCenterY() - (mp2)->GetY()) > fMaxRowRangeCm) continue;      
+      if (TMath::Abs(clusterKr.GetCenterT() - (mp2)->GetT()) >fMaxTimeRange) continue;
+
+      {
+       clusterValue+=(mp2)->GetSum();
+       
+       nUsedPads++;
+       nUsedRows.push_back((mp2)->GetRow());
+       
+       AliSimDigits *digrowTmp1;
+       if(fRawData){
+         digrowTmp1 = (AliSimDigits*)fDigarr->GetRow(iSec,(mp2)->GetRow());
+       }else{
+         digrowTmp1 = (AliSimDigits*)fDigarr->LoadRow(iSec,(mp2)->GetRow());
+       }
+       digrowTmp1->ExpandBuffer(); //decrunch
+       
+       for(Int_t itb=(mp2)->GetBegin(); itb<(mp2)->GetEnd()+1; itb++){
+         Int_t adcTmp = digrowTmp1->GetDigitUnchecked(itb,(mp2)->GetPad());
+         AliTPCvtpr *vtpr=new AliTPCvtpr(adcTmp,itb,(mp2)->GetPad(),(mp2)->GetRow(),(mp2)->GetX(),(mp2)->GetY(),(mp2)->GetT());
+         clusterKr.AddDigitToCluster(vtpr);
+       }
+       
+       clusterKr.SetCenter();//set center of the cluster
+       
+       //which one is bigger
+       if( (mp2)->GetAdc() > maxDig ){
+         maxDig      =(mp2)->GetAdc() ;
+         maxSumAdc   =(mp2)->GetSum() ;
+         maxTimeBin  =(mp2)->GetTime();
+         maxPad      =(mp2)->GetPad() ;
+         maxRow      =(mp2)->GetRow() ;
+         maxX        =(mp2)->GetX() ;
+         maxY        =(mp2)->GetY() ;
+         maxT        =(mp2)->GetT() ;
+       } else if ( (mp2)->GetAdc() == maxDig ){
+         if( (mp2)->GetSum() > maxSumAdc){
+           maxDig      =(mp2)->GetAdc() ;
+           maxSumAdc   =(mp2)->GetSum() ;
+           maxTimeBin  =(mp2)->GetTime();
+           maxPad      =(mp2)->GetPad() ;
+           maxRow      =(mp2)->GetRow() ;
+           maxX        =(mp2)->GetX() ;
+           maxY        =(mp2)->GetY() ;
+           maxT        =(mp2)->GetT() ;
+         }
+       }
+       delete maximaInSector->RemoveAt(it2);
+      }
+    }//inside loop
+    delete maximaInSector->RemoveAt(it1);          
+    clusterKr.SetSize();
+    //through out clusters on the edge and noise
+    //if(clusterValue/clusterKr.fCluster.size()<fValueToSize)continue;
+    if(clusterValue/(clusterKr.GetSize())<fValueToSize)continue;
+    
+    clusterKr.SetADCcluster(clusterValue);
+    clusterKr.SetNPads(nUsedPads);
+    clusterKr.SetMax(AliTPCvtpr(maxDig,maxTimeBin,maxPad,maxRow,maxX,maxY,maxT));
+    clusterKr.SetSec(iSec);
+    clusterKr.SetSize();
+    
+    nUsedRows.sort();
+    nUsedRows.unique();
+    clusterKr.SetNRows(nUsedRows.size());
+    clusterKr.SetCenter();
+    
+    clusterCounter++;
+    
+    
+    //save each cluster into file
+    if (fOutput){
+      (*fOutput)<<"Kr"<<
+       "Cl.="<<&clusterKr<<
+       "\n";
+    }
+    //end of save each cluster into file adc.root
+  }//outer loop
+}
+
+
+
+////____________________________________________________________________________
+
+
+void AliTPCclustererKr::GetXY(Int_t sec,Int_t row,Int_t pad,Double_t& xGlob,Double_t& yGlob){
+  //
+  //gives global XY coordinate of the pad
+  //
+
+  Double_t yLocal = fParam->GetPadRowRadii(sec,row);//radius of row in sector in cm
+
+  Int_t padmax = fParam->GetNPads(sec,row);//number of pads in a given row
+  Float_t padXSize;
+  if(sec<fParam->GetNInnerSector())padXSize=0.4;
+  else padXSize=0.6;
+  Double_t xLocal=(pad+0.5-padmax/2.)*padXSize;//x-value of the center of pad
+
+  Float_t sin,cos;
+  fParam->AdjustCosSin((Int_t)sec,cos,sin);//return sinus and cosinus of the sector
+
+  Double_t xGlob1 =  xLocal * cos + yLocal * sin;
+  Double_t yGlob1 = -xLocal * sin + yLocal * cos;
+
+
+  Double_t rot=0;
+  rot=TMath::Pi()/2.;
+
+  xGlob =  xGlob1 * TMath::Cos(rot) + yGlob1 * TMath::Sin(rot);
+  yGlob = -xGlob1 * TMath::Sin(rot) + yGlob1 * TMath::Cos(rot);
+
+   yGlob=-1*yGlob;
+   if(sec<18||(sec>=36&&sec<54)) xGlob =-1*xGlob;
+
+
+  return;
+}