Calibration objects now have identifier(s) (Laurent)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 17 Jun 2007 20:41:34 +0000 (20:41 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sun, 17 Jun 2007 20:41:34 +0000 (20:41 +0000)
MUON/AliMUONCalibParamNF.cxx
MUON/AliMUONCalibParamNF.h
MUON/AliMUONCalibParamNI.cxx
MUON/AliMUONCalibParamNI.h
MUON/AliMUONVCalibParam.cxx
MUON/AliMUONVCalibParam.h

index 97e6d7f..c5f3f7d 100644 (file)
@@ -46,8 +46,10 @@ AliMUONCalibParamNF::AliMUONCalibParamNF()
 }
 
 //_____________________________________________________________________________
-AliMUONCalibParamNF::AliMUONCalibParamNF(Int_t dimension, Int_t theSize, Float_t fillWithValue) 
-: AliMUONVCalibParam(),
+AliMUONCalibParamNF::AliMUONCalibParamNF(Int_t dimension, Int_t theSize, 
+                                         Int_t id0, Int_t id1,
+                                         Float_t fillWithValue) 
+: AliMUONVCalibParam(id0,id1),
   fDimension(dimension),
   fSize(theSize),
   fN(fSize*fDimension),
@@ -105,6 +107,9 @@ AliMUONCalibParamNF::CopyTo(AliMUONCalibParamNF& destination) const
 {
 /// Copy *this to destination
 
+  const TObject& o = static_cast<const TObject&>(*this);
+  o.Copy(destination);
+  
   delete[] destination.fValues;
   destination.fN = fN;
   destination.fSize = fSize;
@@ -145,8 +150,8 @@ AliMUONCalibParamNF::Print(Option_t* opt) const
 
   TString sopt(opt);
   sopt.ToUpper();
-  cout << "AliMUONCalibParamNF - Size=" << Size()
-    << " Dimension=" << Dimension() << endl;
+  cout << Form("AliMUONCalibParamNF Id=(%d,%d) Size=%d Dimension=%d",ID0(),
+               ID1(),Size(),Dimension()) << endl;
   if ( sopt.Contains("FULL") )
   {
     for ( Int_t i = 0; i < Size(); ++i )
index 5e2ef0d..25b340b 100644 (file)
@@ -20,7 +20,7 @@ class AliMUONCalibParamNF : public AliMUONVCalibParam
 {
 public:
   AliMUONCalibParamNF();
-  AliMUONCalibParamNF(Int_t dimension, Int_t theSize, Float_t fillWithValue=0);
+  AliMUONCalibParamNF(Int_t dimension, Int_t theSize, Int_t id0, Int_t id1, Float_t fillWithValue=0);
   AliMUONCalibParamNF(const AliMUONCalibParamNF& other);
   AliMUONCalibParamNF& operator=(const AliMUONCalibParamNF& other);
   
@@ -52,7 +52,7 @@ private:
   /// The values array
   Float_t* fValues; //[fN] The values array
   
-  ClassDef(AliMUONCalibParamNF,1) // Container for calibration parameters
+  ClassDef(AliMUONCalibParamNF,3) // Container for calibration parameters
 };
 
 #endif
index 562a164..959ef18 100644 (file)
@@ -50,12 +50,14 @@ AliMUONCalibParamNI::AliMUONCalibParamNI()
   fValues(0x0)
 {
 /// Default constructor.
+    AliDebug(1,Form("this=%p default ctor",this));
 }
 
 //_____________________________________________________________________________
-AliMUONCalibParamNI::AliMUONCalibParamNI(Int_t dimension, Int_t theSize, 
+AliMUONCalibParamNI::AliMUONCalibParamNI(Int_t dimension, Int_t theSize,
+                                         Int_t id0, Int_t id1,
                                          Int_t fillWithValue, Int_t packingFactor) 
-: AliMUONVCalibParam(),
+: AliMUONVCalibParam(id0,id1),
   fDimension(dimension),
   fSize(theSize),
   fN(fSize*fDimension),
@@ -66,6 +68,9 @@ 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));
+
   if ( fN > 0 )
   {
     fValues = new Int_t[fN];
@@ -88,6 +93,7 @@ fValues(0x0)
 {
 /// Copy constructor.
 
+  AliDebug(1,Form("this=%p copy ctor",this));
   other.CopyTo(*this);
 }
 
@@ -106,6 +112,7 @@ AliMUONCalibParamNI::~AliMUONCalibParamNI()
 {
 /// Destructor
 
+  AliDebug(1,Form("this=%p",this));
   delete[] fValues;
 }
 
@@ -115,6 +122,9 @@ AliMUONCalibParamNI::CopyTo(AliMUONCalibParamNI& destination) const
 {
 /// Copy *this to destination
 
+  const TObject& o = static_cast<const TObject&>(*this);
+  o.Copy(destination);
+  
   delete[] destination.fValues;
   destination.fN = fN;
   destination.fSize = fSize;
@@ -157,7 +167,9 @@ AliMUONCalibParamNI::Print(Option_t* opt) const
   TString sopt(opt);
   sopt.ToUpper();
   cout << "AliMUONCalibParamNI - Size=" << Size()
-    << " Dimension=" << Dimension();
+    << " Dimension=" << Dimension()
+    << " Id=(" << ID0() << "," << ID1() << ")";
+  
   if ( IsPacked() ) 
   {
     cout << " Packing Factor=" << fPackingFactor;
@@ -176,11 +188,11 @@ AliMUONCalibParamNI::Print(Option_t* opt) const
         {
           Int_t m,c;
           UnpackValue(v,m,c);
-          cout << Form(" (%d,%d)",m,c);
+          cout << Form(" (%d,%d) (0x%x,0x%x)",m,c,m,c);
         }
         else
         {
-          cout << Form(" %d",v);
+          cout << Form(" %d (0x%x)",v,v);
         }
       }
       cout << endl;
index 8f0b69e..5960649 100644 (file)
@@ -20,7 +20,7 @@ class AliMUONCalibParamNI : public AliMUONVCalibParam
 {
 public:
   AliMUONCalibParamNI();
-  AliMUONCalibParamNI(Int_t dimension, Int_t theSize, Int_t fillWithValue=0, Int_t packingValue=0);
+  AliMUONCalibParamNI(Int_t dimension, Int_t theSize, Int_t id0, Int_t id1, Int_t fillWithValue=0, Int_t packingValue=0);
   AliMUONCalibParamNI(const AliMUONCalibParamNI& other);
   AliMUONCalibParamNI& operator=(const AliMUONCalibParamNI& other);
   
@@ -59,7 +59,7 @@ private:
   /// The values array
   Int_t* fValues; //[fN] The values array
   
-  ClassDef(AliMUONCalibParamNI,1) // Container for calibration parameters
+  ClassDef(AliMUONCalibParamNI,3) // Container for calibration parameters
 };
 
 #endif
index f1fe280..e1f1a9d 100644 (file)
 
 #include "AliMUONVCalibParam.h"
 
+#include "AliLog.h"
+
 /// 
 /// \class AliMUONVCalibParam
 ///  
 /// Defines an interface for a calibration container object.
 ///
-/// \author Laurent Aphecetche
+/// Note that a VCalibParam object is identified by a pair (id0,id1), 
+/// where each member of the pair is a 16 bits word, so that id0 and id1
+/// can be packed into a single 32 bits word.
+///
+/// id1 might be left to zero if not required (e.g. for calibparam which 
+/// can be identified by a single integer)
+///
+/// \author Laurent Aphecetche, Subatech
 
 /// \cond CLASSIMP
 ClassImp(AliMUONVCalibParam)
 /// \endcond
 
 //_____________________________________________________________________________
-  AliMUONVCalibParam::AliMUONVCalibParam() : TObject()
+AliMUONVCalibParam::AliMUONVCalibParam() : TObject()
 {
-///  Default constructor
+  ///  Default constructor
+}
+
+//_____________________________________________________________________________
+AliMUONVCalibParam::AliMUONVCalibParam(Int_t id0, Int_t id1) : TObject()
+{
+  ///  constructor for 2D
+  SetUniqueID(BuildUniqueID(id0,id1));
 }
 
 //_____________________________________________________________________________
@@ -39,3 +55,78 @@ AliMUONVCalibParam::~AliMUONVCalibParam()
 {
 /// Destructor.
 }
+
+//_____________________________________________________________________________
+UInt_t
+AliMUONVCalibParam::BuildUniqueID(Int_t id0, Int_t id1)
+{
+  /// Build a single index from the pair (id0,id1)
+  return ( id0 | ( id1 << 16 ) );
+}
+
+//_____________________________________________________________________________
+void
+AliMUONVCalibParam::DecodeUniqueID(UInt_t uniqueID, Int_t& id0, Int_t& id1)
+{
+  /// Convert single integer into a pair (i,j)
+  id0 = ID0(uniqueID);
+  id1 = ID1(uniqueID);
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONVCalibParam::ID0(UInt_t uniqueID)
+{
+  /// Extract id0 from uniqueID
+  return uniqueID & 0xFFFF;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONVCalibParam::ID0() const
+{
+  /// Extract first identifier
+  return ID0(GetUniqueID());
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONVCalibParam::ID1(UInt_t uniqueID)
+{
+  /// Extract id1 from uniqueID
+  return ( uniqueID & 0xFFFF0000 ) >> 16;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONVCalibParam::ID1() const
+{
+  /// Extract second identifier
+  return ID1(GetUniqueID());
+}
+
+//_____________________________________________________________________________
+const char* 
+AliMUONVCalibParam::GetName() const
+{
+  /// Build a name for this object
+  return Form("I=%d,J=%d",ID0(),ID1());
+}
+
+//_____________________________________________________________________________
+void 
+AliMUONVCalibParam::SetValueAsDouble(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
+{
+  /// By default, this one does not exist
+  AliFatal("Not implemented");
+  return 0;
+}
+
index 1aeeabf..e6ab17b 100644 (file)
@@ -20,14 +20,29 @@ class AliMUONVCalibParam : public TObject
 {
 public:
   AliMUONVCalibParam();
+  //AliMUONVCalibParam(Int_t id0);
+  AliMUONVCalibParam(Int_t id0, Int_t id1);
   virtual ~AliMUONVCalibParam();
 
+  virtual const char* GetName() const;
+  
+  /// First id of this object
+  virtual Int_t ID0() const;
+  
+  /// Second id of this object (might not be required)
+  virtual Int_t ID1() const;
+  
   /// whether or not the value we store are packed, e.g. as v = a*cste + b
   virtual Bool_t IsPacked() const { return kFALSE; }
   
   /// j indices in following methods are valid from 0 to Dimension()-1.
   virtual Int_t Dimension() const = 0;
-  
+
+  /** Set one value, for channel i, dimension j. Consider value is a double.
+    Only ok to use if IsDoublePrecision() is kTRUE.
+    */
+  virtual void SetValueAsDouble(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;
   
@@ -37,6 +52,14 @@ public:
   /// The number of channels handled by this object.
   virtual Int_t Size() const = 0;
 
+  /// Whether we can store double precision values   
+  virtual Bool_t IsDoublePrecision() const { return kFALSE; }
+  
+  /** Retrieve the value for a given (channel,dim) as a double.
+      Only ok if IsDoublePrecision() is kTRUE.
+    */
+  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;
   
@@ -51,8 +74,15 @@ public:
   
   /// Return 1E38 as invalid float value
   static Float_t InvalidFloatValue() { return 1E38; }
+
+protected:
+    
+  static UInt_t BuildUniqueID(Int_t id0, Int_t id1);
+  static void DecodeUniqueID(UInt_t uniqueID, Int_t& id0, Int_t& id1);
+  static Int_t ID0(UInt_t uniqueID);
+  static Int_t ID1(UInt_t uniqueID);
   
-  ClassDef(AliMUONVCalibParam,0) // 
+  ClassDef(AliMUONVCalibParam,0) // Base class for a calibration data holder (usually for 64 channels)
 };
 
 #endif