Line data    Source code

       1             : #ifndef ALI_TPC_COMPOSED_CORRECTION_H
       2             : #define ALI_TPC_COMPOSED_CORRECTION_H
       3             : 
       4             : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
       5             :  * See cxx source for full Copyright notice                               */
       6             : 
       7             : /// \class AliTPCComposedCorrection
       8             : /// \brief AliTPCComposedCorrection class
       9             : ///
      10             : /// This class is creating a correction that is composed out of smaller
      11             : /// corrections.
      12             : /// There are two ways the sub-corrections can be combined into this one:
      13             : /// 1. kParallel: All corrections are applied at the given position x and
      14             : ///   the dx terms are summed up (this commutes).
      15             : /// 2. kQueue: The corrections are called in order. The first one at the
      16             : ///   given position x resulting in dx1, the second one is called at
      17             : ///   the corrected position (x+dx1) resulting in dx2, the third one
      18             : ///   is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...
      19             : ///   is returned.
      20             : /// For the inverse of the correction this is taken into account by reversing
      21             : /// the order the corrections are applied in the kQueue case (no issue for
      22             : /// kParallel).
      23             : ///
      24             : /// \author Magnus Mager, Stefan Rossegger, Jim Thomas
      25             : /// \date 27/04/2010
      26             : 
      27             : #include "AliTPCCorrection.h"
      28             : #include "TVectorD.h"
      29             : 
      30             : class TCollection;
      31             : class TTimeStamp;
      32             : 
      33             : class AliTPCComposedCorrection : public AliTPCCorrection {
      34             : public:
      35             :   enum CompositionType {kParallel,kQueue, kQueueResidual};
      36             : 
      37             :   AliTPCComposedCorrection();
      38             :   AliTPCComposedCorrection(TCollection *corrections,CompositionType mode);
      39             :   virtual ~AliTPCComposedCorrection();
      40             :   virtual Bool_t AddCorrectionCompact(AliTPCCorrection* corr, Double_t weight);
      41             :   void SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2);
      42             : 
      43          36 :   TCollection* GetCorrections() const {return fCorrections;}
      44           0 :   void SetCorrections(const TCollection *corrections) {fCorrections=(TCollection*)corrections;}
      45           0 :   CompositionType GetMode() const {return fMode;}
      46           0 :   void SetMode(CompositionType mode) {fMode=mode;}
      47             : 
      48             :   virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
      49             :   virtual void GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]);
      50             :   virtual  AliTPCCorrection * GetSubCorrection(Int_t ipos);
      51             :   virtual  AliTPCCorrection * GetSubCorrection(const char * cname);
      52             : 
      53             :   virtual void Print(Option_t* option="") const;
      54             : 
      55             :   // initialization and update functions
      56             :   virtual void Init();
      57             :   virtual void Update(const TTimeStamp &timeStamp);
      58           0 :   void SetWeights(TVectorD * weights){fWeights= (TVectorD*) weights->Clone();}
      59           0 :   const  TVectorD * GetWeights() const {return fWeights;}
      60             : 
      61             : private:
      62             :   TCollection *fCorrections; ///< The corrections this one is composed of.
      63             :   CompositionType fMode;     ///< The way to apply the corrections (see general class documentation)
      64             :   TVectorD        *fWeights;  ///< optional vector with weights - used for fit benchmarking
      65             :   AliTPCComposedCorrection & operator = (const AliTPCComposedCorrection &); // dummy assignment operator
      66             :   AliTPCComposedCorrection(const AliTPCComposedCorrection&); //dummy copy contructor
      67             : 
      68             :   /// \cond CLASSIMP
      69          54 :   ClassDef(AliTPCComposedCorrection,2);
      70             :   /// \endcond
      71             : };
      72             : 
      73             : 
      74             : #endif