[u/mrichter/AliRoot.git] / TPC / AliTPCComposedCorrection.h

#ifndef ALI_TPC_COMPOSED_CORRECTION_H
#define ALI_TPC_COMPOSED_CORRECTION_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// AliTPCComposedCorrection class                                             //
//                                                                            //
// This class is creating a correction that is composed out of smaller        //
// corrections.                                                               //
// There are two ways the sub-corrections can be combined into this one:      //
// 1. kParallel: All corrections are applied at the given position x and      //
//    the dx terms are summed up (this commutes).                             //
// 2. kQueue: The corrections are called in order. The first one at the       //
//    given position x resulting in dx1, the second one is called at          //
//    the corrected position (x+dx1) resulting in dx2, the third one          //
//    is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+...     //
//    is returned.                                                            //
// For the inverse of the correction this is taken into account by reversing  //
// the order the corrections are applied in the kQueue case (no issue for     //
// kParallel).                                                                //
//                                                                            //
// date: 27/04/2010                                                           //
// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas                       //
////////////////////////////////////////////////////////////////////////////////

#include "AliTPCCorrection.h"

class TCollection;

class AliTPCComposedCorrection : public AliTPCCorrection {
public:
  enum CompositionType {kParallel,kQueue};

  AliTPCComposedCorrection();
  AliTPCComposedCorrection(TCollection *corrections,CompositionType mode);
  virtual ~AliTPCComposedCorrection();

  void SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2);

  TCollection* GetCorrections() const {return fCorrections;}
  void SetCorrections(TCollection *corrections) {fCorrections=corrections;}
  CompositionType GetMode() const {return fMode;}
  void SetMode(CompositionType mode) {fMode=mode;}

  virtual void GetCorrection(const Float_t x[],const Short_t roc,Float_t dx[]);
  virtual void GetDistortion(const Float_t x[],const Short_t roc,Float_t dx[]);

  virtual void Print(Option_t* option="") const;

  // initialization and update functions
  virtual void Init();
  virtual void Update(const TTimeStamp &timeStamp);


private:
  TCollection *fCorrections; // The corrections this one is composed of.
  CompositionType fMode;     // The way to apply the corrections (see general class documentation)

  AliTPCComposedCorrection & operator = (const AliTPCComposedCorrection);
  AliTPCComposedCorrection(const AliTPCComposedCorrection&); //dummy copy contructor

  ClassDef(AliTPCComposedCorrection,1);
};

#endif
Commit	Line	Data
0116859c	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	////////////////////////////////////////////////////////////////////////////////
	8	// //
	9	// AliTPCComposedCorrection class //
	10	// //
	11	// This class is creating a correction that is composed out of smaller //
	12	// corrections. //
	13	// There are two ways the sub-corrections can be combined into this one: //
	14	// 1. kParallel: All corrections are applied at the given position x and //
	15	// the dx terms are summed up (this commutes). //
	16	// 2. kQueue: The corrections are called in order. The first one at the //
	17	// given position x resulting in dx1, the second one is called at //
	18	// the corrected position (x+dx1) resulting in dx2, the third one //
	19	// is then called at position (x+dx1+dx2) and so forth. dx=dx1+dx2+... //
	20	// is returned. //
	21	// For the inverse of the correction this is taken into account by reversing //
	22	// the order the corrections are applied in the kQueue case (no issue for //
	23	// kParallel). //
	24	// //
	25	// date: 27/04/2010 //
	26	// Authors: Magnus Mager, Stefan Rossegger, Jim Thomas //
	27	////////////////////////////////////////////////////////////////////////////////
	28
	29	#include "AliTPCCorrection.h"
	30
	31	class TCollection;
	32
	33	class AliTPCComposedCorrection : public AliTPCCorrection {
	34	public:
	35	enum CompositionType {kParallel,kQueue};
	36
	37	AliTPCComposedCorrection();
	38	AliTPCComposedCorrection(TCollection *corrections,CompositionType mode);
	39	virtual ~AliTPCComposedCorrection();
	40
	41	void SetOmegaTauT1T2(Float_t omegaTau,Float_t t1,Float_t t2);
	42
	43	TCollection* GetCorrections() const {return fCorrections;}
	44	void SetCorrections(TCollection *corrections) {fCorrections=corrections;}
	45	CompositionType GetMode() const {return fMode;}
	46	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
	51	virtual void Print(Option_t* option="") const;
	52
e527a1b9	53	// initialization and update functions
	54	virtual void Init();
	55	virtual void Update(const TTimeStamp &timeStamp);
	56
	57
0116859c	58	private:
	59	TCollection *fCorrections; // The corrections this one is composed of.
	60	CompositionType fMode; // The way to apply the corrections (see general class documentation)
	61
	62	AliTPCComposedCorrection & operator = (const AliTPCComposedCorrection);
	63	AliTPCComposedCorrection(const AliTPCComposedCorrection&); //dummy copy contructor
	64
	65	ClassDef(AliTPCComposedCorrection,1);
	66	};
	67
	68	#endif