FMD/AliFMDAlignFaker.h

   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