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

//_________________________________________________________________________
// This is a TTask that constructs ReconstParticles (reconstructed particles) 
// out of Digits
// 
//-- Authors: Evgeny Karpechev(INR) and Alla Maevsksia
//////////////////////////////////////////////////////////////////////////////

// --- ROOT system ---
#include "TTask.h"
#include "TTree.h"
#include "TSystem.h"
#include "TFile.h"
#include "TROOT.h"
#include "TFolder.h"
#include "TH2F.h"

// --- Standard library ---
#include <stdlib.h>
#include <Riostream.h>

// --- AliRoot header files ---

#include "AliRunLoader.h"
#include "AliLoader.h"

#include "AliFMDdigit.h"
#include "AliFMDhit.h"
#include "AliFMDReconstParticles.h"
#include "AliFMD.h"
#include "AliFMDv1.h"
#include "AliFMDReconstruction.h"
#include "AliRun.h"
#include "AliConfig.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"

ClassImp(AliFMDReconstruction)

        
//____________________________________________________________________________ 

AliFMDReconstruction::AliFMDReconstruction():TTask("AliFMDReconstruction","") 
{
  fNevents = 0 ;  // Number of events to rreconnstraction, 0 means all events in current file
  fRunLoader = 0x0;
  
}
//____________________________________________________________________________ 

AliFMDReconstruction::AliFMDReconstruction(AliRunLoader* rl):TTask("AliFMDReconstruction","")
{

  if (rl == 0x0)
   {
     Fatal("AliFMDReconstruction","Argument AliRunLoader* is null!");
     return;
   }
   
  fNevents = 0 ;    // Number of events to rreconnstraction, 0 means all events in current file

  fRunLoader = rl;
  AliLoader* gime = fRunLoader->GetLoader("FMDLoader");
  if (gime == 0x0)
   {
     Fatal("AliFMDReconstruction","Can not find FMD (loader) in specified event");
     return;//never reached
   }
  //add Task to //root/Tasks folder
  gime->PostReconstructioner(this);
}

//____________________________________________________________________________ 

AliFMDReconstruction::~AliFMDReconstruction()
{
  AliLoader* gime = fRunLoader->GetLoader("FMDLoader");
  gime->CleanReconstructioner();
}

//____________________________________________________________________________

void AliFMDReconstruction::Exec() 
{ 
 //Collects all digits in the same active volume into number of particles
  /*
    Reconstruct number of particles 
    in given group of pads for given FMDvolume
    determine by numberOfVolume , 
    numberOfMinSector,numberOfMaxSector,
    numberOfMinRing, numberOgMaxRing
    Reconstruction method choose dependence on number of empty pads  
  */


  cout<<"\nStart AliFMDReconstruction::Exec(...)"<<endl;
  Int_t const knumVolumes=5;
  Int_t padADC;
  Float_t eta, etain,etaout,rad,theta;
  Int_t ivol, iSector, iRing;
  Float_t rin[5]={4.2,15.4,4.2,15.4,4.2};
  Float_t rout[5]={17.4,28.4,17.4,28.4,17.4};
  Float_t z[5]={-62.8, -75.2, 83.4, 75.2, 340.};
  Int_t numberOfRings[5]={512,256,512,256,512};
  Int_t numberOfSectors[5]=  {20,40,20,40,20};
  Int_t numberOfEtaIntervals[5];
  // number of ring for boundary 0.1 eta

  
  if (fRunLoader == 0x0)
   {
    Error("Exec","Run Loader loader is NULL - Session not opened");
    return;
   }
 
 
 AliLoader* gime = fRunLoader->GetLoader("FMDLoader");
  if (gime == 0x0)
   {
     Fatal("AliFMDReconstruction","Can not find FMD (loader) in specified event");
     return;//never reached
   }
   
  fRunLoader->LoadgAlice();
  fRunLoader->LoadHeader();
  Int_t retval;
  TDirectory* cwd = gDirectory;
  gDirectory = 0x0;
    Text_t buf1[20];
  TH2F* hTotal[10];
  for (Int_t j=1; j<=5; j++){
    sprintf(buf1,"hTotal%d",j);
    
    hTotal[j] = new TH2F(buf1," Number of primary particles ",
			 numberOfSectors[j-1],1,numberOfSectors[j-1],
			 numberOfRings[j-1],1,numberOfRings[j-1]);
  }   
  gDirectory = cwd;
 
       
  if(fNevents == 0) fNevents=Int_t (fRunLoader->TreeE()->GetEntries()); 
  cout<<" fNevents "<<fNevents<<endl;
   for(Int_t ievent=0;ievent<fNevents;ievent++)
    { 
      fRunLoader->GetEvent(ievent) ;

      cout<<" ievent "<<ievent<<endl;
    for (Int_t i=0; i<5; i++)
        hTotal[i+1]->Reset();
      
      retval = gime->LoadDigits("READ"); 
      if (retval)
	{
	  Error("Exec","Error occured while loading digits. Exiting.");
	  return;
	}
      
      AliFMD * fFMD = (AliFMD *) gAlice->GetDetector("FMD");
      TClonesArray *fReconParticles=fFMD->ReconParticles();
      TClonesArray *fDigits=fFMD->Digits();
 
      TTree* treeD = gime->TreeD();
      if (treeD == 0x0)
	{
	  Error("Exec","Can not get Tree with Digits. Nothing to reconstruct - Exiting");
	  return;
	}
      
      TBranch *brDigits=0;
	    
      brDigits=treeD->GetBranch("FMD");
      cout<<" brDigits "<<brDigits<<endl;
      if (brDigits) {
	brDigits->SetAddress(&fDigits);
	//        fFMD->SetHitsAddressBranch(brHits);
      }else{
	cerr<<"EXEC Branch FMD digits not found"<<endl;
	return;
      } 
	  
      if(gime->TreeR()==0) gime->MakeTree("R");

      //Make branches
      fFMD->MakeBranch("R");

      
      Int_t zeroADC=6;
 
      AliFMDdigit  *fmdDigit;
       if (fFMD)
	{
	  gime->TreeD()->GetEvent(0); 
	  	  
	  Int_t nDigits=fDigits->GetEntries();
	  cout<<" nDigits "<<nDigits<<endl;
	  Int_t recParticles[6];
	  Int_t nRecPart=0 ;
	   Int_t zeroPads=0;
	   Int_t numberOfPads=0; //To avoid warning
	   Int_t pedestal;
	   Float_t channelWidth=(22400*50)/1024;
	   for (Int_t digit=0;digit<nDigits;digit++) 
	     {
	       fmdDigit=(AliFMDdigit*)fDigits->UncheckedAt(digit);    
	       ivol=fmdDigit->Volume();
	       iSector=fmdDigit->NumberOfSector();
	       iRing=fmdDigit->NumberOfRing();
	       pedestal=Int_t(gRandom->Gaus(500,250));
	       padADC= fmdDigit->ADCsignal()
		 -Int_t(Float_t(pedestal)/channelWidth);
	       if (padADC<0) padADC=0;
              hTotal[ivol]->Fill(iSector,iRing,padADC);
 	     } //digit loop
	   Int_t rmin=0; Int_t rmax=0; //To avoid warning
	   Int_t smin=0; Int_t smax=0; //To avoid warning
	   AliHeader *header = fRunLoader->GetHeader();
	   AliGenEventHeader* genHeader = header->GenEventHeader();
	   TArrayF *o = new TArrayF(3); 
	   genHeader->PrimaryVertex(*o);
	   Float_t zVertex=o->At(2);
 	   for (ivol=0; ivol<knumVolumes; ivol++)
	     {
               Float_t ring2number=Float_t (numberOfRings[ivol])/
                 (rout[ivol]-rin[ivol]);
               Float_t realZ=zVertex+z[ivol];
               theta=TMath::ATan(rout[ivol]/TMath::Abs(realZ));
               etain = - TMath::Log( TMath::Tan(theta/2.));
               theta=TMath::ATan(rin[ivol]/TMath::Abs(realZ));
               etaout=- TMath::Log( TMath::Tan(theta/2.));
               numberOfEtaIntervals[ivol]=Int_t((etaout-etain)*10)-1;
               eta=etain;
               for (Int_t e1=0;e1<=numberOfEtaIntervals[ivol];e1++) 
                 {
                   theta = 2.*TMath::ATan (TMath::Exp (-eta));
                   Float_t radmin = TMath::Abs(realZ) * (TMath::Tan (theta));
                   rmax= Int_t ( (radmin-rin[ivol])*ring2number+0.5);
                   cout<<ivol<<" "<<" eta "<<eta<<" radmin "<<radmin<<

                     " Rmax "<<rmax<<" "<<endl;;
                   eta=eta+0.1;
                   theta = 2.*TMath::ATan (TMath::Exp (-eta));
                   rad = TMath::Abs(realZ) * (TMath::Tan (theta));
                   rmin=Int_t( (rad-rin[ivol])*ring2number+0.5);
                   cout<<"eta "<<eta<<" rad "<<rad<<" Rmin "<<rmin<<endl;
                   //      if(ivol==2&&e1==13) rmin=0;
                   zeroPads=0;
                   smin=0;
                   smax=numberOfSectors[ivol]; 
                   numberOfPads=(rmax-rmin)*(smax-smin);
                   for (Int_t iring=rmin; iring<rmax; iring++) 
                     {
                       for 
                         (Int_t isector=0;
                          isector<numberOfSectors[ivol]; 
                          isector++) 
                         {
			   if(hTotal[ivol+1]->GetBinContent(isector+1,iring+1)
                            <zeroADC) zeroPads++;}

                     } //ring
                   Float_t numberOfPads=Float_t(smax-smin)*Float_t(rmax-rmin);

                   cout<<" zero "<<zeroPads++<<" pads "<<numberOfPads;
                   Double_t lambda=-TMath::Log(Double_t(zeroPads)/numberOfPads);
                   Int_t fRecon=Int_t (lambda*numberOfPads+0.5);
                   
                   Float_t zerosRatio= 
                     (Float_t)zeroPads/(Float_t)numberOfPads;
                   cout<<" zerosRatio "<<zerosRatio<<" recon "<<fRecon<<endl;
                   recParticles[0]=ivol+1;
                   recParticles[1]=smin;
                   recParticles[2]=smax;
                   recParticles[3]=rmin;
                   recParticles[4]=rmax;
                   recParticles[5]= fRecon;
                   new((*fReconParticles)[nRecPart++]) 
                     AliFMDReconstParticles(recParticles);             


		 } // eta
	     } // volume
	   
	}//if FMD
       gime->TreeR()->Reset();
       gime->TreeR()->Fill(); 
       gime->WriteRecPoints("OVERWRITE");
    } //event loop
  cout<<"\nAliFMDReconstruction::Exec finished"<<endl;
}
Commit	Line	Data
37c55dc0	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	// This is a TTask that constructs ReconstParticles (reconstructed particles)
	18	// out of Digits
	19	//
	20	//-- Authors: Evgeny Karpechev(INR) and Alla Maevsksia
	21	//////////////////////////////////////////////////////////////////////////////
	22
dc8af42e	23	// --- ROOT system ---
	24	#include "TTask.h"
	25	#include "TTree.h"
	26	#include "TSystem.h"
	27	#include "TFile.h"
37c55dc0	28	#include "TROOT.h"
37c55dc0	29	#include "TFolder.h"
46501dfb	30	#include "TH2F.h"
37c55dc0	31
dc8af42e	32	// --- Standard library ---
37c55dc0	33	#include <stdlib.h>
88cb7938	34	#include <Riostream.h>
dc8af42e	35
	36	// --- AliRoot header files ---
	37
88cb7938	38	#include "AliRunLoader.h"
	39	#include "AliLoader.h"
	40
dc8af42e	41	#include "AliFMDdigit.h"
1a42d4f2	42	#include "AliFMDhit.h"
dc8af42e	43	#include "AliFMDReconstParticles.h"
	44	#include "AliFMD.h"
	45	#include "AliFMDv1.h"
	46	#include "AliFMDReconstruction.h"
	47	#include "AliRun.h"
88cb7938	48	#include "AliConfig.h"
1a42d4f2	49	#include "AliHeader.h"
1a42d4f2	50	#include "AliGenEventHeader.h"
88cb7938	51
dc8af42e	52	ClassImp(AliFMDReconstruction)
	53
	54
	55	//____________________________________________________________________________
	56
	57	AliFMDReconstruction::AliFMDReconstruction():TTask("AliFMDReconstruction","")
	58	{
	59	fNevents = 0 ; // Number of events to rreconnstraction, 0 means all events in current file
88cb7938	60	fRunLoader = 0x0;
88cb7938	61
dc8af42e	62	}
	63	//____________________________________________________________________________
	64
88cb7938	65	AliFMDReconstruction::AliFMDReconstruction(AliRunLoader* rl):TTask("AliFMDReconstruction","")
dc8af42e	66	{
88cb7938	67
	68	if (rl == 0x0)
	69	{
	70	Fatal("AliFMDReconstruction","Argument AliRunLoader* is null!");
	71	return;
	72	}
	73
dc8af42e	74	fNevents = 0 ; // Number of events to rreconnstraction, 0 means all events in current file
88cb7938	75
	76	fRunLoader = rl;
	77	AliLoader* gime = fRunLoader->GetLoader("FMDLoader");
	78	if (gime == 0x0)
	79	{
	80	Fatal("AliFMDReconstruction","Can not find FMD (loader) in specified event");
	81	return;//never reached
	82	}
dc8af42e	83	//add Task to //root/Tasks folder
88cb7938	84	gime->PostReconstructioner(this);
dc8af42e	85	}
	86
	87	//____________________________________________________________________________
	88
	89	AliFMDReconstruction::~AliFMDReconstruction()
	90	{
1584c57e	91	AliLoader* gime = fRunLoader->GetLoader("FMDLoader");
1584c57e	92	gime->CleanReconstructioner();
dc8af42e	93	}
88cb7938	94
88cb7938	95	//____________________________________________________________________________
dc8af42e	96
46501dfb	97	void AliFMDReconstruction::Exec()
dc8af42e	98	{
88cb7938	99	//Collects all digits in the same active volume into number of particles
a39f3926	100	/*
88cb7938	101	Reconstruct number of particles
a39f3926	102	in given group of pads for given FMDvolume
	103	determine by numberOfVolume ,
	104	numberOfMinSector,numberOfMaxSector,
	105	numberOfMinRing, numberOgMaxRing
	106	Reconstruction method choose dependence on number of empty pads
	107	*/
	108
	109
1a42d4f2	110	cout<<"\nStart AliFMDReconstruction::Exec(...)"<<endl;
a39f3926	111	Int_t const knumVolumes=5;
46501dfb	112	Int_t padADC;
1a42d4f2	113	Float_t eta, etain,etaout,rad,theta;
cb1df35e	114	Int_t ivol, iSector, iRing;
1a42d4f2	115	Float_t rin[5]={4.2,15.4,4.2,15.4,4.2};
1a42d4f2	116	Float_t rout[5]={17.4,28.4,17.4,28.4,17.4};
2ad713c4	117	Float_t z[5]={-62.8, -75.2, 83.4, 75.2, 340.};
46501dfb	118	Int_t numberOfRings[5]={512,256,512,256,512};
a39f3926	119	Int_t numberOfSectors[5]= {20,40,20,40,20};
a39f3926	120	Int_t numberOfEtaIntervals[5];
cb1df35e	121	// number of ring for boundary 0.1 eta
cb1df35e	122
88cb7938	123
	124	if (fRunLoader == 0x0)
	125	{
	126	Error("Exec","Run Loader loader is NULL - Session not opened");
	127	return;
	128	}
46501dfb	129
	130
	131	AliLoader* gime = fRunLoader->GetLoader("FMDLoader");
88cb7938	132	if (gime == 0x0)
	133	{
	134	Fatal("AliFMDReconstruction","Can not find FMD (loader) in specified event");
	135	return;//never reached
	136	}
	137
	138	fRunLoader->LoadgAlice();
46501dfb	139	fRunLoader->LoadHeader();
88cb7938	140	Int_t retval;
46501dfb	141	TDirectory* cwd = gDirectory;
	142	gDirectory = 0x0;
	143	Text_t buf1[20];
	144	TH2F* hTotal[10];
	145	for (Int_t j=1; j<=5; j++){
	146	sprintf(buf1,"hTotal%d",j);
	147
	148	hTotal[j] = new TH2F(buf1," Number of primary particles ",
	149	numberOfSectors[j-1],1,numberOfSectors[j-1],
	150	numberOfRings[j-1],1,numberOfRings[j-1]);
	151	}
	152	gDirectory = cwd;
	153
	154
7fe81cad	155	if(fNevents == 0) fNevents=Int_t (fRunLoader->TreeE()->GetEntries());
46501dfb	156	cout<<" fNevents "<<fNevents<<endl;
46501dfb	157	for(Int_t ievent=0;ievent<fNevents;ievent++)
dc8af42e	158	{
88cb7938	159	fRunLoader->GetEvent(ievent) ;
88cb7938	160
1a42d4f2	161	cout<<" ievent "<<ievent<<endl;
46501dfb	162	for (Int_t i=0; i<5; i++)
	163	hTotal[i+1]->Reset();
	164
	165	retval = gime->LoadDigits("READ");
	166	if (retval)
	167	{
	168	Error("Exec","Error occured while loading digits. Exiting.");
	169	return;
	170	}
	171
	172	AliFMD * fFMD = (AliFMD *) gAlice->GetDetector("FMD");
	173	TClonesArray *fReconParticles=fFMD->ReconParticles();
	174	TClonesArray *fDigits=fFMD->Digits();
1a42d4f2	175
46501dfb	176	TTree* treeD = gime->TreeD();
	177	if (treeD == 0x0)
	178	{
	179	Error("Exec","Can not get Tree with Digits. Nothing to reconstruct - Exiting");
	180	return;
	181	}
	182
	183	TBranch *brDigits=0;
	184
	185	brDigits=treeD->GetBranch("FMD");
	186	cout<<" brDigits "<<brDigits<<endl;
	187	if (brDigits) {
	188	brDigits->SetAddress(&fDigits);
	189	// fFMD->SetHitsAddressBranch(brHits);
	190	}else{
	191	cerr<<"EXEC Branch FMD digits not found"<<endl;
	192	return;
	193	}
	194
88cb7938	195	if(gime->TreeR()==0) gime->MakeTree("R");
88cb7938	196
dc8af42e	197	//Make branches
a39f3926	198	fFMD->MakeBranch("R");
1a42d4f2	199
37c55dc0	200
46501dfb	201	Int_t zeroADC=6;
1a42d4f2	202
1a42d4f2	203	AliFMDdigit *fmdDigit;
a39f3926	204	if (fFMD)
dc8af42e	205	{
88cb7938	206	gime->TreeD()->GetEvent(0);
46501dfb	207
46501dfb	208	Int_t nDigits=fDigits->GetEntries();
1a42d4f2	209	cout<<" nDigits "<<nDigits<<endl;
46501dfb	210	Int_t recParticles[6];
46501dfb	211	Int_t nRecPart=0 ;
a39f3926	212	Int_t zeroPads=0;
a39f3926	213	Int_t numberOfPads=0; //To avoid warning
cb1df35e	214	Int_t pedestal;
cb1df35e	215	Float_t channelWidth=(22400*50)/1024;
dc8af42e	216	for (Int_t digit=0;digit<nDigits;digit++)
dc8af42e	217	{
46501dfb	218	fmdDigit=(AliFMDdigit*)fDigits->UncheckedAt(digit);
cb1df35e	219	ivol=fmdDigit->Volume();
	220	iSector=fmdDigit->NumberOfSector();
	221	iRing=fmdDigit->NumberOfRing();
	222	pedestal=Int_t(gRandom->Gaus(500,250));
46501dfb	223	padADC= fmdDigit->ADCsignal()
cb1df35e	224	-Int_t(Float_t(pedestal)/channelWidth);
46501dfb	225	if (padADC<0) padADC=0;
	226	hTotal[ivol]->Fill(iSector,iRing,padADC);
	227	} //digit loop
a39f3926	228	Int_t rmin=0; Int_t rmax=0; //To avoid warning
a39f3926	229	Int_t smin=0; Int_t smax=0; //To avoid warning
88cb7938	230	AliHeader *header = fRunLoader->GetHeader();
1a42d4f2	231	AliGenEventHeader* genHeader = header->GenEventHeader();
	232	TArrayF *o = new TArrayF(3);
	233	genHeader->PrimaryVertex(*o);
	234	Float_t zVertex=o->At(2);
a39f3926	235	for (ivol=0; ivol<knumVolumes; ivol++)
cb1df35e	236	{
46501dfb	237	Float_t ring2number=Float_t (numberOfRings[ivol])/
	238	(rout[ivol]-rin[ivol]);
	239	Float_t realZ=zVertex+z[ivol];
	240	theta=TMath::ATan(rout[ivol]/TMath::Abs(realZ));
	241	etain = - TMath::Log( TMath::Tan(theta/2.));
	242	theta=TMath::ATan(rin[ivol]/TMath::Abs(realZ));
	243	etaout=- TMath::Log( TMath::Tan(theta/2.));
7fe81cad	244	numberOfEtaIntervals[ivol]=Int_t((etaout-etain)*10)-1;
46501dfb	245	eta=etain;
	246	for (Int_t e1=0;e1<=numberOfEtaIntervals[ivol];e1++)
	247	{
	248	theta = 2.*TMath::ATan (TMath::Exp (-eta));
	249	Float_t radmin = TMath::Abs(realZ) * (TMath::Tan (theta));
	250	rmax= Int_t ( (radmin-rin[ivol])*ring2number+0.5);
	251	cout<<ivol<<" "<<" eta "<<eta<<" radmin "<<radmin<<
	252
	253	" Rmax "<<rmax<<" "<<endl;;
	254	eta=eta+0.1;
	255	theta = 2.*TMath::ATan (TMath::Exp (-eta));
	256	rad = TMath::Abs(realZ) * (TMath::Tan (theta));
	257	rmin=Int_t( (rad-rin[ivol])*ring2number+0.5);
	258	cout<<"eta "<<eta<<" rad "<<rad<<" Rmin "<<rmin<<endl;
	259	// if(ivol==2&&e1==13) rmin=0;
	260	zeroPads=0;
	261	smin=0;
	262	smax=numberOfSectors[ivol];
	263	numberOfPads=(rmax-rmin)*(smax-smin);
	264	for (Int_t iring=rmin; iring<rmax; iring++)
	265	{
	266	for
	267	(Int_t isector=0;
	268	isector<numberOfSectors[ivol];
	269	isector++)
	270	{
	271	if(hTotal[ivol+1]->GetBinContent(isector+1,iring+1)
	272	<zeroADC) zeroPads++;}
	273
	274	} //ring
	275	Float_t numberOfPads=Float_t(smax-smin)*Float_t(rmax-rmin);
	276
	277	cout<<" zero "<<zeroPads++<<" pads "<<numberOfPads;
	278	Double_t lambda=-TMath::Log(Double_t(zeroPads)/numberOfPads);
7fe81cad	279	Int_t fRecon=Int_t (lambda*numberOfPads+0.5);
46501dfb	280
	281	Float_t zerosRatio=
	282	(Float_t)zeroPads/(Float_t)numberOfPads;
	283	cout<<" zerosRatio "<<zerosRatio<<" recon "<<fRecon<<endl;
	284	recParticles[0]=ivol+1;
	285	recParticles[1]=smin;
	286	recParticles[2]=smax;
	287	recParticles[3]=rmin;
	288	recParticles[4]=rmax;
	289	recParticles[5]= fRecon;
	290	new((*fReconParticles)[nRecPart++])
	291	AliFMDReconstParticles(recParticles);
	292
	293
1a42d4f2	294	} // eta
1a42d4f2	295	} // volume
cb1df35e	296
cb1df35e	297	}//if FMD
88cb7938	298	gime->TreeR()->Reset();
	299	gime->TreeR()->Fill();
	300	gime->WriteRecPoints("OVERWRITE");
dc8af42e	301	} //event loop
1a42d4f2	302	cout<<"\nAliFMDReconstruction::Exec finished"<<endl;
88cb7938	303	}
dc8af42e	304