code according Convertions
authoralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 6 Mar 2003 13:08:57 +0000 (13:08 +0000)
committeralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 6 Mar 2003 13:08:57 +0000 (13:08 +0000)
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMDDigitizer.cxx
FMD/AliFMDDigitizer.h
FMD/AliFMDReconstParticles.cxx
FMD/AliFMDReconstParticles.h
FMD/AliFMDhit.h

index 6094ab6..5c2d456 100644 (file)
@@ -50,6 +50,7 @@
 #include "AliFMDv1.h"
 #include "AliRun.h"
 #include "AliDetector.h"
+#include <TBranch.h>
 #include <Riostream.h>
 #include "AliMagF.h"
 #include "AliFMDhit.h"
@@ -68,7 +69,6 @@ AliFMD::AliFMD ():AliDetector ()
   fIshunt = 0;
   fHits     = 0;
   fDigits   = 0;
-  fSDigits  = 0;
   fReconParticles=0; 
 }
 
@@ -85,7 +85,6 @@ AliDetector (name, title)
   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);
 
@@ -114,12 +113,6 @@ AliFMD::~AliFMD ()
       delete fDigits;
       fDigits = 0;
     }
-  if (fSDigits)
-    {
-      fSDigits->Delete ();
-      delete fSDigits;
-      fSDigits = 0;
-    }
   if (fReconParticles)
     {
       fReconParticles->Delete ();
@@ -150,15 +143,6 @@ void AliFMD::AddDigit (Int_t * 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 ()
 {
   //
@@ -274,14 +258,7 @@ void AliFMD::MakeBranch (Option_t * option, const char *file)
   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(), 
@@ -318,16 +295,8 @@ void AliFMD::SetTreeAddress ()
        }
 
     }
-  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"); 
@@ -356,41 +325,6 @@ void AliFMD::SetSectorsSi2(Int_t sectorsSi2)
 }
 
 //---------------------------------------------------------------------
-/*
-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;
-}
-*/
-//---------------------------------------------------------------------
 
 
 
@@ -407,28 +341,6 @@ AliFMD::Eta2Radius (Float_t eta, Float_t zDisk, Float_t * radius)
     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()
index cad1c3d..311a3b9 100644 (file)
@@ -8,22 +8,16 @@
 ////////////////////////////////////////////////
  
 #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; 
@@ -44,13 +38,11 @@ public:
   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:
@@ -68,9 +60,7 @@ public:
   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
 };
index 0cadf32..673c0fa 100644 (file)
@@ -64,19 +64,25 @@ AliFMDDigitizer::~AliFMDDigitizer()
 }
 
  //------------------------------------------------------------------------
-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
@@ -87,23 +93,22 @@ void AliFMDDigitizer::Exec(Option_t* option)
 
    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") ;
 
@@ -117,15 +122,15 @@ void AliFMDDigitizer::Exec(Option_t* option)
     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++)
        {
@@ -148,14 +153,14 @@ void AliFMDDigitizer::Exec(Option_t* option)
 
  
   // 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)
index a95f6ac..2c1b292 100644 (file)
@@ -4,18 +4,15 @@
  * 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
index 42bb482..216d2a9 100644 (file)
@@ -20,10 +20,3 @@ AliFMDReconstParticles::AliFMDReconstParticles(Int_t *RecParticles)
      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;}
-
index 1f1f4ec..a47dee6 100644 (file)
@@ -1,11 +1,29 @@
 #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 
@@ -14,16 +32,6 @@ class AliFMDReconstParticles: public TObject
   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
index 90faa38..9db5671 100644 (file)
@@ -71,39 +71,31 @@ class AliFMDhit : public AliHit {
 // 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