beam test digitisation classes
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 23 Dec 2004 11:33:18 +0000 (11:33 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 23 Dec 2004 11:33:18 +0000 (11:33 +0000)
21 files changed:
ITS/AliITSBeamTest.cxx [new file with mode: 0644]
ITS/AliITSBeamTest.h [new file with mode: 0644]
ITS/AliITSBeamTestDig.cxx [new file with mode: 0644]
ITS/AliITSBeamTestDig.h [new file with mode: 0644]
ITS/AliITSBeamTestDigSDD.cxx [new file with mode: 0644]
ITS/AliITSBeamTestDigSDD.h [new file with mode: 0644]
ITS/AliITSBeamTestDigSPD.cxx [new file with mode: 0644]
ITS/AliITSBeamTestDigSPD.h [new file with mode: 0644]
ITS/AliITSBeamTestDigSSD.cxx [new file with mode: 0644]
ITS/AliITSBeamTestDigSSD.h [new file with mode: 0644]
ITS/AliITSBeamTestDigitizer.cxx [new file with mode: 0644]
ITS/AliITSBeamTestDigitizer.h [new file with mode: 0644]
ITS/AliITSEventHeader.cxx [new file with mode: 0644]
ITS/AliITSEventHeader.h [new file with mode: 0644]
ITS/AliITSRawStreamSDD.h
ITS/AliITSRawStreamSDDv3.cxx
ITS/AliITSRawStreamSSD.h
ITS/AliITSRawStreamSSDv1.cxx [new file with mode: 0644]
ITS/AliITSRawStreamSSDv1.h [new file with mode: 0644]
ITS/ITSLinkDef.h
ITS/libITS.pkg

diff --git a/ITS/AliITSBeamTest.cxx b/ITS/AliITSBeamTest.cxx
new file mode 100644 (file)
index 0000000..a966237
--- /dev/null
@@ -0,0 +1,61 @@
+////////////////////////////////////////////////////
+//  Base class to define                          //
+//  ITS beam test                                 //
+//                                                //   
+//  Origin: E. Crescio crescio@to.infn.it         //
+////////////////////////////////////////////////////
+
+#include "AliITSBeamTest.h"
+
+const Int_t AliITSBeamTest::fgkNumberOfSPD=6;
+const Int_t AliITSBeamTest::fgkNumberOfSDD=2;
+const Int_t AliITSBeamTest::fgkNumberOfSSD=4;
+
+
+ClassImp(AliITSBeamTest)
+
+
+//_____________________________________________________________
+AliITSBeamTest::AliITSBeamTest() : AliITS()
+{
+  //
+  // Constructor
+  //
+
+  SetNumberOfSPD(fgkNumberOfSPD);
+  SetNumberOfSDD(fgkNumberOfSDD);
+  SetNumberOfSSD(fgkNumberOfSSD);
+}
+
+//_____________________________________________________________
+AliITSBeamTest::AliITSBeamTest(const char* name,const char *title) : AliITS(name,title)
+{
+  //
+  // Constructor
+  //
+
+  SetNumberOfSPD(fgkNumberOfSPD);
+  SetNumberOfSDD(fgkNumberOfSDD);
+  SetNumberOfSSD(fgkNumberOfSSD);
+}
+
+
+//__________________________________________________________________
+AliITSBeamTest::~AliITSBeamTest()
+{
+  //
+  // Destructor
+  //
+
+}
+
+//____________________________________________________________________
+Int_t AliITSBeamTest::GetNumberOfSubDet(const TString& det) const{
+
+  if(det.Contains("SPD")) return fNspd;
+  if(det.Contains("SDD")) return fNsdd;
+  if(det.Contains("SSD")) return fNssd;
+  return 0;
+}
diff --git a/ITS/AliITSBeamTest.h b/ITS/AliITSBeamTest.h
new file mode 100644 (file)
index 0000000..f2c6c1c
--- /dev/null
@@ -0,0 +1,54 @@
+#ifndef ALIITSBEAMTEST_H
+#define ALIITSBEAMTEST_H
+
+////////////////////////////////////////////////////
+//  Base class to define                          //
+//  ITS beam test                                 //
+//                                                //   
+//  Origin: E. Crescio crescio@to.infn.it         //
+////////////////////////////////////////////////////
+
+#include "AliITS.h"
+
+typedef enum {kAug04,kNov04} BeamtestPeriod_t;
+
+class AliITSBeamTest : public AliITS {
+ public:
+
+
+  AliITSBeamTest();
+  AliITSBeamTest(const char* name,const char *title);
+  virtual ~AliITSBeamTest();
+
+  virtual void SetNumberOfSPD(Int_t nSPD) {fNspd=nSPD;}
+  virtual void SetNumberOfSDD(Int_t nSDD) {fNsdd=nSDD;}
+  virtual void SetNumberOfSSD(Int_t nSSD) {fNssd=nSSD;}
+
+  Int_t GetNSPD() const {return fNspd;}
+  Int_t GetNSDD() const {return fNsdd;}
+  Int_t GetNSSD() const {return fNssd;}
+
+  Int_t GetNumberOfSubDet(const TString& det) const;
+    
+  
+ protected:
+
+  static const Int_t fgkNumberOfSPD; //number of SPD detectors
+  static const Int_t fgkNumberOfSDD; //number of SDD detectors
+  static const Int_t fgkNumberOfSSD; //number of SSD detectors
+
+
+  Int_t     fNspd;                    //Number of SPD modules
+  Int_t     fNsdd;                    //Number of SDD modules
+  Int_t     fNssd;                    //Number of SSD modules
+  
+
+  ClassDef(AliITSBeamTest,0)  // An Alice ITS beam test 
+
+ };
+
+
+#endif
+
+    
diff --git a/ITS/AliITSBeamTestDig.cxx b/ITS/AliITSBeamTestDig.cxx
new file mode 100644 (file)
index 0000000..667cc79
--- /dev/null
@@ -0,0 +1,62 @@
+////////////////////////////////////////////////////
+//  Class to define                               //
+//  beam test raw 2 dig conv.                     //
+//  Origin: E. Crescio crescio@to.infn.it         //
+//                                                //
+////////////////////////////////////////////////////
+
+#include "AliITSBeamTestDig.h"
+
+ClassImp(AliITSBeamTestDig)
+
+
+
+//_____________________________________________________________
+  AliITSBeamTestDig::AliITSBeamTestDig(): TTask()
+{
+  //
+  // Default constructor
+  //
+  fReaderDate=0;
+  fTreeD=0;
+  fBt=0;
+  fITSHeader=0;
+}
+
+//_____________________________________________________________
+  AliITSBeamTestDig::AliITSBeamTestDig(const Text_t* name, const Text_t* title): TTask(name,title)
+{
+  //
+  // Standard constructor
+  //
+
+  fReaderDate=0;
+  fTreeD=0;
+  fBt=0;
+  fITSHeader=0;
+}
+
+//______________________________________________________________________
+AliITSBeamTestDig::AliITSBeamTestDig(const AliITSBeamTestDig &bt):TTask(bt){
+    // Copy constructor. 
+
+  fReaderDate=bt.fReaderDate;
+  fTreeD=bt.fTreeD;
+  fBt=bt.fBt;
+  fITSHeader=bt.fITSHeader;
+}
+//______________________________________________________________________
+AliITSBeamTestDig& AliITSBeamTestDig::operator=(AliITSBeamTestDig &bt){
+    // Assignment operator. This is a function which is not allowed to be
+    // done to the ITS beam test dig. It exits with an error.
+    // Inputs:
+    if(this==&bt) return *this;
+    Error("operator=","You are not allowed to make a copy of the AliITSBeamTestDig");
+    exit(1);
+    return *this; //fake return
+}
+
+
+  
diff --git a/ITS/AliITSBeamTestDig.h b/ITS/AliITSBeamTestDig.h
new file mode 100644 (file)
index 0000000..99b9c77
--- /dev/null
@@ -0,0 +1,53 @@
+#ifndef ALIITSBEAMTESTDIG_H
+#define ALIITSBEAMTESTDIG_H
+
+////////////////////////////////////////////////////
+//  Class to define                               //
+//  beam test raw 2 dig conv.                     //
+//  Origin: E. Crescio crescio@to.infn.it         //
+//  November 2004                                 //
+////////////////////////////////////////////////////
+
+#include "TTask.h"
+#include "AliITSEventHeader.h"
+
+class AliITSBeamTest;
+class AliRawReaderDate;
+class TTree;
+
+
+class AliITSBeamTestDig: public TTask {
+ public:
+
+  AliITSBeamTestDig();
+  AliITSBeamTestDig(const Text_t* name, const Text_t* title);
+  AliITSBeamTestDig(const AliITSBeamTestDig& bt);
+  AliITSBeamTestDig& operator=(AliITSBeamTestDig &bt);
+  virtual ~AliITSBeamTestDig() {}
+  void SetRawReaderDate(AliRawReaderDate* rd) {fReaderDate=rd;}
+  void SetTree(TTree* treedig) {fTreeD=treedig;}
+  void SetITSEventHeader(AliITSEventHeader* header){fITSHeader = header;}
+
+  void SetBeamTest(AliITSBeamTest* bt) {fBt=bt;}
+
+
+ protected:      
+  
+  AliITSEventHeader* fITSHeader;     // its event header
+  AliRawReaderDate* fReaderDate;     // !reader date;
+  TTree* fTreeD;                     // tree of digits
+  AliITSBeamTest* fBt;               // !beam test object
+
+  ClassDef(AliITSBeamTestDig,1)   // its beam test digitization 
+
+ };
+
+
+
+#endif
+
+    
diff --git a/ITS/AliITSBeamTestDigSDD.cxx b/ITS/AliITSBeamTestDigSDD.cxx
new file mode 100644 (file)
index 0000000..8a96e65
--- /dev/null
@@ -0,0 +1,183 @@
+////////////////////////////////////////////////////
+//  Class to define                               //
+//  SDD beam test raw 2 dig conv.                 //
+//  Origin: E. Crescio crescio@to.infn.it         //
+//                                                // 
+//                                                //
+////////////////////////////////////////////////////
+#include "AliITSdigitSDD.h"
+#include "AliRawReaderDate.h"
+#include "AliITSRawStreamSDDv2.h"
+#include "AliITSRawStreamSDDv3.h"
+#include "AliITSRawStreamSDD.h"
+#include "AliITSBeamTestDigSDD.h"
+#include "AliITSBeamTest.h"
+
+ClassImp(AliITSBeamTestDigSDD)
+
+//_____________________________________________________________
+  AliITSBeamTestDigSDD::AliITSBeamTestDigSDD(): AliITSBeamTestDig()
+{
+  //
+  // Constructor
+  //
+  SetBtPeriod();
+  fSubEventAttributes=0;
+  fThreshold=0;
+  fStreamer=0;
+}
+
+//_____________________________________________________________
+AliITSBeamTestDigSDD::AliITSBeamTestDigSDD(const Text_t* name, const Text_t* title): AliITSBeamTestDig(name,title)
+{
+  //
+  // Constructor
+  //
+  SetBtPeriod();
+  fSubEventAttributes=0;
+  fThreshold=0;
+  fStreamer=0;
+}
+
+//__________________________________________________________________
+AliITSBeamTestDigSDD::~AliITSBeamTestDigSDD()
+{
+  //
+  // Destructor
+  //
+  if(fSubEventAttributes) delete fSubEventAttributes;
+  if(fStreamer) delete fStreamer;
+ }
+
+
+//_______________________________________________________________________
+void AliITSBeamTestDigSDD::Exec(Option_t* /*opt*/)
+{
+
+  // Reads raw data and fills the tree of digits
+
+  TBranch* branch = fTreeD->GetBranch("ITSDigitSDD");
+
+  TClonesArray** digits = new TClonesArray*[fBt->GetNSDD()+fBt->GetNSPD()];
+  Int_t* idig = new Int_t[fBt->GetNSDD()+fBt->GetNSPD()];
+  for(Int_t idet=0;idet<(fBt->GetNSDD()+fBt->GetNSPD());idet++){
+    digits[idet]=new TClonesArray("AliITSdigitSDD");
+    idig[idet]=0;
+  }
+
+
+  switch(fBtPer){
+  case kNov04:
+    fStreamer = new AliITSRawStreamSDDv3(fReaderDate);
+    break;
+  case kAug04:
+    fStreamer = new AliITSRawStreamSDDv2(fReaderDate);
+    fReaderDate->RequireHeader(kFALSE);
+    fReaderDate->ReadHeader();
+   do{
+      fSubEventAttributes = fReaderDate->GetSubEventAttributes();
+    }while(fReaderDate->ReadHeader());
+   fSDDEvType=GetEventType();
+    if(fSDDEvType==1) fITSHeader->SetEventTypeSDD(kReal);
+    if(fSDDEvType==2) fITSHeader->SetEventTypeSDD(kCalibration1);
+    if(fSDDEvType==3) fITSHeader->SetEventTypeSDD(kCalibration2);
+    fReaderDate->Reset();
+    break;
+  }
+
+
+   fStreamer->SetLowCarlosThreshold(fThreshold,0);
+   fStreamer->SetLowCarlosThreshold(fThreshold,1);
+
+  //from raw data the signal is already decompressed..
+  //set compressed fSignal of AliITSdigitSDD to -1000
+  //set expanded fSignalExpanded of AliITSdigitSDD equal to fStreamer.GetSignal() 
+  while(fStreamer->Next()){   
+
+    Int_t ndet = fStreamer->GetChannel()+fBt->GetNSPD();
+    Int_t anode = fStreamer->GetCoord1();
+
+    /* if we are reading only one det, two wings
+       if(fStreamer.GetChannel()==1) anode+=256; //wing 1 0-255, wing 2 256-511
+    */
+
+    /* bt august 2004 and november 2004: with only 1 carlos 
+       channel 0 for one wing of one
+       det, channel 1 for the wing of the second det*/
+
+    const Int_t kdgt[3]={anode,fStreamer->GetCoord2(),-1000};
+    const Int_t ktracks[10]={0,0,0,0,0,0,0,0,0,0};
+    const Int_t khits[10]={0,0,0,0,0,0,0,0,0,0};
+    const Float_t kcharges[10]={0,0,0,0,0,0,0,0,0,0};
+
+    new ((*digits[ndet])[idig[ndet]]) AliITSdigitSDD(0,kdgt,ktracks,khits,kcharges,fStreamer->GetSignal());
+    idig[ndet]++;
+
+  }
+
+  if(GetBtPeriod()==kNov04){
+    Int_t jitter=fStreamer->ReadJitter();
+    fITSHeader->SetJitterSDD(jitter);
+  }
+  for(Int_t n = fBt->GetNSPD();n<fBt->GetNSDD()+fBt->GetNSPD();n++){
+    branch->SetAddress(&digits[n]);
+    branch->Fill();
+  }
+      
+  fTreeD->SetEntries(fBt->GetNSPD()+fBt->GetNSDD()+fBt->GetNSSD());
+  fReaderDate->Reset();
+  fTreeD->AutoSave();
+
+  for(Int_t n=0;n<fBt->GetNSPD()+fBt->GetNSDD();n++){
+    delete digits[n];
+  }
+
+  
+  delete[] digits;
+  delete[] idig;
+  delete fStreamer;
+}
+
+  
+//______________________________________
+Int_t AliITSBeamTestDigSDD::GetEventType(){
+
+  // defines the SDD event type:
+  // 1: physics event (kReal)
+  // 2: calibration 1 (kCalibration1, injector pulse)
+  // 3: calibration 2 (kCalibration2, test pulse)
+  fSDDEvType = 2;
+  if(fSubEventAttributes[0]==0 && fSubEventAttributes[1]==0 && fSubEventAttributes[2]==0) fSDDEvType = 1;
+
+  if(fSubEventAttributes[0]==2 && fSubEventAttributes[1]==0 && fSubEventAttributes[2]==0) fSDDEvType = 3;
+
+  fSubEventAttributes = 0;
+  return fSDDEvType;
+}
+
+//______________________________________________________________________
+AliITSBeamTestDigSDD::AliITSBeamTestDigSDD(const AliITSBeamTestDigSDD &bt):AliITSBeamTestDig(bt){
+    // Copy constructor. 
+
+  fSDDEvType = bt.fSDDEvType;
+  fSubEventAttributes = bt.fSubEventAttributes;
+  fBtPer = bt.fBtPer;
+  fThreshold = bt.fThreshold;
+  fStreamer = bt.fStreamer;
+}
+//______________________________________________________________________
+AliITSBeamTestDigSDD& AliITSBeamTestDigSDD::operator=(AliITSBeamTestDigSDD &bt){
+    // Assignment operator. This is a function which is not allowed to be
+    // done to the ITS beam test dig. It exits with an error.
+    // Inputs:
+    if(this==&bt) return *this;
+    Error("operator=","You are not allowed to make a copy of the AliITSBeamTestDig");
+    exit(1);
+    return *this; //fake return
+}
+
+
+
+
diff --git a/ITS/AliITSBeamTestDigSDD.h b/ITS/AliITSBeamTestDigSDD.h
new file mode 100644 (file)
index 0000000..ac9a2c0
--- /dev/null
@@ -0,0 +1,62 @@
+#ifndef ALIITSBEAMTESTDIGSDD_H
+#define ALIITSBEAMTESTDIGSDD_H
+
+////////////////////////////////////////////////////
+//  Class to define                               //
+//  SDD beam test raw 2 dig conv.                 //
+//  Origin: E. Crescio crescio@to.infn.it         //
+//                                                //
+////////////////////////////////////////////////////
+
+#include "AliITSBeamTestDig.h"
+#include "AliITSBeamTest.h"
+
+class AliRawReaderDate;
+class AliITSRawStreamSDD;
+
+class AliITSBeamTestDigSDD: public AliITSBeamTestDig {
+ public:
+
+  AliITSBeamTestDigSDD();
+  AliITSBeamTestDigSDD(const Text_t* name, const Text_t* title);
+  AliITSBeamTestDigSDD(const AliITSBeamTestDigSDD& bt);
+  AliITSBeamTestDigSDD& operator=(AliITSBeamTestDigSDD &bt);
+
+  virtual ~AliITSBeamTestDigSDD();
+
+  void SetBtPeriod(BeamtestPeriod_t per=kNov04) {fBtPer=per;}
+  void SetThreshold(Int_t threshold) {fThreshold=threshold;}
+
+  BeamtestPeriod_t GetBtPeriod() const {return fBtPer;}
+  Int_t GetThreshold() const {return fThreshold;}
+  
+  virtual void Exec(Option_t* opt);
+
+  
+ protected:      
+
+  Int_t  fSDDEvType;                 //SDD event type (real, calibration)
+  const UInt_t* fSubEventAttributes; //SDD sub-event attributes 
+  BeamtestPeriod_t fBtPer;           //beam test version 
+                                     // November 2004 = kNov04
+                                     // August 2004 = kAug04
+  Int_t fThreshold;                  // Low carlos threshold 
+  AliITSRawStreamSDD* fStreamer;     //! SDD streamer
+
+ private: 
+
+  Int_t GetEventType();
+
+
+  ClassDef(AliITSBeamTestDigSDD,1)  // An Alice SDD beam test digitizer
+
+ };
+
+
+
+#endif
+
+    
diff --git a/ITS/AliITSBeamTestDigSPD.cxx b/ITS/AliITSBeamTestDigSPD.cxx
new file mode 100644 (file)
index 0000000..9e66659
--- /dev/null
@@ -0,0 +1,158 @@
+////////////////////////////////////////////////////
+//  Class to define                               //
+//  SPD beam test raw 2 dig conv.                 //
+//                                                //
+//  Origin: Jan Conrad  Jan.Conrad@cern.ch        //
+//                                                //
+////////////////////////////////////////////////////
+
+
+#include "AliITSdigitSPD.h"
+#include "AliRawReaderDate.h"
+#include "AliRawDataHeader.h"
+#include "AliITSRawStreamSPD.h"
+#include "AliITSBeamTestDigSPD.h"
+#include "AliITSBeamTest.h"
+
+
+ClassImp(AliITSBeamTestDigSPD)
+
+
+
+//_____________________________________________________________
+  AliITSBeamTestDigSPD::AliITSBeamTestDigSPD(): AliITSBeamTestDig()
+{
+  //
+  // Constructor
+  //
+
+  
+}
+
+//_____________________________________________________________
+  AliITSBeamTestDigSPD::AliITSBeamTestDigSPD(const Text_t* name, const Text_t* title): AliITSBeamTestDig(name,title)
+{
+  //
+  // Constructor
+  //
+
+}
+
+//__________________________________________________________________
+AliITSBeamTestDigSPD::~AliITSBeamTestDigSPD()
+{
+  //
+  // Destructor
+  //
+
+ }
+
+
+//_______________________________________________________________________
+void AliITSBeamTestDigSPD::Exec(Option_t* /*opt*/)
+{
+  //Reads raw data for SPD, fill SPD digits tree
+
+
+  TBranch* branch = fTreeD->GetBranch("ITSDigitSPD");
+  TClonesArray** newdigits = new TClonesArray*[fBt->GetNSPD()];
+
+   Int_t* idig = new Int_t[fBt->GetNSPD()];
+
+  
+
+  for (Int_t idet =0; idet < fBt->GetNSPD();idet++){
+     newdigits[idet]=new TClonesArray("AliITSdigitSPD");
+     idig[idet]=0;  
+   }
+  
+
+
+  //cout <<"still here"<< endl;
+  AliITSRawStreamSPD str(fReaderDate);
+
+  fReaderDate->SelectEquipment(17,211,211);
+
+  while(str.Next()){  
+
+    const AliRawDataHeader* rdh = fReaderDate->GetDataHeader();
+    UChar_t blockAttributes = fReaderDate->GetBlockAttributes();     
+    UInt_t statusBits = fReaderDate->GetStatusBits();     
+    UInt_t orbitNumber = rdh->fEventID2;                        
+    UShort_t  bunchCross = rdh->fEventID1;      
+      // UInt_t DataSize = rdh->fSize;                               
+      //UChar_t L1TrigType = rdh->fL1TriggerType;                            
+      //UInt_t MiniEvId = rdh->GetMiniEventID();                             
+      // ULong64_t TriggerCL = rdh->GetTriggerClasses();     
+      //ULong64_t ROI = rdh->GetROI();
+      //      UChar_t Version =rdh->fVersion;                                 
+      
+
+    Int_t modID = str.GetModuleID();
+    //    Int_t triggernumber = str.GetTriggerEventNumber();
+
+    Int_t row = str.GetRow();
+    Int_t col = str.GetColumn();
+
+
+
+    //    if (modID == 0 || modID == 1) {
+    // cout <<"Mod ID " << modID  <<" Row : "<< row << "Col : " << col << endl; 
+     //}
+
+
+    const Int_t kdgt[3]={row,col,1};
+    
+    //    newdigits = new TClonesArray*[fBt->GetNSPD()];
+
+    new ((*newdigits[modID])[idig[modID]]) AliITSdigitSPD(kdgt);
+    
+    idig[modID]++;
+    
+      fITSHeader->SetOrbitNumber(0,orbitNumber);
+      fITSHeader->SetStatusBits(0,statusBits);
+      fITSHeader->SetBlockAttributes(0,blockAttributes);
+      fITSHeader->SetBunchCross(0,bunchCross);
+      //fITSHeader->SetTriggerClass(0,TriggerCL);
+      //fITSHeader->SetSubDet(0,
+      //fITSHeader->SetMiniEvId(0,MiniEvId);
+      //fITSHeader->SetVersion(0,Version);
+      //fITSHeader->SetSubDet(0,Subdets);
+      //fITSHeader->SetL1TriggerType(0,L1TrigType);
+
+   // fITSHeader->SetOrbitNumberSPD(OrbitNumber);
+         //printf("Bunch Crossing  = %x\n ",BunchCross);
+     if ( blockAttributes != 0x3a ) {
+       Info("Exec","Block Attribs  = %x\n ",blockAttributes);
+     }  
+    
+     
+    
+    } // while(str.Next());
+    
+
+    for(Int_t n=0;n<fBt->GetNSPD();n++){
+      branch->SetAddress(&newdigits[n]);
+      branch->Fill();  
+   }
+    
+    fTreeD->SetEntries(fBt->GetNSDD()+fBt->GetNSPD()+fBt->GetNSSD());
+  
+       
+  
+    fReaderDate->Reset();
+    fTreeD->AutoSave();
+   
+
+    for(Int_t n=0;n<fBt->GetNSPD();n++){
+    delete newdigits[n];
+    }
+
+    delete[] newdigits;
+    delete[] idig;
+
+}
+
+  
diff --git a/ITS/AliITSBeamTestDigSPD.h b/ITS/AliITSBeamTestDigSPD.h
new file mode 100644 (file)
index 0000000..135559d
--- /dev/null
@@ -0,0 +1,43 @@
+#ifndef ALIITSBEAMTESTDIGSPD_H
+#define ALIITSBEAMTESTDIGSPD_H
+
+////////////////////////////////////////////////////
+//  Class to define                               //
+//  SPD beam test raw 2 dig conv.                 //
+//
+//  Origin: Jan Conrad Jan.Conrad@cern.ch         //
+////////////////////////////////////////////////////
+
+#include "AliITSBeamTestDig.h"
+
+
+class AliRawReaderDate;
+class AliITSBeamTest;
+
+class AliITSBeamTestDigSPD: public AliITSBeamTestDig {
+ public:
+
+  AliITSBeamTestDigSPD();
+  AliITSBeamTestDigSPD(const Text_t* name, const Text_t* title);
+  virtual ~AliITSBeamTestDigSPD();
+
+  virtual void Exec(Option_t* opt);
+  
+  
+ protected:      
+  
+   
+  Bool_t fFlagHeader; // flag for the event header
+
+
+
+ ClassDef(AliITSBeamTestDigSPD,0)  // An Alice SPD beam test run
+
+ };
+
+
+#endif
+
+    
diff --git a/ITS/AliITSBeamTestDigSSD.cxx b/ITS/AliITSBeamTestDigSSD.cxx
new file mode 100644 (file)
index 0000000..7498352
--- /dev/null
@@ -0,0 +1,97 @@
+/////////////////////////////////////////
+// Class for SSD raw2digits conv       //
+//                                     //
+// Author: Enrico Fragiacomo           //
+// Date: October 2004                  //
+////////////////////////////////////////
+
+#include "AliITSdigitSSD.h"
+#include "AliRawReaderDate.h"
+#include "AliITSRawStreamSSDv1.h"
+#include "AliITSBeamTestDigSSD.h"
+#include "AliITSBeamTest.h"
+
+ClassImp(AliITSBeamTestDigSSD)
+
+//_____________________________________________________________
+AliITSBeamTestDigSSD::AliITSBeamTestDigSSD(): AliITSBeamTestDig() {
+  //
+  // Constructor
+  //  
+}
+
+//_____________________________________________________________
+AliITSBeamTestDigSSD::AliITSBeamTestDigSSD(const Text_t* name, const Text_t* title): AliITSBeamTestDig(name,title) {
+  //
+  // Constructor
+  //
+}
+
+//__________________________________________________________________
+AliITSBeamTestDigSSD::~AliITSBeamTestDigSSD() {
+  //
+  // Destructor
+  //
+}
+
+//_______________________________________________________________________
+void AliITSBeamTestDigSSD::Exec(Option_t* /*opt*/) {
+  //Reads raw data for SSD, fill SSD digits tree, returns 1 if real data,
+  //returns 2 if calibration (injector) data, returns 3 if calibration (test pul  //se) event
+
+  TBranch* branch = fTreeD->GetBranch("ITSDigitSSD");
+
+  TClonesArray** newdigits = new TClonesArray*[fBt->GetNSSD()];
+
+  Int_t* idig = new Int_t[fBt->GetNSSD()];
+
+  for (Int_t idet =0; idet < fBt->GetNSSD();idet++) {
+     newdigits[idet] = new TClonesArray("AliITSdigitSSD");
+     idig[idet]=0;  
+   }
+  
+  // this constructor sets the flag to select SSD data only 
+  // the Next method below will then jump to SSD data for this event
+
+  AliITSRawStreamSSDv1 str(fReaderDate);
+
+  // no selection of equipment 
+  //fReaderDate->SelectEquipment(-1);
+  //fReaderDate->SelectEquipment(17,102,102);
+
+  while(str.Next()){   
+    
+    //if((str.GetADModule()!=2)&&(str.GetADModule()!=6)) continue;
+  
+    Int_t side = str.GetSideFlag();
+    Int_t strip = str.GetStrip();
+    Int_t signal = str.GetSignal();
+    Int_t module = str.GetModuleID();
+    if( (module<10) || (module>13) ) continue;
+    const Int_t kdgt[3]={side,strip,signal};
+    
+    //  SSD modules 10, 11, 12 and 13
+    new ( (*newdigits[module-10])[idig[module-10]] ) AliITSdigitSSD(kdgt);    
+    idig[module-10]++;
+    
+  } // end while
+  
+  for(Int_t n=0;n<fBt->GetNSSD();n++){
+    branch->SetAddress(&newdigits[n]);
+    branch->Fill();  
+  }
+  
+  fTreeD->SetEntries(fBt->GetNSPD()+fBt->GetNSDD()+fBt->GetNSSD());
+    
+  fReaderDate->Reset();
+  
+  fTreeD->AutoSave();
+  
+  for(Int_t n=0;n<fBt->GetNSSD();n++){
+    delete newdigits[n];
+  }
+  
+}
+
+  
+
diff --git a/ITS/AliITSBeamTestDigSSD.h b/ITS/AliITSBeamTestDigSSD.h
new file mode 100644 (file)
index 0000000..6315281
--- /dev/null
@@ -0,0 +1,49 @@
+#ifndef ALIITSBEAMTESTDIGSSD_H
+#define ALIITSBEAMTESTDIGSSD_H
+
+////////////////////////////////////////////////////
+//  Class to define                               //
+//  SSD beam test raw 2 dig conv.                 //
+//                                                //
+//  Origin: Enrico Fragiacomo                     //
+//                                                //
+////////////////////////////////////////////////////
+
+#include "AliITSBeamTestDig.h"
+
+
+class AliRawReaderDate;
+class AliITSBeamTest;
+
+class AliITSBeamTestDigSSD: public AliITSBeamTestDig {
+ public:
+
+  AliITSBeamTestDigSSD();
+  AliITSBeamTestDigSSD(const Text_t* name, const Text_t* title);
+  virtual ~AliITSBeamTestDigSSD();
+
+  virtual void Exec(Option_t* opt);
+  
+  //  void SetRawReaderDate(AliRawReaderDate* rd) {fReaderDate=rd;}
+  // void SetHeader(Bool_t H){fFlagHeader = H;}
+
+  //void SetTree(TTree* treedig) {fTreeD=treedig;}
+    
+ protected:      
+  
+   
+
+  Bool_t fFlagHeader;  //flag for the header
+
+
+ ClassDef(AliITSBeamTestDigSSD,1)  // An Alice SSD beam test run
+
+ };
+
+
+#endif
+
+    
+
diff --git a/ITS/AliITSBeamTestDigitizer.cxx b/ITS/AliITSBeamTestDigitizer.cxx
new file mode 100644 (file)
index 0000000..789cd7b
--- /dev/null
@@ -0,0 +1,303 @@
+////////////////////////////////////////////////////
+//  Class to manage the                           //
+//  ITS beam test conversion from rawdata         //
+//  to digits. It executes the digitization for   //
+//  SPD, SDD and SSD.                             //
+//  Origin:  E. Crescio crescio@to.infn.it        //
+//           J. Conrad  Jan.Conrad@cern.ch        //
+////////////////////////////////////////////////////
+#include "AliHeader.h"
+#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliITSEventHeader.h"
+#include "AliITSLoader.h"
+#include "AliITSBeamTest.h"
+#include "AliITSBeamTestDigSDD.h"
+#include "AliITSBeamTestDigSPD.h"
+#include "AliITSBeamTestDigSSD.h"
+#include "AliITSBeamTestDigitizer.h"
+#include "AliRawReaderDate.h"
+
+
+const TString AliITSBeamTestDigitizer::fgkDefaultDigitsFileName="ITSbt.Digits.root";  
+
+ClassImp(AliITSBeamTestDigitizer)
+
+
+//_____________________________________________________________
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer():TTask() 
+{  
+  //
+  // Default constructor
+  //
+  fRunLoader = 0;
+  fLoader =0;
+  fEvIn=0;
+  fEvFin=0;
+  fFlagHeader=kTRUE;
+  fDATEEvType=7;
+  fRunNumber=-1;
+  SetFlagInit();
+  fBt=0;
+  SetBeamTestPeriod();
+} 
+
+//_____________________________________________________________
+  AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title):TTask(name,title) 
+{  
+  //
+  // Standard constructor 
+  //
+  Init();
+  fEvIn=0;
+  fEvFin=0;
+  fDATEEvType=7;
+  fFlagHeader=kTRUE;
+  fRunNumber=-1;
+  SetBeamTestPeriod();
+ } 
+
+//_____________________________________________________________
+  AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const Text_t* name, const Text_t* title, Int_t run):TTask(name,title) 
+
+{  
+  //
+  // Constructor 
+  //
+  Init();
+  fEvIn=0;
+  fEvFin=0;
+  fDATEEvType=7;
+  fFlagHeader=kTRUE;
+  fRunNumber=run;
+  SetBeamTestPeriod();
+ } 
+
+//___________________________________________________________
+void AliITSBeamTestDigitizer::Init(){
+
+  //
+  //Initialization of run loader and its loader 
+  //creation of galice.root
+  //
+  fRunLoader = AliRunLoader::Open("galice.root",
+                                 AliConfig::GetDefaultEventFolderName(),"recreate");
+  
+  gAlice->SetRunLoader(fRunLoader);    
+  fRunLoader->SetEventFolderName();
+  fBt = new AliITSBeamTest("ITS","ITS beam test");
+  fBt->SetDefaults();
+  gAlice->AddModule(fBt);
+  fRunLoader->AddLoader(fBt);
+  fLoader = (AliITSLoader*)fRunLoader->GetLoader("ITSLoader");
+  fRunLoader->MakeTree("E");  
+
+  fRunLoader->WriteRunLoader("OVERWRITE");
+  fRunLoader->WriteAliRun("OVERWRITE");
+  fDigitsFileName=fgkDefaultDigitsFileName;
+  this->Add(new AliITSBeamTestDigSPD("DigSPD","SPD Digitization")); 
+  this->Add(new AliITSBeamTestDigSDD("DigSDD","SDD Digitization")); 
+  this->Add(new AliITSBeamTestDigSSD("DigSSD","SSD Digitization"));
+
+  SetFlagInit(kTRUE);
+}
+
+//_____________________________________________________________
+  AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const char* filename)
+{
+  //
+  // Constructor for reading (reads galice.root)
+  //
+
+  fRunLoader = AliRunLoader::Open(filename);
+  if (fRunLoader == 0x0)
+    {
+      Error("AliITSBeamTestDigitizer","Can not load the session",filename);
+      return;
+    }
+  fRunLoader->LoadgAlice();
+  gAlice = fRunLoader->GetAliRun();
+  
+  if(!gAlice) {
+    Error("AliITSBeamTestDigitizer","gAlice not found on file. Aborting.");
+    return;
+  } 
+  
+  fLoader = (AliITSLoader*)fRunLoader->GetLoader("ITSLoader");
+  
+  fBt = (AliITSBeamTest*)gAlice->GetDetector("ITS");
+  fBt->SetDefaults();
+
+  fDigitsFileName=fgkDefaultDigitsFileName;
+
+  fEvIn=0;
+  fEvFin=0;
+  
+}
+
+//______________________________________________________________________
+AliITSBeamTestDigitizer::AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer &bt):TTask(bt){
+  // Copy constructor. 
+  //not allowed
+  if(this==&bt) return;
+  Error("Copy constructor",
+       "You are not allowed to make a copy of the AliITSBeamTestDigitizer");
+  exit(1);
+
+}
+//______________________________________________________________________
+AliITSBeamTestDigitizer& AliITSBeamTestDigitizer::operator=(AliITSBeamTestDigitizer &bt){
+    // Assignment operator. This is a function which is not allowed to be
+    // done to the ITS beam test digitizer. It exits with an error.
+    // Inputs:
+    if(this==&bt) return *this;
+    Error("operator=","You are not allowed to make a copy of the AliITSBeamTestDigitizer");
+    exit(1);
+    return *this; //fake return
+}
+
+
+//______________________________________________________________
+AliITSBeamTestDigitizer::~AliITSBeamTestDigitizer(){
+
+  //Destructor
+  if(fBt) delete fBt;
+  if(fLoader) delete fLoader;
+  if(fRunLoader) delete fRunLoader;
+} 
+
+
+//_____________________________________________________________
+void AliITSBeamTestDigitizer::SetNumberOfEventsPerFile(Int_t nev)
+{
+  //Sets number of events per file
+
+  if(fRunLoader) fRunLoader->SetNumberOfEventsPerFile(nev);
+  else Warning("SetNumberOfEventsPerFile","fRunLoader is 0");
+}
+
+
+//____________________________________________________
+void AliITSBeamTestDigitizer::ExecDigitization(){
+
+  // Execution of digitisation for SPD,SDD and SSD
+
+  if(!GetFlagInit()){
+    Warning("ExecDigitization()","Run Init() please..");
+    return;
+  }
+  fLoader->SetDigitsFileName(fDigitsFileName);
+  fLoader->LoadDigits("recreate");
+  AliRawReaderDate rd(fRawdataFileName,fEvIn);
+  AliHeader* header = fRunLoader->GetHeader();
+  
+  Int_t iev=fEvIn-1;
+
+  
+  AliITSBeamTestDigSDD* digSDD = (AliITSBeamTestDigSDD*)fTasks->FindObject("DigSDD");
+  AliITSBeamTestDigSPD* digSPD = (AliITSBeamTestDigSPD*)fTasks->FindObject("DigSPD");
+  AliITSBeamTestDigSSD* digSSD = (AliITSBeamTestDigSSD*)fTasks->FindObject("DigSSD");
+
+
+  do{
+    iev++;
+    if(fEvFin!=0){
+      if(iev>fEvFin) break;
+    } 
+    AliITSEventHeader* itsh = new AliITSEventHeader("ITSHeader");
+    fRunLoader->SetEventNumber(iev);
+   
+    rd.RequireHeader(fFlagHeader);
+    rd.SelectEvents(fDATEEvType);
+    digSDD->SetRawReaderDate(&rd);
+    digSPD->SetRawReaderDate(&rd);
+    digSSD->SetRawReaderDate(&rd);
+    
+    if(fLoader->TreeD() == 0x0) fLoader->MakeTree("D");
+
+    TTree* treeD = (TTree*)fLoader->TreeD();
+   
+    // Make branches outside the dig-classes
+
+    TClonesArray* digitsSPD = new TClonesArray("AliITSdigitSPD",1000);
+    treeD->Branch("ITSDigitSPD",&digitsSPD);
+    TClonesArray* digitsSDD = new TClonesArray("AliITSdigitSDD",1000);
+    treeD->Branch("ITSDigitSDD",&digitsSDD);
+   
+    TClonesArray* digitsSSD = new TClonesArray("AliITSdigitSSD",1000);
+    treeD->Branch("ITSDigitSSD",&digitsSSD);
+
+
+    digSSD->SetTree(treeD);
+    digSDD->SetTree(treeD);
+    digSPD->SetTree(treeD);
+
+    digSSD->SetBeamTest(fBt);
+    digSDD->SetBeamTest(fBt);
+    digSPD->SetBeamTest(fBt);
+
+    digSSD->SetITSEventHeader(itsh);
+    digSDD->SetITSEventHeader(itsh);
+    digSPD->SetITSEventHeader(itsh);
+
+    digSDD->SetBtPeriod(GetBeamTestPeriod());
+    digSDD->SetThreshold(16);
+
+    ExecuteTask(0);  
+
+    header->SetEventNrInRun(iev);
+    header->SetEvent(iev);
+    header->SetRun(fRunNumber);
+    fRunLoader->GetHeader()->AddDetectorEventHeader(itsh);
+    fRunLoader->TreeE()->Fill();
+    header->Reset(fRunNumber,iev);
+    
+    delete digitsSPD;
+    delete digitsSDD;
+    delete digitsSSD;
+
+   }while(rd.NextEvent());
+
+  fRunLoader->WriteHeader("OVERWRITE");
+  fRunLoader->WriteRunLoader("OVERWRITE");
+  fLoader->UnloadDigits();
+  fLoader->UnloadRawClusters();
+  fRunLoader->UnloadHeader();
+  
+}
+
+
+
+//_______________________________________________
+void AliITSBeamTestDigitizer:: SetActive(const TString& subdet,Bool_t value){
+
+  //Sets active sub-tasks (detectors)
+  
+  Bool_t sdd = subdet.Contains("SDD");
+  Bool_t spd = subdet.Contains("SPD");
+  Bool_t ssd = subdet.Contains("SSD");
+
+  if(sdd){
+  AliITSBeamTestDigSDD* digSDD = (AliITSBeamTestDigSDD*)fTasks->FindObject("DigSDD");
+  digSDD->SetActive(value);
+  }
+  
+ if(spd){
+  AliITSBeamTestDigSPD* digSPD = (AliITSBeamTestDigSPD*)fTasks->FindObject("DigSPD");
+  digSPD->SetActive(value);
+  
+  }
+  if(ssd){
+  AliITSBeamTestDigSSD* digSSD = (AliITSBeamTestDigSSD*)fTasks->FindObject("DigSSD");
+  digSSD->SetActive(value);
+  
+  }
+
+
+
+}
+
diff --git a/ITS/AliITSBeamTestDigitizer.h b/ITS/AliITSBeamTestDigitizer.h
new file mode 100644 (file)
index 0000000..5bce22e
--- /dev/null
@@ -0,0 +1,89 @@
+#ifndef ALIITSBEAMTESTDIGITIZER_H
+#define ALIITSBEAMTESTDIGITIZER_H
+
+////////////////////////////////////////////////////
+//  Class to manage the                           //
+//  ITS beam test conversion from rawdata         //
+//  to digits. It executes the digitization for   //
+//  SPD, SDD and SSD.                             //
+//  Origin:  E. Crescio crescio@to.infn.it        //
+//           J. Conrad  Jan.Conrad@cern.ch        //
+////////////////////////////////////////////////////
+#include <TTask.h>
+
+class AliITSBeamTest;
+class AliITSBeamTestDigSDD;
+class AliRawReaderDate;
+class AliRunLoader;
+class AliITSLoader;
+class AliITS;
+class AliITSEventHeader;
+class AliRawDataHeader;
+
+class AliITSBeamTestDigitizer : public TTask {
+ public:
+  AliITSBeamTestDigitizer(); 
+  AliITSBeamTestDigitizer(const Text_t* name,const Text_t* title);
+  AliITSBeamTestDigitizer(const Text_t* name,const Text_t* title, Int_t run);
+  AliITSBeamTestDigitizer(const char* filename);
+  AliITSBeamTestDigitizer(const AliITSBeamTestDigitizer& bt);
+  AliITSBeamTestDigitizer& operator=(AliITSBeamTestDigitizer &bt);
+
+  virtual ~AliITSBeamTestDigitizer();
+
+  void SetDigitsFileName(const TString& name)     {fDigitsFileName=name;}
+  void SetRawdataFileName(const TString& name) {fRawdataFileName=name;}
+  void SetNumberOfEventsPerFile(Int_t nev); 
+
+  void SetStartEventNumber(Int_t evin) {fEvIn=evin;}
+  void SetStopEventNumber(Int_t evfin) {fEvFin=evfin;}
+  void SetFlagHeader(Bool_t flag=kFALSE){fFlagHeader=flag;}
+  void SetFlagInit(Bool_t flag=kFALSE){fFlagInit=flag;}
+  void SelectEvents(Int_t eventtype) {fDATEEvType=eventtype;}
+  void SetBeamTestPeriod(BeamtestPeriod_t per=kNov04) {fPeriod=per;}
+  void SetRunNumber(Int_t run) {fRunNumber=run;}
+
+  void SetActive(const TString& subdet,Bool_t value);
+
+  void ExecDigitization();
+  void Init();
+  Int_t GetRunNumber()  const {return fRunNumber;}
+  Bool_t GetFlagInit()  const {return fFlagInit;}
+  BeamtestPeriod_t GetBeamTestPeriod() const {return fPeriod;}
+
+
+ protected:
+
+
+  Int_t    fEvIn;                   //starting event to be read
+  Int_t    fEvFin;                  //last event to be read
+  Int_t    fRunNumber;              //run number 
+  Int_t    fDATEEvType;             //date eventtype (JC) 
+
+  Bool_t   fFlagHeader;             //flag for the hader 
+  Bool_t   fFlagInit;               //flag for initialization
+
+  TString  fDigitsFileName;         //Digits file name
+  TString  fRawdataFileName;        //Raw data file name
+  BeamtestPeriod_t  fPeriod;                 //Beam test period
+
+  AliITSBeamTest*     fBt;          //! Local pointer to ITS beam test class.
+  
+  AliRunLoader* fRunLoader;         // Local pointer to run loader
+  AliITSLoader* fLoader;            // Pointer to ITS loader
+
+  const AliRawDataHeader* fHeader;  //!current data header
+
+  static const TString fgkDefaultDigitsFileName; // default name for dig. file  
+
+  ClassDef(AliITSBeamTestDigitizer,1)  // An Alice SDD beam test digitization class 
+
+  };
+
+
+#endif
+
+    
diff --git a/ITS/AliITSEventHeader.cxx b/ITS/AliITSEventHeader.cxx
new file mode 100644 (file)
index 0000000..c910215
--- /dev/null
@@ -0,0 +1,65 @@
+////////////////////////////////////////////////////
+//  Base class to define                          //
+//  ITS Event Header                              //
+//  
+//  Origin: E. Crescio crescio@to.infn.it         //
+//                                                //
+////////////////////////////////////////////////////
+
+#include "AliITSEventHeader.h"
+
+ClassImp(AliITSEventHeader)
+
+  
+//_____________________________________________________________
+AliITSEventHeader::AliITSEventHeader():AliDetectorEventHeader()
+{
+  //
+  // Defaulst Constructor
+  //
+  
+  SetEventTypeSDD();
+  
+  for(Int_t idet=0;idet<3;idet++){
+    fL1TriggerType[idet]=0;
+    fOrbitNumber[idet]=0;
+    fBunchCross[idet]=0;
+    fBlockAttr[idet]=0;
+    fTriggerClass[idet]=0;
+    fStatusBits[idet]=0;
+    fMiniEvId[idet]=0;
+    fSubDet[idet]=0;
+    fVersion[idet]=0;
+    fJitterSDD=0;
+  }
+  
+  
+}
+
+//_____________________________________________________________
+AliITSEventHeader::AliITSEventHeader(const char* name):AliDetectorEventHeader(name)
+{
+  //
+  // Constructor
+  //
+  SetEventTypeSDD();
+  for(Int_t idet=0;idet<3;idet++){
+    fL1TriggerType[idet]=0;
+    fOrbitNumber[idet]=0;
+    fBunchCross[idet]=0;
+    fBlockAttr[idet]=0;
+    fTriggerClass[idet]=0;
+    fStatusBits[idet]=0;
+    fMiniEvId[idet]=0;
+    fSubDet[idet]=0;
+    fVersion[idet]=0;
+    fJitterSDD=-123;
+  }
+  
+
+}
+
+
+
+
+
diff --git a/ITS/AliITSEventHeader.h b/ITS/AliITSEventHeader.h
new file mode 100644 (file)
index 0000000..defe724
--- /dev/null
@@ -0,0 +1,71 @@
+#ifndef ALIITSEVENTHEADER_H
+#define ALIITSEVENTHEADER_H
+
+////////////////////////////////////////////////////
+//  Base class to define                          //
+//  ITS Event Header                              //
+//  
+//  Origin: E. Crescio crescio@to.infn.it         //
+//                                                //
+////////////////////////////////////////////////////
+
+#include "AliDetectorEventHeader.h"
+
+typedef enum { kSimulated, kReal, kCalibration1, kCalibration2 }  EventType_t;
+
+class AliITSEventHeader : public AliDetectorEventHeader {
+ public:
+
+
+  AliITSEventHeader(const char* name);
+  AliITSEventHeader();
+
+  virtual ~AliITSEventHeader() {}
+  
+  EventType_t GetEventTypeSDD()   const {return fEventTypeSDD;};
+  UChar_t     GetL1TriggerType(Int_t i) const {return fL1TriggerType[i];}
+  UInt_t      GetOrbitNumber(Int_t i) const  {return fOrbitNumber[i];}
+  UShort_t    GetBunchCross(Int_t i)  const  {return fBunchCross[i];}
+  UChar_t     GetBlockAttributes(Int_t i) const {return fBlockAttr[i];}
+  ULong64_t   GetTriggerClass(Int_t i) const {return fTriggerClass[i];}
+  UInt_t      GetStatusBits(Int_t i)  const {return fStatusBits[i];}
+  UInt_t      GetMiniEvId(Int_t i)   const {return fMiniEvId[i];}
+  UInt_t      GetSubDet(Int_t i)     const {return fSubDet[i];}
+  UInt_t      GetVersion(Int_t i)    const {return fVersion[i];}
+  Int_t       GetJitterSDD()         const {return fJitterSDD;}
+
+  void SetEventTypeSDD(EventType_t type=kSimulated){fEventTypeSDD=type;}
+  void SetL1TriggerType(Int_t i,UChar_t l1trig) {fL1TriggerType[i]=l1trig;}
+  void SetOrbitNumber(Int_t i,UInt_t orbitnum) {fOrbitNumber[i]=orbitnum;}
+  void SetBunchCross(Int_t i,UShort_t bunchcross) {fBunchCross[i]=bunchcross;}
+  void SetBlockAttributes(Int_t i,UChar_t attr) {fBlockAttr[i]=attr;}
+  void SetTriggerClass(Int_t i,ULong64_t trigclass){fTriggerClass[i]=trigclass;}
+  void SetStatusBits(Int_t i,UInt_t bits) {fStatusBits[i]=bits;}
+  void SetMiniEvId(Int_t i,UInt_t minievid) {fMiniEvId[i]=minievid;}
+  void SetSubDet(Int_t i,UInt_t subdet) {fSubDet[i]=subdet;}
+  void SetVersion(Int_t i,UInt_t version) {fVersion[i]=version;}
+  void SetJitterSDD(Int_t jitter) {fJitterSDD=jitter;}
+  
+ protected:
+  
+  EventType_t fEventTypeSDD;       //event type for SDD 
+  UChar_t   fL1TriggerType[3];     //Level 1 trigger type (0 spd,1 sdd,2 ssd) 
+  UInt_t    fOrbitNumber[3];       //Orbit Number (0 spd,1 sdd,2 ssd)
+  UShort_t  fBunchCross[3];        //Bunch Crossing Number (0 spd,1 sdd,2 ssd)
+  UChar_t   fBlockAttr[3];         //Block Attributes (0 spd,1 sdd,2 ssd)
+  ULong64_t fTriggerClass[3];      //Trigger classes (0 spd,1 sdd,2 ssd)
+  UInt_t    fStatusBits[3];        //Status Bits (0 spd,1 sdd,2 ssd)
+  UInt_t    fMiniEvId[3];          //MiniEvent ID (0 spd,1 sdd,2 ssd)
+  UInt_t    fSubDet[3];            //partic. sub-detectors (0 spd,1 sdd,2 ssd)
+  UInt_t    fVersion[3];           //Header Version (0 spd,1 sdd,2 ssd)
+  Int_t     fJitterSDD;            // SDD jitter between L0 and pascal stop
+
+  ClassDef(AliITSEventHeader,1)  // An Alice ITS event header 
+
+ };
+
+
+#endif
+
+    
index 228aaa6..b966a52 100644 (file)
@@ -45,7 +45,7 @@ class AliITSRawStreamSDD: public AliITSRawStream {
     virtual UInt_t   ReadBits();
     virtual Int_t    DecompAmbra(Int_t value) const;
 
-    static const UInt_t fgkCodeLength[8];
+    static const UInt_t fgkCodeLength[8]; //code length
 
     UInt_t           fData;         // data read for file
     Int_t            fSkip;         // number of skipped words
index 5255546..d7d8beb 100644 (file)
@@ -139,6 +139,9 @@ Bool_t AliITSRawStreamSDDv3::Next()
 
 Int_t AliITSRawStreamSDDv3::GetJitter() {
 
+  // Reads the value of the jitter between L0 and pascal stop
+  // written in the last word of the buffer
+
      if (!fRawReader->ReadNextInt(fData)){
        Error("GetJitter","Jitter word not found!!");
        return -1;  // read last word
index 79e15ec..b4c7aff 100644 (file)
@@ -33,7 +33,7 @@ class AliITSRawStreamSSD: public AliITSRawStream {
     static Int_t     GetModuleNumber(UInt_t iDDL, UInt_t iModule)
       {return fgkDDLModuleMap[iDDL][iModule];}
 
-  private :
+  protected :
     static const Int_t fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL];  // mapping DDL/module -> module number
 
     UInt_t           fData;         // data read for file
diff --git a/ITS/AliITSRawStreamSSDv1.cxx b/ITS/AliITSRawStreamSSDv1.cxx
new file mode 100644 (file)
index 0000000..2b96984
--- /dev/null
@@ -0,0 +1,86 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/* $Id$ */
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This class provides access to beam test ITS SSD digits in raw data.
+//  Modified by Enrico Fragiacomo, October 2004, for beamtest analysis
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliITSRawStreamSSDv1.h"
+#include "AliRawReader.h"
+
+ClassImp(AliITSRawStreamSSDv1)
+
+
+AliITSRawStreamSSDv1::AliITSRawStreamSSDv1(AliRawReader* rawReader) :
+  AliITSRawStreamSSD(rawReader)
+{
+// create an object to read ITS SSD raw digits
+
+  fADC =0;
+  fADModule=0;
+  fRawReader->Select(3);
+  fRawReader->SelectEquipment(17,102,102);
+}
+
+
+Bool_t AliITSRawStreamSSDv1::Next()
+{
+// read the next raw digit
+// returns kFALSE if there is no digit left
+
+  Int_t seq=0;
+
+  fPrevModuleID = fModuleID;
+
+  if (!fRawReader->ReadNextInt(fData)) return kFALSE;
+
+  fADModule = (fData >> 27) & 0x0000000F;
+  fADC       = (fData >> 23) & 0x0000000F;
+
+  // seq 0 (first 768 strips) or 1 are obtained from fCoord2
+  fCoord2    = (fData >> 12) & 0x000007FF;
+  seq    = (fCoord2 >= 768) ? 1 : 0; 
+  if(seq) fCoord2 = 1535 - fCoord2;
+
+  if((fCoord2<0)||(fCoord2>=768)) return kFALSE;
+
+  // ADModule 2 -> layer 5
+  // fCoord1 is set according to the cabling map
+  if(fADModule==2) {
+    if ((fADC==0)&&(seq==0)) {fModuleID = 10; fCoord1=1;}
+    else if ((fADC==0)&&(seq==1)) {fModuleID = 11; fCoord1=1;}
+    else if ((fADC==1)&&(seq==0)) {fModuleID = 11; fCoord1=0;}
+    else if ((fADC==1)&&(seq==1)) {fModuleID = 10; fCoord1=0;}
+  }
+  // ADModule 6 -> layer 6
+  // fCoord1 is set according to the cabling map
+  else if(fADModule==6) {
+    if ((fADC==0)&&(seq==0)) {fModuleID = 12; fCoord1=0;}
+    else if ((fADC==0)&&(seq==1)) {fModuleID = 13; fCoord1=0;}
+    else if ((fADC==1)&&(seq==0)) {fModuleID = 13; fCoord1=1;}
+    else if ((fADC==1)&&(seq==1)) {fModuleID = 12; fCoord1=1;}
+  }
+
+  fSignal    = (fData & 0x00000FFF);
+
+  if(fSignal>=2048) fSignal-=4096;
+
+  return kTRUE;
+}
+
diff --git a/ITS/AliITSRawStreamSSDv1.h b/ITS/AliITSRawStreamSSDv1.h
new file mode 100644 (file)
index 0000000..c8fc85e
--- /dev/null
@@ -0,0 +1,39 @@
+#ifndef ALIITSRAWSTREAMSSDV1_H
+#define ALIITSRAWSTREAMSSDV1_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+///////////////////////////////////////////////////////////////////////////////
+///
+/// This class provides access to ITS SSD digits in raw data.
+///
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliITSRawStreamSSD.h"
+
+class AliRawReader;
+
+
+class AliITSRawStreamSSDv1: public AliITSRawStreamSSD {
+  public :
+    AliITSRawStreamSSDv1(AliRawReader* rawReader);
+    virtual ~AliITSRawStreamSSDv1() {};
+
+    virtual Bool_t   Next();
+
+    Int_t            GetADC() const {return fADC;}
+    Int_t            GetADModule() const {return fADModule;}
+
+  protected :
+
+  Int_t  fADModule;               // FEROM module
+  Int_t  fADC;                    // ADC within the ADModule
+         
+
+    ClassDef(AliITSRawStreamSSDv1, 0) // class for reading beam test ITS digits
+};
+
+#endif
+
index 08628d1..28467dc 100644 (file)
 #pragma link C++ class AliITStrackSA+;
 #pragma link C++ class AliITSVertexerFast+;
 #pragma link C++ class AliITSRawStream+;
-#pragma link C++ class AliITSRawStreamSDD;
-#pragma link C++ class AliITSRawStreamSDDv2;
-#pragma link C++ class AliITSRawStreamSDDv3;
-#pragma link C++ class AliITSRawStreamSPD;
-#pragma link C++ class AliITSRawStreamSSD;
+#pragma link C++ class AliITSRawStreamSDD+;
+#pragma link C++ class AliITSRawStreamSDDv2+;
+#pragma link C++ class AliITSRawStreamSDDv3+;
+#pragma link C++ class AliITSRawStreamSPD+;
+#pragma link C++ class AliITSRawStreamSSD+;
+#pragma link C++ class AliITSRawStreamSSDv1+;
+#pragma link C++ class AliITSBeamTest+;
+#pragma link C++ class AliITSBeamTestDig+;
+#pragma link C++ class AliITSBeamTestDigSPD+;
+#pragma link C++ class AliITSBeamTestDigSDD+;
+#pragma link C++ class AliITSBeamTestDigSSD+;
+#pragma link C++ class AliITSBeamTestDigitizer+;
+#pragma link C++ class AliITSEventHeader+;
 
 #pragma link C++ class AliITSReconstructor+;
 
index a90da0e..2246d08 100644 (file)
@@ -103,6 +103,14 @@ SRCS =     AliITS.cxx \
                AliITSRawStreamSSD.cxx \
                AliITSRawStreamSDD.cxx \
                AliITSRawStreamSPD.cxx \
+               AliITSBeamTest.cxx \
+               AliITSBeamTestDig.cxx \
+               AliITSBeamTestDigSDD.cxx \
+               AliITSBeamTestDigSPD.cxx \
+               AliITSBeamTestDigSSD.cxx \
+               AliITSBeamTestDigitizer.cxx \
+               AliITSEventHeader.cxx \
+               AliITSRawStreamSSDv1.cxx \
 #          AliITSv11.cxx \
 #          AliITSv11Geometry.cxx \
 #          AliITSv11GeometrySupport.cxx \