ROOT logo
/* ----------------------------------------------------------------------------------------
   Class to solve a set of N linearized parametric equations of the type
   Eq(k): sum_i=0^n { g_i G_ik }  + t_k T_k = res_k
   whith n "global" parameters gi and one "local" parameter (per equation) t_k.
   Each measured points provides 3 measured coordinates, with proper covariance matrix.

   Used for Newton-Raphson iteration step in solution of non-linear parametric equations
   F(g,t_k) - res_k = 0, with G_ik = dF(g,t_k)/dg_i and T_k = dF(g,t_k)/dt_k
   Solution is obtained by elimination of local parameters via large (n+N) matrix partitioning 

   Author: ruben.shahoyan@cern.ch
-------------------------------------------------------------------------------------------*/ 
#include "AliParamSolver.h"
#include "AliSymMatrix.h"
#include "AliLog.h"
#include <TMath.h>

ClassImp(AliParamSolver)

//______________________________________________________________________________________
AliParamSolver::AliParamSolver()
: fMatrix(0),fSolGlo(0),fSolLoc(0),fMaxGlobal(0),fNGlobal(0),fNPoints(0),fMaxPoints(0),
  fRHSGlo(0),fRHSLoc(0),fMatGamma(0),fMatG(0),fCovDGl(0)
{ 
  // default constructor
}

//______________________________________________________________________________________
AliParamSolver::AliParamSolver(Int_t maxglo,Int_t locbuff)
: fMatrix(0),fSolGlo(0),fSolLoc(0),fMaxGlobal(maxglo),fNGlobal(maxglo),fNPoints(0),fMaxPoints(0),
  fRHSGlo(0),fRHSLoc(0),fMatGamma(0),fMatG(0),fCovDGl(0)
{ 
  // constructor for nglo globals
  Init(locbuff);
}

//______________________________________________________________________________________
AliParamSolver::AliParamSolver(const AliParamSolver& src)
  : TObject(src),fMatrix(0),fSolGlo(0),fSolLoc(0),fMaxGlobal(src.fMaxGlobal),fNGlobal(src.fNGlobal),
    fNPoints(0),fMaxPoints(0),fRHSGlo(0),fRHSLoc(0),fMatGamma(0),fMatG(0),fCovDGl(0)
{ 
  // copy constructor 
  if (src.fMatrix) {
    Init(src.fMaxPoints);
    (*this) = src;
  }
}

//______________________________________________________________________________________
AliParamSolver& AliParamSolver::operator=(const AliParamSolver& src)
{
  // assignment operator
  if (this==&src) return *this;
  TObject::operator=(src);
  if (src.fMatrix && (fNGlobal!=src.fNGlobal || fMaxPoints<src.fNPoints)) {
    fNGlobal   = src.fNGlobal;
    fMaxGlobal = src.fMaxGlobal;
    if (fMatrix)   delete   fMatrix; fMatrix = 0;
    if (fSolGlo)   delete[] fSolGlo; fSolGlo = 0;
    if (fSolLoc)   delete[] fSolLoc; fSolLoc = 0;
    if (fRHSGlo)   delete[] fRHSGlo; fRHSGlo = 0;
    if (fRHSLoc)   delete[] fRHSLoc; fRHSLoc = 0;
    if (fMatGamma) delete[] fMatGamma; fMatGamma = 0;
    if (fMatG)     delete[] fMatG; fMatG = 0;
    if (fCovDGl)   delete[] fCovDGl; fCovDGl = 0;
    Init(src.fMaxPoints);
  }
  if (src.fMatrix) {
    (*fMatrix) = *(src.fMatrix);
    memcpy(fSolGlo,src.fSolGlo,fNGlobal*sizeof(double));
    memcpy(fSolLoc,src.fSolLoc,fNPoints*sizeof(double));
    memcpy(fRHSGlo,src.fRHSGlo,fNGlobal*sizeof(double));
    memcpy(fRHSLoc,src.fRHSLoc,fNPoints*sizeof(double));
    memcpy(fMatGamma,src.fMatGamma,fNPoints*sizeof(double));
    memcpy(fMatG,src.fMatG,fNPoints*fNGlobal*sizeof(double));
  }
  //
  return *this;
}

//______________________________________________________________________________________
AliParamSolver::~AliParamSolver()
{ 
  // destructor
  delete fMatrix;
  delete[] fSolGlo;
  delete[] fSolLoc;
  delete[] fRHSGlo;
  delete[] fRHSLoc;
  delete[] fMatGamma;
  delete[] fMatG;
  delete[] fCovDGl;
}

//______________________________________________________________________________________
Bool_t AliParamSolver::SolveGlobals(Bool_t obtainCov)
{
  // solve against global vars.
  if (fNPoints<fNGlobal/3) {
    AliError(Form("Number of points: %d is not enough for %d globals",fNPoints,fNGlobal));
    return kFALSE;
  }
  //
  if (!TestBit(kBitGloSol)) {
    if (!fMatrix->SolveChol(fRHSGlo, fSolGlo, obtainCov)) {
      AliError("Solution Failed");
      return kFALSE;
    }
    SetBit(kBitGloSol);
    if (obtainCov) SetBit(kBitCInv);
  }
  return kTRUE;
}

//______________________________________________________________________________________
Bool_t AliParamSolver::SolveLocals()
{
  // solve for locals
  const double kTiny = 1e-16;
  if (TestBit(kBitLocSol)) return kTRUE;
  if (!TestBit(kBitGloSol)) {
    AliError("Cannot solve for Locals before SolveGlobals is called");
    return kFALSE;
  }
  for (int i=fNPoints;i--;) {
    if (TMath::Abs(fMatGamma[i])<kTiny) {fSolLoc[i] = 0; continue;}
    double beta = fRHSLoc[i];
    double *mtG = fMatG + i*fNGlobal;  // G_i
    for (int j=fNGlobal;j--;) beta -= mtG[j]*fSolGlo[j];
    fSolLoc[i] = beta/fMatGamma[i];   // Gamma^-1 * (beta - G_i * a)
  }
  SetBit(kBitLocSol);
  return kTRUE;
}

//______________________________________________________________________________________
AliSymMatrix* AliParamSolver::GetCovMatrix()
{
  // obtain cov.mat
  if (!TestBit(kBitGloSol)) {
    AliError("Cannot obtain Cov.Matrix before SolveGlobals is called");
    return 0;
  }
  if (TestBit(kBitCInv)) return fMatrix;
  //
  if (fMatrix->InvertChol()) {
    SetBit(kBitCInv);
    return fMatrix;
  }
  return 0;
}

//______________________________________________________________________________________
Bool_t AliParamSolver::Solve(Bool_t obtainCov)
{
  // solve all
  return (SolveGlobals(obtainCov) && SolveLocals()) ? kTRUE : kFALSE; 
}

//______________________________________________________________________________________
void AliParamSolver::AddEquation(const Double_t* dGl,const Double_t *dLc,const Double_t *res, const Double_t *covI,Double_t sclErrI)
{
  // add the measured point to chi2 normal equations
  // Input: 
  // dGl : NGlo x 3 matrix of derivative for each of the 3 coordinates vs global params
  // dLc : 3-vector of derivative for each coordinate vs local param
  // res : residual of the point (extrapolated - measured)
  // covI: 3 x (3+1)/2 matrix of the (inverted) errors (symmetric)
  // sclErrI: scaling coefficient to apply to inverted errors (used if >0)
  // The contribution of the point to chi2 is  V * covI * V 
  // with component of the vector V(i) = dGl[i]*glob + dLc[i]*loc - res[i] 
  //
  // Instead of the NGlo + NMeasPoints size matrix we create only NGlo size matrix using the 
  // reduction a la millepede : http://www.desy.de/~blobel/millepede1.ps
  const double kTiny = 1e-16;
  //
  if (fNPoints+1 == fMaxPoints) ExpandStorage((fNPoints+1)*2);
  ResetBit(kBitGloSol|kBitLocSol);
  //
  if (TestBit(kBitCInv)) { // solution was obtained and the matrix was inverted for previous points
    fMatrix->InvertChol();
    ResetBit(kBitCInv);
  }
  //
  double *mtG   = fMatG + fNPoints*fNGlobal;  // G_i
  double &beta  = fRHSLoc[fNPoints];
  double &gamma = fMatGamma[fNPoints];
  double cDl[3];
  //
  // cov * dR/dloc
  cDl[kX] = covI[kXX]*dLc[kX] + covI[kXY]*dLc[kY] + covI[kXZ]*dLc[kZ];
  cDl[kY] = covI[kXY]*dLc[kX] + covI[kYY]*dLc[kY] + covI[kYZ]*dLc[kZ];
  cDl[kZ] = covI[kXZ]*dLc[kX] + covI[kYZ]*dLc[kY] + covI[kZZ]*dLc[kZ];
  if (sclErrI>0) { cDl[kX] *= sclErrI; cDl[kY] *= sclErrI; cDl[kZ] *= sclErrI;}
  //
  for (int i=fNGlobal;i--;) {
    const double *dGli = dGl+i*3;  // derivatives of XYZ vs i-th global param
    double *cDgi = fCovDGl+i*3;    // cov * dR/dGl_i
    cDgi[kX] = covI[kXX]*dGli[kX] + covI[kXY]*dGli[kY] + covI[kXZ]*dGli[kZ];
    cDgi[kY] = covI[kXY]*dGli[kX] + covI[kYY]*dGli[kY] + covI[kYZ]*dGli[kZ];
    cDgi[kZ] = covI[kXZ]*dGli[kX] + covI[kYZ]*dGli[kY] + covI[kZZ]*dGli[kZ];
    if (sclErrI>0) { cDgi[kX] *= sclErrI; cDgi[kY] *= sclErrI; cDgi[kZ] *= sclErrI;}
    //
    mtG[i]   = cDl[kX]*dGli[kX] + cDl[kY]*dGli[kY] + cDl[kZ]*dGli[kZ];  // dR/dGl_i * cov * dR/dLoc
  }
  beta    = res[kX]*cDl[kX] + res[kY]*cDl[kY] + res[kZ]*cDl[kZ];  //RHS: res*cov*dR/dloc
  gamma   = dLc[kX]*cDl[kX] + dLc[kY]*cDl[kY] + dLc[kZ]*cDl[kZ];  //RHS: dR/dloc*cov*dR/dloc
  double locSol  = TMath::Abs(gamma)<kTiny ? 0. : beta/gamma;     //local solution: gamma^-1 beta
  //
  AliSymMatrix &matC = *fMatrix;
  for (int i=fNGlobal;i--;) {
    const double *cDgi = fCovDGl+i*3;    // cov * dR/dGl_i
    //
    fRHSGlo[i] += cDgi[kX]*res[kX] + cDgi[kY]*res[kY] + cDgi[kZ]*res[kZ]      // b_i = dR/dGi * cov * res
      -           mtG[i]*locSol;                                              //     - [G gamma^-1 beta ]_i
    //
    for (int j=i+1;j--;) {
      //      const double *cDgj = fCovDGl+j*3;  // cov * dR/dGl_j
      const double *dGlj = dGl+j*3;        // derivatives of XYZ vs i-th global param
      double add = dGlj[kX]*cDgi[kX] + dGlj[kY]*cDgi[kY] + dGlj[kZ]*cDgi[kZ];  // C_ij = dR/dGi * cov * dR/dGj
      if (TMath::Abs(gamma)>kTiny) add -= mtG[i]*mtG[j]/gamma;                 //        - [G gamma^-1 T(G) ]_ij      
      matC(i,j) += add;       
    }
  }
  //
  fNPoints++;
  //
}

//______________________________________________________________________________________
void AliParamSolver::AddConstraint(Int_t parID, Double_t val, Double_t err2inv)
{
  // add gassian constriant to parameter parID
  if (parID>=fNGlobal) {
    AliError(Form("Attempt to constraint non-existing parameter %d",parID));
    return;
  }
  //
  (*fMatrix)(parID,parID) += err2inv;
  fRHSGlo[parID] += val*err2inv;
  //
}

//______________________________________________________________________________________
void AliParamSolver::Init(Int_t npini)
{
  // create storage assuming maximum npini measured points
  fMatrix = new AliSymMatrix(fMaxGlobal);
  fSolGlo = new Double_t[fMaxGlobal];
  fRHSGlo = new Double_t[fMaxGlobal];
  //
  fCovDGl = new Double_t[3*fMaxGlobal];
  ExpandStorage(npini);
  fMatrix->SetSizeUsed(fNGlobal);
  //
}

//______________________________________________________________________________________
void AliParamSolver::ExpandStorage(Int_t newSize)
{
  // increase space to newSize measured points
  newSize = newSize>fMaxPoints ? newSize : fMaxPoints+1;
  double* tmp;
  tmp = new Double_t[newSize];
  if (fSolLoc) delete[] fSolLoc; 
  fSolLoc = tmp;
  //
  tmp = new Double_t[newSize];
  if (fMatGamma) {
    memcpy(tmp,fMatGamma,fNPoints*sizeof(Double_t));
    delete[] fMatGamma;
  }
  fMatGamma = tmp;
  //
  tmp = new Double_t[newSize];
  if (fRHSLoc) {
    memcpy(tmp,fRHSLoc,fNPoints*sizeof(Double_t));
    delete[] fRHSLoc;
  }
  fRHSLoc = tmp;
  //
  tmp = new Double_t[newSize*fMaxGlobal];
  if (fMatG) {
    memcpy(tmp,fMatG,fNPoints*fMaxGlobal*sizeof(Double_t));
    delete[] fMatG;
  }
  fMatG = tmp;
  //
  fMaxPoints = newSize;
  //
}

//______________________________________________________________________________________
void AliParamSolver::Clear(Option_t*)
{
  // reset all
  fNPoints = 0;
  fMatrix->Reset();
  for (int i=fNGlobal;i--;) fRHSGlo[i] = 0;
  ResetBit(kBitGloSol | kBitLocSol | kBitCInv);
}

//______________________________________________________________________________________
void AliParamSolver::Print(Option_t*) const
{
  // print itself
  AliInfo(Form("Solver with %d globals for %d points",fNGlobal,fNPoints));
}

//______________________________________________________________________________________
void AliParamSolver::SetNGlobal(Int_t n) 
{
  // set N global params
  if (n>fMaxGlobal) {
    AliError(Form("Maximum number of globals was set to %d",fMaxGlobal));
    return;
  }
  fNGlobal = n;
  fMatrix->SetSizeUsed(fNGlobal);
}

//______________________________________________________________________________________
void AliParamSolver::SetMaxGlobal(Int_t n) 
{
  // set limit on N glob.
  if (n>0 && n==fMaxGlobal) return;
  fMaxGlobal = n;
  fNGlobal = n;
  if (fMatrix)   delete   fMatrix;   fMatrix = 0;
  if (fSolGlo)   delete[] fSolGlo;   fSolGlo = 0;
  if (fSolLoc)   delete[] fSolLoc;   fSolLoc = 0;
  if (fRHSGlo)   delete[] fRHSGlo;   fRHSGlo = 0;
  if (fRHSLoc)   delete[] fRHSLoc;   fRHSLoc = 0;
  if (fMatGamma) delete[] fMatGamma; fMatGamma = 0;
  if (fMatG)     delete[] fMatG;     fMatG = 0;
  if (fCovDGl)   delete[] fCovDGl;   fCovDGl = 0;
  n = TMath::Max(16,fMaxPoints);
  Init(n);
  //
}

 AliParamSolver.cxx:1
 AliParamSolver.cxx:2
 AliParamSolver.cxx:3
 AliParamSolver.cxx:4
 AliParamSolver.cxx:5
 AliParamSolver.cxx:6
 AliParamSolver.cxx:7
 AliParamSolver.cxx:8
 AliParamSolver.cxx:9
 AliParamSolver.cxx:10
 AliParamSolver.cxx:11
 AliParamSolver.cxx:12
 AliParamSolver.cxx:13
 AliParamSolver.cxx:14
 AliParamSolver.cxx:15
 AliParamSolver.cxx:16
 AliParamSolver.cxx:17
 AliParamSolver.cxx:18
 AliParamSolver.cxx:19
 AliParamSolver.cxx:20
 AliParamSolver.cxx:21
 AliParamSolver.cxx:22
 AliParamSolver.cxx:23
 AliParamSolver.cxx:24
 AliParamSolver.cxx:25
 AliParamSolver.cxx:26
 AliParamSolver.cxx:27
 AliParamSolver.cxx:28
 AliParamSolver.cxx:29
 AliParamSolver.cxx:30
 AliParamSolver.cxx:31
 AliParamSolver.cxx:32
 AliParamSolver.cxx:33
 AliParamSolver.cxx:34
 AliParamSolver.cxx:35
 AliParamSolver.cxx:36
 AliParamSolver.cxx:37
 AliParamSolver.cxx:38
 AliParamSolver.cxx:39
 AliParamSolver.cxx:40
 AliParamSolver.cxx:41
 AliParamSolver.cxx:42
 AliParamSolver.cxx:43
 AliParamSolver.cxx:44
 AliParamSolver.cxx:45
 AliParamSolver.cxx:46
 AliParamSolver.cxx:47
 AliParamSolver.cxx:48
 AliParamSolver.cxx:49
 AliParamSolver.cxx:50
 AliParamSolver.cxx:51
 AliParamSolver.cxx:52
 AliParamSolver.cxx:53
 AliParamSolver.cxx:54
 AliParamSolver.cxx:55
 AliParamSolver.cxx:56
 AliParamSolver.cxx:57
 AliParamSolver.cxx:58
 AliParamSolver.cxx:59
 AliParamSolver.cxx:60
 AliParamSolver.cxx:61
 AliParamSolver.cxx:62
 AliParamSolver.cxx:63
 AliParamSolver.cxx:64
 AliParamSolver.cxx:65
 AliParamSolver.cxx:66
 AliParamSolver.cxx:67
 AliParamSolver.cxx:68
 AliParamSolver.cxx:69
 AliParamSolver.cxx:70
 AliParamSolver.cxx:71
 AliParamSolver.cxx:72
 AliParamSolver.cxx:73
 AliParamSolver.cxx:74
 AliParamSolver.cxx:75
 AliParamSolver.cxx:76
 AliParamSolver.cxx:77
 AliParamSolver.cxx:78
 AliParamSolver.cxx:79
 AliParamSolver.cxx:80
 AliParamSolver.cxx:81
 AliParamSolver.cxx:82
 AliParamSolver.cxx:83
 AliParamSolver.cxx:84
 AliParamSolver.cxx:85
 AliParamSolver.cxx:86
 AliParamSolver.cxx:87
 AliParamSolver.cxx:88
 AliParamSolver.cxx:89
 AliParamSolver.cxx:90
 AliParamSolver.cxx:91
 AliParamSolver.cxx:92
 AliParamSolver.cxx:93
 AliParamSolver.cxx:94
 AliParamSolver.cxx:95
 AliParamSolver.cxx:96
 AliParamSolver.cxx:97
 AliParamSolver.cxx:98
 AliParamSolver.cxx:99
 AliParamSolver.cxx:100
 AliParamSolver.cxx:101
 AliParamSolver.cxx:102
 AliParamSolver.cxx:103
 AliParamSolver.cxx:104
 AliParamSolver.cxx:105
 AliParamSolver.cxx:106
 AliParamSolver.cxx:107
 AliParamSolver.cxx:108
 AliParamSolver.cxx:109
 AliParamSolver.cxx:110
 AliParamSolver.cxx:111
 AliParamSolver.cxx:112
 AliParamSolver.cxx:113
 AliParamSolver.cxx:114
 AliParamSolver.cxx:115
 AliParamSolver.cxx:116
 AliParamSolver.cxx:117
 AliParamSolver.cxx:118
 AliParamSolver.cxx:119
 AliParamSolver.cxx:120
 AliParamSolver.cxx:121
 AliParamSolver.cxx:122
 AliParamSolver.cxx:123
 AliParamSolver.cxx:124
 AliParamSolver.cxx:125
 AliParamSolver.cxx:126
 AliParamSolver.cxx:127
 AliParamSolver.cxx:128
 AliParamSolver.cxx:129
 AliParamSolver.cxx:130
 AliParamSolver.cxx:131
 AliParamSolver.cxx:132
 AliParamSolver.cxx:133
 AliParamSolver.cxx:134
 AliParamSolver.cxx:135
 AliParamSolver.cxx:136
 AliParamSolver.cxx:137
 AliParamSolver.cxx:138
 AliParamSolver.cxx:139
 AliParamSolver.cxx:140
 AliParamSolver.cxx:141
 AliParamSolver.cxx:142
 AliParamSolver.cxx:143
 AliParamSolver.cxx:144
 AliParamSolver.cxx:145
 AliParamSolver.cxx:146
 AliParamSolver.cxx:147
 AliParamSolver.cxx:148
 AliParamSolver.cxx:149
 AliParamSolver.cxx:150
 AliParamSolver.cxx:151
 AliParamSolver.cxx:152
 AliParamSolver.cxx:153
 AliParamSolver.cxx:154
 AliParamSolver.cxx:155
 AliParamSolver.cxx:156
 AliParamSolver.cxx:157
 AliParamSolver.cxx:158
 AliParamSolver.cxx:159
 AliParamSolver.cxx:160
 AliParamSolver.cxx:161
 AliParamSolver.cxx:162
 AliParamSolver.cxx:163
 AliParamSolver.cxx:164
 AliParamSolver.cxx:165
 AliParamSolver.cxx:166
 AliParamSolver.cxx:167
 AliParamSolver.cxx:168
 AliParamSolver.cxx:169
 AliParamSolver.cxx:170
 AliParamSolver.cxx:171
 AliParamSolver.cxx:172
 AliParamSolver.cxx:173
 AliParamSolver.cxx:174
 AliParamSolver.cxx:175
 AliParamSolver.cxx:176
 AliParamSolver.cxx:177
 AliParamSolver.cxx:178
 AliParamSolver.cxx:179
 AliParamSolver.cxx:180
 AliParamSolver.cxx:181
 AliParamSolver.cxx:182
 AliParamSolver.cxx:183
 AliParamSolver.cxx:184
 AliParamSolver.cxx:185
 AliParamSolver.cxx:186
 AliParamSolver.cxx:187
 AliParamSolver.cxx:188
 AliParamSolver.cxx:189
 AliParamSolver.cxx:190
 AliParamSolver.cxx:191
 AliParamSolver.cxx:192
 AliParamSolver.cxx:193
 AliParamSolver.cxx:194
 AliParamSolver.cxx:195
 AliParamSolver.cxx:196
 AliParamSolver.cxx:197
 AliParamSolver.cxx:198
 AliParamSolver.cxx:199
 AliParamSolver.cxx:200
 AliParamSolver.cxx:201
 AliParamSolver.cxx:202
 AliParamSolver.cxx:203
 AliParamSolver.cxx:204
 AliParamSolver.cxx:205
 AliParamSolver.cxx:206
 AliParamSolver.cxx:207
 AliParamSolver.cxx:208
 AliParamSolver.cxx:209
 AliParamSolver.cxx:210
 AliParamSolver.cxx:211
 AliParamSolver.cxx:212
 AliParamSolver.cxx:213
 AliParamSolver.cxx:214
 AliParamSolver.cxx:215
 AliParamSolver.cxx:216
 AliParamSolver.cxx:217
 AliParamSolver.cxx:218
 AliParamSolver.cxx:219
 AliParamSolver.cxx:220
 AliParamSolver.cxx:221
 AliParamSolver.cxx:222
 AliParamSolver.cxx:223
 AliParamSolver.cxx:224
 AliParamSolver.cxx:225
 AliParamSolver.cxx:226
 AliParamSolver.cxx:227
 AliParamSolver.cxx:228
 AliParamSolver.cxx:229
 AliParamSolver.cxx:230
 AliParamSolver.cxx:231
 AliParamSolver.cxx:232
 AliParamSolver.cxx:233
 AliParamSolver.cxx:234
 AliParamSolver.cxx:235
 AliParamSolver.cxx:236
 AliParamSolver.cxx:237
 AliParamSolver.cxx:238
 AliParamSolver.cxx:239
 AliParamSolver.cxx:240
 AliParamSolver.cxx:241
 AliParamSolver.cxx:242
 AliParamSolver.cxx:243
 AliParamSolver.cxx:244
 AliParamSolver.cxx:245
 AliParamSolver.cxx:246
 AliParamSolver.cxx:247
 AliParamSolver.cxx:248
 AliParamSolver.cxx:249
 AliParamSolver.cxx:250
 AliParamSolver.cxx:251
 AliParamSolver.cxx:252
 AliParamSolver.cxx:253
 AliParamSolver.cxx:254
 AliParamSolver.cxx:255
 AliParamSolver.cxx:256
 AliParamSolver.cxx:257
 AliParamSolver.cxx:258
 AliParamSolver.cxx:259
 AliParamSolver.cxx:260
 AliParamSolver.cxx:261
 AliParamSolver.cxx:262
 AliParamSolver.cxx:263
 AliParamSolver.cxx:264
 AliParamSolver.cxx:265
 AliParamSolver.cxx:266
 AliParamSolver.cxx:267
 AliParamSolver.cxx:268
 AliParamSolver.cxx:269
 AliParamSolver.cxx:270
 AliParamSolver.cxx:271
 AliParamSolver.cxx:272
 AliParamSolver.cxx:273
 AliParamSolver.cxx:274
 AliParamSolver.cxx:275
 AliParamSolver.cxx:276
 AliParamSolver.cxx:277
 AliParamSolver.cxx:278
 AliParamSolver.cxx:279
 AliParamSolver.cxx:280
 AliParamSolver.cxx:281
 AliParamSolver.cxx:282
 AliParamSolver.cxx:283
 AliParamSolver.cxx:284
 AliParamSolver.cxx:285
 AliParamSolver.cxx:286
 AliParamSolver.cxx:287
 AliParamSolver.cxx:288
 AliParamSolver.cxx:289
 AliParamSolver.cxx:290
 AliParamSolver.cxx:291
 AliParamSolver.cxx:292
 AliParamSolver.cxx:293
 AliParamSolver.cxx:294
 AliParamSolver.cxx:295
 AliParamSolver.cxx:296
 AliParamSolver.cxx:297
 AliParamSolver.cxx:298
 AliParamSolver.cxx:299
 AliParamSolver.cxx:300
 AliParamSolver.cxx:301
 AliParamSolver.cxx:302
 AliParamSolver.cxx:303
 AliParamSolver.cxx:304
 AliParamSolver.cxx:305
 AliParamSolver.cxx:306
 AliParamSolver.cxx:307
 AliParamSolver.cxx:308
 AliParamSolver.cxx:309
 AliParamSolver.cxx:310
 AliParamSolver.cxx:311
 AliParamSolver.cxx:312
 AliParamSolver.cxx:313
 AliParamSolver.cxx:314
 AliParamSolver.cxx:315
 AliParamSolver.cxx:316
 AliParamSolver.cxx:317
 AliParamSolver.cxx:318
 AliParamSolver.cxx:319
 AliParamSolver.cxx:320
 AliParamSolver.cxx:321
 AliParamSolver.cxx:322
 AliParamSolver.cxx:323
 AliParamSolver.cxx:324
 AliParamSolver.cxx:325
 AliParamSolver.cxx:326
 AliParamSolver.cxx:327
 AliParamSolver.cxx:328
 AliParamSolver.cxx:329
 AliParamSolver.cxx:330
 AliParamSolver.cxx:331
 AliParamSolver.cxx:332
 AliParamSolver.cxx:333
 AliParamSolver.cxx:334
 AliParamSolver.cxx:335
 AliParamSolver.cxx:336
 AliParamSolver.cxx:337
 AliParamSolver.cxx:338
 AliParamSolver.cxx:339
 AliParamSolver.cxx:340
 AliParamSolver.cxx:341