#include "AliMUONReconstructor.h"
-#include "AliESD.h"
-#include "AliESDMuonTrack.h"
-#include "AliLog.h"
#include "AliMUONConstants.h"
#include "AliMUONCalibrationData.h"
#include "AliMUONClusterFinderAZ.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackParam.h"
#include "AliMUONTrackExtrap.h"
+#include "AliMUONTracker.h"
#include "AliMUONVTrackReconstructor.h"
#include "AliMUONTrackReconstructor.h"
#include "AliMUONTrackReconstructorK.h"
#include "AliMUONTriggerCrateStore.h"
#include "AliMUONSegFactory.h"
#include "AliMUONSegmentation.h"
-
-#include "AliMpSegmentation.h"
-
#include "AliMUONPreClusterFinder.h"
#include "AliMUONClusterFinderCOG.h"
#include "AliMUONClusterFinderSimpleFit.h"
#include "AliMUONClusterFinderMLEM.h"
-
+
+#include "AliESD.h"
+#include "AliESDMuonTrack.h"
+#include "AliLog.h"
#include "AliRawReader.h"
-#include "AliRun.h"
#include "AliRunLoader.h"
+#include "AliCDBManager.h"
+
#include "TTask.h"
#include "TStopwatch.h"
//_____________________________________________________________________________
AliMUONReconstructor::AliMUONReconstructor()
: AliReconstructor(),
- fRunLoader(0x0),
fDigitMaker(new AliMUONDigitMaker()),
fCalibrationData(0x0),
fCrateManager(new AliMUONTriggerCrateStore()),
fTriggerCircuit(new TClonesArray("AliMUONTriggerCircuit", 234)),
fTransformer(new AliMUONGeometryTransformer(kTRUE)),
- fSegmentation(0x0)
-
+ fSegmentation(0x0),
+ fMUONData(new AliMUONData(0x0,"MUON","MUON"))
{
/// Default constructor
delete fTriggerCircuit;
delete fTransformer;
delete fSegmentation;
+ delete fMUONData;
}
//_____________________________________________________________________________
TTask*
-AliMUONReconstructor::GetCalibrationTask(AliMUONData* data) const
+AliMUONReconstructor::GetCalibrationTask() const
{
/// Create the calibration task(s).
- const AliRun* run = fRunLoader->GetAliRun();
-
+ //const AliRun* run = fRunLoader->GetAliRun();
+ //Int_t runNumber = run->GetRunNumber();
+ Int_t runNumber = AliCDBManager::Instance()->GetRun();
AliInfo("Calibration will occur.");
- Int_t runNumber = run->GetRunNumber();
+
fCalibrationData = new AliMUONCalibrationData(runNumber);
if ( !fCalibrationData->IsValid() )
{
fCalibrationData = 0x0;
return 0x0;
}
+ // Check that we get all the calibrations we'll need
+ if ( !fCalibrationData->Pedestals() ||
+ !fCalibrationData->Gains() ||
+ !fCalibrationData->HV() )
+ {
+ AliFatal("Could not access all required calibration data");
+ }
TTask* calibration = new TTask("MUONCalibrator","MUON Digit calibrator");
- calibration->Add(new AliMUONDigitCalibrator(data,fCalibrationData));
- //FIXME: calibration->Add(something about dead channels should go here).
+
+ TString opt(GetOption());
+ opt.ToUpper();
+ Bool_t statusMap(kTRUE);
+
+ if ( strstr(opt,"NOSTATUSMAP") )
+ {
+ AliWarning("Disconnecting status map : SHOULD BE USED FOR DEBUG ONLY. NOT FOR PRODUCTION !!!");
+ statusMap = kFALSE;
+ }
+ calibration->Add(new AliMUONDigitCalibrator(fMUONData,fCalibrationData,statusMap));
return calibration;
-
-}
-
-//_____________________________________________________________________________
-void
-AliMUONReconstructor::Init(AliRunLoader* runLoader)
-{
-/// Initialize
-
- fRunLoader = runLoader;
}
//_____________________________________________________________________________
AliMUONClusterReconstructor*
-AliMUONReconstructor::CreateClusterReconstructor(AliMUONData* data) const
+AliMUONReconstructor::CreateClusterReconstructor() const
{
/// Create cluster reconstructor
}
AliMUONClusterReconstructor* clusterReco =
- new AliMUONClusterReconstructor(data,clusterFinder,fTransformer);
+ new AliMUONClusterReconstructor(fMUONData,clusterFinder,fTransformer);
return clusterReco;
}
Int_t nEvents = runLoader->GetNumberOfEvents();
Int_t evtNumber = runLoader->GetEventNumber();
- AliMUONData* data = new AliMUONData(loader,"MUON","MUON");
+ fMUONData->SetLoader(loader);
// passing loader as argument.
AliMUONVTrackReconstructor* recoEvent;
- if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(data);
- else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(data,"Combi");
- else recoEvent = new AliMUONTrackReconstructorK(data,"Kalman");
+ if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(fMUONData);
+ else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(fMUONData,"Combi");
+ else recoEvent = new AliMUONTrackReconstructorK(fMUONData,"Kalman");
recoEvent->SetTriggerCircuit(fTriggerCircuit);
- AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor(data);
+ AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor();
AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
loader->LoadRecPoints("RECREATE");
loader->LoadTracks("RECREATE");
- TTask* calibration = GetCalibrationTask(data);
+ TTask* calibration = GetCalibrationTask();
Int_t chBeg = (strstr(GetOption(),"Combi") ? 6 : 0);
// tracking branch
if (!strstr(GetOption(),"Combi")) {
- data->MakeBranch("RC");
- data->SetTreeAddress("D,RC");
+ fMUONData->MakeBranch("RC");
+ fMUONData->SetTreeAddress("D,RC");
} else {
- data->SetTreeAddress("D");
- data->SetTreeAddress("RCC");
+ fMUONData->SetTreeAddress("D");
+ fMUONData->SetTreeAddress("RCC");
}
// Important for avoiding a memory leak when reading digits ( to be investigated more in detail)
// In any case the reading of GLT is needed for the Trigger2Tigger method below
- data->SetTreeAddress("GLT");
+ fMUONData->SetTreeAddress("GLT");
- data->GetDigits();
+ fMUONData->GetDigits();
if ( calibration )
{
if (strstr(GetOption(),"Combi")) {
// Combined cluster / track finder
- AliMUONEventRecoCombi::Instance()->FillEvent(data, (AliMUONClusterFinderAZ*)recModel);
+ AliMUONEventRecoCombi::Instance()->FillEvent(fMUONData, (AliMUONClusterFinderAZ*)recModel);
((AliMUONClusterFinderAZ*) recModel)->SetReco(2);
}
- else data->Fill("RC");
+ else fMUONData->Fill("RC");
// trigger branch
- data->MakeBranch("TC");
- data->SetTreeAddress("TC");
+ fMUONData->MakeBranch("TC");
+ fMUONData->SetTreeAddress("TC");
recoCluster->Trigger2Trigger();
- data->Fill("TC");
+ fMUONData->Fill("TC");
//AZ loader->WriteRecPoints("OVERWRITE");
if (!loader->TreeT()) loader->MakeTracksContainer();
// trigger branch
- data->MakeBranch("RL"); //trigger track
- data->SetTreeAddress("RL");
+ fMUONData->MakeBranch("RL"); //trigger track
+ fMUONData->SetTreeAddress("RL");
recoEvent->EventReconstructTrigger();
- data->Fill("RL");
+ fMUONData->Fill("RL");
// tracking branch
- data->MakeBranch("RT"); //track
- data->SetTreeAddress("RT");
+ fMUONData->MakeBranch("RT"); //track
+ fMUONData->SetTreeAddress("RT");
recoEvent->EventReconstruct();
- data->Fill("RT");
+ fMUONData->Fill("RT");
loader->WriteTracks("OVERWRITE");
if (strstr(GetOption(),"Combi")) {
// Combined cluster / track
((AliMUONClusterFinderAZ*) recModel)->SetReco(1);
- data->MakeBranch("RC");
- data->SetTreeAddress("RC");
- AliMUONEventRecoCombi::Instance()->FillRecP(data, (AliMUONTrackReconstructorK*)recoEvent);
- data->Fill("RC");
+ fMUONData->MakeBranch("RC");
+ fMUONData->SetTreeAddress("RC");
+ AliMUONEventRecoCombi::Instance()->FillRecP(fMUONData, (AliMUONTrackReconstructorK*)recoEvent);
+ fMUONData->Fill("RC");
}
loader->WriteRecPoints("OVERWRITE");
//--------------------------- Resetting branches -----------------------
- data->ResetDigits();
- data->ResetRawClusters();
- data->ResetTrigger();
- data->ResetRecTracks();
- data->ResetRecTriggerTracks();
+ fMUONData->ResetDigits();
+ fMUONData->ResetRawClusters();
+ fMUONData->ResetTrigger();
+ fMUONData->ResetRecTracks();
+ fMUONData->ResetRecTriggerTracks();
}
loader->UnloadDigits();
delete recoCluster;
delete recoEvent;
- delete data;
delete calibration;
}
AliLoader* loader = runLoader->GetLoader("MUONLoader");
Int_t evtNumber = runLoader->GetEventNumber();
- AliMUONData data(loader,"MUON","MUON");
+ fMUONData->SetLoader(loader);
// passing loader as argument.
- fDigitMaker->SetMUONData(&data);
+ fDigitMaker->SetMUONData(fMUONData);
- AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor(&data);
+ // disable trigger rawdata reading
+ if (strstr(GetOption(),"TriggerDisable"))
+ fDigitMaker->DisableTrigger();
- AliMUONVTrackReconstructor *recoEvent;
- if (strstr(GetOption(),"Original")) recoEvent = new AliMUONTrackReconstructor(&data);
- else if (strstr(GetOption(),"Combi")) recoEvent = new AliMUONTrackReconstructorK(&data,"Combi");
- else recoEvent = new AliMUONTrackReconstructorK(&data,"Kalman");
-
- recoEvent->SetTriggerCircuit(fTriggerCircuit);
+ AliMUONClusterReconstructor* recoCluster = CreateClusterReconstructor();
AliMUONClusterFinderVS *recModel = recoCluster->GetRecoModel();
}
recModel->SetGhostChi2Cut(10);
recModel->SetEventNumber(evtNumber);
-
- TTask* calibration = GetCalibrationTask(&data);
+
+ TTask* calibration = GetCalibrationTask();
loader->LoadRecPoints("RECREATE");
- loader->LoadTracks("RECREATE");
- // Digits are not stored on disk and created on flight from rawdata.
+ // Digits are not stored on disk and created on flight from rawdata.
// In order to write digits on disk the following line should be uncommented
// loader->LoadDigits("RECREATE");
TStopwatch rawTimer;
TStopwatch calibTimer;
TStopwatch clusterTimer;
- TStopwatch trackingTimer;
rawTimer.Start(kTRUE); rawTimer.Stop();
calibTimer.Start(kTRUE); calibTimer.Stop();
clusterTimer.Start(kTRUE); clusterTimer.Stop();
- trackingTimer.Start(kTRUE); trackingTimer.Stop();
totalTimer.Start(kTRUE);
AliDebug(1,Form("Event %d",iEvent));
runLoader->GetEvent(iEvent++);
-
+
//----------------------- raw2digits & raw2trigger-------------------
-// if (!loader->TreeD())
-// {
-// AliDebug(1,Form("Making Digit Container for event %d",iEvent));
-// loader->MakeDigitsContainer();
-// }
- // Digits are not stored on disk and created on flight from rawdata.
- // In order to write digits on disk the following lines should be uncommented
- // data.MakeBranch("D,GLT");
- // data.SetTreeAddress("D,GLT");
- data.SetDataContainer("D, GLT");
+ // if (!loader->TreeD())
+ // {
+ // AliDebug(1,Form("Making Digit Container for event %d",iEvent));
+ // loader->MakeDigitsContainer();
+ // }
+ // Digits are not stored on disk and created on flight from rawdata.
+ // In order to write digits on disk the following lines should be uncommented
+ // fMUONData->MakeBranch("D,GLT");
+ // fMUONData->SetTreeAddress("D,GLT");
+ fMUONData->SetDataContainer("D, GLT");
rawTimer.Start(kFALSE);
fDigitMaker->Raw2Digits(rawReader);
rawTimer.Stop();
}
// Digits are not stored on disk and created on flight from rawdata.
// In order to write digits on disk the following lines should be uncommented
- // data.Fill("D,GLT");
+ // fMUONData->Fill("D,GLT");
// loader->WriteDigits("OVERWRITE");
//----------------------- digit2cluster & Trigger2Trigger -------------------
clusterTimer.Start(kFALSE);
if (!loader->TreeR()) loader->MakeRecPointsContainer();
-
+
// tracking branch
- data.MakeBranch("RC");
- data.SetTreeAddress("RC");
+ fMUONData->MakeBranch("RC");
+ fMUONData->SetTreeAddress("RC");
recoCluster->Digits2Clusters();
- data.Fill("RC");
+ fMUONData->Fill("RC");
// trigger branch
- data.MakeBranch("TC");
- data.SetTreeAddress("TC");
- data.Fill("TC");
+ fMUONData->MakeBranch("TC");
+ fMUONData->SetTreeAddress("TC");
+ fMUONData->Fill("TC");
loader->WriteRecPoints("OVERWRITE");
clusterTimer.Stop();
-
- //---------------------------- Track & TriggerTrack ---------------------
- trackingTimer.Start(kFALSE);
- if (!loader->TreeT()) loader->MakeTracksContainer();
-
- // trigger branch
- data.MakeBranch("RL"); //trigger track
- data.SetTreeAddress("RL");
- recoEvent->EventReconstructTrigger();
- data.Fill("RL");
-
- // tracking branch
- data.MakeBranch("RT"); //track
- data.SetTreeAddress("RT");
- recoEvent->EventReconstruct();
- data.Fill("RT");
-
- loader->WriteTracks("OVERWRITE");
- trackingTimer.Stop();
+
//--------------------------- Resetting branches -----------------------
- data.ResetDigits();
- data.ResetRawClusters();
- data.ResetTrigger();
- data.ResetRecTracks();
- data.ResetRecTriggerTracks();
-
+ fMUONData->ResetDigits();
+ fMUONData->ResetRawClusters();
+ fMUONData->ResetTrigger();
}
totalTimer.Stop();
loader->UnloadRecPoints();
- loader->UnloadTracks();
loader->UnloadDigits();
- delete recoEvent;
-
delete recoCluster;
+ delete calibration;
AliInfo(Form("Execution time for converting RAW data to digits in MUON : R:%.2fs C:%.2fs",
rawTimer.RealTime(),rawTimer.CpuTime()));
calibTimer.RealTime(),calibTimer.CpuTime()));
AliInfo(Form("Execution time for clusterizing MUON : R:%.2fs C:%.2fs",
clusterTimer.RealTime(),clusterTimer.CpuTime()));
- AliInfo(Form("Execution time for tracking MUON : R:%.2fs C:%.2fs",
- trackingTimer.RealTime(),trackingTimer.CpuTime()));
AliInfo(Form("Total Execution time for Reconstruct(from raw) MUON : R:%.2fs C:%.2fs",
totalTimer.RealTime(),totalTimer.CpuTime()));
}
AliLoader* loader = runLoader->GetLoader("MUONLoader");
loader->LoadTracks("READ");
- AliMUONData* muonData = new AliMUONData(loader,"MUON","MUON");
+ fMUONData->SetLoader(loader);
// declaration
Int_t iEvent;// nPart;
Int_t nTrackHits;// nPrimary;
- Double_t fitFmin;
-
- Double_t bendingSlope, nonBendingSlope, inverseBendingMomentum;
- Double_t xRec, yRec, zRec, chi2MatchTrigger;
+ Double_t fitFmin, chi2MatchTrigger;
+ Double_t xRec, yRec, zRec, bendingSlope, nonBendingSlope, inverseBendingMomentum;
+ Double_t xVtx, yVtx, zVtx, bendingSlopeAtVtx, nonBendingSlopeAtVtx, inverseBendingMomentumAtVtx;
Bool_t matchTrigger;
// setting pointer for tracks, triggertracks & trackparam at vertex
AliMUONTrack* recTrack = 0;
- AliMUONTrackParam* trackParam = 0;
+ AliMUONTrackParam trackParamAtVtx;
AliMUONTriggerTrack* recTriggerTrack = 0;
iEvent = runLoader->GetEventNumber();
const AliESDVertex *esdVert = esd->GetVertex();
if (esdVert->GetNContributors()) {
esdVert->GetXYZ(vertex);
- printf("find vertex\n");
+ AliDebug(1, "find vertex\n");
}
// setting ESD MUON class
AliESDMuonTrack* theESDTrack = new AliESDMuonTrack() ;
//-------------------- trigger tracks-------------
Long_t trigPat = 0;
- muonData->SetTreeAddress("RL");
- muonData->GetRecTriggerTracks();
- recTrigTracksArray = muonData->RecTriggerTracks();
+ fMUONData->SetTreeAddress("RL");
+ fMUONData->GetRecTriggerTracks();
+ recTrigTracksArray = fMUONData->RecTriggerTracks();
// ready global trigger pattern from first track
if (recTrigTracksArray)
//printf(">>> Event %d Number of Recconstructed tracks %d \n",iEvent, nrectracks);
// -------------------- tracks-------------
- muonData->SetTreeAddress("RT");
- muonData->GetRecTracks();
- recTracksArray = muonData->RecTracks();
+ fMUONData->SetTreeAddress("RT");
+ fMUONData->GetRecTracks();
+ recTracksArray = fMUONData->RecTracks();
Int_t nRecTracks = 0;
if (recTracksArray)
// reading info from tracks
recTrack = (AliMUONTrack*) recTracksArray->At(iRecTracks);
-
- trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
+ AliMUONTrackParam *trackParam = (AliMUONTrackParam*) (recTrack->GetTrackParamAtHit())->First();
+ trackParamAtVtx = *trackParam;
+ // extrapolate to the vertex if available, else to (0,0,0)
if (esdVert->GetNContributors())
- AliMUONTrackExtrap::ExtrapToVertex(trackParam, vertex[0],vertex[1],vertex[2]);
-
- bendingSlope = trackParam->GetBendingSlope();
- nonBendingSlope = trackParam->GetNonBendingSlope();
- inverseBendingMomentum = trackParam->GetInverseBendingMomentum();
- xRec = trackParam->GetNonBendingCoor();
- yRec = trackParam->GetBendingCoor();
- zRec = trackParam->GetZ();
-
+ AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0],vertex[1],vertex[2]);
+ else
+ AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, 0.,0.,0.);
+
+ // Track parameters at first station
+ bendingSlope = trackParam->GetBendingSlope();
+ nonBendingSlope = trackParam->GetNonBendingSlope();
+ inverseBendingMomentum = trackParam->GetInverseBendingMomentum();
+ xRec = trackParam->GetNonBendingCoor();
+ yRec = trackParam->GetBendingCoor();
+ zRec = trackParam->GetZ();
+
+ // Track parameters at vertex
+ bendingSlopeAtVtx = trackParamAtVtx.GetBendingSlope();
+ nonBendingSlopeAtVtx = trackParamAtVtx.GetNonBendingSlope();
+ inverseBendingMomentumAtVtx = trackParamAtVtx.GetInverseBendingMomentum();
+ xVtx = trackParamAtVtx.GetNonBendingCoor();
+ yVtx = trackParamAtVtx.GetBendingCoor();
+ zVtx = trackParamAtVtx.GetZ();
+
+ // Global info
nTrackHits = recTrack->GetNTrackHits();
fitFmin = recTrack->GetFitFMin();
matchTrigger = recTrack->GetMatchTrigger();
chi2MatchTrigger = recTrack->GetChi2MatchTrigger();
// setting data member of ESD MUON
- theESDTrack->SetInverseBendingMomentum(inverseBendingMomentum);
- theESDTrack->SetThetaX(TMath::ATan(nonBendingSlope));
- theESDTrack->SetThetaY(TMath::ATan(bendingSlope));
- theESDTrack->SetZ(zRec);
- theESDTrack->SetBendingCoor(yRec); // calculate vertex at ESD or Tracking level ?
- theESDTrack->SetNonBendingCoor(xRec);
+ // at first station
+ theESDTrack->SetInverseBendingMomentumUncorrected(inverseBendingMomentum);
+ theESDTrack->SetThetaXUncorrected(TMath::ATan(nonBendingSlope));
+ theESDTrack->SetThetaYUncorrected(TMath::ATan(bendingSlope));
+ theESDTrack->SetZUncorrected(zRec);
+ theESDTrack->SetBendingCoorUncorrected(yRec);
+ theESDTrack->SetNonBendingCoorUncorrected(xRec);
+ // at vertex
+ theESDTrack->SetInverseBendingMomentum(inverseBendingMomentumAtVtx);
+ theESDTrack->SetThetaX(TMath::ATan(nonBendingSlopeAtVtx));
+ theESDTrack->SetThetaY(TMath::ATan(bendingSlopeAtVtx));
+ theESDTrack->SetZ(zVtx);
+ theESDTrack->SetBendingCoor(yVtx);
+ theESDTrack->SetNonBendingCoor(xVtx);
+ // global info
theESDTrack->SetChi2(fitFmin);
theESDTrack->SetNHit(nTrackHits);
theESDTrack->SetMatchTrigger(matchTrigger);
} // end loop tracks
// reset muondata
- muonData->ResetRecTracks();
- muonData->ResetRecTriggerTracks();
+ fMUONData->ResetRecTracks();
+ fMUONData->ResetRecTriggerTracks();
//} // end loop on event
loader->UnloadTracks();
delete theESDTrack;
- delete muonData;
-}//_____________________________________________________________________________
+}
+
+//_____________________________________________________________________________
void AliMUONReconstructor::FillESD(AliRunLoader* runLoader, AliRawReader* /*rawReader*/, AliESD* esd) const
{
/// Fill ESD
// don't need rawReader ???
FillESD(runLoader, esd);
}
+
+//_____________________________________________________________________________
+AliTracker* AliMUONReconstructor::CreateTracker(AliRunLoader* runLoader) const
+{
+ /// create tracker for MUON
+ /// go into the tracking framework finally (Ch.F)
+
+ AliLoader* loader = runLoader->GetLoader("MUONLoader");
+
+ fMUONData->SetLoader(loader);
+
+ AliMUONTracker* tracker = new AliMUONTracker();
+ tracker->SetMUONData(fMUONData);
+ tracker->SetTriggerCircuit(fTriggerCircuit);
+ tracker->SetOption(GetOption());
+
+ return tracker;
+
+}