[u/mrichter/AliRoot.git] / TRD / AliTRDdigitsManager.cxx

/**************************************************************************
 * 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$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Manages the digits and the track dictionary in the form of               //
//  AliTRDdataArray objects.                                                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <Riostream.h>
 
#include <TROOT.h>
#include <TTree.h>                                                              
#include <TFile.h>

#include "AliRun.h"
#include "AliLog.h"

#include "AliTRDdigitsManager.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)

//_____________________________________________________________________________

  // 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
  //

  for (Int_t iDict = 0; iDict < kNDict; iDict++) {
    fDictionary[iDict] = NULL;
  }
  
  fSignalIndexes = new TObjArray(AliTRDgeometry::Ndet());
  
}

//_____________________________________________________________________________
AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
  :TObject(m)
  ,fEvent(m.fEvent)
  ,fTree(0)
  ,fDigits(0)
  ,fHasSDigits(m.fHasSDigits)
  ,fSignalIndexes(NULL)
  ,fUseDictionaries(kTRUE)
{
  //
  // AliTRDdigitsManager copy constructor
  //

}

//_____________________________________________________________________________
AliTRDdigitsManager::~AliTRDdigitsManager()
{
  //
  // AliTRDdigitsManager destructor
  //

  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;
  }

}

//_____________________________________________________________________________
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
  //

  ((AliTRDdigitsManager &) m).fEvent           = fEvent;
  ((AliTRDdigitsManager &) m).fHasSDigits      = fHasSDigits;
  
  ((AliTRDdigitsManager &) m).fSignalIndexes   = fSignalIndexes;
  ((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;

  TObject::Copy(m);

}

//_____________________________________________________________________________
void AliTRDdigitsManager::CreateArrays()
{
  //
  // Create the data arrays
  //

  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());
  }

}

//_____________________________________________________________________________
void AliTRDdigitsManager::ResetArrays()
{
  //
  // 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 (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 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;
      }
    }
  }

  return status;

}

//_____________________________________________________________________________
Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
{
  //
  // Reads the digit information from the input file
  //

  Bool_t status = kTRUE;

  if (tree) {
    fTree = tree;
  }

  if (!fDigits) {
    AliDebug(1,"Create the data arrays.\n");
    CreateArrays();
  }

  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;

}

//_____________________________________________________________________________
Bool_t AliTRDdigitsManager::WriteDigits()
{
  //
  // Writes out the TRD-digits and the dictionaries
  //

  // Store the contents of the segment array in the tree
  if (!fDigits->StoreArray("TRDdigits",fTree)) {
    AliError("Error while storing digits in branch TRDdigits\n");
    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) const
{
  // 
  // Creates a single digit object 
  //

  Int_t digits[4];
  Int_t amp[1];

  digits[0] = det;
  digits[1] = row;
  digits[2] = col;
  digits[3] = time;

  amp[0]    = ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time);
  
  return (new AliTRDdigit(digits,amp));

}

//_____________________________________________________________________________
Int_t AliTRDdigitsManager::GetTrack(Int_t track
                                  , Int_t row, Int_t col, Int_t time
                                  , Int_t det) const
{
  // 
  // Returns the MC-track numbers from the dictionary.
  //

  if ((track < 0) || (track >= kNDict)) {
    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 (((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;

}
Commit	Line	Data
6f1e466d	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
88cb7938	16	/* $Id$ */
6f1e466d	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Manages the digits and the track dictionary in the form of //
	21	// AliTRDdataArray objects. //
	22	// //
	23	///////////////////////////////////////////////////////////////////////////////
6244debe	24
a2cb5b3d	25	#include <Riostream.h>
793ff80c	26
2ab0c725	27	#include <TROOT.h>
793ff80c	28	#include <TTree.h>
2ab0c725	29	#include <TFile.h>
94de3818	30
6f1e466d	31	#include "AliRun.h"
2745a409	32	#include "AliLog.h"
6f1e466d	33
6f1e466d	34	#include "AliTRDdigitsManager.h"
793ff80c	35	#include "AliTRDsegmentArray.h"
625f5260	36	#include "AliTRDdataArray.h"
793ff80c	37	#include "AliTRDdataArrayI.h"
625f5260	38	#include "AliTRDdataArrayS.h"
f5375dcb	39	#include "AliTRDdataArrayDigits.h"
793ff80c	40	#include "AliTRDdigit.h"
793ff80c	41	#include "AliTRDgeometry.h"
6f1e466d	42
ca21baaa	43	#include "AliTRDSignalIndex.h"
ca21baaa	44
6f1e466d	45	ClassImp(AliTRDdigitsManager)
6f1e466d	46
793ff80c	47	//_____________________________________________________________________________
	48
	49	// Number of track dictionary arrays
	50	const Int_t AliTRDdigitsManager::fgkNDict = kNDict;
	51
6f1e466d	52	//_____________________________________________________________________________
2745a409	53	AliTRDdigitsManager::AliTRDdigitsManager()
	54	:TObject()
	55	,fEvent(0)
	56	,fTree(0)
	57	,fDigits(0)
625f5260	58	,fHasSDigits(0)
ca21baaa	59	,fSignalIndexes(NULL)
001be664	60	,fUseDictionaries(kTRUE)
6f1e466d	61	{
	62	//
	63	// Default constructor
	64	//
	65
6f1e466d	66	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
abaf1f1d	67	fDictionary[iDict] = NULL;
6f1e466d	68	}
ca21baaa	69
ca21baaa	70	fSignalIndexes = new TObjArray(AliTRDgeometry::Ndet());
ca21baaa	71
6f1e466d	72	}
6f1e466d	73
8230f242	74	//_____________________________________________________________________________
dd9a6ee3	75	AliTRDdigitsManager::AliTRDdigitsManager(const AliTRDdigitsManager &m)
2745a409	76	:TObject(m)
	77	,fEvent(m.fEvent)
	78	,fTree(0)
	79	,fDigits(0)
625f5260	80	,fHasSDigits(m.fHasSDigits)
ca21baaa	81	,fSignalIndexes(NULL)
001be664	82	,fUseDictionaries(kTRUE)
8230f242	83	{
	84	//
	85	// AliTRDdigitsManager copy constructor
	86	//
	87
8230f242	88	}
8230f242	89
6f1e466d	90	//_____________________________________________________________________________
	91	AliTRDdigitsManager::~AliTRDdigitsManager()
	92	{
8230f242	93	//
	94	// AliTRDdigitsManager destructor
	95	//
6f1e466d	96
	97	if (fDigits) {
	98	fDigits->Delete();
	99	delete fDigits;
625f5260	100	fDigits = NULL;
6f1e466d	101	}
	102
	103	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	104	fDictionary[iDict]->Delete();
	105	delete fDictionary[iDict];
abaf1f1d	106	fDictionary[iDict] = NULL;
6f1e466d	107	}
6f1e466d	108
c0ab62ff	109	if (fSignalIndexes) {
	110	fSignalIndexes->Delete();
	111	delete fSignalIndexes;
625f5260	112	fSignalIndexes = NULL;
c0ab62ff	113	}
ca21baaa	114
6f1e466d	115	}
6f1e466d	116
2745a409	117	//_____________________________________________________________________________
	118	AliTRDdigitsManager &AliTRDdigitsManager::operator=(const AliTRDdigitsManager &m)
	119	{
	120	//
	121	// Assignment operator
	122	//
	123
625f5260	124	if (this != &m) {
	125	((AliTRDdigitsManager &) m).Copy(*this);
	126	}
	127
2745a409	128	return *this;
	129
	130	}
	131
8230f242	132	//_____________________________________________________________________________
e0d47c25	133	void AliTRDdigitsManager::Copy(TObject &m) const
8230f242	134	{
	135	//
	136	// Copy function
	137	//
	138
625f5260	139	((AliTRDdigitsManager &) m).fEvent = fEvent;
625f5260	140	((AliTRDdigitsManager &) m).fHasSDigits = fHasSDigits;
ca21baaa	141
625f5260	142	((AliTRDdigitsManager &) m).fSignalIndexes = fSignalIndexes;
001be664	143	((AliTRDdigitsManager &) m).fUseDictionaries = fUseDictionaries;
001be664	144
8230f242	145	TObject::Copy(m);
	146
	147	}
	148
abaf1f1d	149	//_____________________________________________________________________________
	150	void AliTRDdigitsManager::CreateArrays()
	151	{
	152	//
	153	// Create the data arrays
	154	//
	155
625f5260	156	if (fHasSDigits) {
	157	fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
	158	}
	159	else {
f5375dcb	160	fDigits = new AliTRDsegmentArray("AliTRDdataArrayDigits",AliTRDgeometry::Ndet());
625f5260	161	}
abaf1f1d	162
625f5260	163	if (fUseDictionaries) {
	164	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	165	fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
	166	,AliTRDgeometry::Ndet());
001be664	167	}
625f5260	168	}
	169
	170	for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++) {
	171	fSignalIndexes->AddLast(new AliTRDSignalIndex());
	172	}
abaf1f1d	173
17eee78a	174	}
625f5260	175
17eee78a	176	//_____________________________________________________________________________
	177	void AliTRDdigitsManager::ResetArrays()
	178	{
	179	//
	180	// Reset the data arrays
	181	//
	182
	183	if (fDigits) {
c0ab62ff	184	fDigits->Delete();
17eee78a	185	delete fDigits;
17eee78a	186	}
625f5260	187	if (fHasSDigits) {
	188	fDigits = new AliTRDsegmentArray("AliTRDdataArrayF",AliTRDgeometry::Ndet());
	189	}
	190	else {
	191	fDigits = new AliTRDsegmentArray("AliTRDdataArrayS",AliTRDgeometry::Ndet());
	192	}
17eee78a	193
625f5260	194	if (fUseDictionaries) {
	195	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	196	if (fDictionary[iDict]) {
	197	fDictionary[iDict]->Delete();
	198	delete fDictionary[iDict];
001be664	199	}
625f5260	200	fDictionary[iDict] = new AliTRDsegmentArray("AliTRDdataArrayI"
625f5260	201	,AliTRDgeometry::Ndet());
17eee78a	202	}
625f5260	203	}
17eee78a	204
625f5260	205	for (Int_t i = 0; i < AliTRDgeometry::Ndet(); i++) {
	206	AliTRDSignalIndex idx = (AliTRDSignalIndex )fSignalIndexes->At(i);
	207	if (idx) idx->Reset();
	208	}
6f1e466d	209
6f1e466d	210	}
6f1e466d	211
16bf9884	212	//_____________________________________________________________________________
	213	Short_t AliTRDdigitsManager::GetDigitAmp(Int_t row, Int_t col,Int_t time
	214	, Int_t det) const
	215	{
	216	//
	217	// Returns the amplitude of a digit
	218	//
	219
625f5260	220	if (!GetDigits(det)) {
	221	return 0;
	222	}
	223
f5375dcb	224	return ((Short_t) ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time));
16bf9884	225
	226	}
	227
d739fd4e	228	//_____________________________________________________________________________
	229	UChar_t AliTRDdigitsManager::GetPadStatus(Int_t row, Int_t col, Int_t time
	230	, Int_t det) const
	231	{
c10bf383	232	//
	233	// Returns the pad status for the requested pad
	234	//
d739fd4e	235
c10bf383	236	if (!GetDigits(det)) {
	237	return 0;
	238	}
	239
	240	return ((UChar_t) ((AliTRDdataArrayDigits *) GetDigits(det))->GetPadStatus(row,col,time));
d739fd4e	241
d739fd4e	242	}
d739fd4e	243
6f1e466d	244	//_____________________________________________________________________________
88cb7938	245	Bool_t AliTRDdigitsManager::MakeBranch(TTree *tree)
855bfffd	246	{
	247	//
	248	// Creates the tree and branches for the digits and the dictionary
	249	//
	250
	251	Int_t buffersize = 64000;
	252
	253	Bool_t status = kTRUE;
	254
855bfffd	255	if (tree) {
	256	fTree = tree;
	257	}
	258
abaf1f1d	259	// Make the branch for the digits
	260	if (fDigits) {
	261	const AliTRDdataArray kDigits = (AliTRDdataArray ) fDigits->At(0);
	262	if (kDigits) {
bdbb05bb	263	if (!fTree) return kFALSE;
bdbb05bb	264	TBranch* branch = fTree->GetBranch("TRDdigits");
625f5260	265	if (!branch) fTree->Branch("TRDdigits",kDigits->IsA()->GetName()
625f5260	266	,&kDigits,buffersize,99);
2745a409	267	AliDebug(1,"Making branch TRDdigits\n");
6f1e466d	268	}
	269	else {
	270	status = kFALSE;
	271	}
abaf1f1d	272	}
	273	else {
	274	status = kFALSE;
	275	}
6f1e466d	276
625f5260	277	if (fUseDictionaries) {
	278	// Make the branches for the dictionaries
	279	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	280	Char_t branchname[15];
	281	sprintf(branchname,"TRDdictionary%d",iDict);
	282	if (fDictionary[iDict]) {
	283	const AliTRDdataArray *kDictionary =
	284	(AliTRDdataArray *) fDictionary[iDict]->At(0);
	285	if (kDictionary) {
	286	if (!fTree) return kFALSE;
	287	TBranch* branch = fTree->GetBranch(branchname);
	288	if (!branch) fTree->Branch(branchname,kDictionary->IsA()->GetName()
	289	,&kDictionary,buffersize,99);
	290	AliDebug(1,Form("Making branch %s\n",branchname));
001be664	291	}
	292	else {
	293	status = kFALSE;
	294	}
6f1e466d	295	}
625f5260	296	else {
	297	status = kFALSE;
	298	}
abaf1f1d	299	}
625f5260	300	}
6f1e466d	301
	302	return status;
	303
	304	}
	305
	306	//_____________________________________________________________________________
855bfffd	307	Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
6f1e466d	308	{
8230f242	309	//
	310	// Reads the digit information from the input file
	311	//
6f1e466d	312
	313	Bool_t status = kTRUE;
	314
855bfffd	315	if (tree) {
855bfffd	316	fTree = tree;
abaf1f1d	317	}
	318
	319	if (!fDigits) {
2745a409	320	AliDebug(1,"Create the data arrays.\n");
abaf1f1d	321	CreateArrays();
	322	}
	323
	324	status = fDigits->LoadArray("TRDdigits",fTree);
6f1e466d	325
625f5260	326	if (fUseDictionaries) {
	327	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	328	Char_t branchname[15];
	329	sprintf(branchname,"TRDdictionary%d",iDict);
	330	status = fDictionary[iDict]->LoadArray(branchname,fTree);
	331	if (status == kFALSE) {
	332	fUseDictionaries = kFALSE;
	333	AliWarning("Unable to load dict arrays. Will not use them.\n");
	334	break;
	335	}
	336	}
6f1e466d	337	}
	338
	339	return kTRUE;
	340
	341	}
	342
	343	//_____________________________________________________________________________
	344	Bool_t AliTRDdigitsManager::WriteDigits()
	345	{
	346	//
	347	// Writes out the TRD-digits and the dictionaries
	348	//
	349
6f1e466d	350	// Store the contents of the segment array in the tree
abaf1f1d	351	if (!fDigits->StoreArray("TRDdigits",fTree)) {
2745a409	352	AliError("Error while storing digits in branch TRDdigits\n");
6f1e466d	353	return kFALSE;
6f1e466d	354	}
001be664	355
625f5260	356	if (fUseDictionaries) {
	357	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	358	Char_t branchname[15];
	359	sprintf(branchname,"TRDdictionary%d",iDict);
	360	if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
	361	AliError(Form("Error while storing dictionary in branch %s\n",branchname));
	362	return kFALSE;
001be664	363	}
6f1e466d	364	}
625f5260	365	}
6f1e466d	366
abaf1f1d	367	// Write the new tree to the output file
8e64dd77	368	fTree->AutoSave(); // Modification by Jiri
abaf1f1d	369
6f1e466d	370	return kTRUE;
	371
	372	}
9d0b222b	373
	374	//_____________________________________________________________________________
	375	AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
793ff80c	376	, Int_t time, Int_t det) const
9d0b222b	377	{
	378	//
	379	// Creates a single digit object
	380	//
	381
	382	Int_t digits[4];
	383	Int_t amp[1];
	384
	385	digits[0] = det;
	386	digits[1] = row;
	387	digits[2] = col;
	388	digits[3] = time;
	389
f5375dcb	390	amp[0] = ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time);
9d0b222b	391
625f5260	392	return (new AliTRDdigit(digits,amp));
9d0b222b	393
	394	}
	395
	396	//_____________________________________________________________________________
	397	Int_t AliTRDdigitsManager::GetTrack(Int_t track
	398	, Int_t row, Int_t col, Int_t time
793ff80c	399	, Int_t det) const
9d0b222b	400	{
	401	//
	402	// Returns the MC-track numbers from the dictionary.
	403	//
	404
	405	if ((track < 0) \|\| (track >= kNDict)) {
2745a409	406	AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)"
2745a409	407	,track,kNDict,this));
9d0b222b	408	return -1;
	409	}
	410
625f5260	411	if (fUseDictionaries == kFALSE) {
	412	return -1;
	413	}
	414
9d0b222b	415	// Array contains index+1 to allow data compression
625f5260	416	return (((AliTRDdataArrayI *) GetDictionary(det,track))->GetData(row,col,time) - 1);
9d0b222b	417
	418	}
	419
dd9a6ee3	420	//_____________________________________________________________________________
f5375dcb	421	AliTRDdataArrayDigits *AliTRDdigitsManager::GetDigits(Int_t det) const
dd9a6ee3	422	{
	423	//
	424	// Returns the digits array for one detector
	425	//
	426
625f5260	427	if (!fDigits) {
	428	return 0x0;
	429	}
	430
f5375dcb	431	return (AliTRDdataArrayDigits *) fDigits->At(det);
dd9a6ee3	432
	433	}
	434
	435	//_____________________________________________________________________________
625f5260	436	AliTRDdataArray *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
dd9a6ee3	437	{
	438	//
	439	// Returns the dictionary for one detector
	440	//
	441
625f5260	442	if (fUseDictionaries == kFALSE) {
	443	return 0x0;
	444	}
	445
	446	return (AliTRDdataArray *) fDictionary[i]->At(det);
dd9a6ee3	447
	448	}
	449
	450	//_____________________________________________________________________________
793ff80c	451	Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
dd9a6ee3	452	{
	453	//
	454	// Returns the MC-track numbers from the dictionary for a given digit
	455	//
	456
	457	Int_t row = Digit->GetRow();
	458	Int_t col = Digit->GetCol();
	459	Int_t time = Digit->GetTime();
	460	Int_t det = Digit->GetDetector();
	461
	462	return GetTrack(track,row,col,time,det);
	463
	464	}
ca21baaa	465
	466	//_____________________________________________________________________________
	467	AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
	468	{
	469	//
	470	// Returns indexes of active pads
	471	//
	472
625f5260	473	return (AliTRDSignalIndex *) fSignalIndexes->At(det);
ca21baaa	474
	475	}
	476
	477	//_____________________________________________________________________________
	478	void AliTRDdigitsManager::RemoveDigits(Int_t det)
	479	{
	480	//
	481	// Clear memory
	482	//
	483
	484	fDigits->ClearSegment(det);
	485
	486	}
	487
	488	//_____________________________________________________________________________
	489	void AliTRDdigitsManager::RemoveDictionaries(Int_t det)
	490	{
	491	//
	492	// Clear memory
	493	//
625f5260	494
	495	if (fUseDictionaries == kFALSE) {
	496	return;
	497	}
ca21baaa	498
	499	for (Int_t i = 0; i < kNDict; i++) {
	500	fDictionary[i]->ClearSegment(det);
	501	}
	502
	503	}
	504
	505	//_____________________________________________________________________________
	506	void AliTRDdigitsManager::ClearIndexes(Int_t det)
	507	{
	508	//
	509	// Clear memory
	510	//
625f5260	511
c10bf383	512	((AliTRDSignalIndex *) fSignalIndexes->At(det))->ClearAll();
ca21baaa	513
625f5260	514	}
ca21baaa	515
	516	//_____________________________________________________________________________
	517	Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
	518	{
	519	//
	520	// Build the list of indices
	521	//
	522
	523	Int_t nRows = 0;
	524	Int_t nCols = 0;
	525	Int_t nTbins = 0;
	526
	527	AliTRDgeometry geom;
f5375dcb	528	AliTRDdataArrayDigits *digits = 0x0;
625f5260	529
	530	if (fHasSDigits) {
	531	return kFALSE;
	532	}
	533	else {
f5375dcb	534	digits = (AliTRDdataArrayDigits *) GetDigits(det);
625f5260	535	}
625f5260	536
ca21baaa	537	//digits should be expanded by now!!!
625f5260	538	if (digits->GetNtime() > 0) {
	539
	540	digits->Expand();
	541	nRows = digits->GetNrow();
	542	nCols = digits->GetNcol();
	543	nTbins = digits->GetNtime();
	544
	545	AliTRDSignalIndex *indexes = GetIndexes(det);
	546	indexes->SetSM(geom.GetSector(det));
053767a4	547	indexes->SetStack(geom.GetStack(det));
053767a4	548	indexes->SetLayer(geom.GetLayer(det));
625f5260	549	indexes->SetDetNumber(det);
	550
	551	if (indexes->IsAllocated() == kFALSE) {
	552	indexes->Allocate(nRows,nCols,nTbins);
ca21baaa	553	}
625f5260	554
	555	for (Int_t ir = 0; ir < nRows; ir++) {
	556	for (Int_t ic = 0; ic < nCols; ic++) {
	557	for (Int_t it = 0; it < nTbins; it++) {
	558
	559	Int_t isig = digits->GetDataUnchecked(ir,ic,it);
	560	if (isig > 0) {
	561	indexes->AddIndexTBin(ir,ic,it);
	562	}
	563	} // tbins
	564	} // cols
	565	} // rows
	566
	567	} // if GetNtime
	568	else {
	569	return kFALSE;
	570	}
	571
ca21baaa	572	return kTRUE;
	573
	574	}