[u/mrichter/AliRoot.git] / HLT / global / FlatESDConverter.C

/**
 * >> Testing Macro to fill FlatESDEvent from ALiESDEvent <<
 **
 * Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli
 *
 * Usage:
 *  aliroot -b -l -q LoadLibs.C FlatESDConverter.C++
 *
 **************************************************************************/

#if !defined(__CINT__) || defined(__MAKECINT__)
#include "AliESDEvent.h"
#include "AliESD.h"
#include "AliESDfriend.h"
#include "AliESDfriendTrack.h"
#include "../TPC/Rec/AliTPCseed.h"
#include <TFile.h>
#include <TTree.h>
#include <TSystem.h>
#include "./AliFlatESDEvent.h"
#include "./AliFlatESDTrack.h"
#include "./AliFlatTPCCluster.h"
#include "./AliFlatExternalTrackParam.h"
#include "Riostream.h"
#include "AliSysInfo.h"
#endif   

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) {
  // -- Convert AliESDEvent to AliFlatESDEvent

  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
  AliESDEvent *esd = new AliESDEvent;
  esd->ReadFromTree(esdTree);
  
  // -- Connect ESD friend
  AliESDfriend *esdFriend = NULL; 
  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"));
    if (esdFriend)
      esdTree->SetBranchAddress("ESDfriend.", &esdFriend);
  } // if (!esdTree->FindBranch("ESDfriend.")) {
  
  AliFlatESDEvent *flatEsd = NULL;

  // -- Event Loop
  for (Int_t idxEvent = 0; idxEvent < esdTree->GetEntries(); idxEvent++) {
  
  AliSysInfo::AddStamp("getEntry",0,0,idxEvent);
    esdTree->GetEntry(idxEvent);
    // -- Book memory for AliFlatESDEvent
   // -- TEST >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

    Byte_t *mem = new Byte_t[AliFlatESDEvent::EstimateSize(esd, useESDFriends)];
    
AliSysInfo::AddStamp("DoEvent.Start",0,0,idxEvent);
    flatEsd = reinterpret_cast<AliFlatESDEvent*>(mem);    
	new (flatEsd) AliFlatESDEvent(1);

    // -- Fill AliFlatESDEvent
    flatEsd->Fill(esd, useESDFriends);  
    
    
AliSysInfo::AddStamp("DoEvent.Stop",0,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();
    for (Int_t idxTrack = 0; idxTrack < flatEsd->GetNumberOfTracks(); ++idxTrack) {      
       AliESDtrack *esdTrack = esd->GetTrack(idxTrack);      
       AliESDfriendTrack *friendTrack = esdFriend->GetTrack(idxTrack) ;
       
       if (track && !esdTrack) {
	 Printf("ERROR THIS SHOULD NOT HAPPEN AT ALL !!! TRACK %d HAS NO ESD TRACK!!!", idxTrack);
	 return;
       }

      if (track ) {
	
	/*
	AliFlatExternalTrackParam* exp1 = track->GetTrackParamCp();
	AliFlatExternalTrackParam* exp2 = track->GetTrackParamIp();
	AliFlatExternalTrackParam* exp3 = track->GetTrackParamTPCInner();
	AliFlatExternalTrackParam* exp4 = track->GetTrackParamOp();

	Float_t alphaFLAT[4] = {0., 0., 0., 0.};
	if (exp1) alphaFLAT[0] = exp1->GetAlpha();
	if (exp2) alphaFLAT[1] = exp2->GetAlpha();
	if (exp3) alphaFLAT[2] = exp3->GetAlpha();
	if (exp4) alphaFLAT[3] = exp4->GetAlpha();
	
	Float_t alphaOLD[4]  = {0., 0., 0., 0.};
	if (esdTrack->GetConstrainedParam())  alphaOLD[0] = esdTrack->GetConstrainedParam()->GetAlpha();
	if (esdTrack->GetInnerParam())        alphaOLD[1] = esdTrack->GetInnerParam()->GetAlpha();
	if (esdTrack->GetTPCInnerParam())     alphaOLD[2] = esdTrack->GetTPCInnerParam()->GetAlpha();
	if (esdTrack->GetOuterParam())        alphaOLD[3] = esdTrack->GetOuterParam()->GetAlpha();

     	Printf("  TEST: FlatTrack %d > FlatExternalTrackParam > %p %p %p %p", idxTrack, exp1, exp2, exp3, exp4);
	Printf("  TEST: FlatTrack %d > Alpha %f %f %f %f", idxTrack, alphaFLAT[0], alphaFLAT[1], alphaFLAT[2], alphaFLAT[3]);
	Printf("  TEST: Old Track %d > Alpha %f %f %f %f", idxTrack, alphaOLD[0], alphaOLD[1], alphaOLD[2], alphaOLD[3]);
	Printf("  TEST: Diff      %d > Alpha %f %f %f %f", idxTrack, 
	       alphaFLAT[0]-alphaOLD[0], alphaFLAT[1]-alphaOLD[1], alphaFLAT[2]-alphaOLD[2], alphaFLAT[3]-alphaOLD[3]);
*/

Int_t nCl = track->GetNumberOfTPCClusters();
	Printf("  TEST: FlatTrack %d has %d FlatClusters", idxTrack,  nCl );
	if(nCl && verbose > 1){
	
	  TObject* calibObject = NULL;
    AliTPCseed* seed = NULL;

    for (Int_t idx = 0; (calibObject = friendTrack->GetCalibObject(idx)); ++idx) {
      if ((seed = dynamic_cast<AliTPCseed*>(calibObject))) break;
    }

    // -- Fill cluster
    if (seed) {
      for (Int_t idxRow = 0; idxRow <  nCl; idxRow++){
      AliFlatTPCCluster * cl = track->GetTPCCluster(idxRow);

			 	cout<<" idx fX fY fZ  fSigmaY2 fSigmaZ2 fCharge fQMax fPadRow" <<endl;
				cout<< idxRow <<" "<< cl->GetX()<<" "<< cl->GetY()<<" "<< cl->GetZ()<<" "<< cl->GetSigmaY2()<<" "<< cl->GetSigmaZ2()<<" "<< cl->GetCharge()<<" "<< cl->GetQMax() <<" "<< cl->GetPadRow()<<endl;
				
				AliTPCclusterMI* cl2 =seed->GetClusterPointer( cl->GetPadRow());
      
	if (cl2) {
	  //cout<<" normalCl fX fY fZ fPadRow fSigmaY2 fSigmaZ2 fCharge fQMax" <<endl;
				cout<< idxRow <<" "<< cl2->GetX()<<" "<< cl2->GetY()<<" "<< cl2->GetZ()<<" "<< cl2->GetSigmaY2()<<" "<< cl2->GetSigmaZ2()<<" "<< cl2->GetQ()<<" "<< cl2->GetMax()<<" "<< cl2->GetRow() <<endl<<endl;
	}
		else
		  	cout<<idxRow<<"---------------------------------"<<endl<<endl;	
      }
    }
	}
	
      }
      track = track->GetNextTrack();
    }
}

    outFile.write(reinterpret_cast<char*>(mem), flatEsd->GetSize());

    delete[] mem; 

  } // for (Int_t idxEvent = 1; idxEvent < 2; idxEvent++) {

  outFile.close();

  return;
}
Commit	Line	Data
251a2c81	1	/**
	2	* >> Testing Macro to fill FlatESDEvent from ALiESDEvent <<
	3	**
	4	* Primary Authors : Sergey Gorbunov, Jochen Thaeder, Chiara Zampolli
	5	*
	6	* Usage:
	7	* aliroot -b -l -q LoadLibs.C FlatESDConverter.C++
	8	*
	9	**************************************************************************/
	10
	11	#if !defined(__CINT__) \|\| defined(__MAKECINT__)
	12	#include "AliESDEvent.h"
	13	#include "AliESD.h"
	14	#include "AliESDfriend.h"
6eb01754	15	#include "AliESDfriendTrack.h"
6eb01754	16	#include "../TPC/Rec/AliTPCseed.h"
251a2c81	17	#include <TFile.h>
	18	#include <TTree.h>
	19	#include <TSystem.h>
	20	#include "./AliFlatESDEvent.h"
	21	#include "./AliFlatESDTrack.h"
	22	#include "./AliFlatTPCCluster.h"
	23	#include "./AliFlatExternalTrackParam.h"
	24	#include "Riostream.h"
d3b8c07f	25	#include "AliSysInfo.h"
251a2c81	26	#endif
251a2c81	27
6eb01754	28	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) {
251a2c81	29	// -- Convert AliESDEvent to AliFlatESDEvent
251a2c81	30
d5b8cffe	31	ofstream outFile(Form("%s",filenameOut), std::ifstream::binary \| std::ifstream::out);
251a2c81	32	//ofstream outFile("outFlatESD.dat");
	33
	34	TFile *file = new TFile(Form("%s", filename));
8f658767	35
	36	TTree esdTree = useHLTtree? dynamic_cast<TTree>(file->Get("HLTesdTree")) : dynamic_cast<TTree*>(file->Get("esdTree"));
	37
251a2c81	38
	39	// -- Connect ESD
	40	AliESDEvent *esd = new AliESDEvent;
	41	esd->ReadFromTree(esdTree);
	42
	43	// -- Connect ESD friend
	44	AliESDfriend *esdFriend = NULL;
	45	if (useESDFriends && !esdTree->FindBranch("ESDfriend.")) {
d5b8cffe	46	esdTree->AddFriend("esdFriendTree", Form("%s", filenameFriends));
251a2c81	47	esdTree->SetBranchStatus("ESDfriend.", 1);
	48
	49	esdFriend = dynamic_cast<AliESDfriend>((const_cast<AliESDEvent>(esd))->FindListObject("AliESDfriend"));
	50	if (esdFriend)
	51	esdTree->SetBranchAddress("ESDfriend.", &esdFriend);
	52	} // if (!esdTree->FindBranch("ESDfriend.")) {
	53
	54	AliFlatESDEvent *flatEsd = NULL;
	55
	56	// -- Event Loop
8f658767	57	for (Int_t idxEvent = 0; idxEvent < esdTree->GetEntries(); idxEvent++) {
6eb01754	58
d3b8c07f	59	AliSysInfo::AddStamp("getEntry",0,0,idxEvent);
251a2c81	60	esdTree->GetEntry(idxEvent);
	61	// -- Book memory for AliFlatESDEvent
	62	// -- TEST >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
	63
	64	Byte_t *mem = new Byte_t[AliFlatESDEvent::EstimateSize(esd, useESDFriends)];
6eb01754	65
d3b8c07f	66	AliSysInfo::AddStamp("DoEvent.Start",0,0,idxEvent);
251a2c81	67	flatEsd = reinterpret_cast<AliFlatESDEvent*>(mem);
9e363878	68	new (flatEsd) AliFlatESDEvent(1);
251a2c81	69
	70	// -- Fill AliFlatESDEvent
	71	flatEsd->Fill(esd, useESDFriends);
6eb01754	72
6eb01754	73
d3b8c07f	74	AliSysInfo::AddStamp("DoEvent.Stop",0,flatEsd->GetSize(),idxEvent);
6eb01754	75	if(verbose){
251a2c81	76	Printf("TEST: Event %d \|\| Tracks %d \| FRIEND Tracks %d \|\| estimated size %llu \|\| sizeof(AliFlatESDEvent) %llu",
	77	idxEvent, esd->GetNumberOfTracks(), esdFriend->GetNumberOfTracks(),
	78	AliFlatESDEvent::EstimateSize(esd, useESDFriends), flatEsd->GetSize());
	79
8f658767	80
251a2c81	81	AliFlatESDTrack *track = flatEsd->GetTracks();
251a2c81	82	for (Int_t idxTrack = 0; idxTrack < flatEsd->GetNumberOfTracks(); ++idxTrack) {
6eb01754	83	AliESDtrack *esdTrack = esd->GetTrack(idxTrack);
6eb01754	84	AliESDfriendTrack *friendTrack = esdFriend->GetTrack(idxTrack) ;
251a2c81	85
	86	if (track && !esdTrack) {
	87	Printf("ERROR THIS SHOULD NOT HAPPEN AT ALL !!! TRACK %d HAS NO ESD TRACK!!!", idxTrack);
	88	return;
	89	}
	90
6eb01754	91	if (track ) {
	92
	93	/*
251a2c81	94	AliFlatExternalTrackParam* exp1 = track->GetTrackParamCp();
	95	AliFlatExternalTrackParam* exp2 = track->GetTrackParamIp();
	96	AliFlatExternalTrackParam* exp3 = track->GetTrackParamTPCInner();
	97	AliFlatExternalTrackParam* exp4 = track->GetTrackParamOp();
	98
	99	Float_t alphaFLAT[4] = {0., 0., 0., 0.};
	100	if (exp1) alphaFLAT[0] = exp1->GetAlpha();
	101	if (exp2) alphaFLAT[1] = exp2->GetAlpha();
	102	if (exp3) alphaFLAT[2] = exp3->GetAlpha();
	103	if (exp4) alphaFLAT[3] = exp4->GetAlpha();
	104
	105	Float_t alphaOLD[4] = {0., 0., 0., 0.};
	106	if (esdTrack->GetConstrainedParam()) alphaOLD[0] = esdTrack->GetConstrainedParam()->GetAlpha();
	107	if (esdTrack->GetInnerParam()) alphaOLD[1] = esdTrack->GetInnerParam()->GetAlpha();
	108	if (esdTrack->GetTPCInnerParam()) alphaOLD[2] = esdTrack->GetTPCInnerParam()->GetAlpha();
	109	if (esdTrack->GetOuterParam()) alphaOLD[3] = esdTrack->GetOuterParam()->GetAlpha();
	110
	111	Printf(" TEST: FlatTrack %d > FlatExternalTrackParam > %p %p %p %p", idxTrack, exp1, exp2, exp3, exp4);
	112	Printf(" TEST: FlatTrack %d > Alpha %f %f %f %f", idxTrack, alphaFLAT[0], alphaFLAT[1], alphaFLAT[2], alphaFLAT[3]);
	113	Printf(" TEST: Old Track %d > Alpha %f %f %f %f", idxTrack, alphaOLD[0], alphaOLD[1], alphaOLD[2], alphaOLD[3]);
	114	Printf(" TEST: Diff %d > Alpha %f %f %f %f", idxTrack,
	115	alphaFLAT[0]-alphaOLD[0], alphaFLAT[1]-alphaOLD[1], alphaFLAT[2]-alphaOLD[2], alphaFLAT[3]-alphaOLD[3]);
6eb01754	116	*/
251a2c81	117
6eb01754	118	Int_t nCl = track->GetNumberOfTPCClusters();
	119	Printf(" TEST: FlatTrack %d has %d FlatClusters", idxTrack, nCl );
	120	if(nCl && verbose > 1){
	121
	122	TObject* calibObject = NULL;
	123	AliTPCseed* seed = NULL;
	124
	125	for (Int_t idx = 0; (calibObject = friendTrack->GetCalibObject(idx)); ++idx) {
	126	if ((seed = dynamic_cast<AliTPCseed*>(calibObject))) break;
	127	}
251a2c81	128
6eb01754	129	// -- Fill cluster
	130	if (seed) {
	131	for (Int_t idxRow = 0; idxRow < nCl; idxRow++){
	132	AliFlatTPCCluster * cl = track->GetTPCCluster(idxRow);
	133
	134	cout<<" idx fX fY fZ fSigmaY2 fSigmaZ2 fCharge fQMax fPadRow" <<endl;
	135	cout<< idxRow <<" "<< cl->GetX()<<" "<< cl->GetY()<<" "<< cl->GetZ()<<" "<< cl->GetSigmaY2()<<" "<< cl->GetSigmaZ2()<<" "<< cl->GetCharge()<<" "<< cl->GetQMax() <<" "<< cl->GetPadRow()<<endl;
	136
	137	AliTPCclusterMI* cl2 =seed->GetClusterPointer( cl->GetPadRow());
	138
	139	if (cl2) {
	140	//cout<<" normalCl fX fY fZ fPadRow fSigmaY2 fSigmaZ2 fCharge fQMax" <<endl;
d3b8c07f	141	cout<< idxRow <<" "<< cl2->GetX()<<" "<< cl2->GetY()<<" "<< cl2->GetZ()<<" "<< cl2->GetSigmaY2()<<" "<< cl2->GetSigmaZ2()<<" "<< cl2->GetQ()<<" "<< cl2->GetMax()<<" "<< cl2->GetRow() <<endl<<endl;
6eb01754	142	}
	143	else
	144	cout<<idxRow<<"---------------------------------"<<endl<<endl;
	145	}
	146	}
	147	}
	148
251a2c81	149	}
	150	track = track->GetNextTrack();
	151	}
6eb01754	152	}
251a2c81	153
	154	outFile.write(reinterpret_cast<char*>(mem), flatEsd->GetSize());
	155
	156	delete[] mem;
	157
	158	} // for (Int_t idxEvent = 1; idxEvent < 2; idxEvent++) {
	159
	160	outFile.close();
	161
	162	return;
	163	}