#include <string.h>
#include "AliEveMUONData.h"
#include <EveDet/AliEveMUONChamberData.h>
#include <EveBase/AliEveEventManager.h>
#include <AliRawReader.h>
#include <AliRawReaderFile.h>
#include <AliRawReaderDate.h>
#include <AliRawReaderRoot.h>
#include <AliMUONDigitMaker.h>
#include <AliMUONHit.h>
#include <AliMUONVCluster.h>
#include "AliMUONVClusterStore.h"
#include <AliMUONVDigit.h>
#include "AliMUONDigitStoreV1.h"
#include "AliMUONVDigitStore.h"
#include "AliMUONTrackParam.h"
#include "AliMUONTrack.h"
#include "AliMUONESDInterface.h"
#include "AliESDMuonTrack.h"
#include "AliESDEvent.h"
#include "TTree.h"
#include "TString.h"
#include "TClonesArray.h"
#include "TFile.h"
using std::cout;
using std::endl;
ClassImp(AliEveMUONData)
AliRawReader* AliEveMUONData::fgRawReader = 0;
AliEveMUONData::AliEveMUONData() :
fChambers(14),
fNTrackList(0)
{
for (Int_t i = 0; i < 256; i++) {
fTrackList[i] = -1;
}
CreateAllChambers();
}
AliEveMUONData::~AliEveMUONData()
{
DeleteAllChambers();
}
void AliEveMUONData::Reset()
{
fNTrackList = 0;
for (Int_t i = 0; i < 256; i++) {
fTrackList[i] = -1;
}
}
AliEveMUONData::AliEveMUONData(const AliEveMUONData &mdata) :
TObject(mdata),
TEveRefCnt(),
fChambers(14),
fNTrackList(0)
{
memset(fTrackList,0,256*sizeof(Int_t));
}
AliEveMUONData& AliEveMUONData::operator=(const AliEveMUONData &mdata)
{
if (this != &mdata) {
}
return *this;
}
void AliEveMUONData::CreateChamber(Int_t chamber)
{
if (fChambers[chamber] == 0)
fChambers[chamber] = new AliEveMUONChamberData(chamber);
}
void AliEveMUONData::CreateAllChambers()
{
for (Int_t c = 0; c < 14; ++c)
CreateChamber(c);
}
void AliEveMUONData::DropAllChambers()
{
for (Int_t c = 0; c < 14; ++c) {
if (fChambers[c] != 0)
fChambers[c]->DropData();
}
}
void AliEveMUONData::DeleteAllChambers()
{
for (Int_t c = 0; c < 14; ++c) {
delete fChambers[c];
fChambers[c] = 0;
}
}
void AliEveMUONData::RegisterTrack(Int_t track)
{
if (fNTrackList == (256-1)) {
cout << "Maximum of registered tracks reached..." << endl;
return;
}
Bool_t inList = kFALSE;
for (Int_t i = 0; i < fNTrackList; i++) {
if (track == fTrackList[i]) {
inList = kTRUE;
break;
}
}
if (!inList) {
fTrackList[fNTrackList] = track;
fNTrackList++;
}
}
void AliEveMUONData::LoadRecPoints(TTree* tree)
{
AliMUONVClusterStore *clusterStore = AliMUONVClusterStore::Create(*tree);
clusterStore->Clear();
clusterStore->Connect(*tree,kFALSE);
tree->GetEvent(0);
AliMUONVCluster *cluster;
Int_t detElemId;
Double_t clsX, clsY, clsZ, charge;
for (Int_t ch = 0; ch < 10; ++ch) {
if (fChambers[ch] == 0) continue;
TIter next(clusterStore->CreateChamberIterator(ch,ch));
while ( ( cluster = static_cast<AliMUONVCluster*>(next()) ) ) {
detElemId = cluster->GetDetElemId();
clsX = cluster->GetX();
clsY = cluster->GetY();
clsZ = cluster->GetZ();
charge = cluster->GetCharge();
fChambers[ch]->RegisterCluster(detElemId,0,clsX,clsY,clsZ,charge);
fChambers[ch]->RegisterCluster(detElemId,1,clsX,clsY,clsZ,charge);
}
}
delete clusterStore;
}
void AliEveMUONData::LoadRecPointsFromESD(const Char_t *fileName)
{
TFile* esdFile = TFile::Open(fileName);
if (!esdFile || !esdFile->IsOpen()) {
cout << "opening ESD file " << fileName << "failed" << endl;
return;
}
TTree* esdTree = (TTree*) esdFile->Get("esdTree");
if (!esdTree) {
cout << "no ESD tree found" << endl;
esdFile->Close();
return;
}
AliESDEvent* esdEvent = new AliESDEvent();
esdEvent->ReadFromTree(esdTree);
AliMUONVCluster *cluster;
AliMUONTrackParam *trackParam;
AliESDMuonTrack *esdTrack;
AliMUONTrack muonTrack;
Int_t detElemId, chamber, nTrackParam;
Double_t clsX, clsY, clsZ, charge;
if (esdTree->GetEvent(AliEveEventManager::GetMaster()->GetEventId()) <= 0) {
cout << "fails to read ESD object for event " << AliEveEventManager::GetMaster()->GetEventId() << endl;
return;
}
Int_t nTracks = Int_t(esdEvent->GetNumberOfMuonTracks());
for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
esdTrack = esdEvent->GetMuonTrack(iTrack);
if (!esdTrack->ContainTrackerData()) continue;
AliMUONESDInterface::ESDToMUON(*esdTrack,muonTrack);
nTrackParam = muonTrack.GetTrackParamAtCluster()->GetEntries();
for(Int_t iCluster = 0; iCluster < nTrackParam; iCluster++) {
trackParam = (AliMUONTrackParam *) muonTrack.GetTrackParamAtCluster()->At(iCluster);
cluster = trackParam->GetClusterPtr();
chamber = cluster->GetChamberId();
detElemId = cluster->GetDetElemId();
charge = cluster->GetCharge();
clsX = cluster->GetX();
clsY = cluster->GetY();
clsZ = cluster->GetZ();
fChambers[chamber]->RegisterCluster(detElemId,0,clsX,clsY,clsZ,charge);
fChambers[chamber]->RegisterCluster(detElemId,1,clsX,clsY,clsZ,charge);
}
}
delete esdEvent;
esdFile->Close();
}
void AliEveMUONData::LoadHits(TTree* tree)
{
TClonesArray *hits = 0;
AliMUONHit *mhit;
Int_t cha, detElemId, nhits, ntracks;
Float_t hitX, hitY, hitZ;
ntracks = tree->GetEntries();
tree->SetBranchAddress("MUONHits",&hits);
for (Int_t it = 0; it < ntracks; it++) {
tree->GetEvent(it);
nhits = hits->GetEntriesFast();
for (Int_t ih = 0; ih < nhits; ih++) {
mhit = (AliMUONHit*)hits->UncheckedAt(ih);
hitX = mhit->X();
hitY = mhit->Y();
hitZ = mhit->Z();
detElemId = mhit->DetElemId();
cha = mhit->Chamber();
RegisterTrack(mhit->GetTrack());
fChambers[cha-1]->RegisterHit(detElemId,hitX,hitY,hitZ);
}
}
}
void AliEveMUONData::LoadDigits(TTree* tree)
{
AliMUONVDigitStore *digitStore = AliMUONVDigitStore::Create(*tree);
digitStore->Clear();
digitStore->Connect(*tree,0);
tree->GetEvent(0);
AliMUONVDigit* digit;
TIter next(digitStore->CreateIterator());
Int_t cathode, detElemId, ix, iy, charge, chamber, adc;
while ( ( digit = static_cast<AliMUONVDigit*>(next() ) ) )
{
cathode = digit->Cathode();
ix = digit->PadX();
iy = digit->PadY();
detElemId = digit->DetElemId();
charge = (Int_t)digit->Charge();
adc = digit->ADC();
chamber = detElemId/100 - 1;
if (chamber > 9) {
fChambers[chamber]->RegisterDigit(detElemId,cathode,ix,iy,charge);
} else {
fChambers[chamber]->RegisterDigit(detElemId,cathode,ix,iy,adc);
}
}
delete digitStore;
}
void AliEveMUONData::LoadRaw(TString fileName)
{
if (fgRawReader == 0) {
if (fileName.EndsWith("/")) {
fgRawReader = new AliRawReaderFile(fileName);
} else if (fileName.EndsWith(".root")) {
fgRawReader = new AliRawReaderRoot(fileName);
} else if (!fileName.IsNull()) {
fgRawReader = new AliRawReaderDate(fileName);
}
}
fgRawReader->RewindEvents();
fgRawReader->Reset();
Int_t iEvent = 0;
while (fgRawReader->NextEvent())
{
if (iEvent != AliEveEventManager::GetMaster()->GetEventId())
{
iEvent++;
continue;
}
break;
}
AliMUONDigitMaker digitMaker;
digitMaker.SetMakeTriggerDigits(kTRUE);
AliMUONDigitStoreV1 digitStore;
digitMaker.Raw2Digits(fgRawReader,&digitStore);
AliMUONVDigit* digit;
TIter next(digitStore.CreateIterator());
Int_t cathode, detElemId, ix, iy, charge, chamber, adc;
while ( ( digit = static_cast<AliMUONVDigit*>(next() ) ) )
{
cathode = digit->Cathode();
ix = digit->PadX();
iy = digit->PadY();
detElemId = digit->DetElemId();
charge = (Int_t)digit->Charge();
adc = digit->ADC();
chamber = detElemId/100 - 1;
if (chamber > 9) {
fChambers[chamber]->RegisterDigit(detElemId,cathode,ix,iy,charge);
} else {
fChambers[chamber]->RegisterDigit(detElemId,cathode,ix,iy,adc);
}
}
}
Int_t AliEveMUONData::GetTrack(Int_t index) const
{
if (index < 256) {
return fTrackList[index];
} else {
return -1;
}
}
AliEveMUONChamberData* AliEveMUONData::GetChamberData(Int_t chamber)
{
if (chamber < 0 || chamber > 13) return 0;
return fChambers[chamber];
}