Merging implemented
authorcoppedis <coppedis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 26 Sep 2001 16:06:10 +0000 (16:06 +0000)
committercoppedis <coppedis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 26 Sep 2001 16:06:10 +0000 (16:06 +0000)
ZDC/AliZDC.cxx
ZDC/AliZDC.h
ZDC/AliZDCDigit.cxx
ZDC/AliZDCDigit.h
ZDC/AliZDCHit.h
ZDC/AliZDCMerger.cxx [new file with mode: 0644]
ZDC/AliZDCMerger.h [new file with mode: 0644]
ZDC/Makefile
ZDC/ZDCLinkDef.h

index ba0d62c..a04a3af 100644 (file)
@@ -15,6 +15,9 @@
 
 /*
 $Log$
+Revision 1.23  2001/05/15 13:44:57  coppedis
+Changes in AddHit method
+
 Revision 1.22  2001/05/14 09:53:32  coppedis
 Adding functions ZMin and ZMax
 
@@ -66,14 +69,15 @@ Introduction of the Copyright and cvs Log
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
-//  Zero Degree Calorimeter                                                  //
-//  This class contains the basic functions for the ZDCs                     //
-//  Functions specific to one particular geometry are                       //
-//  contained in the derived classes                                         //
+//                     Zero Degree Calorimeter                              //
+//          This class contains the basic functions for the ZDCs;           //
+//            functions specific to one particular geometry are              //
+//                      contained in the derived classes                     //
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <stdlib.h>
+#include <iostream.h>
 
 // --- ROOT system
 #include <TBRIK.h>
@@ -85,11 +89,14 @@ Introduction of the Copyright and cvs Log
 // --- AliRoot header files
 #include "AliZDC.h"
 #include "AliZDCHit.h"
-#include "AliRun.h"
+#include "AliZDCDigit.h"
+#include "AliZDCMerger.h"
 #include "AliDetector.h"
 #include "AliCallf77.h"
 #include "AliConst.h"
 #include "AliMC.h"
+#include "AliRun.h"
+#include "AliHeader.h"
 
  
 ClassImp(AliZDC)
@@ -101,14 +108,16 @@ AliZDC::AliZDC()
   // Default constructor for the Zero Degree Calorimeter base class
   //
   
-  fIshunt = 1;
-
-  fNhits = 0;
+  fIshunt   = 1;
+  fNoShower = 0;
+  fMerger   = 0;
 
-//  fNStHits = 0;
+  fHits     = 0;
+  fNhits    = 0;
 
-//  fNPrimaryHits = 0;
-  fNoShower   = 0;
+  fDigits   = 0;
+  fNdigits  = 0;
+  
 }
  
 //_____________________________________________________________________________
@@ -119,19 +128,17 @@ AliZDC::AliZDC(const char *name, const char *title)
   // Standard constructor for the Zero Degree Calorimeter base class
   //
 
-  //
-  // Allocate the array of hits
-  
-  fIshunt =  1;
+  fIshunt   = 1;
+  fNoShower = 0;
+  fMerger   = 0;
 
+  // Allocate the hits array  
   fHits   = new TClonesArray("AliZDCHit",1000);
   gAlice->AddHitList(fHits);
-  
-//  fStHits = new TClonesArray("AliZDCHit",1000);
-//  fNStHits = 0;
 
-//  fNPrimaryHits = 0;
-  fNoShower   = 0;
+  // Allocate the digits array  
+  fDigits = new TClonesArray("AliZDCDigit",1000);
+  
 
 }
 //____________________________________________________________________________ 
@@ -142,14 +149,19 @@ AliZDC::~AliZDC()
   //
 
   fIshunt   = 0;
+  
+//  if(fMerger) delete fMerger;
 
-//  delete fHits;
-//  if(fStHits){
-//    fStHits->Delete();
-//    delete fStHits;
-//    fNStHits = 0;
+//  if(fHits){
+//    fHits->Delete();
+//    delete fHits;
 //  }
-//  delete fDigits;
+
+//  if(fDigits){
+//    fDigits->Delete();
+//    delete fDigits;
+//  }
+
 }
 //_____________________________________________________________________________
 void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits)
@@ -165,10 +177,7 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits)
   static Float_t primKinEn, xImpact, yImpact, sFlag;
 
   AliZDCHit *newquad, *curprimquad;
-//  AliZDCHit *curevquad;  
   newquad = new AliZDCHit(fIshunt, track, vol, hits);
-
-//  TClonesArray &lsthits = *fStHits;
   TClonesArray &lhits = *fHits;
   
   if(fNhits==0){
@@ -194,18 +203,6 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits)
    }
  
   Int_t j;
-//  Int_t i,kStHit = 1;
-//  for(i=0; i<fNStHits; i++){
-//    // If hits are equal (same track, same volume), sum them.
-//     curevquad = (AliZDCHit*) lsthits[i];
-//     kStHit = 1;
-//     if(*curevquad == *newquad){
-//     *curevquad = *curevquad+*newquad;
-//     kStHit = 0;
-//     } 
-//     if(kStHit == 0) break;
-//  }
-
   for(j=0; j<fNhits; j++){
     // If hits are equal (same track, same volume), sum them.
      curprimquad = (AliZDCHit*) lhits[j];
@@ -220,46 +217,37 @@ void AliZDC::AddHit(Int_t track, Int_t *vol, Float_t *hits)
     new(lhits[fNhits]) AliZDCHit(newquad);
     fNhits++;
     
-//    if(kStHit){
-//      new(lsthits[fNStHits]) AliZDCHit(newquad);
-//      fNStHits++;
-//    }
-
-    if(fDebug == 1){ 
-      printf("\n  Primary Hits --------------------------------------------------------\n");
-      fHits->Print("");
-//      printf("\n  Event Hits --------------------------------------------------------\n");
-//      fStHits->Print("");
-    }
-
     delete newquad;
-  }
-//____________________________________________________________________________
-Float_t AliZDC::ZMin(void) const
-{
-  // Minimum dimension of the ZDC module in z
-  return 11600.;
 }
 
-//____________________________________________________________________________
-Float_t AliZDC::ZMax(void) const
-{
-  // Maximum dimension of the ZDC module in z
-  return  11750.;
-}
-  
 //_____________________________________________________________________________
-void AliZDC::ResetDigits()
+void  AliZDC::AddDigit(Int_t *sect, Int_t digit)
 {
-  //
-  // Reset number of digits and the digits array
-  //
-    
-    AliDetector::ResetDigits();
-//    fNStHits = 0;
-//    if(fStHits) fStHits->Clear();
+//
+  AliZDCDigit *newdigit;
+  newdigit = new AliZDCDigit(sect, digit);
+
+//  AliZDCDigit *curdigit;
+//  TClonesArray &ldigits = *fDigits;
+//
+//  Int_t j;
+//  for(j=0; j<fNdigits; j++){
+//     curdigit = (AliZDCDigit*) ldigits[j];
+//     if(*curdigit == *newdigit){
+//     *curdigit = *curdigit+*newdigit;
+//      delete newdigit;
+//      return;
+//     } 
+//  } 
+//
+  
+//  printf("\n AddDigit -> sector[0] = %d, sector[1] = %d, digit = %d",
+//         sect[0], sect[1], digit);
+  new((*fDigits)[fNdigits]) AliZDCDigit(*newdigit);
+  fNdigits++;
+  delete newdigit;
 }
-
+      
 //_____________________________________________________________________________
 void AliZDC::BuildGeometry()
 {
@@ -271,7 +259,7 @@ void AliZDC::BuildGeometry()
 
   TNode *node, *top;
   TBRIK *brik;
-  const int kColorZDC  = kRed;
+  const int kColorZDC  = kBlue;
   
   //
   top=gAlice->GetGeometry()->GetNode("alice");
@@ -293,11 +281,140 @@ Int_t AliZDC::DistancetoPrimitive(Int_t , Int_t )
   //
   return 9999;
 }
+
+//____________________________________________________________________________
+Float_t AliZDC::ZMin(void) const
+{
+  // Minimum dimension of the ZDC module in z
+  return 11600.;
+}
+
+//____________________________________________________________________________
+Float_t AliZDC::ZMax(void) const
+{
+  // Maximum dimension of the ZDC module in z
+  return  11750.;
+}
+  
+
 //_____________________________________________________________________________
-void AliZDC::StepManager()
+ void AliZDC::MakeBranch(Option_t *opt, const char *file)
 {
   //
-  // Routine called at every step in the Zero Degree Calorimeter
+  // Create Tree branches for the ZDC
   //
+
+  char branchname[10];
+  sprintf(branchname,"%s",GetName());
+  
+  AliDetector::MakeBranch(opt);
+
+  const char *cS = strstr(opt,"S");
+
+  if (gAlice->TreeS() && cS) {
+    MakeBranchInTree(gAlice->TreeS(), 
+                     branchname, &fHits, fBufferSize, file) ;
+    printf("* AliZDC::MakeBranch    * Making Branch %s for SDigits\n\n",branchname);
+  }
+
+    
+  const char *cD = strstr(opt,"D");
+
+  if (gAlice->TreeD() && cD) {
+    if(fDigits!=0) fDigits->Clear();
+    else fDigits = new TClonesArray ("AliZDCDigit",1000);
+    MakeBranchInTree(gAlice->TreeD(), 
+                     branchname, &fDigits, fBufferSize, file) ;
+    printf("* AliZDC::MakeBranch    * Making Branch %s for Digits\n\n",branchname);
+  }
+
+  
+  const char *cR = strstr(opt,"R");
+
+  if (gAlice->TreeR() && cR) {
+    MakeBranchInTree(gAlice->TreeR(), 
+                    branchname, &fRecPoints, fBufferSize, file) ;
+    printf("* AliZDC::MakeBranch    * Making Branch %s for RecPoints\n\n",branchname);   }
+          
 }
+
+//_____________________________________________________________________________
+void AliZDC::Hits2SDigits()
+{
+
+  if(!fMerger){ 
+    // ### Copy of TreeH in TreeS
+    // Pointer to TreeH
+//    printf("\n       ZDC digitization (without merging)\n");
+    TTree *treeH = gAlice->TreeH();
+    Int_t ntracks = (Int_t) treeH->GetEntries();
+    Int_t fNhits = 0;
+    gAlice->ResetHits();
+  
+    // Tracks loop
+    for(Int_t itrack=0; itrack<ntracks; itrack++){
+       treeH->GetEvent(itrack);
+       // Hits loop
+       for(AliZDCHit* zdcHit=(AliZDCHit*)this->FirstHit(-1); zdcHit;
+           zdcHit = (AliZDCHit*)this->NextHit()){ 
+         TClonesArray &sdigits = *fHits;
+         new (sdigits[fNhits++]) AliZDCHit(zdcHit);
+       }
+    }
+  
+    gAlice->TreeS()->Fill();
+    gAlice->TreeS()->Write(0,TObject::kOverwrite);  
+    gAlice->TreeS()->Reset();  
+  }
+  
+}
+
+//_____________________________________________________________________________
+void AliZDC::SDigits2Digits()
+{
+  if(!fMerger){ // Only digitization
+//    printf("\n        ZDC digitization (without merging) \n");
+    fMerger = new AliZDCMerger();    
+    fMerger->Digitize();
+  }
+  else{        // Merging and digitization
+    printf("\n        ZDC merging and digitization\n");
+    fMerger -> InitMerging();
+  }
+
+  char hname[30];
+  sprintf(hname,"TreeD%d",gAlice->GetHeader()->GetEvent());
+
+  gAlice->TreeD()->Fill();
+  gAlice->TreeD()->Write(0,TObject::kOverwrite);
+  gAlice->TreeD()->Reset();  
+  
+}
+//_____________________________________________________________________________
+void AliZDC::Hits2Digits()
+{
+    gAlice->Hits2SDigits();
+    gAlice->SDigits2Digits();
+}
+
+//_____________________________________________________________________________
+void AliZDC::Digits2Reco()
+{
+    
+}
+
+//_____________________________________________________________________________
+void   AliZDC::SetMerger(AliZDCMerger* merger)
+{
+// Set pointer to merger 
+    fMerger = merger;
+}
+
+//_____________________________________________________________________________
+AliZDCMerger*  AliZDC::Merger()
+{
+// Return pointer to merger
+    return fMerger;
+}
+
index 095cffd..18320f9 100644 (file)
@@ -8,9 +8,10 @@
 ////////////////////////////////////////////////
 //  Manager and classes for set ZDC           //
 ////////////////////////////////////////////////
+
+class AliZDCMerger;
  
 #include "AliDetector.h"
-
  
 class AliZDC : public AliDetector {
 
@@ -19,6 +20,7 @@ public:
   AliZDC(const char *name, const char *title);
   virtual       ~AliZDC();
   virtual void  AddHit(Int_t track, Int_t *vol, Float_t *hits);
+  virtual void  AddDigit(Int_t *sector, Int_t digit);
   virtual void  BuildGeometry();
   virtual void  CreateGeometry() {}
   virtual void  CreateMaterials() {}
@@ -26,22 +28,34 @@ public:
   virtual Int_t IsVersion() const =0;
   virtual Float_t ZMin() const;        // Minimum overall dimension of the ZDC
   virtual Float_t ZMax() const;        // Maximum overall dimension of the ZDC
-  virtual void  ResetDigits();
-  virtual void  StepManager();
+  virtual void  MakeBranch(Option_t* opt, const char *file=0);
+  virtual void  Hits2SDigits();
+  virtual void  SDigits2Digits();
+  virtual void  Hits2Digits();
+  virtual void  Digits2Reco();
+  virtual void  SetMerger(AliZDCMerger* merger);
+  virtual AliZDCMerger* Merger();
+  virtual void  StepManager() {}
   
   // Switching off the shower development in ZDCs
   void  NoShower(){fNoShower=1;}
   void  Shower()  {fNoShower=0;}
-  
+
 protected:
-  // TClonesArray of stored hits -> not reset et finish event
-  //    (for digitization at the end of the event)
-//  TClonesArray *fStHits;
-//  Int_t fNStHits;
+
+  Int_t        fNoShower;      // Flag to switch off the shower        
+  AliZDCMerger *fMerger;       // ! pointer to merger
   
+  Int_t        fNRecPoints;    // Number of RecPoints
+  TClonesArray *fRecPoints;    // List of RecPoints
+
+//  // --- TClonesArray of stored hits -> not reset et finish event
+//  //                 (for digitization at the end of the event)
+//
+//  TClonesArray *fStHits;
+//  Int_t   fNStHits;
 //  Int_t   fNPrimaryHits;     // Number of primary particles
 
-  Int_t   fNoShower;           // Flag to switch off the shower        
 
   ClassDef(AliZDC,1)   // Zero Degree Calorimeter base class
 };
index 8d03f9f..a8eb896 100644 (file)
@@ -30,18 +30,20 @@ ClassImp(AliZDCDigit)
 {
   // Default constructor 
   
-  fDetector = 0;
-  fQuadrant = 0;
+  fSector[0]   = 0;
+  fSector[1]   = 0;
   fADCValue = 0;  
 }
 
 //____________________________________________________________________________
-AliZDCDigit::AliZDCDigit(Int_t Det, Int_t Quad, Float_t ADCValue) 
+AliZDCDigit::AliZDCDigit(Int_t *Sector, Int_t ADCValue) 
 {  
   // Constructor 
  
-  fDetector = Det;
-  fQuadrant = Quad;
+  Int_t i;
+  for(i=0; i<2; i++) {
+     fSector[i] = Sector[i];
+  }
   fADCValue = ADCValue;  
 }
 
@@ -50,8 +52,8 @@ AliZDCDigit::AliZDCDigit(const AliZDCDigit & digit)
 {
   // Copy constructor
 
-  fDetector = digit.fDetector;           
-  fQuadrant = digit.fQuadrant;           
+  fSector[0]   = digit.fSector[0];           
+  fSector[1]   = digit.fSector[1];           
   fADCValue = digit.fADCValue;             
 
 }
index 312f6c4..8836730 100644 (file)
@@ -17,41 +17,38 @@ class AliZDCDigit : public AliDigitNew {
  public:
   
   AliZDCDigit() ;
-  AliZDCDigit(Int_t Det, Int_t Quad, Float_t ADCValue);
+  AliZDCDigit(Int_t *Sector, Int_t ADCValue);
   AliZDCDigit(const AliZDCDigit & digit);
+  virtual ~AliZDCDigit() {}
 
   // Getters 
-  virtual Float_t   GetDetector() {return fDetector;}
-  virtual Float_t   GetQuadrant() {return fQuadrant;}
+  virtual Float_t   GetSector(Int_t i) {return fSector[i];}
   virtual Float_t   GetADCValue() {return fADCValue;}
 
-  virtual ~AliZDCDigit(){} 
-
   // Operators
   Int_t operator == (AliZDCDigit &digit) {
     // Two digits are equal if they refers to the detector
     // in the same sub-volume (same procedure as for hits)
-    if (fDetector != digit.fDetector) return 0;
-    if (fQuadrant != digit.fQuadrant) return 0;
+    Int_t i;
+    for(i=0; i<2; i++) if(fSector[i]!=digit.GetSector(i)) return 0;
     return 1;
   }
   virtual AliZDCDigit& operator + (AliZDCDigit &digit) {
     // Adds the amplitude of digits 
-
     fADCValue += digit.fADCValue ;
     return *this ;
   }
   
  protected:
 
-  Int_t   fDetector;          // Detector
-  Int_t   fQuadrant;          // Quadrant
+  //Data members
+  Int_t   fSector[2];         // Detecor and tower in which light is produced
   Float_t fADCValue;          // ADC channel value
 
   // Print method
   virtual void Print(Option_t *) {
-     printf(" -> DIGIT: Det =  %d Quad =  %d ADCCh =  %f\n ",
-     fDetector, fQuadrant, fADCValue);
+     printf(" -> DIGIT: Detector =  %d Quadrant =  %d ADCCh =  %f\n ",
+     fSector[0], fSector[1], fADCValue);
   }
     
   ClassDef(AliZDCDigit,1)   // Digits in ZDC 
index 47e6c60..6bf6675 100644 (file)
@@ -19,9 +19,17 @@ public:
 
   // Getters 
   virtual Int_t   GetVolume(Int_t i) {return fVolume[i];}
-  virtual Float_t GetLightPMQ() {return fLightPMQ;}
-  virtual Float_t GetLightPMC() {return fLightPMC;}
-  virtual Float_t GetEnergy() {return fEnergy;}
+  virtual Float_t GetPrimKinEn()     {return fPrimKinEn;}
+  virtual Float_t GetXImpact()       {return fXImpact;}
+  virtual Float_t GetYImpact()       {return fYImpact;}
+  virtual Float_t GetSFlag()         {return fSFlag;}
+  virtual Float_t GetLightPMQ()      {return fLightPMQ;}
+  virtual Float_t GetLightPMC()      {return fLightPMC;}
+  virtual Float_t GetEnergy()        {return fEnergy;}
+
+  // Setters 
+  virtual void SetLightPMQ(Float_t value) {fLightPMQ=value;}
+  virtual void SetLightPMC(Float_t value) {fLightPMC=value;}
 
 
   // Data members
@@ -38,7 +46,6 @@ public:
   // Operators
   Int_t operator == (AliZDCHit &quad) {
      Int_t i;
-//      Superfluo finche' c'e' shunt = 1 !?!?
      if(fTrack!=quad.GetTrack()) return 0;
      for(i=0; i<2; i++) if(fVolume[i]!=quad.GetVolume(i)) return 0;
      return 1;
diff --git a/ZDC/AliZDCMerger.cxx b/ZDC/AliZDCMerger.cxx
new file mode 100644 (file)
index 0000000..b37bcf1
--- /dev/null
@@ -0,0 +1,524 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+//                     ZDC event merging class                              //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+// --- ROOT system
+#include <iostream.h>
+#include <TTree.h>
+#include <TFile.h>
+#include <TDirectory.h>
+#include <TH1.h>
+
+// --- AliRoot header files
+#include "AliZDCMerger.h"
+#include "AliZDC.h"
+#include "AliZDCHit.h"
+#include "AliZDCDigit.h"
+#include "AliZDCFragment.h"
+#include "AliRun.h"
+#include "AliDetector.h"
+#include "AliHeader.h"
+#include "AliGenEventHeader.h"
+#include "/home/oppedisa/AliRoot/pro/EVGEN/AliGenHijingEventHeader.h"
+
+ClassImp(AliZDCMerger)
+
+//____________________________________________________________________________
+AliZDCMerger::AliZDCMerger()
+{
+// Default constructor    
+    fMerge       = kDigitize;
+    fNEvBgr     = 0;
+    fFnBgr       = 0;
+//    fFnBgr       = "/home/oppedisa/alirun/hijing.root";
+    fBgrFile     = 0;
+    fTrHBgr      = 0;
+    fTrSDBgr     = 0;
+    fImpPar      = 0;
+    fSpecn       = 0;
+    fSpecp       = 0;
+    fFreeSpn     = 0;
+    fFreeSpp     = 0;
+    fFnSpecn     = 0;
+//    fFnSpecn     = "/home/oppedisa/alirun/ZNsignal.root";
+    fSpecnFile   = 0;
+    fFnSpecp     = 0;
+//    fFnSpecp     = "/home/oppedisa/alirun/ZPsignal.root";
+    fSpecpFile   = 0;
+    
+}
+
+//____________________________________________________________________________
+AliZDCMerger::~AliZDCMerger()
+{
+// Destructor
+    if (fBgrFile)    delete fBgrFile;
+    if (fTrHBgr)     delete fTrHBgr;
+    if (fTrSDBgr)    delete fTrSDBgr;
+    if (fHitsBgr)    delete fHitsBgr;
+    if (fSpecnFile)  delete fSpecnFile;
+    if (fSpecpFile)  delete fSpecpFile;
+}
+
+//____________________________________________________________________________
+void AliZDCMerger::InitMerging()
+{
+    // Hits tree, impact parameter, num. of spectators n & p 
+    //                 in background (full Hijing) event
+    Float_t b;
+    Int_t nspecn, nspecp;
+    Background(b, nspecn, nspecp);
+
+    // Production of nuclear fragments -> num. of FREE spectators n & p
+    Fragmentation(b, nspecn, nspecp, fFreeSpn, fFreeSpp);
+    
+    // Extract from spectators distribution the signal events:
+    // NFreeSpectatorN spectator n & NFreeSpectatorP spectator p 
+    Mixing(fFreeSpn, fFreeSpp);
+}
+
+//____________________________________________________________________________
+void AliZDCMerger::Background(Float_t &fImpPar, Int_t &fSpecn, Int_t &fSpecp)
+{
+    
+    // --- Open the background file
+    if (fMerge && !fBgrFile) fBgrFile = OpenBgrFile();
+    
+    // --- Read from the TreeE impact parameter (b),
+    //     # of spectators n and p (fSpecn, fSpecp)
+    fBgrFile->cd();
+
+    // Get AliRun object from file or create it if not on file
+    gAlice = (AliRun*)fBgrFile->Get("gAlice");
+    if (!gAlice) {
+      gAlice = (AliRun*)fBgrFile->Get("gAlice");
+      if (gAlice) printf("AliRun object found on file\n");
+      if (!gAlice) {
+         printf("\n create new gAlice object");
+         gAlice = new AliRun("gAlice","Alice test program");
+      }
+    }
+
+//    gAlice = (AliRun*)fBgrFile->Get("gAlice");
+    AliHeader *header = gAlice->GetHeader();
+    AliGenEventHeader* mcHeader = header->GenEventHeader();
+    fImpPar = ((AliGenHijingEventHeader*) mcHeader)->ImpactParameter();
+    fSpecn  = ((AliGenHijingEventHeader*) mcHeader)->Spectatorsn();
+    fSpecp  = ((AliGenHijingEventHeader*) mcHeader)->Spectatorsp();
+//      printf("\n     HIJING simulation - b = %f fm, Nspecn = %d, Nspecp = %d\n",fImpPar,fSpecn,fSpecp);
+}
+
+//____________________________________________________________________________
+TFile* AliZDCMerger::OpenBgrFile()
+{
+    // Initialise background event
+    TFile *file = new TFile(fFnBgr,"UPDATE");
+//      printf("\n AliZDCMerger --- Background event -> %s file opened \n", fFnBgr);
+    fHitsBgr = new TClonesArray("AliZDCHit",1000);
+    return file;
+}
+
+//____________________________________________________________________________
+void AliZDCMerger::Fragmentation(Float_t fImpPar, Int_t fSpecn, Int_t fSpecp,
+                                 Int_t &fFreeSpn, Int_t &fFreeSpp)
+{
+    Int_t j, zz[100], nn[100], nAlpha, Ztot, Ntot;
+    AliZDCFragment *frag = new AliZDCFragment(fImpPar);
+    for(j=0; j<=99; j++){
+       zz[j] =0;
+       nn[j] =0;
+    }
+
+    // Fragments generation
+    frag->GenerateIMF(zz, nAlpha);
+
+    // Attach neutrons
+    Ztot=0;
+    Ntot=0;
+    frag->AttachNeutrons(zz, nn, Ztot, Ntot);
+    fFreeSpn = fSpecn-Ztot-2*nAlpha;
+    fFreeSpp = fSpecp-Ntot-2*nAlpha;
+//      printf("\n     Fragmentation -> FreeSpn = %d, FreeSpp = %d\n",fFreeSpn,fFreeSpp);
+}
+
+//____________________________________________________________________________
+void AliZDCMerger::Mixing(Int_t fFreeSpn, Int_t fFreeSpp)
+{
+
+//      printf("\n     AliZDCMerger->Mixing\n");
+        
+    // ### Background event Hits ###########################################
+    fBgrFile->cd();
+//    fBgrFile->ls();
+    
+    AliZDC *ZDC = (AliZDC *)gAlice->GetModule("ZDC");
+//    if(ZDC) printf("\n       Ho trovato lo ZDC!\n");
+
+    // Hits tree
+    if(fTrHBgr) delete fTrHBgr;
+    fTrHBgr = 0;    
+    // SDigits tree
+    if(fTrSDBgr) delete fTrSDBgr;
+    fTrSDBgr = 0;    
+
+//    // Read from Event Tree the # of events of the Hijing file 
+//    TTree *thead = (TTree *) fBgrFile->Get("TE");
+//    if(!te){
+//      printf("\n     ERROR! -> File %s does not contain TreeE\n");
+//    }
+//    fNEvBgr = (Int_t) te->GetEntries();
+    fNEvBgr = 0; // Let's suppose to have 1 full Hijing event per file
+
+    // Hits Tree
+    char treeBgrName[20];
+    sprintf(treeBgrName,"TreeH%d",fNEvBgr);
+    fTrHBgr = (TTree*)gDirectory->Get(treeBgrName); // TreeH
+    if(!fTrHBgr){
+      printf("\n ERROR -> Can't find TreeH%d in background file\n",fNEvBgr);
+    }    
+    Int_t ntracks =  (Int_t) fTrHBgr->GetEntries();
+//    printf("\n       --- ntracks = %d\n",ntracks);
+
+    // SDigits Tree
+    char treeSBgrName[20];
+    sprintf(treeSBgrName,"TreeS%d",fNEvBgr);
+    fTrSDBgr = (TTree*)gDirectory->Get(treeSBgrName); // TreeH
+    if(!fTrSDBgr){
+      printf("\n ERROR -> Can't find TreeS%d in background file\n",fNEvBgr);
+    }    
+
+    Int_t itrack, i, volume[2], detector, quadrant;
+    TClonesArray &sdigits = *fHitsBgr; // SDigits TCArray
+    Float_t hits[10];
+    // --- Tracks loop
+    for(itrack=0; itrack<ntracks; itrack++){
+//       printf("              itrack = %d \n", itrack);
+       fTrHBgr->GetEvent(itrack);
+       
+       fTrack = itrack;
+       Int_t NMhits  = 0;
+       for(AliZDCHit* zdcHit=(AliZDCHit*)ZDC->FirstHit(-1); 
+           zdcHit;
+          zdcHit = (AliZDCHit*)ZDC->NextHit()){ 
+
+         for(i=0; i<2; i++) volume[i] = zdcHit->GetVolume(i);
+//       printf("\n            volume[0] = %d volume[1]= %d \n",volume[0], volume[1]);
+         if(volume[0] != 3){
+           // Background hits  
+           hits[7] = zdcHit->GetLightPMQ();
+           hits[8] = zdcHit->GetLightPMC();
+//         printf("\n  Prima ### Background -> PMQ = %f, PMC = %f\n",hits[7],hits[8]);
+
+            //Signal hits
+           detector = volume[0];
+           quadrant = volume[1];
+           ExtractSignal(detector, quadrant, fQuadLight, fComLight);      
+           hits[7] += fQuadLight;
+           hits[8] += fComLight;
+//         printf("\n  Bckg + Signal -> PMQ = %f, PMC = %f\n",hits[7],hits[8]);
+
+            zdcHit->SetLightPMQ(hits[7]);
+            zdcHit->SetLightPMC(hits[8]);
+           hits[7] = zdcHit->GetLightPMQ();
+           hits[8] = zdcHit->GetLightPMC();
+//         printf("\n  Dopo ### Background -> PMQ = %f, PMC = %f\n",hits[7],hits[8]);
+                   
+           new (sdigits[NMhits++]) AliZDCHit(zdcHit);
+//            printf("\n       NMhits = %d\n",NMhits);
+         }
+          fBgrFile->cd();
+          fTrSDBgr->Fill();
+          fTrSDBgr->Write(0,TObject::kOverwrite);
+       } //Hits loop
+       Digitize();
+    } // Tracks loop
+        
+//    fBgrFile->Close();
+        
+}
+
+//____________________________________________________________________________
+void AliZDCMerger::ExtractSignal(Int_t detector, Int_t quadrant,
+                                    Float_t &fQuadLight, Float_t &fComLight)
+{
+
+//    printf("\n       Entering ExtractSignal method -> detector = %d quadrant = %d\n",
+//           detector, quadrant);
+
+    // Connect spectator n histo's file
+    fSpecnFile = TFile::Open("/home/oppedisa/alirun/ZNsignal.root");
+    fSpecnFile->cd();
+//    fSpecnFile->ls();
+    TH1F *hPMQ1zn = (TH1F*) gDirectory->Get("hPMQ1zn;1");
+    TH1F *hPMQ2zn = (TH1F*) gDirectory->Get("hPMQ2zn;1");
+    TH1F *hPMQ3zn = (TH1F*) gDirectory->Get("hPMQ3zn;1");
+    TH1F *hPMQ4zn = (TH1F*) gDirectory->Get("hPMQ4zn;1");
+    TH1F *hPMC1zn = (TH1F*) gDirectory->Get("hPMC1zn;1");
+    TH1F *hPMC2zn = (TH1F*) gDirectory->Get("hPMC2zn;1");
+    TH1F *hPMC3zn = (TH1F*) gDirectory->Get("hPMC3zn;1");
+    TH1F *hPMC4zn = (TH1F*) gDirectory->Get("hPMC4zn;1");
+//    Axis_t x = hPMQ1zn -> GetRandom();
+//    printf(" hPMQ1zn -> GetRandom() = %f\n",x);
+    
+    // Connect spectator p histo's file
+    fSpecpFile = TFile::Open("/home/oppedisa/alirun/ZPsignal.root");
+    fSpecpFile->cd(); 
+//    fSpecpFile->ls();
+    TH1F *hPMQ1zp = (TH1F*) gDirectory->Get("hPMQ1zp;1");
+    TH1F *hPMQ2zp = (TH1F*) gDirectory->Get("hPMQ2zp;1");
+    TH1F *hPMQ3zp = (TH1F*) gDirectory->Get("hPMQ3zp;1");
+    TH1F *hPMQ4zp = (TH1F*) gDirectory->Get("hPMQ4zp;1");
+    TH1F *hPMC1zp = (TH1F*) gDirectory->Get("hPMC1zp;1");
+    TH1F *hPMC2zp = (TH1F*) gDirectory->Get("hPMC2zp;1");
+    TH1F *hPMC3zp = (TH1F*) gDirectory->Get("hPMC3zp;1");
+    TH1F *hPMC4zp = (TH1F*) gDirectory->Get("hPMC4zp;1");
+
+    if(detector == 1){ // --- ZN
+      if(quadrant == 1){
+        fQuadLight = (Float_t) hPMQ1zn -> GetRandom();
+       fComLight = (Float_t) hPMC1zn -> GetRandom();
+      }
+      else if(quadrant == 2){
+        fQuadLight = (Float_t) hPMQ2zn -> GetRandom();
+       fComLight = (Float_t) hPMC2zn -> GetRandom();
+      }
+      else if(quadrant == 3){
+        fQuadLight = (Float_t) hPMQ3zn -> GetRandom();
+       fComLight = (Float_t) hPMC3zn -> GetRandom();
+      }
+      else if(quadrant == 4){
+        fQuadLight = (Float_t) hPMQ4zn -> GetRandom();
+       fComLight = (Float_t) hPMC4zn -> GetRandom();
+      }
+    }
+
+    else if(detector == 2){ // --- ZP
+      fSpecpFile->cd();        // Connect spectator p histo's file
+//      fSpecpFile->ls();
+      if(quadrant == 1){
+        fQuadLight = (Float_t) hPMQ1zp -> GetRandom();
+       fComLight = (Float_t) hPMC1zp -> GetRandom();
+      }
+      else if(quadrant == 2){
+        fQuadLight = (Float_t) hPMQ2zp -> GetRandom();
+       fComLight = (Float_t) hPMC2zp -> GetRandom();
+      }
+      else if(quadrant == 3){
+        fQuadLight = (Float_t) hPMQ3zp -> GetRandom();
+       fComLight = (Float_t) hPMC3zp -> GetRandom();
+      }
+      else if(quadrant == 4){
+        fQuadLight = (Float_t) hPMQ4zp -> GetRandom();
+       fComLight = (Float_t) hPMC4zp -> GetRandom();
+      }
+    }
+//    printf(" ---     Exiting ExtractSignal -> fQuadLight = %f, fComLight = %f",
+//           fQuadLight,fComLight);
+
+}
+
+//____________________________________________________________________________
+void AliZDCMerger::Digitize()
+{
+
+//  printf("\n AliZDCMerger->Digitize()");
+
+  AliZDC *ZDC = (AliZDC *)gAlice->GetModule("ZDC");
+//  if(ZDC) printf("\n         Ho trovato lo ZDC!\n");
+
+  Int_t itrack, lightQ, lightC, sector[2], digit;
+  Int_t PMCZN = 0, PMCZP = 0, PMQZN[4], PMQZP[4], PMZEM = 0;
+  Int_t i;
+  for(i=0; i<4; i++){
+     PMQZN[i] = 0;
+     PMQZP[i] = 0;
+  }
+
+  // ### Digitization "on the flight" (no merging) #######################
+  if(fMerge == kDigitize){
+//    printf("\n               fMerge == kDigitize\n");
+    fTrHBgr = gAlice->TreeH(); // TTree
+    TTree *treeH = gAlice->TreeH();
+    if(!fTrHBgr){
+      printf("\n ERROR -> Can't find TreeH%d in background file\n",fNEvBgr);
+    }    
+    Int_t ntracks =  (Int_t) treeH->GetEntries();
+//    printf("\n       --- ntracks = %d\n",ntracks);
+        
+    // Loop over tracks
+    for(itrack=0; itrack<ntracks; itrack++){
+       gAlice->ResetHits();
+       gAlice->TreeH()->GetEvent(itrack);
+       
+       // Loop over hits
+       for(AliZDCHit* zdcHit=(AliZDCHit*)ZDC->FirstHit(-1); 
+           zdcHit;
+          zdcHit = (AliZDCHit*)ZDC->NextHit()){ 
+         sector[0] = zdcHit->GetVolume(0);
+         sector[1] = zdcHit->GetVolume(1);
+         lightQ    = Int_t(zdcHit->GetLightPMQ());
+         lightC    = Int_t(zdcHit->GetLightPMC());
+//       printf("\n    Digitise -> DET. = %d, quad = %d", sector[0], sector[1]);
+//       printf("                  PMQ = %d, PMC = %d",  lightQ, lightC);
+          
+         if(sector[0] == 1){   //ZN 
+           PMCZN = PMCZN + lightC;
+           PMQZN[sector[1]-1] = PMQZN[sector[1]-1] + lightQ;
+         }
+          else if(sector[0] == 2){     //ZP 
+           PMCZP = PMCZP + lightC;
+           PMQZP[sector[1]-1] = PMQZP[sector[1]-1] + lightQ;
+         }
+          else if(sector[0] == 3){     //ZEM 
+           PMZEM = PMZEM + lightC;
+         }
+       } // hits loop
+    } // tracks loop
+  } // if(fMerge)
+
+  // ### Merging and digitization #######################################
+  else if(fMerge == kMerge){
+//    printf("\n               fMerge == kMerge\n");
+
+//    Int_t ntracks =  (Int_t) fTrHBgr->GetEntries();
+//    printf("\n        --- ntracks = %d\n",ntracks);
+//        
+//    // Loop over tracks
+//    for(itrack=0; itrack<ntracks; itrack++){
+       fTrHBgr->GetEvent(fTrack);
+       
+//       printf("\n\n  Track # %d --- Digitise -> ", fTrack);
+       // Loop over hits
+       for(AliZDCHit* zdcHit=(AliZDCHit*)ZDC->FirstHit(-1); 
+           zdcHit;
+          zdcHit = (AliZDCHit*)ZDC->NextHit()){ 
+         sector[0] = zdcHit->GetVolume(0);
+         sector[1] = zdcHit->GetVolume(1);
+         lightQ    = Int_t(zdcHit->GetLightPMQ());
+         lightC    = Int_t(zdcHit->GetLightPMC());
+//       printf("\n    DET. = %d, quad = %d,PMQ = %d, PMC = %d", 
+//              sector[0], sector[1],lightQ, lightC);
+          
+         if(sector[0] == 1){   //ZN 
+           PMCZN = PMCZN + lightC;
+           PMQZN[sector[1]-1] = PMQZN[sector[1]-1] + lightQ;
+         }
+          else if(sector[0] == 2){     //ZP 
+           PMCZP = PMCZP + lightC;
+           PMQZP[sector[1]-1] = PMQZP[sector[1]-1] + lightQ;
+         }
+          else if(sector[0] == 3){     //ZEM 
+           PMZEM = PMZEM + lightC;
+         }
+       } // hits loop
+//    } // tracks loop
+  } // if(fMerge)
+
+      
+  // Create digits for ZN
+  Int_t PedValue;
+  sector[0] = 1; // Detector = ZN
+  sector[1] = 0; // Common PM ADC
+  digit = Phe2ADCch(1, 0, PMCZN);
+//  printf("\n\n       ZN ###  PMCZN = %d      ADCZN = %d",PMCZN, digit);
+  ZDC->AddDigit(sector, digit);
+  Int_t j;
+  for(j=0; j<4; j++){
+    sector[1] = j+1; // Towers PM ADCs
+    digit = Phe2ADCch(1, j+1, PMQZN[j]);
+//    printf("\n               PMQZN[%d] = %d  ADCZN[%d] = %d",j,PMQZN[j],j,digit);
+    PedValue = AddPedestal();
+    digit += PedValue;
+//    printf(" PedValue = %d",PedValue);
+    ZDC->AddDigit(sector, digit);
+  }
+//    printf("\n");
+  
+  // Create digits for ZP
+  sector[0] = 2; // Detector = ZP
+  sector[1] = 0; // Common PM ADC
+  digit = Phe2ADCch(2, 0, PMCZP);
+//  printf("\n ZP --- PMCZP = %d       ADCZP = %d",PMCZP,digit);
+  ZDC->AddDigit(sector, digit);
+  for(j=0; j<4; j++){
+    sector[1] = j+1; // Towers PM ADCs
+    digit = Phe2ADCch(2, j+1, PMQZP[j]);
+//    printf("\n              PMQZP[%d] = %d   ADCZP[%d] = %d",j,PMQZP[j],j,digit);
+    PedValue = AddPedestal();
+    digit += PedValue;
+//    printf(" PedValue = %d",PedValue);
+    ZDC->AddDigit(sector, digit);
+  }
+//    printf("\n");
+  
+  // Create digits for ZEM
+  sector[0] = 3; // Detector = ZZEM
+  sector[1] = 0; // Single PM ADC
+  digit  = Phe2ADCch(3, 0, PMZEM);
+//  printf("\n ZEM *** PMZEM = %d      ADCZEM = %d",PMZEM,digit);
+    PedValue = AddPedestal();
+    digit += PedValue;
+//    printf(" PedValue = %d\n",PedValue);
+  ZDC->AddDigit(sector, digit); 
+
+}
+
+//_____________________________________________________________________________
+Int_t AliZDCMerger::Phe2ADCch(Int_t Det, Int_t Quad, Int_t Light)
+{
+  // Evaluation of the ADC channel corresponding to the light yield Light
+
+  if(gAlice->GetDebug() > 0){
+//    printf("\n  Phe2ADCch -> Detector = %d, Quadrant = %d, Light = %d\n", Det, Quad, Light);
+  }
+  
+  Int_t ADCch = 0;
+  // Parameters for conversion of light yield in ADC channels
+  Float_t fPMGain[3][5];      // PM gain
+  Float_t fADCRes;            // ADC conversion factor
+  
+  Int_t j,i;
+  for(i=0; i<3; i++){
+     for(j=0; j<5; j++){
+        fPMGain[i][j]   = 100000.;
+     }
+  }
+  fADCRes   = 0.00000064; // ADC Resolution: 250 fC/ADCch
+  
+  ADCch = (Int_t) (Light*fPMGain[Det-1][Quad]*fADCRes);
+     
+  return ADCch;
+}
+
+//_____________________________________________________________________________
+Int_t AliZDCMerger::AddPedestal()
+{
+  // --- Pedestal value -> extracted from a gaussian distribution
+  // obtained from the beam test on the ZEM prototype (Aug. 2000)
+  
+  Int_t PedValue;
+  Float_t PedMean  = 50.;
+  Float_t PedWidth = 10.;
+  
+  PedValue    = (Int_t) gRandom->Gaus(PedMean,PedWidth);
+  
+  return PedValue;
+}
diff --git a/ZDC/AliZDCMerger.h b/ZDC/AliZDCMerger.h
new file mode 100644 (file)
index 0000000..2407a49
--- /dev/null
@@ -0,0 +1,90 @@
+#ifndef ALIZDCMERGER_H
+#define ALIZDCMERGER_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+////////////////////////////////////////////////
+//             Merger class for ZDC          //
+////////////////////////////////////////////////
+
+class AliZDC;
+class AliZDCHit;
+class AliZDCDigit;
+
+typedef enum {kDigitize=0, kMerge=1} MergeMode_t;
+
+class AliZDCMerger{
+
+public:
+   AliZDCMerger();
+   virtual ~AliZDCMerger();
+   
+   void    InitMerging();
+   void    Background(Float_t &b, Int_t &nspecn, Int_t &nspecp);
+   void    Fragmentation(Float_t b, Int_t nspecn, Int_t nspecp,
+                         Int_t &nfreespn, Int_t &nfreespp);
+   void    Mixing(Int_t nfreespn, Int_t nfreespp);
+   void    ExtractSignal(Int_t detector, Int_t quadrant, Float_t &quadLight, 
+                         Float_t &comLight);
+//   void    MergeHit(Int_t track, Int_t *vol, Float_t *hits);
+
+   void    Digitize();
+   Int_t   Phe2ADCch(Int_t Detector, Int_t Quadrant, Int_t Light);
+   Int_t   AddPedestal();
+   
+   // Setters 
+   void SetBackgroundFileName(char* file) {fFnBgr = file;}        
+   void SetMode(MergeMode_t mode)         {fMerge = mode;}
+     
+private:
+   //Open the background file 
+   TFile *OpenBgrFile(); 
+
+protected:
+   MergeMode_t  fMerge;                // Merging type kDigitize, kMerge
+   
+   // Background event
+   Int_t       fNEvBgr;        // Number of events in the background file
+   char         *fFnBgr;       // Background file name
+   TFile       *fBgrFile;      // Pointer to background file
+   TTree        *fTrHBgr;      // Hits tree for background event
+   TTree        *fTrSDBgr;     // SDigits tree for background event
+   Float_t     fImpPar;        // Impact Parameter of the collision
+   Int_t        fSpecn;                // Number of spectator n
+   Int_t        fSpecp;                // Number of spectator p
+   TClonesArray *fHitsBgr;     // TClonesArray of background hits
+
+   // Signal events
+   Int_t        fFreeSpn;       // Signal event number x spectator n
+   Int_t        fFreeSpp;       // Signal event number x spectator p
+      
+   // File containing hit histograms for spectators
+   char        *fFnSpecn;      // Spectator n file name
+   TFile       *fSpecnFile;    // Pointer to signal file -> spectator n
+   char        *fFnSpecp;      // Spectator p file name
+   TFile       *fSpecpFile;    // Pointer to signal file -> spectator p
+   Float_t     fQuadLight;     // Light produced in tower PM
+   Float_t     fComLight;      // Light produced in common PM
+   
+   Int_t       fTrack;
+
+//  // *** Digits
+//  // --- Digitization parameters setters and getters
+//  //         PM gain
+//  void SetPMGain(Int_t Det, Int_t PMDet, Int_t PMGain)
+//       {fPMGain[Det][PMDet] = PMGain;}
+//  Float_t GetPMGain(Int_t Det, Int_t PMDet)
+//       {return fPMGain[Det][PMDet];}
+//  //         Conversion factor from charge to ADC channels
+//  //         F = 1.6E-19 / Resolution [Coulomb/ch]
+//  void SetADCRes(Int_t ADCRes) {fADCRes =  ADCRes;}
+//  Float_t GetADCRes() {return fADCRes;}
+//
+//  // --- Parameters for conversion of light yield in ADC channels
+//  Float_t fPMGain[3][5];      // PM gain
+//  Float_t fADCRes;            // ADC conversion factor
+  
+       
+    ClassDef(AliZDCMerger,0)
+};    
+#endif
index 8a39fed..1fb6039 100644 (file)
@@ -13,7 +13,8 @@ FSRCS       =
 
 # C++ sources
 
-SRCS          = AliZDC.cxx AliZDCv1.cxx  AliZDCv2.cxx AliZDCHit.cxx AliZDCDigit.cxx AliGenZDC.cxx AliZDCFragment.cxx
+SRCS          = AliZDC.cxx AliZDCv1.cxx AliZDCv2.cxx AliZDCHit.cxx AliZDCDigit.cxx \
+                AliGenZDC.cxx AliZDCFragment.cxx AliZDCMerger.cxx
 
 # C++ Headers
 
index e1b2763..03f4979 100644 (file)
@@ -15,5 +15,6 @@
 #pragma link C++ class  AliZDCDigit+;
 #pragma link C++ class  AliGenZDC+;
 #pragma link C++ class  AliZDCFragment+;
+#pragma link C++ class  AliZDCMerger+;
 
 #endif