06-jul-2004 NvE AliCalorimeter hit I/O only via the linear array to decrease filesize...
authornick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Jul 2004 13:34:17 +0000 (13:34 +0000)
committernick <nick@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Jul 2004 13:34:17 +0000 (13:34 +0000)
                and improve I/O speed.
                Internal temp. arrays used for hit sorting in AliDevice and AliEvent and array
                pointers returned instead of the arrays themselves. This will provide more
                flexibility in usage.
                Sorting and clustering procedures in AliCalorimeter modified to use TObjArray pointers
                to enable direct use of the AliDevice linear sorting facility.
                Default for AliDevice changed such that now all registered hits are by default owned
                by the AliDevice object.

RALICE/AliCalorimeter.cxx
RALICE/AliCalorimeter.h
RALICE/AliDevice.cxx
RALICE/AliDevice.h
RALICE/AliEvent.cxx
RALICE/AliEvent.h
RALICE/history.txt

index 5835370..56ef431 100644 (file)
@@ -189,7 +189,7 @@ AliCalorimeter::AliCalorimeter(const AliCalorimeter& c) : AliDevice(c)
   {
    for (Int_t icol=1; icol<=ncols; icol++)
    {
-    AliPosition* p=c.GetPosition(irow,icol);
+    AliPosition* p=(AliPosition*)(c.fPositions->GetObject(irow,icol));
     if (p) SetPosition(irow,icol,*p);
    } 
   }  
@@ -221,19 +221,6 @@ AliCalorimeter::AliCalorimeter(const AliCalorimeter& c) : AliDevice(c)
   }
  }
 
- n=c.GetNsignals();
- if (n)
- {
-  fMatrix=new AliObjMatrix();
-  fMatrix->SetOwner();
-  fMatrix->SetSwapMode(fSwap);
-  for (Int_t im=1; im<=n; im++)
-  {
-   AliCalmodule* m=c.GetModule(im);
-   if (m) fMatrix->EnterObject(m->GetRow(),m->GetColumn(),new AliCalmodule(*m));
-  }
- }
-
  n=c.GetNvetos();
  for (Int_t iv=1; iv<=n; iv++)
  {
@@ -242,18 +229,20 @@ AliCalorimeter::AliCalorimeter(const AliCalorimeter& c) : AliDevice(c)
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetNrows() const
+Int_t AliCalorimeter::GetNrows()
 {
 // Provide the number of rows for the calorimeter module matrix
  Int_t nrows=fNrows;
+ if (!fMatrix) LoadMatrix();
  if (fMatrix && !nrows) nrows=fMatrix->GetMaxRow();
  return nrows;
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetNcolumns() const
+Int_t AliCalorimeter::GetNcolumns()
 {
 // Provide the number of columns for the calorimeter module matrix
  Int_t ncols=fNcolumns;
+ if (!fMatrix) LoadMatrix();
  if (fMatrix && !ncols) ncols=fMatrix->GetMaxColumn();
  return ncols;
 }
@@ -270,40 +259,44 @@ void AliCalorimeter::SetSignal(Int_t row,Int_t col,Float_t sig)
   if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
   return;
  }
+
+ if (!fMatrix) LoadMatrix();
+
  if (!fMatrix)
  {
   fMatrix=new AliObjMatrix();
-  fMatrix->SetOwner();
   fMatrix->SetSwapMode(fSwap);
  }
 
- AliCalmodule* m=GetModule(row,col);
- if (!m) // initialise for a new module
+ AliCalmodule* mx=GetModule(row,col);
+ if (mx) // Existing module
  {
-  m=new AliCalmodule();
-  m->SetRow(row);
-  m->SetColumn(col);
+  mx->SetSignal(sig);
+ }
+ else // Initialise for a new module
+ {
+  AliCalmodule m;
+  m.SetRow(row);
+  m.SetColumn(col);
+  m.SetSignal(sig);
   AliPosition* r=0;
   if (fPositions) r=(AliPositionObj*)fPositions->GetObject(row,col);
-  if (r) m->SetPosition(*r);
+  if (r) m.SetPosition(*r);
   if (fAttributes)
   {
    AliAttribObj* a=0;
    if (row <= fAttributes->GetSize()) a=(AliAttribObj*)fAttributes->At(row-1);
    if (a)
    {
-    if (a->GetGainFlag(col)) m->SetGain(a->GetGain(col));
-    if (a->GetOffsetFlag(col)) m->SetOffset(a->GetOffset(col));
-    if (a->GetDeadValue(col)) m->SetDead();
-    if (a->GetEdgeValue(col)) m->SetEdgeValue(a->GetEdgeValue(col));
+    if (a->GetGainFlag(col)) m.SetGain(a->GetGain(col));
+    if (a->GetOffsetFlag(col)) m.SetOffset(a->GetOffset(col));
+    if (a->GetDeadValue(col)) m.SetDead();
+    if (a->GetEdgeValue(col)) m.SetEdgeValue(a->GetEdgeValue(col));
    }
   }
-  fMatrix->EnterObject(row,col,m);
+  AddHit(m);
+  fMatrix->EnterObject(row,col,fHits->Last());
  }
-
- m->SetSignal(sig);
- AddHit(m);
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliCalorimeter::AddSignal(Int_t row, Int_t col, Float_t sig)
@@ -356,43 +349,44 @@ void AliCalorimeter::AddSignal(AliCalmodule* mod)
   if (fNrows && fNcolumns) cout << " Nrows,Ncols = " << fNrows << "," << fNcolumns << endl;
   return;
  }
+
+ if (!fMatrix) LoadMatrix();
  
  if (!fMatrix)
  {
   fMatrix=new AliObjMatrix();
-  fMatrix->SetOwner();
   fMatrix->SetSwapMode(fSwap);
  }
 
- AliCalmodule* m=GetModule(row,col);
- if (!m) // No module existed yet at this position
+ AliCalmodule* mx=GetModule(row,col);
+ if (!mx) // No module existed yet at this position
  {
-  m=new AliCalmodule(*mod);
+  AliCalmodule m(*mod);
   AliPosition* r=0;
   if (fPositions) r=(AliPositionObj*)fPositions->GetObject(row,col);
-  if (r) m->SetPosition(*r);
+  if (r) m.SetPosition(*r);
   // Don't take the dead and edge attributes from this module,
   // but from the calorimeter dbase, if present.
-  m->SetEdgeOff();
-  m->SetAlive();
+  m.SetEdgeOff();
+  m.SetAlive();
   if (fAttributes)
   {
    AliAttribObj* a=0;
    if (row <= fAttributes->GetSize()) a=(AliAttribObj*)fAttributes->At(row-1);
    if (a)
    {
-    if (a->GetGainFlag(col)) m->SetGain(a->GetGain(col));
-    if (a->GetOffsetFlag(col)) m->SetOffset(a->GetOffset(col));
-    if (a->GetDeadValue(col)) m->SetDead();
-    if (a->GetEdgeValue(col)) m->SetEdgeValue(a->GetEdgeValue(col));
+    if (a->GetGainFlag(col)) m.SetGain(a->GetGain(col));
+    if (a->GetOffsetFlag(col)) m.SetOffset(a->GetOffset(col));
+    if (a->GetDeadValue(col)) m.SetDead();
+    if (a->GetEdgeValue(col)) m.SetEdgeValue(a->GetEdgeValue(col));
    }
   }
-  fMatrix->EnterObject(row,col,m);
   AddHit(m);
+  fMatrix->EnterObject(row,col,fHits->Last());
  }
  else
  {
-  m->AddSignal(sig);
+  mx->AddSignal(sig);
  }
 }
 ///////////////////////////////////////////////////////////////////////////
@@ -439,6 +433,8 @@ void AliCalorimeter::Reset(Int_t mode)
   return;
  }
 
+ AliDevice::Reset(mode);
+
  if (fClusters)
  {
   delete fClusters;
@@ -488,11 +484,9 @@ void AliCalorimeter::Reset(Int_t mode)
    fHclusters=0;
   }
  }
-
- AliDevice::Reset(mode);
 }
 ///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetSignal(Int_t row,Int_t col,Int_t mode) const
+Float_t AliCalorimeter::GetSignal(Int_t row,Int_t col,Int_t mode)
 {
 // Provide the signal of a certain calorimeter module.
 // In case the module was marked dead, 0 is returned.
@@ -882,7 +876,7 @@ void AliCalorimeter::SetPosition(Int_t row,Int_t col,Ali3Vector& r)
  if (m) m->SetPosition(r);
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetEdgeValue(Int_t row,Int_t col) const
+Int_t AliCalorimeter::GetEdgeValue(Int_t row,Int_t col)
 {
 // Provide the value of the edge flag of a certain module.
 
@@ -918,7 +912,7 @@ Int_t AliCalorimeter::GetEdgeValue(Int_t row,Int_t col) const
  return edge;
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetDeadValue(Int_t row,Int_t col) const
+Int_t AliCalorimeter::GetDeadValue(Int_t row,Int_t col)
 {
 // Provide the value of the dead flag of a certain module
 
@@ -954,7 +948,7 @@ Int_t AliCalorimeter::GetDeadValue(Int_t row,Int_t col) const
  return dead;
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetGainFlag(Int_t row,Int_t col) const
+Int_t AliCalorimeter::GetGainFlag(Int_t row,Int_t col)
 {
 // Provide the value of the gain flag of a certain module.
 
@@ -990,7 +984,7 @@ Int_t AliCalorimeter::GetGainFlag(Int_t row,Int_t col) const
  return gf;
 }
 ///////////////////////////////////////////////////////////////////////////
-Int_t AliCalorimeter::GetOffsetFlag(Int_t row,Int_t col) const
+Int_t AliCalorimeter::GetOffsetFlag(Int_t row,Int_t col)
 {
 // Provide the value of the offset flag of a certain module.
 
@@ -1026,7 +1020,7 @@ Int_t AliCalorimeter::GetOffsetFlag(Int_t row,Int_t col) const
  return of;
 }
 ///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetGain(Int_t row,Int_t col) const
+Float_t AliCalorimeter::GetGain(Int_t row,Int_t col)
 {
 // Provide the gain value of a certain module.
 // See the memberfunction GetSignal() for a definition of the gain value.
@@ -1074,7 +1068,7 @@ Float_t AliCalorimeter::GetGain(Int_t row,Int_t col) const
  return gain;
 }
 ///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetOffset(Int_t row,Int_t col) const
+Float_t AliCalorimeter::GetOffset(Int_t row,Int_t col)
 {
 // Provide the offset value of a certain module.
 // See the memberfunction GetSignal() for a definition of the offset value.
@@ -1122,7 +1116,7 @@ Float_t AliCalorimeter::GetOffset(Int_t row,Int_t col) const
  return offset;
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::GetPosition(Int_t row,Int_t col,Float_t* vec,TString f) const
+void AliCalorimeter::GetPosition(Int_t row,Int_t col,Float_t* vec,TString f)
 {
 // Return the position in user coordinates for a certain calorimeter module
  vec[0]=0;
@@ -1133,7 +1127,7 @@ void AliCalorimeter::GetPosition(Int_t row,Int_t col,Float_t* vec,TString f) con
  if (p) p->GetVector(vec,f);
 }
 ///////////////////////////////////////////////////////////////////////////
-AliPosition* AliCalorimeter::GetPosition(Int_t row,Int_t col) const
+AliPosition* AliCalorimeter::GetPosition(Int_t row,Int_t col)
 {
 // Access to the position of a certain calorimeter module.
 
@@ -1146,8 +1140,6 @@ AliPosition* AliCalorimeter::GetPosition(Int_t row,Int_t col) const
   return 0;
  }
 
- if (!fPositions && !fMatrix) return 0;
-
  AliPositionObj* po=0;
  if (fPositions) po=(AliPositionObj*)fPositions->GetObject(row,col);
  if (po) return po;
@@ -1156,7 +1148,7 @@ AliPosition* AliCalorimeter::GetPosition(Int_t row,Int_t col) const
  return m;
 }
 ///////////////////////////////////////////////////////////////////////////
-Float_t AliCalorimeter::GetClusteredSignal(Int_t row,Int_t col) const
+Float_t AliCalorimeter::GetClusteredSignal(Int_t row,Int_t col)
 {
 // Provide the module signal after clustering.
 
@@ -1182,9 +1174,7 @@ Int_t AliCalorimeter::GetNsignals() const
 // Provide the number of modules that contain a signal
 // Note : The number of modules marked 'dead' but which had a signal
 //        are included.
- Int_t nsig=0;
- if (fMatrix) nsig=fMatrix->GetNobjects();
- return nsig;
+ return GetNhits();
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliCalorimeter::Group(Int_t n,Int_t mode)
@@ -1210,6 +1200,14 @@ void AliCalorimeter::Group(Int_t n,Int_t mode)
   mode=1;
  }
 
+ if (fClusters)
+ {
+  delete fClusters;
+  fClusters=0;
+ }
+
+ if (!fMatrix) LoadMatrix();
+
  if (!fMatrix) return;
  
  Int_t nsignals=GetNsignals();
@@ -1218,31 +1216,26 @@ void AliCalorimeter::Group(Int_t n,Int_t mode)
   if (GetNclusters() > 0) Ungroup(); // Restore unclustered situation if needed
  
   // Order the modules with decreasing signal
-  AliCalmodule** ordered=new AliCalmodule*[nsignals]; // temp. array for ordered modules
+  if (mode==1) SortM(); 
+  if (mode==2) SortA();
+
   Int_t nord=0;
-  if (mode==1) SortM(ordered,nord);
-  if (mode==2) SortA(ordered,nord);
+  if (fOrdered) nord=fOrdered->GetEntries();
  
   // Clustering of modules. Start with the highest signal.
-  if (fClusters)
-  {
-   delete fClusters;
-   fClusters=0;
-  }
   fClusters=new TObjArray();
   fClusters->SetOwner();
   Int_t row=0;
   Int_t col=0;
   AliCalcluster* c=0;
-  AliCalmodule* m=0;
   for (Int_t i=0; i<nord; i++)
   {
-   row=ordered[i]->GetRow();    // row number of cluster center
-   col=ordered[i]->GetColumn(); // column number of cluster center
-
-   m=(AliCalmodule*)fMatrix->GetObject(row,col);
+   AliCalmodule* m=(AliCalmodule*)fOrdered->At(i);
    if (!m) continue;
 
+   row=m->GetRow();    // row number of cluster center
+   col=m->GetColumn(); // column number of cluster center
+
    // only use modules not yet used in a cluster
    if (m->GetClusteredSignal() > 0.)
    {
@@ -1261,20 +1254,10 @@ void AliCalorimeter::Group(Int_t n,Int_t mode)
     }
    }
   }
-  // Delete the temp. array
-  if (ordered)
-  { 
-   for (Int_t j=0; j<nord; j++)
-   {
-    ordered[j]=0;
-   }
-   delete [] ordered;
-  }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SortM(AliCalmodule** ordered,Int_t& nord)
+void AliCalorimeter::SortM()
 {
 // Order the modules with decreasing signal by looping over the (row,col) grid
 // of the matrix.
@@ -1301,23 +1284,37 @@ void AliCalorimeter::SortM(AliCalmodule** ordered,Int_t& nord)
 // ---------------
 // * In case of a very high occupancy, there might be a slight effect on the
 //   cluster signals depending on the geometrical location in the detector matrix.
+
+ if (fOrdered)
+ {
+  delete fOrdered;
+  fOrdered=0;
+ }
+
  Int_t nrows=fMatrix->GetMaxRow();
  Int_t ncols=fMatrix->GetMaxColumn();
 
  Float_t signal=0.;
- nord=0;
+ Int_t nord=0;
  for (Int_t irow=1; irow<=nrows; irow++) // loop over all modules of the matrix
  {
   for (Int_t icol=1; icol<=ncols; icol++)
   {
-   signal=GetSignal(irow,icol,1); // get the gain etc... corrected signal
-   if (signal <= 0.) continue;    // only take alive modules with a signal
+   AliCalmodule* m=(AliCalmodule*)fMatrix->GetObject(irow,icol);
+   if (!m) continue;
+
+   signal=m->GetSignal(1,1);   // get the gain etc... corrected signal
+   if (signal <= 0.) continue; // only take alive modules with a signal
  
    if (nord == 0) // store the first module with a signal at the first ordered position
    {
+    if (!fOrdered)
+    {
+     Int_t nhits=GetNhits();
+     fOrdered=new TObjArray(nhits);
+    }
     nord++;
-    ordered[nord-1]=(AliCalmodule*)fMatrix->GetObject(irow,icol);
+    fOrdered->AddAt(m,nord-1);
     continue;
    }
  
@@ -1326,25 +1323,25 @@ void AliCalorimeter::SortM(AliCalmodule** ordered,Int_t& nord)
     if (j == nord) // module has smallest signal seen so far
     {
      nord++;
-     ordered[j]=(AliCalmodule*)fMatrix->GetObject(irow,icol); // add module at the end
+     fOrdered->AddAt(m,j); // add module at the end
      break; // go for next matrix module
     }
  
-    if (signal < ordered[j]->GetSignal(1,1)) continue;
+    if (signal < ((AliCalmodule*)fOrdered->At(j))->GetSignal(1,1)) continue;
  
     nord++;
     for (Int_t k=nord-1; k>j; k--) // create empty position
     {
-     ordered[k]=ordered[k-1];
+     fOrdered->AddAt(fOrdered->At(k-1),k);
     }
-    ordered[j]=(AliCalmodule*)fMatrix->GetObject(irow,icol); // put module at empty position
+    fOrdered->AddAt(m,j); // put module at empty position
     break; // go for next matrix module
    }
   }
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-void AliCalorimeter::SortA(AliCalmodule** ordered,Int_t& nord)
+void AliCalorimeter::SortA()
 {
 // Order the modules with decreasing signal by looping over the linear array
 // of fired modules.
@@ -1371,45 +1368,8 @@ void AliCalorimeter::SortA(AliCalmodule** ordered,Int_t& nord)
 //   of the resulting cluster signal.
 // * This method might produce results depending on the filling
 //   order of the matrix modules.
- Int_t nmods=0;
- if (fMatrix) nmods=fMatrix->GetNobjects();
-
- nord=0;
- for (Int_t i=1; i<=nmods; i++) // loop over all fired modules of the matrix
- {
-  AliCalmodule* m=(AliCalmodule*)fMatrix->GetObject(i);
 
-  if (!m) continue;
-  if (m->GetDeadValue()) continue; // only take alive modules with a signal
-  if (nord == 0) // store the first module with a signal at the first ordered position
-  {
-   nord++;
-   ordered[nord-1]=m;
-   continue;
-  }
-  for (Int_t j=0; j<=nord; j++) // put module in the right ordered position
-  {
-   if (j == nord) // module has smallest signal seen so far
-   {
-    nord++;
-    ordered[j]=m; // add module at the end
-    break; // go for next matrix module
-   }
-   if (m->GetSignal(1,1) < ordered[j]->GetSignal(1,1)) continue;
-   nord++;
-   for (Int_t k=nord-1; k>j; k--) // create empty position
-   {
-    ordered[k]=ordered[k-1];
-   }
-   ordered[j]=m; // put module at empty position
-   break; // go for next matrix module
-  }
- }
+ SortHits();
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliCalorimeter::AddRing(Int_t row, Int_t col, Int_t n)
@@ -1481,26 +1441,17 @@ AliCalmodule* AliCalorimeter::GetModule(Int_t j) const
 // Provide 'fired' module number j
 // Note : j=1 denotes the first 'fired' module
 
- if (!fMatrix) return 0;
-
- if ((j >= 1) && (j <= GetNsignals()))
- {
-  return (AliCalmodule*)fMatrix->GetObject(j);
- }
- else
- {
-  cout << " *AliCalorimeter::GetModule* module number : " << j
-       << " out of range ==> 0 returned." << endl;
-  return 0;
- }
+ AliCalmodule* m=(AliCalmodule*)GetHit(j);
+ return m;
 }
 ///////////////////////////////////////////////////////////////////////////
-AliCalmodule* AliCalorimeter::GetModule(Int_t row,Int_t col) const
+AliCalmodule* AliCalorimeter::GetModule(Int_t row,Int_t col)
 {
 // Provide access to module (row,col).
 // Note : first module is at (1,1).
 
  AliCalmodule* m=0;
+ if (!fMatrix) LoadMatrix();
  if (fMatrix) m=(AliCalmodule*)fMatrix->GetObject(row,col);
  return m;
 }
@@ -1516,6 +1467,8 @@ TH2F* AliCalorimeter::DrawModules(Float_t thresh,Int_t mode)
  Int_t nrows=fNrows;
  Int_t ncols=fNcolumns;
 
+ if (!fMatrix) LoadMatrix();
+
  if (fMatrix && !nrows && !ncols)
  {
   nrows=fMatrix->GetMaxRow();
@@ -1566,6 +1519,8 @@ TH2F* AliCalorimeter::DrawClusters(Float_t thresh)
  Int_t nrows=fNrows;
  Int_t ncols=fNcolumns;
 
+ if (!fMatrix) LoadMatrix();
+
  if (fMatrix && !nrows && !ncols)
  {
   nrows=fMatrix->GetMaxRow();
@@ -1607,6 +1562,8 @@ void AliCalorimeter::Ungroup()
 {
 // Set the module signals back to the non-clustered situation
 
+ if (!fMatrix) LoadMatrix();
+
  if (!fMatrix) return;
  
  Int_t nsig=GetNsignals();
@@ -1684,6 +1641,30 @@ Int_t AliCalorimeter::GetMatrixSwapMode() const
  return fSwap;
 }
 ///////////////////////////////////////////////////////////////////////////
+void AliCalorimeter::LoadMatrix()
+{
+// Load the matrix lookup table of module pointers from the linear hit array.
+ Int_t nhits=GetNhits();
+ if (!nhits) return;
+
+ fMatrix=new AliObjMatrix();
+ fMatrix->SetSwapMode(fSwap);
+
+ Int_t row=0;
+ Int_t col=0;
+ for (Int_t i=1; i<=nhits; i++)
+ {
+  AliCalmodule* m=(AliCalmodule*)GetHit(i);
+  if (m)
+  {
+   row=m->GetRow();
+   col=m->GetColumn();
+   fMatrix->EnterObject(row,col,m);
+  }
+ }
+}
+///////////////////////////////////////////////////////////////////////////
 TObject* AliCalorimeter::Clone(const char* name) const
 {
 // Make a deep copy of the current object and provide the pointer to the copy.
index 2dcefe2..ecae8ff 100644 (file)
@@ -27,8 +27,8 @@ class AliCalorimeter : public AliDevice
   virtual ~AliCalorimeter();                             // Destructor
   AliCalorimeter(const AliCalorimeter& c);               // Copy constructor
   virtual TObject* Clone(const char* name="") const;     // Make a deep copy and provide pointer of the copy
-  Int_t GetNrows() const;                                // Return number of rows of the matrix
-  Int_t GetNcolumns() const;                             // Return number of columns of the matrix
+  Int_t GetNrows();                                      // Return number of rows of the matrix
+  Int_t GetNcolumns();                                   // Return number of columns of the matrix
   using AliDevice::SetSignal;
   void SetSignal(Int_t row,Int_t col,Float_t s);         // Set signal for a certain module
   using AliDevice::AddSignal;
@@ -36,45 +36,45 @@ class AliCalorimeter : public AliDevice
   void AddSignal(AliCalmodule* m);                       // Add module signal to current calorimeter
   void Reset(Int_t row,Int_t col);                       // Reset signal for a certain module
   virtual void Reset(Int_t mode=0);                      // Reset the complete calorimeter
-  virtual Float_t GetSignal(Int_t row,Int_t col=0) const { return GetSignal(row,col,0); }
-  Float_t GetSignal(Int_t row,Int_t col,Int_t mode) const; // Provide signal of a certain module
+  virtual Float_t GetSignal(Int_t row,Int_t col=0) { return GetSignal(row,col,0); }
+  Float_t GetSignal(Int_t row,Int_t col,Int_t mode);     // Provide signal of a certain module
   Int_t GetNsignals() const;                             // Return number of modules with a signal
   void Group(Int_t n=1,Int_t mode=1);                    // Group modules into clusters (n rings)
   Int_t GetNclusters() const;                            // Return number of clusters
-  Float_t GetClusteredSignal(Int_t row,Int_t col) const; // Provide module signal after clustering
+  Float_t GetClusteredSignal(Int_t row,Int_t col);       // Provide module signal after clustering
   AliCalcluster* GetCluster(Int_t j) const;              // Access to cluster number j
   AliCalmodule* GetModule(Int_t j) const;                // Access to 'fired' module number j
-  AliCalmodule* GetModule(Int_t row,Int_t col) const;    // Access to module at (row,col)
+  AliCalmodule* GetModule(Int_t row,Int_t col);          // Access to module at (row,col)
   using AliDevice::SetEdgeOn;
   void SetEdgeOn(Int_t row,Int_t col);                   // Indicate module as 'edge module'
   using AliDevice::SetEdgeOff;
   void SetEdgeOff(Int_t row,Int_t col);                  // Indicate module as 'non-edge module'
   using AliDevice::GetEdgeValue;
-  Int_t GetEdgeValue(Int_t row,Int_t col) const;         // Provide the edge flag of a module
+  Int_t GetEdgeValue(Int_t row,Int_t col);               // Provide the edge flag of a module
   using AliDevice::SetDead;
   void SetDead(Int_t row,Int_t col);                     // Indicate module as 'dead module'
   using AliDevice::SetAlive;
   void SetAlive(Int_t row,Int_t col);                    // Indicate module as 'active module'
   using AliDevice::GetDeadValue;
-  Int_t GetDeadValue(Int_t row,Int_t col) const;         // Provide the dead flag of a module
+  Int_t GetDeadValue(Int_t row,Int_t col);               // Provide the dead flag of a module
   using AliDevice::SetGain;
   void SetGain(Int_t row,Int_t col,Float_t g);           // Set the gain value for a module
   using AliDevice::SetOffset;
   void SetOffset(Int_t row,Int_t col,Float_t o);         // Set the offset value for a module
   using AliDevice::GetGain;
-  Float_t GetGain(Int_t row,Int_t col) const;            // Provide the gain value of a module
+  Float_t GetGain(Int_t row,Int_t col);                  // Provide the gain value of a module
   using AliDevice::GetGainFlag;
-  Int_t GetGainFlag(Int_t row,Int_t col) const;          // Provide the gain flag value of a module
+  Int_t GetGainFlag(Int_t row,Int_t col);                // Provide the gain flag value of a module
   using AliDevice::GetOffset;
-  Float_t GetOffset(Int_t row,Int_t col) const;          // Provide the offset value of a module
+  Float_t GetOffset(Int_t row,Int_t col);                // Provide the offset value of a module
   using AliDevice::GetOffsetFlag;
-  Int_t GetOffsetFlag(Int_t row,Int_t col) const;        // Provide the offset flag value of a module
+  Int_t GetOffsetFlag(Int_t row,Int_t col);              // Provide the offset flag value of a module
   using AliDevice::SetPosition;
   void SetPosition(Int_t row,Int_t col,Float_t* r,TString f); // Set module position
   void SetPosition(Int_t row,Int_t col,Ali3Vector& r);   // Set module position
   using AliDevice::GetPosition;
-  void GetPosition(Int_t row,Int_t col,Float_t* r,TString f) const; // Return module position
-  AliPosition* GetPosition(Int_t row,Int_t col) const;   // Access to module position
+  void GetPosition(Int_t row,Int_t col,Float_t* r,TString f); // Return module position
+  AliPosition* GetPosition(Int_t row,Int_t col);         // Access to module position
   TH2F* DrawModules(Float_t thresh=0.,Int_t mode=0);     // Lego plot of module (corr.) signals above threshold
   TH2F* DrawClusters(Float_t thresh=0.);                 // Lego plot of cluster signals above threshold
   void AddVetoSignal(AliSignal& s);                      // Associate (extrapolated) signal
@@ -87,19 +87,20 @@ class AliCalorimeter : public AliDevice
  protected:
   Int_t fNrows;                              // The number of rows
   Int_t fNcolumns;                           // The number of columns
-  AliObjMatrix* fMatrix;                     // The matrix of module pointers
+  AliObjMatrix* fMatrix;                     //! Matrix lookup table of module pointers
   Int_t fSwap;                               // The swapmode for the module and position matrices
-  void SortM(AliCalmodule** a,Int_t& n);     // Order the modules with decreasing signal (matrix search)
-  void SortA(AliCalmodule** a,Int_t& n);     // Order the modules with decreasing signal (fired array search)
+  void SortM();                              // Order the modules with decreasing signal (matrix search)
+  void SortA();                              // Order the modules with decreasing signal (fired array search)
   TObjArray* fClusters;                      // The array of clusters
   void AddRing(Int_t row,Int_t col,Int_t n); // add signals of n rings around cluster center
   void Ungroup();                            // Restore module matrix as before clustering
   TH2F* fHmodules;                           //! The module 2-D histogram for event display
   TH2F* fHclusters;                          //! The cluster 2-D histogram for event display
   TObjArray* fVetos;                         // The array of associated (extrapolated) veto signals
-  TObjArray* fAttributes;                    //! Matrix with module attributes (e.g. gain, offset etc...)
-  AliObjMatrix* fPositions;                  //! The matrix of module position pointers
+  TObjArray* fAttributes;                    //! Matrix dbase with module attributes (e.g. gain, offset etc...)
+  AliObjMatrix* fPositions;                  //! Matrix dbase of module position pointers
+  void LoadMatrix();                         // Loading of matrix lookup table from the linear hit array
  
- ClassDef(AliCalorimeter,9) // Description of a modular calorimeter system.
+ ClassDef(AliCalorimeter,10) // Description of a modular calorimeter system.
 };
 #endif
index acd886a..e851627 100644 (file)
 // s.SetSignal(-1002,3);
 // m.AddHit(s);
 //
-// TObjArray ordered=m.SortHits("TOT");
-// nhits=ordered.GetEntries();
+// TObjArray* ordered=m.SortHits("TOT");
+// nhits=ordered->GetEntries();
 // for (Int_t i=0; i<nhits; i++)
 // {
-//  AliSignal* sx=(AliSignal*)ordered.At(i);
+//  AliSignal* sx=(AliSignal*)ordered->At(i);
 //  if (sx) sx->Data();
 // }
 //
@@ -85,8 +85,12 @@ ClassImp(AliDevice) // Class implementation to enable ROOT I/O
 AliDevice::AliDevice() : AliSignal()
 {
 // Default constructor.
- fHitCopy=0;
+// By default private copies of the recorded hits will be made.
+// This implies that by default the device will own the registered hits.
+// See the SetHitCopy() memberfunction for further details.
+ fHitCopy=1;
  fHits=0;
+ fOrdered=0;
 }
 ///////////////////////////////////////////////////////////////////////////
 AliDevice::~AliDevice()
@@ -109,12 +113,23 @@ AliDevice::~AliDevice()
   delete fHits;
   fHits=0;
  }
+
+ if (fOrdered)
+ {
+  delete fOrdered;
+  fOrdered=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 AliDevice::AliDevice(const AliDevice& dev) : AliSignal(dev)
 {
 // Copy constructor.
+
+ fHits=0;
+ fOrdered=0;
+
  fHitCopy=dev.GetHitCopy();
+
  Int_t nhits=dev.GetNhits();
  if (nhits)
  {
@@ -227,6 +242,11 @@ void AliDevice::RemoveHit(AliSignal& s)
    if (fHitCopy) delete test;
   }
  }
+ if (fOrdered)
+ {
+  AliSignal* test=(AliSignal*)fOrdered->Remove(&s);
+  if (test) fOrdered->Compress();
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 void AliDevice::RemoveHits()
@@ -237,6 +257,11 @@ void AliDevice::RemoveHits()
   delete fHits;
   fHits=0;
  }
+ if (fOrdered)
+ {
+  delete fOrdered;
+  fOrdered=0;
+ }
 }
 ///////////////////////////////////////////////////////////////////////////
 Int_t AliDevice::GetNhits() const
@@ -307,7 +332,7 @@ void AliDevice::Data(TString f) const
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-TObjArray AliDevice::SortHits(Int_t idx,Int_t mode,TObjArray* hits) const
+TObjArray* AliDevice::SortHits(Int_t idx,Int_t mode,TObjArray* hits)
 {
 // Order the references to an array of hits by looping over the input array "hits"
 // and checking the signal value. The ordered array is returned as a TObjArray.
@@ -322,20 +347,24 @@ TObjArray AliDevice::SortHits(Int_t idx,Int_t mode,TObjArray* hits) const
 // Signals which were declared as "Dead" will be rejected.
 // The gain etc... corrected signals will be used in the ordering process.
 
- TObjArray ordered;
+ if (fOrdered)
+ {
+  delete fOrdered;
+  fOrdered=0;
+ }
 
  if (!hits) hits=fHits;
  
- if (idx<=0 || abs(mode)!=1 || !hits) return ordered;
+ if (idx<=0 || abs(mode)!=1 || !hits) return fOrdered;
 
  Int_t nhits=hits->GetEntries();
  if (!nhits)
  {
-  return ordered;
+  return fOrdered;
  }
  else
  {
-  ordered.Expand(nhits);
+  fOrdered=new TObjArray(nhits);
  }
 
  Int_t nord=0;
@@ -351,7 +380,7 @@ TObjArray AliDevice::SortHits(Int_t idx,Int_t mode,TObjArray* hits) const
   if (nord == 0) // store the first hit with a signal at the first ordered position
   {
    nord++;
-   ordered.AddAt(s,nord-1);
+   fOrdered->AddAt(s,nord-1);
    continue;
   }
  
@@ -360,26 +389,26 @@ TObjArray AliDevice::SortHits(Int_t idx,Int_t mode,TObjArray* hits) const
    if (j == nord) // module has smallest (mode=-1) or largest (mode=1) signal seen so far
    {
     nord++;
-    ordered.AddAt(s,j); // add hit at the end
+    fOrdered->AddAt(s,j); // add hit at the end
     break; // go for next hit
    }
  
-   if (mode==-1 && s->GetSignal(idx,1) < ((AliSignal*)ordered.At(j))->GetSignal(idx,1)) continue;
-   if (mode==1 && s->GetSignal(idx,1) > ((AliSignal*)ordered.At(j))->GetSignal(idx,1)) continue;
+   if (mode==-1 && s->GetSignal(idx,1) < ((AliSignal*)fOrdered->At(j))->GetSignal(idx,1)) continue;
+   if (mode==1 && s->GetSignal(idx,1) > ((AliSignal*)fOrdered->At(j))->GetSignal(idx,1)) continue;
  
    nord++;
    for (Int_t k=nord-1; k>j; k--) // create empty position
    {
-    ordered.AddAt(ordered.At(k-1),k);
+    fOrdered->AddAt(fOrdered->At(k-1),k);
    }
-   ordered.AddAt(s,j); // put hit at empty position
+   fOrdered->AddAt(s,j); // put hit at empty position
    break; // go for next matrix module
   }
  }
- return ordered;
+ return fOrdered;
 }
 ///////////////////////////////////////////////////////////////////////////
-TObjArray AliDevice::SortHits(TString name,Int_t mode,TObjArray* hits) const
+TObjArray* AliDevice::SortHits(TString name,Int_t mode,TObjArray* hits)
 {
 // Order the references to an array of hits by looping over the input array "hits"
 // and checking the signal value. The ordered array is returned as a TObjArray.
@@ -394,20 +423,24 @@ TObjArray AliDevice::SortHits(TString name,Int_t mode,TObjArray* hits) const
 // Signals which were declared as "Dead" will be rejected.
 // The gain etc... corrected signals will be used in the ordering process.
 
- TObjArray ordered;
+ if (fOrdered)
+ {
+  delete fOrdered;
+  fOrdered=0;
+ }
 
  if (!hits) hits=fHits;
  
- if (abs(mode)!=1 || !hits) return ordered;
+ if (abs(mode)!=1 || !hits) return fOrdered;
 
  Int_t nhits=hits->GetEntries();
  if (!nhits)
  {
-  return ordered;
+  return fOrdered;
  }
  else
  {
-  ordered.Expand(nhits);
+  fOrdered=new TObjArray(nhits);
  }
 
  Int_t idx=0; // The signal slotindex to perform the sorting on
@@ -428,7 +461,7 @@ TObjArray AliDevice::SortHits(TString name,Int_t mode,TObjArray* hits) const
   if (nord == 0) // store the first hit with a signal at the first ordered position
   {
    nord++;
-   ordered.AddAt(s,nord-1);
+   fOrdered->AddAt(s,nord-1);
    continue;
   }
  
@@ -437,23 +470,23 @@ TObjArray AliDevice::SortHits(TString name,Int_t mode,TObjArray* hits) const
    if (j == nord) // module has smallest (mode=-1) or largest (mode=1) signal seen so far
    {
     nord++;
-    ordered.AddAt(s,j); // add hit at the end
+    fOrdered->AddAt(s,j); // add hit at the end
     break; // go for next hit
    }
  
-   if (mode==-1 && s->GetSignal(idx,1) < ((AliSignal*)ordered.At(j))->GetSignal(idx,1)) continue;
-   if (mode==1 && s->GetSignal(idx,1) > ((AliSignal*)ordered.At(j))->GetSignal(idx,1)) continue;
+   if (mode==-1 && s->GetSignal(idx,1) < ((AliSignal*)fOrdered->At(j))->GetSignal(idx,1)) continue;
+   if (mode==1 && s->GetSignal(idx,1) > ((AliSignal*)fOrdered->At(j))->GetSignal(idx,1)) continue;
  
    nord++;
    for (Int_t k=nord-1; k>j; k--) // create empty position
    {
-    ordered.AddAt(ordered.At(k-1),k);
+    fOrdered->AddAt(fOrdered->At(k-1),k);
    }
-   ordered.AddAt(s,j); // put hit at empty position
+   fOrdered->AddAt(s,j); // put hit at empty position
    break; // go for next matrix module
   }
  }
- return ordered;
+ return fOrdered;
 }
 ///////////////////////////////////////////////////////////////////////////
 TObject* AliDevice::Clone(const char* name) const
index 8221464..ea0f081 100644 (file)
@@ -27,13 +27,14 @@ class AliDevice : public AliSignal
   virtual void Reset(Int_t mode=0);                  // Reset registered hits and AliSignal attributes
   void ShowHit(Int_t j=0) const;                     // Show data of the j-th hit (j=0 means all hits)
   virtual void Data(TString f="car") const;          // Print device and all signal info for coord. frame f
-  TObjArray SortHits(TString name,Int_t mode=-1,TObjArray* hits=0) const; // Sort hits by named signal value
-  TObjArray SortHits(Int_t idx=1,Int_t mode=-1,TObjArray* hits=0) const;  // Sort hits by indexed signal value
+  TObjArray* SortHits(TString name,Int_t mode=-1,TObjArray* hits=0); // Sort hits by named signal value
+  TObjArray* SortHits(Int_t idx=1,Int_t mode=-1,TObjArray* hits=0);  // Sort hits by indexed signal value
 
  protected:
-  Int_t fHitCopy;   // Flag to denote making private copies of added hits
-  TObjArray* fHits; // Array to hold the associated hits
+  Int_t fHitCopy;      // Flag to denote making private copies of added hits
+  TObjArray* fHits;    // Array to hold the registered hits
+  TObjArray* fOrdered; //! Temp. array to hold the ordered hits
 
- ClassDef(AliDevice,2) // Signal (Hit) handling of a generic device.
+ ClassDef(AliDevice,3) // Signal (Hit) handling of a generic device.
 };
 #endif
index 68af583..6f5be43 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// $Id: AliEvent.cxx,v 1.22 2004/06/29 11:29:37 nick Exp $
+// $Id: AliEvent.cxx,v 1.23 2004/07/01 14:28:50 nick Exp $
 
 ///////////////////////////////////////////////////////////////////////////
 // Class AliEvent
 // Order and investigate all the hits of all the TOF devices
 //
 //        TObjArray* hits=evt.GetHits("AliTOF");
-//        TObjArray orderedtofs=evt.SortHits(hits);
-//        Int_t nhits=orderedtofs.GetEntries();
+//        TObjArray* orderedtofs=evt.SortHits(hits);
+//        Int_t nhits=0;
+//        if (orderedtofs) nhits=orderedtofs->GetEntries();
 //        for (Int_t i=0; i<nhits; i++)
 //        {
-//         AliSignal* sx=(AliSignal*)orderedtofs.At(i);
+//         AliSignal* sx=(AliSignal*)orderedtofs->At(i);
 //         if (sx) sx->Data();
 //        }
 //
 // Order and investigate all the hits of all the calorimeter devices
 //
 //        TObjArray* hits=evt.GetHits("AliCalorimeter");
-//        TObjArray orderedcals=evt.SortHits(hits);
-//        Int_t nhits=orderedcals.GetEntries();
+//        TObjArray* orderedcals=evt.SortHits(hits);
+//        Int_t nhits=0;
+//        if (orderedcals) nhits=orderedcals->GetEntries();
 //        for (Int_t i=0; i<nhits; i++)
 //        {
-//         AliSignal* sx=(AliSignal*)orderedcals.At(i);
+//         AliSignal* sx=(AliSignal*)orderedcals->At(i);
 //         if (sx) sx->Data();
 //        }
 //
 // Note : All quantities are in GeV, GeV/c or GeV/c**2
 //
 //--- Author: Nick van Eijndhoven 27-may-2001 UU-SAP Utrecht
-//- Modified: NvE $Date: 2004/06/29 11:29:37 $ UU-SAP Utrecht
+//- Modified: NvE $Date: 2004/07/01 14:28:50 $ UU-SAP Utrecht
 ///////////////////////////////////////////////////////////////////////////
 
 #include "AliEvent.h"
@@ -369,7 +371,7 @@ void AliEvent::Reset()
 // Reset all variables to default values
 // The max. number of tracks is set to the initial value again
 // The max. number of vertices is set to the default value again
-// Note : The CalCopy mode is maintained as it was set by the user before.
+// Note : The DevCopy mode is maintained as it was set by the user before.
 
  AliVertex::Reset();
 
@@ -728,9 +730,12 @@ void AliEvent::ShowDevices() const
    TObject* dev=GetDevice(i);
    if (dev)
    {
-    cout << " Device number : " << i
-         << " Class : " << dev->ClassName()
-         << " Name : " << dev->GetName() << endl;
+    const char* name=dev->GetName();
+    cout << " Device number : " << i;
+    cout << " Class : " << dev->ClassName();
+    if (strlen(name)) cout << " Name : " << name;
+    if (dev->InheritsFrom("AliDevice")) cout << " Nhits : " << ((AliDevice*)dev)->GetNhits();
+    cout << endl;
    }
   }
  }
@@ -795,7 +800,7 @@ void AliEvent::LoadHits(const char* classname)
  }
 }
 ///////////////////////////////////////////////////////////////////////////
-TObjArray AliEvent::SortHits(TObjArray* hits,Int_t idx,Int_t mode) const
+TObjArray* AliEvent::SortHits(TObjArray* hits,Int_t idx,Int_t mode)
 {
 // Order the references to an array of hits by looping over the input array "hits"
 // and checking the signal value. The ordered array is returned as a TObjArray.
@@ -808,21 +813,22 @@ TObjArray AliEvent::SortHits(TObjArray* hits,Int_t idx,Int_t mode) const
 // The default is mode=-1.
 // Signals which were declared as "Dead" will be rejected.
 // The gain etc... corrected signals will be used in the ordering process.
- if (idx<=0 || abs(mode)!=1 || !hits)
- {
-  TObjArray ordered;
-  return ordered;
- }
- else
+
+ if (fHits)
  {
-  AliDevice dev;
-  TObjArray ordered=dev.SortHits(idx,mode,hits);
-  return ordered;
- }
+  delete fHits;
+  fHits=0;
+ } 
+
+ if (idx<=0 || abs(mode)!=1 || !hits) return fHits;
+
+ AliDevice dev;
+ TObjArray* ordered=dev.SortHits(idx,mode,hits);
+ if (ordered) fHits=new TObjArray(*ordered);
+ return fHits;
 }
 ///////////////////////////////////////////////////////////////////////////
-TObjArray AliEvent::SortHits(TObjArray* hits,TString name,Int_t mode) const
+TObjArray* AliEvent::SortHits(TObjArray* hits,TString name,Int_t mode)
 {
 // Order the references to an array of hits by looping over the input array "hits"
 // and checking the signal value. The ordered array is returned as a TObjArray.
@@ -835,18 +841,19 @@ TObjArray AliEvent::SortHits(TObjArray* hits,TString name,Int_t mode) const
 // The default is mode=-1.
 // Signals which were declared as "Dead" will be rejected.
 // The gain etc... corrected signals will be used in the ordering process.
- if (abs(mode)!=1 || !hits)
- {
-  TObjArray ordered;
-  return ordered;
- }
- else
+
+ if (fHits)
  {
-  AliDevice dev;
-  TObjArray ordered=dev.SortHits(name,mode,hits);
-  return ordered;
- }
+  delete fHits;
+  fHits=0;
+ } 
+ if (abs(mode)!=1 || !hits) return fHits;
+
+ AliDevice dev;
+ TObjArray* ordered=dev.SortHits(name,mode,hits);
+ if (ordered) fHits=new TObjArray(*ordered);
+ return fHits;
 }
 ///////////////////////////////////////////////////////////////////////////
 TObject* AliEvent::Clone(const char* name) const
index bc904dc..70cfe46 100644 (file)
@@ -3,7 +3,7 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
-// $Id: AliEvent.h,v 1.16 2004/05/04 15:33:04 nick Exp $
+// $Id: AliEvent.h,v 1.17 2004/06/29 11:29:37 nick Exp $
 
 #include <math.h>
  
@@ -54,8 +54,8 @@ class AliEvent : public AliVertex
   TObject* GetDevice(TString name) const; // Provide device with name "name"
   Int_t GetNhits(const char* classname);  // Provide number of hits for the specified device class
   TObjArray* GetHits(const char* classname); // Provide refs to all hits of the specified device class 
-  TObjArray SortHits(TObjArray* hits,TString name,Int_t mode=-1) const; // Sort hits by named signal value
-  TObjArray SortHits(TObjArray* hits,Int_t idx=1,Int_t mode=-1) const;  // Sort hits by indexed signal value
+  TObjArray* SortHits(TObjArray* hits,TString name,Int_t mode=-1); // Sort hits by named signal value
+  TObjArray* SortHits(TObjArray* hits,Int_t idx=1,Int_t mode=-1);  // Sort hits by indexed signal value
 
  protected:
   TTimeStamp fDaytime;                  // The date and time stamp
@@ -74,6 +74,6 @@ class AliEvent : public AliVertex
   void LoadHits(const char* classname); // Load references to the hits registered to the specified device class
   TObjArray* fHits;                     //! Temp. array to hold references to the registered AliDevice hits
 
- ClassDef(AliEvent,14) // Creation and investigation of an Alice physics event.
+ ClassDef(AliEvent,15) // Creation and investigation of an Alice physics event.
 };
 #endif
index b55e639..606877d 100644 (file)
                 and GetMatrixSwapMode, respectively. 
                 Examples in the AliEvent.cxx documentation updated accordingly. 
                 Backward links reset for non-owned hits in AliDevice destructor.
+06-jul-2004 NvE AliCalorimeter hit I/O only via the linear array to decrease filesize on disk
+                and improve I/O speed.
+                Internal temp. arrays used for hit sorting in AliDevice and AliEvent and array
+                pointers returned instead of the arrays themselves. This will provide more
+                flexibility in usage. 
+                Sorting and clustering procedures in AliCalorimeter modified to use TObjArray pointers
+                to enable direct use of the AliDevice linear sorting facility.
+                Default for AliDevice changed such that now all registered hits are by default owned
+                by the AliDevice object.