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)
{
--- /dev/null
+/**************************************************************************
+ * 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;
+ }
+
+}
--- /dev/null
+#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
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
// 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;
}
#include <TClonesArray.h>
#include "AliESDfriendTrack.h"
+#include "AliESDVZEROfriend.h"
//_____________________________________________________________________________
class AliESDfriend : public TObject {
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
}
if (fWriteESDfriend) {
- fesdf->~AliESDfriend();
- new (fesdf) AliESDfriend(); // Reset...
+ // fesdf->~AliESDfriend();
+ // new (fesdf) AliESDfriend(); // Reset...
fesd->GetESDfriend(fesdf);
}
ftree->Fill();
#pragma link C++ class AliTriggerIR+;
+#pragma link C++ class AliESDVZEROfriend+;
+
#endif
AliMeanVertex.cxx \
AliESDCaloCells.cxx \
AliESDACORDE.cxx \
- AliTriggerIR.cxx
+ AliTriggerIR.cxx \
+ AliESDVZEROfriend.cxx
HDRS:= $(SRCS:.cxx=.h)
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 -
#include "AliVZERORawStream.h"
#include "AliESDEvent.h"
#include "AliVZEROTriggerMask.h"
+#include "AliESDfriend.h"
+#include "AliESDVZEROfriend.h"
ClassImp(AliVZEROReconstructor)
AliVZEROReconstructor:: AliVZEROReconstructor(): AliReconstructor(),
fESDVZERO(0x0),
fESD(0x0),
+ fESDVZEROfriend(0x0),
fCalibData(GetCalibData())
{
// Default constructor
{
// destructor
- delete fESDVZERO;
+ delete fESDVZERO;
+ delete fESDVZEROfriend;
}
//_____________________________________________________________________________
// initializer
fESDVZERO = new AliESDVZERO;
+ fESDVZEROfriend = new AliESDVZEROfriend;
}
//______________________________________________________________________
TClonesArray* digitsArray = new TClonesArray("AliVZEROdigit");
digitsTree->Branch("VZERODigit", &digitsArray);
+ fESDVZEROfriend->Reset();
+
rawReader->Reset();
AliVZERORawStream rawStream(rawReader);
if (rawStream.Next()) {
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()])
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);
+ }
+ }
}
//_____________________________________________________________________________
#include "AliESDVZERO.h"
class AliESDEvent;
+class AliESDVZEROfriend;
class AliVZEROReconstructor: public AliReconstructor {
public:
protected:
AliESDVZERO* fESDVZERO; // ESD output object
AliESDEvent* fESD; // ESD object
+ AliESDVZEROfriend* fESDVZEROfriend; // ESD friend object (complete raw data)
private:
AliVZEROReconstructor(const AliVZEROReconstructor& reconstructor);
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff