X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TOF%2FAliTOFDigitizer.cxx;h=0f310678fa6ded3ffe3079d9f886fec05e5e717c;hb=c3fe1eed99fdf0b9d47ae456bfd833b656551094;hp=b2a0c8ef7a7a185a962659787f57ef4281f7709b;hpb=0efc163f5848f689d9b4bf8a70538ee0e2b1ce61;p=u%2Fmrichter%2FAliRoot.git diff --git a/TOF/AliTOFDigitizer.cxx b/TOF/AliTOFDigitizer.cxx index b2a0c8ef7a7..0f310678fa6 100644 --- a/TOF/AliTOFDigitizer.cxx +++ b/TOF/AliTOFDigitizer.cxx @@ -1,5 +1,5 @@ /************************************************************************** - * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * + * 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. * @@ -13,367 +13,556 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ +//_________________________________________________________________________// +// // +// This is a TTask that makes TOF-Digits out of TOF-SDigits. // +// The simulation of the detector is performed at sdigits level: // +// during digitization the unique task is the sum of all sdigits in the // +// same pad. // +// Digits are written to TreeD in branch "TOF". // +// // +// -- Author : F. Pierella (Bologna University) pierella@bo.infn.it // +// // +//_________________________________________________________________________// -//_________________________________________________________________________ -// This is a TTask that makes TOF-Digits out of TOF-Hits. -// A TOF Digit is essentially a TOF hit with the smearing for strip -// time resolution and simulation of the ADC correlation signal. -// Digits are written to TreeD in branch "TOF". -// AliTOFDigitizer with all current parameters used for digitization -// (time resolution and ADC parameter) is written -// to TreeD branch "AliTOFDigitizer". -// Both branches have the same title. If necessary one can produce -// another set of Digits with different parameters. Two versions -// can be distunguished using titles of the branches. -// User case: -// root [0] AliTOFDigitizer * s = new AliTOFDigitizer("galice.root") -// Warning in : Detector size may not be write. -// Warning in : object already instantiated -// root [1] s->ExecuteTask() -// // Makes Digits for all events stored in galice.root -// root [2] s->SetTimeRes(100.) -// // One can change parameters of digitization -// root [3] s->SetDigitsBranch("Time Resolution 100. ps") -// // and write them into the new branch -// root [4] s->ExecuteTask("deb all tim") -// // available parameters: -// deb - print number of produced Digits -// deb all - print number and list of produced Digits -// tim - print benchmarking information -// -// -- Author : F. Pierella (Bologna University) pierella@bo.infn.it -////////////////////////////////////////////////////////////////////////////// - -#include "TFile.h" -#include "TTask.h" -#include "TTree.h" -#include "TSystem.h" -#include "TROOT.h" -#include "TFolder.h" -#include "TBenchmark.h" -#include "TObjString.h" +//#include "Riostream.h" -#include +//#include "TFile.h" +#include "TH1F.h" +#include "TTree.h" +#include "TRandom.h" +#include "TObjArray.h" +#include "AliLoader.h" +#include "AliLog.h" +#include "AliRunDigitizer.h" +#include "AliRunLoader.h" #include "AliRun.h" -#include "AliTOF.h" -#include "AliTOFdigit.h" -#include "AliTOFhit.h" + +#include "AliTOFcalib.h" +//#include "AliTOFChannelOnline.h" +#include "AliTOFChannelOffline.h" #include "AliTOFDigitizer.h" +#include "AliTOFdigit.h" +#include "AliTOFHitMap.h" +#include "AliTOFGeometry.h" +#include "AliTOFSDigit.h" +#include "AliTOF.h" + +extern TDirectory *gDirectory; +//extern TFile *gFile; +extern TRandom *gRandom; + +extern AliRun *gAlice; ClassImp(AliTOFDigitizer) - -//____________________________________________________________________________ - AliTOFDigitizer::AliTOFDigitizer():TTask("AliTOFDigitizer","") +//___________________________________________ + AliTOFDigitizer::AliTOFDigitizer() : + AliDigitizer(), + fDigits(new TClonesArray("AliTOFdigit",4000)), + fSDigitsArray(new TClonesArray("AliTOFSDigit",1000)), + fhitMap(0x0), + fCalib(new AliTOFcalib()) +{ + // Default ctor - don't use it + InitDecalibration(); +} + +//___________________________________________ +AliTOFDigitizer::AliTOFDigitizer(AliRunDigitizer* manager): + AliDigitizer(manager), + fDigits(new TClonesArray("AliTOFdigit",4000)), + fSDigitsArray(new TClonesArray("AliTOFSDigit",1000)), + fhitMap(0x0), + fCalib(new AliTOFcalib()) { - // ctor - fTimeRes = 100; // ps - fChrgRes = 100.; // pC - fNevents = 0 ; - fDigits = 0 ; - fHits = 0 ; - fIsInitialized = kFALSE ; + //ctor with RunDigitizer + InitDecalibration(); +} +//------------------------------------------------------------------------ +AliTOFDigitizer::AliTOFDigitizer(const AliTOFDigitizer &source): + AliDigitizer(source), + fDigits(source.fDigits), + fSDigitsArray(source.fSDigitsArray), + fhitMap(source.fhitMap), + fCalib(source.fCalib) +{ + // copy constructor } -//____________________________________________________________________________ -AliTOFDigitizer::AliTOFDigitizer(const char* headerFile, const char *digitsTitle):TTask("AliTOFDigitizer","") +//------------------------------------------------------------------------ + AliTOFDigitizer& AliTOFDigitizer::operator=(const AliTOFDigitizer &source) { - // ctor - fTimeRes = 100; // ps - fChrgRes = 100.; // pC - fNevents = 0 ; - fDigitsTitle = digitsTitle ; - fHeadersFile = headerFile ; - fIsInitialized = kFALSE ; - Init(); + // ass. op. + + if (this == &source) + return *this; + + AliDigitizer::operator=(source); + fDigits=source.fDigits; + fSDigitsArray=source.fSDigitsArray; + fhitMap=source.fhitMap; + fCalib=source.fCalib; + return *this; + } -//____________________________________________________________________________ +//------------------------------------------------------------------------ AliTOFDigitizer::~AliTOFDigitizer() { - // dtor - if(fDigits) - delete fDigits ; - if(fHits) - delete fHits ; + // Destructor + delete fCalib; + if (fDigits){ + fDigits->Delete(); + delete fDigits; + fDigits=0x0; + } + if (fSDigitsArray){ + fSDigitsArray->Delete(); + delete fSDigitsArray; + fSDigitsArray=0x0; + } } -//____________________________________________________________________________ -void AliTOFDigitizer::Init() + +//--------------------------------------------------------------------- + +void AliTOFDigitizer::Exec(Option_t* /*option*/) { - // Initialization: open root-file, allocate arrays for hits and digits, - // attach task Digitizer to the list of TOF tasks - // - // Initialization can not be done in the default constructor + // + // Perform digitization and merging. + // The algorithm is the following: + // - a hitmap is created to check if a pad is already activated; + // - an sdigits container is created to collect all sdigits from + // different files; + // - sdigits are summed using the hitmap; + // - the sdigits container is used to create the array of AliTOFdigit. + // - if(!fIsInitialized){ + AliDebug(1, ""); - if(fHeadersFile.IsNull()) - fHeadersFile="galice.root" ; - TFile * file = (TFile*) gROOT->GetFile(fHeadersFile.Data() ) ; - - //if file was not opened yet, read gAlice - if(file == 0){ - if(fHeadersFile.Contains("rfio")) - file = TFile::Open(fHeadersFile,"update") ; - else - file = new TFile(fHeadersFile.Data(),"update") ; - gAlice = (AliRun *) file->Get("gAlice") ; - } - fHits = new TClonesArray("AliTOFhit" , 405); - fDigits = new TClonesArray("AliTOFdigit", 405); - - //add Task to //FPAlice/tasks/(S)Digitizer/TOF - TFolder * alice = (TFolder*)gROOT->GetListOfBrowsables()->FindObject("FPAlice") ; - TTask * aliceSD = (TTask*)alice->FindObject("tasks/(S)Digitizer") ; - TTask * tofD = (TTask*)aliceSD->GetListOfTasks()->FindObject("TOF") ; - tofD->Add(this) ; + // get the ptr to TOF detector + AliTOF * tof = (AliTOF *) gAlice->GetDetector("TOF") ; - fIsInitialized = kTRUE ; + //Make branches + char branchname[20]; + sprintf (branchname, "%s", tof->GetName ()); + + AliRunLoader* outrl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName()); + if (outrl == 0x0) + { + AliError("Can not find Run Loader in output folder."); + return; + } + + /* + outrl->CdGAFile(); + TFile *in=(TFile*)gFile; + TDirectory *savedir=gDirectory; + + + //when fGeom was needed + + if (!in->IsOpen()) { + AliWarning("Geometry file is not open default TOF geometry will be used"); + fGeom = new AliTOFGeometry(); + } + else { + in->cd(); + fGeom = (AliTOFGeometry*)in->Get("TOFgeometry"); } -} -//____________________________________________________________________________ -void AliTOFDigitizer::Exec(Option_t *option) -{ - Int_t tracks[3]; // track info - Int_t vol[5]; // dummy location for digit - Float_t digit[2]; // TOF digit variables - - // Collects all hits in the same active volume into digit - if(!fIsInitialized) - Init() ; + savedir->cd(); + */ + AliLoader* outgime = outrl->GetLoader("TOFLoader"); + if (outgime == 0x0) + { + AliError("Can not get TOF Loader from Output Run Loader."); + return; + } + + TTree* treeD = outgime->TreeD(); + if (treeD == 0x0) + { + outgime->MakeTree("D"); + treeD = outgime->TreeD(); + } + //Make branch for digits (to be created in Init()) + tof->MakeBranchInTree(treeD,branchname,&fDigits,4000); - if(strstr(option,"tim")) - gBenchmark->Start("TOFDigitizer"); + // container for all summed sdigits (to be created in Init()) + //fSDigitsArray=new TClonesArray("AliTOFSDigit",1000); - fNevents = (Int_t) gAlice->TreeE()->GetEntries() ; + // create hit map (to be created in Init()) + fhitMap = new AliTOFHitMap(fSDigitsArray); - Int_t ievent ; - // start loop on events - for(ievent = 0; ievent < fNevents; ievent++){ - gAlice->GetEvent(ievent) ; - gAlice->SetEvent(ievent) ; + // Loop over files to digitize + + for (Int_t inputFile=0; inputFileGetNinputs(); + inputFile++) { + ReadSDigit(inputFile); + } + + // create digits + CreateDigits(); + + // free used memory for Hit Map in current event + delete fhitMap; + fSDigitsArray->Clear(); + + treeD->Fill(); + + outgime->WriteDigits("OVERWRITE"); + outgime->UnloadDigits(); + fDigits->Clear(); + +} + +//--------------------------------------------------------------------- + +void AliTOFDigitizer::CreateDigits() +{ + // loop on sdigits container to fill the AliTOFdigit TClonesArray + // start digitizing all the collected sdigits + + Int_t ndump=0; // dump the first ndump created digits for each event + + // get the total number of collected sdigits + Int_t ndig = fSDigitsArray->GetEntriesFast(); + + for (Int_t k = 0; k < ndig; k++) { - if(gAlice->TreeH()==0){ - cout << "AliTOFDigitizer: There is no Hit Tree" << endl; - return ; - } + Int_t vol[5]; // location for a digit + for (Int_t i=0; i<5; i++) vol[i] = -1; - //set address of the hits - TBranch * branch = gAlice->TreeH()->GetBranch("TOF"); - if (branch) - branch->SetAddress(&fHits); - else{ - cout << "ERROR in AliTOFDigitizer: "<< endl ; - cout << " no branch TOF in TreeH"<< endl ; - cout << " do nothing " << endl ; - return ; - } + // Get the information for this digit + AliTOFSDigit *tofsdigit = (AliTOFSDigit *) fSDigitsArray->UncheckedAt(k); - fDigits->Clear(); - Int_t ndigits = 0 ; + Int_t nslot=tofsdigit->GetNDigits(); // get the number of slots + // for current sdigit - //Now made Digits from hits, for TOF it is the same a part for the tof smearing - // and some missing MC variables - Int_t itrack ; - for (itrack=0; itrack < gAlice->GetNtrack(); itrack++){ - - //=========== Get the TOF branch from Hits Tree for the Primary track itrack - branch->GetEntry(itrack,0); - - Int_t i; - for ( i = 0 ; i < fHits->GetEntries() ; i++ ) { - - AliTOFhit * hit = (AliTOFhit*)fHits->At(i) ; - - vol[0] = hit->GetSector(); - vol[1] = hit->GetPlate(); - vol[2] = hit->GetPadx(); - vol[3] = hit->GetPadz(); - vol[4] = hit->GetStrip(); - // 95% of efficiency to be inserted here - // edge effect to be inserted here - // cross talk to be inserted here - // simulation of the detector response - Float_t idealtime = hit->GetTof(); // unit s - idealtime *= 1.E+12; // conversion from s to ps - // fTimeRes is given usually in ps - Float_t tdctime = gRandom->Gaus(idealtime, fTimeRes); - digit[0] = tdctime; - // typical Landau Distribution to be inserted here - Float_t idealcharge = hit->GetEdep(); - Float_t adccharge = gRandom->Gaus(idealcharge, fChrgRes); - digit[1] = adccharge; - // to be added a check for overlaps - new((*fDigits)[ndigits]) AliTOFdigit(tracks, vol, digit); - ndigits++ ; - } - - } // end loop over tracks - - ndigits = fDigits->GetEntriesFast() ; - printf("AliTOFDigitizer: Total number of digits %d\n",ndigits); - - if(gAlice->TreeD() == 0) - gAlice->MakeTree("D") ; + // TOF sdigit volumes (always the same for all slots) + Int_t sector = tofsdigit->GetSector(); // range [0-17] + Int_t plate = tofsdigit->GetPlate(); // range [0- 4] + Int_t strip = tofsdigit->GetStrip(); // range [0-14/18/19] + Int_t padz = tofsdigit->GetPadz(); // range [0- 1] + Int_t padx = tofsdigit->GetPadx(); // range [0-47] - //check, if this branch already exits - TBranch * digitsBranch = 0; - TBranch * digitizerBranch = 0; + vol[0] = sector; + vol[1] = plate; + vol[2] = strip; + vol[3] = padx; + vol[4] = padz; - TObjArray * branches = gAlice->TreeD()->GetListOfBranches() ; - Int_t ibranch; - Bool_t tofNotFound = kTRUE ; - Bool_t digitizerNotFound = kTRUE ; + //--------------------- QA section ---------------------- + // in the while, I perform QA + Bool_t isSDigitBad = (sector<0 || sector>17 || plate<0 || plate >4 || padz<0 || padz>1 || padx<0 || padx>47); - for(ibranch = 0;ibranch GetEntries();ibranch++){ - - if(tofNotFound){ - digitsBranch=(TBranch *) branches->At(ibranch) ; - if( (strcmp("TOF",digitsBranch->GetName())==0 ) && - (fDigitsTitle.CompareTo(digitsBranch->GetTitle()) == 0) ) - tofNotFound = kFALSE ; - } - if(digitizerNotFound){ - digitizerBranch = (TBranch *) branches->At(ibranch) ; - if( (strcmp(digitizerBranch->GetName(),"AliTOFDigitizer") == 0)&& - (fDigitsTitle.CompareTo(digitizerBranch->GetTitle()) == 0) ) - digitizerNotFound = kFALSE ; - } - } - - if(!(digitizerNotFound && tofNotFound)){ - cout << "AliTOFdigitizer error:" << endl ; - cout << "Can not overwrite existing branches: do not write" << endl ; - return ; + if (isSDigitBad) { + //AliFatal("strange sdigit found"); + AliFatal(Form("strange sdigit found %3i %2i %2i %3i %3i", sector, plate, padz, padx, strip)); } + //------------------------------------------------------- - //Make (if necessary) branches - char * file =0; - if(gSystem->Getenv("CONFIG_SPLIT_FILE")){ //generating file name - file = new char[strlen(gAlice->GetBaseFile())+20] ; - sprintf(file,"%s/TOF.Digits.root",gAlice->GetBaseFile()) ; + //------------------- Dump section ---------------------- + if(kTreeD()->Branch("TOF",&fDigits,bufferSize); - digitsBranch->SetTitle(fDigitsTitle.Data()); - if (file) { - digitsBranch->SetFile(file); - TIter next( digitsBranch->GetListOfBranches()); - TBranch * subbr; - while ((subbr=(TBranch*)next())) { - subbr->SetFile(file); - } - cwd->cd(); - } + // start loop on number of slots for current sdigit + for (Int_t islot = 0; islot < nslot; islot++) { + Int_t digit[4] = {-1,-1,-1,-1}; // TOF digit variables + Int_t tracknum[AliTOFSDigit::kMAXDIGITS]; // contributing tracks for the current slot - //second - Digitizer - Int_t splitlevel = 0 ; - AliTOFDigitizer * digtz = this ; - digitizerBranch = gAlice->TreeD()->Branch("AliTOFDigitizer","AliTOFDigitizer", - &digtz,bufferSize,splitlevel); - digitizerBranch->SetTitle(fDigitsTitle.Data()); - if (file) { - digitizerBranch->SetFile(file); - TIter next( digitizerBranch->GetListOfBranches()); - TBranch * subbr ; - while ((subbr=(TBranch*)next())) { - subbr->SetFile(file); - } - cwd->cd(); - delete file; - } + Int_t tdc=tofsdigit->GetTdc(islot); digit[0]=tdc; + Int_t adc=tofsdigit->GetAdc(islot); digit[1]=adc; - digitsBranch->Fill(); - digitizerBranch->Fill(); - gAlice->TreeD()->Write(0,TObject::kOverwrite) ; - - if(strstr(option,"deb")) - PrintDigits(option) ; + //if (tdc>=8192) continue;//AdC + + tracknum[0]=tofsdigit->GetTrack(islot,0); + tracknum[1]=tofsdigit->GetTrack(islot,1); + tracknum[2]=tofsdigit->GetTrack(islot,2); + + // new with placement must be used + // adding a TOF digit for each slot + TClonesArray &aDigits = *fDigits; + Int_t last=fDigits->GetEntriesFast(); + new (aDigits[last]) AliTOFdigit(tracknum, vol, digit); + + } - } + } // end loop on sdigits - end digitizing all collected sdigits + + //Insert Decalibration + AliInfo("in digitizer, create digits"); + DecalibrateTOFSignal(); +} + +//--------------------------------------------------------------------- + +void AliTOFDigitizer::ReadSDigit(Int_t inputFile ) +{ + // Read sdigits for current event and inputFile; + // store them into the sdigits container + // and update the hit map + // SDigits from different files are assumed to + // be created with the same simulation parameters. - if(strstr(option,"tim")){ - gBenchmark->Stop("TOFDigitizer"); - cout << "AliTOFDigitizer:" << endl ; - cout << " took " << gBenchmark->GetCpuTime("TOFDigitizer") << " seconds for Digitizing " - << gBenchmark->GetCpuTime("TOFDigitizer")/fNevents << " seconds per event " << endl ; - cout << endl ; + // creating the TClonesArray to store the digits + static TClonesArray sdigitsClonesArray("AliTOFSDigit", 1000); + sdigitsClonesArray.Clear(); + + // get the treeS from manager + AliRunLoader* rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile)); + if (rl == 0x0) + { + AliError(Form("Can not find Run Loader in input %d folder.",inputFile)); + return; + } + + AliLoader* gime = rl->GetLoader("TOFLoader"); + if (gime == 0x0) + { + AliError(Form("Can not get TOF Loader from Input %d Run Loader.",inputFile)); + return; + } + + TTree* currentTreeS=gime->TreeS(); + if (currentTreeS == 0x0) + { + Int_t retval = gime->LoadSDigits(); + if (retval) + { + AliError(Form("Error occured while loading S. Digits for Input %d",inputFile)); + return; + } + currentTreeS=gime->TreeS(); + if (currentTreeS == 0x0) + { + AliError(Form("Can not get S. Digits Tree for Input %d",inputFile)); + return; + } + } + // get the branch TOF inside the treeS + TClonesArray * sdigitsDummyContainer=&sdigitsClonesArray; + // check if the branch exist + TBranch* tofBranch=currentTreeS->GetBranch("TOF"); + + if(!tofBranch){ + AliFatal(Form("TOF branch not found for input %d",inputFile)); } + tofBranch->SetAddress(&sdigitsDummyContainer); -} -//__________________________________________________________________ -void AliTOFDigitizer::SetDigitsBranch(const char* title ) -{ - // Setting title to branch Digits - if(!fDigitsTitle.IsNull()) - cout << "AliTOFdigitizer: changing Digits file from " <GetEntries(); + + // Loop through all entries in the tree + Int_t nbytes = 0; + for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) { + + // Import the tree + nbytes += tofBranch->GetEvent(iEntry); + + // Get the number of sdigits + Int_t ndig = sdigitsDummyContainer->GetEntriesFast(); + + for (Int_t k=0; kUncheckedAt(k); + + Int_t vol[5]; // location for a sdigit + for (Int_t i=0; i<5; i++) vol[i] = -1; + + // check the sdigit volume + vol[0] = tofSdigit->GetSector(); + vol[1] = tofSdigit->GetPlate(); + vol[2] = tofSdigit->GetStrip(); + vol[3] = tofSdigit->GetPadx(); + vol[4] = tofSdigit->GetPadz(); + + if (fhitMap->TestHit(vol) != kEmpty) { + AliTOFSDigit *sdig = static_cast(fhitMap->GetHit(vol)); + sdig->Update(tofSdigit); + + } else { + + CollectSDigit(tofSdigit); // collect the current sdigit + fhitMap->SetHit(vol); // update the hitmap for location vol + + } // if (hitMap->TestHit(vol) != kEmpty) + + } // for (Int_t k=0; kGetEntriesFast(); + // make a copy of the current sdigit and + // put it into tmp array + new (aSDigitsArray[last]) AliTOFSDigit(*sdigit); } -//__________________________________________________________________ -void AliTOFDigitizer::PrintDigits(Option_t * option) -{ - // Prints list of digits produced in the current pass of AliTOFDigitizer + +//_____________________________________________________________________________ +void AliTOFDigitizer::InitDecalibration() const { + // + // + // + + fCalib->CreateCalArrays(); + fCalib->ReadSimHistoFromCDB("TOF/Calib", -1); // use AliCDBManager's number + fCalib->ReadParOfflineFromCDB("TOF/Calib", -1); // use AliCDBManager's number +} +//--------------------------------------------------------------------- +void AliTOFDigitizer::DecalibrateTOFSignal(){ + + // Read Calibration parameters from the CDB + + TObjArray * calOffline= fCalib->GetTOFCalArrayOffline(); + + AliDebug(2,Form("Size of array for Offline Calibration = %i",calOffline->GetEntries())); + + // Initialize Quantities to Simulate ToT Spectra + + TH1F * hToT= fCalib->GetTOFSimToT(); + Int_t nbins = hToT->GetNbinsX(); + Float_t delta = hToT->GetBinWidth(1); + Float_t maxch = hToT->GetBinLowEdge(nbins)+delta; + Float_t minch = hToT->GetBinLowEdge(1); + Float_t max=0,min=0; //maximum and minimum value of the distribution + Int_t maxbin=0,minbin=0; //maximum and minimum bin of the distribution + + for (Int_t ii=nbins; ii>0; ii--){ + if (hToT->GetBinContent(ii)!= 0) { + max = maxch - (nbins-ii-1)*delta; + maxbin = ii; + break;} + } + for (Int_t j=1; jGetBinContent(j)!= 0) { + min = minch + (j-1)*delta; + minbin = j; + break;} + } + + Float_t maxToT=max; + Float_t minToT=min; + + Float_t maxToTDistr=hToT->GetMaximum(); + + AliDebug (1, Form(" The minimum ToT = %f", minToT)); + AliDebug (1, Form(" The maximum ToT = %f", maxToT)); + AliDebug (1, Form(" The maximum peak in ToT = %f", maxToTDistr)); - cout << "AliTOFDigitizer: " << endl ; - cout << " Number of entries in Digits list " << fDigits->GetEntriesFast() << endl ; - cout << endl ; + // Loop on TOF Digits + + Bool_t isToTSimulated=kFALSE; + Bool_t misCalibPars=kFALSE; + if(hToT->GetEntries()>0)isToTSimulated=kTRUE; + Int_t ndigits = fDigits->GetEntriesFast(); + for (Int_t i=0;iAt(i); + Int_t detId[5]; + detId[0] = dig->GetSector(); + detId[1] = dig->GetPlate(); + detId[2] = dig->GetStrip(); + detId[3] = dig->GetPadz(); + detId[4] = dig->GetPadx(); + dig->SetTdcND(dig->GetTdc()); // save the non decalibrated time + if(isToTSimulated){ + + //A realistic ToT Spectrum was found in input, + //decalibrated TOF Digits likely to be simulated.... + + Int_t index = AliTOFGeometry::GetIndex(detId); // The channel index + AliTOFChannelOffline *calChannelOffline = (AliTOFChannelOffline *)calOffline->At(index); //retrieve the info for time slewing + Double_t par[6]; // time slewing parameters - if(strstr(option,"all")){// print all digits - - //loop over digits - AliTOFdigit * digit; - cout << "Digit # " << " Time of flight(ps) " << - " ADC(pC)" << " Sector #" << " Plate #" << - " Strip #" << " Pad # (x) " << " Pad # (z) " << endl; - Int_t index ; - for (index = 0 ; index < fDigits->GetEntries() ; index++) { - digit = (AliTOFdigit * ) fDigits->At(index) ; - - // set the width of the output with the setw(int width) manipulator - - cout << setw(7) << index << " " - << setw(13) << digit->GetTdc() << " " - << setw(13) << digit->GetAdc() << " " - << setw(6) << digit->GetSector() << " " - << setw(6) << digit->GetPlate() << " " - << setw(6) << digit->GetStrip() << " " - << setw(7) << digit->GetPadx() << " " - << setw(7) << digit->GetPadz() << " " << endl; - - } // end loop on digits - - } // close if "all" option selected + //check whether we actually ask for miscalibration + + for (Int_t j = 0; j<6; j++){ + par[j]=(Double_t)calChannelOffline->GetSlewPar(j); + if(par[j]!=0)misCalibPars=kTRUE; + } + AliDebug(2,Form(" Calib Pars = %f (0-th parameter for time slewing + time delay), %f, %f, %f, %f, %f ",par[0],par[1],par[2],par[3],par[4],par[5])); + + // Now generate Realistic ToT distribution from TestBeam Data. + // Tot is in ns, assuming a Matching Window of 10 ns. + + Float_t simToT = 0; + Float_t trix = 0; + Float_t triy = 0; + Double_t timeCorr; + Double_t tToT; + while (simToT <= triy){ + trix = gRandom->Rndm(i); + triy = gRandom->Rndm(i); + trix = (maxToT-minToT)*trix + minToT; + triy = maxToTDistr*triy; + Int_t binx=hToT->FindBin(trix); + simToT=hToT->GetBinContent(binx); + } + // the generated ToT (ns) + tToT= (Double_t) trix; // to apply slewing we start from ns.. + // transform TOF signal in ns + AliDebug(2,Form(" The Initial Time (counts): %i: ",dig->GetTdc())); + AliDebug(2,Form(" Time before miscalibration (ps) %e: ",dig->GetTdc()*(Double_t)AliTOFGeometry::TdcBinWidth())); + // add slewing effect + timeCorr=par[0] + tToT*(par[1] +tToT*(par[2] +tToT*(par[3] +tToT*(par[4] +tToT*par[5])))); + AliDebug(2,Form(" The Time slewing + delay (ns): %f: ",timeCorr)); + // add global time shift + //convert to ps + timeCorr*=1E3; + Double_t timeMis = (Double_t)(dig->GetTdc())*(Double_t)AliTOFGeometry::TdcBinWidth(); + timeMis = timeMis+timeCorr; + AliDebug(2,Form(" The Miscalibrated time (ps): %e: ",timeMis)); + + // now update the digit info + + Int_t tdcCorr= (Int_t)(timeMis/AliTOFGeometry::TdcBinWidth()); + AliDebug(2,Form(" Final Time (counts): %i: ",tdcCorr)); + // Setting Decalibrated Time signal (TDC counts) + dig->SetTdc(tdcCorr); + // Setting realistic ToT signal (TDC counts) + tToT*=1E3; //back to ps + Int_t tot=(Int_t)(tToT/AliTOFGeometry::ToTBinWidth());//(factor 1E3 as input ToT is in ns) + dig->SetToT(tot); + AliDebug(2,Form(" Final Time and ToT (counts): %i: , %i:",dig->GetTdc(),dig->GetToT())); + if(tdcCorr<0){ + AliWarning (Form(" The bad Slewed Time(TDC counts)= %i ", tdcCorr)); + AliWarning(Form(" The bad ToT (TDC counts)= %i ", tot)); + } + } + else{ + // For Data with no Miscalibration, set ToT signal == Adc + dig->SetToT((Int_t)(dig->GetAdc()/AliTOFGeometry::ToTBinWidth())); //remove the factor 10^3 just to have a reasonable ToT range for raw data simulation even in the case of non-realistic ToT distribution (n.b. fAdc is practically an arbitrary quantity, and ToT has no impact on the TOF reco for non-miscalibrated digits) + } + } + + if(!isToTSimulated){ + AliDebug(1,"Standard Production, no miscalibrated digits"); + }else{ + if(!misCalibPars){ + AliDebug(1,"Standard Production, no miscalibrated digits"); + } + else { + AliDebug(1,"Simulating miscalibrated digits"); + } + } + return; } +