[u/mrichter/AliRoot.git] / MFT / AliMFTDigitizer.cxx

/**************************************************************************
 * Copyright(c) 1998-2000, 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.                  *
 **************************************************************************/

//====================================================================================================================================================
//
//      Digitizer class for the ALICE Muon Forward Tracker
//
//      Contact author: antonio.uras@cern.ch
//
//====================================================================================================================================================

#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliDigitizationInput.h"
#include "AliLoader.h"
#include "AliLog.h"
#include "AliMFTDigitizer.h"
#include "AliMFTDigit.h"
#include "AliMFT.h"
#include "AliMFTSegmentation.h"
#include "TObjArray.h"
#include "TClonesArray.h"
#include "AliDigitizer.h"

ClassImp(AliMFTDigitizer)

//====================================================================================================================================================
    
AliMFTDigitizer::AliMFTDigitizer():
  AliDigitizer(),
  fNPlanes(0),
  fSegmentation(0)
{

  // default constructor 

}

//====================================================================================================================================================

AliMFTDigitizer::AliMFTDigitizer(AliDigitizationInput *digInp):
  AliDigitizer(digInp),
  fNPlanes(0),
  fSegmentation(0)
{

}

//====================================================================================================================================================

void AliMFTDigitizer::Digitize(Option_t*) {

  // This method is responsible for merging sdigits to a list of digits

  AliDebug(1, "************************************************************************");
  AliDebug(1, "************************ AliMFTDigitizer::Digitize *********************");
  AliDebug(1, "************************************************************************");
  
  if (!fSegmentation) {
    fSegmentation = new AliMFTSegmentation("AliMFTGeometry.root");
    fNPlanes = fSegmentation -> GetNPlanes();
  }

  AliDebug(1, Form("nPlanes = %d",fNPlanes));

  AliDebug(1,Form("Start with %i input(s) for event %i", fDigInput->GetNinputs(), fDigInput->GetOutputEventNr()));
    
  AliRunLoader *pInRunLoader=0;
  AliLoader    *pInMFTLoader=0;
  
  TClonesArray sDigits[fNMaxPlanes];
  for (Int_t iPlane=0; iPlane<fNMaxPlanes; iPlane++) sDigits[iPlane].SetClass("AliMFTDigit");  // tmp storage for sdigits sum up from all input files
  
  // filling the arrays of sdigits...

  for (Int_t iFile=0; iFile<fDigInput->GetNinputs(); iFile++) {
    
    pInRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(iFile));
    pInMFTLoader = pInRunLoader->GetLoader("MFTLoader"); 
    if (!pInMFTLoader) {
      AliDebug(1,"no MFT lodader, checking in the other input \n"); 
      continue;
    }
    
    if (!pInRunLoader->GetAliRun()) pInRunLoader->LoadgAlice();
    AliMFT *pInMFT = (AliMFT*) pInRunLoader->GetAliRun()->GetDetector("MFT"); 
    
    AliDebug(1, "pInMFTLoader->LoadSDigits()...");
    pInMFTLoader->LoadSDigits();
    AliDebug(1, "... done!");
    AliDebug(1, "    pInMFTLoader->TreeS()->GetEntry(0);");
    pInMFTLoader->TreeS()->GetEntry(0);
    AliDebug(1, "... done!");
    
    for (Int_t iPlane=0; iPlane<pInMFT->GetSDigitsList()->GetEntries(); iPlane++) {      
      for(Int_t iSDig=0; iSDig<((TClonesArray*)pInMFT->GetSDigitsList()->At(iPlane))->GetEntries(); iSDig++) {
	AliDebug(2, Form("Reading digit %03d of plane %02d (A)", iSDig, iPlane));
	AliMFTDigit *pSDig = (AliMFTDigit*) ((TClonesArray*)pInMFT->GetSDigitsList()->At(iPlane))->At(iSDig);
	AliDebug(2, Form("Reading digit %03d of plane %02d (B)", iSDig, iPlane));
	pSDig->AddOffset2TrackID(fDigInput->GetMask(iFile));   // -> To be introduced for merging (since all inputs count tracks independently from 0)
	AliDebug(2, Form("Reading digit %03d of plane %02d (C)", iSDig, iPlane));
	new ((sDigits[iPlane])[sDigits[iPlane].GetEntries()]) AliMFTDigit(*pSDig);  
	AliDebug(2, Form("Reading digit %03d of plane %02d (D)", iSDig, iPlane));
      }
    }
    
    pInMFTLoader->UnloadSDigits();   
    pInMFT->ResetSDigits();

  }
  
  AliRunLoader *pOutRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName());  // open output stream (only 1 possible)
  AliLoader    *pOutMFTLoader = pOutRunLoader->GetLoader("MFTLoader");                        
  AliRun       *pAliRun       = pOutRunLoader->GetAliRun();
  AliMFT       *pOutMFT       = (AliMFT*) pAliRun->GetDetector("MFT");      
  pOutMFTLoader->MakeTree("D");   
  pOutMFT->MakeBranch("D");
  pOutMFT->SetTreeAddress();
  
  SDigits2Digits(sDigits, pOutMFT->GetDigitsList());   // here the sdigits are merged into digits
  
  pOutMFTLoader->TreeD()->Fill();              // fill the output tree with the list of digits
  pOutMFTLoader->WriteDigits("OVERWRITE");     // serialize them to file
  
  for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) sDigits[iPlane].Clear();   // remove all tmp sdigits
  pOutMFTLoader->UnloadDigits();   
  pOutMFT->ResetDigits(); 

}

//====================================================================================================================================================

void AliMFTDigitizer::SDigits2Digits(TClonesArray *pSDigitList, TObjArray *pDigitList) {   

  TClonesArray *myDigitList[fNMaxPlanes] = {0};
 
  for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) { 
    myDigitList[iPlane] = (TClonesArray*)(*pDigitList)[iPlane];
    if (myDigitList[iPlane]->GetEntries()!=0) AliErrorClass("Some of digits lists is not empty");   // in principle those lists should be empty 
  }
   
  AliDebug(1,"starting loop over planes");
   
  for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
     
    AliMFTDigit *newDig=NULL;
    AliMFTDigit *oldDig=NULL;
    pSDigitList[iPlane].Sort();

    Int_t nDetElem = fSegmentation->GetPlane(iPlane)->GetNActiveElements();
    TClonesArray *digitsPerDetElem[fNMaxDetElemPerPlane] = {0};
    for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) digitsPerDetElem[iDetElem] = new TClonesArray("AliMFTDigit");

    AliDebug(1,"starting loop over sdigits to create digits");
    AliDebug(1, Form("MFT plane #%02d has %d SDigits", iPlane, Int_t(pSDigitList[iPlane].GetEntries())));

    for (Int_t iSDig=0; iSDig<pSDigitList[iPlane].GetEntries(); iSDig++) {

      newDig = (AliMFTDigit*) (pSDigitList[iPlane].At(iSDig));
      Int_t localDetElemID = fSegmentation->GetDetElemLocalID(newDig->GetDetElemID());
      Bool_t digitExists = kFALSE;
      Int_t nDigits = digitsPerDetElem[localDetElemID]->GetEntries();
      
      for (Int_t iDig=0; iDig<nDigits; iDig++) {
	oldDig = (AliMFTDigit*) (digitsPerDetElem[localDetElemID]->At(iDig));
	if (newDig->GetDetElemID()==oldDig->GetDetElemID() &&
	    newDig->GetPixelX()==oldDig->GetPixelX() &&
	    newDig->GetPixelY()==oldDig->GetPixelY() &&
	    newDig->GetPixelZ()==oldDig->GetPixelZ()) {
	  digitExists = kTRUE;
	  MergeDigits(oldDig, newDig);
	  break;
	}
      }
      
      if (!digitExists) new ((*digitsPerDetElem[localDetElemID])[digitsPerDetElem[localDetElemID]->GetEntries()]) AliMFTDigit(*newDig);

    }

    // Now we merge the digit lists coming from each detection element, to have an ordered final list

    for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) {
      for (Int_t iSDig=0; iSDig<digitsPerDetElem[iDetElem]->GetEntries(); iSDig++) {
	newDig = (AliMFTDigit*) (digitsPerDetElem[iDetElem]->At(iSDig));
	new ((*myDigitList[iPlane])[myDigitList[iPlane]->GetEntries()]) AliMFTDigit(*newDig);
      }
    }

    for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) delete digitsPerDetElem[iDetElem];
    
    AliDebug(1, Form("MFT plane #%02d has %d Digits", iPlane, Int_t(myDigitList[iPlane]->GetEntries())));
    
//     for (Int_t iDigit=0; iDigit<myDigitList[iPlane]->GetEntries(); iDigit++) {
//       AliDebug(1, Form("Digit %03d of MFT plane %02d has pixel coordinates (%05d, %05d)", 
// 		       iDigit, iPlane, ((AliMFTDigit*) myDigitList[iPlane]->At(iDigit))->GetPixelX(), ((AliMFTDigit*) myDigitList[iPlane]->At(iDigit))->GetPixelY()) );
//     }

    AliDebug(1, "ending loop over sdigits to create digits");

  }

  AliDebug(1,"ending loop over layers");  

}

//====================================================================================================================================================

void AliMFTDigitizer::MergeDigits(AliMFTDigit *mainDig, AliMFTDigit *digToSum) {
  
  mainDig -> SetEloss(mainDig->GetEloss() + digToSum->GetEloss());
  
  Bool_t trackExists = kFALSE;
  for (Int_t iTrack=0; iTrack<mainDig->GetNMCTracks(); iTrack++) {
    if (digToSum->GetMCLabel(0) == mainDig->GetMCLabel(iTrack)) {
      trackExists = kTRUE;
      break;
    }
  }
  
  if (!trackExists) mainDig->AddMCLabel(digToSum->GetMCLabel(0));
  
}

//====================================================================================================================================================
Commit	Line	Data
820b4d9e	1	/**************************************************************************
	2	* Copyright(c) 1998-2000, 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
	16	//====================================================================================================================================================
	17	//
	18	// Digitizer class for the ALICE Muon Forward Tracker
	19	//
	20	// Contact author: antonio.uras@cern.ch
	21	//
	22	//====================================================================================================================================================
	23
	24	#include "AliRun.h"
	25	#include "AliRunLoader.h"
f21fc003	26	#include "AliDigitizationInput.h"
820b4d9e	27	#include "AliLoader.h"
	28	#include "AliLog.h"
	29	#include "AliMFTDigitizer.h"
	30	#include "AliMFTDigit.h"
	31	#include "AliMFT.h"
	32	#include "AliMFTSegmentation.h"
	33	#include "TObjArray.h"
	34	#include "TClonesArray.h"
	35	#include "AliDigitizer.h"
	36
	37	ClassImp(AliMFTDigitizer)
	38
	39	//====================================================================================================================================================
	40
	41	AliMFTDigitizer::AliMFTDigitizer():
	42	AliDigitizer(),
	43	fNPlanes(0),
	44	fSegmentation(0)
	45	{
	46
	47	// default constructor
	48
	49	}
	50
	51	//====================================================================================================================================================
	52
d4643a10	53	AliMFTDigitizer::AliMFTDigitizer(AliDigitizationInput *digInp):
f21fc003	54	AliDigitizer(digInp),
820b4d9e	55	fNPlanes(0),
	56	fSegmentation(0)
	57	{
	58
	59	}
	60
	61	//====================================================================================================================================================
	62
f21fc003	63	void AliMFTDigitizer::Digitize(Option_t*) {
820b4d9e	64
	65	// This method is responsible for merging sdigits to a list of digits
	66
	67	AliDebug(1, "************************************************************************");
d4643a10	68	AliDebug(1, "********************** AliMFTDigitizer::Digitize *******************");
820b4d9e	69	AliDebug(1, "************************************************************************");
	70
	71	if (!fSegmentation) {
	72	fSegmentation = new AliMFTSegmentation("AliMFTGeometry.root");
	73	fNPlanes = fSegmentation -> GetNPlanes();
	74	}
	75
	76	AliDebug(1, Form("nPlanes = %d",fNPlanes));
	77
f21fc003	78	AliDebug(1,Form("Start with %i input(s) for event %i", fDigInput->GetNinputs(), fDigInput->GetOutputEventNr()));
820b4d9e	79
	80	AliRunLoader *pInRunLoader=0;
	81	AliLoader *pInMFTLoader=0;
	82
	83	TClonesArray sDigits[fNMaxPlanes];
	84	for (Int_t iPlane=0; iPlane<fNMaxPlanes; iPlane++) sDigits[iPlane].SetClass("AliMFTDigit"); // tmp storage for sdigits sum up from all input files
	85
	86	// filling the arrays of sdigits...
	87
f21fc003	88	for (Int_t iFile=0; iFile<fDigInput->GetNinputs(); iFile++) {
820b4d9e	89
f21fc003	90	pInRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetInputFolderName(iFile));
820b4d9e	91	pInMFTLoader = pInRunLoader->GetLoader("MFTLoader");
	92	if (!pInMFTLoader) {
	93	AliDebug(1,"no MFT lodader, checking in the other input \n");
	94	continue;
	95	}
	96
	97	if (!pInRunLoader->GetAliRun()) pInRunLoader->LoadgAlice();
	98	AliMFT pInMFT = (AliMFT) pInRunLoader->GetAliRun()->GetDetector("MFT");
	99
	100	AliDebug(1, "pInMFTLoader->LoadSDigits()...");
	101	pInMFTLoader->LoadSDigits();
	102	AliDebug(1, "... done!");
	103	AliDebug(1, " pInMFTLoader->TreeS()->GetEntry(0);");
	104	pInMFTLoader->TreeS()->GetEntry(0);
	105	AliDebug(1, "... done!");
	106
	107	for (Int_t iPlane=0; iPlane<pInMFT->GetSDigitsList()->GetEntries(); iPlane++) {
	108	for(Int_t iSDig=0; iSDig<((TClonesArray*)pInMFT->GetSDigitsList()->At(iPlane))->GetEntries(); iSDig++) {
	109	AliDebug(2, Form("Reading digit %03d of plane %02d (A)", iSDig, iPlane));
	110	AliMFTDigit pSDig = (AliMFTDigit) ((TClonesArray*)pInMFT->GetSDigitsList()->At(iPlane))->At(iSDig);
	111	AliDebug(2, Form("Reading digit %03d of plane %02d (B)", iSDig, iPlane));
f21fc003	112	pSDig->AddOffset2TrackID(fDigInput->GetMask(iFile)); // -> To be introduced for merging (since all inputs count tracks independently from 0)
820b4d9e	113	AliDebug(2, Form("Reading digit %03d of plane %02d (C)", iSDig, iPlane));
	114	new ((sDigits[iPlane])[sDigits[iPlane].GetEntries()]) AliMFTDigit(*pSDig);
	115	AliDebug(2, Form("Reading digit %03d of plane %02d (D)", iSDig, iPlane));
	116	}
	117	}
	118
	119	pInMFTLoader->UnloadSDigits();
	120	pInMFT->ResetSDigits();
	121
	122	}
	123
f21fc003	124	AliRunLoader *pOutRunLoader = AliRunLoader::GetRunLoader(fDigInput->GetOutputFolderName()); // open output stream (only 1 possible)
820b4d9e	125	AliLoader *pOutMFTLoader = pOutRunLoader->GetLoader("MFTLoader");
	126	AliRun *pAliRun = pOutRunLoader->GetAliRun();
	127	AliMFT pOutMFT = (AliMFT) pAliRun->GetDetector("MFT");
	128	pOutMFTLoader->MakeTree("D");
	129	pOutMFT->MakeBranch("D");
	130	pOutMFT->SetTreeAddress();
	131
	132	SDigits2Digits(sDigits, pOutMFT->GetDigitsList()); // here the sdigits are merged into digits
	133
	134	pOutMFTLoader->TreeD()->Fill(); // fill the output tree with the list of digits
	135	pOutMFTLoader->WriteDigits("OVERWRITE"); // serialize them to file
	136
	137	for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) sDigits[iPlane].Clear(); // remove all tmp sdigits
	138	pOutMFTLoader->UnloadDigits();
	139	pOutMFT->ResetDigits();
	140
	141	}
	142
	143	//====================================================================================================================================================
	144
	145	void AliMFTDigitizer::SDigits2Digits(TClonesArray pSDigitList, TObjArray pDigitList) {
	146
	147	TClonesArray *myDigitList[fNMaxPlanes] = {0};
	148
	149	for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
	150	myDigitList[iPlane] = (TClonesArray)(pDigitList)[iPlane];
	151	if (myDigitList[iPlane]->GetEntries()!=0) AliErrorClass("Some of digits lists is not empty"); // in principle those lists should be empty
	152	}
	153
	154	AliDebug(1,"starting loop over planes");
	155
	156	for (Int_t iPlane=0; iPlane<fNPlanes; iPlane++) {
	157
	158	AliMFTDigit *newDig=NULL;
	159	AliMFTDigit *oldDig=NULL;
	160	pSDigitList[iPlane].Sort();
	161
660cbe7c	162	Int_t nDetElem = fSegmentation->GetPlane(iPlane)->GetNActiveElements();
	163	TClonesArray *digitsPerDetElem[fNMaxDetElemPerPlane] = {0};
	164	for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) digitsPerDetElem[iDetElem] = new TClonesArray("AliMFTDigit");
	165
820b4d9e	166	AliDebug(1,"starting loop over sdigits to create digits");
	167	AliDebug(1, Form("MFT plane #%02d has %d SDigits", iPlane, Int_t(pSDigitList[iPlane].GetEntries())));
	168
	169	for (Int_t iSDig=0; iSDig<pSDigitList[iPlane].GetEntries(); iSDig++) {
	170
	171	newDig = (AliMFTDigit*) (pSDigitList[iPlane].At(iSDig));
660cbe7c	172	Int_t localDetElemID = fSegmentation->GetDetElemLocalID(newDig->GetDetElemID());
820b4d9e	173	Bool_t digitExists = kFALSE;
660cbe7c	174	Int_t nDigits = digitsPerDetElem[localDetElemID]->GetEntries();
820b4d9e	175
820b4d9e	176	for (Int_t iDig=0; iDig<nDigits; iDig++) {
660cbe7c	177	oldDig = (AliMFTDigit*) (digitsPerDetElem[localDetElemID]->At(iDig));
820b4d9e	178	if (newDig->GetDetElemID()==oldDig->GetDetElemID() &&
	179	newDig->GetPixelX()==oldDig->GetPixelX() &&
	180	newDig->GetPixelY()==oldDig->GetPixelY() &&
	181	newDig->GetPixelZ()==oldDig->GetPixelZ()) {
	182	digitExists = kTRUE;
	183	MergeDigits(oldDig, newDig);
	184	break;
	185	}
	186	}
660cbe7c	187
	188	if (!digitExists) new ((digitsPerDetElem[localDetElemID])[digitsPerDetElem[localDetElemID]->GetEntries()]) AliMFTDigit(newDig);
	189
	190	}
820b4d9e	191
660cbe7c	192	// Now we merge the digit lists coming from each detection element, to have an ordered final list
820b4d9e	193
660cbe7c	194	for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) {
	195	for (Int_t iSDig=0; iSDig<digitsPerDetElem[iDetElem]->GetEntries(); iSDig++) {
	196	newDig = (AliMFTDigit*) (digitsPerDetElem[iDetElem]->At(iSDig));
	197	new ((myDigitList[iPlane])[myDigitList[iPlane]->GetEntries()]) AliMFTDigit(newDig);
	198	}
820b4d9e	199	}
660cbe7c	200
660cbe7c	201	for (Int_t iDetElem=0; iDetElem<nDetElem; iDetElem++) delete digitsPerDetElem[iDetElem];
820b4d9e	202
	203	AliDebug(1, Form("MFT plane #%02d has %d Digits", iPlane, Int_t(myDigitList[iPlane]->GetEntries())));
	204
	205	// for (Int_t iDigit=0; iDigit<myDigitList[iPlane]->GetEntries(); iDigit++) {
	206	// AliDebug(1, Form("Digit %03d of MFT plane %02d has pixel coordinates (%05d, %05d)",
	207	// iDigit, iPlane, ((AliMFTDigit) myDigitList[iPlane]->At(iDigit))->GetPixelX(), ((AliMFTDigit) myDigitList[iPlane]->At(iDigit))->GetPixelY()) );
	208	// }
	209
	210	AliDebug(1, "ending loop over sdigits to create digits");
	211
	212	}
	213
	214	AliDebug(1,"ending loop over layers");
	215
	216	}
	217
	218	//====================================================================================================================================================
	219
	220	void AliMFTDigitizer::MergeDigits(AliMFTDigit mainDig, AliMFTDigit digToSum) {
	221
	222	mainDig -> SetEloss(mainDig->GetEloss() + digToSum->GetEloss());
	223
	224	Bool_t trackExists = kFALSE;
	225	for (Int_t iTrack=0; iTrack<mainDig->GetNMCTracks(); iTrack++) {
	226	if (digToSum->GetMCLabel(0) == mainDig->GetMCLabel(iTrack)) {
	227	trackExists = kTRUE;
	228	break;
	229	}
	230	}
	231
	232	if (!trackExists) mainDig->AddMCLabel(digToSum->GetMCLabel(0));
	233
	234	}
	235
	236	//====================================================================================================================================================
	237