Fix of coding rule violations
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 12 Nov 2007 13:53:17 +0000 (13:53 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 12 Nov 2007 13:53:17 +0000 (13:53 +0000)
TRD/AliTRDtestBeam.cxx
TRD/AliTRDtestBeam.h

index 158b8f9..ea28b60 100644 (file)
 #include <iostream>
 #include <fstream>
 
+/*
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
-
-//#include <>
+*/
 
 ClassImp(AliTRDtestBeam)
 
-const Long_t AliTRDtestBeam::file_head_size = 544; // ?
-const Long_t AliTRDtestBeam::event_head_size = 68; //?
-const Long_t AliTRDtestBeam::ldc_head_size = 68; //?
-const Long_t AliTRDtestBeam::equip_head_size = 28; //
-const Int_t AliTRDtestBeam::vme_in =1; //VME event in
-const Int_t AliTRDtestBeam::sim_in =1; //Si-strips in
+const Long_t AliTRDtestBeam::fgkFileHeadSize = 544; // ?
+const Long_t AliTRDtestBeam::fgkEventHeadSize = 68; //?
+const Long_t AliTRDtestBeam::fgkLdcHeadSize = 68; //?
+const Long_t AliTRDtestBeam::fgkEquipHeadSize = 28; //
+const Int_t AliTRDtestBeam::fgkVmeIn =1; //VME event in
+const Int_t AliTRDtestBeam::fgkSimIn =1; //Si-strips in
 
 //typedef char byte;
 
 //offsets in bytes
-const Int_t AliTRDtestBeam::pos_run = 20; //run nr. (in file and event header)
-const Int_t AliTRDtestBeam::pos_length = 0; //event/equip. length
-const Int_t AliTRDtestBeam::pos_eqid = 8;  //equipment id.
-const Int_t AliTRDtestBeam::pos_sioff = 12;  //Si data size offset (3 extra words!!!)      
+const Int_t AliTRDtestBeam::fgkPosRun = 20; //run nr. (in file and event header)
+const Int_t AliTRDtestBeam::fgkPosLength = 0; //event/equip. length
+const Int_t AliTRDtestBeam::fgkEqId = 8;  //equipment id.
+const Int_t AliTRDtestBeam::fgkPosSiOff = 12;  //Si data size offset (3 extra words!!!)      
      
 using namespace std;
 
@@ -68,6 +68,9 @@ AliTRDtestBeam::AliTRDtestBeam() :
   fCher(0),
   fPb(0)
 {
+  //
+  // Standard construction
+  //
 
 }
 //____________________________________________________________________________ 
@@ -89,60 +92,81 @@ AliTRDtestBeam::AliTRDtestBeam(const char *filename) :
   fCher(0),
   fPb(0)
 {
+  //
+  // AliTRDtestBeam constructor
+  //
 
   fDataStream = new ifstream(filename, ifstream::in | ifstream::binary );
   cout << fDataStream->is_open() << endl;
   //fHeaderIsRead = kTRUE;
   fHeaderIsRead = kTRUE;
 
-  fFileHeader = new Char_t[file_head_size];
-  fEventHeader = new Char_t[event_head_size];
+  fFileHeader = new Char_t[fgkFileHeadSize];
+  fEventHeader = new Char_t[fgkEventHeadSize];
   fEventData = new Char_t[fLimit];
+
 }
+
 //____________________________________________________________________________ 
+AliTRDtestBeam::~AliTRDtestBeam() 
+{
+  //
+  // Destructor
+  //
 
-Int_t AliTRDtestBeam::NextEvent() {
+  if (fDataStream)  delete fDataStream;
+  if (fEventHeader) delete fEventHeader;
+  if (fFileHeader)  delete fFileHeader;
+  if (fEventData)   delete fEventData;
+
+}
+
+//____________________________________________________________________________ 
+Int_t AliTRDtestBeam::NextEvent() 
+{
+  //
+  // Read the next event
+  //
   
-  Long_t data_size=0,ldc_off; //,ldc_id,ldc2_id;
-  Long_t ldc_size,eq_id; //,ev_l2;
-  Long_t event_nr,ev_l1;
+  Long_t dataSize=0,ldcOff; //,ldc_id,ldc2_id;
+  Long_t ldcSize,eqId; //,ev_l2;
+  Long_t eventNr,evL1;
   Long_t word;
   
   if ( !fHeaderIsRead ) {
-    fDataStream->read(fFileHeader, file_head_size);
+    fDataStream->read(fFileHeader, fgkFileHeadSize);
     if(fDataStream->fail()) {
       cerr << "Error reading file header! " << endl;   
       return false;
     }
-    cout  << " Run nr.  " << Int(pos_run, fFileHeader) << endl;    
+    cout  << " Run nr.  " << Int(fgkPosRun, fFileHeader) << endl;    
     fHeaderIsRead=kTRUE;
   }
 
-  fDataStream->read(fEventHeader, event_head_size);
+  fDataStream->read(fEventHeader, fgkEventHeadSize);
   if(fDataStream->fail()) {
     cerr << "End of file, Event " << fEventCount  << endl;     
     return false;
   }
   
-  data_size = Int(pos_length, fEventHeader)-event_head_size; //?
-  event_nr = Int((4+pos_run), fEventHeader); //ev.nr.
-  //cout << " Event " << event_nr <<" size "<< data_size <<endl;
+  dataSize = Int(fgkPosLength, fEventHeader)-fgkEventHeadSize; //?
+  eventNr = Int((4+fgkPosRun), fEventHeader); //ev.nr.
+  //cout << " Event " << eventNr <<" size "<< dataSize <<endl;
   
-    if (event_nr <= fEventCount-1) { //watch-out ...event counter starts at 1?
+    if (eventNr <= fEventCount-1) { //watch-out ...event counter starts at 1?
       cout << fEventCount << " End of file?, Event " << fEventCount << endl;   
       return false;
     }
-    //cout <<  "Run " << Int(pos_run, header)<< " , Event " <<event_nr <<endl;
+    //cout <<  "Run " << Int(fgkPosRun, header)<< " , Event " <<eventNr <<endl;
     
     // enough space for data?
-    if (fLimit < data_size) {
+    if (fLimit < dataSize) {
       delete[] fEventData;
-      fEventData = new Char_t[data_size];
-      fLimit = data_size;
+      fEventData = new Char_t[dataSize];
+      fLimit = dataSize;
     }
     
-    fDataStream->read(fEventData, data_size);
+    fDataStream->read(fEventData, dataSize);
     
     if(fDataStream->fail()) {
       cerr << "End of file, Event " << fEventCount; // << endl;        
@@ -151,40 +175,40 @@ Int_t AliTRDtestBeam::NextEvent() {
     
     //cout  << " ...IDs (size) : ";
     
-    ldc_off=0; // size of data from one DDL link
+    ldcOff=0; // size of data from one DDL link
     
     for ( size_t k = 0; k < 2; k++ ) { // 2 LDCs (DDL & VME)
       
-      ldc_size = Int(ldc_off+pos_length, fEventData); //
-      //ldc_size1=(ldc_size-ldc_head_size);
-      eq_id = Int(ldc_off+ldc_head_size+pos_eqid, fEventData);     
-      //cout  << eq_id <<" ("<<ldc_size<<") ";     
+      ldcSize = Int(ldcOff+fgkPosLength, fEventData); //
+      //ldcSize1=(ldcSize-fgkLdcHeadSize);
+      eqId = Int(ldcOff+fgkLdcHeadSize+fgkEqId, fEventData);       
+      //cout  << eqId <<" ("<<ldcSize<<") ";       
       
-      ev_l1 = Int((4+ldc_off+pos_run), fEventData); //ev.nr.
-      if ( ev_l1 != event_nr ){
-       //cerr << "Eq_id " <<eq_id<<" event nr. mismatch? " << event_nr <<" / "<< ev_l1 <<" ...LDC data size (header:68) " <<ldc_size<<endl;
+      evL1 = Int((4+ldcOff+fgkPosRun), fEventData); //ev.nr.
+      if ( evL1 != eventNr ){
+       //cerr << "eqId " <<eqId<<" event nr. mismatch? " << eventNr <<" / "<< evL1 <<" ...LDC data size (header:68) " <<ldcSize<<endl;
       }
       
-      if (eq_id == 1024) {  //DDL data
-       fDdlOff = ldc_off; //+ldc_head_size+equip_head_size + 32;
-       fDdlSize = ldc_size;
+      if (eqId == 1024) {  //DDL data
+       fDdlOff = ldcOff; //+fgkLdcHeadSize+fgkEquipHeadSize + 32;
+       fDdlSize = ldcSize;
       }
       
-      if (eq_id == 550) {  //Si-strip data (+QDC)
+      if (eqId == 550) {  //Si-strip data (+QDC)
        //cout << "550" << endl;
-       fSiOff=ldc_off+ldc_head_size+equip_head_size+pos_sioff;
+       fSiOff=ldcOff+fgkLdcHeadSize+fgkEquipHeadSize+fgkPosSiOff;
        word = Int(fSiOff, fEventData);
-       Short_t LenSi1 = (word >> 16) & 0xffff;
-       Short_t LenSi2 = word & 0xffff;
-       fQdcOff=fSiOff+4*(LenSi1+LenSi2+1)+equip_head_size+4; 
+       Short_t lenSi1 = (word >> 16) & 0xffff;
+       Short_t lenSi2 = word & 0xffff;
+       fQdcOff=fSiOff+4*(lenSi1+lenSi2+1)+fgkEquipHeadSize+4; 
       } 
-      else if (eq_id == 1182) {  //QDC first...
+      else if (eqId == 1182) {  //QDC first...
        //cout << "1182" << endl;
-       fQdcOff=ldc_off+ldc_head_size+equip_head_size+pos_sioff;
-       fSiOff=fQdcOff+equip_head_size+4;
+       fQdcOff=ldcOff+fgkLdcHeadSize+fgkEquipHeadSize+fgkPosSiOff;
+       fSiOff=fQdcOff+fgkEquipHeadSize+4;
       }
       
-      ldc_off=ldc_size;
+      ldcOff=ldcSize;
       
     }
     //cout << endl;
@@ -198,8 +222,13 @@ Int_t AliTRDtestBeam::NextEvent() {
     fEventCount++; //event counter
     return true;
 }
+
 //____________________________________________________________________________
-Int_t AliTRDtestBeam::DecodeSi() {
+Int_t AliTRDtestBeam::DecodeSi() 
+{
+  //
+  // Decode the silicon detector
+  //
   
   if (fSiOff < 0) return 0;
   
@@ -226,7 +255,7 @@ Int_t AliTRDtestBeam::DecodeSi() {
   
   // reconstruction
 
-  int LenSiX = 640;
+  int aLenSiX = 640;
 
   int qmaxX; int amaxX;
   int qmaxY; int amaxY;
@@ -234,13 +263,13 @@ Int_t AliTRDtestBeam::DecodeSi() {
   qmaxX = 5;
   qmaxY = 5;
   amaxX = -1;
-  amaxY = -1+LenSiX;
+  amaxY = -1+aLenSiX;
  
   for( int i = 0; i < GetNSi1(); i++ ) {
  
     if (fSi1Address[i] == 0) continue; // noise
    
-    if (fSi1Address[i] < LenSiX ) {
+    if (fSi1Address[i] < aLenSiX ) {
       if( fSi1Charge[i] > qmaxX ) {
        qmaxX = fSi1Charge[i];
        amaxX = fSi1Address[i];
@@ -254,7 +283,7 @@ Int_t AliTRDtestBeam::DecodeSi() {
   }
   
   fX[0] = (float)(amaxX*0.05);  // [mm]
-  fY[0] = (float)((amaxY-LenSiX)*0.05);
+  fY[0] = (float)((amaxY-aLenSiX)*0.05);
   fQx[0] = (float)qmaxX;
   fQy[0] = (float)qmaxY;
   
@@ -262,14 +291,14 @@ Int_t AliTRDtestBeam::DecodeSi() {
   qmaxX = 5;
   qmaxY = 5;
   amaxX = -1;
-  amaxY = -1+LenSiX;
+  amaxY = -1+aLenSiX;
 
   for( int i = 0; i < GetNSi2(); i++ ) {
     
     if (fSi2Address[i] == 1279) continue; // noise
     if (fSi2Address[i] == 0) continue;    // noise
     
-    if(fSi2Address[i] < LenSiX) {
+    if(fSi2Address[i] < aLenSiX) {
       if( fSi2Charge[i] > qmaxX ) {
        qmaxX = fSi2Charge[i];
        amaxX = fSi2Address[i];
@@ -284,7 +313,7 @@ Int_t AliTRDtestBeam::DecodeSi() {
   }
   
   fX[1] = (float)(amaxX*0.05);  // [mm]
-  fY[1] = (float)((amaxY-LenSiX)*0.05);
+  fY[1] = (float)((amaxY-aLenSiX)*0.05);
   fQx[1] = (float)qmaxX;
   fQy[1] = (float)qmaxY;
   
@@ -296,10 +325,14 @@ Int_t AliTRDtestBeam::DecodeSi() {
 
   //cout << fCher << " " << fPb << endl;
   return 1;
+
 }
 //____________________________________________________________________________ 
-/**/
-AliTRDRawStreamTB *AliTRDtestBeam::GetTRDrawStream() {
+AliTRDRawStreamTB *AliTRDtestBeam::GetTRDrawStream() 
+{
+  //
+  // Get the TRD raw stream
+  //
   
   // needs AliTRDRawStreamTB  
   //cout << "Chamber reader:" << (Int_t)(fEventData+fDdlOff) << " " << fDdlSize << endl;
@@ -328,10 +361,13 @@ AliTRDRawStreamTB *AliTRDtestBeam::GetTRDrawStream() {
     
   */
 }
-/**/
-//____________________________________________________________________________ 
 
-Int_t AliTRDtestBeam::Int(Int_t i, Char_t *start) {
+//____________________________________________________________________________ 
+Int_t AliTRDtestBeam::Int(Int_t i, Char_t *start) 
+{
+  //
+  // ?????
+  //
   
   bool swap = kFALSE;
 
@@ -340,6 +376,7 @@ Int_t AliTRDtestBeam::Int(Int_t i, Char_t *start) {
     char p[] = {q[3], q[2], q[1], q[0]};
     return *((int*) p);
   } else return *((int*)(start+i));
+
 }
 
 //____________________________________________________________________________ 
index 41f4e71..2988a26 100644 (file)
@@ -9,7 +9,7 @@
 The class to read the test beam 2007 data
 */
 
-#define MAX_SI 2000
+//#define MAX_SI 2000
 
 #include "TObject.h"
 
@@ -20,74 +20,75 @@ using namespace std;
 class AliTRDtestBeam: public TObject {
 
 public:
+
   AliTRDtestBeam();       // ctor
   AliTRDtestBeam(const char *filename); // constructor
   //AliTRDtestBeam(const AliTRDtestBeam &tb);  
   //AliTRDtestBeam& operator = (const AliTRDtestBeam& tb) {return *this}
-  virtual ~AliTRDtestBeam() {;} // dtor
+  virtual ~AliTRDtestBeam(); // dtor
 
   Int_t NextEvent();
   
   AliTRDRawStreamTB *GetTRDrawStream(); // needs RawStreamTB
 
   // silicon
-  Short_t GetNSi1() {return fNSi1;}
-  Short_t GetNSi2() {return fNSi2;}
+  Short_t GetNSi1() const {return fNSi1;}
+  Short_t GetNSi2() const {return fNSi2;}
   
-  Int_t GetSi1Address(Int_t i) {return (i<fNSi1)? fSi1Address[i] : -1;};
-  Int_t GetSi2Address(Int_t i) {return (i<fNSi2)? fSi2Address[i] : -1;};
+  Int_t GetSi1Address(Int_t i) const {return (i<fNSi1)? fSi1Address[i] : -1;};
+  Int_t GetSi2Address(Int_t i) const {return (i<fNSi2)? fSi2Address[i] : -1;};
   
-  Int_t GetSi1Charge(Int_t i) {return (i<fNSi1)? fSi1Charge[i] : -1;};
-  Int_t GetSi2Charge(Int_t i) {return (i<fNSi2)? fSi1Charge[i] : -1;};
+  Int_t GetSi1Charge(Int_t i) const {return (i<fNSi1)? fSi1Charge[i] : -1;};
+  Int_t GetSi2Charge(Int_t i) const {return (i<fNSi2)? fSi1Charge[i] : -1;};
   
-  Double_t GetX(Int_t n) {return (n<2)? fX[n] : -1;}
-  Double_t GetY(Int_t n) {return (n<2)? fY[n] : -1;}
-  Double_t GetQx(Int_t n) {return (n<2)? fQx[n] : -1;}
-  Double_t GetQy(Int_t n) {return (n<2)? fQy[n] : -1;}
+  Double_t GetX(Int_t n)   const {return (n<2)? fX[n] : -1;}
+  Double_t GetY(Int_t n)   const {return (n<2)? fY[n] : -1;}
+  Double_t GetQx(Int_t n)  const {return (n<2)? fQx[n] : -1;}
+  Double_t GetQy(Int_t n)  const {return (n<2)? fQy[n] : -1;}
 
   // calo
-  Double_t GetCher() {return fCher;}
-  Double_t GetPb() {return fPb;}
+  Double_t GetCher() const {return fCher;}
+  Double_t GetPb() const {return fPb;}
 
 protected:
   
-  ifstream *fDataStream;
+  ifstream *fDataStream;      // input data stream
   
-  Bool_t fHeaderIsRead;
-  Int_t fEventCount;
-  Int_t fLimit; // = 4
-  Int_t fCurrent;
-
-  Int_t fDdlOff;
-  Int_t fSiOff;
-  Int_t fQdcOff;
-  Int_t fDdlSize;
-
-  Char_t *fFileHeader;
-  Char_t *fEventHeader;
-  Char_t *fEventData;
+  Bool_t fHeaderIsRead;       // do we read Header ?
+  Int_t fEventCount;          // number of events
+  Int_t fLimit;               // = 4
+  Int_t fCurrent;             // ...
+
+  Int_t fDdlOff;              // offset to DDL data
+  Int_t fSiOff;               // offset to Silicon data
+  Int_t fQdcOff;              // offset to Cherenkov and LeadGlass data
+  Int_t fDdlSize;             // size of DDL data
+  Char_t *fFileHeader;        // file header data
+  Char_t *fEventHeader;       // event header data 
+  Char_t *fEventData;         // actual event data
 
   // silicon data
   
-  Short_t fNSi1;
-  Short_t fNSi2;
+  Short_t fNSi1;              // number of fired silicon pads from Si1
+  Short_t fNSi2;              // fired pads in Si2 
   
-  Int_t fSi1Address[MAX_SI];
-  Int_t fSi2Address[MAX_SI];
+  Int_t fSi1Address[1270];  // addresses of fires silicon pads Si1
+  Int_t fSi2Address[1270];  // addresses if fires silicon pads Si2
   
-  Int_t fSi1Charge[MAX_SI];
-  Int_t fSi2Charge[MAX_SI];
+  Int_t fSi1Charge[1270];   // charge collected on Si1
+  Int_t fSi2Charge[1270];   // charge collected on Si2
   
   // reconstructed Silicon data 
 
-  Double_t fX[2];
-  Double_t fY[2];
-  Double_t fQx[2];
-  Double_t fQy[2];
+  Double_t fX[2];             // x position for Si1 and Si2
+  Double_t fY[2];             // y position
+  Double_t fQx[2];            // charge on X
+  Double_t fQy[2];            // charge on y 
 
   // cherenkov glass
-  Double_t fCher;
-  Double_t fPb;
+  Double_t fCher;             // cherenkov signal
+  Double_t fPb;               // lead glass signal
   
 
   // data reading
@@ -96,23 +97,24 @@ protected:
   Int_t DecodeSi();
 
   //
-  static const Long_t file_head_size; //= 544; // ?
-  static const Long_t event_head_size; // = 68; //?
-  static const Long_t ldc_head_size; // = 68; //?
-  static const Long_t equip_head_size; // = 28; //
-  static const Int_t vme_in; //=1; //VME event in
-  static const Int_t sim_in; //=1; //Si-strips in
+  static const Long_t fgkFileHeadSize; //= 544; // ?
+  static const Long_t fgkEventHeadSize; // = 68; //?
+  static const Long_t fgkLdcHeadSize; // = 68; //?
+  static const Long_t fgkEquipHeadSize; // = 28; //
+  static const Int_t fgkVmeIn; //=1; //VME event in
+  static const Int_t fgkSimIn; //=1; //Si-strips in
   
   //typedef char byte;
   
   //offsets in bytes
-  static const Int_t pos_run; // = 20; //run nr. (in file and event header)
-  static const Int_t pos_length; // = 0; //event/equip. length
-  static const Int_t pos_eqid; // = 8;  //equipment id.
-  static const Int_t pos_sioff; // = 12;  //Si data size offset (3 extra words!!!)
+  static const Int_t fgkPosRun; // = 20; //run nr. (in file and event header)
+  static const Int_t fgkPosLength; // = 0; //event/equip. length
+  static const Int_t fgkEqId; // = 8;  //equipment id.
+  static const Int_t fgkPosSiOff; // = 12;  //Si data size offset (3 extra words!!!)
 
   ClassDef(AliTRDtestBeam,1)  // description 
+
 };
 
-#endif // AliTRDQADatamaker_H
+#endif