[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="");
  /** 
   * Get the geometry
   * 
   * @param toCdb   Whether to store in CDB
   * @param storage Storage element to use 
   * 
   * @return true on success 
   */
  static Bool_t GetGeometry(Bool_t toCdb=kFALSE, 
			    const TString& storage=TString());
protected:
  /** 
   * Copy constructor 
   * 
   * @param o Object to copy from 
   */
  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("")
  {}
  /** 
   * Assignment operator 
   * 
   * 
   * @return Reference to this
   */  
  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
	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	*/
	10	/**
	11	* @file AliFMDAlignFaker.h
	12	* @author Christian Holm Christensen <cholm@nbi.dk>
	13	* @date Sun Mar 26 18:26:39 2006
	14	* @brief Make fake alignment
	15	*/
	16	//____________________________________________________________________
	17	//
	18	// Class
	19	// to
	20	// make
	21	// fake
	22	// alignment
	23	// parameters
	24	//
	25	#ifndef ROOT_TTask
	26	# include <TTask.h>
	27	#endif
	28	#ifndef ROOT_TVector3
	29	# include <TVector3.h>
	30	#endif
	31	class TClonesArray;
	32	class TString;
	33
	34	/**
	35	* @class AliFMDAlignFaker
	36	* @brief This task creates fake alignment.
	37	*
	38	* Which alignment, depends on the bit mask passed to the
	39	* constructor, or added by `AddAlign'.
	40	*
	41	* The default is to write all alignment parameters to a local
	42	* storage @c local://cdb which is a directory in the current
	43	* directory.
	44	*
	45	* @ingroup FMD_util
	46	*/
	47	class AliFMDAlignFaker : public TTask
	48	{
	49	public:
	50	/**
	51	* What to make alignments for
	52	*/
	53	enum EWhat {
	54	/** MAke alignment for sensors */
	55	kSensors = 1,
	56	/** Make alignment for half-rings */
	57	kHalves
	58	};
	59	enum {
	60	/** All types of alignment */
	61	kAll = (1<<kHalves\|1<<kSensors)
	62	};
	63	/**
	64	* Constructor
	65	@param mask Bit mask of what to make alignments for
	66	@param geo File to read geometry from, if needed
	67	@param loc Where to store the result
	68	*/
	69	AliFMDAlignFaker(Int_t mask=kAll,
	70	const char* geo="geometry.root",
	71	const char* loc="");
	72	/**
	73	* Destructor
	74	*/
	75	virtual ~AliFMDAlignFaker() {}
	76	/**
	77	* Add something to make alignment for
	78	* @param w Bit of alignment mask
	79	*/
	80	void AddAlign(EWhat w) { SETBIT(fMask, w); }
	81	/**
	82	* Remove something to make alignment for
	83	* @param w Bit of alignment mask
	84	*/
	85	void RemoveAlign(EWhat w) { CLRBIT(fMask, w); }
	86	/**
	87	* Set alignment select mask
	88	* @param mask Bit mask
	89	*/
	90	void SetAlign(Int_t mask) { fMask = mask; }
	91	/**
	92	* Set the displacement (translation) of sensors. The displacement
	93	* is selected random uniformly between the corresponding minimum
	94	* and maximum.
	95	* @param x1 Minimum X displacement (in centimeters)
	96	* @param y1 Minimum Y displacement (in centimeters)
	97	* @param z1 Minimum Z displacement (in centimeters)
	98	* @param x2 Maximum X displacement (in centimeters)
	99	* @param y2 Maximum Y displacement (in centimeters)
	100	* @param z2 Maximum Z displacement (in centimeters)
	101	*/
	102	void SetSensorDisplacement(Double_t x1=0, Double_t y1=0, Double_t z1=0,
	103	Double_t x2=.01, Double_t y2=.01, Double_t z2=0);
	104	/**
	105	* Set the rotation of sensors. The displacement is selected
	106	* random uniformly between the corresponding minimum and maximum.
	107	* @param x1 Minimum X rotation (in degrees)
	108	* @param y1 Minimum Y rotation (in degrees)
	109	* @param z1 Minimum Z rotation (in degrees)
	110	* @param x2 Maximum X rotation (in degrees)
	111	* @param y2 Maximum Y rotation (in degrees)
	112	* @param z2 Maximum Z rotation (in degrees)
	113	*/
	114	void SetSensorRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
	115	Double_t x2=.5, Double_t y2=.5, Double_t z2=.5);
	116	/**
	117	* Set the displacement (translation) of half-rings. The
	118	* displacement is selected random uniformly between the
	119	* corresponding minimum and maximum.
	120	* @param x1 Minimum X displacement
	121	* @param y1 Minimum Y displacement
	122	* @param z1 Minimum Z displacement
	123	* @param x2 Maximum X displacement
	124	* @param y2 Maximum Y displacement
	125	* @param z2 Maximum Z displacement
	126	*/
	127	void SetHalfDisplacement(Double_t x1=0, Double_t y1=0, Double_t z1=0,
	128	Double_t x2=.05, Double_t y2=.05, Double_t z2=.05);
	129	/**
	130	* Set the rotation of half-rings. The displacement is selected
	131	* random uniformly between the corresponding minimum and maximum.
	132	* @param x1 Minimum X rotation (in degrees)
	133	* @param y1 Minimum Y rotation (in degrees)
	134	* @param z1 Minimum Z rotation (in degrees)
	135	* @param x2 Maximum X rotation (in degrees)
	136	* @param y2 Maximum Y rotation (in degrees)
	137	* @param z2 Maximum Z rotation (in degrees)
	138	*/
	139	void SetHalfRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
	140	Double_t x2=0, Double_t y2=0, Double_t z2=0);
	141	/**
	142	* Set the output file name. Should be a valid CDB URL.
	143	* @param file CDB URL
	144	*/
	145	void SetOutput(const char* file) { SetTitle(file); }
	146	/**
	147	* Set the file to read the geometry from.
	148	* @param file File name
	149	*/
	150	void SetGeometryFile(const char* file) { SetName(file); }
	151	/**
	152	* Set the comment
	153	*/
	154	void SetComment(const Char_t* comment="dummy data") { fComment = comment; }
	155	/**
	156	* Make the alignment objects.
	157	* @param option Not used.
	158	*/
	159	void Exec(Option_t* option="");
	160	/**
	161	* Get the geometry
	162	*
	163	* @param toCdb Whether to store in CDB
	164	* @param storage Storage element to use
	165	*
	166	* @return true on success
	167	*/
	168	static Bool_t GetGeometry(Bool_t toCdb=kFALSE,
	169	const TString& storage=TString());
	170	protected:
	171	/**
	172	* Copy constructor
	173	*
	174	* @param o Object to copy from
	175	*/
	176	AliFMDAlignFaker(const AliFMDAlignFaker& o)
	177	: TTask(o),
	178	fMask(0),
	179	fSensorTransMin(0,0,0),
	180	fSensorTransMax(0,0,0),
	181	fSensorRotMin(0,0,0),
	182	fSensorRotMax(0,0,0),
	183	fHalfTransMin(0,0,0),
	184	fHalfTransMax(0,0,0),
	185	fHalfRotMin(0,0,0),
	186	fHalfRotMax(0,0,0),
	187	fRunMin(0),
	188	fRunMax(0),
	189	fArray(0),
	190	fComment("")
	191	{}
	192	/**
	193	* Assignment operator
	194	*
	195	*
	196	* @return Reference to this
	197	*/
	198	AliFMDAlignFaker& operator=(const AliFMDAlignFaker&) { return *this; }
	199
	200	/**
	201	* Make the alignment object for a path
	202	* @param path Node path.
	203	* @param volID Volume identifier
	204	* @param transX Translation in X
	205	* @param transY Translation in Y
	206	* @param transZ Translation in Z
	207	* @param rotX Rotation around X axis
	208	* @param rotY Rotation around Y axis
	209	* @param rotZ Rotation around Z axis
	210	* @return @c true on success
	211	*/
	212	Bool_t MakeAlign(const TString& path, Int_t volID,
	213	Double_t transX, Double_t transY, Double_t transZ,
	214	Double_t rotX, Double_t rotY, Double_t rotZ);
	215	/**
	216	* Align a sensor
	217	* @param path of a sensor
	218	* @param id Volume id
	219	*/
	220	Bool_t MakeAlignSensor(const TString& path, Int_t id);
	221	/**
	222	* Align a half-ring
	223	* @param path of a sensor
	224	* @param id Volume id
	225	*/
	226	Bool_t MakeAlignHalf(const TString& path, Int_t id);
	227	/**
	228	* Write to CDB
	229	*/
	230	void WriteToCDB();
	231	/**
	232	* Write to file
	233	*/
	234	void WriteToFile();
	235	Long_t fMask; // What to write
	236	TVector3 fSensorTransMin; // Minimum translations of a sensor
	237	TVector3 fSensorTransMax; // Maximum translations of a sensor
	238	TVector3 fSensorRotMin; // Minimum rotation of a sensor
	239	TVector3 fSensorRotMax; // Maximum rotation of a sensor
	240	TVector3 fHalfTransMin; // Minimum translations of a half-ring
	241	TVector3 fHalfTransMax; // Maximum translations of a half-ring
	242	TVector3 fHalfRotMin; // Minimum rotation of a half-ring
	243	TVector3 fHalfRotMax; // Maximum rotation of a half-ring
	244	Int_t fRunMin; // Run validity start
	245	Int_t fRunMax; // Run validity end
	246	TClonesArray* fArray; // Cache
	247	TString fComment; // Comment on data
	248
	249	ClassDef(AliFMDAlignFaker,0)
	250	};
	251
	252	#endif
	253	//____________________________________________________________________
	254	//
	255	// Local Variables:
	256	// mode: C++
	257	// End:
	258	//
	259	// EOF
	260	//
	261