[u/mrichter/AliRoot.git] / PMD / AliPMDEmpDiscriminator.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   : August 05 2003                   //
//  This does photon hadron discrimination on the      // 
//  of matching a PMD cluster with a CPV cluster       //
//                                                     //
//-----------------------------------------------------//

#include <Riostream.h>
#include <TMath.h>
#include <TTree.h>
#include <TObjArray.h>
#include <TClonesArray.h>
#include <TFile.h>
#include <TNtuple.h>
#include <TParticle.h>

#include "AliLog.h"
#include "AliPMDrecpoint1.h"
#include "AliPMDclupid.h"
#include "AliPMDDiscriminator.h"
#include "AliPMDEmpDiscriminator.h"

ClassImp(AliPMDEmpDiscriminator)

AliPMDEmpDiscriminator::AliPMDEmpDiscriminator()
{
//
// Default Constructor
//
}
// -----------------------------------------------------------------------
AliPMDEmpDiscriminator::~AliPMDEmpDiscriminator()
{
  // Destructor
}

// -----------------------------------------------------------------------

void AliPMDEmpDiscriminator::Discrimination(TObjArray *pmdcontin, TObjArray *pmdcontout)
{
  // Does Photon/Hadron discrimination
  // matching the clusters of CPV and PREshower plane
  //
  const  Int_t kumperdet = 24;
  static Int_t neibx[6]={1,0,-1,-1,0,1}, neiby[6]={0,1,1,0,-1,-1}; 
  Int_t   det,smn;
  Int_t   iprecount[24], icpvcount[24];
  Float_t xpos,ypos;
  Float_t adc, ncell, rad;
  Float_t clusdata[6];

  for(Int_t i = 0; i < kumperdet; i++)
    {
      iprecount[i] = 0;
      icpvcount[i] = 0;
    }
  AliPMDrecpoint1  *pmdcl    = 0;
  AliPMDclupid   *pmdclout = 0;

  Int_t nentries1 = pmdcontin->GetEntries();

  AliDebug(1,Form("Number of total clusters from CPV PRE = %d",nentries1));
  for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
    {
      pmdcl = (AliPMDrecpoint1*)pmdcontin->UncheckedAt(ient1);

      det   = pmdcl->GetDetector();
      smn   = pmdcl->GetSMNumber();
      if(det == 0) iprecount[smn]++;
      if(det == 1) icpvcount[smn]++;
    } // Entries of TObjArray loop

  Int_t   idet, ismn;
  Float_t edepcpv[48][96];
  Int_t   statuscpv[48][96];

  for(Int_t i = 0; i < kumperdet; i++) // unit module
    {
      // Initialisation of the ADC of CPV (1UM)
      for (Int_t ix = 0; ix < 48;ix++)
	{
	  for (Int_t iy = 0; iy < 96;iy++)
	    {
	      edepcpv[ix][iy]   = 0.;
	      statuscpv[ix][iy] = 0;
	    }
	}
      Int_t precounter   = iprecount[i];
      Int_t cpvcounter   = icpvcount[i];
      
      Float_t *xpadpre   = new Float_t[precounter];
      Float_t *ypadpre   = new Float_t[precounter];
      Float_t *adcpre    = new Float_t[precounter];
      Float_t *ncellpre  = new Float_t[precounter];
      Float_t *radpre    = new Float_t[precounter];
      Int_t   *sortcoord = new Int_t[precounter];
      Int_t   *clupidpre = new Int_t[precounter];

      Float_t *xpadcpv   = new Float_t[cpvcounter];
      Float_t *ypadcpv   = new Float_t[cpvcounter];
      Float_t *adccpv    = new Float_t[cpvcounter];
      Float_t *ncellcpv  = new Float_t[cpvcounter];
      Float_t *radcpv    = new Float_t[cpvcounter];

      Int_t ii = 0;
      Int_t ij = 0;
      for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
	{
	  pmdcl = (AliPMDrecpoint1*)pmdcontin->UncheckedAt(ient1);
	  
	  det   = pmdcl->GetDetector();
	  smn   = pmdcl->GetSMNumber();
	  xpos  = pmdcl->GetClusX();
	  ypos  = pmdcl->GetClusY();
	  adc   = pmdcl->GetClusADC();
	  ncell = pmdcl->GetClusCells();
	  rad   = pmdcl->GetClusSigmaX();

	  if(det == 0 && smn == i)
	    {
	      xpadpre[ii]  = xpos;
	      ypadpre[ii]  = ypos;
	      adcpre[ii]   = adc;
	      ncellpre[ii] = ncell;
	      radpre[ii]   = rad;
	      ii++;
	    }
	  if(det == 1 && smn == i)
	    {
	      Int_t ix = (Int_t) (xpos+0.5);
	      Int_t iy = (Int_t) (ypos+0.5);
	      if(ix > 47) ix = 47;
	      if(iy > 95) iy = 95;
	      edepcpv[ix][iy] = adc;
	      xpadcpv[ij]  = xpos;
	      ypadcpv[ij]  = ypos;
	      adccpv[ij]   = adc;
	      ncellcpv[ij] = ncell;
	      radcpv[ij]   = rad;
	      ij++;
	    }
	} // Entries of TObjArray loop
      // sorts from lowest ADC to highest ADC
      // and returns the coordinates
      Bool_t jsort = false;
      TMath::Sort(precounter,adcpre,sortcoord,jsort);

      Int_t jjsort = 0;
      for(Int_t jj=0; jj<precounter; jj++)
	{
	  // PRE information
	  // PIDs for PRE clusters are 0(photon) and 1(hadron)

	  jjsort = sortcoord[jj];

	  Int_t ix = (Int_t) (xpadpre[jjsort]+0.5);
	  Int_t iy = (Int_t) (ypadpre[jjsort]+0.5);
	  if(ix > 47) ix = 47;
	  if(iy > 95) iy = 95;

	  for(Int_t jk=0; jk<6; jk++)
	    {
	      Int_t jd1 = ix + neibx[jk]; 
	      Int_t jd2 = iy + neiby[jk];
	      if(jd1 <0 ) jd1 = 0;
	      if(jd1 >47) jd1 = 47;
	      if(jd2 <0 ) jd2 = 0;
	      if(jd2 >47) jd2 = 47;
	      if(edepcpv[jd1][jd2] > 0.0 && statuscpv[jd1][jd2] == 0)
		{
		  statuscpv[jd1][jd2] = 1;
		  clupidpre[jjsort]   = 1;
		  break;
		}
	    }

	  idet        = 0;
	  ismn        = i;
	  clusdata[0] = xpadpre[jjsort];
	  clusdata[1] = ypadpre[jjsort];
	  clusdata[2] = adcpre[jjsort];
	  clusdata[3] = ncellpre[jjsort];
	  clusdata[4] = radpre[jjsort];
	  //PH	  clusdata[5] = (Float_t) clupidpre[jjsort];

	  // Temporary the cluster PID is set to 1 if the
	  // adc > 3MIP units which will be changed later on.

	  if (adcpre[jjsort] > 300.)
	    {
	      clusdata[5] = 1.0;
	    }
	  else
	    {
	      clusdata[5] = 0.0;
	    }
	  pmdclout = new AliPMDclupid(idet,ismn,clusdata);
	  pmdcontout->Add(pmdclout);
	} // jj loop

      for(Int_t jj=0; jj<cpvcounter; jj++)
	{
	  // CPV information
	  // PID for CPV clusters is 1

	  idet        = 1;
	  ismn        = i;
	  clusdata[0] = xpadcpv[jj];
	  clusdata[1] = ypadcpv[jj];
	  clusdata[2] = adccpv[jj];
	  clusdata[3] = ncellcpv[jj];
	  clusdata[4] = radcpv[jj];
	  clusdata[5] = 0.;

	  pmdclout = new AliPMDclupid(idet,ismn,clusdata);
	  pmdcontout->Add(pmdclout);
	}

      // delete all the pointers
      delete [] xpadpre;
      delete [] ypadpre;
      delete [] adcpre;
      delete [] ncellpre;
      delete [] radpre;
      delete [] sortcoord;
      delete [] clupidpre;
      delete [] xpadcpv;
      delete [] ypadcpv;
      delete [] adccpv;
      delete [] ncellcpv;
      delete [] radcpv;
    } // i loop

}
// -----------------------------------------------------------------------
Commit	Line	Data
077a4c66	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 : August 05 2003 //
	19	// This does photon hadron discrimination on the //
	20	// of matching a PMD cluster with a CPV cluster //
	21	// //
	22	//-----------------------------------------------------//
	23
	24	#include <Riostream.h>
	25	#include <TMath.h>
077a4c66	26	#include <TTree.h>
077a4c66	27	#include <TObjArray.h>
	28	#include <TClonesArray.h>
	29	#include <TFile.h>
	30	#include <TNtuple.h>
	31	#include <TParticle.h>
	32
	33	#include "AliLog.h"
077a4c66	34	#include "AliPMDrecpoint1.h"
	35	#include "AliPMDclupid.h"
	36	#include "AliPMDDiscriminator.h"
	37	#include "AliPMDEmpDiscriminator.h"
	38
	39	ClassImp(AliPMDEmpDiscriminator)
	40
	41	AliPMDEmpDiscriminator::AliPMDEmpDiscriminator()
	42	{
	43	//
	44	// Default Constructor
	45	//
	46	}
	47	// -----------------------------------------------------------------------
	48	AliPMDEmpDiscriminator::~AliPMDEmpDiscriminator()
	49	{
	50	// Destructor
	51	}
	52
	53	// -----------------------------------------------------------------------
	54
	55	void AliPMDEmpDiscriminator::Discrimination(TObjArray pmdcontin, TObjArray pmdcontout)
	56	{
	57	// Does Photon/Hadron discrimination
	58	// matching the clusters of CPV and PREshower plane
	59	//
	60	const Int_t kumperdet = 24;
	61	static Int_t neibx[6]={1,0,-1,-1,0,1}, neiby[6]={0,1,1,0,-1,-1};
	62	Int_t det,smn;
	63	Int_t iprecount[24], icpvcount[24];
	64	Float_t xpos,ypos;
	65	Float_t adc, ncell, rad;
	66	Float_t clusdata[6];
	67
	68	for(Int_t i = 0; i < kumperdet; i++)
	69	{
	70	iprecount[i] = 0;
	71	icpvcount[i] = 0;
	72	}
	73	AliPMDrecpoint1 *pmdcl = 0;
	74	AliPMDclupid *pmdclout = 0;
	75
	76	Int_t nentries1 = pmdcontin->GetEntries();
	77
	78	AliDebug(1,Form("Number of total clusters from CPV PRE = %d",nentries1));
	79	for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
	80	{
	81	pmdcl = (AliPMDrecpoint1*)pmdcontin->UncheckedAt(ient1);
	82
	83	det = pmdcl->GetDetector();
	84	smn = pmdcl->GetSMNumber();
	85	if(det == 0) iprecount[smn]++;
	86	if(det == 1) icpvcount[smn]++;
	87	} // Entries of TObjArray loop
	88
	89	Int_t idet, ismn;
	90	Float_t edepcpv[48][96];
	91	Int_t statuscpv[48][96];
	92
	93	for(Int_t i = 0; i < kumperdet; i++) // unit module
	94	{
	95	// Initialisation of the ADC of CPV (1UM)
	96	for (Int_t ix = 0; ix < 48;ix++)
	97	{
98	for (Int_t iy = 0; iy < 96;iy++)
99	{
100	edepcpv[ix][iy] = 0.;
101	statuscpv[ix][iy] = 0;
102	}
103	}
104	Int_t precounter = iprecount[i];
105	Int_t cpvcounter = icpvcount[i];
106
107	Float_t *xpadpre = new Float_t[precounter];
108	Float_t *ypadpre = new Float_t[precounter];
109	Float_t *adcpre = new Float_t[precounter];
110	Float_t *ncellpre = new Float_t[precounter];
111	Float_t *radpre = new Float_t[precounter];
112	Int_t *sortcoord = new Int_t[precounter];
113	Int_t *clupidpre = new Int_t[precounter];
114
115	Float_t *xpadcpv = new Float_t[cpvcounter];
116	Float_t *ypadcpv = new Float_t[cpvcounter];
117	Float_t *adccpv = new Float_t[cpvcounter];
118	Float_t *ncellcpv = new Float_t[cpvcounter];
119	Float_t *radcpv = new Float_t[cpvcounter];
120
121	Int_t ii = 0;
122	Int_t ij = 0;
123	for (Int_t ient1 = 0; ient1 < nentries1; ient1++)
124	{
125	pmdcl = (AliPMDrecpoint1*)pmdcontin->UncheckedAt(ient1);
126
127	det = pmdcl->GetDetector();
128	smn = pmdcl->GetSMNumber();
129	xpos = pmdcl->GetClusX();
130	ypos = pmdcl->GetClusY();
131	adc = pmdcl->GetClusADC();
132	ncell = pmdcl->GetClusCells();
133	rad = pmdcl->GetClusSigmaX();
134
135	if(det == 0 && smn == i)
136	{
137	xpadpre[ii] = xpos;
138	ypadpre[ii] = ypos;
139	adcpre[ii] = adc;
140	ncellpre[ii] = ncell;
141	radpre[ii] = rad;
142	ii++;
143	}
144	if(det == 1 && smn == i)
145	{
146	Int_t ix = (Int_t) (xpos+0.5);
147	Int_t iy = (Int_t) (ypos+0.5);
148	if(ix > 47) ix = 47;
149	if(iy > 95) iy = 95;
150	edepcpv[ix][iy] = adc;
151	xpadcpv[ij] = xpos;
152	ypadcpv[ij] = ypos;
153	adccpv[ij] = adc;
154	ncellcpv[ij] = ncell;
155	radcpv[ij] = rad;
156	ij++;
157	}
158	} // Entries of TObjArray loop
159	// sorts from lowest ADC to highest ADC
160	// and returns the coordinates
161	Bool_t jsort = false;
162	TMath::Sort(precounter,adcpre,sortcoord,jsort);
163
164	Int_t jjsort = 0;
165	for(Int_t jj=0; jj<precounter; jj++)
166	{
167	// PRE information
168	// PIDs for PRE clusters are 0(photon) and 1(hadron)
169
170	jjsort = sortcoord[jj];
171
172	Int_t ix = (Int_t) (xpadpre[jjsort]+0.5);
173	Int_t iy = (Int_t) (ypadpre[jjsort]+0.5);
174	if(ix > 47) ix = 47;
175	if(iy > 95) iy = 95;
176
177	for(Int_t jk=0; jk<6; jk++)
178	{
179	Int_t jd1 = ix + neibx[jk];
180	Int_t jd2 = iy + neiby[jk];
181	if(jd1 <0 ) jd1 = 0;
182	if(jd1 >47) jd1 = 47;
183	if(jd2 <0 ) jd2 = 0;
184	if(jd2 >47) jd2 = 47;
185	if(edepcpv[jd1][jd2] > 0.0 && statuscpv[jd1][jd2] == 0)
186	{
187	statuscpv[jd1][jd2] = 1;
188	clupidpre[jjsort] = 1;
189	break;
190	}
191	}
192
193	idet = 0;
194	ismn = i;
195	clusdata[0] = xpadpre[jjsort];
196	clusdata[1] = ypadpre[jjsort];
197	clusdata[2] = adcpre[jjsort];
198	clusdata[3] = ncellpre[jjsort];
199	clusdata[4] = radpre[jjsort];
200	//PH clusdata[5] = (Float_t) clupidpre[jjsort];
201
202	// Temporary the cluster PID is set to 1 if the
203	// adc > 3MIP units which will be changed later on.
204
205	if (adcpre[jjsort] > 300.)
206	{
207	clusdata[5] = 1.0;
208	}
209	else
210	{
211	clusdata[5] = 0.0;
212	}
213	pmdclout = new AliPMDclupid(idet,ismn,clusdata);
214	pmdcontout->Add(pmdclout);
215	} // jj loop
216
217	for(Int_t jj=0; jj<cpvcounter; jj++)
218	{
219	// CPV information
220	// PID for CPV clusters is 1
221
222	idet = 1;
223	ismn = i;
224	clusdata[0] = xpadcpv[jj];
225	clusdata[1] = ypadcpv[jj];
226	clusdata[2] = adccpv[jj];
227	clusdata[3] = ncellcpv[jj];
228	clusdata[4] = radcpv[jj];
229	clusdata[5] = 0.;
230
231	pmdclout = new AliPMDclupid(idet,ismn,clusdata);
232	pmdcontout->Add(pmdclout);
233	}
234
235	// delete all the pointers
236	delete [] xpadpre;
237	delete [] ypadpre;
238	delete [] adcpre;
239	delete [] ncellpre;
240	delete [] radpre;
316c6cd9	241	delete [] sortcoord;
077a4c66	242	delete [] clupidpre;
	243	delete [] xpadcpv;
	244	delete [] ypadcpv;
	245	delete [] adccpv;
	246	delete [] ncellcpv;
	247	delete [] radcpv;
	248	} // i loop
	249
	250	}
	251	// -----------------------------------------------------------------------