[u/mrichter/AliRoot.git] / TPC / AliTPCAlign.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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.3  2007/10/22 14:20:25  kowal2
Hardwired "ideal" coordinates replaced with those from the DCDB.
Corrected bug in SetDebug method

Revision 1.2  2007/10/03 09:27:50  marian
Extra semicolon removed (Marian)

Revision 1.1  2007/10/01 14:12:45  kowal2
Class creating the aligmnent object fro the surveyor measurements.

*/ 

//
//  Creates the TPC align object
//

#include "AliTPCAlign.h"
#include "AliSurveyPoint.h"
#include "AliSurveyPoint.h"
//
#include "TROOT.h"
#include "Riostream.h"
#include "TFile.h"
#include "TMath.h"
#include "TSystem.h"
#include "AliSurveyObj.h"
#include "AliSurveyPoint.h"
#include "AliAlignObjParams.h"
#include "AliCDBStorage.h"
#include <TClonesArray.h>
#include <TFile.h>
#include "AliLog.h"
#include "AliCDBManager.h"

using std::cout;
using std::endl;
ClassImp(AliTPCAlign)

AliTPCAlign::AliTPCAlign() :
  TObject(),
  fFileLoc(0x0),
  fFileGlob(0x0),
  fTPCAlignObj(0x0),
  fX(),
  fA(),
  fY(),
  fDebug(0)
{
  //
  //  default constructor
  //
}   
//________________________________________________________________________
AliTPCAlign::AliTPCAlign(Int_t reportloc, Int_t reportglob) :
  TObject(),
  fFileLoc(0x0),
  fFileGlob(0x0),
  fTPCAlignObj(0x0),
  fX(6,1),
  fA(24,6),
  fY(24,1),
  fDebug(0)
{
  //
  // constructor - defines data files
  //
  fFileLoc = new Char_t[80];
  fFileGlob = new Char_t[80];
  Char_t path[50];
  //sprintf(path,gSystem->Getenv("ALICE_ROOT")); 
  snprintf(path,50,"%s",gSystem->Getenv("ALICE_ROOT"));
  //
  //sprintf(fFileLoc,"%s/TPC/Survey_%d_TPC.txt",path,reportloc);
  snprintf(fFileLoc,80,"%s/TPC/Survey_%d_TPC.txt",path,reportloc);
  //sprintf(fFileGlob,"%s/TPC/Survey_%d_TPC.txt",path,reportglob);
  snprintf(fFileGlob,80,"%s/TPC/Survey_%d_TPC.txt",path,reportglob);
  //

}
//_________________________________________________________________________
AliTPCAlign::AliTPCAlign(const AliTPCAlign &align) :
  TObject(),
  fFileLoc(0x0),
  fFileGlob(0x0),
  fTPCAlignObj(0x0),
  fX(),
  fA(),
  fY(),
  fDebug(0)
{
  //
  //  copy constructor - dummy
  //
  fDebug = align.fDebug;
}
//__________________________________________________________________________
AliTPCAlign & AliTPCAlign::operator =(const AliTPCAlign & align)
{
  //
  // assignment operator - dummy
  //
  if(this!=&align){
    fDebug=align.fDebug;
  }
  return (*this);
}

//__________________________________________________________________________
AliTPCAlign::~AliTPCAlign(){
  //
  // destructor
  //
  if(fTPCAlignObj) delete fTPCAlignObj;
}
//__________________________________________________________________________
Bool_t AliTPCAlign::LoadSurveyData(){
  //
  // for a time being it loads from the local file the surveyed point
  // and has the ideal points hardwired. I am waiting until Ricardo
  // completes his job
  // 

 AliSurveyObj * s1 = new AliSurveyObj();
 s1->FillFromLocalFile(fFileGlob);
 //
 Int_t numberPoints = 8;
 //
 TString pointNames[8] = {"T1Final_R04241","T1Final_R05241","T1Final_R06241",
                          "T1Final_R07241","T1Final_R08241","T1Final_R10241",
                          "T1Final_R11241","T1Final_R12241"};
 //
 Float_t surveyedPoints[8][3];
 AliSurveyPoint *currPoint;
 //
 for(Int_t i=0;i<numberPoints;i++){
   currPoint=0;
   currPoint = (AliSurveyPoint *) s1->GetData()->FindObject(pointNames[i]);
   //
   if(currPoint){
     surveyedPoints[i][0]=currPoint->GetX();
     surveyedPoints[i][1]=currPoint->GetY();
     surveyedPoints[i][2]=currPoint->GetZ();
     if(fDebug)
     Printf("INFO: Point \"%s\" coordinates read.", pointNames[i].Data());
   }
   else {
     if(fDebug){
    Printf("ERROR: Essential point missing: \"%s\"", pointNames[i].Data());
    return 1;
     }
   }  
 }
 //
 //  Ideal points
 //
 Float_t idealPoints[8][3];
 //
 AliSurveyObj * s2 = new AliSurveyObj();
 s2->FillFromLocalFile(fFileLoc);
 //
 TString pointNamesL[8] ={"R04","R05","R06","R07","R08","R10","R11","R12"};
 //
  AliSurveyPoint *currPointL;
  //
 for(Int_t i=0;i<numberPoints;i++){
   currPointL=0;
   currPointL = (AliSurveyPoint *) s2->GetData()->FindObject(pointNamesL[i]);
   if(currPointL){
     idealPoints[i][0]=currPointL->GetY();
     idealPoints[i][1]=currPointL->GetZ();
     idealPoints[i][2]=currPointL->GetX();
          if(fDebug)
     Printf("INFO: Point \"%s\" coordinates read.", pointNamesL[i].Data());
   }
   else{
     if(fDebug){
    Printf("ERROR: Essential point missing: \"%s\"", pointNamesL[i].Data());
    return 1; }
   }
 }
 //
 // Create and fill matrices a & y
 //
 for(Int_t i = 0;i<numberPoints;i++){
   for(Int_t j=0;j<3;j++){
     fY(i*3+j,0)=surveyedPoints[i][j]-idealPoints[i][j];

   }
 }
 fA.Zero(); 
 //
 //
 // setting matrix a
 //
 for(Int_t i=0;i<numberPoints;i++){
   fA(3*i,0)=    -idealPoints[i][1];
   fA(3*i,1)=    idealPoints[i][2];
   fA(3*i,3)=1.; 
   fA(3*i+1,0)=    idealPoints[i][0];
   fA(3*i+1,2)=    -idealPoints[i][2];
   fA(3*i+1,4)=    1.;
   fA(3*i+2,1)=   -idealPoints[i][0];
   fA(3*i+2,2)=   idealPoints[i][1];
   fA(3*i+2,5)=1.; 
 }
 //
 delete s1;
 //
 return 0;
}
//_________________________________________________________________
Double_t AliTPCAlign::ComputeTransform(){
  //
  // Here simple matrix operations for the linear least square
  // The trigonometric function sin is approximated by the angle
  // and the cos by "1", because angles are very small (Y-convention!)
  // This secures the linearity of the problem
  // This method returns a sum of squares of residuals
  //
  TMatrixD tt1(TMatrixD::kInverted,(TMatrixD(fA,TMatrixD::kTransposeMult,fA)));
  fX=TMatrixD(tt1,TMatrixD::kMult,TMatrixD(fA,TMatrixD::kTransposeMult,fY));
  //
 TMatrixD Unit(24,24);
 Unit.UnitMatrix();
 TMatrixD xxt1(TMatrixD::kInverted,TMatrixD(fA,TMatrixD::kTransposeMult,fA));
 TMatrixD t(fA,TMatrixD::kMult,TMatrixD(xxt1,TMatrixD::kMultTranspose,fA));
 TMatrixD t2(Unit,TMatrixD::kMinus,t);
 TMatrixD chi2(fY,TMatrixD::kTransposeMult,TMatrixD(t2,TMatrixD::kMult,fY));
 //

 return chi2(0,0);
 	    
}
//_______________________________________________________________________
void AliTPCAlign::CreateAlignObj(){
  //
  // This method creates AliAlignObj and fills it with Euler angles
  // and shifts. The units are degrees and cm.
  // 
 fTPCAlignObj = new AliAlignObjParams();
 fTPCAlignObj->SetSymName("ALIC_1/TPC_M_1");
 fTPCAlignObj->SetVolUID(0);
 Double_t raddeg = TMath::RadToDeg();
 Double_t phi,theta,psi;
 //
 phi=fX(0,0)*raddeg;
 theta=fX(1,0)*raddeg;
 psi=fX(2,0)*raddeg;
 //
 Double_t dx,dy,dz;
 dx=fX(3,0)*100.;
 dy=fX(4,0)*100.;
 dz=fX(5,0)*100.;
 fTPCAlignObj->SetRotation(psi,theta,phi);
 fTPCAlignObj->SetTranslation(dx,dy,dz);
 fTPCAlignObj->Print("");
}
//______________________________________________________________________
void AliTPCAlign::Run(){
  //
  // runs the full chain
  //
  SetDebug(0);
  Bool_t flag = LoadSurveyData();
  if(flag) {
    cout<<"Missing points"<<endl;
    return;
  }
  Double_t chi2 = ComputeTransform();
  if(chi2>0.01) return;
  CreateAlignObj();
  StoreAlignObj();
  //
}
//_________________________________________________________________________
void AliTPCAlign::StoreAlignObj(){
  //
AliCDBManager* cdb = AliCDBManager::Instance();
 if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
 //
TClonesArray *array = new TClonesArray("AliAlignObjParams",1);
//
 Double_t shifts[3];
 Double_t rots[3];
 //
 fTPCAlignObj->GetPars(shifts,rots);
 new((*array)[0]) AliAlignObjParams(fTPCAlignObj->GetSymName(),0,shifts[0],
                   shifts[1],shifts[2],rots[0],rots[1],rots[2],kTRUE);

//
// storing either in the OCDB or local file
//
  if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
    // save on file
    const char* filename = "TPCSurveyMisalignment.root";
    Char_t fullname[80];
    //sprintf(fullname,"%s/TPC/%s",gSystem->Getenv("ALICE_ROOT"),filename);
    snprintf(fullname,80,"%s/TPC/%s",gSystem->Getenv("ALICE_ROOT"),filename);
    TFile *f = new TFile(fullname,"RECREATE");
    if(!f){
      AliError("cannot open file for output\n");
      return;
    }
    AliInfo(Form("Saving alignment objects to the file %s", filename));
    f->cd();
    f->WriteObject(array,"TPCAlignObjs","kSingleKey");
    f->Close();
  }else{
    // save in CDB storage
    AliCDBStorage* storage;
    //
   TString Storage = gSystem->Getenv("STORAGE");
    if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
      AliError(Form(
      "STORAGE variable set to %s is not valid. Exiting\n",Storage.Data()));
      return;
    }
    storage = cdb->GetStorage(Storage.Data());
    if(!storage){
      AliError(Form("Unable to open storage %s\n",Storage.Data()));
      return;
    }
    //
    AliCDBMetaData* md = new AliCDBMetaData();
    md->SetResponsible("Marek Kowalski");
    md->SetComment("Full misalignment of entire TPC from surveyors");
    AliCDBId id("TPC/Align/Data",0,AliCDBRunRange::Infinity());
    storage->Put(array,id,md);
  }

}
Commit	Line	Data
2574314d	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	/*
	17	$Log$
68e43693	18	Revision 1.3 2007/10/22 14:20:25 kowal2
	19	Hardwired "ideal" coordinates replaced with those from the DCDB.
	20	Corrected bug in SetDebug method
	21
3e3d6422	22	Revision 1.2 2007/10/03 09:27:50 marian
	23	Extra semicolon removed (Marian)
	24
dd89d4d2	25	Revision 1.1 2007/10/01 14:12:45 kowal2
	26	Class creating the aligmnent object fro the surveyor measurements.
	27
2574314d	28	*/
	29
	30	//
	31	// Creates the TPC align object
	32	//
	33
	34	#include "AliTPCAlign.h"
68e43693	35	#include "AliSurveyPoint.h"
68e43693	36	#include "AliSurveyPoint.h"
2574314d	37	//
	38	#include "TROOT.h"
	39	#include "Riostream.h"
	40	#include "TFile.h"
	41	#include "TMath.h"
	42	#include "TSystem.h"
	43	#include "AliSurveyObj.h"
68e43693	44	#include "AliSurveyPoint.h"
2574314d	45	#include "AliAlignObjParams.h"
	46	#include "AliCDBStorage.h"
	47	#include <TClonesArray.h>
	48	#include <TFile.h>
	49	#include "AliLog.h"
	50	#include "AliCDBManager.h"
	51
a11596ad	52	using std::cout;
a11596ad	53	using std::endl;
dd89d4d2	54	ClassImp(AliTPCAlign)
2574314d	55
	56	AliTPCAlign::AliTPCAlign() :
	57	TObject(),
	58	fFileLoc(0x0),
	59	fFileGlob(0x0),
	60	fTPCAlignObj(0x0),
	61	fX(),
	62	fA(),
	63	fY(),
	64	fDebug(0)
	65	{
	66	//
	67	// default constructor
	68	//
	69	}
	70	//________________________________________________________________________
	71	AliTPCAlign::AliTPCAlign(Int_t reportloc, Int_t reportglob) :
	72	TObject(),
	73	fFileLoc(0x0),
	74	fFileGlob(0x0),
	75	fTPCAlignObj(0x0),
	76	fX(6,1),
	77	fA(24,6),
	78	fY(24,1),
	79	fDebug(0)
	80	{
	81	//
	82	// constructor - defines data files
	83	//
	84	fFileLoc = new Char_t[80];
	85	fFileGlob = new Char_t[80];
	86	Char_t path[50];
94e6c6f4	87	//sprintf(path,gSystem->Getenv("ALICE_ROOT"));
2bf7eed2	88	snprintf(path,50,"%s",gSystem->Getenv("ALICE_ROOT"));
2574314d	89	//
94e6c6f4	90	//sprintf(fFileLoc,"%s/TPC/Survey_%d_TPC.txt",path,reportloc);
5a41314b	91	snprintf(fFileLoc,80,"%s/TPC/Survey_%d_TPC.txt",path,reportloc);
94e6c6f4	92	//sprintf(fFileGlob,"%s/TPC/Survey_%d_TPC.txt",path,reportglob);
5a41314b	93	snprintf(fFileGlob,80,"%s/TPC/Survey_%d_TPC.txt",path,reportglob);
2574314d	94	//
	95
	96	}
	97	//_________________________________________________________________________
	98	AliTPCAlign::AliTPCAlign(const AliTPCAlign &align) :
	99	TObject(),
	100	fFileLoc(0x0),
	101	fFileGlob(0x0),
	102	fTPCAlignObj(0x0),
	103	fX(),
	104	fA(),
	105	fY(),
	106	fDebug(0)
	107	{
	108	//
	109	// copy constructor - dummy
	110	//
	111	fDebug = align.fDebug;
	112	}
	113	//__________________________________________________________________________
	114	AliTPCAlign & AliTPCAlign::operator =(const AliTPCAlign & align)
	115	{
	116	//
	117	// assignment operator - dummy
	118	//
63a14ef0	119	if(this!=&align){
	120	fDebug=align.fDebug;
	121	}
2574314d	122	return (*this);
	123	}
	124
	125	//__________________________________________________________________________
	126	AliTPCAlign::~AliTPCAlign(){
	127	//
	128	// destructor
	129	//
	130	if(fTPCAlignObj) delete fTPCAlignObj;
	131	}
	132	//__________________________________________________________________________
	133	Bool_t AliTPCAlign::LoadSurveyData(){
	134	//
	135	// for a time being it loads from the local file the surveyed point
	136	// and has the ideal points hardwired. I am waiting until Ricardo
	137	// completes his job
	138	//
	139
	140	AliSurveyObj * s1 = new AliSurveyObj();
	141	s1->FillFromLocalFile(fFileGlob);
	142	//
	143	Int_t numberPoints = 8;
	144	//
	145	TString pointNames[8] = {"T1Final_R04241","T1Final_R05241","T1Final_R06241",
	146	"T1Final_R07241","T1Final_R08241","T1Final_R10241",
	147	"T1Final_R11241","T1Final_R12241"};
	148	//
	149	Float_t surveyedPoints[8][3];
	150	AliSurveyPoint *currPoint;
	151	//
	152	for(Int_t i=0;i<numberPoints;i++){
	153	currPoint=0;
	154	currPoint = (AliSurveyPoint *) s1->GetData()->FindObject(pointNames[i]);
	155	//
	156	if(currPoint){
	157	surveyedPoints[i][0]=currPoint->GetX();
	158	surveyedPoints[i][1]=currPoint->GetY();
	159	surveyedPoints[i][2]=currPoint->GetZ();
	160	if(fDebug)
2bf7eed2	161	Printf("INFO: Point \"%s\" coordinates read.", pointNames[i].Data());
2574314d	162	}
	163	else {
	164	if(fDebug){
2bf7eed2	165	Printf("ERROR: Essential point missing: \"%s\"", pointNames[i].Data());
2574314d	166	return 1;
	167	}
	168	}
	169	}
	170	//
	171	// Ideal points
	172	//
	173	Float_t idealPoints[8][3];
	174	//
3e3d6422	175	AliSurveyObj * s2 = new AliSurveyObj();
3e3d6422	176	s2->FillFromLocalFile(fFileLoc);
2574314d	177	//
3e3d6422	178	TString pointNamesL[8] ={"R04","R05","R06","R07","R08","R10","R11","R12"};
2574314d	179	//
3e3d6422	180	AliSurveyPoint *currPointL;
	181	//
	182	for(Int_t i=0;i<numberPoints;i++){
	183	currPointL=0;
	184	currPointL = (AliSurveyPoint *) s2->GetData()->FindObject(pointNamesL[i]);
	185	if(currPointL){
	186	idealPoints[i][0]=currPointL->GetY();
	187	idealPoints[i][1]=currPointL->GetZ();
	188	idealPoints[i][2]=currPointL->GetX();
	189	if(fDebug)
2bf7eed2	190	Printf("INFO: Point \"%s\" coordinates read.", pointNamesL[i].Data());
3e3d6422	191	}
	192	else{
	193	if(fDebug){
2bf7eed2	194	Printf("ERROR: Essential point missing: \"%s\"", pointNamesL[i].Data());
3e3d6422	195	return 1; }
	196	}
	197	}
2574314d	198	//
	199	// Create and fill matrices a & y
	200	//
	201	for(Int_t i = 0;i<numberPoints;i++){
	202	for(Int_t j=0;j<3;j++){
	203	fY(i*3+j,0)=surveyedPoints[i][j]-idealPoints[i][j];
	204
	205	}
	206	}
	207	fA.Zero();
	208	//
	209	//
	210	// setting matrix a
	211	//
	212	for(Int_t i=0;i<numberPoints;i++){
	213	fA(3*i,0)= -idealPoints[i][1];
	214	fA(3*i,1)= idealPoints[i][2];
	215	fA(3*i,3)=1.;
	216	fA(3*i+1,0)= idealPoints[i][0];
	217	fA(3*i+1,2)= -idealPoints[i][2];
	218	fA(3*i+1,4)= 1.;
	219	fA(3*i+2,1)= -idealPoints[i][0];
	220	fA(3*i+2,2)= idealPoints[i][1];
	221	fA(3*i+2,5)=1.;
	222	}
	223	//
	224	delete s1;
	225	//
	226	return 0;
	227	}
	228	//_________________________________________________________________
	229	Double_t AliTPCAlign::ComputeTransform(){
	230	//
	231	// Here simple matrix operations for the linear least square
	232	// The trigonometric function sin is approximated by the angle
	233	// and the cos by "1", because angles are very small (Y-convention!)
	234	// This secures the linearity of the problem
	235	// This method returns a sum of squares of residuals
	236	//
	237	TMatrixD tt1(TMatrixD::kInverted,(TMatrixD(fA,TMatrixD::kTransposeMult,fA)));
	238	fX=TMatrixD(tt1,TMatrixD::kMult,TMatrixD(fA,TMatrixD::kTransposeMult,fY));
	239	//
	240	TMatrixD Unit(24,24);
	241	Unit.UnitMatrix();
	242	TMatrixD xxt1(TMatrixD::kInverted,TMatrixD(fA,TMatrixD::kTransposeMult,fA));
	243	TMatrixD t(fA,TMatrixD::kMult,TMatrixD(xxt1,TMatrixD::kMultTranspose,fA));
	244	TMatrixD t2(Unit,TMatrixD::kMinus,t);
	245	TMatrixD chi2(fY,TMatrixD::kTransposeMult,TMatrixD(t2,TMatrixD::kMult,fY));
	246	//
	247
	248	return chi2(0,0);
	249
	250	}
	251	//_______________________________________________________________________
	252	void AliTPCAlign::CreateAlignObj(){
	253	//
	254	// This method creates AliAlignObj and fills it with Euler angles
	255	// and shifts. The units are degrees and cm.
	256	//
	257	fTPCAlignObj = new AliAlignObjParams();
	258	fTPCAlignObj->SetSymName("ALIC_1/TPC_M_1");
	259	fTPCAlignObj->SetVolUID(0);
	260	Double_t raddeg = TMath::RadToDeg();
	261	Double_t phi,theta,psi;
262	//
263	phi=fX(0,0)*raddeg;
264	theta=fX(1,0)*raddeg;
265	psi=fX(2,0)*raddeg;
266	//
267	Double_t dx,dy,dz;
268	dx=fX(3,0)*100.;
269	dy=fX(4,0)*100.;
270	dz=fX(5,0)*100.;
271	fTPCAlignObj->SetRotation(psi,theta,phi);
272	fTPCAlignObj->SetTranslation(dx,dy,dz);
273	fTPCAlignObj->Print("");
274	}
275	//______________________________________________________________________
276	void AliTPCAlign::Run(){
277	//
278	// runs the full chain
279	//
280	SetDebug(0);
281	Bool_t flag = LoadSurveyData();
282	if(flag) {
283	cout<<"Missing points"<<endl;
284	return;
285	}
286	Double_t chi2 = ComputeTransform();
287	if(chi2>0.01) return;
288	CreateAlignObj();
289	StoreAlignObj();
290	//
291	}
292	//_________________________________________________________________________
293	void AliTPCAlign::StoreAlignObj(){
294	//
295	AliCDBManager* cdb = AliCDBManager::Instance();
162637e4	296	if(!cdb->IsDefaultStorageSet()) cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
2574314d	297	//
	298	TClonesArray *array = new TClonesArray("AliAlignObjParams",1);
	299	//
	300	Double_t shifts[3];
	301	Double_t rots[3];
	302	//
	303	fTPCAlignObj->GetPars(shifts,rots);
	304	new((*array)[0]) AliAlignObjParams(fTPCAlignObj->GetSymName(),0,shifts[0],
	305	shifts[1],shifts[2],rots[0],rots[1],rots[2],kTRUE);
	306
	307	//
	308	// storing either in the OCDB or local file
	309	//
	310	if( TString(gSystem->Getenv("TOCDB")) != TString("kTRUE") ){
	311	// save on file
	312	const char* filename = "TPCSurveyMisalignment.root";
	313	Char_t fullname[80];
32a48cc1	314	//sprintf(fullname,"%s/TPC/%s",gSystem->Getenv("ALICE_ROOT"),filename);
32a48cc1	315	snprintf(fullname,80,"%s/TPC/%s",gSystem->Getenv("ALICE_ROOT"),filename);
2574314d	316	TFile *f = new TFile(fullname,"RECREATE");
	317	if(!f){
	318	AliError("cannot open file for output\n");
	319	return;
	320	}
	321	AliInfo(Form("Saving alignment objects to the file %s", filename));
	322	f->cd();
	323	f->WriteObject(array,"TPCAlignObjs","kSingleKey");
	324	f->Close();
	325	}else{
	326	// save in CDB storage
	327	AliCDBStorage* storage;
	328	//
	329	TString Storage = gSystem->Getenv("STORAGE");
	330	if(!Storage.BeginsWith("local://") && !Storage.BeginsWith("alien://")) {
	331	AliError(Form(
	332	"STORAGE variable set to %s is not valid. Exiting\n",Storage.Data()));
	333	return;
	334	}
	335	storage = cdb->GetStorage(Storage.Data());
	336	if(!storage){
	337	AliError(Form("Unable to open storage %s\n",Storage.Data()));
	338	return;
	339	}
	340	//
	341	AliCDBMetaData* md = new AliCDBMetaData();
	342	md->SetResponsible("Marek Kowalski");
	343	md->SetComment("Full misalignment of entire TPC from surveyors");
	344	AliCDBId id("TPC/Align/Data",0,AliCDBRunRange::Infinity());
	345	storage->Put(array,id,md);
	346	}
	347
	348	}