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

  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;
  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->SetChamber(geom.GetChamber(det));
    indexes->SetPlane(geom.GetPlane(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	{
	232	//
	233	// Returns the pad status for the requested pad
	234	//
	235
	236	if(!GetDigits(det)){
	237	return 0;
	238	}
	239
	240	return ((UChar_t)((AliTRDdataArrayDigits *) GetDigits(det))->GetPadStatus(row, col, time));
	241	}
	242
6f1e466d	243	//_____________________________________________________________________________
88cb7938	244	Bool_t AliTRDdigitsManager::MakeBranch(TTree *tree)
855bfffd	245	{
	246	//
	247	// Creates the tree and branches for the digits and the dictionary
	248	//
	249
	250	Int_t buffersize = 64000;
	251
	252	Bool_t status = kTRUE;
	253
855bfffd	254	if (tree) {
	255	fTree = tree;
	256	}
	257
abaf1f1d	258	// Make the branch for the digits
	259	if (fDigits) {
	260	const AliTRDdataArray kDigits = (AliTRDdataArray ) fDigits->At(0);
	261	if (kDigits) {
bdbb05bb	262	if (!fTree) return kFALSE;
bdbb05bb	263	TBranch* branch = fTree->GetBranch("TRDdigits");
625f5260	264	if (!branch) fTree->Branch("TRDdigits",kDigits->IsA()->GetName()
625f5260	265	,&kDigits,buffersize,99);
2745a409	266	AliDebug(1,"Making branch TRDdigits\n");
6f1e466d	267	}
	268	else {
	269	status = kFALSE;
	270	}
abaf1f1d	271	}
	272	else {
	273	status = kFALSE;
	274	}
6f1e466d	275
625f5260	276	if (fUseDictionaries) {
	277	// Make the branches for the dictionaries
	278	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	279	Char_t branchname[15];
	280	sprintf(branchname,"TRDdictionary%d",iDict);
	281	if (fDictionary[iDict]) {
	282	const AliTRDdataArray *kDictionary =
	283	(AliTRDdataArray *) fDictionary[iDict]->At(0);
	284	if (kDictionary) {
	285	if (!fTree) return kFALSE;
	286	TBranch* branch = fTree->GetBranch(branchname);
	287	if (!branch) fTree->Branch(branchname,kDictionary->IsA()->GetName()
	288	,&kDictionary,buffersize,99);
	289	AliDebug(1,Form("Making branch %s\n",branchname));
001be664	290	}
	291	else {
	292	status = kFALSE;
	293	}
6f1e466d	294	}
625f5260	295	else {
	296	status = kFALSE;
	297	}
abaf1f1d	298	}
625f5260	299	}
6f1e466d	300
	301	return status;
	302
	303	}
	304
	305	//_____________________________________________________________________________
855bfffd	306	Bool_t AliTRDdigitsManager::ReadDigits(TTree *tree)
6f1e466d	307	{
8230f242	308	//
	309	// Reads the digit information from the input file
	310	//
6f1e466d	311
	312	Bool_t status = kTRUE;
	313
855bfffd	314	if (tree) {
855bfffd	315	fTree = tree;
abaf1f1d	316	}
	317
	318	if (!fDigits) {
2745a409	319	AliDebug(1,"Create the data arrays.\n");
abaf1f1d	320	CreateArrays();
	321	}
	322
	323	status = fDigits->LoadArray("TRDdigits",fTree);
6f1e466d	324
625f5260	325	if (fUseDictionaries) {
	326	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	327	Char_t branchname[15];
	328	sprintf(branchname,"TRDdictionary%d",iDict);
	329	status = fDictionary[iDict]->LoadArray(branchname,fTree);
	330	if (status == kFALSE) {
	331	fUseDictionaries = kFALSE;
	332	AliWarning("Unable to load dict arrays. Will not use them.\n");
	333	break;
	334	}
	335	}
6f1e466d	336	}
	337
	338	return kTRUE;
	339
	340	}
	341
	342	//_____________________________________________________________________________
	343	Bool_t AliTRDdigitsManager::WriteDigits()
	344	{
	345	//
	346	// Writes out the TRD-digits and the dictionaries
	347	//
	348
6f1e466d	349	// Store the contents of the segment array in the tree
abaf1f1d	350	if (!fDigits->StoreArray("TRDdigits",fTree)) {
2745a409	351	AliError("Error while storing digits in branch TRDdigits\n");
6f1e466d	352	return kFALSE;
6f1e466d	353	}
001be664	354
625f5260	355	if (fUseDictionaries) {
	356	for (Int_t iDict = 0; iDict < kNDict; iDict++) {
	357	Char_t branchname[15];
	358	sprintf(branchname,"TRDdictionary%d",iDict);
	359	if (!fDictionary[iDict]->StoreArray(branchname,fTree)) {
	360	AliError(Form("Error while storing dictionary in branch %s\n",branchname));
	361	return kFALSE;
001be664	362	}
6f1e466d	363	}
625f5260	364	}
6f1e466d	365
abaf1f1d	366	// Write the new tree to the output file
8e64dd77	367	fTree->AutoSave(); // Modification by Jiri
abaf1f1d	368
6f1e466d	369	return kTRUE;
	370
	371	}
9d0b222b	372
	373	//_____________________________________________________________________________
	374	AliTRDdigit *AliTRDdigitsManager::GetDigit(Int_t row, Int_t col
793ff80c	375	, Int_t time, Int_t det) const
9d0b222b	376	{
	377	//
	378	// Creates a single digit object
	379	//
	380
	381	Int_t digits[4];
	382	Int_t amp[1];
	383
	384	digits[0] = det;
	385	digits[1] = row;
	386	digits[2] = col;
	387	digits[3] = time;
	388
f5375dcb	389	amp[0] = ((AliTRDdataArrayDigits *) GetDigits(det))->GetData(row,col,time);
9d0b222b	390
625f5260	391	return (new AliTRDdigit(digits,amp));
9d0b222b	392
	393	}
	394
	395	//_____________________________________________________________________________
	396	Int_t AliTRDdigitsManager::GetTrack(Int_t track
	397	, Int_t row, Int_t col, Int_t time
793ff80c	398	, Int_t det) const
9d0b222b	399	{
	400	//
	401	// Returns the MC-track numbers from the dictionary.
	402	//
	403
	404	if ((track < 0) \|\| (track >= kNDict)) {
2745a409	405	AliError(Form("track %d out of bounds (size: %d, this: 0x%08x)"
2745a409	406	,track,kNDict,this));
9d0b222b	407	return -1;
	408	}
	409
625f5260	410	if (fUseDictionaries == kFALSE) {
	411	return -1;
	412	}
	413
9d0b222b	414	// Array contains index+1 to allow data compression
625f5260	415	return (((AliTRDdataArrayI *) GetDictionary(det,track))->GetData(row,col,time) - 1);
9d0b222b	416
	417	}
	418
dd9a6ee3	419	//_____________________________________________________________________________
f5375dcb	420	AliTRDdataArrayDigits *AliTRDdigitsManager::GetDigits(Int_t det) const
dd9a6ee3	421	{
	422	//
	423	// Returns the digits array for one detector
	424	//
	425
625f5260	426	if (!fDigits) {
	427	return 0x0;
	428	}
	429
f5375dcb	430	return (AliTRDdataArrayDigits *) fDigits->At(det);
dd9a6ee3	431
	432	}
	433
	434	//_____________________________________________________________________________
625f5260	435	AliTRDdataArray *AliTRDdigitsManager::GetDictionary(Int_t det, Int_t i) const
dd9a6ee3	436	{
	437	//
	438	// Returns the dictionary for one detector
	439	//
	440
625f5260	441	if (fUseDictionaries == kFALSE) {
	442	return 0x0;
	443	}
	444
	445	return (AliTRDdataArray *) fDictionary[i]->At(det);
dd9a6ee3	446
	447	}
	448
	449	//_____________________________________________________________________________
793ff80c	450	Int_t AliTRDdigitsManager::GetTrack(Int_t track, AliTRDdigit *Digit) const
dd9a6ee3	451	{
	452	//
	453	// Returns the MC-track numbers from the dictionary for a given digit
	454	//
	455
	456	Int_t row = Digit->GetRow();
	457	Int_t col = Digit->GetCol();
	458	Int_t time = Digit->GetTime();
	459	Int_t det = Digit->GetDetector();
	460
	461	return GetTrack(track,row,col,time,det);
	462
	463	}
ca21baaa	464
	465	//_____________________________________________________________________________
	466	AliTRDSignalIndex *AliTRDdigitsManager::GetIndexes(Int_t det)
	467	{
	468	//
	469	// Returns indexes of active pads
	470	//
	471
625f5260	472	return (AliTRDSignalIndex *) fSignalIndexes->At(det);
ca21baaa	473
	474	}
	475
	476	//_____________________________________________________________________________
	477	void AliTRDdigitsManager::RemoveDigits(Int_t det)
	478	{
	479	//
	480	// Clear memory
	481	//
	482
	483	fDigits->ClearSegment(det);
	484
	485	}
	486
	487	//_____________________________________________________________________________
	488	void AliTRDdigitsManager::RemoveDictionaries(Int_t det)
	489	{
	490	//
	491	// Clear memory
	492	//
625f5260	493
	494	if (fUseDictionaries == kFALSE) {
	495	return;
	496	}
ca21baaa	497
	498	for (Int_t i = 0; i < kNDict; i++) {
	499	fDictionary[i]->ClearSegment(det);
	500	}
	501
	502	}
	503
	504	//_____________________________________________________________________________
	505	void AliTRDdigitsManager::ClearIndexes(Int_t det)
	506	{
	507	//
	508	// Clear memory
	509	//
625f5260	510
ca21baaa	511	fSignalIndexes->At(det)->Clear();
ca21baaa	512
625f5260	513	}
ca21baaa	514
	515	//_____________________________________________________________________________
	516	Bool_t AliTRDdigitsManager::BuildIndexes(Int_t det)
	517	{
	518	//
	519	// Build the list of indices
	520	//
	521
	522	Int_t nRows = 0;
	523	Int_t nCols = 0;
	524	Int_t nTbins = 0;
	525
	526	AliTRDgeometry geom;
f5375dcb	527	AliTRDdataArrayDigits *digits = 0x0;
625f5260	528
	529	if (fHasSDigits) {
	530	return kFALSE;
	531	}
	532	else {
f5375dcb	533	digits = (AliTRDdataArrayDigits *) GetDigits(det);
625f5260	534	}
625f5260	535
ca21baaa	536	//digits should be expanded by now!!!
625f5260	537	if (digits->GetNtime() > 0) {
	538
	539	digits->Expand();
	540	nRows = digits->GetNrow();
	541	nCols = digits->GetNcol();
	542	nTbins = digits->GetNtime();
	543
	544	AliTRDSignalIndex *indexes = GetIndexes(det);
	545	indexes->SetSM(geom.GetSector(det));
	546	indexes->SetChamber(geom.GetChamber(det));
	547	indexes->SetPlane(geom.GetPlane(det));
	548	indexes->SetDetNumber(det);
	549
	550	if (indexes->IsAllocated() == kFALSE) {
	551	indexes->Allocate(nRows,nCols,nTbins);
ca21baaa	552	}
625f5260	553
	554	for (Int_t ir = 0; ir < nRows; ir++) {
	555	for (Int_t ic = 0; ic < nCols; ic++) {
	556	for (Int_t it = 0; it < nTbins; it++) {
	557
	558	Int_t isig = digits->GetDataUnchecked(ir,ic,it);
	559	if (isig > 0) {
	560	indexes->AddIndexTBin(ir,ic,it);
	561	}
	562	} // tbins
	563	} // cols
	564	} // rows
	565
	566	} // if GetNtime
	567	else {
	568	return kFALSE;
	569	}
	570
ca21baaa	571	return kTRUE;
	572
	573	}