{
/// Copy *this to destination
+ TObject::Copy(destination);
+
delete[] destination.fValues;
destination.fN = fN;
destination.fSize = fSize;
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
}
}
+//_____________________________________________________________________________
+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
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)
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
}
}
+//_____________________________________________________________________________
+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
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
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);
+}
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; }
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
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
}
}
+//_____________________________________________________________________________
+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)
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
}
}
+//_____________________________________________________________________________
+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
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);
+}
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
/// 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 )
{
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
}
}
+//_____________________________________________________________________________
+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)
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
}
}
+//_____________________________________________________________________________
+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
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
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;
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
/// 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
//-----------------------------------------------------------------------------
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
return 0;
}
+//_____________________________________________________________________________
+Double_t
+AliMUONVCalibParam::ValueAsDoubleFast(Int_t , Int_t ) const
+{
+ /// By default, this one does not exist
+ AliFatal("Not implemented");
+ return 0;
+}
+
*/
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;
/** 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; }