X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ZDC%2FZDCLASERda.cxx;h=9fdf1dacd09ea2dca65782d555e2ef9a9f6263b2;hb=83e3774242dcc6732d95c64387451410b710a581;hp=2cf2f8df83c27e4bf7ce2b4c1caae63df49354e6;hpb=6f4272556db0c85324458c2138ebb42233245008;p=u%2Fmrichter%2FAliRoot.git diff --git a/ZDC/ZDCLASERda.cxx b/ZDC/ZDCLASERda.cxx index 2cf2f8df83c..9fdf1dacd09 100644 --- a/ZDC/ZDCLASERda.cxx +++ b/ZDC/ZDCLASERda.cxx @@ -2,9 +2,6 @@ This program reads the DAQ data files passed as argument using the monitoring library. -It computes the average event size and populates local "./result.txt" file with the -result. - The program reports about its processing progress. Messages on stdout are exported to DAQ log system. @@ -16,12 +13,15 @@ Link: Run Type: STANDALONE_LASER_RUN DA Type: LDC Number of events needed: no constraint (tipically ~10^3) -Input Files: +Input Files: ZDCPedestal.dat Output Files: ZDCLaser.dat Trigger Types Used: Standalone Trigger */ #define PEDDATA_FILE "ZDCPedestal.dat" +#define MAPDATA_FILE "ZDCChMapping.dat" +#define LASHISTO_FILE "ZDCLaserHisto.root" +#define LASDATA_FILE "ZDCLaserCalib.dat" #include #include @@ -33,11 +33,13 @@ Trigger Types Used: Standalone Trigger #include //ROOT -#include +#include +#include #include #include #include #include +#include "TMinuitMinimizer.h" //AliRoot #include @@ -50,13 +52,46 @@ Trigger Types Used: Standalone Trigger */ int main(int argc, char **argv) { - TFitter *minuitFit = new TFitter(4); - TVirtualFitter::SetFitter(minuitFit); + gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo", + "*", + "TStreamerInfo", + "RIO", + "TStreamerInfo()"); + + TMinuitMinimizer m; + gROOT->GetPluginManager()->AddHandler("ROOT::Math::Minimizer", "Minuit","TMinuitMinimizer", + "Minuit", "TMinuitMinimizer(const char *)"); + TVirtualFitter::SetDefaultFitter("Minuit"); + int status = 0; + int const kNModules = 10; + int const kNChannels = 24; + int const kNScChannels = 32; + Int_t kFirstADCGeo=0, kLastADCGeo=1; // NO out-of-time signals!!! + + Int_t iMod=-1; + Int_t modGeo[kNModules], modType[kNModules],modNCh[kNModules]; + for(Int_t kl=0; kl check if a pedestal run has been analyzied + // *** -> check if a pedestal run has been analyzed int read = 0; - read = daqDA_FES_storeFile(PEDDATA_FILE,"ZDCPEDESTAL_data"); + read = daqDA_DB_getFile(PEDDATA_FILE, PEDDATA_FILE); if(read){ printf("\t ERROR!!! ZDCPedestal.dat file NOT FOUND in DAQ db!!!\n"); return -1; @@ -104,46 +172,49 @@ int main(int argc, char **argv) { } // 144 = 48 in-time + 48 out-of-time + 48 correlations - Float_t readValues[2][144], MeanPed[44], MeanPedWidth[44], - MeanPedOOT[44], MeanPedWidthOOT[44]; + Float_t readValues[2][6*kNChannels]; + Float_t MeanPedhg[kNChannels], MeanPedlg[kNChannels]; + Float_t CorrCoeff0[2*kNChannels], CorrCoeff1[2*kNChannels]; // *************************************************** // Unless we have a narrow correlation to fit we // don't fit and store in-time vs. out-of-time // histograms -> mean pedstal subtracted!!!!!! // *************************************************** - //Float_t CorrCoeff0[44], CorrCoeff1[44]; // - for(int jj=0; jj<144; jj++){ + for(int jj=0; jj<6*kNChannels; jj++){ for(int ii=0; ii<2; ii++){ fscanf(filePed,"%f",&readValues[ii][jj]); } - if(jj<48){ - MeanPed[jj] = readValues[0][jj]; - MeanPedWidth[jj] = readValues[1][jj]; - //printf("\t MeanPed[%d] = %1.1f\n",jj, MeanPed[jj]); + if(jj48 && jj<96){ - MeanPedOOT[jj-48] = readValues[0][jj]; - MeanPedWidthOOT[jj-48] = readValues[1][jj]; + else if(jj>=kNChannels && jj<2*kNChannels){ + MeanPedlg[jj-kNChannels] = readValues[0][jj]; + //printf("\t MeanPedlg[%d] = %1.1f\n",jj-kNChannels, MeanPedlg[jj-kNChannels]); } - /*else if(jj>144){ - CorrCoeff0[jj-96] = readValues[0][jj]; - CorrCoeff1[jj-96] = readValues[1][jj];; + else if(jj>4*kNChannels){ + CorrCoeff0[jj-4*kNChannels] = readValues[0][jj]; + CorrCoeff1[jj-4*kNChannels] = readValues[1][jj];; } - */ } + + FILE *mapFile4Shuttle; /* report progress */ - daqDA_progressReport(10); + daqDA_progressReport(20); /* init some counters */ int nevents_physics=0; int nevents_total=0; + struct eventHeaderStruct *event; + eventTypeType eventT; + /* read the data files */ int n; - for (n=1;neventType; - Int_t ich=0, adcMod[48], adcCh[48], sigCode[48], det[48], sec[48]; if(eventT==START_OF_DATA){ - + + iMod=-1; ich=0; iScCh=0; + + rawStreamZDC->SetSODReading(kTRUE); + + // -------------------------------------------------------- + // --- Writing ascii data file for the Shuttle preprocessor + mapFile4Shuttle = fopen(MAPDATA_FILE,"w"); if(!rawStreamZDC->Next()) printf(" \t No raw data found!! \n"); else{ - while(rawStreamZDC->Next()){ - if(rawStreamZDC->IsChMapping()){ - adcMod[ich] = rawStreamZDC->GetADCModFromMap(ich); - adcCh[ich] = rawStreamZDC->GetADCChFromMap(ich); - sigCode[ich] = rawStreamZDC->GetADCSignFromMap(ich); - det[ich] = rawStreamZDC->GetDetectorFromMap(ich); - sec[ich] = rawStreamZDC->GetTowerFromMap(ich); - ich++; + while((rawStreamZDC->Next())){ + if(rawStreamZDC->IsHeaderMapping()){ // mapping header + iMod++; + modGeo[iMod] = rawStreamZDC->GetADCModule(); + modType[iMod] = rawStreamZDC->GetModType(); + modNCh[iMod] = rawStreamZDC->GetADCNChannels(); } + if(rawStreamZDC->IsChMapping()){ + if(modType[iMod]==1){ // ADC mapping ---------------------- + adcMod[ich] = rawStreamZDC->GetADCModFromMap(ich); + adcCh[ich] = rawStreamZDC->GetADCChFromMap(ich); + sigCode[ich] = rawStreamZDC->GetADCSignFromMap(ich); + det[ich] = rawStreamZDC->GetDetectorFromMap(ich); + sec[ich] = rawStreamZDC->GetTowerFromMap(ich); + ich++; + } + else if(modType[iMod]==2){ //VME scaler mapping -------------------- + scMod[iScCh] = rawStreamZDC->GetScalerModFromMap(iScCh); + scCh[iScCh] = rawStreamZDC->GetScalerChFromMap(iScCh); + scSigCode[iScCh] = rawStreamZDC->GetScalerSignFromMap(iScCh); + scDet[iScCh] = rawStreamZDC->GetScDetectorFromMap(iScCh); + scSec[iScCh] = rawStreamZDC->GetScTowerFromMap(iScCh); + iScCh++; + } + } + } + // Writing data on output FXS file + for(Int_t is=0; is<2*kNChannels; is++){ + fprintf(mapFile4Shuttle,"\t%d\t%d\t%d\t%d\t%d\t%d\n", + is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]); + //printf(" Laser DA -> %d ADC: mod %d ch %d, code %d det %d, sec %d\n", + // is,adcMod[is],adcCh[is],sigCode[is],det[is],sec[is]); + } + for(Int_t is=0; is %d Scaler: mod %d ch %d, code %d det %d, sec %d\n", + // is,scMod[is],scCh[is],scSigCode[is],scDet[is],scSec[is]); + } + for(Int_t is=0; is Module mapping: geo %d type %d #ch %d\n", + // modGeo[is],modType[is],modNCh[is]); } + } - // -------------------------------------------------------- - // --- Writing ascii data file for the Shuttle preprocessor - mapFile4Shuttle = fopen(mapfName,"w"); - for(Int_t i=0; i ch.%d mod %d, ch %d, code %d det %d, sec %d\n", - // i,adcMod[i],adcCh[i],sigCode[i],det[i],sec[i]); - } fclose(mapFile4Shuttle); - } + }// SOD event - /* use event - here, just write event id to result file */ - eventT=event->eventType; - - if(eventT==PHYSICS_EVENT){ - // - // --- Reading data header + else if(eventT==PHYSICS_EVENT){ + // --- Reading data header reader->ReadHeader(); const AliRawDataHeader* header = reader->GetDataHeader(); if(header) { UChar_t message = header->GetAttributes(); - if(message & 0x20){ // DEDICATED LASER RUN + if((message & 0x30) == 0x30){ // DEDICATED LASER RUN //printf("\t STANDALONE_LASER_RUN raw data found\n"); - continue; } else{ - printf("\t NO STANDALONE_LASER_RUN raw data found\n"); + printf("ZDCLASERda.cxx -> NO STANDALONE_LASER_RUN raw data found\n"); return -1; } } @@ -240,10 +336,12 @@ int main(int argc, char **argv) { return -1; } + rawStreamZDC->SetSODReading(kTRUE); + if (!rawStreamZDC->Next()) printf(" \t No raw data found!! \n"); // // ----- Setting ch. mapping ----- - for(Int_t jk=0; jk<48; jk++){ + for(Int_t jk=0; jk<2*kNChannels; jk++){ rawStreamZDC->SetMapADCMod(jk, adcMod[jk]); rawStreamZDC->SetMapADCCh(jk, adcCh[jk]); rawStreamZDC->SetMapADCSig(jk, sigCode[jk]); @@ -253,27 +351,77 @@ int main(int argc, char **argv) { // while(rawStreamZDC->Next()){ Int_t index=-1; - // Getting data only for reference PMTs (sector[1]=5) - if((rawStreamZDC->IsADCDataWord()) && (rawStreamZDC->GetSector(1)==5)){ - index = rawStreamZDC->GetADCChannel(); - Float_t Pedestal = MeanPed[index]; + Int_t detector = rawStreamZDC->GetSector(0); + Int_t sector = rawStreamZDC->GetSector(1); + + if(rawStreamZDC->IsADCDataWord() && !(rawStreamZDC->IsUnderflow()) && + !(rawStreamZDC->IsOverflow()) && detector!=-1 && + rawStreamZDC->GetADCModule()>=kFirstADCGeo && rawStreamZDC->GetADCModule()<=kLastADCGeo){ + + if(sector!=5){ // Physics signals + if(detector==1) index = sector; // *** ZNC + else if(detector==2) index = sector+5; // *** ZPC + else if(detector==3) index = sector+9; // *** ZEM + else if(detector==4) index = sector+12;// *** ZNA + else if(detector==5) index = sector+17;// *** ZPA + } + else{ // Reference PMs + index = (detector-1)/3+22; + } + // + if(index==-1) printf("ERROR in ZDCLASERda.cxx -> det %d quad %d res %d index %d ADC %d\n", + detector, sector, rawStreamZDC->GetADCGain(), index, rawStreamZDC->GetADCValue()); + + Float_t Pedestal=0.; + if(rawStreamZDC->GetADCGain()==0) Pedestal = MeanPedhg[index]; + else if(rawStreamZDC->GetADCGain()==1) Pedestal = MeanPedlg[index]; + // Float_t CorrADC = rawStreamZDC->GetADCValue() - Pedestal; + // + //printf("\tdet %d sec %d res %d index %d ped %1.0f ADCcorr %1.0f\n", + // detector, sector, rawStreamZDC->GetADCGain(), index, Pedestal,CorrADC); - // ==== HIGH GAIN CHAIN - if(rawStreamZDC->GetADCGain() == 0){ - // %%%%% PMRef chain side C - if(rawStreamZDC->GetSector(0)==1) hPMRefChg->Fill(CorrADC); - // %%%%% PMRef side A - else if(rawStreamZDC->GetSector(0)==4) hPMRefAhg->Fill(CorrADC); + // **** Detector PMs + if(sector!=5){ + if(rawStreamZDC->GetADCGain()==0){ // --- High gain chain --- + // ---- side C + if(detector==1) hZNChg[sector]->Fill(CorrADC); + else if(detector==2) hZPChg[sector]->Fill(CorrADC); + // ---- side A + else if(detector==4) hZNAhg[sector]->Fill(CorrADC); + else if(detector==5) hZPAhg[sector]->Fill(CorrADC); + // ---- ZEM + /*else if(detector==3){ + hZEMhg[sector-1]->Fill(CorrADC); + }*/ + } + else if(rawStreamZDC->GetADCGain()==1){ // --- Low gain chain --- + // ---- side C + if(detector==1) hZNClg[sector]->Fill(CorrADC); + else if(detector==2) hZPClg[sector]->Fill(CorrADC); + // ---- side A + else if(detector==4) hZNAlg[sector]->Fill(CorrADC); + else if(detector==5) hZPAlg[sector]->Fill(CorrADC); + // ---- ZEM + //else if(detector==3) hZEMlg[sector-1]->Fill(CorrADC); + } } - // ==== LOW GAIN CHAIN - else{ - // %%%%% PMRef chain side C - if(rawStreamZDC->GetSector(0)==1) hPMRefClg->Fill(CorrADC); - // %%%%% PMRef side A - else if(rawStreamZDC->GetSector(0)==4) hPMRefAlg->Fill(CorrADC); + // **** Reference PMs + else if(sector==5){ + if(rawStreamZDC->GetADCGain()==0){ // --- High gain chain --- + // ---- PMRef chain side C + if(detector==1) hPMRefChg->Fill(CorrADC); + // ---- PMRef side A + else if(detector==4) hPMRefAhg->Fill(CorrADC); + } + else if(rawStreamZDC->GetADCGain()==1){ // --- Low gain chain --- + // ---- PMRef chain side C + if(detector==1) hPMRefClg->Fill(CorrADC); + // ---- PMRef side A + else if(detector==4) hPMRefAlg->Fill(CorrADC); + } } - }//IsADCDataWord() + }//IsADCDataWord()+NOunderflow+NOoverflow // } // @@ -283,88 +431,348 @@ int main(int argc, char **argv) { delete rawStreamZDC; }//(if PHYSICS_EVENT) - nevents_total++; - /* free resources */ - free(event); + /* exit when last event received, no need to wait for TERM signal */ + else if(eventT==END_OF_RUN) { + printf(" -> EOR event detected\n"); + break; + } + + + nevents_total++; } + + /* free resources */ + free(event); } /* Analysis of the histograms */ // - Int_t maxBinRef[4], nBinRef[4]; - Float_t xMaxRef[4], maxXvalRef[4], xlowRef[4]; - Float_t meanRef[2], sigmaRef[2]; - TF1 *funRef[4]; - - // ~~~~~~~~ PM Ref side C high gain chain ~~~~~~~~ - maxBinRef[0] = hPMRefChg->GetMaximumBin(); - nBinRef[0] = (hPMRefChg->GetXaxis())->GetNbins(); - xMaxRef[0] = (hPMRefChg->GetXaxis())->GetXmax(); - maxXvalRef[0] = maxBinRef[0]*xMaxRef[0]/nBinRef[0]; - // - if(maxXvalRef[0]-100.<0.) {xlowRef[0]=0.;} - else xlowRef[0] = maxXvalRef[0]; - hPMRefChg->Fit("gaus","Q","",xlowRef[0],maxXvalRef[0]+100.); - funRef[0] = hPMRefChg->GetFunction("gaus"); - meanRef[0] = (Float_t) (funRef[0]->GetParameter(1)); - sigmaRef[0] = (Float_t) (funRef[0]->GetParameter(2)); - - // ~~~~~~~~ PM Ref side A high gain chain ~~~~~~~~ - maxBinRef[1] = hPMRefAhg->GetMaximumBin(); - nBinRef[1] = (hPMRefAhg->GetXaxis())->GetNbins(); - xMaxRef[1] = (hPMRefAhg->GetXaxis())->GetXmax(); - maxXvalRef[1] = maxBinRef[1]*xMaxRef[1]/nBinRef[1]; - // - if(maxXvalRef[1]-100.<0.) {xlowRef[1]=0.;} - else xlowRef[1] = maxXvalRef[1]; - hPMRefAhg->Fit("gaus","Q","",xlowRef[1],maxXvalRef[1]+100.); - funRef[1] = hPMRefAhg->GetFunction("gaus"); - meanRef[1] = (Float_t) (funRef[1]->GetParameter(1)); - sigmaRef[1] = (Float_t) (funRef[1]->GetParameter(2)); + Int_t detector[2*kNChannels], quad[2*kNChannels]; + Int_t maxBin[2*kNChannels], nBin[2*kNChannels]; + Float_t xMax[2*kNChannels], maxXval[2*kNChannels], xlow[2*kNChannels]; + Float_t mean[2*kNChannels], sigma[2*kNChannels]; + for(Int_t t=0; t<2*kNChannels; t++){ + detector[t] = quad[t] = 0; + maxBin[t] = nBin[t] = 0; + xMax[t] = maxXval[t] = xlow[t] = 0.; + mean[t] = sigma[t] = 0.; + } + TF1 *fun[2*kNChannels]; + Int_t atLeastOneHisto=0; - // ~~~~~~~~ PM Ref side C low gain chain ~~~~~~~~ - maxBinRef[2] = hPMRefClg->GetMaximumBin(); - nBinRef[2] = (hPMRefClg->GetXaxis())->GetNbins(); - xMaxRef[2] = (hPMRefClg->GetXaxis())->GetXmax(); - maxXvalRef[2] = maxBinRef[2]*xMaxRef[2]/nBinRef[2]; - // - if(maxXvalRef[2]-100.<0.) {xlowRef[2]=0.;} - else xlowRef[2] = maxXvalRef[2]; - hPMRefClg->Fit("gaus","Q","",xlowRef[2],maxXvalRef[2]+100.); - funRef[2] = hPMRefClg->GetFunction("gaus"); - meanRef[2] = (Float_t) (funRef[2]->GetParameter(1)); - sigmaRef[2] = (Float_t) (funRef[2]->GetParameter(2)); + // ******** High gain chain ******** + for(Int_t k=0; k<5; k++){ + // --- ZNC + detector[k] = 1; + quad[k] = k; + maxBin[k] = hZNChg[k]->GetMaximumBin(); + nBin[k] = (hZNChg[k]->GetXaxis())->GetNbins(); + xMax[k] = (hZNChg[k]->GetXaxis())->GetXmax(); + if(nBin[k]!=0) maxXval[k] = maxBin[k]*xMax[k]/nBin[k]; + if(maxXval[k]-150.<0.) xlow[k]=0.; + else xlow[k] = maxXval[k]-150.; + // checking if at least one histo is fitted + if(hZNChg[k]->GetEntries()!=0 || hZNChg[k]->GetMean()>0){ + atLeastOneHisto=1; + // + hZNChg[k]->Fit("gaus","Q","",xlow[k],maxXval[k]+150.); + fun[k] = hZNChg[k]->GetFunction("gaus"); + mean[k] = (Float_t) (fun[k]->GetParameter(1)); + sigma[k] = (Float_t) (fun[k]->GetParameter(2)); + } + // --- ZPC + detector[k+5] = 2; + quad[k+5] = k; + maxBin[k+5] = hZPChg[k]->GetMaximumBin(); + nBin[k+5] = (hZPChg[k]->GetXaxis())->GetNbins(); + xMax[k+5] = (hZPChg[k]->GetXaxis())->GetXmax(); + if(nBin[k+5]!=0) maxXval[k+5] = maxBin[k+5]*xMax[k+5]/nBin[k+5]; + if(maxXval[k+5]-150.<0.) xlow[k+5]=0.; + else xlow[k+5] = maxXval[k+5]-150.; + if(hZPChg[k]->GetEntries()!=0 || hZPChg[k]->GetMean()>0){ + atLeastOneHisto=1; + // + hZPChg[k]->Fit("gaus","Q","",xlow[k+5],maxXval[k+5]+150.); + fun[k+5] = hZPChg[k]->GetFunction("gaus"); + mean[k+5] = (Float_t) (fun[k+5]->GetParameter(1)); + sigma[k+5] = (Float_t) (fun[k+5]->GetParameter(2)); + } + // --- ZEM +/* if(k<2){ + detector[k+10] = 3; + quad[k+10] = k+1; + maxBin[k+10] = hZEMhg[k]->GetMaximumBin(); + nBin[k+10] = (hZEMhg[k]->GetXaxis())->GetNbins(); + xMax[k+10] = (hZEMhg[k]->GetXaxis())->GetXmax(); + if(nBin[k+10]!=0) maxXval[k+10] = maxBin[k+10]*xMax[k+10]/nBin[k+10]; + if(maxXval[k+10]-150.<0.) xlow[k+10]=0.; + else xlow[k+10] = maxXval[k+10]-150.; + printf("ZEM%d: entries %1.0f mean %1.0f\n",k+1,hZEMhg[k]->GetEntries(),hZEMhg[k]->GetMean()); + if(hZEMhg[k]->GetEntries()!=0 || hZEMhg[k]->GetMean()>0){ + atLeastOneHisto=1; + // + hZEMhg[k]->Fit("gaus","Q","",xlow[k+10],maxXval[k+10]+150.); + fun[k+10] = hZEMhg[k]->GetFunction("gaus"); + mean[k+10] = (Float_t) (fun[k+10]->GetParameter(1)); + sigma[k+10] = (Float_t) (fun[k+10]->GetParameter(2)); + } + } +*/ + // --- ZNA + detector[k+12] = 4; + quad[k+12] = k; + maxBin[k+12] = hZNAhg[k]->GetMaximumBin(); + nBin[k+12] = (hZNAhg[k]->GetXaxis())->GetNbins(); + xMax[k+12] = (hZNAhg[k]->GetXaxis())->GetXmax(); + if(nBin[k+12]!=0) maxXval[k+12] = maxBin[k+12]*xMax[k+12]/nBin[k+12]; + if(maxXval[k+12]-150.<0.) xlow[k+12]=0.; + else xlow[k+12] = maxXval[k+12]-150.; + if(hZNAhg[k]->GetEntries()!=0 || hZNAhg[k]->GetMean()>0){ + atLeastOneHisto=1; + // + hZNAhg[k]->Fit("gaus","Q","",xlow[k+12],maxXval[k+12]+150.); + fun[k+12] = hZNAhg[k]->GetFunction("gaus"); + mean[k+12] = (Float_t) (fun[k+12]->GetParameter(1)); + sigma[k+12] = (Float_t) (fun[k+12]->GetParameter(2)); + } + // --- ZPA + detector[k+17] = 4; + quad[k+17] = 5; + maxBin[k+17] = hZPAhg[k]->GetMaximumBin(); + nBin[k+17] = (hZPAhg[k]->GetXaxis())->GetNbins(); + xMax[k+17] = (hZPAhg[k]->GetXaxis())->GetXmax(); + if(nBin[k+17]!=0) maxXval[k+17] = maxBin[k+17]*xMax[k+17]/nBin[k+17]; + if(maxXval[k+17]-150.<0.) xlow[k+17]=0.; + else xlow[k+17] = maxXval[k+17]-150.; + if(hZPAhg[k]->GetEntries()!=0 || hZPAhg[k]->GetMean()>0){ + atLeastOneHisto=1; + // + hZPAhg[k]->Fit("gaus","Q","",xlow[k+17],maxXval[k+17]+150.); + fun[k+17] = hZPAhg[k]->GetFunction("gaus"); + mean[k+17] = (Float_t) (fun[k+17]->GetParameter(1)); + sigma[k+17] = (Float_t) (fun[k+17]->GetParameter(2)); + } + } + // ~~~~~~~~ PM Ref side C ~~~~~~~~ + detector[22] = 1; + quad[22] = 5; + maxBin[22] = hPMRefChg->GetMaximumBin(); + nBin[22] = (hPMRefChg->GetXaxis())->GetNbins(); + xMax[22] = (hPMRefChg->GetXaxis())->GetXmax(); + if(nBin[22]!=0) maxXval[22] = maxBin[22]*xMax[22]/nBin[22]; + if(maxXval[22]-150.<0.) xlow[22]=0.; + else xlow[22] = maxXval[22]-150.; + if(hPMRefChg->GetEntries()!=0){ + atLeastOneHisto=1; + // + hPMRefChg->Fit("gaus","Q","",xlow[22],maxXval[22]+150.); + fun[22] = hPMRefChg->GetFunction("gaus"); + mean[22] = (Float_t) (fun[22]->GetParameter(1)); + sigma[22] = (Float_t) (fun[22]->GetParameter(2)); + } + // ~~~~~~~~ PM Ref side A ~~~~~~~~ + detector[23] = 4; + quad[23] = 5; + maxBin[23] = hPMRefAhg->GetMaximumBin(); + nBin[23] = (hPMRefAhg->GetXaxis())->GetNbins(); + xMax[23] = (hPMRefAhg->GetXaxis())->GetXmax(); + if(nBin[23]!=0) maxXval[23] = maxBin[23]*xMax[23]/nBin[23]; + if(maxXval[23]-100.<0.) xlow[23]=0.; + else xlow[23] = maxXval[23]-150.; + if(hPMRefAhg->GetEntries()!=0){ + atLeastOneHisto=1; + // + hPMRefAhg->Fit("gaus","Q","",xlow[23],maxXval[23]+100.); + fun[23] = hPMRefAhg->GetFunction("gaus"); + mean[23] = (Float_t) (fun[23]->GetParameter(1)); + sigma[23] = (Float_t) (fun[23]->GetParameter(2)); + } - // ~~~~~~~~ PM Ref side A low gain chain ~~~~~~~~ - maxBinRef[3] = hPMRefAlg->GetMaximumBin(); - nBinRef[3] = (hPMRefAlg->GetXaxis())->GetNbins(); - xMaxRef[3] = (hPMRefAlg->GetXaxis())->GetXmax(); - maxXvalRef[3] = maxBinRef[3]*xMaxRef[3]/nBinRef[3]; - // - if(maxXvalRef[3]-100.<0.) {xlowRef[3]=0.;} - else xlowRef[3] = maxXvalRef[3]; - hPMRefAlg->Fit("gaus","Q","",xlowRef[3],maxXvalRef[3]+100.); - funRef[3] = hPMRefAlg->GetFunction("gaus"); - meanRef[3] = (Float_t) (funRef[3]->GetParameter(1)); - sigmaRef[3] = (Float_t) (funRef[3]->GetParameter(2)); - // + // ******** Low gain chain ******** +/* Int_t kOffset = 24; + for(Int_t k=0; k<5; k++){ + // --- ZNC + detector[k+kOffset] = 1; + quad[k+kOffset] = k; + maxBin[k+kOffset] = hZNClg[k]->GetMaximumBin(); + nBin[k+kOffset] = (hZNClg[k]->GetXaxis())->GetNbins(); + xMax[k+kOffset] = (hZNClg[k]->GetXaxis())->GetXmax(); + if(nBin[k+kOffset]!=0) maxXval[k+kOffset] = maxBin[k+kOffset]*xMax[k+kOffset]/nBin[k+kOffset]; + if(maxXval[k+kOffset]-150.<0.) xlow[k+kOffset]=0.; + else xlow[k+kOffset] = maxXval[k+kOffset]-150.; + if(hZNClg[k]->GetEntries()!=0){ + atLeastOneHisto=1; + // + hZNClg[k]->Fit("gaus","Q","",xlow[k+kOffset],maxXval[k+kOffset]+150.); + fun[k+kOffset] = hZNClg[k]->GetFunction("gaus"); + mean[k+kOffset] = (Float_t) (fun[k+kOffset]->GetParameter(1)); + sigma[k+kOffset] = (Float_t) (fun[k+kOffset]->GetParameter(2)); + } + // --- ZPC + detector[k+kOffset+5] = 2; + quad[k+kOffset+5] = k; + maxBin[k+kOffset+5] = hZPClg[k]->GetMaximumBin(); + nBin[k+kOffset+5] = (hZPClg[k]->GetXaxis())->GetNbins(); + xMax[k+kOffset+5] = (hZPClg[k]->GetXaxis())->GetXmax(); + if(nBin[k+kOffset+5]!=0) maxXval[k+kOffset+5] = maxBin[k+kOffset+5]*xMax[k+kOffset+5]/nBin[k+kOffset+5]; + if(maxXval[k+kOffset+5]-150.<0.) xlow[k+kOffset+5]=0.; + else xlow[k+kOffset+5] = maxXval[k+kOffset+5]-150.; + if(hZPClg[k]->GetEntries()!=0){ + atLeastOneHisto=1; + // + hZPClg[k]->Fit("gaus","Q","",xlow[k+kOffset+5],maxXval[k+kOffset+5]+150.); + fun[k+kOffset+5] = hZPClg[k]->GetFunction("gaus"); + mean[k+kOffset+5] = (Float_t) (fun[k+kOffset+5]->GetParameter(1)); + sigma[k+kOffset+5] = (Float_t) (fun[k+kOffset+5]->GetParameter(2)); + } + // --- ZEM1 + if(k+kOffset<2){ + detector[k+kOffset+10] = 3; + quad[k+kOffset+10] = k+1; + maxBin[k+kOffset+10] = hZEMlg[k]->GetMaximumBin(); + nBin[k+kOffset+10] = (hZEMlg[k]->GetXaxis())->GetNbins(); + xMax[k+kOffset+10] = (hZEMlg[k]->GetXaxis())->GetXmax(); + if(nBin[k+kOffset+10]!=0) maxXval[k+kOffset+10] = maxBin[k+kOffset+10]*xMax[k+kOffset+10]/nBin[k+kOffset+10]; + if(maxXval[k+kOffset+10]-150.<0.) xlow[k+kOffset+10]=0.; + else xlow[k+kOffset+10] = maxXval[k+kOffset+10]-150.; + if(hZEMlg[k]->GetEntries()!=0){ + atLeastOneHisto=1; + // + hZEMlg[k]->Fit("gaus","Q","",xlow[k+kOffset+10],maxXval[k+kOffset+10]+150.); + fun[k+kOffset+10] = hZEMlg[k]->GetFunction("gaus"); + mean[k+kOffset+10] = (Float_t) (fun[k+kOffset+10]->GetParameter(1)); + sigma[k+kOffset+10] = (Float_t) (fun[k+kOffset+10]->GetParameter(2)); + } + } + // --- ZNA + detector[k+kOffset+12] = 4; + quad[k+kOffset+12] = k; + maxBin[k+kOffset+12] = hZNAlg[k]->GetMaximumBin(); + nBin[k+kOffset+12] = (hZNAlg[k]->GetXaxis())->GetNbins(); + xMax[k+kOffset+12] = (hZNAlg[k]->GetXaxis())->GetXmax(); + if(nBin[k+kOffset+12]!=0) maxXval[k+kOffset+12] = maxBin[k+kOffset+12]*xMax[k+kOffset+12]/nBin[k+kOffset+12]; + if(maxXval[k+kOffset+12]-150.<0.) xlow[k+kOffset+12]=0.; + else xlow[k+kOffset+12] = maxXval[k+kOffset+12]-150.; + if(hZNAlg[k]->GetEntries()!=0){ + atLeastOneHisto=1; + // + hZNAlg[k]->Fit("gaus","Q","",xlow[k+kOffset+12],maxXval[k+kOffset+12]+150.); + fun[k+kOffset+12] = hZNAlg[k]->GetFunction("gaus"); + mean[k+kOffset+12] = (Float_t) (fun[k+kOffset+12]->GetParameter(1)); + sigma[k+kOffset+12] = (Float_t) (fun[k+kOffset+12]->GetParameter(2)); + } + // --- ZPA + detector[k+kOffset+17] = 5; + quad[k+kOffset+17] = k; + maxBin[k+kOffset+17] = hZPAlg[k]->GetMaximumBin(); + nBin[k+kOffset+17] = (hZPAlg[k]->GetXaxis())->GetNbins(); + xMax[k+kOffset+17] = (hZPAlg[k]->GetXaxis())->GetXmax(); + if(nBin[k+kOffset+17]!=0) maxXval[k+kOffset+17] = maxBin[k+kOffset+17]*xMax[k+kOffset+17]/nBin[k+kOffset+17]; + if(maxXval[k+kOffset+17]-150.<0.) xlow[k+kOffset+17]=0.; + else xlow[k+kOffset+17] = maxXval[k+kOffset+17]-150.; + if(hZPAlg[k]->GetEntries()!=0){ + atLeastOneHisto=1; + // + hZPAlg[k]->Fit("gaus","Q","",xlow[k+kOffset+17],maxXval[k+kOffset+17]+150.); + fun[k+kOffset+17] = hZPAlg[k]->GetFunction("gaus"); + mean[k+kOffset+17] = (Float_t) (fun[k+kOffset+17]->GetParameter(1)); + sigma[k+kOffset+17] = (Float_t) (fun[k+kOffset+17]->GetParameter(2)); + } + } + // ~~~~~~~~ PM Ref side C ~~~~~~~~ + detector[46] = 1; + quad[46] = 5; + maxBin[46] = hPMRefClg->GetMaximumBin(); + nBin[46] = (hPMRefClg->GetXaxis())->GetNbins(); + xMax[46] = (hPMRefClg->GetXaxis())->GetXmax(); + if(nBin[46]!=0) maxXval[46] = maxBin[46]*xMax[46]/nBin[46]; + if(maxXval[46]-150.<0.) xlow[46]=0.; + else xlow[46] = maxXval[46]-150.; + if(hPMRefClg->GetEntries()!=0){ + atLeastOneHisto=1; + // + hPMRefClg->Fit("gaus","Q","",xlow[46],maxXval[46]+150.); + fun[46] = hPMRefClg->GetFunction("gaus"); + mean[46] = (Float_t) (fun[46]->GetParameter(1)); + sigma[46] = (Float_t) (fun[46]->GetParameter(2)); + } + // ~~~~~~~~ PM Ref side A ~~~~~~~~ + detector[47] = 4; + quad[47] = 5; + maxBin[47] = hPMRefAlg->GetMaximumBin(); + nBin[47] = (hPMRefAlg->GetXaxis())->GetNbins(); + xMax[47] = (hPMRefAlg->GetXaxis())->GetXmax(); + if(nBin[47]!=0) maxXval[47] = maxBin[47]*xMax[47]/nBin[47]; + if(maxXval[47]-100.<0.) xlow[47]=0.; + else xlow[47] = maxXval[47]-150.; + if(hPMRefAlg->GetEntries()!=0){ + atLeastOneHisto=1; + // + hPMRefAlg->Fit("gaus","Q","",xlow[47],maxXval[47]+100.); + fun[47] = hPMRefAlg->GetFunction("gaus"); + mean[47] = (Float_t) (fun[47]->GetParameter(1)); + sigma[47] = (Float_t) (fun[47]->GetParameter(2)); + } +*/ + if(atLeastOneHisto==0){ + printf("\n WARNING! Empty LASER histos -> ending DA WITHOUT writing output\n\n"); + return -1; + } FILE *fileShuttle; - const char *fName = "ZDCLaser.dat"; - fileShuttle = fopen(fName,"w"); - for(Int_t i=0; i<4; i++) fprintf(fileShuttle,"\t%f\t%f\n",meanRef[i], sigmaRef[i]); + fileShuttle = fopen(LASDATA_FILE,"w"); + for(Int_t i=0; i<2*kNChannels; i++){ + fprintf(fileShuttle,"\t%d\t%d\t%f\t%f\n",detector[i],quad[i],mean[i], sigma[i]); + } // fclose(fileShuttle); + + /* report progress */ + daqDA_progressReport(80); + // + TFile *histofile = new TFile(LASHISTO_FILE,"RECREATE"); + histofile->cd(); + for(int j=0; j<5; j++){ + hZNChg[j]->Write(); + hZPChg[j]->Write(); + hZNAhg[j]->Write(); + hZPAhg[j]->Write(); + hZNClg[j]->Write(); + hZPClg[j]->Write(); + hZNAlg[j]->Write(); + hZPAlg[j]->Write(); + /*if(j<2){ + hZEMhg[j]->Write(); + hZEMlg[j]->Write(); + }*/ + } + hPMRefChg->Write(); + hPMRefAhg->Write(); + hPMRefClg->Write(); + hPMRefAlg->Write(); // + histofile->Close(); + // + for(Int_t j=0; j<5; j++){ + delete hZNChg[j]; + delete hZPChg[j]; + delete hZNAhg[j]; + delete hZPAhg[j]; + delete hZNClg[j]; + delete hZPClg[j]; + delete hZNAlg[j]; + delete hZPAlg[j]; + /*if(j<2){ + delete hZEMhg[j]; + delete hZEMlg[j]; + }*/ + } delete hPMRefChg; delete hPMRefAhg; delete hPMRefClg; delete hPMRefAlg; - //delete minuitFit; - TVirtualFitter::SetFitter(0); - /* write report */ fprintf(fp,"Run #%s, received %d physics events out of %d\n",getenv("DATE_RUN_NUMBER"),nevents_physics,nevents_total); @@ -373,23 +781,30 @@ int main(int argc, char **argv) { /* report progress */ daqDA_progressReport(90); - + /* store the result file on FES */ - status = daqDA_FES_storeFile(mapfName,"ZDCCHMAPPING_data"); + // [1] File with mapping + status = daqDA_FES_storeFile(MAPDATA_FILE, "MAPPING"); if(status){ printf("Failed to export file : %d\n",status); return -1; } // - status = daqDA_FES_storeFile(fName,"ZDCLASER_data"); + // [2] File with laser data + status = daqDA_FES_storeFile(LASDATA_FILE, "LASERDATA"); if(status){ printf("Failed to export file : %d\n",status); return -1; } + // [3] File with laser histos + status = daqDA_FES_storeFile(LASHISTO_FILE, "LASERHISTOS"); + if(status){ + printf("Failed to export pedestal histos file to DAQ FES\n"); + return -1; + } /* report progress */ daqDA_progressReport(100); - return status; }