Adding the complete vzero raw data to the esd friend. The channel numbering follows...
authorcvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Sep 2008 22:07:00 +0000 (22:07 +0000)
committercvetan <cvetan@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Sep 2008 22:07:00 +0000 (22:07 +0000)
STEER/AliESDEvent.cxx
STEER/AliESDVZEROfriend.cxx [new file with mode: 0644]
STEER/AliESDVZEROfriend.h [new file with mode: 0644]
STEER/AliESDfriend.cxx
STEER/AliESDfriend.h
STEER/AliReconstruction.cxx
STEER/ESDLinkDef.h
STEER/libESD.pkg
VZERO/AliVZERORawStream.h
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROReconstructor.h

index a2c17ec..2adc3f5 100644 (file)
@@ -894,8 +894,10 @@ void AliESDEvent::GetESDfriend(AliESDfriend *ev) const
     t->ReleaseESDfriendTrack();// Not to have two copies of "friendTrack"
 
   }
-}
 
+  AliESDfriend *fr = (AliESDfriend*)(const_cast<AliESDEvent*>(this)->FindListObject("AliESDfriend"));
+  if (fr) ev->SetVZEROfriend(fr->GetVZEROfriend());
+}
 
 void AliESDEvent::AddObject(TObject* obj) 
 {
diff --git a/STEER/AliESDVZEROfriend.cxx b/STEER/AliESDVZEROfriend.cxx
new file mode 100644 (file)
index 0000000..a242bb4
--- /dev/null
@@ -0,0 +1,168 @@
+/**************************************************************************
+ * 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 class for containing all the VZERO DDL raw data
+/// It is written to the ESD-friend file
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliESDVZEROfriend.h"
+
+ClassImp(AliESDVZEROfriend)
+
+//_____________________________________________________________________________
+AliESDVZEROfriend::AliESDVZEROfriend():
+  TObject(),
+  fTrigger(0),
+  fTriggerMask(0)
+{
+  // default constructor
+  for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+    fScalers[iScaler] = 0;
+
+  for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
+    fBunchNumbers[iBunch] = 0;
+
+  for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+    fBBScalers[iChannel] = 0;
+    fBGScalers[iChannel] = 0;
+    for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
+      fChargeMB[iChannel][iBunch] = 0;
+      fIsIntMB[iChannel][iBunch] = kFALSE;
+      fIsBBMB[iChannel][iBunch] = kFALSE;
+      fIsBGMB[iChannel][iBunch] = kFALSE;
+    }
+    for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+      fADC[iChannel][iEv] = 0;
+      fIsInt[iChannel][iEv] = kFALSE;
+      fIsBB[iChannel][iEv] = kFALSE;
+      fIsBG[iChannel][iEv] = kFALSE;
+    }
+    fTime[iChannel] = 0;
+    fWidth[iChannel] = 0;
+  }
+}
+
+//_____________________________________________________________________________
+AliESDVZEROfriend::~AliESDVZEROfriend()
+{
+  // destructor
+}
+
+//_____________________________________________________________________________
+AliESDVZEROfriend::AliESDVZEROfriend(const AliESDVZEROfriend& vzerofriend):
+  TObject(vzerofriend),
+  fTrigger(vzerofriend.fTrigger),
+  fTriggerMask(vzerofriend.fTriggerMask)
+{
+  // copy constructor
+  for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+    fScalers[iScaler] = vzerofriend.fScalers[iScaler];
+
+  for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
+    fBunchNumbers[iBunch] = vzerofriend.fBunchNumbers[iBunch];
+
+  for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+    fBBScalers[iChannel] = vzerofriend.fBBScalers[iChannel];
+    fBGScalers[iChannel] = vzerofriend.fBGScalers[iChannel];
+    for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
+      fChargeMB[iChannel][iBunch] = vzerofriend.fChargeMB[iChannel][iBunch];
+      fIsIntMB[iChannel][iBunch] = vzerofriend.fIsIntMB[iChannel][iBunch];
+      fIsBBMB[iChannel][iBunch] = vzerofriend.fIsBBMB[iChannel][iBunch];
+      fIsBGMB[iChannel][iBunch] = vzerofriend.fIsBGMB[iChannel][iBunch];
+    }
+    for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+      fADC[iChannel][iEv] = vzerofriend.fADC[iChannel][iEv];
+      fIsInt[iChannel][iEv] = vzerofriend.fIsInt[iChannel][iEv];
+      fIsBB[iChannel][iEv] = vzerofriend.fIsBB[iChannel][iEv];
+      fIsBG[iChannel][iEv] = vzerofriend.fIsBG[iChannel][iEv];
+    }
+    fTime[iChannel] = vzerofriend.fTime[iChannel];
+    fWidth[iChannel] = vzerofriend.fWidth[iChannel];
+  }
+}
+
+//_____________________________________________________________________________
+AliESDVZEROfriend& AliESDVZEROfriend::operator = (const AliESDVZEROfriend& vzerofriend)
+{
+  // assignment operator
+  if(&vzerofriend == this) return *this;
+  TObject::operator=(vzerofriend);
+
+  fTrigger = vzerofriend.fTrigger;
+  fTriggerMask = vzerofriend.fTriggerMask;
+
+  for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+    fScalers[iScaler] = vzerofriend.fScalers[iScaler];
+
+  for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
+    fBunchNumbers[iBunch] = vzerofriend.fBunchNumbers[iBunch];
+
+  for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+    fBBScalers[iChannel] = vzerofriend.fBBScalers[iChannel];
+    fBGScalers[iChannel] = vzerofriend.fBGScalers[iChannel];
+    for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
+      fChargeMB[iChannel][iBunch] = vzerofriend.fChargeMB[iChannel][iBunch];
+      fIsIntMB[iChannel][iBunch] = vzerofriend.fIsIntMB[iChannel][iBunch];
+      fIsBBMB[iChannel][iBunch] = vzerofriend.fIsBBMB[iChannel][iBunch];
+      fIsBGMB[iChannel][iBunch] = vzerofriend.fIsBGMB[iChannel][iBunch];
+    }
+    for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+      fADC[iChannel][iEv] = vzerofriend.fADC[iChannel][iEv];
+      fIsInt[iChannel][iEv] = vzerofriend.fIsInt[iChannel][iEv];
+      fIsBB[iChannel][iEv] = vzerofriend.fIsBB[iChannel][iEv];
+      fIsBG[iChannel][iEv] = vzerofriend.fIsBG[iChannel][iEv];
+    }
+    fTime[iChannel] = vzerofriend.fTime[iChannel];
+    fWidth[iChannel] = vzerofriend.fWidth[iChannel];
+  }
+
+  return *this;
+}
+
+void AliESDVZEROfriend::Reset()
+{
+  // Reset the contents of the object
+  fTrigger = 0;
+  fTriggerMask = 0;
+
+  for (Int_t iScaler = 0; iScaler < kNScalers; iScaler++)
+    fScalers[iScaler] = 0;
+
+  for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++)
+    fBunchNumbers[iBunch] = 0;
+
+  for (Int_t iChannel = 0; iChannel < kNChannels; iChannel++) {
+    fBBScalers[iChannel] = 0;
+    fBGScalers[iChannel] = 0;
+    for (Int_t iBunch = 0; iBunch < kNBunches; iBunch++) {
+      fChargeMB[iChannel][iBunch] = 0;
+      fIsIntMB[iChannel][iBunch] = kFALSE;
+      fIsBBMB[iChannel][iBunch] = kFALSE;
+      fIsBGMB[iChannel][iBunch] = kFALSE;
+    }
+    for (Int_t iEv = 0; iEv < kNEvOfInt; iEv++) {
+      fADC[iChannel][iEv] = 0;
+      fIsInt[iChannel][iEv] = kFALSE;
+      fIsBB[iChannel][iEv] = kFALSE;
+      fIsBG[iChannel][iEv] = kFALSE;
+    }
+    fTime[iChannel] = 0;
+    fWidth[iChannel] = 0;
+  }
+  
+}
diff --git a/STEER/AliESDVZEROfriend.h b/STEER/AliESDVZEROfriend.h
new file mode 100644 (file)
index 0000000..77499e9
--- /dev/null
@@ -0,0 +1,132 @@
+#ifndef ALIESDVZEROFRIEND_H
+#define ALIESDVZEROFRIEND_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This is a class for containing all the VZERO DDL raw data
+/// It is written to the ESD-friend file
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include <TObject.h>
+
+class AliESDVZEROfriend: public TObject {
+  public :
+    AliESDVZEROfriend();
+    virtual ~AliESDVZEROfriend();
+
+    AliESDVZEROfriend(const AliESDVZEROfriend& vzerofriend);
+    AliESDVZEROfriend& operator = (const AliESDVZEROfriend& vzerofriend);
+
+    void Reset();
+
+// Getters of various scalers and Minimum Bias flags :
+
+   ULong64_t          GetBBScalers(Int_t channel) const  
+      { return        fBBScalers[channel]; }
+   ULong64_t          GetBGScalers(Int_t channel) const  
+      { return        fBGScalers[channel]; }
+   UInt_t             GetTriggerScalers(Int_t num_scaler) const 
+      { return        fScalers[num_scaler]; }
+   UInt_t             GetBunchNumbersMB(Int_t num_bunch) const 
+      { return        fBunchNumbers[num_bunch]; }
+   UShort_t           GetChargeMB(Int_t channel, Int_t num_bunch) const  
+      { return        fChargeMB[channel][num_bunch]; } 
+   Bool_t             GetIntMBFlag(Int_t channel, Int_t num_bunch) const   
+      { return        fIsIntMB[channel][num_bunch]; } 
+   Bool_t             GetBBMBFlag(Int_t channel, Int_t num_bunch) const   
+      { return        fIsBBMB[channel][num_bunch]; }  
+   Bool_t             GetBGMBFlag(Int_t channel, Int_t num_bunch) const   
+      { return        fIsBGMB[channel][num_bunch]; }      
+       
+// Getters of ADC signals, ADC pedestals, time information and corresponding flags :
+
+    UShort_t          GetADC(Int_t channel) const
+      { return fADC[channel][kNEvOfInt/2]; }
+    UShort_t          GetPedestal(Int_t channel, Int_t event) const
+      { return fADC[channel][event]; }
+    Bool_t            GetIntegratorFlag(Int_t channel, Int_t event) const
+      { return fIsInt[channel][event]; }
+    Bool_t            GetBBFlag(Int_t channel, Int_t event) const
+      { return fIsBB[channel][event]; } 
+    Bool_t            GetBGFlag(Int_t channel, Int_t event) const
+      { return fIsBG[channel][event]; }   
+    UInt_t            GetTime(Int_t channel) const
+      { return fTime[channel]; }
+    UInt_t            GetWidth(Int_t channel) const
+      { return fWidth[channel]; }
+
+    // Setters
+    void              SetBBScalers(Int_t channel, ULong64_t scalers)
+      { fBBScalers[channel] = scalers; }
+    void              SetBGScalers(Int_t channel, ULong64_t scalers)
+      { fBGScalers[channel] = scalers; }
+    void              SetTriggerScalers(Int_t num_scaler, UInt_t scaler)
+      { fScalers[num_scaler] = scaler; }
+    void              SetBunchNumbersMB(Int_t num_bunch, UInt_t bunch)
+      { fBunchNumbers[num_bunch] = bunch; }
+    void              SetChargeMB(Int_t channel,Int_t num_bunch, UShort_t charge)
+      { fChargeMB[channel][num_bunch] = charge; }
+    void              SetIntMBFlag(Int_t channel,Int_t num_bunch, Bool_t flag)
+      { fIsIntMB[channel][num_bunch] = flag; }
+    void              SetBBMBFlag(Int_t channel,Int_t num_bunch, Bool_t flag)
+      { fIsBBMB[channel][num_bunch] = flag; }
+    void              SetBGMBFlag(Int_t channel,Int_t num_bunch, Bool_t flag)
+      { fIsBGMB[channel][num_bunch] = flag; }
+
+    void              SetPedestal(Int_t channel, Int_t event, UShort_t adc)
+      { fADC[channel][event] = adc; }
+    void              SetIntegratorFlag(Int_t channel, Int_t event, Bool_t flag)
+      { fIsInt[channel][event] = flag; }
+    void              SetBBFlag(Int_t channel, Int_t event, Bool_t flag)
+      { fIsBB[channel][event] = flag; }
+    void              SetBGFlag(Int_t channel, Int_t event, Bool_t flag)
+      { fIsBB[channel][event] = flag; }
+    void              SetTime(Int_t channel, UInt_t time)
+      { fTime[channel] = time; }
+    void              SetWidth(Int_t channel, UInt_t width)
+      { fWidth[channel] = width; }
+
+    UShort_t          GetTriggerInputs() const
+      { return fTrigger; }
+    UShort_t          GetTriggerInputsMask() const
+      { return fTriggerMask; }
+    void              SetTriggerInputs(UShort_t inputs)
+      { fTrigger = inputs; }
+    void              SetTriggerInputsMask(UShort_t mask)
+      { fTriggerMask = mask; }
+
+    enum EESDVZEROfriendParams {
+      kNChannels = 64, // number of electronic channels in V0 (FEE numbering)
+      kNEvOfInt  = 21, // number of events of interest
+      kNScalers  = 16, // number of scalers
+      kNBunches  = 10  // number of bunches used in Minimum Bias information 
+    };
+
+  private:
+
+    ULong64_t     fBBScalers[kNChannels];        // 'Beam-Beam' scalers for all channels
+    ULong64_t     fBGScalers[kNChannels];        // 'Beam-Gas' scalers for all channels
+    UInt_t        fScalers[kNScalers];           // Trigger scalers
+    UInt_t        fBunchNumbers[kNBunches];      // Bunch numbers for the previous 10 MB events
+    UShort_t      fChargeMB[kNChannels][kNBunches]; // ADC counts for all channels for the previous 10 MB events
+    Bool_t        fIsIntMB[kNChannels][kNBunches];  // 'Integrator' flag for all channels for the previous 10 MB events
+    Bool_t        fIsBBMB[kNChannels][kNBunches];   // 'Beam-Beam' flag for all channels for the previous 10 MB events
+    Bool_t        fIsBGMB[kNChannels][kNBunches];   // 'Beam-Gas' for all channels for the previous 10 MB events
+
+    UShort_t      fADC[kNChannels][kNEvOfInt];   // ADC counts for all channels and all events of interest
+    Bool_t        fIsInt[kNChannels][kNEvOfInt]; // 'Integrator' flag for all channels 
+    Bool_t        fIsBB[kNChannels][kNEvOfInt];  // 'Beam-Beam' flag for all channels
+    Bool_t        fIsBG[kNChannels][kNEvOfInt];  // 'Beam-Gas' flag for all channels
+    Int_t         fTime[kNChannels];             // leading time for all channels - from HPTDC
+    Int_t         fWidth[kNChannels];            // pulse width for all channels - from HPTDC
+
+    UShort_t      fTrigger;        // VZERO trigger inputs
+    UShort_t      fTriggerMask;    // VZERO trigger inputs mask
+
+    ClassDef(AliESDVZEROfriend, 1) // container class for VZERO DDL raw data
+};
+
+#endif
index 9a878e0..3215893 100644 (file)
 
 ClassImp(AliESDfriend)
 
-AliESDfriend::AliESDfriend(): TObject(), fTracks("AliESDfriendTrack",15000)
+AliESDfriend::AliESDfriend(): TObject(), fTracks("AliESDfriendTrack",15000),
+                             fESDVZEROfriend(NULL)
 {
  //
  // Default constructor
  //
 }
 
-AliESDfriend::AliESDfriend(const AliESDfriend &f):TObject(f),fTracks(f.fTracks)
+AliESDfriend::AliESDfriend(const AliESDfriend &f):TObject(f),fTracks(f.fTracks),
+                                                 fESDVZEROfriend(f.fESDVZEROfriend)
 {
  //
  // Copy constructor
@@ -43,4 +45,14 @@ AliESDfriend::~AliESDfriend() {
   // Destructor
   //
   fTracks.Delete();
+  delete fESDVZEROfriend;
+}
+
+void AliESDfriend::SetVZEROfriend(AliESDVZEROfriend * obj)
+{
+  //
+  // Set the VZERO friend data object
+  // (complete raw data)
+  if (!fESDVZEROfriend) fESDVZEROfriend = new AliESDVZEROfriend();
+  if (obj) *fESDVZEROfriend = *obj;
 }
index def5faa..ef65cae 100644 (file)
@@ -11,6 +11,7 @@
 #include <TClonesArray.h>
 
 #include "AliESDfriendTrack.h"
+#include "AliESDVZEROfriend.h"
 
 //_____________________________________________________________________________
 class AliESDfriend : public TObject {
@@ -27,9 +28,14 @@ public:
      new(fTracks[fTracks.GetEntriesFast()]) AliESDfriendTrack(*t);
   }
 
+  void SetVZEROfriend(AliESDVZEROfriend * obj);
+  AliESDVZEROfriend *GetVZEROfriend(){ return fESDVZEROfriend; }
+
 protected:
   TClonesArray fTracks;    // ESD friend tracks
-  ClassDef(AliESDfriend,1) // ESD friend
+  AliESDVZEROfriend *fESDVZEROfriend; // VZERO object containing complete raw data
+
+  ClassDef(AliESDfriend,2) // ESD friend
 };
 
 #endif
index 0cb33dc..7cacfc0 100644 (file)
@@ -1660,8 +1660,8 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
     }
 
     if (fWriteESDfriend) {
-      fesdf->~AliESDfriend();
-      new (fesdf) AliESDfriend(); // Reset...
+      //      fesdf->~AliESDfriend();
+      //  new (fesdf) AliESDfriend(); // Reset...
       fesd->GetESDfriend(fesdf);
     }
     ftree->Fill();
index 735bf22..deb9c0a 100644 (file)
@@ -74,6 +74,8 @@
 
 #pragma link C++ class  AliTriggerIR+;
 
+#pragma link C++ class  AliESDVZEROfriend+;
+
 #endif
 
 
index c543ba6..e4b4548 100644 (file)
@@ -26,7 +26,8 @@ SRCS = AliESDEvent.cxx AliESDInputHandler.cxx AliESDInputHandlerRP.cxx AliESDfri
        AliMeanVertex.cxx \
        AliESDCaloCells.cxx \
        AliESDACORDE.cxx \
-       AliTriggerIR.cxx
+       AliTriggerIR.cxx \
+       AliESDVZEROfriend.cxx
 
 HDRS:= $(SRCS:.cxx=.h) 
 
index 9b15e47..db5dd61 100644 (file)
@@ -65,6 +65,11 @@ class AliVZERORawStream: public TObject {
     UInt_t            GetWidth(Int_t channel) const
       { return fWidth[channel]; }
 
+    UShort_t          GetTriggerInputs() const
+      { return fTrigger; }
+    UShort_t          GetTriggerInputsMask() const
+      { return fTriggerMask; }
+
 // Getter of Offline Channel number as used in aliroot (defined by aliroot 
 // numbering convention) from FEE channel (electronic channel number given 
 // by the V0 electronics readout) - See comment above - 
index 3829216..87f610e 100644 (file)
@@ -27,6 +27,8 @@
 #include "AliVZERORawStream.h"
 #include "AliESDEvent.h"
 #include "AliVZEROTriggerMask.h"
+#include "AliESDfriend.h"
+#include "AliESDVZEROfriend.h"
 
 ClassImp(AliVZEROReconstructor)
 
@@ -34,6 +36,7 @@ ClassImp(AliVZEROReconstructor)
 AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
    fESDVZERO(0x0),
    fESD(0x0),
+   fESDVZEROfriend(0x0),
    fCalibData(GetCalibData())
 {
   // Default constructor  
@@ -59,7 +62,8 @@ AliVZEROReconstructor::~AliVZEROReconstructor()
 {
 // destructor
 
-   delete fESDVZERO;    
+   delete fESDVZERO;
+   delete fESDVZEROfriend;
 }
 
 //_____________________________________________________________________________
@@ -68,6 +72,7 @@ void AliVZEROReconstructor::Init()
 // initializer
 
   fESDVZERO  = new AliESDVZERO;
+  fESDVZEROfriend = new AliESDVZEROfriend;
 }
 
 //______________________________________________________________________
@@ -83,6 +88,8 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
   TClonesArray* digitsArray = new TClonesArray("AliVZEROdigit");
   digitsTree->Branch("VZERODigit", &digitsArray);
 
+  fESDVZEROfriend->Reset();
+
   rawReader->Reset();
   AliVZERORawStream rawStream(rawReader);
   if (rawStream.Next()) {  
@@ -104,7 +111,37 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
         width[j]  =  rawStream.GetWidth(i);
         BBFlag[j] =  rawStream.GetBBFlag(i,imax);
         BGFlag[j] =  rawStream.GetBGFlag(i,imax); 
+
+        // Filling the esd friend object
+        fESDVZEROfriend->SetBBScalers(j,rawStream.GetBBScalers(i));
+        fESDVZEROfriend->SetBGScalers(j,rawStream.GetBGScalers(i));
+        for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++) {
+          fESDVZEROfriend->SetChargeMB(j,iBunch,rawStream.GetChargeMB(i,iBunch));
+          fESDVZEROfriend->SetIntMBFlag(j,iBunch,rawStream.GetIntMBFlag(i,iBunch));
+          fESDVZEROfriend->SetBBMBFlag(j,iBunch,rawStream.GetBBMBFlag(i,iBunch));
+          fESDVZEROfriend->SetBGMBFlag(j,iBunch,rawStream.GetBGMBFlag(i,iBunch));
+        }
+        for (Int_t iEv = 0; iEv < AliESDVZEROfriend::kNEvOfInt; iEv++) {
+          fESDVZEROfriend->SetPedestal(j,iEv,rawStream.GetPedestal(i,iEv));
+          fESDVZEROfriend->SetIntegratorFlag(j,iEv,rawStream.GetIntegratorFlag(i,iEv));
+          fESDVZEROfriend->SetBBFlag(j,iEv,rawStream.GetBBFlag(i,iEv));
+          fESDVZEROfriend->SetBGFlag(j,iEv,rawStream.GetBGFlag(i,iEv));
+        }
+        fESDVZEROfriend->SetTime(j,rawStream.GetTime(i));
+        fESDVZEROfriend->SetWidth(j,rawStream.GetWidth(i));
      }  
+
+     // Filling the esd friend object
+     fESDVZEROfriend->SetTriggerInputs(rawStream.GetTriggerInputs());
+     fESDVZEROfriend->SetTriggerInputsMask(rawStream.GetTriggerInputsMask());
+
+     for(Int_t iScaler = 0; iScaler < AliESDVZEROfriend::kNScalers; iScaler++)
+       fESDVZEROfriend->SetTriggerScalers(iScaler,rawStream.GetTriggerScalers(iScaler));
+
+     for (Int_t iBunch = 0; iBunch < AliESDVZEROfriend::kNBunches; iBunch++)
+       fESDVZEROfriend->SetBunchNumbersMB(iBunch,rawStream.GetBunchNumbersMB(iBunch));
+     
+
      // Channels(aliroot numbering) will be ordered in the tree
      for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
          new ((*digitsArray)[digitsArray->GetEntriesFast()])
@@ -200,6 +237,14 @@ void AliVZEROReconstructor::FillESD(TTree* digitsTree, TTree* /*clustersTree*/,
      AliDebug(1, Form("Writing VZERO data to ESD tree"));
      esd->SetVZEROData(fESDVZERO);
   }
+
+  if (esd) {
+    AliESDfriend *fr = (AliESDfriend*)esd->FindListObject("AliESDfriend");
+    if (fr) {
+      AliDebug(1, Form("Writing VZERO friend data to ESD tree"));
+      fr->SetVZEROfriend(fESDVZEROfriend);
+    }
+  }
 }
 
 //_____________________________________________________________________________
index e1767c0..a9a0e61 100644 (file)
@@ -20,6 +20,7 @@
 #include "AliESDVZERO.h"
 
 class AliESDEvent;
+class AliESDVZEROfriend;
 
 class AliVZEROReconstructor: public AliReconstructor {
 public:
@@ -50,6 +51,7 @@ public:
 protected:
   AliESDVZERO*        fESDVZERO;      // ESD output object  
   AliESDEvent*             fESD;      // ESD object
+  AliESDVZEROfriend*  fESDVZEROfriend; // ESD friend object (complete raw data)
   
 private:
   AliVZEROReconstructor(const AliVZEROReconstructor& reconstructor);