Fixes for coverity
authorcoppedis <coppedis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 20 Jan 2011 21:45:07 +0000 (21:45 +0000)
committercoppedis <coppedis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 20 Jan 2011 21:45:07 +0000 (21:45 +0000)
ZDC/AliGenZDC.cxx
ZDC/AliZDC.cxx
ZDC/AliZDCDataDCS.cxx
ZDC/AliZDCDigitizer.cxx
ZDC/AliZDCRawStream.cxx
ZDC/AliZDCRecoParamPbPb.cxx
ZDC/AliZDCTriggerParameters.cxx
ZDC/AliZDCv3.cxx

index 7247512..3b1c8d8 100644 (file)
@@ -55,6 +55,11 @@ AliGenZDC::AliGenZDC()
   //
   // Default constructor
   //
+  for(Int_t i=0; i<201; i++){
+    fProbintp[i]=0.;
+    fProbintn[i]=0.;
+    fPp[i]=0.;
+  }
 }
 
 //_____________________________________________________________________________
@@ -107,7 +112,7 @@ void AliGenZDC::Generate()
   //
   Int_t i;
 
-  Double_t mass, pLab[3], fP0, fP[3], fBoostP[3], ddp[3], dddp0, dddp[3]; 
+  Double_t mass, pLab[3], fP0, fP[3], fBoostP[3], ddp[3]={0.,0.,0.}, dddp0, dddp[3]; 
   Float_t  fPTrack[3], ptot = fPMin;
   Int_t nt;
   
@@ -218,26 +223,28 @@ void AliGenZDC::ExtractFermi(Int_t id, Double_t *ddp)
 // Compute Fermi momentum for spectator nucleons
 //
   
-  Int_t i;
+  Int_t index=0;
   Float_t xx = gRandom->Rndm();
   assert ( id==kProton || id==kNeutron );
   if(id==kProton){
-    for(i=1; i<=200; i++){
+    for(Int_t i=1; i<=200; i++){
        if((xx>=fProbintp[i-1]) && (xx<fProbintp[i])) break;
-       }
+       index = i;
+    }
   }
   else {
-    for(i=0; i<=200; i++){
+    for(Int_t i=1; i<=200; i++){
        if((xx>=fProbintn[i-1]) && (xx<fProbintn[i])) break;
-       }
-   }
-         Float_t pext = fPp[i]+0.001;
-        Float_t phi = k2PI*(gRandom->Rndm());
-        Float_t cost = (1.-2.*(gRandom->Rndm()));
-        Float_t tet = TMath::ACos(cost);
-        ddp[0] = pext*TMath::Sin(tet)*TMath::Cos(phi);
-        ddp[1] = pext*TMath::Sin(tet)*TMath::Sin(phi);
-        ddp[2] = pext*cost;
+       index = i;
+    }
+  }
+  Float_t pext = fPp[index]+0.001;
+  Float_t phi = k2PI*(gRandom->Rndm());
+  Float_t cost = (1.-2.*(gRandom->Rndm()));
+  Float_t tet = TMath::ACos(cost);
+  ddp[0] = pext*TMath::Sin(tet)*TMath::Cos(phi);
+  ddp[1] = pext*TMath::Sin(tet)*TMath::Sin(phi);
+  ddp[2] = pext*cost;
 
   if(fDebugOpt == 1){
     printf("\n\n               Extraction of Fermi momentum\n");
index 220a0bc..f891fad 100644 (file)
@@ -99,10 +99,7 @@ AliZDC::AliZDC(const char *name, const char *title) :
   fHits = new TClonesArray("AliZDCHit",1000);
   gAlice->GetMCApp()->AddHitList(fHits);
   
-  char sensname[5],senstitle[25];
-  sprintf(sensname,"ZDC");
-  sprintf(senstitle,"ZDC dummy");
-  SetName(sensname); SetTitle(senstitle);
+  SetName("ZDC"); SetTitle("ZDC");
 
 }
 
@@ -237,7 +234,7 @@ void AliZDC::MakeBranch(Option_t *opt)
   //
 
   char branchname[10];
-  sprintf(branchname,"%s",GetName());
+  snprintf(branchname, 10, "%s", GetName());
 
   const char *cH = strstr(opt,"H");
   
@@ -511,8 +508,10 @@ void AliZDC::Digits2Raw()
   //
   UInt_t lADCDataChannel = 0;
   
+  Int_t indADC0=0, indADC1=0, indADC2=0, indADC3=0;
+  
   // loop over digits
-  for(Int_t iDigit=0; iDigit<treeD->GetEntries(); iDigit++){
+  for(Int_t iDigit=0; iDigit<(Int_t) (treeD->GetEntries()); iDigit++){
     treeD->GetEntry(iDigit);
     if(!pdigit) continue;
     //digit.Print("");
@@ -527,7 +526,7 @@ void AliZDC::Digits2Raw()
         break;
        } 
       }
-      else{
+      else if(iDigit>knADCData1+knADCData2){
        if(digit.GetSector(0)==mapADC[k][2] && digit.GetSector(1)==mapADC[k][3]){
         lADCDataGEO = (UInt_t) mapADC[k][0];
         lADCDataChannel = (UInt_t) mapADC[k][1];
@@ -540,72 +539,84 @@ void AliZDC::Digits2Raw()
     // digit.GetSector(0),digit.GetSector(1),lADCDataGEO,lADCDataChannel);
      
     if(lADCDataGEO==0){ 
-      Int_t indHG = iDigit;
-      Int_t indLG = indHG+knADCData1;
+      if(indADC0>knADCData1) AliError(" Problem with digit index 4 ADC0\n");
+      Int_t indLG = indADC0+knADCData1;
       // High gain ADC ch.      
       if(digit.GetADCValue(0) > 2047) lADCDataOvFlwHG = 1; 
-      lADCDataValue1[indHG] = digit.GetADCValue(0);    
-      lADCData1[indHG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 
-                   lADCDataOvFlwHG << 12 | (lADCDataValue1[indHG] & 0xfff); 
+      lADCDataValue1[indADC0] = digit.GetADCValue(0);    
+      lADCData1[indADC0] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 
+                   lADCDataOvFlwHG << 12 | (lADCDataValue1[indADC0] & 0xfff); 
       // Low gain ADC ch.
       if(digit.GetADCValue(1) > 2047) lADCDataOvFlwLG = 1; 
       lADCDataValue1[indLG] = digit.GetADCValue(1); 
       lADCData1[indLG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 0x1 << 16 |
                    lADCDataOvFlwLG << 12 | (lADCDataValue1[indLG] & 0xfff);  
+                   
+      indADC0++;
+      //
       // Ch. debug
       //printf(" lADCDataGEO %d lADCDataValue1[%d] = %d  lADCDataValue1[%d] = %d\n", 
       //  lADCDataGEO,iDigit,lADCDataValue1[indLG],indLG,lADCDataValue1[indLG]);
     }
     else if(lADCDataGEO==1){ 
-        Int_t indHG = iDigit-knADCData1;
-       Int_t indLG = indHG+knADCData2;
-        // High gain ADC ch.       
-        if(digit.GetADCValue(0) > 2047) lADCDataOvFlwHG = 1; 
-        lADCDataValue2[indHG] = digit.GetADCValue(0);    
-        lADCData2[indHG] = lADCDataGEO << 27 | lADCDataChannel << 17 | 
-                     lADCDataOvFlwHG << 12 | (lADCDataValue2[indHG] & 0xfff); 
-        // Low gain ADC ch.
-        if(digit.GetADCValue(1) > 2047) lADCDataOvFlwLG = 1; 
-        lADCDataValue2[indLG] = digit.GetADCValue(1); 
-        lADCData2[indLG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 0x1 << 16 |
-                     lADCDataOvFlwLG << 12 | (lADCDataValue2[indLG] & 0xfff);  
-        //Ch. debug
-        //printf(" lADCDataGEO %d  lADCDataValue2[%d] = %d  lADCDataValue2[%d] = %d\n", 
-        //  lADCDataGEO,indHG,lADCDataValue2[indHG],indLG,lADCDataValue2[indLG]);
+      if(indADC1>knADCData2) AliError(" Problem with digit index 4 ADC1\n");
+      Int_t indLG = indADC1+knADCData2;
+      // High gain ADC ch.      
+      if(digit.GetADCValue(0) > 2047) lADCDataOvFlwHG = 1; 
+      lADCDataValue2[indADC1] = digit.GetADCValue(0);   
+      lADCData2[indADC1] = lADCDataGEO << 27 | lADCDataChannel << 17 | 
+                   lADCDataOvFlwHG << 12 | (lADCDataValue2[indADC1] & 0xfff); 
+      // Low gain ADC ch.
+      if(digit.GetADCValue(1) > 2047) lADCDataOvFlwLG = 1; 
+      lADCDataValue2[indLG] = digit.GetADCValue(1); 
+      lADCData2[indLG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 0x1 << 16 |
+                   lADCDataOvFlwLG << 12 | (lADCDataValue2[indLG] & 0xfff);  
+                 
+      indADC1++;
+      //
+      //Ch. debug
+      //printf(" lADCDataGEO %d  lADCDataValue2[%d] = %d  lADCDataValue2[%d] = %d\n", 
+      //  lADCDataGEO,indHG,lADCDataValue2[indHG],indLG,lADCDataValue2[indLG]);
     }
     else if(lADCDataGEO==2){ 
-        Int_t indHG = iDigit-knADCData1-knADCData2;
-       Int_t indLG = indHG+knADCData3;
-       // High gain ADC ch.       
-        if(digit.GetADCValue(0) > 2047) lADCDataOvFlwHG = 1; 
-        lADCDataValue3[indHG] = digit.GetADCValue(0);    
-        lADCData3[indHG] = lADCDataGEO << 27 | lADCDataChannel << 17 | 
-                     lADCDataOvFlwHG << 12 | (lADCDataValue3[indHG] & 0xfff); 
-        // Low gain ADC ch.
-        if(digit.GetADCValue(1) > 2047) lADCDataOvFlwLG = 1; 
-        lADCDataValue3[indLG] = digit.GetADCValue(1); 
-        lADCData3[indLG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 0x1 << 16 |
-                     lADCDataOvFlwLG << 12 | (lADCDataValue3[indLG] & 0xfff);  
-        //Ch. debug
-        //printf(" lADCDataGEO %d   lADCDataValue3[%d] = %d  lADCDataValue3[%d] = %d\n", 
-        //  lADCDataGEO,indHG,lADCDataValue3[indHG],indLG,lADCDataValue3[indLG]);
+      if(indADC2>knADCData2) AliError(" Problem with digit index 4 ADC2\n");
+      Int_t indLG = indADC2+knADCData3;
+      // High gain ADC ch.      
+      if(digit.GetADCValue(0) > 2047) lADCDataOvFlwHG = 1; 
+      lADCDataValue3[indADC1] = digit.GetADCValue(0);    
+      lADCData3[indADC1] = lADCDataGEO << 27 | lADCDataChannel << 17 | 
+                   lADCDataOvFlwHG << 12 | (lADCDataValue3[indADC2] & 0xfff); 
+      // Low gain ADC ch.
+      if(digit.GetADCValue(1) > 2047) lADCDataOvFlwLG = 1; 
+      lADCDataValue3[indLG] = digit.GetADCValue(1); 
+      lADCData3[indLG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 0x1 << 16 |
+                   lADCDataOvFlwLG << 12 | (lADCDataValue3[indLG] & 0xfff);  
+                 
+      indADC2++;
+      //
+      //Ch. debug
+      //printf(" lADCDataGEO %d   lADCDataValue3[%d] = %d  lADCDataValue3[%d] = %d\n", 
+      //  lADCDataGEO,indHG,lADCDataValue3[indHG],indLG,lADCDataValue3[indLG]);
     }
     else if(lADCDataGEO==3){ 
-        Int_t indHG = iDigit-knADCData1-knADCData2-knADCData3;
-       Int_t indLG = indHG+knADCData4;
-       // High gain ADC ch.       
-        if(digit.GetADCValue(0) > 2047) lADCDataOvFlwHG = 1; 
-        lADCDataValue4[indHG] = digit.GetADCValue(0);    
-        lADCData4[indHG] = lADCDataGEO << 27 | lADCDataChannel << 17 | 
-                     lADCDataOvFlwHG << 12 | (lADCDataValue4[indHG] & 0xfff); 
-        // Low gain ADC ch.
-        if(digit.GetADCValue(1) > 2047) lADCDataOvFlwLG = 1; 
-        lADCDataValue4[indLG] = digit.GetADCValue(1); 
-        lADCData4[indLG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 0x1 << 16 |
-                     lADCDataOvFlwLG << 12 | (lADCDataValue4[indLG] & 0xfff);  
-        // Ch. debug
-        //printf(" lADCDataGEO %d lADCDataValue4[%d] = %d  lADCDataValue4[%d] = %d\n", 
-        //  lADCDataGEO,indHG,lADCDataValue4[indHG],indLG,lADCDataValue4[indLG]);
+      if(indADC3>knADCData3) AliError(" Problem with digit index 4 ADC2\n");
+      Int_t indLG = indADC3+knADCData4;
+      // High gain ADC ch.      
+      if(digit.GetADCValue(0) > 2047) lADCDataOvFlwHG = 1; 
+      lADCDataValue4[indADC3] = digit.GetADCValue(0);    
+      lADCData4[indADC3] = lADCDataGEO << 27 | lADCDataChannel << 17 | 
+                   lADCDataOvFlwHG << 12 | (lADCDataValue4[indADC3] & 0xfff); 
+      // Low gain ADC ch.
+      if(digit.GetADCValue(1) > 2047) lADCDataOvFlwLG = 1; 
+      lADCDataValue4[indLG] = digit.GetADCValue(1); 
+      lADCData4[indLG] = lADCDataGEO << 27 |  lADCDataChannel << 17 | 0x1 << 16 |
+                   lADCDataOvFlwLG << 12 | (lADCDataValue4[indLG] & 0xfff);  
+                 
+      indADC3++;
+      //
+      // Ch. debug
+      //printf(" lADCDataGEO %d lADCDataValue4[%d] = %d  lADCDataValue4[%d] = %d\n", 
+      //  lADCDataGEO,indHG,lADCDataValue4[indHG],indLG,lADCDataValue4[indLG]);
     }            
 
   }
@@ -626,10 +637,10 @@ void AliZDC::Digits2Raw()
   //printf("\t AliZDC::Digits2Raw -> ADCEndBlock = %d\n",lADCEndBlock);
 
   // open the output file
-  char fileName[30];
-  strcpy(fileName,AliDAQ::DdlFileName("ZDC",0));
+  TString fileName;
+  fileName.Form("%s",AliDAQ::DdlFileName("ZDC",0)); 
 
-  AliFstream* file = new AliFstream(fileName);
+  AliFstream* file = new AliFstream(fileName.Data());
 
   // write the DDL data header
   AliRawDataHeaderSim header;
@@ -733,6 +744,7 @@ Int_t AliZDC::Pedestal(Int_t Det, Int_t Quad, Int_t Res) const
   // Getting calibration object for ZDC set
   AliCDBManager *man = AliCDBManager::Instance();
   AliCDBEntry  *entry = man->Get("ZDC/Calib/Pedestals");
+  if(!entry) AliFatal("No calibration data loaded!");  
   AliZDCPedestals *calibPed = (AliZDCPedestals*) entry->GetObject();
   //
   if(!calibPed){
index 580aa20..00cee75 100644 (file)
@@ -57,6 +57,8 @@ AliZDCDataDCS::AliZDCDataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime,
    TTimeStamp(startTimeDCSQuery).AsString(), 
    TTimeStamp(endTimeDCSQuery).AsString()));
 
+   for(Int_t i=0; i<kNAlignDet; i++) fAlignData[i] = 0.;
+
    Init();
 
 }
index d3310b5..d5e7536 100644 (file)
@@ -61,7 +61,7 @@ AliZDCDigitizer::AliZDCDigitizer() :
   fBeamEnergy(0.)
 {
   // Default constructor    
-
+  for(Int_t i=0; i<2; i++) fADCRes[i]=0.;
 }
 
 //____________________________________________________________________________
@@ -118,6 +118,7 @@ Bool_t AliZDCDigitizer::Init()
   // Initialize the digitizer
   
   AliCDBEntry*  entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+  if(!entry) AliFatal("No calibration data loaded!");  
   AliGRPObject* grpData = 0x0;
   if(entry){
     TMap* m = dynamic_cast<TMap*>(entry->GetObject());  // old GRP entry
@@ -132,7 +133,10 @@ Bool_t AliZDCDigitizer::Init()
     entry->SetOwner(0);
     AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
   }
-  if(!grpData) AliError("No GRP entry found in OCDB!");
+  if(!grpData){
+    AliError("No GRP entry found in OCDB! \n ");
+    return kFALSE;
+  }
   
   TString beamType = grpData->GetBeamType();
   if(beamType==AliGRPObject::GetInvalidString()){
@@ -506,6 +510,11 @@ void AliZDCDigitizer::SpectatorSignal(Int_t SpecType, Int_t numEvents,
     }
   }
   
+  if(!zdcSignal){
+    printf("\n No spectator signal available for ZDC digitization\n");
+    return;
+  } 
+  
   Int_t nentries = (Int_t) zdcSignal->GetEntries();
   
   Float_t *entry;
index 5974a2e..4965852 100644 (file)
@@ -674,9 +674,9 @@ Bool_t AliZDCRawStream::Next()
         if((fBuffer & 0x07000000) != 0x06000000){
           fRawReader->AddMajorErrorLog(kZDCDataError);
         }
-        else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
-          fIsADCEventGood = kFALSE;
-        }
+        //else if((fBuffer & 0x07000000) == 0x06000001){ // Corrupted event!!!
+        //  fIsADCEventGood = kFALSE;
+        //}
       }
     
       // If the not valid datum isn't followed by the 1st ADC header
index 6c7b085..da718d0 100644 (file)
@@ -134,9 +134,12 @@ AliZDCRecoParamPbPb *AliZDCRecoParamPbPb::GetHighFluxParam(Float_t beamEnergy)
   // Create high flux reco parameter
   TH1::AddDirectory(0);
   TH2::AddDirectory(0);
-  //
+  
   TFile *fileGlauberMC =  TFile::Open("$ALICE_ROOT/ZDC/GlauberMCDist.root");
-  if(!fileGlauberMC) printf(" AliZDCRecoParamPbPb::GetHighFluxParam() ERROR opening file $ALICE_ROOT/ZDC/SpectatorSignal.root\n");
+  if(!fileGlauberMC) {
+    printf(" Opening file $ALICE_ROOT/ZDC/GlauberMCDist.root failed\n");
+    return NULL;
+  }
   
   Float_t sqrtS = 2*beamEnergy;
   
@@ -157,8 +160,8 @@ AliZDCRecoParamPbPb *AliZDCRecoParamPbPb::GetHighFluxParam(Float_t beamEnergy)
   }
   else printf(" No AliZDCRecoParam provided for Pb-Pb @ sqrt(s) = %1.0f GeV\n", sqrtS);
   //
-  hNpartDist->SetDirectory(0);
-  hbDist->SetDirectory(0);
+  if(hNpartDist) hNpartDist->SetDirectory(0);
+  if(hbDist) hbDist->SetDirectory(0);
 
   AliZDCRecoParamPbPb* zdcRecoParam = new AliZDCRecoParamPbPb(hNpartDist, hbDist, 0.1);
   //
index 171d5f2..62c064a 100644 (file)
@@ -38,6 +38,13 @@ fDiscZEMCentralityThr(0),
 fDiscMBThreshold(0)
 {
   // Default constructor
+  for(Int_t j=0; j<4; j++){
+     fADCEMDWindow[j] = fDiscEMDWindow[j] = 0.;
+     if(j<2){
+       fADCCentralWindow[j] = fADCSemicentralWindow[j] = 0.;
+       fDiscCentralWindow[j] = fDiscSemicentralWindow[j] = 0.;
+     }
+  }
 }  
 
 //________________________________________________________________
index e58ff64..40c8ef3 100644 (file)
@@ -92,7 +92,11 @@ AliZDCv3::AliZDCv3() :
   //
   // Default constructor for Zero Degree Calorimeter
   //
-  
+  for(Int_t i=0; i<3; i++){
+     fDimZN[i] = fDimZP[i] = 0.;
+     fPosZNC[i] = fPosZNA[i] = fPosZPC[i]= fPosZPA[i] = fPosZEM[i] = 0.;
+     fFibZN[i] = fFibZP[i] = 0.;
+  }
 }
  
 //_____________________________________________________________________________