[u/mrichter/AliRoot.git] / PMD / AliPMDRecpointRead.C

// ----------------------------------------------------//
//                                                     //
//       This macro reads the PMD clusters which       //
//       are stored in the file "PMD.RecPoints.root"   //
//                                                     //
// ----------------------------------------------------//

#include <Riostream.h>
#include "TBranch.h"
#include "TStopwatch.h"

extern AliRun *gAlice;

Int_t AliPMDRecpointRead(Int_t nevent = 1)
{
  if (gAlice)
    { 
      delete gAlice->GetRunLoader();
      delete gAlice;//if everything was OK here it is already NULL
      gAlice = 0x0;
    }
  AliRunLoader *fRunLoader = AliRunLoader::Open("galice.root","Event","update");
  if (!fRunLoader)
    {
      cerr<<"Can't load RunLoader"<<endl;
      return 1;
    }
  AliLoader *pmdloader = fRunLoader->GetLoader("PMDLoader");
  Int_t nevent = fRunLoader->GetNumberOfEvents();
  cout << " * *********** nevent = " << nevent << endl;
  
  if (pmdloader == 0x0)
    {
      cerr<<" ===> Can not find PMD or PMDLoader <===\n";
      delete fRunLoader;
      return 2;
    }
  
  pmdloader->LoadRecPoints("READ");
  TClonesArray *fRecpoints;
  AliPMDUtility *cc = new AliPMDUtility();
  TH2F *h2 = new TH2F("h2"," ",100,-100.,100.,100,-100.,100.);

  FILE *fpw = fopen("junk_rec.dat","w");
  
  for (Int_t ievt = 0; ievt < nevent; ievt++)
    {
      fRunLoader->GetEvent(ievt);
      TTree *treeR = pmdloader->TreeR();
      if (treeR == 0x0)
	{
	  cout << " Can not get TreeR" << endl;
	  return 3;
	}

      AliPMDrecpoint1  *pmdrecpoint;
      TBranch *branch1 = treeR->GetBranch("PMDRecpoint");
      branch1->SetAddress(&fRecpoints);
      /**********************************************************************
       *    det   : Detector, 0: PRE & 1:CPV                                *
       *    smn   : Serial Module Number from which Super Module Number     *
       *            and Unit Module Numbers are extracted                   *
       *    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)                          *
       *    ism   : Supermodule number extracted from smn                   *
       *    ium   : Unit module number extracted from smn                   *
       *    xpad  : TRUE x-position of the cluster                          *
       *    ypad  : TRUE y-position of the cluster                          *
       **********************************************************************/
      Int_t   ism, ium;
      Int_t   det,smn;
      Float_t xpos,ypos, xpad, ypad;
      Float_t adc, ncell, sigx, sigy;
      Float_t xx, yy;
      Int_t   nmodules = branch1->GetEntries();
      cout << " nmodules = " << nmodules << endl;
      for (Int_t imodule = 0; imodule < nmodules; imodule++)
	{
	  branch1->GetEntry(imodule); 
	  Int_t nentries = fRecpoints->GetLast();
	  for(Int_t ient = 0; ient < nentries+1; ient++)
	    {
	      pmdrecpoint = (AliPMDrecpoint1*)fRecpoints->UncheckedAt(ient);
	      det   = (Int_t) pmdrecpoint->GetDetector();
	      smn   = (Int_t) pmdrecpoint->GetSMNumber();
	      xpos  = pmdrecpoint->GetClusX();
	      ypos  = pmdrecpoint->GetClusY();
	      adc   = pmdrecpoint->GetClusADC();
	      ncell = pmdrecpoint->GetClusCells();
	      sigx  = pmdrecpoint->GetClusSigmaX();
	      sigy  = pmdrecpoint->GetClusSigmaY();
	      //
	      // Now change the xpos and ypos to its original values
	      // for the unit modules which are earlier changed.
	      // xpad and ypad are the real positions.
	      //
	      if(det == 0 || det == 1)
		{
		  if(smn < 12)
		    {
		      ism  = smn/6;
		      ium  = smn - ism*6;
		      xpad = ypos;
		      ypad = xpos;
		    }
		  else if( smn >= 12 && smn < 24)
		    {
		      ism  = smn/6;
		      ium  = smn - ism*6;
		      xpad = xpos;
		      ypad = ypos;
		    }
		}
	      //
	      // User has to plug in his analysis code here
	      //

	      fprintf(fpw,"%d %d %d %d %f %f %f %f %f %f\n",
		      det,smn,ism,ium,xpad,ypad,adc,ncell,sigx,sigy);
	      //
	      // Plot the cluster centroid to see the PMD geometry
	      // using the PMD Utility class
	      //
	      if (det == 1)
		{
		  // Draw only for PRE plane
		  cc->RectGeomCellPos(ism,ium,xpad,ypad,xx,yy);
		  h2->Fill(xx,yy);
		}

	      //
	      // End of the User code
	      //
	    }
	}
      
    }

  h2->Draw();

  fclose(fpw);
  return 0;
}
Commit	Line	Data
2d3c3da3	1	// ----------------------------------------------------//
	2	// //
	3	// This macro reads the PMD clusters which //
	4	// are stored in the file "PMD.RecPoints.root" //
	5	// //
	6	// ----------------------------------------------------//
	7
	8	#include <Riostream.h>
	9	#include "TBranch.h"
	10	#include "TStopwatch.h"
	11
	12	extern AliRun *gAlice;
	13
	14	Int_t AliPMDRecpointRead(Int_t nevent = 1)
	15	{
	16	if (gAlice)
	17	{
	18	delete gAlice->GetRunLoader();
	19	delete gAlice;//if everything was OK here it is already NULL
	20	gAlice = 0x0;
	21	}
	22	AliRunLoader *fRunLoader = AliRunLoader::Open("galice.root","Event","update");
	23	if (!fRunLoader)
	24	{
	25	cerr<<"Can't load RunLoader"<<endl;
	26	return 1;
	27	}
	28	AliLoader *pmdloader = fRunLoader->GetLoader("PMDLoader");
	29	Int_t nevent = fRunLoader->GetNumberOfEvents();
	30	cout << " * *********** nevent = " << nevent << endl;
	31
	32	if (pmdloader == 0x0)
	33	{
	34	cerr<<" ===> Can not find PMD or PMDLoader <===\n";
	35	delete fRunLoader;
	36	return 2;
	37	}
	38
	39	pmdloader->LoadRecPoints("READ");
	40	TClonesArray *fRecpoints;
	41	AliPMDUtility *cc = new AliPMDUtility();
	42	TH2F *h2 = new TH2F("h2"," ",100,-100.,100.,100,-100.,100.);
	43
	44	FILE *fpw = fopen("junk_rec.dat","w");
	45
	46	for (Int_t ievt = 0; ievt < nevent; ievt++)
	47	{
	48	fRunLoader->GetEvent(ievt);
	49	TTree *treeR = pmdloader->TreeR();
	50	if (treeR == 0x0)
	51	{
	52	cout << " Can not get TreeR" << endl;
	53	return 3;
	54	}
	55
	56	AliPMDrecpoint1 *pmdrecpoint;
50555ba1	57	TBranch *branch1 = treeR->GetBranch("PMDRecpoint");
50555ba1	58	branch1->SetAddress(&fRecpoints);
2d3c3da3	59	/**********************************************************************
	60	* det : Detector, 0: PRE & 1:CPV *
	61	* smn : Serial Module Number from which Super Module Number *
	62	* and Unit Module Numbers are extracted *
	63	* xpos : x-position of the cluster *
	64	* ypos : y-position of the cluster *
	65	* THESE xpos & ypos are not the true xpos and ypos *
	66	* for some of the unit modules. They are rotated. *
	67	* adc : ADC contained in the cluster *
	68	* ncell : Number of cells contained in the cluster *
	69	* rad : radius of the cluster (1d fit) *
	70	* ism : Supermodule number extracted from smn *
	71	* ium : Unit module number extracted from smn *
	72	* xpad : TRUE x-position of the cluster *
	73	* ypad : TRUE y-position of the cluster *
	74	**********************************************************************/
	75	Int_t ism, ium;
	76	Int_t det,smn;
	77	Float_t xpos,ypos, xpad, ypad;
50555ba1	78	Float_t adc, ncell, sigx, sigy;
2d3c3da3	79	Float_t xx, yy;
50555ba1	80	Int_t nmodules = branch1->GetEntries();
2d3c3da3	81	cout << " nmodules = " << nmodules << endl;
	82	for (Int_t imodule = 0; imodule < nmodules; imodule++)
	83	{
50555ba1	84	branch1->GetEntry(imodule);
2d3c3da3	85	Int_t nentries = fRecpoints->GetLast();
	86	for(Int_t ient = 0; ient < nentries+1; ient++)
	87	{
	88	pmdrecpoint = (AliPMDrecpoint1*)fRecpoints->UncheckedAt(ient);
	89	det = (Int_t) pmdrecpoint->GetDetector();
	90	smn = (Int_t) pmdrecpoint->GetSMNumber();
	91	xpos = pmdrecpoint->GetClusX();
	92	ypos = pmdrecpoint->GetClusY();
	93	adc = pmdrecpoint->GetClusADC();
	94	ncell = pmdrecpoint->GetClusCells();
50555ba1	95	sigx = pmdrecpoint->GetClusSigmaX();
50555ba1	96	sigy = pmdrecpoint->GetClusSigmaY();
2d3c3da3	97	//
	98	// Now change the xpos and ypos to its original values
	99	// for the unit modules which are earlier changed.
	100	// xpad and ypad are the real positions.
	101	//
	102	if(det == 0 \|\| det == 1)
	103	{
	104	if(smn < 12)
	105	{
	106	ism = smn/6;
	107	ium = smn - ism*6;
	108	xpad = ypos;
	109	ypad = xpos;
	110	}
	111	else if( smn >= 12 && smn < 24)
	112	{
	113	ism = smn/6;
	114	ium = smn - ism*6;
	115	xpad = xpos;
	116	ypad = ypos;
	117	}
	118	}
	119	//
	120	// User has to plug in his analysis code here
	121	//
	122
50555ba1	123	fprintf(fpw,"%d %d %d %d %f %f %f %f %f %f\n",
50555ba1	124	det,smn,ism,ium,xpad,ypad,adc,ncell,sigx,sigy);
2d3c3da3	125	//
	126	// Plot the cluster centroid to see the PMD geometry
	127	// using the PMD Utility class
	128	//
	129	if (det == 1)
	130	{
	131	// Draw only for PRE plane
	132	cc->RectGeomCellPos(ism,ium,xpad,ypad,xx,yy);
	133	h2->Fill(xx,yy);
	134	}
	135
	136	//
	137	// End of the User code
	138	//
	139	}
	140	}
	141
	142	}
	143
	144	h2->Draw();
	145
	146	fclose(fpw);
	147	return 0;
	148	}
	149