[u/mrichter/AliRoot.git] / STEER / AliTrackResidualsFast.cxx

/**************************************************************************
 * 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$ */

//-----------------------------------------------------------------
//   Implementation of the derived class for track residuals
//   based on linear chi2 minimization (in approximation of
//   small alignment angles and translations)
//
//-----------------------------------------------------------------

#include <TMath.h>
#include <TGeoMatrix.h>

#include "AliLog.h"
#include "AliAlignObj.h"
#include "AliTrackPointArray.h"
#include "AliTrackResidualsFast.h"

#include <TMatrixDSym.h>
#include <TMatrixDSymEigen.h>

ClassImp(AliTrackResidualsFast)

//______________________________________________________________________________
AliTrackResidualsFast::AliTrackResidualsFast():
  AliTrackResiduals(),
  fSumR(0)
{
  // Default constructor
  for (Int_t i = 0; i < 27; i++) fSum[i] = 0;
}

//______________________________________________________________________________
AliTrackResidualsFast::AliTrackResidualsFast(Int_t ntracks):
  AliTrackResiduals(ntracks),
  fSumR(0)
{
  // Constructor
  for (Int_t i = 0; i < 27; i++) fSum[i] = 0;
}
 
//______________________________________________________________________________
AliTrackResidualsFast::AliTrackResidualsFast(const AliTrackResidualsFast &res):
  AliTrackResiduals(res),
  fSumR(res.fSumR)
{
  // Copy constructor
  for (Int_t i = 0; i < 27; i++) fSum[i] = res.fSum[i];
}

//______________________________________________________________________________
AliTrackResidualsFast &AliTrackResidualsFast::operator= (const AliTrackResidualsFast& res)
{
  // Assignment operator
 ((AliTrackResiduals *)this)->operator=(res);
 for (Int_t i = 0; i < 27; i++) fSum[i] = res.fSum[i];
 fSumR = res.fSumR;

 return *this;
}

//______________________________________________________________________________
Bool_t AliTrackResidualsFast::Minimize()
{
  // Implementation of fast linear Chi2
  // based minimization of track residuals sum

  //  if(fBFixed[0]||fBFixed[1]||fBFixed[2]||fBFixed[3]||fBFixed[4]||fBFixed[5])
  //    AliError("Cannot yet fix parameters in this minimizer");


  for (Int_t i = 0; i < 27; i++) fSum[i] = 0;
  fSumR = 0;

  AliTrackPoint p1,p2;

  for (Int_t itrack = 0; itrack < fLast; itrack++) {
    if (!fVolArray[itrack] || !fTrackArray[itrack]) continue;
    for (Int_t ipoint = 0; ipoint < fVolArray[itrack]->GetNPoints(); ipoint++) {
      fVolArray[itrack]->GetPoint(p1,ipoint);
      fTrackArray[itrack]->GetPoint(p2,ipoint);
      AddPoints(p1,p2);
    }
  }

  return Update();

  // debug info
//   Float_t chi2 = 0;
//   for (Int_t itrack = 0; itrack < fLast; itrack++) {
//     if (!fVolArray[itrack] || !fTrackArray[itrack]) continue;
//     for (Int_t ipoint = 0; ipoint < fVolArray[itrack]->GetNPoints(); ipoint++) {
//       fVolArray[itrack]->GetPoint(p1,ipoint);
//       fAlignObj->Transform(p1);
//       fTrackArray[itrack]->GetPoint(p2,ipoint);
//       Float_t residual = p2.GetResidual(p1,kFALSE);
//       chi2 += residual;
//     }
//   }
//   printf("Final chi2 = %f\n",chi2);
}

//______________________________________________________________________________
void AliTrackResidualsFast::AddPoints(AliTrackPoint &p, AliTrackPoint &pprime)
{
  // Update the sums used for
  // the linear chi2 minimization
  Float_t xyz[3],xyzp[3];
  Float_t cov[6],covp[6];
  p.GetXYZ(xyz,cov); pprime.GetXYZ(xyzp,covp);
  TMatrixDSym mcov(3);
  mcov(0,0) = cov[0]; mcov(0,1) = cov[1]; mcov(0,2) = cov[2];
  mcov(1,0) = cov[1]; mcov(1,1) = cov[3]; mcov(1,2) = cov[4];
  mcov(2,0) = cov[2]; mcov(2,1) = cov[4]; mcov(2,2) = cov[5];
  TMatrixDSym mcovp(3);
  mcovp(0,0) = covp[0]; mcovp(0,1) = covp[1]; mcovp(0,2) = covp[2];
  mcovp(1,0) = covp[1]; mcovp(1,1) = covp[3]; mcovp(1,2) = covp[4];
  mcovp(2,0) = covp[2]; mcovp(2,1) = covp[4]; mcovp(2,2) = covp[5];
  TMatrixDSym msum = mcov + mcovp;


  msum.Invert();


  if (!msum.IsValid()) return;

  TMatrixD        sums(3,1);
  sums(0,0) = (xyzp[0]-xyz[0]); 
  sums(1,0) = (xyzp[1]-xyz[1]);
  sums(2,0) = (xyzp[2]-xyz[2]);   
  TMatrixD sumst = sums.T(); sums.T();

  TMatrixD        mf(3,6);
  mf(0,0) = 1;      mf(1,0) = 0;       mf(2,0) = 0;
  mf(0,1) = 0;      mf(1,1) = 1;       mf(2,1) = 0;
  mf(0,2) = 0;      mf(1,2) = 0;       mf(2,2) = 1;
  mf(0,3) = 0;      mf(1,3) = -xyz[2]; mf(2,3) = xyz[1];
  mf(0,4) = xyz[2]; mf(1,4) = 0;       mf(2,4) =-xyz[0];
  mf(0,5) =-xyz[1]; mf(1,5) = xyz[0];  mf(2,5) = 0;

  for(Int_t j=0;j<6;j++){
    if(fBFixed[j]==kTRUE){
      mf(0,j)=0.;mf(1,j)=0.;mf(2,j)=0.;
    }
  }

  TMatrixD        mft = mf.T(); mf.T();
  TMatrixD sums2 = mft * msum * sums;

  TMatrixD smatrix = mft * msum * mf;

  fSum[0] += smatrix(0,0);
  fSum[1] += smatrix(0,1);
  fSum[2] += smatrix(0,2);
  fSum[3] += smatrix(0,3);
  fSum[4] += smatrix(0,4);
  fSum[5] += smatrix(0,5);
  fSum[6] += smatrix(1,1);
  fSum[7] += smatrix(1,2);
  fSum[8] += smatrix(1,3);
  fSum[9] += smatrix(1,4);
  fSum[10]+= smatrix(1,5);
  fSum[11]+= smatrix(2,2);
  fSum[12]+= smatrix(2,3);
  fSum[13]+= smatrix(2,4);
  fSum[14]+= smatrix(2,5);
  fSum[15]+= smatrix(3,3);
  fSum[16]+= smatrix(3,4);
  fSum[17]+= smatrix(3,5);
  fSum[18]+= smatrix(4,4);
  fSum[19]+= smatrix(4,5);
  fSum[20]+= smatrix(5,5);
  fSum[21] += sums2(0,0);
  fSum[22] += sums2(1,0);
  fSum[23] += sums2(2,0);
  fSum[24] += sums2(3,0);
  fSum[25] += sums2(4,0);
  fSum[26] += sums2(5,0);

  TMatrixD  tmp = sumst * msum * sums;
  fSumR += tmp(0,0);

  fNdf += 3;
}

//______________________________________________________________________________
Bool_t AliTrackResidualsFast::Update()
{
  // Find the alignment parameters
  // by using the already accumulated
  // sums
  TMatrixDSym     smatrix(6);
  TMatrixD        sums(1,6);

  smatrix(0,0) = fSum[0];
  smatrix(0,1) = smatrix(1,0) = fSum[1];
  smatrix(0,2) = smatrix(2,0) = fSum[2];
  smatrix(0,3) = smatrix(3,0) = fSum[3];
  smatrix(0,4) = smatrix(4,0) = fSum[4];
  smatrix(0,5) = smatrix(5,0) = fSum[5];
  smatrix(1,1) = fSum[6];
  smatrix(1,2) = smatrix(2,1) = fSum[7];
  smatrix(1,3) = smatrix(3,1) = fSum[8];
  smatrix(1,4) = smatrix(4,1) = fSum[9];
  smatrix(1,5) = smatrix(5,1) = fSum[10];
  smatrix(2,2) = fSum[11];
  smatrix(2,3) = smatrix(3,2) = fSum[12];
  smatrix(2,4) = smatrix(4,2) = fSum[13];
  smatrix(2,5) = smatrix(5,2) = fSum[14];
  smatrix(3,3) = fSum[15];
  smatrix(3,4) = smatrix(4,3) = fSum[16];
  smatrix(3,5) = smatrix(5,3) = fSum[17];
  smatrix(4,4) = fSum[18];
  smatrix(4,5) = smatrix(5,4) = fSum[19];
  smatrix(5,5) = fSum[20];

  sums(0,0)    = fSum[21]; sums(0,1) = fSum[22]; sums(0,2) = fSum[23];
  sums(0,3)    = fSum[24]; sums(0,4) = fSum[25]; sums(0,5) = fSum[26];

  
  Int_t fixedparamat[6]={0,0,0,0,0,0}; 
  const Int_t unfixedparam=GetNFreeParam();
  Int_t position[6],last=0;//position is of size 6 but only unfiexedparam indeces will be used
  
  if(fBFixed[0]==kTRUE){
    fixedparamat[0]=1;
  }
  else {
    position[0]=0;
    last++;
  }
  
  for(Int_t j=1;j<6;j++){
    if(fBFixed[j]==kTRUE){
      fixedparamat[j]=fixedparamat[j-1]+1;
    }
    else {
      fixedparamat[j]=fixedparamat[j-1];
      position[last]=j;
      last++;
    }
  }

  TMatrixDSym smatrixRedu(unfixedparam);
  for(Int_t i=0;i<unfixedparam;i++){
    for(Int_t j=0;j<unfixedparam;j++){
      smatrixRedu(i,j)=smatrix(position[i],position[j]);
    }
  }
  
  //  smatrixRedu.Print();
  smatrixRedu.Invert();
  
  if (!smatrixRedu.IsValid()) {
    printf("Minimization Failed! \n");
    return kFALSE;
  }

  TMatrixDSym smatrixUp(6);
  for(Int_t i=0;i<6;i++){
    for(Int_t j=0;j<6;j++){
      if(fBFixed[i]==kTRUE||fBFixed[j]==kTRUE)smatrixUp(i,j)=0.;
      else smatrixUp(i,j)=smatrixRedu(i-fixedparamat[i],j-fixedparamat[j]);
    }
  }
  
  Double_t covmatrarray[21];
  
  for(Int_t i=0;i<6;i++){
      for(Int_t j=0;j<=i;j++){
	if(fBFixed[i]==kFALSE&&fBFixed[j]==kFALSE){
	  if(TMath::Abs(smatrixUp(i,j)/TMath::Sqrt(TMath::Abs(smatrixUp(i,i)*smatrixUp(j,j))))>1.01)printf("Too large Correlation number!\n");
	}
	covmatrarray[i*(i+1)/2+j]=smatrixUp(i,j);
      }
  }
    
  TMatrixD res = sums*smatrixUp;
  fAlignObj->SetPars(res(0,0),res(0,1),res(0,2),
		     TMath::RadToDeg()*res(0,3),
		     TMath::RadToDeg()*res(0,4),
		     TMath::RadToDeg()*res(0,5));
  
  fAlignObj->SetCorrMatrix(covmatrarray);
  TMatrixD  tmp = res*sums.T();
  fChi2 = fSumR - tmp(0,0);
  fNdf -= unfixedparam;
  
  return kTRUE;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	//-----------------------------------------------------------------
	19	// Implementation of the derived class for track residuals
	20	// based on linear chi2 minimization (in approximation of
	21	// small alignment angles and translations)
	22	//
	23	//-----------------------------------------------------------------
	24
	25	#include <TMath.h>
	26	#include <TGeoMatrix.h>
	27
	28	#include "AliLog.h"
	29	#include "AliAlignObj.h"
	30	#include "AliTrackPointArray.h"
	31	#include "AliTrackResidualsFast.h"
	32
	33	#include <TMatrixDSym.h>
	34	#include <TMatrixDSymEigen.h>
	35
	36	ClassImp(AliTrackResidualsFast)
	37
	38	//______________________________________________________________________________
	39	AliTrackResidualsFast::AliTrackResidualsFast():
	40	AliTrackResiduals(),
	41	fSumR(0)
	42	{
	43	// Default constructor
	44	for (Int_t i = 0; i < 27; i++) fSum[i] = 0;
	45	}
	46
	47	//______________________________________________________________________________
	48	AliTrackResidualsFast::AliTrackResidualsFast(Int_t ntracks):
	49	AliTrackResiduals(ntracks),
	50	fSumR(0)
	51	{
	52	// Constructor
	53	for (Int_t i = 0; i < 27; i++) fSum[i] = 0;
	54	}
	55
	56	//______________________________________________________________________________
	57	AliTrackResidualsFast::AliTrackResidualsFast(const AliTrackResidualsFast &res):
	58	AliTrackResiduals(res),
	59	fSumR(res.fSumR)
	60	{
	61	// Copy constructor
	62	for (Int_t i = 0; i < 27; i++) fSum[i] = res.fSum[i];
	63	}
	64
	65	//______________________________________________________________________________
	66	AliTrackResidualsFast &AliTrackResidualsFast::operator= (const AliTrackResidualsFast& res)
	67	{
	68	// Assignment operator
	69	((AliTrackResiduals *)this)->operator=(res);
	70	for (Int_t i = 0; i < 27; i++) fSum[i] = res.fSum[i];
	71	fSumR = res.fSumR;
	72
	73	return *this;
	74	}
	75
	76	//______________________________________________________________________________
	77	Bool_t AliTrackResidualsFast::Minimize()
	78	{
	79	// Implementation of fast linear Chi2
	80	// based minimization of track residuals sum
	81
	82	// if(fBFixed[0]\|\|fBFixed[1]\|\|fBFixed[2]\|\|fBFixed[3]\|\|fBFixed[4]\|\|fBFixed[5])
	83	// AliError("Cannot yet fix parameters in this minimizer");
	84
	85
	86	for (Int_t i = 0; i < 27; i++) fSum[i] = 0;
	87	fSumR = 0;
	88
	89	AliTrackPoint p1,p2;
	90
	91	for (Int_t itrack = 0; itrack < fLast; itrack++) {
	92	if (!fVolArray[itrack] \|\| !fTrackArray[itrack]) continue;
	93	for (Int_t ipoint = 0; ipoint < fVolArray[itrack]->GetNPoints(); ipoint++) {
	94	fVolArray[itrack]->GetPoint(p1,ipoint);
	95	fTrackArray[itrack]->GetPoint(p2,ipoint);
	96	AddPoints(p1,p2);
	97	}
	98	}
	99
	100	return Update();
	101
	102	// debug info
	103	// Float_t chi2 = 0;
	104	// for (Int_t itrack = 0; itrack < fLast; itrack++) {
	105	// if (!fVolArray[itrack] \|\| !fTrackArray[itrack]) continue;
	106	// for (Int_t ipoint = 0; ipoint < fVolArray[itrack]->GetNPoints(); ipoint++) {
	107	// fVolArray[itrack]->GetPoint(p1,ipoint);
	108	// fAlignObj->Transform(p1);
	109	// fTrackArray[itrack]->GetPoint(p2,ipoint);
	110	// Float_t residual = p2.GetResidual(p1,kFALSE);
	111	// chi2 += residual;
	112	// }
	113	// }
	114	// printf("Final chi2 = %f\n",chi2);
	115	}
	116
	117	//______________________________________________________________________________
	118	void AliTrackResidualsFast::AddPoints(AliTrackPoint &p, AliTrackPoint &pprime)
	119	{
	120	// Update the sums used for
	121	// the linear chi2 minimization
	122	Float_t xyz[3],xyzp[3];
	123	Float_t cov[6],covp[6];
	124	p.GetXYZ(xyz,cov); pprime.GetXYZ(xyzp,covp);
	125	TMatrixDSym mcov(3);
	126	mcov(0,0) = cov[0]; mcov(0,1) = cov[1]; mcov(0,2) = cov[2];
	127	mcov(1,0) = cov[1]; mcov(1,1) = cov[3]; mcov(1,2) = cov[4];
	128	mcov(2,0) = cov[2]; mcov(2,1) = cov[4]; mcov(2,2) = cov[5];
	129	TMatrixDSym mcovp(3);
	130	mcovp(0,0) = covp[0]; mcovp(0,1) = covp[1]; mcovp(0,2) = covp[2];
	131	mcovp(1,0) = covp[1]; mcovp(1,1) = covp[3]; mcovp(1,2) = covp[4];
	132	mcovp(2,0) = covp[2]; mcovp(2,1) = covp[4]; mcovp(2,2) = covp[5];
	133	TMatrixDSym msum = mcov + mcovp;
	134
	135
	136	msum.Invert();
	137
	138
	139	if (!msum.IsValid()) return;
	140
	141	TMatrixD sums(3,1);
	142	sums(0,0) = (xyzp[0]-xyz[0]);
	143	sums(1,0) = (xyzp[1]-xyz[1]);
	144	sums(2,0) = (xyzp[2]-xyz[2]);
	145	TMatrixD sumst = sums.T(); sums.T();
	146
	147	TMatrixD mf(3,6);
	148	mf(0,0) = 1; mf(1,0) = 0; mf(2,0) = 0;
	149	mf(0,1) = 0; mf(1,1) = 1; mf(2,1) = 0;
	150	mf(0,2) = 0; mf(1,2) = 0; mf(2,2) = 1;
	151	mf(0,3) = 0; mf(1,3) = -xyz[2]; mf(2,3) = xyz[1];
	152	mf(0,4) = xyz[2]; mf(1,4) = 0; mf(2,4) =-xyz[0];
	153	mf(0,5) =-xyz[1]; mf(1,5) = xyz[0]; mf(2,5) = 0;
	154
	155	for(Int_t j=0;j<6;j++){
	156	if(fBFixed[j]==kTRUE){
	157	mf(0,j)=0.;mf(1,j)=0.;mf(2,j)=0.;
	158	}
	159	}
	160
	161	TMatrixD mft = mf.T(); mf.T();
	162	TMatrixD sums2 = mft * msum * sums;
	163
	164	TMatrixD smatrix = mft * msum * mf;
	165
	166	fSum[0] += smatrix(0,0);
	167	fSum[1] += smatrix(0,1);
	168	fSum[2] += smatrix(0,2);
	169	fSum[3] += smatrix(0,3);
	170	fSum[4] += smatrix(0,4);
	171	fSum[5] += smatrix(0,5);
	172	fSum[6] += smatrix(1,1);
	173	fSum[7] += smatrix(1,2);
	174	fSum[8] += smatrix(1,3);
	175	fSum[9] += smatrix(1,4);
	176	fSum[10]+= smatrix(1,5);
	177	fSum[11]+= smatrix(2,2);
	178	fSum[12]+= smatrix(2,3);
	179	fSum[13]+= smatrix(2,4);
	180	fSum[14]+= smatrix(2,5);
	181	fSum[15]+= smatrix(3,3);
	182	fSum[16]+= smatrix(3,4);
	183	fSum[17]+= smatrix(3,5);
	184	fSum[18]+= smatrix(4,4);
	185	fSum[19]+= smatrix(4,5);
	186	fSum[20]+= smatrix(5,5);
	187	fSum[21] += sums2(0,0);
	188	fSum[22] += sums2(1,0);
	189	fSum[23] += sums2(2,0);
	190	fSum[24] += sums2(3,0);
	191	fSum[25] += sums2(4,0);
	192	fSum[26] += sums2(5,0);
	193
	194	TMatrixD tmp = sumst * msum * sums;
	195	fSumR += tmp(0,0);
	196
	197	fNdf += 3;
	198	}
	199
	200	//______________________________________________________________________________
	201	Bool_t AliTrackResidualsFast::Update()
	202	{
	203	// Find the alignment parameters
	204	// by using the already accumulated
	205	// sums
	206	TMatrixDSym smatrix(6);
	207	TMatrixD sums(1,6);
	208
	209	smatrix(0,0) = fSum[0];
	210	smatrix(0,1) = smatrix(1,0) = fSum[1];
	211	smatrix(0,2) = smatrix(2,0) = fSum[2];
	212	smatrix(0,3) = smatrix(3,0) = fSum[3];
	213	smatrix(0,4) = smatrix(4,0) = fSum[4];
	214	smatrix(0,5) = smatrix(5,0) = fSum[5];
	215	smatrix(1,1) = fSum[6];
	216	smatrix(1,2) = smatrix(2,1) = fSum[7];
	217	smatrix(1,3) = smatrix(3,1) = fSum[8];
	218	smatrix(1,4) = smatrix(4,1) = fSum[9];
	219	smatrix(1,5) = smatrix(5,1) = fSum[10];
	220	smatrix(2,2) = fSum[11];
	221	smatrix(2,3) = smatrix(3,2) = fSum[12];
	222	smatrix(2,4) = smatrix(4,2) = fSum[13];
	223	smatrix(2,5) = smatrix(5,2) = fSum[14];
	224	smatrix(3,3) = fSum[15];
	225	smatrix(3,4) = smatrix(4,3) = fSum[16];
	226	smatrix(3,5) = smatrix(5,3) = fSum[17];
	227	smatrix(4,4) = fSum[18];
	228	smatrix(4,5) = smatrix(5,4) = fSum[19];
	229	smatrix(5,5) = fSum[20];
	230
	231	sums(0,0) = fSum[21]; sums(0,1) = fSum[22]; sums(0,2) = fSum[23];
	232	sums(0,3) = fSum[24]; sums(0,4) = fSum[25]; sums(0,5) = fSum[26];
	233
	234
	235	Int_t fixedparamat[6]={0,0,0,0,0,0};
	236	const Int_t unfixedparam=GetNFreeParam();
	237	Int_t position[6],last=0;//position is of size 6 but only unfiexedparam indeces will be used
	238
	239	if(fBFixed[0]==kTRUE){
	240	fixedparamat[0]=1;
	241	}
	242	else {
	243	position[0]=0;
	244	last++;
	245	}
	246
	247	for(Int_t j=1;j<6;j++){
	248	if(fBFixed[j]==kTRUE){
	249	fixedparamat[j]=fixedparamat[j-1]+1;
	250	}
	251	else {
	252	fixedparamat[j]=fixedparamat[j-1];
	253	position[last]=j;
	254	last++;
	255	}
	256	}
	257
	258	TMatrixDSym smatrixRedu(unfixedparam);
	259	for(Int_t i=0;i<unfixedparam;i++){
	260	for(Int_t j=0;j<unfixedparam;j++){
	261	smatrixRedu(i,j)=smatrix(position[i],position[j]);
	262	}
	263	}
	264
	265	// smatrixRedu.Print();
	266	smatrixRedu.Invert();
	267
	268	if (!smatrixRedu.IsValid()) {
	269	printf("Minimization Failed! \n");
	270	return kFALSE;
	271	}
	272
	273	TMatrixDSym smatrixUp(6);
	274	for(Int_t i=0;i<6;i++){
	275	for(Int_t j=0;j<6;j++){
	276	if(fBFixed[i]==kTRUE\|\|fBFixed[j]==kTRUE)smatrixUp(i,j)=0.;
	277	else smatrixUp(i,j)=smatrixRedu(i-fixedparamat[i],j-fixedparamat[j]);
	278	}
	279	}
	280
	281	Double_t covmatrarray[21];
	282
	283	for(Int_t i=0;i<6;i++){
	284	for(Int_t j=0;j<=i;j++){
	285	if(fBFixed[i]==kFALSE&&fBFixed[j]==kFALSE){
	286	if(TMath::Abs(smatrixUp(i,j)/TMath::Sqrt(TMath::Abs(smatrixUp(i,i)*smatrixUp(j,j))))>1.01)printf("Too large Correlation number!\n");
	287	}
	288	covmatrarray[i*(i+1)/2+j]=smatrixUp(i,j);
	289	}
	290	}
	291
	292	TMatrixD res = sums*smatrixUp;
	293	fAlignObj->SetPars(res(0,0),res(0,1),res(0,2),
	294	TMath::RadToDeg()*res(0,3),
	295	TMath::RadToDeg()*res(0,4),
	296	TMath::RadToDeg()*res(0,5));
	297
	298	fAlignObj->SetCorrMatrix(covmatrarray);
	299	TMatrixD tmp = res*sums.T();
	300	fChi2 = fSumR - tmp(0,0);
	301	fNdf -= unfixedparam;
	302
	303	return kTRUE;
	304	}
	305
	306
	307