Retagging v4-18-Rev-07

EMCAL/AliCaloCalibPedestal.h

@@ -36,7 +36,7 @@ class AliCaloCalibPedestal : public TObject {
  public:
 
   enum kDetType {kPhos, kEmCal, kNone};//The detector types
-  enum kDeadMapEntry{kAlive = 0, kDead, kWarning, kHot, kResurrected, kRecentlyDeceased, kNumDeadMapStates};//The entries being put to the deadmap
+  enum kDeadMapEntry{kAlive = 0, kDead, kHot, kWarning, kResurrected, kRecentlyDeceased, kNumDeadMapStates};//The entries being put to the deadmap
 
   AliCaloCalibPedestal(kDetType detectorType = kPhos);
   virtual ~AliCaloCalibPedestal();

EMCAL/AliCaloFitResults.cxx

@@ -28,34 +28,55 @@
 // The signal was fitted sucessfully. fStatus might have a different meaning If other 
 // procedures than  A different meaning Fitting is applied 
 AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Float_t ped, 
-				       const Short_t fitstatus, const Float_t  amp,  
-				       const Float_t t0,  const Float_t chi,  
-				       const Int_t ndf, Int_t minSig ) : fMaxSig(maxSig),
-									       fPed(ped), 
-									       fStatus(fitstatus),
-									       fAmpSig(amp),
-									       fT0(t0),
-									       fChi2Sig(chi),
-									       fNdfSig(ndf),
-									       fMinSig(minSig) 
+				     const Short_t fitstatus, const Float_t  amp,  
+				     const Float_t t0,  const Float_t chi,  
+				     const Int_t ndf, Int_t minSig,
+				     const AliCaloFitSubarray fitSubarray) : 
+  fMaxSig(maxSig),
+  fPed(ped), 
+  fStatus(fitstatus),
+  fAmpSig(amp),
+  fT0(t0),
+  fChi2Sig(chi),
+  fNdfSig(ndf),
+  fMinSig(minSig),
+  fFitSubarray(fitSubarray) 
 {
-
-
 }
 
 
+AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Float_t ped, 
+				     const Short_t fitstatus, const Float_t  amp,  
+				     const Float_t t0,  const Float_t chi,  
+				     const Int_t ndf, Int_t minSig ) : 
+  fMaxSig(maxSig),
+  fPed(ped), 
+  fStatus(fitstatus),
+  fAmpSig(amp),
+  fT0(t0),
+  fChi2Sig(chi),
+  fNdfSig(ndf),
+  fMinSig(minSig),
+  fFitSubarray(kDummy)  
+{
+
+}
 
 
-AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Int_t minSig) : fMaxSig(maxSig),
-										       fPed(-98),
-										       fStatus( -1 ),
-										       fAmpSig( -1 ), 
-										       fT0(-99),  
-										       fChi2Sig( -1 ),
-										       fNdfSig( -1),
-										       fMinSig (minSig)
+
+
+AliCaloFitResults::AliCaloFitResults(const Int_t maxSig, const Int_t minSig) : 
+  fMaxSig(maxSig),
+  fPed(kNoFit),
+  fStatus( kNoFit ),
+  fAmpSig( kNoFit ), 
+  fT0(kNoFit),  
+  fChi2Sig( kNoFit ),
+  fNdfSig( kNoFit),
+  fMinSig (minSig),
+  fFitSubarray(kNoFit)  
 {
-  
+
 }
 
 

EMCAL/AliCaloFitResults.h

@@ -22,20 +22,34 @@
 
 #include "Rtypes.h"
 
+#include "AliCaloFitSubarray.h"
+
 // Container class to hold results from fitting 
 // as well as other methods for
 // raw data signals extraction
 class  AliCaloFitResults
 {
  public:
+  enum kReturnCode {kDummy=-1, kCrude=-9, kNoFit=-99, kInvalid=-9999};// possible return values
+
+  explicit AliCaloFitResults( const Int_t maxSig, 
+			      const Float_t ped, 
+			      const Short_t fitStatus, 
+			      const Float_t  amp, 
+			      const Float_t t0,
+			      const Float_t chi, 
+			      const Int_t ndf, 
+			      const Int_t minSig, 
+			      const AliCaloFitSubarray fitSubarray); 
+
   explicit AliCaloFitResults( const Int_t maxSig, 
 			      const Float_t ped, 
 			      const Short_t fitStatus, 
 			      const Float_t  amp, 
 			      const Float_t t0,
 			      const Float_t chi, 
 			      const Int_t ndf, 
-			      const Int_t minSig = -99); 
+			      const Int_t minSig = kDummy); 
 
   explicit AliCaloFitResults( const Int_t maxSig, const Int_t minSig );
   //AliCaloFitResults( const Int_t maxSig, const Int_t minSig );
@@ -50,6 +64,7 @@ class  AliCaloFitResults
   Float_t   GetTof() const {  return fT0; }; 
   Float_t   GetChisSquare() const { return fChi2Sig;};
   Int_t  GetNdf() const { return fNdfSig; };
+  AliCaloFitSubarray  GetFitSubarray() const { return fFitSubarray; };
 
  private:
   AliCaloFitResults();
@@ -61,6 +76,7 @@ class  AliCaloFitResults
   Float_t    fChi2Sig;  //Chi Square of fit 
   Int_t   fNdfSig;   //Number of degrees of freedom of fit
   Int_t   fMinSig;   //Pedestal 
+  AliCaloFitSubarray fFitSubarray; // info on time-bin array used for the fitting
 };
 
 #endif

EMCAL/AliCaloFitSubarray.cxx

@@ -0,0 +1,60 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+#include "AliCaloFitSubarray.h"
+
+
+// Container class to hold info from bunches/samples
+// selected for signal fitting.
+// Variables are:
+//  Int_t   fBunchIndex;  // Index for selected bunch
+//  Int_t   fMaxRev;      // Max index in reversed array
+//  Int_t   fFirst;   // first index in array used for fit
+//  Int_t   fLast;    // last index in array used for fit
+
+AliCaloFitSubarray::AliCaloFitSubarray(const Int_t bunchIndex, 
+				       const Int_t maxrev, 
+				       const Int_t first, 
+				       const Int_t last ) : 
+  fBunchIndex(bunchIndex),
+  fMaxRev(maxrev), 
+  fFirst(first), 
+  fLast(last)   
+{
+}
+
+AliCaloFitSubarray::AliCaloFitSubarray(const AliCaloFitSubarray & fitS) :
+  fBunchIndex( fitS.fBunchIndex ),
+  fMaxRev( fitS.fMaxRev ), 
+  fFirst( fitS.fFirst ), 
+  fLast( fitS.fLast )   
+{
+}
+
+AliCaloFitSubarray::AliCaloFitSubarray(const Int_t init) : 
+  fBunchIndex(init),
+  fMaxRev(init), 
+  fFirst(init), 
+  fLast(init)   
+{
+}
+
+
+AliCaloFitSubarray::~AliCaloFitSubarray()
+{
+}
+

EMCAL/AliCaloFitSubarray.h

@@ -0,0 +1,51 @@
+#ifndef ALICALOFITSUBARRAY_H
+#define ALICALOFITSUBARRAY_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#include "Rtypes.h"
+
+// Container class to hold info from bunches/samples
+// selected for signal fitting.
+// Variables are:
+//  Int_t   fBunchIndex;  // Index for selected bunch
+//  Int_t   fMaxRev;      // Max index in reversed array
+//  Int_t   fFirst;   // first index in array used for fit
+//  Int_t   fLast;    // last index in array used for fit
+
+class  AliCaloFitSubarray
+{
+ public:
+  explicit AliCaloFitSubarray( const Int_t bunchIndex, 
+			       const Int_t maxrev, 
+			       const Int_t first, 
+			       const Int_t last ); 
+
+  explicit AliCaloFitSubarray(const Int_t init);
+
+  AliCaloFitSubarray(const AliCaloFitSubarray &fitSubarray);
+
+  virtual  ~AliCaloFitSubarray();
+
+  void SetBunchIndex(Int_t i) { fBunchIndex = i;};
+  void SetMaxRev(Int_t i) { fMaxRev = i;};
+  void SetFirst(Int_t i) { fFirst = i; };
+  void SetLast(Int_t i) { fLast = i; };
+
+  Int_t GetBunchIndex() const  { return fBunchIndex;};
+  Int_t GetMaxRev() const { return fMaxRev;};
+  Int_t GetFirst() const { return fFirst; };
+  Int_t GetLast() const { return fLast; };
+
+ private:
+
+  Int_t   fBunchIndex;  // Index for selected bunch
+  Int_t   fMaxRev;      // Max index in reversed array
+  Int_t   fFirst;   // first index in array used for fit
+  Int_t   fLast;    // last index in array used for fit
+};
+
+#endif