class HMdcMetaAligner: public HReconstructor

 Default constructor.

 Constructor including module election. Alignment procedure
 proyects hits of modA and modB on META coordinate system and compares

 Constructor including module election (and name and title, which
 seems to be very important). Alignment procedure
 proyects hits of modA and modB on META coordinate system and compares

 Constructor for only one MDC

 Inits common defaults

 Destructor.

 Minimization defaults

 Sets ascii output for debugging.

 Sets ascii output for debugging.

 Sets number of sigmas in cuts.

 Inits histograms

Fits to a gaussian the two relevant histograms
(residuals in X and Y for Meta Histograms)
and obtains the fit parameters for further data selection

Fits to a gaussian the four relevant histograms
and obtains the fit parameters for further data selection

 return a tree to the minimization functional.

 Inits TNtuple

 Inits hitaux category and calls setParContainers()

 Call the functions returning auxiliar geometrical parameters

Turn on the automatic geometrical parameter input

Turn on the automatic geometrical parameter input

 Disables control histograms output (saving memory)

 Selects minimization strategy

 select = 0  Disables minimization
 select = 1  Angle reduction by minuit
 select = 2  Analytic translation minimization
 select = 3  (1+2) Angle reduction+analytic translation
 select = 4  Translation reduction by minuit
 select = 5  6 parameters reduction by minuit
 select = 100 (fcnalign34) Chi square sum in minimization
 select = 101 (fcnalign34) Distances line-hit
 select = 500 + (2) Iterative minimization
            version of the previously described algorithms
  in particular:
 select = 502 Iterative version

 Disables minimization

 introduce unit errors in Hits

 Only one Reference System is used for all TOF in one
 sector

 Target position is defined and used for
 the hit definition in
 (WARNING. Use only with one MDC)

 Fix a parameter set in minimization


 20    fixes translations
 30    fixes rotations
 40    fixes Z traslations
 110   fixes all first and third angles

 Disables the cuts after fitting the histograms

 Enables the Slope cuts after fitting the histograms.
 This cut makes the sample near indep. of Z translations
 and results useful for X and Y minimization.
 The cut is effective only in MDCB, because fTranslation
 is represented in MDCB coordinates. Then, tracks passing
 the cut are almost parallel to Z direction

 Loads the parameter containers it uses later

 Defines the parameter containers it uses later

 The transformations are:  X = R X' + T
 in the geometrical parameters.
 To obtain relative transformations: X(B) = M X(A) + V
 we follow:
   X = R(A) X(A) + T(A)
   X = R(B) X(B) + T(B)

   X(B) = [R(B)]E-1 R(A) X(A) + [R(B)]E-1 [T(A)-T(B)]

   M = [R(B)]E-1 R(A)
   V = [R(B)]E-1 [T(A)-T(B)]

 From M it is easy to get the relative Euler angles

 CONVENTION: fRotMat[i] and fTranslation[i] store the
 matrix M and vector V of the transformations made like this:
 4 modules: [0]  X(D) = fRotMat[0] X(C) + fTranslation[0]
            [1]  X(D) = fRotMat[1] X(B) + fTranslation[1]
            [2]  X(D) = fRotMat[2] X(A) + fTranslation[2]

 3 modules: [0]  X(C) = fRotMat[0] X(B) + fTranslation[0]
            [1]  X(C) = fRotMat[1] X(A) + fTranslation[1]

 2 modules: [0]  X(B) = fRotMat[0] X(A) + fTranslation[0]

 From the relative rotation, get the euler angles (radians)

 From an Euler rotation (see Dahlinger paper for the convention)
 the euler angles are:
 euler[0] = atan2(rot(5)/sin(euler[1]),rot(2)/sin(euler[1]))
 euler[1] = acos (rot(8))    with possible change of sign
 euler[2] = atan2(rot(7)/sin(euler[1]),-rot(6)/sin(euler[1]))

 Entering geometrical parameters.

 To be used introducing in the macro the parameters for
 testing, optimization ...

 Entering geometrical parameters.

 To be used introducing in the macro the parameters for
 testing, optimization ...

 Iteration in the hit category. Fills histograms
 and TTree and calculates relevant quantities

 New execute for four MDCs
 Find the projection of Hits in the most external MDCs
 on the inners (besides this can be modified, changing the
 order of the MDCs in the constructor). Then merge the hits
 and continue to find till the last MDC. If successfull,
 fills a TClonesArray of Hits in a TTree for further
 analysis and minimization

 New execute for more than two MDCs

 Adapting the old execute

 Only one MDC.

 Transformation from one coordinate system to a new one
     newV = eulrot * oldV + eulvec

 Transformation from one coordinate system to a new one
     newV = eulrot * (oldV - eulvec)

 Find the projection point of a Hit on META plane
 Uses a Hit to project on the META plane
 defined by rotM and traM

 Two methods are defined. One suposes target at fTargetPos
 (fUseTarget =kTRUE) and the other uses the hit slopes.

 Find the projection point of a Hit pair on META plane

 Given a relative rotation and translation from MDC A to MDC B
 (see CONVENTION in HMdcMetaAligner::setGeomAuxPar())
  X(B) = rot X(A) + tra
 this function obtains the MDC A coordinates in
 MDC B coordinate system using rot and tra.
 Then uses both Hits to project on the META plane
 defined by rotM and traM

 Find the projection point of a Hit on another MDC

 Given a relative rotation and translation from MDC A to MDC B
 (see CONVENTION in HMdcMetaAligner::setGeomAuxPar())
  X(B) = rot X(A) + tra
 this function obtains the projection in MDC B of a Hit in MDC A

 When the user wants to obtain the projection in MDC A of a Hit in
 MDC B, should provide the inverse transformations
 Example: X(A) = rot-1 * X(B) - rot-1 * tra
               = newrot * X(B) + newtra
 where:
    newrot = rot-1
    newtra = - (rot-1 * tra)
 The function returns also the slopes in the new coordinate system

Check if the TOF hit is inside a window around proj  point
If it is, include in vec
montones de parametros que deberian estar en contenedores estan a mano!

Check if the SHOWER hit is inside a window around proj  point
If it is, include in vec
SHOWER
getting info from the address

Check if the hit is inside a window around point and slope

old check. Implement new one PLEASE!
New one base on equiprobability elipse (Beatriz paper)

 Propagates hitA in hitB coordinate system and merges
 the information in a new hit in hitB coordinate system
 The rot and tra verifies the CONVENTION
 (see HMdcMetaAligner::setGeomAuxPar()), that is:
     X(B) = rot X(A) + tra
 Normally B is reference MDC, which is farther from target
HMdcHit* pHit = new HMdcHit();
Now, only mean values. Later, propagate the covariance and add the
multiple scattering effect on hitA

      pHit->setX(,);
      pHit->setY(,);
      pHit->setXDir(,);
      pHit->setYDir(,);

      return pHit;

Only for test purposes, return hitB

Transform hit angular components in slopes

 Statistical information and Minimization procedure

 Performs the graphical output from obtained parameters

 Performs the graphical output from obtained parameters

 Stores all histos and tree in the Root file

 Fill a matrix using the Euler angles of the relative transformation

OLD
      fRotMat[0][0]=(cos(prim) * cos(segu) * cos(terc)) - (sin(prim) * sin(terc));
      fRotMat[1][0]=( - cos(prim) * cos(segu) * sin(terc)) - (sin(prim) * cos(terc));
      fRotMat[2][0]=(cos(prim) * sin(segu));
      fRotMat[0][1]=(sin(prim) * cos(segu) * cos(terc)) + (cos(prim) * sin(terc));
      fRotMat[1][1]=( - sin(prim) * cos(segu) * sin(terc)) + (cos(prim) * cos(terc));
      fRotMat[2][1]=(sin(prim) * sin(segu));
      fRotMat[0][2]=( - sin(segu) * cos(terc));
      fRotMat[1][2]=(sin(segu) * sin(terc));
      fRotMat[2][2]=(cos(segu));

ATT! Correspondencia entre HGeomRotation y la antigua transf. arriba

  rot(0) rot(1) rot(2)     fRotMat[0][0] fRotMat[1][0] fRotMat[2][0]
  rot(3) rot(4) rot(5)  =  fRotMat[0][1] fRotMat[1][1] fRotMat[2][1]
  rot(6) rot(7) rot(8)     fRotMat[0][2] fRotMat[1][2] fRotMat[2][2]

 Translation from META to MDC

TOF Unique CS (all modules refer to [fUniqueTofDet])

 Fill a matrix using the Euler angles of the relative transformation

OLD
      fRotMat[0][0]=(cos(prim) * cos(segu) * cos(terc)) - (sin(prim) * sin(terc));
      fRotMat[1][0]=( - cos(prim) * cos(segu) * sin(terc)) - (sin(prim) * cos(terc));
      fRotMat[2][0]=(cos(prim) * sin(segu));
      fRotMat[0][1]=(sin(prim) * cos(segu) * cos(terc)) + (cos(prim) * sin(terc));
      fRotMat[1][1]=( - sin(prim) * cos(segu) * sin(terc)) + (cos(prim) * cos(terc));
      fRotMat[2][1]=(sin(prim) * sin(segu));
      fRotMat[0][2]=( - sin(segu) * cos(terc));
      fRotMat[1][2]=(sin(segu) * sin(terc));
      fRotMat[2][2]=(cos(segu));

ATT! Correspondencia entre HGeomRotation y la antigua transf. arriba

  rot(0) rot(1) rot(2)     fRotMat[0][0] fRotMat[1][0] fRotMat[2][0]
  rot(3) rot(4) rot(5)  =  fRotMat[0][1] fRotMat[1][1] fRotMat[2][1]
  rot(6) rot(7) rot(8)     fRotMat[0][2] fRotMat[1][2] fRotMat[2][2]

 Translation from MDC A to MDC B

 Euler angles in transformation MDC B - META

 Euler angles in transformation from MDC A to MDC B

 Limits of the square defined in the search procedure

 Set the criteria for iteration in the minimization (see finalize())

 Set the weights in the fcn()

 Set the steps in the minimization

 Set the criteria for iteration in the minimization (see finalize())

 Analytical minimization of the function
 X and Y residuals
 Results are the relative translation
 vector components
 (WARNING: Use it here just with one MDC and target)

 Matrix:

    a 0 c      translation[0]     f
    0 b d   *  translation[1]  =  g
    c d e      translation[2]     h

 results in

 translation[0] = (fbe+gdc-bch-fdd)/(abe-bcc-add)
 translation[1] = (age+fdc-gcc-dha)/(abe-bcc-add)
 translation[2] = (abh-fbc-gda)/(abe-bcc-add)

 Analytical minimization of the function
 X and Y residuals fot Unique Reference System in TOF
 Results are the relative translation
 vector components for Reference TOF System
 (WARNING: Use it here just with one MDC and target)

 Matrix:

    a b c      translation[0]     j
    b e f   *  translation[1]  =  k
    c f i      translation[2]     l

 results in

 translation[0] = (jei+bfl+kfc-cel-bki-ffj)/(aei+2fcb-cce-bbi-ffa)
 translation[1] = (aki+jfc+cbl-cck-jbi-lfa)/(aei+2fcb-cce-bbi-ffa)
 translation[2] = (ael+bkc+fbj-jec-bbl-kfa)/(aei+2fcb-cce-bbi-ffa)

 Minuit menu
 Put first argument to 1 to fix angular values
 Put first argument to 2 to fix translation values
 Other arguments are init values for the parameters!