Coverity fixes (Jens)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 25 Feb 2012 09:43:42 +0000 (09:43 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 25 Feb 2012 09:43:42 +0000 (09:43 +0000)
TPC/AliTPCMonitor.cxx
TPC/AliTPCMonitorConfig.cxx
TPC/AliTPCMonitorConfig.h
TPC/AliTPCMonitorMappingHandler.cxx
TPC/AliTPCMonitorMappingHandler.h
TPC/macros/TPCMonitor.C

index 31afb15..0fffae2 100755 (executable)
@@ -1921,7 +1921,7 @@ void AliTPCMonitor::ShowSel(const Int_t* compval)
   Int_t   feclocbran  =  0;
   Int_t   branch      =  0;
   Short_t rcuget      =  0;
-  Int_t   emptyI      =  1;
+  // Int_t   emptyI      =  1;
   Int_t   index       = -1;
   Int_t   hwadd       =  0;
   
@@ -1991,7 +1991,7 @@ void AliTPCMonitor::ShowSel(const Int_t* compval)
     // Altro chip
       altrochip     =  fMapHand->GetAltro(hwadd);
       if(compval[5]!=-1 && altrochip!=compval[5])      {         fHist->SetCellContent(row-subrows+1,pad+1,0);           continue;     }
-      emptyI =0;
+      // emptyI =0;
     }
   }
   
index b1bf892..82a5459 100755 (executable)
@@ -53,7 +53,6 @@ AliTPCMonitorConfig::AliTPCMonitorConfig(const Char_t* name, const Char_t* title
   fSector(0),
   fSectorLast(-1),
   fSectorLastDisplayed(-1),
-  fSectorArr(new Int_t[36]),
   fFileLast(),
   fFileLastSet(0),
   fFileCurrent(),
@@ -82,7 +81,6 @@ AliTPCMonitorConfig::AliTPCMonitorConfig(const Char_t* name, const Char_t* title
   fButtonFirstX2(50),
   fButtonFirstY(300),  
   fWrite10Bit(0),
-  fComponents(new Float_t[10]), 
   fSamplingFreq(1000000),
   fPedestals(1),
   fNumOfChannels(16000),
@@ -106,7 +104,6 @@ AliTPCMonitorConfig::AliTPCMonitorConfig(const AliTPCMonitorConfig &config) :
   fSector(config.fSector),
   fSectorLast(config.fSectorLast),
   fSectorLastDisplayed(config.fSectorLastDisplayed),
-  fSectorArr(new Int_t[36]),
   fFileLast(config.fFileLast),
   fFileLastSet(config.fFileLastSet),
   fFileCurrent(config.fFileCurrent),
@@ -135,7 +132,6 @@ AliTPCMonitorConfig::AliTPCMonitorConfig(const AliTPCMonitorConfig &config) :
   fButtonFirstX2(config.fButtonFirstX2),
   fButtonFirstY(config.fButtonFirstY),
   fWrite10Bit(config.fWrite10Bit),
-  fComponents(new Float_t[10]),
   fSamplingFreq(config.fSamplingFreq),
   fPedestals(config.fPedestals),
   fNumOfChannels(config.fNumOfChannels),
@@ -146,8 +142,8 @@ AliTPCMonitorConfig::AliTPCMonitorConfig(const AliTPCMonitorConfig &config) :
 {
   // copy constructor
   
-  for(Int_t i =0; i<36; i++) { fSectorArr[i]  =  0;}
-  for(Int_t i =0; i<10;i++)  { fComponents[i] =0.0;}
+  for(Int_t i =0; i<36; i++) { fSectorArr[i]  =  config.fSectorArr[i]; }
+  for(Int_t i =0; i<10;i++)  { fComponents[i] =  config.fComponents[i];}
 
 
 }
@@ -162,7 +158,6 @@ AliTPCMonitorConfig &AliTPCMonitorConfig::operator =(const AliTPCMonitorConfig&
   fSector=config.fSector;
   fSectorLast=config.fSectorLast;
   fSectorLastDisplayed=config.fSectorLastDisplayed;
-  if (!fSectorArr) fSectorArr= new Int_t[36];
   fFileLast= config.fFileLast;
   fFileLastSet=config.fFileLastSet;
   fFileCurrent=config.fFileCurrent;
@@ -191,7 +186,6 @@ AliTPCMonitorConfig &AliTPCMonitorConfig::operator =(const AliTPCMonitorConfig&
   fButtonFirstX2=config.fButtonFirstX2;
   fButtonFirstY=config.fButtonFirstY;
   fWrite10Bit=config.fWrite10Bit;
-  if (!fComponents) fComponents= new Float_t[10];
   fSamplingFreq=config.fSamplingFreq;
   fPedestals=config.fPedestals;
   fNumOfChannels=config.fNumOfChannels;
@@ -200,8 +194,8 @@ AliTPCMonitorConfig &AliTPCMonitorConfig::operator =(const AliTPCMonitorConfig&
   fFitPulse=config.fFitPulse;
   fProcOneSector=config.fProcOneSector;
 
-  for(Int_t i =0; i<36; i++) { fSectorArr[i]  = 0;}
-  for(Int_t i =0; i<10;i++)  { fComponents[i] = 0.;}
+  for(Int_t i =0; i<36; i++) { fSectorArr[i]  = config.fSectorArr[i]; }
+  for(Int_t i =0; i<10;i++)  { fComponents[i] = config.fComponents[i];}
     
   return *this;
 }
@@ -211,8 +205,6 @@ AliTPCMonitorConfig &AliTPCMonitorConfig::operator =(const AliTPCMonitorConfig&
 AliTPCMonitorConfig::~AliTPCMonitorConfig() 
 {
   // Destructor
-  delete[] fSectorArr;
-  delete[] fComponents;
 } 
 
 
@@ -284,60 +276,63 @@ void AliTPCMonitorConfig::ReadConfig(const Char_t* nameconf)
   ifstream datin;
   datin.open(nameconf);
   
-  if(!datin) {  AliWarning("Could not read configfile");}
+  if(!datin.is_open()) {
+    AliWarning(Form("Could not read configfile '%s'",nameconf));
+    return;
+  }
   
   cout << "////  Read Configuration ///////// " << endl;
   while(!datin.eof())
+  {
+    string line;
+    getline(datin,line);
+    if(line.find("max adc")!=string::npos)
+    {
+      datin >> fRangeMaxAdcMin     ;
+      datin >> fRangeMaxAdcMax     ;
+      cout << " range max          :: " << fRangeMaxAdcMin << " : " << fRangeMaxAdcMax << endl;
+    }
+
+    if(line.find("baseline")!=string::npos)
+    {
+      datin >> fRangeBaseMin  ;
+      datin >> fRangeBaseMax  ;
+      cout << " range  base        :: " <<  fRangeBaseMin << " : " <<  fRangeBaseMax  << endl;
+    }
+    if(line.find("adc sum")!=string::npos)
+    {
+      datin >> fRangeSumMin  ;
+      datin >> fRangeSumMax  ;
+      cout << " range sum          :: " <<  fRangeSumMin << " : " << fRangeSumMax  << endl;
+    }
+    if(line.find("frequency")!=string::npos)
+    {
+      datin >> fSamplingFreq  ;
+      cout << " sampling frequency :: " <<  fSamplingFreq << endl;
+    }
+    if(line.find("timebins")!=string::npos)
+    {
+      datin >> fTimeBins  ;
+      cout << " timebins           :: " <<  fTimeBins << endl;
+    }
+    if(line.find("pedestal")!=string::npos)
+    {
+      datin >> fPedestals  ;
+      cout << " pedestal scheme    :: " <<  fPedestals << endl;
+    }
+    if(line.find("main window size")!=string::npos)
+    {
+      datin >> fMainXSize  ;
+      datin >> fMainYSize  ;
+      cout << " main window size   :: " <<  fMainXSize  << "  , " << fMainYSize <<  endl;
+    }
+    if(line.find("border size")!=string::npos)
     {
-      string line;
-      getline(datin,line);
-      if(line.find("max adc")!=string::npos)
-       { 
-         datin >> fRangeMaxAdcMin     ; 
-         datin >> fRangeMaxAdcMax     ;
-         cout << " range max          :: " << fRangeMaxAdcMin << " : " << fRangeMaxAdcMax << endl;
-       }
-      
-      if(line.find("baseline")!=string::npos)
-       { 
-         datin >> fRangeBaseMin  ;
-         datin >> fRangeBaseMax  ;
-         cout << " range  base        :: " <<  fRangeBaseMin << " : " <<  fRangeBaseMax  << endl;
-       }
-      if(line.find("adc sum")!=string::npos)
-       { 
-         datin >> fRangeSumMin  ;
-         datin >> fRangeSumMax  ;
-         cout << " range sum          :: " <<  fRangeSumMin << " : " << fRangeSumMax  << endl;
-       }
-      if(line.find("frequency")!=string::npos)
-       { 
-         datin >> fSamplingFreq  ;
-         cout << " sampling frequency :: " <<  fSamplingFreq << endl;
-       }
-      if(line.find("timebins")!=string::npos)
-       { 
-         datin >> fTimeBins  ;
-         cout << " timebins           :: " <<  fTimeBins << endl;
-       }
-      if(line.find("pedestal")!=string::npos)
-       { 
-         datin >> fPedestals  ;
-         cout << " pedestal scheme    :: " <<  fPedestals << endl;
-       }
-      if(line.find("main window size")!=string::npos)
-       { 
-         datin >> fMainXSize  ;
-         datin >> fMainYSize  ;
-         cout << " main window size   :: " <<  fMainXSize  << "  , " << fMainYSize <<  endl;
-       }
-      if(line.find("border size")!=string::npos)
-       { 
-         datin >> fBorderXSize  ; 
-         datin >> fBorderYSize  ;
-         cout << " border size        :: " <<  fBorderXSize  << "  , " << fBorderYSize <<  endl;
-       }
+      datin >> fBorderXSize  ;
+      datin >> fBorderYSize  ;
+      cout << " border size        :: " <<  fBorderXSize  << "  , " << fBorderYSize <<  endl;
     }
+  }
   cout << "////  Read Configuration done //// " << endl;
   SetMainSize(fMainXSize,fMainYSize,fBorderXSize,fBorderYSize) ;
 }
index c929c00..01e0d39 100755 (executable)
@@ -47,7 +47,7 @@ class AliTPCMonitorConfig: public TNamed
     Int_t    GetCanvasXSpace()                       const { return fCanvasXSpace;}
     Int_t    GetCanvasYSpace()                       const { return fCanvasYSpace;}
     
-    Float_t* GetComponentSelection()                 const { return fComponents;}
+    const Float_t* GetComponentSelection()                 const { return fComponents;}
     
     Int_t    GetEventProcessed()                     const { return fEventProcessed  ;}
     
@@ -145,7 +145,7 @@ class AliTPCMonitorConfig: public TNamed
     Int_t    fSector;                                                   // Currently processed sector 
     Int_t    fSectorLast;                                               // Previously processed sector
     Int_t    fSectorLastDisplayed;                                      // Last displayed sector
-    Int_t*   fSectorArr;                                                // Array of processed sectors
+    Int_t    fSectorArr[36];                                            // Array of processed sectors
     
     // Current and Last Files and Dirs
     TString  fFileLast;                                                 // Name of last processed file/stream
@@ -193,7 +193,7 @@ class AliTPCMonitorConfig: public TNamed
     Int_t    fWrite10Bit ;                                              // Flag to write 10 bit data words to file
     
     // Arr to Store Selected components to be displayed
-    Float_t* fComponents;                                               // Array of components to be selected for display
+    Float_t  fComponents[10];                                           // Array of components to be selected for display
     
     // Sampling Freq required for FFT 
     Int_t    fSamplingFreq;                                             // Sampling frequency for data taking
index cff5a7d..9599ea3 100755 (executable)
@@ -59,43 +59,30 @@ AliTPCMonitorMappingHandler::AliTPCMonitorMappingHandler(const Char_t* name, con
   TNamed(name,title),
   fnumofChannels(0),
   fmaxHWAdress(0),
-  fsizeofArray(0),
-  fmapping(new Short_t*[24000]),
-  fmappingChannelinRow(new Int_t*[160]),
-  fu2ftestmapping(new Short_t*[7000]),
-  fMapHwFECglobal(new Int_t*[24000]),
-  fecGainMap(new Float_t*[7000])
+  fsizeofArray(0)
 {
   // Constructor : Initialize mapping arrays
  
-  for(Int_t in = 0; in<160; in++)
-    {
-      Int_t* hold = new Int_t[150]; 
-      for(Int_t jn = 0; jn<150;jn++)  hold[jn]=0;
-      fmappingChannelinRow[in]= hold;
-    }
-  
-  for(Int_t i = 0; i<7000; i++)
-    {
-      Short_t* hold = new Short_t[8]; 
-      for(Int_t j = 0; j<8;j++)  hold[j]=0;
-      fu2ftestmapping[i]= hold;
-    }
-  
-  for(Int_t i = 0; i<24000; i++)
-    {
-      Int_t* hold = new Int_t[2]; 
-      for(Int_t j = 0; j<2;j++)  hold[j]=0;
-      fMapHwFECglobal[i]= hold;
-    }
+  for(Int_t in = 0; in<160; ++in)
+    for(Int_t jn = 0; jn<150; ++jn)
+      fmappingChannelinRow[in][jn] = 0;
   
+  for(Int_t i = 0; i<7000; ++i){
+    for(Int_t j = 0; j<8; ++j)
+      fu2ftestmapping[i][j] = 0;
+    
+    for(Int_t j = 0; j<128; ++j)
+      fecGainMap[i][j] = 0.;
+  }
   
-  for(Int_t i = 0; i<7000; i++)
-    {
-      Float_t* hold = new Float_t[128]; 
-      for(Int_t j = 0; j<128;j++)  hold[j]=0;
-      fecGainMap[i]= hold;
-    }
+  for(Int_t i = 0; i<24000; ++i){
+    for(Int_t j = 0; j<2; ++j)
+      fMapHwFECglobal[i][j]=0;
+    
+    for (Int_t j=0; j<11; ++j)
+      fmapping[i][j]=0;
+    fmapping[i][1]=-1;
+  }
 }
 
 //____________________________________________________________________________
@@ -103,44 +90,30 @@ AliTPCMonitorMappingHandler::AliTPCMonitorMappingHandler(const  AliTPCMonitorMap
   TNamed(maphand.GetName(),maphand.GetTitle()),
   fnumofChannels(maphand.fnumofChannels),
   fmaxHWAdress(maphand.fmaxHWAdress),
-  fsizeofArray(maphand.fsizeofArray),
-  fmapping(new Short_t*[24000]),
-  fmappingChannelinRow(new Int_t*[160]),
-  fu2ftestmapping(new Short_t*[7000]),
-  fMapHwFECglobal(new Int_t*[24000]),
-  fecGainMap(new Float_t*[7000])
+  fsizeofArray(maphand.fsizeofArray)
 {
   // copy constructor
  
  
-  for(Int_t in = 0; in<160; in++)
-    {
-      Int_t* hold = new Int_t[150]; 
-      for(Int_t jn = 0; jn<150;jn++)  hold[jn]=maphand.fmappingChannelinRow[in][jn];
-      fmappingChannelinRow[in]= hold;
-    }
+  for(Int_t in = 0; in<160; ++in)
+    for(Int_t jn = 0; jn<150; ++jn)
+      fmappingChannelinRow[in][jn] = maphand.fmappingChannelinRow[in][jn];
   
-  for(Int_t i = 0; i<7000; i++)
-    {
-      Short_t* hold = new Short_t[8]; 
-      for(Int_t j = 0; j<8;j++)  hold[j]=maphand.fu2ftestmapping[i][j];
-      fu2ftestmapping[i]= hold;
-    }
+  for(Int_t i = 0; i<7000; ++i){
+    for(Int_t j = 0; j<8; ++j)
+      fu2ftestmapping[i][j] = maphand.fu2ftestmapping[i][j];
 
-  for(Int_t i = 0; i<24000; i++)
-    {
-      Int_t* hold = new Int_t[2]; 
-      for(Int_t j = 0; j<2;j++)  hold[j]=maphand.fMapHwFECglobal[i][j];
-      fMapHwFECglobal[i]= hold;
-    }
-  
-  for(Int_t i = 0; i<7000; i++)
-    {
-      Float_t* hold = new Float_t[128]; 
-      for(Int_t j = 0; j<128;j++)  hold[j]=maphand.fecGainMap[i][j];
-      fecGainMap[i]= hold;
-    }
+    for(Int_t j = 0; j<128; ++j)
+      fecGainMap[i][j] = maphand.fecGainMap[i][j];
+  }
 
+  for(Int_t i = 0; i<24000; ++i){
+    for (Int_t j = 0; j<2; ++j)
+      fMapHwFECglobal[i][j]=maphand.fMapHwFECglobal[i][j];
+
+    for (Int_t j=0; j<11; ++j)
+      fmapping[i][j] = maphand.fmapping[i][j];
+  }
 }
 
 
@@ -148,49 +121,32 @@ AliTPCMonitorMappingHandler::AliTPCMonitorMappingHandler(const  AliTPCMonitorMap
 AliTPCMonitorMappingHandler &AliTPCMonitorMappingHandler:: operator= (const AliTPCMonitorMappingHandler& maphand)
 {
   // assignment operator
-  if(this!=&maphand)
-    {
-      fnumofChannels=maphand.fnumofChannels;
-      fmaxHWAdress=maphand.fmaxHWAdress;
-      fsizeofArray=maphand.fsizeofArray;
+  if (this == &maphand) return *this;
+
+  fnumofChannels=maphand.fnumofChannels;
+  fmaxHWAdress=maphand.fmaxHWAdress;
+  fsizeofArray=maphand.fsizeofArray;
 
-      fmapping = new Short_t*[24000]; // empty
+  for(Int_t in = 0; in<160; ++in)
+    for(Int_t jn = 0; jn<150; ++jn)
+      fmappingChannelinRow[in][jn] = maphand.fmappingChannelinRow[in][jn];
   
-      
-      fmappingChannelinRow = new Int_t*[160];
-      for(Int_t in = 0; in<160; in++)
-       {
-         Int_t* hold = new Int_t[150]; 
-         for(Int_t jn = 0; jn<150;jn++)  hold[jn]=maphand.fmappingChannelinRow[in][jn];
-         fmappingChannelinRow[in]= hold;
-       }
-      
-      fu2ftestmapping      = new Short_t*[7000];
-      for(Int_t i = 0; i<7000; i++)
-       {
-         Short_t* hold = new Short_t[8]; 
-         for(Int_t j = 0; j<8;j++)  hold[j]=maphand.fu2ftestmapping[i][j];
-         fu2ftestmapping[i]= hold;
-       }
-      
-      fMapHwFECglobal = new Int_t*[24000];
-      for(Int_t i = 0; i<24000; i++)
-       {
-         Int_t* hold = new Int_t[2]; 
-         for(Int_t j = 0; j<2;j++)  hold[j]=maphand.fMapHwFECglobal[i][j];
-         fMapHwFECglobal[i]= hold;
-       }
-      
-      fecGainMap = new Float_t*[7000];
-      for(Int_t i = 0; i<7000; i++)
-       {
-         Float_t* hold = new Float_t[128]; 
-         for(Int_t j = 0; j<128;j++)  hold[j]=maphand.fecGainMap[i][j];
-         fecGainMap[i]= hold;
-       }
-      
-      
-    }
+  for(Int_t i = 0; i<7000; ++i){
+    for(Int_t j = 0; j<8; ++j)
+      fu2ftestmapping[i][j]=maphand.fu2ftestmapping[i][j];
+
+    for(Int_t j = 0; j<128; ++j)
+      fecGainMap[i][j] = maphand.fecGainMap[i][j];
+  }
+
+  for(Int_t i = 0; i<24000; ++i){
+    for(Int_t j = 0; j<2; ++j)
+      fMapHwFECglobal[i][j] = maphand.fMapHwFECglobal[i][j];
+
+    for (Int_t j=0; j<11; ++j)
+      fmapping[i][j] = maphand.fmapping[i][j];
+  }
+
   return *this;
 }
 
@@ -199,53 +155,10 @@ AliTPCMonitorMappingHandler &AliTPCMonitorMappingHandler:: operator= (const AliT
 AliTPCMonitorMappingHandler::~AliTPCMonitorMappingHandler() 
 {
   // Destructor
-  Short_t* temp;
-  for(Int_t i = 0; i < 24000 ; i++) {
-    temp = (Short_t *) fmapping[i];
-    if(temp[1] != -1)
-      delete temp;
-  }
-  temp = (Short_t *) fmapping;
-  delete temp;
-  
-  
-  Int_t* temp1;
-  for(Int_t i = 0; i < 24000 ; i++) {
-    temp1 = (Int_t *) fMapHwFECglobal[i];
-    delete temp1;
-  }
-  temp1 = (Int_t *) fMapHwFECglobal;
-  delete temp1;
-  for(Int_t i = 0; i < 7000 ; i++) {
-    temp = (Short_t *) fu2ftestmapping[i];
-    delete temp;
-  }
-  temp = (Short_t *) fu2ftestmapping;
-  delete temp;
-        
-  for(Int_t i = 0; i < 150 ; i++) {
-    temp1= (Int_t *) fmappingChannelinRow[i];
-    delete temp1;
-  }
-  temp1 = (Int_t *) fmappingChannelinRow;
-  delete temp1;
-
-  Float_t* temp2;
-  for(Int_t i = 0; i<7000; i++)
-    {
-      temp2= (Float_t *) fecGainMap[i];
-      delete temp2;
-    }
-  temp2 = (Float_t *) fecGainMap;
-  delete temp2;
-
-       
 }
 
 //_____________________________________________________________________________________________
-void AliTPCMonitorMappingHandler::ReadMapping(char* mapfile)
+void AliTPCMonitorMappingHandler::ReadMapping(const char* mapfile)
 {
   // Read global Mapping file
   // Format of data in mapping file:
@@ -268,73 +181,58 @@ void AliTPCMonitorMappingHandler::ReadMapping(char* mapfile)
   // can hence be found in fmapping[hwaddr]
 
 
-  Short_t*  mappingRow; 
-//   char readcarry[255];
   Int_t version = -1;
   Int_t actPos  = 0;
-  Int_t oldPos  = 0;
 
-  ifstream *in = new ifstream();
-  in->open(mapfile);
+  ifstream infile(mapfile,ios::in);
 
-  if (!in->is_open()) return;
+//   printf("file1: %s\n",mapfile);
+  if (!infile.is_open()) return;
+//   int numLines = 0;
+//   std::string line;
+//   while ( std::getline(infile, line) )
+//     ++numLines;
+//   infile.seekg(0,ios::beg);
+//   infile.clear();
 
-  int numLines = 0;
-  std::string line;
-  while ( std::getline(*in, line) )
-    ++numLines;
- in->seekg(0,ios::beg);
+//   printf("file: %s - %d\n",mapfile,numLines);
   
-//   *in >> readcarry;
-//   version = atoi(readcarry);
-  *in >> version;
-  --numLines;
-//   *in >> readcarry;
-//   fnumofChannels = atoi(readcarry);
-  *in >> fnumofChannels;
-  --numLines;
+  infile >> version;
+//   --numLines;
+
+  infile >> fnumofChannels;
+//   --numLines;
   
-//   *in >> readcarry;
-//   fmaxHWAdress = atoi(readcarry);
-  *in >> fmaxHWAdress;
+  infile >> fmaxHWAdress;
   fsizeofArray = fmaxHWAdress;
-  --numLines;
+//   --numLines;
 
   //consistency check
   fnumofChannels=TMath::Abs(fnumofChannels);
-  fnumofChannels=TMath::Min(fnumofChannels,numLines);
-  
-  Short_t *fmappingEmptyRow = new Short_t[11];
-  for(Int_t i = 0; i < 11 ; i++) {
-    fmappingEmptyRow[i] = 0;
-  }
-  fmappingEmptyRow[1] = -1;
+//   fnumofChannels=TMath::Min(fnumofChannels,numLines);
+
+  Int_t val=0;
   for(Int_t i = 0; i < fnumofChannels ; i++) {
-    mappingRow = new Short_t[11];
-    for(Int_t j = 0 ; j < 11 ; j++) {
-//       *in >> readcarry;
-//       mappingRow[j] = atoi(readcarry);
-      *in >> mappingRow[j];
-    }
-    actPos = mappingRow[0];
-    fmapping[actPos] = mappingRow;
-    if( (actPos - oldPos) > 1) {
-      for(Int_t j = (oldPos+1); j < actPos; j++) {
-        fmapping[j] = fmappingEmptyRow;
-      }
+    //get hw address
+    infile >> actPos;
+
+    //set first value of hw address to channel number
+    if (actPos>0 && actPos<24000)
+      fmapping[actPos][0] = (Short_t)i;
+
+    //loop over channel parameters
+    for(Int_t j = 1 ; j < 11 ; j++) {
+      infile >> val;
+      if (actPos>0 && actPos<24000)
+        fmapping[actPos][j] = (Short_t)val;
     }
-    oldPos = actPos;
-    fmapping[actPos][0] = i;
   }
   
-  in->close();
-  delete in;
-
-  delete [] fmappingEmptyRow;
+  infile.close();
 }
 
 //_____________________________________________________________________________________________
-Int_t  AliTPCMonitorMappingHandler::ReadFECMapping(char* u2ftestfile)
+Int_t  AliTPCMonitorMappingHandler::ReadFECMapping(const char* u2ftestfile)
 {
   // Read in Mapping of global FEC numbers to branches, rcu patches etc.
   // Format in Mapping file
@@ -354,16 +252,14 @@ Int_t  AliTPCMonitorMappingHandler::ReadFECMapping(char* u2ftestfile)
   Int_t carry     = 0;
   Int_t ncards    = 0;
  
-  for(Int_t ind = 0; ind<7000; ind++)
-    {
-      for(Int_t entr = 0; entr<8; entr++)
-       {
-         datin >> carry ;
-         fu2ftestmapping[ind][entr] = carry  ;
-         
-         if(entr==0 && carry!=0) ncards++;
-       }
-    }
+  for(Int_t ind = 0; ind<7000; ind++) {
+      for(Int_t entr = 0; entr<8; entr++) {
+        datin >> carry ;
+        fu2ftestmapping[ind][entr] = carry  ;
+
+        if(entr==0 && carry!=0) ncards++;
+      }
+  }
   return ncards ;
 }
 
@@ -390,30 +286,28 @@ void AliTPCMonitorMappingHandler::ReadfecHwMap(Int_t sector)
   if(sector>18)    fsector= sector-18;
   else             fsector= sector   ;
 
-  for(Int_t ind = 0; ind<7000; ind++)
-    { 
-      if((Int_t)U2fGetSide(ind)==fside && U2fGetSector(ind)==fsector) 
-       {
-         nfecs++;
-         fec            = U2fGetFECinBranch(ind);
-         branch         = U2fGetBranch(ind);
-         rcupatch      = U2fGetRCU(ind);
-                 
-         for(Int_t ch = 0; ch<128; ch++)
-           {
-             altrchann      = ch%16;
-             altrchip       = ch/16;
-             
-             nextHwAddress  = (   ((branch&1)<<11) + (fec<<7) + (altrchip<<4) + (altrchann)  + ((rcupatch-1)<<12) ); 
-             
-             fMapHwFECglobal[nextHwAddress][0] = ind;
-             fMapHwFECglobal[nextHwAddress][1] = ch ;
-           }
-       }
+  for(Int_t ind = 0; ind<7000; ind++) { 
+    if((Int_t)U2fGetSide(ind)==fside && U2fGetSector(ind)==fsector) {
+      nfecs++;
+      fec            = U2fGetFECinBranch(ind);
+      branch         = U2fGetBranch(ind);
+      rcupatch      = U2fGetRCU(ind);
+
+      for(Int_t ch = 0; ch<128; ch++) {
+        altrchann      = ch%16;
+        altrchip       = ch/16;
+
+        nextHwAddress  = (   ((branch&1)<<11) + (fec<<7) + (altrchip<<4) + (altrchann)  + ((rcupatch-1)<<12) );
+
+        if (nextHwAddress<0 || nextHwAddress>=24000) continue;
+        fMapHwFECglobal[nextHwAddress][0] = ind;
+        fMapHwFECglobal[nextHwAddress][1] = ch ;
+      }
     }
+  }
 }
 //_____________________________________________________________________________________________
-void AliTPCMonitorMappingHandler::ReadfecGainMap(char* fecgainmap)
+void AliTPCMonitorMappingHandler::ReadfecGainMap(const char* fecgainmap)
 {
   // Read global gain calibration pap
   // Format in file :
@@ -430,13 +324,14 @@ void AliTPCMonitorMappingHandler::ReadfecGainMap(char* fecgainmap)
     for(Int_t in = 0; in<128; in++)
     {
       datin >> val ;
+      if (fecnr<0 || fecnr>=7000) continue;
       fecGainMap[fecnr][in] = val;
     }
   }
 }
 
 //_____________________________________________________________________________________________
-void  AliTPCMonitorMappingHandler::ReadRowMappingGlob(char* fpathtoMappingRowfile) 
+void  AliTPCMonitorMappingHandler::ReadRowMappingGlob(const char* fpathtoMappingRowfile) 
 {
   // Read mapping of hardware addresses in rows
   // Format of file:
@@ -446,21 +341,20 @@ void  AliTPCMonitorMappingHandler::ReadRowMappingGlob(char* fpathtoMappingRowfil
  
   char readcarry[256];
   char readcarry2[256];
-  ifstream *in = new ifstream();
-  in->open(fpathtoMappingRowfile);
+  ifstream in(fpathtoMappingRowfile,ios::in);
   
   for(Int_t i = 0; i < 159 ; i++) {
-    *in >> readcarry;   // row number 
-    *in >> readcarry2;  // numof pads
+    in >> readcarry;   // row number
+    in >> readcarry2;  // numof pads
     fmappingChannelinRow[i][0] = atoi(readcarry2);
     fmappingChannelinRow[i][1] = atoi(readcarry);
     
     for(Int_t j = 2 ; j < fmappingChannelinRow[i][0]+2 ; j++) {
-      *in >> readcarry;
+      in >> readcarry;
       fmappingChannelinRow[i][j] = atoi(readcarry);
     }
   }
-  in->close();
+  in.close();
 }
 
 
@@ -482,10 +376,10 @@ Int_t AliTPCMonitorMappingHandler::GetSizeofArray() const
 
 
 //_____________________________________________________________________________________________
-Short_t* AliTPCMonitorMappingHandler::GetLine(Int_t hwaddr)const
+const Short_t* AliTPCMonitorMappingHandler::GetLine(Int_t hwaddr) const
 {
   // Return pointer to mapping array for the hardware address hwaddr 
-  Short_t* retval;
+  const Short_t* retval=0x0;
   if(hwaddr <= fsizeofArray)
     retval = fmapping[hwaddr];
   else
@@ -618,10 +512,10 @@ Int_t AliTPCMonitorMappingHandler::GetAltro(Int_t hwaddr)  const
 Int_t AliTPCMonitorMappingHandler::GetNumofPads(Int_t row) 
 {
   // Return number of pads in row
-  if(row<159)
+  if(row>=0&&row<159)
     return fmappingChannelinRow[row][0];
   else  {
-    AliError("Row number to high");
+    AliError("Wrong row number");
     return 0;
   }
 }
@@ -630,10 +524,10 @@ Int_t AliTPCMonitorMappingHandler::GetNumofPads(Int_t row)
 Int_t AliTPCMonitorMappingHandler::GetPadAddInRow(Int_t row,Int_t pad )
 {
   // Return hardware address for given pad in row
-  if(row<159)
+  if(row>=0&&row<159)
     return fmappingChannelinRow[row][pad+2];
   else {
-    AliError("Row number to high");
+    AliError("Wrong row number");
     return 0;
   }
 }
index 366426a..c245cc6 100755 (executable)
@@ -28,11 +28,11 @@ class AliTPCMonitorMappingHandler:   public TNamed {
 
     ~AliTPCMonitorMappingHandler();
     
-    void     ReadMapping(char* mapfile);
-    void     ReadRowMappingGlob(char* fpathtoMappingRowfile) ;
+    void     ReadMapping(const char* mapfile);
+    void     ReadRowMappingGlob(const char* fpathtoMappingRowfile) ;
     Int_t    GetNumOfChannels() const;
     Int_t    GetSizeofArray() const ;
-    Short_t* GetLine(          Int_t channel) const;
+    const Short_t* GetLine(          Int_t channel) const;
     Int_t    GetIndex(         Int_t channel) const;
     Int_t    GetPadRow(        Int_t channel) const;
     Int_t    GetPad(           Int_t channel) const;
@@ -46,9 +46,9 @@ class AliTPCMonitorMappingHandler:   public TNamed {
     Int_t    GetPadAddInRow(   Int_t row, Int_t pad);
     Int_t    GetNumofPads(     Int_t row);
     
-    Int_t    ReadFECMapping(   char* u2ftestfile);
+    Int_t    ReadFECMapping(   const char* u2ftestfile);
     void     ReadfecHwMap(     Int_t sector);
-    void     ReadfecGainMap(   char* fecgainmap);
+    void     ReadfecGainMap(   const char* fecgainmap);
      
     Int_t    U2fGetBranch(     Int_t fecnr) const;
     Int_t    U2fGetRCU(        Int_t fecnr) const;
@@ -65,15 +65,15 @@ class AliTPCMonitorMappingHandler:   public TNamed {
  private:
     
  
-    Int_t     fnumofChannels;            // Max number of channels
-    Int_t     fmaxHWAdress;              // Max value of hardware addresses
-    Int_t     fsizeofArray;              // Set to max value of hardware addresses
-    Short_t** fmapping;                  // global  mapping array
-    Int_t**   fmappingChannelinRow;      // mapping of hardware addresses in one pad row
+    Int_t   fnumofChannels;              // Max number of channels
+    Int_t   fmaxHWAdress;                // Max value of hardware addresses
+    Int_t   fsizeofArray;                // Set to max value of hardware addresses
+    Short_t fmapping[24000][11];         // global  mapping array
+    Int_t   fmappingChannelinRow[159][150];  // mapping of hardware addresses in one pad row
     
-    Short_t** fu2ftestmapping;           // mapping of global FEC numbers in sectors (determined during installation with U2F card)  
-    Int_t**   fMapHwFECglobal;           // mapping of global FEC numbers to hardware addresses in these FECs              
-    Float_t** fecGainMap;                // global gain calibration map
+    Short_t fu2ftestmapping[7000][8];  // mapping of global FEC numbers in sectors (determined during installation with U2F card)
+    Int_t   fMapHwFECglobal[24000][2]; // mapping of global FEC numbers to hardware addresses in these FECs
+    Float_t fecGainMap[7000][128];     // global gain calibration map
        
     ClassDef(AliTPCMonitorMappingHandler,1);
 };
index ac9bada..9965024 100755 (executable)
@@ -74,27 +74,28 @@ void TPCMonitor()
   // Initialize the monitor 
   SetStyle();
   
-  // MappingHandler
-  Char_t fglobalmap[256] ; sprintf(fglobalmap,"%s/TPC/mapping/MappingGlobal.txt", gSystem->Getenv("ALICE_ROOT"));
-  Char_t frowmap[256]    ; sprintf(frowmap,   "%s/TPC/mapping/MappingRow.txt",    gSystem->Getenv("ALICE_ROOT"));
-  Char_t ffecmap[256]    ; sprintf(ffecmap,   "%s/TPC/mapping/MappingCards.txt",  gSystem->Getenv("ALICE_ROOT"));
-  Char_t fnameconf[256]  ; sprintf(fnameconf, "%s/TPC/AliTPCMonitorConfig.txt",   gSystem->Getenv("ALICE_ROOT"));
+  TString aliceroot=gSystem->Getenv("ALICE_ROOT");
+  TString dateroot=gSystem->Getenv("DATE_ROOT");
   
-  cout << " ALICE_ROOT : " << gSystem->Getenv("ALICE_ROOT") << endl;
-  cout << " DATE_ROOT  : " << gSystem->Getenv("DATE_ROOT")  << endl;
-
+  cout << " ALICE_ROOT : " << aliceroot.Data() << endl;
+  cout << " DATE_ROOT  : " << dateroot.Data()  << endl;
+  
+  // MappingHandler
+  TString fglobalmap=Form("%s/TPC/mapping/MappingGlobal.txt", aliceroot.Data());
+  TString frowmap=Form("%s/TPC/mapping/MappingRow.txt",    aliceroot.Data());
+  TString ffecmap=Form("%s/TPC/mapping/MappingCards.txt",  aliceroot.Data());
+  TString fnameconf=Form("%s/TPC/AliTPCMonitorConfig.txt",   aliceroot.Data());
   fMapHand = new AliTPCMonitorMappingHandler("maphand","maphand");
-  fMapHand->ReadMapping(fglobalmap);
-  fMapHand->ReadRowMappingGlob(frowmap);
-  fMapHand->ReadFECMapping(    ffecmap);  
+  fMapHand->ReadMapping(fglobalmap.Data());
+  fMapHand->ReadRowMappingGlob(frowmap.Data());
+  fMapHand->ReadFECMapping(    ffecmap.Data());
   if (gDirectory) { gDirectory->Append(fMapHand); }
   
   // Monitor
   fMon = new AliTPCMonitor("monitor","monitor");
-  fMon->ReadConfig(fnameconf);
+  fMon->ReadConfig(fnameconf.Data());
   fMon->SetMappingHandler(fMapHand);
   MonitorGui(fMon);
-  
 }
 
 //_________________________________________________________________________