Transition to NewIO
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 13 Jul 2003 09:26:14 +0000 (09:26 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 13 Jul 2003 09:26:14 +0000 (09:26 +0000)
748 files changed:
CONTAINERS/AliArrayBranch.cxx
CONTAINERS/AliArrayI.cxx
CONTAINERS/AliArrayS.cxx
CONTAINERS/AliArrayVT.cxx
CONTAINERS/AliClassInfo.cxx
CONTAINERS/AliClassInfo.h
CONTAINERS/AliDataType.cxx
CONTAINERS/AliDataType.h
CONTAINERS/AliDigits.cxx
CONTAINERS/AliH2F.cxx
CONTAINERS/AliH2F.h
CONTAINERS/AliMemArray.cxx
CONTAINERS/AliMemArray.h
CONTAINERS/AliObjectArray.cxx
CONTAINERS/AliSegmentArray.cxx
CONTAINERS/AliSegmentArray.h
CONTAINERS/AliSegmentID.cxx
CONTAINERS/TArrayOfArray.cxx
CONTAINERS/libCONTAINERS.pkg
CRT/AliCRT.cxx
CRT/AliCRTConstants.cxx
CRT/AliCRThit.cxx
CRT/AliCRTv0.cxx
CRT/AliCRTv1.cxx
CRT/AliGenCRT.cxx
EMCAL/AliEMCAL.cxx
EMCAL/AliEMCAL.h
EMCAL/AliEMCALClusterizer.cxx
EMCAL/AliEMCALClusterizer.h
EMCAL/AliEMCALClusterizerv1.cxx
EMCAL/AliEMCALClusterizerv1.h
EMCAL/AliEMCALDigit.cxx
EMCAL/AliEMCALDigit.h
EMCAL/AliEMCALDigitizer.cxx
EMCAL/AliEMCALDigitizer.h
EMCAL/AliEMCALFast.cxx
EMCAL/AliEMCALGeometry.cxx
EMCAL/AliEMCALGeometry.h
EMCAL/AliEMCALGetter.cxx
EMCAL/AliEMCALGetter.h
EMCAL/AliEMCALHadronCorrectionv0.cxx
EMCAL/AliEMCALJet.cxx
EMCAL/AliEMCALJetFinder.cxx
EMCAL/AliEMCALLink.cxx
EMCAL/AliEMCALLink.h
EMCAL/AliEMCALLoader.cxx [new file with mode: 0644]
EMCAL/AliEMCALLoader.h [new file with mode: 0644]
EMCAL/AliEMCALPID.cxx
EMCAL/AliEMCALPID.h
EMCAL/AliEMCALPIDv1.cxx
EMCAL/AliEMCALPIDv1.h
EMCAL/AliEMCALParton.cxx
EMCAL/AliEMCALRecParticle.cxx
EMCAL/AliEMCALRecPoint.cxx
EMCAL/AliEMCALRecPoint.h
EMCAL/AliEMCALSDigitizer.cxx
EMCAL/AliEMCALSDigitizer.h
EMCAL/AliEMCALTowerRecPoint.cxx
EMCAL/AliEMCALTrackSegment.cxx
EMCAL/AliEMCALTrackSegment.h
EMCAL/AliEMCALTrackSegmentMaker.cxx
EMCAL/AliEMCALTrackSegmentMaker.h
EMCAL/AliEMCALTrackSegmentMakerv1.cxx
EMCAL/AliEMCALTrackSegmentMakerv1.h
EMCAL/EMCALLinkDef.h
EMCAL/libEMCAL.pkg
EVGEN/AliDecayer.h
EVGEN/AliDimuCombinator.cxx
EVGEN/AliGenBeamGas.cxx
EVGEN/AliGenBox.cxx
EVGEN/AliGenCocktail.cxx
EVGEN/AliGenCocktailAfterBurner.cxx
EVGEN/AliGenCocktailAfterBurner.h
EVGEN/AliGenDoubleScan.cxx
EVGEN/AliGenExtFile.cxx
EVGEN/AliGenFLUKAsource.cxx
EVGEN/AliGenFixed.cxx
EVGEN/AliGenGSIlib.cxx
EVGEN/AliGenHIJINGpara.cxx
EVGEN/AliGenHIJINGparaBa.cxx
EVGEN/AliGenHalo.cxx
EVGEN/AliGenHaloProtvino.cxx
EVGEN/AliGenMC.cxx
EVGEN/AliGenMUONlib.cxx
EVGEN/AliGenPHOSlib.cxx
EVGEN/AliGenPMDlib.cxx
EVGEN/AliGenParam.cxx
EVGEN/AliGenReader.cxx
EVGEN/AliGenReader.h
EVGEN/AliGenReaderCwn.cxx
EVGEN/AliGenReaderEcalHijing.cxx
EVGEN/AliGenReaderEcalJets.cxx
EVGEN/AliGenReaderTreeK.cxx
EVGEN/AliGenReaderTreeK.h
EVGEN/AliGenSTRANGElib.cxx
EVGEN/AliGenScan.cxx
EVGEN/AliGenSlowNucleons.cxx
EVGEN/AliGenThetaSlice.cxx
EVGEN/AliPartonicEnergyLoss.cxx
EVGEN/AliSlowNucleonModel.cxx
EVGEN/AliSlowNucleonModelExp.cxx
EVGEN/AliStructFuncType.cxx
FASTSIM/AliFastDetector.cxx
FASTSIM/AliFastEvent.cxx
FASTSIM/AliFastGlauber.cxx
FASTSIM/AliFastMuonTrackingAcc.cxx
FASTSIM/AliFastMuonTrackingEff.cxx
FASTSIM/AliFastMuonTrackingRes.cxx
FASTSIM/AliFastMuonTriggerEff.cxx
FASTSIM/AliFastParticle.cxx
FASTSIM/AliFastResponse.cxx
FASTSIM/AliMUONFastTracking.cxx
FASTSIM/AliMUONFastTrackingEntry.cxx
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMDDigitizer.cxx
FMD/AliFMDDigitizer.h
FMD/AliFMDMerger.cxx
FMD/AliFMDMerger.h
FMD/AliFMDReconstruction.cxx
FMD/AliFMDReconstruction.h
FMD/AliFMDSDigitizer.cxx
FMD/AliFMDSDigitizer.h
FMD/AliFMDv0.cxx
FMD/AliFMDv1.cxx
FMD/FMDDigit.C
FMD/FMDReconstructor.C
HBTAN/AliHBTCorrelFctn.cxx
HBTAN/AliHBTCorrelFctn.h
HBTAN/AliHBTEvent.cxx
HBTAN/AliHBTEvent.h
HBTAN/AliHBTLLWeightFctn.cxx
HBTAN/AliHBTLLWeightFctn.h
HBTAN/AliHBTLLWeights.cxx
HBTAN/AliHBTLLWeights.h
HBTAN/AliHBTMonDistributionFctns.cxx
HBTAN/AliHBTMonDistributionFctns.h
HBTAN/AliHBTPairCut.cxx
HBTAN/AliHBTPairCut.h
HBTAN/AliHBTPositionRandomizer.cxx [new file with mode: 0644]
HBTAN/AliHBTPositionRandomizer.h [new file with mode: 0644]
HBTAN/AliHBTReader.cxx
HBTAN/AliHBTReader.h
HBTAN/AliHBTReaderITSv1.cxx
HBTAN/AliHBTReaderITSv2.cxx
HBTAN/AliHBTReaderITSv2.h
HBTAN/AliHBTReaderKineTree.cxx
HBTAN/AliHBTReaderKineTree.h
HBTAN/AliHBTReaderPPprod.cxx
HBTAN/AliHBTReaderTPC.cxx
HBTAN/AliHBTReaderTPC.h
HBTAN/HBTAnalysisLinkDef.h
HBTAN/libHBTAN.pkg
HBTAN/ltran12.F
HBTP/common_event_summary.inc
HBTP/hbt_event_processor.f
ITS/AliITS.cxx
ITS/AliITS.h
ITS/AliITSBaseGeometry.cxx
ITS/AliITSBaseGeometry.h
ITS/AliITSClusterFinder.cxx
ITS/AliITSClusterFinder.h
ITS/AliITSClusterFinderSDD.cxx
ITS/AliITSClusterFinderSPDdubna.cxx
ITS/AliITSComparisonV2.C
ITS/AliITSDetType.cxx
ITS/AliITSDigitizer.cxx
ITS/AliITSDigits2RecPoints.C
ITS/AliITSDumpVertices.C
ITS/AliITSFDigitizer.cxx
ITS/AliITSFindClustersV2.C
ITS/AliITSFindClustersV2.cxx
ITS/AliITSFindPrimaryVertex.C
ITS/AliITSFindTracksV2.C
ITS/AliITSGeoPlot.C
ITS/AliITSGeometrySDDCone.cxx
ITS/AliITSGeometrySSDCone.cxx
ITS/AliITSHits2FastRecPoints.C
ITS/AliITSHits2SDigits.C
ITS/AliITSLoader.cxx [new file with mode: 0644]
ITS/AliITSLoader.h [new file with mode: 0644]
ITS/AliITSRawCluster.cxx
ITS/AliITSRecPoint.cxx
ITS/AliITSSDigits2Digits.C
ITS/AliITSTrackerV1.cxx
ITS/AliITSVertexer.cxx
ITS/AliITSVertexer.h
ITS/AliITSVertexerIons.cxx
ITS/AliITSVertexerIons.h
ITS/AliITSVertexerPPZ.cxx
ITS/AliITSVertexerPPZ.h
ITS/AliITSVertexerTracks.cxx
ITS/AliITSVertexerTracks.h
ITS/AliITSVertexerZTest.C
ITS/AliITSclusterSSD.cxx
ITS/AliITSclustererV2.cxx
ITS/AliITSdigit.cxx
ITS/AliITSdigit.h
ITS/AliITSetfSDD.cxx
ITS/AliITSetfSDD.h
ITS/AliITSgeom.cxx
ITS/AliITSgeomMatrix.cxx
ITS/AliITSgeomSDD.cxx
ITS/AliITSgeomSPD.cxx
ITS/AliITSgeomSSD.cxx
ITS/AliITShit.cxx
ITS/AliITShitDigitizer.cxx
ITS/AliITSmodule.cxx
ITS/AliITSneuralTracker.h
ITS/AliITSpList.cxx
ITS/AliITSpList.h
ITS/AliITSpackageSSD.cxx
ITS/AliITSreconstruction.cxx
ITS/AliITSreconstruction.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSsDigitize.cxx
ITS/AliITSsDigitize.h
ITS/AliITSsegmentationSSD.cxx
ITS/AliITSsimulation.h
ITS/AliITSsimulationFastPoints.cxx
ITS/AliITSsimulationSDD.cxx
ITS/AliITSsimulationSDD.h
ITS/AliITSsimulationSPD.cxx
ITS/AliITSsimulationSPDdubna.cxx
ITS/AliITSsimulationSSD.cxx
ITS/AliITSsimulationSSD.h
ITS/AliITStestV2.C
ITS/AliITStrackerV2.cxx
ITS/AliITStrackerV2.h
ITS/AliITSv1.cxx
ITS/AliITSv11.cxx
ITS/AliITSv5.cxx
ITS/AliITSv5asymm.cxx
ITS/AliITSv5symm.cxx
ITS/AliITSvPPRasymm.cxx
ITS/AliITSvPPRasymmFMD.cxx
ITS/AliITSvPPRcoarseasymm.cxx
ITS/AliITSvPPRcoarsesymm.cxx
ITS/AliITSvPPRsymm.cxx
ITS/AliITSvSPD02.cxx
ITS/AliITSvtest.cxx
ITS/ConfigSPD02.C
ITS/ITSLinkDef.h
ITS/libITS.pkg
MICROCERN/abend.F
MICROCERN/cfill.F
MICROCERN/cltou.F
MICROCERN/fchput.c
MICROCERN/fchtak.c
MICROCERN/fint.F
MICROCERN/gamma.F
MICROCERN/gamma64.F
MICROCERN/gauss.F
MICROCERN/gauss64.F
MICROCERN/gausscod.inc
MICROCERN/gen/def128.inc
MICROCERN/gen/def64.inc
MICROCERN/gen/defc64.inc
MICROCERN/gen/imp128.inc
MICROCERN/gen/imp64.inc
MICROCERN/gen/impc64.inc
MICROCERN/geteni.c
MICROCERN/getenvf.F
MICROCERN/kerngen/cf_clos.h
MICROCERN/kerngen/cf_open.h
MICROCERN/kerngen/cf_reaw.h
MICROCERN/kerngen/cf_seek.h
MICROCERN/kerngen/cf_xaft.h
MICROCERN/kerngen/fortchar.h
MICROCERN/kerngen/q_andor.inc
MICROCERN/kerngen/q_cbyt.inc
MICROCERN/kerngen/q_isabit.inc
MICROCERN/kerngen/q_jbit.inc
MICROCERN/kerngen/q_jbytet.inc
MICROCERN/kerngen/q_sbit.inc
MICROCERN/kerngen/q_sbyt.inc
MICROCERN/kerngen/q_shift.inc
MICROCERN/kerngen/qf_f2c.h
MICROCERN/kerngen/qnatch.inc
MICROCERN/kerngen/qnatchdata.inc
MICROCERN/kerngen/wordsizc.h
MICROCERN/kerngen/wordsize.inc
MICROCERN/kerset.F
MICROCERN/mtlprt.F
MICROCERN/mtlset.F
MICROCERN/sortzv.F
MICROCERN/sungs/abend.F
MICROCERN/ufill.F
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONChamber.cxx
MUON/AliMUONChamberTrigger.cxx
MUON/AliMUONClusterFinderAZ.cxx
MUON/AliMUONClusterFinderVS.cxx
MUON/AliMUONClusterInput.cxx
MUON/AliMUONConstants.cxx
MUON/AliMUONDigit.cxx
MUON/AliMUONDigitizer.cxx
MUON/AliMUONDigitizerv1.cxx
MUON/AliMUONDisplay.cxx
MUON/AliMUONEventReconstructor.cxx
MUON/AliMUONFactory.cxx
MUON/AliMUONHit.cxx
MUON/AliMUONHitForRec.cxx
MUON/AliMUONHitMapA1.cxx
MUON/AliMUONMerger.cxx
MUON/AliMUONPadHit.cxx
MUON/AliMUONPoints.cxx
MUON/AliMUONRawCluster.cxx
MUON/AliMUONRecoDisplay.cxx
MUON/AliMUONRecoEvent.cxx
MUON/AliMUONReconstHit.cxx
MUON/AliMUONResponse.cxx
MUON/AliMUONResponseTrigger.cxx
MUON/AliMUONResponseV0.cxx
MUON/AliMUONSegment.cxx
MUON/AliMUONSegmentationSlat.cxx
MUON/AliMUONSegmentationSlat.h
MUON/AliMUONSegmentationSlatModule.cxx
MUON/AliMUONSegmentationSlatModuleN.cxx
MUON/AliMUONSegmentationSlatN.cxx
MUON/AliMUONSegmentationTrigger.cxx
MUON/AliMUONSegmentationTriggerX.cxx
MUON/AliMUONSegmentationTriggerY.cxx
MUON/AliMUONSegmentationV0.cxx
MUON/AliMUONSegmentationV01.cxx
MUON/AliMUONSegmentationV02.cxx
MUON/AliMUONSegmentationV04.cxx
MUON/AliMUONSegmentationV05.cxx
MUON/AliMUONSegmentationV1.cxx
MUON/AliMUONSt1Decoder.cxx
MUON/AliMUONSt1ElectronicElement.cxx
MUON/AliMUONSt1IniReader.cxx
MUON/AliMUONSt1ResponseParameter.cxx
MUON/AliMUONSt1ResponseRule.cxx
MUON/AliMUONSt1Segmentation.cxx
MUON/AliMUONSt1SpecialMotif.cxx
MUON/AliMUONTrack.cxx
MUON/AliMUONTrackHit.cxx
MUON/AliMUONTrackParam.cxx
MUON/AliMUONTransientDigit.cxx
MUON/AliMUONTriggerCircuit.cxx
MUON/AliMUONTriggerConstants.cxx
MUON/AliMUONTriggerDecision.cxx
MUON/AliMUONTriggerLut.cxx
MUON/AliMUONproto.cxx
MUON/AliMUONv0.cxx
MUON/AliMUONv1.cxx
MUON/AliMUONv1.h
MUON/AliMUONv2.cxx
MUON/AliMUONv3.cxx
MUON/Config_MUON_test.C [new file with mode: 0644]
MUON/MUONCheck.C [new file with mode: 0644]
MUON/MUONLinkDef.h
MUON/MUONrawclusters.C
MUON/MUONrecoNtuple.C
MUON/MUONtrigger.C
MUON/README [new file with mode: 0644]
MUON/libMUON.pkg
PHOS/AliPHOS.cxx
PHOS/AliPHOS.h
PHOS/AliPHOSAnalyze.cxx
PHOS/AliPHOSAnalyze.h
PHOS/AliPHOSCPVDigit.h
PHOS/AliPHOSCPVGeometry.cxx
PHOS/AliPHOSCalibrator.cxx
PHOS/AliPHOSCalibrator.h
PHOS/AliPHOSClusterizer.cxx
PHOS/AliPHOSClusterizer.h
PHOS/AliPHOSClusterizerv1.cxx
PHOS/AliPHOSClusterizerv1.h
PHOS/AliPHOSClusterizerv2.cxx
PHOS/AliPHOSClusterizerv2.h
PHOS/AliPHOSCpvRecPoint.cxx
PHOS/AliPHOSCpvRecPoint.h
PHOS/AliPHOSDebug.cxx
PHOS/AliPHOSDebug.h
PHOS/AliPHOSDigit.cxx
PHOS/AliPHOSDigit.h
PHOS/AliPHOSDigitizer.cxx
PHOS/AliPHOSDigitizer.h
PHOS/AliPHOSEMCAGeometry.h
PHOS/AliPHOSEmcRecPoint.cxx
PHOS/AliPHOSEvalRecPoint.cxx
PHOS/AliPHOSEvalRecPoint.h
PHOS/AliPHOSFastGlobalReconstruction.cxx
PHOS/AliPHOSGeometry.cxx
PHOS/AliPHOSGeometry.h
PHOS/AliPHOSGetter.cxx
PHOS/AliPHOSGetter.h
PHOS/AliPHOSHit.cxx
PHOS/AliPHOSHit.h
PHOS/AliPHOSIhepAnalyze.cxx
PHOS/AliPHOSIhepAnalyze.h
PHOS/AliPHOSImpact.cxx
PHOS/AliPHOSJetFinder.cxx
PHOS/AliPHOSLink.h
PHOS/AliPHOSLoader.cxx [new file with mode: 0644]
PHOS/AliPHOSLoader.h [new file with mode: 0644]
PHOS/AliPHOSPID.cxx
PHOS/AliPHOSPID.h
PHOS/AliPHOSPIDv0.cxx
PHOS/AliPHOSPIDv0.h
PHOS/AliPHOSPIDv1.cxx
PHOS/AliPHOSPIDv1.h
PHOS/AliPHOSPpsdRecPoint.cxx
PHOS/AliPHOSPpsdRecPoint.h
PHOS/AliPHOSQAAlarm.h
PHOS/AliPHOSQAChecker.cxx
PHOS/AliPHOSQAChecker.h
PHOS/AliPHOSQAFloatCheckable.cxx
PHOS/AliPHOSQAFloatCheckable.h
PHOS/AliPHOSQAIntCheckable.cxx
PHOS/AliPHOSQAIntCheckable.h
PHOS/AliPHOSQAMeanChecker.cxx
PHOS/AliPHOSQAMeanChecker.h
PHOS/AliPHOSQAObjectCheckable.cxx
PHOS/AliPHOSQAObjectCheckable.h
PHOS/AliPHOSQAVirtualCheckable.cxx
PHOS/AliPHOSQAVirtualCheckable.h
PHOS/AliPHOSRaw2Digits.cxx
PHOS/AliPHOSRaw2Digits.h
PHOS/AliPHOSRecCpvManager.cxx
PHOS/AliPHOSRecParticle.cxx
PHOS/AliPHOSRecParticle.h
PHOS/AliPHOSRecPoint.cxx
PHOS/AliPHOSRecPoint.h
PHOS/AliPHOSReconstructioner.cxx
PHOS/AliPHOSReconstructioner.h
PHOS/AliPHOSSDigitizer.cxx
PHOS/AliPHOSSDigitizer.h
PHOS/AliPHOSSupportGeometry.h
PHOS/AliPHOSTick.cxx
PHOS/AliPHOSTick.h
PHOS/AliPHOSTrackSegment.cxx
PHOS/AliPHOSTrackSegment.h
PHOS/AliPHOSTrackSegmentMaker.cxx
PHOS/AliPHOSTrackSegmentMaker.h
PHOS/AliPHOSTrackSegmentMakerv1.cxx
PHOS/AliPHOSTrackSegmentMakerv1.h
PHOS/AliPHOSv0.cxx
PHOS/AliPHOSv1.cxx
PHOS/AliPHOSv3.cxx
PHOS/AliPHOSv4.cxx
PHOS/AliPHOSv4.h
PHOS/AliPHOSvFast.cxx
PHOS/AliPHOSvFast.h
PHOS/AliPHOSvImpacts.cxx
PHOS/AliPHOSvImpacts.h
PHOS/AnaPhotons_v1.C
PHOS/ConfigTestSuite.C [new file with mode: 0644]
PHOS/ConvertPHOSToNewIO.C [new file with mode: 0644]
PHOS/PHOSLinkDef.h
PHOS/TestSuite.csh [new file with mode: 0755]
PHOS/grunTestSuite.C [new file with mode: 0644]
PHOS/libPHOS.pkg
PHOS/test.C
PHOS/testconfig.C
PHOS/testsim.C
PHOS/testsimglobal.C
PMD/AliPMD.cxx
PMD/AliPMD.h
PMD/AliPMDv0.cxx
PMD/AliPMDv1.cxx
PYTHIA6/AliDecayerPythia.cxx
PYTHIA6/AliGenPythiaEventHeader.cxx
PYTHIA6/AliGenPythiaJets.cxx
PYTHIA6/AliPythia.cxx
PYTHIA6/AliPythiaRndm.cxx
PYTHIA6/pythia6203.f
RALICE/AliCalorimeter.cxx
RALICE/AliEvent.cxx
RALICE/AliEvent.h
RICH/AliRICH.cxx
RICH/AliRICH.h
RICH/AliRICHChamber.h
RICH/AliRICHClusterFinder.cxx
RICH/AliRICHDetect.cxx
RICH/AliRICHDetectV1.cxx
RICH/AliRICHDigitizer.cxx
RICH/AliRICHDisplay.cxx
RICH/AliRICHEllipse.cxx
RICH/AliRICHMerger.cxx
RICH/AliRICHPatRec.cxx
RICH/AliRICHPoints.cxx
RICH/AliRICHRecHit3D.cxx
RICH/AliRICHRecHit3D.h
RICH/AliRICHResponseV0.cxx
RICH/AliRICHv0.cxx
RICH/AliRICHv1.cxx
RICH/AliRICHv2.cxx
RICH/AliRICHv3.cxx
START/AliSTART.cxx
START/AliSTART.h
START/AliSTARTDigitizer.cxx
START/AliSTARTdigit.cxx
START/AliSTARTv0.cxx
START/AliSTARTv1.cxx
START/AliSTARTv2.cxx
START/AliSTARTvertex.cxx
START/readDigits.C
START/readVertex.C
STEER/AliConfig.cxx
STEER/AliConfig.h
STEER/AliDataLoader.cxx [new file with mode: 0644]
STEER/AliDataLoader.h [new file with mode: 0644]
STEER/AliDebugVolume.cxx
STEER/AliDetector.cxx
STEER/AliDetector.h
STEER/AliDigitizer.cxx
STEER/AliDigitizer.h
STEER/AliDisplay.cxx
STEER/AliESD.h
STEER/AliHits2SDigits.C
STEER/AliLoader.cxx [new file with mode: 0644]
STEER/AliLoader.h [new file with mode: 0644]
STEER/AliMCQA.cxx
STEER/AliMagF.h
STEER/AliMagFCM.cxx
STEER/AliMagFMaps.cxx
STEER/AliMagFMaps.h
STEER/AliModule.cxx
STEER/AliModule.h
STEER/AliRndm.cxx
STEER/AliRndm.h
STEER/AliRun.cxx
STEER/AliRun.h
STEER/AliRunDigitizer.cxx
STEER/AliRunDigitizer.h
STEER/AliRunLoader.cxx [new file with mode: 0644]
STEER/AliRunLoader.h [new file with mode: 0644]
STEER/AliSDigits2Digits.C
STEER/AliStack.cxx
STEER/AliStack.h
STEER/AliStream.cxx
STEER/AliStream.h
STEER/AliTrackMapper.cxx
STEER/AliTrackMapper.h
STEER/AliTracker.cxx
STEER/AliTracker.h
STEER/STEERLinkDef.h
STEER/libSTEER.pkg
STRUCT/ABSOConst.h
STRUCT/ABSOSHILConst.h
STRUCT/AliABSOv0.cxx
STRUCT/AliALIFE.cxx
STRUCT/AliBODY.cxx
STRUCT/AliDIPOv1.cxx
STRUCT/AliDIPOv2.cxx
STRUCT/AliFRAMEv1.cxx
STRUCT/AliFRAMEv2.cxx
STRUCT/AliHALL.cxx
STRUCT/AliMAG.cxx
STRUCT/AliPIPEv0.cxx
STRUCT/AliPIPEv1.cxx
STRUCT/AliPIPEv3.cxx
STRUCT/AliSHILv0.cxx
THbtp/AliGenHBTprocessor.cxx
THbtp/AliGenHBTprocessor.h
THbtp/THBTprocessor.cxx
THbtp/THBTprocessor.h
TMEVSIM/AliGenMevSim.cxx
TMEVSIM/AliMevSimConfig.cxx
TMEVSIM/AliMevSimParticle.cxx
TMEVSIM/TMevSim.cxx
TMEVSIM/libTMEVSIM.pkg
TOF/AliTOF.cxx
TOF/AliTOF.h
TOF/AliTOFDigitizer.cxx
TOF/AliTOFDigitizer.h
TOF/AliTOFHitMap.cxx
TOF/AliTOFMerger.cxx
TOF/AliTOFMerger.h
TOF/AliTOFReconstructioner.cxx
TOF/AliTOFReconstructionerV2.cxx
TOF/AliTOFSDigit.cxx
TOF/AliTOFSDigitizer.cxx
TOF/AliTOFSDigitizer.h
TOF/AliTOFT0.cxx
TOF/AliTOFdigit.cxx
TOF/AliTOFv0.cxx
TOF/AliTOFv1.cxx
TOF/AliTOFv2.cxx
TOF/AliTOFv2FHoles.cxx
TOF/AliTOFv3.cxx
TOF/AliTOFv4.cxx
TOF/AliTOFv4T0.cxx
TPC/AliBarrelReconstruction.C
TPC/AliClusters.cxx
TPC/AliClustersArray.cxx
TPC/AliComplexCluster.cxx
TPC/AliDetectorParam.cxx
TPC/AliDigitsArray.cxx
TPC/AliSimDigits.cxx
TPC/AliTPC.cxx
TPC/AliTPC.h
TPC/AliTPCBuffer.cxx
TPC/AliTPCCluster.cxx [deleted file]
TPC/AliTPCCluster.h [deleted file]
TPC/AliTPCClusterFinder.cxx
TPC/AliTPCClustersArray.cxx
TPC/AliTPCClustersRow.cxx
TPC/AliTPCComparison.C
TPC/AliTPCComparison2.C
TPC/AliTPCDigitizer.cxx
TPC/AliTPCDigitsArray.cxx
TPC/AliTPCDisplayDigits3Dnew.C
TPC/AliTPCFindClusters.C
TPC/AliTPCFindTracks.C
TPC/AliTPCHits2Digits.C
TPC/AliTPCHits2SDigits.C
TPC/AliTPCLoader.cxx [new file with mode: 0644]
TPC/AliTPCLoader.h [new file with mode: 0644]
TPC/AliTPCPRF2D.cxx
TPC/AliTPCParam.cxx
TPC/AliTPCParamCR.cxx
TPC/AliTPCParamSR.cxx
TPC/AliTPCPid.cxx
TPC/AliTPCRF1D.cxx
TPC/AliTPCSDigits2Digits.C
TPC/AliTPCTrackHits.cxx
TPC/AliTPCTrackHitsV2.cxx
TPC/AliTPCcluster.cxx
TPC/AliTPCclusterer.cxx
TPC/AliTPCclusterer.h
TPC/AliTPCclustererMI.cxx
TPC/AliTPCclustererMI.h
TPC/AliTPCkineGrid.cxx
TPC/AliTPCtest.C
TPC/AliTPCtrack.cxx
TPC/AliTPCtrackPid.cxx
TPC/AliTPCtracker.cxx
TPC/AliTPCtracker.h
TPC/AliTPCtrackerMI.cxx
TPC/AliTPCtrackerParam.cxx
TPC/AliTPCtrackerParam.h
TPC/AliTPCv0.cxx
TPC/AliTPCv1.cxx
TPC/AliTPCv2.cxx
TPC/AliTPCv3.cxx
TPC/TPCLinkDef.h
TPC/TestTPCTrackHits.cxx
TPC/alles.h
TPC/libTPC.pkg
TPC/template.cxx
TPHIC/AliGenTPHIC.cxx
TRD/AliTRD.cxx
TRD/AliTRD.h
TRD/AliTRDanaDigits.C
TRD/AliTRDarrayF.cxx
TRD/AliTRDarrayI.cxx
TRD/AliTRDcluster.cxx
TRD/AliTRDclusterizer.cxx
TRD/AliTRDclusterizer.h
TRD/AliTRDclusterizerV0.cxx
TRD/AliTRDclusterizerV1.cxx
TRD/AliTRDclusterizerV1.h
TRD/AliTRDdataArray.cxx
TRD/AliTRDdataArrayF.cxx
TRD/AliTRDdataArrayI.cxx
TRD/AliTRDdigit.cxx
TRD/AliTRDdigitizer.cxx
TRD/AliTRDdigitizer.h
TRD/AliTRDdigitsManager.cxx
TRD/AliTRDdigitsManager.h
TRD/AliTRDgeometry.cxx
TRD/AliTRDgeometryDetail.cxx
TRD/AliTRDgeometryFull.cxx
TRD/AliTRDgeometryHole.cxx
TRD/AliTRDhit.cxx
TRD/AliTRDhits2sdigits.C
TRD/AliTRDmatrix.cxx
TRD/AliTRDmcTrack.cxx
TRD/AliTRDmcTrack.h
TRD/AliTRDparameter.cxx
TRD/AliTRDpid.cxx
TRD/AliTRDpid.h
TRD/AliTRDpixel.cxx
TRD/AliTRDpoints.cxx
TRD/AliTRDrawData.cxx
TRD/AliTRDrecPoint.cxx
TRD/AliTRDsdigits2digits.C
TRD/AliTRDsegmentArray.cxx
TRD/AliTRDsegmentArrayBase.cxx
TRD/AliTRDsegmentArrayBase.h
TRD/AliTRDsegmentID.cxx
TRD/AliTRDsim.cxx
TRD/AliTRDsimple.cxx
TRD/AliTRDsimpleGen.cxx
TRD/AliTRDsimpleGen.h
TRD/AliTRDsimpleMC.cxx
TRD/AliTRDsimpleMC.h
TRD/AliTRDtimeBin.cxx
TRD/AliTRDtrack.cxx
TRD/AliTRDtracker.cxx
TRD/AliTRDtracker.h
TRD/AliTRDtrackingSector.cxx
TRD/AliTRDv0.cxx
TRD/AliTRDv1.cxx
TRD/AliTRDv2.cxx
TRD/libTRD.pkg
VZERO/AliVZERO.cxx
VZERO/AliVZEROhit.cxx
VZERO/AliVZEROhit.h
VZERO/AliVZEROv0.cxx
VZERO/AliVZEROv2.cxx
ZDC/AliGenZDC.cxx
ZDC/AliZDC.cxx
ZDC/AliZDC.h
ZDC/AliZDCMerger.h
ZDC/AliZDCv1.cxx
ZDC/AliZDCv2.cxx
build/Makefile.Darwin
build/Makefile.icc
build/header.tpl
build/makeg2cso.sh [new file with mode: 0755]
build/module.dep
build/module.tpl
macros/Config.C
macros/ConfigCharmPPR.C
macros/ConfigHBT.C
macros/Config_gener.C
macros/Config_pp.C
macros/ConvertToNewIO.C [new file with mode: 0644]
macros/DrawALICE.C
macros/DrawSTART.C
macros/TestNewIO.C [new file with mode: 0644]
macros/ViewABSO.C
macros/ViewFMD.C
macros/ViewFRAME.C
macros/ViewHALL.C
macros/ViewITS.C
macros/ViewMUON.C
macros/ViewPHOS.C
macros/ViewPIPE.C
macros/ViewPMD.C
macros/ViewRICH.C
macros/ViewSHIL.C
macros/ViewSTART.C
macros/ViewTOF.C
macros/ViewTPC.C
macros/ViewTRD.C
macros/analHits.C
macros/display.C
macros/loadlibs.C
macros/plotField.C
share/alibtool

index a4461f0..d97bfd9 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.1  2000/11/01 16:01:22  kowal2
-Classes for handling the new hits structures
+/* $Id$ */
 
-*/
 #include "TROOT.h"
 #include "AliArrayBranch.h"
 #include "TFile.h"
@@ -58,7 +54,7 @@ ClassImp(AliTree)
 
 
 
-Int_t AliArraySubBranch::GetEntryExport(Int_t entry, Int_t getall, AliObjectArray *list, Int_t nentries)
+  Int_t AliArraySubBranch::GetEntryExport(Int_t entry, Int_t /*getall*/, AliObjectArray *list, Int_t nentries)
 {
 //*-*-*-*-*-*Read all leaves of entry and return total number of bytes*-*-*
 //*-* export buffers to real objects in the AliObjectArray list.
index ae37f08..9907839 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.1  2000/11/01 15:57:13  kowal2
-Moved from the TPC directory
-
-Revision 1.2  2000/04/17 09:37:33  kowal2
-removed obsolete AliTPCDigitsDisplay.C
-
-Revision 1.1.4.2  2000/04/10 11:32:37  kowal2
-
-"ROOT"-based class with some extra functionality
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////
 //   Added additional functionality  to original TArrayI              //
index 64e1e12..2aea65b 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.1  2000/11/01 15:57:13  kowal2
-Moved from the TPC directory
-
-Revision 1.2  2000/04/17 09:37:33  kowal2
-removed obsolete AliTPCDigitsDisplay.C
-
-Revision 1.1.4.2  2000/04/10 11:32:37  kowal2
-
-"ROOT"-based class with some extra functionality
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////
 //   Added additional functionality  to original TArrayS              //
index 6948ceb..9f0ba32 100644 (file)
@@ -13,9 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-*/
+/* $Id$ */
+
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  AliArrayVT                                                          //
index 37ed435..f555b9b 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.2  2000/11/10 15:54:51  kowal2
-Corrections by P.Hristov to deal with the CINT problems.
+/* $Id$ */
 
-Revision 1.1  2000/11/01 16:01:22  kowal2
-Classes for handling the new hits structures
-
-*/
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  AliClassInfo                                                             //
index c07b091..0ac558e 100644 (file)
@@ -25,13 +25,14 @@ class AliClassInfo : public TNamed {
 public:   
   AliClassInfo(){;}
   virtual ~AliClassInfo(){;}
-  virtual void CTORBuffer(void * pointer, UInt_t size=1){;}
+  virtual void CTORBuffer(void * /*pointer*/, UInt_t /*size=1*/){;}
     //  {return (*ctorbuffer)(p,size);}
-  virtual void DTORBuffer(void * pointer, UInt_t size=1){;}
+  virtual void DTORBuffer(void * /*pointer*/, UInt_t /*size=1*/){;}
     //{return (*dtorbuffer)(p,size);}
-  virtual void StreamBuffer(TBuffer& b, const void *object, UInt_t size){;}
+  virtual void StreamBuffer(TBuffer& /*b*/,
+                           const void */*object*/, UInt_t /*size*/){;}
     //{return (*streamb)(b,object,size);}
-  virtual void ObjectDump(void *p){;}
+  virtual void ObjectDump(void */*p*/){;}
   virtual const char  * GetClassName(){ return 0;}
   virtual TClass *    GetClass(){return 0;} 
   virtual TDataType * GetDataType(){return 0;}
index b5f21a5..ea5cc81 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.2  2002/02/04 14:47:22  hristov
-Corrections needed bu Root v3-02-07
+/* $Id$ */
 
-Revision 1.1  2000/11/01 16:01:22  kowal2
-Classes for handling the new hits structures
-
-*/
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  AliDataType                                                              //
index 04c0e08..7b3e25f 100644 (file)
@@ -26,7 +26,7 @@ public:
   void ObjectDump(void *p);
   TDataType * GetDataType(){return fDataType;}  
 protected:
-  AliDataType(const AliDataType & type){;}
+  AliDataType(const AliDataType & type): AliClassInfo(type) {;}
   AliDataType &operator = (const AliDataType & type){return *this;} //assignment operator
   TDataType * fDataType;  //root type information
   ClassDef(AliDataType,0)
index 6d0b56b..c1fcfa0 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-
-$Log$
-Revision 1.4  2002/01/21 17:04:12  kowal2
-check the range of digits array
-
-Revision 1.3  2001/11/24 16:08:09  kowal2
-Fatsre algorithms
-
-Revision 1.2  2000/12/20 09:36:46  kowal2
-Improvements in algorithms to make the code faster
-
-Revision 1.1  2000/11/01 15:57:13  kowal2
-Moved from the TPC directory
-
-Revision 1.4  2000/10/05 16:01:49  kowal2
-Corrected for memory leaks.
-
-Revision 1.3  2000/06/30 12:07:49  kowal2
-Updated from the TPC-PreRelease branch
-
-Revision 1.2.4.3  2000/06/26 07:39:42  kowal2
-Changes to obey the coding rules
-
-Revision 1.2.4.2  2000/06/25 08:38:41  kowal2
-Splitted from AliTPCtracking
-
-Revision 1.2.4.1  2000/06/14 16:45:13  kowal2
-Improved algorithms. Compiler warnings removed.
-
-Revision 1.2  2000/04/17 09:37:33  kowal2
-removed obsolete AliTPCDigitsDisplay.C
-
-Revision 1.1.4.2  2000/04/10 11:37:42  kowal2
-
-Digits handling in a new data structure
-
-*/
+/* $Id$ */
 
 /*MI change -- for Rule checker
           -- added copy constructor and assignmet operator 
@@ -96,7 +59,8 @@ AliDigits::AliDigits()
   Invalidate();
 }
 
-AliDigits::AliDigits(const AliDigits& digits)
+AliDigits::AliDigits(const AliDigits& digits):
+  AliSegmentID(digits)
 {
   //
   //copy constructor
index 28fa953..6e66634 100644 (file)
@@ -24,7 +24,6 @@
 
 #include "AliH2F.h"
 #include "TClonesArray.h"
-#include "AliTPC.h"
 #include "TRandom.h"
 
 
@@ -53,26 +52,33 @@ AliH2F::~AliH2F()
   //
 }
 
-AliH2F::AliH2F(const AliH2F &his) 
+AliH2F::AliH2F(const AliH2F &his) :
+  TH2F(his)
 {
   //
   
 }
 
-AliH2F & AliH2F::operator = (const AliH2F & his) 
+AliH2F & AliH2F::operator = (const AliH2F & /*his*/) 
 {
   //
   return *this;
 }
 
+/*
 TClonesArray * AliH2F::FindPeaks(Float_t threshold, Float_t noise)
 {
-
-  //
-  // not implemented
-  //
-  return 0;
+  //find peaks and write it in form of AliTPCcluster to array
+    
+  //firstly we need to create object for cluster finding
+  //and fill it with contents of histogram
+  AliTPCClusterFinder cfinder;
+  cfinder.SetThreshold(threshold);
+  cfinder.SetNoise(noise);
+  cfinder.GetHisto(this);
+  return cfinder.FindPeaks3();
 }
+*/
 
 void AliH2F::ClearSpectrum()
 {
index 9316da0..7f015bc 100644 (file)
@@ -23,7 +23,7 @@ public:
 public:
   AliH2F(const AliH2F &his);
   AliH2F & operator = (const AliH2F &his);
-  TClonesArray * FindPeaks(Float_t threshold, Float_t noise);  
+//  TClonesArray * FindPeaks(Float_t threshold, Float_t noise);  
     //find peaks and write it in form of AliTPCcluster to array
   void ClearSpectrum();
   void AddGauss(Float_t x,Float_t y,Float_t sx, Float_t sy, Float_t max);
index c17f902..a126497 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.2  2001/01/10 09:33:56  kowal2
-Clear method modified to fix the problem with reading Tree.
+/* $Id$ */
 
-Revision 1.1  2000/11/01 16:01:26  kowal2
-Classes for handling the new hits structures
-
-*/
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  AliMemArray                                                              //                      
@@ -92,7 +85,8 @@ AliMemArray::AliMemArray(Int_t objectSize, Int_t buffersize)
   fBufferSize  =buffersize;
 }
 
-AliMemArray::AliMemArray(const AliMemArray & arr) 
+AliMemArray::AliMemArray(const AliMemArray & arr):
+  TObject(arr)
 {
   //
   //copy constructor
index 628ef16..161fd35 100644 (file)
@@ -58,8 +58,8 @@ protected :
   void   Reserve2D(UInt_t n);     
   //  
 protected:      
-  virtual void     CTORBuffer(void *buffer, UInt_t size){;} //array placement constructor
-  virtual void     DTORBuffer(void *buffer, UInt_t size){;} //array placement destructor
+  virtual void     CTORBuffer(void */*buffer*/, UInt_t /*size*/){;} //array placement constructor
+  virtual void     DTORBuffer(void */*buffer*/, UInt_t /*size*/){;} //array placement destructor
   virtual void     CopyBuffer(void *src, void *dest,  UInt_t size); //array placement copy constructor
   UInt_t          fSize;             //total number of valid  objects  
   UInt_t          fCapacity;         //capacity of array 
index 8632d99..84197e3 100644 (file)
@@ -13,9 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-*/
+/* $Id$ */
+
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 //  AliObjectArray                                                           //
@@ -62,7 +61,8 @@ AliObjectArray::AliObjectArray(const char * classname, Int_t buffersize):AliMemA
   SetClass(classname);
 }
 
-AliObjectArray::AliObjectArray(const AliObjectArray &arr)
+AliObjectArray::AliObjectArray(const AliObjectArray &arr):
+  AliMemArray(arr)
 {  
   //
   //
index 0b1d3c8..24e0d1d 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.9  2002/10/14 14:55:34  hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
-
-Revision 1.7.6.1  2002/06/10 15:00:53  hristov
-Merged with v3-08-02
-
-Revision 1.8  2002/04/04 16:38:52  kowal2
-Digits and Sdigits go to separate files
-
-Revision 1.7  2001/10/21 18:22:54  hristov
-BranchOld replaced by Branch. It works correctly with Root 2.02.xx
-
-Revision 1.6  2001/08/30 09:25:24  hristov
-The operator[] is replaced by At() or AddAt() in case of TObjArray. A temporary replacement of Branch with BranchOld is introduced
-
-Revision 1.5  2001/07/27 13:03:11  hristov
-Default Branch split level set to 99
-
-Revision 1.4  2001/06/07 18:23:52  buncic
-TPC branches now correctly diverted into Digits.TPS.root file
-
-Revision 1.3  2001/02/05 14:34:54  hristov
-Avoid deleting of Root class dictionary (R.Brun, M.Ivanov)
-
-Revision 1.2  2001/01/26 20:29:00  hristov
-Major upgrade of AliRoot code
-
-Revision 1.1  2000/11/01 15:57:13  kowal2
-Moved from the TPC directory
-
-Revision 1.3  2000/06/30 12:07:49  kowal2
-Updated from the TPC-PreRelease branch
-
-Revision 1.2.4.1  2000/06/25 08:38:41  kowal2
-Splitted from AliTPCtracking
-
-Revision 1.2  2000/04/17 09:37:33  kowal2
-removed obsolete AliTPCDigitsDisplay.C
-
-Revision 1.1.4.2  2000/04/10 11:39:36  kowal2
-
-New data structure handling
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -67,8 +22,10 @@ New data structure handling
 ///////////////////////////////////////////////////////////////////////////////
 #include <Riostream.h>
 
-#include  <TROOT.h>
 #include <TTree.h>
+#include <TROOT.h>
+#include "AliRun.h"
+
 #include "TClonesArray.h"
 #include "TDirectory.h"
 #include "AliArrayI.h"
@@ -76,7 +33,6 @@ New data structure handling
 #include "TClass.h"
 #include "TFile.h"
 
-#include "AliRun.h"
 #include "AliSegmentID.h"
 #include "AliSegmentArray.h"
 #include "TObjString.h"
@@ -96,6 +52,7 @@ AliSegmentArray::AliSegmentArray()
   fTree  = 0;
   fClass = 0;
   fBranch = 0;
+  fTreeOwner = kFALSE;
 }
 
 AliSegmentArray::AliSegmentArray(Text_t *classname, Int_t n)
@@ -106,6 +63,7 @@ AliSegmentArray::AliSegmentArray(Text_t *classname, Int_t n)
   //  Create an array of objects of classname. The class must inherit from
   //  AliSegmentID .  The second argument adjust number of entries in 
   //  the array.
+  fTreeOwner = kFALSE;
   fNSegment=0;
   fSegment =0; 
   fTreeIndex = 0;
@@ -121,14 +79,15 @@ AliSegmentArray::AliSegmentArray(Text_t *classname, Int_t n)
    }
 }
 
-AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment)
+AliSegmentArray::AliSegmentArray(const AliSegmentArray &segment):
+  TNamed(segment)
 {
   //
   //copy constructor
   // to be later implemented
 }
 
-AliSegmentArray &AliSegmentArray::operator = (const AliSegmentArray & segment)
+AliSegmentArray &AliSegmentArray::operator = (const AliSegmentArray & /*segment*/)
 {
   //assignment operator
   //to be later implemented
@@ -143,7 +102,10 @@ AliSegmentArray::~AliSegmentArray()
     fSegment->Delete();
     delete fSegment;
   }
-  if (fTree) delete fTree;
+  if (fTree) 
+   if (fTreeOwner) delete fTree;
+   else fTree->Reset();
+
   if (fTreeIndex) delete fTreeIndex;
   //  if (fClass!=0) delete fClass;
 }
@@ -158,17 +120,20 @@ Bool_t AliSegmentArray::SetClass(Text_t *classname)
     fClass = 0;
   }
   if (fTree !=0) {
-    delete fTree;
+    if (fTreeOwner) delete fTree;
+    else fTree->Reset();
     fTree = 0;
     fBranch = 0;
     delete fTreeIndex;
     fTreeIndex = 0;
   } 
+  
   if (fSegment != 0) {
     fSegment->Delete();
     delete fSegment;
     fSegment = 0;
   }
+  
   if (!gROOT)
       ::Fatal("AliSegmentArray::AliSegmentArray", "ROOT system not initialized");
    
@@ -259,17 +224,33 @@ Bool_t AliSegmentArray::MakeArray(Int_t n)
   if (fSegment) return kTRUE;  
   else return kFALSE;            
 }
+void AliSegmentArray::MakeTree(TTree* tree)
+{
+             //Make tree with the name
+  AliSegmentID * psegment = NewSegment();  
+  fTree = tree;
+  //PH  fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000);
+  fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000,99);
 
+}
 
 void AliSegmentArray::MakeTree(char *file)
 {
   //  AliSegmentID  segment;
   AliSegmentID * psegment = NewSegment();  
-  if (fTree) delete fTree;
-  fTree = new TTree("Segment Tree","Tree with segments");
+  if (fTree) 
+    if (fTreeOwner) 
+     {
+       delete fTree;
+       fTree = new TTree("Segment Tree","Tree with segments");     
+     }
+    else fTree->Reset();
+
+  
   //PH  fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000);
    fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000,99);
- if (file) {
+  if (file) {
         TString outFile = gAlice->GetBaseFile();
         outFile = outFile + "/" + file;
         fBranch->SetFile(outFile.Data());
@@ -279,29 +260,12 @@ void AliSegmentArray::MakeTree(char *file)
         while ((b=(TBranch*)next())) {
            b->SetFile(outFile.Data());
         }
-           cout << "Diverting branch " << "Segment" << " to file " << outFile << endl;  
+        cout << "Diverting branch " << "Segment" << " to file " << outFile << endl;  
         wd->cd(); 
     }
   delete psegment;
 }              
 
-////////////////////////////////////////////////////////////////////////
-TTree* AliSegmentArray::MakeTree(TFile *file)
-{
-  // 
-  //  create the whole tree in the file file
-  //
-  AliSegmentID * psegment = NewSegment();  
-  if (fTree) delete fTree;
-  TDirectory *wd = gDirectory;
-  file->cd();
-  fTree = new TTree("Segment Tree","Tree with segments");
-  fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000,99);
-  wd->cd(); 
-  delete psegment;
-  return fTree;
-}              
-////////////////////////////////////////////////////////////////////////
 
 Bool_t  AliSegmentArray::MakeDictionary(Int_t size)
 {
@@ -328,15 +292,32 @@ Bool_t  AliSegmentArray::MakeDictionary(Int_t size)
   return kTRUE;
 }
 
+Bool_t AliSegmentArray::ConnectTree(TTree* tree)
+{
+  fTree =tree;
+  if (fTree == 0)    return kFALSE;
+  fBranch = fTree->GetBranch("Segment");
+  if (fBranch==0) return kFALSE;
+  MakeDictionary(TMath::Max(fNSegment,Int_t(fTree->GetEntries())));
+  MakeArray(fTreeIndex->fN);
+  return kTRUE;
+}
+
+
 Bool_t AliSegmentArray::ConnectTree(const char * treeName)
 {
   //connect tree from current directory  
   if (fTree){
-    delete fTree;
-    fTree = 0;
-    fBranch = 0;
+   if (fTreeOwner) 
+    {
+     delete fTree;
+     fTree = 0;
+    }
+   else fTree->Reset();
+   fBranch = 0;
   }
   fTree =(TTree*)gDirectory->Get(treeName);
+  
   if (fTree == 0)    return kFALSE;
   fBranch = fTree->GetBranch("Segment");
   if (fBranch==0) return kFALSE;
@@ -419,7 +400,7 @@ void AliSegmentArray::Streamer(TBuffer &R__b)
     Version_t R__v = R__b.ReadVersion(); if (R__v) { }
     TNamed::Streamer(R__b);
     R__b>>ptreeName;
-    if (fTree) delete fTree;
+    if (fTree && fTreeOwner) delete fTree;
     ConnectTree(ptreeName->String());   
   } else {
     R__b.WriteVersion(AliSegmentArray::IsA());
@@ -431,3 +412,4 @@ void AliSegmentArray::Streamer(TBuffer &R__b)
     fTree->Write();
   }
 }
+
index f3f7361..24faeed 100644 (file)
@@ -37,9 +37,12 @@ public:
   //input output functions
   TTree * GetTree(){return fTree;}      //return pointer to connected tree
   
-  virtual void MakeTree(char *file=0);            //Make tree with the name
-  virtual TTree* MakeTree(TFile *file);           //Make tree in the file file
+  virtual void MakeTree(char *file=0);              //Make tree with the name
+  virtual void MakeTree(TTree* tree);              //Make tree with the name
+
   virtual Bool_t ConnectTree(const char * treeName); //connect tree from current directory 
+  virtual Bool_t ConnectTree(TTree* tree); //connect tree from current directory 
+  
   virtual AliSegmentID * LoadSegment(Int_t index);//load segment with index to the memory
   virtual AliSegmentID * LoadEntry(Int_t index); //load segment entry from position index in tree
   virtual void StoreSegment(Int_t index);//write segmen persistent  
@@ -53,10 +56,11 @@ protected:
   AliArrayI    * fTreeIndex; //!pointers(index) table in tree
   Int_t      fNSegment; //number of alocated segments   
   TTree    * fTree;   //!tree with segment objects
-  TBranch  * fBranch; //!total branch 
+  Bool_t   fTreeOwner;// flag determing the ownership of the fTree
+  TBranch  * fBranch; //!total branch
 private: 
   TClass  *   fClass;    //!class type of included objects 
-  ClassDef(AliSegmentArray,1) 
+  ClassDef(AliSegmentArray,2) 
 };
 
 
index 40faed5..9e5a4c1 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.2  2000/04/17 09:37:33  kowal2
-removed obsolete AliTPCDigitsDisplay.C
-
-Revision 1.1.4.2  2000/04/10 11:39:36  kowal2
-
-New data structure handling
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
index 9ad4d3e..f76d2bf 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.2  2001/01/10 09:32:50  kowal2
-Changes to obey the coding rules.
+/* $Id$ */
 
-Revision 1.1  2000/11/01 16:01:26  kowal2
-Classes for handling the new hits structures
-
-*/
 #include "TArrayOfArray.h"
 #include "Riostream.h"
 
index fb71486..650f7d9 100644 (file)
@@ -10,4 +10,3 @@ HDRS= $(SRCS:.cxx=.h)
 
 DHDR:= CONTAINERSLinkDef.h
 
-EINCLUDE:= TPC
index d05855f..c1e4ffa 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.6  2002/10/14 14:55:34  hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
-
-Revision 1.4.2.2  2002/10/10 14:40:31  hristov
-Updating VirtualMC to v3-09-02
-
-Revision 1.5  2002/10/07 11:12:26  gamez
-Cleaned up version
-
-Revision 1.4  2002/07/12 12:56:18  gamez
-Material numbers, correction
-
-Revision 1.3.2.1  2002/07/12 12:31:30  gamez
-Material numbers, correction
-
-Revision 1.3  2002/07/10 15:53:10  gamez
-Molasse redefinition
-
-Revision 1.2  2002/07/09 08:45:35  hristov
-Old style include files needed on HP (aCC)
-
-Revision 1.1  2002/06/16 17:08:19  hristov
-First version of CRT
-
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -65,14 +38,14 @@ First version of CRT
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <TTree.h>
-
-#include "AliRun.h"
-#include "AliMagF.h"
+#include <TVirtualMC.h>
 
 #include "AliCRT.h"
 #include "AliCRTConstants.h"
 #include "AliCRThit.h"
-
+#include "AliLoader.h"
+#include "AliMagF.h"
+#include "AliRun.h"
  
 ClassImp(AliCRT)
 
@@ -349,7 +322,7 @@ void AliCRT::SetTreeAddress()
   sprintf(branchname,"%s",GetName());
   
   // Branch address for hit tree
-  TTree *treeH = gAlice->TreeH();
+  TTree *treeH = fLoader->TreeH();
   if (treeH && fHits) {
     branch = treeH->GetBranch(branchname);
     if (branch) branch->SetAddress(&fHits);
index 2c78588..280543c 100644 (file)
 
 /*
 $Log$
+Revision 1.3.4.1  2002/11/26 16:32:24  hristov
+Merging NewIO with v3-09-04
+
+Revision 1.3  2002/10/14 14:55:34  hristov
+Merging the VirtualMC branch to the main development branch (HEAD)
+
 Revision 1.1.4.2  2002/10/10 14:40:31  hristov
 Updating VirtualMC to v3-09-02
 
index 2b97e26..17b28f6 100644 (file)
 
 /*
 $Log$
+Revision 1.6.4.1  2002/11/26 16:32:24  hristov
+Merging NewIO with v3-09-04
+
+Revision 1.6  2002/10/14 14:55:34  hristov
+Merging the VirtualMC branch to the main development branch (HEAD)
+
 Revision 1.1.4.3  2002/10/10 14:40:31  hristov
 Updating VirtualMC to v3-09-02
 
index 1d3981e..5c45b0e 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.10  2002/10/29 17:20:37  hristov
-Corrections for subscript out of range (Alpha)
-
-Revision 1.9  2002/10/23 06:47:56  alibrary
-Introducing Riostream.h
-
-Revision 1.8  2002/10/14 14:55:34  hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
-
-Revision 1.4.2.4  2002/10/10 14:40:31  hristov
-Updating VirtualMC to v3-09-02
-
-Revision 1.7  2002/10/07 11:13:25  gamez
-Access shafts added
-
-Revision 1.6  2002/07/26 06:21:12  gamez
-CRT3 volume taken as sensitive volume
-
-Revision 1.5  2002/07/25 12:52:34  morsch
-AddHit call only if hit has been defined.
-
-Revision 1.4  2002/07/12 12:57:29  gamez
-Division of CRT1 corrected
-
-Revision 1.3.2.1  2002/07/12 12:32:50  gamez
-Division of CRT1 corrected
-
-Revision 1.3  2002/07/10 15:57:04  gamez
-CreateHall() removed, and new Molasse volumes
-
-Revision 1.2  2002/07/09 08:45:35  hristov
-Old style include files needed on HP (aCC)
-
-Revision 1.1  2002/06/16 17:08:19  hristov
-First version of CRT
-
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -86,18 +47,18 @@ First version of CRT
 
 #include <Riostream.h>
 
-#include <TGeometry.h>
 #include <TBRIK.h>
-#include <TNode.h>
+#include <TGeometry.h>
 #include <TLorentzVector.h>
+#include <TNode.h>
+#include <TVirtualMC.h>
 
-#include "AliRun.h"
-#include "AliMagF.h"
+#include "AliCRTConstants.h"
+#include "AliCRTv0.h"
 #include "AliConst.h"
+#include "AliMagF.h"
 #include "AliPDG.h"
-
-#include "AliCRTv0.h"
-#include "AliCRTConstants.h"
+#include "AliRun.h"
 
 ClassImp(AliCRTv0)
  
index fe1d896..8f05fc5 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.4  2002/11/21 19:34:52  alibrary
-Removing AliMC and AliMCProcess
-
-Revision 1.3  2002/10/23 06:47:56  alibrary
-Introducing Riostream.h
-
-Revision 1.2  2002/10/14 14:55:34  hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
-
-Revision 1.1.2.1  2002/10/10 14:40:31  hristov
-Updating VirtualMC to v3-09-02
-
-Revision 1.1  2002/10/07 11:22:53  gamez
-First version, stand alone detector
-
-
-*/
+/* $Id$ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
@@ -64,14 +46,12 @@ First version, stand alone detector
 ///////////////////////////////////////////////////////////////////////////////
 
 
-#include <Riostream.h>
 #include <TBRIK.h>
 #include <TGeometry.h>
 #include <TLorentzVector.h>
 #include <TNode.h>
 #include <TPDGCode.h>
 
-
 #include "AliCRTConstants.h"
 #include "AliCRTv1.h"
 #include "AliConst.h"
index 735b350..ecf4cba 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-Revision 1.4  2002/11/21 19:34:52  alibrary
-Removing AliMC and AliMCProcess
-
-Revision 1.3  2002/10/23 06:47:56  alibrary
-Introducing Riostream.h
-
-Revision 1.2  2002/10/14 14:55:34  hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
-
-Revision 1.1.2.1  2002/10/10 14:40:31  hristov
-Updating VirtualMC to v3-09-02
-
-Revision 1.1  2002/10/07 11:25:28  gamez
-First version, generation of cosmic muons on the surface
-
-
-*/
+/* $Id$ */
 
 /////////////////////////////////////////////////////////////////////////////
 //
@@ -54,6 +36,7 @@ First version, generation of cosmic muons on the surface
 /////////////////////////////////////////////////////////////////////////////
 
 #include <Riostream.h>
+
 #include <TMCProcess.h>
 #include <TPDGCode.h>
 
index 8546a66..89f47bd 100644 (file)
 
 // --- ROOT system ---
 class TFile;
-#include "TBranch.h" 
-#include "TClonesArray.h" 
-#include "TTree.h" 
+#include <TFolder.h> 
+#include <TROOT.h>
+#include <TTree.h>
+#include <TVirtualMC.h> 
 
 // --- Standard library ---
 #include <Rstrstream.h>
 
 // --- AliRoot header files ---
-#include "AliEMCAL.h"
-#include "AliRun.h"
 #include "AliMagF.h"
+#include "AliEMCAL.h"
 #include "AliEMCALGeometry.h"
+#include "AliEMCALLoader.h"
 //#include "AliEMCALQAChecker.h" 
+#include "AliRun.h"
 
 ClassImp(AliEMCAL)
 //____________________________________________________________________________
@@ -57,7 +59,6 @@ AliEMCAL::AliEMCAL(const char* name, const char* title): AliDetector(name,title)
 {
   //   ctor : title is used to identify the layout
   
-  fGeom = AliEMCALGeometry::GetInstance(GetTitle(),"") ; 
   //fQATask = 0;
   fTreeQA = 0;
 }
@@ -187,31 +188,57 @@ void AliEMCAL::SetTreeAddress()
   sprintf(branchname,"%s",GetName());
   
   // Branch address for hit tree
-  TTree *treeH = gAlice->TreeH();
-  if (treeH && fHits) {
+  TTree *treeH = TreeH();
+  if (treeH) {
     branch = treeH->GetBranch(branchname);
-    if (branch) branch->SetAddress(&fHits);
+    if (branch) 
+      { 
+       if (fHits == 0x0) fHits= new TClonesArray("AliEMCALHit",1000);
+       //Info("SetTreeAddress","<%s> Setting Hits Address",GetName());
+       branch->SetAddress(&fHits);
+      }
+    else
+      {
+       Warning("SetTreeAddress","<%s> Failed",GetName());
+      }
   }
 }
-
 //____________________________________________________________________________
 void AliEMCAL::WriteQA()
 {
-
+  
   // Make TreeQA in the output file. 
-
+  
   if(fTreeQA == 0)
     fTreeQA = new TTree("TreeQA", "QA Alarms") ;    
   // Create Alarms branches
-//   Int_t bufferSize = 32000 ;    
-//   Int_t splitlevel = 0 ; 
-//   TFolder * alarmsF = (TFolder*)gROOT->FindObjectAny("Folders/Run/Conditions/QA/PHOS") ; 
-//   TString branchName(alarmsF->GetName());  
-//   TBranch * alarmsBranch = fTreeQA->Branch(branchName,"TFolder", &alarmsF, bufferSize, splitlevel);
-//   TString branchTitle = branchName + " QA alarms" ; 
-//   alarmsBranch->SetTitle(branchTitle);
-//   alarmsBranch->Fill() ; 
-
-  //fTreeQA->Fill() ; 
+  Int_t bufferSize = 32000 ;    
+  Int_t splitlevel = 0 ; 
+  
+  TFolder* topfold = GetLoader()->GetTopFolder(); //get top aliroot folder; skowron
+  TString emcalqafn(AliConfig::Instance()->GetQAFolderName()+"/"); //get name of QAaut folder relative to top event; skowron
+  emcalqafn+=GetName(); //hard wired string!!! add the detector name to the pathname; skowron 
+  TFolder * alarmsF = (TFolder*)topfold->FindObjectAny(emcalqafn); //get the folder
+  
+  if (alarmsF == 0x0)
+    {
+      Error("WriteQA","Can not find folder with qa alarms");
+      return;
+    }
+  TString branchName(alarmsF->GetName());
+  TBranch * alarmsBranch = fTreeQA->Branch(branchName,"TFolder", &alarmsF, bufferSize, splitlevel);
+  TString branchTitle = branchName + " QA alarms" ; 
+  alarmsBranch->SetTitle(branchTitle);
+  alarmsBranch->Fill() ; 
+  
+  //fTreeQA
 }
 
+//____________________________________________________________________________
+AliLoader* AliEMCAL::MakeLoader(const char* topfoldername)
+{
+//different behaviour than standard (singleton getter)
+// --> to be discussed and made eventually coherent
+ fLoader = new AliEMCALLoader(GetName(),topfoldername);
+ return fLoader;
+}
index 00b8ca9..673f835 100644 (file)
@@ -60,6 +60,8 @@ class AliEMCAL : public AliDetector {
     return *this ; 
   }
  
+  virtual AliLoader* MakeLoader(const char* topfoldername);
+  
 protected:
 
   //AliEMCALQAChecker * fQATask ; //! PHOS checkers container
index 2582a70..50010de 100644 (file)
@@ -48,26 +48,20 @@ ClassImp(AliEMCALClusterizer)
   AliEMCALClusterizer::AliEMCALClusterizer():TTask("","")
 {
   // ctor
-  fSplitFile = 0 ;  
-  fToSplit  = kFALSE ;
-
+  fEventFolderName = "" ;  
 }
 
 //____________________________________________________________________________
-AliEMCALClusterizer::AliEMCALClusterizer(const char* headerFile, const char* name, const Bool_t toSplit):
-TTask(name, headerFile)
+AliEMCALClusterizer::AliEMCALClusterizer(const TString alirunFileName, const TString eventFolderName):
+  TTask("EMCAL"+AliConfig::fgkReconstructionerTaskName, alirunFileName), fEventFolderName(eventFolderName)
 {
   // ctor
-  fToSplit  = toSplit ;
-  fSplitFile = 0 ;  
-
+  
 }
 
 //____________________________________________________________________________
 AliEMCALClusterizer::~AliEMCALClusterizer()
 {
   // dtor
-  
-  fSplitFile = 0 ;
- }
+}
 
index 1babb7c..e7299a8 100644 (file)
 // --- Standard library ---
 
 // --- AliRoot header files ---
-
-//#include "AliEMCALDigit.h"
+#include "AliConfig.h"
 
 class AliEMCALClusterizer : public TTask {
 
 public:
 
   AliEMCALClusterizer() ;        // default ctor
-  AliEMCALClusterizer(const char * headerFile, const char * name, const Bool_t toSplit) ;
+  AliEMCALClusterizer(const TString alirunFileName, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;
   virtual ~AliEMCALClusterizer() ; // dtor
 
   virtual Float_t GetTowerClusteringThreshold()const {Warning("GetTowerClusteringThreshold", "Not Defined") ; return 0. ; }
@@ -59,11 +58,9 @@ public:
   virtual const char * Version() const {Warning("Version", "Not Defined") ; return 0 ; } 
 
 protected:
-  
-  TFile * fSplitFile ;             //! file in which RecPoints will eventually be stored
-  Bool_t  fToSplit ;               //! Should we write to splitted file
+  TString fEventFolderName ;  // event folder name
 
-  ClassDef(AliEMCALClusterizer,2)  // Clusterization algorithm class 
+  ClassDef(AliEMCALClusterizer,3)  // Clusterization algorithm class 
 
 } ;
 
index 2daf060..8d82108 100644 (file)
 
 
 // --- AliRoot header files ---
-
+#include "AliEMCALGetter.h"
 #include "AliEMCALClusterizerv1.h"
+#include "AliEMCALTowerRecPoint.h"
 #include "AliEMCALDigit.h"
 #include "AliEMCALDigitizer.h"
-#include "AliEMCALTowerRecPoint.h"
 #include "AliEMCAL.h"
-#include "AliEMCALGetter.h"
 #include "AliEMCALGeometry.h"
-#include "AliRun.h"
 
 ClassImp(AliEMCALClusterizerv1)
   
@@ -90,8 +88,8 @@ ClassImp(AliEMCALClusterizerv1)
 }
 
 //____________________________________________________________________________
-AliEMCALClusterizerv1::AliEMCALClusterizerv1(const char* headerFile, const char* name, const Bool_t toSplit)
-:AliEMCALClusterizer(headerFile, name, toSplit)
+AliEMCALClusterizerv1::AliEMCALClusterizerv1(const TString alirunFileName, const TString eventFolderName)
+:AliEMCALClusterizer(alirunFileName, eventFolderName)
 {
   // ctor with the indication of the file where header Tree and digits Tree are stored
   
@@ -105,16 +103,14 @@ AliEMCALClusterizerv1::AliEMCALClusterizerv1(const char* headerFile, const char*
   AliEMCALClusterizerv1::~AliEMCALClusterizerv1()
 {
   // dtor
-  fSplitFile = 0 ; 
   
 }
 
 //____________________________________________________________________________
 const TString AliEMCALClusterizerv1::BranchName() const 
 { 
-  TString branchName(GetName() ) ;
-  branchName.Remove(branchName.Index(Version())-1) ;
-  return branchName ;
+   return GetName();
+
 }
 
 //____________________________________________________________________________
@@ -124,10 +120,10 @@ Float_t  AliEMCALClusterizerv1::Calibrate(Int_t amp, Int_t where) const
   // where = 0 == PRE ; where = 1 == ECAL ; where = 2 == HCAL
   if ( where == 0 ) // calibrate as PRE section
     return -fADCpedestalPRE + amp * fADCchannelPRE ; 
-  else if (where == 1) //calibrate as EC section 
-    return -fADCpedestalEC + amp * fADCchannelEC ;
-  else if (where == 2) //calibrate as HC section
-    return -fADCpedestalHC + amp * fADCchannelHC ;
+  else if (where == 1) //calibrate as ECA section 
+    return -fADCpedestalECA + amp * fADCchannelECA ;
+  else if (where == 2) //calibrate as HCA section
+    return -fADCpedestalHCA + amp * fADCchannelHCA ;
   else 
     Fatal("Calibrate", "Something went wrong!") ;
   return -9999999. ; 
@@ -138,18 +134,14 @@ void AliEMCALClusterizerv1::Exec(Option_t * option)
 {
   // Steering method
 
-  if( strcmp(GetName(), "")== 0 ) 
-    Init() ;
-
   if(strstr(option,"tim"))
     gBenchmark->Start("EMCALClusterizer"); 
   
   if(strstr(option,"print"))
     Print("") ; 
 
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ;
-  if(gime->BranchExists("RecPoints"))
-    return ;
+  AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
+
   Int_t nevents = gime->MaxEvent() ;
   Int_t ievent ;
 
@@ -157,10 +149,9 @@ void AliEMCALClusterizerv1::Exec(Option_t * option)
 
     gime->Event(ievent,"D") ;
 
-    if(ievent == 0)
-      GetCalibrationParameters() ;
+    GetCalibrationParameters() ;
 
-    fNumberOfPREClusters = fNumberOfECClusters = fNumberOfHCClusters = 0 ;
+    fNumberOfPREClusters = fNumberOfECAClusters = fNumberOfHCAClusters = 0 ;
            
     MakeClusters() ;
 
@@ -172,18 +163,19 @@ void AliEMCALClusterizerv1::Exec(Option_t * option)
     if(strstr(option,"deb"))  
       PrintRecPoints(option) ;
 
-    //increment the total number of digits per run 
+    //increment the total number of recpoints per run 
     fRecPointsInRun += gime->PRERecPoints()->GetEntriesFast() ;  
-    fRecPointsInRun += gime->ECALRecPoints()->GetEntriesFast() ;  
-    fRecPointsInRun += gime->HCALRecPoints()->GetEntriesFast() ;  
- }
+    fRecPointsInRun += gime->ECARecPoints()->GetEntriesFast() ;  
+    fRecPointsInRun += gime->HCARecPoints()->GetEntriesFast() ;  
+  }
   
+  Unload();
+
   if(strstr(option,"tim")){
     gBenchmark->Stop("EMCALClusterizer");
     Info("Exec", "took %f seconds for Clusterizing %f seconds per event", 
         gBenchmark->GetCpuTime("EMCALClusterizer"), gBenchmark->GetCpuTime("EMCALClusterizer")/nevents ) ;
   }
-  
 }
 
 //____________________________________________________________________________
@@ -194,7 +186,7 @@ Bool_t AliEMCALClusterizerv1::FindFit(AliEMCALTowerRecPoint * emcRP, AliEMCALDig
   // The initial values for fitting procedure are set equal to the positions of local maxima.
   // Cluster will be fitted as a superposition of nPar/3 electromagnetic showers
 
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ; 
+  AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
   TClonesArray * digits = gime->Digits() ; 
   
 
@@ -281,17 +273,20 @@ Bool_t AliEMCALClusterizerv1::FindFit(AliEMCALTowerRecPoint * emcRP, AliEMCALDig
 //____________________________________________________________________________
 void AliEMCALClusterizerv1::GetCalibrationParameters() 
 {
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ;
-  const AliEMCALDigitizer * dig = gime->Digitizer(BranchName()) ;
+  AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
 
+  if ( !gime->Digitizer() ) 
+    gime->LoadDigitizer();
+  AliEMCALDigitizer * dig = gime->Digitizer(); 
+   
   fADCchannelPRE  = dig->GetPREchannel() ;
   fADCpedestalPRE = dig->GetPREpedestal() ; 
 
-  fADCchannelEC   = dig->GetECchannel() ;
-  fADCpedestalEC  = dig->GetECpedestal();
+  fADCchannelECA   = dig->GetECAchannel() ;
+  fADCpedestalECA  = dig->GetECApedestal();
 
-  fADCchannelHC   = dig->GetHCchannel() ;
-  fADCpedestalHC  = dig->GetHCpedestal();
+  fADCchannelHCA   = dig->GetHCAchannel() ;
+  fADCpedestalHCA  = dig->GetHCApedestal();
 }
 
 //____________________________________________________________________________
@@ -300,78 +295,39 @@ void AliEMCALClusterizerv1::Init()
   // Make all memory allocations which can not be done in default constructor.
   // Attach the Clusterizer task to the list of EMCAL tasks
   
-  if ( strcmp(GetTitle(), "") == 0 )
-    SetTitle("galice.root") ;
-
-  TString branchname = GetName() ;
-  branchname.Remove(branchname.Index(Version())-1) ;
+  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName.Data());
 
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance(GetTitle(), branchname.Data(), fToSplit ) ; 
-  if ( gime == 0 ) {
-    Error("Init", "Could not obtain the Getter object !" ) ; 
-    return ;
-  } 
-
-  fSplitFile = 0 ;
-  if(fToSplit){
-    // construct the name of the file as /path/EMCAL.SDigits.root
-    //First - extract full path if necessary
-    TString fileName(GetTitle()) ;
-    Ssiz_t islash = fileName.Last('/') ;
-    if(islash<fileName.Length())
-      fileName.Remove(islash+1,fileName.Length()) ;
-    else
-      fileName="" ;
-    // Next - append the file name 
-    fileName+="EMCAL.RecData." ;
-    if((strcmp(branchname.Data(),"Default")!=0)&&(strcmp(branchname.Data(),"")!=0)){
-      fileName+=branchname ;
-      fileName+="." ;
-    }
-    fileName+="root" ;
-    // Finally - check if the file already opened or open the file
-    fSplitFile = static_cast<TFile*>(gROOT->GetFile(fileName.Data()));   
-    if(!fSplitFile)
-      fSplitFile =  TFile::Open(fileName.Data(),"update") ;
-  }
+  AliEMCALGeometry * geom = gime->EMCALGeometry() ;
 
-  const AliEMCALGeometry * geom = gime->EMCALGeometry() ;
   fNTowers = geom->GetNZ() *  geom->GetNPhi() ;
   if(!gMinuit) 
     gMinuit = new TMinuit(100) ;
 
-  gime->PostClusterizer(this) ;
-  gime->PostRecPoints(branchname ) ;
+ if ( !gime->Clusterizer() ) 
+    gime->PostClusterizer(this); 
 }
 
 //____________________________________________________________________________
 void AliEMCALClusterizerv1::InitParameters()
 {
-  fNumberOfPREClusters = fNumberOfECClusters = fNumberOfHCClusters = 0 ;   
+  fNumberOfPREClusters = fNumberOfECAClusters = fNumberOfHCAClusters = 0 ;   
   fPREClusteringThreshold  = 0.0001; // must be adjusted according to the noise leve set by digitizer
-  fECClusteringThreshold   = 0.0045;  // must be adjusted according to the noise leve set by digitizer
-  fHCClusteringThreshold   = 0.001;  // must be adjusted according to the noise leve set by digitizer  
+  fECAClusteringThreshold   = 0.0045;  // must be adjusted according to the noise leve set by digitizer
+  fHCAClusteringThreshold   = 0.001;  // must be adjusted according to the noise leve set by digitizer  
   fPRELocMaxCut = 0.03 ;
-  fECLocMaxCut  = 0.03 ;
-  fHCLocMaxCut  = 0.03 ;
+  fECALocMaxCut = 0.03 ;
+  fHCALocMaxCut = 0.03 ;
   
   fPREW0    = 4.0 ;
-  fECW0     = 4.5 ;
-  fHCW0     = 4.5 ;
+  fECAW0     = 4.5 ;
+  fHCAW0     = 4.5 ;
 
   fTimeGate = 1.e-8 ; 
   
   fToUnfold = kFALSE ;
-  
-  TString clusterizerName( GetName()) ; 
-  if (clusterizerName.IsNull() ) 
-    clusterizerName = "Default" ; 
-  clusterizerName.Append(":") ; 
-  clusterizerName.Append(Version()) ; 
-  SetName(clusterizerName) ;
-  fRecPointsInRun          = 0 ; 
-
+   
+  fRecPointsInRun          = 0 ;
 }
 
 //____________________________________________________________________________
@@ -384,7 +340,7 @@ Int_t AliEMCALClusterizerv1::AreNeighbours(AliEMCALDigit * d1, AliEMCALDigit * d
   // The order of d1 and d2 is important: first (d1) should be a digit already in a cluster 
   //                                      which is compared to a digit (d2)  not yet in a cluster  
 
-   AliEMCALGeometry * geom = AliEMCALGetter::GetInstance()->EMCALGeometry() ;
+   AliEMCALGeometry * geom = AliEMCALGetter::Instance()->EMCALGeometry() ;
 
   Int_t rv = 0 ; 
 
@@ -423,6 +379,13 @@ Int_t AliEMCALClusterizerv1::AreNeighbours(AliEMCALDigit * d1, AliEMCALDigit * d
   return rv ; 
 }
 
+//____________________________________________________________________________
+void AliEMCALClusterizerv1::Unload() 
+{
+  AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
+  gime->EmcalLoader()->UnloadDigits() ; 
+  gime->EmcalLoader()->UnloadRecPoints() ; 
+}
  
 //____________________________________________________________________________
 void AliEMCALClusterizerv1::WriteRecPoints(Int_t event)
@@ -431,32 +394,15 @@ void AliEMCALClusterizerv1::WriteRecPoints(Int_t event)
   // Creates new branches with given title
   // fills and writes into TreeR.
 
-  AliEMCALGetter *gime = AliEMCALGetter::GetInstance() ; 
+  AliEMCALGetter *gime = AliEMCALGetter::Instance() ; 
 
   TObjArray * aPRERecPoints = gime->PRERecPoints() ; 
-  TObjArray * aECRecPoints = gime->ECALRecPoints() ; 
-  TObjArray * aHCRecPoints = gime->HCALRecPoints() ; 
+  TObjArray * aECARecPoints = gime->ECARecPoints() ; 
+  TObjArray * aHCARecPoints = gime->HCARecPoints() ; 
 
   TClonesArray * digits = gime->Digits() ; 
-  TTree * treeR ; 
+  TTree * treeR = gime->TreeR(); ; 
   
-  if(fToSplit){
-    if(!fSplitFile)
-      return ;
-    fSplitFile->cd() ;
-    TString name("TreeR") ;
-    name += event ; 
-    treeR = dynamic_cast<TTree*>(fSplitFile->Get(name)); 
-  }
-  else{
-    treeR = gAlice->TreeR();
-  }
-
-  if(!treeR){
-    gAlice->MakeTree("R", fSplitFile);
-    treeR = gAlice->TreeR() ;
-  }
   Int_t index ;
 
   //Evaluate position, dispersion and other RecPoint properties for PRE section
@@ -470,26 +416,26 @@ void AliEMCALClusterizerv1::WriteRecPoints(Int_t event)
   aPRERecPoints->Expand(aPRERecPoints->GetEntriesFast()) ;
   
   //Evaluate position, dispersion and other RecPoint properties for EC section
-  for(index = 0; index < aECRecPoints->GetEntries(); index++)
-    (dynamic_cast<AliEMCALTowerRecPoint *>(aECRecPoints->At(index)))->EvalAll(fECW0,digits) ;
+  for(index = 0; index < aECARecPoints->GetEntries(); index++)
+    (dynamic_cast<AliEMCALTowerRecPoint *>(aECARecPoints->At(index)))->EvalAll(fECAW0,digits) ;
   
-  aECRecPoints->Sort() ;
+  aECARecPoints->Sort() ;
 
-  for(index = 0; index < aECRecPoints->GetEntries(); index++)
-    (dynamic_cast<AliEMCALTowerRecPoint *>(aECRecPoints->At(index)))->SetIndexInList(index) ;
+  for(index = 0; index < aECARecPoints->GetEntries(); index++)
+    (dynamic_cast<AliEMCALTowerRecPoint *>(aECARecPoints->At(index)))->SetIndexInList(index) ;
 
-  aECRecPoints->Expand(aECRecPoints->GetEntriesFast()) ; 
+  aECARecPoints->Expand(aECARecPoints->GetEntriesFast()) ; 
   
-  //Evaluate position, dispersion and other RecPoint properties for HC section
-  for(index = 0; index < aHCRecPoints->GetEntries(); index++)
-    (dynamic_cast<AliEMCALTowerRecPoint *>(aHCRecPoints->At(index)))->EvalAll(fHCW0,digits) ;
+  //Evaluate position, dispersion and other RecPoint properties for HCA section
+  for(index = 0; index < aHCARecPoints->GetEntries(); index++)
+    (dynamic_cast<AliEMCALTowerRecPoint *>(aHCARecPoints->At(index)))->EvalAll(fHCAW0,digits) ;
   
-  aHCRecPoints->Sort() ;
+  aHCARecPoints->Sort() ;
 
-  for(index = 0; index < aHCRecPoints->GetEntries(); index++)
-    (dynamic_cast<AliEMCALTowerRecPoint *>(aHCRecPoints->At(index)))->SetIndexInList(index) ;
+  for(index = 0; index < aHCARecPoints->GetEntries(); index++)
+    (dynamic_cast<AliEMCALTowerRecPoint *>(aHCARecPoints->At(index)))->SetIndexInList(index) ;
 
-  aHCRecPoints->Expand(aHCRecPoints->GetEntriesFast()) ; 
+  aHCARecPoints->Expand(aHCARecPoints->GetEntriesFast()) ; 
  
   Int_t bufferSize = 32000 ;    
   Int_t splitlevel = 0 ; 
@@ -499,27 +445,19 @@ void AliEMCALClusterizerv1::WriteRecPoints(Int_t event)
   branchPRE->SetTitle(BranchName());
 
   //EC section branch
-  TBranch * branchEC = treeR->Branch("EMCALECRP","TObjArray",&aECRecPoints,bufferSize,splitlevel);
-  branchEC->SetTitle(BranchName());
+  TBranch * branchECA = treeR->Branch("EMCALECARP","TObjArray",&aECARecPoints,bufferSize,splitlevel);
+  branchECA->SetTitle(BranchName());
 
-  //HC section branch
-  TBranch * branchHC = treeR->Branch("EMCALHCRP","TObjArray",&aHCRecPoints,bufferSize,splitlevel);
-  branchHC->SetTitle(BranchName());
-    
-  //And Finally  clusterizer branch
-  AliEMCALClusterizerv1 * cl = (AliEMCALClusterizerv1*)gime->Clusterizer(BranchName()) ;
-  TBranch * clusterizerBranch = treeR->Branch("AliEMCALClusterizer","AliEMCALClusterizerv1",
-                                             &cl,bufferSize,splitlevel);
-  clusterizerBranch->SetTitle(BranchName());
+  //HCA section branch
+  TBranch * branchHCA = treeR->Branch("EMCALHCARP","TObjArray",&aHCARecPoints,bufferSize,splitlevel);
+  branchHCA->SetTitle(BranchName());
 
   branchPRE->Fill() ;
-  branchEC->Fill() ;
-  branchHC->Fill() ;
-  clusterizerBranch->Fill() ;
+  branchECA->Fill() ;
+  branchHCA->Fill() ;
 
-  treeR->AutoSave() ; //Write(0,kOverwrite) ;  
-  if(gAlice->TreeR()!=treeR)
-    treeR->Delete(); 
+  gime->WriteRecPoints("OVERWRITE");
+  gime->WriteClusterizer("OVERWRITE");
 }
 
 //____________________________________________________________________________
@@ -528,48 +466,45 @@ void AliEMCALClusterizerv1::MakeClusters()
   // Steering method to construct the clusters stored in a list of Reconstructed Points
   // A cluster is defined as a list of neighbour digits
     
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ; 
+  AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
 
   AliEMCALGeometry * geom = gime->EMCALGeometry() ; 
 
 
-  TObjArray * aPRERecPoints = gime->PRERecPoints(BranchName()) ; 
-  TObjArray * aECRecPoints  = gime->ECALRecPoints(BranchName()) ; 
-  TObjArray * aHCRecPoints  = gime->HCALRecPoints(BranchName()) ; 
+  TObjArray * aPRERecPoints = gime->PRERecPoints() ; 
+  TObjArray * aECARecPoints  = gime->ECARecPoints() ; 
+  TObjArray * aHCARecPoints  = gime->HCARecPoints() ; 
 
   aPRERecPoints->Delete() ;
-  aECRecPoints->Delete() ;
-  aHCRecPoints->Delete() ;
+  aECARecPoints->Delete() ;
+  aHCARecPoints->Delete() ;
 
   TClonesArray * digits = gime->Digits() ; 
-  if ( !digits ) {
-    Fatal("MakeClusters -> Digits with name %s not found", GetName() ) ; 
-  } 
 
   TIter next(digits) ; 
   AliEMCALDigit * digit ; 
-  Int_t ndigEC=0, ndigPRE=0, ndigHC=0 ; 
+  Int_t ndigECA=0, ndigPRE=0, ndigHCA=0 ; 
 
-  // count the number of digits in EC section
+  // count the number of digits in ECA section
   while ( (digit = dynamic_cast<AliEMCALDigit *>(next())) ) { // scan over the list of digits 
-    if (geom->IsInECAL(digit->GetId())) 
-      ndigEC++ ; 
+    if (geom->IsInECA(digit->GetId())) 
+      ndigECA++ ; 
     else if (geom->IsInPRE(digit->GetId()))
       ndigPRE++; 
-    else if (geom->IsInHCAL(digit->GetId()))
-      ndigHC++;
+    else if (geom->IsInHCA(digit->GetId()))
+      ndigHCA++;
     else {
       Error("MakeClusters", "id = %d is a wrong ID!", digit->GetId()) ; 
       abort() ;
     }
   }
 
-  // add amplitude of PRE and EC sections
-  Int_t digEC ; 
-  for (digEC = 0 ; digEC < ndigEC ; digEC++) {
-    digit = dynamic_cast<AliEMCALDigit *>(digits->At(digEC)) ;
+  // add amplitude of PRE and ECA sections
+  Int_t digECA ; 
+  for (digECA = 0 ; digECA < ndigECA ; digECA++) {
+    digit = dynamic_cast<AliEMCALDigit *>(digits->At(digECA)) ;
     Int_t digPRE ;
-    for (digPRE = ndigEC ; digPRE < ndigEC+ndigPRE ; digPRE++) {
+    for (digPRE = ndigECA ; digPRE < ndigECA+ndigPRE ; digPRE++) {
       AliEMCALDigit *  digitPRE = dynamic_cast<AliEMCALDigit *>(digits->At(digPRE)) ;
       if ( geom->AreInSameTower(digit->GetId(), digitPRE->GetId()) ){
        Float_t  amp = static_cast<Float_t>(digit->GetAmp()) + geom->GetSummationFraction() * static_cast<Float_t>(digitPRE->GetAmp()) + 0.5 ; 
@@ -587,61 +522,61 @@ void AliEMCALClusterizerv1::MakeClusters()
   // Clusterization starts  
   
   TIter nextdigit(digitsC) ; 
-  Bool_t notremovedEC = kTRUE, notremovedPRE = kTRUE ;
+  Bool_t notremovedECA = kTRUE, notremovedPRE = kTRUE ;
   
   while ( (digit = dynamic_cast<AliEMCALDigit *>(nextdigit())) ) { // scan over the list of digitsC
     AliEMCALRecPoint * clu = 0 ; 
     
-    TArrayI clusterPREdigitslist(50), clusterECdigitslist(50), clusterHCdigitslist(50);   
+    TArrayI clusterPREdigitslist(50), clusterECAdigitslist(50), clusterHCAdigitslist(50);   
  
-    Bool_t inPRE = kFALSE, inECAL = kFALSE, inHCAL = kFALSE ;
+    Bool_t inPRE = kFALSE, inECA = kFALSE, inHCA = kFALSE ;
     if( geom->IsInPRE(digit->GetId()) ) {
       inPRE = kTRUE ; 
     }
-    else if( geom->IsInECAL(digit->GetId()) ) {
-      inECAL = kTRUE ;
+    else if( geom->IsInECA(digit->GetId()) ) {
+      inECA = kTRUE ;
     }
-    else if( geom->IsInHCAL(digit->GetId()) ) {
-      inHCAL = kTRUE ;
+    else if( geom->IsInHCA(digit->GetId()) ) {
+      inHCA = kTRUE ;
     }
     
     if (gDebug == 2) { 
       if (inPRE)
        Info("MakeClusters","id = %d, ene = %f , thre = %f ", 
             digit->GetId(),Calibrate(digit->GetAmp(), 0), fPREClusteringThreshold) ;  
-      if (inECAL)
+      if (inECA)
        Info("MakeClusters","id = %d, ene = %f , thre = %f", 
-            digit->GetId(),Calibrate(digit->GetAmp(), 1), fECClusteringThreshold) ;  
-      if (inHCAL)
+            digit->GetId(),Calibrate(digit->GetAmp(), 1), fECAClusteringThreshold) ;  
+      if (inHCA)
        Info("MakeClusters","id = %d, ene = %f , thre = %f", 
-            digit->GetId(),Calibrate(digit->GetAmp(), 2), fHCClusteringThreshold ) ;  
+            digit->GetId(),Calibrate(digit->GetAmp(), 2), fHCAClusteringThreshold ) ;  
     }
     
     if ( (inPRE  && (Calibrate(digit->GetAmp(), 0) > fPREClusteringThreshold  )) || 
-        (inECAL && (Calibrate(digit->GetAmp(), 1) > fECClusteringThreshold  ))  || 
-        (inHCAL && (Calibrate(digit->GetAmp(), 2) > fHCClusteringThreshold  )) ) {
+        (inECA && (Calibrate(digit->GetAmp(), 1) > fECAClusteringThreshold  ))  || 
+        (inHCA && (Calibrate(digit->GetAmp(), 2) > fHCAClusteringThreshold  )) ) {
       
-      Int_t  iDigitInPRECluster = 0, iDigitInECCluster = 0, iDigitInHCCluster = 0; 
+      Int_t  iDigitInPRECluster = 0, iDigitInECACluster = 0, iDigitInHCACluster = 0; 
       Int_t where ; // PRE = 0, ECAl = 1, HCAL = 2
 
       // Find the seed in each of the section ECAL/PRE/HCAL
 
-      if( geom->IsInECAL(digit->GetId()) ) {   
+      if( geom->IsInECA(digit->GetId()) ) {   
        where = 1 ; // to tell we are in ECAL
        // start a new Tower RecPoint
-       if(fNumberOfECClusters >= aECRecPoints->GetSize()) 
-         aECRecPoints->Expand(2*fNumberOfECClusters+1) ;
+       if(fNumberOfECAClusters >= aECARecPoints->GetSize()) 
+         aECARecPoints->Expand(2*fNumberOfECAClusters+1) ;
        AliEMCALTowerRecPoint * rp = new  AliEMCALTowerRecPoint("") ; 
-       rp->SetECAL() ; 
-       aECRecPoints->AddAt(rp, fNumberOfECClusters) ;
-       clu = dynamic_cast<AliEMCALTowerRecPoint *>(aECRecPoints->At(fNumberOfECClusters)) ; 
-       fNumberOfECClusters++ ; 
+       rp->SetECA() ; 
+       aECARecPoints->AddAt(rp, fNumberOfECAClusters) ;
+       clu = dynamic_cast<AliEMCALTowerRecPoint *>(aECARecPoints->At(fNumberOfECAClusters)) ; 
+       fNumberOfECAClusters++ ; 
        clu->AddDigit(*digit, Calibrate(digit->GetAmp(), where)) ; 
-       clusterECdigitslist[iDigitInECCluster] = digit->GetIndexInList() ;      
-       iDigitInECCluster++ ; 
+       clusterECAdigitslist[iDigitInECACluster] = digit->GetIndexInList() ;    
+       iDigitInECACluster++ ; 
        digitsC->Remove(digit) ; 
        if (gDebug == 2 ) 
-         Info("MakeClusters","OK id = %d, ene = %f , thre = %f ", digit->GetId(),Calibrate(digit->GetAmp(), 1), fECClusteringThreshold) ;  
+         Info("MakeClusters","OK id = %d, ene = %f , thre = %f ", digit->GetId(),Calibrate(digit->GetAmp(), 1), fECAClusteringThreshold) ;  
        
       } 
       else if( geom->IsInPRE(digit->GetId()) ) { 
@@ -663,35 +598,35 @@ void AliEMCALClusterizerv1::MakeClusters()
        
        nextdigit.Reset() ;
 
-       // Here we remove remaining EC digits, which cannot make a cluster
+       // Here we remove remaining ECA digits, which cannot make a cluster
        
-       if( notremovedEC ) { 
+       if( notremovedECA ) { 
          while( ( digit = dynamic_cast<AliEMCALDigit *>(nextdigit()) ) ) {
-           if( geom->IsInECAL(digit->GetId()) )
+           if( geom->IsInECA(digit->GetId()) )
              digitsC->Remove(digit) ;
            else 
              break ; 
          }
-         notremovedEC = kFALSE ;
+         notremovedECA = kFALSE ;
        }
 
       } 
-      else if( geom->IsInHCAL(digit->GetId()) ) { 
+      else if( geom->IsInHCA(digit->GetId()) ) { 
        where = 2 ; // to tell we are in HCAL
        // start a new HCAL cluster
-       if(fNumberOfHCClusters >= aHCRecPoints->GetSize()) 
-         aHCRecPoints->Expand(2*fNumberOfHCClusters+1);
+       if(fNumberOfHCAClusters >= aHCARecPoints->GetSize()) 
+         aHCARecPoints->Expand(2*fNumberOfHCAClusters+1);
        AliEMCALTowerRecPoint * rp = new AliEMCALTowerRecPoint("") ;    
-       rp->SetHCAL() ; 
-       aHCRecPoints->AddAt(rp, fNumberOfHCClusters) ;
-       clu =  dynamic_cast<AliEMCALTowerRecPoint *>(aHCRecPoints->At(fNumberOfHCClusters))  ;  
-       fNumberOfHCClusters++ ; 
+       rp->SetHCA() ; 
+       aHCARecPoints->AddAt(rp, fNumberOfHCAClusters) ;
+       clu =  dynamic_cast<AliEMCALTowerRecPoint *>(aHCARecPoints->At(fNumberOfHCAClusters))  ;  
+       fNumberOfHCAClusters++ ; 
        clu->AddDigit(*digit, Calibrate(digit->GetAmp(), where));       
-       clusterHCdigitslist[iDigitInHCCluster] = digit->GetIndexInList()  ;     
-       iDigitInHCCluster++ ; 
+       clusterHCAdigitslist[iDigitInHCACluster] = digit->GetIndexInList()  ;   
+       iDigitInHCACluster++ ; 
        digitsC->Remove(digit) ;
        if (gDebug == 2 ) 
-         Info("MakeClusters","OK id = %d, ene = %f , thre = %f ", digit->GetId(),Calibrate(digit->GetAmp(), 2), fHCClusteringThreshold) ;  
+         Info("MakeClusters","OK id = %d, ene = %f , thre = %f ", digit->GetId(),Calibrate(digit->GetAmp(), 2), fHCAClusteringThreshold) ;  
  
        nextdigit.Reset() ;
    
@@ -715,8 +650,8 @@ void AliEMCALClusterizerv1::MakeClusters()
 
       // Do the Clustering in each of the three section ECAL/PRE/HCAL
 
-      while (index < iDigitInECCluster){ // scan over digits already in cluster 
-       digit =  (AliEMCALDigit*)digits->At(clusterECdigitslist[index])  ;      
+      while (index < iDigitInECACluster){ // scan over digits already in cluster 
+       digit =  (AliEMCALDigit*)digits->At(clusterECAdigitslist[index])  ;      
        index++ ; 
         while ( (digitN = (AliEMCALDigit *)nextdigit()) ) { // scan over the reduced list of digits 
          Int_t ineb = AreNeighbours(digit, digitN);       // call (digit,digitN) in THAT oder !!!!!
@@ -726,8 +661,8 @@ void AliEMCALClusterizerv1::MakeClusters()
            break ;
          case 1 :   // are neighbours 
            clu->AddDigit(*digitN, Calibrate( digitN->GetAmp(), 1) ) ;
-           clusterECdigitslist[iDigitInECCluster] = digitN->GetIndexInList() ; 
-           iDigitInECCluster++ ; 
+           clusterECAdigitslist[iDigitInECACluster] = digitN->GetIndexInList() ; 
+           iDigitInECACluster++ ; 
            digitsC->Remove(digitN) ;
            break ;
           case 2 :   // too far from each other
@@ -738,7 +673,7 @@ void AliEMCALClusterizerv1::MakeClusters()
        
       endofloop1: ;
        nextdigit.Reset() ; 
-      } // loop over EC cluster
+      } // loop over ECA cluster
       
       index = 0 ; 
       while (index < iDigitInPRECluster){ // scan over digits already in cluster 
@@ -767,8 +702,8 @@ void AliEMCALClusterizerv1::MakeClusters()
       } // loop over PRE cluster
     
       index = 0 ; 
-      while (index < iDigitInHCCluster){ // scan over digits already in cluster 
-       digit =  (AliEMCALDigit*)digits->At(clusterHCdigitslist[index])  ;      
+      while (index < iDigitInHCACluster){ // scan over digits already in cluster 
+       digit =  (AliEMCALDigit*)digits->At(clusterHCAdigitslist[index])  ;      
        index++ ; 
         while ( (digitN = (AliEMCALDigit *)nextdigit()) ) { // scan over the reduced list of digits 
          Int_t ineb = AreNeighbours(digit, digitN);       // call (digit,digitN) in THAT oder !!!!!
@@ -778,8 +713,8 @@ void AliEMCALClusterizerv1::MakeClusters()
            break ;
          case 1 :   // are neighbours 
            clu->AddDigit(*digitN, Calibrate( digitN->GetAmp(), 2) ) ;
-           clusterHCdigitslist[iDigitInHCCluster] = digitN->GetIndexInList() ; 
-           iDigitInHCCluster++ ; 
+           clusterHCAdigitslist[iDigitInHCACluster] = digitN->GetIndexInList() ; 
+           iDigitInHCACluster++ ; 
            digitsC->Remove(digitN) ;
            break ;
           case 2 :   // too far from each other
@@ -789,7 +724,7 @@ void AliEMCALClusterizerv1::MakeClusters()
        
       endofloop3: ;
        nextdigit.Reset() ; 
-      } // loop over HC cluster
+      } // loop over HCA cluster
 
     } // energy theshold     
   } // while digit  
@@ -864,18 +799,18 @@ void AliEMCALClusterizerv1::Print(Option_t * option)const
     message += fPRELocMaxCut ;
     message += "\n                       Pre Shower Logarothmic weight   = " ; 
     message += fPREW0 ;
-    message += "\n                       EC Clustering threshold = " ; 
-    message += fECClusteringThreshold ; 
-    message += "\n                       EC Local Maximum cut    = " ;
-    message += fECLocMaxCut ; 
-    message += "\n                       EC Logarothmic weight   = " ;
-    message += fECW0 ;
+    message += "\n                       ECA Clustering threshold = " ; 
+    message += fECAClusteringThreshold ; 
+    message += "\n                       ECA Local Maximum cut    = " ;
+    message += fECALocMaxCut ; 
+    message += "\n                       ECA Logarothmic weight   = " ;
+    message += fECAW0 ;
     message += "\n                       Pre Shower Clustering threshold = " ; 
-    message += fHCClusteringThreshold ; 
-    message += "\n                       HC Local Maximum cut    = " ;
-    message += fHCLocMaxCut ; 
-    message += "\n                       HC Logarothmic weight   = " ;
-    message += fHCW0 ;
+    message += fHCAClusteringThreshold ; 
+    message += "\n                       HCA Local Maximum cut    = " ;
+    message += fHCALocMaxCut ; 
+    message += "\n                       HCA Logarothmic weight   = " ;
+    message += fHCAW0 ;
     if(fToUnfold)
       message +="\nUnfolding on\n" ;
     else
@@ -894,19 +829,19 @@ void AliEMCALClusterizerv1::PrintRecPoints(Option_t * option)
 {
   // Prints list of RecPoints produced at the current pass of AliEMCALClusterizer
 
-  TObjArray * aPRERecPoints = AliEMCALGetter::GetInstance()->PRERecPoints() ; 
-  TObjArray * aECRecPoints = AliEMCALGetter::GetInstance()->ECALRecPoints() ; 
-  TObjArray * aHCRecPoints = AliEMCALGetter::GetInstance()->HCALRecPoints() ; 
+  TObjArray * aPRERecPoints = AliEMCALGetter::Instance()->PRERecPoints() ; 
+  TObjArray * aECARecPoints = AliEMCALGetter::Instance()->ECARecPoints() ; 
+  TObjArray * aHCARecPoints = AliEMCALGetter::Instance()->HCARecPoints() ; 
 
   Info("PrintRecPoints", "Clusterization result:") ; 
   
   printf("event # %d\n", gAlice->GetEvNumber() ) ;
-  printf("           Found %d PRE SHOWER RecPoints, %d EC Rec Points and %d HC Rec Points\n ", 
-        aPRERecPoints->GetEntriesFast(), aECRecPoints->GetEntriesFast(), aHCRecPoints->GetEntriesFast() ) ; 
+  printf("           Found %d PRE SHOWER RecPoints, %d ECA Rec Points and %d HCA Rec Points\n ", 
+        aPRERecPoints->GetEntriesFast(), aECARecPoints->GetEntriesFast(), aHCARecPoints->GetEntriesFast() ) ; 
 
   fRecPointsInRun +=  aPRERecPoints->GetEntriesFast() ; 
-  fRecPointsInRun +=  aECRecPoints->GetEntriesFast() ; 
-  fRecPointsInRun +=  aHCRecPoints->GetEntriesFast() ; 
+  fRecPointsInRun +=  aECARecPoints->GetEntriesFast() ; 
+  fRecPointsInRun +=  aHCARecPoints->GetEntriesFast() ; 
   
   if(strstr(option,"all")) {
 
@@ -942,8 +877,8 @@ void AliEMCALClusterizerv1::PrintRecPoints(Option_t * option)
     printf("Clusters in ECAL section\n") ;
     printf("Index    Ene(GeV) Multi Module     phi     r   theta    X    Y      Z   Dispersion Lambda 1   Lambda 2  # of prim  Primaries list\n") ;      
     
-    for (index = 0 ; index < aECRecPoints->GetEntries() ; index++) {
-      AliEMCALTowerRecPoint * rp = dynamic_cast<AliEMCALTowerRecPoint * >(aECRecPoints->At(index)) ; 
+    for (index = 0 ; index < aECARecPoints->GetEntries() ; index++) {
+      AliEMCALTowerRecPoint * rp = dynamic_cast<AliEMCALTowerRecPoint * >(aECARecPoints->At(index)) ; 
       TVector3  globalpos;  
       rp->GetGlobalPosition(globalpos);
       TVector3  localpos;  
@@ -966,8 +901,8 @@ void AliEMCALClusterizerv1::PrintRecPoints(Option_t * option)
     printf("Clusters in HCAL section\n") ;
     printf("Index    Ene(GeV) Multi Module     phi     r   theta    X    Y      Z   Dispersion Lambda 1   Lambda 2  # of prim  Primaries list\n") ;      
     
-    for (index = 0 ; index < aHCRecPoints->GetEntries() ; index++) {
-      AliEMCALTowerRecPoint * rp = dynamic_cast<AliEMCALTowerRecPoint * >(aHCRecPoints->At(index)) ; 
+    for (index = 0 ; index < aHCARecPoints->GetEntries() ; index++) {
+      AliEMCALTowerRecPoint * rp = dynamic_cast<AliEMCALTowerRecPoint * >(aHCARecPoints->At(index)) ; 
       TVector3  globalpos;  
       rp->GetGlobalPosition(globalpos);
       TVector3  localpos;  
index 6b3630d..29adee0 100644 (file)
@@ -35,7 +35,7 @@ class AliEMCALClusterizerv1 : public AliEMCALClusterizer {
 public:
   
   AliEMCALClusterizerv1() ;         
-  AliEMCALClusterizerv1(const char * headerFile, const char * name = "Default", const Bool_t toSplit=kFALSE);
+  AliEMCALClusterizerv1(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName);
   virtual ~AliEMCALClusterizerv1()  ;
   
   virtual Int_t   AreNeighbours(AliEMCALDigit * d1, AliEMCALDigit * d2)const ; 
@@ -44,19 +44,19 @@ public:
   virtual Float_t Calibrate(Int_t amp, Int_t where)const ;  // Tranforms Amp to energy 
 
   virtual void    GetNumberOfClustersFound(int * numb )const{ numb[0] = fNumberOfPREClusters ; 
-                                                              numb[1] = fNumberOfECClusters ; 
-                                                              numb[2] = fNumberOfHCClusters ; }
+                                                              numb[1] = fNumberOfECAClusters ; 
+                                                              numb[2] = fNumberOfHCAClusters ; }
 
   virtual Float_t GetPREClusteringThreshold()const{ return fPREClusteringThreshold;  } 
-  virtual Float_t GetECClusteringThreshold()const{ return fECClusteringThreshold;}
-  virtual Float_t GetHCClusteringThreshold()const{ return fHCClusteringThreshold;}
+  virtual Float_t GetECAClusteringThreshold()const{ return fECAClusteringThreshold;}
+  virtual Float_t GetHCAClusteringThreshold()const{ return fHCAClusteringThreshold;}
 
   virtual Float_t GetPRELocalMaxCut()const       { return fPRELocMaxCut;} 
   virtual Float_t GetPREShoLogWeight()const      { return fPREW0;}  
-  virtual Float_t GetECLocalMaxCut()const        { return fECLocMaxCut;} 
-  virtual Float_t GetECLogWeight()const          { return fECW0;}  
-  virtual Float_t GetHCLocalMaxCut()const        { return fHCLocMaxCut;} 
-  virtual Float_t GetHCLogWeight()const          { return fHCW0;}  
+  virtual Float_t GetECALocalMaxCut()const       { return fECALocMaxCut;} 
+  virtual Float_t GetECALogWeight()const         { return fECAW0;}  
+  virtual Float_t GetHCALocalMaxCut()const       { return fHCALocMaxCut;} 
+  virtual Float_t GetHCALogWeight()const         { return fHCAW0;}  
 
   virtual Float_t GetTimeGate() const            { return fTimeGate ; }
   virtual const char *  GetRecPointsBranch() const{ return GetName() ;}
@@ -66,21 +66,22 @@ public:
 
   virtual void Print(Option_t * option)const ;
 
-  virtual void SetECClusteringThreshold(Float_t cluth)  { fECClusteringThreshold = cluth ; }
-  virtual void SetECLocalMaxCut(Float_t cut)            { fECLocMaxCut = cut ; }
-  virtual void SetECLogWeight(Float_t w)                { fECW0 = w ; }
-  virtual void SetHCClusteringThreshold(Float_t cluth)  { fHCClusteringThreshold = cluth ; }
-  virtual void SetHCLocalMaxCut(Float_t cut)            { fHCLocMaxCut = cut ; }
-  virtual void SetHCLogWeight(Float_t w)                { fHCW0 = w ; }
-  virtual void SetTimeGate(Float_t gate)                { fTimeGate = gate ;}
-  virtual void SetPREClusteringThreshold(Float_t cluth) { fPREClusteringThreshold = cluth ; }
-  virtual void SetPRELocalMaxCut(Float_t cut)           { fPRELocMaxCut = cut ; }
-  virtual void SetPRELogWeight(Float_t w)               { fPREW0 = w ; }
-  virtual void SetUnfolding(Bool_t toUnfold = kTRUE )      {fToUnfold = toUnfold ;}  
+  virtual void SetECAClusteringThreshold(Float_t cluth)  { fECAClusteringThreshold = cluth ; }
+  virtual void SetECALocalMaxCut(Float_t cut)            { fECALocMaxCut = cut ; }
+  virtual void SetECALogWeight(Float_t w)                { fECAW0 = w ; }
+  virtual void SetHCAClusteringThreshold(Float_t cluth)  { fHCAClusteringThreshold = cluth ; }
+  virtual void SetHCALocalMaxCut(Float_t cut)            { fHCALocMaxCut = cut ; }
+  virtual void SetHCALogWeight(Float_t w)                { fHCAW0 = w ; }
+  virtual void SetTimeGate(Float_t gate)                 { fTimeGate = gate ;}
+  virtual void SetPREClusteringThreshold(Float_t cluth)  { fPREClusteringThreshold = cluth ; }
+  virtual void SetPRELocalMaxCut(Float_t cut)            { fPRELocMaxCut = cut ; }
+  virtual void SetPRELogWeight(Float_t w)                { fPREW0 = w ; }
+  virtual void SetUnfolding(Bool_t toUnfold = kTRUE )    {fToUnfold = toUnfold ;}  
   static Double_t ShowerShape(Double_t r) ; // Shape of EM shower used in unfolding; 
                                             //class member function (not object member function)
   static void UnfoldingChiSquare(Int_t & nPar, Double_t * Grad, Double_t & fret, Double_t * x, Int_t iflag)  ;
                                             // Chi^2 of the fit. Should be static to be passes to MINUIT
+  void Unload() ; 
   virtual const char * Version() const { return "clu-v1" ; }  
 
 protected:
@@ -112,28 +113,28 @@ private:
   Bool_t  fToUnfold ;                // To perform unfolding 
 
   Int_t   fNumberOfPREClusters ;     // number of clusters found in PRE section 
-  Int_t   fNumberOfECClusters ;      // number of clusters found in EC section
-  Int_t   fNumberOfHCClusters ;      // number of clusters found in HC section
+  Int_t   fNumberOfECAClusters ;     // number of clusters found in EC section
+  Int_t   fNumberOfHCAClusters ;     // number of clusters found in HC section
   
   //Calibration parameters... to be replaced by database 
   Float_t fADCchannelPRE ;          // width of one ADC channel for PRE section (GeV)
   Float_t fADCpedestalPRE ;         // pedestal of ADC for PRE section (GeV)
-  Float_t fADCchannelEC ;           // width of one ADC channel for EC section (GeV)
-  Float_t fADCpedestalEC ;          // pedestal of ADC for EC section (GeV) 
-  Float_t fADCchannelHC ;           // width of one ADC channel for HC section (GeV)
-  Float_t fADCpedestalHC ;          // pedestal of ADC for HC section (GeV) 
+  Float_t fADCchannelECA ;          // width of one ADC channel for EC section (GeV)
+  Float_t fADCpedestalECA ;         // pedestal of ADC for EC section (GeV) 
+  Float_t fADCchannelHCA ;          // width of one ADC channel for HC section (GeV)
+  Float_t fADCpedestalHCA ;         // pedestal of ADC for HC section (GeV) 
  
-  Float_t fECClusteringThreshold ;  // minimum energy to include a EC digit in a cluster
-  Float_t fHCClusteringThreshold ;  // minimum energy to include a HC digit in a cluster
-  Float_t fPREClusteringThreshold ; // minimum energy to include a PRE digit in a cluster
-  Float_t fECLocMaxCut ;            // minimum energy difference to distinguish local maxima in a cluster
-  Float_t fECW0 ;                   // logarithmic weight for the cluster center of gravity calculation
-  Float_t fHCLocMaxCut ;            // minimum energy difference to distinguish local maxima in a cluster
-  Float_t fHCW0 ;                   // logarithmic weight for the cluster center of gravity calculation
-  Float_t fPRELocMaxCut ;           //  minimum energy difference to distinguish local maxima in a CPV cluster
-  Float_t fPREW0 ;                  // logarithmic weight for the CPV cluster center of gravity calculation
-  Int_t fRecPointsInRun ;           //! Total number of recpoints in one run
-  Float_t fTimeGate ;               // Maximum time difference between the digits in ont EMC cluster
+  Float_t fECAClusteringThreshold ;  // minimum energy to include a EC digit in a cluster
+  Float_t fHCAClusteringThreshold ;  // minimum energy to include a HC digit in a cluster
+  Float_t fPREClusteringThreshold ;  // minimum energy to include a PRE digit in a cluster
+  Float_t fECALocMaxCut ;            // minimum energy difference to distinguish local maxima in a cluster
+  Float_t fECAW0 ;                   // logarithmic weight for the cluster center of gravity calculation
+  Float_t fHCALocMaxCut ;            // minimum energy difference to distinguish local maxima in a cluster
+  Float_t fHCAW0 ;                   // logarithmic weight for the cluster center of gravity calculation
+  Float_t fPRELocMaxCut ;            //  minimum energy difference to distinguish local maxima in a CPV cluster
+  Float_t fPREW0 ;                   // logarithmic weight for the CPV cluster center of gravity calculation
+  Int_t fRecPointsInRun ;            //! Total number of recpoints in one run
+  Float_t fTimeGate ;                // Maximum time difference between the digits in ont EMC cluster
     
   ClassDef(AliEMCALClusterizerv1,2)   // Clusterizer implementation version 1
 
index 9aeac80..d61b9fb 100644 (file)
@@ -46,12 +46,11 @@ ClassImp(AliEMCALDigit)
 {
   // default ctor 
 
-  fIndexInList = 0 ; 
+  fIndexInList = -1 ; 
   fNprimary    = 0 ;  
-  fNMaxPrimary = 0 ; 
-  fNiparent     = 0 ;
-
-  fNMaxiparent = 0; 
+  fNMaxPrimary = 5 ; 
+  fNiparent    = 0 ;
+  fNMaxiparent = 5; 
   fPrimary = 0 ;
   fIparent = 0 ;
   fMaxIter = 0;
@@ -149,21 +148,21 @@ Int_t AliEMCALDigit::Compare(const TObject * obj) const
 }
 
 //____________________________________________________________________________
-const Float_t AliEMCALDigit::GetEta() const
+Float_t AliEMCALDigit::GetEta() const
 {
   Float_t eta=-10., phi=-10.;
   Int_t id = GetId();
-  const AliEMCALGeometry *g = AliEMCALGetter::GetInstance()->EMCALGeometry();
+  const AliEMCALGeometry *g = AliEMCALGetter::Instance()->EMCALGeometry();
   g->EtaPhiFromIndex(id,eta,phi);
   return eta ;
 }
 
 //____________________________________________________________________________
-const Float_t AliEMCALDigit::GetPhi() const
+Float_t AliEMCALDigit::GetPhi() const
 {
   Float_t eta=-10., phi=-10.;
   Int_t id = GetId();
-  const AliEMCALGeometry *g = AliEMCALGetter::GetInstance()->EMCALGeometry();
+  const AliEMCALGeometry *g = AliEMCALGetter::Instance()->EMCALGeometry();
   g->EtaPhiFromIndex(id,eta,phi);
   return phi ;
 }
index 6a1aab2..b05c7b7 100644 (file)
@@ -40,26 +40,21 @@ class AliEMCALDigit : public AliDigitNew {
   AliEMCALDigit& operator*(Float_t factor) ; 
  
   Int_t   Compare(const TObject * obj) const ;  
-  const Float_t GetEta() const ; 
-  Int_t   GetNprimary() const { 
-    // returns the number of primaries
-    return fNprimary ; }
+  Float_t GetEta() const ; 
+  Int_t   GetNprimary() const { return fNprimary ; }
   Int_t   GetPrimary(Int_t index) const ; 
   Int_t   GetNiparent() const {return fNiparent;}
   Int_t   GetIparent(Int_t index) const ;
-  const Float_t GetPhi() const;
+  Float_t GetPhi() const;
   Float_t GetTime(void) const {return fTime ;}
-  Bool_t  IsSortable() const { 
-    // says that AliEMCALDigits are sortable (needed for Sort method
-    return kTRUE ; }
-  void    SetAmp(Int_t amp) { 
-    // sets the amplitude data member 
-    fAmp= amp ; } 
-  void SetId(Int_t id) {fId = id ;}
-  void SetTime(Float_t time) {fTime = time ;}
-  void ShiftPrimary(Int_t shift); // shift to semarate different TreeK in merging
+  Bool_t  IsSortable() const { return kTRUE ; }
+  void    SetAmp(Int_t amp) { fAmp= amp ; } 
+  void    SetId(Int_t id) {fId = id ;}
+  void    SetTime(Float_t time) {fTime = time ;}
+  void    ShiftPrimary(Int_t shift); // shift to semarate different TreeK in merging
  
  private: 
+
   Int_t fNprimary ;     // Number of primaries
   Int_t fNMaxPrimary ;  // Max Number of primaries
   Int_t *fPrimary ;     //[fNMaxPrimary]  Array of primaries       
index 5f1c50d..804d475 100644 (file)
@@ -86,54 +86,80 @@ ClassImp(AliEMCALDigitizer)
 
 
 //____________________________________________________________________________ 
-  AliEMCALDigitizer::AliEMCALDigitizer()
+  AliEMCALDigitizer::AliEMCALDigitizer():AliDigitizer("",""),
+                                      fInput(0),
+                                      fInputFileNames(0x0),
+                                      fEventNames(0x0)
 {
   // ctor
-  //InitParameters() ; 
+  InitParameters() ; 
   fDefaultInit = kTRUE ; 
   fManager = 0 ;                     // We work in the standalong mode
+  fEventFolderName = "" ; 
 }
 
 //____________________________________________________________________________ 
-AliEMCALDigitizer::AliEMCALDigitizer(const char *headerFile, const char *name, const Bool_t toSplit)
+AliEMCALDigitizer::AliEMCALDigitizer(const TString alirunFileName, const TString eventFolderName):
+  AliDigitizer("EMCAL"+AliConfig::fgkDigitizerTaskName, alirunFileName),
+  fInputFileNames(0), fEventNames(0), fEventFolderName(eventFolderName)
 {
   // ctor
 
-  SetTitle(headerFile) ;
-  SetName(name) ;
-  fManager = 0 ;                     // We work in the standalong mode
-  fSplitFile= 0 ; 
-  fToSplit = toSplit ;
-  Init() ;
   InitParameters() ; 
+  Init() ;
   fDefaultInit = kFALSE ; 
+  fManager = 0 ;                     // We work in the standalong mode
 }
 
 //____________________________________________________________________________ 
-AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * ard):AliDigitizer(ard)
+AliEMCALDigitizer::AliEMCALDigitizer(const AliEMCALDigitizer & d)
+{
+  // copyy ctor 
+
+  SetName(d.GetName()) ; 
+  SetTitle(d.GetTitle()) ; 
+  fDigitThreshold = d.fDigitThreshold ; 
+  fMeanPhotonElectron = d.fMeanPhotonElectron ; 
+  fPedestal           = d.fPedestal ; 
+  fSlope              = d.fSlope ; 
+  fPinNoise           = d.fPinNoise ; 
+  fTimeResolution     = d.fTimeResolution ; 
+  fTimeThreshold      = d.fTimeThreshold ; 
+  fTimeSignalLength   = d.fTimeSignalLength ; 
+  fADCchannelEC       = d.fADCchannelEC ; 
+  fADCpedestalEC      = d.fADCpedestalEC ; 
+  fNADCEC             = d.fNADCEC ;
+  fADCchannelHC       = d.fADCchannelHC ; 
+  fADCpedestalHC      = d.fADCpedestalHC ; 
+  fNADCHC             = d.fNADCHC ;
+  fADCchannelPRE      = d.fADCchannelPRE ; 
+  fADCpedestalPRE     = d.fADCpedestalPRE ; 
+  fNADCPRE            = d.fNADCPRE ;
+  fEventFolderName    = d.fEventFolderName;
+ }
+
+//____________________________________________________________________________ 
+AliEMCALDigitizer::AliEMCALDigitizer(AliRunDigitizer * rd):
+ AliDigitizer(rd,"EMCAL"+AliConfig::fgkDigitizerTaskName),
+ fEventFolderName(0)
 {
   // ctor
-  SetTitle(ard->GetInputFileName(0,0)) ;
+  fManager = rd ; 
+  SetName(fManager->GetInputFolderName(0)) ;
+  // take title as name of stream 0
+  SetTitle(dynamic_cast<AliStream*>(fManager->GetInputStream(0))->GetFileName(0));
   InitParameters() ; 
+  Init() ; 
   fDefaultInit = kFALSE ; 
-  fSplitFile   = 0 ; 
-  if (ard->GetOutputFile()) {
-    SetName(ard->GetOutputFile().Data());
-    fToSplit = kTRUE ;
-  } else {
-    SetName("Default") ;
-    fToSplit = kFALSE ;
-  }
 }
 
 //____________________________________________________________________________ 
   AliEMCALDigitizer::~AliEMCALDigitizer()
 {
   // dtor
+  delete [] fInputFileNames ; 
+  delete [] fEventNames ; 
 
-    fSplitFile = 0 ; 
 }
 
 //____________________________________________________________________________
@@ -147,9 +173,8 @@ void AliEMCALDigitizer::Digitize(const Int_t event)
   // helps to avoid scanning over the list of digits to add 
   // contribution of any new SDigit.
 
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ; 
-  TClonesArray * digits = gime->Digits(GetName()) ; 
-  
+  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
+  TClonesArray * digits = gime->Digits() ; 
   digits->Clear() ;
 
   const AliEMCALGeometry *geom = gime->EMCALGeometry() ; 
@@ -159,47 +184,44 @@ void AliEMCALDigitizer::Digitize(const Int_t event)
     nEMC = 3*geom->GetNPhi()*geom->GetNZ(); //max number of digits possible (Preshower, ECAL, HCAL)
   else 
     nEMC = 2*geom->GetNPhi()*geom->GetNZ(); //max number of digits possible (Preshower, ECAL)
- Int_t absID ;
-  TString name      =  geom->GetName() ;
+  
+  Int_t absID ;
 
- // get first the sdigitizer from the tasks list (must have same name as the digitizer)
-  const AliEMCALSDigitizer * sDigitizer = gime->SDigitizer(GetName()); 
-  if ( !sDigitizer) {
-    Fatal("Digitize", "SDigitizer with name %s not found", GetName() ); 
-  }
+  digits->Expand(nEMC) ;
 
-// loop through the sdigits posted to the White Board and add them to the noise
-  TCollection * folderslist = gime->SDigitsFolder()->GetListOfFolders() ; 
-  TIter next(folderslist) ; 
-  TFolder * folder = 0 ; 
-  TClonesArray * sdigits = 0 ;
-  Int_t input = 0 ;
-  TObjArray * sdigArray = new TObjArray(2) ;
-  while ( (folder = (TFolder*)next()) ) {
-    if ( (sdigits = (TClonesArray*)folder->FindObject(GetName()) ) ) {
-      TString fileName(folder->GetName()) ;
-      fileName.ReplaceAll("_","/") ;
-      if (gDebug)
-       Info("Digitize", "Adding SDigits %s from %s", GetName(), fileName.Data()) ; 
-      sdigArray->AddAt(sdigits, input) ;
-      input++ ;
-    }
+  // get first the sdigitizer from the tasks list (must have same name as the digitizer)
+  if ( !gime->SDigitizer() ) 
+    gime->LoadSDigitizer();
+  AliEMCALSDigitizer * sDigitizer = gime->SDigitizer(); 
+  
+  if ( !sDigitizer )
+    Fatal("Digitize", "SDigitizer with name %s %s not found", fEventFolderName.Data(), GetTitle() ) ; 
+
+  //take all the inputs to add together and load the SDigits
+  TObjArray * sdigArray = new TObjArray(fInput) ;
+  sdigArray->AddAt(gime->SDigits(), 0) ;
+  Int_t i ;
+  for(i = 1 ; i < fInput ; i++){
+    TString tempo(fEventNames[i]) ; 
+    tempo += i ;
+    AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[i], tempo) ; 
+    gime->Event(event,"S");
+    sdigArray->AddAt(gime->SDigits(), i) ;
   }
-
+  
   //Find the first tower with signal
   Int_t nextSig = nEMC + 1 ; 
-  Int_t i;
-  for(i=0; i<input; i++){
-    sdigits = (TClonesArray *)sdigArray->At(i) ;
+  TClonesArray * sdigits ;  
+  for(i = 0 ; i < fInput ; i++){
+    sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
     if ( !sdigits->GetEntriesFast() )
       continue ; 
-    Int_t curNext = ((AliEMCALDigit *)sdigits->At(0))->GetId() ;
+    Int_t curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(0))->GetId() ;
      if(curNext < nextSig) 
        nextSig = curNext ;
   }
 
-  TArrayI index(input) ;
+  TArrayI index(fInput) ;
   index.Reset() ;  //Set all indexes to zero
 
   AliEMCALDigit * digit ;
@@ -209,28 +231,27 @@ void AliEMCALDigitizer::Digitize(const Int_t event)
 
   //Put Noise contribution
   for(absID = 1; absID <= nEMC; absID++){
-    Float_t amp = 0 ; 
-    //    Float_t noise = TMath::Abs(gRandom->Gaus(0., fPinNoise)); 
-    //new((*digits)[absID-1]) AliEMCALDigit( -1, -1, absID, sDigitizer->Digitize(noise), TimeOfNoise() ) ;
+    Float_t amp = 0 ;
     // amplitude set to zero, noise will be added later
     new((*digits)[absID-1]) AliEMCALDigit( -1, -1, absID, 0, TimeOfNoise() ) ;
     //look if we have to add signal?
-    digit = (AliEMCALDigit *) digits->At(absID-1) ;
+    digit = dynamic_cast<AliEMCALDigit *>(digits->At(absID-1)) ;
+    
     if(absID==nextSig){
       //Add SDigits from all inputs    
       ticks->Clear() ;
       Int_t contrib = 0 ;
       Float_t a = digit->GetAmp() ;
       Float_t b = TMath::Abs( a /fTimeSignalLength) ;
-      //Mark the beginnign of the signal
+      //Mark the beginning of the signal
       new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime(),0, b);  
       //Mark the end of the ignal     
       new((*ticks)[contrib++]) AliEMCALTick(digit->GetTime()+fTimeSignalLength, -a, -b);
       
- // loop over input
-      for(i = 0; i< input ; i++){  //loop over (possible) merge sources
-       if(((TClonesArray *)sdigArray->At(i))->GetEntriesFast() > index[i] )
-         curSDigit = (AliEMCALDigit*)((TClonesArray *)sdigArray->At(i))->At(index[i]) ;        
+      // loop over input
+      for(i = 0; i< fInput ; i++){  //loop over (possible) merge sources
+       if(dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
+         curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;      
        else
          curSDigit = 0 ;
        //May be several digits will contribute from the same input
@@ -251,45 +272,39 @@ void AliEMCALDigitizer::Digitize(const Int_t event)
          *digit = *digit + *curSDigit ;  //add energies
 
          index[i]++ ;
-         if(((TClonesArray *)sdigArray->At(i))->GetEntriesFast() > index[i] )
-           curSDigit = (AliEMCALDigit*)((TClonesArray *)sdigArray->At(i))->At(index[i]) ;      
+         if( dynamic_cast<TClonesArray *>(sdigArray->At(i))->GetEntriesFast() > index[i] )
+           curSDigit = dynamic_cast<AliEMCALDigit*>(dynamic_cast<TClonesArray *>(sdigArray->At(i))->At(index[i])) ;            
          else
            curSDigit = 0 ;
        }
       }
       // add fluctuations for photo-electron creation
       amp = sDigitizer->Calibrate(digit->GetAmp()) ; // GeV
-      if (gDebug==1) 
-       Info("Digitize", "id = %d BEFORE amp = %f\n", digit->GetId(),amp) ; 
       amp *= static_cast<Float_t>(gRandom->Poisson(fMeanPhotonElectron)) / static_cast<Float_t>(fMeanPhotonElectron) ;
-      if (gDebug==1) 
-       Info("Digitize", "After fluctuation amp = %f\n", amp) ; 
+  
       //calculate and set time
       Float_t time = FrontEdgeTime(ticks) ;
       digit->SetTime(time) ;
 
       //Find next signal module
       nextSig = nEMC + 1 ;
-      for(i=0; i<input; i++){
-       sdigits = ((TClonesArray *)sdigArray->At(i)) ;
+      for(i = 0 ; i < fInput ; i++){
+       sdigits = dynamic_cast<TClonesArray *>(sdigArray->At(i)) ;
        Int_t curNext = nextSig ;
        if(sdigits->GetEntriesFast() > index[i] ){
-         curNext = ((AliEMCALDigit *) sdigits->At(index[i]))->GetId() ;
-         
+         curNext = dynamic_cast<AliEMCALDigit *>(sdigits->At(index[i]))->GetId() ;       
        }
        if(curNext < nextSig) nextSig = curNext ;
       }
     }
     // add the noise now
     
-    if (geom->IsInECAL(digit->GetId())) 
+    if (geom->IsInECA(digit->GetId())) 
       amp += TMath::Abs(gRandom->Gaus(0., fPinNoise)) ;
     else if (geom->IsInPRE(digit->GetId())) 
       amp += TMath::Abs(gRandom->Gaus(0., fPinNoise/100.)) ; // arbitrarely divide by 100, assuming that the gain of APD will be higher
-    else if (geom->IsInHCAL(digit->GetId())) 
+    else if (geom->IsInHCA(digit->GetId())) 
       amp += TMath::Abs(gRandom->Gaus(0., fPinNoise/10.)) ;  // arbitrarely divide by 10, assuming that the gain of APD will be higher
-   if (gDebug==1) 
-      Info("Digitize", "After noise amp = %f \n", amp) ; 
     digit->SetAmp(sDigitizer->Digitize(amp)) ;  
   }
   
@@ -299,30 +314,27 @@ void AliEMCALDigitizer::Digitize(const Int_t event)
   delete sdigArray ; //We should not delete its contents
 
   //remove digits below thresholds
-  for(absID = 0; absID < nEMC; absID++){
-    digit = dynamic_cast<AliEMCALDigit*>( digits->At(absID) ) ;
+  for(i = 0 ; i < nEMC ; i++){
+    digit = dynamic_cast<AliEMCALDigit*>( digits->At(i) ) ;
     Float_t threshold = 0 ; 
 
-    if (geom->IsInECAL(digit->GetId())) 
+    if (geom->IsInECA(digit->GetId())) 
       threshold = fDigitThreshold ; 
     else  if (geom->IsInPRE(digit->GetId()))
       threshold = fDigitThreshold / 100. ; // arbitrary see before when noise is added
-    else  if (geom->IsInHCAL(digit->GetId()))
+    else  if (geom->IsInHCA(digit->GetId()))
       threshold = fDigitThreshold / 10. ; // arbitrary see before when noise is added    
 
-    if(sDigitizer->Calibrate( digit->GetAmp() ) <= threshold)
-      digits->RemoveAt(absID) ;
-    else {
-      if (gDebug == 1)
-       Info("Digitize", "id = %d, amp = %f, noise = %f", absID, sDigitizer->Calibrate(digit->GetAmp()), fPinNoise) ; 
+    if(sDigitizer->Calibrate( digit->GetAmp() ) < threshold)
+      digits->RemoveAt(i) ;
+    else 
       digit->SetTime(gRandom->Gaus(digit->GetTime(),fTimeResolution) ) ;
-    }
   }
   
   digits->Compress() ;  
   
   Int_t ndigits = digits->GetEntriesFast() ; 
-  //  digits->Expand(ndigits) ;
+  digits->Expand(ndigits) ;
   
   //Set indexes in list of digits
   for (i = 0 ; i < ndigits ; i++) { 
@@ -338,19 +350,19 @@ void AliEMCALDigitizer::Digitize(const Int_t event)
 Int_t AliEMCALDigitizer::DigitizeEnergy(Float_t energy, Int_t absId)
 { 
   Int_t channel = -999;
-  AliEMCALGeometry * geom = AliEMCALGetter::GetInstance()->EMCALGeometry() ; 
+  AliEMCALGeometry * geom = AliEMCALGetter::Instance()->EMCALGeometry() ; 
   
   if(geom->IsInPRE(absId)){        //digitize as PRE section
     channel =  static_cast<Int_t>(TMath::Ceil( (energy + fADCpedestalPRE)/fADCchannelPRE ))  ;
     if(channel > fNADCPRE ) 
       channel =  fNADCPRE ;
   }
-  else if(geom->IsInECAL(absId)){  //digitize as ECAL section
+  else if(geom->IsInECA(absId)){  //digitize as ECAL section
     channel = static_cast<Int_t> (TMath::Ceil( (energy + fADCpedestalEC)/fADCchannelEC ))  ;
     if(channel > fNADCEC ) 
       channel =  fNADCEC ;
   } 
-  else if(geom->IsInHCAL(absId)){  //digitize as HCAL section
+  else if(geom->IsInHCA(absId)){  //digitize as HCAL section
     channel = static_cast<Int_t> (TMath::Ceil( (energy + fADCpedestalHC)/fADCchannelHC ))  ;
     if(channel > fNADCHC ) 
       channel =  fNADCHC ;
@@ -364,86 +376,39 @@ void AliEMCALDigitizer::Exec(Option_t *option)
 { 
   // Managing method
 
-  if(strcmp(GetName(), "") == 0 )   
-    Init() ;
+  if (!fInit) { // to prevent overwrite existing file
+    Error( "Exec", "Give a version name different from %s", fEventFolderName.Data() ) ;
+    return ;
+  } 
+
   if (strstr(option,"print")) {
-    Print("");
+    Print();
     return ; 
   }
   
   if(strstr(option,"tim"))
     gBenchmark->Start("EMCALDigitizer");
 
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ;
+  if (fManager) 
+    fInput = fManager->GetNinputs() ;
   
-  Int_t nevents ;
+  AliEMCALGetter * gime = AliEMCALGetter::Instance() ;
   
-  TTree * treeD ;
-  
-  if(fManager){
-    treeD = fManager->GetTreeD() ;
-    nevents = 1 ;    // Will process only one event
-    
-    //Check, if this branch already exits
-    if (treeD) { 
-      TObjArray * lob = (TObjArray*)treeD->GetListOfBranches() ;
-      TIter next(lob) ; 
-      TBranch * branch = 0 ;  
-      Bool_t emcalfound = kFALSE, digitizerfound = kFALSE ; 
-      
-      while ( (branch = (TBranch*)next()) && (!emcalfound || !digitizerfound) ) {
-       if ( (strcmp(branch->GetName(), "EMCAL")==0) && 
-            (strcmp(branch->GetTitle(), GetName())==0) ) 
-         emcalfound = kTRUE ;
-       
-       else if ( (strcmp(branch->GetName(), "AliEMCALDigitizer")==0) && 
-                 (strcmp(branch->GetTitle(), GetName())==0) ) 
-         digitizerfound = kTRUE ; 
-      }
-      
-      if ( emcalfound ) {
-       Error( "Exec", "Digits branch with name %s already exits", GetName() ) ;
-       return ; 
-      }   
-      if ( digitizerfound ) {
-       Error( "Exec", "Digitizer branch with name %s already exit", GetName() ) ;
-              return ; 
-      }
-    }   
-  }
-  else { //EMCAL standalone
-    if(gime->BranchExists("Digits") ) 
-      return ;
-    nevents=gime->MaxEvent() ;
-  }
+  Int_t nevents = gime->MaxEvent() ;;
   
   Int_t ievent ;
 
   for(ievent = 0; ievent < nevents; ievent++){
     
-    if(fManager){
-
-      Int_t input ;
-      for(input = 0 ; input < fManager->GetNinputs(); input ++){
-       TTree * treeS = fManager->GetInputTreeS(input) ;
-       if(!treeS){
-         Error( "Exec", "No Input") ;
-         return ;
-       }
-       gime->ReadTreeS(treeS,input) ;
-      }
+    gime->Event(ievent,"S") ; 
 
-    }
-    else 
-      gime->Event(ievent,"S") ; 
-    
     Digitize(ievent) ; //Add prepared SDigits to digits and add the noise
-    
+
     WriteDigits(ievent) ;
-    
+
     if(strstr(option,"deb"))
       PrintDigits(option);
-    
+
     //increment the total number of Digits per run 
     fDigitsInRun += gime->Digits()->GetEntriesFast() ;  
   }
@@ -452,13 +417,14 @@ void AliEMCALDigitizer::Exec(Option_t *option)
     gBenchmark->Stop("EMCALDigitizer");
     Info("Exec", "took %f seconds for Digitizing %f seconds per event", 
         gBenchmark->GetCpuTime("EMCALDigitizer"), gBenchmark->GetCpuTime("EMCALDigitizer")/nevents ) ;
-  }
-  
+  } 
 }
 
 //____________________________________________________________________________ 
 Float_t AliEMCALDigitizer::FrontEdgeTime(TClonesArray * ticks) 
-{ // 
+{ 
+  //  Returns the shortest time among all time ticks
+
   ticks->Sort() ; //Sort in accordance with times of ticks
   TIter it(ticks) ;
   AliEMCALTick * ctick = (AliEMCALTick *) it.Next() ;
@@ -480,64 +446,51 @@ Float_t AliEMCALDigitizer::FrontEdgeTime(TClonesArray * ticks)
 Bool_t AliEMCALDigitizer::Init()
 {
   // Makes all memory allocations
-
-  if( strcmp(GetTitle(), "") == 0 )
-    SetTitle("galice.root") ;
-  
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance(GetTitle(), GetName(), fToSplit) ; 
+  fInit = kTRUE ; 
+  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ;  
   if ( gime == 0 ) {
-    Error("Init", "Could not obtain the Getter object !" ) ; 
+    Error("Init", "Could not obtain the Getter object for file %s and event %s !", GetTitle(), fEventFolderName.Data()) ;   
     return kFALSE;
   } 
   
-  //const AliEMCALGeometry * geom = gime->EMCALGeometry() ;
+  TString opt("Digits") ; 
+  if(gime->VersionExists(opt) ) { 
+    Error( "Init", "Give a version name different from %s", fEventFolderName.Data() ) ;
+    fInit = kFALSE ; 
+  }
 
-  //fEmcCrystals = geom->GetNModules() *  geom->GetNCristalsInModule() ;
-  
-  // Post Digits to the white board
-  gime->PostDigits(GetName() ) ;   
-  
   // Post Digitizer to the white board
   gime->PostDigitizer(this) ;
  
-  fSplitFile = 0 ;
-  if(fToSplit){
-    // construct the name of the file as /path/EMCAL.SDigits.root
-    //First - extract full path if necessary
-    TString digitsFileName(GetTitle()) ;
-    Ssiz_t islash = digitsFileName.Last('/') ;
-    if(islash<digitsFileName.Length())
-      digitsFileName.Remove(islash+1,digitsFileName.Length()) ;
-    else
-      digitsFileName="" ;
-    // Next - append the file name 
-    digitsFileName+="EMCAL.Digits." ;
-    if((strcmp(GetName(),"Default")!=0)&&(strcmp(GetName(),"")!=0)){
-      digitsFileName+=GetName() ;
-      digitsFileName+="." ;
-    }
-    digitsFileName+="root" ;
-    // Finally - check if the file already opened or open the file
-    fSplitFile = static_cast<TFile*>(gROOT->GetFile(digitsFileName.Data()));   
-    if(!fSplitFile)
-      fSplitFile =  TFile::Open(digitsFileName.Data(),"update") ;
+  if(fManager)
+    fInput = fManager->GetNinputs() ; 
+  else 
+    fInput           = 1 ;
+
+  fInputFileNames  = new TString[fInput] ; 
+  fEventNames      = new TString[fInput] ; 
+  fInputFileNames[0] = GetTitle() ; 
+  fEventNames[0]     = fEventFolderName.Data() ; 
+  Int_t index ; 
+  for (index = 1 ; index < fInput ; index++) {
+    fInputFileNames[index] = dynamic_cast<AliStream*>(fManager->GetInputStream(index))->GetFileName(0); 
+    TString tempo = fManager->GetInputFolderName(index) ;
+    fEventNames[index] = tempo.Remove(tempo.Length()-1) ; // strip of the stream number added bt fManager 
   }
   
-  //Mark that we will use current header file
-  if(!fManager){
-    gime->PostSDigits(GetName(),GetTitle()) ;
-    gime->PostSDigitizer(GetName(),GetTitle()) ;
-  }
-  return kTRUE ;    
+  //to prevent cleaning of this object while GetEvent is called
+  gime->EmcalLoader()->GetDigitsDataLoader()->GetBaseTaskLoader()->SetDoNotReload(kTRUE);
+  
+  return fInit ;    
 }
 
 //____________________________________________________________________________ 
 void AliEMCALDigitizer::InitParameters()
 {
   fMeanPhotonElectron = 1250 ; // electrons per GeV
-  
-  Warning("InitParameters", "No noise added\n") ; 
-  fPinNoise           = 0. ; // 0.001 ; // noise equivalent GeV (random choice)
+  fPinNoise           = 0.001 ; // noise equivalent GeV (random choice)
+  if (fPinNoise == 0. ) 
+    Warning("InitParameters", "No noise added\n") ; 
   fDigitThreshold     = fPinNoise * 3; //2 sigma
   fTimeResolution     = 0.5e-9 ;
   fTimeSignalLength   = 1.0e-9 ;
@@ -559,7 +512,7 @@ void AliEMCALDigitizer::InitParameters()
 }
 
 //__________________________________________________________________
-void AliEMCALDigitizer::MixWith(char* headerFile)
+void AliEMCALDigitizer::MixWith(const TString alirunFileName, const TString eventFolderName)
 {
   // Allows to produce digits by superimposing background and signal event.
   // It is assumed, that headers file with SIGNAL events is opened in 
@@ -580,105 +533,99 @@ void AliEMCALDigitizer::MixWith(char* headerFile)
     Error("MixWith", "Cannot use this method under AliRunDigitizer") ;
     return ;
   } 
-  
-  // check if the specified SDigits do not already exist on the White Board:
-  // //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname
-
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ; 
-  TString path = gime->SDigitsFolder()->GetName() ; 
-
-  // before it was ???? "Folders/RunMC/Event/Data/EMCAL/SDigits" ; 
-  path += headerFile ; 
-  path += "/" ; 
-  path += GetName() ;
-  if ( gROOT->FindObjectAny(path.Data()) ) {
-    Error("MixWith", "Entry already exists, do not add" ) ;
-    return;
+  // looking for file which contains AliRun
+  if (gSystem->AccessPathName(alirunFileName)) {// file does not exist
+    Error("MixWith", "File %s does not exist!", alirunFileName.Data()) ;
+    return ; 
   }
-
-  gime->PostSDigits(GetName(),headerFile) ;
-  
-  // check if the requested file is already open or exist and if SDigits Branch exist
-  TFile * file = (TFile*)gROOT->FindObject(headerFile); 
-  if ( !file ) { 
-    file = new TFile(headerFile, "READ") ; 
-    if (!file) { 
-      Error("MixWith", "File %s does not exist!", headerFile) ; 
-      return ; 
+  // looking for the file which contains SDigits
+  AliEMCALGetter * gime = AliEMCALGetter::Instance() ; 
+  TString fileName( gime->GetSDigitsFileName() ) ; 
+    if ( eventFolderName != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
+      fileName = fileName.ReplaceAll(".root", "") + "_" + eventFolderName + ".root" ;
+    if ( (gSystem->AccessPathName(fileName)) ) { 
+      Error("MixWith", "The file %s does not exist!", fileName.Data()) ;
+      return ;
     }
-  }
-  
-}
-
+    // need to increase the arrays
+    TString tempo = fInputFileNames[fInput-1] ; 
+    delete [] fInputFileNames ; 
+    fInputFileNames = new TString[fInput+1] ; 
+    fInputFileNames[fInput-1] = tempo ; 
+    tempo = fEventNames[fInput-1] ; 
+    delete [] fEventNames ; 
+    fEventNames = new TString[fInput+1] ; 
+    fEventNames[fInput-1] = tempo ; 
+
+    fInputFileNames[fInput] = alirunFileName ; 
+    fEventNames[fInput]     = eventFolderName ;
+    fInput++ ;
+}  
 //__________________________________________________________________
-void AliEMCALDigitizer::Print(Option_t* option)const {
-
-  TString message("\n") ; 
-
-  if( strcmp(GetName(), "") != 0) {
-    message += "------------------- " ; 
-    message += GetName() ; 
-    message += " -------------" ;
-    const Int_t nStreams = GetNInputStreams() ; 
-    if (nStreams) {
-      Int_t index = 0 ;  
-      for (index = 0 ; index < nStreams ; index++) {  
-       message += "\nAdding SDigits " ; 
-       message += GetName() ; 
-       message += " from " ; 
-       message += fManager->GetInputFileName(index, 0) ;
-      } 
-     
-      message += "\nWriting digits to " ; 
-      message += fManager->GetInputFileName(0, 0) ;   
-    } else { 
-      message += "\nWriting digits to " ;
-      message += GetTitle() ;
-    }       
-    message += "\nWith following parameters: " ;
-    message += "\n     Electronics noise in EMC (fPinNoise) = " ; 
-    message += fPinNoise ;
-    message += "\n  Threshold  in EMC  (fDigitThreshold) = " ; 
-    message += fDigitThreshold  ;
-    message += "\n---------------------------------------------------"  ;
+void AliEMCALDigitizer::Print()const 
+{
+  // Print Digitizer's parameters
+  Info("Print", "\n------------------- %s -------------", GetName() ) ; 
+  if( strcmp(fEventFolderName.Data(), "") != 0 ){
+    printf(" Writing Digits to branch with title  %s\n", fEventFolderName.Data()) ;
+    
+    Int_t nStreams ; 
+    if (fManager) 
+      nStreams =  GetNInputStreams() ;
+    else 
+      nStreams = fInput ; 
+    
+    Int_t index = 0 ;  
+    for (index = 0 ; index < nStreams ; index++) {  
+      TString tempo(fEventNames[index]) ; 
+      tempo += index ;
+      AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[index], tempo) ; 
+      TString fileName( gime->GetSDigitsFileName() ) ; 
+      if ( fEventNames[index] != AliConfig::fgkDefaultEventFolderName) // only if not the default folder name 
+       fileName = fileName.ReplaceAll(".root", "") + "_" + fEventNames[index]  + ".root" ;
+      printf ("Adding SDigits from %s %s\n", fInputFileNames[index].Data(), fileName.Data()) ; 
+    }
+    AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
+    printf("\nWriting digits to %s", gime->GetDigitsFileName().Data()) ;
+    
+    printf("\nWith following parameters:\n") ;
+    
+    printf("    Electronics noise in EMC (fPinNoise) = %f\n", fPinNoise) ;
+    printf("    Threshold  in EMC  (fDigitThreshold) = %f\n", fDigitThreshold)  ;
+    printf("---------------------------------------------------\n")  ;
   }
   else
-    message += "\nAliEMCALDigitizer not initialized " ;
-
-  Info("Print", message.Data() ) ; 
+    Info("Print", "AliEMCALDigitizer not initialized") ; 
 }
 
 //__________________________________________________________________
 void AliEMCALDigitizer::PrintDigits(Option_t * option){
     
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ; 
-  TClonesArray * fDigits = gime->Digits() ;
-
-  TString message("\n") ; 
-  message += "       Number of entries in Digits list " ; 
-  message += fDigits->GetEntriesFast() ;
-
-  if(strstr(option,"all")){
-    
+  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
+  TClonesArray * digits = gime->Digits() ;
+  
+  Info("PrintDigits", "%d", digits->GetEntriesFast()) ; 
+  printf("\nevent %d", gAlice->GetEvNumber()) ;
+  printf("\n       Number of entries in Digits list %d", digits->GetEntriesFast() )  ;  
+  
+  if(strstr(option,"all")){  
     //loop over digits
     AliEMCALDigit * digit;
-    message += "\n   Id  Amplitude    Time          Index Nprim: Primaries list \n" ;    
+    printf("\nEMC digits (with primaries):\n")  ;
+    printf("\n   Id  Amplitude    Time          Index Nprim: Primaries list \n") ;    
     Int_t index ;
-    char * tempo = new char[8192]; 
-    for (index = 0 ; index < fDigits->GetEntries() ; index++) {
-      digit = (AliEMCALDigit * )  fDigits->At(index) ;
-      sprintf(tempo, "\n%6d  %8d    %6.5e %4d      %2d : ",
+    for (index = 0 ; index < digits->GetEntries() ; index++) {
+      digit = dynamic_cast<AliEMCALDigit *>(digits->At(index)) ;
+      printf("\n%6d  %8d    %6.5e %4d      %2d : ",
              digit->GetId(), digit->GetAmp(), digit->GetTime(), digit->GetIndexInList(), digit->GetNprimary()) ;  
-      message += tempo ; 
       Int_t iprimary;
       for (iprimary=0; iprimary<digit->GetNprimary(); iprimary++) {
-       sprintf(tempo, "%d ",digit->GetPrimary(iprimary+1) ) ; 
-       message += tempo ; 
+       printf("%d ",digit->GetPrimary(iprimary+1) ) ; 
       }
     }   
-    delete tempo ; 
   }
-  Info("PrintDigits", message.Data() ) ; 
 }
 
 //__________________________________________________________________
@@ -689,6 +636,22 @@ Float_t AliEMCALDigitizer::TimeOfNoise(void)
 
 }
 
+//__________________________________________________________________
+void AliEMCALDigitizer::Unload() 
+{  
+  
+  Int_t i ; 
+  for(i = 1 ; i < fInput ; i++){
+    TString tempo(fEventNames[i]) ; 
+    tempo += i ;
+    AliEMCALGetter * gime = AliEMCALGetter::Instance(fInputFileNames[i], tempo) ; 
+    gime->EmcalLoader()->UnloadSDigits() ; 
+  }
+  
+  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
+  gime->EmcalLoader()->UnloadDigits() ; 
+}
+
 //_________________________________________________________________________________________
 void AliEMCALDigitizer::WriteDigits(Int_t event)
 {
@@ -701,34 +664,20 @@ void AliEMCALDigitizer::WriteDigits(Int_t event)
   //      and branch "AliEMCALDigitizer", with the same title to keep all the parameters
   //      and names of files, from which digits are made.
 
-  AliEMCALGetter * gime = AliEMCALGetter::GetInstance() ; 
-  const TClonesArray * digits = gime->Digits(GetName()) ; 
- TTree * treeD ;
-
- if(fManager)
-   treeD = fManager->GetTreeD() ;
- else {
-   if ((gAlice->TreeD() == 0) || (fSplitFile)) // we should not create TreeD if it is already here 
-     gAlice->MakeTree("D", fSplitFile); // We overwrite TreeD in split file in the case of second reconstruction
-   if(fSplitFile)
-     fSplitFile->cd() ;
-   treeD = gAlice->TreeD();
- }
- // -- create Digits branch
- Int_t bufferSize = 32000 ;    
- TBranch * digitsBranch = treeD->Branch("EMCAL",&digits,bufferSize);
- digitsBranch->SetTitle(GetName());
- // -- Create Digitizer branch
- Int_t splitlevel = 0 ;
- const  AliEMCALDigitizer * d = gime->Digitizer(GetName()) ;
- TBranch * digitizerBranch = treeD->Branch("AliEMCALDigitizer", "AliEMCALDigitizer", &d,bufferSize,splitlevel); 
- digitizerBranch->SetTitle(GetName());
- digitsBranch->Fill() ;
- digitizerBranch->Fill() ; 
- treeD->AutoSave() ;  
+  AliEMCALGetter * gime = AliEMCALGetter::Instance(GetTitle(), fEventFolderName) ; 
+  const TClonesArray * digits = gime->Digits() ; 
+  TTree * treeD = gime->TreeD(); 
+
+  // -- create Digits branch
+  Int_t bufferSize = 32000 ;    
+  TBranch * digitsBranch = treeD->Branch("EMCAL",&digits,bufferSize);
+  digitsBranch->SetTitle(fEventFolderName);
+  digitsBranch->Fill() ;
+  
+  gime->WriteDigits("OVERWRITE");
+  gime->WriteDigitizer("OVERWRITE");
+
+  Unload() ; 
+
 }
 
index 4cf238f..32fae09 100644 (file)
@@ -10,6 +10,7 @@
 //                  
 //*-- Author: Sahal Yacoob (LBL)
 // based on : AliPHOSDigit
+// July 2003 Yves Schutz : NewIO 
 //_________________________________________________________________________ 
 
 
@@ -19,10 +20,10 @@ class TArrayI ;
 class TClonesArray ; 
 
 // --- Standard library ---
-#include <stdlib.h>
 
 // --- AliRoot header files ---
 #include "AliDigitizer.h"
+#include "AliConfig.h"
 class AliEMCALSDigitizer ;
 class AliRunDigitizer ;
 
@@ -30,10 +31,9 @@ class AliEMCALDigitizer: public AliDigitizer {
 
 public:
   AliEMCALDigitizer() ;          // ctor
-  AliEMCALDigitizer(const char *headerFile, const char * sDigitsBranchTitle = "Default", const Bool_t toSplit = kFALSE) ; 
-  AliEMCALDigitizer(AliRunDigitizer * ard) ;
-  AliEMCALDigitizer(const AliEMCALDigitizer & dtizer) 
-                  {( (AliEMCALDigitizer &)dtizer ).Copy(*this) ;} 
+  AliEMCALDigitizer(const TString alirunFileNameFile, const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ;  
+  AliEMCALDigitizer(const AliEMCALDigitizer & dtizer) ;
+  AliEMCALDigitizer(AliRunDigitizer * manager) ;
   virtual ~AliEMCALDigitizer() ;       
 
   void    Digitize(const Int_t event);          // Make Digits from SDigits stored in fSDigits
@@ -44,10 +44,10 @@ public:
   const Float_t GetPinNoise()       const { return fPinNoise;}
   const Float_t GetSlope()          const { return fSlope; }
   const Float_t GetTimeResolution() const { return fTimeResolution ; }
-  const Float_t GetECchannel()      const { return fADCchannelEC ; }
-  const Float_t GetECpedestal()     const { return fADCpedestalEC ; }
-  const Float_t GetHCchannel()      const { return fADCchannelHC ; }
-  const Float_t GetHCpedestal()     const { return fADCpedestalHC ; }
+  const Float_t GetECAchannel()     const { return fADCchannelEC ; }
+  const Float_t GetECApedestal()    const { return fADCpedestalEC ; }
+  const Float_t GetHCAchannel()     const { return fADCchannelHC ; }
+  const Float_t GetHCApedestal()    const { return fADCpedestalHC ; }
   const Float_t GetPREchannel()     const { return fADCchannelPRE ; }
   const Float_t GetPREpedestal()    const { return fADCpedestalPRE ; }
 
@@ -55,9 +55,10 @@ public:
   void    SetPinNoise(Float_t PinNoise )         {fPinNoise = PinNoise;}
 
   //General
-  const Int_t   GetDigitsInRun()  const { return fDigitsInRun; } ;
-  void  MixWith(char* HeaderFile) ; // Add another one file to mix
-  void  Print(Option_t* option)const ;
+  const Int_t   GetDigitsInRun()  const { return fDigitsInRun; } 
+  void  MixWith(const TString alirunFileName, 
+               const TString eventFolderName = AliConfig::fgkDefaultEventFolderName) ; // Add another one file to mix
+  void  Print()const ;
  
  AliEMCALDigitizer & operator = (const AliEMCALDigitizer & rvalue)  {
     // assignement operator requested by coding convention but not needed
@@ -70,16 +71,24 @@ private:
   Bool_t  Init();                   
   void    InitParameters() ; 
   void    PrintDigits(Option_t * option) ;
+  void    Unload() ; 
   void    WriteDigits(Int_t evt) ;            // Writes Digits for particular event
   Float_t TimeOfNoise(void) ;                 // Calculate time signal generated by noise
+
   //Calculate the time of crossing of the threshold by front edge
   Float_t FrontEdgeTime(TClonesArray * ticks) ;
   Int_t   DigitizeEnergy(Float_t energy, Int_t absId) ;
 
 private:
   
-  Bool_t fDefaultInit;            //! Says if the task was created by defaut ctor (only parameters are initialized)
-  Int_t fDigitsInRun ;            //! Total number of digits in one run
+  Bool_t  fDefaultInit;           //! Says if the task was created by defaut ctor (only parameters are initialized)
+  Int_t   fDigitsInRun ;          //! Total number of digits in one run
+  Bool_t  fInit ;                 //! To avoid overwriting existing files
+
+  Int_t   fInput ;                // Number of files to merge
+  TString * fInputFileNames ;     //[fInput] List of file names to merge 
+  TString * fEventNames ;         //[fInput] List of event names to merge
+
   Float_t fDigitThreshold  ;      // Threshold for storing digits in EMC
   Int_t   fMeanPhotonElectron ;   // number of photon electrons per GeV deposited energy 
   Float_t fPedestal ;             // Calibration parameters 
@@ -97,10 +106,10 @@ private:
   Float_t fADCchannelPRE ;        // width of one ADC channel in PRE section (GeV)
   Float_t fADCpedestalPRE ;       // 
   Int_t fNADCPRE ;                // number of channels in PRE section ADC
-  Bool_t  fToSplit ;              //! Do we work in the split mode
-  TFile * fSplitFile ;            //! file in which Digits will eventually be stored
 
-  ClassDef(AliEMCALDigitizer,3)  // description 
+  TString fEventFolderName;         // skowron: name of EFN to read data from in stand alone mode
+
+  ClassDef(AliEMCALDigitizer,4)  // description 
 
 };
 
index 3e405d0..a8918ac 100644 (file)
 
 /*
 $Log$
+Revision 1.3.4.1  2003/07/07 14:13:31  schutz
+NewIO
+
+Revision 1.4  2002/12/18 08:25:31  morsch
+Correction in efficiency for p < 0.5.
+
 Revision 1.3  2002/02/05 11:32:15  morsch
 Smearing parameters with TRD included added.
 
index c639c37..a36fb8d 100644 (file)
@@ -200,14 +200,16 @@ void AliEMCALGeometry::Init(void){
   
   fgInit = kTRUE; 
   
-  Info("Init", "geometry of EMCAL named %s is as follows:", name.Data());
-  printf( "Tower geometry pre-shower: %d x (%f mm Pb, %f mm Sc) \n", GetNPRLayers(), GetPRPbRadThick(), GetPRScintThick() ) ; 
-  printf( "               ECAL      : %d x (%f mm Pb, %f mm Sc) \n", GetNECLayers(), GetECPbRadThick(), GetECScintThick() ) ; 
-  if ( GetNHCLayers() > 0 )
-    printf( "               HCAL      : %d x (%f mm Pb, %f mm Sc) \n", GetNHCLayers(), GetHCCuRadThick(), GetHCScintThick() ) ; 
-  printf("Granularity: %d in eta and %d in phi\n", GetNZ(), GetNPhi()) ;
-  printf("Layout: phi = (%f, %f), eta = (%f, %f), y = %f\n",  
-        GetArm1PhiMin(), GetArm1PhiMax(),GetArm1EtaMin(), GetArm1EtaMax(), GetIPDistance() ) ;    
+  if (gDebug) {
+    Info("Init", "geometry of EMCAL named %s is as follows:", name.Data());
+    printf( "Tower geometry pre-shower: %d x (%f mm Pb, %f mm Sc) \n", GetNPRLayers(), GetPRPbRadThick(), GetPRScintThick() ) ; 
+    printf( "               ECAL      : %d x (%f mm Pb, %f mm Sc) \n", GetNECLayers(), GetECPbRadThick(), GetECScintThick() ) ; 
+    if ( GetNHCLayers() > 0 )
+      printf( "               HCAL      : %d x (%f mm Pb, %f mm Sc) \n", GetNHCLayers(), GetHCCuRadThick(), GetHCScintThick() ) ; 
+    printf("Granularity: %d in eta and %d in phi\n", GetNZ(), GetNPhi()) ;
+    printf("Layout: phi = (%f, %f), eta = (%f, %f), y = %f\n",  
+          GetArm1PhiMin(), GetArm1PhiMax(),GetArm1EtaMin(), GetArm1EtaMax(), GetIPDistance() ) ;    
+  }
 }
 
 //______________________________________________________________________
@@ -289,11 +291,11 @@ void AliEMCALGeometry::TowerIndexes(Int_t index,Int_t &ieta,Int_t &iphi,
     nindex = index - itowers;
     ipre = 1 ; 
   }
-  else  if ( IsInECAL(index) ) { // ECAL index
+  else  if ( IsInECA(index) ) { // ECAL index
     nindex = index ;
     ipre = 0 ; 
   }
-  else  if ( IsInHCAL(index) ) { // HCAL index
+  else  if ( IsInHCA(index) ) { // HCAL index
     nindex = index - 2*itowers;
     ipre = 2 ; 
   }
@@ -425,9 +427,9 @@ void AliEMCALGeometry::PosInAlice(const Int_t *relid, Float_t &theta, Float_t &p
   if (sect == 1)
     d = GetIP2PRESection() -  GetIPDistance() ; 
   else if (sect == 0)
-    d = GetIP2ECALSection() - GetIPDistance() ; 
+    d = GetIP2ECASection() - GetIPDistance() ; 
   else if (sect == 2) 
-    d = GetIP2HCALSection() - GetIPDistance() ;
+    d = GetIP2HCASection() - GetIPDistance() ;
   else 
     Fatal("PosInAlice", "Unexpected tower section!") ; 
 
@@ -461,10 +463,10 @@ void AliEMCALGeometry::PosInAlice(const Int_t absid, Float_t &theta, Float_t &ph
   Float_t d = 0. ; 
   if (IsInPRE(absid))
     d = GetIP2PRESection() -  GetIPDistance() ; 
-  else if (IsInECAL(absid))
-    d = GetIP2ECALSection() - GetIPDistance() ; 
-  else if (IsInHCAL(absid)) 
-    d = GetIP2HCALSection() - GetIPDistance() ;
+  else if (IsInECA(absid))
+    d = GetIP2ECASection() - GetIPDistance() ; 
+  else if (IsInHCA(absid)) 
+    d = GetIP2HCASection() - GetIPDistance() ;
   else 
     Fatal("PosInAlice", "Unexpected id # %d!", absid) ; 
 
@@ -501,11 +503,11 @@ void AliEMCALGeometry::XYZFromIndex(const Int_t *relid,Float_t &x,Float_t &y, Fl
     theta = 180.*(2.0*TMath::ATan(TMath::Exp(-eta)))/TMath::Pi();
     
     if ( ipre == 0 ) 
-      cyl_radius = GetIP2ECALSection() ;
+      cyl_radius = GetIP2ECASection() ;
     else if ( ipre == 1 ) 
       cyl_radius = GetIP2PRESection() ;
     else if ( ipre == 2 ) 
-      cyl_radius = GetIP2HCALSection() ;
+      cyl_radius = GetIP2HCASection() ;
     else 
       Fatal("XYZFromIndex", "Unexpected Tower section # %d", ipre) ;  
 
@@ -533,12 +535,12 @@ void AliEMCALGeometry::XYZFromIndex(const Int_t absid,  TVector3 &v) const {
         
     PosInAlice(absid, theta, phi) ; 
     
-    if ( IsInECAL(absid) ) 
-      cyl_radius = GetIP2ECALSection() ;
+    if ( IsInECA(absid) ) 
+      cyl_radius = GetIP2ECASection() ;
     else if ( IsInPRE(absid) ) 
       cyl_radius = GetIP2PRESection() ;
-    else if ( IsInHCAL(absid) ) 
-      cyl_radius = GetIP2HCALSection() ;
+    else if ( IsInHCA(absid) ) 
+      cyl_radius = GetIP2HCASection() ;
     else 
       Fatal("XYZFromIndex", "Unexpected Tower section") ;  
 
index 554e62a..9aa2168 100644 (file)
@@ -58,9 +58,9 @@ public:
   const Float_t GetArm1EtaMin() const { return fArm1EtaMin;}
   const Float_t GetArm1EtaMax() const { return fArm1EtaMax;}
   const Float_t GetIPDistance() const { return fIPDistance  ; } 
-  const Float_t GetIP2PRESection()  const { return (GetIPDistance() + GetAlFrontThickness() +  GetGap2Active() ) ;}
-  const Float_t GetIP2ECALSection() const { return ( GetIP2PRESection() + GetNPRLayers() * (  GetPRScintThick() +  GetPRPbRadThick() ) ) ; }  
-  const Float_t GetIP2HCALSection() const { return ( GetIP2ECALSection() + GetNECLayers() * ( GetECScintThick() +  GetECPbRadThick() ) ) ; }  
+  const Float_t GetIP2PRESection() const { return (GetIPDistance() + GetAlFrontThickness() +  GetGap2Active() ) ;}
+  const Float_t GetIP2ECASection() const { return ( GetIP2PRESection() + GetNPRLayers() * (  GetPRScintThick() +  GetPRPbRadThick() ) ) ; }  
+  const Float_t GetIP2HCASection() const { return ( GetIP2ECASection() + GetNECLayers() * ( GetECScintThick() +  GetECPbRadThick() ) ) ; }  
   const Float_t GetEnvelop(Int_t index) const { return fEnvelop[index] ; }  
   const Float_t GetShellThickness() const { return fShellThickness ; }
   const Float_t GetZLength() const { return fZLength ; } 
@@ -86,8 +86,8 @@ public:
   const Float_t GetSummationFraction() const {return fSummationFraction ; } 
   
   const Bool_t IsInPRE(Int_t index) const  { if ( (index > (GetNZ() * GetNPhi()) && (index <= 2 * (GetNZ() * GetNPhi())))) return kTRUE; else return kFALSE ;} 
-  const Bool_t IsInECAL(Int_t index) const { if ( (index > 0 && (index <= GetNZ() * GetNPhi()))) return kTRUE; else return kFALSE ;}
-  const Bool_t IsInHCAL(Int_t index) const { if ( (index > 2*(GetNZ() * GetNPhi()) && (index <= 3 * (GetNZ() * GetNPhi())))) return kTRUE; else return kFALSE ;} ; 
+  const Bool_t IsInECA(Int_t index) const { if ( (index > 0 && (index <= GetNZ() * GetNPhi()))) return kTRUE; else return kFALSE ;}
+  const Bool_t IsInHCA(Int_t index) const { if ( (index > 2*(GetNZ() * GetNPhi()) && (index <= 3 * (GetNZ() * GetNPhi())))) return kTRUE; else return kFALSE ;} ; 
 
   Float_t AngleFromEta(Float_t eta){ // returns angle in radians for a given
     // pseudorapidity.
index eac9246..8c37d6b 100644 (file)
  **************************************************************************/
 
 /* $Id:  */
+
 /* $Log:
    29.05.2001 Yuri Kharlov:
               Everywhere reading the treese TTree->GetEvent(i)
               is replaced by reading the branches TBranch->GetEntry(0)
 */
-
 /* $Log:
    08.2002 Dmitri Peressounko:
+
 */
 
 //_________________________________________________________________________
 //  A singleton. This class should be used in the analysis stage to get 
 //  reconstructed objects: Digits, RecPoints, TrackSegments and RecParticles,
 //  instead of directly reading them from galice.root file. This container 
-//  ensures, that one reads Digits, made of these particular digits, RecPoints,
+//  ensures, that one reads Digits, made of these particular digits, RecPoints, 
 //  made of these particular RecPoints, TrackSegments and RecParticles. 
 //  This becomes non trivial if there are several identical branches, produced with
 //  different set of parameters. 
 //  for(Int_t irecp = 0; irecp < gime->NRecParticles() ; irecp++)
 //     AliEMCALRecParticle * part = gime->RecParticle(1) ;
 //     ................
-//  please->GetEvent(event) ;    // reads new event from galice.root
+//  gime->Event(event) ;    // reads new event from galice.root
 //                  
 //*-- Author: Yves Schutz (SUBATECH) & Dmitri Peressounko (RRC KI & SUBATECH)
 //*--         Completely redesigned by Dmitri Peressounko March 2001  
 //
 //*-- YS June 2001 : renamed the original AliEMCALIndexToObject and make
-//*--         systematic usage of TFolders without changing the interface     
-//*-- YS August 2002 : clone PHOS as closely as possible and intoduction
-//                     of new  IO (à la PHOS)
-
+//*--         systematic usage of TFolders without changing the interface        
 //////////////////////////////////////////////////////////////////////////////
 
-
-
 // --- ROOT system ---
 
+#include "TSystem.h"
 #include "TFile.h"
-#include "TTree.h"
+// #include "TTree.h"
 #include "TROOT.h"
-#include "TObjString.h"
-#include "TFolder.h"
-#include "TParticle.h"
+// #include "TObjString.h"
+// #include "TFolder.h"
+// #include "TParticle.h"
 
 // --- Standard library ---
 
-#include <Riostream.h>
-
 // --- AliRoot header files ---
-
-#include "AliRun.h"
-#include "AliConfig.h"
+// #include "AliRun.h"
+// #include "AliConfig.h"
 #include "AliEMCALGetter.h"
-#include "AliEMCAL.h"
-#include "AliEMCALDigitizer.h"
-#include "AliEMCALSDigitizer.h"
-#include "AliEMCALClusterizerv1.h"
-#include "AliEMCALTrackSegmentMakerv1.h"
-#include "AliEMCALTrackSegment.h"
-#include "AliEMCALPIDv1.h" 
-#include "AliEMCALGeometry.h"
+#include "AliRunLoader.h"
+#include "AliStack.h"  
+#include "AliEMCALLoader.h"
 
 ClassImp(AliEMCALGetter)
+  
+AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; 
+AliEMCALLoader * AliEMCALGetter::fgEmcalLoader = 0;
+Int_t AliEMCALGetter::fgDebug = 0;
 
-  AliEMCALGetter * AliEMCALGetter::fgObjGetter = 0 ; 
-  TFile * AliEMCALGetter::fFile = 0 ; 
+//  TFile * AliEMCALGetter::fgFile = 0 ; 
 
 //____________________________________________________________________________ 
-
-AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* branchTitle, const Bool_t toSplit)
+AliEMCALGetter::AliEMCALGetter(const char* headerFile, const char* version, Option_t * openingOption)
 {
-  // This is the ctor called by GetInstance and the only one that can be used 
-
-  if ( fHeaderFile.Contains("_") ) {
-    Fatal("AliEMCALGetter","Invalid file name (_ not allowed) %s",fHeaderFile.Data()) ;
-  }
-
-  //Initialize  all data
-
-  fFailed = kFALSE ;   
-  fDebug  = 0 ; 
-  fAlice  = 0 ; 
-
-  fToSplit    = toSplit ;
-  fHeaderFile = headerFile ; 
+  // ctor only called by Instance()
 
-  fPrimaries = new TObjArray(1) ;
-
-  fModuleFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Configuration/Modules")); 
-  fPrimariesFolder = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data")); 
-  fHitsFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/Hits")); 
-  fSDigitsFolder   = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/RunMC/Event/Data/SDigits")); 
-  fDigitsFolder    = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/Data")); 
-  fRecoFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Event/RecData")); 
-  //fQAFolder      = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Run/Conditions/QA")); 
-  fTasksFolder     = dynamic_cast<TFolder*>(gROOT->FindObjectAny("Folders/Tasks")) ; 
-
-  //Set titles to branches and create EMCAL specific folders
-
-  SetTitle(branchTitle) ;
-
-  if ( fHeaderFile != "aliroot"  ) { // to call the getter without a file
-
-    //open headers file
-
-    fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
-
-    if(!fFile){    //if file was not opened yet, read gAlice
-      fFile = TFile::Open(fHeaderFile.Data(), "update") ;   
-      if (!fFile->IsOpen()) {
-        Error("AliEMCALGetter","Cannot open %s",fHeaderFile.Data()) ; 
-               fFailed = kTRUE ;
-        return ;  
-      }
-    }
-    gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
-  }
-
-  if (!gAlice) {
-    Error("AliEMCALGetter","Cannot find gAlice in %s",fHeaderFile.Data()) ; 
-    fFailed = kTRUE ;
-    return ; 
-  }
-  if (!EMCAL()) {
-    if (fDebug)
-      Info("AliEMCALGetter","Posting EMCAL to Folders") ; 
-
-    if (gAlice->GetDetector("EMCAL")) {
-      AliConfig * conf = AliConfig::Instance() ;
-      conf->Add(static_cast<AliDetector*>(gAlice->GetDetector("EMCAL"))) ; 
-      conf->Add(static_cast<AliModule*>(gAlice->GetDetector("EMCAL"))) ;
+  AliRunLoader* rl = AliRunLoader::GetRunLoader(version) ; 
+  if (!rl) {
+    rl = AliRunLoader::Open(headerFile, version, openingOption);
+    if (!rl) {
+      Fatal("AliEMCALGetter", "Could not find the Run Loader for %s - %s",headerFile, version) ; 
+      return ;
+    } 
+    if (rl->GetAliRun() == 0x0) {
+      rl->LoadgAlice();
+      gAlice = rl->GetAliRun(); // should be removed
     }
-    else 
-      Error("AliEMCALGetter"," Detector EMCAL not found");
   }
-
-  fDebug=0;
+  fgEmcalLoader = dynamic_cast<AliEMCALLoader*>(rl->GetLoader("EMCALLoader"));
+  if ( !fgEmcalLoader ) 
+    Error("AliEMCALGetter", "Could not find EMCALLoader") ; 
+  else 
+    fgEmcalLoader->SetTitle(version);
+  
+  
+  // initialize data members
+  SetDebug(0) ; 
+  //fBTE = 0 ; 
+  fPrimaries = 0 ; 
+  fLoadingStatus = "" ; 
 }
 
 //____________________________________________________________________________ 
-
 AliEMCALGetter::~AliEMCALGetter()
 {
-  if (fPrimaries) {
-    fPrimaries->Delete() ; 
-    delete fPrimaries ; 
-  }
-
-  TFolder * emcalF = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
-  TCollection * folderslist = emcalF->GetListOfFolders() ; 
-  TIter next(folderslist) ; 
-  TFolder * folder = 0 ; 
-
-  while ( (folder = static_cast<TFolder*>(next())) ) 
-    emcalF->Remove(folder) ; 
-
-  if (fFile) { 
-    fFile->Close() ;  
-    delete fFile ; 
-    fFile = 0 ;
-  }
-
-  fgObjGetter = 0 ; 
-}
-
-//____________________________________________________________________________ 
-
-void AliEMCALGetter::CloseFile()
-{
-  delete gAlice ;  
-  gAlice = 0 ; 
-  delete fAlice ; 
-  fAlice = 0 ; 
+  // dtor
+  delete fgEmcalLoader ;
+  fgEmcalLoader = 0 ;
+  //delete fBTE ; 
+  // fBTE = 0 ; 
+  fPrimaries->Delete() ; 
+  delete fPrimaries ; 
 }
 
 //____________________________________________________________________________ 
-
-const TFolder * AliEMCALGetter::Folder(const TString what) const {
-
-  // returns the EMCAL folder required by what
-  // what = hits, sdigits, digits
-
-  if ( what == "hits" ) 
-    return dynamic_cast<const TFolder *>(fHitsFolder->FindObject("EMCAL")) ; 
-  else if ( what == "sdigits" ) 
-    return  dynamic_cast<const TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ; 
-  else if ( what == "digits" ) 
-    return  dynamic_cast<const TFolder *>(fDigitsFolder->FindObject("EMCAL")) ;
-  else {
-    Error("GetFolder","%s illegal option (hits, sdigits, digits) ", what.Data()) ; 
-    return 0 ; 
+AliEMCALClusterizer * AliEMCALGetter::Clusterizer()
+{ 
+  AliEMCALClusterizer * rv ; 
+  rv =  dynamic_cast<AliEMCALClusterizer *>(EmcalLoader()->Reconstructioner()) ;
+  if (!rv) {
+    Event(0, "R") ; 
+    rv =  dynamic_cast<AliEMCALClusterizer*>(EmcalLoader()->Reconstructioner()) ;
   }
+  return rv ; 
 }
 
-//____________________________________________________________________________ 
-
-AliEMCALGetter * AliEMCALGetter::GetInstance()
-{
-  // Returns the pointer of the unique instance already defined
-
-  if ( fgObjGetter ) {
-    return fgObjGetter ;
-  }
-  else {
-    return 0 ;
-  }
-}
 
 //____________________________________________________________________________ 
-
-AliEMCALGetter * AliEMCALGetter::GetInstance(const char* headerFile,
-                                            const char* branchTitle,
-                                            const Bool_t toSplit)
+TClonesArray * AliEMCALGetter::Digits() 
 {
-  // Creates and returns the pointer of the unique instance
-  // Must be called only when the environment has changed 
-
-  if(!fgObjGetter){
-    fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
-    if(fgObjGetter->fFailed)
-      return 0;
-    else
-      return fgObjGetter ;
-  }
-
-  //First checks, if header file already opened
+  // asks the Loader to return the Digits container 
 
-  if(!fgObjGetter->fFile){
-     fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
-    if(fgObjGetter->fFailed)
-      return 0;
-    else
-      return fgObjGetter ;
-  }
+  TClonesArray * rv = 0 ; 
+  rv = EmcalLoader()->Digits() ; 
 
-  if(fgObjGetter->fHeaderFile.CompareTo(headerFile)==0){ //Opened the same header file   
-    if((fgObjGetter->fBranchTitle.CompareTo(branchTitle) == 0)&&   //Open the same branch title
-       (toSplit==fgObjGetter->fToSplit)){                          //Nothing should be cleaned
-    }
-    else{ //Clean all data and AliEMCAL...zers
-      if(fgObjGetter->fToSplit)
-        fgObjGetter->CloseSplitFiles() ;         
-      //fgObjGetter->CleanWhiteBoard() ;
-      fgObjGetter->fToSplit = toSplit ;
-      fgObjGetter->SetTitle(branchTitle) ;
-    }
+  if( !rv ) {
+    EmcalLoader()->MakeDigitsArray() ; 
+    rv = EmcalLoader()->Digits() ;
   }
-  else{  //Close already opened files, clean memory and open new header file
-    if(gAlice){ //should first delete gAlice, then close file
-      //Should be in dtor of EMCAL, but if one changes path ...
-      fgObjGetter->fModuleFolder->Remove(fgObjGetter->fModuleFolder->FindObject("EMCAL")) ; 
-      delete gAlice ;
-    }
-    if(fgObjGetter->fFile){
-      fgObjGetter->fFile->Close() ;
-      fgObjGetter->fFile=0;
-    }
-    if(fgObjGetter->fToSplit)
-      fgObjGetter->CloseSplitFiles() ;
-    fgObjGetter->CleanWhiteBoard() ;    
-    fgObjGetter = new AliEMCALGetter(headerFile,branchTitle,toSplit) ;
-  }
-
-  return fgObjGetter ; 
-
+  return rv ; 
 }
 
 //____________________________________________________________________________ 
-
-const Bool_t AliEMCALGetter::BranchExists(const TString recName) const
-{
-  //Looks in the tree Tree"name" if branch with current name olready exists
-
-  TString filename("") ;
-  TString name, dataname, zername;
-  if(recName == "SDigits"){
-    filename=fSDigitsFileName ;
-    name = "TreeS0" ;
-    dataname = "EMCAL" ;
-    zername = "AliEMCALSDigitizer" ;
-  }
-  else if(recName == "Digits"){
-    filename=fDigitsFileName ;
-    name = "TreeD0" ;
-    dataname = "EMCAL" ;
-    zername = "AliEMCALDigitizer" ;
-  }
-  else if(recName =="RecPoints"){
-       filename=fRecPointsFileName ;
-       name = "TreeR0" ;
-       dataname = "EMCALEmcRP" ;
-       zername = "AliEMCALClusterizer" ;
-  }
-  else if(recName == "TrackSegments"){
-    filename=fTrackSegmentsFileName ;
-    name = "TreeR0" ;
-    dataname = "EMCALTS" ;
-    zername = "AliEMCALTrackSegmentMaker" ;
-  }     
-  else if(recName == "RecParticles"){
-    filename= fRecParticlesFileName ;
-    name = "TreeR0" ;
-    dataname = "EMCALRP" ;
-    zername = "AliEMCALPID" ;
-  }
-  else
-    return kFALSE ;
-
-  TFile * file ;
-  TTree * tree ;
-  if(fToSplit){
-    file = static_cast<TFile*>(gROOT->GetFile(filename.Data() ) ) ;
-    if(!file)
-      file = TFile::Open(fSDigitsFileName.Data(),"update");
-  }
-  else
-    file = fFile ;
-
-  tree = (TTree *)file->Get(name.Data()) ;
-
-  if(!tree ) 
-    return kFALSE ;
-
-  TObjArray * lob = static_cast<TObjArray*>(tree->GetListOfBranches()) ;
-  TIter next(lob) ; 
-  TBranch * branch = 0 ;  
-  TString titleName(fBranchTitle);
-  titleName+=":";
-
-  while ((branch = (static_cast<TBranch*>(next())))) {
-    TString branchName(branch->GetName() ) ; 
-    TString branchTitle(branch->GetTitle() ) ;  
-    if ( branchName.BeginsWith(dataname) && branchTitle.BeginsWith(fBranchTitle) ){  
-      Warning("BranchExists", "branch %s with title %s already exits in %s", dataname.Data(), fBranchTitle.Data(), name.Data());
-      return kTRUE ;
-    }
-
-    if ( branchName.BeginsWith(zername) &&  branchTitle.BeginsWith(titleName) ){
-      Warning("BranchExists","Branch AliEMCAL... with title %s already exits in %s",branch->GetTitle(), name.Data());     
-      return kTRUE ; 
-    }
-  }
-
-    //We can't delete three if gAlice points to it... To be redisigned somehow???!!!
-
-  if(!fToSplit){
-    if(name.Contains("TreeS"))
-      if(tree!=gAlice->TreeS())
-        tree->Delete();
-    if(name.Contains("TreeD"))
-      if(tree!=gAlice->TreeD())
-        tree->Delete();
-    if(name.Contains("TreeR"))
-      if(tree!=gAlice->TreeR())
-        tree->Delete();    
+AliEMCALDigitizer * AliEMCALGetter::Digitizer() 
+{ 
+  AliEMCALDigitizer * rv ; 
+  rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
+  if (!rv) {
+    Event(0, "D") ; 
+    rv =  dynamic_cast<AliEMCALDigitizer *>(EmcalLoader()->Digitizer()) ;
   }
-
-  return kFALSE ;
+  return rv ; 
 }
 
-//____________________________________________________________________________ 
 
-void AliEMCALGetter::ListBranches(Int_t event) const  
+//____________________________________________________________________________ 
+TObjArray * AliEMCALGetter::PRERecPoints() 
 {
-  TBranch * branch = 0 ; 
-  if (gAlice->GetEvent(event) == -1)
-    return ; 
-
-  TTree * t =  gAlice->TreeH() ; 
-
-  if(t){
-    Info("ListBranches"," -> ****** Hits    : "); 
-    TObjArray * lob = t->GetListOfBranches() ;
-    TIter next(lob) ; 
+  // asks the Loader to return the EMC RecPoints container 
 
-    while ( (branch = static_cast<TBranch*>(next())) )
-      Info("ListBranches","         %s", branch->GetName());
-
-  } else 
-    Warning("ListBranches"," -> TreeH not found for event %d",event);  
-
-  t = gAlice->TreeS() ;
-
-  if(t){
-    Info("ListBranches"," -> ****** SDigits : "); 
-    TObjArray * lob = t->GetListOfBranches() ;
-    TIter next(lob) ; 
-
-    while ( (branch = static_cast<TBranch*>(next())) )
-      Info("ListBranches","             %s %s",branch->GetName(),branch->GetTitle()); 
-  } else 
-    Warning("ListBranches"," -> TreeS not found for event %d",event);  
-
-  t = gAlice->TreeD() ;
-
-  if(t){
-    Info("ListBranches"," -> ****** Digits  : "); 
-    TObjArray * lob = t->GetListOfBranches() ;
-    TIter next(lob) ; 
-
-    while ( (branch = static_cast<TBranch*>(next())) )
-      Info("             %s %s", branch->GetName(), branch->GetTitle()); 
-  } else 
-    Warning("ListBranches"," -> TreeD not found for event %d", event);  
-
-  t = gAlice->TreeR() ;
-
-  if(t){
-    Info("ListBranches"," -> ****** Recon   : "); 
-    TObjArray * lob = t->GetListOfBranches() ;
-    TIter next(lob) ; 
-    while ( (branch = static_cast<TBranch*>(next())) )
-      Info("             %s %s", branch->GetName(), branch->GetTitle()); 
-  } else 
-    Warning("ListBranches"," -> TreeR not found for event %d",event);  
+  TObjArray * rv = 0 ; 
+  
+  rv = EmcalLoader()->PRERecPoints() ; 
+  if (!rv) {
+    EmcalLoader()->MakeRecPointsArray() ;
+    rv = EmcalLoader()->PRERecPoints() ; 
+  }
+  return rv ; 
 }
 
 //____________________________________________________________________________ 
-
-void AliEMCALGetter::NewBranch(TString name, Int_t event)  
+TObjArray * AliEMCALGetter::ECARecPoints() 
 {
-  fBranchTitle = fSDigitsTitle = fDigitsTitle = fRecPointsTitle = fTrackSegmentsTitle = fRecParticlesTitle =  name ; 
-  Event(event) ; 
+  // asks the Loader to return the EMC RecPoints container 
+
+  TObjArray * rv = 0 ; 
+  
+  rv = EmcalLoader()->ECARecPoints() ; 
+  if (!rv) {
+    EmcalLoader()->MakeRecPointsArray() ;
+    rv = EmcalLoader()->ECARecPoints() ; 
+  }
+  return rv ; 
 }
 
 //____________________________________________________________________________ 
-
-Bool_t AliEMCALGetter::NewFile(TString name)  
+TObjArray * AliEMCALGetter::HCARecPoints() 
 {
-  fHeaderFile = name ; 
-  fFile->Close() ; 
-  fFailed = kFALSE; 
-
-  fFile = static_cast<TFile*>(gROOT->GetFile(fHeaderFile.Data() ) ) ;
-
-  if(!fFile) {    //if file was not opened yet, read gAlice
-    fFile = TFile::Open(fHeaderFile.Data(),"update") ;
-    if (!fFile->IsOpen()) {
-      Error("NewFile", " -> Cannot open %s", fHeaderFile.Data()); 
-      fFailed = kTRUE ;
-      return fFailed ;  
-    }
-    gAlice = static_cast<AliRun *>(fFile->Get("gAlice")) ;
-  } 
+  // asks the Loader to return the EMC RecPoints container 
 
-  if (!gAlice) {
-    Error("NewFile"," -> Cannot find gAlice in %s", fHeaderFile.Data());
-    fFailed = kTRUE ;
-    return fFailed ; 
+  TObjArray * rv = 0 ; 
+  
+  rv = EmcalLoader()->HCARecPoints() ; 
+  if (!rv) {
+    EmcalLoader()->MakeRecPointsArray() ;
+    rv = EmcalLoader()->HCARecPoints() ; 
   }
-  return fFailed ; 
+  return rv ; 
 }
 
 //____________________________________________________________________________ 
-
-const AliEMCAL * AliEMCALGetter::EMCAL() 
+TClonesArray * AliEMCALGetter::TrackSegments() 
 {
-  // returns the EMCAL object 
-
-  AliEMCAL * emcal = dynamic_cast<AliEMCAL*>(fModuleFolder->FindObject("EMCAL")) ;  
-
-  if (!emcal) 
-    if (fDebug)
-      Warning("EMCAL"," -> EMCAL module not found in Folders" );
-  return emcal ; 
-}  
+  // asks the Loader to return the TrackSegments container 
 
-//____________________________________________________________________________ 
-
-AliEMCALGeometry * AliEMCALGetter::EMCALGeometry() 
-{
-  AliEMCALGeometry * rv = 0 ; 
-  if (EMCAL() )
-    rv =  EMCAL()->GetGeometry() ;
+  TClonesArray * rv = 0 ; 
+  
+  rv = EmcalLoader()->TrackSegments() ; 
+  if (!rv) {
+    EmcalLoader()->MakeTrackSegmentsArray() ;
+    rv = EmcalLoader()->TrackSegments() ; 
+  }
   return rv ; 
-} 
-
-//____________________________________________________________________________ 
-
-const Bool_t AliEMCALGetter::PostPrimaries(void) const 
-{  
-  //------- Primaries ----------------------
-  // the hierarchy is //Folders/RunMC/Event/Data/Primaries
-
-  TFolder * primariesFolder = dynamic_cast<TFolder*>(fPrimariesFolder->FindObject("Primaries")) ; 
-  if ( !primariesFolder ) {
-    if (fDebug) {
-      Warning("PostPrimaries", "-> Folder //%s/Primaries/ not found!", fPrimariesFolder->GetName());
-      Info("PostPrimaries", "-> Adding Folder //%s/Primaries/",fPrimariesFolder->GetName());
-    }
-    primariesFolder = fPrimariesFolder->AddFolder("Primaries", "Primaries particles from TreeK") ; 
-  }    
-
-  TClonesArray *primaries=  new TClonesArray("TParticle",1000) ;
-  primaries->SetName("Primaries") ;
-  primariesFolder->Add(primaries) ; 
-
-  return kTRUE;
-} 
+}
 
 //____________________________________________________________________________ 
-
-TObject** AliEMCALGetter::PrimariesRef(void) const 
-{  
-  //------- Primaries ----------------------
-  // the hierarchy is //Folders/RunMC/Event/Data/Primaries
-
-  if ( !fPrimariesFolder ) {
-    Fatal("PrimariesRef", "-> Folder //%s not found!",fPrimariesFolder);
-  }    
-
-  TFolder * primariesFolder = dynamic_cast<TFolder *>(fPrimariesFolder->FindObject("Primaries")) ;
-
-  if ( !primariesFolder ) {
-    Fatal("PrimariesRef", "-> Folder //%s/Primaries/ not found!",fPrimariesFolder);  
-  }
-
-  TObject * p = primariesFolder->FindObject("Primaries") ;
-
-  if(!p) {
-    Fatal("PrimariesRef", "-> %s/Primaries not found !",primariesFolder->GetName()); 
+AliEMCALTrackSegmentMaker * AliEMCALGetter::TrackSegmentMaker() 
+{ 
+  AliEMCALTrackSegmentMaker * rv ; 
+  rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
+  if (!rv) {
+    Event(0, "T") ; 
+    rv =  dynamic_cast<AliEMCALTrackSegmentMaker *>(EmcalLoader()->TrackSegmentMaker()) ;
   }
-
-  return primariesFolder->GetListOfFolders()->GetObjectRef(p) ;
+  return rv ; 
 }
 
 //____________________________________________________________________________ 
+TClonesArray * AliEMCALGetter::RecParticles() 
+{
+  // asks the Loader to return the TrackSegments container 
 
-const Bool_t AliEMCALGetter::PostHits(void) const 
-{  
-  //------- Hits ----------------------
-  // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
-
-  TFolder * emcalFolder = dynamic_cast<TFolder*>(fHitsFolder->FindObject("EMCAL")) ; 
-
-  if ( !emcalFolder ) {
-    if (fDebug) {
-      Warning("PostHits", "-> Folder //%s/EMCAL/ not found!", fHitsFolder);
-      Info("PostHits", "-> Adding Folder //%s/EMCAL/",fHitsFolder);
-    }
-    emcalFolder = fHitsFolder->AddFolder("EMCAL", "Hits from EMCAL") ; 
-  }    
-
-  TClonesArray *hits=  new TClonesArray("AliEMCALHit",1000) ;
-  hits->SetName("Hits") ;
-  emcalFolder->Add(hits) ; 
-
-  return kTRUE;
-} 
-
-//____________________________________________________________________________ 
-
-TObject ** AliEMCALGetter::HitsRef(void) const 
-{  
-  //------- Hits ----------------------
-  // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/Hits
-
-  if ( !fHitsFolder ) {
-    Error("HitsRef", "-> Folder //%s not found!",fHitsFolder);
-    return 0;
-  }    
-
-  TFolder * emcalFolder = dynamic_cast<TFolder *>(fHitsFolder->FindObject("EMCAL")) ;
-  if ( !emcalFolder ) {
-    Error("HitsRef", "-> Folder //%s/EMCAL/ not found!",fHitsFolder);
-    return 0;
-  }
-
-  TObject * h = emcalFolder->FindObject("Hits") ;
-
-  if(!h) {
-    Error("HitsRef", "-> %s/Hits not found !",emcalFolder->GetName());
-    return 0 ;
+  TClonesArray * rv = 0 ; 
+  
+  rv = EmcalLoader()->RecParticles() ; 
+  if (!rv) {
+    EmcalLoader()->MakeRecParticlesArray() ;
+    rv = EmcalLoader()->RecParticles() ; 
   }
-  else
-    return emcalFolder->GetListOfFolders()->GetObjectRef(h) ;
+  return rv ; 
 }
-
 //____________________________________________________________________________ 
+void AliEMCALGetter::Event(const Int_t event, const char* opt) 
+{
+  // Reads the content of all Tree's S, D and R
 
-const Bool_t AliEMCALGetter::PostSDigits(const char * name, const char * headerFile) const 
-{  
-  //---------- SDigits -------------------------
-  // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/headerFile/sdigitsname
-  // because you can have sdigits from several hit files for mixing
-
-  TFolder * emcalFolder = dynamic_cast<TFolder*>(fSDigitsFolder->FindObject("EMCAL")) ;
-
-  if ( !emcalFolder ) {
-    if (fDebug) {
-      Warning("PostSDigits", "-> Folder //%s/EMCAL/ not found!", fSDigitsFolder);
-      Info("PostSDigits", "-> Adding Folder //%s/EMCAL/",fHitsFolder);
-    }
-    emcalFolder = fSDigitsFolder->AddFolder("EMCAL", "SDigits from EMCAL") ; 
-  }    
-
-  TString subdir(headerFile) ;
-  subdir.ReplaceAll("/", "_") ; 
-  TFolder * emcalSubFolder = dynamic_cast<TFolder*>(emcalFolder->FindObject(subdir)) ; 
-  if ( !emcalSubFolder ) 
-    emcalSubFolder = emcalFolder->AddFolder(subdir, ""); 
-
-  TObject * sd  = emcalSubFolder->FindObject(name); 
-
-  if ( !sd ) {
-    TClonesArray * sdigits = new TClonesArray("AliEMCALDigit",1) ;
-    sdigits->SetName(name) ;
-    emcalSubFolder->Add(sdigits) ;
+  if ( event >= MaxEvent() ) {
+    Error("Event", "%d not found in TreeE !", event) ; 
+    return ; 
   }
 
-  return kTRUE;
-} 
-
-//____________________________________________________________________________ 
+  AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
 
-TObject ** AliEMCALGetter::SDigitsRef(const char * name, const char * file) const 
-{  
-  //------- SDigits ----------------------
-  // the hierarchy is //Folders/RunMC/Event/Data/EMCAL/SDigits/filename/SDigits
+  // checks if we are dealing with test-beam data
+//   TBranch * btb = rl->TreeE()->GetBranch("AliEMCALBeamTestEvent") ;
+//   if(btb){
+//     if(!fBTE)
+//       fBTE = new AliEMCALBeamTestEvent() ;
+//     btb->SetAddress(&fBTE) ;
+//     btb->GetEntry(event) ;
+//   }
+//   else{
+//     if(fBTE){
+//       delete fBTE ;
+//       fBTE = 0 ;
+//     }
+//   }
 
-  if ( !fSDigitsFolder ) {
-    Fatal("SDigitsRef", "-> Folder //%s not found!", fSDigitsFolder);
-  }    
+  // Loads the type of object(s) requested
+  
+  rl->GetEvent(event) ;
 
-  TFolder * emcalFolder = dynamic_cast<TFolder *>(fSDigitsFolder->FindObject("EMCAL")) ;
+  if( strstr(opt,"X") || (strcmp(opt,"")==0) )
+    ReadPrimaries() ;
 
-  if ( !emcalFolder ) {
-    Fatal("SDigitsRef", "-> Folder //%s/EMCAL/ not found!", fSDigitsFolder);
-  }
+  if(strstr(opt,"H") )
+    ReadTreeH();
 
-  TFolder * emcalSubFolder = 0 ;
+  if(strstr(opt,"S") )
+    ReadTreeS() ;
 
-  if(file)
-    emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(file)) ;
-  else
-    emcalSubFolder = dynamic_cast<TFolder *>(emcalFolder->FindObject(fHeaderFile)) ;
+  if( strstr(opt,"D") )
+    ReadTreeD() ;
 
-  if(!emcalSubFolder) {
-    Fatal("SDigitsRef", "-> Folder //Folders/RunMC/Event/Data/EMCAL/%s not found!", file);
-  }
+  if( strstr(opt,"R") )
+    ReadTreeR() ;
 
-  TObject * dis = emcalSubFolder->FindObject(name) ;
+  if( strstr(opt,"T") )
+    ReadTreeT() ;
 
-  if(!dis) {
-    Fatal("SDigitsRef", "-> object %s not found!", name);
-  }
+  if( strstr(opt,"P") )
+    ReadTreeP() ;
 
-  return emcalSubFolder->GetListOfFolders()->GetObjectRef(dis) ;
+//   if( strstr(opt,"Q") )
+//     ReadTreeQA() ;
 }
 
-//____________________________________________________________________________ 
-
-const Bool_t AliEMCALGetter::PostSDigitizer(AliEMCALSDigitizer * sdigitizer) const 
-{  
-  //---------- SDigitizer -------------------------
-  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
-
-  TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
-
-  if ( !sd ) {
-    Error("PostSDigitizer", "-> Task //%s/SDigitizer not found!",fTasksFolder);
-    return kFALSE ;
-  }        
-
-  TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
-
-  if ( !emcal )  {
-    if (fDebug) {
-      Warning("PostSDigitizer", "->//%s/SDigitizer/EMCAL/ not found!",fTasksFolder);
-      Info("PostSDigitizer", "-> Adding //%s/SDigitizer/EMCAL/", fTasksFolder);
-    }
-    emcal = new TTask("EMCAL", "") ; 
-    sd->Add(emcal) ; 
-  } 
-
-  AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdigitizer->GetName() )); 
-
-  if (emcalsd) { 
-    if (fDebug)
-      Info("PostSDigitizer", "-> Task %s already exists",sdigitizer->GetName());
-    emcal->GetListOfTasks()->Remove(emcalsd) ;
-  }
-
-  emcal->Add(sdigitizer) ;     
-
-  return kTRUE; 
-}
 
 //____________________________________________________________________________ 
-
-TObject ** AliEMCALGetter::SDigitizerRef(const char * name) const 
-{  
-  TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
-
-  if ( !sd ) {
-    Fatal("SDigitizerRef", "-> Task //%s/SDigitizer not found!", fTasksFolder);
-  }        
-
-  TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
-
-  if ( !emcal )  {
-    Fatal("SDigitizerRef", "->  //%s/SDigitizer/EMCAL not found!", fTasksFolder);
-  }        
-
-  TTask * task = dynamic_cast<TTask*>(emcal->GetListOfTasks()->FindObject(name)) ; 
-
-  return emcal->GetListOfTasks()->GetObjectRef(task) ;
+Int_t AliEMCALGetter::EventNumber() const
+  {
+  // return the current event number
+  AliRunLoader * rl = AliRunLoader::GetRunLoader(EmcalLoader()->GetTitle());
+  return static_cast<Int_t>(rl->GetEventNumber()) ;   
 }
 
 //____________________________________________________________________________ 
-
-const Bool_t AliEMCALGetter::PostSDigitizer(const char * name, const char * file) const 
-{  
-  //---------- SDigitizer -------------------------
-  // the hierarchy is //Folders/Tasks/SDigitizer/EMCAL/sdigitsname
-
-  TTask * sd  = dynamic_cast<TTask*>(fTasksFolder->FindObject("SDigitizer")) ; 
-
-  if ( !sd ) {
-    Error("PostSDigitizer", "-> Task //%s/SDigitizer not found!", fTasksFolder);
-    return kFALSE ;
-  }        
-
-  TTask * emcal = dynamic_cast<TTask*>(sd->GetListOfTasks()->FindObject("EMCAL")) ; 
-
-  if ( !emcal )  {
-    if (fDebug) {
-      Warning("PostSDigitizer", "->  //%s/SDigitizer/EMCAL/ not found!", fTasksFolder);
-
-      Info("PostSDigitizer", "-> Adding  //%s/SDigitizer/EMCAL", fTasksFolder);
-
-    }
-    emcal = new TTask("EMCAL", "") ; 
-    sd->Add(emcal) ; 
-  } 
-
-  TString sdname(name) ;
-  sdname.Append(":") ;
-  sdname.Append(file);
-  sdname.ReplaceAll("/","_") ; 
-  AliEMCALSDigitizer * emcalsd  = dynamic_cast<AliEMCALSDigitizer *>(emcal->GetListOfTasks()->FindObject( sdname )); 
-
-  if (!emcalsd) {
-    emcalsd = new AliEMCALSDigitizer() ;  
-
-    //Note, we can not call constructor with parameters: it will call Getter and screw up everething
-
-    emcalsd->SetName(sdname) ;
-    emcalsd->SetTitle(file) ;
-    emcal->Add(emcalsd) ;