#include "AliMUON.h"
#include "AliMUONTriggerTrack.h"
#include "AliMUONEventReconstructor.h"
+#include "AliMUONClusterReconstructor.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackParam.h"
#include "AliMUONChamberTrigger.h"
-#include "AliMUONClusterFinderVS.h"
+#include "AliMUONClusterFinderAZ.h"
#include "AliMUONClusterInput.h"
#include "AliMUONConstants.h"
#include "AliMUONDigit.h"
void AliMUON::SetTreeAddress()
{
GetMUONData()->SetLoader(fLoader);
- GetMUONData()->MakeBranch("D,RC");
- GetMUONData()->SetTreeAddress("H,D,RC");
+ // GetMUONData()->MakeBranch("D,RC");
+ // GetMUONData()->SetTreeAddress("H,D,RC");
+ GetMUONData()->SetTreeAddress("H");
fHits = GetMUONData()->Hits(); // Added by Ivana to use the methods FisrtHit, NextHit of AliDetector
}
Info("MakeLoader",
"Creating standard getter for detector %s. Top folder is %s.",
GetName(),topfoldername);
-
fLoader = new AliLoader(GetName(),topfoldername);
fMUONData = new AliMUONData(fLoader,GetName(),GetName());
fMUONData->SetSplitLevel(fSplitLevel);
Int_t pairLike[3] = {0,0,0};
ResetTrigger();
- AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
+ AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(fLoader,1);
decision->Trigger();
decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
pairUnlike, pairLike);
//________________________________________________________________________
void AliMUON::Reconstruct() const
{
-// reconstruct clusters
// AliLoader* loader = GetLoader();
+
AliRunLoader* runLoader = fLoader->GetRunLoader();
Int_t nEvents = runLoader->GetNumberOfEvents();
+// used local container for each method
+// passing fLoader as argument, could be avoided ???
+ AliMUONEventReconstructor* recoEvent = new AliMUONEventReconstructor(fLoader);
+ AliMUONData* dataEvent = recoEvent->GetMUONData();
+
+ AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(fLoader);
+ AliMUONData* dataCluster = recoCluster->GetMUONData();
+
+ AliMUONTriggerDecision* trigDec = new AliMUONTriggerDecision(fLoader);
+ AliMUONData* dataTrig = trigDec->GetMUONData();
+
+
for (Int_t i = 0; i < 10; i++) {
AliMUONClusterFinderVS *RecModel = new AliMUONClusterFinderVS();
RecModel->SetGhostChi2Cut(10);
- const_cast<AliMUON*>(this)->SetReconstructionModel(i,RecModel);
+ recoCluster->SetReconstructionModel(i,RecModel);
}
- AliMUONEventReconstructor* reco = new AliMUONEventReconstructor();
-
+ fLoader->LoadDigits("READ");
fLoader->LoadRecPoints("RECREATE");
fLoader->LoadTracks("RECREATE");
- fLoader->LoadDigits("READ");
-
-
+
// Loop over events
for(Int_t ievent = 0; ievent < nEvents; ievent++) {
printf("Event %d\n",ievent);
runLoader->GetEvent(ievent);
- //---------------------------- digit2Reco & Trigger ---------------------
+ //----------------------- digit2cluster & Digits2Trigger -------------------
if (!fLoader->TreeR()) fLoader->MakeRecPointsContainer();
// tracking branch
- fMUONData->MakeBranch("RC");
- fMUONData->SetTreeAddress("D,RC");
- const_cast<AliMUON*>(this)->Digits2Reco();
+ dataCluster->MakeBranch("RC");
+ dataCluster->SetTreeAddress("D,RC");
+ recoCluster->Digits2Clusters();
+ dataCluster->Fill("RC");
// trigger branch
- fMUONData->MakeBranch("GLT");
- fMUONData->SetTreeAddress("D,GLT");
- const_cast<AliMUON*>(this)->Trigger(ievent);
+ dataTrig->MakeBranch("GLT");
+ dataTrig->SetTreeAddress("D,GLT");
+ trigDec->Digits2Trigger();
+ dataTrig->Fill("GLT");
+
+ fLoader->WriteRecPoints("OVERWRITE");
//---------------------------- Track & TriggerTrack ---------------------
if (!fLoader->TreeT()) fLoader->MakeTracksContainer();
+ // tracking branch
+ dataEvent->MakeBranch("RT"); //track
+ dataEvent->SetTreeAddress("RT");
+ recoEvent->EventReconstruct();
+ dataEvent->Fill("RT");
- fMUONData->MakeBranch("RT"); //track
- fMUONData->SetTreeAddress("RT");
- reco->EventReconstruct();
- for(Int_t i=0; i<reco->GetNRecTracks(); i++) {
- AliMUONTrack * track = (AliMUONTrack*) reco->GetRecTracksPtr()->At(i);
- fMUONData->AddRecTrack(*track);
- }
- fMUONData->Fill("RT");
-
- fMUONData->MakeBranch("RL"); //trigger track
- fMUONData->SetTreeAddress("RL");
- reco->EventReconstructTrigger();
- for(Int_t i=0; i<reco->GetNRecTriggerTracks(); i++) {
- AliMUONTriggerTrack * triggertrack = (AliMUONTriggerTrack*) reco->GetRecTriggerTracksPtr()->At(i);
- fMUONData->AddRecTriggerTrack(*triggertrack);
- }
- fMUONData->Fill("RL");
+ // trigger branch
+ dataEvent->MakeBranch("RL"); //trigger track
+ dataEvent->SetTreeAddress("RL");
+ recoEvent->EventReconstructTrigger();
+ dataEvent->Fill("RL");
fLoader->WriteTracks("OVERWRITE");
//--------------------------- Resetting branches -----------------------
- fMUONData->ResetDigits();
- fMUONData->ResetRawClusters();
- fMUONData->ResetTrigger();
- fMUONData->ResetRecTracks();
- fMUONData->ResetRecTriggerTracks();
+ dataCluster->ResetDigits();
+ dataCluster->ResetRawClusters();
+
+ dataTrig->ResetDigits();
+ dataTrig->ResetTrigger();
+
+ dataEvent->ResetRawClusters();
+ dataEvent->ResetTrigger();
+ dataEvent->ResetRecTracks();
+ dataEvent->ResetRecTriggerTracks();
+
}
fLoader->UnloadDigits();
fLoader->UnloadRecPoints();
fLoader->UnloadTracks();
- //delete reco;
+
+ delete recoCluster;
+ delete recoEvent;
+ delete trigDec;
}
//________________________________________________________________________
void AliMUON::FillESD(AliESD* event) const
ESDTrack->SetY11(y11);
}
// storing ESD MUON Track into ESD Event & reset muondata
- if (ntrectracks+ntrectracks != 0) //YS
+ if (ntrectracks+ntrectracks != 0)
event->AddMuonTrack(ESDTrack);
} // end loop tracks
- if (ntrectracks+ntrectracks != 0) //YS
- event->SetTrigger(trigPat);
-
+ // if (ntrectracks+ntrectracks != 0)
+ // event->SetTrigger(trigPat);
+ // Waiting for STEER update
fMUONData->ResetRecTracks();
fMUONData->ResetRecTriggerTracks();
- //YS } // end loop on event
- fLoader->UnloadTracks(); //YS
+ //} // end loop on event
+ fLoader->UnloadTracks();
}
--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, 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. *
+ **************************************************************************/
+
+/* $Id$ */
+
+////////////////////////////////////
+//
+// MUON event reconstructor in ALICE
+//
+// This class contains as data:
+// * the parameters for the event reconstruction
+// * a pointer to the array of hits to be reconstructed (the event)
+// * a pointer to the array of segments made with these hits inside each station
+// * a pointer to the array of reconstructed tracks
+//
+// It contains as methods, among others:
+// * MakeEventToBeReconstructed to build the array of hits to be reconstructed
+// * MakeSegments to build the segments
+// * MakeTracks to build the tracks
+//
+////////////////////////////////////
+
+#include <Riostream.h> // for cout
+#include <stdlib.h> // for exit()
+
+#include <TTree.h>
+
+#include "AliMUON.h"
+#include "AliMUONClusterReconstructor.h"
+#include "AliMUONDigit.h"
+#include "AliMUONConstants.h"
+#include "AliMUONData.h"
+#include "AliMUONClusterFinderVS.h"
+#include "AliMUONClusterFinderAZ.h"
+#include "AliMUONClusterInput.h"
+#include "AliMUONRawCluster.h"
+#include "AliRun.h" // for gAlice
+#include "AliConfig.h"
+#include "AliRunLoader.h"
+#include "AliLoader.h"
+
+static const Int_t kDefaultPrintLevel = 0;
+
+ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
+
+//__________________________________________________________________________
+AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
+{
+ // Default Constructor
+
+ fDebug = 0;
+ fNCh = 0;
+ fNTrackingCh = 0;
+ fChambers = 0;
+ fMUONData = 0;
+ fChambers = new TObjArray(AliMUONConstants::NCh());
+
+ fPrintLevel = kDefaultPrintLevel;
+
+ // initialize loader's
+ fLoader = loader;
+
+ // initialize container
+ fMUONData = new AliMUONData(fLoader,"MUON","MUON");
+
+ // Loading AliRun master
+ AliRunLoader* runloader = fLoader->GetRunLoader();
+ if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+ gAlice = runloader->GetAliRun();
+
+ // getting MUON
+ fMUON = (AliMUON*) gAlice->GetDetector("MUON");
+
+ return;
+}
+//____________________________________________________________________
+void AliMUONClusterReconstructor::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
+{
+ // take infos chambers from AliMUON
+ AliMUONChamber* pCh = 0;
+ pCh = &(fMUON->Chamber(id));
+
+ fChambers->AddAt(pCh, id);
+
+ // Set ClusterFinder for chamber id
+ ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
+}
+//_______________________________________________________________________
+AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& Reconstructor):TObject(Reconstructor)
+{
+ // Dummy copy constructor
+}
+
+AliMUONClusterReconstructor & AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& /*Reconstructor*/)
+{
+ // Dummy assignment operator
+ return *this;
+}
+
+//__________________________________________________________________________
+AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
+{
+ if (fChambers){
+ fChambers->Delete();
+ delete fChambers;
+ }
+ if (fMUONData)
+ delete fMUONData;
+
+ return;
+}
+//____________________________________________________________________
+void AliMUONClusterReconstructor::Digits2Clusters()
+{
+//
+// Perform cluster finding
+//
+ TClonesArray *dig1, *dig2;
+ Int_t ndig, k;
+ dig1 = new TClonesArray("AliMUONDigit",1000);
+ dig2 = new TClonesArray("AliMUONDigit",1000);
+ AliMUONDigit *digit;
+// Loop on chambers and on cathode planes
+//
+// fMUONData->ResetRawClusters();
+ TClonesArray * muonDigits;
+
+ for (Int_t ich = 0; ich < 10; ich++) {
+ AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
+ AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
+ //AliMUONClusterFinderAZ* rec = (AliMUONClusterFinderAZ*)iChamber->ReconstructionModel();
+
+ fMUONData->ResetDigits();
+ fMUONData->GetCathode(0);
+ //TClonesArray *
+ muonDigits = fMUONData->Digits(ich);
+ ndig=muonDigits->GetEntriesFast();
+ if(fDebug)
+ printf("1 Found %d digits in %p chamber %d\n", ndig, muonDigits,ich);
+ TClonesArray &lhits1 = *dig1;
+ Int_t n = 0;
+ for (k = 0; k < ndig; k++) {
+ digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
+ if (rec->TestTrack(digit->Track(0)))
+ new(lhits1[n++]) AliMUONDigit(*digit);
+ }
+ fMUONData->ResetDigits();
+ fMUONData->GetCathode(1);
+ muonDigits = fMUONData->Digits(ich);
+ ndig=muonDigits->GetEntriesFast();
+ if(fDebug)
+ printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
+ TClonesArray &lhits2 = *dig2;
+ n=0;
+
+ for (k=0; k<ndig; k++) {
+ digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
+ if (rec->TestTrack(digit->Track(0)))
+ new(lhits2[n++]) AliMUONDigit(*digit);
+ }
+
+ if (rec) {
+ AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
+ rec->FindRawClusters();
+ }
+ // copy into the container
+ TClonesArray* tmp = rec->GetRawClusters();
+ for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
+ AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
+ fMUONData->AddRawCluster(ich, *pClus);
+ }
+ dig1->Delete();
+ dig2->Delete();
+ } // for ich
+ delete dig1;
+ delete dig2;
+}
void AliMUONDisplay::Trigger()
{
// returns Trigger Decision for current event
- AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
+ AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
+ AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(pMUON->GetLoader());
+
+ // AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
decision->Trigger();
}
#include <TTree.h>
#include "AliMUON.h"
-#include "AliMUONChamber.h"
+//#include "AliMUONChamber.h"
#include "AliMUONEventReconstructor.h"
#include "AliMUONHitForRec.h"
#include "AliMUONTriggerTrack.h"
//#include "AliMUONTriggerConstants.h"
#include "AliMUONTriggerCircuit.h"
#include "AliMUONRawCluster.h"
-#include "AliMUONGlobalTrigger.h"
#include "AliMUONLocalTrigger.h"
+#include "AliMUONGlobalTrigger.h"
#include "AliMUONRecoEvent.h"
#include "AliMUONSegment.h"
#include "AliMUONTrack.h"
ClassImp(AliMUONEventReconstructor) // Class implementation in ROOT context
//__________________________________________________________________________
-AliMUONEventReconstructor::AliMUONEventReconstructor(void)
+AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
{
// Constructor for class AliMUONEventReconstructor
SetReconstructionParametersToDefaults();
fRecoEvent = 0;
fEventTree = 0;
fTreeFile = 0;
-
+
+ // initialize loader's
+ fLoader = loader;
+
+ // initialize container
+ fMUONData = new AliMUONData(fLoader,"MUON","MUON");
+
+ // Loading AliRun master
+ AliRunLoader* runloader = fLoader->GetRunLoader();
+ if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+ gAlice = runloader->GetAliRun();
+
return;
}
-
+ //__________________________________________________________________________
AliMUONEventReconstructor::AliMUONEventReconstructor (const AliMUONEventReconstructor& Reconstructor):TObject(Reconstructor)
{
// Dummy copy constructor
// To make the list of hits to be reconstructed,
// either from the GEANT hits or from the raw clusters
// according to the parameter set for the reconstructor
- TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
+// TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
- AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
- if (rl == 0x0)
- {
- Error("MakeEventToBeReconstructed",
- "Can not find Run Loader in Event Folder named %s.",
- evfoldname.Data());
- return;
- }
- AliLoader* gime = rl->GetLoader("MUONLoader");
- if (gime == 0x0)
- {
- Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
- return;
- }
+// AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
+// if (rl == 0x0)
+// {
+// Error("MakeEventToBeReconstructed",
+// "Can not find Run Loader in Event Folder named %s.",
+// evfoldname.Data());
+// return;
+// }
+// AliLoader* gime = rl->GetLoader("MUONLoader");
+// if (gime == 0x0)
+// {
+// Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
+// return;
+// }
if (fPrintLevel >= 1) cout << "enter MakeEventToBeReconstructed" << endl;
ResetHitsForRec();
if (fRecGeantHits == 1) {
// Reconstruction from GEANT hits
// Back to the signal file
- TTree* treeH = gime->TreeH();
+ TTree* treeH = fLoader->TreeH();
if (treeH == 0x0)
{
- Int_t retval = gime->LoadHits();
+ Int_t retval = fLoader->LoadHits();
if ( retval)
{
Error("MakeEventToBeReconstructed","Error occured while loading hits.");
return;
}
- treeH = gime->TreeH();
+ treeH = fLoader->TreeH();
if (treeH == 0x0)
{
Error("MakeEventToBeReconstructed","Can not get TreeH");
return;
}
}
-
- AddHitsForRecFromGEANT(treeH);
+ fMUONData->SetTreeAddress("H");
+ AddHitsForRecFromGEANT(treeH);
// Background hits
AddHitsForRecFromBkgGEANT(fBkgGeantTH, fBkgGeantHits);
// Security on MUON ????
// TreeR assumed to be be "prepared" in calling function
// by "MUON->GetTreeR(nev)" ????
- TTree *treeR = gime->TreeR();
+ TTree *treeR = fLoader->TreeR();
+ fMUONData->SetTreeAddress("RC");
AddHitsForRecFromRawClusters(treeR);
// No sorting: it is done automatically in the previous function
}
if (fPrintLevel >= 2)
cout << "enter AddHitsForRecFromGEANT with TH: " << TH << endl;
if (TH == NULL) return;
- AliMUON *pMUON = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
- AliMUONData * muondata = pMUON->GetMUONData();
+ // AliMUON *pMUON = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
+ //AliMUONData * muondata = pMUON->GetMUONData();
// Security on MUON ????
// See whether it could be the same for signal and background ????
// Loop over tracks in tree
cout << "ntracks: " << ntracks << endl;
fMuons = 0; //AZ
for (Int_t track = 0; track < ntracks; track++) {
- muondata->ResetHits();
+ fMUONData->ResetHits();
TH->GetEvent(track);
// Loop over hits
Int_t hit = 0;
Int_t itrack = track; //AZ
Int_t ihit, nhits=0;
- nhits = (Int_t) muondata->Hits()->GetEntriesFast();
+ nhits = (Int_t) fMUONData->Hits()->GetEntriesFast();
AliMUONHit* mHit=0x0;
for(ihit=0; ihit<nhits; ihit++) {
- mHit = static_cast<AliMUONHit*>(muondata->Hits()->At(ihit));
+ mHit = static_cast<AliMUONHit*>(fMUONData->Hits()->At(ihit));
Int_t ipart = TMath::Abs ((Int_t) mHit->Particle()); //AZ
if (NewHitForRecFromGEANT(mHit,track, hit, 1) && ipart == 13
//if (NewHitForRecFromGEANT(mHit,itrack-1, hit, 1) && ipart == 13
TClonesArray *rawclusters;
if (fPrintLevel >= 1) cout << "enter AddHitsForRecFromRawClusters" << endl;
- TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
- AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
- if (rl == 0x0)
- {
- Error("MakeEventToBeReconstructed",
- "Can not find Run Loader in Event Folder named %s.",
- evfoldname.Data());
- return;
- }
- AliLoader* gime = rl->GetLoader("MUONLoader");
- if (gime == 0x0)
- {
- Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
- return;
- }
- // Loading AliRun master
- if (rl->GetAliRun() == 0x0) rl->LoadgAlice();
- gAlice = rl->GetAliRun();
+// TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
+// AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
+// if (rl == 0x0)
+// {
+// Error("MakeEventToBeReconstructed",
+// "Can not find Run Loader in Event Folder named %s.",
+// evfoldname.Data());
+// return;
+// }
+// AliLoader* gime = rl->GetLoader("MUONLoader");
+// if (gime == 0x0)
+// {
+// Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
+// return;
+// }
+// // Loading AliRun master
+// rl->LoadgAlice();
+// gAlice = rl->GetAliRun();
// Loading MUON subsystem
- AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
+ // AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
nTRentries = Int_t(TR->GetEntries());
if (nTRentries != 1) {
cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
exit(0);
}
- gime->TreeR()->GetEvent(0); // only one entry
+ fLoader->TreeR()->GetEvent(0); // only one entry
+
// Loop over tracking chambers
for (Int_t ch = 0; ch < kMaxMuonTrackingChambers; ch++) {
// number of HitsForRec to 0 for the chamber
// index of first HitForRec for the chamber
if (ch == 0) fIndexOfFirstHitForRecPerChamber[ch] = 0;
else fIndexOfFirstHitForRecPerChamber[ch] = fNHitsForRec;
- rawclusters = pMUON->GetMUONData()->RawClusters(ch);
+ rawclusters =fMUONData->RawClusters(ch);
// pMUON->ResetRawClusters();
// TR->GetEvent((Int_t) (TR->GetEntries()) - 1); // to be checked ????
nclus = (Int_t) (rawclusters->GetEntries());
// Remove double tracks
RemoveDoubleTracks();
}
+ // AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
+ for(Int_t i=0; i<GetNRecTracks(); i++) {
+ AliMUONTrack * track = (AliMUONTrack*) GetRecTracksPtr()->At(i);
+ fMUONData->AddRecTrack(*track);
+ }
return;
}
{
// To make the trigger tracks from Local Trigger
if (fPrintLevel >= 1) cout << "enter MakeTriggerTracks" << endl;
- ResetTriggerTracks();
+ // ResetTriggerTracks();
Int_t nTRentries;
+ Long_t gloTrigPat;
TClonesArray *localTrigger;
TClonesArray *globalTrigger;
AliMUONLocalTrigger *locTrg;
AliMUONGlobalTrigger *gloTrg;
AliMUONTriggerCircuit *circuit;
- AliMUONTriggerTrack *recTriggerTrack;
- Long_t gloTrigPat;
-
- TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
- AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
- if (rl == 0x0)
- {
- Error("MakeTriggerTracks",
- "Can not find Run Loader in Event Folder named %s.",
- evfoldname.Data());
- return;
- }
- AliLoader* gime = rl->GetLoader("MUONLoader");
- if (gime == 0x0)
- {
- Error("MakeTriggerTracks","Can not get MUON Loader from Run Loader.");
- return;
- }
- TTree* TR = gime->TreeR();
+ AliMUONTriggerTrack *recTriggerTrack = 0;
+// TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
+// AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
+// if (rl == 0x0)
+// {
+// Error("MakeTriggerTracks",
+// "Can not find Run Loader in Event Folder named %s.",
+// evfoldname.Data());
+// return;
+// }
+// AliLoader* gime = rl->GetLoader("MUONLoader");
+// if (gime == 0x0)
+// {
+// Error("MakeTriggerTracks","Can not get MUON Loader from Run Loader.");
+// return;
+// }
+ TTree* TR = fLoader->TreeR();
// Loading AliRun master
- if (rl->GetAliRun() == 0x0) rl->LoadgAlice();
- gAlice = rl->GetAliRun();
+// rl->LoadgAlice();
+// gAlice = rl->GetAliRun();
// Loading MUON subsystem
AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
nTRentries = Int_t(TR->GetEntries());
if (nTRentries != 1) {
- cout << "Error in AliMUONEventReconstructor::MakeTriggerTracks"
- << endl;
- cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
- exit(0);
+ cout << "Error in AliMUONEventReconstructor::MakeTriggerTracks"
+ << endl;
+ cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
+ exit(0);
}
- gime->TreeR()->GetEvent(0); // only one entry
+ fLoader->TreeR()->GetEvent(0); // only one entry
- pMUON->GetMUONData()->SetTreeAddress("GLT");
- pMUON->GetMUONData()->GetTrigger();
+ fMUONData->SetTreeAddress("GLT");
+ fMUONData->GetTrigger();
-// global trigger
+ // global trigger for trigger pattern
gloTrigPat = 0;
- globalTrigger = pMUON->GetMUONData()->GlobalTrigger();
+ globalTrigger = fMUONData->GlobalTrigger();
gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
if (gloTrg->SinglePlusLpt()) gloTrigPat|= 0x1;
if (gloTrg->SinglePlusHpt()) gloTrigPat|= 0x2;
if (gloTrg->PairLikeHpt()) gloTrigPat|= 0x2000;
if (gloTrg->PairLikeApt()) gloTrigPat|= 0x4000;
-// local trigger
- localTrigger = pMUON->GetMUONData()->LocalTrigger();
+
+
+ // local trigger for tracking
+ localTrigger = fMUONData->LocalTrigger();
Int_t nlocals = (Int_t) (localTrigger->GetEntries());
Float_t z11 = ( &(pMUON->Chamber(10)) )->Z();
Float_t z21 = ( &(pMUON->Chamber(12)) )->Z();
for (Int_t i=0; i<nlocals; i++) { // loop on Local Trigger
- locTrg = (AliMUONLocalTrigger*)localTrigger->UncheckedAt(i);
- circuit = &(pMUON->TriggerCircuit(locTrg->LoCircuit()));
- Float_t y11 = circuit->GetY11Pos(locTrg->LoStripX());
- Float_t y21 = circuit->GetY21Pos(locTrg->LoStripX());
- Float_t x11 = circuit->GetX11Pos(locTrg->LoStripY());
- Float_t thetax = TMath::ATan2( x11 , z11 );
- Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
-
- recTriggerTrack = new ((*fRecTriggerTracksPtr)[fNRecTriggerTracks])
- AliMUONTriggerTrack(x11,y11,thetax,thetay,gloTrigPat,this);
-// since static statement does not work, set gloTrigPat for each track
- fNRecTriggerTracks++;
+ locTrg = (AliMUONLocalTrigger*)localTrigger->UncheckedAt(i);
+ circuit = &(pMUON->TriggerCircuit(locTrg->LoCircuit()));
+ Float_t y11 = circuit->GetY11Pos(locTrg->LoStripX());
+ Float_t y21 = circuit->GetY21Pos(locTrg->LoStripX());
+ Float_t x11 = circuit->GetX11Pos(locTrg->LoStripY());
+ Float_t thetax = TMath::ATan2( x11 , z11 );
+ Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
+
+ recTriggerTrack = new AliMUONTriggerTrack(x11,y11,thetax,thetay,gloTrigPat,this);
+ // since static statement does not work, set gloTrigPat for each track
+
+ // fNRecTriggerTracks++;
+ fMUONData->AddRecTriggerTrack(*recTriggerTrack);
} // end of loop on Local Trigger
return;
}
// Dump reconstructed trigger event
// and the particle parameters
- AliMUONTriggerTrack *triggertrack;
- Int_t trackIndex;
+ AliMUONTriggerTrack *triggertrack ;
+ Int_t nTriggerTracks = fMUONData->RecTriggerTracks()->GetEntriesFast();
- if (fPrintLevel >= 1) cout << "****** enter EventDumpTrigger ******" << endl;
if (fPrintLevel >= 1) {
- cout << " Number of Reconstructed tracks :" << fNRecTriggerTracks << endl;
+ cout << "****** enter EventDumpTrigger ******" << endl;
+ cout << " Number of Reconstructed tracks :" << nTriggerTracks << endl;
}
// Loop over reconstructed tracks
- for (trackIndex = 0; trackIndex < fNRecTriggerTracks; trackIndex++) {
- triggertrack = (AliMUONTriggerTrack*) ((*fRecTriggerTracksPtr)[trackIndex]);
+ for (Int_t trackIndex = 0; trackIndex < nTriggerTracks; trackIndex++) {
+ triggertrack = (AliMUONTriggerTrack*)fMUONData->RecTriggerTracks()->At(trackIndex);
printf(" trigger track number %i x11=%f y11=%f thetax=%f thetay=%f \n",
trackIndex,
triggertrack->GetX11(),triggertrack->GetY11(),
class TFile;
class TTree;
class AliMUONRecoEvent;
+class AliMUONData;
+class AliRunLoader;
+class AliLoader;
// Constants which should be elsewhere ????
const Int_t kMaxMuonTrackingChambers = 10;
class AliMUONEventReconstructor : public TObject {
public:
- AliMUONEventReconstructor(void); // Constructor
+ AliMUONEventReconstructor(AliLoader* ); // default Constructor
virtual ~AliMUONEventReconstructor(void); // Destructor
AliMUONEventReconstructor (const AliMUONEventReconstructor& Reconstructor); // copy constructor
AliMUONEventReconstructor& operator=(const AliMUONEventReconstructor& Reconstructor); // assignment operator
Int_t GetNRecTracks() const {return fNRecTracks;} // Number
void SetNRecTracks(Int_t NRecTracks) {fNRecTracks = NRecTracks;}
TClonesArray* GetRecTracksPtr(void) const {return fRecTracksPtr;} // Array
+
+ // Reconstructed trigger tracks
+ Int_t GetNRecTriggerTracks() const {return fNRecTriggerTracks;} // Number
+ void SetNRecTriggerTracks(Int_t NRecTriggerTracks) {fNRecTriggerTracks = NRecTriggerTracks;}
+ TClonesArray* GetRecTriggerTracksPtr(void) const {return fRecTriggerTracksPtr;} // Array
- // Reconstructed trigger tracks
- Int_t GetNRecTriggerTracks() const {return fNRecTriggerTracks;} // Number
- void SetNRecTriggerTracks(Int_t NRecTriggerTracks) {fNRecTriggerTracks = NRecTriggerTracks;}
- TClonesArray* GetRecTriggerTracksPtr(void) const {return fRecTriggerTracksPtr;} // Array
-
// Hits on reconstructed tracks
Int_t GetNRecTrackHits() const {return fNRecTrackHits;} // Number
void SetNRecTrackHits(Int_t NRecTrackHits) {fNRecTrackHits = NRecTrackHits;}
void SetTrackMethod(Int_t TrackMethod) {fTrackMethod = TrackMethod;} //AZ
Int_t GetTrackMethod(void) const {return fTrackMethod;} //AZ
Int_t fMuons; // AZ - number of muons within acceptance - just for tests
+
+ AliMUONData* GetMUONData() {return fMUONData;}
+
protected:
private:
TTree *fEventTree; // tree of reconstructed events
TFile *fTreeFile; // file where the tree is outputed
+ // data container
+ AliMUONData* fMUONData;
+
+ // alice loader
+ AliLoader* fLoader;
+
// Functions
void ResetHitsForRec(void);
void MakeEventToBeReconstructed(void);
#include "AliMUONResponse.h"
#include "AliMUONChamber.h"
#include "AliMUONDigit.h"
+#include "AliMUONConstants.h"
+#include "AliMUONGlobalTrigger.h"
+#include "AliMUONLocalTrigger.h"
#include <TF1.h>
ClassImp(AliMUONTriggerDecision)
//----------------------------------------------------------------------
-AliMUONTriggerDecision::AliMUONTriggerDecision(Int_t iprint)
+AliMUONTriggerDecision::AliMUONTriggerDecision(AliLoader* loader, Int_t iprint)
{
// Constructor
fDebug = iprint; // print option
fXbit21[icirc][istrip]=fXbit22[icirc][istrip]=0;
}
}
-}
+ fTriggerCircuit = new TObjArray(AliMUONConstants::NTriggerCircuit());
+
+ // initialize loader's
+ fLoader = loader;
+
+ // initialize container
+ fMUONData = new AliMUONData(fLoader,"MUON","MUON");
+
+ // Loading AliRun master
+ AliRunLoader* runloader = fLoader->GetRunLoader();
+ if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+ gAlice = runloader->GetAliRun();
+
+ // getting MUON
+ fMUON = (AliMUON*) gAlice->GetDetector("MUON");
+
+ // setting circuit
+ for (icirc = 0; icirc < AliMUONConstants::NTriggerCircuit(); icirc++) {
+ AliMUONTriggerCircuit* pCir = 0;
+ pCir = &(fMUON->TriggerCircuit(icirc));
+ fTriggerCircuit->AddAt(pCir, icirc);
+ }
+}
//----------------------------------------------------------------------
AliMUONTriggerDecision::~AliMUONTriggerDecision()
{
// Destructor
+ if (fTriggerCircuit){
+ fTriggerCircuit->Delete();
+ delete fTriggerCircuit;
+ }
+ if (fMUONData)
+ delete fMUONData;
}
-
//----------------------------------------------------------------------
void AliMUONTriggerDecision::Trigger(){
// main method of the class which calls the overall Trigger procedure
Int_t coinc44=0, resetMid=0; // initialize coincidence
- AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONTriggerCircuit* triggerCircuit;
for (Int_t icirc=0; icirc<234; icirc++) { // loop on circuits
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
// Int_t idCircuit=triggerCircuit->GetIdCircuit();
Int_t minDevStrip[5], minDev[5], coordY[5];
// 4) set the bit patterns
- AliMUON *pMUON = (AliMUON*)gAlice->GetDetector("MUON");
AliMUONTriggerCircuit* triggerCircuit;
- AliRunLoader * rl = AliRunLoader::GetRunLoader();
- AliLoader * gime = rl->GetLoader("MUONLoader");
for (Int_t chamber=11; chamber<15; chamber++){
for (Int_t cathode=1; cathode<3; cathode++){
- AliMUONChamber* iChamber = &(pMUON->Chamber(chamber-1));
- AliSegmentation* segmentation;
- gime->TreeD()->GetEvent(cathode-1);
- TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1);
+ // AliMUONChamber* iChamber = &(pMUON->Chamber(chamber-1));
+ // AliSegmentation* segmentation;
+ fLoader->TreeD()->GetEvent(cathode-1);
+ TClonesArray *muonDigits = fMUONData->Digits(chamber-1);
Int_t ndigits = muonDigits->GetEntriesFast();
if (fDebug>3)
- printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
-// if (ndigits == 0) return;
-
-// iChamber = &(pMUON->Chamber(chamber-1));
- segmentation=iChamber->SegmentationModel(cathode);
+ printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
+
AliMUONDigit *mdig;
for (Int_t digit=0; digit<ndigits; digit++) {
{
case 11:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);
for (istrip=0; istrip<16; istrip++) {
if (triggerCircuit->GetXcode(0,istrip)==code)
fXbit11[icirc][istrip]=1;
break;
case 12:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
for (istrip=0; istrip<16; istrip++) {
if (triggerCircuit->GetXcode(1,istrip)==code)
fXbit12[icirc][istrip]=1;
break;
case 13:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
for (istrip=0; istrip<32; istrip++) {
if (triggerCircuit->GetXcode(2,istrip)==code)
fXbit21[icirc][istrip]=1;
break;
case 14:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
for (istrip=0; istrip<32; istrip++) {
if (triggerCircuit->GetXcode(3,istrip)==code)
fXbit22[icirc][istrip]=1;
{
case 11:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(0,istrip)==code)
break;
case 12:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(1,istrip)==code)
break;
case 13:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(2,istrip)==code)
break;
case 14:
for (icirc=0; icirc<234; icirc++) {
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
nStrip=triggerCircuit->GetNstripY();
for (istrip=0; istrip<nStrip; istrip++) {
if (triggerCircuit->GetYcode(3,istrip)==code)
} // if cathode
} // remove soft background
} // end loop on digit
- pMUON->GetMUONData()->ResetDigits();
+ fMUONData->ResetDigits();
} // end loop on cathode
} // end loop on chamber
}
// Set Y bit for up and down parts of circuits
Int_t idModule, nStripX, nStripY, iPosCircuit;
- AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
for (Int_t icirc=0; icirc<234; icirc++) {
AliMUONTriggerCircuit* circuitD; // circuit Down
AliMUONTriggerCircuit* circuitU; // circuit Up
- circuit = &(pMUON->TriggerCircuit(icirc));
+ circuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
idModule=circuit->GetIdModule(); // corresponding module Id.
nStripX=circuit->GetNstripX(); // number of X strips
nStripY=circuit->GetNstripY(); // number of Y strips
if (iPosCircuit==1) { // need to scan lower module
if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) {
Int_t icircD=circuit->GetICircuitD();
- circuitD = &(pMUON->TriggerCircuit(icircD));
+ circuitD = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icircD);
Int_t nStripD=circuitD->GetNstripY();
if (TMath::Abs(idModule)==42) { // shift of +8 bits
(iPosCircuit==3&&nStripX==48)||(iPosCircuit==4&&nStripX==64)) {
if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
Int_t icircU=circuit->GetICircuitU();
- circuitU = &(pMUON->TriggerCircuit(icircU));
+ circuitU = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icircU);
Int_t nStripU=circuitU->GetNstripY();
if (TMath::Abs(idModule)==62) { // shift of +8 bits
// returns local trigger answer for circuit icirc
Int_t i;
- AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONTriggerCircuit* triggerCircuit;
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);
Int_t idCircuit=triggerCircuit->GetIdCircuit();
Int_t signDev=minDev[4];
Int_t istrip;
- AliMUON *pMUON = (AliMUON*)gAlice->GetModule("MUON");
AliMUONTriggerCircuit* triggerCircuit;
- triggerCircuit = &(pMUON->TriggerCircuit(icirc));
+ triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);
Int_t idCircuit=triggerCircuit->GetIdCircuit();
Int_t nStrip=triggerCircuit->GetNstripY();
Int_t pairUnlike[3],
Int_t pairLike[3]){
// returns Global Trigger information (0,1,2 : Lpt,Hpt,Apt)
+// should not be used anymore.
for (Int_t i=0; i<3; i++) {
singlePlus[i] = fGlobalSinglePlus[i];
singleMinus[i] = fGlobalSingleMinus[i];
pairLike[i] = fGlobalPairLike[i];
}
}
-//----------------------------------------------------------------------
-//--- end of methods which return member data related info
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-/*
-void AliMUONTriggerDecision::AddLocalTrigger(const AliMUONLocalTrigger c){
-// Add a Local Trigger copy to the list
- AliMUON *MUON=(AliMUON*)gAlice->GetModule("MUON");
- MUON->AddLocalTrigger(c);
- fNLocalTriggers++;
+//_______________________________________________________________________
+void AliMUONTriggerDecision::Digits2Trigger(){
+// call the Trigger Algorithm and fill TreeR
+
+
+ fMUONData->ResetTrigger();
+ Trigger();
+ AliMUONGlobalTrigger* pGloTrig = new AliMUONGlobalTrigger(fGlobalSinglePlus, fGlobalSingleMinus,
+ fGlobalSingleUndef, fGlobalPairUnlike,
+ fGlobalPairLike);
+ // add a local trigger in the list
+ fMUONData->AddGlobalTrigger(*pGloTrig);
+
+ Int_t i;
+
+ for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) {
+ if(GetITrigger(icirc)==1) {
+ Int_t localtr[7]={0,0,0,0,0,0,0};
+ Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
+ GetLutOutput(icirc, loLpt, loHpt, loApt);
+ localtr[0] = icirc;
+ localtr[1] = GetStripX11(icirc);
+ localtr[2] = GetDev(icirc);
+ localtr[3] = GetStripY11(icirc);
+ for (i=0; i<2; i++) { // convert the Lut output in 1 digit
+ localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
+ localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
+ localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
+ }
+ AliMUONLocalTrigger* pLocTrig = new AliMUONLocalTrigger(localtr);
+ fMUONData->AddLocalTrigger(*pLocTrig); // add a local trigger in the list
+ }
+ }
}
-*/
// MUON Trigger Decision Class //
////////////////////////////////////////////////
#include "TObject.h"
+#include "TObjArray.h"
-class AliMUONHitMapA1;
-class TF1;
+class AliLoader;
class TClonesArray;
-class AliMUONSegmentation;
-class AliMUONResponse;
+class AliMUONData;
+class AliMUON;
+
class AliMUONTriggerDecision :
public TObject {
public:
- AliMUONTriggerDecision(Int_t iprint); // constructor
+ AliMUONTriggerDecision(AliLoader*, Int_t iprint = 0); // constructor
~AliMUONTriggerDecision(); // destructor
+ AliMUONData* GetMUONData() {return fMUONData;}
void Trigger();
void ResetBit();
void SetBit();
Int_t &iTrigger);
void GlobalTrigger();
+ void Digits2Trigger(); // main function
+
// print-debug
void PrintBitPatXInput(Int_t icirc);
void PrintBitPatYInput(Int_t icirc);
Int_t singleUndef[3], Int_t pairUnlike[3],
Int_t pairLike[3]);
+
// Add a new Local Trigger
// virtual void AddLocalTrigger(const AliMUONLocalTrigger);
// Return pointer to Local Triggers
Int_t fYbit21D[234][16]; // bit pattern YM21 Down
Int_t fYbit22D[234][16]; // bit pattern YM22 Down
+
+ AliLoader* fLoader; //! alice loader
+ TObjArray* fTriggerCircuit; //! List of Trigger Circuit
+ AliMUONData* fMUONData; //! Data container for MUON subsystem
+ AliMUON* fMUON; //! pointer to MUON
+
// ???
// TClonesArray* fLocalTriggers; // Local Triggers
// Int_t fNLocalTriggers; // Number of Local Triggers
// Gines MARTINEZ, Subatech, sep 2003
#if !defined(__CINT__) || defined(__MAKECINT__)
-#include <TClonesArray.h>
-
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONData.h"
#include "AliMUONEventReconstructor.h"
-#include "AliMUONTrack.h"
-#include "AliMUONTrackHit.h"
-#include "AliMUONTrackParam.h"
#endif
void MUONTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0, Int_t LastEvent = 9999)
cout << "FileName ``" << FileName << "''" << endl;
// Creating Run Loader and openning file containing Hits, Digits and RecPoints
- AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"Event","UPDATE");
+ AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"MUONLoader","UPDATE");
if (RunLoader ==0x0) {
printf(">>> Error : Error Opening %s file \n",FileName);
return;
}
-
// Loading AliRun master
- RunLoader->LoadgAlice();
+ if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
gAlice = RunLoader->GetAliRun();
- RunLoader->LoadKinematics("READ");
+ // RunLoader->LoadKinematics("READ");
// Loading MUON subsystem
- AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
- AliMUONData * muondata = MUON->GetMUONData();
-
- Int_t nevents;
- nevents = RunLoader->GetNumberOfEvents();
MUONLoader->LoadRecPoints("READ");
MUONLoader->LoadTracks("UPDATE");
+
+ Int_t nevents;
+ nevents = RunLoader->GetNumberOfEvents();
+
+ AliMUONEventReconstructor* Reco = new AliMUONEventReconstructor(MUONLoader);
+ AliMUONData* muondata = Reco->GetMUONData();
-
- // Testing if Tracking has already been done
+ // Testing if Tracker has already been done
RunLoader->GetEvent(0);
if (MUONLoader->TreeT()) {
if (muondata->IsTrackBranchesInTree()) {
MUONLoader->UnloadTracks();
MUONLoader->LoadTracks("RECREATE");
- printf("Recreating Tracks files\n");
+ printf("Recreating RecPoints files\n");
}
}
-
- AliMUONEventReconstructor *Reco = new AliMUONEventReconstructor();
// The right place for changing AliMUONEventReconstructor parameters
// with respect to the default ones
Reco->SetPrintLevel(0);
// Reco->SetBendingResolution(0.0);
// Reco->SetNonBendingResolution(0.0);
- cout << "AliMUONEventReconstructor: actual parameters" << endl;
-// Reco->Dump();
- // gObjectTable->Print();
+ // cout << "AliMUONEventReconstructor: actual parameters" << endl;
if (LastEvent>nevents) LastEvent=nevents;
+
// Loop over events
for (Int_t event = FirstEvent; event < LastEvent; event++) {
+ //MUONLoader->LoadHits("READ");
cout << "Event: " << event << endl;
RunLoader->GetEvent(event);
- if (MUONLoader->TreeT() == 0x0) MUONLoader->MakeTracksContainer();
-
+ // Test if trigger track has already been done before
+ if (MUONLoader->TreeT() == 0x0) {
+ MUONLoader->MakeTracksContainer();
+ } else {
+ if (muondata->IsTrackBranchesInTree()){ // Test if track has already been done before
+ if (event==FirstEvent) MUONLoader->UnloadTracks();
+ MUONLoader->MakeTracksContainer(); // Redoing Tracking
+ Info("TrackContainer","Recreating TrackContainer and deleting previous ones");
+ }
+ }
+
muondata->MakeBranch("RT");
muondata->SetTreeAddress("RT");
Reco->EventReconstruct();
- // Dump current event
- // Reco->EventDump();
-
- // Duplicating rectrack data in muondata for output
- for(Int_t i=0; i<Reco->GetNRecTracks(); i++) {
- AliMUONTrack * track = (AliMUONTrack*) Reco->GetRecTracksPtr()->At(i);
- muondata->AddRecTrack(*track);
- //printf(">>> TEST TEST event %d Number of hits in the track %d is %d \n",event,i,track->GetNTrackHits());
- }
-
- muondata->Fill("RT");
- MUONLoader->WriteTracks("OVERWRITE");
- muondata->ResetRecTracks();
- muondata->ResetRawClusters();
+
+ muondata->Fill("RT");
+ MUONLoader->WriteTracks("OVERWRITE");
+ muondata->ResetRecTracks();
+ muondata->ResetRawClusters();
} // Event loop
+
MUONLoader->UnloadRecPoints();
MUONLoader->UnloadTracks();
}
// The output is a TClonesArray of AliMUONTriggerTracks.
#if !defined(__CINT__) || defined(__MAKECINT__)
-#include <TClonesArray.h>
#include "AliRun.h"
#include "AliMUON.h"
#include "AliMUONData.h"
#include "AliMUONEventReconstructor.h"
-#include "AliMUONTriggerTrack.h"
#endif
void MUONTriggerTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0, Int_t LastEvent = 9999)
cout << "FileName ``" << FileName << "''" << endl;
// Creating Run Loader and openning file containing Hits, Digits and RecPoints
- AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"Event","UPDATE");
+ AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"MUONLoader","UPDATE");
if (RunLoader ==0x0) {
printf(">>> Error : Error Opening %s file \n",FileName);
return;
}
// Loading AliRun master
- RunLoader->LoadgAlice();
+ if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
gAlice = RunLoader->GetAliRun();
- RunLoader->LoadKinematics("READ");
+ // RunLoader->LoadKinematics("READ");
// Loading MUON subsystem
- AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
- AliMUONData * muondata = MUON->GetMUONData();
-
+
Int_t nevents;
nevents = RunLoader->GetNumberOfEvents();
MUONLoader->LoadRecPoints("READ");
MUONLoader->LoadTracks("UPDATE");
+
+ AliMUONEventReconstructor *Reco = new AliMUONEventReconstructor(MUONLoader);
+ AliMUONData* muondata = Reco->GetMUONData();
+
// Testing if Trigger Tracking has already been done
RunLoader->GetEvent(0);
if (MUONLoader->TreeT()) {
}
}
- AliMUONEventReconstructor *Reco = new AliMUONEventReconstructor();
-
- Reco->SetPrintLevel(0);
- cout << "AliMUONEventReconstructor: actual parameters" << endl;
- // Reco->Dump();
- // gObjectTable->Print();
-
+ Reco->SetPrintLevel(0);
if (LastEvent>nevents) LastEvent=nevents;
+
// Loop over events
for (Int_t event = FirstEvent; event < LastEvent; event++) {
cout << "Event: " << event << endl;
muondata->MakeBranch("RL");
muondata->SetTreeAddress("RL");
Reco->EventReconstructTrigger();
- // Dump current event
- // Reco->EventDumpTrigger();
-
- // Duplicating rectriggertrack data in muondata for output
- for(Int_t i=0; i<Reco->GetNRecTriggerTracks(); i++) {
- AliMUONTriggerTrack * triggertrack = (AliMUONTriggerTrack*) Reco->GetRecTriggerTracksPtr()->At(i);
- muondata->AddRecTriggerTrack(*triggertrack);
-// printf(">>> TEST TEST event %d Number of hits in the track %d is %d \n",event,i,track->GetNTrackHits());
- }
-
+
muondata->Fill("RL");
MUONLoader->WriteTracks("OVERWRITE");
muondata->ResetRecTriggerTracks();
muondata->ResetTrigger();
} // Event loop
+
MUONLoader->UnloadRecPoints();
MUONLoader->UnloadTracks();
}
/* $Id$ */
#if !defined(__CINT__) || defined(__MAKECINT__)
-#include "iostream.h"
+//#include "iostream.h"
#include <TClassTable.h>
#include <TClonesArray.h>
#include "AliMUON.h"
#include "AliMUONClusterFinderVS.h"
+//#include "AliMUONClusterFinderAZ.h"
+#include "AliMUONClusterReconstructor.h"
#endif
void MUONrawclusters (char* filename="galice.root", Int_t evNumber1=0,Int_t evNumber2=9999)
{
- //////////////////////////////////////
- // //
- // ROOT macro for ALICE Dimuon Arm: //
- // Clusterization of digits //
- // //
- //////////////////////////////////////
- //
- // Adds the tree TR for raw clusters
- // to the ROOT file "galice.root"
- // containing the digits (tree TD).
- //
- // Arguments:
- // evNumber1 = first event number to act on in file "galice.root"
- // evNumber2 = last event number to act on in file "galice.root"
- //
- // Input/output file:
- // "galice.root"
- //
- //__________________________________________________________________________
-
-// // Dynamically link some shared libs
-
- //if (gClassTable->GetID("AliRun") < 0) {
- // gROOT->LoadMacro("$ALICE_ROOT/macros/loadlibs.C");
- // loadlibs();
- // }
-
// Creating Run Loader and openning file containing Hits
- AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","UPDATE");
+ AliRunLoader* RunLoader = AliRunLoader::Open(filename,"MUONLoader","UPDATE");
if (RunLoader ==0x0) {
printf(">>> Error : Error Opening %s file \n",filename);
return;
}
-
- // Loading AliRun master
- RunLoader->UnloadgAlice();
- RunLoader->LoadgAlice();
- gAlice = RunLoader->GetAliRun();
+ if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
// Loading MUON subsystem
- AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
- AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
- AliMUONData * muondata = MUON->GetMUONData();
+ AliLoader* MUONLoader = RunLoader->GetLoader("MUONLoader");
+ MUONLoader->LoadDigits("READ");
+ MUONLoader->LoadRecPoints("UPDATE");
+
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
-
+
+ AliMUONClusterReconstructor* Reco = new AliMUONClusterReconstructor(MUONLoader);
+ AliMUONData* muondata = Reco->GetMUONData();
+
for (Int_t i=0; i<10; i++) {
- //RecModel = new AliMUONClusterFinderVS();
- AliMUONClusterFinderVS *RecModel = new AliMUONClusterFinderVS();
+ AliMUONClusterFinderVS* RecModel = new AliMUONClusterFinderVS();
// RecModel->SetTracks(16,17);
// RecModel->SetTracks(266,267);
RecModel->SetGhostChi2Cut(10);
- MUON->SetReconstructionModel(i,RecModel);
+ Reco->SetReconstructionModel(i,RecModel);
}
-
- MUONLoader->LoadDigits("READ");
- MUONLoader->LoadRecPoints("UPDATE");
-
+
// Testing if RawClusterisation has already been done
RunLoader->GetEvent(0);
if (MUONLoader->TreeR()) {
}
}
-// Loop over events
- if (evNumber2>nevents) evNumber2=nevents;
- for(Int_t ievent=evNumber1; ievent<evNumber2; ievent++) {
- printf("event %d\n",ievent);
- RunLoader->GetEvent(ievent);
- if (MUONLoader->TreeR() == 0x0) MUONLoader->MakeRecPointsContainer();
-
- muondata->MakeBranch("RC");
- muondata->SetTreeAddress("D,RC");
- MUON->Digits2Reco();
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ if (evNumber2 > nevents) evNumber2 = nevents;
+
+ for(ievent = evNumber1; ievent < evNumber2; ievent++) {
+ printf("event %d\n",ievent);
+ RunLoader->GetEvent(ievent);
+
+ // Test if rawcluster has already been done before
+ if (MUONLoader->TreeR() == 0x0)
+ MUONLoader->MakeRecPointsContainer();
+ else {
+ if (muondata->IsRawClusterBranchesInTree()){
+ // Test if rawcluster has already been done before
+ if (ievent == evNumber1) MUONLoader->UnloadRecPoints();
+ MUONLoader->MakeRecPointsContainer(); // Redoing clusterisation
+ Info("RecPointsContainer",
+ "Recreating RecPointsContainer and deleting previous ones");
+ }
+ }
+ muondata->MakeBranch("RC");
+ muondata->SetTreeAddress("D,RC");
+
+ Reco->Digits2Clusters();
+
+ muondata->Fill("RC"); //Filling Reconstructed Cluster
+ MUONLoader->WriteRecPoints("OVERWRITE");
+ muondata->ResetRawClusters();
+ muondata->ResetDigits();
}
MUONLoader->UnloadDigits();
MUONLoader->UnloadRecPoints();
#include "AliLoader.h"
#include "AliMUON.h"
#include "AliMUONData.h"
+#include "AliMUONTriggerDecision.h"
#endif
AliRun * gAlice;
{
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// Creating Run Loader and openning file containing Hits
- AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","UPDATE");
+ AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONLoader","UPDATE");
if (RunLoader ==0x0) {
printf(">>> Error : Error Opening %s file \n",filename);
return;
}
-// Loading AliRun master
- RunLoader->UnloadgAlice();
- RunLoader->LoadgAlice();
- gAlice = RunLoader->GetAliRun();
+ // Loading AliRun master
+ if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
-// Loading MUON subsystem
- AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
+ // Loading MUON subsystem
AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
- AliMUONData * muondata = MUON->GetMUONData();
Int_t ievent, nevents;
nevents = RunLoader->GetNumberOfEvents();
+ AliMUONTriggerDecision* TrigDec = new AliMUONTriggerDecision(MUONLoader);
+ AliMUONData* muondata = TrigDec->GetMUONData();
+
MUONLoader->LoadDigits("READ");
MUONLoader->LoadRecPoints("UPDATE");
-// Testing if trigger has already been done
+ // Testing if trigger has already been done
RunLoader->GetEvent(0);
if (MUONLoader->TreeR()) {
- if (muondata->IsTriggerBranchesInTree()) {
- MUONLoader->UnloadRecPoints();
- MUONLoader->LoadRecPoints("RECREATE");
- printf("Recreating RecPoints files\n");
- }
+ if (muondata->IsTriggerBranchesInTree()) {
+ MUONLoader->UnloadRecPoints();
+ MUONLoader->LoadRecPoints("RECREATE");
+ printf("Recreating RecPoints files\n");
+ }
}
-
-// Loop over events
+
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if (evNumber2>nevents) evNumber2=nevents;
- for (Int_t ievent=evNumber1; ievent<evNumber2; ievent++) { // event loop
- printf("event %d\n",ievent);
- RunLoader->GetEvent(ievent);
- if (MUONLoader->TreeR() == 0x0) MUONLoader->MakeRecPointsContainer();
-
- muondata->MakeBranch("GLT");
- muondata->SetTreeAddress("D,GLT");
- MUON->Trigger(ievent);
- muondata->ResetDigits();
- muondata->ResetTrigger();
- }
- MUONLoader->UnloadDigits();
- MUONLoader->UnloadRecPoints();
+ for (ievent = evNumber1; ievent < evNumber2; ievent++) { // event loop
+
+ printf("event %d\n",ievent);
+ RunLoader->GetEvent(ievent);
+ // Test if rawcluster has already been done before
+ if (MUONLoader->TreeR() == 0x0)
+ MUONLoader->MakeRecPointsContainer();
+ else {
+ if (muondata->IsTriggerBranchesInTree()){
+ // Test if rawcluster has already been done before
+ if (ievent == evNumber1) MUONLoader->UnloadRecPoints();
+ MUONLoader->MakeRecPointsContainer(); // Redoing clusterisation
+ Info("RecPointsContainer",
+ "Recreating RecPointsContainer and deleting previous ones");
+ }
+ }
+ muondata->MakeBranch("GLT");
+ muondata->SetTreeAddress("D,GLT");
+
+ TrigDec->Digits2Trigger();
+
+ muondata->Fill("GLT"); //Filling Global Local Trigger
+ MUONLoader->WriteRecPoints("OVERWRITE");
+ muondata->ResetDigits();
+ muondata->ResetTrigger();
+
+ } // event loop
+
+ MUONLoader->UnloadDigits();
+ MUONLoader->UnloadRecPoints();
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff