#include <TFile.h>
#include "AliRun.h"
+#include "AliLog.h"
#include "AliTRDdigitsManager.h"
#include "AliTRDsegmentArray.h"
#include "AliTRDdigit.h"
#include "AliTRDgeometry.h"
+#include "AliTRDSignalIndex.h"
+
ClassImp(AliTRDdigitsManager)
//_____________________________________________________________________________
const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
//_____________________________________________________________________________
-AliTRDdigitsManager::AliTRDdigitsManager():TObject()
+AliTRDdigitsManager::AliTRDdigitsManager()
+ :TObject()
+ ,fEvent(0)
+ ,fTree(0)
+ ,fDigits(0)
+ ,fIsRaw(0)
+ ,fSDigits(0)
+ ,fSignalIndexes(NULL)
+ ,fUseDictionaries(kTRUE)
{
//
// Default constructor
//
- fIsRaw = kFALSE;
- fEvent = 0;
- fDebug = 0;
- fSDigits = 0;
-
- fTree = NULL;
- fDigits = NULL;
for (Int_t iDict = 0; iDict < kNDict; iDict++) {
fDictionary[iDict] = NULL;
}
-
+
+ //fSignalIndexes = new TList();
+ fSignalIndexes = new TObjArray(AliTRDgeometry::Ndet());
+
}
//_____________________________________________________________________________
AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
-:TObject(m)
+ :TObject(m)
+ ,fEvent(m.fEvent)
+ ,fTree(0)
+ ,fDigits(0)
+ ,fIsRaw(m.fIsRaw)
+ ,fSDigits(m.fSDigits)
+ ,fSignalIndexes(NULL)
+ ,fUseDictionaries(kTRUE)
{
//
// AliTRDdigitsManager copy constructor
//
- ((AliTRDdigitsManager &) m).Copy(*this);
-
}
//_____________________________________________________________________________
fDictionary[iDict] = NULL;
}
+ if (fSignalIndexes) {
+ fSignalIndexes->Delete();
+ delete fSignalIndexes;
+ }
+ fSignalIndexes = NULL;
+
+}
+
+//_____________________________________________________________________________
+AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
+{
+ //
+ // Assignment operator
+ //
+
+ if (this != &m) ((AliTRDdigitsManager &) m).Copy(*this);
+ return *this;
+
}
//_____________________________________________________________________________
-void AliTRDdigitsManager::Copy(TObject &m)
+void AliTRDdigitsManager::Copy(TObject &m) const
{
//
// Copy function
((AliTRDdigitsManager &) m).fIsRaw = fIsRaw;
((AliTRDdigitsManager &) m).fEvent = fEvent;
- ((AliTRDdigitsManager &) m).fDebug = fDebug;
((AliTRDdigitsManager &) m).fSDigits = fSDigits;
+
+ ((AliTRDdigitsManager &) m).fSignalIndexes = fSignalIndexes;
+ ((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;
TObject::Copy(m);
fDigits = new AliTRDsegmentArray("AliTRDdataArrayI",AliTRDgeometry::Ndet());
- for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
- ,AliTRDgeometry::Ndet());
- }
+ if (fUseDictionaries)
+ {
+ for (Int_t iDict = 0; iDict < kNDict; iDict++) {
+ fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
+ ,AliTRDgeometry::Ndet());
+ }
+ }
+ for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++)
+ {
+ fSignalIndexes->AddLast(new AliTRDSignalIndex());
+ }
}
//_____________________________________________________________________________
void AliTRDdigitsManager::ResetArrays()
//
if (fDigits) {
+ fDigits->Delete();
delete fDigits;
}
fDigits = new AliTRDsegmentArray("AliTRDdataArrayI",AliTRDgeometry::Ndet());
- for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- if (fDictionary[iDict]) {
- delete fDictionary[iDict];
+ if (fUseDictionaries)
+ {
+ for (Int_t iDict = 0; iDict < kNDict; iDict++) {
+ if (fDictionary[iDict]) {
+ fDictionary[iDict]->Delete();
+ delete fDictionary[iDict];
+ }
+ fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
+ ,AliTRDgeometry::Ndet());
+ }
}
- fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
- ,AliTRDgeometry::Ndet());
- }
+ for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++)
+ {
+ AliTRDSignalIndex *idx = (AliTRDSignalIndex *)fSignalIndexes->At(i);
+ if (idx) idx->Reset();
+ }
}
//_____________________________________________________________________________
//
fIsRaw = kTRUE;
-
- fDigits->SetBit(AliTRDdigit::RawDigit());
+ if (fDigits)
+ fDigits->SetBit(AliTRDdigit::RawDigit());
}
// Returns the amplitude of a digit
//
+ if (!GetDigits(det)) return 0;
return ((Short_t) GetDigits(det)->GetData(row,col,time));
}
TBranch* branch = fTree->GetBranch("TRDdigits");
if (!branch) fTree->Branch("TRDdigits",kDigits->IsA()->GetName(),
&kDigits,buffersize,99);
- if (fDebug > 0) {
- printf("<AliTRDdigitsManager::MakeBranch> ");
- printf("Making branch TRDdigits\n");
- }
+ AliDebug(1,"Making branch TRDdigits\n");
}
else {
status = kFALSE;
status = kFALSE;
}
- // Make the branches for the dictionaries
- for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- Char_t branchname[15];
- sprintf(branchname,"TRDdictionary%d",iDict);
- if (fDictionary[iDict]) {
- const AliTRDdataArray *kDictionary =
- (AliTRDdataArray *) fDictionary[iDict]->At(0);
- if (kDictionary) {
- if (!fTree) return kFALSE;
- TBranch* branch = fTree->GetBranch(branchname);
- if (!branch) fTree->Branch(branchname,kDictionary->IsA()->GetName(),
+ if (fUseDictionaries)
+ {
+ // Make the branches for the dictionaries
+ for (Int_t iDict = 0; iDict < kNDict; iDict++) {
+ Char_t branchname[15];
+ sprintf(branchname,"TRDdictionary%d",iDict);
+ if (fDictionary[iDict]) {
+ const AliTRDdataArray *kDictionary =
+ (AliTRDdataArray *) fDictionary[iDict]->At(0);
+ if (kDictionary) {
+ if (!fTree) return kFALSE;
+ TBranch* branch = fTree->GetBranch(branchname);
+ if (!branch) fTree->Branch(branchname,kDictionary->IsA()->GetName(),
&kDictionary,buffersize,99);
- if (fDebug > 0) {
- printf("<AliTRDdigitsManager::MakeBranch> ");
- printf("Making branch %s\n",branchname);
+ AliDebug(1,Form("Making branch %s\n",branchname));
+ }
+ else {
+ status = kFALSE;
+ }
+ }
+ else {
+ status = kFALSE;
}
}
- else {
- status = kFALSE;
- }
- }
- else {
- status = kFALSE;
}
- }
return status;
}
if (!fDigits) {
- if (fDebug > 0) {
- printf("<AliTRDdigitsManager::ReadDigits> ");
- printf("Create the data arrays.\n");
- }
+ AliDebug(1,"Create the data arrays.\n");
CreateArrays();
}
status = fDigits->LoadArray("TRDdigits",fTree);
- for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- Char_t branchname[15];
- sprintf(branchname,"TRDdictionary%d",iDict);
- status = fDictionary[iDict]->LoadArray(branchname,fTree);
- }
+ if (fUseDictionaries)
+ {
+ for (Int_t iDict = 0; iDict < kNDict; iDict++) {
+ Char_t branchname[15];
+ sprintf(branchname,"TRDdictionary%d",iDict);
+ status = fDictionary[iDict]->LoadArray(branchname,fTree);
+ if (status == kFALSE)
+ {
+ fUseDictionaries = kFALSE;
+ AliWarning("Unable to load dict arrays. Will not use them.\n");
+ break;
+ }
+ }
+ }
if (fDigits->TestBit(AliTRDdigit::RawDigit())) {
fIsRaw = kTRUE;
// Store the contents of the segment array in the tree
if (!fDigits->StoreArray("TRDdigits",fTree)) {
- printf("<AliTRDdigitsManager::WriteDigits> ");
- printf("Error while storing digits in branch TRDdigits\n");
+ AliError("Error while storing digits in branch TRDdigits\n");
return kFALSE;
}
- for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- Char_t branchname[15];
- sprintf(branchname,"TRDdictionary%d",iDict);
- if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
- printf("<AliTRDdigitsManager::WriteDigits> ");
- printf("Error while storing dictionary in branch %s\n",branchname);
- return kFALSE;
+
+ if (fUseDictionaries)
+ {
+ for (Int_t iDict = 0; iDict < kNDict; iDict++) {
+ Char_t branchname[15];
+ sprintf(branchname,"TRDdictionary%d",iDict);
+ if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
+ AliError(Form("Error while storing dictionary in branch %s\n",branchname));
+ return kFALSE;
+ }
+ }
}
- }
// Write the new tree to the output file
- //fTree->Write();
fTree->AutoSave(); // Modification by Jiri
return kTRUE;
//
if ((track < 0) || (track >= kNDict)) {
- TObject::Error("GetTracks"
- ,"track %d out of bounds (size: %d, this: 0x%08x)"
- ,track,kNDict,this);
+ AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)"
+ ,track,kNDict,this));
return -1;
}
+ if (fUseDictionaries == kFALSE)
+ {
+ return -1;
+ }
// Array contains index+1 to allow data compression
return (GetDictionary(det,track)->GetData(row,col,time) - 1);
// Returns the digits array for one detector
//
+ if (!fDigits) return 0x0;
return (AliTRDdataArrayI *) fDigits->At(det);
}
//
// Returns the dictionary for one detector
//
+ if (fUseDictionaries == kFALSE)
+ {
+ return NULL;
+ }
return (AliTRDdataArrayI *) fDictionary[i]->At(det);
}
//_____________________________________________________________________________
-AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
+AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
{
+ //
+ // Returns indexes of active pads
//
- // Assignment operator
+
+ return (AliTRDSignalIndex*)fSignalIndexes->At(det);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::RemoveDigits(Int_t det)
+{
+ //
+ // Clear memory
//
- if (this != &m) ((AliTRDdigitsManager &) m).Copy(*this);
- return *this;
+ fDigits->ClearSegment(det);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::RemoveDictionaries(Int_t det)
+{
+ //
+ // Clear memory
+ //
+ if (fUseDictionaries == kFALSE)
+ {
+ return;
+ }
+
+ for (Int_t i = 0; i < kNDict; i++) {
+ fDictionary[i]->ClearSegment(det);
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::ClearIndexes(Int_t det)
+{
+ //
+ // Clear memory
+ //
+ fSignalIndexes->At(det)->Clear();
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
+{
+ //
+ // Build the list of indices
+ //
+
+ Int_t nRows = 0;
+ Int_t nCols = 0;
+ Int_t nTbins = 0;
+
+ AliTRDgeometry geom;
+ AliTRDdataArrayI *digits = GetDigits(det);
+ //digits should be expanded by now!!!
+ if (digits->GetNtime() > 0)
+ {
+ digits->Expand();
+ nRows = digits->GetNrow();
+ nCols = digits->GetNcol();
+ nTbins = digits->GetNtime();
+
+ //AliInfo(Form("rows %d cols %d tbins %d", nRows, nCols, nTbins));
+
+ AliTRDSignalIndex* indexes = GetIndexes(det);
+ indexes->SetSM(geom.GetSector(det));
+ indexes->SetChamber(geom.GetChamber(det));
+ indexes->SetPlane(geom.GetPlane(det));
+ indexes->SetDetNumber(det);
+ if (indexes->IsAllocated() == kFALSE)
+ {
+ indexes->Allocate(nRows, nCols, nTbins);
+ //AliInfo(Form("Allocating 0x%x %d", indexes->GetArray(), indexes->GetArray()->GetSize()));
+ }
+ for (Int_t ir = 0; ir < nRows; ir++)
+ {
+ for (Int_t ic = 0; ic < nCols; ic++)
+ {
+ for (Int_t it = 0; it < nTbins; it++)
+ {
+ //AliInfo(Form("row %d col %d tbin %d", ir, ic, it));
+
+ Int_t isig = digits->GetDataUnchecked(ir, ic, it);
+ if (isig > 0)
+ {
+ //AliInfo(Form("row %d col %d tbin %d", ir, ic, it));
+ indexes->AddIndexTBin(ir, ic, it);
+ }
+ } //tbins
+ } //cols
+ } // rows
+ } // if GetNtime
+ else
+ {
+ return kFALSE;
+ }
+ return kTRUE;
}