[u/mrichter/AliRoot.git] / EVE / EveDet / AliEveTOFDigitsInfo.cxx

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

//
// Class to map TOF digit/raw data information
//
// Author: A. De Caro (email: decaro@sa.infn.it)
//

#include <TClonesArray.h>
#include <TTree.h>

//#include <TEveTreeTools.h>

#include <AliDAQ.h>
#include <AliLog.h>
#include <AliRawReader.h>

#include <AliTOFCableLengthMap.h>
#include <AliTOFdigit.h>
#include <AliTOFGeometry.h>
#include <AliTOFrawData.h>
#include <AliTOFRawStream.h>
#include <AliTOFDigitMap.h>

#include "AliEveTOFDigitsInfo.h"

//_________________________________________________________

ClassImp(AliEveTOFDigitsInfo)

  AliEveTOFDigitsInfo::AliEveTOFDigitsInfo(): 
    TObject(),
    TEveRefCnt(),
    fTree (0),
    fNewTree (0),
    fGeom (new AliTOFGeometry()),
    fTOFdigitMap(new AliTOFDigitMap())
{}
/* ******************************************************* */

AliEveTOFDigitsInfo:: ~AliEveTOFDigitsInfo() 
{
  //dtr

  delete fGeom;
  delete fTree;
  delete fNewTree;
  delete fTOFdigitMap;

}
/* ******************************************************* */

void AliEveTOFDigitsInfo::SetTree(TTree * const tree)
{
  //
  // Set fTree global variable
  //

  static const TEveException kEH("AliEveTOFDigitsInfo::SetTree ");
  
  if(fGeom == 0) {
    fGeom = new AliTOFGeometry();
  }

  fTree = tree;
  /*
  DecRefCount();
  IncRefCount();
  */
}
/* ******************************************************* */
void AliEveTOFDigitsInfo::ReadRaw(AliRawReader* rawReader, Bool_t newDecoder)
{
  //
  // Read raw-data. AliTOFdigit is used to
  // store raw-adata for all sub-detectors.
  //

  AliTOFCableLengthMap *cableLength = new AliTOFCableLengthMap();

  //ofstream ftxt;
  //Char_t fileName[100];
  //sprintf(fileName,"TOFrawDataReadingFromEVE%d.txt",nEvent);

  //ftxt.open(fileName,ios::app);
  //ftxt << endl;
  //ftxt << "  " << nEvent << endl;

  //if (nEvent<0) printf("%3i\n", nEvent); // only to use nEvent variable

  const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");

  TClonesArray *tofDigits = new TClonesArray("AliTOFdigit",10000);
  fTree = new TTree();
  fTree->Branch("TOF", &tofDigits, 32000);
  fTree->GetEntry(0);

  TClonesArray * clonesRawData = 0x0;

  Int_t detectorIndex[5];
  Int_t digit[4];

  AliTOFRawStream stream(rawReader);

  for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++) {

    rawReader->Reset();
    if (!newDecoder) stream.LoadRawData(indexDDL);
    else stream.LoadRawDataBuffers(indexDDL);

    clonesRawData = (TClonesArray*)stream.GetRawData();

    if (clonesRawData->GetEntriesFast()) AliDebug(2, Form(" Number of TOF digits in the sector number %2i: %5i", indexDDL, clonesRawData->GetEntriesFast()));

    for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {

      AliTOFrawData *tofRawDatum = (AliTOFrawData*)clonesRawData->UncheckedAt(iRawData);

      if (tofRawDatum->GetTOF()==-1) continue;

      Int_t cLenInt = Int_t(cableLength->GetCableTimeShift(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),tofRawDatum->GetTDC())*1000./AliTOFGeometry::TdcBinWidth());
      digit[0] = tofRawDatum->GetTOF() - cLenInt;
      digit[1] = tofRawDatum->GetTOT();
      digit[2] = tofRawDatum->GetTOT();
      digit[3] = -1;

      /*
      if (indexDDL<10) ftxt << "  " << indexDDL;
      else             ftxt << " " << indexDDL;
      if (tofRawDatum->GetTRM()<10) ftxt << "  " << tofRawDatum->GetTRM();
      else                          ftxt << " " << tofRawDatum->GetTRM();
      ftxt << "  " << tofRawDatum->GetTRMchain();
      if (tofRawDatum->GetTDC()<10) ftxt << "  " << tofRawDatum->GetTDC();
      else                          ftxt << " " << tofRawDatum->GetTDC();
      ftxt << "  " << tofRawDatum->GetTDCchannel();
      */

      stream.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
				  tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);

      if (detectorIndex[0]==0 || detectorIndex[0]==10)
	AliDebug(2, Form(" %2i %2i %1i %2i %1i --- %2i %1i %2i %1i %2i     %5i -  %4i =  %5i (%f ns)\n",
			 indexDDL,
			 tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
			 tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(),
			 detectorIndex[0], detectorIndex[1],
			 detectorIndex[2], detectorIndex[3],
			 detectorIndex[4], tofRawDatum->GetTOF(),
			 cLenInt, tofRawDatum->GetTOF()-cLenInt,
			 (tofRawDatum->GetTOF()-cLenInt)*
			 AliTOFGeometry::TdcBinWidth()/1000.));

      /*
      if (detectorIndex[0]<10) ftxt  << "  ->  " << detectorIndex[0];
      else                     ftxt  << "  -> " << detectorIndex[0];
      ftxt << "  " << detectorIndex[1];
      if (detectorIndex[2]<10) ftxt << "  " << detectorIndex[2];
      else                     ftxt << " " << detectorIndex[2];
      ftxt << "  " << detectorIndex[3];
      if (detectorIndex[4]<10) ftxt << "  " << detectorIndex[4];
      else                     ftxt << " " << detectorIndex[4];

      if (tofRawDatum->GetTOT()<10)                                            ftxt << "        " << tofRawDatum->GetTOT();
      else if (tofRawDatum->GetTOT()>=10 && tofRawDatum->GetTOT()<100)         ftxt << "       " << tofRawDatum->GetTOT();
      else if (tofRawDatum->GetTOT()>=100 && tofRawDatum->GetTOT()<1000)       ftxt << "      " << tofRawDatum->GetTOT();
      else if (tofRawDatum->GetTOT()>=1000 && tofRawDatum->GetTOT()<10000)     ftxt << "     " << tofRawDatum->GetTOT();
      else if (tofRawDatum->GetTOT()>=10000 && tofRawDatum->GetTOT()<100000)   ftxt << "    " << tofRawDatum->GetTOT();
      else if (tofRawDatum->GetTOT()>=100000 && tofRawDatum->GetTOT()<1000000) ftxt << "   " << tofRawDatum->GetTOT();
      else                                                                     ftxt << "  " << tofRawDatum->GetTOT();
      if (tofRawDatum->GetTOF()<10)                                            ftxt << "        " << tofRawDatum->GetTOF() << endl;
      else if (tofRawDatum->GetTOF()>=10 && tofRawDatum->GetTOF()<100)         ftxt << "       " << tofRawDatum->GetTOF() << endl;
      else if (tofRawDatum->GetTOF()>=100 && tofRawDatum->GetTOF()<1000)       ftxt << "      " << tofRawDatum->GetTOF() << endl;
      else if (tofRawDatum->GetTOF()>=1000 && tofRawDatum->GetTOF()<10000)     ftxt << "     " << tofRawDatum->GetTOF() << endl;
      else if (tofRawDatum->GetTOF()>=10000 && tofRawDatum->GetTOF()<100000)   ftxt << "    " << tofRawDatum->GetTOF() << endl;
      else if (tofRawDatum->GetTOF()>=100000 && tofRawDatum->GetTOF()<1000000) ftxt << "   " << tofRawDatum->GetTOF() << endl;
      else                                                                     ftxt << "  " << tofRawDatum->GetTOF() << endl;
      */

      TClonesArray &aDigits = *tofDigits;
      Int_t last = tofDigits->GetEntriesFast();

      fTOFdigitMap->AddDigit(detectorIndex, last);

      AliDebug(2,Form(" %3i -> %2i %2i %2i %2i %2i   %i  %i\n",
		      last, detectorIndex[0], detectorIndex[1],
		      detectorIndex[2], detectorIndex[4], detectorIndex[3],
		      digit[1], digit[0]));

      Int_t tracknum[3]={-1,-1,-1};
      new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);

    } // while loop

    clonesRawData->Clear();

  } // DDL Loop

  fTree->Fill();

  //ftxt.close();

  delete cableLength;

}


/* ******************************************************* */
void AliEveTOFDigitsInfo::LoadDigits()
{
  //
  // Load TOF digits
  //

  TClonesArray *digitsTOF = 0x0;
  AliTOFdigit *digs;

  fTree->SetBranchAddress("TOF",&digitsTOF);
  fTree->GetEntry(0);

  Int_t vol[5] = {-1,-1,-1,-1,-1};

  for (Int_t digitNumber=0; digitNumber<digitsTOF->GetEntries(); digitNumber++) {

    if (digitNumber==digitsTOF->GetEntries()-1)
      AliDebug(2,Form(" Hello  4 -> %3i digit of %i \n", digitNumber+1, digitsTOF->GetEntries()));

    digs = (AliTOFdigit*)digitsTOF->UncheckedAt(digitNumber);

    vol[0] = digs->GetSector(); // Sector Number (0-17)
    vol[1] = digs->GetPlate();  // Plate Number (0-4)
    vol[2] = digs->GetStrip();  // Strip Number (0-14/18)
    vol[3] = digs->GetPadx();   // Pad Number in x direction (0-47)
    vol[4] = digs->GetPadz();   // Pad Number in z direction (0-1)

    fTOFdigitMap->AddDigit(vol, digitNumber);
    if (digitNumber==digitsTOF->GetEntries()-1)
      AliDebug(2,Form(" I am inside LoadDigits %3i \n", digitNumber));

  }

}

/* ******************************************************* */

void AliEveTOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
				    Int_t nStrip, Int_t nPadZ, Int_t nPadX,
				    Int_t indexDigit[3])
{
  //
  // Get TOF digit indices in the TOF volume
  // (nSector, nPlate,nStrip,nPadZ,nPadX)
  //

  Int_t vol[5] = {nSector,nPlate,nStrip,nPadX,nPadZ};

  fTOFdigitMap->GetDigitIndex(vol, indexDigit);
  //for (Int_t ii=1; ii<3; ii++) indexDigit[ii]=-1;

}
/* ******************************************************* */

TClonesArray* AliEveTOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
					     Int_t nStrip)
{
  //
  // Get TOF digits in the TOF volume
  // (nSector, nPlate,nStrip)
  //

  Int_t newCounter = 0;
  Int_t nDigitsInVolume[3] = {-1, -1, -1};
  Int_t dummy[3] = {-1, -1, -1};
  Int_t informations[4] = {-1, -1, -1, -1};

  TClonesArray* digitsTOFnew = new TClonesArray("AliTOFdigit",  300);
  TClonesArray &ldigits = *digitsTOFnew;

  AliTOFdigit *digs;

  TClonesArray *digitsTOF = 0x0;
  fTree->SetBranchAddress("TOF",&digitsTOF);
  fTree->GetEntry(0);

  Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};

  for(Int_t iPadZ=0; iPadZ<fGeom->NpadZ(); iPadZ++){
    vol[4] = iPadZ;
    for(Int_t iPadX=0; iPadX<fGeom->NpadX(); iPadX++) {
      vol[3] = iPadX;

      fTOFdigitMap->GetDigitIndex(vol, nDigitsInVolume);

      for (Int_t ii=0; ii<3; ii++) {
	//if (ii!=0) continue;
	if (nDigitsInVolume[ii]>=0 ) {
	  AliDebug(2,Form("  nDigitsInVolume[%2i]  = %3i\n ", ii, nDigitsInVolume[ii]));
	  digs = (AliTOFdigit*)digitsTOF->UncheckedAt(nDigitsInVolume[ii]);
	  informations[0] = digs->GetTdc();
	  informations[1] = digs->GetAdc();
	  informations[2] = digs->GetToT();
	  informations[3] = digs->GetTdcND();
	  for(Int_t kk=0; kk<3; kk++) dummy[kk] = digs->GetTrack(kk);
	  new (ldigits[newCounter++]) AliTOFdigit(dummy, vol, informations);
	}

      }

      for (Int_t ii=0; ii<4; ii++) informations[ii]=-1;
      for (Int_t ii=0; ii<3; ii++) dummy[ii]=-1;
      for (Int_t ii=0; ii<3; ii++) nDigitsInVolume[ii]=-1;

    }
  }

  if (digitsTOFnew)
    AliDebug(2, Form("Sector %2i   Plate %1i  Strip %2i  -> number of digits %3i \n",
		     nSector, nPlate, nStrip, digitsTOFnew->GetEntries()));

  return digitsTOFnew;

}
/* ******************************************************* */

TClonesArray* AliEveTOFDigitsInfo::GetDigits(Int_t nSector)
{
  //
  // Get TOF digits in the TOF SM nSector
  //

  const Int_t kND = AliTOFDigitMap::kMaxDigitsPerPad;

  Int_t newCounter = 0;
  Int_t nDigitsInVolume[kND];
  Int_t dummy[3];
  Int_t informations[4];

  Int_t nStrips=19;

  TClonesArray* digitsTOFnew = new TClonesArray("AliTOFdigit",  300);
  TClonesArray &ldigits = *digitsTOFnew;

  AliTOFdigit *digs;

  TClonesArray *digitsTOF = 0x0;
  fTree->SetBranchAddress("TOF",&digitsTOF);
  fTree->GetEntry(0);

  //Int_t nSector = 1;
  Int_t vol[5] = {nSector,-1,-1,-1,-1};
 
  for(Int_t iPlate=0; iPlate<fGeom->NPlates(); iPlate++){
    vol[1] = iPlate;
    if(iPlate==2) nStrips=15;
    else nStrips=19;

    for(Int_t iStrip=0; iStrip<nStrips; iStrip++){
      vol[2] = iStrip;

      for(Int_t iPadZ=0; iPadZ<fGeom->NpadZ(); iPadZ++){
	vol[4] = iPadZ;

	for(Int_t iPadX=0; iPadX<fGeom->NpadX(); iPadX++) {

	  for (Int_t ii=0; ii<4; ii++) informations[ii]=-1;
	  for (Int_t ii=0; ii<3; ii++) dummy[ii]=-1;
	  for (Int_t ii=0; ii<kND; ii++) nDigitsInVolume[ii]=-1;

	  vol[3] = iPadX;

	  fTOFdigitMap->GetDigitIndex(vol, nDigitsInVolume);

	  for (Int_t ii=0; ii<kND; ii++) {
	    //if (ii!=0) continue;
	    if (nDigitsInVolume[ii]>=0 ) {

	      digs = (AliTOFdigit*)digitsTOF->UncheckedAt(nDigitsInVolume[ii]);
	      informations[0] = digs->GetTdc();
	      informations[1] = digs->GetAdc();
	      informations[2] = digs->GetToT();
	      informations[3] = digs->GetTdcND();
	      for(Int_t kk=0; kk<3; kk++) dummy[kk] = digs->GetTrack(kk);
	      new (ldigits[newCounter++]) AliTOFdigit(dummy, vol, informations);

	      AliDebug(2,Form(" %2i -> %2i %2i %2i %2i %2i %7i %7i\n",
			      nDigitsInVolume[ii],
			      vol[0], vol[1], vol[2], vol[4], vol[3],
			      informations[1], informations[0]));

	    }

	  }

	}
      }
    }
  }

  if (digitsTOFnew)
    AliDebug(2,Form("Sector %2i  -> number of digits %3i \n",
		    nSector, digitsTOFnew->GetEntries()));

  return digitsTOFnew;

}
/* ******************************************************* */

Int_t AliEveTOFDigitsInfo::GetTOFInfos() const
{
  //
  // Return number of TOF digits
  //

  return fTOFdigitMap->GetFilledCellNumber();

}

/* ******************************************************* */
Int_t AliEveTOFDigitsInfo::IsStripFilled(Int_t iSector, Int_t iPlate, Int_t iStrip)
{
  //
  // Return number of TOF digits
  // in volume (iSector,iPlate,iStrip)
  //

  Int_t vol[5] = {iSector, iPlate, iStrip, -1, -1};

  Int_t index = 0;

  for (Int_t iPadZ=0; iPadZ<fGeom->NpadZ(); iPadZ++) 
    for (Int_t iPadX=0; iPadX<fGeom->NpadX(); iPadX++) 
      {
	vol[3] = iPadX;
	vol[4] = iPadZ;
	if (fTOFdigitMap->GetDigitIndex(vol,0)>=0) index++;
      }

  return index;

}

/* ******************************************************* */
/*
void AliEveTOFDigitsInfo::GetDigits()
{

  for (Int_t iSector=0; iSector<fGeom->NSectors(); iSector++) {

    fNewTree = new TTree();


  }

}
*/
Commit	Line	Data
d810d0de	1	/**************************************************************************
	2	* Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
	3	* See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for *
51346b82	4	* full copyright notice. *
d810d0de	5	**************************************************************************/
fd54c9e3	6
	7	// $Id$
	8	// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
	9
8616d353	10	//
fd54c9e3	11	// Class to map TOF digit/raw data information
	12	//
	13	// Author: A. De Caro (email: decaro@sa.infn.it)
8616d353	14	//
8616d353	15
fd54c9e3	16	#include <TClonesArray.h>
fd54c9e3	17	#include <TTree.h>
8616d353	18
fd54c9e3	19	//#include <TEveTreeTools.h>
ee9d8eca	20
ee9d8eca	21	#include <AliDAQ.h>
fd54c9e3	22	#include <AliLog.h>
fd54c9e3	23	#include <AliRawReader.h>
ee9d8eca	24
545d5001	25	#include <AliTOFCableLengthMap.h>
8616d353	26	#include <AliTOFdigit.h>
28a21457	27	#include <AliTOFGeometry.h>
ee9d8eca	28	#include <AliTOFrawData.h>
ee9d8eca	29	#include <AliTOFRawStream.h>
fd54c9e3	30	#include <AliTOFDigitMap.h>
	31
	32	#include "AliEveTOFDigitsInfo.h"
8616d353	33
	34	//_________________________________________________________
	35
d810d0de	36	ClassImp(AliEveTOFDigitsInfo)
8616d353	37
ee9d8eca	38	AliEveTOFDigitsInfo::AliEveTOFDigitsInfo():
8616d353	39	TObject(),
84aff7a4	40	TEveRefCnt(),
8616d353	41	fTree (0),
8616d353	42	fNewTree (0),
545d5001	43	fGeom (new AliTOFGeometry()),
8616d353	44	fTOFdigitMap(new AliTOFDigitMap())
	45	{}
	46	/* ******************************************************* */
	47
ee9d8eca	48	AliEveTOFDigitsInfo:: ~AliEveTOFDigitsInfo()
8616d353	49	{
fd54c9e3	50	//dtr
8616d353	51
	52	delete fGeom;
	53	delete fTree;
	54	delete fNewTree;
	55	delete fTOFdigitMap;
	56
	57	}
	58	/* ******************************************************* */
	59
fd54c9e3	60	void AliEveTOFDigitsInfo::SetTree(TTree * const tree)
8616d353	61	{
fd54c9e3	62	//
	63	// Set fTree global variable
	64	//
	65
a15e6d7d	66	static const TEveException kEH("AliEveTOFDigitsInfo::SetTree ");
ee9d8eca	67
8616d353	68	if(fGeom == 0) {
28a21457	69	fGeom = new AliTOFGeometry();
8616d353	70	}
51346b82	71
8616d353	72	fTree = tree;
	73	/*
	74	DecRefCount();
	75	IncRefCount();
	76	*/
	77	}
	78	/* ******************************************************* */
82dabae7	79	void AliEveTOFDigitsInfo::ReadRaw(AliRawReader* rawReader, Bool_t newDecoder)
ee9d8eca	80	{
fd54c9e3	81	//
ee9d8eca	82	// Read raw-data. AliTOFdigit is used to
ee9d8eca	83	// store raw-adata for all sub-detectors.
fd54c9e3	84	//
ee9d8eca	85
545d5001	86	AliTOFCableLengthMap *cableLength = new AliTOFCableLengthMap();
545d5001	87
ee9d8eca	88	//ofstream ftxt;
	89	//Char_t fileName[100];
	90	//sprintf(fileName,"TOFrawDataReadingFromEVE%d.txt",nEvent);
	91
	92	//ftxt.open(fileName,ios::app);
	93	//ftxt << endl;
	94	//ftxt << " " << nEvent << endl;
	95
82dabae7	96	//if (nEvent<0) printf("%3i\n", nEvent); // only to use nEvent variable
d12dcb66	97
ee9d8eca	98	const Int_t kDDL = AliDAQ::NumberOfDdls("TOF");
	99
	100	TClonesArray *tofDigits = new TClonesArray("AliTOFdigit",10000);
	101	fTree = new TTree();
39590252	102	fTree->Branch("TOF", &tofDigits, 32000);
ee9d8eca	103	fTree->GetEntry(0);
	104
	105	TClonesArray * clonesRawData = 0x0;
	106
	107	Int_t detectorIndex[5];
	108	Int_t digit[4];
	109
	110	AliTOFRawStream stream(rawReader);
	111
	112	for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++) {
	113
	114	rawReader->Reset();
06b27cbf	115	if (!newDecoder) stream.LoadRawData(indexDDL);
06b27cbf	116	else stream.LoadRawDataBuffers(indexDDL);
ee9d8eca	117
	118	clonesRawData = (TClonesArray*)stream.GetRawData();
	119
49409e0e	120	if (clonesRawData->GetEntriesFast()) AliDebug(2, Form(" Number of TOF digits in the sector number %2i: %5i", indexDDL, clonesRawData->GetEntriesFast()));
06b27cbf	121
ee9d8eca	122	for (Int_t iRawData = 0; iRawData<clonesRawData->GetEntriesFast(); iRawData++) {
	123
	124	AliTOFrawData tofRawDatum = (AliTOFrawData)clonesRawData->UncheckedAt(iRawData);
	125
82dabae7	126	if (tofRawDatum->GetTOF()==-1) continue;
ee9d8eca	127
545d5001	128	Int_t cLenInt = Int_t(cableLength->GetCableTimeShift(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),tofRawDatum->GetTDC())*1000./AliTOFGeometry::TdcBinWidth());
545d5001	129	digit[0] = tofRawDatum->GetTOF() - cLenInt;
ee9d8eca	130	digit[1] = tofRawDatum->GetTOT();
	131	digit[2] = tofRawDatum->GetTOT();
	132	digit[3] = -1;
06b27cbf	133
ee9d8eca	134	/*
	135	if (indexDDL<10) ftxt << " " << indexDDL;
	136	else ftxt << " " << indexDDL;
	137	if (tofRawDatum->GetTRM()<10) ftxt << " " << tofRawDatum->GetTRM();
	138	else ftxt << " " << tofRawDatum->GetTRM();
	139	ftxt << " " << tofRawDatum->GetTRMchain();
	140	if (tofRawDatum->GetTDC()<10) ftxt << " " << tofRawDatum->GetTDC();
	141	else ftxt << " " << tofRawDatum->GetTDC();
	142	ftxt << " " << tofRawDatum->GetTDCchannel();
	143	*/
82dabae7	144
ee9d8eca	145	stream.EquipmentId2VolumeId(indexDDL, tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
06b27cbf	146	tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(), detectorIndex);
545d5001	147
	148	if (detectorIndex[0]==0 \|\| detectorIndex[0]==10)
	149	AliDebug(2, Form(" %2i %2i %1i %2i %1i --- %2i %1i %2i %1i %2i %5i - %4i = %5i (%f ns)\n",
	150	indexDDL,
	151	tofRawDatum->GetTRM(), tofRawDatum->GetTRMchain(),
	152	tofRawDatum->GetTDC(), tofRawDatum->GetTDCchannel(),
	153	detectorIndex[0], detectorIndex[1],
	154	detectorIndex[2], detectorIndex[3],
	155	detectorIndex[4], tofRawDatum->GetTOF(),
	156	cLenInt, tofRawDatum->GetTOF()-cLenInt,
	157	(tofRawDatum->GetTOF()-cLenInt)*
	158	AliTOFGeometry::TdcBinWidth()/1000.));
	159
ee9d8eca	160	/*
	161	if (detectorIndex[0]<10) ftxt << " -> " << detectorIndex[0];
	162	else ftxt << " -> " << detectorIndex[0];
	163	ftxt << " " << detectorIndex[1];
	164	if (detectorIndex[2]<10) ftxt << " " << detectorIndex[2];
	165	else ftxt << " " << detectorIndex[2];
	166	ftxt << " " << detectorIndex[3];
	167	if (detectorIndex[4]<10) ftxt << " " << detectorIndex[4];
	168	else ftxt << " " << detectorIndex[4];
	169
	170	if (tofRawDatum->GetTOT()<10) ftxt << " " << tofRawDatum->GetTOT();
	171	else if (tofRawDatum->GetTOT()>=10 && tofRawDatum->GetTOT()<100) ftxt << " " << tofRawDatum->GetTOT();
	172	else if (tofRawDatum->GetTOT()>=100 && tofRawDatum->GetTOT()<1000) ftxt << " " << tofRawDatum->GetTOT();
	173	else if (tofRawDatum->GetTOT()>=1000 && tofRawDatum->GetTOT()<10000) ftxt << " " << tofRawDatum->GetTOT();
	174	else if (tofRawDatum->GetTOT()>=10000 && tofRawDatum->GetTOT()<100000) ftxt << " " << tofRawDatum->GetTOT();
	175	else if (tofRawDatum->GetTOT()>=100000 && tofRawDatum->GetTOT()<1000000) ftxt << " " << tofRawDatum->GetTOT();
	176	else ftxt << " " << tofRawDatum->GetTOT();
	177	if (tofRawDatum->GetTOF()<10) ftxt << " " << tofRawDatum->GetTOF() << endl;
	178	else if (tofRawDatum->GetTOF()>=10 && tofRawDatum->GetTOF()<100) ftxt << " " << tofRawDatum->GetTOF() << endl;
	179	else if (tofRawDatum->GetTOF()>=100 && tofRawDatum->GetTOF()<1000) ftxt << " " << tofRawDatum->GetTOF() << endl;
	180	else if (tofRawDatum->GetTOF()>=1000 && tofRawDatum->GetTOF()<10000) ftxt << " " << tofRawDatum->GetTOF() << endl;
	181	else if (tofRawDatum->GetTOF()>=10000 && tofRawDatum->GetTOF()<100000) ftxt << " " << tofRawDatum->GetTOF() << endl;
	182	else if (tofRawDatum->GetTOF()>=100000 && tofRawDatum->GetTOF()<1000000) ftxt << " " << tofRawDatum->GetTOF() << endl;
	183	else ftxt << " " << tofRawDatum->GetTOF() << endl;
	184	*/
	185
	186	TClonesArray &aDigits = *tofDigits;
	187	Int_t last = tofDigits->GetEntriesFast();
	188
	189	fTOFdigitMap->AddDigit(detectorIndex, last);
	190
	191	AliDebug(2,Form(" %3i -> %2i %2i %2i %2i %2i %i %i\n",
39590252	192	last, detectorIndex[0], detectorIndex[1],
39590252	193	detectorIndex[2], detectorIndex[4], detectorIndex[3],
ee9d8eca	194	digit[1], digit[0]));
	195
	196	Int_t tracknum[3]={-1,-1,-1};
	197	new (aDigits[last]) AliTOFdigit(tracknum, detectorIndex, digit);
	198
	199	} // while loop
	200
	201	clonesRawData->Clear();
	202
	203	} // DDL Loop
	204
	205	fTree->Fill();
	206
	207	//ftxt.close();
8616d353	208
545d5001	209	delete cableLength;
545d5001	210
ee9d8eca	211	}
ee9d8eca	212
06b27cbf	213
ee9d8eca	214	/* ******************************************************* */
d810d0de	215	void AliEveTOFDigitsInfo::LoadDigits()
8616d353	216	{
fd54c9e3	217	//
	218	// Load TOF digits
	219	//
8616d353	220
	221	TClonesArray *digitsTOF = 0x0;
	222	AliTOFdigit *digs;
	223
	224	fTree->SetBranchAddress("TOF",&digitsTOF);
	225	fTree->GetEntry(0);
	226
	227	Int_t vol[5] = {-1,-1,-1,-1,-1};
	228
	229	for (Int_t digitNumber=0; digitNumber<digitsTOF->GetEntries(); digitNumber++) {
	230
39590252	231	if (digitNumber==digitsTOF->GetEntries()-1)
39590252	232	AliDebug(2,Form(" Hello 4 -> %3i digit of %i \n", digitNumber+1, digitsTOF->GetEntries()));
51346b82	233
8616d353	234	digs = (AliTOFdigit*)digitsTOF->UncheckedAt(digitNumber);
	235
	236	vol[0] = digs->GetSector(); // Sector Number (0-17)
	237	vol[1] = digs->GetPlate(); // Plate Number (0-4)
	238	vol[2] = digs->GetStrip(); // Strip Number (0-14/18)
ee9d8eca	239	vol[3] = digs->GetPadx(); // Pad Number in x direction (0-47)
ee9d8eca	240	vol[4] = digs->GetPadz(); // Pad Number in z direction (0-1)
8616d353	241
8616d353	242	fTOFdigitMap->AddDigit(vol, digitNumber);
39590252	243	if (digitNumber==digitsTOF->GetEntries()-1)
39590252	244	AliDebug(2,Form(" I am inside LoadDigits %3i \n", digitNumber));
8616d353	245
	246	}
	247
	248	}
	249
	250	/* ******************************************************* */
	251
d810d0de	252	void AliEveTOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
39590252	253	Int_t nStrip, Int_t nPadZ, Int_t nPadX,
39590252	254	Int_t indexDigit[3])
8616d353	255	{
fd54c9e3	256	//
	257	// Get TOF digit indices in the TOF volume
	258	// (nSector, nPlate,nStrip,nPadZ,nPadX)
	259	//
8616d353	260
	261	Int_t vol[5] = {nSector,nPlate,nStrip,nPadX,nPadZ};
	262
	263	fTOFdigitMap->GetDigitIndex(vol, indexDigit);
545d5001	264	//for (Int_t ii=1; ii<3; ii++) indexDigit[ii]=-1;
8616d353	265
	266	}
	267	/* ******************************************************* */
	268
d810d0de	269	TClonesArray* AliEveTOFDigitsInfo::GetDigits(Int_t nSector, Int_t nPlate,
39590252	270	Int_t nStrip)
8616d353	271	{
fd54c9e3	272	//
	273	// Get TOF digits in the TOF volume
	274	// (nSector, nPlate,nStrip)
	275	//
8616d353	276
	277	Int_t newCounter = 0;
	278	Int_t nDigitsInVolume[3] = {-1, -1, -1};
	279	Int_t dummy[3] = {-1, -1, -1};
	280	Int_t informations[4] = {-1, -1, -1, -1};
	281
	282	TClonesArray* digitsTOFnew = new TClonesArray("AliTOFdigit", 300);
	283	TClonesArray &ldigits = *digitsTOFnew;
	284
	285	AliTOFdigit *digs;
	286
	287	TClonesArray *digitsTOF = 0x0;
	288	fTree->SetBranchAddress("TOF",&digitsTOF);
	289	fTree->GetEntry(0);
	290
8616d353	291	Int_t vol[5] = {nSector,nPlate,nStrip,-1,-1};
	292
	293	for(Int_t iPadZ=0; iPadZ<fGeom->NpadZ(); iPadZ++){
	294	vol[4] = iPadZ;
	295	for(Int_t iPadX=0; iPadX<fGeom->NpadX(); iPadX++) {
	296	vol[3] = iPadX;
	297
8616d353	298	fTOFdigitMap->GetDigitIndex(vol, nDigitsInVolume);
	299
	300	for (Int_t ii=0; ii<3; ii++) {
545d5001	301	//if (ii!=0) continue;
8616d353	302	if (nDigitsInVolume[ii]>=0 ) {
39590252	303	AliDebug(2,Form(" nDigitsInVolume[%2i] = %3i\n ", ii, nDigitsInVolume[ii]));
8616d353	304	digs = (AliTOFdigit*)digitsTOF->UncheckedAt(nDigitsInVolume[ii]);
	305	informations[0] = digs->GetTdc();
	306	informations[1] = digs->GetAdc();
	307	informations[2] = digs->GetToT();
	308	informations[3] = digs->GetTdcND();
82dabae7	309	for(Int_t kk=0; kk<3; kk++) dummy[kk] = digs->GetTrack(kk);
8616d353	310	new (ldigits[newCounter++]) AliTOFdigit(dummy, vol, informations);
	311	}
	312
	313	}
	314
	315	for (Int_t ii=0; ii<4; ii++) informations[ii]=-1;
	316	for (Int_t ii=0; ii<3; ii++) dummy[ii]=-1;
	317	for (Int_t ii=0; ii<3; ii++) nDigitsInVolume[ii]=-1;
	318
	319	}
	320	}
	321
8616d353	322	if (digitsTOFnew)
545d5001	323	AliDebug(2, Form("Sector %2i Plate %1i Strip %2i -> number of digits %3i \n",
545d5001	324	nSector, nPlate, nStrip, digitsTOFnew->GetEntries()));
39590252	325
8616d353	326	return digitsTOFnew;
	327
	328	}
	329	/* ******************************************************* */
	330
d810d0de	331	TClonesArray* AliEveTOFDigitsInfo::GetDigits(Int_t nSector)
8616d353	332	{
fd54c9e3	333	//
	334	// Get TOF digits in the TOF SM nSector
	335	//
	336
2dc6d650	337	const Int_t kND = AliTOFDigitMap::kMaxDigitsPerPad;
8616d353	338
8616d353	339	Int_t newCounter = 0;
2dc6d650	340	Int_t nDigitsInVolume[kND];
	341	Int_t dummy[3];
	342	Int_t informations[4];
8616d353	343
	344	Int_t nStrips=19;
	345
	346	TClonesArray* digitsTOFnew = new TClonesArray("AliTOFdigit", 300);
	347	TClonesArray &ldigits = *digitsTOFnew;
	348
	349	AliTOFdigit *digs;
	350
	351	TClonesArray *digitsTOF = 0x0;
	352	fTree->SetBranchAddress("TOF",&digitsTOF);
	353	fTree->GetEntry(0);
	354
	355	//Int_t nSector = 1;
	356	Int_t vol[5] = {nSector,-1,-1,-1,-1};
ee9d8eca	357
8616d353	358	for(Int_t iPlate=0; iPlate<fGeom->NPlates(); iPlate++){
	359	vol[1] = iPlate;
	360	if(iPlate==2) nStrips=15;
	361	else nStrips=19;
51346b82	362
8616d353	363	for(Int_t iStrip=0; iStrip<nStrips; iStrip++){
8616d353	364	vol[2] = iStrip;
51346b82	365
8616d353	366	for(Int_t iPadZ=0; iPadZ<fGeom->NpadZ(); iPadZ++){
	367	vol[4] = iPadZ;
	368
	369	for(Int_t iPadX=0; iPadX<fGeom->NpadX(); iPadX++) {
2dc6d650	370
	371	for (Int_t ii=0; ii<4; ii++) informations[ii]=-1;
	372	for (Int_t ii=0; ii<3; ii++) dummy[ii]=-1;
	373	for (Int_t ii=0; ii<kND; ii++) nDigitsInVolume[ii]=-1;
	374
8616d353	375	vol[3] = iPadX;
8616d353	376
8616d353	377	fTOFdigitMap->GetDigitIndex(vol, nDigitsInVolume);
8616d353	378
2dc6d650	379	for (Int_t ii=0; ii<kND; ii++) {
545d5001	380	//if (ii!=0) continue;
8616d353	381	if (nDigitsInVolume[ii]>=0 ) {
ee9d8eca	382
8616d353	383	digs = (AliTOFdigit*)digitsTOF->UncheckedAt(nDigitsInVolume[ii]);
	384	informations[0] = digs->GetTdc();
	385	informations[1] = digs->GetAdc();
	386	informations[2] = digs->GetToT();
	387	informations[3] = digs->GetTdcND();
82dabae7	388	for(Int_t kk=0; kk<3; kk++) dummy[kk] = digs->GetTrack(kk);
8616d353	389	new (ldigits[newCounter++]) AliTOFdigit(dummy, vol, informations);
ee9d8eca	390
ee9d8eca	391	AliDebug(2,Form(" %2i -> %2i %2i %2i %2i %2i %7i %7i\n",
545d5001	392	nDigitsInVolume[ii],
545d5001	393	vol[0], vol[1], vol[2], vol[4], vol[3],
39590252	394	informations[1], informations[0]));
ee9d8eca	395
8616d353	396	}
	397
	398	}
	399
8616d353	400	}
	401	}
	402	}
	403	}
	404
8616d353	405	if (digitsTOFnew)
39590252	406	AliDebug(2,Form("Sector %2i -> number of digits %3i \n",
	407	nSector, digitsTOFnew->GetEntries()));
	408
8616d353	409	return digitsTOFnew;
	410
	411	}
	412	/* ******************************************************* */
	413
ee9d8eca	414	Int_t AliEveTOFDigitsInfo::GetTOFInfos() const
ee9d8eca	415	{
fd54c9e3	416	//
	417	// Return number of TOF digits
	418	//
ee9d8eca	419
	420	return fTOFdigitMap->GetFilledCellNumber();
	421
	422	}
	423
	424	/* ******************************************************* */
	425	Int_t AliEveTOFDigitsInfo::IsStripFilled(Int_t iSector, Int_t iPlate, Int_t iStrip)
	426	{
fd54c9e3	427	//
	428	// Return number of TOF digits
	429	// in volume (iSector,iPlate,iStrip)
	430	//
ee9d8eca	431
	432	Int_t vol[5] = {iSector, iPlate, iStrip, -1, -1};
	433
	434	Int_t index = 0;
	435
	436	for (Int_t iPadZ=0; iPadZ<fGeom->NpadZ(); iPadZ++)
	437	for (Int_t iPadX=0; iPadX<fGeom->NpadX(); iPadX++)
	438	{
	439	vol[3] = iPadX;
	440	vol[4] = iPadZ;
	441	if (fTOFdigitMap->GetDigitIndex(vol,0)>=0) index++;
	442	}
	443
	444	return index;
	445
	446	}
	447
	448	/* ******************************************************* */
39590252	449	/*
d810d0de	450	void AliEveTOFDigitsInfo::GetDigits()
8616d353	451	{
	452
	453	for (Int_t iSector=0; iSector<fGeom->NSectors(); iSector++) {
	454
	455	fNewTree = new TTree();
	456
	457
	458
	459
	460	}
	461
	462	}
39590252	463	*/