[u/mrichter/AliRoot.git] / FMD / AliFMDAlignFaker.h

#ifndef ALIFMDALIGNFAKER_H
#define ALIFMDALIGNFAKER_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
 * reserved. 
 *
 * Latest changes by Christian Holm Christensen <cholm@nbi.dk>
 *
 * See cxx source for full Copyright notice                               
 */
/** @file    AliFMDAlignFaker.h
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Sun Mar 26 18:26:39 2006
    @brief   Make fake alignment 
*/
//____________________________________________________________________
//
//  Class 
//  to 
//  make 
//  fake 
//  alignment
//  parameters 
//
#ifndef ROOT_TTask
# include <TTask.h>
#endif
#ifndef ROOT_TVector3
# include <TVector3.h>
#endif
class TClonesArray;
class TString;

/** @class AliFMDAlignFaker 
    @brief This task creates fake alignment. 
    Which alignment, depends on the bit mask passed to the
    constructor, or added by `AddAlign'.

    The default is to write all alignment parameters to a local
    storage @c local://cdb which is a directory in the current
    directory.
    @ingroup FMD_util
*/
class AliFMDAlignFaker : public TTask
{
public:
  /** What to make alignments for */
  enum EWhat {
    /** MAke alignment for sensors */
    kSensors =  1, 
    /** Make alignment for half-rings */
    kHalves
  };
  enum {
    /** All types of alignment */
    kAll             = (1<<kHalves|1<<kSensors)
  };
  /** Constructor 
      @param mask Bit mask of what to make alignments for 
      @param geo  File to read geometry from, if needed
      @param loc  Where to store the result */
  AliFMDAlignFaker(Int_t mask=kAll, 
		   const char* geo="geometry.root",
		   const char* loc="");
  /** Destructor */
  virtual ~AliFMDAlignFaker() {}
  /** Add something to make alignment for 
      @param w Bit of alignment mask */
  void AddAlign(EWhat w) { SETBIT(fMask, w); }
  /** Remove something to make alignment for 
      @param w Bit of alignment mask */
  void RemoveAlign(EWhat w) { CLRBIT(fMask, w); }
  /** Set alignment select mask 
      @param mask Bit mask */
  void SetAlign(Int_t mask) { fMask = mask; }
  /** Set the displacement (translation) of sensors.  The displacement
      is selected random uniformly between the corresponding minimum
      and maximum. 
      @param x1 Minimum X displacement (in centimeters)
      @param y1 Minimum Y displacement (in centimeters)
      @param z1 Minimum Z displacement (in centimeters)
      @param x2 Maximum X displacement (in centimeters)
      @param y2 Maximum Y displacement (in centimeters)
      @param z2 Maximum Z displacement (in centimeters) */
  void SetSensorDisplacement(Double_t x1=0,   Double_t y1=0,   Double_t z1=0,
			     Double_t x2=.01, Double_t y2=.01, Double_t z2=0);
  /** Set the rotation of sensors.  The displacement is selected
      random uniformly between the corresponding minimum and maximum.
      @param x1 Minimum X rotation (in degrees)
      @param y1 Minimum Y rotation (in degrees)
      @param z1 Minimum Z rotation (in degrees)
      @param x2 Maximum X rotation (in degrees)
      @param y2 Maximum Y rotation (in degrees)
      @param z2 Maximum Z rotation (in degrees) */
  void SetSensorRotation(Double_t x1=0,  Double_t y1=0,  Double_t z1=0,
			 Double_t x2=.5, Double_t y2=.5, Double_t z2=.5);
  /** Set the displacement (translation) of half-rings.  The
      displacement is selected random uniformly between the
      corresponding minimum and maximum.
      @param x1 Minimum X displacement
      @param y1 Minimum Y displacement
      @param z1 Minimum Z displacement
      @param x2 Maximum X displacement
      @param y2 Maximum Y displacement
      @param z2 Maximum Z displacement */
  void SetHalfDisplacement(Double_t x1=0,   Double_t y1=0,   Double_t z1=0,
			   Double_t x2=.05, Double_t y2=.05, Double_t z2=.05);
  /** Set the rotation of half-rings.  The displacement is selected
      random uniformly between the corresponding minimum and maximum.
      @param x1 Minimum X rotation (in degrees)
      @param y1 Minimum Y rotation (in degrees)
      @param z1 Minimum Z rotation (in degrees)
      @param x2 Maximum X rotation (in degrees)
      @param y2 Maximum Y rotation (in degrees)
      @param z2 Maximum Z rotation (in degrees) */
  void SetHalfRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
		       Double_t x2=0, Double_t y2=0, Double_t z2=0);
  /** Set the output file name.  Should be a valid CDB URL.
      @param file CDB URL */
  void SetOutput(const char* file) { SetTitle(file); }
  /** Set the file to read the geometry from. 
      @param file File name */
  void SetGeometryFile(const char* file) { SetName(file); }
  /** Set the comment  */ 
  void SetComment(const Char_t* comment="dummy data") { fComment = comment; }
  /** Make the alignment objects. 
      @param option Not used. */
  void Exec(Option_t* option="");
protected:
  AliFMDAlignFaker(const AliFMDAlignFaker& o) 
    : TTask(o), 
      fMask(0), 
      fSensorTransMin(0,0,0),
      fSensorTransMax(0,0,0),
      fSensorRotMin(0,0,0),
      fSensorRotMax(0,0,0),
      fHalfTransMin(0,0,0),
      fHalfTransMax(0,0,0),
      fHalfRotMin(0,0,0),
      fHalfRotMax(0,0,0),
      fRunMin(0), 
      fRunMax(0),
      fArray(0),
      fComment("")
{}
  AliFMDAlignFaker& operator=(const AliFMDAlignFaker&) { return *this; }
  
  /** Make the alignment object for a path
      @param path   Node path.
      @param volID  Volume identifier 
      @param transX Translation in X
      @param transY Translation in Y
      @param transZ Translation in Z
      @param rotX   Rotation around X axis
      @param rotY   Rotation around Y axis
      @param rotZ   Rotation around Z axis
      @return @c true on success */
  Bool_t MakeAlign(const TString& path, Int_t volID, 
		   Double_t transX, Double_t transY, Double_t transZ,
		   Double_t rotX, Double_t rotY, Double_t rotZ);
  /** Align a sensor 
      @param path of a sensor 
      @param id Volume id */
  Bool_t MakeAlignSensor(const TString& path, Int_t id);
  /** Align a half-ring
      @param path of a sensor 
      @param id Volume id */
  Bool_t MakeAlignHalf(const TString& path, Int_t id);
  /** Write to CDB */
  void   WriteToCDB();
  /** Write to file */
  void   WriteToFile();
  Long_t        fMask;            // What to write 
  TVector3      fSensorTransMin;  // Minimum translations of a sensor
  TVector3      fSensorTransMax;  // Maximum translations of a sensor
  TVector3      fSensorRotMin;    // Minimum rotation of a sensor
  TVector3      fSensorRotMax;    // Maximum rotation of a sensor
  TVector3      fHalfTransMin;    // Minimum translations of a half-ring
  TVector3      fHalfTransMax;	  // Maximum translations of a half-ring
  TVector3      fHalfRotMin;	  // Minimum rotation of a half-ring    
  TVector3      fHalfRotMax;	  // Maximum rotation of a half-ring 
  Int_t         fRunMin;          // Run validity start 
  Int_t         fRunMax;          // Run validity end
  TClonesArray* fArray;           // Cache
  TString       fComment;         // Comment on data
  
  ClassDef(AliFMDAlignFaker,0)
};

#endif
//____________________________________________________________________
//
// Local Variables:
//   mode: C++
// End:
//
// EOF
//
Commit	Line	Data
20345ac5	1	#ifndef ALIFMDALIGNFAKER_H
	2	#define ALIFMDALIGNFAKER_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights
	4	* reserved.
	5	*
	6	* Latest changes by Christian Holm Christensen <cholm@nbi.dk>
	7	*
	8	* See cxx source for full Copyright notice
	9	*/
c2fc1258	10	/** @file AliFMDAlignFaker.h
	11	@author Christian Holm Christensen <cholm@nbi.dk>
	12	@date Sun Mar 26 18:26:39 2006
	13	@brief Make fake alignment
	14	*/
20345ac5	15	//____________________________________________________________________
20345ac5	16	//
02a27b50	17	// Class
	18	// to
	19	// make
	20	// fake
	21	// alignment
	22	// parameters
20345ac5	23	//
	24	#ifndef ROOT_TTask
	25	# include <TTask.h>
	26	#endif
	27	#ifndef ROOT_TVector3
	28	# include <TVector3.h>
	29	#endif
	30	class TClonesArray;
	31	class TString;
	32
9f662337	33	/** @class AliFMDAlignFaker
c2fc1258	34	@brief This task creates fake alignment.
	35	Which alignment, depends on the bit mask passed to the
	36	constructor, or added by `AddAlign'.
9f662337	37
	38	The default is to write all alignment parameters to a local
	39	storage @c local://cdb which is a directory in the current
	40	directory.
	41	@ingroup FMD_util
	42	*/
20345ac5	43	class AliFMDAlignFaker : public TTask
	44	{
	45	public:
9f662337	46	/** What to make alignments for */
20345ac5	47	enum EWhat {
9f662337	48	/** MAke alignment for sensors */
20345ac5	49	kSensors = 1,
9f662337	50	/** Make alignment for half-rings */
4183a24f	51	kHalves
20345ac5	52	};
20345ac5	53	enum {
9f662337	54	/** All types of alignment */
20345ac5	55	kAll = (1<<kHalves\|1<<kSensors)
20345ac5	56	};
9f662337	57	/** Constructor
	58	@param mask Bit mask of what to make alignments for
	59	@param geo File to read geometry from, if needed
	60	@param loc Where to store the result */
20345ac5	61	AliFMDAlignFaker(Int_t mask=kAll,
20345ac5	62	const char* geo="geometry.root",
9234535e	63	const char* loc="");
9f662337	64	/** Destructor */
20345ac5	65	virtual ~AliFMDAlignFaker() {}
9f662337	66	/** Add something to make alignment for
9f662337	67	@param w Bit of alignment mask */
20345ac5	68	void AddAlign(EWhat w) { SETBIT(fMask, w); }
9f662337	69	/** Remove something to make alignment for
9f662337	70	@param w Bit of alignment mask */
1e8f773e	71	void RemoveAlign(EWhat w) { CLRBIT(fMask, w); }
9f662337	72	/** Set alignment select mask
9f662337	73	@param mask Bit mask */
20345ac5	74	void SetAlign(Int_t mask) { fMask = mask; }
9f662337	75	/** Set the displacement (translation) of sensors. The displacement
	76	is selected random uniformly between the corresponding minimum
	77	and maximum.
	78	@param x1 Minimum X displacement (in centimeters)
	79	@param y1 Minimum Y displacement (in centimeters)
	80	@param z1 Minimum Z displacement (in centimeters)
	81	@param x2 Maximum X displacement (in centimeters)
	82	@param y2 Maximum Y displacement (in centimeters)
	83	@param z2 Maximum Z displacement (in centimeters) */
20345ac5	84	void SetSensorDisplacement(Double_t x1=0, Double_t y1=0, Double_t z1=0,
20345ac5	85	Double_t x2=.01, Double_t y2=.01, Double_t z2=0);
9f662337	86	/** Set the rotation of sensors. The displacement is selected
	87	random uniformly between the corresponding minimum and maximum.
	88	@param x1 Minimum X rotation (in degrees)
	89	@param y1 Minimum Y rotation (in degrees)
	90	@param z1 Minimum Z rotation (in degrees)
	91	@param x2 Maximum X rotation (in degrees)
	92	@param y2 Maximum Y rotation (in degrees)
	93	@param z2 Maximum Z rotation (in degrees) */
20345ac5	94	void SetSensorRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
20345ac5	95	Double_t x2=.5, Double_t y2=.5, Double_t z2=.5);
9f662337	96	/** Set the displacement (translation) of half-rings. The
	97	displacement is selected random uniformly between the
	98	corresponding minimum and maximum.
	99	@param x1 Minimum X displacement
	100	@param y1 Minimum Y displacement
	101	@param z1 Minimum Z displacement
	102	@param x2 Maximum X displacement
	103	@param y2 Maximum Y displacement
	104	@param z2 Maximum Z displacement */
20345ac5	105	void SetHalfDisplacement(Double_t x1=0, Double_t y1=0, Double_t z1=0,
20345ac5	106	Double_t x2=.05, Double_t y2=.05, Double_t z2=.05);
9f662337	107	/** Set the rotation of half-rings. The displacement is selected
	108	random uniformly between the corresponding minimum and maximum.
	109	@param x1 Minimum X rotation (in degrees)
	110	@param y1 Minimum Y rotation (in degrees)
	111	@param z1 Minimum Z rotation (in degrees)
	112	@param x2 Maximum X rotation (in degrees)
	113	@param y2 Maximum Y rotation (in degrees)
	114	@param z2 Maximum Z rotation (in degrees) */
20345ac5	115	void SetHalfRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
20345ac5	116	Double_t x2=0, Double_t y2=0, Double_t z2=0);
9f662337	117	/** Set the output file name. Should be a valid CDB URL.
9f662337	118	@param file CDB URL */
20345ac5	119	void SetOutput(const char* file) { SetTitle(file); }
9f662337	120	/** Set the file to read the geometry from.
9f662337	121	@param file File name */
20345ac5	122	void SetGeometryFile(const char* file) { SetName(file); }
9234535e	123	/** Set the comment */
9234535e	124	void SetComment(const Char_t* comment="dummy data") { fComment = comment; }
9f662337	125	/** Make the alignment objects.
9f662337	126	@param option Not used. */
20345ac5	127	void Exec(Option_t* option="");
20345ac5	128	protected:
b5ee4425	129	AliFMDAlignFaker(const AliFMDAlignFaker& o)
	130	: TTask(o),
	131	fMask(0),
	132	fSensorTransMin(0,0,0),
	133	fSensorTransMax(0,0,0),
	134	fSensorRotMin(0,0,0),
	135	fSensorRotMax(0,0,0),
	136	fHalfTransMin(0,0,0),
	137	fHalfTransMax(0,0,0),
	138	fHalfRotMin(0,0,0),
	139	fHalfRotMax(0,0,0),
	140	fRunMin(0),
	141	fRunMax(0),
	142	fArray(0),
	143	fComment("")
	144	{}
02a27b50	145	AliFMDAlignFaker& operator=(const AliFMDAlignFaker&) { return *this; }
02a27b50	146
9f662337	147	/** Make the alignment object for a path
	148	@param path Node path.
	149	@param volID Volume identifier
	150	@param transX Translation in X
	151	@param transY Translation in Y
	152	@param transZ Translation in Z
	153	@param rotX Rotation around X axis
	154	@param rotY Rotation around Y axis
	155	@param rotZ Rotation around Z axis
	156	@return @c true on success */
20345ac5	157	Bool_t MakeAlign(const TString& path, Int_t volID,
	158	Double_t transX, Double_t transY, Double_t transZ,
	159	Double_t rotX, Double_t rotY, Double_t rotZ);
9f662337	160	/** Align a sensor
	161	@param path of a sensor
	162	@param id Volume id */
20345ac5	163	Bool_t MakeAlignSensor(const TString& path, Int_t id);
9f662337	164	/** Align a half-ring
	165	@param path of a sensor
	166	@param id Volume id */
20345ac5	167	Bool_t MakeAlignHalf(const TString& path, Int_t id);
9f662337	168	/** Write to CDB */
20345ac5	169	void WriteToCDB();
9f662337	170	/** Write to file */
20345ac5	171	void WriteToFile();
20345ac5	172	Long_t fMask; // What to write
9f662337	173	TVector3 fSensorTransMin; // Minimum translations of a sensor
	174	TVector3 fSensorTransMax; // Maximum translations of a sensor
	175	TVector3 fSensorRotMin; // Minimum rotation of a sensor
	176	TVector3 fSensorRotMax; // Maximum rotation of a sensor
	177	TVector3 fHalfTransMin; // Minimum translations of a half-ring
	178	TVector3 fHalfTransMax; // Maximum translations of a half-ring
	179	TVector3 fHalfRotMin; // Minimum rotation of a half-ring
	180	TVector3 fHalfRotMax; // Maximum rotation of a half-ring
	181	Int_t fRunMin; // Run validity start
	182	Int_t fRunMax; // Run validity end
	183	TClonesArray* fArray; // Cache
9234535e	184	TString fComment; // Comment on data
20345ac5	185
	186	ClassDef(AliFMDAlignFaker,0)
	187	};
	188
	189	#endif
	190	//____________________________________________________________________
	191	//
	192	// Local Variables:
	193	// mode: C++
	194	// End:
	195	//
	196	// EOF
	197	//
	198