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

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  The TRD propagation layer                                             //
//                                                                        //
//  Authors:                                                              //
//    Marian Ivanov <M.Ivanov@gsi.de>                                     //
//    Alex Bercuci <A.Bercuci@gsi.de>                                     //
//    Markus Fasel <M.Fasel@gsi.de>                                       //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include "string.h"

#include "TMath.h"

#include "AliTRDpropagationLayer.h"
//#include "AliTRDtracker.h"
#include "AliTRDcluster.h"
#include "AliTRDgeometry.h"

//_____________________________________________________________________________
AliTRDpropagationLayer::AliTRDpropagationLayer()
  :TObject()
  ,fN(0)
  ,fSec(0)
  ,fClusters(NULL)
  ,fIndex(NULL)
  ,fX(0.)
  ,fdX(0.)
  ,fRho(0.)
  ,fX0(0.)
  ,fTimeBinIndex(0)
  ,fPlane(0)
  ,fYmax(0)
  ,fYmaxSensitive(0)
  ,fHole(kFALSE)
  ,fHoleZc(0)
  ,fHoleZmax(0)
  ,fHoleYc(0)
  ,fHoleYmax(0)
  ,fHoleRho(0)
  ,fHoleX0(0)
{
  //
  // Default constructor
  //

  for (Int_t iZones = 0; iZones < (Int_t)kZones; iZones++) {
    fZc[iZones]            = 0.0;
    fZmax[iZones]          = 0.0;
    fZmaxSensitive[iZones] = 0.0;
    fIsHole[iZones]        = kFALSE;   
  }
  memset(fZmaxSensitive, 0, kZones*sizeof(Double_t));
}

//_____________________________________________________________________________
AliTRDpropagationLayer::AliTRDpropagationLayer(Double_t x, Double_t dx, Double_t rho
                                             , Double_t radLength, Int_t tbIndex, Int_t plane)
  :TObject()
  ,fN(0)
  ,fSec(0)
  ,fClusters(NULL)
  ,fIndex(NULL)
  ,fX(x)
  ,fdX(dx)
  ,fRho(rho)
  ,fX0(radLength)
  ,fTimeBinIndex(tbIndex)
  ,fPlane(plane)
  ,fYmax(0)
  ,fYmaxSensitive(0)
  ,fHole(kFALSE)
  ,fHoleZc(0)
  ,fHoleZmax(0)
  ,fHoleYc(0)
  ,fHoleYmax(0)
  ,fHoleRho(0)
  ,fHoleX0(0)
{ 
  //
  // AliTRDpropagationLayer constructor
  //

  for (Int_t i = 0; i < (Int_t)kZones; i++) {
    fZc[i]   = 0; 
    fZmax[i] = 0;
  }

  if (fTimeBinIndex >= 0) { 
    fClusters = new AliTRDcluster*[kMaxClusterPerTimeBin];
    fIndex    = new UInt_t[kMaxClusterPerTimeBin];
  }

  for (Int_t i = 0; i < 5; i++) {
    fIsHole[i] = kFALSE;
  }
  memset(fZmaxSensitive, 0, kZones*sizeof(Double_t));
}

//_____________________________________________________________________________
AliTRDpropagationLayer::AliTRDpropagationLayer(const AliTRDpropagationLayer &p)
  :TObject((TObject&)p)
  ,fN(p.fN)
  ,fSec(p.fSec)
  ,fClusters(NULL)
  ,fIndex(NULL)
  ,fX(p.fX)
  ,fdX(p.fdX)
  ,fRho(p.fRho)
  ,fX0(p.fX0)
  ,fTimeBinIndex(p.fTimeBinIndex)
  ,fPlane(p.fPlane)
  ,fYmax(p.fYmax)
  ,fYmaxSensitive(p.fYmaxSensitive)
  ,fHole(p.fHole)
  ,fHoleZc(p.fHoleZc)
  ,fHoleZmax(p.fHoleZmax)
  ,fHoleYc(p.fHoleYc)
  ,fHoleYmax(p.fHoleYmax)
  ,fHoleRho(p.fHoleRho)
  ,fHoleX0(p.fHoleX0)
{
  //
  // AliTRDpropagationLayer copy constructor
  //

  for (Int_t i = 0; i < (Int_t)kZones; i++) {
    fZc[i]   = p.fZc[i]; 
    fZmax[i] = p.fZmax[i];
		fIsHole[i] = p.fIsHole[i];
		fZmaxSensitive[i] = p.fZmaxSensitive[i];  
	}

	// Make a deep copy of the Clusters array and the Index array unless they are needed in class AliTRDstackLayer
	Int_t arrsize = (Int_t)kMaxClusterPerTimeBin;
	if (fTimeBinIndex >= 0) {
    fClusters = new AliTRDcluster*[arrsize];
    fIndex    = new UInt_t[arrsize];
    memset(fIndex, 0, sizeof(UInt_t)*arrsize);
    memset(fClusters, 0, sizeof(AliTRDcluster *)*arrsize);
    for(Int_t i = 0; i < arrsize; i++){
      fClusters[i] = p.fClusters[i];
      fIndex[i] = p.fIndex[i];
    }
  }
}
 
//_____________________________________________________________________________
AliTRDpropagationLayer::~AliTRDpropagationLayer()
{
  //
  // Destructor
  //

  if (fTimeBinIndex >= 0) { 
    delete[] fClusters;
    delete[] fIndex;
  }

}

//_____________________________________________________________________________
void AliTRDpropagationLayer::Copy(TObject &o) const 
{
  //
  // Copy function
  //

  AliTRDpropagationLayer &p = (AliTRDpropagationLayer &)o; 
  p.fN   = fN;
  p.fSec = fSec;
  p.fX = fX;
  p.fdX = fdX;
  p.fRho = fRho;
  p.fX0  = fX0;
  p.fTimeBinIndex = fTimeBinIndex;
  p.fPlane  = fPlane;
  p.fYmax = fYmax;
  p.fYmaxSensitive  = fYmaxSensitive;
  p.fHole = fHole;
  p.fHoleZc = fHoleZc;
  p.fHoleZmax = fHoleZmax;
  p.fHoleYc = fHoleYc;
  p.fHoleYmax = fHoleYmax;
  p.fHoleRho = fHoleRho;
  p.fHoleX0 = fHoleX0;

  for (Int_t i = 0; i < (Int_t)kZones; i++) {
    p.fZc[i]   = fZc[i]; 
    p.fZmax[i] = fZmax[i];
    p.fIsHole[i] = fIsHole[i];
    p.fZmaxSensitive[i] = fZmaxSensitive[i];  
  }
	
  // Make a deep copy of the Clusters array and the Index array
  // unless they are needed in class AliTRDstackLayer
  if (fTimeBinIndex >= 0) { 
    if (!p.fClusters) 
      p.fClusters = new AliTRDcluster*[(Int_t)kMaxClusterPerTimeBin];
    if (!p.fIndex)
      p.fIndex    = new UInt_t[(Int_t)kMaxClusterPerTimeBin];
  }
  for (Int_t i = 0; i < (Int_t)kMaxClusterPerTimeBin; i++){
    //overwrite
    p.fClusters[i] = fClusters[i];
    p.fIndex[i] = fIndex[i];
  }

}

//_____________________________________________________________________________
void AliTRDpropagationLayer::SetZ(Double_t * const center, Double_t * const w, Double_t * const wsensitive )
{
  //
  // Set centers and the width of sectors
  //

  for (Int_t istack = 0; istack < AliTRDgeometry::kNstack; istack++) {
    fZc[istack]            = center[istack];  
    fZmax[istack]          = w[istack];
    fZmaxSensitive[istack] = wsensitive[istack];
  }  

}

//_____________________________________________________________________________
void AliTRDpropagationLayer::SetHoles(Bool_t * const holes)
{
  //
  // Set centers and the width of sectors
  //

  fHole = kFALSE;

  for (Int_t istack = 0; istack < AliTRDgeometry::kNstack; istack++) {
    fIsHole[istack] = holes[istack]; 
    if (holes[istack]) {
      fHole = kTRUE;
    }
  }  

}

//_____________________________________________________________________________
void AliTRDpropagationLayer::InsertCluster(AliTRDcluster *c, UInt_t index) 
{
  //
  // Insert cluster in cluster array.
  // Clusters are sorted according to Y coordinate.  
  //

  if (fTimeBinIndex < 0) { 
    //AliWarning("Attempt to insert cluster into non-sensitive time bin!\n");
    return;
  }

  if (fN == (Int_t) kMaxClusterPerTimeBin) {
    //AliWarning("Too many clusters !\n"); 
    return;
  }

  if (fN == 0) {
    fIndex[0]       = index; 
    fClusters[fN++] = c; 
    return;
  }

  Int_t i = Find(c->GetY());
  memmove(fClusters+i+1,fClusters+i,(fN-i)*sizeof(AliTRDcluster*));
  memmove(fIndex   +i+1,fIndex   +i,(fN-i)*sizeof(UInt_t)); 
  fIndex[i]    = index; 
  fClusters[i] = c; 
  fN++;

}  

//_____________________________________________________________________________
Int_t AliTRDpropagationLayer::Find(Float_t y) const
{
  //
  // Returns index of the cluster nearest in Y    
  //

  if (fN <= 0) {
    return 0;
  }
  if (y <= fClusters[0]->GetY()) {
    return 0;
  }
  if (y >  fClusters[fN-1]->GetY()) {
    return fN;
  }

  Int_t b = 0;
  Int_t e = fN - 1;
  Int_t m = (b + e) / 2;

  for ( ; b < e; m = (b + e) / 2) {
    if (y > fClusters[m]->GetY()) {
      b = m + 1;
    }
    else {
      e = m;
    }
  }

  return m;

}    

//_____________________________________________________________________________
Int_t AliTRDpropagationLayer::FindNearestCluster(Float_t y, Float_t z
                                               , Float_t maxroad
                                               , Float_t maxroadz) const 
{
  //
  // Returns index of the cluster nearest to the given y,z
  //

  Int_t   index   = -1;
  Int_t   maxn    = fN;
  Float_t mindist = maxroad;			

  for (Int_t i = Find(y-maxroad); i < maxn; i++) {
    AliTRDcluster *c = (AliTRDcluster *) (fClusters[i]);
    Float_t ycl = c->GetY();
    if (ycl > (y + maxroad)) {
      break;
    }
    if (TMath::Abs(c->GetZ() - z) > maxroadz) {
      continue;
    }
    if (TMath::Abs(ycl - y)       < mindist) {
      mindist = TMath::Abs(ycl - y);
      index   = fIndex[i];
    }
  }						

  return index;

}
Commit	Line	Data
e4f2f73d	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	// The TRD propagation layer //
	21	// //
	22	// Authors: //
	23	// Marian Ivanov <M.Ivanov@gsi.de> //
	24	// Alex Bercuci <A.Bercuci@gsi.de> //
	25	// Markus Fasel <M.Fasel@gsi.de> //
	26	// //
	27	////////////////////////////////////////////////////////////////////////////
	28
	29	#include "string.h"
	30
	31	#include "TMath.h"
	32
	33	#include "AliTRDpropagationLayer.h"
	34	//#include "AliTRDtracker.h"
	35	#include "AliTRDcluster.h"
	36	#include "AliTRDgeometry.h"
	37
	38	//_____________________________________________________________________________
	39	AliTRDpropagationLayer::AliTRDpropagationLayer()
	40	:TObject()
	41	,fN(0)
	42	,fSec(0)
	43	,fClusters(NULL)
	44	,fIndex(NULL)
	45	,fX(0.)
	46	,fdX(0.)
	47	,fRho(0.)
	48	,fX0(0.)
	49	,fTimeBinIndex(0)
	50	,fPlane(0)
	51	,fYmax(0)
	52	,fYmaxSensitive(0)
	53	,fHole(kFALSE)
	54	,fHoleZc(0)
	55	,fHoleZmax(0)
	56	,fHoleYc(0)
	57	,fHoleYmax(0)
	58	,fHoleRho(0)
	59	,fHoleX0(0)
	60	{
	61	//
	62	// Default constructor
	63	//
	64
2f9bdd85	65	for (Int_t iZones = 0; iZones < (Int_t)kZones; iZones++) {
	66	fZc[iZones] = 0.0;
	67	fZmax[iZones] = 0.0;
	68	fZmaxSensitive[iZones] = 0.0;
	69	fIsHole[iZones] = kFALSE;
	70	}
41f024fb	71	memset(fZmaxSensitive, 0, kZones*sizeof(Double_t));
e4f2f73d	72	}
	73
	74	//_____________________________________________________________________________
	75	AliTRDpropagationLayer::AliTRDpropagationLayer(Double_t x, Double_t dx, Double_t rho
	76	, Double_t radLength, Int_t tbIndex, Int_t plane)
	77	:TObject()
	78	,fN(0)
	79	,fSec(0)
	80	,fClusters(NULL)
	81	,fIndex(NULL)
	82	,fX(x)
	83	,fdX(dx)
	84	,fRho(rho)
	85	,fX0(radLength)
	86	,fTimeBinIndex(tbIndex)
	87	,fPlane(plane)
	88	,fYmax(0)
	89	,fYmaxSensitive(0)
	90	,fHole(kFALSE)
	91	,fHoleZc(0)
	92	,fHoleZmax(0)
	93	,fHoleYc(0)
	94	,fHoleYmax(0)
	95	,fHoleRho(0)
	96	,fHoleX0(0)
	97	{
	98	//
	99	// AliTRDpropagationLayer constructor
	100	//
	101
	102	for (Int_t i = 0; i < (Int_t)kZones; i++) {
	103	fZc[i] = 0;
	104	fZmax[i] = 0;
	105	}
	106
	107	if (fTimeBinIndex >= 0) {
	108	fClusters = new AliTRDcluster*[kMaxClusterPerTimeBin];
	109	fIndex = new UInt_t[kMaxClusterPerTimeBin];
	110	}
	111
	112	for (Int_t i = 0; i < 5; i++) {
	113	fIsHole[i] = kFALSE;
	114	}
41f024fb	115	memset(fZmaxSensitive, 0, kZones*sizeof(Double_t));
e4f2f73d	116	}
	117
	118	//_____________________________________________________________________________
	119	AliTRDpropagationLayer::AliTRDpropagationLayer(const AliTRDpropagationLayer &p)
	120	:TObject((TObject&)p)
	121	,fN(p.fN)
	122	,fSec(p.fSec)
4d6aee34	123	,fClusters(NULL)
4d6aee34	124	,fIndex(NULL)
e4f2f73d	125	,fX(p.fX)
	126	,fdX(p.fdX)
	127	,fRho(p.fRho)
	128	,fX0(p.fX0)
	129	,fTimeBinIndex(p.fTimeBinIndex)
	130	,fPlane(p.fPlane)
	131	,fYmax(p.fYmax)
	132	,fYmaxSensitive(p.fYmaxSensitive)
	133	,fHole(p.fHole)
	134	,fHoleZc(p.fHoleZc)
	135	,fHoleZmax(p.fHoleZmax)
	136	,fHoleYc(p.fHoleYc)
	137	,fHoleYmax(p.fHoleYmax)
	138	,fHoleRho(p.fHoleRho)
	139	,fHoleX0(p.fHoleX0)
	140	{
	141	//
	142	// AliTRDpropagationLayer copy constructor
	143	//
	144
	145	for (Int_t i = 0; i < (Int_t)kZones; i++) {
	146	fZc[i] = p.fZc[i];
	147	fZmax[i] = p.fZmax[i];
	148	fIsHole[i] = p.fIsHole[i];
	149	fZmaxSensitive[i] = p.fZmaxSensitive[i];
	150	}
	151
	152	// Make a deep copy of the Clusters array and the Index array unless they are needed in class AliTRDstackLayer
	153	Int_t arrsize = (Int_t)kMaxClusterPerTimeBin;
41f024fb	154	if (fTimeBinIndex >= 0) {
e4f2f73d	155	fClusters = new AliTRDcluster*[arrsize];
e4f2f73d	156	fIndex = new UInt_t[arrsize];
41f024fb	157	memset(fIndex, 0, sizeof(UInt_t)*arrsize);
	158	memset(fClusters, 0, sizeof(AliTRDcluster )arrsize);
	159	for(Int_t i = 0; i < arrsize; i++){
	160	fClusters[i] = p.fClusters[i];
	161	fIndex[i] = p.fIndex[i];
	162	}
e4f2f73d	163	}
e4f2f73d	164	}
	165
	166	//_____________________________________________________________________________
	167	AliTRDpropagationLayer::~AliTRDpropagationLayer()
	168	{
	169	//
	170	// Destructor
	171	//
	172
	173	if (fTimeBinIndex >= 0) {
	174	delete[] fClusters;
	175	delete[] fIndex;
	176	}
	177
	178	}
	179
	180	//_____________________________________________________________________________
	181	void AliTRDpropagationLayer::Copy(TObject &o) const
	182	{
	183	//
	184	// Copy function
	185	//
	186
	187	AliTRDpropagationLayer &p = (AliTRDpropagationLayer &)o;
	188	p.fN = fN;
	189	p.fSec = fSec;
	190	p.fX = fX;
	191	p.fdX = fdX;
	192	p.fRho = fRho;
	193	p.fX0 = fX0;
	194	p.fTimeBinIndex = fTimeBinIndex;
	195	p.fPlane = fPlane;
	196	p.fYmax = fYmax;
	197	p.fYmaxSensitive = fYmaxSensitive;
	198	p.fHole = fHole;
	199	p.fHoleZc = fHoleZc;
	200	p.fHoleZmax = fHoleZmax;
	201	p.fHoleYc = fHoleYc;
	202	p.fHoleYmax = fHoleYmax;
	203	p.fHoleRho = fHoleRho;
	204	p.fHoleX0 = fHoleX0;
	205
	206	for (Int_t i = 0; i < (Int_t)kZones; i++) {
	207	p.fZc[i] = fZc[i];
	208	p.fZmax[i] = fZmax[i];
	209	p.fIsHole[i] = fIsHole[i];
	210	p.fZmaxSensitive[i] = fZmaxSensitive[i];
	211	}
	212
	213	// Make a deep copy of the Clusters array and the Index array
	214	// unless they are needed in class AliTRDstackLayer
	215	if (fTimeBinIndex >= 0) {
	216	if (!p.fClusters)
	217	p.fClusters = new AliTRDcluster*[(Int_t)kMaxClusterPerTimeBin];
	218	if (!p.fIndex)
	219	p.fIndex = new UInt_t[(Int_t)kMaxClusterPerTimeBin];
	220	}
	221	for (Int_t i = 0; i < (Int_t)kMaxClusterPerTimeBin; i++){
	222	//overwrite
	223	p.fClusters[i] = fClusters[i];
	224	p.fIndex[i] = fIndex[i];
	225	}
	226
	227	}
228
229	//_____________________________________________________________________________
4d6aee34	230	void AliTRDpropagationLayer::SetZ(Double_t * const center, Double_t * const w, Double_t * const wsensitive )
e4f2f73d	231	{
	232	//
	233	// Set centers and the width of sectors
	234	//
	235
053767a4	236	for (Int_t istack = 0; istack < AliTRDgeometry::kNstack; istack++) {
	237	fZc[istack] = center[istack];
	238	fZmax[istack] = w[istack];
	239	fZmaxSensitive[istack] = wsensitive[istack];
e4f2f73d	240	}
	241
	242	}
	243
	244	//_____________________________________________________________________________
4d6aee34	245	void AliTRDpropagationLayer::SetHoles(Bool_t * const holes)
e4f2f73d	246	{
	247	//
	248	// Set centers and the width of sectors
	249	//
	250
	251	fHole = kFALSE;
	252
053767a4	253	for (Int_t istack = 0; istack < AliTRDgeometry::kNstack; istack++) {
	254	fIsHole[istack] = holes[istack];
	255	if (holes[istack]) {
e4f2f73d	256	fHole = kTRUE;
	257	}
	258	}
	259
	260	}
	261
	262	//_____________________________________________________________________________
	263	void AliTRDpropagationLayer::InsertCluster(AliTRDcluster *c, UInt_t index)
	264	{
	265	//
	266	// Insert cluster in cluster array.
	267	// Clusters are sorted according to Y coordinate.
	268	//
	269
	270	if (fTimeBinIndex < 0) {
	271	//AliWarning("Attempt to insert cluster into non-sensitive time bin!\n");
	272	return;
	273	}
	274
	275	if (fN == (Int_t) kMaxClusterPerTimeBin) {
	276	//AliWarning("Too many clusters !\n");
	277	return;
	278	}
	279
	280	if (fN == 0) {
	281	fIndex[0] = index;
	282	fClusters[fN++] = c;
	283	return;
	284	}
	285
	286	Int_t i = Find(c->GetY());
	287	memmove(fClusters+i+1,fClusters+i,(fN-i)sizeof(AliTRDcluster));
	288	memmove(fIndex +i+1,fIndex +i,(fN-i)*sizeof(UInt_t));
	289	fIndex[i] = index;
	290	fClusters[i] = c;
	291	fN++;
	292
	293	}
	294
	295	//_____________________________________________________________________________
	296	Int_t AliTRDpropagationLayer::Find(Float_t y) const
	297	{
	298	//
	299	// Returns index of the cluster nearest in Y
	300	//
	301
	302	if (fN <= 0) {
	303	return 0;
	304	}
	305	if (y <= fClusters[0]->GetY()) {
	306	return 0;
	307	}
	308	if (y > fClusters[fN-1]->GetY()) {
	309	return fN;
	310	}
	311
	312	Int_t b = 0;
	313	Int_t e = fN - 1;
	314	Int_t m = (b + e) / 2;
	315
	316	for ( ; b < e; m = (b + e) / 2) {
	317	if (y > fClusters[m]->GetY()) {
	318	b = m + 1;
	319	}
320	else {
321	e = m;
322	}
323	}
324
325	return m;
326
327	}
328
329	//_____________________________________________________________________________
330	Int_t AliTRDpropagationLayer::FindNearestCluster(Float_t y, Float_t z
331	, Float_t maxroad
332	, Float_t maxroadz) const
333	{
334	//
335	// Returns index of the cluster nearest to the given y,z
336	//
337
338	Int_t index = -1;
339	Int_t maxn = fN;
340	Float_t mindist = maxroad;
341
342	for (Int_t i = Find(y-maxroad); i < maxn; i++) {
343	AliTRDcluster c = (AliTRDcluster ) (fClusters[i]);
344	Float_t ycl = c->GetY();
345	if (ycl > (y + maxroad)) {
346	break;
347	}
348	if (TMath::Abs(c->GetZ() - z) > maxroadz) {
349	continue;
350	}
351	if (TMath::Abs(ycl - y) < mindist) {
352	mindist = TMath::Abs(ycl - y);
353	index = fIndex[i];
354	}
355	}
356
357	return index;
358
359	}
360