/* $Id$ */
-/// AliMUONData class
+/// \class AliMUONData
///
/// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
/// The classe makes the lik between the MUON data lists and the event trees from loaders
///
-/// Gines Martinez, Subatech, September 2003
+/// \author Gines Martinez, Subatech, September 2003
///
#include "AliMUONData.h"
-
-#include "AliLog.h"
+#include "AliMUONDataIterator.h"
#include "AliMUONConstants.h"
#include "AliMUONHit.h"
#include "AliMUONDigit.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUONLocalTrigger.h"
#include "AliMUONRegionalTrigger.h"
+#include "AliMUONTriggerCrateStore.h"
+#include "AliMUONTriggerCircuit.h"
+#include "AliMUONGeometryTransformer.h"
#include "AliMUONRawCluster.h"
+
+// This is from rec, classes in base should not depend on rec !!!
#include "AliMUONTrack.h"
#include "AliMUONTriggerTrack.h"
+
#include "AliRunLoader.h"
-#include "TArrayI.h"
-#include "TString.h"
+#include "AliStack.h"
+#include "AliLog.h"
+
+#include <TString.h>
+#include <TParticle.h>
+#include <TNtuple.h>
+#include <Riostream.h>
+#include <TFile.h>
/// \cond CLASSIMP
ClassImp(AliMUONData)
//_____________________________________________________________________________
AliMUONData::AliMUONData():
TNamed(),
+ fRunLoader(0x0),
fLoader(0x0),
fHits(0x0),
fDigits(0x0),
fSplitLevel(0),
fCurrentEvent(-1)
{
- // Default constructor
+/// Default constructor
}
//_____________________________________________________________________________
AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
TNamed(name,title),
+ fRunLoader(0x0),
fLoader(loader),
fHits(0x0),
fDigits(0x0),
/// Standard constructor
}
+//_____________________________________________________________________________
+AliMUONData::AliMUONData(const char* galiceFile):
+ TNamed("MUON", "MUON"),
+ fRunLoader(0x0),
+ fLoader(0x0),
+ fHits(0x0),
+ fDigits(0x0),
+ fSDigits(0x0),
+ fRawClusters(0x0),
+ fGlobalTrigger(0x0),
+ fLocalTrigger(0x0),
+ fRegionalTrigger(0x0),
+ fRecTracks(0x0),
+ fRecTriggerTracks(0x0),
+ fNhits(0),
+ fNdigits(0x0),
+ fNSdigits(0x0),
+ fNrawclusters(0x0),
+ fNglobaltrigger(0),
+ fNlocaltrigger(0),
+ fNregionaltrigger(0),
+ fNrectracks(0),
+ fNrectriggertracks(0),
+ fSplitLevel(0),
+ fCurrentEvent(-1)
+{
+/// Constructor for loading data from gAlice file
+
+ fRunLoader = AliRunLoader::Open(galiceFile, "MUONFolder", "READ");
+ if (!fRunLoader) {
+ AliError(Form("Error opening %s file \n", galiceFile));
+ return;
+ }
+
+ fLoader = fRunLoader->GetLoader("MUONLoader");
+ if ( ! fLoader ) {
+ AliError(Form("Could get MUONLoader"));
+ return;
+ }
+}
+
//_____________________________________________________________________________
AliMUONData::~AliMUONData()
{
fRecTriggerTracks->Delete();
delete fRecTriggerTracks;
}
+
+ if (fRunLoader) {
+ fRunLoader->UnloadAll();
+ delete fRunLoader;
+ }
}
//____________________________________________________________________________
void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t detElemId,
Float_t phi, Float_t length, Float_t destep,
Float_t Xref,Float_t Yref,Float_t Zref)
{
- // Add new hit to the hit list
+ /// Add new hit to the hit list
TClonesArray &lhits = *fHits;
new(lhits[fNhits++]) AliMUONHit(fIshunt, track, detElemId,
const Int_t kBufferSize = 4000;
char branchname[30];
-
+ //Setting Data Container
+ SetDataContainer(option);
+
const char *cH = strstr(option,"H");
const char *cD = strstr(option,"D"); // Digits branches in TreeD
const char *cS = strstr(option,"S"); // Digits branches in TreeS
// Creating Branches for Hits
if (TreeH() && cH) {
-
- if (fHits == 0x0) {
- fHits = new TClonesArray("AliMUONHit",1000);
- // if (gAlice->GetMCApp())
- // gAlice->GetMCApp()->AddHitList (fHits);
- }
-
- fNhits = 0;
sprintf(branchname,"%sHits",GetName());
branch = TreeH()->GetBranch(branchname);
if (branch) {
if ( treeD && cD )
{
// one branch for digits per chamber
- if (fDigits == 0x0)
- {
- fDigits = new TObjArray(AliMUONConstants::NCh());
- for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++)
- {
- TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
- tca->SetOwner();
- fDigits->AddAt(tca,iDetectionPlane);
- }
- }
- if (fNdigits == 0x0)
- {
- fNdigits = new Int_t[AliMUONConstants::NCh()];
- for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++)
- {
- fNdigits[iDetectionPlane]=0;
- }
- }
for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++)
{
sprintf(branchname,"%sDigits%d",GetName(),iDetectionPlane+1);
// one branch for global trigger
//
sprintf(branchname,"%sGlobalTrigger",GetName());
-
- if (fGlobalTrigger == 0x0)
- {
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
- fNglobaltrigger = 0;
- }
branch = treeD->GetBranch(branchname);
if (branch)
{
//
sprintf(branchname,"%sRegionalTrigger",GetName());
branch = 0x0;
-
- if (fRegionalTrigger == 0x0)
- {
- fRegionalTrigger = new TClonesArray("AliMUONRegionalTrigger",16);
- fNregionaltrigger = 0;
- }
branch = treeD->GetBranch(branchname);
if (branch)
{
//
sprintf(branchname,"%sLocalTrigger",GetName());
branch = 0x0;
-
- if (fLocalTrigger == 0x0)
- {
- fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
- fNlocaltrigger = 0;
- }
branch = treeD->GetBranch(branchname);
if (branch)
{
//Creating Branches for SDigits
if (TreeS() && cS ) {
// one branch for Sdigits per chamber
- if (fSDigits == 0x0) {
- fSDigits = new TObjArray(AliMUONConstants::NCh());
- for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
- TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
- tca->SetOwner();
- fSDigits->AddAt(tca,iDetectionPlane);
- }
- }
- if (fNSdigits == 0x0) {
- fNSdigits = new Int_t[AliMUONConstants::NCh()];
- for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
- fNSdigits[iDetectionPlane]=0;
- }
- }
for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
sprintf(branchname,"%sSDigits%d",GetName(),iDetectionPlane+1);
branch = 0x0;
if (TreeR() && cRC ) {
// one branch for raw clusters per tracking detection plane
//
- Int_t i;
- if (fRawClusters == 0x0) {
- fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
- for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
- TClonesArray * tca = new TClonesArray("AliMUONRawCluster",1000);
- tca->SetOwner();
- fRawClusters->AddAt(tca,i);
- }
- }
-
- if (fNrawclusters == 0x0) {
- fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
- for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
- fNrawclusters[i]=0;
- }
- }
-
+ Int_t i;
for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
branch = 0x0;
//
sprintf(branchname,"%sGlobalTrigger",GetName());
branch = 0x0;
-
- if (fGlobalTrigger == 0x0) {
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger");
- fNglobaltrigger = 0;
- }
branch = TreeR()->GetBranch(branchname);
if (branch) {
AliInfo(Form("Branch GlobalTrigger is already in treeR."));
//
sprintf(branchname,"%sRegionalTrigger",GetName());
branch = 0x0;
-
- if (fRegionalTrigger == 0x0) {
- fRegionalTrigger = new TClonesArray("AliMUONRegionalTrigger",16);
- fNregionaltrigger = 0;
- }
branch = TreeR()->GetBranch(branchname);
if (branch) {
AliInfo(Form("Branch RegionalTrigger is already in treeR."));
//
sprintf(branchname,"%sLocalTrigger",GetName());
branch = 0x0;
-
- if (fLocalTrigger == 0x0) {
- fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
- fNlocaltrigger = 0;
- }
branch = TreeR()->GetBranch(branchname);
if (branch) {
AliInfo(Form("Branch LocalTrigger is already in treeR."));
}
if (TreeT() && cRT ) {
- if (fRecTracks == 0x0) fRecTracks = new TClonesArray("AliMUONTrack",100);
- fNrectracks = 0;
sprintf(branchname,"%sTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) {
}
// trigger tracks
if (TreeT() && cRL ) {
- if (fRecTriggerTracks == 0x0) fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
- fNrectriggertracks = 0;
sprintf(branchname,"%sTriggerTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) {
return fRegionalTrigger;
}
+//____________________________________________________________________________
+Int_t
+AliMUONData::GetNtracks() const
+{
+/// Get number of entries in hits three
+
+ Int_t ntrk = 0;
+ if (fLoader && fLoader->TreeH())
+ ntrk = (Int_t) fLoader->TreeH()->GetEntries();
+ return ntrk;
+}
+
//____________________________________________________________________________
void
AliMUONData::GetDigits() const
fNrectriggertracks = 0;
if (fRecTriggerTracks) fRecTriggerTracks->Delete(); // necessary to delete in case of memory allocation
}
-//_____________________________________________________________________________
+//____________________________________________________________________________
+void AliMUONData::SetDataContainer(Option_t* option)
+{
+/// Setting data containers of muon data
+ const char *cH = strstr(option,"H");
+ const char *cD = strstr(option,"D"); // Digits
+ const char *cS = strstr(option,"S"); // SDigits
+ const char *cRC = strstr(option,"RC"); // RawCluster
+ const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger
+ const char *cTC = strstr(option,"TC"); // global and local Trigger
+ const char *cRT = strstr(option,"RT"); // Reconstructed Tracks
+ const char *cRL = strstr(option,"RL"); // Reconstructed Trigger Tracks
+ //const char *cRP = strstr(option,"RP"); // Reconstructed Particles
+ AliDebug(1,Form("option=%s",option));
+ //
+ // Clones array for hits
+ if ( cH ) {
+ if (fHits == 0x0) {
+ fHits = new TClonesArray("AliMUONHit",1000);
+ }
+ ResetHits();
+ }
+
+ //
+ // ObjArray of ClonesArrays for Digits
+ if ( cD ) {
+ if (fDigits == 0x0 ) {
+ fDigits = new TObjArray(AliMUONConstants::NCh());
+ fNdigits= new Int_t[AliMUONConstants::NCh()];
+ for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
+ TClonesArray * tca = new TClonesArray("AliMUONDigit",10000);
+ tca->SetOwner();
+ fDigits->AddAt(tca,i);
+ fNdigits[i]=0;
+ }
+ }
+ else {
+ AliDebug(1,Form("fDigits already there = %p",fSDigits));
+ }
+ ResetDigits();
+ }
+
+ //
+ // ClonesArrays for Trigger
+ if ( cGLT ) {
+ if (fLocalTrigger == 0x0) {
+ fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
+ }
+ if (fRegionalTrigger == 0x0) {
+ fRegionalTrigger = new TClonesArray("AliMUONRegionalTrigger",16);
+ }
+ if (fGlobalTrigger== 0x0) {
+ fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
+ }
+ ResetTrigger();
+ }
+
+ //
+ // Container for Sdigits
+ if (cS) {
+ if (fSDigits == 0x0) {
+ AliDebug(1,"Creating fSDigits TObjArray");
+ fSDigits = new TObjArray(AliMUONConstants::NCh());
+ fNSdigits= new Int_t[AliMUONConstants::NCh()];
+ for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
+ TClonesArray* a = new TClonesArray("AliMUONDigit",10000);
+ a->SetOwner();
+ fSDigits->AddAt(a,i);
+ AliDebug(1,Form("fSDigits[%d]=%p",i,a));
+ fNSdigits[i]=0;
+ }
+ }
+ else {
+ AliDebug(1,Form("fSDigits already there = %p",fSDigits));
+ }
+ ResetSDigits();
+ }
+
+ //
+ // Containers for rawclusters, globaltrigger and local trigger tree
+ if (cRC ) {
+ if (fRawClusters == 0x0) {
+ fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
+ fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
+ for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
+ TClonesArray* tca = new TClonesArray("AliMUONRawCluster",10000);
+ tca->SetOwner();
+ fRawClusters->AddAt(tca,i);
+ fNrawclusters[i]=0;
+ }
+ }
+ // ResetRawClusters();
+ // It breaks the correct functioning of the combined reconstruction (AZ)
+
+ }
+ if (cTC ) {
+ if (fLocalTrigger == 0x0) {
+ fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
+ }
+ if (fRegionalTrigger == 0x0) {
+ fRegionalTrigger = new TClonesArray("AliMUONRegionalTrigger",16);
+ }
+ if (fGlobalTrigger== 0x0) {
+ fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
+ }
+ // ResetTrigger();
+ // This is not necessary here since trigger info ins copied from digits info on flight to RecPoint output
+ }
+
+ //
+ // Containers for rectracks and rectrigger tracks
+ if ( cRT ) {
+ if (fRecTracks == 0x0) {
+ fRecTracks = new TClonesArray("AliMUONTrack",100);
+ }
+ ResetRecTracks();
+ }
+ if (cRL) {
+ if (fRecTriggerTracks == 0x0 && cRL) {
+ fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
+ }
+ ResetRecTriggerTracks();
+ }
+}
+
+//____________________________________________________________________________
void AliMUONData::SetTreeAddress(Option_t* option)
{
+ // Setting Data containers
+ SetDataContainer(option);
+
/// Setting Addresses to the events trees
const char *cH = strstr(option,"H");
AliDebug(1,Form("option=%s",option));
//
// Branch address for hit tree
- if ( TreeH() && cH ) {
- if (fHits == 0x0) {
- fHits = new TClonesArray("AliMUONHit",1000);
- // if (gAlice->GetMCApp())
- // gAlice->GetMCApp()->AddHitList (fHits); Moved to AliMUON
- }
- fNhits =0;
- }
if (TreeH() && fHits && cH) {
sprintf(branchname,"%sHits",GetName());
branch = TreeH()->GetBranch(branchname);
//
// Branch address for digit tree
- if ( TreeD() ) {
- if (fDigits == 0x0 && cD) {
- fDigits = new TObjArray(AliMUONConstants::NCh());
- fNdigits= new Int_t[AliMUONConstants::NCh()];
- for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
- fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),i);
- fNdigits[i]=0;
- }
- }
- if (fLocalTrigger == 0x0 && cGLT) {
- fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
- }
- if (fRegionalTrigger == 0x0 && cGLT) {
- fRegionalTrigger = new TClonesArray("AliMUONRegionalTrigger",16);
- }
- if (fGlobalTrigger== 0x0 && cGLT) {
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
- }
- }
-
if (TreeD() && fDigits && cD) {
for (int i=0; i<AliMUONConstants::NCh(); i++) {
sprintf(branchname,"%sDigits%d",GetName(),i+1);
//
// Branch address for Sdigit tree
- if ( TreeS() && cS)
- {
- if (fSDigits == 0x0)
- {
- AliDebug(1,"Creating fSDigits TObjArray");
- fSDigits = new TObjArray(AliMUONConstants::NCh());
- fNSdigits= new Int_t[AliMUONConstants::NCh()];
- for (Int_t i=0; i<AliMUONConstants::NCh() ;i++)
- {
- TClonesArray* a = new TClonesArray("AliMUONDigit",10000);
- fSDigits->AddAt(a,i);
- AliDebug(1,Form("fSDigits[%d]=%p",i,a));
- fNSdigits[i]=0;
- }
- }
- else
- {
- AliDebug(1,Form("fSDigits already there = %p",fSDigits));
- }
- }
-
if (TreeS() && fSDigits && cS) {
AliDebug(1,"Setting branch addresses");
for (int i=0; i<AliMUONConstants::NCh(); i++) {
//
// Branch address for rawclusters, globaltrigger and local trigger tree
- if (TreeR() ) {
- if (fRawClusters == 0x0 && cRC) {
- fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
- fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
- for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
- fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i);
- fNrawclusters[i]=0;
- }
- }
- if (fLocalTrigger == 0x0 && cTC) {
- fLocalTrigger = new TClonesArray("AliMUONLocalTrigger",234);
- }
- if (fRegionalTrigger == 0x0 && cTC) {
- fRegionalTrigger = new TClonesArray("AliMUONRegionalTrigger",16);
- }
- if (fGlobalTrigger== 0x0 && cTC) {
- fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);
- }
-
- }
if ( TreeR() && fRawClusters && cRC && !strstr(cRC,"RCC")) {
for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
if (branch) branch->SetAddress(&fLocalTrigger);
else AliWarning(Form("(%s) Failed for LocalTrigger. Can not find branch in treeR.",GetName()));
}
-
if ( TreeR() && fRegionalTrigger && cTC) {
sprintf(branchname,"%sRegionalTrigger",GetName());
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress(&fRegionalTrigger);
else AliWarning(Form("(%s) Failed for RegionalTrigger. Can not find branch in treeR.",GetName()));
}
-
if ( TreeR() && fGlobalTrigger && cTC) {
sprintf(branchname,"%sGlobalTrigger",GetName());
branch = TreeR()->GetBranch(branchname);
if (branch) branch->SetAddress(&fGlobalTrigger);
else AliWarning(Form("(%s) Failed for GlobalTrigger. Can not find branch in treeR.",GetName()));
}
-
- if ( TreeT() ) {
- if (fRecTracks == 0x0 && cRT) {
- fRecTracks = new TClonesArray("AliMUONTrack",100);
- }
-
- }
+
+ // Rec Trakcs
if ( TreeT() && fRecTracks && cRT ) {
sprintf(branchname,"%sTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) branch->SetAddress(&fRecTracks);
else AliWarning(Form("(%s) Failed for Tracks. Can not find branch in tree.",GetName()));
}
- // trigger tracks
- if ( TreeT() ) {
- if (fRecTriggerTracks == 0x0 && cRL) {
- fRecTriggerTracks = new TClonesArray("AliMUONTriggerTrack",100);
- }
-
- }
+ // Trigger tracks
if ( TreeT() && fRecTriggerTracks && cRL ) {
sprintf(branchname,"%sTriggerTrack",GetName());
branch = TreeT()->GetBranch(branchname);
if (branch) branch->SetAddress(&fRecTriggerTracks);
else AliWarning(Form("(%s) Failed for Trigger Tracks. Can not find branch in tree.",GetName()));
}
-
-
}
//_____________________________________________________________________________
}
}
+
+//_____________________________________________________________________________
+void
+AliMUONData::DumpKine(Int_t event2Check)
+{
+/// Dump kinematics
+
+ fRunLoader->LoadKinematics("READ");
+
+ Int_t nevents = fRunLoader->GetNumberOfEvents();
+ for (Int_t ievent=0; ievent<nevents; ievent++) { // Event loop
+ if ( event2Check != 0 ) ievent=event2Check;
+
+ // Getting event ievent
+ fRunLoader->GetEvent(ievent);
+
+ // Stack of particle for this event
+ AliStack* stack = fRunLoader->Stack();
+
+ Int_t nparticles = (Int_t) fRunLoader->Stack()->GetNtrack();
+ printf(">>> Event %d, Number of particles is %d \n", ievent, nparticles);
+
+ for (Int_t iparticle=0; iparticle<nparticles; iparticle++) {
+ stack->Particle(iparticle)->Print("");
+ }
+ if (event2Check!=0) ievent=nevents;
+ }
+ fRunLoader->UnloadKinematics();
+}
+
+
+//_____________________________________________________________________________
+void
+AliMUONData::DumpHits(Int_t event2Check, Option_t* opt)
+{
+/// Dump hits
+
+ fLoader->LoadHits("READ");
+
+ // Event loop
+ Int_t nevents = fRunLoader->GetNumberOfEvents();
+ for (Int_t ievent=0; ievent<nevents; ievent++) {
+ if (event2Check!=0) ievent=event2Check;
+ printf(">>> Event %d \n",ievent);
+
+ // Getting event ievent
+ fRunLoader->GetEvent(ievent);
+ SetTreeAddress("H");
+
+ // Track loop
+ Int_t ntracks = (Int_t) GetNtracks();
+ for (Int_t itrack=0; itrack<ntracks; itrack++) {
+ //Getting List of Hits of Track itrack
+ GetTrack(itrack);
+
+ Int_t nhits = (Int_t) Hits()->GetEntriesFast();
+ printf(">>> Track %d, Number of hits %d \n",itrack,nhits);
+ for (Int_t ihit=0; ihit<nhits; ihit++) {
+ AliMUONHit* mHit = static_cast<AliMUONHit*>(Hits()->At(ihit));
+ mHit->Print(opt);
+ }
+ ResetHits();
+ }
+ if (event2Check!=0) ievent=nevents;
+ }
+ fLoader->UnloadHits();
+}
+
+//_____________________________________________________________________________
+void
+AliMUONData::DumpDigits(Int_t event2Check, Option_t* opt)
+{
+/// Dump digits
+
+ fLoader->LoadDigits("READ");
+
+ // Event loop
+ Int_t firstEvent = 0;
+ Int_t lastEvent = fRunLoader->GetNumberOfEvents()-1;
+ if ( event2Check != 0 ) {
+ firstEvent = event2Check;
+ lastEvent = event2Check;
+ }
+
+ for ( Int_t ievent = firstEvent; ievent <= lastEvent; ++ievent ) {
+ printf(">>> Event %d \n",ievent);
+ fRunLoader->GetEvent(ievent);
+
+ AliMUONDataIterator it(this, "digit", AliMUONDataIterator::kTrackingChambers);
+ AliMUONDigit* digit;
+
+ while ( ( digit = (AliMUONDigit*)it.Next() ) )
+ {
+ digit->Print(opt);
+ }
+ }
+ fLoader->UnloadDigits();
+}
+
+//_____________________________________________________________________________
+void
+AliMUONData::DumpSDigits(Int_t event2Check, Option_t* opt)
+{
+/// Dump SDigits
+
+ fLoader->LoadSDigits("READ");
+
+ // Event loop
+ Int_t nevents = fRunLoader->GetNumberOfEvents();
+ for (Int_t ievent=0; ievent<nevents; ievent++) {
+ if (event2Check!=0) ievent=event2Check;
+ printf(">>> Event %d \n",ievent);
+
+ // Getting event ievent
+ fRunLoader->GetEvent(ievent);
+ SetTreeAddress("S");
+ GetSDigits();
+
+ // Loop on chambers
+ Int_t nchambers = AliMUONConstants::NCh(); ;
+ for (Int_t ichamber=0; ichamber<nchambers; ichamber++) {
+ TClonesArray* digits = SDigits(ichamber);
+
+ // Loop on Sdigits
+ Int_t ndigits = (Int_t)digits->GetEntriesFast();
+ for (Int_t idigit=0; idigit<ndigits; idigit++) {
+ AliMUONDigit* mDigit = static_cast<AliMUONDigit*>(digits->At(idigit));
+ mDigit->Print(opt);
+ }
+ }
+ ResetSDigits();
+ if (event2Check!=0) ievent=nevents;
+ }
+ fLoader->UnloadSDigits();
+}
+
+//_____________________________________________________________________________
+void
+AliMUONData::DumpRecPoints(Int_t event2Check, Option_t* opt)
+{
+/// Dump rec points
+
+ fLoader->LoadRecPoints("READ");
+
+ // Event loop
+ Int_t nevents = fRunLoader->GetNumberOfEvents();
+ for (Int_t ievent=0; ievent<nevents; ievent++) {
+ if (event2Check!=0) ievent=event2Check;
+ printf(">>> Event %d \n",ievent);
+
+ // Getting event ievent
+ fRunLoader->GetEvent(ievent);
+ Int_t nchambers = AliMUONConstants::NTrackingCh();
+ SetTreeAddress("RC,TC");
+ GetRawClusters();
+
+ // Loop on chambers
+ for (Int_t ichamber=0; ichamber<nchambers; ichamber++) {
+ char branchname[30];
+ sprintf(branchname,"MUONRawClusters%d",ichamber+1);
+ //printf(">>> branchname %s\n",branchname);
+
+ // Loop on rec points
+ Int_t nrecpoints = (Int_t) RawClusters(ichamber)->GetEntriesFast();
+ // printf(">>> Chamber %2d, Number of recpoints = %6d \n",ichamber+1, nrecpoints);
+ for (Int_t irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
+ AliMUONRawCluster* mRecPoint = static_cast<AliMUONRawCluster*>(RawClusters(ichamber)->At(irecpoint));
+ mRecPoint->Print(opt);
+ }
+ }
+ ResetRawClusters();
+ if (event2Check!=0) ievent=nevents;
+ }
+ fLoader->UnloadRecPoints();
+}
+
+
+//_____________________________________________________________________________
+void
+AliMUONData::DumpRecTrigger(Int_t event2Check,
+ Int_t write, Bool_t readFromRP)
+{
+/// Reads and dumps trigger objects from MUON.RecPoints.root
+
+ TClonesArray * globalTrigger;
+ TClonesArray * localTrigger;
+
+ // Do NOT print out all the info if the loop runs over all events
+ Int_t printout = (event2Check == 0 ) ? 0 : 1 ;
+
+ // Book a ntuple for more detailled studies
+ TNtuple *tupleGlo = new TNtuple("TgtupleGlo","Global Trigger Ntuple","ev:global:slpt:shpt:uplpt:uphpt:lplpt:lplpt");
+ TNtuple *tupleLoc = new TNtuple("TgtupleLoc","Local Trigger Ntuple","ev:LoCircuit:LoStripX:LoDev:StripY:LoLpt:LoHpt:y11:y21:x11");
+
+ // counters
+ Int_t sLowpt=0,sHighpt=0;
+ Int_t uSLowpt=0,uSHighpt=0;
+ Int_t lSLowpt=0,lSHighpt=0;
+
+ AliMUONTriggerCrateStore* crateManager = new AliMUONTriggerCrateStore();
+ crateManager->ReadFromFile();
+
+ AliMUONGeometryTransformer* transformer = new AliMUONGeometryTransformer(kFALSE);
+ transformer->ReadGeometryData("volpath.dat", "geometry.root");
+
+ TClonesArray* triggerCircuit = new TClonesArray("AliMUONTriggerCircuit", 234);
+
+ for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++) {
+ AliMUONTriggerCircuit* c = new AliMUONTriggerCircuit();
+ c->SetTransformer(transformer);
+ c->Init(i,*crateManager);
+ TClonesArray& circuit = *triggerCircuit;
+ new(circuit[circuit.GetEntriesFast()])AliMUONTriggerCircuit(*c);
+ delete c;
+ }
+
+ Char_t fileName[30];
+ if (!readFromRP) {
+ AliInfoStream() << " reading from digits \n";
+ fLoader->LoadDigits("READ");
+ sprintf(fileName,"TriggerCheckFromDigits.root");
+ } else {
+ AliInfoStream() << " reading from RecPoints \n";
+ fLoader->LoadRecPoints("READ");
+ sprintf(fileName,"TriggerCheckFromRP.root");
+ }
+
+
+ AliMUONGlobalTrigger *gloTrg(0x0);
+ AliMUONLocalTrigger *locTrg(0x0);
+
+ Int_t nevents = fRunLoader->GetNumberOfEvents();
+ for (Int_t ievent=0; ievent<nevents; ievent++) {
+ if (event2Check!=0) ievent=event2Check;
+ if (ievent%100==0 || event2Check)
+ AliInfoStream() << "Processing event " << ievent << endl;
+ fRunLoader->GetEvent(ievent);
+
+ if (!readFromRP) {
+ SetTreeAddress("D,GLT");
+ GetTriggerD();
+ } else {
+ SetTreeAddress("RC,TC");
+ GetTrigger();
+ }
+
+ globalTrigger = GlobalTrigger();
+ localTrigger = LocalTrigger();
+
+ Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
+ Int_t nlocals = (Int_t) localTrigger->GetEntriesFast(); // up to 234
+ if (printout) printf("###################################################\n");
+ if (printout) printf("event %d nglobal %d nlocal %d \n",ievent,nglobals,nlocals);
+
+ for (Int_t iglobal=0; iglobal<nglobals; iglobal++) { // Global Trigger
+ gloTrg = static_cast<AliMUONGlobalTrigger*>(globalTrigger->At(iglobal));
+
+ sLowpt+=gloTrg->SingleLpt() ;
+ sHighpt+=gloTrg->SingleHpt() ;
+ uSLowpt+=gloTrg->PairUnlikeLpt();
+ uSHighpt+=gloTrg->PairUnlikeHpt();
+ lSLowpt+=gloTrg->PairLikeLpt();
+ lSHighpt+=gloTrg->PairLikeHpt();
+
+ if (printout) gloTrg->Print("full");
+
+ } // end of loop on Global Trigger
+
+ for (Int_t ilocal=0; ilocal<nlocals; ilocal++) { // Local Trigger
+ locTrg = static_cast<AliMUONLocalTrigger*>(localTrigger->At(ilocal));
+
+ Bool_t xTrig=kFALSE;
+ Bool_t yTrig=kFALSE;
+
+ if ( locTrg->LoSdev()==1 && locTrg->LoDev()==0 &&
+ locTrg->LoStripX()==0) xTrig=kFALSE; // no trigger in X
+ else xTrig=kTRUE; // trigger in X
+ if (locTrg->LoTrigY()==1 &&
+ locTrg->LoStripY()==15 ) yTrig = kFALSE; // no trigger in Y
+ else yTrig = kTRUE; // trigger in Y
+
+ if (xTrig && yTrig) { // make Trigger Track if trigger in X and Y
+
+ if (printout) locTrg->Print("full");
+
+ AliMUONTriggerCircuit* circuit = (AliMUONTriggerCircuit*)triggerCircuit->At(locTrg->LoCircuit()-1);
+
+ tupleLoc->Fill(ievent,locTrg->LoCircuit(),locTrg->LoStripX(),locTrg->LoDev(),locTrg->LoStripY(),locTrg->LoLpt(),locTrg->LoHpt(),circuit->GetY11Pos(locTrg->LoStripX()),circuit->GetY21Pos(locTrg->LoStripX()+locTrg->LoDev()+1),circuit->GetX11Pos(locTrg->LoStripY()));
+ }
+
+ } // end of loop on Local Trigger
+
+ // fill ntuple
+ tupleGlo->Fill(ievent,nglobals,gloTrg->SingleLpt(),gloTrg->SingleHpt(),gloTrg->PairUnlikeLpt(),gloTrg->PairUnlikeHpt(),gloTrg->PairLikeLpt(),gloTrg->PairLikeHpt());
+
+ ResetTrigger();
+ if (event2Check!=0) ievent=nevents;
+ } // end loop on event
+
+ // Print out summary if loop ran over all event
+ if (!event2Check){
+
+ printf("\n");
+ printf("=============================================\n");
+ printf("================ SUMMARY ==================\n");
+ printf("\n");
+ printf("Total number of events processed %d \n", (event2Check==0) ? nevents : 1);
+ printf("\n");
+ printf(" Global Trigger output Low pt High pt\n");
+ printf(" number of Single :\t");
+ printf("%i\t%i\t",sLowpt,sHighpt);
+ printf("\n");
+ printf(" number of UnlikeSign pair :\t");
+ printf("%i\t%i\t",uSLowpt,uSHighpt);
+ printf("\n");
+ printf(" number of LikeSign pair :\t");
+ printf("%i\t%i\t",lSLowpt,lSHighpt);
+ printf("\n");
+ printf("=============================================\n");
+ fflush(stdout);
+ }
+
+ if (write){
+ TFile *myFile = new TFile(fileName, "RECREATE");
+ tupleGlo->Write();
+ tupleLoc->Write();
+ myFile->Close();
+ }
+
+ fLoader->UnloadRecPoints();
+
+ delete crateManager;
+ delete transformer;
+ delete triggerCircuit;
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff