Adding misalignment with gaussian distribution
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 7 Apr 2006 15:26:58 +0000 (15:26 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 7 Apr 2006 15:26:58 +0000 (15:26 +0000)
(Javier)

MUON/AliMUONGeometryMisAligner.cxx
MUON/AliMUONGeometryMisAligner.h

index 66ead22..f686725 100644 (file)
@@ -19,7 +19,7 @@
 // ----------------------------
 // Class for misalignment of geometry transformations
 //
-// Author:Bruce Becker
+// Authors: Bruce Becker, Javier Castillo
 
 //__________________________________________________________________
 //
 
 #include "AliLog.h"
 
-#include <TGeoManager.h>
-#include <Riostream.h>
-#include <TObjArray.h>
-#include <TSystem.h>
+#include <TGeoMatrix.h>
 #include <TMath.h>
 #include <TRandom.h>
 
-#include <sstream>
-
 ClassImp(AliMUONGeometryMisAligner)
 //______________________________________________________________________________
+AliMUONGeometryMisAligner::AliMUONGeometryMisAligner(Double_t cartXMisAligM, Double_t cartXMisAligW, Double_t cartYMisAligM, Double_t cartYMisAligW, Double_t angMisAligM, Double_t angMisAligW)
+:TObject(), fDisplacementGenerator(0)
+{
+  /// Standard constructor
+  fCartXMisAligM = cartXMisAligM;
+  fCartXMisAligW = cartXMisAligW;      // 0.5 mm. Perhaps this should go into AliMUONConstants.h ? 
+  fCartYMisAligM = cartYMisAligM;
+  fCartYMisAligW = cartYMisAligW;      // 0.5 mm. Perhaps this should go into AliMUONConstants.h ? 
+  fAngMisAligM = angMisAligM;
+  fAngMisAligW = angMisAligW;
+  fXYAngMisAligFactor = 0.0;
+  fZCartMisAligFactor = 0.0;
+  fDisplacementGenerator = new TRandom(0);
+  fUseUni = kFALSE;
+  fUseGaus = kTRUE;
+}
+
+//______________________________________________________________________________
+AliMUONGeometryMisAligner::AliMUONGeometryMisAligner(Double_t cartMisAligM, Double_t cartMisAligW, Double_t angMisAligM, Double_t angMisAligW)
+:TObject(), fDisplacementGenerator(0)
+{
+  /// Standard constructor
+  fCartXMisAligM = cartMisAligM;
+  fCartXMisAligW = cartMisAligW;       // 0.5 mm. Perhaps this should go into AliMUONConstants.h ? 
+  fCartYMisAligM = cartMisAligM;
+  fCartYMisAligW = cartMisAligW;       // 0.5 mm. Perhaps this should go into AliMUONConstants.h ? 
+  fAngMisAligM = angMisAligM;
+  fAngMisAligW = angMisAligW;
+  fXYAngMisAligFactor = 0.0;
+  fZCartMisAligFactor = 0.0;
+  fDisplacementGenerator = new TRandom(0);
+  fUseUni = kFALSE;
+  fUseGaus = kTRUE;
+}
+
+//______________________________________________________________________________
 AliMUONGeometryMisAligner::AliMUONGeometryMisAligner(Double_t cartMisAlig, Double_t angMisAlig)
 :TObject(), fDisplacementGenerator(0)
 {
   /// Standard constructor
-  fMaxCartMisAlig = cartMisAlig;       // 0.5 mm. Perhaps this should go into AliMUONConstants.h ? 
-  fMaxAngMisAlig = angMisAlig;
-  fXYAngMisAligFactor = 1.0;
+  fCartXMisAligM = 0.;
+  fCartXMisAligW = cartMisAlig;        // 0.5 mm. Perhaps this should go into AliMUONConstants.h ? 
+  fCartYMisAligM = 0.;
+  fCartYMisAligW = cartMisAlig;        // 0.5 mm. Perhaps this should go into AliMUONConstants.h ? 
+  fAngMisAligM = 0.;
+  fAngMisAligW = angMisAlig;
+  fXYAngMisAligFactor = 0.0;
+  fZCartMisAligFactor = 0.0;
   fDisplacementGenerator = new TRandom(0);
+  fUseUni = kTRUE;
+  fUseGaus = kFALSE;
 }
 
 //_____________________________________________________________________________
@@ -120,12 +158,66 @@ operator=(const AliMUONGeometryMisAligner & right)
 void
 AliMUONGeometryMisAligner::SetXYAngMisAligFactor(Double_t factor)
 {
-  /// Set factor 
+  /// Set XY angular misalign factor 
 
   if (TMath::Abs(factor) > 1.0 && factor > 0.)
     fXYAngMisAligFactor = factor;
   else
-    AliError(Form("Invalid factor, %d", factor));
+    AliError(Form("Invalid XY angular misalign factor, %d", factor));
+}
+
+//_________________________________________________________________________
+void AliMUONGeometryMisAligner::SetZCartMisAligFactor(Double_t factor) 
+{
+  /// Set XY angular misalign factor 
+  if (TMath::Abs(factor)<1.0 && factor>0.)
+    fZCartMisAligFactor = factor;
+  else
+    AliError(Form("Invalid Z cartesian misalign factor, %d", factor));
+}
+
+//_________________________________________________________________________
+void AliMUONGeometryMisAligner::GetUniMisAlign(Double_t *cartMisAlig, Double_t *angMisAlig) const
+{
+  /// Misalign using uniform distribution
+  /*
+    misalign the centre of the local transformation
+    rotation axes : 
+    fAngMisAlig[1,2,3] = [x,y,z]
+    Assume that misalignment about the x and y axes (misalignment of z plane)
+    is much smaller, since the entire detection plane has to be moved (the 
+    detection elements are on a support structure), while rotation of the x-y
+    plane is more free.
+  */
+  cartMisAlig[0] = fDisplacementGenerator->Uniform(-fCartXMisAligW+fCartXMisAligM, fCartXMisAligM+fCartXMisAligW);
+  cartMisAlig[1] = fDisplacementGenerator->Uniform(-fCartYMisAligW+fCartYMisAligM, fCartYMisAligM+fCartYMisAligW);
+  cartMisAlig[2] = fDisplacementGenerator->Uniform(-fZCartMisAligFactor*(fCartXMisAligW+fCartXMisAligM), fZCartMisAligFactor*(fCartXMisAligM+fCartXMisAligW));  
+  angMisAlig[0] = fDisplacementGenerator->Uniform(-fXYAngMisAligFactor*(fAngMisAligW+fAngMisAligM), fXYAngMisAligFactor*(fAngMisAligM+fAngMisAligW));
+  angMisAlig[1] = fDisplacementGenerator->Uniform(-fXYAngMisAligFactor*(fAngMisAligW+fAngMisAligM), fXYAngMisAligFactor*(fAngMisAligM+fAngMisAligW));
+  angMisAlig[2] = fDisplacementGenerator->Uniform(-fAngMisAligW+fAngMisAligM, fAngMisAligM+fAngMisAligW);      // degrees
+}
+
+//_________________________________________________________________________
+void AliMUONGeometryMisAligner::GetGausMisAlign(Double_t cartMisAlig[3], Double_t angMisAlig[3]) const
+{
+  /// Misalign using gaussian distribution
+  /*
+    misalign the centre of the local transformation
+    rotation axes : 
+    fAngMisAlig[1,2,3] = [x,y,z]
+    Assume that misalignment about the x and y axes (misalignment of z plane)
+    is much smaller, since the entire detection plane has to be moved (the 
+    detection elements are on a support structure), while rotation of the x-y
+    plane is more free.
+  */
+  cartMisAlig[0] = fDisplacementGenerator->Gaus(fCartXMisAligM, fCartXMisAligW);
+  cartMisAlig[1] = fDisplacementGenerator->Gaus(fCartYMisAligM, fCartYMisAligW);
+  cartMisAlig[2] = fDisplacementGenerator->Gaus(fCartXMisAligM, fZCartMisAligFactor*fCartXMisAligW);
+  angMisAlig[0] = fDisplacementGenerator->Gaus(fAngMisAligM, fXYAngMisAligFactor*fAngMisAligW);
+  angMisAlig[1] = fDisplacementGenerator->Gaus(fAngMisAligM, fXYAngMisAligFactor*fAngMisAligW);
+  angMisAlig[2] = fDisplacementGenerator->Gaus(fAngMisAligM, fAngMisAligW);    // degrees
 }
 
 //_________________________________________________________________________
@@ -146,26 +238,19 @@ TGeoCombiTrans AliMUONGeometryMisAligner::MisAlign(const TGeoCombiTrans & transf
     {
       rot = new TGeoRotation("rot");
     }                  // default constructor.
-  
-  cartMisAlig[0] = fDisplacementGenerator->Uniform(-1. * fMaxCartMisAlig, fMaxCartMisAlig);
-  cartMisAlig[1] = fDisplacementGenerator->Uniform(-1. * fMaxCartMisAlig, fMaxCartMisAlig);
-  cartMisAlig[2] = fDisplacementGenerator->Uniform(-1. * fMaxCartMisAlig, fMaxCartMisAlig);
-  
+
+  if (fUseUni) { 
+    GetUniMisAlign(cartMisAlig,angMisAlig);
+  }
+  else { 
+    if (!fUseGaus) {
+      AliWarning("Neither uniform nor gausian distribution is set! Will use gausian...");
+    } 
+    GetGausMisAlign(cartMisAlig,angMisAlig);
+  }
+
   TGeoTranslation newTrans(cartMisAlig[0] + trans[0], cartMisAlig[1] + trans[1], cartMisAlig[2] + trans[2]);
   
-  /*
-    misalign the centre of the local transformation
-    rotation axes : 
-    fAngMisAlig[1,2,3] = [x,y,z]
-    Assume that misalignment about the x and y axes (misalignment of z plane)
-    is much smaller, since the entire detection plane has to be moved (the 
-    detection elements are on a support structure), while rotation of the x-y
-    plane is more free.
-  */
-  
-  angMisAlig[0] = fDisplacementGenerator->Uniform(fXYAngMisAligFactor * fMaxAngMisAlig,  1.0 * fMaxAngMisAlig);
-  angMisAlig[1] =    fDisplacementGenerator->Uniform(fXYAngMisAligFactor * fMaxAngMisAlig, 1.0 * fMaxAngMisAlig);
-  angMisAlig[2] = fDisplacementGenerator->Uniform(-1. * fMaxAngMisAlig, fMaxAngMisAlig);       // degrees
   AliInfo(Form("Rotated by %f about Z axis.", angMisAlig[2]));
   rot->RotateX(angMisAlig[0]);
   rot->RotateY(angMisAlig[1]);
@@ -174,7 +259,6 @@ TGeoCombiTrans AliMUONGeometryMisAligner::MisAlign(const TGeoCombiTrans & transf
   return TGeoCombiTrans(newTrans, *rot);
 }
 
-
 //______________________________________________________________________
 AliMUONGeometryTransformer *
 AliMUONGeometryMisAligner::MisAlign(const AliMUONGeometryTransformer *
index 9ba2e07..e22b6e3 100644 (file)
@@ -7,23 +7,25 @@
 /// \class AliMUONGeometryMisAligner
 /// \brief Class for misalignment of geometry transformations
 ///
-/// Author: Bruce Becker
+/// Authors: Bruce Becker, Javier Castillo
 
 
 #ifndef ALI_MUON_GEOMETRY_MIS_ALIGNER_H
 #define ALI_MUON_GEOMETRY_MIS_ALIGNER_H
 
 #include <TObject.h>
-#include <TGeoMatrix.h>
 
 class AliMUONGeometryTransformer;
 
 class TRandom;
+class TGeoCombiTrans;
 
 class AliMUONGeometryMisAligner:public TObject
 {
  public:
-  AliMUONGeometryMisAligner(Double_t cartMisAlig, Double_t angMisAlig);
+  AliMUONGeometryMisAligner(Double_t cartXMisAligM, Double_t cartXMisAligW, Double_t cartYMisAligM, Double_t cartYMisAligW, Double_t angMisAligM, Double_t angMisAligW);
+  AliMUONGeometryMisAligner(Double_t cartMisAligM, Double_t cartMisAligW, Double_t angMisAligM, Double_t angMisAligW);
+  AliMUONGeometryMisAligner(Double_t cartMisAligW, Double_t angMisAligW);
   AliMUONGeometryMisAligner();
   virtual ~AliMUONGeometryMisAligner();
   
@@ -34,29 +36,55 @@ class AliMUONGeometryMisAligner:public TObject
   AliMUONGeometryTransformer* MisAlign(const AliMUONGeometryTransformer* transformer, 
                                        Bool_t verbose = kFALSE);
   
-  void SetMaxCartMisAlig(Double_t offset)
-    {fMaxCartMisAlig = offset ;}
+  void SetCartMisAlig(Double_t xmean, Double_t xwidth, Double_t ymean, Double_t ywidth)
+    {fCartXMisAligM = xmean; fCartXMisAligW = xwidth; fCartYMisAligM = ymean; fCartYMisAligW = ywidth;}
+
+  void SetCartMisAlig(Double_t mean, Double_t width)
+    {fCartXMisAligM = mean; fCartXMisAligW = width; fCartYMisAligM = mean; fCartYMisAligW = width;}
   
-  void SetMaxAngMisAlig(Double_t offset)
-    {fMaxAngMisAlig = offset;}
+  void SetAngMisAlig(Double_t mean, Double_t width)
+    {fAngMisAligM = mean; fAngMisAligW = width;}
   
-  void SetXYAngMisAligFactor(Double_t factor);
+  void SetMaxCartMisAlig(Double_t width) // Kept for backward compatibility
+    {fCartXMisAligM = 0.0; fCartXMisAligW = width; fCartYMisAligM = 0.0; fCartYMisAligW = width;}
   
+  void SetMaxAngMisAlig(Double_t width) // Kept for backward compatibility
+    {fAngMisAligM = 0.0; fAngMisAligW = width;}
+
+  void SetXYAngMisAligFactor(Double_t factor);
+
+  void SetZCartMisAligFactor(Double_t factor);
+
+  void SetUseGaus(Bool_t usegaus)
+    {fUseGaus=usegaus; fUseUni=!usegaus;}
+
+  void SetUseUni(Bool_t useuni)
+    {fUseGaus=!useuni; fUseUni=useuni;}
   
  protected:
   AliMUONGeometryMisAligner(const AliMUONGeometryMisAligner & right);
   AliMUONGeometryMisAligner & operator =(const AliMUONGeometryMisAligner &right);
   
+  
  private:
   // return a misaligned transformation
   TGeoCombiTrans MisAlign(const TGeoCombiTrans& transform) const;
+  void GetUniMisAlign(Double_t cartMisAlig[3], Double_t angMisAlig[3]) const;
+  void GetGausMisAlign(Double_t cartMisAlig[3], Double_t angMisAlig[3]) const;
 
-  Double_t fMaxCartMisAlig;   // cartesian displacement range, set by SetMaxCartMisAlig (translations)
-  Double_t fMaxAngMisAlig;    // Angular displacement range (rotations)
+  Bool_t fUseUni;            // use uniform distribution for misaligmnets
+  Bool_t fUseGaus;            // use gaussian distribution for misaligmnets
+  Double_t fCartXMisAligM;   // cartesian displacement mean along x,  (translations)
+  Double_t fCartXMisAligW;   // cartesian displacement width along x,  (translations)
+  Double_t fCartYMisAligM;   // cartesian displacement mean along y,  (translations)
+  Double_t fCartYMisAligW;   // cartesian displacement width along y,  (translations)
+  Double_t fAngMisAligM;    // Angular displacement mean (rotations)
+  Double_t fAngMisAligW;    // Angular displacement range (rotations)
   Double_t fXYAngMisAligFactor; // factor (<1) to apply to angular misalignment range since range of motion is restricted out of the xy plane
+  Double_t fZCartMisAligFactor; // factor (<1) to apply to cartetian misalignment range since range of motion is restricted in z direction
   TRandom *fDisplacementGenerator;  // random number generator for the displacements
   
-  ClassDef(AliMUONGeometryMisAligner,2)        // Geometry parametrisation
+  ClassDef(AliMUONGeometryMisAligner,3)        // Geometry parametrisation
 };
 
 #endif //ALI_MUON_GEOMETRY_MIS_ALIGNER_H