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

//-----------------------------------------------------//
//                                                     //
//           Date   : March 25 2004                    //
//  This reads the file PMD.RecPoints.root(TreeR),     //
//  calls the Clustering algorithm and stores the      //
//  clustering output in PMD.RecPoints.root(TreeR)     // 
//                                                     //
//-----------------------------------------------------//

#include <Riostream.h>
#include <TMath.h>
#include <TBRIK.h>
#include <TNode.h>
#include <TTree.h>
#include <TGeometry.h>
#include <TObjArray.h>
#include <TClonesArray.h>
#include <TFile.h>
#include <TBranch.h>
#include <TNtuple.h>
#include <TParticle.h>

#include "AliPMDcluster.h"
#include "AliPMDclupid.h"
#include "AliPMDrecpoint1.h"
#include "AliPMDUtility.h"
#include "AliPMDDiscriminator.h"
#include "AliPMDEmpDiscriminator.h"
#include "AliPMDtracker.h"

#include "AliESDPmdTrack.h"
#include "AliESD.h"
#include "AliLog.h"

ClassImp(AliPMDtracker)

AliPMDtracker::AliPMDtracker():
  fTreeR(0),
  fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
  fPMDcontin(new TObjArray()),
  fPMDcontout(new TObjArray()),
  fPMDutil(new AliPMDUtility()),
  fPMDrecpoint(0),
  fPMDclin(0),
  fPMDclout(0),
  fXvertex(0.),
  fYvertex(0.),
  fZvertex(0.),
  fSigmaX(0.),
  fSigmaY(0.),
  fSigmaZ(0.)
{
  //
  // Default Constructor
  //
}
//--------------------------------------------------------------------//
AliPMDtracker:: AliPMDtracker(const AliPMDtracker & /* tracker */):
  TObject(/* tracker */),
  fTreeR(0),
  fRecpoints(NULL),
  fPMDcontin(NULL),
  fPMDcontout(NULL),
  fPMDutil(NULL),
  fPMDrecpoint(0),
  fPMDclin(0),
  fPMDclout(0),
  fXvertex(0.),
  fYvertex(0.),
  fZvertex(0.),
  fSigmaX(0.),
  fSigmaY(0.),
  fSigmaZ(0.)
{
  // copy constructor
  AliError("Copy constructor not allowed");
}

//--------------------------------------------------------------------//
AliPMDtracker& AliPMDtracker::operator=(const AliPMDtracker & /* tracker */)
{
 // assignment operator
  AliError("Assignment operator not allowed");
  return *this;
}

//--------------------------------------------------------------------//
AliPMDtracker::~AliPMDtracker()
{
  // Destructor
  if (fRecpoints)
    {
      fRecpoints->Delete();
      delete fRecpoints;
      fRecpoints=0;
    }
  if (fPMDcontin)
    {
      fPMDcontin->Delete();
      delete fPMDcontin;
      fPMDcontin=0;
    }
  if (fPMDcontout)
    {
      fPMDcontout->Delete();
      delete fPMDcontout;
      fPMDcontout=0;
    }
}
//--------------------------------------------------------------------//
void AliPMDtracker::LoadClusters(TTree *treein)
{
  // Load the Reconstructed tree
  fTreeR = treein;
}
//--------------------------------------------------------------------//
void AliPMDtracker::Clusters2Tracks(AliESD *event)
{
  // Converts digits to recpoints after running clustering
  // algorithm on CPV plane and PREshower plane
  //

  Int_t   idet;
  Int_t   ismn;
  Float_t clusdata[6];

  TBranch *branch = fTreeR->GetBranch("PMDRecpoint");
  if (!branch)
    {
      AliError("PMDRecpoint branch not found");
      return;
    }
  branch->SetAddress(&fRecpoints);  
  
  Int_t   nmodules = (Int_t) branch->GetEntries();
  
  AliDebug(1,Form("Number of modules filled in treeR = %d",nmodules));
  for (Int_t imodule = 0; imodule < nmodules; imodule++)
    {
      branch->GetEntry(imodule); 
      Int_t nentries = fRecpoints->GetLast();
      AliDebug(2,Form("Number of clusters per modules filled in treeR = %d"
		      ,nentries));
      for(Int_t ient = 0; ient < nentries+1; ient++)
	{
	  fPMDrecpoint = (AliPMDrecpoint1*)fRecpoints->UncheckedAt(ient);
	  idet        = fPMDrecpoint->GetDetector();
	  ismn        = fPMDrecpoint->GetSMNumber();
	  clusdata[0] = fPMDrecpoint->GetClusX();
	  clusdata[1] = fPMDrecpoint->GetClusY();
	  clusdata[2] = fPMDrecpoint->GetClusADC();
	  clusdata[3] = fPMDrecpoint->GetClusCells();
	  clusdata[4] = fPMDrecpoint->GetClusSigmaX();
	  clusdata[5] = fPMDrecpoint->GetClusSigmaY();

	  fPMDclin = new AliPMDrecpoint1(idet,ismn,clusdata);
	  fPMDcontin->Add(fPMDclin);
	}
    }

  AliPMDDiscriminator *pmddiscriminator = new AliPMDEmpDiscriminator();
  pmddiscriminator->Discrimination(fPMDcontin,fPMDcontout);

  const Float_t kzpos = 361.5;    // middle of the PMD

  Int_t   det,smn;
  Float_t xpos,ypos;
  Float_t adc, ncell, rad;
  Float_t xglobal = 0., yglobal = 0., zglobal = 0;
  Float_t pid;


  Int_t nentries2 = fPMDcontout->GetEntries();
  AliDebug(1,Form("Number of clusters coming after discrimination = %d"
		  ,nentries2));
  for (Int_t ient1 = 0; ient1 < nentries2; ient1++)
    {
      fPMDclout = (AliPMDclupid*)fPMDcontout->UncheckedAt(ient1);
      
      det   = fPMDclout->GetDetector();
      smn   = fPMDclout->GetSMN();
      xpos  = fPMDclout->GetClusX();
      ypos  = fPMDclout->GetClusY();
      adc   = fPMDclout->GetClusADC();
      ncell = fPMDclout->GetClusCells();
      rad   = fPMDclout->GetClusRadius();
      pid   = fPMDclout->GetClusPID();
      
      //
      /**********************************************************************
       *    det   : Detector, 0: PRE & 1:CPV                                *
       *    smn   : Serial Module Number 0 to 23 for each plane             *
       *    xpos  : x-position of the cluster                               *
       *    ypos  : y-position of the cluster                               *
       *            THESE xpos & ypos are not the true xpos and ypos        *
       *            for some of the unit modules. They are rotated.         *
       *    adc   : ADC contained in the cluster                            *
       *    ncell : Number of cells contained in the cluster                *
       *    rad   : radius of the cluster (1d fit)                          *
       **********************************************************************/
      //

      fPMDutil->RectGeomCellPos(smn,xpos,ypos,xglobal,yglobal);

      if (det == 0)
	{
	  zglobal = kzpos + 1.6; // PREshower plane
	}
      else if (det == 1)
	{
	  zglobal = kzpos - 1.7; // CPV plane
	}

      // Fill ESD

      AliESDPmdTrack *esdpmdtr = new  AliESDPmdTrack();

      esdpmdtr->SetDetector(det);
      esdpmdtr->SetClusterX(xglobal);
      esdpmdtr->SetClusterY(yglobal);
      esdpmdtr->SetClusterZ(zglobal);
      esdpmdtr->SetClusterADC(adc);
      esdpmdtr->SetClusterCells(ncell);
      esdpmdtr->SetClusterPID(pid);

      event->AddPmdTrack(esdpmdtr);
    }
}
//--------------------------------------------------------------------//
void AliPMDtracker::SetVertex(Double_t vtx[3], Double_t evtx[3])
{
  fXvertex = vtx[0];
  fYvertex = vtx[1];
  fZvertex = vtx[2];
  fSigmaX  = evtx[0];
  fSigmaY  = evtx[1];
  fSigmaZ  = evtx[2];
}
//--------------------------------------------------------------------//
void AliPMDtracker::ResetClusters()
{
  if (fRecpoints) fRecpoints->Clear();
}
//--------------------------------------------------------------------//
Commit	Line	Data
7dcaf913	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	// //
	18	// Date : March 25 2004 //
	19	// This reads the file PMD.RecPoints.root(TreeR), //
	20	// calls the Clustering algorithm and stores the //
	21	// clustering output in PMD.RecPoints.root(TreeR) //
	22	// //
	23	//-----------------------------------------------------//
	24
	25	#include <Riostream.h>
	26	#include <TMath.h>
	27	#include <TBRIK.h>
	28	#include <TNode.h>
	29	#include <TTree.h>
	30	#include <TGeometry.h>
	31	#include <TObjArray.h>
	32	#include <TClonesArray.h>
	33	#include <TFile.h>
	34	#include <TBranch.h>
	35	#include <TNtuple.h>
	36	#include <TParticle.h>
	37
	38	#include "AliPMDcluster.h"
	39	#include "AliPMDclupid.h"
	40	#include "AliPMDrecpoint1.h"
	41	#include "AliPMDUtility.h"
	42	#include "AliPMDDiscriminator.h"
26f1ae17	43	#include "AliPMDEmpDiscriminator.h"
7dcaf913	44	#include "AliPMDtracker.h"
	45
	46	#include "AliESDPmdTrack.h"
	47	#include "AliESD.h"
ecee2a1a	48	#include "AliLog.h"
7dcaf913	49
	50	ClassImp(AliPMDtracker)
	51
	52	AliPMDtracker::AliPMDtracker():
	53	fTreeR(0),
	54	fRecpoints(new TClonesArray("AliPMDrecpoint1", 1000)),
	55	fPMDcontin(new TObjArray()),
	56	fPMDcontout(new TObjArray()),
7dcaf913	57	fPMDutil(new AliPMDUtility()),
	58	fPMDrecpoint(0),
	59	fPMDclin(0),
	60	fPMDclout(0),
7dcaf913	61	fXvertex(0.),
	62	fYvertex(0.),
	63	fZvertex(0.),
	64	fSigmaX(0.),
	65	fSigmaY(0.),
	66	fSigmaZ(0.)
	67	{
	68	//
	69	// Default Constructor
	70	//
	71	}
a48edddd	72	//--------------------------------------------------------------------//
a48edddd	73	AliPMDtracker:: AliPMDtracker(const AliPMDtracker & /* tracker */):
2332574a	74	TObject(/* tracker */),
	75	fTreeR(0),
	76	fRecpoints(NULL),
	77	fPMDcontin(NULL),
	78	fPMDcontout(NULL),
	79	fPMDutil(NULL),
	80	fPMDrecpoint(0),
	81	fPMDclin(0),
	82	fPMDclout(0),
	83	fXvertex(0.),
	84	fYvertex(0.),
	85	fZvertex(0.),
	86	fSigmaX(0.),
	87	fSigmaY(0.),
	88	fSigmaZ(0.)
a48edddd	89	{
	90	// copy constructor
	91	AliError("Copy constructor not allowed");
	92	}
	93
	94	//--------------------------------------------------------------------//
	95	AliPMDtracker& AliPMDtracker::operator=(const AliPMDtracker & /* tracker */)
	96	{
	97	// assignment operator
	98	AliError("Assignment operator not allowed");
	99	return *this;
	100	}
	101
7dcaf913	102	//--------------------------------------------------------------------//
	103	AliPMDtracker::~AliPMDtracker()
	104	{
	105	// Destructor
	106	if (fRecpoints)
	107	{
	108	fRecpoints->Delete();
	109	delete fRecpoints;
	110	fRecpoints=0;
	111	}
	112	if (fPMDcontin)
	113	{
	114	fPMDcontin->Delete();
	115	delete fPMDcontin;
	116	fPMDcontin=0;
	117	}
	118	if (fPMDcontout)
	119	{
	120	fPMDcontout->Delete();
	121	delete fPMDcontout;
	122	fPMDcontout=0;
	123	}
	124	}
	125	//--------------------------------------------------------------------//
	126	void AliPMDtracker::LoadClusters(TTree *treein)
	127	{
	128	// Load the Reconstructed tree
	129	fTreeR = treein;
	130	}
	131	//--------------------------------------------------------------------//
	132	void AliPMDtracker::Clusters2Tracks(AliESD *event)
	133	{
	134	// Converts digits to recpoints after running clustering
	135	// algorithm on CPV plane and PREshower plane
	136	//
	137
	138	Int_t idet;
	139	Int_t ismn;
26f1ae17	140	Float_t clusdata[6];
7dcaf913	141
7dcaf913	142	TBranch *branch = fTreeR->GetBranch("PMDRecpoint");
ecee2a1a	143	if (!branch)
	144	{
	145	AliError("PMDRecpoint branch not found");
	146	return;
	147	}
7dcaf913	148	branch->SetAddress(&fRecpoints);
7dcaf913	149
26f1ae17	150	Int_t nmodules = (Int_t) branch->GetEntries();
26f1ae17	151
ecee2a1a	152	AliDebug(1,Form("Number of modules filled in treeR = %d",nmodules));
7dcaf913	153	for (Int_t imodule = 0; imodule < nmodules; imodule++)
7dcaf913	154	{
26f1ae17	155	branch->GetEntry(imodule);
7dcaf913	156	Int_t nentries = fRecpoints->GetLast();
ecee2a1a	157	AliDebug(2,Form("Number of clusters per modules filled in treeR = %d"
ecee2a1a	158	,nentries));
7dcaf913	159	for(Int_t ient = 0; ient < nentries+1; ient++)
	160	{
	161	fPMDrecpoint = (AliPMDrecpoint1*)fRecpoints->UncheckedAt(ient);
	162	idet = fPMDrecpoint->GetDetector();
	163	ismn = fPMDrecpoint->GetSMNumber();
	164	clusdata[0] = fPMDrecpoint->GetClusX();
	165	clusdata[1] = fPMDrecpoint->GetClusY();
	166	clusdata[2] = fPMDrecpoint->GetClusADC();
	167	clusdata[3] = fPMDrecpoint->GetClusCells();
26f1ae17	168	clusdata[4] = fPMDrecpoint->GetClusSigmaX();
	169	clusdata[5] = fPMDrecpoint->GetClusSigmaY();
	170
	171	fPMDclin = new AliPMDrecpoint1(idet,ismn,clusdata);
7dcaf913	172	fPMDcontin->Add(fPMDclin);
	173	}
	174	}
	175
26f1ae17	176	AliPMDDiscriminator *pmddiscriminator = new AliPMDEmpDiscriminator();
26f1ae17	177	pmddiscriminator->Discrimination(fPMDcontin,fPMDcontout);
7dcaf913	178
50555ba1	179	const Float_t kzpos = 361.5; // middle of the PMD
01c4d84a	180
7dcaf913	181	Int_t det,smn;
7dcaf913	182	Float_t xpos,ypos;
7dcaf913	183	Float_t adc, ncell, rad;
01c4d84a	184	Float_t xglobal = 0., yglobal = 0., zglobal = 0;
7dcaf913	185	Float_t pid;
7dcaf913	186
7dcaf913	187
7dcaf913	188	Int_t nentries2 = fPMDcontout->GetEntries();
ecee2a1a	189	AliDebug(1,Form("Number of clusters coming after discrimination = %d"
ecee2a1a	190	,nentries2));
7dcaf913	191	for (Int_t ient1 = 0; ient1 < nentries2; ient1++)
	192	{
	193	fPMDclout = (AliPMDclupid*)fPMDcontout->UncheckedAt(ient1);
	194
	195	det = fPMDclout->GetDetector();
	196	smn = fPMDclout->GetSMN();
	197	xpos = fPMDclout->GetClusX();
	198	ypos = fPMDclout->GetClusY();
	199	adc = fPMDclout->GetClusADC();
	200	ncell = fPMDclout->GetClusCells();
	201	rad = fPMDclout->GetClusRadius();
	202	pid = fPMDclout->GetClusPID();
	203
7dcaf913	204	//
	205	/**********************************************************************
	206	* det : Detector, 0: PRE & 1:CPV *
01c4d84a	207	* smn : Serial Module Number 0 to 23 for each plane *
7dcaf913	208	* xpos : x-position of the cluster *
	209	* ypos : y-position of the cluster *
	210	* THESE xpos & ypos are not the true xpos and ypos *
	211	* for some of the unit modules. They are rotated. *
	212	* adc : ADC contained in the cluster *
	213	* ncell : Number of cells contained in the cluster *
	214	* rad : radius of the cluster (1d fit) *
7dcaf913	215	**********************************************************************/
7dcaf913	216	//
01c4d84a	217
01c4d84a	218	fPMDutil->RectGeomCellPos(smn,xpos,ypos,xglobal,yglobal);
26f1ae17	219
	220	if (det == 0)
	221	{
50555ba1	222	zglobal = kzpos + 1.6; // PREshower plane
26f1ae17	223	}
	224	else if (det == 1)
	225	{
50555ba1	226	zglobal = kzpos - 1.7; // CPV plane
26f1ae17	227	}
26f1ae17	228
7dcaf913	229	// Fill ESD
	230
	231	AliESDPmdTrack *esdpmdtr = new AliESDPmdTrack();
	232
	233	esdpmdtr->SetDetector(det);
26f1ae17	234	esdpmdtr->SetClusterX(xglobal);
	235	esdpmdtr->SetClusterY(yglobal);
	236	esdpmdtr->SetClusterZ(zglobal);
7dcaf913	237	esdpmdtr->SetClusterADC(adc);
26f1ae17	238	esdpmdtr->SetClusterCells(ncell);
7dcaf913	239	esdpmdtr->SetClusterPID(pid);
	240
	241	event->AddPmdTrack(esdpmdtr);
	242	}
7dcaf913	243	}
	244	//--------------------------------------------------------------------//
	245	void AliPMDtracker::SetVertex(Double_t vtx[3], Double_t evtx[3])
	246	{
	247	fXvertex = vtx[0];
	248	fYvertex = vtx[1];
	249	fZvertex = vtx[2];
	250	fSigmaX = evtx[0];
	251	fSigmaY = evtx[1];
	252	fSigmaZ = evtx[2];
	253	}
	254	//--------------------------------------------------------------------//
7dcaf913	255	void AliPMDtracker::ResetClusters()
	256	{
	257	if (fRecpoints) fRecpoints->Clear();
	258	}
	259	//--------------------------------------------------------------------//