X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ZDC%2FAliZDC.cxx;h=6ee09dd5ce45a9900b8d497c3ad72a53dea2ef2e;hb=55739e9e30060ffc10a60a2ecdf96e7681303b2a;hp=f09fd3aca805ed60f9378addb7f03ddde728899e;hpb=92e95964b6bb1f3c91245eca544746348a6bf23b;p=u%2Fmrichter%2FAliRoot.git diff --git a/ZDC/AliZDC.cxx b/ZDC/AliZDC.cxx index f09fd3aca80..6ee09dd5ce4 100644 --- a/ZDC/AliZDC.cxx +++ b/ZDC/AliZDC.cxx @@ -13,77 +13,7 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -/* -$Log$ -Revision 1.28 2002/02/04 09:18:08 coppedis -Merging and reconstruction code review - -Revision 1.26.2.2 2001/11/12 18:41:44 hristov -All the changes from the head are merged to the release - -Revision 1.27 2001/10/21 18:27:45 hristov -Several pointers were set to zero in the default constructors to avoid memory management problems - -Revision 1.26 2001/10/04 14:30:28 coppedis -Event merging for ZDC - -Revision 1.25 2001/10/04 14:24:15 coppedis -Event merging for ZDC - -Revision 1.24 2001/09/26 16:03:41 coppedis -Merging implemented - -Revision 1.23 2001/05/15 13:44:57 coppedis -Changes in AddHit method - -Revision 1.22 2001/05/14 09:53:32 coppedis -Adding functions ZMin and ZMax - -Revision 1.21 2001/04/20 10:05:02 coppedis -Minor changes - -Revision 1.20 2001/03/26 13:39:20 coppedis -Comment prints - -Revision 1.19 2001/03/26 09:10:23 coppedis -Corrected bug in constructor (fIshunt has to be =1) - -Revision 1.18 2001/03/20 08:21:55 coppedis -ZDC needs PIPE, ABSO, DIPO and SHIL - -Revision 1.17 2001/03/16 16:18:03 coppedis -Correction for superposition of ZDC volumes with MUON arm one - -Revision 1.16 2001/03/15 16:01:11 coppedis -Code review - -Revision 1.15 2001/01/26 19:56:27 hristov -Major upgrade of AliRoot code - -Revision 1.14 2000/12/12 13:17:01 coppedis -Minor corrections suggested by P. Hristov - -Revision 1.12 2000/12/01 08:19:01 coppedis -Adding a message error if ZDC is constructed without DIPO - -Revision 1.11 2000/11/30 17:21:03 coppedis -Introduce hit array fStHits reset only at the end of the event (for digitization) - -Revision 1.10 2000/11/22 11:32:58 coppedis -Major code revision - -Revision 1.9 2000/10/02 21:28:20 fca -Removal of useless dependecies via forward declarations - -Revision 1.8 2000/07/10 13:58:01 fca -New version of ZDC from E.Scomparin & C.Oppedisano - -Revision 1.7 2000/01/19 17:17:40 fca - -Revision 1.6 1999/09/29 09:24:35 fca -Introduction of the Copyright and cvs Log - -*/ +/* $Id$ */ /////////////////////////////////////////////////////////////////////////////// // // @@ -94,89 +24,85 @@ Introduction of the Copyright and cvs Log // // /////////////////////////////////////////////////////////////////////////////// -#include -#include - // --- ROOT system #include -#include +#include #include -#include +#include #include -#include -#include +#include +#include +#include // --- AliRoot header files +#include "AliDetector.h" +#include "AliRawDataHeaderSim.h" +#include "AliRawReader.h" +#include "AliLoader.h" +#include "AliRun.h" +#include "AliMC.h" +#include "AliLog.h" +#include "AliDAQ.h" #include "AliZDC.h" #include "AliZDCHit.h" -#include "AliZDCMergedHit.h" -#include "AliZDCMerger.h" +#include "AliZDCSDigit.h" #include "AliZDCDigit.h" -#include "AliZDCReco.h" -#include "AliDetector.h" -#include "AliCallf77.h" -#include "AliConst.h" -#include "AliMC.h" -#include "AliRun.h" -#include "AliHeader.h" +#include "AliZDCDigitizer.h" +#include "AliZDCRawStream.h" +#include "AliZDCPedestals.h" +#include "AliZDCCalib.h" +#include "AliFstream.h" ClassImp(AliZDC) - + //_____________________________________________________________________________ -AliZDC::AliZDC() +AliZDC::AliZDC() : + AliDetector(), + fNoShower(0), + fPedCalib(0), + fCalibData(0), + fZDCCalibFName("") { // // Default constructor for the Zero Degree Calorimeter base class // - fIshunt = 1; - fNoShower = 0; - fMerger = new AliZDCMerger(); - - fHits = 0; - fNhits = 0; - - fDigits = 0; - fNdigits = 0; - - fMergedHits = 0; - fTreeSD = 0; - fTreeMD = 0; - - fNRecPoints = 0; - fRecPoints = 0; + fIshunt = 1; + fNhits = 0; + fHits = 0; + fDigits = 0; + fNdigits = 0; } //_____________________________________________________________________________ -AliZDC::AliZDC(const char *name, const char *title) - : AliDetector(name,title) +AliZDC::AliZDC(const char *name, const char *title) : + AliDetector(name,title), + fNoShower (0), + fPedCalib(0), + fCalibData(0), + fZDCCalibFName("") { // // Standard constructor for the Zero Degree Calorimeter base class // - - fIshunt = 1; - fNoShower = 0; - fMerger = 0; - - // Allocate the hits array - fHits = new TClonesArray("AliZDCHit",1000); - gAlice->AddHitList(fHits); - // Allocate the merged hits array - fMergedHits = new TClonesArray("AliZDCMergedHit",1000); - - // Allocate the digits array - fDigits = new TClonesArray("AliZDCDigit",1000); + + fIshunt = 1; + fNhits = 0; + fDigits = 0; + fNdigits = 0; + + fHits = new TClonesArray("AliZDCHit",1000); + gAlice->GetMCApp()->AddHitList(fHits); - fTreeSD = 0; - fTreeMD = 0; - - fNRecPoints = 0; - fRecPoints = 0; + char sensname[5],senstitle[25]; + sprintf(sensname,"ZDC"); + sprintf(senstitle,"ZDC dummy"); + SetName(sensname); SetTitle(senstitle); } + //____________________________________________________________________________ AliZDC::~AliZDC() { @@ -184,21 +110,35 @@ AliZDC::~AliZDC() // ZDC destructor // - fIshunt = 0; - - if(fMerger) delete fMerger; + fIshunt = 0; + delete fPedCalib; + delete fCalibData; -// if(fHits){ -// fHits->Delete(); -// delete fHits; -// } +} -// if(fDigits){ -// fDigits->Delete(); -// delete fDigits; -// } +//_____________________________________________________________________________ +AliZDC::AliZDC(const AliZDC& ZDC) : +AliDetector("ZDC","ZDC"), +fNoShower(ZDC.fNoShower), +fPedCalib(ZDC.fPedCalib), +fCalibData(ZDC.fCalibData), +fZDCCalibFName(ZDC.fZDCCalibFName) +{ + // copy constructor +} +//_____________________________________________________________________________ +AliZDC& AliZDC::operator=(const AliZDC& ZDC) +{ + // assignement operator + if(this!=&ZDC){ + fNoShower = ZDC.fNoShower; + fPedCalib = ZDC.fPedCalib; + fCalibData = ZDC.fCalibData; + fZDCCalibFName = ZDC.fZDCCalibFName; + } return *this; } + //_____________________________________________________________________________ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits) { @@ -210,7 +150,8 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits) // obtain digits at the end of each event // - static Float_t primKinEn, xImpact, yImpact, sFlag; + static Float_t primKinEn=0., xImpact=0., yImpact=0., sFlag=0.; + static Int_t pcPDGcode; AliZDCHit *newquad, *curprimquad; newquad = new AliZDCHit(fIshunt, track, vol, hits); @@ -218,24 +159,26 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits) if(fNhits==0){ // First hit -> setting flag for primary or secondary particle - Int_t primary = gAlice->GetPrimary(track); + Int_t primary = gAlice->GetMCApp()->GetPrimary(track); + // if(track != primary){ - newquad->fSFlag = 1; // SECONDARY particle entering the ZDC + newquad->SetSFlag(1); // SECONDARY particle entering the ZDC } else if(track == primary){ - newquad->fSFlag = 0; // PRIMARY particle entering the ZDC + newquad->SetSFlag(0); // PRIMARY particle entering the ZDC } -// fNPrimaryHits += 1; - sFlag = newquad->fSFlag; - primKinEn = newquad->fPrimKinEn; - xImpact = newquad->fXImpact; - yImpact = newquad->fYImpact; + sFlag = newquad->GetSFlag(); + primKinEn = newquad->GetPrimKinEn(); + xImpact = newquad->GetXImpact(); + yImpact = newquad->GetYImpact(); + pcPDGcode = newquad->GetPDGCode(); } else{ - newquad->fPrimKinEn = primKinEn; - newquad->fXImpact = xImpact; - newquad->fYImpact = yImpact; - newquad->fSFlag = sFlag; + newquad->SetPrimKinEn(primKinEn); + newquad->SetXImpact(xImpact); + newquad->SetYImpact(yImpact); + newquad->SetSFlag(sFlag); + newquad->SetPDGCode(pcPDGcode); } Int_t j; @@ -244,32 +187,34 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits) curprimquad = (AliZDCHit*) lhits[j]; if(*curprimquad == *newquad){ *curprimquad = *curprimquad+*newquad; + // CH. debug + /*if(newquad->GetEnergy() != 0. || newquad->GetLightPMC() != 0. || + newquad->GetLightPMQ() != 0.){ + printf("\n\t --- Equal hits found\n"); + curprimquad->Print(""); + newquad->Print(""); + printf("\t --- Det. %d, Quad. %d: X = %f, E = %f, LightPMC = %f, LightPMQ = %f\n", + curprimquad->GetVolume(0),curprimquad->GetVolume(1),curprimquad->GetXImpact(), + curprimquad->GetEnergy(), curprimquad->GetLightPMC(), curprimquad->GetLightPMQ()); + }*/ + // delete newquad; return; } } //Otherwise create a new hit - new(lhits[fNhits]) AliZDCHit(newquad); + new(lhits[fNhits]) AliZDCHit(*newquad); fNhits++; - + // CH. debug + /*printf("\n\t New ZDC hit added! fNhits = %d\n", fNhits); + printf("\t Det. %d, Quad.t %d: X = %f, E = %f, LightPMC = %f, LightPMQ = %f\n", + newquad->GetVolume(0),newquad->GetVolume(1),newquad->GetXImpact(), + newquad->GetEnergy(), newquad->GetLightPMC(), newquad->GetLightPMQ()); + */ delete newquad; } -//_____________________________________________________________________________ -void AliZDC::AddDigit(Int_t *sect, Int_t digit) -{ -// - AliZDCDigit *newdigit; - newdigit = new AliZDCDigit(sect, digit); - -// printf("\n AddDigit -> sector[0] = %d, sector[1] = %d, digit = %d", -// sect[0], sect[1], digit); - new((*fDigits)[fNdigits]) AliZDCDigit(*newdigit); - fNdigits++; - delete newdigit; -} - //_____________________________________________________________________________ void AliZDC::BuildGeometry() { @@ -287,40 +232,30 @@ void AliZDC::BuildGeometry() top=gAlice->GetGeometry()->GetNode("alice"); // ZDC - brik = new TBRIK("S_ZDC","ZDC box","void",300,300,5); - top->cd(); - node = new TNode("ZDC","ZDC","S_ZDC",0,0,600,""); - node->SetLineColor(kColorZDC); - fNodes->Add(node); -} - -//_____________________________________________________________________________ -Int_t AliZDC::DistancetoPrimitive(Int_t , Int_t ) -{ - // - // Distance from the mouse to the Zero Degree Calorimeter - // Dummy routine - // - return 9999; + brik = new TBRIK("S_ZDC","ZDC box","void",300,300,5); + top->cd(); + node = new TNode("ZDC","ZDC","S_ZDC",0,0,600,""); + node->SetLineColor(kColorZDC); + fNodes->Add(node); } //____________________________________________________________________________ Float_t AliZDC::ZMin(void) const { // Minimum dimension of the ZDC module in z - return 11600.; + return -11600.; } //____________________________________________________________________________ Float_t AliZDC::ZMax(void) const { // Maximum dimension of the ZDC module in z - return 11750.; + return -11750.; } //_____________________________________________________________________________ - void AliZDC::MakeBranch(Option_t *opt, const char *file) +void AliZDC::MakeBranch(Option_t *opt) { // // Create Tree branches for the ZDC @@ -328,473 +263,538 @@ Float_t AliZDC::ZMax(void) const char branchname[10]; sprintf(branchname,"%s",GetName()); - - AliDetector::MakeBranch(opt); - - const char *cS = strstr(opt,"S"); - - if (gAlice->TreeS() && cS) { - if(fMergedHits!=0) fMergedHits->Clear(); - else fMergedHits = new TClonesArray ("AliZDCMergedHit",1000); - MakeBranchInTree(gAlice->TreeS(), - branchname, &fMergedHits, fBufferSize, file) ; - printf("* AliZDC::MakeBranch * Making Branch %s for SDigits\n\n",branchname); - } - - - const char *cD = strstr(opt,"D"); - - if (gAlice->TreeD() && cD) { - if(fDigits!=0) fDigits->Clear(); - else fDigits = new TClonesArray ("AliZDCDigit",1000); - MakeBranchInTree(gAlice->TreeD(), - branchname, &fDigits, fBufferSize, file) ; - printf("* AliZDC::MakeBranch * Making Branch %s for Digits\n\n",branchname); - } + const char *cH = strstr(opt,"H"); - const char *cR = strstr(opt,"R"); - - if (gAlice->TreeR() && cR) { - MakeBranchInTree(gAlice->TreeR(), - branchname, &fRecPoints, fBufferSize, file) ; - printf("* AliZDC::MakeBranch * Making Branch %s for RecPoints\n\n",branchname); } - -} - -//_____________________________________________________________________________ - void AliZDC::MakeBranchInTreeSD(TTree *treeSD, const char *file) -{ - // MakeBranchInTree - const Int_t kBufferSize = 4000; - char branchname[20]; - sprintf(branchname,"%s",GetName()); - MakeBranchInTree(treeSD, branchname, &fMergedHits, kBufferSize, file) ; - printf("* AliZDC::MakeBranch * Making Branch %s for SDigits\n\n",branchname); - -} -//_____________________________________________________________________________ - void AliZDC::MakeBranchInTreeD(TTree *treeD, const char *file) -{ - // MakeBranchInTree - const Int_t kBufferSize = 4000; - char branchname[20]; - sprintf(branchname,"%s",GetName()); - MakeBranchInTree(treeD, branchname, &fDigits, kBufferSize, file) ; - printf("* AliZDC::MakeBranch * Making Branch %s for Digits\n\n",branchname); - + if(cH && fLoader->TreeH()) + fHits = new TClonesArray("AliZDCHit",1000); + + AliDetector::MakeBranch(opt); } -//_____________________________________________________________________________ - void AliZDC::MakeBranchInTreeR(TTree *treeR, const char *file) -{ - // MakeBranchInTree - const Int_t kBufferSize = 4000; - char branchname[20]; - sprintf(branchname,"%s",GetName()); - MakeBranchInTree(treeR, branchname, &fRecPoints, kBufferSize, file) ; - printf("* AliZDC::MakeBranch * Making Branch %s for RecPoints\n\n",branchname); -} //_____________________________________________________________________________ void AliZDC::Hits2SDigits() { - printf("\n Entering AliZDC::SDigits2Digits() "); + // Create summable digits from hits - //---------------------------------------------------------------- - if(!fMerger){ - printf(" ZDC digitization (without merging)\n"); - - AliZDCMergedHit *MHit; - Int_t j, sector[2]; - Float_t MHits[7]; - fNMergedhits = 0; - - TTree *treeH = gAlice->TreeH(); - Int_t ntracks = (Int_t) treeH->GetEntries(); - gAlice->ResetHits(); + AliDebug(1,"\n Entering AliZDC::Hits2SDigits() "); + fLoader->LoadHits("read"); + fLoader->LoadSDigits("recreate"); + AliRunLoader* runLoader = fLoader->GetRunLoader(); + AliZDCSDigit sdigit; + AliZDCSDigit* psdigit = &sdigit; + + // Event loop + for(Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) { + Float_t pmCZNC=0, pmCZPC=0, pmCZNA=0, pmCZPA=0, pmZEM1 = 0, pmZEM2 = 0; + Float_t pmQZNC[4], pmQZPC[4], pmQZNA[4], pmQZPA[4]; + for(Int_t i = 0; i < 4; i++) pmQZNC[i] = pmQZPC[i] = pmQZNA[i] = pmQZPA[i] = 0; + + runLoader->GetEvent(iEvent); + TTree* treeH = fLoader->TreeH(); + Int_t ntracks = (Int_t) treeH->GetEntries(); + ResetHits(); + // Tracks loop - for(Int_t itrack=0; itrackGetEvent(itrack); - for(AliZDCHit* zdcHit=(AliZDCHit*)this->FirstHit(-1); zdcHit; - zdcHit = (AliZDCHit*)this->NextHit()){ + Int_t sector[2]; + for(Int_t itrack = 0; itrack < ntracks; itrack++) { + treeH->GetEntry(itrack); + for(AliZDCHit* zdcHit = (AliZDCHit*)FirstHit(-1); zdcHit; + zdcHit = (AliZDCHit*)NextHit()) { - for(j=0; j<2; j++) sector[j] = zdcHit->GetVolume(j); - MHits[0] = zdcHit->GetPrimKinEn(); - MHits[1] = zdcHit->GetXImpact(); - MHits[2] = zdcHit->GetYImpact(); - MHits[3] = zdcHit->GetSFlag(); - MHits[4] = zdcHit->GetLightPMQ(); - MHits[5] = zdcHit->GetLightPMC(); - MHits[6] = zdcHit->GetEnergy(); - }//Hits loop - - MHit = new AliZDCMergedHit(sector, MHits); - new((*fMergedHits)[fNMergedhits]) AliZDCMergedHit(*MHit); - TClonesArray &sdigits = *fMergedHits; - new (sdigits[fNMergedhits]) AliZDCMergedHit(*MHit); - fNMergedhits++; - delete MHit; - } -// printf("\n ### Filling SDigits tree\n"); - gAlice->TreeS()->Fill(); - gAlice->TreeS()->Write(0,TObject::kOverwrite); - gAlice->TreeS()->Reset(); - } - //---------------------------------------------------------------- - else if(fMerger){ - printf(" ZDC merging and digitization\n"); - // ### Initialise merging - fMerger -> InitMerging(); - - TFile *bgrFile = fMerger->BgrFile(); - bgrFile->cd(); - - // SDigits tree - Int_t fNEvBgr = fMerger->EvNum(); - char treeSDBgrName[20]; - sprintf(treeSDBgrName,"TreeS%d",fNEvBgr); - fTreeSD = (TTree*)gDirectory->Get(treeSDBgrName); // TreeH - if(!fTreeSD){ - printf("\n ERROR -> Can't find TreeS%d in background file\n",fNEvBgr); - } - // Branch address - char branchSDname[20]; - sprintf(branchSDname,"%s",GetName()); - if(fTreeSD && fMergedHits){ - TBranch *branchSD = fTreeSD->GetBranch(branchSDname); - if(branchSD) branchSD->SetAddress(&fMergedHits); - else if(!branchSD) MakeBranchInTreeSD(fTreeSD); + sector[0] = zdcHit->GetVolume(0); + sector[1] = zdcHit->GetVolume(1); + if((sector[1] < 1) || (sector[1] > 5)) { + Error("Hits2SDigits", "sector[0] = %d, sector[1] = %d", + sector[0], sector[1]); + continue; + } + Float_t lightQ = zdcHit->GetLightPMQ(); + Float_t lightC = zdcHit->GetLightPMC(); + + if(sector[0] == 1) { //ZNC + pmCZNC += lightC; + pmQZNC[sector[1]-1] += lightQ; + } + else if(sector[0] == 2) { //ZPC + pmCZPC += lightC; + pmQZPC[sector[1]-1] += lightQ; + } + else if(sector[0] == 3) { //ZEM + if(sector[1] == 1) pmZEM1 += lightC; + else pmZEM2 += lightQ; + } + if(sector[0] == 4) { //ZNA + pmCZNA += lightC; + pmQZNA[sector[1]-1] += lightQ; + } + else if(sector[0] == 5) { //ZPA + pmCZPA += lightC; + pmQZPA[sector[1]-1] += lightQ; + } + }//Hits loop } - // ### Get TCA of MergedHits from AliZDCMerger - fMergedHits = fMerger->MergedHits(); - fNMergedhits = fMerger->GetNMhits(); -// printf("\n fNMergedhits (from AliZDCMerger) = %d\n", fNMergedhits); - AliZDCMergedHit *MHit; - TClonesArray &sdigits = *fMergedHits; - Int_t imhit; - //Merged Hits loop - for(imhit=0; imhitUncheckedAt(imhit); - new (sdigits[imhit]) AliZDCMergedHit(*MHit); + // create the output tree + fLoader->MakeTree("S"); + TTree* treeS = fLoader->TreeS(); + const Int_t kBufferSize = 4000; + treeS->Branch(GetName(), "AliZDCSDigit", &psdigit, kBufferSize); + + // Create sdigits for ZNC + sector[0] = 1; // Detector = ZNC + sector[1] = 0; // Common PM ADC + new(psdigit) AliZDCSDigit(sector, pmCZNC); + if(pmCZNC > 0) treeS->Fill(); + for(Int_t j = 0; j < 4; j++) { + sector[1] = j+1; // Towers PM ADCs + new(psdigit) AliZDCSDigit(sector, pmQZNC[j]); + if(pmQZNC[j] > 0) treeS->Fill(); } - -// printf("\n ### Filling SDigits tree\n"); - bgrFile->cd(); - fTreeSD->Fill(); - fTreeSD->Write(0,TObject::kOverwrite); - } -} + // Create sdigits for ZPC + sector[0] = 2; // Detector = ZPC + sector[1] = 0; // Common PM ADC + new(psdigit) AliZDCSDigit(sector, pmCZPC); + if(pmCZPC > 0) treeS->Fill(); + for(Int_t j = 0; j < 4; j++) { + sector[1] = j+1; // Towers PM ADCs + new(psdigit) AliZDCSDigit(sector, pmQZPC[j]); + if(pmQZPC[j] > 0) treeS->Fill(); + } -//_____________________________________________________________________________ -void AliZDC::SDigits2Digits() -{ - //printf("\n Entering AliZDC::SDigits2Digits() "); - if(!fMerger){ // Only digitization - printf(" ZDC digitization (without merging) \n"); - fMerger = new AliZDCMerger(); - fMerger->Digitize(fNMergedhits, fMergedHits); - - char hname[30]; - sprintf(hname,"TreeD%d",gAlice->GetHeader()->GetEvent()); - gAlice->TreeD()->Fill(); - gAlice->TreeD()->Write(0,TObject::kOverwrite); - gAlice->TreeD()->Reset(); - } - else if(fMerger){ // Merging and digitization - printf(" ZDC merging and digitization\n"); - fMerger->Digitize(fNMergedhits, fMergedHits); - - TFile *bgrFile = fMerger->BgrFile(); - bgrFile->cd(); - // Digits tree - Int_t fNEvBgr = fMerger->EvNum(); - //printf(" fNEvBgr = %d\n",fNEvBgr); - char treeDBgrName[20]; - sprintf(treeDBgrName,"TreeD%d",fNEvBgr); - fTreeMD = (TTree*)gDirectory->Get(treeDBgrName); // TreeH - if(!fTreeMD){ - printf("\n ERROR -> Can't find TreeD%d in background file\n",fNEvBgr); - } - // Branch address - char branchDname[20]; - sprintf(branchDname,"%s",GetName()); - if(fTreeMD && fDigits){ -// printf("\n fTreeMD!=0 && fDigits!=0\n"); - TBranch *branchD = fTreeMD->GetBranch(branchDname); - if(branchD) branchD->SetAddress(&fDigits); - else if(!branchD) MakeBranchInTreeD(fTreeMD); + // Create sdigits for ZEM + sector[0] = 3; + sector[1] = 1; // Detector = ZEM1 + new(psdigit) AliZDCSDigit(sector, pmZEM1); + if(pmZEM1 > 0) treeS->Fill(); + sector[1] = 2; // Detector = ZEM2 + new(psdigit) AliZDCSDigit(sector, pmZEM2); + if(pmZEM2 > 0) treeS->Fill(); + + // Create sdigits for ZNA + sector[0] = 4; // Detector = ZNA + sector[1] = 0; // Common PM ADC + new(psdigit) AliZDCSDigit(sector, pmCZNA); + if(pmCZNA > 0) treeS->Fill(); + for(Int_t j = 0; j < 4; j++) { + sector[1] = j+1; // Towers PM ADCs + new(psdigit) AliZDCSDigit(sector, pmQZNA[j]); + if(pmQZNA[j] > 0) treeS->Fill(); } - - fTreeMD->Fill(); - fTreeMD->Write(0,TObject::kOverwrite); - } - + // Create sdigits for ZPA + sector[0] = 5; // Detector = ZPA + sector[1] = 0; // Common PM ADC + new(psdigit) AliZDCSDigit(sector, pmCZPA); + if(pmCZPA > 0) treeS->Fill(); + for(Int_t j = 0; j < 4; j++) { + sector[1] = j+1; // Towers PM ADCs + new(psdigit) AliZDCSDigit(sector, pmQZPA[j]); + if(pmQZPA[j] > 0) treeS->Fill(); + } + + // write the output tree + fLoader->WriteSDigits("OVERWRITE"); + } + + fLoader->UnloadHits(); + fLoader->UnloadSDigits(); } + //_____________________________________________________________________________ -void AliZDC::Hits2Digits() +AliDigitizer* AliZDC::CreateDigitizer(AliRunDigitizer* manager) const { - gAlice->Hits2SDigits(); - gAlice->SDigits2Digits(); + // Create the digitizer for ZDC + + return new AliZDCDigitizer(manager); } //_____________________________________________________________________________ -void AliZDC::Digits2Reco() +void AliZDC::Digits2Raw() { - //printf("\n Entering AliZDC::Digits2Reco() "); + // Convert ZDC digits to raw data + + // Format: 24 int values -> ZN1(C+Q1-4), ZP1(C+Q1-4), ZEM1, ZEM2, ZN(C+Q1-4), ZP2(C+Q1-4), 2 Ref PMs + // + 24 int values for the corresponding out of time channels + // For the CAEN module V965 we have an Header, the Data Words and an End Of Block + // 12 channels x 2 gain chains read from 1st ADC module + // 12 channels x 2 gain chains read from 2nd ADC module + // 12 channels x 2 gain chains read from 3rd ADC module (o.o.t.) + // 12 channels x 2 gain chains read from 4rth ADC module (o.o.t.) + // + const int knADCData1=24, knADCData2=24; // In principle the 2 numbers can be different! + UInt_t lADCHeader1; + UInt_t lADCHeader2; + UInt_t lADCData1[knADCData1]; + UInt_t lADCData2[knADCData2]; + UInt_t lADCData3[knADCData1]; + UInt_t lADCData4[knADCData2]; + // + UInt_t lADCEndBlock; + + // load the digits + fLoader->LoadDigits("read"); + AliZDCDigit digit; + AliZDCDigit* pdigit = &digit; + TTree* treeD = fLoader->TreeD(); + if(!treeD) return; + treeD->SetBranchAddress("ZDC", &pdigit); + //printf("\t AliZDC::Digits2Raw -> TreeD has %d entries\n",(Int_t) treeD->GetEntries()); + + // Fill data array + // ADC header + UInt_t lADCHeaderGEO = 0; + UInt_t lADCHeaderCRATE = 0; + UInt_t lADCHeaderCNT1 = knADCData1; + UInt_t lADCHeaderCNT2 = knADCData2; - Int_t fNEvBgr = fMerger->EvNum(); - //printf(" fNEvBgr = %d\n",fNEvBgr); - gAlice->GetEvent(fNEvBgr); - - AliDetector *ZDC = gAlice->GetDetector("ZDC"); - TClonesArray *ZDCdigits = ZDC->Digits(); + lADCHeader1 = lADCHeaderGEO << 27 | 0x1 << 25 | lADCHeaderCRATE << 16 | + lADCHeaderCNT1 << 8 ; + lADCHeader2 = lADCHeaderGEO << 27 | 0x1 << 25 | lADCHeaderCRATE << 16 | + lADCHeaderCNT2 << 8 ; + + // ADC data word + UInt_t lADCDataGEO = lADCHeaderGEO; + // + UInt_t lADCDataValue1[knADCData1]; + UInt_t lADCDataValue2[knADCData2]; + UInt_t lADCDataValue3[knADCData1]; + UInt_t lADCDataValue4[knADCData2]; + // + UInt_t lADCDataOvFlw1[knADCData1]; + UInt_t lADCDataOvFlw2[knADCData2]; + UInt_t lADCDataOvFlw3[knADCData1]; + UInt_t lADCDataOvFlw4[knADCData2]; + // + for(Int_t i=0; iGetEntries(); iDigit++){ + treeD->GetEntry(iDigit); + if(!pdigit) continue; + //digit.Print(""); - char tdname[20]; - sprintf(tdname,"TreeD%d",fNEvBgr); - TTree *TD = (TTree*)gDirectory->Get(tdname); - //TTree *TD = gAlice->TreeD(); - if(TD){ - //printf(" TreeD found in gAlice object\n"); - char brname[20]; - sprintf(brname,"%s",ZDC->GetName()); - TBranch *br = TD->GetBranch(brname); - if(br) br->SetAddress(&ZDCdigits); + // *** ADC data + Int_t index=0; + if(digit.GetSector(1)!=5){ // ZDC signal channels + // *** ADC1 (ZN1, ZP1, ZEM1,2) or ADC3 (ZN1, ZP1, ZEM1,2 o.o.t.) + if(digit.GetSector(0)==1 || digit.GetSector(0)==2 || digit.GetSector(0)==3){ + if(digit.GetSector(0)==1 || digit.GetSector(0)==2){ + index = (digit.GetSector(0)-1) + 4*digit.GetSector(1); // ZN1 or ZP1 + lADCDataChannel = 8*(digit.GetSector(0)-1) + digit.GetSector(1); + } + else if(digit.GetSector(0)==3){ // ZEM 1,2 + index = 20 + (digit.GetSector(1)-1); + lADCDataChannel = 5 + 8*(digit.GetSector(1)-1); + } + // + /*printf("\t AliZDC::Digits2Raw -> idig%d det %d quad %d index %d, ADCch %d ADCVal[%d, %d]\n", + iDigit,digit.GetSector(0),digit.GetSector(1),index,lADCDataChannel, + digit.GetADCValue(0),digit.GetADCValue(1));// Ch. debug + */ + // + if(iDigit 2047) lADCDataOvFlw1[index] = 1; + lADCDataValue1[index+2] = digit.GetADCValue(1); // Low gain ADC ch. + if(lADCDataValue1[index+2] > 2047) lADCDataOvFlw1[index+2] = 1; + + lADCData1[index] = lADCDataGEO << 27 | 0x1 << 24 | lADCDataChannel << 17 | + lADCDataOvFlw1[index] << 12 | (lADCDataValue1[index] & 0xfff); + lADCData1[index+2] = lADCDataGEO << 27 | 0x1 << 24 | lADCDataChannel << 17 | 0x1 << 16 | + lADCDataOvFlw1[index+2] << 12 | (lADCDataValue1[index+2] & 0xfff); + } + else{ // *** Out-of-time signals + lADCDataValue3[index] = digit.GetADCValue(0); // High gain ADC ch. + if(lADCDataValue3[index] > 2047) lADCDataOvFlw3[index] = 1; + lADCDataValue3[index+2] = digit.GetADCValue(1); // Low gain ADC ch. + if(lADCDataValue3[index+2] > 2047) lADCDataOvFlw3[index+2] = 1; + + lADCData3[index] = lADCDataGEO << 27 | lADCDataChannel << 17 | + lADCDataOvFlw3[index] << 12 | (lADCDataValue3[index] & 0xfff); + lADCData3[index+2] = lADCDataGEO << 27 | lADCDataChannel << 17 | 0x1 << 16 | + lADCDataOvFlw3[index+2] << 12 | (lADCDataValue3[index+2] & 0xfff); + } + } + // *** ADC2 (ZN2, ZP2) or ADC4 (ZN2, ZP2 o.o.t.) + else if(digit.GetSector(0)==4 || digit.GetSector(0)==5){ + index = (digit.GetSector(0)-4) + 4*digit.GetSector(1); // ZN2 or ZP2 + lADCDataChannel = 8*(digit.GetSector(0)-4) + digit.GetSector(1); + // + /*printf("\t AliZDC::Digits2Raw -> idig%d det %d quad %d index %d, ADCch %d ADCVal[%d, %d]\n", + iDigit,digit.GetSector(0),digit.GetSector(1),index,lADCDataChannel, + digit.GetADCValue(0),digit.GetADCValue(1));// Ch. debug + */ + // + if(iDigit 2047) lADCDataOvFlw2[index] = 1; + lADCDataValue2[index+2] = digit.GetADCValue(1); + if(lADCDataValue2[index+2] > 2047) lADCDataOvFlw2[index+2] = 1; + // + lADCData2[index] = lADCDataGEO << 27 | lADCDataChannel << 17 | + lADCDataOvFlw2[index] << 12 | (lADCDataValue2[index] & 0xfff); + lADCData2[index+2] = lADCDataGEO << 27 | lADCDataChannel << 17 | 0x1 << 16 | + lADCDataOvFlw2[index+2] << 12 | (lADCDataValue2[index+2] & 0xfff); + } + else{ // *** Out-of-time signals + lADCDataValue4[index] = digit.GetADCValue(0); + if(lADCDataValue4[index] > 2047) lADCDataOvFlw4[index] = 1; + lADCDataValue4[index+2] = digit.GetADCValue(1); + if(lADCDataValue4[index+2] > 2047) lADCDataOvFlw4[index+2] = 1; + // + lADCData4[index] = lADCDataGEO << 27 | lADCDataChannel << 17 | + lADCDataOvFlw4[index] << 12 | (lADCDataValue4[index] & 0xfff); + lADCData4[index+2] = lADCDataGEO << 27 | lADCDataChannel << 17 | 0x1 << 16 | + lADCDataOvFlw4[index+2] << 12 | (lADCDataValue4[index+2] & 0xfff); + } + } + } + // *** ADC2 (Reference PTMs) or ADC4 (Reference PTMs o.o.t.) + else if(digit.GetSector(1)==5){ + index = 20 + (digit.GetSector(0)-1)/3; + lADCDataChannel = 5 + 8*(digit.GetSector(0)-1)/3; + // + /*printf("\t AliZDC::Digits2Raw -> idig%d det %d quad %d index %d, ADCch %d ADCVal[%d, %d]\n", + iDigit,digit.GetSector(0),digit.GetSector(1),index,lADCDataChannel, + digit.GetADCValue(0),digit.GetADCValue(1));// Ch. debug + */ + // + if(iDigit 2047) lADCDataOvFlw2[index] = 1; + lADCDataValue2[index+2] = digit.GetADCValue(1); + if(lADCDataValue2[index+2] > 2047) lADCDataOvFlw2[index+2] = 1; + // + lADCData2[index] = lADCDataGEO << 27 | lADCDataChannel << 17 | + lADCDataOvFlw2[index] << 12 | (lADCDataValue2[index] & 0xfff); + lADCData2[index+2] = lADCDataGEO << 27 | lADCDataChannel << 17 | 0x1 << 16 | + lADCDataOvFlw2[index+2] << 12 | (lADCDataValue2[index+2] & 0xfff); + } + else{ // *** Out-of-time signals + lADCDataValue4[index] = digit.GetADCValue(0); + if(lADCDataValue4[index] > 2047) lADCDataOvFlw4[index] = 1; + lADCDataValue4[index+2] = digit.GetADCValue(1); + if(lADCDataValue4[index+2] > 2047) lADCDataOvFlw4[index+2] = 1; + // + lADCData4[index] = lADCDataGEO << 27 | lADCDataChannel << 17 | + lADCDataOvFlw4[index] << 12 | (lADCDataValue4[index] & 0xfff); + lADCData4[index+2] = lADCDataGEO << 27 | lADCDataChannel << 17 | 0x1 << 16 | + lADCDataOvFlw4[index+2] << 12 | (lADCDataValue4[index+2] & 0xfff); + } + + } + if((index<0) || (index>23)) { + Error("Digits2Raw", "sector[0] = %d, sector[1] = %d", + digit.GetSector(0), digit.GetSector(1)); + continue; } - else if(!TD) printf(" ERROR -> TreeD NOT found in gAlice object\n"); - - Int_t nt = (Int_t) (TD->GetEntries()); - //printf("\n #entries in TreeD = %d\n",nt); - gAlice->ResetDigits(); - AliZDCDigit *dig; - Int_t j, idig, ndigits, ZNraw=0, ZPraw=0, ZEMraw=0; - // --- Summing raw ADCs for each detector to obtain total light - for(j=0; jGetEvent(j); - ndigits = ZDCdigits->GetEntries(); - //printf("\n Entry #%d, ndigits = %d",j,ndigits); - ZNraw=0; - ZPraw=0; - ZEMraw=0; - // --- Loop over event digits - for(idig=0; idigUncheckedAt(idig); - if(dig->GetSector(0) == 1) ZNraw += dig->GetADCValue(); - else if(dig->GetSector(0) == 2) ZPraw += dig->GetADCValue(); - else if(dig->GetSector(0) == 3) ZEMraw += dig->GetADCValue(); - } // Digits loop - } // TreeD entries loop - printf("\n --- ZNraw = %d, ZPraw = %d, ZEMraw = %d\n",ZNraw, ZPraw, ZEMraw); - // --- Pedestal subtraction - Int_t ZNcorr, ZPcorr, ZEMcorr, MeanPed=50; - ZNcorr = ZNraw - 5*MeanPed; - ZPcorr = ZPraw - 5*MeanPed; - ZEMcorr = ZEMraw - 2*MeanPed; - if(ZNcorr<0) ZNcorr=0; - if(ZPcorr<0) ZPcorr=0; - if(ZEMcorr<0) ZEMcorr=0; - printf("\n ZNcorr = %d, ZPcorr = %d, ZEMcorr = %d\n",ZNcorr,ZPcorr,ZEMcorr); - - // --- ADCchannel -> photoelectrons - // NB-> PM gain = 10^(5), ADC resolution = 6.4*10^(-7) - Float_t ZNphe, ZPphe, ZEMphe, ConvFactor = 0.064; - ZNphe = ZNcorr/ConvFactor; - ZPphe = ZPcorr/ConvFactor; - ZEMphe = ZEMcorr/ConvFactor; - printf("\n ZNphe = %f, ZPphe = %f, ZEMphe = %f\n",ZNphe, ZPphe, ZEMphe); - - // --- Energy calibration - // Conversion factors for hadronic ZDCs goes from phe yield to TRUE incident - // energy (conversion from GeV to TeV is included); while for EM calos - // conversion is from light yield to detected energy calculated by GEANT - // NB -> ZN and ZP conversion factors are constant since incident spectators - // have all the same energy, ZEM energy is obtained through a fit over the whole - // range of incident particle energies (obtained with full HIJING simulations) - Float_t ZNenergy, ZPenergy, ZEMenergy, ZDCenergy; - Float_t ZNphexTeV=329., ZPphexTeV=369.; - ZNenergy = ZNphe/ZNphexTeV; - ZPenergy = ZPphe/ZPphexTeV; - ZDCenergy = ZNenergy+ZPenergy; - ZEMenergy = -4.81+0.3238*ZEMphe; - if(ZEMenergy<0) ZEMenergy=0; - printf(" ZNenergy = %f TeV, ZPenergy = %f TeV, ZDCenergy = %f GeV, " - "\n ZEMenergy = %f TeV\n", ZNenergy, ZPenergy, - ZDCenergy, ZEMenergy); - - if(ZDCenergy==0) - printf("\n\n ### ATTENZIONE!!! -> ev# %d: ZNenergy = %f TeV, ZPenergy = %f TeV, ZDCenergy = %f GeV, " - " ZEMenergy = %f TeV\n\n", fNEvBgr, ZNenergy, ZPenergy, ZDCenergy, ZEMenergy); - - // --- Number of incident spectator nucleons - Int_t NDetSpecN, NDetSpecP; - NDetSpecN = (Int_t) (ZNenergy/2.760); - NDetSpecP = (Int_t) (ZPenergy/2.760); - printf("\n NDetSpecN = %d, NDetSpecP = %d\n",NDetSpecN, NDetSpecP); - - // --- Number of generated spectator nucleons and impact parameter - // -------------------------------------------------------------------------------------------------- - // [1] ### Results in Chiara's PhD thesis -> 0 0 0 0 0 0 0 0 (EZEMCut+DeltaEZEMSup)){ - NGenSpecN = (Int_t) (fZNCen->Eval(ZNenergy)); - NGenSpecP = (Int_t) (fZPCen->Eval(ZPenergy)); - NGenSpec = (Int_t) (fZDCCen->Eval(ZDCenergy)); - ImpPar = fbCen->Eval(ZDCenergy); - //printf(" fZNCen = %f, fZPCen = %f, fZDCCen = %f\n",fZNCen->Eval(ZNenergy), - // fZPCen->Eval(ZPenergy),fZDCCen->Eval(ZDCenergy)); - } - else if(ZEMenergy < (EZEMCut-DeltaEZEMInf)){ - NGenSpecN = (Int_t) (fZNPer->Eval(ZNenergy)); - NGenSpecP = (Int_t) (fZPPer->Eval(ZPenergy)); - NGenSpec = (Int_t) (fZDCPer->Eval(ZDCenergy)); - ImpPar = fbPer->Eval(ZDCenergy); - //printf(" fZNPer = %f, fZPPer = %f, fZDCPer = %f\n",fZNPer->Eval(ZNenergy), - // fZPPer->Eval(ZPenergy),fZDCPer->Eval(ZDCenergy)); - } - else if(ZEMenergy >= (EZEMCut-DeltaEZEMInf) && ZEMenergy <= (EZEMCut+DeltaEZEMSup)){ - NGenSpecN = (Int_t) (fZEMn->Eval(ZEMenergy)); - NGenSpecP = (Int_t) (fZEMp->Eval(ZEMenergy)); - NGenSpec = (Int_t)(fZEMsp->Eval(ZEMenergy)); - ImpPar = fZEMb->Eval(ZEMenergy); - //printf(" Nspec ZEM = %f, Nspec ZDC = %f\n",fZEMsp->Eval(ZNenergy),fZDCPer->Eval(ZDCenergy)); } - // [1] ### Results in Chiara's PhD thesis -> 0158.5) NGenSpecN = (Int_t) (fZEMn->Eval(ZEMenergy)); - if(ZPenergy>58.91) NGenSpecP = (Int_t) (fZEMp->Eval(ZEMenergy)); - if(ZDCenergy>220.4) NGenSpec = (Int_t)(fZEMsp->Eval(ZEMenergy)); - if(ZDCenergy>225.) ImpPar = fZEMb->Eval(ZEMenergy);*/ - // [2] ### Results from a new production -> 0162.) NGenSpecN = (Int_t) (fZEMn->Eval(ZEMenergy)); - if(ZPenergy>59.75) NGenSpecP = (Int_t) (fZEMp->Eval(ZEMenergy)); - if(ZDCenergy>221.5) NGenSpec = (Int_t)(fZEMsp->Eval(ZEMenergy)); - if(ZDCenergy>220.) ImpPar = fZEMb->Eval(ZEMenergy); - - if(NGenSpecN>125) NGenSpecN=125; - else if(NGenSpecN<0) NGenSpecN=0; - if(NGenSpecP>82) NGenSpecP=82; - else if(NGenSpecP<0) NGenSpecP=0; - if(NGenSpec>207) NGenSpec=207; - else if(NGenSpec<0) NGenSpec=0; - //printf(" NRecSpecN = %d, NRecSpecP = %d, NRecSpec = %d\n",NGenSpecN,NGenSpecP,NGenSpec); - - // --- Number of participants - Int_t NPart, NPartTot; - NPart = 207-NGenSpecN-NGenSpecP; - NPartTot = 207-NGenSpec; - //printf(" ### NPart(ZP+ZN) = %d, NPart(ZDC) = %d, b = %f fm\n",NPart,NPartTot,ImpPar); - printf(" ### NPart = %d, b = %f fm\n",NPartTot,ImpPar); - - // --- Writing RecPoints TCA - // Allocate the RecPoints TCA - fRecPoints = new TClonesArray("AliZDCReco",1000); - AliZDCReco *reco = new AliZDCReco(ZNenergy,ZPenergy,ZDCenergy,ZEMenergy, - NDetSpecN,NDetSpecP,NGenSpecN,NGenSpecP,NGenSpec,NPartTot,ImpPar); - new((*fRecPoints)[fNRecPoints]) AliZDCReco(*reco); - //printf(" fNRecPoints = %d \n",fNRecPoints ); - //fNRecPoints++; - //fRecPoints->Dump(); - delete reco; + // + /* + for(Int_t i=0;iGetEventNrInRun(); + // + lADCEndBlock = lADCEndBlockGEO << 27 | 0x1 << 26 | lADCEndBlockEvCount; + //printf("\t AliZDC::Digits2Raw -> ADCEndBlock = %d\n",lADCEndBlock); + + + // open the output file + char fileName[30]; + strcpy(fileName,AliDAQ::DdlFileName("ZDC",0)); + + AliFstream* file = new AliFstream(fileName); + + // write the DDL data header + AliRawDataHeaderSim header; + header.fSize = sizeof(header) + + sizeof(lADCHeader1) + sizeof(lADCData1) + sizeof(lADCEndBlock) + + sizeof(lADCHeader2) + sizeof(lADCData2) + sizeof(lADCEndBlock) + + sizeof(lADCHeader1) + sizeof(lADCData3) + sizeof(lADCEndBlock) + + sizeof(lADCHeader2) + sizeof(lADCData4) + sizeof(lADCEndBlock); + // + /*printf("sizeof header = %d, ADCHeader1 = %d, ADCData1 = %d, ADCEndBlock = %d\n", + sizeof(header),sizeof(lADCHeader1),sizeof(lADCData1),sizeof(lADCEndBlock)); + printf("sizeof header = %d, ADCHeader2 = %d, ADCData2 = %d, ADCEndBlock = %d\n", + sizeof(header),sizeof(lADCHeader2),sizeof(lADCData2),sizeof(lADCEndBlock)); + */ + // + header.SetAttribute(0); // valid data + file->WriteBuffer((char*)(&header), sizeof(header)); + + // write the raw data and close the file + file->WriteBuffer((char*) &lADCHeader1, sizeof (lADCHeader1)); + file->WriteBuffer((char*)(lADCData1), sizeof(lADCData1)); + file->WriteBuffer((char*) &lADCEndBlock, sizeof(lADCEndBlock)); + file->WriteBuffer((char*) &lADCHeader2, sizeof (lADCHeader2)); + file->WriteBuffer((char*)(lADCData2), sizeof(lADCData2)); + file->WriteBuffer((char*) &lADCEndBlock, sizeof(lADCEndBlock)); + file->WriteBuffer((char*) &lADCHeader1, sizeof (lADCHeader1)); + file->WriteBuffer((char*)(lADCData3), sizeof(lADCData3)); + file->WriteBuffer((char*) &lADCEndBlock, sizeof(lADCEndBlock)); + file->WriteBuffer((char*) &lADCHeader2, sizeof (lADCHeader2)); + file->WriteBuffer((char*)(lADCData4), sizeof(lADCData4)); + file->WriteBuffer((char*) &lADCEndBlock, sizeof(lADCEndBlock)); + delete file; + + // unload the digits + fLoader->UnloadDigits(); +} + +//_____________________________________________________________________________ +Bool_t AliZDC::Raw2SDigits(AliRawReader* rawReader) +{ + // Convert ZDC raw data to Sdigits - // TreeR - TTree *treeR = gAlice->TreeR(); - char tname[20]; - sprintf(tname,"TreeR%d",fNEvBgr); - if(!treeR) printf("\n ERROR -> Can't find TreeR%d in background file\n",fNEvBgr); - // Branch address - char branchRname[20]; - sprintf(branchRname,"%s",GetName()); - if(fRecPoints){ - TBranch *branchR = treeR->GetBranch(branchRname); - if(branchR) branchR->SetAddress(&fRecPoints); - else if(!branchR) MakeBranchInTreeR(treeR); + AliLoader* loader = (gAlice->GetRunLoader())->GetLoader("ZDCLoader"); + if(!loader) { + AliError("no ZDC loader found"); + return kFALSE; } - treeR->Fill(); - treeR->Write(tname,TObject::kOverwrite); - treeR->Reset(); + +// // Event loop + Int_t iEvent = 0; + while(rawReader->NextEvent()){ + (gAlice->GetRunLoader())->GetEvent(iEvent++); + // Create the output digit tree + TTree* treeS = loader->TreeS(); + if(!treeS){ + loader->MakeTree("S"); + treeS = loader->TreeS(); + } + // + AliZDCSDigit sdigit; + AliZDCSDigit* psdigit = &sdigit; + const Int_t kBufferSize = 4000; + treeS->Branch("ZDC", "AliZDCSDigit", &psdigit, kBufferSize); + // + AliZDCRawStream rawStream(rawReader); + Int_t sector[2], resADC, rawADC, corrADC, nPheVal; + Int_t jcount = 0; + while(rawStream.Next()){ + if(rawStream.IsADCDataWord()){ + //For the moment only in-time SDigits are foreseen (1st 48 raw values) + if(jcount < 48){ + for(Int_t j=0; j<2; j++) sector[j] = rawStream.GetSector(j); + rawADC = rawStream.GetADCValue(); + resADC = rawStream.GetADCGain(); + //printf("\t RAw2SDigits raw%d -> RawADC[%d, %d, %d] read\n", + // jcount, sector[0], sector[1], rawADC); + // + corrADC = rawADC - Pedestal(sector[0], sector[1], resADC); + if(corrADC<0) corrADC=0; + nPheVal = ADCch2Phe(sector[0], sector[1], corrADC, resADC); + // + //printf("\t \t -> SDigit[%d, %d, %d] created\n", + // sector[0], sector[1], nPheVal); + // + new(psdigit) AliZDCSDigit(sector, (Float_t) nPheVal); + treeS->Fill(); + jcount++; + } + }//IsADCDataWord + }//rawStream.Next + // write the output tree + fLoader->WriteSDigits("OVERWRITE"); + fLoader->UnloadSDigits(); + }//Event loop + + return kTRUE; } - //_____________________________________________________________________________ -void AliZDC::SetMerger(AliZDCMerger* merger) +Int_t AliZDC::Pedestal(Int_t Det, Int_t Quad, Int_t Res) const { -// Set pointer to merger - fMerger = merger; + // Returns a pedestal for detector det, PM quad, channel with res. + // + // Getting calibration object for ZDC set + AliCDBManager *man = AliCDBManager::Instance(); + AliCDBEntry *entry = man->Get("ZDC/Calib/Pedestals"); + AliZDCPedestals *calibPed = (AliZDCPedestals*) entry->GetObject(); + // + if(!calibPed){ + printf("\t No calibration object found for ZDC!"); + return -1; + } + // + Int_t index=0, kNch=24; + if(Quad!=5){ + if(Det==1) index = Quad+kNch*Res; // ZN1 + else if(Det==2) index = Quad+5+kNch*Res; // ZP1 + else if(Det==3) index = Quad+9+kNch*Res; // ZEM + else if(Det==4) index = Quad+12+kNch*Res; // ZN2 + else if(Det==5) index = Quad+17+kNch*Res; // ZP2 + } + else index = (Det-1)/3+22+kNch*Res; // Reference PMs + // + // + Float_t meanPed = calibPed->GetMeanPed(index); + Float_t pedWidth = calibPed->GetMeanPedWidth(index); + Float_t pedValue = gRandom->Gaus(meanPed,pedWidth); + // + //printf("\t AliZDC::Pedestal - det(%d, %d) - Ped[%d] = %d\n",Det, Quad, index,(Int_t) pedValue); // Chiara debugging! + + + + return (Int_t) pedValue; } + //_____________________________________________________________________________ -AliZDCMerger* AliZDC::Merger() +Int_t AliZDC::ADCch2Phe(Int_t Det, Int_t Quad, Int_t ADCVal, Int_t Res) const { -// Return pointer to merger - return fMerger; + // Evaluation of the no. of phe produced + Float_t pmGain[6][5]; + Float_t resADC[2]; + for(Int_t j = 0; j < 5; j++){ + pmGain[0][j] = 50000.; + pmGain[1][j] = 100000.; + pmGain[2][j] = 100000.; + pmGain[3][j] = 50000.; + pmGain[4][j] = 100000.; + pmGain[5][j] = 100000.; + } + // ADC Caen V965 + resADC[0] = 0.0000008; // ADC Resolution high gain: 200 fC/adcCh + resADC[1] = 0.0000064; // ADC Resolution low gain: 25 fC/adcCh + // + Int_t nPhe = (Int_t) (ADCVal * pmGain[Det-1][Quad] * resADC[Res]); + // + //printf("\t AliZDC::ADCch2Phe -> det(%d, %d) - ADC %d phe %d\n",Det,Quad,ADCVal,nPhe); + + return nPhe; } +//______________________________________________________________________ +void AliZDC::SetTreeAddress(){ + + // Set branch address for the Trees. + if(fLoader->TreeH() && (fHits == 0x0)) + fHits = new TClonesArray("AliZDCHit",1000); + + AliDetector::SetTreeAddress(); +}