Faster algorithms.
authorkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 24 Nov 2001 16:10:22 +0000 (16:10 +0000)
committerkowal2 <kowal2@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 24 Nov 2001 16:10:22 +0000 (16:10 +0000)
TPC/AliSimDigits.cxx
TPC/AliSimDigits.h
TPC/AliTPC.cxx
TPC/AliTPC.h
TPC/AliTPCDigitizer.cxx
TPC/AliTPCDigitizer.h

index a3fbba5..1929ef0 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.4  2000/10/05 16:01:49  kowal2
+Corrected for memory leaks.
+
 Revision 1.3  2000/06/30 12:07:49  kowal2
 Updated from the TPC-PreRelease branch
 
@@ -255,11 +258,16 @@ void  AliSimDigits::CompresTrackBuffer1()
   buf->Set(fNrows*fNcols*fNlevel); //lets have the nearly the "worst case"
   AliArrayI *  index = new AliArrayI;
   index->Set(fNcols*fNlevel);
+  //  Int_t * pindex = 
 
+  
   Int_t icurrent=-1;  //current index
   Int_t izero;      //number of zero
   Int_t inum;      //number of digits  with the same current track id  
-  Int_t lastID =0;  //last track id
+  Int_t lastID =0;  //last track id  
+  
+  Int_t *cbuff=fTracks->GetArray(); //MI change
+
   for (Int_t lev =0; lev<fNlevel; lev++){    //loop over levels 
     for (Int_t col = 0; col<fNcols; col++){    //loop over columns
       izero = 0;
@@ -267,8 +275,9 @@ void  AliSimDigits::CompresTrackBuffer1()
       lastID = 0;
       (*index)[lev*fNcols+col]=icurrent+1;//set collumn pointer
       Int_t id=0;  //current id
-      for (Int_t row = 0; row< fNrows;row++){ //loop over rows
-       id = GetTrackIDFast(row,col,lev);
+      for (Int_t row = 0; row< fNrows;row++){ //loop over rows        
+       id = *cbuff;  //MI change
+       //      id = GetTrackIDFast(row,col,lev);
        if (id <= 0) {
          if ( inum> 0 ) { //if we have some tracks in buffer
            icurrent++;
@@ -306,8 +315,8 @@ void  AliSimDigits::CompresTrackBuffer1()
          else {          
            inum++;
          }
-       
-      }//end of loop over rows
+       cbuff++;  //MI change
+      }//end of loop over row
       if ( izero > 0 ) { 
        //if we have currently izero count of non tracks digits
        icurrent++;       
index 8d8f3c5..f8c60cd 100644 (file)
@@ -22,6 +22,7 @@ public:
   AliSimDigits();
   virtual ~AliSimDigits();
   void AllocateTrack(Int_t length);  //construct empty buffer fTracks with size rows x column x length (number of tracks for one digit)
+  Int_t *GetTracks(){return fTracks->GetArray();}
   Int_t GetTrackIDFast(Int_t row, Int_t column,Int_t level);  //return track ID  at given row and collumn
   void  SetTrackIDFast(Int_t value,Int_t row, Int_t column,Int_t level);  //set ID track at given row and collumn
   virtual Int_t GetTrackID(Int_t row, Int_t column, Int_t level);
index bbfe600..62e3c80 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.47  2001/11/19 10:25:34  kowal2
+Nearest integer instead of integer when converting to ADC counts
+
 Revision 1.46  2001/11/07 06:47:12  kowal2
 Removed printouts
 
@@ -220,7 +223,9 @@ AliTPC::AliTPC()
   fDefaults = 0;
   fTrackHits = 0;  
   fHitType = 2;  
-  fTPCParam = 0; 
+  fTPCParam = 0;    
+  fNoiseTable = 0;
+
 }
  
 //_____________________________________________________________________________
@@ -244,6 +249,7 @@ AliTPC::AliTPC(const char *name, const char *title)
   fTrackHits->SetHitPrecision(0.002);
   fTrackHits->SetStepPrecision(0.003);  
   fTrackHits->SetMaxDistance(100); 
+  fNoiseTable =0;
 
   fHitType = 2;
   //
@@ -282,6 +288,8 @@ AliTPC::~AliTPC()
   delete fDigits;
   delete fTPCParam;
   delete fTrackHits; //MI 15.09.2000
+  if (fNoiseTable) delete [] fNoiseTable;
+
 }
 
 //_____________________________________________________________________________
@@ -811,6 +819,36 @@ void AliTPC::CreateMaterials()
     
 }
 
+void AliTPC::GenerNoise(Int_t tablesize)
+{
+  //
+  //Generate table with noise
+  //
+  if (fTPCParam==0) {
+    // error message
+    fNoiseDepth=0;
+    return;
+  }
+  if (fNoiseTable)  delete[] fNoiseTable;
+  fNoiseTable = new Float_t[tablesize];
+  fNoiseDepth = tablesize; 
+  fCurrentNoise =0; //!index of the noise in  the noise table 
+  
+  Float_t norm = fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac();
+  for (Int_t i=0;i<tablesize;i++) fNoiseTable[i]= gRandom->Gaus(0,norm);      
+}
+
+Float_t AliTPC::GetNoise()
+{
+  // get noise from table
+  //  if ((fCurrentNoise%10)==0) 
+  //  fCurrentNoise= gRandom->Rndm()*fNoiseDepth;
+  if (fCurrentNoise>=fNoiseDepth) fCurrentNoise=0;
+  return fNoiseTable[fCurrentNoise++];
+  //gRandom->Gaus(0, fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac()); 
+}
+
+
 
 void AliTPC::Digits2Clusters(TFile *of, Int_t eventnumber)
 {
@@ -1220,7 +1258,7 @@ void AliTPC::Hits2ExactClustersSector(Int_t isec)
 void AliTPC::SDigits2Digits2(Int_t eventnumber)  
 {
   //create digits from summable digits
-
+  GenerNoise(500000); //create teble with noise
   char  sname[100];
   char  dname[100];
   sprintf(sname,"TreeS_%s_%d",fTPCParam->GetTitle(),eventnumber);
@@ -1268,23 +1306,38 @@ void AliTPC::SDigits2Digits2(Int_t eventnumber)
     digarr.ExpandTrackBuffer();
 
     
-    for (Int_t rows=0;rows<nrows; rows++){
-      for (Int_t col=0;col<ncols; col++){
-       Float_t  q  = digarr.GetDigitFast(rows,col);
-       //add noise
-       q = gRandom->Gaus(q,fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac()*16); 
-       q/=16;  //conversion faktor
-        q=(Short_t)q; // digits are short integers
+    Short_t * pamp0 = digarr.GetDigits();
+    Int_t   * ptracks0 = digarr.GetTracks();
+    Short_t * pamp1 = digrow->GetDigits();
+    Int_t   * ptracks1 = digrow->GetTracks();
+    Int_t  nelems =nrows*ncols;
+    Int_t saturation = fTPCParam->GetADCSat();
+    //use internal structure of the AliDigits - for speed reason
+    //if you cahnge implementation
+    //of the Alidigits - it must be rewriten -
+    for (Int_t i= 0; i<nelems; i++){
+      //      Float_t q = *pamp0;
+      //q/=16.;  //conversion faktor
+      //Float_t noise= GetNoise(); 
+      //q+=noise;      
+      //q= TMath::Nint(q);
+      Float_t q = TMath::Nint(Float_t(*pamp0)/16.+GetNoise());
+      if (q>zerosup){
+       if (q>saturation) q=saturation;      
+       *pamp1=(Short_t)q;
+       //if (ptracks0[0]==0)
+       //  ptracks1[0]=1;
+       //else
+       ptracks1[0]=ptracks0[0];        
+       ptracks1[nelems]=ptracks0[nelems];
+       ptracks1[2*nelems]=ptracks0[2*nelems];
+      }
+      pamp0++;
+      pamp1++;
+      ptracks0++;
+      ptracks1++;       
+    }
 
-       if (q > zerosup){
-          if(q > fTPCParam->GetADCSat()) q = (Short_t)(fTPCParam->GetADCSat());
-         digrow->SetDigitFast(q,rows,col);  
-         for (Int_t tr=0;tr<3;tr++)    
-          
-((AliSimDigits*)digrow)->SetTrackIDFast(digarr.GetTrackIDFast(rows,col,tr)-2,rows,col,tr);
-       }
-       }   
-      }        
     arr->StoreRow(sec,row);
     arr->ClearRow(sec,row);   
     // cerr<<sec<<"\t"<<row<<"\n";   
@@ -1475,6 +1528,7 @@ void AliTPC::Hits2Digits(Int_t eventnumber)
 
 
   if(fDefaults == 0) SetDefaults();  // check if the parameters are set
+  GenerNoise(500000); //create teble with noise
 
   //setup TPCDigitsArray 
 
@@ -1520,7 +1574,7 @@ void AliTPC::Hits2SDigits2(Int_t eventnumber)
 
 
   if(fDefaults == 0) SetDefaults();
-
+  GenerNoise(500000); //create table with noise
   //setup TPCDigitsArray 
 
   if(GetDigitsArray()) delete GetDigitsArray();
@@ -1749,8 +1803,8 @@ void AliTPC::DigitizeRow(Int_t irow,Int_t isec,TObjArray **rows)
 
       if(fDigitsSwitch == 0){
 
-        q = gRandom->Gaus(q,fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac()); 
-
+       //        q = gRandom->Gaus(q,fTPCParam->GetNoise()*fTPCParam->GetNoiseNormFac()); 
+       q+=GetNoise();
         q = TMath::Nint(q);
 
         if(q <=zerosup) continue; // do not fill zeros
@@ -1770,7 +1824,7 @@ void AliTPC::DigitizeRow(Int_t irow,Int_t isec,TObjArray **rows)
       //    
 
       for(Int_t j1=0;j1<3;j1++){
-        tracks[j1] = (pList[gi]) ?(Int_t)(*(pList[gi]+j1)) : -1;
+       tracks[j1] = (pList[gi]) ?(Int_t)(*(pList[gi]+j1)) : -2;
       }
 
 //Begin_Html
index 5bf32c7..d613991 100644 (file)
@@ -121,6 +121,8 @@ public:
    void SetDigitsSwitch(Int_t sw){fDigitsSwitch = sw;}
    void SetDefSwitch(Int_t def){fDefaults = def;}
    virtual void  Merge(TTree * intree, Int_t *mask, Int_t nin, Int_t outid);
+   Float_t GetNoise();  //get Current noise  
+   void    GenerNoise(Int_t tablasize);  // make noise table
 
 private:
   //
@@ -136,7 +138,11 @@ private:
                          // index[1] sector number, 
                          // index[2] pad row number  
                          // index[3] pad row number for which signal is calculated
-  
+  Int_t      fNoiseDepth;  //!noise table
+  Float_t *  fNoiseTable;  //![fNoiseDepth] table with noise
+  Int_t      fCurrentNoise; //!index of the noise in  the noise table 
+
+
   ClassDef(AliTPC,4)  // Time Projection Chamber class
 };
 
index 618c6e8..7d54fa9 100644 (file)
@@ -13,9 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/*
-$Log$
-*/
+
 
 #include <TTree.h> 
 #include <TObjArray.h>
@@ -83,11 +81,19 @@ void AliTPCDigitizer::Exec(Option_t* option)
   //get detector and geometry
   AliTPC *pTPC  = (AliTPC *) gAlice->GetModule("TPC");
   AliTPCParam * param = pTPC->GetParam();
-
+  pTPC->GenerNoise(500000); //create teble with noise
   printf("noise %f \n",  param->GetNoise()*param->GetNoiseNormFac());
+  //
+  Int_t nInputs = fManager->GetNinputs();
+  Int_t * masks = new Int_t[nInputs];
+  for (Int_t i=0; i<nInputs;i++)
+    masks[i]= fManager->GetMask(i);
+  Short_t **pdig= new Short_t*[nInputs];   //pointers to the expanded digits array
+  Int_t **ptr=  new Int_t*[nInputs];       //pointers to teh expanded tracks array
+
   //create digits array for given sectors
-  AliSimDigits ** digarr = new AliSimDigits*[fManager->GetNinputs()]; 
-  for (Int_t i1=0;i1<fManager->GetNinputs(); i1++){
+  AliSimDigits ** digarr = new AliSimDigits*[nInputs]; 
+  for (Int_t i1=0;i1<nInputs; i1++){
     digarr[i1]=0;
     //    intree[i1]
     TTree * treear =  fManager->GetInputTreeTPCS(i1);
@@ -102,17 +108,20 @@ void AliTPCDigitizer::Exec(Option_t* option)
   //create branch's in TPC treeD
   AliSimDigits * digrow = new AliSimDigits;
   TTree * tree  = fManager->GetTreeDTPC();
-  if (tree->GetBranch("Segment") ) tree->GetBranch("Segment")->SetAddress(&digrow);
-  else
-    tree->Branch("Segment","AliSimDigits",&digrow);
+  //if (tree->GetBranch("Segment") ) tree->GetBranch("Segment")->SetAddress(&digrow);
+  //else
+  tree->Branch("Segment","AliSimDigits",&digrow);
   //
 
+  param->SetZeroSup(2);
+
   Int_t zerosup = param->GetZeroSup();
   //Loop over segments of the TPC
     
   for (Int_t n=0; n<nentries; n++) {
-    
-    for (Int_t i=0;i<fManager->GetNinputs(); i++){ 
+  //    for (Int_t n=0; n<300; n++) {
+           
+    for (Int_t i=0;i<nInputs; i++){ 
       fManager->GetInputTreeTPCS(i)->GetEvent(n);      
       digarr[i]->ExpandBuffer();
       digarr[i]->ExpandTrackBuffer();
@@ -132,50 +141,75 @@ void AliTPCDigitizer::Exec(Option_t* option)
     digrow->Allocate(nrows,ncols);
     digrow->AllocateTrack(3);
 
-    for (Int_t rows=0;rows<nrows; rows++){
-      for (Int_t col=0;col<ncols; col++){
-        Float_t q=0;
-        Int_t label[1000]; //stack for 300 events 
-        Int_t labptr = 0;
-        // looop over digits
-        for (Int_t i=0;i<fManager->GetNinputs(); i++){ 
-          q  += digarr[i]->GetDigitFast(rows,col);
+    Float_t q=0;
+    Int_t label[1000]; //stack for 300 events 
+    Int_t labptr = 0;
+
+    
+    for (Int_t i=0;i<nInputs; i++){ 
+      pdig[i] = digarr[i]->GetDigits();
+      ptr[i]  = digarr[i]->GetTracks();
+    }
+    Short_t *pdig1= digrow->GetDigits();
+    Int_t   *ptr1= digrow->GetTracks() ;
+
+    Int_t nElems = nrows*ncols;      
+
+    //    for (Int_t rows=0;rows<nrows; rows++){
+    //  for (Int_t col=0;col<ncols; col++){
+    for (Int_t elem=0;elem<nElems; elem++){
+
+       q=0;
+       labptr=0;
+       // looop over digits 
+        for (Int_t i=0;i<nInputs; i++){ 
+         //          q  += digarr[i]->GetDigitFast(rows,col);
+          q  += *(pdig[i]);
+         
           for (Int_t tr=0;tr<3;tr++) {
-            Int_t lab = digarr[i]->GetTrackIDFast(rows,col,tr);
+           //             Int_t lab = digarr[i]->GetTrackIDFast(rows,col,tr);
+           Int_t lab = ptr[i][tr*nElems];
             if ( lab > 1) {
-              label[labptr]=lab+fManager->GetMask(i)-2;
+              label[labptr]=lab+masks[i];
               labptr++;
-            }
+            }     
           }
+         pdig[i]++;
+         ptr[i]++;
+         
         }
-        //add noise
        q/=16.;  //conversion factor
-       Float_t noise  = gRandom->Gaus(0,param->GetNoise()*param->GetNoiseNormFac());     
-       //printf("%f\n",noise);
+       //      Float_t noise  = gRandom->Gaus(0,param->GetNoise()*param->GetNoiseNormFac());  
+       Float_t noise  = pTPC->GetNoise();
        q+=noise;
         q=TMath::Nint(q);
-       printf("%f\n",q);
-
-        if (q <= zerosup)continue;
+        if (q > zerosup){ 
          
-       if(q > param->GetADCSat()) q = (Short_t)(param->GetADCSat());
-       digrow->SetDigitFast((Short_t)q,rows,col);  
-       
-       for (Int_t tr=0;tr<3;tr++){
-         if (tr<labptr)
-           ((AliSimDigits*)digrow)->SetTrackIDFast(label[tr],rows,col,tr);
-         else
-           ((AliSimDigits*)digrow)->SetTrackIDFast(-1,rows,col,tr);          
-        }
-      } 
+         if(q > param->GetADCSat()) q = (Short_t)(param->GetADCSat());
+         //digrow->SetDigitFast((Short_t)q,rows,col);  
+         *pdig1 =Short_t(q);
+         for (Int_t tr=0;tr<3;tr++){
+           if (tr<labptr) 
+             //  ((AliSimDigits*)digrow)->SetTrackIDFast(label[tr],rows,col,tr);
+             ptr1[tr*nElems] = label[tr];
+           //else
+             //            ((AliSimDigits*)digrow)->SetTrackIDFast(-1,rows,col,tr);          
+           //  ptr1[tr*nElems] = 1;
+         }
+       }
+       pdig1++;
+       ptr1++;
     }
+    
     digrow->CompresBuffer(1,zerosup);
     digrow->CompresTrackBuffer(1);
     tree->Fill();
     if (fDebug>0) cerr<<sec<<"\t"<<row<<"\n";  
   }
+  fManager->GetTreeDTPC()->Write(0,TObject::kOverwrite);
   delete digrow;     
-  for (Int_t ii1=0;ii1<fManager->GetNinputs(); ii1++) delete digarr[ii1];
+  for (Int_t i1=0;i1<nInputs; i1++) delete digarr[i1];
+  delete []masks;
   delete digarr;  
 }
 
index db2433b..9933989 100644 (file)
@@ -3,8 +3,6 @@
 /* Copyright(c) 1998-2001, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-/* $Id$ */
-
 #include "AliDigitizer.h"
 
 class AliRunDigitizer;