+
+//____________________________________________________________________________
+void AliZDCQADataMakerRec::MakeRaws(AliRawReader *rawReader)
+{
+ // Filling Raws QA histos
+ //
+ // Checking the event type
+// if (rawReader->GetType()!=7){
+
+ // Check if histograms already created for this Event Specie
+ if(!GetRawsData(0)) InitRaws();
+ // Parameters for mean value pedestal subtraction
+ int const kNch = 24;
+ Float_t meanPed[2*kNch];
+ for(Int_t jj=0; jj<2*kNch; jj++) meanPed[jj] = fPedCalibData->GetMeanPed(jj);
+
+ Float_t zncSignal=0., znaSignal=0., zpcSignal=0., zpaSignal=0.;
+ Float_t zncSumQ=0., znaSumQ=0., zpcSumQ=0., zpaSumQ=0.;
+ Float_t zncpmC=0., znapmC=0., zpcpmC=0., zpapmC=0.;
+ Bool_t isZNCFired=kFALSE, isZPCFired=kFALSE, isZNAFired=kFALSE, isZPAFired=kFALSE;
+ Int_t indZNC=0, indZNA=0, indZPC=0, indZPA=0;
+ Float_t zncTDC[10], zpcTDC[10], zem1TDC[10], zem2TDC[10], znaTDC[10], zpaTDC[10];
+ Float_t zncSumTDC[10], znaSumTDC[10];
+ for(Int_t i=0; i<10; i++){
+ zncTDC[i]=zpcTDC[i]=zem1TDC[i]=zem2TDC[i]=znaTDC[i]=zpaTDC[i]=zncSumTDC[i]=znaSumTDC[i]=-999.;
+ }
+ Float_t tdcGate=-999., l0=-999.;
+ Int_t iMultZNCTDC=0, iMultZPCTDC=0, iMultZEM1TDC=0, iMultZEM2TDC=0, iMultZNATDC=0, iMultZPATDC=0;
+ Int_t iMultTDCC=0, iMultTDCA=0;
+
+ const Float_t x[4] = {-1.75, 1.75, -1.75, 1.75};
+ const Float_t y[4] = {-1.75, -1.75, 1.75, 1.75};
+ const Float_t alpha=0.5;
+ Float_t numXZNC=0., numYZNC=0., denZNC=0., wZNC=0.;
+ Float_t numXZNA=0., numYZNA=0., denZNA=0., wZNA=0.;
+
+ rawReader->Reset();
+ AliZDCRawStream stream(rawReader);
+ while(stream.Next()){
+
+ if(stream.IsADCDataWord() &&
+ (stream.GetADCModule()==0 || stream.GetADCModule()==1)){
+
+ Int_t det = stream.GetSector(0);
+ Int_t quad = stream.GetSector(1);
+ Int_t gain = stream.GetADCGain();
+ Int_t pedindex=0;
+
+ // Stuff for pedestal subtraction
+ if(quad != 5){ // ZDCs (not reference PTMs)
+ Float_t rawVal=-99., pedSubVal=-99.;
+ if(det == 1){
+ pedindex = quad;
+ if(gain == 0){
+ rawVal = (Float_t) (stream.GetADCValue());
+ pedSubVal = (Float_t) (rawVal-meanPed[pedindex]);
+ zncSignal += pedSubVal;
+ isZNCFired = kTRUE;
+ if(quad!=0){
+ zncSumQ += pedSubVal;
+ if(pedSubVal>0.&& zncpmC>7.){
+ wZNC = TMath::Power(pedSubVal, alpha);
+ numXZNC += x[quad-1]*wZNC;
+ numYZNC += y[quad-1]*wZNC;
+ denZNC += wZNC;
+ }
+ }
+ else{
+ zncpmC = pedSubVal;
+ FillRawsData(6,zncpmC);
+ }
+ indZNC++;
+
+ FillRawsData(16, pedindex, pedSubVal);
+ }
+ }
+ else if(det == 2){
+ pedindex = quad+5;
+ if(gain == 0){
+ rawVal = (Float_t) (stream.GetADCValue());
+ pedSubVal = (Float_t) (rawVal-meanPed[pedindex]);
+ zpcSignal += pedSubVal;
+ isZPCFired = kTRUE;
+ if(quad!=0) zpcSumQ += pedSubVal;
+ else{
+ zpcpmC = pedSubVal;
+ FillRawsData(8,zpcpmC);
+ }
+ indZPC++;
+
+ FillRawsData(16, pedindex, pedSubVal);
+ }
+ }
+ else if(det == 3){
+ pedindex = quad+9;
+ if(quad==1){
+ if(gain == 0){
+ rawVal = (Float_t) (stream.GetADCValue());
+ pedSubVal = (Float_t) (rawVal-meanPed[pedindex]);
+ FillRawsData(4,pedSubVal);
+ FillRawsData(16,pedindex, pedSubVal);
+ }
+ }
+ else if(quad==2){
+ if(gain == 0){
+ rawVal = (Float_t) (stream.GetADCValue());
+ pedSubVal = (Float_t) (rawVal-meanPed[pedindex]);
+ FillRawsData(5,pedSubVal);
+ FillRawsData(16,pedindex, pedSubVal);
+ }
+ }
+ }
+ else if(det == 4){
+ pedindex = quad+12;
+ if(gain == 0){
+ rawVal = (Float_t) (stream.GetADCValue());
+ pedSubVal = (Float_t) (rawVal-meanPed[pedindex]);
+ znaSignal += pedSubVal;
+ isZNAFired = kTRUE;
+ if(quad!=0){
+ znaSumQ += pedSubVal;
+ if(pedSubVal>0.&& znapmC>7.) {
+ wZNA = TMath::Power(pedSubVal, alpha);
+ numXZNA += x[quad-1]*wZNA;
+ numYZNA += y[quad-1]*wZNA;
+ denZNA += wZNA;
+ }
+ }
+ else{
+ znapmC = pedSubVal;
+ FillRawsData(7,znapmC);
+ }
+ indZNA++;
+
+ FillRawsData(16,pedindex, pedSubVal);
+ }
+ }
+ else if(det == 5){
+ pedindex = quad+17;
+ if(gain == 0){
+ rawVal = (Float_t) (stream.GetADCValue());
+ pedSubVal = (Float_t) (rawVal-meanPed[pedindex]);
+ zpaSignal += pedSubVal;
+ isZPAFired = kTRUE;
+ if(quad!=0) zpaSumQ += pedSubVal;
+ else{
+ zpapmC = pedSubVal;
+ FillRawsData(9,zpapmC);
+ }
+ indZPA++;
+
+ FillRawsData(16,pedindex, pedSubVal);
+ }
+ }
+
+ }
+
+ if(isZNCFired && indZNC==5){
+ FillRawsData(0,zncSignal);
+ FillRawsData(10,zncSumQ);
+ //
+ Float_t xZNC, yZNC;
+ if(denZNC!=0){
+ xZNC = numXZNC/denZNC;
+ yZNC = numYZNC/denZNC;
+ }
+ else xZNC = yZNC = 999.;
+ FillRawsData(20,xZNC, yZNC);
+ }
+ if(isZPCFired && indZPC==5){
+ FillRawsData(2,zpcSignal);
+ FillRawsData(12,zpcSumQ);
+ }
+ if(isZNAFired && indZNA==5){
+ FillRawsData(1,znaSignal);
+ FillRawsData(11,znaSumQ);
+ //
+ Float_t xZNA, yZNA;
+ if(denZNA!=0){
+ xZNA = numXZNA/denZNA;
+ yZNA = numYZNA/denZNA;
+ }
+ else xZNA = yZNA = 999.;
+ FillRawsData(21,xZNA, yZNA);
+ }
+ if(isZPAFired && indZPA==5){
+ FillRawsData(3,zpaSignal);
+ FillRawsData(13,zpaSumQ);
+ }
+
+ if(indZNC==5){
+ zncSignal = zncSumQ = zncpmC = 0;
+ isZNCFired=kFALSE; indZNC=0;
+ }
+ if(indZPC==5){
+ zpcSignal = zpcSumQ = zpcpmC = 0;
+ isZPCFired=kFALSE; indZPC=0;
+ }
+ if(indZNA==5){
+ znaSignal = znaSumQ = znapmC = 0;
+ isZNAFired=kFALSE; indZNA=0;
+ }
+ if(indZPA==5){
+ zpaSignal = zpaSumQ = zpapmC = 0;
+ isZPAFired=kFALSE; indZPA=0;
+ }
+
+ } //IsADCDataWord && signal ADCs
+ else if(stream.IsZDCTDCDatum()){
+ if(stream.GetChannel()==1){
+ zncTDC[iMultZNCTDC] = (0.025*stream.GetZDCTDCDatum());
+ iMultZNCTDC++;
+ }
+ else if(stream.GetChannel()==3){
+ zpcTDC[iMultZPCTDC] = (0.025*stream.GetZDCTDCDatum());
+ iMultZPCTDC++;
+ }
+ else if(stream.GetChannel()==5){
+ znaTDC[iMultZNATDC] = (0.025*stream.GetZDCTDCDatum());
+ iMultZNATDC++;
+ }
+ else if(stream.GetChannel()==7){
+ zpaTDC[iMultZPATDC] = (0.025*stream.GetZDCTDCDatum());
+ iMultZPATDC++;
+ }
+ else if(stream.GetChannel()==8){
+ zem1TDC[iMultZEM1TDC] = (0.025*stream.GetZDCTDCDatum());
+ iMultZEM1TDC++;
+ }
+ else if(stream.GetChannel()==9){
+ zem2TDC[iMultZEM2TDC] = (0.025*stream.GetZDCTDCDatum());
+ iMultZEM2TDC++;
+ }
+ else if(stream.GetChannel()==10){
+ zncSumTDC[iMultTDCC] = (0.025*stream.GetZDCTDCDatum());
+ iMultTDCC++;
+ }
+ else if(stream.GetChannel()==12){
+ znaSumTDC[iMultTDCA] = (0.025*stream.GetZDCTDCDatum());
+ iMultTDCA++;
+ }
+ else if(stream.GetChannel()==14) tdcGate = (0.025*stream.GetZDCTDCDatum());
+ else if(stream.GetChannel()==15) l0 = (0.025*stream.GetZDCTDCDatum());
+
+ if(stream.GetChannel()==16 && tdcGate!=-999.){
+ for(Int_t iHit=0; iHit<10; iHit++){
+ if(zncTDC[iHit]!=-999.){
+ if(zncTDC[iHit]-tdcGate>-340. && zncTDC[iHit]-tdcGate<-300.)
+ FillRawsData(17,1, zncTDC[iHit]-tdcGate);
+ }
+ if(zpcTDC[iHit]!=-999.){
+ Float_t diffZPC = zpcTDC[iHit]-tdcGate;
+ FillRawsData(15,diffZPC);
+ if(diffZPC>-340. && diffZPC<-300.) FillRawsData(17,2, diffZPC);
+ }
+ if(znaTDC[iHit]!=-999.){
+ if(znaTDC[iHit]-tdcGate>-340. && znaTDC[iHit]-tdcGate<-300.)
+ FillRawsData(17,3, znaTDC[iHit]-tdcGate);
+ }
+ if(zpaTDC[iHit]!=-999.){
+ if(zpaTDC[iHit]-tdcGate>-340. && zpaTDC[iHit]-tdcGate<-300.)
+ FillRawsData(17,4, zpaTDC[iHit]-tdcGate);
+ }
+ if(zem1TDC[iHit]!=-999.){
+ Float_t diffZEM1 = zem1TDC[iHit]-tdcGate;
+ FillRawsData(14,diffZEM1);
+ if(diffZEM1>-340. && diffZEM1<-300.) FillRawsData(17,5, diffZEM1);
+ }
+ if(zem2TDC[iHit]!=-999.){
+ if(zem2TDC[iHit]-tdcGate>-340. && zem2TDC[iHit]-tdcGate<-300.)
+ FillRawsData(17,6, zem2TDC[iHit]-tdcGate);
+ }
+ if(zncSumTDC[iHit]!=-999.){
+ Float_t tdcC = zncSumTDC[iHit]-l0;
+ if(znaSumTDC[iHit]!=-999.){
+ Float_t tdcA = znaSumTDC[iHit]-l0;
+ //if (((tdcC-tdcA-refDelta)*(tdcC-tdcA-refDelta)/(sigmaDelta*sigmaDelta) +
+ //(tdcC+tdcA-refSum)*(tdcC+tdcA-refSum)/(sigmaSum*sigmaSum))< 1.0)
+ FillRawsData(22,tdcC-tdcA,tdcC+tdcA);
+
+ }
+ }
+ }
+ //
+ tdcGate = -999.;
+ for(Int_t i=0; i<10; i++){
+ zncTDC[i] = zpcTDC[i] = zem1TDC[i] = zem2TDC[i] = znaTDC[i] = zpaTDC[i] = -999.;
+ zncSumTDC[i] = znaSumTDC[i] = -999.;
+ }
+ }
+ }
+
+ } //stream.Next()
+// } // check on event type
+// else{
+// AliDebug(1,Form("Skipping non-physics event for QA -> event type %d \n", rawReader->GetType()));
+// }
+//
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
+}
+
+//____________________________________________________________________________
+void AliZDCQADataMakerRec::MakeRecPoints(TTree * clustersTree)
+{
+ // Filling QA histos from RecPoints
+
+ TBranch *branch = clustersTree->GetBranch("ZDC");
+ if(!branch){
+ AliError("Can't get the ZDC branch for rec points!");
+ return;
+ }
+
+ if(!GetRecPointsData(0)) InitRecPoints() ;
+
+ Float_t sum_ZNC=0., sum_ZNA=0., sum_ZPC=0., sum_ZPA=0.;
+ Float_t sumQ_ZNC=0., sumQ_ZNA=0., sumQ_ZPC=0., sumQ_ZPA=0.;
+
+ AliZDCReco reco;
+ AliZDCReco* preco = &reco;
+ clustersTree->SetBranchAddress("ZDC", &preco);
+
+ clustersTree->GetEntry(0);
+ for(Int_t i=0; i<5; i++){
+ sum_ZNC += reco.GetZN1HREnTow(i);
+ sum_ZPC += reco.GetZN2HREnTow(i);
+ sum_ZNA += reco.GetZP1HREnTow(i);
+ sum_ZPA += reco.GetZP2HREnTow(i);
+ if(i==0){
+ FillRecPointsData(8,reco.GetZN1HREnTow(i));
+ FillRecPointsData(9,reco.GetZN2HREnTow(i));
+ FillRecPointsData(10,reco.GetZP1HREnTow(i));
+ FillRecPointsData(11,reco.GetZP2HREnTow(i));
+ }
+ else{
+ sumQ_ZNC += reco.GetZN1HREnTow(i);
+ sumQ_ZPC += reco.GetZN2HREnTow(i);
+ sumQ_ZNA += reco.GetZP1HREnTow(i);
+ sumQ_ZPA += reco.GetZP2HREnTow(i);
+ }
+ }
+
+ FillRecPointsData(0,sum_ZNC);
+ FillRecPointsData(1,sum_ZNA);
+ FillRecPointsData(2,sum_ZPC);
+ FillRecPointsData(3,sum_ZPA);
+ //
+ FillRecPointsData(4,sumQ_ZNC);
+ FillRecPointsData(5,sumQ_ZNA);
+ FillRecPointsData(6,sumQ_ZPC);
+ FillRecPointsData(7,sumQ_ZPA);
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
+}
+