X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TOF%2FAliTOFSDigitizer.cxx;h=6ab931c748cea64457922e9af629861e7b22b87e;hb=34eaaa7ef77cf5c1e497d5a2218baa7163448bc9;hp=66d1198c2bee036d5109372073d47a61fe563788;hpb=55991c8b72f293fb28fcfa492cb0fc744dfda643;p=u%2Fmrichter%2FAliRoot.git diff --git a/TOF/AliTOFSDigitizer.cxx b/TOF/AliTOFSDigitizer.cxx index 66d1198c2be..6ab931c748c 100644 --- a/TOF/AliTOFSDigitizer.cxx +++ b/TOF/AliTOFSDigitizer.cxx @@ -13,98 +13,272 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ -//_________________________________________________________________________ -// This is a TTask that constructs SDigits out of Hits -// A Summable Digits is the "sum" of all hits in a pad -// Detector response has been simulated via the method -// SimulateDetectorResponse -// -//-- Authors: F. Pierella, A. De Caro -// Use case: see AliTOFhits2sdigits.C macro in the CVS -////////////////////////////////////////////////////////////////////////////// - -#include "TBenchmark.h" -#include "TTask.h" -#include "TTree.h" -#include "TSystem.h" -#include "TParticle.h" -#include "TH1.h" -#include "TFile.h" -#include "TROOT.h" -#include "TFolder.h" +/* $Id$ */ + +//__________________________________________________________// +// // +// This is a TTask that constructs SDigits out of Hits // +// A Summable Digits is the "sum" of all hits in a pad // +// Detector response has been simulated via the method // +// SimulateDetectorResponse // +// // +// -- Authors: F. Pierella, A. De Caro // +// Use case: see AliTOFhits2sdigits.C macro in the CVS // +//__________________________________________________________// + +#include +#include #include -#include -#include -#include +#include +#include +#include +#include +#include + +#include "AliLoader.h" +#include "AliLog.h" +#include "AliMC.h" +#include "AliRunLoader.h" +#include "AliRun.h" +#include "AliTOFGeometry.h" #include "AliTOFHitMap.h" -#include "AliTOFSDigit.h" -#include "AliTOFConstants.h" +#include "AliTOFhitT0.h" #include "AliTOFhit.h" -#include "AliTOF.h" -#include "AliTOFv1.h" -#include "AliTOFv2.h" -#include "AliTOFv3.h" -#include "AliTOFv4.h" #include "AliTOFSDigitizer.h" -#include "AliRun.h" -#include "AliDetector.h" -#include "AliMC.h" +#include "AliTOFSDigit.h" +#include "AliTOF.h" ClassImp(AliTOFSDigitizer) //____________________________________________________________________________ - AliTOFSDigitizer::AliTOFSDigitizer():TTask("AliTOFSDigitizer","") +AliTOFSDigitizer::AliTOFSDigitizer(): + TTask("TOFSDigitizer",""), + fEvent1(-1), + fEvent2(-1), + ftail(0x0), + fHeadersFile(""), + fRunLoader(0x0), + fTOFLoader(0x0), + fTOFGeometry(new AliTOFGeometry()), + fSelectedSector(-1), + fSelectedPlate(-1), + fTimeResolution(0), + fpadefficiency(0), + fEdgeEffect(-1), + fEdgeTails(-1), + fHparameter(0), + fH2parameter(0), + fKparameter(0), + fK2parameter(0), + fEffCenter(0), + fEffBoundary(0), + fEff2Boundary(0), + fEff3Boundary(0), + fAddTRes(0), + fResCenter(0), + fResBoundary(0), + fResSlope(0), + fTimeWalkCenter(0), + fTimeWalkBoundary(0), + fTimeWalkSlope(0), + fTimeDelayFlag(-1), + fPulseHeightSlope(0), + fTimeDelaySlope(0), + fMinimumCharge(0), + fChargeSmearing(0), + fLogChargeSmearing(0), + fTimeSmearing(0), + fAverageTimeFlag(-1), + fAdcBin(0), + fAdcMean(0), + fAdcRms(0) { // ctor - fEvent1=0; - fEvent2=0; - ftail = 0; - fSelectedSector=0; - fSelectedPlate =0; } - + +//------------------------------------------------------------------------ +AliTOFSDigitizer::AliTOFSDigitizer(const AliTOFSDigitizer &source): + TTask(source), + fEvent1(-1), + fEvent2(-1), + ftail(0x0), + fHeadersFile(""), + fRunLoader(0x0), + fTOFLoader(0x0), + fTOFGeometry(0x0), + fSelectedSector(-1), + fSelectedPlate(-1), + fTimeResolution(0), + fpadefficiency(0), + fEdgeEffect(-1), + fEdgeTails(-1), + fHparameter(0), + fH2parameter(0), + fKparameter(0), + fK2parameter(0), + fEffCenter(0), + fEffBoundary(0), + fEff2Boundary(0), + fEff3Boundary(0), + fAddTRes(0), + fResCenter(0), + fResBoundary(0), + fResSlope(0), + fTimeWalkCenter(0), + fTimeWalkBoundary(0), + fTimeWalkSlope(0), + fTimeDelayFlag(-1), + fPulseHeightSlope(0), + fTimeDelaySlope(0), + fMinimumCharge(0), + fChargeSmearing(0), + fLogChargeSmearing(0), + fTimeSmearing(0), + fAverageTimeFlag(-1), + fAdcBin(0), + fAdcMean(0), + fAdcRms(0) +{ + // copy constructor + this->fTOFGeometry=source.fTOFGeometry; + +} + //____________________________________________________________________________ - AliTOFSDigitizer::AliTOFSDigitizer(char* HeaderFile, Int_t evNumber1, Int_t nEvents):TTask("AliTOFSDigitizer","") +AliTOFSDigitizer& AliTOFSDigitizer::operator=(const AliTOFSDigitizer &source) { - fEvent1=evNumber1; - fEvent2=fEvent1+nEvents; - ftail = 0; - fSelectedSector=0; // by default we sdigitize all sectors - fSelectedPlate =0; // by default we sdigitize all plates in all sectors - - fHeadersFile = HeaderFile ; // input filename (with hits) - TFile * file = (TFile*) gROOT->GetFile(fHeadersFile.Data() ) ; - - //File was not opened yet - // open file and get alirun object - if(file == 0){ - file = TFile::Open(fHeadersFile.Data(),"update") ; - gAlice = (AliRun *) file->Get("gAlice") ; + // ass. op. + this->fTOFGeometry=source.fTOFGeometry; + return *this; + +} + +//____________________________________________________________________________ +AliTOFSDigitizer::AliTOFSDigitizer(const char* HeaderFile, Int_t evNumber1, Int_t nEvents): + TTask("TOFSDigitizer",""), + fEvent1(-1), + fEvent2(-1), + ftail(0x0), + fHeadersFile(HeaderFile), // input filename (with hits) + fRunLoader(0x0), + fTOFLoader(0x0), + fTOFGeometry(0x0), + fSelectedSector(-1), // by default we sdigitize all sectors + fSelectedPlate(-1), // by default we sdigitize all plates in all sectors + fTimeResolution(0), + fpadefficiency(0), + fEdgeEffect(-1), + fEdgeTails(-1), + fHparameter(0), + fH2parameter(0), + fKparameter(0), + fK2parameter(0), + fEffCenter(0), + fEffBoundary(0), + fEff2Boundary(0), + fEff3Boundary(0), + fAddTRes(0), + fResCenter(0), + fResBoundary(0), + fResSlope(0), + fTimeWalkCenter(0), + fTimeWalkBoundary(0), + fTimeWalkSlope(0), + fTimeDelayFlag(-1), + fPulseHeightSlope(0), + fTimeDelaySlope(0), + fMinimumCharge(0), + fChargeSmearing(0), + fLogChargeSmearing(0), + fTimeSmearing(0), + fAverageTimeFlag(-1), + fAdcBin(0), + fAdcMean(0), + fAdcRms(0) +{ + //ctor, reading from input file + + TFile * file = (TFile*) gROOT->GetFile(fHeadersFile.Data()); + + //File was not opened yet open file and get alirun object + if (file == 0) { + file = TFile::Open(fHeadersFile.Data(),"update") ; + gAlice = (AliRun *) file->Get("gAlice") ; } + + // add Task to //root/Tasks folder + TString evfoldname = AliConfig::GetDefaultEventFolderName(); + fRunLoader = AliRunLoader::GetRunLoader(evfoldname); + if (!fRunLoader) + fRunLoader = AliRunLoader::Open(HeaderFile);//open session and mount on default event folder + if (fRunLoader == 0x0) + { + AliFatal("Event is not loaded. Exiting"); + return; + } + + fRunLoader->CdGAFile(); + TDirectory *savedir=gDirectory; + TFile *in=(TFile*)gFile; + if (!in->IsOpen()) { + AliWarning("Geometry file is not open default TOF geometry will be used"); + fTOFGeometry = new AliTOFGeometry(); + } + else { + in->cd(); + fTOFGeometry = (AliTOFGeometry*)in->Get("TOFgeometry"); + } + + savedir->cd(); + + if (fRunLoader->TreeE() == 0x0) fRunLoader->LoadHeader(); + + if (evNumber1>=0) fEvent1 = evNumber1; + else fEvent1=0; + + if (nEvents==0) fEvent2 = (Int_t)(fRunLoader->GetNumberOfEvents()); + else if (nEvents>0) fEvent2 = evNumber1+nEvents; + else fEvent2 = 1; + + if (!(fEvent2>fEvent1)) { + AliError(Form("fEvent2 = %d <= fEvent1 = %d", fEvent2, fEvent1)); + fEvent1 = 0; + fEvent2 = 1; + AliError(Form("Correction: fEvent2 = %d <= fEvent1 = %d", fEvent2, fEvent1)); + } + // init parameters for sdigitization InitParameters(); - - // add Task to //root/Tasks folder - TTask * roottasks = (TTask*)gROOT->GetRootFolder()->FindObject("Tasks") ; - roottasks->Add(this) ; + + fTOFLoader = fRunLoader->GetLoader("TOFLoader"); + if (fTOFLoader == 0x0) + { + AliFatal("Can not find TOF loader in event. Exiting."); + return; + } + fTOFLoader->PostSDigitizer(this); } //____________________________________________________________________________ - AliTOFSDigitizer::~AliTOFSDigitizer() +AliTOFSDigitizer::~AliTOFSDigitizer() { // dtor + fTOFLoader->CleanSDigitizer(); + + delete fTOFGeometry; + } //____________________________________________________________________________ void AliTOFSDigitizer::InitParameters() { // set parameters for detector simulation - - fTimeResolution =0.120; - fpadefficiency =0.99 ; + + fTimeResolution = 0.080; //0.120; OLD + fpadefficiency = 0.99 ; fEdgeEffect = 2 ; fEdgeTails = 0 ; fHparameter = 0.4 ; @@ -115,9 +289,12 @@ void AliTOFSDigitizer::InitParameters() fEffBoundary = 0.65; fEff2Boundary = 0.90; fEff3Boundary = 0.08; - fResCenter = 50. ; + fAddTRes = 68. ; // \sqrt{2x20^2 + 15^2 + 2x10^2 + 30^2 + 50^2} (p-p) + //fAddTRes = 48. ; // \sqrt{2x20^2 + 15^2 + 2x10^2 + 30^2 + 15^2} (Pb-Pb) + // 30^2+20^2+40^2+50^2+50^2+50^2 = 10400 ps^2 (very old value) + fResCenter = 35. ; //50. ; // OLD fResBoundary = 70. ; - fResSlope = 40. ; + fResSlope = 37. ; //40. ; // OLD fTimeWalkCenter = 0. ; fTimeWalkBoundary=0. ; fTimeWalkSlope = 0. ; @@ -130,8 +307,8 @@ void AliTOFSDigitizer::InitParameters() fLogChargeSmearing=0.13; fTimeSmearing =0.022; fAverageTimeFlag=0 ; - fTdcBin = 50.; // 1 TDC bin = 50 ps - fAdcBin = 0.25; // 1 ADC bin = 0.25 pC (or 0.03 pC) + + fAdcBin = 0.25; // 1 ADC bin = 0.25 pC (or 0.03 pC) fAdcMean = 50.; // ADC distribution mpv value for Landau (in bins) // it corresponds to a mean value of ~100 bins fAdcRms = 25.; // ADC distribution rms value (in bins) @@ -154,33 +331,14 @@ Double_t TimeWithTail(Double_t* x, Double_t* par) return f; } - //____________________________________________________________________________ -void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { - - if(strstr(verboseOption,"tim") || strstr(verboseOption,"all")) +void AliTOFSDigitizer::Exec(Option_t *verboseOption) { + //execute TOF sdigitization + if (strstr(verboseOption,"tim") || strstr(verboseOption,"all")) gBenchmark->Start("TOFSDigitizer"); - AliTOF *TOF = (AliTOF *) gAlice->GetDetector ("TOF"); - - if (!TOF) { - Error("AliTOFSDigitizer","TOF not found"); - return; - } - - // is pointer to fSDigits non zero after changes? - cout<<"TOF fSDigits pointer:"<SDigits()<SDigits() == 0) { - TOF->CreateSDigitsArray(); - } else { - TOF->RecreateSDigitsArray(); - } - - if (fEdgeTails) ftail = new TF1("tail",TimeWithTail,-2,2,3); - + Int_t nselectedHits=0; Int_t ntotalsdigits=0; Int_t ntotalupdates=0; @@ -190,16 +348,47 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { Int_t nHitsFromSec=0; Int_t nlargeTofDiff=0; - if (strstr(allEvents,"all")){ - fEvent1=0; - fEvent2= (Int_t) gAlice->TreeE()->GetEntries(); + Bool_t thereIsNotASelection=(fSelectedSector==-1) && (fSelectedPlate==-1); + + if (fRunLoader->GetAliRun() == 0x0) fRunLoader->LoadgAlice(); + gAlice = fRunLoader->GetAliRun(); + + fRunLoader->LoadKinematics(); + + AliTOF *tof = (AliTOF *) gAlice->GetDetector("TOF"); + + if (!tof) { + AliError("TOF not found"); + return; } + + fTOFLoader->LoadHits("read"); + fTOFLoader->LoadSDigits("recreate"); + + for (Int_t iEvent=fEvent1; iEventGetEvent(iEvent); - for (Int_t ievent = fEvent1; ievent < fEvent2; ievent++) { - cout << "------------------- "<< GetName() << " -------------" << endl ; - cout << "Sdigitizing event " << ievent << endl; + TTree *hitTree = fTOFLoader->TreeH (); + if (!hitTree) return; + + if (fTOFLoader->TreeS () == 0) fTOFLoader->MakeTree ("S"); + + //Make branch for digits + tof->MakeBranch("S"); + + // recreate TClonesArray fSDigits - for backward compatibility + if (tof->SDigits() == 0) { + tof->CreateSDigitsArray(); + } else { + tof->RecreateSDigitsArray(); + } + + tof->SetTreeAddress(); + + Int_t version=tof->IsVersion(); Int_t nselectedHitsinEv=0; Int_t ntotalsdigitsinEv=0; @@ -207,73 +396,81 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { Int_t nnoisesdigitsinEv=0; Int_t nsignalsdigitsinEv=0; - gAlice->GetEvent(ievent); - TTree *TH = gAlice->TreeH (); - if (!TH) - return; - if (gAlice->TreeS () == 0) - gAlice->MakeTree ("S"); - - - //Make branches - char branchname[20]; - sprintf (branchname, "%s", TOF->GetName ()); - //Make branch for digits - TOF->MakeBranch ("S"); - - //Now made SDigits from hits - - Int_t vol[5]; // location for a digit - Float_t digit[2]; // TOF digit variables TParticle *particle; - AliTOFhit *tofHit; - TClonesArray *TOFhits = TOF->Hits(); + //AliTOFhit *tofHit; + TClonesArray *tofHitArray = tof->Hits(); // create hit map - AliTOFHitMap *hitMap = new AliTOFHitMap(TOF->SDigits()); + AliTOFHitMap *hitMap = new AliTOFHitMap(tof->SDigits(), fTOFGeometry); - // increase performances in terms of CPU time - TH->SetBranchStatus("*",0); // switch off all branches - TH->SetBranchStatus("TOF*",1); // switch on only TOF + TBranch * tofHitsBranch = hitTree->GetBranch("TOF"); - Int_t ntracks = static_cast(TH->GetEntries()); + Int_t ntracks = static_cast(hitTree->GetEntries()); for (Int_t track = 0; track < ntracks; track++) { gAlice->ResetHits(); - TH->GetEvent(track); - particle = gAlice->Particle(track); - Int_t nhits = TOFhits->GetEntriesFast(); - // cleaning all hits of the same track in the same pad volume - // it is a rare event, however it happens + tofHitsBranch->GetEvent(track); - Int_t previousTrack =0; - Int_t previousSector=0; - Int_t previousPlate =0; - Int_t previousStrip =0; - Int_t previousPadX =0; - Int_t previousPadZ =0; + AliMC *mcApplication = (AliMC*)gAlice->GetMCApp(); - for (Int_t hit = 0; hit < nhits; hit++) - { - tofHit = (AliTOFhit *) TOFhits->UncheckedAt(hit); - Int_t tracknum = tofHit->GetTrack(); - vol[0] = tofHit->GetSector(); - vol[1] = tofHit->GetPlate(); + particle = mcApplication->Particle(track); + Int_t nhits = tofHitArray->GetEntriesFast(); + // cleaning all hits of the same track in the same pad volume + // it is a rare event, however it happens - // selection case for sdigitizing only hits in a given plate of a given sector - if(thereIsNotASelection || (vol[0]==fSelectedSector && vol[1]==fSelectedPlate)){ - + Int_t previousTrack =-1; + Int_t previousSector=-1; + Int_t previousPlate =-1; + Int_t previousStrip =-1; + Int_t previousPadX =-1; + Int_t previousPadZ =-1; + + for (Int_t hit = 0; hit < nhits; hit++) { + Int_t vol[5]; // location for a digit + Int_t digit[2]; // TOF digit variables + Int_t tracknum; + Float_t dxPad; + Float_t dzPad; + Float_t geantTime; + + // fp: really sorry for this, it is a temporary trick to have + // track length too + if (version<6) { //(version!=6 && version!=7) + AliTOFhit *tofHit = (AliTOFhit *) tofHitArray->UncheckedAt(hit); + tracknum = tofHit->GetTrack(); + vol[0] = tofHit->GetSector(); + vol[1] = tofHit->GetPlate(); + vol[2] = tofHit->GetStrip(); + vol[3] = tofHit->GetPadx(); + vol[4] = tofHit->GetPadz(); + dxPad = tofHit->GetDx(); + dzPad = tofHit->GetDz(); + geantTime = tofHit->GetTof(); // unit [s] + } else { + AliTOFhitT0 *tofHit = (AliTOFhitT0 *) tofHitArray->UncheckedAt(hit); + tracknum = tofHit->GetTrack(); + vol[0] = tofHit->GetSector(); + vol[1] = tofHit->GetPlate(); vol[2] = tofHit->GetStrip(); vol[3] = tofHit->GetPadx(); vol[4] = tofHit->GetPadz(); + dxPad = tofHit->GetDx(); + dzPad = tofHit->GetDz(); + geantTime = tofHit->GetTof(); // unit [s] + } + + geantTime *= 1.e+09; // conversion from [s] to [ns] + + // selection case for sdigitizing only hits in a given plate of a given sector + if(thereIsNotASelection || (vol[0]==fSelectedSector && vol[1]==fSelectedPlate)){ Bool_t dummy=((tracknum==previousTrack) && (vol[0]==previousSector) && (vol[1]==previousPlate) && (vol[2]==previousStrip)); Bool_t isCloneOfThePrevious=dummy && ((vol[3]==previousPadX) && (vol[4]==previousPadZ)); - // much stronger check to be inserted here + Bool_t isNeighOfThePrevious=dummy && ((((vol[3]==previousPadX-1) || (vol[3]==previousPadX+1)) && (vol[4]==previousPadZ)) || ((vol[3]==previousPadX) && ((vol[4]==previousPadZ+1) || (vol[4]==previousPadZ-1)))); - if(!isCloneOfThePrevious){ + if(!isCloneOfThePrevious && !isNeighOfThePrevious){ // update "previous" values // in fact, we are yet in the future, so the present is past previousTrack=tracknum; @@ -285,18 +482,11 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { nselectedHits++; nselectedHitsinEv++; - if (particle->GetFirstMother() < 0){ - nHitsFromPrim++; - } // counts hits due to primary particles + if (particle->GetFirstMother() < 0) nHitsFromPrim++; // counts hits due to primary particles - Float_t Xpad = tofHit->GetDx(); - Float_t Zpad = tofHit->GetDz(); - Float_t xStrip=AliTOFConstants::fgkXPad*(vol[3]-0.5-0.5*AliTOFConstants::fgkNpadX)+Xpad; - Float_t zStrip=AliTOFConstants::fgkZPad*(vol[4]-0.5-0.5*AliTOFConstants::fgkNpadZ)+Zpad; - Float_t geantTime = tofHit->GetTof(); // unit [s] - geantTime *= 1.e+09; // conversion from [s] to [ns] - - //cout << "geantTime " << geantTime << " [ns]" << endl; + Float_t xStrip=AliTOFGeometry::XPad()*(vol[3]+0.5-0.5*AliTOFGeometry::NpadX())+dxPad; + Float_t zStrip=AliTOFGeometry::ZPad()*(vol[4]+0.5-0.5*AliTOFGeometry::NpadZ())+dzPad; + Int_t nActivatedPads = 0, nFiredPads = 0; Bool_t isFired[4] = {kFALSE, kFALSE, kFALSE, kFALSE}; Float_t tofAfterSimul[4] = {0., 0., 0., 0.}; @@ -311,29 +501,28 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { if(timediff>=0.2) nlargeTofDiff++; - digit[0] = (Int_t) ((tofAfterSimul[indexOfPad]*1.e+03)/fTdcBin); // TDC bin number (each bin -> 25. ps) + digit[0] = (Int_t) ((tofAfterSimul[indexOfPad]*1.e+03)/AliTOFGeometry::TdcBinWidth()); // TDC bin number (each bin -> 24.4 ps) Float_t landauFactor = gRandom->Landau(fAdcMean, fAdcRms); digit[1] = (Int_t) (qInduced[indexOfPad] * landauFactor); // ADC bins (each bin -> 0.25 (or 0.03) pC) - + // recalculate the volume only for neighbouring pads if(indexOfPad){ - (nPlace[indexOfPad]<=AliTOFConstants::fgkNpadX) ? vol[4] = 1 : vol[4] = 2; - (nPlace[indexOfPad]<=AliTOFConstants::fgkNpadX) ? vol[3] = nPlace[indexOfPad] : vol[3] = nPlace[indexOfPad] - AliTOFConstants::fgkNpadX; + (nPlace[indexOfPad]<=AliTOFGeometry::NpadX()) ? vol[4] = 0 : vol[4] = 1; + (nPlace[indexOfPad]<=AliTOFGeometry::NpadX()) ? vol[3] = nPlace[indexOfPad] - 1 : vol[3] = nPlace[indexOfPad] - AliTOFGeometry::NpadX() - 1; } - - // check if two sdigit are on the same pad; in that case we sum - // the two or more sdigits + // check if two sdigit are on the same pad; + // in that case we sum the two or more sdigits if (hitMap->TestHit(vol) != kEmpty) { AliTOFSDigit *sdig = static_cast(hitMap->GetHit(vol)); Int_t tdctime = (Int_t) digit[0]; Int_t adccharge = (Int_t) digit[1]; - sdig->Update(tdctime,adccharge,tracknum); + sdig->Update(AliTOFGeometry::TdcBinWidth(),tdctime,adccharge,tracknum); ntotalupdatesinEv++; ntotalupdates++; } else { - TOF->AddSDigit(tracknum, vol, digit); + tof->AddSDigit(tracknum, vol, digit); if(indexOfPad){ nnoisesdigits++; @@ -355,25 +544,31 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { } // end loop on ntracks delete hitMap; - - gAlice->TreeS()->Reset(); - gAlice->TreeS()->Fill(); - //gAlice->TreeS()->Write(0,TObject::kOverwrite) ; - gAlice->TreeS()->AutoSave(); - - if(strstr(verboseOption,"all")){ - cout << "----------------------------------------" << endl; - cout << " " << endl; - cout << "After sdigitizing " << nselectedHitsinEv << " hits" << " in event " << ievent << endl; + + fTOFLoader->TreeS()->Reset(); + fTOFLoader->TreeS()->Fill(); + fTOFLoader->WriteSDigits("OVERWRITE"); + + if (tof->SDigits()) tof->ResetSDigits(); + + if (strstr(verboseOption,"all")) { + AliInfo("----------------------------------------"); + AliInfo(" "); + AliInfo(Form("After sdigitizing %d hits in event %d", nselectedHitsinEv, iEvent)); //" (" << nHitsFromPrim << " from primaries and " << nHitsFromSec << " from secondaries) TOF hits, " - cout << ntotalsdigitsinEv << " digits have been created " << endl; - cout << "(" << nsignalsdigitsinEv << " due to signals and " << nnoisesdigitsinEv << " due to border effect)" << endl; - cout << ntotalupdatesinEv << " total updates of the hit map have been performed in current event" << endl; - cout << "----------------------------------------" << endl; + AliInfo(Form("%d digits have been created", ntotalsdigitsinEv)); + AliInfo(Form("(%d due to signals and %d due to border effect)", nsignalsdigitsinEv, nnoisesdigitsinEv)); + AliInfo(Form("%d total updates of the hit map have been performed in current event", ntotalupdatesinEv)); + AliInfo("----------------------------------------"); } } //event loop on events + fTOFLoader->UnloadSDigits(); + fTOFLoader->UnloadHits(); + fRunLoader->UnloadKinematics(); + //fRunLoader->UnloadgAlice(); + // free used memory if (ftail){ delete ftail; @@ -382,51 +577,51 @@ void AliTOFSDigitizer::Exec(Option_t *verboseOption, Option_t *allEvents) { nHitsFromSec=nselectedHits-nHitsFromPrim; if(strstr(verboseOption,"all")){ - cout << "----------------------------------------" << endl; - cout << "----------------------------------------" << endl; - cout << "-----------SDigitization Summary--------" << endl; - cout << " " << endl; - cout << "After sdigitizing " << nselectedHits << " hits" << endl; - cout << "in " << (fEvent2-fEvent1) << " events" << endl; + AliInfo("----------------------------------------"); + AliInfo("----------------------------------------"); + AliInfo("-----------SDigitization Summary--------"); + AliInfo(" "); + AliInfo(Form("After sdigitizing %d hits", nselectedHits)); + AliInfo(Form("in %d events", fEvent2-fEvent1)); //" (" << nHitsFromPrim << " from primaries and " << nHitsFromSec << " from secondaries) TOF hits, " - cout << ntotalsdigits << " sdigits have been created " << endl; - cout << "(" << nsignalsdigits << " due to signals and " << nnoisesdigits << " due to border effect)" << endl; - cout << ntotalupdates << " total updates of the hit map have been performed" << endl; - cout << "in " << nlargeTofDiff << " cases the time of flight difference is greater than 200 ps" << endl; + AliInfo(Form("%d sdigits have been created", ntotalsdigits)); + AliInfo(Form("(%d due to signals and " + "%d due to border effect)", nsignalsdigits, nnoisesdigits)); + AliInfo(Form("%d total updates of the hit map have been performed", ntotalupdates)); + AliInfo(Form("in %d cases the time of flight difference is greater than 200 ps", nlargeTofDiff)); } if(strstr(verboseOption,"tim") || strstr(verboseOption,"all")){ gBenchmark->Stop("TOFSDigitizer"); - cout << "AliTOFSDigitizer:" << endl ; - cout << " took " << gBenchmark->GetCpuTime("TOFSDigitizer") << " seconds in order to make sdigits " - << gBenchmark->GetCpuTime("TOFSDigitizer")/(fEvent2-fEvent1) << " seconds per event " << endl ; - cout << endl ; + AliInfo("AliTOFSDigitizer:"); + AliInfo(Form(" took %f seconds in order to make sdigits " + "%f seconds per event", gBenchmark->GetCpuTime("TOFSDigitizer"), gBenchmark->GetCpuTime("TOFSDigitizer")/(fEvent2-fEvent1))); + AliInfo(" +++++++++++++++++++++++++++++++++++++++++++++++++++ "); } - Print(""); } //__________________________________________________________________ -void AliTOFSDigitizer::Print(Option_t* opt)const +void AliTOFSDigitizer::Print(Option_t* /*opt*/)const { - cout << "------------------- "<< GetName() << " -------------" << endl ; - + AliInfo(Form(" ------------------- %s ------------- ", GetName())); } //__________________________________________________________________ void AliTOFSDigitizer::SelectSectorAndPlate(Int_t sector, Int_t plate) { - Bool_t isaWrongSelection=(sector < 1) || (sector > AliTOFConstants::fgkNSectors) || (plate < 1) || (plate > AliTOFConstants::fgkNPlates); + //Select sector and plate + Bool_t isaWrongSelection=(sector < 0) || (sector >= AliTOFGeometry::NSectors()) || (plate < 0) || (plate >= AliTOFGeometry::NPlates()); if(isaWrongSelection){ - cout << "You have selected an invalid value for sector or plate " << endl; - cout << "The correct range for sector is [1,"<< AliTOFConstants::fgkNSectors <<"]" << endl; - cout << "The correct range for plate is [1,"<< AliTOFConstants::fgkNPlates <<"]" << endl; - cout << "By default we continue sdigitizing all hits in all plates of all sectors" << endl; + AliError("You have selected an invalid value for sector or plate "); + AliError(Form("The correct range for sector is [0,%d]", AliTOFGeometry::NSectors()-1)); + AliError(Form("The correct range for plate is [0,%d]", AliTOFGeometry::NPlates()-1)); + AliError("By default we continue sdigitizing all hits in all plates of all sectors"); } else { fSelectedSector=sector; fSelectedPlate =plate; - cout << "SDigitizing only hits in plate " << fSelectedPlate << " of the sector " << fSelectedSector << endl; + AliInfo(Form("SDigitizing only hits in plate %d of the sector %d", fSelectedPlate, fSelectedSector)); } } @@ -461,7 +656,7 @@ void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t // qCenterPad - charge extimated for each pad, arb. units // weightsSum - sum of weights extimated for each pad fired, arb. units - const Float_t kSigmaForTail[2] = {AliTOFConstants::fgkSigmaForTail1,AliTOFConstants::fgkSigmaForTail2}; //for tail + const Float_t kSigmaForTail[2] = {AliTOFGeometry::SigmaForTail1(),AliTOFGeometry::SigmaForTail2()}; //for tail Int_t iz = 0, ix = 0; Float_t dX = 0., dZ = 0., x = 0., z = 0.; Float_t h = fHparameter, h2 = fH2parameter, k = fKparameter, k2 = fK2parameter; @@ -481,17 +676,17 @@ void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t nFiredPads = 0; (z0 <= 0) ? iz = 0 : iz = 1; - dZ = z0 + (0.5 * AliTOFConstants::fgkNpadZ - iz - 0.5) * AliTOFConstants::fgkZPad; // hit position in the pad frame, (0,0) - center of the pad - z = 0.5 * AliTOFConstants::fgkZPad - TMath::Abs(dZ); // variable for eff., res. and timeWalk. functions - iz++; // z row: 1, ..., AliTOFConstants::fgkNpadZ = 2 - ix = (Int_t)((x0 + 0.5 * AliTOFConstants::fgkNpadX * AliTOFConstants::fgkXPad) / AliTOFConstants::fgkXPad); - dX = x0 + (0.5 * AliTOFConstants::fgkNpadX - ix - 0.5) * AliTOFConstants::fgkXPad; // hit position in the pad frame, (0,0) - center of the pad - x = 0.5 * AliTOFConstants::fgkXPad - TMath::Abs(dX); // variable for eff., res. and timeWalk. functions; - ix++; // x row: 1, ..., AliTOFConstants::fgkNpadX = 48 + dZ = z0 + (0.5 * AliTOFGeometry::NpadZ() - iz - 0.5) * AliTOFGeometry::ZPad(); // hit position in the pad frame, (0,0) - center of the pad + z = 0.5 * AliTOFGeometry::ZPad() - TMath::Abs(dZ); // variable for eff., res. and timeWalk. functions + iz++; // z row: 1, ..., AliTOFGeometry::NpadZ = 2 + ix = (Int_t)((x0 + 0.5 * AliTOFGeometry::NpadX() * AliTOFGeometry::XPad()) / AliTOFGeometry::XPad()); + dX = x0 + (0.5 * AliTOFGeometry::NpadX() - ix - 0.5) * AliTOFGeometry::XPad(); // hit position in the pad frame, (0,0) - center of the pad + x = 0.5 * AliTOFGeometry::XPad() - TMath::Abs(dX); // variable for eff., res. and timeWalk. functions; + ix++; // x row: 1, ..., AliTOFGeometry::NpadX = 48 ////// Pad A: nActivatedPads++; - nPlace[nActivatedPads-1] = (iz - 1) * AliTOFConstants::fgkNpadX + ix; + nPlace[nActivatedPads-1] = (iz - 1) * AliTOFGeometry::NpadX() + ix; qInduced[nActivatedPads-1] = qCenterPad; padId[nActivatedPads-1] = 1; @@ -499,7 +694,7 @@ void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t eff[nActivatedPads-1] = fEffCenter; if (gRandom->Rndm() < eff[nActivatedPads-1]) { nFiredPads = 1; - res[nActivatedPads-1] = 0.001 * TMath::Sqrt(10400 + fResCenter * fResCenter); // 10400=30^2+20^2+40^2+50^2+50^2+50^2 ns; + res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + fResCenter * fResCenter); // ns isFired[nActivatedPads-1] = kTRUE; tofTime[nActivatedPads-1] = gRandom->Gaus(geantTime + fTimeWalkCenter, res[0]); averageTime = tofTime[nActivatedPads-1]; @@ -537,7 +732,7 @@ void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t } (effZ 0) { if( (iz == 1 && dZ > 0) || (iz == 2 && dZ < 0) ) { nActivatedPads++; - nPlace[nActivatedPads-1] = nPlace[0] + (3 - 2 * iz) * AliTOFConstants::fgkNpadX; + nPlace[nActivatedPads-1] = nPlace[0] + (3 - 2 * iz) * AliTOFGeometry::NpadX(); eff[nActivatedPads-1] = effZ; - res[nActivatedPads-1] = 0.001 * TMath::Sqrt(10400 + resZ * resZ); // 10400=30^2+20^2+40^2+50^2+50^2+50^2 ns + res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resZ * resZ); // ns timeWalk[nActivatedPads-1] = 0.001 * timeWalkZ; // ns nTail[nActivatedPads-1] = 2; if (fTimeDelayFlag) { @@ -587,7 +782,7 @@ void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t nActivatedPads++; nPlace[nActivatedPads-1] = nPlace[0] - 1; eff[nActivatedPads-1] = effX; - res[nActivatedPads-1] = 0.001 * TMath::Sqrt(10400 + resX * resX); // 10400=30^2+20^2+40^2+50^2+50^2+50^2 ns + res[nActivatedPads-1] = 0.001 * TMath::Sqrt(fAddTRes*fAddTRes + resX * resX); // ns timeWalk[nActivatedPads-1] = 0.001 * timeWalkX; // ns nTail[nActivatedPads-1] = 2; if (fTimeDelayFlag) { @@ -605,9 +800,9 @@ void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t if(z < k && z > 0) { if( (iz == 1 && dZ > 0) || (iz == 2 && dZ < 0) ) { nActivatedPads++; - nPlace[nActivatedPads-1] = nPlace[0] + (3 - 2 * iz) * AliTOFConstants::fgkNpadX - 1; + nPlace[nActivatedPads-1] = nPlace[0] + (3 - 2 * iz) * AliTOFGeometry::NpadX() - 1; eff[nActivatedPads-1] = effX * effZ; - (resZ 0) { + if(ix < AliTOFGeometry::NpadX() && dX > 0) { nActivatedPads++; nPlace[nActivatedPads-1] = nPlace[0] + 1; eff[nActivatedPads-1] = effX; - res[nActivatedPads-1] = 0.001 * (TMath::Sqrt(10400 + resX * resX)); // ns + res[nActivatedPads-1] = 0.001 * (TMath::Sqrt(fAddTRes*fAddTRes + resX * resX)); // ns timeWalk[nActivatedPads-1] = 0.001 * timeWalkX; // ns nTail[nActivatedPads-1] = 2; if (fTimeDelayFlag) { @@ -656,9 +851,9 @@ void AliTOFSDigitizer::SimulateDetectorResponse(Float_t z0, Float_t x0, Float_t if(z < k && z > 0) { if( (iz == 1 && dZ > 0) || (iz == 2 && dZ < 0) ) { nActivatedPads++; - nPlace[nActivatedPads - 1] = nPlace[0] + (3 - 2 * iz) * AliTOFConstants::fgkNpadX + 1; + nPlace[nActivatedPads - 1] = nPlace[0] + (3 - 2 * iz) * AliTOFGeometry::NpadX() + 1; eff[nActivatedPads - 1] = effX * effZ; - (resZ