X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ZDC%2FAliZDC.cxx;h=6ee09dd5ce45a9900b8d497c3ad72a53dea2ef2e;hb=55739e9e30060ffc10a60a2ecdf96e7681303b2a;hp=fcc243848a4c25c2fcb3858e2a55b64fce4b53f0;hpb=362c9d61708912a81d77cb017e1d05fd1f9486a6;p=u%2Fmrichter%2FAliRoot.git diff --git a/ZDC/AliZDC.cxx b/ZDC/AliZDC.cxx index fcc243848a4..6ee09dd5ce4 100644 --- a/ZDC/AliZDC.cxx +++ b/ZDC/AliZDC.cxx @@ -26,66 +26,74 @@ // --- ROOT system #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 "AliZDCSDigit.h" #include "AliZDCDigit.h" #include "AliZDCDigitizer.h" #include "AliZDCRawStream.h" -#include "AliZDCCalibData.h" +#include "AliZDCPedestals.h" +#include "AliZDCCalib.h" +#include "AliFstream.h" -#include "AliRawDataHeader.h" -#include "AliLoader.h" -#include "AliRun.h" -#include "AliMC.h" -#include "AliLog.h" -#include "AliDAQ.h" ClassImp(AliZDC) -AliZDC *gAliZDC; - //_____________________________________________________________________________ -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; - - fHits = 0; - fNhits = 0; - - fDigits = 0; - fNdigits = 0; + fIshunt = 1; + fNhits = 0; + fHits = 0; + fDigits = 0; + fNdigits = 0; - fCalibData = 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; - - // Allocate the hits array - fHits = new TClonesArray("AliZDCHit",1000); + + fIshunt = 1; + fNhits = 0; + fDigits = 0; + fNdigits = 0; + + fHits = new TClonesArray("AliZDCHit",1000); gAlice->GetMCApp()->AddHitList(fHits); char sensname[5],senstitle[25]; @@ -93,14 +101,8 @@ AliZDC::AliZDC(const char *name, const char *title) sprintf(senstitle,"ZDC dummy"); SetName(sensname); SetTitle(senstitle); - fDigits = 0; - fNdigits = 0; - - fCalibData = 0; - - gAliZDC=this; - } + //____________________________________________________________________________ AliZDC::~AliZDC() { @@ -108,12 +110,35 @@ AliZDC::~AliZDC() // ZDC destructor // - fIshunt = 0; - gAliZDC=0; - + fIshunt = 0; + delete fPedCalib; delete fCalibData; } + +//_____________________________________________________________________________ +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) { @@ -125,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); @@ -134,6 +160,7 @@ 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->GetMCApp()->GetPrimary(track); + // if(track != primary){ newquad->SetSFlag(1); // SECONDARY particle entering the ZDC } @@ -144,12 +171,14 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits) primKinEn = newquad->GetPrimKinEn(); xImpact = newquad->GetXImpact(); yImpact = newquad->GetYImpact(); + pcPDGcode = newquad->GetPDGCode(); } else{ newquad->SetPrimKinEn(primKinEn); newquad->SetXImpact(xImpact); newquad->SetYImpact(yImpact); newquad->SetSFlag(sFlag); + newquad->SetPDGCode(pcPDGcode); } Int_t j; @@ -158,15 +187,31 @@ 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; } @@ -187,11 +232,11 @@ 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); + 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); } //____________________________________________________________________________ @@ -221,7 +266,7 @@ void AliZDC::MakeBranch(Option_t *opt) const char *cH = strstr(opt,"H"); - if (cH && fLoader->TreeH()) + if(cH && fLoader->TreeH()) fHits = new TClonesArray("AliZDCHit",1000); AliDetector::MakeBranch(opt); @@ -232,7 +277,7 @@ void AliZDC::Hits2SDigits() { // Create summable digits from hits - AliDebug(1,"\n Entering AliZDC::Hits2Digits() "); + AliDebug(1,"\n Entering AliZDC::Hits2SDigits() "); fLoader->LoadHits("read"); fLoader->LoadSDigits("recreate"); @@ -241,9 +286,10 @@ void AliZDC::Hits2SDigits() AliZDCSDigit* psdigit = &sdigit; // Event loop - for (Int_t iEvent = 0; iEvent < runLoader->GetNumberOfEvents(); iEvent++) { - Float_t pmCZN = 0, pmCZP = 0, pmQZN[4], pmQZP[4], pmZEM1 = 0, pmZEM2 = 0; - for (Int_t i = 0; i < 4; i++) pmQZN[i] = pmQZP[i] = 0; + 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(); @@ -252,14 +298,14 @@ void AliZDC::Hits2SDigits() // Tracks loop Int_t sector[2]; - for (Int_t itrack = 0; itrack < ntracks; itrack++) { + for(Int_t itrack = 0; itrack < ntracks; itrack++) { treeH->GetEntry(itrack); - for (AliZDCHit* zdcHit = (AliZDCHit*)FirstHit(-1); zdcHit; + for(AliZDCHit* zdcHit = (AliZDCHit*)FirstHit(-1); zdcHit; zdcHit = (AliZDCHit*)NextHit()) { sector[0] = zdcHit->GetVolume(0); sector[1] = zdcHit->GetVolume(1); - if ((sector[1] < 1) || (sector[1] > 4)) { + if((sector[1] < 1) || (sector[1] > 5)) { Error("Hits2SDigits", "sector[0] = %d, sector[1] = %d", sector[0], sector[1]); continue; @@ -267,16 +313,26 @@ void AliZDC::Hits2SDigits() Float_t lightQ = zdcHit->GetLightPMQ(); Float_t lightC = zdcHit->GetLightPMC(); - if (sector[0] == 1) { //ZN - pmCZN += lightC; - pmQZN[sector[1]-1] += lightQ; - } else if (sector[0] == 2) { //ZP - pmCZP += lightC; - pmQZP[sector[1]-1] += lightQ; - } else if (sector[0] == 3) { //ZEM - if (sector[1] == 1) pmZEM1 += lightC; - else pmZEM2 += lightQ; + 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 } @@ -286,36 +342,58 @@ void AliZDC::Hits2SDigits() const Int_t kBufferSize = 4000; treeS->Branch(GetName(), "AliZDCSDigit", &psdigit, kBufferSize); - // Create sdigits for ZN - sector[0] = 1; // Detector = ZN + // Create sdigits for ZNC + sector[0] = 1; // Detector = ZNC sector[1] = 0; // Common PM ADC - new(psdigit) AliZDCSDigit(sector, pmCZN); - if (pmCZN > 0) treeS->Fill(); - for (Int_t j = 0; j < 4; j++) { + 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, pmQZN[j]); - if (pmQZN[j] > 0) treeS->Fill(); + new(psdigit) AliZDCSDigit(sector, pmQZNC[j]); + if(pmQZNC[j] > 0) treeS->Fill(); } - // Create sdigits for ZP - sector[0] = 2; // Detector = ZP + // Create sdigits for ZPC + sector[0] = 2; // Detector = ZPC sector[1] = 0; // Common PM ADC - new(psdigit) AliZDCSDigit(sector, pmCZP); - if (pmCZP > 0) treeS->Fill(); - for (Int_t j = 0; j < 4; j++) { + 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, pmQZP[j]); - if (pmQZP[j] > 0) treeS->Fill(); + new(psdigit) AliZDCSDigit(sector, pmQZPC[j]); + if(pmQZPC[j] > 0) treeS->Fill(); } // Create sdigits for ZEM sector[0] = 3; sector[1] = 1; // Detector = ZEM1 new(psdigit) AliZDCSDigit(sector, pmZEM1); - if (pmZEM1 > 0) treeS->Fill(); + if(pmZEM1 > 0) treeS->Fill(); sector[1] = 2; // Detector = ZEM2 new(psdigit) AliZDCSDigit(sector, pmZEM2); - if (pmZEM2 > 0) treeS->Fill(); + 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(); + } + + // 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"); @@ -338,14 +416,21 @@ void AliZDC::Digits2Raw() { // Convert ZDC digits to raw data - // preliminary format: 12 interger values (ZNC, ZNQ1-4, ZPC, ZPQ1-4, ZEM1,2) - // For the CAEN module V965 we have an header, the Data Words and an End Of Block - const int knADCData1=24, knADCData2=20; - UInt_t lADCHeader1; - UInt_t lADCData1[knADCData1]; + // 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; @@ -354,8 +439,9 @@ void AliZDC::Digits2Raw() AliZDCDigit digit; AliZDCDigit* pdigit = &digit; TTree* treeD = fLoader->TreeD(); - if (!treeD) return; + 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 @@ -366,74 +452,154 @@ void AliZDC::Digits2Raw() lADCHeader1 = lADCHeaderGEO << 27 | 0x1 << 25 | lADCHeaderCRATE << 16 | lADCHeaderCNT1 << 8 ; -// lADCHeader2 = lADCHeaderGEO << 27 | 0x1 << 25 | lADCHeaderCRATE << 16 | lADCHeaderCNT2 << 8 ; - - //printf("lADCHeader = %d\n",lADCHeader); // 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]; - for(Int_t i = 0; iGetEntries(); iDigit++) { + for(Int_t iDigit=0; iDigitGetEntries(); iDigit++){ treeD->GetEntry(iDigit); - if (!pdigit) continue; - - //ADC data - Int_t index1 = 0, index2 = 0; - if(digit.GetSector(0)==1 || digit.GetSector(0)==2 || digit.GetSector(0)==3){ - if(digit.GetSector(0)==1 || digit.GetSector(0)==2){ - index1 = (digit.GetSector(0)-1) + digit.GetSector(1)*4; - lADCDataChannel = (digit.GetSector(0)-1)*8 + digit.GetSector(1); + if(!pdigit) continue; + //digit.Print(""); + + // *** 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); + } } - else if(digit.GetSector(0)==3){ - index1 = 19 + digit.GetSector(1); - lADCDataChannel = 5 + digit.GetSector(1)*8; + // *** 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); + } } - lADCDataValue1[index1] = digit.GetADCValue(0); - if (lADCDataValue1[index1] > 2047) lADCDataOvFlw1[index1] = 1; - lADCDataValue1[index1+2] = digit.GetADCValue(1); - if (lADCDataValue1[index1+2] > 2047) lADCDataOvFlw1[index1+2] = 1; - - lADCData1[index1] = lADCDataGEO << 27 | lADCDataChannel << 17 | - lADCDataOvFlw1[index1] << 12 | (lADCDataValue1[index1] & 0xfff); - lADCData1[index1+2] = lADCDataGEO << 27 | lADCDataChannel << 17 | 0x1 << 16 | - lADCDataOvFlw1[index1+2] << 12 | (lADCDataValue1[index1+2] & 0xfff); } - else if(digit.GetSector(0)==4 || digit.GetSector(0)==5){ - index2 = (digit.GetSector(0)-4) + digit.GetSector(1)*4; - lADCDataChannel = (digit.GetSector(0)-4)*8 + digit.GetSector(1); - - lADCDataValue2[index2] = digit.GetADCValue(0); - if (lADCDataValue2[index2] > 2047) lADCDataOvFlw2[index2] = 1; - lADCDataValue2[index2+2] = digit.GetADCValue(1); - if (lADCDataValue2[index2+2] > 2047) lADCDataOvFlw2[index2+2] = 1; + // *** 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; // - lADCData2[index2] = lADCDataGEO << 27 | lADCDataChannel << 17 | - lADCDataOvFlw2[index2] << 12 | (lADCDataValue2[index2] & 0xfff); - lADCData2[index2+2] = lADCDataGEO << 27 | lADCDataChannel << 17 | 0x1 << 16 | - lADCDataOvFlw2[index2+2] << 12 | (lADCDataValue2[index2+2] & 0xfff); - } - if ((index1 < 0) || (index1 >= 22)) { - Error("Digits2Raw", "sector[0] = %d, sector[1] = %d", - digit.GetSector(0), digit.GetSector(1)); - continue; + /*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 ((index2 < 0) || (index2 >= 18)) { + if((index<0) || (index>23)) { Error("Digits2Raw", "sector[0] = %d, sector[1] = %d", digit.GetSector(0), digit.GetSector(1)); continue; @@ -441,125 +607,194 @@ void AliZDC::Digits2Raw() } - //for (Int_t i=0;i<24;i++)printf("ADCData1[%d] = %d\n",i,lADCData1[i]); - //for (Int_t i=0;i<20;i++)printf("ADCData2[%d] = %d\n",i,lADCData2[i]); + // + /* + for(Int_t i=0;iGetEventNrInRun(); - + // lADCEndBlock = lADCEndBlockGEO << 27 | 0x1 << 26 | lADCEndBlockEvCount; - - //printf("ADCEndBlock = %d\n",lADCEndBlock); + //printf("\t AliZDC::Digits2Raw -> ADCEndBlock = %d\n",lADCEndBlock); // open the output file char fileName[30]; strcpy(fileName,AliDAQ::DdlFileName("ZDC",0)); -#ifndef __DECCXX - ofstream file(fileName, ios::binary); -#else - ofstream file(fileName); -#endif + + AliFstream* file = new AliFstream(fileName); // write the DDL data header - AliRawDataHeader header; - header.fSize = sizeof(header) + sizeof(lADCHeader1) + sizeof(lADCData1) + - sizeof(lADCEndBlock)+ sizeof(lADCHeader2) + sizeof(lADCData2) + sizeof(lADCEndBlock); - //printf("sizeof header = %d, ADCHeader = %d, ADCData = %d, ADCEndBlock = %d\n", - // sizeof(header),sizeof(lADCHeader),sizeof(lADCData),sizeof(lADCEndBlock)); + 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.write((char*)(&header), sizeof(header)); + file->WriteBuffer((char*)(&header), sizeof(header)); // write the raw data and close the file - file.write((char*) &lADCHeader1, sizeof (lADCHeader1)); - file.write((char*)(lADCData1), sizeof(lADCData1)); - file.write((char*) &lADCEndBlock, sizeof(lADCEndBlock)); - file.write((char*) &lADCHeader2, sizeof (lADCHeader2)); - file.write((char*)(lADCData2), sizeof(lADCData2)); - file.write((char*) &lADCEndBlock, sizeof(lADCEndBlock)); - file.close(); + 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(); } -//______________________________________________________________________ -void AliZDC::SetTreeAddress(){ - // Set branch address for the Trees. - // Inputs: - // none. - // Outputs: - // none. - // Return: - // none. - if (fLoader->TreeH() && (fHits == 0x0)) - fHits = new TClonesArray("AliZDCHit",1000); - - AliDetector::SetTreeAddress(); -} - - -//Calibration methods (by Alberto Colla) - - -//________________________________________________________________ -void AliZDC::CreateCalibData() +//_____________________________________________________________________________ +Bool_t AliZDC::Raw2SDigits(AliRawReader* rawReader) { - // - //if (fCalibData) delete fCalibData; // delete previous version - fCalibData = new AliZDCCalibData(GetName()); + // Convert ZDC raw data to Sdigits + + AliLoader* loader = (gAlice->GetRunLoader())->GetLoader("ZDCLoader"); + if(!loader) { + AliError("no ZDC loader found"); + return kFALSE; + } + +// // 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::WriteCalibData(Int_t option) + +//_____________________________________________________________________________ +Int_t AliZDC::Pedestal(Int_t Det, Int_t Quad, Int_t Res) const { + // Returns a pedestal for detector det, PM quad, channel with res. // - const int kCompressLevel = 9; - char* fnam = GetZDCCalibFName(); - if (!fnam || fnam[0]=='\0') { - fnam = gSystem->ExpandPathName("$(ALICE)/$(ALICE_LEVEL)/data/AliZDCCalib.root"); - Warning("WriteCalibData","No File Name is provided, using default %s",fnam); + // 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; } - TFile* cdfile = TFile::Open(fnam,"UPDATE","",kCompressLevel); - - // Writes Calibration Data to current directory. - // User MUST take care of corresponding file opening and ->cd()... !!! - // By default, the object is overwritten. Use 0 option for opposite. - if (option) option = TObject::kOverwrite; - if (fCalibData) fCalibData->Write(0,option); - else if (fCalibData) fCalibData->Write(0,option); + // + 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! + + - cdfile->Close(); - delete cdfile; + return (Int_t) pedValue; } -//________________________________________________________________ -void AliZDC::LoadCalibData() + +//_____________________________________________________________________________ +Int_t AliZDC::ADCch2Phe(Int_t Det, Int_t Quad, Int_t ADCVal, Int_t Res) const { - // - char* fnam = GetZDCCalibFName(); - if (!fnam || fnam[0]=='\0') return; - if (!gAlice->IsFileAccessible(fnam)) { - Error("LoadCalibData","ZDC Calibration Data file is not accessible, %s",fnam); - exit(1); + // 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.; } - TFile* cdfile = TFile::Open(fnam); - - // Loads Calibration Data from current directory. - // User MUST take care of corresponding file opening and ->cd()...!!! + // 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 // - if (fCalibData) delete fCalibData; // delete previous version - TString dtname = "Calib_"; - dtname += GetName(); - fCalibData = (AliZDCCalibData*) gDirectory->Get(dtname.Data()); - if (!fCalibData) { - Error("LoadCalibData","No Calibration data found for %s",GetName()); - exit(1); - } + 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); - cdfile->Close(); - delete cdfile; + return nPhe; } +//______________________________________________________________________ +void AliZDC::SetTreeAddress(){ -//Calibration methods (by Alberto Colla) + // Set branch address for the Trees. + if(fLoader->TreeH() && (fHits == 0x0)) + fHits = new TClonesArray("AliZDCHit",1000); + + AliDetector::SetTreeAddress(); +}