#include "AliModule.h"
-ClassImp(AliDetectorFrame);
+ClassImp(AliDetectorFrame)
int AliDetectorFrame::fgBaseId = 1000;
AliDisplay2 *gAliDisplay2;
-ClassImp(AliDisplay2);
+ClassImp(AliDisplay2)
//_____________________________________________________________
AliDisplay2::AliDisplay2(const TGWindow *p, UInt_t w, UInt_t h)
:TObject()
fMode = kTracks|fMode;
Update();
}
-};
+}
//_____________________________________________________________
void AliDisplay2::Disable(Int_t m)
#include "AliTPCParam.h"
#include "AliTPCcluster.h"
-ClassImp(AliDisplayClusters);
+ClassImp(AliDisplayClusters)
//_____________________________________________________________
AliDisplayClusters::AliDisplayClusters()
#include "AliRun.h"
-ClassImp(AliDisplayFrame);
+ClassImp(AliDisplayFrame)
//_____________________________________________________________
AliDisplayFrame::AliDisplayFrame(const TGWindow *p, UInt_t w, UInt_t h)
#include "AliL3Logging.h"
#endif
-ClassImp(AliDisplayHLT);
+ClassImp(AliDisplayHLT)
//_____________________________________________________________
AliDisplayHLT::AliDisplayHLT()
#include "AliInfoFrame.h"
#include "AliDisplay2.h"
-ClassImp(AliInfoFrame);
+ClassImp(AliInfoFrame)
//_____________________________________________________________
AliInfoFrame::AliInfoFrame(TGCompositeFrame *p, UInt_t w, UInt_t h)
fMainFrame->Layout();
fMainFrame->MapSubwindows();
fMainFrame->MapWindow();
-};
+}
//_____________________________________________________________
AliInfoFrame::~AliInfoFrame(void){
const char helpTxt[] = "\tAliDisplay v2.0\n\t\tHelp\n\n\nWelcome in the AliDisplay help.\nHere is a list of useful subjects which discribes\nthe main functionnalities of the software\n \nEvent:Use the arrows to get the next or previous event\nView:Each button corresponds to a different view\nDetectors:Select the module you want to see\nOptions:Select the view mode\nSliders:Use the rapidity (or eta) slider to cut the set of hits\n\tAnd the momentum slider to cut with respect to the momentum\n";
-ClassImp(AliMenu);
+ClassImp(AliMenu)
//_____________________________________________________________
AliMenu::AliMenu(TGCompositeFrame *p, UInt_t w, UInt_t h, UInt_t options)
#include "AliModuleInfo.h"
-ClassImp(AliModuleInfo);
+ClassImp(AliModuleInfo)
//_____________________________________________________________
AliModuleInfo::AliModuleInfo(int n)
#include "AliDisplay2.h"
#include "AliSettingFrame.h"
-ClassImp(AliSettingFrame);
+ClassImp(AliSettingFrame)
//_____________________________________________________________
AliSettingFrame::AliSettingFrame(const TGWindow *p, const TGWindow *main, UInt_t w, UInt_t h)
#include "AliShutterFrame.h"
-ClassImp(AliShutterFrame);
+ClassImp(AliShutterFrame)
//_____________________________________________________________
AliShutterFrame::AliShutterFrame(TGCompositeFrame *p, UInt_t /*w*/, UInt_t h)
#include "AliShutterItem.h"
#include "AliDisplay2.h"
-ClassImp(AliShutterItem);
+ClassImp(AliShutterItem)
//_____________________________________________________________
AliShutterItem::AliShutterItem(TGShutter *s, const char *text, UInt_t id)
#include "AliSliderFrame.h"
#include "AliDisplay2.h"
-ClassImp(AliSliderFrame);
+ClassImp(AliSliderFrame)
//_____________________________________________________________
AliSliderFrame::AliSliderFrame(const TGWindow *p, UInt_t w, UInt_t h)
#include "TPad.h"
#include "TPaveText.h"
-ClassImp(AliEMCALFastRecParticle) ;
+ClassImp(AliEMCALFastRecParticle)
//____________________________________________________________________________
AliEMCALFastRecParticle::AliEMCALFastRecParticle() : TParticle()
// --- EMCAL headers
#include "AliEMCALGeometry.h"
-ClassImp(AliEMCALGeometry);
+ClassImp(AliEMCALGeometry)
AliEMCALGeometry *AliEMCALGeometry::fgGeom = 0;
Bool_t AliEMCALGeometry::fgInit = kFALSE;
#include "TMath.h"
#include "AliGeVSimParticle.h"
-ClassImp(AliGeVSimParticle);
+ClassImp(AliGeVSimParticle)
////////////////////////////////////////////////////////////////////////////////////////////////////
#include "AliRun.h"
-ClassImp(AliGenGeVSim);
+ClassImp(AliGenGeVSim)
//////////////////////////////////////////////////////////////////////////////////
#include "AliGenGeVSimEventHeader.h"
-ClassImp(AliGenGeVSimEventHeader);
+ClassImp(AliGenGeVSimEventHeader)
////////////////////////////////////////////////////////////////////////////////
#include "AliGenReaderCwn.h"
-ClassImp(AliGenReaderCwn);
+ClassImp(AliGenReaderCwn)
AliGenReaderCwn::AliGenReaderCwn()
#include "AliRun.h"
#include "AliRunLoader.h"
-ClassImp(AliGenReaderTreeK);
+ClassImp(AliGenReaderTreeK)
const TString AliGenReaderTreeK::fgkEventFolderName("GenReaderTreeK");
// Debugging flag
//#define MYTRIGDEBUG
-ClassImp(AliFastMuonTriggerEff);
+ClassImp(AliFastMuonTriggerEff)
AliFastMuonTriggerEff::AliFastMuonTriggerEff():
AliFastResponse("Efficiency", "Muon Trigger Efficiency")
#include "AliFMDRawWriter.h" // ALIFMDRAWWRITER_H
//____________________________________________________________________
-ClassImp(AliFMD);
+ClassImp(AliFMD)
//____________________________________________________________________
const Char_t* AliFMD::fgkShortLegName = "FSSL";
//____________________________________________________________________
-ClassImp(AliFMD1);
+ClassImp(AliFMD1)
//____________________________________________________________________
AliFMD1::AliFMD1()
#include <TVirtualMC.h> // ROOT_TVirtualMC
//____________________________________________________________________
-ClassImp(AliFMD2);
+ClassImp(AliFMD2)
//____________________________________________________________________
AliFMD2::AliFMD2()
#include <Riostream.h> // ROOT_Riostream
//____________________________________________________________________
-ClassImp(AliFMD3);
+ClassImp(AliFMD3)
//____________________________________________________________________
AliFMD3::AliFMD3()
#include <Riostream.h> // ROOT_Riostream
//____________________________________________________________________
-ClassImp(AliFMD3Support);
+ClassImp(AliFMD3Support)
//____________________________________________________________________
const Char_t* AliFMD3Support::fgkNoseName = "F3SN";
//
#include "AliFMDBoolMap.h" //ALIFMDBOOLMAP_H
//__________________________________________________________
-ClassImp(AliFMDBoolMap);
+ClassImp(AliFMDBoolMap)
//__________________________________________________________
AliFMDBoolMap::AliFMDBoolMap(const AliFMDBoolMap& other)
: AliFMDMap(other.fMaxDetectors,
#include "Riostream.h" // ROOT_Riostream
//====================================================================
-ClassImp(AliFMDBaseDigit);
+ClassImp(AliFMDBaseDigit)
//____________________________________________________________________
AliFMDBaseDigit::AliFMDBaseDigit()
}
//====================================================================
-ClassImp(AliFMDDigit);
+ClassImp(AliFMDDigit)
//____________________________________________________________________
AliFMDDigit::AliFMDDigit()
}
//====================================================================
-ClassImp(AliFMDSDigit);
+ClassImp(AliFMDSDigit)
//____________________________________________________________________
AliFMDSDigit::AliFMDSDigit()
#include <AliRunLoader.h> // ALIRUNLOADER_H
//____________________________________________________________________
-ClassImp(AliFMDEdepMap);
+ClassImp(AliFMDEdepMap)
//====================================================================
-ClassImp(AliFMDBaseDigitizer);
+ClassImp(AliFMDBaseDigitizer)
//____________________________________________________________________
AliFMDBaseDigitizer::AliFMDBaseDigitizer()
//====================================================================
-ClassImp(AliFMDDigitizer);
+ClassImp(AliFMDDigitizer)
//____________________________________________________________________
AliFMDDigitizer::AliFMDDigitizer()
}
//====================================================================
-ClassImp(AliFMDSDigitizer);
+ClassImp(AliFMDSDigitizer)
//____________________________________________________________________
AliFMDSDigitizer::AliFMDSDigitizer()
#include "AliFMDEdepMap.h" // ALIFMDEDEPMAP_H
//____________________________________________________________________
-ClassImp(AliFMDEdepMap);
+ClassImp(AliFMDEdepMap)
//____________________________________________________________________
AliFMDEdepMap::AliFMDEdepMap(const AliFMDEdepMap& other)
#include "Riostream.h" // ROOT_Riostream
//____________________________________________________________________
-ClassImp(AliFMDHit);
+ClassImp(AliFMDHit)
//____________________________________________________________________
#include "AliFMDMap.h" // ALIFMDMAP_H
//____________________________________________________________________
-ClassImp(AliFMDMap);
+ClassImp(AliFMDMap)
//____________________________________________________________________
AliFMDMap::AliFMDMap(size_t maxDet,
#include <Riostream.h> // ROOT_Riostream
//____________________________________________________________________
-ClassImp(AliFMDMult);
+ClassImp(AliFMDMult)
//____________________________________________________________________
AliFMDMult::AliFMDMult(Float_t particles, UShort_t method)
#include <TClonesArray.h> // ROOT_TClonesArray
//____________________________________________________________________
-ClassImp(AliFMDMultAlgorithm);
+ClassImp(AliFMDMultAlgorithm)
//____________________________________________________________________
AliFMDMultAlgorithm::AliFMDMultAlgorithm(const char* name, const char* title)
#include <TTree.h> // ROOT_TTree
//____________________________________________________________________
-ClassImp(AliFMDMultNaiive);
+ClassImp(AliFMDMultNaiive)
//____________________________________________________________________
AliFMDMultNaiive::AliFMDMultNaiive()
#include <TTree.h> // ROOT_TTree
//____________________________________________________________________
-ClassImp(AliFMDMultPoisson);
+ClassImp(AliFMDMultPoisson)
//____________________________________________________________________
AliFMDMultPoisson::AliFMDMultPoisson()
#include <Riostream.h> // ROOT_Riostream
//____________________________________________________________________
-ClassImp(AliFMDMultRegion);
+ClassImp(AliFMDMultRegion)
//____________________________________________________________________
#include <Riostream.h> // ROOT_Riostream
//____________________________________________________________________
-ClassImp(AliFMDMultStrip);
+ClassImp(AliFMDMultStrip)
//____________________________________________________________________
#include "TError.h" // ROOT_TError
//____________________________________________________________________
-ClassImp(AliFMDPolygon);
+ClassImp(AliFMDPolygon)
//____________________________________________________________________
AliFMDPolygon::AliFMDPolygon()
// #include <TClonesArray.h> // ROOT_TClonesArray
//____________________________________________________________________
-ClassImp(AliFMDRawReader);
+ClassImp(AliFMDRawReader)
//____________________________________________________________________
AliFMDRawReader::AliFMDRawReader(AliFMD* fmd, AliRawReader* reader)
#include <AliRawReader.h> // ALIRAWREADER_H
//____________________________________________________________________
-ClassImp(AliFMDRawStream);
+ClassImp(AliFMDRawStream)
//____________________________________________________________________
AliFMDRawStream::AliFMDRawStream(AliRawReader* reader, UShort_t sampleRate)
#include <TClonesArray.h> // ROOT_TClonesArray
//____________________________________________________________________
-ClassImp(AliFMDRawWriter);
+ClassImp(AliFMDRawWriter)
//____________________________________________________________________
AliFMDRawWriter::AliFMDRawWriter(AliFMD* fmd)
#include "AliFMDMultNaiive.h" // ALIFMDMULTNAIIVE_H
//____________________________________________________________________
-ClassImp(AliFMDReconstructor);
+ClassImp(AliFMDReconstructor)
//____________________________________________________________________
AliFMDReconstructor::AliFMDReconstructor()
//____________________________________________________________________
-ClassImp(AliFMDRing);
+ClassImp(AliFMDRing)
//____________________________________________________________________
AliFMDRing::AliFMDRing(Char_t id, Bool_t detailed)
#include <TString.h> // ROOT_TString
//____________________________________________________________________
-ClassImp(AliFMDSubDetector);
+ClassImp(AliFMDSubDetector)
//____________________________________________________________________
const Char_t* AliFMDSubDetector::fgkHoneyTopFormat = "F%d%cH";
#include "AliFMDUShortMap.h" // ALIFMDUSHORTMAP_H
//____________________________________________________________________
-ClassImp(AliFMDUShortMap);
+ClassImp(AliFMDUShortMap)
//____________________________________________________________________
AliFMDUShortMap::AliFMDUShortMap(const AliFMDUShortMap& other)
#include "AliFMDv0.h" // ALIFMDV0_H
//____________________________________________________________________
-ClassImp(AliFMDv0);
+ClassImp(AliFMDv0)
//___________________________________________________________________
//
#include "AliFMDv1.h" // ALIFMDV1_H
//____________________________________________________________________
-ClassImp(AliFMDv1);
+ClassImp(AliFMDv1)
//____________________________________________________________________
#include <Riostream.h>
#include "AliITSTableSSD.h"
-ClassImp(AliITSTableSSD);
+ClassImp(AliITSTableSSD)
////////////////////////////////////////////////////////////////////////
// Version: 0
// Origin: Massimo Masera
//______________________________________________________________________
-ClassImp(AliITSpList);
+ClassImp(AliITSpList)
//______________________________________________________________________
AliITSpList::AliITSpList(){
// Default constructor
#include "AliITSsimulationSSD.h"
#include "AliITSTableSSD.h"
-ClassImp(AliITSsimulationSSD);
+ClassImp(AliITSsimulationSSD)
////////////////////////////////////////////////////////////////////////
// Version: 0
// Written by Enrico Fragiacomo
// Set all internal pointers to NULL and indices to -1.
Reset();
-};
+}
AliMUONDataInterface::AliMUONDataInterface(const AliMUONDataInterface& rhs)
: TObject(rhs)
if (fRunloader != NULL)
delete fRunloader;
-};
+}
AliMUONDataInterface&
AliMUONDataInterface::operator=(const AliMUONDataInterface& rhs)
fDigitAddressSet = kFALSE;
fClusterAddressSet = kFALSE;
fTriggerAddressSet = kFALSE;
-};
+}
Bool_t AliMUONDataInterface::LoadLoaders(TString filename, TString foldername)
AliError(Form("Could not find or load the run loader for the file: %s and folder: %s",
(const char*)filename, (const char*)foldername));
return kFALSE;
- };
+ }
fMuonloader = fRunloader->GetLoader("MUONLoader");
if (fMuonloader == NULL)
{
(const char*)filename, (const char*)foldername));
fRunloader = NULL;
return kFALSE;
- };
+ }
// Need to connect the muon loader to the AliMUONData object,
// else class to fData will return NULL.
fFoldername = foldername;
fEventnumber = -1; // Reset the event number to force the event to be loaded.
return kTRUE;
-};
+}
Bool_t AliMUONDataInterface::FetchLoaders(TString filename, TString foldername)
// Fetch the current file and folder names.
fFilename = fRunloader->GetFileName();
fFoldername = fRunloader->GetEventFolder()->GetName();
- };
+ }
// If filename or foldername are not the same as the ones currently selected then
// reopen the file.
{
delete fRunloader;
return LoadLoaders(filename, foldername);
- };
+ }
return kTRUE;
-};
+}
Bool_t AliMUONDataInterface::FetchEvent(Int_t event)
fDigitAddressSet = kFALSE;
fClusterAddressSet = kFALSE;
fTriggerAddressSet = kFALSE;
- };
+ }
if ( event != fEventnumber )
{
if ( fRunloader->GetEvent(event) < 0 ) return kFALSE;
fDigitAddressSet = kFALSE;
fClusterAddressSet = kFALSE;
fTriggerAddressSet = kFALSE;
- };
+ }
return kTRUE;
-};
+}
Bool_t AliMUONDataInterface::FetchTreeK()
{
AliError("Could not load TreeK.");
return kFALSE;
- };
- };
+ }
+ }
return kTRUE;
-};
+}
Bool_t AliMUONDataInterface::FetchTreeH()
{
AliError("Could not load TreeH.");
return kFALSE;
- };
+ }
fData.SetTreeAddress("H");
fHitAddressSet = kTRUE;
}
{
fData.SetTreeAddress("H");
fHitAddressSet = kTRUE;
- };
+ }
return kTRUE;
-};
+}
Bool_t AliMUONDataInterface::FetchTreeS()
{
AliError("Could not load TreeS.");
return kFALSE;
- };
+ }
fData.SetTreeAddress("S");
fSDigitAddressSet = kTRUE;
}
{
fData.SetTreeAddress("S");
fSDigitAddressSet = kTRUE;
- };
+ }
return kTRUE;
-};
+}
Bool_t AliMUONDataInterface::FetchTreeD()
{
AliError("Could not load TreeD.");
return kFALSE;
- };
+ }
fData.SetTreeAddress("D");
fDigitAddressSet = kTRUE;
}
{
fData.SetTreeAddress("D");
fDigitAddressSet = kTRUE;
- };
+ }
return kTRUE;
-};
+}
Bool_t AliMUONDataInterface::FetchTreeR()
{
AliError("Could not load TreeR.");
return kFALSE;
- };
+ }
// Need to reset these flags so that the cluster and trigger address
// gets reset after this method.
fClusterAddressSet = kFALSE;
fTriggerAddressSet = kFALSE;
- };
+ }
return kTRUE;
-};
+}
Int_t AliMUONDataInterface::NumberOfEvents(TString filename, TString foldername)
if ( ! FetchLoaders(filename, foldername) ) return -1;
return fRunloader->GetNumberOfEvents();
-};
+}
Int_t AliMUONDataInterface::NumberOfParticles(TString filename, TString foldername, Int_t event)
if ( ! FetchEvent(event) ) return -1;
if ( ! FetchTreeK() ) return -1;
return (Int_t) fRunloader->TreeK()->GetEntriesFast();
-};
+}
TParticle* AliMUONDataInterface::Particle(
treeK->GetBranch("Particles")->SetAddress(&p);
treeK->GetEvent(particle);
return p;
-};
+}
Int_t AliMUONDataInterface::NumberOfTracks(TString filename, TString foldername, Int_t event)
if ( ! FetchEvent(event) ) return -1;
if ( ! FetchTreeH() ) return -1;
return fData.GetNtracks();
-};
+}
Int_t AliMUONDataInterface::NumberOfHits(
fData.ResetHits();
fData.GetTrack(track);
fTrack = track;
- };
+ }
return fData.Hits()->GetEntriesFast();
-};
+}
AliMUONHit* AliMUONDataInterface::Hit(
fData.ResetHits();
fData.GetTrack(track);
fTrack = track;
- };
+ }
return static_cast<AliMUONHit*>( fData.Hits()->At(hit) );
-};
+}
Int_t AliMUONDataInterface::NumberOfSDigits(
fData.ResetSDigits();
fData.GetCathodeS(cathode);
fSCathode = cathode;
- };
+ }
return fData.SDigits(chamber)->GetEntriesFast();
-};
+}
AliMUONDigit* AliMUONDataInterface::SDigit(
fData.ResetSDigits();
fData.GetCathodeS(cathode);
fSCathode = cathode;
- };
+ }
return static_cast<AliMUONDigit*>( fData.SDigits(chamber)->At(sdigit) );
-};
+}
Int_t AliMUONDataInterface::NumberOfDigits(
fData.ResetDigits();
fData.GetCathode(cathode);
fCathode = cathode;
- };
+ }
return fData.Digits(chamber)->GetEntriesFast();
-};
+}
AliMUONDigit* AliMUONDataInterface::Digit(
fData.ResetDigits();
fData.GetCathode(cathode);
fCathode = cathode;
- };
+ }
return static_cast<AliMUONDigit*>( fData.Digits(chamber)->At(digit) );
-};
+}
Int_t AliMUONDataInterface::NumberOfRawClusters(
fData.ResetRawClusters();
fData.GetRawClusters();
fClusterAddressSet = kTRUE;
- };
+ }
return fData.RawClusters(chamber)->GetEntriesFast();
-};
+}
AliMUONRawCluster* AliMUONDataInterface::RawCluster(
fData.ResetRawClusters();
fData.GetRawClusters();
fClusterAddressSet = kTRUE;
- };
+ }
return static_cast<AliMUONRawCluster*>( fData.RawClusters(chamber)->At(cluster) );
-};
+}
Int_t AliMUONDataInterface::NumberOfLocalTriggers(TString filename, TString foldername, Int_t event)
fData.ResetTrigger();
fData.GetTrigger();
fTriggerAddressSet = kTRUE;
- };
+ }
return fData.LocalTrigger()->GetEntriesFast();
-};
+}
AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(
fData.ResetTrigger();
fData.GetTrigger();
fTriggerAddressSet = kTRUE;
- };
+ }
return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
-};
+}
Bool_t AliMUONDataInterface::SetFile(TString filename, TString foldername)
// kTRUE is returned if the run and muon loaders were found, else kFALSE.
return FetchLoaders(filename, foldername);
-};
+}
Bool_t AliMUONDataInterface::GetEvent(Int_t event)
// kTRUE is returned if the event was found, else kFALSE is returned.
return FetchEvent(event);
-};
+}
Int_t AliMUONDataInterface::NumberOfEvents()
{
AliError("File not set.");
return -1;
- };
+ }
return fRunloader->GetNumberOfEvents();
-};
+}
Int_t AliMUONDataInterface::NumberOfParticles()
{
AliError("File not set.");
return -1;
- };
+ }
if ( ! FetchTreeK() ) return -1;
return (Int_t) fRunloader->TreeK()->GetEntriesFast();
-};
+}
TParticle* AliMUONDataInterface::Particle(Int_t particle)
{
AliError("File not set.");
return NULL;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return NULL;
- };
+ }
if ( ! FetchTreeK() ) return NULL;
TTree* treeK = fRunloader->TreeK();
TParticle* p = NULL;
treeK->GetBranch("Particles")->SetAddress(&p);
treeK->GetEvent(particle);
return p;
-};
+}
Int_t AliMUONDataInterface::NumberOfTracks()
{
AliError("File not set.");
return -1;
- };
+ }
if (fEventnumber < 0)
{
AliError( "Event not chosen.");
return -1;
- };
+ }
if ( ! FetchTreeH() ) return -1;
return fData.GetNtracks();
-};
+}
Int_t AliMUONDataInterface::NumberOfHits(Int_t track)
{
AliError("File not set.");
return -1;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return -1;
- };
+ }
if ( ! FetchTreeH() ) return -1;
if (fTrack < 0 || fTrack != track)
{
fData.ResetHits();
fData.GetTrack(track);
fTrack = track;
- };
+ }
return fData.Hits()->GetEntriesFast();
-};
+}
AliMUONHit* AliMUONDataInterface::Hit(Int_t track, Int_t hit)
{
AliError("File not set.");
return NULL;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return NULL;
- };
+ }
if ( ! FetchTreeH() ) return NULL;
if (fTrack < 0 || fTrack != track)
{
fData.ResetHits();
fData.GetTrack(track);
fTrack = track;
- };
+ }
return static_cast<AliMUONHit*>( fData.Hits()->At(hit) );
-};
+}
Int_t AliMUONDataInterface::NumberOfSDigits(Int_t chamber, Int_t cathode)
{
AliError("File not set.");
return -1;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return -1;
- };
+ }
if ( ! FetchTreeS() ) return -1;
if ( fSCathode != cathode )
fData.ResetSDigits();
fData.GetCathodeS(cathode);
fSCathode = cathode;
- };
+ }
return fData.SDigits(chamber)->GetEntriesFast();
-};
+}
AliMUONDigit* AliMUONDataInterface::SDigit(Int_t chamber, Int_t cathode, Int_t sdigit)
{
AliError("File not set.");
return NULL;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return NULL;
- };
+ }
if ( ! FetchTreeS() ) return NULL;
if ( fSCathode != cathode )
fData.ResetSDigits();
fData.GetCathodeS(cathode);
fSCathode = cathode;
- };
+ }
return static_cast<AliMUONDigit*>( fData.SDigits(chamber)->At(sdigit) );
-};
+}
Int_t AliMUONDataInterface::NumberOfDigits(Int_t chamber, Int_t cathode)
{
AliError("File not set.");
return -1;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return -1;
- };
+ }
if ( ! FetchTreeD() ) return -1;
if ( fCathode != cathode )
fData.ResetDigits();
fData.GetCathode(cathode);
fCathode = cathode;
- };
+ }
return fData.Digits(chamber)->GetEntriesFast();
-};
+}
AliMUONDigit* AliMUONDataInterface::Digit(Int_t chamber, Int_t cathode, Int_t digit)
{
AliError("File not set.");
return NULL;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return NULL;
- };
+ }
if ( ! FetchTreeD() ) return NULL;
if ( fCathode != cathode )
fData.ResetDigits();
fData.GetCathode(cathode);
fCathode = cathode;
- };
+ }
return static_cast<AliMUONDigit*>( fData.Digits(chamber)->At(digit) );
-};
+}
Int_t AliMUONDataInterface::NumberOfRawClusters(Int_t chamber)
{
AliError("File not set.");
return -1;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return -1;
- };
+ }
if ( ! FetchTreeR() ) return -1;
if ( ! fClusterAddressSet )
fData.ResetRawClusters();
fData.GetRawClusters();
fClusterAddressSet = kTRUE;
- };
+ }
return fData.RawClusters(chamber)->GetEntriesFast();
-};
+}
AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t cluster)
{
AliError("File not set.");
return NULL;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return NULL;
- };
+ }
if ( ! FetchTreeR() ) return NULL;
if ( ! fClusterAddressSet )
fData.ResetRawClusters();
fData.GetRawClusters();
fClusterAddressSet = kTRUE;
- };
+ }
return static_cast<AliMUONRawCluster*>( fData.RawClusters(chamber)->At(cluster) );
-};
+}
Int_t AliMUONDataInterface::NumberOfLocalTriggers()
{
AliError("File not set.");
return -1;
- };
+ }
if (fEventnumber < 0)
{
AliError("Event not chosen.");
return -1;
- };
+ }
if ( ! FetchTreeR() ) return -1;
if ( ! fTriggerAddressSet )
fData.ResetTrigger();
fData.GetTrigger();
fTriggerAddressSet = kTRUE;
- };
+ }
return fData.LocalTrigger()->GetEntriesFast();
-};
+}
AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(Int_t trigger)
{
AliError("File not set.");
return NULL;
- };
+ }
if (fEventnumber < 0)
{
AliError( "Event not chosen.");
return NULL;
- };
+ }
if ( ! FetchTreeR() ) return NULL;
if ( ! fTriggerAddressSet )
fData.ResetTrigger();
fData.GetTrigger();
fTriggerAddressSet = kTRUE;
- };
+ }
return static_cast<AliMUONLocalTrigger*>( fData.LocalTrigger()->At(trigger) );
-};
+}
fMUON = NULL;
fMUONData = NULL;
fTrigDec = NULL;
-};
+}
//___________________________________________
AliMUONDigitizer::AliMUONDigitizer(AliRunDigitizer* manager) :
fMUON = NULL;
fMUONData = NULL;
fTrigDec = NULL;
-};
+}
//___________________________________________
AliMUONDigitizer::AliMUONDigitizer(const AliMUONDigitizer& rhs)
{
AliWarning("No inputs set, nothing to do.");
return;
- };
+ }
if (!FetchLoaders(fManager->GetInputFolderName(0), fRunLoader, fGime) ) return;
if (! FetchGlobalPointers(fRunLoader) ) return;
if (! InitInputData(fGime) ) continue;
GenerateTransientDigits();
CleanupInputData(fGime);
- };
+ }
Bool_t ok = FetchLoaders(fManager->GetOutputFolderName(), fRunLoader, fGime);
if (ok) ok = InitOutputData(fGime);
CleanupArrays();
CleanupTriggerArrays();
-};
+}
//--------------------------------------------------------------------------
void AliMUONDigitizer::AddOrUpdateTransientDigit(AliMUONTransientDigit* mTD)
}
else
AddTransientDigit(mTD);
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::UpdateTransientDigit(AliMUONTransientDigit* mTD)
ntracks));
AliDebug(1,Form( "Reseting the number of tracks to be %d.", kMAXTRACKS));
ntracks = kMAXTRACKS;
- };
+ }
for (Int_t i = 0; i < ntracks; i++)
{
pdigit->UpdateTrackList( mTD->GetTrack(i), mTD->GetCharge(i) );
- };
-};
+ }
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::AddTransientDigit(AliMUONTransientDigit* mTD)
fTDList->AddAtAndExpand(mTD, fTDCounter);
fHitMap[iNchCpl]->SetHit( mTD->PadX(), mTD->PadY(), fTDCounter);
fTDCounter++;
-};
+}
//------------------------------------------------------------------------
Bool_t AliMUONDigitizer::ExistTransientDigit(AliMUONTransientDigit* mTD)
// Choosing the maping of the cathode plane of the chamber:
Int_t iNchCpl= mTD->Chamber() + (mTD->Cathode()-1) * AliMUONConstants::NCh();
return( fHitMap[iNchCpl]->TestHit(mTD->PadX(), mTD->PadY()) );
-};
+}
//-----------------------------------------------------------------------
void AliMUONDigitizer::CreateDigits()
Int_t q = GetSignalFrom(td);
if (q > 0) AddDigit(td, q);
- };
+ }
FillOutputData();
- };
-};
+ }
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::AddDigit(AliMUONTransientDigit* td, Int_t responseCharge)
nptracks));
AliDebug(1, Form("Reseting the number of tracks to be %d.", kMAXTRACKS));
nptracks = kMAXTRACKS;
- };
+ }
for (Int_t i = 0; i < nptracks; i++)
{
tracks[i] = td->GetTrack(i);
charges[i] = td->GetCharge(i);
- };
+ }
// Sort list of tracks according to charge
SortTracks(tracks,charges,nptracks);
{
tracks[i] = -1;
charges[i] = 0;
- };
- };
+ }
+ }
AliDebug(4,Form( "Adding digit with charge %d.", responseCharge));
OnWriteTransientDigit(td);
AddDigit(td->Chamber(), tracks, charges, digits);
AddDigitTrigger(td->Chamber(), tracks, charges, digits);
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::OnCreateTransientDigit(AliMUONTransientDigit* /*digit*/, TObject* /*source_object*/)
//
// This is derived by Digitisers that want to trace which digits were made from
// which hits.
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::OnWriteTransientDigit(AliMUONTransientDigit* /*digit*/)
//
// This is derived by Digitisers that want to trace which digits were made from
// which hits.
-};
+}
//------------------------------------------------------------------------
Bool_t AliMUONDigitizer::FetchLoaders(const char* foldername, AliRunLoader*& runloader, AliMUONLoader*& muonloader)
}
return kTRUE;
-};
+}
//------------------------------------------------------------------------
Bool_t AliMUONDigitizer::FetchGlobalPointers(AliRunLoader* runloader)
{
AliError(Form("Could not find the AliRun object in runloader 0x%X.", (void*)runloader));
return kFALSE;
- };
+ }
fMUON = (AliMUON*) gAlice->GetDetector("MUON");
if (fMUON == NULL)
{
AliError(Form("Could not find the MUON module in runloader 0x%X.", (void*)runloader));
return kFALSE;
- };
+ }
AliMUONLoader *muonloader = (AliMUONLoader*) runloader->GetLoader("MUONLoader");
if (muonloader == NULL)
{
AliError(Form("Could not find AliMUONData object in runloader 0x%X.", (void*)runloader));
return kFALSE;
- };
+ }
return kTRUE;
}
{
AliInfo("Called with option \"debug\".");
SetDebug(99);
- };
-};
+ }
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::InitArrays()
AliDebug(4,Form( "Creating hit map for chamber %d, cathode 2.", i+1));
AliSegmentation* c2Segmentation = chamber->SegmentationModel(2); // Cathode plane 2
fHitMap[i+AliMUONConstants::NCh()] = new AliMUONHitMapA1(c2Segmentation, fTDList);
- };
-};
+ }
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::CleanupArrays()
AliDebug(4,Form( "Deleting hit map for chamber %d, cathode %d.",
i%AliMUONConstants::NCh()+1, i/AliMUONConstants::NCh()+1));
delete fHitMap[i];
- };
+ }
delete [] fHitMap;
fHitMap = NULL;
delete fTDList;
fTDList = NULL;
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizer::SortTracks(Int_t *tracks, Int_t *charges, Int_t ntr) const
tracks[i] = jtr[i];
}
}
-};
+}
// Tracking Chamber
// Initialize hit position (cursor) in the segmentation model
chamber.SigGenInit(mHit->X(), mHit->Y(), mHit->Z());
- }; // else do nothing for Trigger Chambers
+ } // else do nothing for Trigger Chambers
MakeTransientDigitsFromHit(itrack, ihit, mHit);
} // hit loop
} // track loop
-};
+}
//--------------------------------------------------------------------------
void AliMUONDigitizerv1::MakeTransientDigitsFromHit(Int_t track, Int_t iHit, AliMUONHit * mHit)
{
charge = digits[3] + fMask;
digits[4] = 0; // No signal due to physics since this is now background.
- };
+ }
digits[5] = iHit+fMask; // Hit number in the list
AliDebug(5,Form("MakeTransientDigitsFromHit",
OnCreateTransientDigit(mTD, mHit);
AddOrUpdateTransientDigit(mTD);
- };
-};
+ }
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv1::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6])
{
// Derived to add digits to TreeD.
fMUONData->AddDigit(chamber, tracks, charges, digits);
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv1::AddDigitTrigger(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6])
{
// Derived to add digits to TreeD for trigger.
fTrigDec->AddDigit(chamber, tracks, charges, digits);
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv1::FillTriggerOutput()
AliDebug(3,"Filling trees with trigger.");
fMUONData->Fill("GLT");
fMUONData->ResetTrigger();
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv1::CreateTrigger()
fTrigDec->Digits2Trigger();
FillTriggerOutput();
-};
+}
//------------------------------------------------------------------------
Int_t AliMUONDigitizerv1::GetSignalFrom(AliMUONTransientDigit* td)
AliMUONResponse* response = chamber.ResponseModel();
q = response->DigitResponse(q, td);
return q;
-};
+}
//------------------------------------------------------------------------
Bool_t AliMUONDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
{
AliError("Could not create TreeD.");
return kFALSE;
- };
- };
+ }
+ }
fMUONData->MakeBranch("D");
fMUONData->SetTreeAddress("D");
return kTRUE;
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv1::FillOutputData()
AliDebug(3, "Filling trees with digits.");
fMUONData->Fill("D");
fMUONData->ResetDigits();
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv1::CleanupOutputData(AliMUONLoader* muonloader)
AliDebug(3, "Writing digits and releasing pointers.");
muonloader->WriteDigits("OVERWRITE");
muonloader->UnloadDigits();
-};
+}
//------------------------------------------------------------------------
{
AliError("Can not load the hits tree.");
return kFALSE;
- };
- };
+ }
+ }
fMUONData->SetTreeAddress("H");
return kTRUE;
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv1::CleanupInputData(AliMUONLoader* muonloader)
AliDebug(3, "Releasing loaded hits.");
fMUONData->ResetHits();
muonloader->UnloadHits();
-};
+}
{
sDigit = (AliMUONDigit*) muonSDigits->UncheckedAt(k);
MakeTransientDigitFromSDigit(ich,sDigit);
- };
+ }
} // SDigits loop, end loop over chamber
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv2::MakeTransientDigitFromSDigit(Int_t iChamber, AliMUONDigit* sDigit)
Int_t track = sDigit->Track(itrack);
if (track < 0) break; // Check if we reached the end of the track list.
mTD->AddToTrackList( track + fMask, sDigit->TrackCharge(itrack) );
- };
+ }
OnCreateTransientDigit(mTD, sDigit);
AddOrUpdateTransientDigit(mTD);
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv2::AddDigit(Int_t chamber, Int_t tracks[kMAXTRACKS], Int_t charges[kMAXTRACKS], Int_t digits[6])
{
// Override to add new digits to the digits tree TreeD.
fMUONData->AddDigit(chamber, tracks, charges, digits);
-};
+}
//------------------------------------------------------------------------
Bool_t AliMUONDigitizerv2::InitInputData(AliMUONLoader* muonloader)
{
AliError("Can not load the s-digits tree.");
return kFALSE;
- };
- };
+ }
+ }
fMUONData->SetTreeAddress("S");
return kTRUE;
-};
+}
//------------------------------------------------------------------------
void AliMUONDigitizerv2::CleanupInputData(AliMUONLoader* muonloader)
AliDebug(3,"Releasing loaded s-digits.");
fMUONData->ResetSDigits();
muonloader->UnloadSDigits();
-};
+}
#include "AliMUONGlobalTrigger.h"
-ClassImp(AliMUONGlobalTrigger);
+ClassImp(AliMUONGlobalTrigger)
//----------------------------------------------------------------------
AliMUONGlobalTrigger::AliMUONGlobalTrigger()
: TObject()
#include "AliMUONLocalTrigger.h"
-ClassImp(AliMUONLocalTrigger);
+ClassImp(AliMUONLocalTrigger)
//----------------------------------------------------------------------
AliMUONLocalTrigger::AliMUONLocalTrigger()
: TObject()
#include "AliMUONRawCluster.h"
-ClassImp(AliMUONRawCluster);
+ClassImp(AliMUONRawCluster)
AliMUONRawCluster::AliMUONRawCluster()
: AliMUONResponseV0()
{
// Default constructor
-};
+}
//------------------------------------------------------------------
Int_t AliMUONResponseTrigger::SetGenerCluster(){
// Derived to write to the s-digit tree TreeS.
fMUONData->AddSDigit(chamber, tracks, charges, digits);
-};
+}
//------------------------------------------------------------------------
Int_t AliMUONSDigitizerv1::GetSignalFrom(AliMUONTransientDigit* td)
// Returns the transient digit signal as is without applying the chamber response.
AliDebug(4,"Returning TransientDigit signal.");
return td->Signal();
-};
+}
//------------------------------------------------------------------------
Bool_t AliMUONSDigitizerv1::InitOutputData(AliMUONLoader* muonloader)
{
AliError("Could not create TreeS.");
return kFALSE;
- };
- };
+ }
+ }
fMUONData->MakeBranch("S");
fMUONData->SetTreeAddress("S");
return kTRUE;
-};
+}
//------------------------------------------------------------------------
void AliMUONSDigitizerv1::FillOutputData()
AliDebug(3,"Filling trees with s-digits.");
fMUONData->Fill("S");
fMUONData->ResetSDigits();
-};
+}
//------------------------------------------------------------------------
void AliMUONSDigitizerv1::CleanupOutputData(AliMUONLoader* muonloader)
muonloader->WriteSDigits("OVERWRITE");
fMUONData->ResetSDigits();
muonloader->UnloadSDigits();
-};
+}
#include "AliMUONSegmentationSlatModuleN.h"
//___________________________________________
-ClassImp(AliMUONSegmentationSlatN);
+ClassImp(AliMUONSegmentationSlatN)
AliMUONSegmentationSlatN::AliMUONSegmentationSlatN()
: AliMUONSegmentationSlat()
#include "AliMUONSt1ElectronicElement.h"
#include "AliMpPad.h"
-ClassImp(AliMUONSt1ElectronicElement);
+ClassImp(AliMUONSt1ElectronicElement)
//______________________________________________________________________________
AliMUONSt1ElectronicElement::AliMUONSt1ElectronicElement()
#include "AliMUONTransientDigit.h"
#include "AliLog.h"
-ClassImp(AliMUONSt1Response);
+ClassImp(AliMUONSt1Response)
const TString AliMUONSt1Response::fgkTopDir = getenv("ALICE_ROOT");
const TString AliMUONSt1Response::fgkDataDir = "/MUON/data/";
#include "AliMUONSt1ResponseParameter.h"
#include "AliLog.h"
-ClassImp(AliMUONSt1ResponseParameter);
+ClassImp(AliMUONSt1ResponseParameter)
//_________________________________________________________________________
AliMUONSt1ResponseParameter::AliMUONSt1ResponseParameter()
#include "AliMUONSt1ResponseRule.h"
#include "AliMUONSt1ElectronicElement.h"
#include "AliMUONSt1ResponseParameter.h"
-ClassImp(AliMUONSt1ResponseRule);
+ClassImp(AliMUONSt1ResponseRule)
//__________________________________________________________________________
AliMUONSt1ResponseRule::AliMUONSt1ResponseRule()
#include "AliPHOSCPVBaseGeometry.h"
-ClassImp(AliPHOSCPVBaseGeometry) ;
+ClassImp(AliPHOSCPVBaseGeometry)
//____________________________________________________________________________
#include "AliPHOSCPVGeometry.h"
-ClassImp(AliPHOSCPVGeometry) ;
+ClassImp(AliPHOSCPVGeometry)
//____________________________________________________________________________
AliPHOSCPVGeometry::AliPHOSCPVGeometry()
#include "AliPHOSEMCAGeometry.h"
-ClassImp(AliPHOSEMCAGeometry) ;
+ClassImp(AliPHOSEMCAGeometry)
//____________________________________________________________________________
AliPHOSEMCAGeometry::AliPHOSEMCAGeometry()
#include "TPad.h"
#include "TPaveText.h"
-ClassImp(AliPHOSFastRecParticle) ;
+ClassImp(AliPHOSFastRecParticle)
//____________________________________________________________________________
AliPHOSFastRecParticle::AliPHOSFastRecParticle() : TParticle()
#include "AliPHOSEMCAGeometry.h"
#include "AliPHOSRecPoint.h"
-ClassImp(AliPHOSGeometry) ;
+ClassImp(AliPHOSGeometry)
// these initialisations are needed for a singleton
AliPHOSGeometry * AliPHOSGeometry::fgGeom = 0 ;
#include "AliLog.h"
#include "AliPHOSGridFile.h"
-ClassImp(AliPHOSGridFile) ;
+ClassImp(AliPHOSGridFile)
//____________________________________________________________________________
AliPHOSGridFile::AliPHOSGridFile(TString grid)
#include "AliPHOSSupportGeometry.h"
-ClassImp(AliPHOSSupportGeometry) ;
+ClassImp(AliPHOSSupportGeometry)
//____________________________________________________________________________
AliPHOSSupportGeometry::AliPHOSSupportGeometry()
/* $Id$ */
#include "AliGenPythiaEventHeader.h"
-ClassImp(AliGenPythiaEventHeader);
+ClassImp(AliGenPythiaEventHeader)
//return response bin i - bin given by padrow [0] pad[1] timebin[2]
if (i<fCurrentMax) return &fResponseBin[i*3];
else return 0;
-};
+}
inline Float_t &AliTPCParam::GetResWeight(Int_t i)
{