* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.3 2000/06/07 16:27:01 cblume
-Try to remove compiler warnings on Sun and HP
-
-Revision 1.2 2000/05/08 16:17:27 cblume
-Merge TRD-develop
-
-Revision 1.1.2.1 2000/05/08 14:44:01 cblume
-Add new class AliTRDdigitsManager
-
-*/
+/* $Id$ */
///////////////////////////////////////////////////////////////////////////////
// //
// //
///////////////////////////////////////////////////////////////////////////////
+#include <Riostream.h>
+
+#include <TROOT.h>
+#include <TTree.h>
+#include <TFile.h>
+
#include "AliRun.h"
+#include "AliLog.h"
#include "AliTRDdigitsManager.h"
-#include "AliTRDconst.h"
+#include "AliTRDsegmentArray.h"
+#include "AliTRDdataArray.h"
+#include "AliTRDdataArrayI.h"
+#include "AliTRDdataArrayS.h"
+#include "AliTRDdataArrayDigits.h"
+#include "AliTRDdigit.h"
+#include "AliTRDgeometry.h"
+
+#include "AliTRDSignalIndex.h"
ClassImp(AliTRDdigitsManager)
//_____________________________________________________________________________
-AliTRDdigitsManager::AliTRDdigitsManager():TObject()
+
+ // Number of track dictionary arrays
+ const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
+
+//_____________________________________________________________________________
+AliTRDdigitsManager::AliTRDdigitsManager()
+ :TObject()
+ ,fEvent(0)
+ ,fTree(0)
+ ,fDigits(0)
+ ,fHasSDigits(0)
+ ,fSignalIndexes(NULL)
+ ,fUseDictionaries(kTRUE)
{
//
// Default constructor
//
- fIsRaw = kFALSE;
-
- fDigits = new AliTRDsegmentArray("AliTRDdataArrayI",kNdet);
-
for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI",kNdet);
+ fDictionary[iDict] = NULL;
}
-
+
+ fSignalIndexes = new TObjArray(AliTRDgeometry::Ndet());
+
}
//_____________________________________________________________________________
-AliTRDdigitsManager::AliTRDdigitsManager(AliTRDdigitsManager &m)
+AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
+ :TObject(m)
+ ,fEvent(m.fEvent)
+ ,fTree(0)
+ ,fDigits(0)
+ ,fHasSDigits(m.fHasSDigits)
+ ,fSignalIndexes(NULL)
+ ,fUseDictionaries(kTRUE)
{
//
// AliTRDdigitsManager copy constructor
//
- m.Copy(*this);
-
}
//_____________________________________________________________________________
if (fDigits) {
fDigits->Delete();
delete fDigits;
+ fDigits = NULL;
}
for (Int_t iDict = 0; iDict < kNDict; iDict++) {
fDictionary[iDict]->Delete();
delete fDictionary[iDict];
+ fDictionary[iDict] = NULL;
+ }
+
+ if (fSignalIndexes) {
+ fSignalIndexes->Delete();
+ delete fSignalIndexes;
+ fSignalIndexes = NULL;
}
}
//_____________________________________________________________________________
-void AliTRDdigitsManager::Copy(AliTRDdigitsManager &m)
+AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
+{
+ //
+ // Assignment operator
+ //
+
+ if (this != &m) {
+ ((AliTRDdigitsManager &) m).Copy(*this);
+ }
+
+ return *this;
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::Copy(TObject &m) const
{
//
// Copy function
//
- m.fIsRaw = fIsRaw;
+ ((AliTRDdigitsManager &) m).fEvent = fEvent;
+ ((AliTRDdigitsManager &) m).fHasSDigits = fHasSDigits;
+
+ ((AliTRDdigitsManager &) m).fSignalIndexes = fSignalIndexes;
+ ((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;
TObject::Copy(m);
}
//_____________________________________________________________________________
-void AliTRDdigitsManager::SetRaw()
+void AliTRDdigitsManager::CreateArrays()
{
+ //
+ // Create the data arrays
+ //
- fIsRaw = kTRUE;
+ if (fHasSDigits) {
+ fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
+ }
+ else {
+ fDigits = new AliTRDsegmentArray("AliTRDdataArrayDigits",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());
+ }
- fDigits->SetBit(kRawDigit);
-
}
//_____________________________________________________________________________
-Bool_t AliTRDdigitsManager::MakeBranch()
+void AliTRDdigitsManager::ResetArrays()
{
//
- // Creates the branches for the digits and the dictionary in the digits tree
+ // Reset the data arrays
+ //
+
+ if (fDigits) {
+ fDigits->Delete();
+ delete fDigits;
+ }
+ if (fHasSDigits) {
+ fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
+ }
+ else {
+ fDigits = new AliTRDsegmentArray("AliTRDdataArrayS",AliTRDgeometry::Ndet());
+ }
+
+ 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());
+ }
+ }
+
+ for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++) {
+ AliTRDSignalIndex *idx = (AliTRDSignalIndex *)fSignalIndexes->At(i);
+ if (idx) idx->Reset();
+ }
+
+}
+
+//_____________________________________________________________________________
+Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time
+ , Int_t det) const
+{
+ //
+ // Returns the amplitude of a digit
+ //
+
+ if (!GetDigits(det)) {
+ return 0;
+ }
+
+ return ((Short_t) ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time));
+
+}
+
+//_____________________________________________________________________________
+UChar_t AliTRDdigitsManager::GetPadStatus(Int_t row, Int_t col, Int_t time
+ , Int_t det) const
+{
+ //
+ // Returns the pad status for the requested pad
+ //
+
+ if (!GetDigits(det)) {
+ return 0;
+ }
+
+ return ((UChar_t) ((AliTRDdataArrayDigits *) GetDigits(det))->GetPadStatus(row,col,time));
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliTRDdigitsManager::MakeBranch(TTree *tree)
+{
+ //
+ // Creates the tree and branches for the digits and the dictionary
//
Int_t buffersize = 64000;
Bool_t status = kTRUE;
- if (gAlice->TreeD()) {
-
- // Make the branch for the digits
- if (fDigits) {
- const AliTRDdataArrayI *kDigits =
- (AliTRDdataArrayI *) fDigits->At(0);
- if (kDigits) {
- gAlice->TreeD()->Branch("TRDdigits",kDigits->IsA()->GetName()
- ,&kDigits,buffersize,1);
- printf("AliTRDdigitsManager::MakeBranch -- ");
- printf("Making branch TRDdigits\n");
- }
- else {
- status = kFALSE;
- }
+ if (tree) {
+ fTree = tree;
+ }
+
+ // Make the branch for the digits
+ if (fDigits) {
+ const AliTRDdataArray *kDigits = (AliTRDdataArray *) fDigits->At(0);
+ if (kDigits) {
+ if (!fTree) return kFALSE;
+ TBranch* branch = fTree->GetBranch("TRDdigits");
+ if (!branch) fTree->Branch("TRDdigits",kDigits->IsA()->GetName()
+ ,&kDigits,buffersize,99);
+ AliDebug(1,"Making branch TRDdigits\n");
}
else {
status = kFALSE;
}
+ }
+ else {
+ status = kFALSE;
+ }
+ 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 AliTRDdataArrayI *kDictionary =
- (AliTRDdataArrayI *) fDictionary[iDict]->At(0);
- if (kDictionary) {
- gAlice->TreeD()->Branch(branchname,kDictionary->IsA()->GetName()
- ,&kDictionary,buffersize,1);
- printf("AliTRDdigitsManager::MakeBranch -- ");
- printf("Making branch %s\n",branchname);
+ 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);
+ AliDebug(1,Form("Making branch %s\n",branchname));
}
- else {
- status = kFALSE;
+ else {
+ status = kFALSE;
}
}
else {
- status = kFALSE;
+ status = kFALSE;
}
}
-
- }
- else {
- status = kFALSE;
}
return status;
}
//_____________________________________________________________________________
-Bool_t AliTRDdigitsManager::ReadDigits()
+Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
{
//
// Reads the digit information from the input file
Bool_t status = kTRUE;
- status = fDigits->LoadArray("TRDdigits");
-
- for (Int_t iDict = 0; iDict < kNDict; iDict++) {
- Char_t branchname[15];
- sprintf(branchname,"TRDdictionary%d",iDict);
- status = fDictionary[iDict]->LoadArray(branchname);
- }
+ if (tree) {
+ fTree = tree;
+ }
- if (fDigits->TestBit(kRawDigit)) {
- fIsRaw = kTRUE;
+ if (!fDigits) {
+ AliDebug(1,"Create the data arrays.\n");
+ CreateArrays();
}
- else {
- fIsRaw = kFALSE;
+
+ status = fDigits->LoadArray("TRDdigits",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;
+ }
+ }
}
return kTRUE;
// Writes out the TRD-digits and the dictionaries
//
- // Create the branches
- if (!(gAlice->TreeD()->GetBranch("TRDdigits"))) {
- if (!MakeBranch()) return kFALSE;
- }
-
// Store the contents of the segment array in the tree
- if (!fDigits->StoreArray("TRDdigits")) {
- printf("AliTRDdigitsManager::WriteDigits -- ");
- printf("Error while storing digits in branch TRDdigits\n");
+ if (!fDigits->StoreArray("TRDdigits",fTree)) {
+ 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)) {
- 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->AutoSave(); // Modification by Jiri
+
return kTRUE;
}
//_____________________________________________________________________________
AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
- , Int_t time, Int_t det)
+ , Int_t time, Int_t det) const
{
//
// Creates a single digit object
digits[2] = col;
digits[3] = time;
- amp[0] = GetDigits(det)->GetData(row,col,time);
+ amp[0] = ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time);
- return (new AliTRDdigit(fIsRaw,digits,amp));
+ return (new AliTRDdigit(digits,amp));
}
//_____________________________________________________________________________
Int_t AliTRDdigitsManager::GetTrack(Int_t track
, Int_t row, Int_t col, Int_t time
- , Int_t det)
+ , Int_t det) const
{
//
// Returns the MC-track numbers from the dictionary.
//
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);
+ return (((AliTRDdataArrayI *) GetDictionary(det,track))->GetData(row,col,time) - 1);
+
+}
+
+//_____________________________________________________________________________
+AliTRDdataArrayDigits *AliTRDdigitsManager::GetDigits(Int_t det) const
+{
+ //
+ // Returns the digits array for one detector
+ //
+
+ if (!fDigits) {
+ return 0x0;
+ }
+
+ return (AliTRDdataArrayDigits *) fDigits->At(det);
+
+}
+
+//_____________________________________________________________________________
+AliTRDdataArray *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
+{
+ //
+ // Returns the dictionary for one detector
+ //
+
+ if (fUseDictionaries == kFALSE) {
+ return 0x0;
+ }
+
+ return (AliTRDdataArray *) fDictionary[i]->At(det);
+
+}
+
+//_____________________________________________________________________________
+Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
+{
+ //
+ // Returns the MC-track numbers from the dictionary for a given digit
+ //
+
+ Int_t row = Digit->GetRow();
+ Int_t col = Digit->GetCol();
+ Int_t time = Digit->GetTime();
+ Int_t det = Digit->GetDetector();
+
+ return GetTrack(track,row,col,time,det);
+
+}
+
+//_____________________________________________________________________________
+AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
+{
+ //
+ // Returns indexes of active pads
+ //
+
+ return (AliTRDSignalIndex *) fSignalIndexes->At(det);
+
+}
+
+//_____________________________________________________________________________
+void AliTRDdigitsManager::RemoveDigits(Int_t det)
+{
+ //
+ // Clear memory
+ //
+
+ 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
+ //
+
+ ((AliTRDSignalIndex *) fSignalIndexes->At(det))->ClearAll();
}
+//_____________________________________________________________________________
+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;
+ AliTRDdataArrayDigits *digits = 0x0;
+
+ if (fHasSDigits) {
+ return kFALSE;
+ }
+ else {
+ digits = (AliTRDdataArrayDigits *) GetDigits(det);
+ }
+
+ //digits should be expanded by now!!!
+ if (digits->GetNtime() > 0) {
+
+ digits->Expand();
+ nRows = digits->GetNrow();
+ nCols = digits->GetNcol();
+ nTbins = digits->GetNtime();
+
+ AliTRDSignalIndex *indexes = GetIndexes(det);
+ indexes->SetSM(geom.GetSector(det));
+ indexes->SetStack(geom.GetStack(det));
+ indexes->SetLayer(geom.GetLayer(det));
+ indexes->SetDetNumber(det);
+
+ if (indexes->IsAllocated() == kFALSE) {
+ indexes->Allocate(nRows,nCols,nTbins);
+ }
+
+ for (Int_t ir = 0; ir < nRows; ir++) {
+ for (Int_t ic = 0; ic < nCols; ic++) {
+ for (Int_t it = 0; it < nTbins; it++) {
+
+ Int_t isig = digits->GetDataUnchecked(ir,ic,it);
+ if (isig > 0) {
+ indexes->AddIndexTBin(ir,ic,it);
+ }
+ } // tbins
+ } // cols
+ } // rows
+
+ } // if GetNtime
+ else {
+ return kFALSE;
+ }
+
+ return kTRUE;
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff