ULong64_t size = sizeof(AliFlatESDEvent);
size += 2 * sizeof( AliFlatESDVertex );
size += esd->GetNumberOfTracks() * ( AliFlatESDTrack::EstimateSize() + sizeof(Long64_t) );
+ size += AliESDRun::kNTriggerClasses * sizeof(AliFlatESDTrigger) ;
if( fillV0s ) size += esd->GetNumberOfV0s()*sizeof(AliFlatESDV0);
return size;
}
TString outputFilename = "$PWD/compare.root";
-
+ /*
cout<< "creating histograms"<<endl;
TH2F* hNTracks = new TH2F("nTracks","number of tracks", 100,0,100, 100,0,100);
TH2F* hNV0s = new TH2F("nV0s","number of V0s", 10,0,10, 10,0,10);
hStat->GetXaxis()->SetBinLabel(5,"vtxTracks");
hStat->GetXaxis()->SetBinLabel(6,"vtxSPD");
hStat->GetXaxis()->SetBinLabel(7,"tracks->extParams");
-
+*/
Int_t diff[6]={0};
AliFlatESDEvent *flatEsd1 = reinterpret_cast<AliFlatESDEvent *>(curr1);
AliFlatESDEvent *flatEsd2 = reinterpret_cast<AliFlatESDEvent *>(curr2);
- /*
- if(flatEsd1->GetNumberOfTracks()==0 || flatEsd2->GetNumberOfTracks() ==0){
- if(flatEsd1->GetNumberOfTracks()==0){
- curr1=curr1+ flatEsd1->GetSize();
- }
- if(flatEsd2->GetNumberOfTracks()==0){
- curr2=curr2+ flatEsd2->GetSize();
- }
- continue;
- }
- */
- cout<<endl<<"Reading event "<<iEvent<<":"<<endl;
- /*
+ flatEsd1->Reinitialize();
+ flatEsd2->Reinitialize();
+
+ cout<<endl<<"Reading event "<<iEvent<<":";
+
+ cout<<endl<<"ntracks:\t"<<flatEsd1->GetNumberOfTracks()<< " | " <<flatEsd2->GetNumberOfTracks();
if( flatEsd1->GetNumberOfTracks() != flatEsd2->GetNumberOfTracks() ) {
- cout<<"\t\tDIFFERENCE!: ";
+ cout<<"\t\tDIFFERENCE!!!";
diff[0] =1;
}
- cout<<"\t\tntracks: "<<flatEsd1->GetNumberOfTracks()<< " | " <<flatEsd2->GetNumberOfTracks();
- hNTracks->Fill(flatEsd1->GetNumberOfTracks(),flatEsd2->GetNumberOfTracks());
+ //hNTracks->Fill(flatEsd1->GetNumberOfTracks(),flatEsd2->GetNumberOfTracks());
+ cout<<endl<<"nV0's:\t"<<flatEsd1->GetNumberOfV0s()<< " | " <<flatEsd2->GetNumberOfV0s();
if( flatEsd1->GetNumberOfV0s() != flatEsd2->GetNumberOfV0s() ){
- cout<<"\t\tDIFFERENCE!: ";
+ cout<<"\t\tDIFFERENCE!!!";
diff[1] =1;
}
- cout<<"\t\tnV0's: "<<flatEsd1->GetNumberOfV0s()<< " | " <<flatEsd2->GetNumberOfV0s()<<endl;
- hNV0s->Fill(flatEsd1->GetNumberOfV0s(),flatEsd2->GetNumberOfV0s());
+ //hNV0s->Fill(flatEsd1->GetNumberOfV0s(),flatEsd2->GetNumberOfV0s());
- if( (Bool_t) flatEsd1->GetPrimaryVertexTracks() != (Bool_t) flatEsd2->GetPrimaryVertexTracks() ){
- cout<<"\t\tDIFFERENCE!: ";
+
+
+ /*
+
+ if( (Bool_t) flatEsd1->GetFlatPrimaryVertexTracks() != (Bool_t) flatEsd2->GetFlatPrimaryVertexTracks() ){
+ cout<<"\t\tDIFFERENCE!: "<<endl;
diff[2] =1;
}
- cout<<"\t\tvtx tracks: "<<(Bool_t) flatEsd1->GetPrimaryVertexTracks()<< " | " << (Bool_t) flatEsd2->GetPrimaryVertexTracks();
- hVtxTr->Fill( (Bool_t) flatEsd1->GetPrimaryVertexTracks(), (Bool_t) flatEsd2->GetPrimaryVertexTracks());
+ cout<<"vtx tracks:\t"<<(Bool_t) flatEsd1->GetFlatPrimaryVertexTracks()<< " | " << (Bool_t) flatEsd2->GetFlatPrimaryVertexTracks()<<endl;
+ //hVtxTr->Fill( (Bool_t) flatEsd1->GetFlatPrimaryVertexTracks(), (Bool_t) flatEsd2->GetFlatPrimaryVertexTracks());
- if( (Bool_t) flatEsd1->GetPrimaryVertexSPD() != (Bool_t) flatEsd2->GetPrimaryVertexSPD() ){
- cout<<"\t\tDIFFERENCE!: ";
+ if( (Bool_t) flatEsd1->GetFlatPrimaryVertexSPD() != (Bool_t) flatEsd2->GetFlatPrimaryVertexSPD() ){
+ cout<<"\t\tDIFFERENCE!: "<<endl;
diff[3] =1;
}
- cout<<"\t\tvtx SPD: "<<(Bool_t) flatEsd1->GetPrimaryVertexSPD() << " | " << (Bool_t) flatEsd2->GetPrimaryVertexSPD()<<endl;
- hVtxSPD->Fill( (Bool_t) flatEsd1->GetPrimaryVertexSPD(), (Bool_t) flatEsd2->GetPrimaryVertexSPD());
+ cout<<"vtx SPD:\t"<<(Bool_t) flatEsd1->GetFlatPrimaryVertexSPD() << " | " << (Bool_t) flatEsd2->GetFlatPrimaryVertexSPD()<<endl;
+ //hVtxSPD->Fill( (Bool_t) flatEsd1->GetFlatPrimaryVertexSPD(), (Bool_t) flatEsd2->GetFlatPrimaryVertexSPD());
- if(true|| (Bool_t)flatEsd1->GetPrimaryVertexSPD() && (Bool_t)flatEsd2->GetPrimaryVertexSPD() ){
- cout<<endl<<"\t\tvtx tracksX: "<< flatEsd1->GetPrimaryVertexSPD()<<" | " << flatEsd2->GetPrimaryVertexSPD();
+
+
+ if((Bool_t)flatEsd1->GetFlatPrimaryVertexTracks() && (Bool_t)flatEsd2->GetFlatPrimaryVertexTracks() ){
+ cout<<endl<<"vtx tracks -> X,Y,Z:\t"
+ << flatEsd1->GetFlatPrimaryVertexTracks()->GetX()
+ <<","<< flatEsd1->GetFlatPrimaryVertexTracks()->GetY()
+ <<","<< flatEsd1->GetFlatPrimaryVertexTracks()->GetZ()
+ <<" | " <<flatEsd2->GetFlatPrimaryVertexTracks()->GetX()
+ <<","<< flatEsd2->GetFlatPrimaryVertexTracks()->GetY()
+ <<","<< flatEsd2->GetFlatPrimaryVertexTracks()->GetZ()<<endl;
}
*/
// compare tracks
- #if 1
- AliFlatESDTrack *track1 = flatEsd1->GetTracks();
- AliFlatESDTrack *track2 = flatEsd2->GetTracks();
+if(verbose){
+ AliFlatESDTrack *track1 = const_cast<AliFlatESDTrack*> (flatEsd1->GetTracks());
+ AliFlatESDTrack *track2 = const_cast<AliFlatESDTrack*> (flatEsd2->GetTracks());
for (Int_t idxTrack = 0; idxTrack < flatEsd1->GetNumberOfTracks() && track1 && track2; ++idxTrack) {
- AliFlatExternalTrackParam* ext[2][nExt] ={
+ //track2->Reinitialize();
+ const AliFlatExternalTrackParam* ext[2][nExt] ={
{
- track1->GetTrackParamRefitted(),
- track1->GetTrackParamIp(),
- track1->GetTrackParamTPCInner(),
- track1->GetTrackParamOp(),
- // track1->GetTrackParamCp(),
- // track1->GetTrackParamITSOut()
+ track1->GetFlatTrackParamRefitted(),
+ track1->GetFlatTrackParamIp(),
+ track1->GetFlatTrackParamTPCInner(),
+ track1->GetFlatTrackParamOp(),
+ // track1->GetFlatTrackParamCp(),
+ // track1->GetFlatTrackParamITSOut()
},
{
- track2->GetTrackParamRefitted(),
- track2->GetTrackParamIp(),
- track2->GetTrackParamTPCInner(),
- track2->GetTrackParamOp(),
- // track2->GetTrackParamCp(),
- // track2->GetTrackParamITSOut()
+ track2->GetFlatTrackParamRefitted(),
+ track2->GetFlatTrackParamIp(),
+ track2->GetFlatTrackParamTPCInner(),
+ track2->GetFlatTrackParamOp(),
+ // track2->GetFlatTrackParamCp(),
+ // track2->GetFlatTrackParamITSOut()
}
};
for(int iExt=0; iExt<nExt; ++iExt){
-cout<<endl<<iExt<<endl;
if(!ext[0][iExt] && !ext[1][iExt]) continue;
if(!ext[0][iExt] && ext[1][iExt]){
// cout<<"DIFFERENCE!: ";
if( (!ext[0][iExt] || !ext[1][iExt])|| ext[0][iExt]->GetAlpha() != ext[1][iExt]->GetAlpha() ) {
- // cout<<"DIFFERENCE!: ";
+ cout<<"\t\tDIFFERENCE!: "<<endl;
//cout<<" alpha"<<iExt<<" :" << (ext[0][iExt] ? ext[0][iExt]->GetAlpha() : -99.) << "\t\t" << (ext[1][iExt] ? ext[1][iExt]->GetAlpha(): -99.)<<endl;
diff[4]=1;
- } cout<<" alpha"<<iExt<<" :" << (ext[0][iExt] ? ext[0][iExt]->GetAlpha() : -99.) << "\t\t" << (ext[1][iExt] ? ext[1][iExt]->GetAlpha(): -99.)<<endl;
+ } cout<<" alpha"<<iExt<<" :\t" << (ext[0][iExt] ? ext[0][iExt]->GetAlpha() : -99.) << " | " << (ext[1][iExt] ? ext[1][iExt]->GetAlpha(): -99.)<<endl;
if( (!ext[0][iExt] || !ext[1][iExt])||ext[0][iExt]->GetX() != ext[1][iExt]->GetX() ) {
- //cout<<"DIFFERENCE!: ";
+ cout<<"\t\tDIFFERENCE!: "<<endl;
//cout<<" GetX"<<iExt<<" :" << (ext[0][iExt] ? ext[0][iExt]->GetX(): -99.) << " | " << (ext[1][iExt] ? ext[1][iExt]->GetX(): -99.)<<endl;
diff[4]=1;
}
-cout<<" GetX"<<iExt<<" :" << (ext[0][iExt] ? ext[0][iExt]->GetX(): -99.) << " | " << (ext[1][iExt] ? ext[1][iExt]->GetX(): -99.)<<endl;
+cout<<" GetX"<<iExt<<" :\t" << (ext[0][iExt] ? ext[0][iExt]->GetX(): -99.) << " | " << (ext[1][iExt] ? ext[1][iExt]->GetX(): -99.)<<endl;
if( (!ext[0][iExt] || !ext[1][iExt])||ext[0][iExt]->GetSigned1Pt() != ext[0][iExt]->GetSigned1Pt() ) {
- //cout<<"DIFFERENCE!: ";
+ cout<<"\t\tDIFFERENCE!: "<<endl;
//cout<<" 1/pt"<<iExt<<" :" << (ext[0][iExt] ? ext[0][iExt]->GetSigned1Pt(): -99.) << " | " << (ext[1][iExt] ? ext[1][iExt]->GetSigned1Pt(): -99.)<<endl;
diff[4]=1;
}
- cout<<" 1/pt"<<iExt<<" :" << (ext[0][iExt] ? ext[0][iExt]->GetSigned1Pt(): -99.) << " | " << (ext[1][iExt] ? ext[1][iExt]->GetSigned1Pt(): -99.)<<endl;
+ cout<<" 1/pt"<<iExt<<" :\t" << (ext[0][iExt] ? ext[0][iExt]->GetSigned1Pt(): -99.) << " | " << (ext[1][iExt] ? ext[1][iExt]->GetSigned1Pt(): -99.)<<endl;
}
diff[4]=1;
}
*/
+
+#if 0
// compare clusters
if( verbose && track1->GetNumberOfTPCClusters() == track2->GetNumberOfTPCClusters()){
}
}
-
- track1 = track1->GetNextTrack();
- track2 = track2->GetNextTrack();
+
+#endif
+ track1 = const_cast<AliFlatESDTrack*> (track1->GetNextTrack());
+ track2 = const_cast<AliFlatESDTrack*> (track2->GetNextTrack());
}
-#endif
- hStat->Fill(0);
+}
+
+ /*
+ // hStat->Fill(0);
Bool_t diffs=kFALSE;
for(int iDiff=0; iDiff<5;++iDiff){
if(diff[iDiff]){
- hStat->Fill(iDiff+2);
+ // hStat->Fill(iDiff+2);
diffs = kTRUE;
}
}
if(!diffs) hStat->Fill(1);
-
+*/
curr1=curr1+ flatEsd1->GetSize();
curr2=curr2+ flatEsd2->GetSize();
cout << "File could not be read" << endl;
}
-
+/*
TList histosList;
histosList.Add(hVtxTr);
histosList.Add(hVtxSPD);
histosList.SaveAs(outputFilename);
-
+ */
return;
}
#include <TSystem.h>
#include "./AliFlatESDEvent.h"
#include "./AliFlatESDTrack.h"
+#include "./AliFlatESDTrigger.h"
#include "./AliFlatTPCCluster.h"
#include "./AliFlatExternalTrackParam.h"
#include "Riostream.h"
void FlatESDConverter(const char* filename="AliESDs.root", const char* filenameFriends="AliESDfriends.root",const char* filenameOut="out.dat", Bool_t useESDFriends = kTRUE, Bool_t useHLTtree = kFALSE,Int_t verbose = 0) {
+ if(useESDFriends) Printf("using friends");
+ if(useHLTtree) Printf("using HLT tree");
+
+
// -- Convert AliESDEvent to AliFlatESDEvent
+/*
+ if ( access( filename, F_OK ) == -1 ){
+ Printf("input file not readable!");
+ return;
+ }
+*/
+ TFile *file = new TFile(Form("%s", filename));
+
+
ofstream outFile(Form("%s",filenameOut), std::ifstream::binary | std::ifstream::out);
//ofstream outFile("outFlatESD.dat");
- TFile *file = new TFile(Form("%s", filename));
+
TTree *esdTree = useHLTtree? dynamic_cast<TTree*>(file->Get("HLTesdTree")) : dynamic_cast<TTree*>(file->Get("esdTree"));
// -- Connect ESD
if (useESDFriends && !esdTree->FindBranch("ESDfriend.")) {
esdTree->AddFriend("esdFriendTree", Form("%s", filenameFriends));
esdTree->SetBranchStatus("ESDfriend.", 1);
- esdFriend = dynamic_cast<AliESDfriend*>((const_cast<AliESDEvent*>(esd))->FindListObject("AliESDfriend"));
+ esdFriend = (AliESDfriend*)esd->FindListObject("AliESDfriend");
if (esdFriend)
esdTree->SetBranchAddress("ESDfriend.", &esdFriend);
} // if (!esdTree->FindBranch("ESDfriend.")) {
-
+ ;
AliFlatESDEvent *flatEsd = NULL;
// -- Event Loop
for (Int_t idxEvent = 0; idxEvent < esdTree->GetEntries(); idxEvent++) {
Printf("Processing event nr %d", idxEvent);
- esd->SaveAs("esdTemp.root");
- TFile fTmp = TFile("esdTemp.root");
- Int_t sizeIn = fTmp.GetSize();
+ // esd->SaveAs("esdTemp.root");
+ // TFile fTmp = TFile("esdTemp.root");
+ Int_t sizeIn = 1;//fTmp.GetSize();
AliSysInfo::AddStamp("getEntry",0,0,idxEvent);
// -- Book memory for AliFlatESDEvent
// -- TEST >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
- Byte_t *mem = new Byte_t[AliFlatESDEvent::EstimateSize(esd, useESDFriends)];
+ Int_t size = AliFlatESDEvent::EstimateSize(esd, kTRUE);
+ Byte_t *mem = new Byte_t[size];
flatEsd = reinterpret_cast<AliFlatESDEvent*>(mem);
new (flatEsd) AliFlatESDEvent;
-
+
+
+
AliSysInfo::AddStamp("DoEvent.Start",0,0,idxEvent);
// -- Fill AliFlatESDEvent
- flatEsd->Fill(esd, useESDFriends);
-
+ Int_t err= flatEsd->SetFromESD( size, esd, kTRUE );
+
+ if(err) Printf("!!! Error while filling flatESD event %d!!!", err);
+ Printf("trigger classes: %d size: %d , = %d",flatEsd->GetNumberOfTriggerClasses(), sizeof(AliFlatESDTrigger) , flatEsd->GetNumberOfTriggerClasses() *sizeof(AliFlatESDTrigger) );
AliSysInfo::AddStamp("DoEvent.Stop",sizeIn,flatEsd->GetSize(),idxEvent);
- if (verbose) {
- Printf("TEST: Event %d || Tracks %d | FRIEND Tracks %d || estimated size %llu || sizeof(AliFlatESDEvent) %llu",
- idxEvent, esd->GetNumberOfTracks(), esdFriend->GetNumberOfTracks(),
- AliFlatESDEvent::EstimateSize(esd, useESDFriends), flatEsd->GetSize());
-
- AliFlatESDTrack *track = flatEsd->GetTracks();
+ if(useESDFriends){
+ Printf("ESD : Event %d || V0s %d || Tracks %d | FRIEND Tracks %d || estimated size %llu",
+ idxEvent, esd->GetNumberOfV0s(),esd->GetNumberOfTracks(), esdFriend->GetNumberOfTracks(),
+ AliFlatESDEvent::EstimateSize(esd, useESDFriends));
+ Printf("FLAT: Event %d || V0s %d || Tracks %d | FRIEND Tracks %d || estimated size %llu",
+ idxEvent, flatEsd->GetNumberOfV0s(),flatEsd->GetNumberOfTracks(), esdFriend->GetNumberOfTracks(), flatEsd->GetSize());
+ }
+ else{
+ Printf("ESD : Event %d || V0s %d || Tracks %d || estimated size %llu ",
+ idxEvent,esd->GetNumberOfV0s(), esd->GetNumberOfTracks(),
+ AliFlatESDEvent::EstimateSize(esd, useESDFriends) );
+ Printf("FLAT: Event %d || V0s %d || Tracks %d || estimated size %llu ",
+ idxEvent, flatEsd->GetNumberOfV0s(),flatEsd->GetNumberOfTracks(), flatEsd->GetSize());
+ }
+ AliFlatESDTrack *track = const_cast<AliFlatESDTrack*> (flatEsd->GetTracks());
for (Int_t idxTrack = 0; idxTrack < flatEsd->GetNumberOfTracks(); ++idxTrack) {
AliESDtrack *esdTrack = esd->GetTrack(idxTrack);
- AliESDfriendTrack *friendTrack = esdFriend->GetTrack(idxTrack) ;
+ AliESDfriendTrack *friendTrack = useESDFriends ? esdFriend->GetTrack(idxTrack) :NULL;
if (track && !esdTrack) {
Printf("ERROR THIS SHOULD NOT HAPPEN AT ALL !!! TRACK %d HAS NO ESD TRACK!!!", idxTrack);
return;
}
+ if (verbose) {
if (track) {
- AliFlatExternalTrackParam* exp1 = track->GetTrackParamCp();
- AliFlatExternalTrackParam* exp2 = track->GetTrackParamIp();
- AliFlatExternalTrackParam* exp3 = track->GetTrackParamTPCInner();
- AliFlatExternalTrackParam* exp4 = track->GetTrackParamOp();
+ const AliFlatExternalTrackParam* exp1 = track->GetFlatTrackParamCp();
+ const AliFlatExternalTrackParam* exp2 = track->GetFlatTrackParamIp();
+ const AliFlatExternalTrackParam* exp3 = track->GetFlatTrackParamTPCInner();
+ const AliFlatExternalTrackParam* exp4 = track->GetFlatTrackParamOp();
Float_t alphaFLAT[4] = {0., 0., 0., 0.};
if (exp1) alphaFLAT[0] = exp1->GetAlpha();
Int_t nCl = track->GetNumberOfTPCClusters();
Printf("TEST: FlatTrack %d has %d FlatClusters", idxTrack, nCl);
+
+#if 0
if(nCl && useESDFriends && verbose > 1){
TObject* calibObject = NULL;
AliTPCseed* seed = NULL;
}
}
}
-
+#endif
+
}
- track = track->GetNextTrack();
+ track = const_cast<AliFlatESDTrack*> (track->GetNextTrack() );
}
}
while( curr < endBuff ){
cout<<endl<<"Reading event "<<iEvent<<":"<<endl;
- Printf("curr: %p \t endBuff: %p \t diff %p ", curr, endBuff, endBuff-curr);
+ // Printf("curr: %p \t endBuff: %p \t diff %p ", curr, endBuff, endBuff-curr);
AliFlatESDEvent *flatEsd = reinterpret_cast<AliFlatESDEvent *>(curr);
flatEsd->Reinitialize();
-cout<<"vtx SPD: "<<(Bool_t) flatEsd->GetPrimaryVertexSPD()
- <<" vtx tracks: "<<(Bool_t) flatEsd->GetPrimaryVertexTracks()
+cout<<"vtx SPD: "<<(Bool_t) flatEsd->GetFlatPrimaryVertexSPD()
+ <<" vtx tracks: "<<(Bool_t) flatEsd->GetFlatPrimaryVertexTracks()
<<" ntracks: "<<flatEsd->GetNumberOfTracks()
<<" nV0's: "<<flatEsd->GetNumberOfV0s()
<<endl;
cout<<"track nr "<<idxTrack<<endl;
- AliFlatExternalTrackParam* ext[nExt] ={
+ const AliFlatExternalTrackParam* ext[nExt] ={
- track->GetTrackParamRefitted(),
- track->GetTrackParamIp(),
- track->GetTrackParamTPCInner(),
- track->GetTrackParamOp(),
+ track->GetFlatTrackParamRefitted(),
+ track->GetFlatTrackParamIp(),
+ track->GetFlatTrackParamTPCInner(),
+ track->GetFlatTrackParamOp(),
};
}
}
- Printf("curr: %p \t + %d = %p , diff:%p", curr, flatEsd->GetSize() ,curr+ flatEsd->GetSize(), endBuff-(curr+ flatEsd->GetSize()) );
+ // Printf("curr: %p \t + %d = %p , diff:%p", curr, flatEsd->GetSize() ,curr+ flatEsd->GetSize(), endBuff-(curr+ flatEsd->GetSize()) );
curr=curr+ flatEsd->GetSize();
iEvent++;
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff