ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//-----------------------------------------------------------------------------
/// \class AliMillepede
/// Detector independent alignment class
///
/// This modified C++ version is based on a C++ translation of Millepede used 
/// for LHCb Vertex Detector alignment (lhcb-2005-101), available here 
/// http://isscvs.cern.ch/cgi-bin/cvsweb.cgi/Alignment/AlignmentTools/src/?cvsroot=lhcb
/// The original millepede fortran package is available at:  
/// http://www.desy.de/~blobel/wwwmille.html  
///
/// \author Javier Castillo
//-----------------------------------------------------------------------------

#include <TArrayI.h>
#include <TArrayD.h>
#include <TMath.h>

#include "AliLog.h"

#include "AliMillepede.h"

//=============================================================================
AliMillepede::AliMillepede()
  : TObject(),
    fIndexLocEq(fgkMaxGlobalPar+fgkMaxLocalPar),
    fDerivLocEq(fgkMaxGlobalPar+fgkMaxLocalPar),
    fIndexAllEqs(1000*fgkMaxGlobalPar+fgkMaxLocalPar),
    fDerivAllEqs(1000*fgkMaxGlobalPar+fgkMaxLocalPar),
    fLocEqPlace(1000), 
    fNIndexLocEq(0),
    fNDerivLocEq(0),
    fNIndexAllEqs(0),
    fNDerivAllEqs(0),
    fNLocEqPlace(0),
    fNLocalEquations(0),
    fResCutInit(0.),
    fResCut(0.),
    fChi2CutFactor(1.0),
    fChi2CutRef(1.0),
    fIter(0),
    fMaxIter(10),
    fNStdDev(3),
    fNGlobalConstraints(0),
    fNLocalFits(0),
    fNLocalFitsRejected(0),
    fNGlobalPar(0),
    fNLocalPar(0)
{
  /// Standard constructor

  AliInfo("                                           ");
  AliInfo("            * o o                   o      ");
  AliInfo("              o o                   o      ");
  AliInfo("   o ooooo  o o o  oo  ooo   oo   ooo  oo  ");
  AliInfo("    o  o  o o o o o  o o  o o  o o  o o  o ");
  AliInfo("    o  o  o o o o oooo o  o oooo o  o oooo ");
  AliInfo("    o  o  o o o o o    ooo  o    o  o o    ");
  AliInfo("    o  o  o o o o  oo  o     oo   ooo  oo  ++ starts");	   
  AliInfo("                                           ");

}

//=============================================================================
AliMillepede::~AliMillepede() {
  /// Destructor

}

//=============================================================================
Int_t AliMillepede::InitMille(int nGlo, int nLoc, int lNStdDev,
			      double lResCut, double lResCutInit)
{
  /// Initialization of millepede
  AliDebug(1,"");
  AliDebug(1,"----------------------------------------------------");
  AliDebug(1,"");
  AliDebug(1,"    Entering InitMille");
  AliDebug(1,"");
  AliDebug(1,"-----------------------------------------------------");
  AliDebug(1,"");

  fNGlobalConstraints = 0;
  fNLocalFits  = 0;                      // Total number of local fits
  fNLocalFitsRejected  = 0;              // Total number of local fits rejected
  fChi2CutRef  = 1.0;                    // Reference value for Chi^2/ndof cut

  AliMillepede::SetNLocalEquations(0);     // Number of local fits (starts at 0)

  fIter    = 0;  // By default iterations are turned off, turned on by use SetIterations
  fMaxIter = 10;

  fResCutInit = lResCutInit; 
  fResCut = lResCut;

  fNGlobalPar = nGlo;     // Number of global derivatives
  fNLocalPar  = nLoc;     // Number of local derivatives
  fNStdDev    = lNStdDev; // Number of StDev for local fit chisquare cut

  AliDebug(1,Form("Number of global parameters   : %d", fNGlobalPar));
  AliDebug(1,Form("Number of local parameters    : %d", fNLocalPar));
  AliDebug(1,Form("Number of standard deviations : %d", fNStdDev));

  if (fNGlobalPar>fgkMaxGlobalPar || fNLocalPar>fgkMaxLocalPar) {
    AliDebug(1,"Two many parameters !!!!!");
    return 0;
  }

  // Global parameters initializations
  for (int i=0; i<fNGlobalPar; i++) {  
    fVecBGlo[i]=0.;
    fInitPar[i]=0.;
    fDeltaPar[i]=0.;
    fSigmaPar[i]=-1.;
    fIsNonLinear[i]=0;
    fGlo2CGLRow[i]=-1;
    fCGLRow2Glo[i]=-1;
    
    for (int j=0; j<fNGlobalPar;j++) {    
      fMatCGlo[i][j]=0.;
    }
  }

  // Local parameters initializations
  
  for (int i=0; i<fNLocalPar; i++) {
    fVecBLoc[i]=0.;
    
    for (int j=0; j<fNLocalPar;j++) {
      fMatCLoc[i][j]=0.;
    }
  }

  // Then we fix all parameters...

  for (int j=0; j<fNGlobalPar; j++) {
    AliMillepede::SetParSigma(j,0.0);
  }

  fDerivLocEq.Reset();  fNDerivLocEq=0;  
  fIndexLocEq.Reset();  fNIndexLocEq=0; 

  fIndexAllEqs.Reset();  fNIndexAllEqs=0;
  fDerivAllEqs.Reset();  fNDerivAllEqs=0;
  fLocEqPlace.Reset();  fNLocEqPlace=0;

  AliDebug(1,"");
  AliDebug(1,"----------------------------------------------------");
  AliDebug(1,"");
  AliDebug(1,"    InitMille has been successfully called!");
  AliDebug(1,"");
  AliDebug(1,"-----------------------------------------------------");
  AliDebug(1,"");
	
  return 1;
}

/*
-----------------------------------------------------------
  PARGLO: initialization of global parameters
-----------------------------------------------------------

  param    = array of starting values

-----------------------------------------------------------
*/
Int_t AliMillepede::SetGlobalParameters(double *param)
{
  /// initialization of global parameters
  for(Int_t iPar=0; iPar<fNGlobalPar; iPar++){
    fInitPar[iPar] = param[iPar];
  }

 return 1;
}

/*
-----------------------------------------------------------
  PARGLO: initialization of global parameters
-----------------------------------------------------------

  iPar    = the index of the global parameter in the 
             result array (equivalent to fDeltaPar[]).

  param    = the starting value

-----------------------------------------------------------
*/
Int_t AliMillepede::SetGlobalParameter(int iPar, double param)
{
  /// initialization of global parameter iPar
  if (iPar<0 || iPar>=fNGlobalPar) {
    return 0;
  }
  else {
    fInitPar[iPar] = param;
  }
  return 1;
}


/*
-----------------------------------------------------------
  PARSIG: define a constraint for a single global param
          param is 'encouraged' to vary within [-sigma;sigma] 
	  range
-----------------------------------------------------------

  iPar    = the index of the global parameter in the 
             result array (equivalent to fDeltaPar[]).

  sigma	   = value of the constraint (sigma <= 0. will 
             mean that parameter is FIXED !!!) 
 
-----------------------------------------------------------
*/ 
Int_t AliMillepede::SetParSigma(int iPar, double sigma)
{
  /// Define a range [-sigma;sigma] where iPar is encourage to vary 
  if (iPar>=fNGlobalPar) {
    return 0;
  }
  else {
    fSigmaPar[iPar] = sigma;
  }

  return 1;
}


/*
-----------------------------------------------------------
  NONLIN: set nonlinear flag for a single global param
          update of param durin iterations will not
	  consider initial starting value
-----------------------------------------------------------

  iPar    = the index of the global parameter in the 
             result array (equivalent to fDeltaPar[]).

-----------------------------------------------------------
*/
Int_t AliMillepede::SetNonLinear(int iPar)
{
  /// Set nonlinear flag for iPar 
  if (iPar<0 || iPar>=fNGlobalPar) {
    return 0;
  }
  else {
    fIsNonLinear[iPar] = 1;
  }
  
  return 1;
}


/*
-----------------------------------------------------------
  INITUN: unit for iteration
-----------------------------------------------------------
  
  lChi2CutFac is used by Fitloc to define the Chi^2/ndof cut value

  A large cutfac value enables to take a wider range of tracks 
  for first iterations, which might be useful if misalignments
  are large.

  As soon as cutfac differs from 0 iteration are requested.
  cutfac is then reduced, from one iteration to the other,
  and iterations are stopped when it reaches the value 1.

  At least one more iteration is often needed in order to remove
  tracks containing outliers.
  
-----------------------------------------------------------
*/
Int_t AliMillepede::SetIterations(double lChi2CutFac)
{
  /// Number of iterations is calculated from lChi2CutFac 
  fChi2CutFactor = TMath::Max(1.0, lChi2CutFac);

  AliInfo(Form("Initial cut factor is %f",fChi2CutFactor));
  fIter = 1; // Initializes the iteration process
  return 1;
}

/*
-----------------------------------------------------------
  CONSTF: define a constraint equation in AliMillepede
-----------------------------------------------------------

  dercs    = the row containing constraint equation 
             derivatives (put into the final matrix)

  lLagMult      = the lagrange multiplier value (sum of equation)	     

-----------------------------------------------------------
*/
Int_t AliMillepede::SetGlobalConstraint(double dercs[], double lLagMult)
{ 
  /// Define a constraint equation
  if (fNGlobalConstraints>=fgkMaxGloCsts) {  
    AliInfo("Too many constraints !!!");
    return 0;
  }
 	
  for (int i=0; i<fNGlobalPar; i++) {
    fMatDerConstr[fNGlobalConstraints][i] = dercs[i];
  }
 	
  fLagMult[fNGlobalConstraints] = lLagMult;
  fNGlobalConstraints++ ;
  AliInfo(Form("Number of constraints increased to %d",fNGlobalConstraints));
  return 1;
}


/*
-----------------------------------------------------------
  EQULOC: write ONE equation in the matrices
-----------------------------------------------------------

  dergb[1..fNGlobalPar]	= global parameters derivatives
  derlc[1..fNLocalPar] 	= local parameters derivatives
  rmeas  		= measured value
  sigma 		= error on measured value (nothing to do with SetParSigma!!!)

-----------------------------------------------------------
*/
Int_t AliMillepede::SetLocalEquation(double dergb[], double derlc[], double lMeas, double lSigma)
{	
  /// Write one local equation
  if (lSigma<=0.0) { // If parameter is fixed, then no equation
    for (int i=0; i<fNLocalPar; i++) {
      derlc[i] = 0.0;
    }
    for (int i=0; i<fNGlobalPar; i++) {
      dergb[i] = 0.0;
    }
    return 1;
  }
    
  // Serious equation, initialize parameters   	
  double lWeight =  1.0/(lSigma*lSigma);
  int iLocFirst  = -1;
  int iLocLast   = -1;
  int iGlobFirst = -1;
  int iGlobLast  = -1;
 
  for (int i=0; i<fNLocalPar; i++) { // Retrieve local param interesting indices
    if (derlc[i]!=0.0) {
      if (iLocFirst == -1) { 
	iLocFirst = i;	// first index
      }
      iLocLast = i;     // last index
    }
  }
  AliDebug(2,Form("%d / %d",iLocFirst, iLocLast));
	
  for (int i=0; i<fNGlobalPar; i++) { // Idem for global parameters
    if (dergb[i]!=0.0) {
      if (iGlobFirst == -1) {
	iGlobFirst = i;  // first index
      }
      iGlobLast = i; 	 // last index
    }
  }
  AliDebug(2,Form("%d / %d",iGlobFirst,iGlobLast));

  if (fNIndexLocEq==fIndexLocEq.GetSize()) fIndexLocEq.Set(2*fNIndexLocEq);
  fIndexLocEq.AddAt(-1,fNIndexLocEq++);    
  if (fNDerivLocEq==fDerivLocEq.GetSize()) fDerivLocEq.Set(2*fNDerivLocEq);
  fDerivLocEq.AddAt(lMeas,fNDerivLocEq++);    


  for (int i=iLocFirst; i<=iLocLast; i++) { // Store interesting local parameters
    if (derlc[i]!=0.0) {
      if (fNIndexLocEq==fIndexLocEq.GetSize()) fIndexLocEq.Set(2*fNIndexLocEq);
      fIndexLocEq.AddAt(i,fNIndexLocEq++);    
      if (fNDerivLocEq==fDerivLocEq.GetSize()) fDerivLocEq.Set(2*fNDerivLocEq);
      fDerivLocEq.AddAt(derlc[i],fNDerivLocEq++);    
      derlc[i] = 0.0;
    }
  }

  if (fNIndexLocEq==fIndexLocEq.GetSize()) fIndexLocEq.Set(2*fNIndexLocEq);
  fIndexLocEq.AddAt(-1,fNIndexLocEq++);    
  if (fNDerivLocEq==fDerivLocEq.GetSize()) fDerivLocEq.Set(2*fNDerivLocEq);
  fDerivLocEq.AddAt(lWeight,fNDerivLocEq++);    

  for (int i=iGlobFirst; i<=iGlobLast; i++) { // Store interesting global parameters
    if (dergb[i]!=0.0) {
      if (fNIndexLocEq==fIndexLocEq.GetSize()) fIndexLocEq.Set(2*fNIndexLocEq);
      fIndexLocEq.AddAt(i,fNIndexLocEq++);    
      if (fNDerivLocEq==fDerivLocEq.GetSize()) fDerivLocEq.Set(2*fNDerivLocEq);
      fDerivLocEq.AddAt(dergb[i],fNDerivLocEq++);    
      dergb[i] = 0.0;
    }
  }
  
  AliDebug(2,Form("Out Equloc --  NST = %d",fNDerivLocEq));
  return 1; 	
}

/*
-----------------------------------------------------------
  FITLOC:  perform local params fit, once all the equations
           have been written by EquLoc
-----------------------------------------------------------

  iFit        = number of the fit, it is used to store 
                fit parameters and then retrieve them 
		for iterations (via FINDEXALLEQS and FDERIVALLEQS)

  localParams = contains the fitted track parameters and
                related errors

  bSingleFit  = is an option, if it is set to 1, we don't 
                perform the last loop. It is used to update 
		the track parameters without modifying global
		matrices

-----------------------------------------------------------
*/
Int_t AliMillepede::LocalFit(int iFit, double localParams[], Bool_t bSingleFit)
{
  /// Perform local parameters fit once all the local equations have been set

  // Few initializations
  int iEqTerm = 0;
  int i, j, k;
  int iIdx, jIdx, kIdx;
  int iIdxIdx, jIdxIdx;
  int iMeas   = -1;
  int iWeight = 0;
  int iLocFirst = 0;
  int iLocLast  = 0;
  int iGloFirst = 0;
  int iGloLast  = 0;
  int nGloInFit = 0;
	
  double lMeas    = 0.0;
  double lWeight  = 0.0;

  double lChi2    = 0.0;
  double lRedChi2 = 0.0;
  double lChi2Cut = 0.0;
  int nEq  = 0;
  int nDoF = 0;
  int nEqTerms = fNDerivLocEq; // Number of terms (local + global derivatives, 		 
			       // measurement and weight) involved in this local equation


  // Fill the track store at first pass

  if (fIter < 2 && !bSingleFit) { // Do it only once 
    AliDebug(1,Form("Store equation no: %d", iFit)); 

    for (i=0; i<nEqTerms; i++) { // Store the track parameters
      if (fNIndexAllEqs==fIndexAllEqs.GetSize()) fIndexAllEqs.Set(2*fNIndexAllEqs);
      fIndexAllEqs.AddAt(fIndexLocEq[i],fNIndexAllEqs++);
      if (fNDerivAllEqs==fDerivAllEqs.GetSize()) fDerivAllEqs.Set(2*fNDerivAllEqs);
      fDerivAllEqs.AddAt(fDerivLocEq[i],fNDerivAllEqs++);
    }
    if (fNLocEqPlace==fLocEqPlace.GetSize()) fLocEqPlace.Set(2*fNLocEqPlace);
    fLocEqPlace.AddAt(fNIndexAllEqs,fNLocEqPlace++);

    
    AliDebug(2,Form("FLocEqPlace size = %d",fLocEqPlace[iFit])); 
    AliDebug(2,Form("FIndexAllEqs size   = %d",fNIndexAllEqs)); 
  }


  for (i=0; i<fNLocalPar; i++) { // reset local params
    fVecBLoc[i] = 0.0;

    for (j=0; j<fNLocalPar; j++) {
      fMatCLoc[i][j] = 0.0;
    }
  }
	
  for (i=0; i<fNGlobalPar; i++) {
    fGlo2CGLRow[i] = -1;  // reset mixed params
  }


/*

  LOOPS : HOW DOES IT WORKS ?	

  Now start by reading the informations stored with EquLoc.
  Those informations are in vector FINDEXSTORE and FDERIVSTORE.
  Each -1 in FINDEXSTORE delimits the equation parameters:
  
  First -1  ---> lMeas in FDERIVSTORE 
  Then we have indices of local eq in FINDEXSTORE, and derivatives in FDERIVSTORE
  Second -1 ---> weight in FDERIVSTORE
  Then follows indices and derivatives of global eq.
  ....
  
  We took them and store them into matrices.
  
  As we want ONLY local params, we substract the part of the estimated value
  due to global params. Indeed we could have already an idea of these params,
  with previous alignment constants for example (set with PARGLO). Also if there
  are more than one iteration (FITLOC could be called by FITGLO)

*/

    
//
// FIRST LOOP : local track fit
//
	
  iEqTerm = 0;
//   fIndexLocEq.push_back(-1);
  if (fNIndexLocEq==fIndexLocEq.GetSize()) fIndexLocEq.Set(2*fNIndexLocEq);
  fIndexLocEq.AddAt(-1,fNIndexLocEq++);    
  
  while (iEqTerm <= nEqTerms) {
    if (fIndexLocEq[iEqTerm] == -1) {
      if (iMeas == -1) {        // First  -1 : lMeas
	iMeas = iEqTerm;
	iLocFirst = iEqTerm+1;
      }  
      else if (iWeight == 0) {  // Second -1 : weight 
	iWeight = iEqTerm;
	iLocLast = iEqTerm-1;
	iGloFirst = iEqTerm+1;
      } 
      else {                    // Third  -1 : end of equation; start of next  
	iGloLast = iEqTerm-1;
	lMeas	= fDerivLocEq[iMeas];
	lWeight 	= fDerivLocEq[iWeight];
// 	AliDebug(1,Form("lMeas = %f", lMeas));
// 	AliDebug(1,Form("lWeight = %f", lWeight));
        
	// Now suppress the global part (only relevant with iterations)
	// 
	for (i=iGloFirst; i<=iGloLast; i++) {
	  iIdx = fIndexLocEq[i];              // Global param indice
// 	  AliDebug(2,Form("fDeltaPar[%d] = %f", iIdx, fDeltaPar[iIdx]));        
// 	  AliDebug(2,Form("Starting misalignment = %f",fInitPar[iIdx]));        
	  if (fIsNonLinear[iIdx] == 0)
	    lMeas -= fDerivLocEq[i]*(fInitPar[iIdx]+fDeltaPar[iIdx]); // linear parameter
	  else
	    lMeas -= fDerivLocEq[i]*(fDeltaPar[iIdx]); // nonlinear parameter
	}
// 	AliDebug(2,Form("lMeas after global stuff removal = %f", lMeas));
				
	for (i=iLocFirst; i<=iLocLast; i++) { // Finally fill local matrix and vector
	  iIdx = fIndexLocEq[i];   // Local param indice (the matrix line) 
	  fVecBLoc[iIdx] += lWeight*lMeas*fDerivLocEq[i];  
// 	  AliDebug(2,Form("fVecBLoc[%d] = %f", iIdx, fVecBLoc[iIdx]));
					
	  for (j=iLocFirst; j<=i ; j++) { // Symmetric matrix, don't bother j>i coeffs
	    jIdx = fIndexLocEq[j];						
	    fMatCLoc[iIdx][jIdx] += lWeight*fDerivLocEq[i]*fDerivLocEq[j];	    
// 	    AliDebug(2,Form("fMatCLoc[%d][%d] = ", iIdx, jIdx, fMatCLoc[iIdx][jIdx]));
	  }
	}
	iMeas   = -1;
	iWeight = 0;
	iEqTerm--;   // end of one equation is the beginning of next
      } // End of "end of equation" operations
    } // End of loop on equation
    iEqTerm++;
  } // End of loop on all equations used in the fit


//
// Local params matrix is completed, now invert to solve...
//
	
  Int_t nRank = AliMillepede::SpmInv(fMatCLoc, fVecBLoc, fNLocalPar);
  // nRank is the number of nonzero diagonal elements 
     	
  AliDebug(1,"");
  AliDebug(1," __________________________________________________");
  AliDebug(1,Form(" Printout of local fit  (FITLOC)  with rank= %d", nRank));
  AliDebug(1," Result of local fit :      (index/parameter/error)");
  
  for (i=0; i<fNLocalPar; i++) {
    AliDebug(1,Form("%d   /   %.6f   /   %.6f", i, fVecBLoc[i], TMath::Sqrt(fMatCLoc[i][i])));	
  }
  

// Store the track params and errors

  for (i=0; i<fNLocalPar; i++) {
    localParams[2*i] = fVecBLoc[i];
    localParams[2*i+1] = TMath::Sqrt(TMath::Abs(fMatCLoc[i][i]));
  }

    
//
// SECOND LOOP : residual calculation
//
  
  iEqTerm = 0;
  iMeas = -1;
  iWeight = 0;

  while (iEqTerm <= nEqTerms) {
    if (fIndexLocEq[iEqTerm] == -1) {
      if (iMeas == -1) {        // First  -1 : lMeas
	iMeas = iEqTerm;
	iLocFirst = iEqTerm+1;
      }  
      else if (iWeight == 0) {  // Second -1 : weight 
	iWeight = iEqTerm;
	iLocLast = iEqTerm-1;
	iGloFirst = iEqTerm+1;
      } 
      else {                    // Third  -1 : end of equation; start of next  
	iGloLast = iEqTerm-1;
	lMeas	= fDerivLocEq[iMeas];
	lWeight 	= fDerivLocEq[iWeight];
	
	// Print all (for debugging purposes)

// 	int nDerLoc = iLocLast-iLocFirst+1;   // Number of local derivatives involved
// 	int nDerGlo = iGloLast-iGloFirst+1;   // Number of global derivatives involved

// 	AliDebug(2,"");
// 	AliDebug(2,Form(". equation:  measured value %.6f +/- %.6f", lMeas, 1.0/TMath::Sqrt(lWeight)));
// 	AliDebug(2,Form("Number of derivatives (global, local): %d, %d",nDerGlo,nDerLoc));
// 	AliDebug(2,"Global derivatives are: (index/derivative/parvalue) ");
	
// 	for (i=iGloFirst; i<=iGloLast; i++) {
// 	  AliDebug(2,Form("%d / %.6f / %.6f",fIndexLocEq[i],fDerivLocEq[i],fInitPar[fIndexLocEq[i]]));
//      } 

// 	AliDebug(2,"Local derivatives are: (index/derivative) ");
	
// 	for (i=(ja+1); i<jb; i++) {AliDebug(2,Form("%d / %.6f",fIndexLocEq[i], fDerivLocEq[i]));}	  

	// Now suppress local and global parts to LMEAS;
	//
	// First the local part 
	for (i=iLocFirst; i<=iLocLast; i++) { 
	  iIdx = fIndexLocEq[i];
	  lMeas -= fDerivLocEq[i]*fVecBLoc[iIdx];
	}
	// Then the global part
	for (i=iGloFirst; i<=iGloLast; i++) {
	  iIdx = fIndexLocEq[i];
	  if (fIsNonLinear[iIdx] == 0)
	    lMeas -= fDerivLocEq[i]*(fInitPar[iIdx]+fDeltaPar[iIdx]); // linear parameter
	  else
	    lMeas -= fDerivLocEq[i]*(fDeltaPar[iIdx]); // nonlinear parameter
	}

	// lMeas contains now the residual value
	AliDebug(2,Form("Residual value : %.6f", lMeas));

	// reject the track if lMeas is too important (outlier)
	if (TMath::Abs(lMeas) >= fResCutInit && fIter <= 1) {
	  AliDebug(2,"Rejected track !!!!!");
    	  fNLocalFitsRejected++;      
	  fIndexLocEq.Reset();  fNIndexLocEq=0; // reset stores and go to the next track 
	  fDerivLocEq.Reset();  fNDerivLocEq=0;	  
	  return 0;
	}

	if (TMath::Abs(lMeas) >= fResCut && fIter > 1) {
	  AliDebug(2,"Rejected track !!!!!");
    	  fNLocalFitsRejected++;      
	  fIndexLocEq.Reset();  fNIndexLocEq=0; // reset stores and go to the next track 
	  fDerivLocEq.Reset();  fNDerivLocEq=0;	  
	  return 0;
	}

	lChi2 += lWeight*lMeas*lMeas ; // total chi^2
	nEq++;                    // number of equations			
	iMeas   = -1;
	iWeight = 0;
	iEqTerm--;
      } // End of "end of equation" operations
    }   // End of loop on equation
    iEqTerm++;
  } // End of loop on all equations used in the fit

  nDoF = nEq-nRank;	
  lRedChi2 = 0.0;

  AliDebug(1,Form("Final chi square / degrees of freedom %.2f / %d",lChi2, nDoF));
  
  if (nDoF > 0) lRedChi2 = lChi2/float(nDoF);  // Chi^2/dof
	
  fNLocalFits++;

  if (fNStdDev != 0 && nDoF > 0 && !bSingleFit) // Chisquare cut
  {
    lChi2Cut = AliMillepede::Chi2DoFLim(fNStdDev, nDoF)*fChi2CutFactor;
    
    AliDebug(1,Form("Reject if Chisq/Ndf = %.4f > %.4f",lRedChi2,lChi2Cut));
 
    if (lRedChi2 > lChi2Cut) // Reject the track if too much...
    {
      AliDebug(2,"Rejected track !!!!!");
      fNLocalFitsRejected++;      
      fIndexLocEq.Reset();  fNIndexLocEq=0; // reset stores and go to the next track 
      fDerivLocEq.Reset();  fNDerivLocEq=0;
      return 0;
    }
  }

  if (bSingleFit) // Stop here if just updating the track parameters
  {
    fIndexLocEq.Reset();  fNIndexLocEq=0; // Reset store for the next track 
    fDerivLocEq.Reset();  fNDerivLocEq=0;
    return 1;
  }

//  
// THIRD LOOP: local operations are finished, track is accepted 
// We now update the global parameters (other matrices)
//

  iEqTerm = 0;
  iMeas = -1;
  iWeight = 0;

  while (iEqTerm <= nEqTerms)
  {
    if (fIndexLocEq[iEqTerm] == -1)
    {
      if (iMeas == -1) {        // First  -1 : lMeas
	iMeas = iEqTerm;
	iLocFirst = iEqTerm+1;
      }  
      else if (iWeight == 0) {  // Second -1 : weight 
	iWeight = iEqTerm;
	iLocLast = iEqTerm-1;
	iGloFirst = iEqTerm+1;
      } 
      else {                    // Third  -1 : end of equation; start of next  
	iGloLast = iEqTerm-1;
	lMeas	= fDerivLocEq[iMeas];
	lWeight 	= fDerivLocEq[iWeight];

        // Now suppress the global part
	for (i=iGloFirst; i<=iGloLast; i++) {
	  iIdx = fIndexLocEq[i];   // Global param indice
	  if (fIsNonLinear[iIdx] == 0)
	    lMeas -= fDerivLocEq[i]*(fInitPar[iIdx]+fDeltaPar[iIdx]); // linear parameter
	  else
	    lMeas -= fDerivLocEq[i]*(fDeltaPar[iIdx]); // nonlinear parameter
	}
        
	for (i=iGloFirst; i<=iGloLast; i++) {
	  iIdx = fIndexLocEq[i];   // Global param indice (the matrix line)          
        
	  fVecBGlo[iIdx] += lWeight*lMeas*fDerivLocEq[i];  
// 	  AliDebug(2,Form("fVecBGlo[%d] = %.6f", j, fVecBGlo[j] ));

	  // First of all, the global/global terms (exactly like local matrix)
	  //	  
	  for (j=iGloFirst; j<=iGloLast; j++) {	  
	    jIdx = fIndexLocEq[j];			
            fMatCGlo[iIdx][jIdx] += lWeight*fDerivLocEq[i]*fDerivLocEq[j];
// 	    AliDebug(2,Form("fMatCGlo[%d][%d] = %.6f",iIdx,jIdx,fMatCGlo[iIdx][jIdx]));
	  } 

	  // Now we have also rectangular matrices containing global/local terms.
	  //
	  iIdxIdx = fGlo2CGLRow[iIdx];  // Index of index          
	  if (iIdxIdx == -1) {	  // New global variable	 
	    for (k=0; k<fNLocalPar; k++) {
	      fMatCGloLoc[nGloInFit][k] = 0.0;  // Initialize the row
	    }
	    fGlo2CGLRow[iIdx] = nGloInFit;
	    fCGLRow2Glo[nGloInFit] = iIdx;
	    iIdxIdx = nGloInFit;
	    nGloInFit++;
	  }

	  // Now fill the rectangular matrix
	  for (k=iLocFirst; k<=iLocLast ; k++) {
	    kIdx = fIndexLocEq[k];						
	    fMatCGloLoc[iIdxIdx][kIdx] += lWeight*fDerivLocEq[i]*fDerivLocEq[k];
// 	    AliDebug(2,Form("fMatCGloLoc[%d][%d] = %.6f",iIdxIdx,kIdx,fMatCGloLoc[iIdxIdx][kIdx]));
	  } 
	}
	iMeas   = -1;
	iWeight =  0;
	iEqTerm--;
      } // End of "end of equation" operations
    }   // End of loop on equation
    iEqTerm++;
  } // End of loop on all equations used in the fit
	
  // Third loop is finished, now we update the correction matrices
  AliMillepede::SpAVAt(fMatCLoc, fMatCGloLoc, fMatCGloCorr, fNLocalPar, nGloInFit);
  AliMillepede::SpAX(fMatCGloLoc, fVecBLoc, fVecBGloCorr, fNLocalPar, nGloInFit);

  for (iIdxIdx=0; iIdxIdx<nGloInFit; iIdxIdx++) {
    iIdx = fCGLRow2Glo[iIdxIdx];
    fVecBGlo[iIdx] -= fVecBGloCorr[iIdxIdx];
    
    for (jIdxIdx=0; jIdxIdx<=iIdxIdx; jIdxIdx++) {    
      jIdx = fCGLRow2Glo[jIdxIdx];
      fMatCGlo[iIdx][jIdx] -= fMatCGloCorr[iIdxIdx][jIdxIdx];
      fMatCGlo[jIdx][iIdx] = fMatCGlo[iIdx][jIdx];
    }
  }
	
  fIndexLocEq.Reset();  fNIndexLocEq=0; // Reset store for the next track 
  fDerivLocEq.Reset();  fNDerivLocEq=0;

  return 1;
}
 

/*
-----------------------------------------------------------
  MAKEGLOBALFIT:  perform global params fit, once all the 'tracks'
                  have been fitted by FitLoc
-----------------------------------------------------------

  par[]        = array containing the computed global 
                 parameters (the misalignment constants)

  error[]      = array containing the error on global 
                 parameters (estimated by AliMillepede)

  pull[]        = array containing the corresponding pulls 

-----------------------------------------------------------
*/
Int_t AliMillepede::GlobalFit(double par[], double error[], double pull[])
{
  /// perform global parameters fit once all the local equations have been fitted
  int i, j;
  int nVar    = 0;
  int nGloFix = 0;
  double lConstraint;

  double step[fgkMaxGlobalPar]={0};

  double localPars[2*fgkMaxLocalPar];

  int nLocFitsGood = 0;
  int nLocFitsTot  = 0;
  int nLocFits     = 0;

  AliInfo("..... Making global fit .....");
  AliInfo(Form("First Iteration with cut factor %.2f", fChi2CutFactor));

  nLocFitsTot = AliMillepede::GetNLocalEquations();
	
  while (fIter < fMaxIter)  // Iteration for the final loop
  {

    nLocFits = AliMillepede::GetNLocalEquations();
    AliInfo(Form("...using %d local fits...",nLocFits));

// Start by saving the diagonal elements
    
    for (i=0; i<fNGlobalPar; i++) {
      fDiagCGlo[i] = fMatCGlo[i][i];
    }

//  Then we retrieve the different constraints: fixed parameter or global equation

    nGloFix = 0; // First look at the fixed global params
    
    for (i=0; i<fNGlobalPar; i++) {    
      if (fSigmaPar[i] <= 0.0) {  // fixed global param
	nGloFix++;
	for (j=0; j<fNGlobalPar; j++) {
	  fMatCGlo[i][j] = 0.0;  // Reset row and column
	  fMatCGlo[j][i] = 0.0;
	}
      }
      else {
	fMatCGlo[i][i] += 1.0/(fSigmaPar[i]*fSigmaPar[i]);
      }
    }
        
    nVar = fNGlobalPar;  // Current number of equations	
    AliDebug(1,Form("Number of constraint equations : %d", fNGlobalConstraints));
    
    for (i=0; i<fNGlobalConstraints; i++) { // Then the constraint equation    
      lConstraint = fLagMult[i];
      for (j=0; j<fNGlobalPar; j++) {	
	fMatCGlo[nVar][j] = float(nLocFits)*fMatDerConstr[i][j];
	fMatCGlo[j][nVar] = float(nLocFits)*fMatDerConstr[i][j];          
	lConstraint -= fMatDerConstr[i][j]*(fInitPar[j]+fDeltaPar[j]);
      }
	
      fMatCGlo[nVar][nVar] = 0.0;
      fVecBGlo[nVar] = float(nLocFits)*lConstraint;
      nVar++;
    }


    // Intended to compute the final global chisquare

    double lFinalCor = 0.0;

    if (fIter > 1) {    
      for (i=0; i<fNGlobalPar; i++) {	
	for (j=0; j<fNGlobalPar; j++) {
// 	  printf("%d, %d, %.6f  %.6f  %.6f\n",i,j,step[i],fMatCGlo[i][j],step[j]);
	  lFinalCor += step[i]*fMatCGlo[i][j]*step[j]; 
	  if (i == j && fSigmaPar[i] != 0) {
	    lFinalCor -= step[i]*step[i]/(fSigmaPar[i]*fSigmaPar[i]);
	  }
	}
      }
    }

    AliInfo(Form(" Final coeff is %.6f",lFinalCor));		
    AliInfo(Form(" Final NDOFs = %d", fNGlobalPar));

    //  The final matrix inversion

    Int_t nRank = AliMillepede::SpmInv(fMatCGlo, fVecBGlo, nVar);

    for (i=0; i<fNGlobalPar; i++) {    
      fDeltaPar[i] += fVecBGlo[i];    // Update global parameters values (for iterations)
      AliDebug(1,Form("fDeltaPar[%d] = %.6f", i, fDeltaPar[i]));
      AliDebug(1,Form("fMatCGlo[%d][%d] = %.6f", i, i, fMatCGlo[i][i]));
      AliDebug(1,Form("err = %.6f", TMath::Sqrt(TMath::Abs(fMatCGlo[i][i]))));

      step[i] = fVecBGlo[i];

      if (fIter == 1) error[i] = fMatCGlo[i][i]; // Unfitted error
    }
    AliInfo(Form("The rank defect of the symmetric %d by %d matrix is %d (bad if non 0)",
	    nVar, nVar, nVar-nGloFix-nRank));
		
    AliInfo(Form("Total : %d local fits, %d rejected.", fNLocalFits, fNLocalFitsRejected));
    if (fIter == 0)  break;  // No iterations set     
    fIter++;
        
    if (fIter == fMaxIter)  break;  // End of story         

    // Reinitialize parameters for iteration
    //
    fNLocalFits = 0;
    fNLocalFitsRejected = 0;

    if (fChi2CutFactor != fChi2CutRef) {    
      fChi2CutFactor = TMath::Sqrt(fChi2CutFactor);
      if (fChi2CutFactor < 1.2*fChi2CutRef) {
	fChi2CutFactor = fChi2CutRef;
	fIter = fMaxIter - 1;     // Last iteration
      }
    }
    AliInfo("");
    AliInfo("----------------------------------------------");
    AliInfo(Form("Iteration %d with cut factor %.2f", fIter, fChi2CutFactor));
    
    // Reset global variables
    //    
    for (i=0; i<nVar; i++) {    
      fVecBGlo[i] = 0.0;
      for (j=0; j<nVar; j++) {     
	fMatCGlo[i][j] = 0.0;
      }
    }

    //
    // We start a new iteration
    //

    // First we read the stores for retrieving the local params
    //
    nLocFitsGood = 0;

    for (i=0; i<nLocFitsTot; i++) {
      int iEqFirst = 0;
      int iEqLast = 0;

      (i>0) ? iEqFirst = fLocEqPlace[i-1] : iEqFirst = 0;
      iEqLast = fLocEqPlace[i];

      AliDebug(2,Form("Track %d : ",i));
      AliDebug(2,Form("Starts at %d", iEqFirst));
      AliDebug(2,Form("Ends at %d",iEqLast));

      if (fIndexAllEqs[iEqFirst] != -999) { // Fit is still OK      
	fIndexLocEq.Reset();  fNIndexLocEq=0;
	fDerivLocEq.Reset();  fNDerivLocEq=0;
	
	for (j=iEqFirst; j<iEqLast; j++) {
	  if (fNIndexLocEq==fIndexLocEq.GetSize()) fIndexLocEq.Set(2*fNIndexLocEq);
	  fIndexLocEq.AddAt(fIndexAllEqs[j],fNIndexLocEq++);    
	  if (fNDerivLocEq==fDerivLocEq.GetSize()) fDerivLocEq.Set(2*fNDerivLocEq);
	  fDerivLocEq.AddAt(fDerivAllEqs[j],fNDerivLocEq++);    
	}

	for (j=0; j<2*fNLocalPar; j++) {
	  localPars[j] = 0.;
	}	

//  	Int_t sc = AliMillepede::LocalFit(i,localPars,0);
// 	(sc) ? nLocFitsGood++ : fIndexAllEqs[iEqFirst] = -999;   
	AliMillepede::LocalFit(i,localPars,0);
	nLocFitsGood++;
      }
    } // End of loop on fits

    AliMillepede::SetNLocalEquations(nLocFitsGood);

  } // End of iteration loop
	
  AliMillepede::PrintGlobalParameters(); // Print the final results

  for (j=0; j<fNGlobalPar; j++) {  
    par[j]   = fInitPar[j]+fDeltaPar[j];
    pull[j]  = (fSigmaPar[j] <= 0. || fSigmaPar[j]*fSigmaPar[j]-fMatCGlo[j][j] <=0.) ? 0. : fDeltaPar[j]/TMath::Sqrt(fSigmaPar[j]*fSigmaPar[j]-fMatCGlo[j][j]);
    error[j] = TMath::Sqrt(TMath::Abs(fMatCGlo[j][j]));
  }

  AliInfo(" ");
  AliInfo("            * o o                   o      ");
  AliInfo("              o o                   o      ");
  AliInfo("   o ooooo  o o o  oo  ooo   oo   ooo  oo  ");
  AliInfo("    o  o  o o o o o  o o  o o  o o  o o  o ");
  AliInfo("    o  o  o o o o oooo o  o oooo o  o oooo ");
  AliInfo("    o  o  o o o o o    ooo  o    o  o o    ");
  AliInfo("    o  o  o o o o  oo  o     oo   ooo  oo ++ ends.");
  AliInfo("                       o                   ");	  

  return 1;
}

/*
-----------------------------------------------------------
  ERRPAR: return error for parameter iPar
-----------------------------------------------------------

  iPar     = the index of the global parameter in the 
             result array (equivalent to fDeltaPar[]).
 
-----------------------------------------------------------
*/ 
Double_t AliMillepede::GetParError(int iPar) const
{
  /// return error for parameter iPar
  Double_t lErr = -1.;
  if (iPar>=0 && iPar<fNGlobalPar) {
    lErr = TMath::Sqrt(TMath::Abs(fMatCGlo[iPar][iPar]));
  }
  return lErr;
}


/*
-----------------------------------------------------------
  SPMINV:  obtain solution of a system of linear equations with symmetric matrix 
 	   and the inverse (using 'singular-value friendly' GAUSS pivot)
-----------------------------------------------------------

	Solve the equation :  V * X = B
	
	V is replaced by inverse matrix and B by X, the solution vector
-----------------------------------------------------------
*/
int AliMillepede::SpmInv(double matV[][fgkMaxGloPC], double vecB[], int nGlo)
{
  ///  Obtain solution of a system of linear equations with symmetric matrix 
  ///  and the inverse (using 'singular-value friendly' GAUSS pivot)
    
  Int_t nRank = 0;
  int iPivot;
  double vPivot = 0.;
  double eps = 0.00000000000001;

  bool *bUnUsed = new bool[nGlo];
  double *diagV = new double[nGlo];
  double *rowMax = new double[nGlo];
  double *colMax = new double[nGlo];

  double *temp = new double[nGlo];

  for (Int_t i=0; i<nGlo; i++) {
    rowMax[i] = 0.0;
    colMax[i] = 0.0;
    bUnUsed[i] = true;

    for (Int_t j=0; j<i; j++) {
      if (matV[j][i] == 0) {
	matV[j][i] = matV[i][j];
      }
    }
  }
  
  // Small loop for matrix equilibration (gives a better conditioning) 

  for (Int_t i=0; i<nGlo; i++) {
    for (Int_t j=0; j<nGlo; j++) { 
      if (TMath::Abs(matV[i][j]) >= rowMax[i]) rowMax[i] = TMath::Abs(matV[i][j]); // Max elemt of row i
      if (TMath::Abs(matV[j][i]) >= colMax[i]) colMax[i] = TMath::Abs(matV[j][i]); // Max elemt of column i
    }
  }

  for (Int_t i=0; i<nGlo; i++) {
    if (0.0 != rowMax[i]) rowMax[i] = 1./rowMax[i]; // Max elemt of row i
    if (0.0 != colMax[i]) colMax[i] = 1./colMax[i]; // Max elemt of column i
  }

  for (Int_t i=0; i<nGlo; i++) {
    for (Int_t j=0; j<nGlo; j++) {
      matV[i][j] = TMath::Sqrt(rowMax[i])*matV[i][j]*TMath::Sqrt(colMax[j]); // Equilibrate the V matrix
    }
    diagV[i] = TMath::Abs(matV[i][i]); // save diagonal elem absolute values 	
  }


  for (Int_t i=0; i<nGlo; i++) {
    vPivot = 0.0;
    iPivot = -1;
    
    for (Int_t j=0; j<nGlo; j++) { // First look for the pivot, ie max unused diagonal element       
      if (bUnUsed[j] && (TMath::Abs(matV[j][j])>TMath::Max(TMath::Abs(vPivot),eps*diagV[j]))) {    
	vPivot = matV[j][j];
	iPivot = j;
      }
    }
    
    if (iPivot >= 0) {   // pivot found          
      nRank++;
      bUnUsed[iPivot] = false; // This value is used
      vPivot = 1.0/vPivot;
      matV[iPivot][iPivot] = -vPivot; // Replace pivot by its inverse
      
      for (Int_t j=0; j<nGlo; j++) {      
	for (Int_t jj=0; jj<nGlo; jj++) {  
	  if (j != iPivot && jj != iPivot) {// Other elements (!!! do them first as you use old matV[k][j]'s !!!)	  
	    matV[j][jj] = matV[j][jj] - vPivot*matV[j][iPivot]*matV[iPivot][jj];
	  }
	}
      }
      
      for (Int_t j=0; j<nGlo; j++) {      
	if (j != iPivot) { // Pivot row or column elements 
	  matV[j][iPivot] = matV[j][iPivot]*vPivot;	// Column
	  matV[iPivot][j] = matV[iPivot][j]*vPivot;	// Line
	}
      }
    }
    else {  // No more pivot value (clear those elements)
      for (Int_t j=0; j<nGlo; j++) {
	if (bUnUsed[j]) {
	  vecB[j] = 0.0;

	  for (Int_t k=0; k<nGlo; k++) {
	    matV[j][k] = 0.0;
	    matV[k][j] = 0.0;
	  }
	}
      }
      break;  // No more pivots anyway, stop here
    }
  }
  
  for (Int_t i=0; i<nGlo; i++) {
    for (Int_t j=0; j<nGlo; j++) {
      matV[i][j] = TMath::Sqrt(colMax[i])*matV[i][j]*TMath::Sqrt(rowMax[j]); // Correct matrix V
    }
  }
  
  for (Int_t j=0; j<nGlo; j++) {
    temp[j] = 0.0;
    
    for (Int_t jj=0; jj<nGlo; jj++) { // Reverse matrix elements
      matV[j][jj] = -matV[j][jj];
      temp[j] += matV[j][jj]*vecB[jj];
    }		
  }

  for (Int_t j=0; j<nGlo; j++) {
    vecB[j] = temp[j]; // The final result
  }
  
  delete [] temp;
  delete [] bUnUsed;
  delete [] diagV;
  delete [] rowMax;
  delete [] colMax;

  return nRank;
}

//
// Same method but for local fit, so heavily simplified
//
int AliMillepede::SpmInv(double matV[][fgkMaxLocalPar], double vecB[], int nLoc)
{
  ///  Obtain solution of a system of linear equations with symmetric matrix 
  ///  and the inverse (using 'singular-value friendly' GAUSS pivot)

  Int_t nRank = 0;
  Int_t iPivot = -1;
  double vPivot = 0.;
  double eps = 0.0000000000001;

  bool *bUnUsed = new bool[nLoc];
  double *diagV  = new double[nLoc];
  double *temp  = new double[nLoc];
  
  for (Int_t i=0; i<nLoc; i++) {
    bUnUsed[i] = true;
    diagV[i] = TMath::Abs(matV[i][i]);     // save diagonal elem absolute values
    for (Int_t j=0; j<i; j++) {
      matV[j][i] = matV[i][j] ;
    }
  }
	
  for (Int_t i=0; i<nLoc; i++) {
    vPivot = 0.0;
    iPivot = -1;
		
    for (Int_t j=0; j<nLoc; j++) { // First look for the pivot, ie max unused diagonal element 
      if (bUnUsed[j] && (TMath::Abs(matV[j][j])>TMath::Max(TMath::Abs(vPivot),eps*diagV[j]))) {
	vPivot = matV[j][j];
	iPivot = j;
      }
    }
		
    if (iPivot >= 0) {   // pivot found
      nRank++;
      bUnUsed[iPivot] = false;
      vPivot = 1.0/vPivot;
      matV[iPivot][iPivot] = -vPivot; // Replace pivot by its inverse
      
      for (Int_t j=0; j<nLoc; j++) {
	if (j != iPivot) {
	  for (Int_t jj=0; jj<=j; jj++) {	
	    if (jj != iPivot) {// Other elements (!!! do them first as you use old matV[k][j]'s !!!)
	      matV[j][jj] = matV[j][jj] - vPivot*matV[j][iPivot]*matV[iPivot][jj];
	      matV[jj][j] = matV[j][jj];
	    }
	  }
	}
      }

      for (Int_t j=0; j<nLoc; j++) {      
	if (j != iPivot) {      // Pivot row or column elements 	
	  matV[j][iPivot] = matV[j][iPivot]*vPivot; // Column
	  matV[iPivot][j] = matV[j][iPivot];
	}
      }
    }
    else { // No more pivot value (clear those elements)
      for (Int_t j=0; j<nLoc; j++) {
	if (bUnUsed[j]) {
	  vecB[j] = 0.0;
	  matV[j][j] = 0.0;
	  for (Int_t k=0; k<j; k++) {	  
	    matV[j][k] = 0.0;
	    matV[k][j] = 0.0;
	  }
	}
      }

      break;  // No more pivots anyway, stop here
    }
  }

  for (Int_t j=0; j<nLoc; j++) {  
    temp[j] = 0.0;    
    for (Int_t jj=0; jj<nLoc; jj++) { // Reverse matrix elements
      matV[j][jj] = -matV[j][jj];
      temp[j] += matV[j][jj]*vecB[jj];
    }			
  }

  for (Int_t j=0; j<nLoc; j++) {
    vecB[j] = temp[j];
  }

  delete [] bUnUsed;
  delete [] diagV;
  delete [] temp;
  
  return nRank;
}


/*
-----------------------------------------------------------
  SPAVAT
-----------------------------------------------------------

  multiply symmetric N-by-N matrix from the left with general M-by-N
  matrix and from the right with the transposed of the same  general
  matrix  to  form  symmetric  M-by-M   matrix.
  
                                                       T
  CALL SPAVAT(V,A,W,N,M)      W   =   A   *   V   *   A
   		           M*M     M*N     N*N     N*M
  
  where V = symmetric N-by-N matrix
        A = general N-by-M matrix
        W = symmetric M-by-M matrix
-----------------------------------------------------------
*/
Int_t AliMillepede::SpAVAt(double matV[][fgkMaxLocalPar], double matA[][fgkMaxLocalPar], double matW[][fgkMaxGlobalPar], int nLoc, int nGlo)
{
  ///  multiply symmetric N-by-N matrix from the left with general M-by-N
  ///  matrix and from the right with the transposed of the same general
  ///  matrix to form symmetric M-by-M matrix.

  for (Int_t i=0; i<nGlo; i++) {
    for (Int_t j=0; j<=i; j++) {  // Matrix w is symmetric
      matW[i][j] = 0.0;      // Reset final matrix			
      for (Int_t k=0; k<nLoc; k++) {	
	matW[i][j] += matA[i][k]*matV[k][k]*matA[j][k];    // diagonal terms of v
	for (Int_t l=0; l<k; l++) {	  
	  matW[i][j] += matA[i][k]*matV[k][l]*matA[j][l];  // Use symmetric properties
	  matW[i][j] += matA[i][l]*matV[k][l]*matA[j][k];  // of matrix v
	}
      }
      if (i!=j){
	matW[j][i] = matW[i][j]; // Matrix w is symmetric
      }
    }
  }
	
  return 1;
}


/*
-----------------------------------------------------------
  SPAX
-----------------------------------------------------------

  multiply general M-by-N matrix A and N-vector X
 
  CALL  SPAX(A,X,Y,M,N)          Y =  A * X
                                 M   M*N  N
 
  where A = general M-by-N matrix (A11 A12 ... A1N  A21 A22 ...)
        X = N vector
        Y = M vector
-----------------------------------------------------------
*/
Int_t AliMillepede::SpAX(double matA[][fgkMaxLocalPar], double vecX[], double vecY[], int nCol, int nRow)
{
  ///   multiply general M-by-N matrix A and N-vector X
  for (Int_t i=0; i<nRow; i++) {
    vecY[i] = 0.0;	    // Reset final vector			
    for (Int_t j=0; j<nCol; j++) {
      vecY[i] += matA[i][j]*vecX[j];  // fill the vector
    }
  }
	
  return 1;
}


/*
-----------------------------------------------------------
  PRTGLO
-----------------------------------------------------------

  Print the final results into the logfile

-----------------------------------------------------------
*/
Int_t AliMillepede::PrintGlobalParameters() const
{
  ///  Print the final results into the logfile
  double lError = 0.;
  double lGlobalCor =0.;
	
  AliInfo("");
  AliInfo("   Result of fit for global parameters");
  AliInfo("   ===================================");
  AliInfo("    I       initial       final       differ        lastcor        error       gcor");
  AliInfo("-----------------------------------------------------------------------------------");
	
  for (int i=0; i<fNGlobalPar; i++) {
    lError = TMath::Sqrt(TMath::Abs(fMatCGlo[i][i]));
    if (fMatCGlo[i][i] < 0.0) lError = -lError;
    lGlobalCor = 0.0;
		
    if (TMath::Abs(fMatCGlo[i][i]*fDiagCGlo[i]) > 0) {    
      lGlobalCor = TMath::Sqrt(TMath::Abs(1.0-1.0/(fMatCGlo[i][i]*fDiagCGlo[i])));
      AliInfo(Form("%d\t %.6f\t %.6f\t %.6f\t %.6f\t %.6f\t %.6f",
		   i,fInitPar[i],fInitPar[i]+fDeltaPar[i],fDeltaPar[i],fVecBGlo[i],lError,lGlobalCor));
    }
    else {    
      AliInfo(Form("%d\t %.6f\t %.6f\t %.6f\t %.6f\t OFF\t OFF",i,fInitPar[i],fInitPar[i]+fDeltaPar[i],fDeltaPar[i],fVecBGlo[i]));
    }
  }
  return 1;
}


/*
----------------------------------------------------------------
  CHI2DOFLIM:  return the limit in chi^2/nd for n sigmas stdev authorized
----------------------------------------------------------------

  Only n=1, 2, and 3 are expected in input
----------------------------------------------------------------
*/
double AliMillepede::Chi2DoFLim(int nSig, int nDoF)
{
  /// return the limit in chi^2/nd for n sigmas stdev authorized
  int lNSig;
  double sn[3]        =	{0.47523, 1.690140, 2.782170};
  double table[3][30] = {{1.0000, 1.1479, 1.1753, 1.1798, 1.1775, 1.1730, 1.1680, 1.1630,
			  1.1581, 1.1536, 1.1493, 1.1454, 1.1417, 1.1383, 1.1351, 1.1321,
			  1.1293, 1.1266, 1.1242, 1.1218, 1.1196, 1.1175, 1.1155, 1.1136,
			  1.1119, 1.1101, 1.1085, 1.1070, 1.1055, 1.1040},
			 {4.0000, 3.0900, 2.6750, 2.4290, 2.2628, 2.1415, 2.0481, 1.9736,
			  1.9124, 1.8610, 1.8171, 1.7791, 1.7457, 1.7161, 1.6897, 1.6658,
			  1.6442, 1.6246, 1.6065, 1.5899, 1.5745, 1.5603, 1.5470, 1.5346,
			  1.5230, 1.5120, 1.5017, 1.4920, 1.4829, 1.4742},
			 {9.0000, 5.9146, 4.7184, 4.0628, 3.6410, 3.3436, 3.1209, 2.9468,
			  2.8063, 2.6902, 2.5922, 2.5082, 2.4352, 2.3711, 2.3143, 2.2635,
			  2.2178, 2.1764, 2.1386, 2.1040, 2.0722, 2.0428, 2.0155, 1.9901,
			  1.9665, 1.9443, 1.9235, 1.9040, 1.8855, 1.8681}};

  if (nDoF < 1) {
    return 0.0;
  }
  else {  
    lNSig = TMath::Max(1,TMath::Min(nSig,3));

    if (nDoF <= 30) {    
      return table[lNSig-1][nDoF-1];
    }
    else { // approximation
      return ((sn[lNSig-1]+TMath::Sqrt(float(2*nDoF-3)))*
	      (sn[lNSig-1]+TMath::Sqrt(float(2*nDoF-3))))/float(2*nDoF-2);
    }
  }
}
 AliMillepede.cxx:1
 AliMillepede.cxx:2
 AliMillepede.cxx:3
 AliMillepede.cxx:4
 AliMillepede.cxx:5
 AliMillepede.cxx:6
 AliMillepede.cxx:7
 AliMillepede.cxx:8
 AliMillepede.cxx:9
 AliMillepede.cxx:10
 AliMillepede.cxx:11
 AliMillepede.cxx:12
 AliMillepede.cxx:13
 AliMillepede.cxx:14
 AliMillepede.cxx:15
 AliMillepede.cxx:16
 AliMillepede.cxx:17
 AliMillepede.cxx:18
 AliMillepede.cxx:19
 AliMillepede.cxx:20
 AliMillepede.cxx:21
 AliMillepede.cxx:22
 AliMillepede.cxx:23
 AliMillepede.cxx:24
 AliMillepede.cxx:25
 AliMillepede.cxx:26
 AliMillepede.cxx:27
 AliMillepede.cxx:28
 AliMillepede.cxx:29
 AliMillepede.cxx:30
 AliMillepede.cxx:31
 AliMillepede.cxx:32
 AliMillepede.cxx:33
 AliMillepede.cxx:34
 AliMillepede.cxx:35
 AliMillepede.cxx:36
 AliMillepede.cxx:37
 AliMillepede.cxx:38
 AliMillepede.cxx:39
 AliMillepede.cxx:40
 AliMillepede.cxx:41
 AliMillepede.cxx:42
 AliMillepede.cxx:43
 AliMillepede.cxx:44
 AliMillepede.cxx:45
 AliMillepede.cxx:46
 AliMillepede.cxx:47
 AliMillepede.cxx:48
 AliMillepede.cxx:49
 AliMillepede.cxx:50
 AliMillepede.cxx:51
 AliMillepede.cxx:52
 AliMillepede.cxx:53
 AliMillepede.cxx:54
 AliMillepede.cxx:55
 AliMillepede.cxx:56
 AliMillepede.cxx:57
 AliMillepede.cxx:58
 AliMillepede.cxx:59
 AliMillepede.cxx:60
 AliMillepede.cxx:61
 AliMillepede.cxx:62
 AliMillepede.cxx:63
 AliMillepede.cxx:64
 AliMillepede.cxx:65
 AliMillepede.cxx:66
 AliMillepede.cxx:67
 AliMillepede.cxx:68
 AliMillepede.cxx:69
 AliMillepede.cxx:70
 AliMillepede.cxx:71
 AliMillepede.cxx:72
 AliMillepede.cxx:73
 AliMillepede.cxx:74
 AliMillepede.cxx:75
 AliMillepede.cxx:76
 AliMillepede.cxx:77
 AliMillepede.cxx:78
 AliMillepede.cxx:79
 AliMillepede.cxx:80
 AliMillepede.cxx:81
 AliMillepede.cxx:82
 AliMillepede.cxx:83
 AliMillepede.cxx:84
 AliMillepede.cxx:85
 AliMillepede.cxx:86
 AliMillepede.cxx:87
 AliMillepede.cxx:88
 AliMillepede.cxx:89
 AliMillepede.cxx:90
 AliMillepede.cxx:91
 AliMillepede.cxx:92
 AliMillepede.cxx:93
 AliMillepede.cxx:94
 AliMillepede.cxx:95
 AliMillepede.cxx:96
 AliMillepede.cxx:97
 AliMillepede.cxx:98
 AliMillepede.cxx:99
 AliMillepede.cxx:100
 AliMillepede.cxx:101
 AliMillepede.cxx:102
 AliMillepede.cxx:103
 AliMillepede.cxx:104
 AliMillepede.cxx:105
 AliMillepede.cxx:106
 AliMillepede.cxx:107
 AliMillepede.cxx:108
 AliMillepede.cxx:109
 AliMillepede.cxx:110
 AliMillepede.cxx:111
 AliMillepede.cxx:112
 AliMillepede.cxx:113
 AliMillepede.cxx:114
 AliMillepede.cxx:115
 AliMillepede.cxx:116
 AliMillepede.cxx:117
 AliMillepede.cxx:118
 AliMillepede.cxx:119
 AliMillepede.cxx:120
 AliMillepede.cxx:121
 AliMillepede.cxx:122
 AliMillepede.cxx:123
 AliMillepede.cxx:124
 AliMillepede.cxx:125
 AliMillepede.cxx:126
 AliMillepede.cxx:127
 AliMillepede.cxx:128
 AliMillepede.cxx:129
 AliMillepede.cxx:130
 AliMillepede.cxx:131
 AliMillepede.cxx:132
 AliMillepede.cxx:133
 AliMillepede.cxx:134
 AliMillepede.cxx:135
 AliMillepede.cxx:136
 AliMillepede.cxx:137
 AliMillepede.cxx:138
 AliMillepede.cxx:139
 AliMillepede.cxx:140
 AliMillepede.cxx:141
 AliMillepede.cxx:142
 AliMillepede.cxx:143
 AliMillepede.cxx:144
 AliMillepede.cxx:145
 AliMillepede.cxx:146
 AliMillepede.cxx:147
 AliMillepede.cxx:148
 AliMillepede.cxx:149
 AliMillepede.cxx:150
 AliMillepede.cxx:151
 AliMillepede.cxx:152
 AliMillepede.cxx:153
 AliMillepede.cxx:154
 AliMillepede.cxx:155
 AliMillepede.cxx:156
 AliMillepede.cxx:157
 AliMillepede.cxx:158
 AliMillepede.cxx:159
 AliMillepede.cxx:160
 AliMillepede.cxx:161
 AliMillepede.cxx:162
 AliMillepede.cxx:163
 AliMillepede.cxx:164
 AliMillepede.cxx:165
 AliMillepede.cxx:166
 AliMillepede.cxx:167
 AliMillepede.cxx:168
 AliMillepede.cxx:169
 AliMillepede.cxx:170
 AliMillepede.cxx:171
 AliMillepede.cxx:172
 AliMillepede.cxx:173
 AliMillepede.cxx:174
 AliMillepede.cxx:175
 AliMillepede.cxx:176
 AliMillepede.cxx:177
 AliMillepede.cxx:178
 AliMillepede.cxx:179
 AliMillepede.cxx:180
 AliMillepede.cxx:181
 AliMillepede.cxx:182
 AliMillepede.cxx:183
 AliMillepede.cxx:184
 AliMillepede.cxx:185
 AliMillepede.cxx:186
 AliMillepede.cxx:187
 AliMillepede.cxx:188
 AliMillepede.cxx:189
 AliMillepede.cxx:190
 AliMillepede.cxx:191
 AliMillepede.cxx:192
 AliMillepede.cxx:193
 AliMillepede.cxx:194
 AliMillepede.cxx:195
 AliMillepede.cxx:196
 AliMillepede.cxx:197
 AliMillepede.cxx:198
 AliMillepede.cxx:199
 AliMillepede.cxx:200
 AliMillepede.cxx:201
 AliMillepede.cxx:202
 AliMillepede.cxx:203
 AliMillepede.cxx:204
 AliMillepede.cxx:205
 AliMillepede.cxx:206
 AliMillepede.cxx:207
 AliMillepede.cxx:208
 AliMillepede.cxx:209
 AliMillepede.cxx:210
 AliMillepede.cxx:211
 AliMillepede.cxx:212
 AliMillepede.cxx:213
 AliMillepede.cxx:214
 AliMillepede.cxx:215
 AliMillepede.cxx:216
 AliMillepede.cxx:217
 AliMillepede.cxx:218
 AliMillepede.cxx:219
 AliMillepede.cxx:220
 AliMillepede.cxx:221
 AliMillepede.cxx:222
 AliMillepede.cxx:223
 AliMillepede.cxx:224
 AliMillepede.cxx:225
 AliMillepede.cxx:226
 AliMillepede.cxx:227
 AliMillepede.cxx:228
 AliMillepede.cxx:229
 AliMillepede.cxx:230
 AliMillepede.cxx:231
 AliMillepede.cxx:232
 AliMillepede.cxx:233
 AliMillepede.cxx:234
 AliMillepede.cxx:235
 AliMillepede.cxx:236
 AliMillepede.cxx:237
 AliMillepede.cxx:238
 AliMillepede.cxx:239
 AliMillepede.cxx:240
 AliMillepede.cxx:241
 AliMillepede.cxx:242
 AliMillepede.cxx:243
 AliMillepede.cxx:244
 AliMillepede.cxx:245
 AliMillepede.cxx:246
 AliMillepede.cxx:247
 AliMillepede.cxx:248
 AliMillepede.cxx:249
 AliMillepede.cxx:250
 AliMillepede.cxx:251
 AliMillepede.cxx:252
 AliMillepede.cxx:253
 AliMillepede.cxx:254
 AliMillepede.cxx:255
 AliMillepede.cxx:256
 AliMillepede.cxx:257
 AliMillepede.cxx:258
 AliMillepede.cxx:259
 AliMillepede.cxx:260
 AliMillepede.cxx:261
 AliMillepede.cxx:262
 AliMillepede.cxx:263
 AliMillepede.cxx:264
 AliMillepede.cxx:265
 AliMillepede.cxx:266
 AliMillepede.cxx:267
 AliMillepede.cxx:268
 AliMillepede.cxx:269
 AliMillepede.cxx:270
 AliMillepede.cxx:271
 AliMillepede.cxx:272
 AliMillepede.cxx:273
 AliMillepede.cxx:274
 AliMillepede.cxx:275
 AliMillepede.cxx:276
 AliMillepede.cxx:277
 AliMillepede.cxx:278
 AliMillepede.cxx:279
 AliMillepede.cxx:280
 AliMillepede.cxx:281
 AliMillepede.cxx:282
 AliMillepede.cxx:283
 AliMillepede.cxx:284
 AliMillepede.cxx:285
 AliMillepede.cxx:286
 AliMillepede.cxx:287
 AliMillepede.cxx:288
 AliMillepede.cxx:289
 AliMillepede.cxx:290
 AliMillepede.cxx:291
 AliMillepede.cxx:292
 AliMillepede.cxx:293
 AliMillepede.cxx:294
 AliMillepede.cxx:295
 AliMillepede.cxx:296
 AliMillepede.cxx:297
 AliMillepede.cxx:298
 AliMillepede.cxx:299
 AliMillepede.cxx:300
 AliMillepede.cxx:301
 AliMillepede.cxx:302
 AliMillepede.cxx:303
 AliMillepede.cxx:304
 AliMillepede.cxx:305
 AliMillepede.cxx:306
 AliMillepede.cxx:307
 AliMillepede.cxx:308
 AliMillepede.cxx:309
 AliMillepede.cxx:310
 AliMillepede.cxx:311
 AliMillepede.cxx:312
 AliMillepede.cxx:313
 AliMillepede.cxx:314
 AliMillepede.cxx:315
 AliMillepede.cxx:316
 AliMillepede.cxx:317
 AliMillepede.cxx:318
 AliMillepede.cxx:319
 AliMillepede.cxx:320
 AliMillepede.cxx:321
 AliMillepede.cxx:322
 AliMillepede.cxx:323
 AliMillepede.cxx:324
 AliMillepede.cxx:325
 AliMillepede.cxx:326
 AliMillepede.cxx:327
 AliMillepede.cxx:328
 AliMillepede.cxx:329
 AliMillepede.cxx:330
 AliMillepede.cxx:331
 AliMillepede.cxx:332
 AliMillepede.cxx:333
 AliMillepede.cxx:334
 AliMillepede.cxx:335
 AliMillepede.cxx:336
 AliMillepede.cxx:337
 AliMillepede.cxx:338
 AliMillepede.cxx:339
 AliMillepede.cxx:340
 AliMillepede.cxx:341
 AliMillepede.cxx:342
 AliMillepede.cxx:343
 AliMillepede.cxx:344
 AliMillepede.cxx:345
 AliMillepede.cxx:346
 AliMillepede.cxx:347
 AliMillepede.cxx:348
 AliMillepede.cxx:349
 AliMillepede.cxx:350
 AliMillepede.cxx:351
 AliMillepede.cxx:352
 AliMillepede.cxx:353
 AliMillepede.cxx:354
 AliMillepede.cxx:355
 AliMillepede.cxx:356
 AliMillepede.cxx:357
 AliMillepede.cxx:358
 AliMillepede.cxx:359
 AliMillepede.cxx:360
 AliMillepede.cxx:361
 AliMillepede.cxx:362
 AliMillepede.cxx:363
 AliMillepede.cxx:364
 AliMillepede.cxx:365
 AliMillepede.cxx:366
 AliMillepede.cxx:367
 AliMillepede.cxx:368
 AliMillepede.cxx:369
 AliMillepede.cxx:370
 AliMillepede.cxx:371
 AliMillepede.cxx:372
 AliMillepede.cxx:373
 AliMillepede.cxx:374
 AliMillepede.cxx:375
 AliMillepede.cxx:376
 AliMillepede.cxx:377
 AliMillepede.cxx:378
 AliMillepede.cxx:379
 AliMillepede.cxx:380
 AliMillepede.cxx:381
 AliMillepede.cxx:382
 AliMillepede.cxx:383
 AliMillepede.cxx:384
 AliMillepede.cxx:385
 AliMillepede.cxx:386
 AliMillepede.cxx:387
 AliMillepede.cxx:388
 AliMillepede.cxx:389
 AliMillepede.cxx:390
 AliMillepede.cxx:391
 AliMillepede.cxx:392
 AliMillepede.cxx:393
 AliMillepede.cxx:394
 AliMillepede.cxx:395
 AliMillepede.cxx:396
 AliMillepede.cxx:397
 AliMillepede.cxx:398
 AliMillepede.cxx:399
 AliMillepede.cxx:400
 AliMillepede.cxx:401
 AliMillepede.cxx:402
 AliMillepede.cxx:403
 AliMillepede.cxx:404
 AliMillepede.cxx:405
 AliMillepede.cxx:406
 AliMillepede.cxx:407
 AliMillepede.cxx:408
 AliMillepede.cxx:409
 AliMillepede.cxx:410
 AliMillepede.cxx:411
 AliMillepede.cxx:412
 AliMillepede.cxx:413
 AliMillepede.cxx:414
 AliMillepede.cxx:415
 AliMillepede.cxx:416
 AliMillepede.cxx:417
 AliMillepede.cxx:418
 AliMillepede.cxx:419
 AliMillepede.cxx:420
 AliMillepede.cxx:421
 AliMillepede.cxx:422
 AliMillepede.cxx:423
 AliMillepede.cxx:424
 AliMillepede.cxx:425
 AliMillepede.cxx:426
 AliMillepede.cxx:427
 AliMillepede.cxx:428
 AliMillepede.cxx:429
 AliMillepede.cxx:430
 AliMillepede.cxx:431
 AliMillepede.cxx:432
 AliMillepede.cxx:433
 AliMillepede.cxx:434
 AliMillepede.cxx:435
 AliMillepede.cxx:436
 AliMillepede.cxx:437
 AliMillepede.cxx:438
 AliMillepede.cxx:439
 AliMillepede.cxx:440
 AliMillepede.cxx:441
 AliMillepede.cxx:442
 AliMillepede.cxx:443
 AliMillepede.cxx:444
 AliMillepede.cxx:445
 AliMillepede.cxx:446
 AliMillepede.cxx:447
 AliMillepede.cxx:448
 AliMillepede.cxx:449
 AliMillepede.cxx:450
 AliMillepede.cxx:451
 AliMillepede.cxx:452
 AliMillepede.cxx:453
 AliMillepede.cxx:454
 AliMillepede.cxx:455
 AliMillepede.cxx:456
 AliMillepede.cxx:457
 AliMillepede.cxx:458
 AliMillepede.cxx:459
 AliMillepede.cxx:460
 AliMillepede.cxx:461
 AliMillepede.cxx:462
 AliMillepede.cxx:463
 AliMillepede.cxx:464
 AliMillepede.cxx:465
 AliMillepede.cxx:466
 AliMillepede.cxx:467
 AliMillepede.cxx:468
 AliMillepede.cxx:469
 AliMillepede.cxx:470
 AliMillepede.cxx:471
 AliMillepede.cxx:472
 AliMillepede.cxx:473
 AliMillepede.cxx:474
 AliMillepede.cxx:475
 AliMillepede.cxx:476
 AliMillepede.cxx:477
 AliMillepede.cxx:478
 AliMillepede.cxx:479
 AliMillepede.cxx:480
 AliMillepede.cxx:481
 AliMillepede.cxx:482
 AliMillepede.cxx:483
 AliMillepede.cxx:484
 AliMillepede.cxx:485
 AliMillepede.cxx:486
 AliMillepede.cxx:487
 AliMillepede.cxx:488
 AliMillepede.cxx:489
 AliMillepede.cxx:490
 AliMillepede.cxx:491
 AliMillepede.cxx:492
 AliMillepede.cxx:493
 AliMillepede.cxx:494
 AliMillepede.cxx:495
 AliMillepede.cxx:496
 AliMillepede.cxx:497
 AliMillepede.cxx:498
 AliMillepede.cxx:499
 AliMillepede.cxx:500
 AliMillepede.cxx:501
 AliMillepede.cxx:502
 AliMillepede.cxx:503
 AliMillepede.cxx:504
 AliMillepede.cxx:505
 AliMillepede.cxx:506
 AliMillepede.cxx:507
 AliMillepede.cxx:508
 AliMillepede.cxx:509
 AliMillepede.cxx:510
 AliMillepede.cxx:511
 AliMillepede.cxx:512
 AliMillepede.cxx:513
 AliMillepede.cxx:514
 AliMillepede.cxx:515
 AliMillepede.cxx:516
 AliMillepede.cxx:517
 AliMillepede.cxx:518
 AliMillepede.cxx:519
 AliMillepede.cxx:520
 AliMillepede.cxx:521
 AliMillepede.cxx:522
 AliMillepede.cxx:523
 AliMillepede.cxx:524
 AliMillepede.cxx:525
 AliMillepede.cxx:526
 AliMillepede.cxx:527
 AliMillepede.cxx:528
 AliMillepede.cxx:529
 AliMillepede.cxx:530
 AliMillepede.cxx:531
 AliMillepede.cxx:532
 AliMillepede.cxx:533
 AliMillepede.cxx:534
 AliMillepede.cxx:535
 AliMillepede.cxx:536
 AliMillepede.cxx:537
 AliMillepede.cxx:538
 AliMillepede.cxx:539
 AliMillepede.cxx:540
 AliMillepede.cxx:541
 AliMillepede.cxx:542
 AliMillepede.cxx:543
 AliMillepede.cxx:544
 AliMillepede.cxx:545
 AliMillepede.cxx:546
 AliMillepede.cxx:547
 AliMillepede.cxx:548
 AliMillepede.cxx:549
 AliMillepede.cxx:550
 AliMillepede.cxx:551
 AliMillepede.cxx:552
 AliMillepede.cxx:553
 AliMillepede.cxx:554
 AliMillepede.cxx:555
 AliMillepede.cxx:556
 AliMillepede.cxx:557
 AliMillepede.cxx:558
 AliMillepede.cxx:559
 AliMillepede.cxx:560
 AliMillepede.cxx:561
 AliMillepede.cxx:562
 AliMillepede.cxx:563
 AliMillepede.cxx:564
 AliMillepede.cxx:565
 AliMillepede.cxx:566
 AliMillepede.cxx:567
 AliMillepede.cxx:568
 AliMillepede.cxx:569
 AliMillepede.cxx:570
 AliMillepede.cxx:571
 AliMillepede.cxx:572
 AliMillepede.cxx:573
 AliMillepede.cxx:574
 AliMillepede.cxx:575
 AliMillepede.cxx:576
 AliMillepede.cxx:577
 AliMillepede.cxx:578
 AliMillepede.cxx:579
 AliMillepede.cxx:580
 AliMillepede.cxx:581
 AliMillepede.cxx:582
 AliMillepede.cxx:583
 AliMillepede.cxx:584
 AliMillepede.cxx:585
 AliMillepede.cxx:586
 AliMillepede.cxx:587
 AliMillepede.cxx:588
 AliMillepede.cxx:589
 AliMillepede.cxx:590
 AliMillepede.cxx:591
 AliMillepede.cxx:592
 AliMillepede.cxx:593
 AliMillepede.cxx:594
 AliMillepede.cxx:595
 AliMillepede.cxx:596
 AliMillepede.cxx:597
 AliMillepede.cxx:598
 AliMillepede.cxx:599
 AliMillepede.cxx:600
 AliMillepede.cxx:601
 AliMillepede.cxx:602
 AliMillepede.cxx:603
 AliMillepede.cxx:604
 AliMillepede.cxx:605
 AliMillepede.cxx:606
 AliMillepede.cxx:607
 AliMillepede.cxx:608
 AliMillepede.cxx:609
 AliMillepede.cxx:610
 AliMillepede.cxx:611
 AliMillepede.cxx:612
 AliMillepede.cxx:613
 AliMillepede.cxx:614
 AliMillepede.cxx:615
 AliMillepede.cxx:616
 AliMillepede.cxx:617
 AliMillepede.cxx:618
 AliMillepede.cxx:619
 AliMillepede.cxx:620
 AliMillepede.cxx:621
 AliMillepede.cxx:622
 AliMillepede.cxx:623
 AliMillepede.cxx:624
 AliMillepede.cxx:625
 AliMillepede.cxx:626
 AliMillepede.cxx:627
 AliMillepede.cxx:628
 AliMillepede.cxx:629
 AliMillepede.cxx:630
 AliMillepede.cxx:631
 AliMillepede.cxx:632
 AliMillepede.cxx:633
 AliMillepede.cxx:634
 AliMillepede.cxx:635
 AliMillepede.cxx:636
 AliMillepede.cxx:637
 AliMillepede.cxx:638
 AliMillepede.cxx:639
 AliMillepede.cxx:640
 AliMillepede.cxx:641
 AliMillepede.cxx:642
 AliMillepede.cxx:643
 AliMillepede.cxx:644
 AliMillepede.cxx:645
 AliMillepede.cxx:646
 AliMillepede.cxx:647
 AliMillepede.cxx:648
 AliMillepede.cxx:649
 AliMillepede.cxx:650
 AliMillepede.cxx:651
 AliMillepede.cxx:652
 AliMillepede.cxx:653
 AliMillepede.cxx:654
 AliMillepede.cxx:655
 AliMillepede.cxx:656
 AliMillepede.cxx:657
 AliMillepede.cxx:658
 AliMillepede.cxx:659
 AliMillepede.cxx:660
 AliMillepede.cxx:661
 AliMillepede.cxx:662
 AliMillepede.cxx:663
 AliMillepede.cxx:664
 AliMillepede.cxx:665
 AliMillepede.cxx:666
 AliMillepede.cxx:667
 AliMillepede.cxx:668
 AliMillepede.cxx:669
 AliMillepede.cxx:670
 AliMillepede.cxx:671
 AliMillepede.cxx:672
 AliMillepede.cxx:673
 AliMillepede.cxx:674
 AliMillepede.cxx:675
 AliMillepede.cxx:676
 AliMillepede.cxx:677
 AliMillepede.cxx:678
 AliMillepede.cxx:679
 AliMillepede.cxx:680
 AliMillepede.cxx:681
 AliMillepede.cxx:682
 AliMillepede.cxx:683
 AliMillepede.cxx:684
 AliMillepede.cxx:685
 AliMillepede.cxx:686
 AliMillepede.cxx:687
 AliMillepede.cxx:688
 AliMillepede.cxx:689
 AliMillepede.cxx:690
 AliMillepede.cxx:691
 AliMillepede.cxx:692
 AliMillepede.cxx:693
 AliMillepede.cxx:694
 AliMillepede.cxx:695
 AliMillepede.cxx:696
 AliMillepede.cxx:697
 AliMillepede.cxx:698
 AliMillepede.cxx:699
 AliMillepede.cxx:700
 AliMillepede.cxx:701
 AliMillepede.cxx:702
 AliMillepede.cxx:703
 AliMillepede.cxx:704
 AliMillepede.cxx:705
 AliMillepede.cxx:706
 AliMillepede.cxx:707
 AliMillepede.cxx:708
 AliMillepede.cxx:709
 AliMillepede.cxx:710
 AliMillepede.cxx:711
 AliMillepede.cxx:712
 AliMillepede.cxx:713
 AliMillepede.cxx:714
 AliMillepede.cxx:715
 AliMillepede.cxx:716
 AliMillepede.cxx:717
 AliMillepede.cxx:718
 AliMillepede.cxx:719
 AliMillepede.cxx:720
 AliMillepede.cxx:721
 AliMillepede.cxx:722
 AliMillepede.cxx:723
 AliMillepede.cxx:724
 AliMillepede.cxx:725
 AliMillepede.cxx:726
 AliMillepede.cxx:727
 AliMillepede.cxx:728
 AliMillepede.cxx:729
 AliMillepede.cxx:730
 AliMillepede.cxx:731
 AliMillepede.cxx:732
 AliMillepede.cxx:733
 AliMillepede.cxx:734
 AliMillepede.cxx:735
 AliMillepede.cxx:736
 AliMillepede.cxx:737
 AliMillepede.cxx:738
 AliMillepede.cxx:739
 AliMillepede.cxx:740
 AliMillepede.cxx:741
 AliMillepede.cxx:742
 AliMillepede.cxx:743
 AliMillepede.cxx:744
 AliMillepede.cxx:745
 AliMillepede.cxx:746
 AliMillepede.cxx:747
 AliMillepede.cxx:748
 AliMillepede.cxx:749
 AliMillepede.cxx:750
 AliMillepede.cxx:751
 AliMillepede.cxx:752
 AliMillepede.cxx:753
 AliMillepede.cxx:754
 AliMillepede.cxx:755
 AliMillepede.cxx:756
 AliMillepede.cxx:757
 AliMillepede.cxx:758
 AliMillepede.cxx:759
 AliMillepede.cxx:760
 AliMillepede.cxx:761
 AliMillepede.cxx:762
 AliMillepede.cxx:763
 AliMillepede.cxx:764
 AliMillepede.cxx:765
 AliMillepede.cxx:766
 AliMillepede.cxx:767
 AliMillepede.cxx:768
 AliMillepede.cxx:769
 AliMillepede.cxx:770
 AliMillepede.cxx:771
 AliMillepede.cxx:772
 AliMillepede.cxx:773
 AliMillepede.cxx:774
 AliMillepede.cxx:775
 AliMillepede.cxx:776
 AliMillepede.cxx:777
 AliMillepede.cxx:778
 AliMillepede.cxx:779
 AliMillepede.cxx:780
 AliMillepede.cxx:781
 AliMillepede.cxx:782
 AliMillepede.cxx:783
 AliMillepede.cxx:784
 AliMillepede.cxx:785
 AliMillepede.cxx:786
 AliMillepede.cxx:787
 AliMillepede.cxx:788
 AliMillepede.cxx:789
 AliMillepede.cxx:790
 AliMillepede.cxx:791
 AliMillepede.cxx:792
 AliMillepede.cxx:793
 AliMillepede.cxx:794
 AliMillepede.cxx:795
 AliMillepede.cxx:796
 AliMillepede.cxx:797
 AliMillepede.cxx:798
 AliMillepede.cxx:799
 AliMillepede.cxx:800
 AliMillepede.cxx:801
 AliMillepede.cxx:802
 AliMillepede.cxx:803
 AliMillepede.cxx:804
 AliMillepede.cxx:805
 AliMillepede.cxx:806
 AliMillepede.cxx:807
 AliMillepede.cxx:808
 AliMillepede.cxx:809
 AliMillepede.cxx:810
 AliMillepede.cxx:811
 AliMillepede.cxx:812
 AliMillepede.cxx:813
 AliMillepede.cxx:814
 AliMillepede.cxx:815
 AliMillepede.cxx:816
 AliMillepede.cxx:817
 AliMillepede.cxx:818
 AliMillepede.cxx:819
 AliMillepede.cxx:820
 AliMillepede.cxx:821
 AliMillepede.cxx:822
 AliMillepede.cxx:823
 AliMillepede.cxx:824
 AliMillepede.cxx:825
 AliMillepede.cxx:826
 AliMillepede.cxx:827
 AliMillepede.cxx:828
 AliMillepede.cxx:829
 AliMillepede.cxx:830
 AliMillepede.cxx:831
 AliMillepede.cxx:832
 AliMillepede.cxx:833
 AliMillepede.cxx:834
 AliMillepede.cxx:835
 AliMillepede.cxx:836
 AliMillepede.cxx:837
 AliMillepede.cxx:838
 AliMillepede.cxx:839
 AliMillepede.cxx:840
 AliMillepede.cxx:841
 AliMillepede.cxx:842
 AliMillepede.cxx:843
 AliMillepede.cxx:844
 AliMillepede.cxx:845
 AliMillepede.cxx:846
 AliMillepede.cxx:847
 AliMillepede.cxx:848
 AliMillepede.cxx:849
 AliMillepede.cxx:850
 AliMillepede.cxx:851
 AliMillepede.cxx:852
 AliMillepede.cxx:853
 AliMillepede.cxx:854
 AliMillepede.cxx:855
 AliMillepede.cxx:856
 AliMillepede.cxx:857
 AliMillepede.cxx:858
 AliMillepede.cxx:859
 AliMillepede.cxx:860
 AliMillepede.cxx:861
 AliMillepede.cxx:862
 AliMillepede.cxx:863
 AliMillepede.cxx:864
 AliMillepede.cxx:865
 AliMillepede.cxx:866
 AliMillepede.cxx:867
 AliMillepede.cxx:868
 AliMillepede.cxx:869
 AliMillepede.cxx:870
 AliMillepede.cxx:871
 AliMillepede.cxx:872
 AliMillepede.cxx:873
 AliMillepede.cxx:874
 AliMillepede.cxx:875
 AliMillepede.cxx:876
 AliMillepede.cxx:877
 AliMillepede.cxx:878
 AliMillepede.cxx:879
 AliMillepede.cxx:880
 AliMillepede.cxx:881
 AliMillepede.cxx:882
 AliMillepede.cxx:883
 AliMillepede.cxx:884
 AliMillepede.cxx:885
 AliMillepede.cxx:886
 AliMillepede.cxx:887
 AliMillepede.cxx:888
 AliMillepede.cxx:889
 AliMillepede.cxx:890
 AliMillepede.cxx:891
 AliMillepede.cxx:892
 AliMillepede.cxx:893
 AliMillepede.cxx:894
 AliMillepede.cxx:895
 AliMillepede.cxx:896
 AliMillepede.cxx:897
 AliMillepede.cxx:898
 AliMillepede.cxx:899
 AliMillepede.cxx:900
 AliMillepede.cxx:901
 AliMillepede.cxx:902
 AliMillepede.cxx:903
 AliMillepede.cxx:904
 AliMillepede.cxx:905
 AliMillepede.cxx:906
 AliMillepede.cxx:907
 AliMillepede.cxx:908
 AliMillepede.cxx:909
 AliMillepede.cxx:910
 AliMillepede.cxx:911
 AliMillepede.cxx:912
 AliMillepede.cxx:913
 AliMillepede.cxx:914
 AliMillepede.cxx:915
 AliMillepede.cxx:916
 AliMillepede.cxx:917
 AliMillepede.cxx:918
 AliMillepede.cxx:919
 AliMillepede.cxx:920
 AliMillepede.cxx:921
 AliMillepede.cxx:922
 AliMillepede.cxx:923
 AliMillepede.cxx:924
 AliMillepede.cxx:925
 AliMillepede.cxx:926
 AliMillepede.cxx:927
 AliMillepede.cxx:928
 AliMillepede.cxx:929
 AliMillepede.cxx:930
 AliMillepede.cxx:931
 AliMillepede.cxx:932
 AliMillepede.cxx:933
 AliMillepede.cxx:934
 AliMillepede.cxx:935
 AliMillepede.cxx:936
 AliMillepede.cxx:937
 AliMillepede.cxx:938
 AliMillepede.cxx:939
 AliMillepede.cxx:940
 AliMillepede.cxx:941
 AliMillepede.cxx:942
 AliMillepede.cxx:943
 AliMillepede.cxx:944
 AliMillepede.cxx:945
 AliMillepede.cxx:946
 AliMillepede.cxx:947
 AliMillepede.cxx:948
 AliMillepede.cxx:949
 AliMillepede.cxx:950
 AliMillepede.cxx:951
 AliMillepede.cxx:952
 AliMillepede.cxx:953
 AliMillepede.cxx:954
 AliMillepede.cxx:955
 AliMillepede.cxx:956
 AliMillepede.cxx:957
 AliMillepede.cxx:958
 AliMillepede.cxx:959
 AliMillepede.cxx:960
 AliMillepede.cxx:961
 AliMillepede.cxx:962
 AliMillepede.cxx:963
 AliMillepede.cxx:964
 AliMillepede.cxx:965
 AliMillepede.cxx:966
 AliMillepede.cxx:967
 AliMillepede.cxx:968
 AliMillepede.cxx:969
 AliMillepede.cxx:970
 AliMillepede.cxx:971
 AliMillepede.cxx:972
 AliMillepede.cxx:973
 AliMillepede.cxx:974
 AliMillepede.cxx:975
 AliMillepede.cxx:976
 AliMillepede.cxx:977
 AliMillepede.cxx:978
 AliMillepede.cxx:979
 AliMillepede.cxx:980
 AliMillepede.cxx:981
 AliMillepede.cxx:982
 AliMillepede.cxx:983
 AliMillepede.cxx:984
 AliMillepede.cxx:985
 AliMillepede.cxx:986
 AliMillepede.cxx:987
 AliMillepede.cxx:988
 AliMillepede.cxx:989
 AliMillepede.cxx:990
 AliMillepede.cxx:991
 AliMillepede.cxx:992
 AliMillepede.cxx:993
 AliMillepede.cxx:994
 AliMillepede.cxx:995
 AliMillepede.cxx:996
 AliMillepede.cxx:997
 AliMillepede.cxx:998
 AliMillepede.cxx:999
 AliMillepede.cxx:1000
 AliMillepede.cxx:1001
 AliMillepede.cxx:1002
 AliMillepede.cxx:1003
 AliMillepede.cxx:1004
 AliMillepede.cxx:1005
 AliMillepede.cxx:1006
 AliMillepede.cxx:1007
 AliMillepede.cxx:1008
 AliMillepede.cxx:1009
 AliMillepede.cxx:1010
 AliMillepede.cxx:1011
 AliMillepede.cxx:1012
 AliMillepede.cxx:1013
 AliMillepede.cxx:1014
 AliMillepede.cxx:1015
 AliMillepede.cxx:1016
 AliMillepede.cxx:1017
 AliMillepede.cxx:1018
 AliMillepede.cxx:1019
 AliMillepede.cxx:1020
 AliMillepede.cxx:1021
 AliMillepede.cxx:1022
 AliMillepede.cxx:1023
 AliMillepede.cxx:1024
 AliMillepede.cxx:1025
 AliMillepede.cxx:1026
 AliMillepede.cxx:1027
 AliMillepede.cxx:1028
 AliMillepede.cxx:1029
 AliMillepede.cxx:1030
 AliMillepede.cxx:1031
 AliMillepede.cxx:1032
 AliMillepede.cxx:1033
 AliMillepede.cxx:1034
 AliMillepede.cxx:1035
 AliMillepede.cxx:1036
 AliMillepede.cxx:1037
 AliMillepede.cxx:1038
 AliMillepede.cxx:1039
 AliMillepede.cxx:1040
 AliMillepede.cxx:1041
 AliMillepede.cxx:1042
 AliMillepede.cxx:1043
 AliMillepede.cxx:1044
 AliMillepede.cxx:1045
 AliMillepede.cxx:1046
 AliMillepede.cxx:1047
 AliMillepede.cxx:1048
 AliMillepede.cxx:1049
 AliMillepede.cxx:1050
 AliMillepede.cxx:1051
 AliMillepede.cxx:1052
 AliMillepede.cxx:1053
 AliMillepede.cxx:1054
 AliMillepede.cxx:1055
 AliMillepede.cxx:1056
 AliMillepede.cxx:1057
 AliMillepede.cxx:1058
 AliMillepede.cxx:1059
 AliMillepede.cxx:1060
 AliMillepede.cxx:1061
 AliMillepede.cxx:1062
 AliMillepede.cxx:1063
 AliMillepede.cxx:1064
 AliMillepede.cxx:1065
 AliMillepede.cxx:1066
 AliMillepede.cxx:1067
 AliMillepede.cxx:1068
 AliMillepede.cxx:1069
 AliMillepede.cxx:1070
 AliMillepede.cxx:1071
 AliMillepede.cxx:1072
 AliMillepede.cxx:1073
 AliMillepede.cxx:1074
 AliMillepede.cxx:1075
 AliMillepede.cxx:1076
 AliMillepede.cxx:1077
 AliMillepede.cxx:1078
 AliMillepede.cxx:1079
 AliMillepede.cxx:1080
 AliMillepede.cxx:1081
 AliMillepede.cxx:1082
 AliMillepede.cxx:1083
 AliMillepede.cxx:1084
 AliMillepede.cxx:1085
 AliMillepede.cxx:1086
 AliMillepede.cxx:1087
 AliMillepede.cxx:1088
 AliMillepede.cxx:1089
 AliMillepede.cxx:1090
 AliMillepede.cxx:1091
 AliMillepede.cxx:1092
 AliMillepede.cxx:1093
 AliMillepede.cxx:1094
 AliMillepede.cxx:1095
 AliMillepede.cxx:1096
 AliMillepede.cxx:1097
 AliMillepede.cxx:1098
 AliMillepede.cxx:1099
 AliMillepede.cxx:1100
 AliMillepede.cxx:1101
 AliMillepede.cxx:1102
 AliMillepede.cxx:1103
 AliMillepede.cxx:1104
 AliMillepede.cxx:1105
 AliMillepede.cxx:1106
 AliMillepede.cxx:1107
 AliMillepede.cxx:1108
 AliMillepede.cxx:1109
 AliMillepede.cxx:1110
 AliMillepede.cxx:1111
 AliMillepede.cxx:1112
 AliMillepede.cxx:1113
 AliMillepede.cxx:1114
 AliMillepede.cxx:1115
 AliMillepede.cxx:1116
 AliMillepede.cxx:1117
 AliMillepede.cxx:1118
 AliMillepede.cxx:1119
 AliMillepede.cxx:1120
 AliMillepede.cxx:1121
 AliMillepede.cxx:1122
 AliMillepede.cxx:1123
 AliMillepede.cxx:1124
 AliMillepede.cxx:1125
 AliMillepede.cxx:1126
 AliMillepede.cxx:1127
 AliMillepede.cxx:1128
 AliMillepede.cxx:1129
 AliMillepede.cxx:1130
 AliMillepede.cxx:1131
 AliMillepede.cxx:1132
 AliMillepede.cxx:1133
 AliMillepede.cxx:1134
 AliMillepede.cxx:1135
 AliMillepede.cxx:1136
 AliMillepede.cxx:1137
 AliMillepede.cxx:1138
 AliMillepede.cxx:1139
 AliMillepede.cxx:1140
 AliMillepede.cxx:1141
 AliMillepede.cxx:1142
 AliMillepede.cxx:1143
 AliMillepede.cxx:1144
 AliMillepede.cxx:1145
 AliMillepede.cxx:1146
 AliMillepede.cxx:1147
 AliMillepede.cxx:1148
 AliMillepede.cxx:1149
 AliMillepede.cxx:1150
 AliMillepede.cxx:1151
 AliMillepede.cxx:1152
 AliMillepede.cxx:1153
 AliMillepede.cxx:1154
 AliMillepede.cxx:1155
 AliMillepede.cxx:1156
 AliMillepede.cxx:1157
 AliMillepede.cxx:1158
 AliMillepede.cxx:1159
 AliMillepede.cxx:1160
 AliMillepede.cxx:1161
 AliMillepede.cxx:1162
 AliMillepede.cxx:1163
 AliMillepede.cxx:1164
 AliMillepede.cxx:1165
 AliMillepede.cxx:1166
 AliMillepede.cxx:1167
 AliMillepede.cxx:1168
 AliMillepede.cxx:1169
 AliMillepede.cxx:1170
 AliMillepede.cxx:1171
 AliMillepede.cxx:1172
 AliMillepede.cxx:1173
 AliMillepede.cxx:1174
 AliMillepede.cxx:1175
 AliMillepede.cxx:1176
 AliMillepede.cxx:1177
 AliMillepede.cxx:1178
 AliMillepede.cxx:1179
 AliMillepede.cxx:1180
 AliMillepede.cxx:1181
 AliMillepede.cxx:1182
 AliMillepede.cxx:1183
 AliMillepede.cxx:1184
 AliMillepede.cxx:1185
 AliMillepede.cxx:1186
 AliMillepede.cxx:1187
 AliMillepede.cxx:1188
 AliMillepede.cxx:1189
 AliMillepede.cxx:1190
 AliMillepede.cxx:1191
 AliMillepede.cxx:1192
 AliMillepede.cxx:1193
 AliMillepede.cxx:1194
 AliMillepede.cxx:1195
 AliMillepede.cxx:1196
 AliMillepede.cxx:1197
 AliMillepede.cxx:1198
 AliMillepede.cxx:1199
 AliMillepede.cxx:1200
 AliMillepede.cxx:1201
 AliMillepede.cxx:1202
 AliMillepede.cxx:1203
 AliMillepede.cxx:1204
 AliMillepede.cxx:1205
 AliMillepede.cxx:1206
 AliMillepede.cxx:1207
 AliMillepede.cxx:1208
 AliMillepede.cxx:1209
 AliMillepede.cxx:1210
 AliMillepede.cxx:1211
 AliMillepede.cxx:1212
 AliMillepede.cxx:1213
 AliMillepede.cxx:1214
 AliMillepede.cxx:1215
 AliMillepede.cxx:1216
 AliMillepede.cxx:1217
 AliMillepede.cxx:1218
 AliMillepede.cxx:1219
 AliMillepede.cxx:1220
 AliMillepede.cxx:1221
 AliMillepede.cxx:1222
 AliMillepede.cxx:1223
 AliMillepede.cxx:1224
 AliMillepede.cxx:1225
 AliMillepede.cxx:1226
 AliMillepede.cxx:1227
 AliMillepede.cxx:1228
 AliMillepede.cxx:1229
 AliMillepede.cxx:1230
 AliMillepede.cxx:1231
 AliMillepede.cxx:1232
 AliMillepede.cxx:1233
 AliMillepede.cxx:1234
 AliMillepede.cxx:1235
 AliMillepede.cxx:1236
 AliMillepede.cxx:1237
 AliMillepede.cxx:1238
 AliMillepede.cxx:1239
 AliMillepede.cxx:1240
 AliMillepede.cxx:1241
 AliMillepede.cxx:1242
 AliMillepede.cxx:1243
 AliMillepede.cxx:1244
 AliMillepede.cxx:1245
 AliMillepede.cxx:1246
 AliMillepede.cxx:1247
 AliMillepede.cxx:1248
 AliMillepede.cxx:1249
 AliMillepede.cxx:1250
 AliMillepede.cxx:1251
 AliMillepede.cxx:1252
 AliMillepede.cxx:1253
 AliMillepede.cxx:1254
 AliMillepede.cxx:1255
 AliMillepede.cxx:1256
 AliMillepede.cxx:1257
 AliMillepede.cxx:1258
 AliMillepede.cxx:1259
 AliMillepede.cxx:1260
 AliMillepede.cxx:1261
 AliMillepede.cxx:1262
 AliMillepede.cxx:1263
 AliMillepede.cxx:1264
 AliMillepede.cxx:1265
 AliMillepede.cxx:1266
 AliMillepede.cxx:1267
 AliMillepede.cxx:1268
 AliMillepede.cxx:1269
 AliMillepede.cxx:1270
 AliMillepede.cxx:1271
 AliMillepede.cxx:1272
 AliMillepede.cxx:1273
 AliMillepede.cxx:1274
 AliMillepede.cxx:1275
 AliMillepede.cxx:1276
 AliMillepede.cxx:1277
 AliMillepede.cxx:1278
 AliMillepede.cxx:1279
 AliMillepede.cxx:1280
 AliMillepede.cxx:1281
 AliMillepede.cxx:1282
 AliMillepede.cxx:1283
 AliMillepede.cxx:1284
 AliMillepede.cxx:1285
 AliMillepede.cxx:1286
 AliMillepede.cxx:1287
 AliMillepede.cxx:1288
 AliMillepede.cxx:1289
 AliMillepede.cxx:1290
 AliMillepede.cxx:1291
 AliMillepede.cxx:1292
 AliMillepede.cxx:1293
 AliMillepede.cxx:1294
 AliMillepede.cxx:1295
 AliMillepede.cxx:1296
 AliMillepede.cxx:1297
 AliMillepede.cxx:1298
 AliMillepede.cxx:1299
 AliMillepede.cxx:1300
 AliMillepede.cxx:1301
 AliMillepede.cxx:1302
 AliMillepede.cxx:1303
 AliMillepede.cxx:1304
 AliMillepede.cxx:1305
 AliMillepede.cxx:1306
 AliMillepede.cxx:1307
 AliMillepede.cxx:1308
 AliMillepede.cxx:1309
 AliMillepede.cxx:1310
 AliMillepede.cxx:1311
 AliMillepede.cxx:1312
 AliMillepede.cxx:1313
 AliMillepede.cxx:1314
 AliMillepede.cxx:1315
 AliMillepede.cxx:1316
 AliMillepede.cxx:1317
 AliMillepede.cxx:1318
 AliMillepede.cxx:1319
 AliMillepede.cxx:1320
 AliMillepede.cxx:1321
 AliMillepede.cxx:1322
 AliMillepede.cxx:1323
 AliMillepede.cxx:1324
 AliMillepede.cxx:1325
 AliMillepede.cxx:1326
 AliMillepede.cxx:1327
 AliMillepede.cxx:1328
 AliMillepede.cxx:1329
 AliMillepede.cxx:1330
 AliMillepede.cxx:1331
 AliMillepede.cxx:1332
 AliMillepede.cxx:1333
 AliMillepede.cxx:1334
 AliMillepede.cxx:1335
 AliMillepede.cxx:1336
 AliMillepede.cxx:1337
 AliMillepede.cxx:1338
 AliMillepede.cxx:1339
 AliMillepede.cxx:1340
 AliMillepede.cxx:1341
 AliMillepede.cxx:1342
 AliMillepede.cxx:1343
 AliMillepede.cxx:1344
 AliMillepede.cxx:1345
 AliMillepede.cxx:1346
 AliMillepede.cxx:1347
 AliMillepede.cxx:1348
 AliMillepede.cxx:1349
 AliMillepede.cxx:1350
 AliMillepede.cxx:1351
 AliMillepede.cxx:1352
 AliMillepede.cxx:1353
 AliMillepede.cxx:1354
 AliMillepede.cxx:1355
 AliMillepede.cxx:1356
 AliMillepede.cxx:1357
 AliMillepede.cxx:1358
 AliMillepede.cxx:1359
 AliMillepede.cxx:1360
 AliMillepede.cxx:1361
 AliMillepede.cxx:1362
 AliMillepede.cxx:1363
 AliMillepede.cxx:1364
 AliMillepede.cxx:1365
 AliMillepede.cxx:1366
 AliMillepede.cxx:1367
 AliMillepede.cxx:1368
 AliMillepede.cxx:1369
 AliMillepede.cxx:1370
 AliMillepede.cxx:1371
 AliMillepede.cxx:1372
 AliMillepede.cxx:1373
 AliMillepede.cxx:1374
 AliMillepede.cxx:1375
 AliMillepede.cxx:1376
 AliMillepede.cxx:1377
 AliMillepede.cxx:1378
 AliMillepede.cxx:1379
 AliMillepede.cxx:1380
 AliMillepede.cxx:1381
 AliMillepede.cxx:1382
 AliMillepede.cxx:1383
 AliMillepede.cxx:1384
 AliMillepede.cxx:1385
 AliMillepede.cxx:1386
 AliMillepede.cxx:1387
 AliMillepede.cxx:1388
 AliMillepede.cxx:1389
 AliMillepede.cxx:1390
 AliMillepede.cxx:1391
 AliMillepede.cxx:1392
 AliMillepede.cxx:1393
 AliMillepede.cxx:1394
 AliMillepede.cxx:1395
 AliMillepede.cxx:1396
 AliMillepede.cxx:1397
 AliMillepede.cxx:1398
 AliMillepede.cxx:1399
 AliMillepede.cxx:1400
 AliMillepede.cxx:1401
 AliMillepede.cxx:1402
 AliMillepede.cxx:1403
 AliMillepede.cxx:1404
 AliMillepede.cxx:1405
 AliMillepede.cxx:1406
 AliMillepede.cxx:1407
 AliMillepede.cxx:1408
 AliMillepede.cxx:1409
 AliMillepede.cxx:1410
 AliMillepede.cxx:1411
 AliMillepede.cxx:1412
 AliMillepede.cxx:1413
 AliMillepede.cxx:1414
 AliMillepede.cxx:1415
 AliMillepede.cxx:1416
 AliMillepede.cxx:1417
 AliMillepede.cxx:1418
 AliMillepede.cxx:1419
 AliMillepede.cxx:1420
 AliMillepede.cxx:1421
 AliMillepede.cxx:1422
 AliMillepede.cxx:1423
 AliMillepede.cxx:1424
 AliMillepede.cxx:1425
 AliMillepede.cxx:1426
 AliMillepede.cxx:1427
 AliMillepede.cxx:1428
 AliMillepede.cxx:1429
 AliMillepede.cxx:1430
 AliMillepede.cxx:1431
 AliMillepede.cxx:1432
 AliMillepede.cxx:1433
 AliMillepede.cxx:1434
 AliMillepede.cxx:1435
 AliMillepede.cxx:1436
 AliMillepede.cxx:1437
 AliMillepede.cxx:1438
 AliMillepede.cxx:1439
 AliMillepede.cxx:1440
 AliMillepede.cxx:1441
 AliMillepede.cxx:1442
 AliMillepede.cxx:1443
 AliMillepede.cxx:1444
 AliMillepede.cxx:1445
 AliMillepede.cxx:1446
 AliMillepede.cxx:1447
 AliMillepede.cxx:1448
 AliMillepede.cxx:1449
 AliMillepede.cxx:1450
 AliMillepede.cxx:1451
 AliMillepede.cxx:1452
 AliMillepede.cxx:1453
 AliMillepede.cxx:1454