ROOT logo
AliRoot » STEER » STEER » AliMillePede2

class AliMillePede2: public TObject

Function Members (Methods)

public:
AliMillePede2()
AliMillePede2(const AliMillePede2& src)
virtual~AliMillePede2()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
Float_tChi2DoFLim(int nSig, int nDoF) const
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
voidCloseConsRecStorage()
voidCloseDataRecStorage()
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Float_tGetChi2CutFactor() const
Float_tGetChi2CutRef() const
const Char_t*GetConsRecFName() const
Int_tGetCurrentIteration() const
const Char_t*GetDataRecFName() const
Double_t*GetDeltaPars() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
Double_tGetFinalError(int i) const
Double_tGetFinalParam(int i) const
Double_tGetGlobal(Int_t i) const
AliMatrixSq*GetGlobalMatrix() const
Double_t*GetGlobals() const
Int_tGetGlobalSolveStatus() const
virtual const char*TObject::GetIconName() const
Double_tGetInitPar(Int_t i) const
Double_t*GetInitPars() const
static Bool_tGetInvChol()
Bool_t*GetIsLinear() const
Bool_tGetIsLinear(Int_t i) const
static Int_tGetIterSolverType()
AliSymMatrix*GetLocalMatrix() const
Int_tGetMinPntValid() const
Int_tGetMinRecordLength() const
static Int_tGetMinResMaxIter()
static Int_tGetMinResPrecondType()
static Double_tGetMinResTol()
virtual const char*TObject::GetName() const
Int_tGetNGlobalConstraints() const
Int_tGetNGlobalsFixed() const
Int_tGetNGloPar() const
Int_tGetNGloParIni() const
static Int_tGetNKrylovV()
Int_tGetNLagrangeConstraints() const
Long_tGetNLocalEquations() const
Long_tGetNLocalFits() const
Long_tGetNLocalFitsRejected() const
Int_tGetNLocPar() const
Int_tGetNMaxIterations() const
Int_tGetNStdDev() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
Int_tGetParamGrID(Int_t i) const
Double_tGetParError(int iPar) const
Int_t*GetProcessedPoints() const
Int_tGetProcessedPoints(Int_t i) const
Double_tGetPull(int i) const
const char*GetRecConsBranchName() const
const char*GetRecConsTreeName() const
const char*GetRecDataBranchName() const
const char*GetRecDataTreeName() const
AliMillePedeRecord*GetRecord() const
const Int_t*GetRegrouping() const
Float_tGetResCurInit() const
Float_tGetResCut() const
Int_tGetRGId(Int_t i) const
Long_tGetSelFirst() const
Long_tGetSelLast() const
Double_tGetSigmaPar(Int_t i) const
Double_t*GetSigmaPars() const
virtual const char*TObject::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
Bool_tGetUseRecordWeight() const
Int_tGlobalFit(Double_t* par = 0, Double_t* error = 0, Double_t* pull = 0)
Int_tGlobalFitIteration()
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
Bool_tImposeConsRecFile(const char* fname)
Bool_tImposeDataRecFile(const char* fname)
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
Bool_tInitConsRecStorage(Bool_t read = kFALSE)
Bool_tInitDataRecStorage(Bool_t read = kFALSE)
Int_tInitMille(int nGlo, int nLoc, Int_t lNStdDev = -1, double lResCut = -1., double lResCutInit = -1., const Int_t* regroup = 0)
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
static Bool_tIsGlobalMatSparse()
Bool_tTObject::IsOnHeap() const
Bool_tIsRecordAcceptable()
virtual Bool_tTObject::IsSortable() const
static Bool_tIsWeightSigma()
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AliMillePede2&operator=(const AliMillePede2&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
Int_tPrintGlobalParameters() const
virtual Int_tTObject::Read(const char* name)
Bool_tReadNextRecordConstraint()
Bool_tReadNextRecordData()
voidReadRecordConstraint(Long_t recID)
voidReadRecordData(Long_t recID)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidSaveRecordConstraint()
voidSaveRecordData()
voidSetAccRunList(const UInt_t* runs, Int_t nruns, const Float_t* wghList = 0)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetChi2CutFactor(Float_t v)
voidSetChi2CutRef(Float_t v)
voidSetConsRecFName(const char* flname)
voidSetDataRecFName(const char* flname)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetGlobalConstraint(const double* dergb, double val, double sigma = 0)
voidSetGlobalConstraint(const int* indgb, const double* dergb, int ngb, double val, double sigma = 0)
static voidSetGlobalMatSparse(Bool_t v = kTRUE)
voidSetGlobalParameters(Double_t* par)
voidSetInitPar(Int_t i, Double_t par)
voidSetInitPars(const Double_t* par)
static voidSetInvChol(Bool_t v = kTRUE)
Int_tSetIterations(double lChi2CutFac)
static voidSetIterSolverType(Int_t val = AliMinResSolve::kSolMinRes)
voidSetLocalEquation(double* dergb, double* derlc, double lMeas, double lSigma)
voidSetLocalEquation(int* indgb, double* dergb, int ngb, int* indlc, double* derlc, int nlc, double lMeas, double lSigma)
voidSetMinPntValid(Int_t n)
voidSetMinRecordLength(Int_t v = 1)
static voidSetMinResMaxIter(Int_t val = 2000)
static voidSetMinResPrecondType(Int_t tp = 0)
static voidSetMinResTol(Double_t val = 1e-12)
voidSetNGloPar(Int_t n)
static voidSetNKrylovV(Int_t val = 60)
voidSetNLocPar(Int_t n)
voidSetNMaxIterations(Int_t n = 10)
voidSetNonLinear(int index, Bool_t v = kTRUE)
voidSetNStdDev(Int_t n)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetParamGrID(Int_t grID, Int_t i)
voidSetParSigma(Int_t i, Double_t par)
voidSetRecConsBranchName(const char* name = 0)
voidSetRecConsTreeName(const char* name = 0)
voidSetRecDataBranchName(const char* name = 0)
voidSetRecDataTreeName(const char* name = 0)
voidSetRecordRun(Int_t run)
voidSetRecordWeight(double wgh)
voidSetRejRunList(const UInt_t* runs, Int_t nruns)
voidSetResCurInit(Float_t v)
voidSetResCut(Float_t v)
voidSetSelFirst(Long_t v)
voidSetSelLast(Long_t v)
voidSetSigmaPar(Int_t i, Double_t par)
voidSetSigmaPars(const Double_t* par)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetUseRecordWeight(Bool_t v = kTRUE)
static voidSetWeightSigma(Bool_t v = kTRUE)
voidSetWghScale(Double_t wOdd = 1, Double_t wEven = 1)
virtual voidShowMembers(TMemberInspector&)
Int_tSolveGlobalMatEq()
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
Bool_tIsZero(Double_t v, Double_t eps = 1e-16) const
Int_tLocalFit(double* localParams = 0)
voidTObject::MakeZombie()

Data Members

public:
enum { kFailed
kInvert
kNoInversion
kFixParID
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TArrayL*fAccRunListlist of runs to select (if any)
TArrayF*fAccRunListWghoptional weights for data of accepted runs (if any)
Int_t*fCGlo2Glo[fNGloPar] compressed ID to global ID buffer
Float_tfChi2CutFactorCut factor for chi2 cut to accept local fit
Float_tfChi2CutRefReference cut for chi2 cut to accept local fit
TFile*fConsRecFile! File of processed constraints records
TStringfConstrRecFNameName of File for constraints records
Bool_t*fConstrUsed! Flag for used constraints
Long_tfCurrRecConstrIDID of the current constraint record
Long_tfCurrRecDataIDID of the current data record
TStringfDataRecFNameName of File for data records
TFile*fDataRecFileFile of processed measurements records
Double_t*fDeltaPar[fNGloPar] Variation of global parameters
Double_t*fDiagCGlo[fNGloPar] Initial diagonal elements of C global matrix
Int_t*fFillIndex[fNGloPar] auxilary index array for fast matrix fill
Double_t*fFillValue[fNGloPar] auxilary value array for fast matrix fill
Int_t*fGlo2CGlo[fNGloPar] global ID to compressed ID buffer
Int_tfGloSolveStatusStatus of global solver at current step
Double_t*fInitPar[fNGloPar] Initial global parameters
Bool_t*fIsLinear[fNGloPar] Flag for linear parameters
Int_tfIterCurrent iteration
Bool_tfLocFitAddAdd contribution of carrent track (and not eliminate it)
AliMatrixSq*fMatCGloMatrix C global
AliRectMatrix*fMatCGloLocRectangular matrix C g*l
AliSymMatrix*fMatCLocMatrix C local
Int_tfMaxIterMaximum number of iterations
Int_tfMinPntValidmin number of points for global to vary
Int_tfMinRecordLengthignore shorter records
Int_tfNGloConstraintsNumber of constraint equations
Int_tfNGloFixNumber of globals fixed by user
Int_tfNGloParnumber of global parameters
Int_tfNGloParIninumber of global parameters before grouping
Int_tfNGloSizefinal size of the global matrix (NGloPar+NConstraints)
Int_tfNGroupsSetnumber of groups set
Int_tfNLagrangeConstraintsNumber of constraint equations requiring Lagrange multiplier
Long_tfNLocEquationsNumber of local equations
Long_tfNLocFitsNumber of local fits
Long_tfNLocFitsRejectedNumber of local fits rejected
Int_tfNLocParnumber of local parameters
Int_tfNStdDevNumber of standard deviations for chi2 cut
Int_t*fParamGrID[fNGloPar] group id for the every parameter
Int_t*fProcPnt[fNGloPar] N of processed points per global variable
TStringfRecConsBranchNameName of constraints records branch name
TStringfRecConsTreeNameName of constraints records tree
TStringfRecDataBranchNameName of data records branch name
TStringfRecDataTreeNameName of data records tree
Int_tfRecFileStatusstate of the record file (0-no, 1-read, 2-rw)
AliMillePedeRecord*fRecordBuffer of measurements records
TArrayL*fRejRunListlist of runs to reject (if any)
Float_tfResCutCut in residual for other iterartiona
Float_tfResCutInitCut in residual for first iterartion
Double_tfRunWghrun weight
Int_tfSelFirstevent selection start
Int_tfSelLastevent selection end
Double_t*fSigmaPar[fNGloPar] Sigma of allowed variation of global parameter
TTree*fTreeConstr! Tree of constraint records
TTree*fTreeDataTree of processed measurements records
Bool_tfUseRecordWeightforce or ignore the record weight
Double_t*fVecBGlo! Vector B global (parameters)
Double_t*fVecBLoc[fNLocPar] Vector B local (parameters)
Double_tfWghScl[2]optional rescaling for odd/even residual weights (see its usage in LocalFit)
static Bool_tfgInvCholInvert global matrix in Cholesky solver
static Bool_tfgIsMatGloSparseType of the global matrix (sparse ...)
static Int_tfgIterSoltype of iterative solution: MinRes or FGMRES
static Int_tfgMinResCondTypeType of the preconditioner for MinRes method
static Int_tfgMinResMaxIterMax number of iterations for the MinRes method
static Double_tfgMinResTolTolerance for MinRes solution
static Int_tfgNKrylovVsize of Krylov vectors buffer in FGMRES
static Bool_tfgWeightSigmaweight parameter constraint by statistics
const Int_t*fkReGroupoptional regrouping of parameters wrt ID's from the records

Class Charts

Inheritance Chart:
TObject
AliMillePede2

Function documentation

AliMillePede2()








AliMillePede2(const AliMillePede2& src)
~AliMillePede2()
 destructor
Int_t InitMille(int nGlo, int nLoc, Int_t lNStdDev = -1, double lResCut = -1., double lResCutInit = -1., const Int_t* regroup = 0)
 init all

Bool_t ImposeDataRecFile(const char* fname)
 set filename for records
Bool_t ImposeConsRecFile(const char* fname)
 set filename for constraints
Bool_t InitDataRecStorage(Bool_t read = kFALSE)
 initialize the buffer for processed measurements records

Bool_t InitConsRecStorage(Bool_t read = kFALSE)
 initialize the buffer for processed measurements records

void CloseDataRecStorage()
 close records file
void CloseConsRecStorage()
 close constraints file
Bool_t ReadNextRecordData()
 read next data record (if any)
Bool_t ReadNextRecordConstraint()
 read next constraint record (if any)
void SetRecordWeight(double wgh)
 assign weight
void SetRecordRun(Int_t run)
 assign run
void SetLocalEquation(double* dergb, double* derlc, double lMeas, double lSigma)
 assing derivs of loc.eq.
void SetLocalEquation(int* indgb, double* dergb, int ngb, int* indlc, double* derlc, int nlc, double lMeas, double lSigma)
 write data of single measurement. Note: the records ignore regrouping, store direct parameters
void SetGlobalConstraint(const double* dergb, double val, double sigma = 0)
 Define a constraint equation.
void SetGlobalConstraint(const int* indgb, const double* dergb, int ngb, double val, double sigma = 0)
 Define a constraint equation.
Int_t LocalFit(double* localParams = 0)
    Perform local parameters fit once all the local equations have been set
    -----------------------------------------------------------
    localParams = (if !=0) will contain the fitted track parameters and
    related errors

Int_t GlobalFit(Double_t* par = 0, Double_t* error = 0, Double_t* pull = 0)
 performs a requested number of global iterations
Int_t GlobalFitIteration()
 perform global parameters fit once all the local equations have been fitted

Int_t SolveGlobalMatEq()
 solve global matrix equation MatCGlob*X=VecBGlo and store the result in the VecBGlo


  printf("GlobalMatrix\n");
  fMatCGlo->Print("l");
  printf("RHS\n");
  for (int i=0;i<fNGloPar;i++) printf("%d %+e\n",i,fVecBGlo[i]);


Float_t Chi2DoFLim(int nSig, int nDoF) const
 return the limit in chi^2/nd for n sigmas stdev authorized
 Only n=1, 2, and 3 are expected in input
Int_t SetIterations(double lChi2CutFac)
 Number of iterations is calculated from lChi2CutFac
Double_t GetParError(int iPar) const
 return error for parameter iPar
Double_t GetPull(int i) const
 return pull for parameter iPar
Int_t PrintGlobalParameters() const
  Print the final results into the logfile
Bool_t IsRecordAcceptable()
 validate record according run lists set by the user
void SetRejRunList(const UInt_t* runs, Int_t nruns)
 set the list of runs to be rejected
void SetAccRunList(const UInt_t* runs, Int_t nruns, const Float_t* wghList = 0)
 set the list of runs to be selected
void SetInitPars(const Double_t* par)
 initialize parameters, account for eventual grouping
void SetSigmaPars(const Double_t* par)
 initialize sigmas, account for eventual grouping
void SetInitPar(Int_t i, Double_t par)
 initialize param, account for eventual grouping
void SetSigmaPar(Int_t i, Double_t par)
 initialize sigma, account for eventual grouping
void ReadRecordData(Long_t recID)
{fTreeData->GetEntry(recID); fCurrRecDataID=recID;}
void ReadRecordConstraint(Long_t recID)
{fTreeConstr->GetEntry(recID); fCurrRecConstrID=recID;}
void SaveRecordData()
void SaveRecordConstraint()
AliMillePede2& operator=(const AliMillePede2& )
{printf("Dummy\n"); return *this;}
Int_t GetNGloPar() const
{return fNGloPar;}
Int_t GetNGloParIni() const
{return fNGloParIni;}
const Int_t* GetRegrouping() const
{return fkReGroup;}
Int_t GetNLocPar() const
{return fNLocPar;}
Long_t GetNLocalEquations() const
{return fNLocEquations;}
Int_t GetCurrentIteration() const
{return fIter;}
Int_t GetNMaxIterations() const
{return fMaxIter;}
Int_t GetNStdDev() const
{return fNStdDev;}
Int_t GetNGlobalConstraints() const
Int_t GetNLagrangeConstraints() const
Long_t GetNLocalFits() const
{return fNLocFits;}
Long_t GetNLocalFitsRejected() const
Int_t GetNGlobalsFixed() const
{return fNGloFix;}
Int_t GetGlobalSolveStatus() const
{return fGloSolveStatus;}
Float_t GetChi2CutFactor() const
{return fChi2CutFactor;}
Float_t GetChi2CutRef() const
{return fChi2CutRef;}
Float_t GetResCurInit() const
{return fResCutInit;}
Float_t GetResCut() const
{return fResCut;}
Int_t GetMinPntValid() const
{return fMinPntValid;}
Int_t GetRGId(Int_t i) const
{return fkReGroup ? (fkReGroup[i]<0 ? -1:fkReGroup[i]) : i;}
Int_t GetProcessedPoints(Int_t i) const
{int ir=GetRGId(i); return ir<=0 ? 0:fProcPnt[ir];}
Int_t* GetProcessedPoints() const
{return fProcPnt;}
Int_t GetParamGrID(Int_t i) const
{int ir=GetRGId(i); return ir<=0 ? 0:fParamGrID[ir];}
AliMatrixSq* GetGlobalMatrix() const
{return fMatCGlo;}
AliSymMatrix* GetLocalMatrix() const
{return fMatCLoc;}
Double_t* GetGlobals() const
{return fVecBGlo;}
Double_t* GetDeltaPars() const
{return fDeltaPar;}
Double_t* GetInitPars() const
{return fInitPar;}
Double_t* GetSigmaPars() const
{return fSigmaPar;}
Bool_t* GetIsLinear() const
{return fIsLinear;}
Double_t GetFinalParam(int i) const
{int ir=GetRGId(i); return ir<0 ? 0:fDeltaPar[ir]+fInitPar[ir];}
Double_t GetFinalError(int i) const
{return GetParError(i);}
Double_t GetGlobal(Int_t i) const
{int ir=GetRGId(i); return ir<0 ? 0:fVecBGlo[ir];}
Double_t GetInitPar(Int_t i) const
{int ir=GetRGId(i); return ir<0 ? 0:fInitPar[ir];}
Double_t GetSigmaPar(Int_t i) const
{int ir=GetRGId(i); return ir<0 ? 0:fSigmaPar[ir];}
Bool_t GetIsLinear(Int_t i) const
{int ir=GetRGId(i); return ir<0 ? 0:fIsLinear[ir];}
Bool_t IsGlobalMatSparse()
Bool_t IsWeightSigma()
{return fgWeightSigma;}
void SetWghScale(Double_t wOdd = 1, Double_t wEven = 1)
{fWghScl[0] = wOdd; fWghScl[1] = wEven;}
void SetUseRecordWeight(Bool_t v = kTRUE)
Bool_t GetUseRecordWeight() const
void SetMinRecordLength(Int_t v = 1)
Int_t GetMinRecordLength() const
void SetParamGrID(Int_t grID, Int_t i)
{int ir=GetRGId(i); if(ir<0) return; fParamGrID[ir] = grID; if(fNGroupsSet<grID)fNGroupsSet=grID;}
void SetNGloPar(Int_t n)
{fNGloPar = n;}
void SetNLocPar(Int_t n)
{fNLocPar = n;}
void SetNMaxIterations(Int_t n = 10)
{fMaxIter = n;}
void SetNStdDev(Int_t n)
{fNStdDev = n;}
void SetChi2CutFactor(Float_t v)
void SetChi2CutRef(Float_t v)
void SetResCurInit(Float_t v)
void SetResCut(Float_t v)
{fResCut = v;}
void SetMinPntValid(Int_t n)
{fMinPntValid = n>0 ? n:1;}
void SetGlobalMatSparse(Bool_t v = kTRUE)
void SetWeightSigma(Bool_t v = kTRUE)
void SetInvChol(Bool_t v = kTRUE)
{fgInvChol = v;}
void SetMinResPrecondType(Int_t tp = 0)
void SetMinResTol(Double_t val = 1e-12)
{fgMinResTol = val;}
void SetMinResMaxIter(Int_t val = 2000)
void SetIterSolverType(Int_t val = AliMinResSolve::kSolMinRes)
{fgIterSol = val;}
void SetNKrylovV(Int_t val = 60)
{fgNKrylovV = val;}
Bool_t GetInvChol()
{return fgInvChol;}
Int_t GetMinResPrecondType()
Double_t GetMinResTol()
{return fgMinResTol;}
Int_t GetMinResMaxIter()
{return fgMinResMaxIter;}
Int_t GetIterSolverType()
{return fgIterSol;}
Int_t GetNKrylovV()
{return fgNKrylovV;}
void SetDataRecFName(const char* flname)
 manipilation with processed data and costraints records and its buffer
{fDataRecFName = flname;}
const Char_t* GetDataRecFName() const
{return fDataRecFName.Data();}
void SetConsRecFName(const char* flname)
{fConstrRecFName = flname;}
const Char_t* GetConsRecFName() const
{return fConstrRecFName.Data();}
void SetRecDataTreeName(const char* name = 0)
{fRecDataTreeName = name; if (fRecDataTreeName.IsNull()) fRecDataTreeName = "AliMillePedeRecords_Data";}
void SetRecConsTreeName(const char* name = 0)
{fRecConsTreeName = name; if (fRecConsTreeName.IsNull()) fRecConsTreeName = "AliMillePedeRecords_Consaints";}
void SetRecDataBranchName(const char* name = 0)
{fRecDataBranchName = name; if (fRecDataBranchName.IsNull()) fRecDataBranchName = "Record_Data";}
void SetRecConsBranchName(const char* name = 0)
{fRecConsBranchName = name; if (fRecConsBranchName.IsNull()) fRecConsBranchName = "Record_Consaints";}
const char* GetRecDataTreeName() const
{return fRecDataTreeName.Data();}
const char* GetRecConsTreeName() const
{return fRecConsTreeName.Data();}
const char* GetRecDataBranchName() const
{return fRecDataBranchName.Data();}
const char* GetRecConsBranchName() const
{return fRecConsBranchName.Data();}
AliMillePedeRecord* GetRecord() const
{return fRecord;}
Long_t GetSelFirst() const
{return fSelFirst;}
Long_t GetSelLast() const
{return fSelLast;}
void SetSelFirst(Long_t v)
{fSelFirst = v;}
void SetSelLast(Long_t v)
{fSelLast = v;}
void SetParSigma(Int_t i, Double_t par)
 aliases for compatibility with millipede1
{SetSigmaPar(i,par);}
void SetGlobalParameters(Double_t* par)
{SetInitPars(par);}
void SetNonLinear(int index, Bool_t v = kTRUE)
{int id = GetRGId(index); if (id<0) return; fIsLinear[id] = !v;}
Bool_t IsZero(Double_t v, Double_t eps = 1e-16) const
{return TMath::Abs(v)<eps;}