[u/mrichter/AliRoot.git] / TRD / AliTRDtransform.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$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  Transforms clusters into space points with calibrated positions       //
//  defined in the local tracking system                                  //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include <TGeoMatrix.h>

#include "AliLog.h"
#include "AliTracker.h"
#include "AliCodeTimer.h"

#include "AliTRDtransform.h"
#include "AliTRDcluster.h"
#include "AliTRDgeometry.h"
#include "AliTRDpadPlane.h"
#include "AliTRDCommonParam.h"
#include "AliTRDcalibDB.h"
#include "Cal/AliTRDCalDet.h"
#include "Cal/AliTRDCalROC.h"

ClassImp(AliTRDtransform)

//_____________________________________________________________________________
//AliTRDtransform::AliTRDtransform()
//  :AliTransform()
AliTRDtransform::AliTRDtransform()
  :TObject()
  ,fGeo(0x0)
  ,fDetector(0)
  ,fParam(0x0)
  ,fCalibration(0x0)
  ,fCalVdriftROC(0x0)
  ,fCalT0ROC(0x0)
  ,fCalVdriftDet(0x0)
  ,fCalT0Det(0x0)
  ,fCalVdriftDetValue(0)
  ,fCalT0DetValue(0)
  ,fSamplingFrequency(0)
  ,fPadPlane(0x0)
  ,fZShiftIdeal(0)
  ,fMatrix(0x0)
{
  //
  // AliTRDtransform default constructor
  //

}

//_____________________________________________________________________________
//AliTRDtransform::AliTRDtransform(Int_t det)
//  :AliTransform()
AliTRDtransform::AliTRDtransform(Int_t det)
  :TObject()
  ,fGeo(0x0)
  ,fDetector(0)
  ,fParam(0x0)
  ,fCalibration(0x0)
  ,fCalVdriftROC(0x0)
  ,fCalT0ROC(0x0)
  ,fCalVdriftDet(0x0)
  ,fCalT0Det(0x0)
  ,fCalVdriftDetValue(0)
  ,fCalT0DetValue(0)
  ,fSamplingFrequency(0)
  ,fPadPlane(0x0)
  ,fZShiftIdeal(0)
  ,fMatrix(0x0)
{
  //
  // AliTRDtransform constructor for a given detector
  //

  fGeo               = new AliTRDgeometry();
  if (!fGeo->CreateClusterMatrixArray()) {
    AliError("Could not get transformation matrices\n");
  }

  fParam             = AliTRDCommonParam::Instance();
  if (!fParam) {
    AliError("Could not get common parameters\n");
  }
  fSamplingFrequency = fParam->GetSamplingFrequency();

  fCalibration       = AliTRDcalibDB::Instance();
  if (!fCalibration) {
    AliError("Cannot find calibration object");
  }

  // Get the calibration objects for the global calibration
  fCalVdriftDet      = fCalibration->GetVdriftDet();
  fCalT0Det          = fCalibration->GetT0Det();

  SetDetector(det);

}

//_____________________________________________________________________________
//AliTRDtransform::AliTRDtransform(const AliTRDtransform &t)
//  :AliTransform(t)
AliTRDtransform::AliTRDtransform(const AliTRDtransform &t)
  :TObject(t)
  ,fGeo(0x0)
  ,fDetector(t.fDetector)
  ,fParam(0x0)
  ,fCalibration(0x0)
  ,fCalVdriftROC(0x0)
  ,fCalT0ROC(0x0)
  ,fCalVdriftDet(0x0)
  ,fCalT0Det(0x0)
  ,fCalVdriftDetValue(0)
  ,fCalT0DetValue(0)
  ,fSamplingFrequency(0)
  ,fPadPlane(0x0)
  ,fZShiftIdeal(0)
  ,fMatrix(0x0)
{
  //
  // AliTRDtransform copy constructor
  //

  if (fGeo) {
    delete fGeo;
  }
  fGeo               = new AliTRDgeometry();
  fGeo->CreateClusterMatrixArray();

  fParam             = AliTRDCommonParam::Instance();
  if (!fParam) {
    AliError("Could not get common parameters\n");
  }
  fSamplingFrequency = fParam->GetSamplingFrequency();

  fCalibration = AliTRDcalibDB::Instance();
  if (!fCalibration) {
    AliError("Cannot find calibration object");
  }
  fCalVdriftDet      = fCalibration->GetVdriftDet();
  fCalT0Det          = fCalibration->GetT0Det();

}

//_____________________________________________________________________________
AliTRDtransform::~AliTRDtransform()
{
  //
  // AliTRDtransform destructor
  //

  if (fGeo) {
    delete fGeo;
  }

}

//_____________________________________________________________________________
void AliTRDtransform::SetDetector(Int_t det)
{
  //
  // Set to a new detector number and update the calibration objects
  // and values accordingly
  //

  fDetector          = det;

  // Get the calibration objects for the pad-by-pad calibration
  fCalVdriftROC      = fCalibration->GetVdriftROC(det);
  fCalT0ROC          = fCalibration->GetT0ROC(det);

  // Get the detector wise defined calibration values
  fCalVdriftDetValue = fCalVdriftDet->GetValue(det);
  fCalT0DetValue     = fCalT0Det->GetValue(det);

  // Shift needed to define Z-position relative to middle of chamber
  Int_t layer        = fGeo->GetLayer(det);
  Int_t stack        = fGeo->GetStack(det);
  fPadPlane          = fGeo->GetPadPlane(layer,stack);
  fZShiftIdeal       = 0.5 * (fPadPlane->GetRow0() + fPadPlane->GetRowEnd());

  // Get the current transformation matrix
  fMatrix            = fGeo->GetClusterMatrix(det);

}

//_____________________________________________________________________________
Bool_t AliTRDtransform::Transform(Double_t *x, Int_t *i, UInt_t time, Bool_t &out, Int_t  /*coordinateType*/)
{
  //
  // Transforms the local cluster coordinates into calibrated 
  // space point positions defined in the local tracking system.
  //
  // Here the calibration for T0, Vdrift and ExB is applied as well.
  //
  // Input:
  //   x[0] = COL-position relative to the center pad (pad units)
  //   x[1] = cluster signal in left pad
  //   x[2] = cluster signal in middle pad
  //   x[3] = cluster signal in right pad
  //   i[0] = ROW pad number
  //   i[1] = COL pad number
  //   time = time bin number (uncalibrated for t0)
  //
  // Output:
  //   x[0] = X-positions in tracking CS
  //   x[1] = Y-positions in tracking CS
  //   x[2] = Z-positions in tracking CS
  //   x[3] = total cluster charge
  //   x[4] = error in Y-direction
  //   x[5] = error in Z-direction
  //   i[2] = time bin number (calibrated for t0)
  //

  Double_t posLocal[3];
  Double_t posTracking[3];

  Int_t row = i[0];
  Int_t col = i[1];

  // Parameters to adjust the X position
  const Double_t kX0shift = 2.52 + 0.04273; //[cm]
  const Double_t kT0shift = 3.19e-3;        //[us]

  if (!fMatrix) {

    x[0] = 0.0;
    x[1] = 0.0;
    x[2] = 0.0;
    x[3] = 0.0;
    x[4] = 0.0;
    x[5] = 0.0;
    i[2] = 0;

    return kFALSE;

  }
  else {
 
    // Calibration values
    Double_t vdrift      = fCalVdriftDetValue * fCalVdriftROC->GetValue(col,row);
    Double_t t0          = fCalT0DetValue     + fCalT0ROC->GetValue(col,row);

    // T0 correction
    Double_t timeT0Cal   = time - t0;
    // Calculate the X-position,
    Double_t xLocal      = ((timeT0Cal + 0.5) / fSamplingFrequency + kT0shift) * vdrift; 

    // Length of the amplification region
    Double_t ampLength   = (Double_t) AliTRDgeometry::CamHght();
    // The drift distance
    Double_t driftLength = TMath::Max(xLocal - 0.5*ampLength,0.0);
    // ExB correction
    Double_t exbCorr     = AliTRDCommonParam::Instance()->GetOmegaTau(vdrift);

    // Pad dimensions
    Double_t rowSize     = fPadPlane->GetRowSize(row);
    Double_t colSize     = fPadPlane->GetColSize(col);

    // Invert the X-position,
    // apply ExB correction to the Y-position
    // and move to the Z-position relative to the middle of the chamber
    posLocal[0] = -xLocal;
    posLocal[1] =  (fPadPlane->GetColPos(col) + (0.5 + x[0]) * colSize) - driftLength * exbCorr;
    posLocal[2] =  (fPadPlane->GetRowPos(row) -         0.5  * rowSize) - fZShiftIdeal;

    // Go to tracking coordinates
    fMatrix->LocalToMaster(posLocal,posTracking);

    // The total charge of the cluster
    Double_t q0             = x[1];
    Double_t q1             = x[2];
    Double_t q2             = x[3];
    Double_t clusterCharge  = q0 + q1 + q2; 
    Double_t clusterSigmaY2 = 0.0;
    if (clusterCharge > 0.0) {
      clusterSigmaY2 = (q1 * (q0 + q2) + 4.0 * q0 * q2)
    	             / (clusterCharge*clusterCharge);
    }

    // Output values
    x[0] = posTracking[0] + kX0shift;
    x[1] = posTracking[1];
    x[2] = posTracking[2];
    x[3] = clusterCharge;
    x[4] = colSize*colSize * (clusterSigmaY2 + 1.0/12.0);
    x[5] = rowSize*rowSize / 12.0;                                       
    i[2] = TMath::Nint(timeT0Cal);
		
    // For TRD tracking calibration awareness
    out  = ((i[2] < 0) || (i[2] > Int_t(3.5 * fSamplingFrequency/vdrift))) ? kTRUE : kFALSE; 

    return kTRUE;

  }

}

//_____________________________________________________________________________
void AliTRDtransform::Recalibrate(AliTRDcluster *c, Bool_t setDet)
{
  //
  // Recalibrates the position of a given cluster
  // If <setDet> is TRUE, the detector number is set for each cluster
  // automatically. Otherwise, AliTRDtransform::SetDetector() has to
  // be used.
  //

  if (setDet) {
    SetDetector(c->GetDetector());
  }

  // Transform the local cluster coordinates into recalibrated 
  // space point positions defined in the local tracking system.
  // Here the calibration for T0, Vdrift and ExB is applied as well.
  Double_t clusterXYZ[6];
  clusterXYZ[0] = c->GetCenter();
  clusterXYZ[1] = 0.0;
  clusterXYZ[2] = 0.0;
  clusterXYZ[3] = 0.0;
  clusterXYZ[4] = 0.0;
  clusterXYZ[5] = 0.0;
  Int_t    clusterRCT[3];
  clusterRCT[0] = c->GetPadRow();
  clusterRCT[1] = c->GetPadCol();
  clusterRCT[2] = 0;
  Int_t time    = c->GetPadTime();
  Bool_t out;
  Transform(clusterXYZ,clusterRCT,((UInt_t) time), out, 0);

  // Set the recalibrated coordinates
  c->SetX(clusterXYZ[0]);
  c->SetY(clusterXYZ[1]);
  c->SetZ(clusterXYZ[2]);
  c->SetLocalTimeBin(((Char_t) clusterRCT[2]));
  c->SetInChamber(!out);

}
Commit	Line	Data
af26ce80	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	// Transforms clusters into space points with calibrated positions //
	21	// defined in the local tracking system //
	22	// //
	23	////////////////////////////////////////////////////////////////////////////
	24
	25	#include <TGeoMatrix.h>
	26
	27	#include "AliLog.h"
	28	#include "AliTracker.h"
	29	#include "AliCodeTimer.h"
	30
	31	#include "AliTRDtransform.h"
	32	#include "AliTRDcluster.h"
	33	#include "AliTRDgeometry.h"
	34	#include "AliTRDpadPlane.h"
	35	#include "AliTRDCommonParam.h"
	36	#include "AliTRDcalibDB.h"
	37	#include "Cal/AliTRDCalDet.h"
	38	#include "Cal/AliTRDCalROC.h"
	39
	40	ClassImp(AliTRDtransform)
	41
	42	//_____________________________________________________________________________
	43	//AliTRDtransform::AliTRDtransform()
	44	// :AliTransform()
	45	AliTRDtransform::AliTRDtransform()
	46	:TObject()
	47	,fGeo(0x0)
	48	,fDetector(0)
	49	,fParam(0x0)
	50	,fCalibration(0x0)
	51	,fCalVdriftROC(0x0)
	52	,fCalT0ROC(0x0)
	53	,fCalVdriftDet(0x0)
	54	,fCalT0Det(0x0)
	55	,fCalVdriftDetValue(0)
	56	,fCalT0DetValue(0)
	57	,fSamplingFrequency(0)
	58	,fPadPlane(0x0)
	59	,fZShiftIdeal(0)
	60	,fMatrix(0x0)
	61	{
	62	//
	63	// AliTRDtransform default constructor
	64	//
65
66	}
67
68	//_____________________________________________________________________________
69	//AliTRDtransform::AliTRDtransform(Int_t det)
70	// :AliTransform()
71	AliTRDtransform::AliTRDtransform(Int_t det)
72	:TObject()
73	,fGeo(0x0)
74	,fDetector(0)
75	,fParam(0x0)
76	,fCalibration(0x0)
77	,fCalVdriftROC(0x0)
78	,fCalT0ROC(0x0)
79	,fCalVdriftDet(0x0)
80	,fCalT0Det(0x0)
81	,fCalVdriftDetValue(0)
82	,fCalT0DetValue(0)
83	,fSamplingFrequency(0)
84	,fPadPlane(0x0)
85	,fZShiftIdeal(0)
86	,fMatrix(0x0)
87	{
88	//
89	// AliTRDtransform constructor for a given detector
90	//
91
92	fGeo = new AliTRDgeometry();
a938cf15	93	if (!fGeo->CreateClusterMatrixArray()) {
	94	AliError("Could not get transformation matrices\n");
	95	}
af26ce80	96
	97	fParam = AliTRDCommonParam::Instance();
	98	if (!fParam) {
	99	AliError("Could not get common parameters\n");
	100	}
	101	fSamplingFrequency = fParam->GetSamplingFrequency();
	102
	103	fCalibration = AliTRDcalibDB::Instance();
	104	if (!fCalibration) {
	105	AliError("Cannot find calibration object");
	106	}
	107
	108	// Get the calibration objects for the global calibration
	109	fCalVdriftDet = fCalibration->GetVdriftDet();
	110	fCalT0Det = fCalibration->GetT0Det();
	111
	112	SetDetector(det);
	113
	114	}
	115
	116	//_____________________________________________________________________________
	117	//AliTRDtransform::AliTRDtransform(const AliTRDtransform &t)
	118	// :AliTransform(t)
	119	AliTRDtransform::AliTRDtransform(const AliTRDtransform &t)
	120	:TObject(t)
	121	,fGeo(0x0)
	122	,fDetector(t.fDetector)
	123	,fParam(0x0)
	124	,fCalibration(0x0)
	125	,fCalVdriftROC(0x0)
	126	,fCalT0ROC(0x0)
	127	,fCalVdriftDet(0x0)
	128	,fCalT0Det(0x0)
	129	,fCalVdriftDetValue(0)
	130	,fCalT0DetValue(0)
	131	,fSamplingFrequency(0)
	132	,fPadPlane(0x0)
	133	,fZShiftIdeal(0)
	134	,fMatrix(0x0)
	135	{
	136	//
	137	// AliTRDtransform copy constructor
	138	//
	139
	140	if (fGeo) {
	141	delete fGeo;
	142	}
	143	fGeo = new AliTRDgeometry();
9a96f175	144	fGeo->CreateClusterMatrixArray();
af26ce80	145
	146	fParam = AliTRDCommonParam::Instance();
	147	if (!fParam) {
	148	AliError("Could not get common parameters\n");
	149	}
	150	fSamplingFrequency = fParam->GetSamplingFrequency();
	151
	152	fCalibration = AliTRDcalibDB::Instance();
	153	if (!fCalibration) {
	154	AliError("Cannot find calibration object");
	155	}
	156	fCalVdriftDet = fCalibration->GetVdriftDet();
	157	fCalT0Det = fCalibration->GetT0Det();
	158
	159	}
	160
	161	//_____________________________________________________________________________
	162	AliTRDtransform::~AliTRDtransform()
	163	{
	164	//
	165	// AliTRDtransform destructor
	166	//
	167
	168	if (fGeo) {
	169	delete fGeo;
	170	}
	171
	172	}
	173
	174	//_____________________________________________________________________________
	175	void AliTRDtransform::SetDetector(Int_t det)
	176	{
	177	//
	178	// Set to a new detector number and update the calibration objects
	179	// and values accordingly
	180	//
	181
	182	fDetector = det;
	183
	184	// Get the calibration objects for the pad-by-pad calibration
	185	fCalVdriftROC = fCalibration->GetVdriftROC(det);
	186	fCalT0ROC = fCalibration->GetT0ROC(det);
	187
	188	// Get the detector wise defined calibration values
	189	fCalVdriftDetValue = fCalVdriftDet->GetValue(det);
	190	fCalT0DetValue = fCalT0Det->GetValue(det);
	191
	192	// Shift needed to define Z-position relative to middle of chamber
053767a4	193	Int_t layer = fGeo->GetLayer(det);
	194	Int_t stack = fGeo->GetStack(det);
	195	fPadPlane = fGeo->GetPadPlane(layer,stack);
af26ce80	196	fZShiftIdeal = 0.5 * (fPadPlane->GetRow0() + fPadPlane->GetRowEnd());
	197
	198	// Get the current transformation matrix
9a96f175	199	fMatrix = fGeo->GetClusterMatrix(det);
af26ce80	200
	201	}
	202
	203	//_____________________________________________________________________________
bcb6fb78	204	Bool_t AliTRDtransform::Transform(Double_t x, Int_t i, UInt_t time, Bool_t &out, Int_t /coordinateType/)
af26ce80	205	{
	206	//
	207	// Transforms the local cluster coordinates into calibrated
	208	// space point positions defined in the local tracking system.
	209	//
	210	// Here the calibration for T0, Vdrift and ExB is applied as well.
	211	//
	212	// Input:
	213	// x[0] = COL-position relative to the center pad (pad units)
	214	// x[1] = cluster signal in left pad
	215	// x[2] = cluster signal in middle pad
	216	// x[3] = cluster signal in right pad
	217	// i[0] = ROW pad number
	218	// i[1] = COL pad number
	219	// time = time bin number (uncalibrated for t0)
	220	//
	221	// Output:
	222	// x[0] = X-positions in tracking CS
	223	// x[1] = Y-positions in tracking CS
	224	// x[2] = Z-positions in tracking CS
	225	// x[3] = total cluster charge
	226	// x[4] = error in Y-direction
	227	// x[5] = error in Z-direction
	228	// i[2] = time bin number (calibrated for t0)
	229	//
	230
	231	Double_t posLocal[3];
	232	Double_t posTracking[3];
	233
	234	Int_t row = i[0];
	235	Int_t col = i[1];
	236
76d8c1b9	237	// Parameters to adjust the X position
	238	const Double_t kX0shift = 2.52 + 0.04273; //[cm]
	239	const Double_t kT0shift = 3.19e-3; //[us]
af26ce80	240
1814b374	241	if (!fMatrix) {
	242
	243	x[0] = 0.0;
	244	x[1] = 0.0;
	245	x[2] = 0.0;
	246	x[3] = 0.0;
	247	x[4] = 0.0;
	248	x[5] = 0.0;
	249	i[2] = 0;
	250
9bf8c575	251	return kFALSE;
9bf8c575	252
af26ce80	253	}
1814b374	254	else {
	255
	256	// Calibration values
	257	Double_t vdrift = fCalVdriftDetValue * fCalVdriftROC->GetValue(col,row);
	258	Double_t t0 = fCalT0DetValue + fCalT0ROC->GetValue(col,row);
	259
	260	// T0 correction
	261	Double_t timeT0Cal = time - t0;
	262	// Calculate the X-position,
76d8c1b9	263	Double_t xLocal = ((timeT0Cal + 0.5) / fSamplingFrequency + kT0shift) * vdrift;
1814b374	264
	265	// Length of the amplification region
	266	Double_t ampLength = (Double_t) AliTRDgeometry::CamHght();
	267	// The drift distance
	268	Double_t driftLength = TMath::Max(xLocal - 0.5*ampLength,0.0);
	269	// ExB correction
a076fc2f	270	Double_t exbCorr = AliTRDCommonParam::Instance()->GetOmegaTau(vdrift);
1814b374	271
	272	// Pad dimensions
	273	Double_t rowSize = fPadPlane->GetRowSize(row);
	274	Double_t colSize = fPadPlane->GetColSize(col);
	275
	276	// Invert the X-position,
	277	// apply ExB correction to the Y-position
	278	// and move to the Z-position relative to the middle of the chamber
	279	posLocal[0] = -xLocal;
58d10045	280	posLocal[1] = (fPadPlane->GetColPos(col) + (0.5 + x[0]) * colSize) - driftLength * exbCorr;
1814b374	281	posLocal[2] = (fPadPlane->GetRowPos(row) - 0.5 * rowSize) - fZShiftIdeal;
	282
	283	// Go to tracking coordinates
	284	fMatrix->LocalToMaster(posLocal,posTracking);
	285
	286	// The total charge of the cluster
	287	Double_t q0 = x[1];
	288	Double_t q1 = x[2];
	289	Double_t q2 = x[3];
	290	Double_t clusterCharge = q0 + q1 + q2;
	291	Double_t clusterSigmaY2 = 0.0;
	292	if (clusterCharge > 0.0) {
	293	clusterSigmaY2 = (q1 * (q0 + q2) + 4.0 * q0 * q2)
	294	/ (clusterCharge*clusterCharge);
	295	}
	296
	297	// Output values
	298	x[0] = posTracking[0] + kX0shift;
	299	x[1] = posTracking[1];
	300	x[2] = posTracking[2];
	301	x[3] = clusterCharge;
	302	x[4] = colSizecolSize (clusterSigmaY2 + 1.0/12.0);
	303	x[5] = rowSize*rowSize / 12.0;
	304	i[2] = TMath::Nint(timeT0Cal);
bcb6fb78	305
023b669c	306	// For TRD tracking calibration awareness
023b669c	307	out = ((i[2] < 0) \|\| (i[2] > Int_t(3.5 * fSamplingFrequency/vdrift))) ? kTRUE : kFALSE;
af26ce80	308
9bf8c575	309	return kTRUE;
9bf8c575	310
1814b374	311	}
af26ce80	312
	313	}
	314
	315	//_____________________________________________________________________________
	316	void AliTRDtransform::Recalibrate(AliTRDcluster *c, Bool_t setDet)
	317	{
	318	//
	319	// Recalibrates the position of a given cluster
	320	// If <setDet> is TRUE, the detector number is set for each cluster
	321	// automatically. Otherwise, AliTRDtransform::SetDetector() has to
	322	// be used.
	323	//
	324
	325	if (setDet) {
	326	SetDetector(c->GetDetector());
	327	}
	328
	329	// Transform the local cluster coordinates into recalibrated
	330	// space point positions defined in the local tracking system.
	331	// Here the calibration for T0, Vdrift and ExB is applied as well.
	332	Double_t clusterXYZ[6];
	333	clusterXYZ[0] = c->GetCenter();
	334	clusterXYZ[1] = 0.0;
	335	clusterXYZ[2] = 0.0;
	336	clusterXYZ[3] = 0.0;
	337	clusterXYZ[4] = 0.0;
	338	clusterXYZ[5] = 0.0;
	339	Int_t clusterRCT[3];
	340	clusterRCT[0] = c->GetPadRow();
	341	clusterRCT[1] = c->GetPadCol();
	342	clusterRCT[2] = 0;
	343	Int_t time = c->GetPadTime();
bcb6fb78	344	Bool_t out;
bcb6fb78	345	Transform(clusterXYZ,clusterRCT,((UInt_t) time), out, 0);
af26ce80	346
	347	// Set the recalibrated coordinates
	348	c->SetX(clusterXYZ[0]);
	349	c->SetY(clusterXYZ[1]);
	350	c->SetZ(clusterXYZ[2]);
	351	c->SetLocalTimeBin(((Char_t) clusterRCT[2]));
023b669c	352	c->SetInChamber(!out);
023b669c	353
af26ce80	354	}