Adding methods w/o bound checking (Laurent)
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 17 Oct 2007 13:00:16 +0000 (13:00 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 17 Oct 2007 13:00:16 +0000 (13:00 +0000)
MUON/AliMUONCalibParamND.cxx
MUON/AliMUONCalibParamND.h
MUON/AliMUONCalibParamNF.cxx
MUON/AliMUONCalibParamNF.h
MUON/AliMUONCalibParamNI.cxx
MUON/AliMUONCalibParamNI.h
MUON/AliMUONVCalibParam.cxx
MUON/AliMUONVCalibParam.h

index 2edfcf173515b83ba452f8baa1493337ecec4340..8f620ba1ace7294dc04e7a4b4d203da025efd4b2 100644 (file)
@@ -108,6 +108,8 @@ AliMUONCalibParamND::CopyTo(AliMUONCalibParamND& destination) const
 {
 /// Copy *this to destination
 
+  TObject::Copy(destination);
+  
   delete[] destination.fValues;
   destination.fN = fN;
   destination.fSize = fSize;
@@ -132,11 +134,20 @@ AliMUONCalibParamND::Index(Int_t i, Int_t j) const
 
   if ( i >= 0 && i < Size() && j >= 0 && j < Dimension() )
   {
-    return i + Size()*j;
+    return IndexFast(i,j);
   }
   return -1;
 }
 
+//_____________________________________________________________________________
+Int_t
+AliMUONCalibParamND::IndexFast(Int_t i, Int_t j) const
+{
+  /// Compute the 1D index of the internal storage from the pair (i,j)
+  
+  return i + Size()*j;
+}
+
 //_____________________________________________________________________________
 void
 AliMUONCalibParamND::Print(Option_t* opt) const
@@ -205,6 +216,14 @@ AliMUONCalibParamND::SetValueAsDouble(Int_t i, Int_t j, Double_t value)
   }
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibParamND::SetValueAsDoubleFast(Int_t i, Int_t j, Double_t value)
+{
+  /// Set one value as a double, w/o checking that the indices are correct.
+  
+  fValues[IndexFast(i,j)] = value;
+}
 
 //_____________________________________________________________________________
 void
@@ -214,6 +233,14 @@ AliMUONCalibParamND::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
   SetValueAsDouble(i,j,static_cast<Double_t>(value));
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibParamND::SetValueAsFloatFast(Int_t i, Int_t j, Float_t value)
+{
+  /// Set one value as a float, after checking that the indices are correct.
+  SetValueAsDoubleFast(i,j,static_cast<Double_t>(value));
+}
+
 //_____________________________________________________________________________
 void
 AliMUONCalibParamND::SetValueAsInt(Int_t i, Int_t j, Int_t value)
@@ -223,6 +250,15 @@ AliMUONCalibParamND::SetValueAsInt(Int_t i, Int_t j, Int_t value)
   SetValueAsFloat(i,j,static_cast<Float_t>(value));
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibParamND::SetValueAsIntFast(Int_t i, Int_t j, Int_t value)
+{
+  /// Set one value as an int.
+  
+  SetValueAsFloatFast(i,j,static_cast<Float_t>(value));
+}
+
 //_____________________________________________________________________________
 Double_t
 AliMUONCalibParamND::ValueAsDouble(Int_t i, Int_t j) const
@@ -243,6 +279,15 @@ AliMUONCalibParamND::ValueAsDouble(Int_t i, Int_t j) const
   }
 }
 
+//_____________________________________________________________________________
+Double_t
+AliMUONCalibParamND::ValueAsDoubleFast(Int_t i, Int_t j) const
+{
+  /// Return the value as a double (which it is), w/o checking indices.
+  
+  return fValues[IndexFast(i,j)];
+}
+
 //_____________________________________________________________________________
 Float_t
 AliMUONCalibParamND::ValueAsFloat(Int_t i, Int_t j) const
@@ -251,6 +296,14 @@ AliMUONCalibParamND::ValueAsFloat(Int_t i, Int_t j) const
   return static_cast<Float_t>(ValueAsDouble(i,j));
 }
 
+//_____________________________________________________________________________
+Float_t
+AliMUONCalibParamND::ValueAsFloatFast(Int_t i, Int_t j) const
+{
+  /// Return the value as a float 
+  return static_cast<Float_t>(ValueAsDoubleFast(i,j));
+}
+
 //_____________________________________________________________________________
 Int_t
 AliMUONCalibParamND::ValueAsInt(Int_t i, Int_t j) const
@@ -260,3 +313,13 @@ AliMUONCalibParamND::ValueAsInt(Int_t i, Int_t j) const
   Float_t v = ValueAsFloat(i,j);
   return TMath::Nint(v);
 }
+
+//_____________________________________________________________________________
+Int_t
+AliMUONCalibParamND::ValueAsIntFast(Int_t i, Int_t j) const
+{
+  /// Return the value as an int, by rounding the internal float value.
+  
+  Float_t v = ValueAsFloatFast(i,j);
+  return TMath::Nint(v);
+}
index 183aa56a6017ac122940654de4665e08cc661337..0b4f16f5f789b65f044ead0b301a4298213c5d35 100644 (file)
@@ -26,21 +26,30 @@ public:
   
   virtual ~AliMUONCalibParamND();
 
+  /// Own clone methods (as the default TObject::Clone turned out to be pretty slow !)
+  virtual TObject* Clone(const char* = "") const { return new AliMUONCalibParamND(*this); }
+  
   /// Return dimension
   virtual Int_t Dimension() const { return fDimension; }
   
   virtual void Print(Option_t* opt="") const;
   
   virtual void SetValueAsDouble(Int_t i, Int_t j, Double_t value);
+  virtual void SetValueAsDoubleFast(Int_t i, Int_t j, Double_t value);
   virtual void SetValueAsFloat(Int_t i, Int_t j, Float_t value);
+  virtual void SetValueAsFloatFast(Int_t i, Int_t j, Float_t value);
   virtual void SetValueAsInt(Int_t i, Int_t j, Int_t value);
+  virtual void SetValueAsIntFast(Int_t i, Int_t j, Int_t value);
   
   /// Return size - the number of double tuples we hold
   virtual Int_t Size() const { return fSize; } 
 
   virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const;
+  virtual Float_t ValueAsFloatFast(Int_t i, Int_t j=0) const;
   virtual Double_t ValueAsDouble(Int_t i, Int_t j=0) const;
+  virtual Double_t ValueAsDoubleFast(Int_t i, Int_t j=0) const;
   virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const;
+  virtual Int_t ValueAsIntFast(Int_t i, Int_t j=0) const;
      
   /// Advertise that we can store double precision values
   virtual Bool_t IsDoublePrecision() const { return kTRUE; }
@@ -48,6 +57,7 @@ public:
 private:
   void CopyTo(AliMUONCalibParamND& destination) const;
   Int_t Index(Int_t i, Int_t j) const;  
+  Int_t IndexFast(Int_t i, Int_t j) const;  
     
 private:
   Int_t fDimension; ///< dimension of this object
index 5938f6ad925b7114e001a17e0f7160bbd458d192..600ed1396d92e1356059859b6e3dea8f354f0693 100644 (file)
@@ -135,11 +135,20 @@ AliMUONCalibParamNF::Index(Int_t i, Int_t j) const
 
   if ( i >= 0 && i < Size() && j >= 0 && j < Dimension() )
   {
-    return i + Size()*j;
+    return IndexFast(i,j);
   }
   return -1;
 }
 
+//_____________________________________________________________________________
+Int_t
+AliMUONCalibParamNF::IndexFast(Int_t i, Int_t j) const
+{
+  /// Compute the 1D index of the internal storage from the pair (i,j)
+  
+  return i + Size()*j;
+}
+
 //_____________________________________________________________________________
 void
 AliMUONCalibParamNF::Print(Option_t* opt) const
@@ -208,6 +217,15 @@ AliMUONCalibParamNF::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
   }
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibParamNF::SetValueAsFloatFast(Int_t i, Int_t j, Float_t value)
+{
+  /// Set one value as a float, w/o checking that the indices are correct.
+  
+  fValues[IndexFast(i,j)] = value;
+}
+
 //_____________________________________________________________________________
 void
 AliMUONCalibParamNF::SetValueAsInt(Int_t i, Int_t j, Int_t value)
@@ -217,6 +235,15 @@ AliMUONCalibParamNF::SetValueAsInt(Int_t i, Int_t j, Int_t value)
   SetValueAsFloat(i,j,static_cast<Float_t>(value));
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibParamNF::SetValueAsIntFast(Int_t i, Int_t j, Int_t value)
+{
+  /// Set one value as an int.
+  
+  SetValueAsFloatFast(i,j,static_cast<Float_t>(value));
+}
+
 //_____________________________________________________________________________
 Float_t
 AliMUONCalibParamNF::ValueAsFloat(Int_t i, Int_t j) const
@@ -237,6 +264,15 @@ AliMUONCalibParamNF::ValueAsFloat(Int_t i, Int_t j) const
   }
 }
 
+//_____________________________________________________________________________
+Float_t
+AliMUONCalibParamNF::ValueAsFloatFast(Int_t i, Int_t j) const
+{
+  /// Return the value as a float (which it is), after checking indices.
+  
+  return fValues[IndexFast(i,j)];
+}
+
 //_____________________________________________________________________________
 Int_t
 AliMUONCalibParamNF::ValueAsInt(Int_t i, Int_t j) const
@@ -246,3 +282,13 @@ AliMUONCalibParamNF::ValueAsInt(Int_t i, Int_t j) const
   Float_t v = ValueAsFloat(i,j);
   return TMath::Nint(v);
 }
+
+//_____________________________________________________________________________
+Int_t
+AliMUONCalibParamNF::ValueAsIntFast(Int_t i, Int_t j) const
+{
+  /// Return the value as an int, by rounding the internal float value.
+  
+  Float_t v = ValueAsFloatFast(i,j);
+  return TMath::Nint(v);
+}
index 25b340b33116c3b7c556f5e392740210d8e81216..6b5217a661951aeb6150ccefb031bee056f3b725 100644 (file)
@@ -26,23 +26,34 @@ public:
   
   virtual ~AliMUONCalibParamNF();
 
+  /// Own clone methods (as the default TObject::Clone turned out to be pretty slow !)
+  virtual TObject* Clone(const char* = "") const { return new AliMUONCalibParamNF(*this); }
+  
   /// Return dimension
   virtual Int_t Dimension() const { return fDimension; }
   
   virtual void Print(Option_t* opt="") const;
   
   virtual void SetValueAsFloat(Int_t i, Int_t j, Float_t value);
+  virtual void SetValueAsFloatFast(Int_t i, Int_t j, Float_t value);
   virtual void SetValueAsInt(Int_t i, Int_t j, Int_t value);
+  virtual void SetValueAsIntFast(Int_t i, Int_t j, Int_t value);
   
   /// Return size - the number of float pair we hold
   virtual Int_t Size() const { return fSize; } 
 
   virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const;
+
+  virtual Float_t ValueAsFloatFast(Int_t i, Int_t j=0) const;
+  
   virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const;
+  
+  virtual Int_t ValueAsIntFast(Int_t i, Int_t j=0) const;
      
 private:
   void CopyTo(AliMUONCalibParamNF& destination) const;
   Int_t Index(Int_t i, Int_t j) const;  
+  Int_t IndexFast(Int_t i, Int_t j) const;  
     
 private:
   Int_t fDimension; ///< dimension of this object
index f89a74e30b75a1443c3d1b97c552112dd1c2881c..644975dea4b4f5d14dd488cca31b382134598827 100644 (file)
@@ -69,8 +69,8 @@ AliMUONCalibParamNI::AliMUONCalibParamNI(Int_t dimension, Int_t theSize,
 /// by this object, and fillWithValue the default value assigned to each
 /// channel.
 
-    AliDebug(1,Form("this=%p dimension=%d theSize=%d fillWithValue=%d packingFactor=%d",
-                    this,dimension,theSize,fillWithValue,packingFactor));
+//    AliDebug(1,Form("this=%p dimension=%d theSize=%d fillWithValue=%d packingFactor=%d",
+//                    this,dimension,theSize,fillWithValue,packingFactor));
 
   if ( fN > 0 )
   {
@@ -151,11 +151,20 @@ AliMUONCalibParamNI::Index(Int_t i, Int_t j) const
 
   if ( i >= 0 && i < Size() && j >= 0 && j < Dimension() )
   {
-    return i + Size()*j;
+    return IndexFast(i,j);
   }
   return -1;
 }
 
+//_____________________________________________________________________________
+Int_t
+AliMUONCalibParamNI::IndexFast(Int_t i, Int_t j) const
+{
+  /// Compute the 1D index of the internal storage from the pair (i,j)
+  
+  return i + Size()*j;
+}
+
 //_____________________________________________________________________________
 void
 AliMUONCalibParamNI::Print(Option_t* opt) const
@@ -242,6 +251,15 @@ AliMUONCalibParamNI::SetValueAsInt(Int_t i, Int_t j, Int_t value)
   }
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibParamNI::SetValueAsIntFast(Int_t i, Int_t j, Int_t value)
+{
+  /// Set one value as a float, w/o checking that the indices are correct.
+  
+  fValues[IndexFast(i,j)] = value;
+}
+
 //_____________________________________________________________________________
 void
 AliMUONCalibParamNI::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
@@ -252,6 +270,17 @@ AliMUONCalibParamNI::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
   SetValueAsInt(i,j,TMath::Nint(value));
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibParamNI::SetValueAsFloatFast(Int_t i, Int_t j, Float_t value)
+{
+  /// Set one value as an int.
+  
+  AliWarning("Float will be rounded to be stored...");
+  SetValueAsIntFast(i,j,TMath::Nint(value));
+}
+
+
 //_____________________________________________________________________________
 Int_t
 AliMUONCalibParamNI::ValueAsInt(Int_t i, Int_t j) const
@@ -272,6 +301,15 @@ AliMUONCalibParamNI::ValueAsInt(Int_t i, Int_t j) const
   }
 }
 
+//_____________________________________________________________________________
+Int_t
+AliMUONCalibParamNI::ValueAsIntFast(Int_t i, Int_t j) const
+{
+  /// Return the value as an int (which it is), w/o checking indices.
+  
+  return fValues[IndexFast(i,j)];
+}
+
 //_____________________________________________________________________________
 Float_t
 AliMUONCalibParamNI::ValueAsFloat(Int_t i, Int_t j) const
@@ -280,6 +318,14 @@ AliMUONCalibParamNI::ValueAsFloat(Int_t i, Int_t j) const
   return static_cast<Float_t>(ValueAsInt(i,j));
 }
 
+//_____________________________________________________________________________
+Float_t
+AliMUONCalibParamNI::ValueAsFloatFast(Int_t i, Int_t j) const
+{
+  /// Return the value as a float
+  return static_cast<Float_t>(ValueAsIntFast(i,j));
+}
+
 //_____________________________________________________________________________
 Bool_t 
 AliMUONCalibParamNI::UnpackValue(Int_t value, Int_t& a, Int_t& b) const
index 596064982863f5ea25f30a24f7ce1acf5c83ed8c..e46a89cba83c5c3463f8a4406033faac5e6d55ce 100644 (file)
@@ -26,19 +26,26 @@ public:
   
   virtual ~AliMUONCalibParamNI();
 
+  /// Own clone methods (as the default TObject::Clone turned out to be pretty slow !)
+  virtual TObject* Clone(const char* = "") const { return new AliMUONCalibParamNI(*this); }
+  
   /// Return dimension
   virtual Int_t Dimension() const { return fDimension; }
   
   virtual void Print(Option_t* opt="") const;
   
   virtual void SetValueAsFloat(Int_t i, Int_t j, Float_t value);
+  virtual void SetValueAsFloatFast(Int_t i, Int_t j, Float_t value);
   virtual void SetValueAsInt(Int_t i, Int_t j, Int_t value);
+  virtual void SetValueAsIntFast(Int_t i, Int_t j, Int_t value);
   
   /// Return size - the number of float pair we hold
   virtual Int_t Size() const { return fSize; } 
 
   virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const;
+  virtual Float_t ValueAsFloatFast(Int_t i, Int_t j=0) const;
   virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const;
+  virtual Int_t ValueAsIntFast(Int_t i, Int_t j=0) const;
      
   virtual Bool_t UnpackValue(Int_t value, Int_t& a, Int_t& b) const;
   
@@ -49,6 +56,7 @@ public:
 private:
   void CopyTo(AliMUONCalibParamNI& destination) const;
   Int_t Index(Int_t i, Int_t j) const;  
+  Int_t IndexFast(Int_t i, Int_t j) const;  
     
 private:
   Int_t fDimension; ///< dimension of this object
index 7fa6c393e9e263d54caaf35530ecd166eb33618f..d8a69affdb39aee62637477ba2f001ac9392ac8b 100644 (file)
 /// id1 might be left to zero if not required (e.g. for calibparam which 
 /// can be identified by a single integer)
 ///
+/// Note that the ValueAsXXX methods have 2 versions : with or without bound
+/// checking. The latter is to be used in e.g. loops, where you know for
+/// sure the indices are ok, in order to gain some time.
+///
 /// \author Laurent Aphecetche, Subatech
 //-----------------------------------------------------------------------------
 
@@ -122,6 +126,14 @@ AliMUONVCalibParam::SetValueAsDouble(Int_t, Int_t, Double_t)
   AliFatal("Not implemented");
 }
 
+//_____________________________________________________________________________
+void 
+AliMUONVCalibParam::SetValueAsDoubleFast(Int_t, Int_t, Double_t)
+{
+  /// By default, this one does not exist
+  AliFatal("Not implemented");
+}
+
 //_____________________________________________________________________________
 Double_t 
 AliMUONVCalibParam::ValueAsDouble(Int_t , Int_t ) const
@@ -131,3 +143,12 @@ AliMUONVCalibParam::ValueAsDouble(Int_t , Int_t ) const
   return 0;
 }
 
+//_____________________________________________________________________________
+Double_t 
+AliMUONVCalibParam::ValueAsDoubleFast(Int_t , Int_t ) const
+{
+  /// By default, this one does not exist
+  AliFatal("Not implemented");
+  return 0;
+}
+
index e6ab17b5fdd6e44664957ff0d37f7ab0e19ad8ef..99e5a8bf16d20c7c3c9bdfcfd77279e0c316cce6 100644 (file)
@@ -43,12 +43,23 @@ public:
     */
   virtual void SetValueAsDouble(Int_t i, Int_t j, Double_t value);
 
+  /// Same as above but w/o bound checking
+  virtual void SetValueAsDoubleFast(Int_t i, Int_t j, Double_t value);
+
   /// Set one value, for channel i, dimension j. Consider value is a float.
   virtual void SetValueAsFloat(Int_t i, Int_t j, Float_t value) = 0;
-  
+
+  /** Set one value, for channel i, dimension j. Consider value is a float.
+    Assume (i,j) are valid indices, i.e. do not check them.
+    */
+  virtual void SetValueAsFloatFast(Int_t i, Int_t j, Float_t value) = 0;
+
   /// Set one value, for channel i, dimension j. Consider value is an integer.
   virtual void SetValueAsInt(Int_t i, Int_t j, Int_t value) = 0;
-  
+
+  /// Same as above but w/o bound checkings.
+  virtual void SetValueAsIntFast(Int_t i, Int_t j, Int_t value) = 0;
+
   /// The number of channels handled by this object.
   virtual Int_t Size() const = 0;
 
@@ -57,15 +68,32 @@ public:
   
   /** Retrieve the value for a given (channel,dim) as a double.
       Only ok if IsDoublePrecision() is kTRUE.
+      (i,j) are checked to within boundaries
     */
   virtual Double_t ValueAsDouble(Int_t i, Int_t j=0) const;
 
-  /// Retrieve the value for a given (channel,dim) as a float.
-  virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const = 0;
+  /** Retrieve the value for a given (channel,dim) as a double.
+    Only ok if IsDoublePrecision() is kTRUE.
+    Fast means there's no bound checking on (i,j)
+    */
+  virtual Double_t ValueAsDoubleFast(Int_t i, Int_t j=0) const;
   
-  /// Retrieve the value for a given (channel,dim) as an integer.
+  /** Retrieve the value for a given (channel,dim) as a float, with
+      bound checking on (i,j).
+    */
+  virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const = 0;
+
+  /// Same as above but without bound checking.
+  virtual Float_t ValueAsFloatFast(Int_t i, Int_t j=0) const = 0;
+
+  /** Retrieve the value for a given (channel,dim) as an integer.
+      With bound checking.
+    */
   virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const = 0;
 
+  /// Same as above but w/o bound checking.
+  virtual Int_t ValueAsIntFast(Int_t i, Int_t j=0) const = 0;
+
   /// Unpack a value into a couple (a,b). Returns false if IsPacked()==kFALSE
   virtual Bool_t UnpackValue(Int_t /*value*/, Int_t& /*a*/, Int_t& /*b*/) const { return kFALSE; }