[u/mrichter/AliRoot.git] / T0 / AliT0Parameters.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:  */

//____________________________________________________________________
//                                                                          
// T0 - T0. 
//
// This class is a singleton that handles various parameters of
// the T0 detectors.  
// Eventually, this class will use the Conditions DB to get the
// various parameters, which code can then request from here.
//                                                       
#include "AliT0.h"
#include "AliLog.h"		  
#include "AliT0Parameters.h"	  
#include "AliT0CalibData.h"   
#include "AliT0CalibWalk.h"   
#include "AliT0CalibTimeEq.h"   
#include "AliT0LookUpKey.h"
#include "AliT0LookUpValue.h"
#include <AliCDBManager.h>        
#include <AliCDBEntry.h>          
#include <AliCDBStorage.h>  
#include <TMath.h>
#include <TSystem.h>
//#include <Riostream.h>
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
#include <TGeoMatrix.h>
#include <AliGeomManager.h>

AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
AliT0CalibData* AliT0Parameters::fgLookUp = 0;
AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
//====================================================================
ClassImp(AliT0Parameters)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliT0Parameters* AliT0Parameters::fgInstance = 0;
//____________________________________________________________________
AliT0Parameters* AliT0Parameters::Instance() 
{
  // Get static instance 
  if (!fgInstance) {
    fgInstance = new AliT0Parameters;
  }
  return fgInstance;
}

//____________________________________________________________________
AliT0Parameters::AliT0Parameters()
  :fIsInit(kFALSE),
   fPh2Mip(0),fmV2Mip(0),
   fChannelWidth(0),fmV2Channel(0),
   fQTmin(0),fQTmax(0),
   fAmpLEDRec(0), 
   fPMTeff(),
   fWalk(0),
   fQTC(0),
   fAmpLED(0),
   fTimeDelayCFD(0), 
 //  fTimeV0(0), 
   fTimeDelayTVD(0),
   fMeanT0(512),
   fLookUp(0),
   fNumberOfTRMs(2),
   fCalibentry(), fLookUpentry(),fSlewCorr()

  
{
  // Default constructor 
  for (Int_t ipmt=0; ipmt<24; ipmt++)
    {
      SetPh2Mip();      
      SetmV2Mip();      
      SetChannelWidth();
      SetmV2channel();
      SetQTmin();
      SetQTmax();
      SetPMTeff(ipmt);
    }
  SetTimeDelayTVD();
  SetZposition();
    
}

//__________________________________________________________________
void
AliT0Parameters::Init()
{
  // Initialize the parameters manager.  We need to get stuff from the
  // CDB here. 
   if (fIsInit) return;

   AliCDBManager *stor =AliCDBManager::Instance();
   //time equalizing
   fCalibentry  = stor->Get("T0/Calib/TimeDelay");
   if (fCalibentry)
     fgCalibData  = (AliT0CalibTimeEq*)fCalibentry->GetObject();
   else {
         AliFatal(" ALARM !!!! No time delays in CDB "); 
     fIsInit = kFALSE;
     return;
   }
 //slewing correction
  fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk");
  if (fSlewCorr){
    fgSlewCorr  = (AliT0CalibWalk*)fSlewCorr->GetObject();
  }
  else {
      AliFatal(" ALARM !!!! No slewing correction in CDB "); 
    fIsInit = kFALSE;
    return;
  }
  //lookup table
  fLookUpentry  = stor->Get("T0/Calib/LookUp_Table");
  if (fLookUpentry){
    fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
  }
  else {
     AliFatal(" ALARM !!!! No Lookup table  in CDB "); 
    fIsInit = kFALSE;
    return;
  }
  fIsInit = kTRUE;
}


//__________________________________________________________________

void AliT0Parameters::InitIfOnline()
{
// should be used in online
// for switching to this one should write
  // AliT0RawReader myrawreader(rawReader);
//	myrawreader.SetOnlineMode(kTRUE);

  if (fIsInit) return;
   //standart configuration (used for simulation)
   //Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
  // configuration for test Jun07.
   fgLookUp = new AliT0CalibData("T0");

  fNumberOfTRMs = 1;
 fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
  Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
  for (Int_t ik=0; ik<105; ik++)
        {
         AliT0LookUpKey * lookkey= new AliT0LookUpKey();
         AliT0LookUpValue * lookvalue= new AliT0LookUpValue();


          lookvalue->SetTRM(trm);
          lookvalue->SetTDC(tdc);
          lookvalue->SetChain(chain);
          lookvalue->SetChannel(channel);
          lookkey->SetKey(ik);
	  fgLookUp->GetMapLookup()->Add((TObject*)lookvalue,(TObject*)lookkey);	
	  if (channel<6) channel +=2;
	  else {channel = 0; tdc++;}
	  if(ik==56) { tdc=0; channel=0; chain = 1;}

       }
  
  fIsInit=kTRUE;
}
//__________________________________________________________________
Float_t
AliT0Parameters::GetTimeDelayCFD(Int_t ipmt) 
  {
  // return time delay for CFD channel
   // 
  if (!fCalibentry) 
    {
      fTimeDelayCFD = 1000+ipmt*100;
      return fTimeDelayCFD;
    }
   
  return fgCalibData->GetTimeEq(ipmt);
}
//__________________________________________________________________

TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
{
   if (!fSlewCorr) {
     AliError("No slewing correction is available!");
     return  (TGraph*)fAmpLEDRec.At(ipmt); 
  } 
  return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
}

//__________________________________________________________________

TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
{
  if (!fSlewCorr) {
    AliError("No walk correction is available!");
    return  (TGraph*)fWalk.At(ipmt); 
  } 
  return fgSlewCorr -> GetWalk(ipmt) ;
}

//__________________________________________________________________

TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
{
  if (!fSlewCorr) {
    AliError("No walk correction is available!");
    //    return  (TGraph*)fQTC.At(ipmt); 
   return  0; 
  } 
  return fgSlewCorr -> GetQTC(ipmt) ;
}

//__________________________________________________________________
TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
{
  if (!fSlewCorr) {
    AliError("No walk correction is available!");
    //    return  (TGraph*)fQTC.At(ipmt); 
   return  0; 
  } 
  return fgSlewCorr -> GetAmpLED(ipmt) ;
}

//__________________________________________________________________
void 
AliT0Parameters::SetPMTeff(Int_t ipmt)
{
  Float_t lambda[50];
  Float_t eff[50 ] = {0,        0,       0.23619,  0.202909, 0.177913, 
		    0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
		    0.252276, 0.256267,0.26,     0.27125,  0.281818,
		    0.288118, 0.294057,0.296222, 0.301622, 0.290421, 
		    0.276615, 0.2666,  0.248,    0.23619,  0.227814, 
		    0.219818, 0.206667,0.194087, 0.184681, 0.167917, 
		    0.154367, 0.1364,  0.109412, 0.0834615,0.0725283, 
		    0.0642963,0.05861, 0.0465,   0.0413333,0.032069, 
		    0.0252203,0.02066, 0.016262, 0.012,    0.00590476,
		    0.003875, 0.00190, 0,        0,        0          } ;
  for (Int_t i=0; i<50; i++) lambda[i]=200+10*i; 

  TGraph* gr = new TGraph(50,lambda,eff);
  fPMTeff.AddAtAndExpand(gr,ipmt);
}
//________________________________________________________________

Int_t 
AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
{

  if (fgLookUp) {
    AliT0LookUpValue key(trm,tdc,chain,channel);
      AliT0LookUpKey *val = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
      // AliT0LookUpKey *val = (AliT0LookUpKey*) fLookUp.GetValue((TObject*)&key);
    if (val )
      return val->GetKey();
    else {
      AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
      return -1;
    }
  }
  else {
    AliError("No look up table has been loader!");
    return -1;
  }

}
//__________________________________________________________________
TMap *AliT0Parameters::GetMapLookup()
{
  if (!fgLookUp){
    cout<<" No look up table in OCDB";
    return 0;
  }
  return   fgLookUp->GetMapLookup();
}
//__________________________________________________________________

Int_t
AliT0Parameters::GetNumberOfTRMs() 
{
  // return number of trms
  // 
  if (!fgLookUp) {
    //  fNumberOfTRMs = 2;
    return  fNumberOfTRMs;
  } 
  return  fgLookUp ->GetNumberOfTRMs();
}
/*
//________________________________________________________________________________
Double_t AliT0Parameters::GetZPosition(const char* symname){
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();

  return tr[2];
}
*/
//________________________________________________________________________________
Double_t AliT0Parameters::GetZPosition(const char* symname){
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr;
  TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
  if (!pne) return 0;
  

  TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
  if(pnode){
          TGeoHMatrix* hm = pnode->GetMatrix();
           tr = hm->GetTranslation();
  }else{
          const char* path = pne->GetTitle();
          if(!gGeoManager->cd(path)){
                  AliErrorClass(Form("Volume path %s not valid!",path));
                  return 0;
          }
         tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
  }
  return tr[2];

}
//________________________________________________________________________________

Double_t AliT0Parameters::GetZPositionShift(const char* symname)
{
// Get the global z coordinate of the given T0 alignable volume
//
  Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();

  TGeoHMatrix origmat;
  AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
  Double_t *otr = origmat.GetTranslation();

  return (tr[2]-otr[2]);
}
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	//
	20	// T0 - T0.
	21	//
	22	// This class is a singleton that handles various parameters of
	23	// the T0 detectors.
	24	// Eventually, this class will use the Conditions DB to get the
	25	// various parameters, which code can then request from here.
	26	//
	27	#include "AliT0.h"
	28	#include "AliLog.h"
	29	#include "AliT0Parameters.h"
	30	#include "AliT0CalibData.h"
	31	#include "AliT0CalibWalk.h"
	32	#include "AliT0CalibTimeEq.h"
	33	#include "AliT0LookUpKey.h"
	34	#include "AliT0LookUpValue.h"
	35	#include <AliCDBManager.h>
	36	#include <AliCDBEntry.h>
	37	#include <AliCDBStorage.h>
	38	#include <TMath.h>
	39	#include <TSystem.h>
	40	//#include <Riostream.h>
	41	#include <TGeoManager.h>
	42	#include <TGeoPhysicalNode.h>
	43	#include <TGeoMatrix.h>
	44	#include <AliGeomManager.h>
	45
	46	AliT0CalibTimeEq* AliT0Parameters::fgCalibData = 0;
	47	AliT0CalibData* AliT0Parameters::fgLookUp = 0;
	48	AliT0CalibWalk* AliT0Parameters::fgSlewCorr =0;
	49	//====================================================================
	50	ClassImp(AliT0Parameters)
	51	#if 0
	52	; // This is here to keep Emacs for indenting the next line
	53	#endif
	54
	55	//____________________________________________________________________
	56	AliT0Parameters* AliT0Parameters::fgInstance = 0;
	57	//____________________________________________________________________
	58	AliT0Parameters* AliT0Parameters::Instance()
	59	{
	60	// Get static instance
	61	if (!fgInstance) {
	62	fgInstance = new AliT0Parameters;
	63	}
	64	return fgInstance;
	65	}
	66
	67	//____________________________________________________________________
	68	AliT0Parameters::AliT0Parameters()
	69	:fIsInit(kFALSE),
	70	fPh2Mip(0),fmV2Mip(0),
	71	fChannelWidth(0),fmV2Channel(0),
	72	fQTmin(0),fQTmax(0),
	73	fAmpLEDRec(0),
	74	fPMTeff(),
	75	fWalk(0),
	76	fQTC(0),
	77	fAmpLED(0),
	78	fTimeDelayCFD(0),
	79	// fTimeV0(0),
	80	fTimeDelayTVD(0),
	81	fMeanT0(512),
	82	fLookUp(0),
	83	fNumberOfTRMs(2),
	84	fCalibentry(), fLookUpentry(),fSlewCorr()
	85
	86
	87	{
	88	// Default constructor
	89	for (Int_t ipmt=0; ipmt<24; ipmt++)
	90	{
	91	SetPh2Mip();
	92	SetmV2Mip();
	93	SetChannelWidth();
	94	SetmV2channel();
	95	SetQTmin();
	96	SetQTmax();
	97	SetPMTeff(ipmt);
	98	}
	99	SetTimeDelayTVD();
	100	SetZposition();
	101
	102	}
	103
	104	//__________________________________________________________________
	105	void
	106	AliT0Parameters::Init()
	107	{
	108	// Initialize the parameters manager. We need to get stuff from the
	109	// CDB here.
	110	if (fIsInit) return;
	111
	112	AliCDBManager *stor =AliCDBManager::Instance();
	113	//time equalizing
	114	fCalibentry = stor->Get("T0/Calib/TimeDelay");
	115	if (fCalibentry)
	116	fgCalibData = (AliT0CalibTimeEq*)fCalibentry->GetObject();
	117	else {
	118	AliFatal(" ALARM !!!! No time delays in CDB ");
	119	fIsInit = kFALSE;
	120	return;
	121	}
	122	//slewing correction
	123	fSlewCorr = stor->Get("T0/Calib/Slewing_Walk");
	124	if (fSlewCorr){
	125	fgSlewCorr = (AliT0CalibWalk*)fSlewCorr->GetObject();
	126	}
	127	else {
	128	AliFatal(" ALARM !!!! No slewing correction in CDB ");
	129	fIsInit = kFALSE;
	130	return;
	131	}
	132	//lookup table
	133	fLookUpentry = stor->Get("T0/Calib/LookUp_Table");
	134	if (fLookUpentry){
	135	fgLookUp = (AliT0CalibData*)fLookUpentry->GetObject();
	136	}
	137	else {
	138	AliFatal(" ALARM !!!! No Lookup table in CDB ");
	139	fIsInit = kFALSE;
	140	return;
	141	}
	142	fIsInit = kTRUE;
	143	}
	144
	145
	146	//__________________________________________________________________
	147
	148	void AliT0Parameters::InitIfOnline()
	149	{
	150	// should be used in online
	151	// for switching to this one should write
	152	// AliT0RawReader myrawreader(rawReader);
	153	// myrawreader.SetOnlineMode(kTRUE);
	154
	155	if (fIsInit) return;
	156	//standart configuration (used for simulation)
	157	//Int_t trm=0; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	158	// configuration for test Jun07.
	159	fgLookUp = new AliT0CalibData("T0");
	160
	161	fNumberOfTRMs = 1;
	162	fgLookUp-> SetNumberOfTRMs(fNumberOfTRMs);
	163	Int_t trm=7; Int_t tdc=0; Int_t chain=0; Int_t channel=0;
	164	for (Int_t ik=0; ik<105; ik++)
	165	{
	166	AliT0LookUpKey * lookkey= new AliT0LookUpKey();
	167	AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
	168
	169
	170	lookvalue->SetTRM(trm);
	171	lookvalue->SetTDC(tdc);
	172	lookvalue->SetChain(chain);
	173	lookvalue->SetChannel(channel);
	174	lookkey->SetKey(ik);
	175	fgLookUp->GetMapLookup()->Add((TObject)lookvalue,(TObject)lookkey);
	176	if (channel<6) channel +=2;
	177	else {channel = 0; tdc++;}
	178	if(ik==56) { tdc=0; channel=0; chain = 1;}
	179
	180	}
	181
	182	fIsInit=kTRUE;
	183	}
	184	//__________________________________________________________________
	185	Float_t
	186	AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
	187	{
	188	// return time delay for CFD channel
	189	//
	190	if (!fCalibentry)
	191	{
	192	fTimeDelayCFD = 1000+ipmt*100;
	193	return fTimeDelayCFD;
	194	}
	195
	196	return fgCalibData->GetTimeEq(ipmt);
	197	}
	198	//__________________________________________________________________
	199
	200	TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
	201	{
	202	if (!fSlewCorr) {
	203	AliError("No slewing correction is available!");
	204	return (TGraph*)fAmpLEDRec.At(ipmt);
	205	}
	206	return fgSlewCorr -> GetAmpLEDRec(ipmt) ;
	207	}
	208
	209	//__________________________________________________________________
	210
	211	TGraph *AliT0Parameters::GetWalk(Int_t ipmt) const
	212	{
	213	if (!fSlewCorr) {
	214	AliError("No walk correction is available!");
	215	return (TGraph*)fWalk.At(ipmt);
	216	}
	217	return fgSlewCorr -> GetWalk(ipmt) ;
	218	}
	219
	220	//__________________________________________________________________
	221
	222	TGraph *AliT0Parameters::GetQTC(Int_t ipmt) const
	223	{
	224	if (!fSlewCorr) {
	225	AliError("No walk correction is available!");
	226	// return (TGraph*)fQTC.At(ipmt);
	227	return 0;
	228	}
	229	return fgSlewCorr -> GetQTC(ipmt) ;
	230	}
	231
	232	//__________________________________________________________________
	233	TGraph *AliT0Parameters::GetAmpLED(Int_t ipmt) const
	234	{
	235	if (!fSlewCorr) {
	236	AliError("No walk correction is available!");
	237	// return (TGraph*)fQTC.At(ipmt);
	238	return 0;
	239	}
	240	return fgSlewCorr -> GetAmpLED(ipmt) ;
	241	}
	242
	243	//__________________________________________________________________
	244	void
	245	AliT0Parameters::SetPMTeff(Int_t ipmt)
	246	{
	247	Float_t lambda[50];
	248	Float_t eff[50 ] = {0, 0, 0.23619, 0.202909, 0.177913,
	249	0.175667, 0.17856, 0.190769, 0.206667, 0.230286,
	250	0.252276, 0.256267,0.26, 0.27125, 0.281818,
	251	0.288118, 0.294057,0.296222, 0.301622, 0.290421,
	252	0.276615, 0.2666, 0.248, 0.23619, 0.227814,
	253	0.219818, 0.206667,0.194087, 0.184681, 0.167917,
	254	0.154367, 0.1364, 0.109412, 0.0834615,0.0725283,
	255	0.0642963,0.05861, 0.0465, 0.0413333,0.032069,
	256	0.0252203,0.02066, 0.016262, 0.012, 0.00590476,
	257	0.003875, 0.00190, 0, 0, 0 } ;
	258	for (Int_t i=0; i<50; i++) lambda[i]=200+10*i;
	259
	260	TGraph* gr = new TGraph(50,lambda,eff);
	261	fPMTeff.AddAtAndExpand(gr,ipmt);
	262	}
	263	//________________________________________________________________
	264
	265	Int_t
	266	AliT0Parameters::GetChannel(Int_t trm, Int_t tdc, Int_t chain, Int_t channel)
	267	{
	268
	269	if (fgLookUp) {
	270	AliT0LookUpValue key(trm,tdc,chain,channel);
	271	AliT0LookUpKey val = (AliT0LookUpKey) fgLookUp->GetMapLookup()->GetValue((TObject*)&key);
	272	// AliT0LookUpKey val = (AliT0LookUpKey) fLookUp.GetValue((TObject*)&key);
	273	if (val )
	274	return val->GetKey();
	275	else {
	276	AliWarning(Form("No such address (%d %d %d %d)!",trm,tdc,chain,channel));
	277	return -1;
	278	}
	279	}
	280	else {
	281	AliError("No look up table has been loader!");
	282	return -1;
	283	}
	284
	285	}
	286	//__________________________________________________________________
	287	TMap *AliT0Parameters::GetMapLookup()
	288	{
	289	if (!fgLookUp){
	290	cout<<" No look up table in OCDB";
	291	return 0;
	292	}
	293	return fgLookUp->GetMapLookup();
	294	}
	295	//__________________________________________________________________
	296
	297	Int_t
	298	AliT0Parameters::GetNumberOfTRMs()
	299	{
	300	// return number of trms
	301	//
	302	if (!fgLookUp) {
	303	// fNumberOfTRMs = 2;
	304	return fNumberOfTRMs;
	305	}
	306	return fgLookUp ->GetNumberOfTRMs();
	307	}
	308	/*
	309	//________________________________________________________________________________
	310	Double_t AliT0Parameters::GetZPosition(const char* symname){
	311	// Get the global z coordinate of the given T0 alignable volume
	312	//
	313	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	314
	315	return tr[2];
	316	}
	317	*/
	318	//________________________________________________________________________________
	319	Double_t AliT0Parameters::GetZPosition(const char* symname){
	320	// Get the global z coordinate of the given T0 alignable volume
	321	//
	322	Double_t *tr;
	323	TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
	324	if (!pne) return 0;
	325
	326
	327	TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
	328	if(pnode){
	329	TGeoHMatrix* hm = pnode->GetMatrix();
	330	tr = hm->GetTranslation();
	331	}else{
	332	const char* path = pne->GetTitle();
	333	if(!gGeoManager->cd(path)){
	334	AliErrorClass(Form("Volume path %s not valid!",path));
	335	return 0;
	336	}
	337	tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
	338	}
	339	return tr[2];
	340
	341	}
	342	//________________________________________________________________________________
	343
	344	Double_t AliT0Parameters::GetZPositionShift(const char* symname)
	345	{
	346	// Get the global z coordinate of the given T0 alignable volume
	347	//
	348	Double_t *tr = AliGeomManager::GetMatrix(symname)->GetTranslation();
	349
	350	TGeoHMatrix origmat;
	351	AliGeomManager::GetOrigGlobalMatrix(symname,origmat);
	352	Double_t *otr = origmat.GetTranslation();
	353
	354	return (tr[2]-otr[2]);
	355	}
	356