#include "AliFMDv1.h"
#include "AliRun.h"
#include "AliDetector.h"
+#include <TBranch.h>
#include <Riostream.h>
#include "AliMagF.h"
#include "AliFMDhit.h"
fIshunt = 0;
fHits = 0;
fDigits = 0;
- fSDigits = 0;
fReconParticles=0;
}
fHits = new TClonesArray ("AliFMDhit", 1000);
// Digits for each Si disk
fDigits = new TClonesArray ("AliFMDdigit", 1000);
- fSDigits = new TClonesArray ("AliFMDdigit", 1000);
fReconParticles=new TClonesArray("AliFMDReconstParticles",1000);
gAlice->AddHitList (fHits);
delete fDigits;
fDigits = 0;
}
- if (fSDigits)
- {
- fSDigits->Delete ();
- delete fSDigits;
- fSDigits = 0;
- }
if (fReconParticles)
{
fReconParticles->Delete ();
TClonesArray & ldigits = *fDigits;
new (ldigits[fNdigits++]) AliFMDdigit (digits);
-}
-//_____________________________________________________________________________
-void AliFMD::AddSDigit (Int_t * digits)
-{
- // add a real digit - as coming from data
-
- TClonesArray & ldigits = *fSDigits;
- new (ldigits[fNdigits++]) AliFMDdigit (digits);
-
}
//_____________________________________________________________________________
void AliFMD::BuildGeometry ()
AliDetector::MakeBranch (option, file);
const char *cD = strstr(option,"D");
const char *cR = strstr(option,"R");
- const char *cS = strstr(option,"S");
- if (cS){
-
- MakeBranchInTree(gAlice->TreeS(),
- branchname,&fSDigits,
- kBufferSize, file);
- }
if (cD){
MakeBranchInTree(gAlice->TreeD(),
}
}
- if (fSDigits)
- // fSDigits->Clear ();
-
- if (gAlice->TreeS () && fSDigits)
- {
- branch = gAlice->TreeS ()->GetBranch ("FMD");
- if (branch)
- branch->SetAddress (&fSDigits);
- }
+
if (gAlice->TreeR() && fReconParticles)
{
branch = gAlice->TreeR()->GetBranch("FMD");
}
//---------------------------------------------------------------------
-/*
-void AliFMD::SDigits2Digits()
-{
- cout<<"AliFMD::SDigits2Digits"<<endl;
- if (!fMerger) {
- fMerger = new AliFMDMerger();
- }
-
- fMerger ->SetRingsSi1(fRingsSi1);
- fMerger->SetRingsSi2(fRingsSi2);
- fMerger ->SetSectorsSi1(fSectorsSi1);
- fMerger ->SetSectorsSi2(fSectorsSi2);
-
- fMerger->Init();
- cout<<"AliFMD::SDigits2Digits Init"<<endl;
- fMerger->Digitise();
- cout<<"AliFMD::SDigits2Digits Digitise() "<<endl;
-
-
- }
-
- //---------------------------------------------------------------------
-void AliFMD::SetMerger(AliFMDMerger* merger)
-{
-// Set pointer to merger
- fMerger = merger;
-}
-
-AliFMDMerger* AliFMD::Merger()
-{
-// Return pointer to merger
- return fMerger;
-}
-*/
-//---------------------------------------------------------------------
printf ("%s: eta %f radius %f\n", ClassName (), eta, rad);
}
-//---------------------------------------------------------------------
-
-void AliFMD::Hits2SDigits ()
-{
-
- //#ifdef DEBUG
- cout<<"ALiFMD::Hits2SDigits> start...\n";
- //#endif
-
- char * fileSDigits = "FMD.SDigits.root";
- char * fileHeader = 0;
- AliFMDSDigitizer * sd = new AliFMDSDigitizer(fileHeader,fileSDigits) ;
- sd->SetRingsSi1(fRingsSi1);
- sd->SetRingsSi2(fRingsSi2);
- sd->SetSectorsSi1(fSectorsSi1);
- sd->SetSectorsSi2(fSectorsSi2);
- // sd->SetEventNumber(fEvNrSig);
- sd->Exec("") ;
-
- delete sd ;
-
-}
//-----------------------------------------------------------------------
void AliFMD::Digits2Reco()
////////////////////////////////////////////////
#include "AliDetector.h"
-#include "TString.h"
-#include "TBranch.h"
-//#include "AliFMDMerger.h"
-#include "AliFMDSDigitizer.h"
- class TFile;
- class TTree;
-// class AliFMDMerger;
- class AliFMD : public AliDetector {
+
+class TClonesArray;
+class AliFMD : public AliDetector {
public:
AliFMD();
AliFMD(const char *name, const char *title);
virtual ~AliFMD();
- virtual void AddHit(Int_t, Int_t*, Float_t*);
- virtual void AddDigit(Int_t*);
- virtual void AddSDigit(Int_t*);
+ virtual void AddHit(Int_t track, Int_t * vol, Float_t * hits);
+ virtual void AddDigit(Int_t* digits);
virtual void BuildGeometry();
virtual void CreateGeometry() {}
virtual void CreateMaterials()=0;
virtual void SetSectorsSi2(Int_t sectorsSi2=40);
void SetEventNumber(Int_t i) {fEvNrSig = i;}
- void Eta2Radius(Float_t, Float_t, Float_t*);
- void Hits2SDigits();//
+ void Eta2Radius(Float_t eta, Float_t zDisk, Float_t * radius);
void Digits2Reco();
virtual void SetHitsAddressBranch(TBranch *b){b->SetAddress(&fHits);}
// Digitisation
- TClonesArray *SDigits() const {return fSDigits;}
TClonesArray *ReconParticles() const {return fReconParticles;}
protected:
Int_t fNevents ; // Number of events to digitize
Int_t fEvNrSig; // signal event number
- // AliFMDMerger *fMerger; // ! pointer to merger
- TClonesArray *fSDigits ; // List of summable digits
- TClonesArray *fReconParticles;
+ TClonesArray *fReconParticles; // list of reconstructed particles
ClassDef(AliFMD,4) //Class for the FMD detector
};
}
//------------------------------------------------------------------------
-Bool_t AliFMDDigitizer::Init()
+/*
+Bool_t AliFMDDigitizer::Init()
{
-// Initialization
cout<<"AliFMDDigitizer::Init"<<endl;
return kTRUE;
}
-
+*/
//---------------------------------------------------------------------
void AliFMDDigitizer::Exec(Option_t* option)
{
-
+ /*
+ Conver hits to digits:
+ - number of detector;
+ - number of ring;
+ - number of sector;
+ - ADC signal in this channel
+ */
#ifdef DEBUG
Int_t volume, sector, ring, charge;
Float_t e;
- Float_t de[10][50][300];
+ Float_t de[10][50][800];
Int_t hit;
Int_t digit[5];
Int_t ivol, iSector, iRing;
for (Int_t i=0; i<10; i++)
for(Int_t j=0; j<50; j++)
- for(Int_t ij=0; ij<300; ij++)
+ for(Int_t ij=0; ij<800; ij++)
de[i][j][ij]=0;
- Int_t NumberOfRings[5]=
- {256,128,256,128,256};
- Int_t NumberOfSectors[5]=
+ Int_t numberOfRings[5]=
+ {768,384,768,384,768};
+ Int_t numberOfSector[5]=
{20,40,20,40,20};
AliFMDhit *fmdHit=0;
- TTree *TH=0;
+ TTree *tH=0;
TBranch *brHits=0;
- // fHits = new TClonesArray ("AliFMDhit", 1000);
AliFMD * fFMD = (AliFMD *) gAlice->GetDetector("FMD") ;
if (fFMD)
{
TClonesArray *FMDhits = fFMD->Hits ();
- TH = fManager->GetInputTreeH(inputFile);
- brHits = TH->GetBranch("FMD");
+ tH = fManager->GetInputTreeH(inputFile);
+ brHits = tH->GetBranch("FMD");
if (brHits) {
fFMD->SetHitsAddressBranch(brHits);
}else{
cerr<<"EXEC Branch FMD hit not found"<<endl;
exit(111);
}
- Int_t ntracks = (Int_t) TH->GetEntries();
+ Int_t ntracks = (Int_t) tH->GetEntries();
for (Int_t track = 0; track < ntracks; track++)
{
// Put noise and make ADC signal
- Float_t I = 1.664 * 0.04 * 2.33 / 22400; // = 0.69e-6;
+ Float_t iP = 1.664 * 0.04 * 2.33 / 22400; // = 0.69e-6;
for ( ivol=1; ivol<=5; ivol++){
- for ( iSector=1; iSector<=NumberOfSectors[ivol-1]; iSector++){
- for ( iRing=1; iRing<=NumberOfRings[ivol-1]; iRing++){
+ for ( iSector=1; iSector<=numberOfSector[ivol-1]; iSector++){
+ for ( iRing=1; iRing<=numberOfRings[ivol-1]; iRing++){
digit[0]=ivol;
digit[1]=iSector;
digit[2]=iRing;
- charge = Int_t (de[ivol][iSector][iRing] / I);
+ charge = Int_t (de[ivol][iSector][iRing] / iP);
digit[3]=PutNoise(charge);
if(digit[3]<= 500) digit[3]=500;
//dynamic range from MIP(0.155MeV) to 30MIP(4.65MeV)
* See cxx source for full Copyright notice */
#include "AliDigitizer.h"
-
+class TClonesArray;
class AliRunDigitizer;
-//class AliFMD;
-class AliFMDdigit;
-class AliFMDhit;
class AliFMDDigitizer : public AliDigitizer {
public:
AliFMDDigitizer();
AliFMDDigitizer(AliRunDigitizer * manager);
virtual ~AliFMDDigitizer();
- virtual Bool_t Init();
+ virtual Bool_t Init() {return kTRUE;} ///???????????
// Do the main work
fNumOfMaxRing=RecParticles[4];
fNumOfReconstParticles=RecParticles[5];
}
-Int_t AliFMDReconstParticles::GetVolume(){return fNumOfDet;}
-Int_t AliFMDReconstParticles::GetNumberOfMinSector() {return fNumOfMinSector;}
-Int_t AliFMDReconstParticles::GetNumberOfMaxSector() {return fNumOfMaxSector;}
-Int_t AliFMDReconstParticles::GetNumberOfMinRing() {return fNumOfMinRing;}
-Int_t AliFMDReconstParticles::GetNumberOfMaxRing() {return fNumOfMaxRing;}
-Int_t AliFMDReconstParticles::GetNumberOfReconstParticles() {return fNumOfReconstParticles;}
-
#ifndef AliFMDReconstParticles_h
#define AliFMDReconstParticles_h
-#include <TClonesArray.h>
#include <TObject.h>
+class TClonesArray;
+
class AliFMDReconstParticles: public TObject
{
- //Reconstracted Particles Class
+ /*
+ Reconstracted Particles Class:
+ has number of reconstructed particles in
+ sectors from NumOfMinSector to NumberOfMaxSector()
+ rings from NumOfMinRing to NumOfMaxRing for each FMDvolume
+ */
+
+
+ public:
+ AliFMDReconstParticles();
+ AliFMDReconstParticles (Int_t *RecParticles);
+ virtual ~AliFMDReconstParticles(){};
+ Int_t GetVolume() const {return fNumOfDet;} //number of volume
+ Int_t GetNumberOfMinSector() const {return fNumOfMinSector;} //number of min sector
+ Int_t GetNumberOfMaxSector() const {return fNumOfMaxSector;} // number of max sector
+ Int_t GetNumberOfMinRing() const {return fNumOfMinRing;} //number of min ring
+ Int_t GetNumberOfMaxRing() const {return fNumOfMaxRing;} //number of max ring
+ Int_t GetNumberOfReconstParticles()const {return fNumOfReconstParticles;} //number of reconstructed particles
private:
Int_t fNumOfDet; //Number of FMD disk;
Int_t fNumOfMinSector; //Number of min sector
Int_t fNumOfMaxRing; //Number of max ring
Int_t fNumOfReconstParticles; //Number of reconstructed particles
- public:
- AliFMDReconstParticles();
- AliFMDReconstParticles (Int_t *RecParticles);
- virtual ~AliFMDReconstParticles(){};
- Int_t GetVolume(); //Return the number of volume
- Int_t GetNumberOfMinSector(); //Return the number of min sector
- Int_t GetNumberOfMaxSector(); //Return the number of max sector
- Int_t GetNumberOfMinRing(); //Return the number of min ring
- Int_t GetNumberOfMaxRing(); //Return the number of max ring
- Int_t GetNumberOfReconstParticles(); //Returnthe the number of reconstructed particles
ClassDef(AliFMDReconstParticles,2)
};
#endif
// original particle (if this particle is a daughter). The units
// are those determined by the Monte Carlo.
+
+public:
+ AliFMDhit() {}
+ AliFMDhit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
+ virtual ~AliFMDhit() {}
+ Int_t Volume() const {return fVolume;}
+ Int_t NumberOfSector() const {return fNumberOfSector;}
+ Int_t NumberOfRing() const {return fNumberOfRing;}
+ Float_t Particle() const {return fParticle;}
+ Float_t Edep() const {return fEdep;}
+ Float_t Px() const {return fPx;}
+ Float_t Py() const {return fPy;}
+ Float_t Pz() const {return fPz;}
+ Float_t Time() const {return fTime;}
private:
Int_t fVolume; //Volume copy identifier
- Int_t fNumberOfSector;
- Int_t fNumberOfRing;
+ Int_t fNumberOfSector; //number of sector of hitted pad
+ Int_t fNumberOfRing; //number of ring of hitted pad
Int_t fParticle; //Particle identificator
Float_t fEdep; //Energy deposition
Float_t fPx; // Particle's momentum X
Float_t fPy; // Particle's momentum Y
Float_t fPz; // Particle's momentum Z
Float_t fTime; // Particle's time of flight
-
-public:
- AliFMDhit() {}
- AliFMDhit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits);
- virtual ~AliFMDhit() {}
- Int_t Volume();
- Int_t NumberOfSector();
- Int_t NumberOfRing();
- Float_t Particle();
- Float_t Edep();
- Float_t Px();
- Float_t Py();
- Float_t Pz();
- Float_t Time();
+
ClassDef(AliFMDhit,1) //Hits for detector FMD
};
-inline Int_t AliFMDhit::Volume(){return fVolume;}
-inline Int_t AliFMDhit::NumberOfSector(){return fNumberOfSector;}
-inline Int_t AliFMDhit::NumberOfRing(){return fNumberOfRing;}
-inline Float_t AliFMDhit::Particle(){return fParticle;}
-inline Float_t AliFMDhit::Edep(){return fEdep;}
-inline Float_t AliFMDhit::Px(){return fPx;}
-inline Float_t AliFMDhit::Py(){return fPy;}
-inline Float_t AliFMDhit::Pz(){return fPz;}
-inline Float_t AliFMDhit::Time(){return fTime;}
#endif