[u/mrichter/AliRoot.git] / MUON / AliMUONRecoEvent.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//Authors: Mihaela Gheata, Andrei Gheata 09/10/00
////////////////////////////////////////////////////////////////////
//                                                                //
// AliMUONRecoEvent, AliMUONRecoTrack (and AliMUONRecoDisplay)    //
//                                                                //
// Theses classes are used to store and retrieve                  //
// MUON reconstructed events.                                     //
// The corresponding tree is constructed and filled               //
// during the FillEvent() method of AliMUONEventReconstructor,    //
// when all reconstruction information is available.              //
//                                                                //
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
//                                                                //
// AliMUONRecoEvent                                               //
//                                                                //
// This class handles an array of reconstructed tracks.           //
// It provides :                                                  //
//	- filling the tracks array according to the information   //
//        stored in AliMUONEventReconstructor class ;             //
//	- printing event and track informations : event numer,    //
//	  number of tracks, hits positions, reconstr. mometum.    //
//                                                                //
////////////////////////////////////////////////////////////////////

#include <Riostream.h>
#include <TClonesArray.h>
#include <TMatrixD.h>

#include "AliMUONRecoEvent.h"
#include "AliMUONRecoTrack.h"
#include "AliMUONEventReconstructor.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackK.h"
#include "AliMUONTrackParam.h"
#include "AliMUONHitForRec.h"
#include "AliMUONTrackHit.h"
#include "AliRun.h"
#include "AliHeader.h"

ClassImp(AliMUONRecoEvent)

//-------------------------------------------------------------------
AliMUONRecoEvent::AliMUONRecoEvent(Int_t eventNo) 
  : TObject()
{
// Reconstructed event constructor
   fTracks 	= new TClonesArray("AliMUONRecoTrack",200);
   fNevr 	= eventNo;
   fNtracks = 0;
}

//-------------------------------------------------------------------
AliMUONRecoEvent::AliMUONRecoEvent(const AliMUONRecoEvent& rhs)
  : TObject(rhs)
{
// Protected copy constructor

  Fatal("AliMUONRecoEventModule", "Not implemented.");
}

//-------------------------------------------------------------------
AliMUONRecoEvent::~AliMUONRecoEvent() 
{
// Destructor of AliMUONRecoEvent
   fTracks->Delete();
   delete fTracks;
   fTracks = 0;
}

//-------------------------------------------------------------------
AliMUONRecoEvent&  
AliMUONRecoEvent::operator=(const AliMUONRecoEvent& rhs)
{
// Protected assignement operator

  if (this == &rhs) return *this;

  Fatal("operator=", "Not implemented.");
    
  return *this;  
}    
          
//-------------------------------------------------------------------
AliMUONRecoTrack* AliMUONRecoEvent::AddEmptyTrack()
{
// Add a empty AliMUONRecoTrackObject to the track list
   TClonesArray &dumptracks = *fTracks;
   return (new(dumptracks[fNtracks++])AliMUONRecoTrack(kTRUE));
}

//-------------------------------------------------------------------
void AliMUONRecoEvent::Clear(Option_t * /*option*/)
{
// Clears all track pointers from the list
//   fTracks->Clear(option);
   fTracks->Delete();
   fNtracks=0;
}

//-------------------------------------------------------------------
void AliMUONRecoEvent::EventInfo()
{
// Prints reconstructed event information
   cout << "*********************Reco Dumper**************************" << endl;
   cout << "Event number : " << fNevr << endl;
   cout << "   Number of tracks : " << fNtracks << endl;
   AliMUONRecoTrack *currentTrack =0;
   Int_t trackIndex = 0;
   for(trackIndex=0; trackIndex<fNtracks; trackIndex++) {
      currentTrack = (AliMUONRecoTrack*)fTracks->UncheckedAt(trackIndex);
      cout << "Track : " << trackIndex << endl;
      cout << "   Sign : " << currentTrack->GetSign() << endl;
      cout << "   Vertex position    : " << currentTrack->GetVertexPos() << endl;
      Double_t momreco[3];
      for (Int_t axis=0; axis<3; axis++) {
         momreco[axis] = currentTrack->GetMomReconstr(axis);
      }
      cout << "   Reconstructed mom. : " << "Px=" << momreco[0] << "Py=" << momreco[1] << "Pz=" << momreco[2] << endl;
      cout << "   Chi squared        : " << currentTrack->GetChi2r() << endl;
      cout << "   Hits positions     : " << endl;
      Double_t xhit, yhit, zhit;
      for (Int_t chamber=0; chamber<10; chamber++) {
         xhit = currentTrack->GetPosX(chamber);
         yhit = currentTrack->GetPosY(chamber);
         zhit = currentTrack->GetPosZ(chamber);
//         cout <<"      chamber" << chamber << " X=" << xhit << " Y=" << yhit << " Z=" << zhit << endl;
      }	 
   }
   cout << "**********************************************************" << endl;
}

//-------------------------------------------------------------------
Bool_t AliMUONRecoEvent::MakeDumpTracks(Int_t muons, TClonesArray *tracksPtr, 
  AliMUONEventReconstructor *EventReco)
{
// This method takes the pointer of the list of reconstructed tracks from
// AliMUONEventReconstructor and fill the reconstructed AliMUONRecoEvent
// fields.

	cout << "Enter MakeDumpTracks..." << endl;
   Int_t nTracks = tracksPtr->GetEntriesFast();
   cout << "nTracks = "<< nTracks << endl;
   if (nTracks == 0) {
      cout << "AliMUONRecoEvent::MakeDumpTracks: Number of tracks is zero !" << endl;
      //AZ return kFALSE;
   }
   cout << tracksPtr << endl;
   if (!tracksPtr) {
      cout << "AliMUONRecoEvent::MakeDumpTracks() : You should call SetRecoTracksPtr() first..." << endl;
      return kFALSE;
   }
	// Get event number
   Int_t noEvent = gAlice->GetHeader()->GetEvent();
   cout << "noEvent = "<< nTracks << endl;
   tracksPtr->Compress();  // simple loop
   AliMUONRecoTrack *currentTrack;
   Int_t trackIndex, nTrackHits = 0;
   Double_t z, pYZ, bendingSlope, nonBendingSlope;
   Double_t pX, pY, pZ;			// reconstructed momentum components
   Int_t isign, flag=0;       	// charge sign, flag of reconstructed track
   Double_t alpha, beta;
   TObjArray *hitsOnTrack = 0;
   AliMUONTrackHit *trackHit = 0;
   AliMUONTrack *track = 0;
   AliMUONTrackK *trackK = 0;
   TMatrixD *trackParamK; //AZnon
   AliMUONTrackParam *trackParam = 0;
   // Fill event number and number of tracks
   fNevr = noEvent;
   fMuons = muons; //AZ - number of muons within acceptance
   // Loop over reconstructed tracks
   for (trackIndex=0; trackIndex<nTracks; trackIndex++) {
      cout << " trackIndex = " << trackIndex << endl;
      currentTrack = AddEmptyTrack();
      cout << " currentTrack = " << currentTrack << endl;

      if (EventReco->GetTrackMethod() == 2) { // Kalman

        trackK = (AliMUONTrackK*) ((*tracksPtr)[trackIndex]);
	nTrackHits = trackK->GetNTrackHits();
	trackParamK = trackK->GetTrackParameters();
	isign = Int_t(TMath::Sign(1., (*trackParamK)(4,0)));
	z = trackK->GetZ();
	alpha = (*trackParamK)(2,0);
	beta = (*trackParamK)(3,0);
	pYZ = TMath::Cos(beta)/TMath::Abs((*trackParamK)(4,0));
	pZ = pYZ/TMath::Cos(alpha);
	pX = TMath::Sin(beta)/TMath::Abs((*trackParamK)(4,0));
	pY = pYZ*TMath::Sin(alpha);

	currentTrack->SetVertexPos(z);
	currentTrack->SetMomReconstr(pX,pY,pZ);
	currentTrack->SetSign(isign);
	currentTrack->SetChi2r(trackK->GetTrackQuality());

	// Check hits on the track
	hitsOnTrack = trackK->GetHitOnTrack();
	Float_t signal = 0;
	Float_t tht = 0;
	for (int ihit = 0; ihit < nTrackHits; ihit++) {
	  signal += ((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetGeantSignal();
	  tht += TMath::Min (1,((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetTHTrack());
	}
	signal /= nTrackHits;
	tht /= nTrackHits;
	flag = 0;
	if (TMath::Nint(signal) > 0) { // signal muon
	  for (int ihit = 0; ihit < nTrackHits ; ihit++) {
	    if (((AliMUONHitForRec*)((*hitsOnTrack)[ihit]))->GetTHTrack() != TMath::Nint(tht)) flag++;
	  }
	} else flag = -9; // background track
	//cout << TMath::Nint(signal) << " " << TMath::Nint(tht) << " " << recTrackNt->fFlag << endl;
      	currentTrack->SetFlag(flag);
      } else { // default tracking

        track = (AliMUONTrack*) ((*tracksPtr)[trackIndex]);
	nTrackHits = track->GetNTrackHits();
	// track parameters at Vertex
	trackParam = track->GetTrackParamAtVertex();
	bendingSlope = trackParam->GetBendingSlope();
	nonBendingSlope = trackParam->GetNonBendingSlope();

	z = trackParam->GetZ();
	pYZ = 1/TMath::Abs(trackParam->GetInverseBendingMomentum());
	pZ = pYZ/TMath::Sqrt(1+bendingSlope*bendingSlope);
	pX = pZ * nonBendingSlope;
	pY = pZ * bendingSlope;
	
	if (trackParam->GetInverseBendingMomentum()<0) isign=-1; else isign=1;
	currentTrack->SetVertexPos(z);
	currentTrack->SetMomReconstr(pX,pY,pZ);
	currentTrack->SetSign(isign);
	//         currentTrack->SetChi2r(trackParam->GetChi2());
	currentTrack->SetChi2r(0);

	// Check hits on the track
	hitsOnTrack = track->GetTrackHitsPtr();
	Float_t signal = 0;
	Float_t tht = 0;
	AliMUONHitForRec *hitForRec = 0;
	for (int ihit = 0; ihit < nTrackHits; ihit++) {
	  hitForRec = ((AliMUONTrackHit*)(*hitsOnTrack)[ihit])->GetHitForRecPtr();
	  signal += hitForRec->GetGeantSignal();
	  tht += TMath::Min (1,hitForRec->GetTHTrack());
	}
	signal /= nTrackHits;
	tht /= nTrackHits;
	flag = 0;
	if (TMath::Nint(signal) > 0) { // signal muon
	  for (int ihit = 0; ihit < nTrackHits ; ihit++) {
	    hitForRec = ((AliMUONTrackHit*)(*hitsOnTrack)[ihit])->GetHitForRecPtr();
	    if (hitForRec->GetTHTrack() != TMath::Nint(tht)) flag++;
	  }
	} else flag = -9; // background track
	//cout << TMath::Nint(signal) << " " << TMath::Nint(tht) << " " << recTrackNt->fFlag << endl;
      	currentTrack->SetFlag(flag);
      }
     
      Double_t xhit,yhit,zhit;
      // Loop over track hits
      for (Int_t trackHitIndex = 0; trackHitIndex < nTrackHits; trackHitIndex++) {
	if (EventReco->GetTrackMethod() == 2) { // Kalman
	  xhit = ((AliMUONHitForRec*)((*hitsOnTrack)[trackHitIndex]))->GetNonBendingCoor();
	  yhit = ((AliMUONHitForRec*)((*hitsOnTrack)[trackHitIndex]))->GetBendingCoor();
	  zhit = ((AliMUONHitForRec*)((*hitsOnTrack)[trackHitIndex]))->GetZ();    
	} else {
	  trackHit = (AliMUONTrackHit*) (*(track->GetTrackHitsPtr()))[trackHitIndex];
	  xhit = trackHit->GetHitForRecPtr()->GetNonBendingCoor();
	  yhit = trackHit->GetHitForRecPtr()->GetBendingCoor();
	  zhit = trackHit->GetHitForRecPtr()->GetZ();
	}
	if (trackHitIndex >= 0 && trackHitIndex < 10) {
	  currentTrack->SetHitPosition(trackHitIndex,xhit,yhit,zhit);
	} else { cout << "track " << trackIndex << " hit out of range" << endl;} 
      }
   
   }
   cout << "Leave MakeDumpTracks..." << endl;
   return kTRUE;
}

//-------------------------------------------------------------------
void AliMUONRecoEvent::Streamer(TBuffer &R__b)
{
// Streams an object of class AliMUONRecoEvent
   if (R__b.IsReading()) {
      fTracks->Clear();
      AliMUONRecoEvent::Class()->ReadBuffer(R__b, this);
   } else {
      cout << "...writing event to file...\n";
      AliMUONRecoEvent::Class()->WriteBuffer(R__b, this);
   }
}
Commit	Line	Data
2c0075de	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
88cb7938	16	/* $Id$ */
c7ba256d	17
2c0075de	18	//Authors: Mihaela Gheata, Andrei Gheata 09/10/00
	19	////////////////////////////////////////////////////////////////////
	20	// //
	21	// AliMUONRecoEvent, AliMUONRecoTrack (and AliMUONRecoDisplay) //
	22	// //
	23	// Theses classes are used to store and retrieve //
	24	// MUON reconstructed events. //
	25	// The corresponding tree is constructed and filled //
	26	// during the FillEvent() method of AliMUONEventReconstructor, //
	27	// when all reconstruction information is available. //
	28	// //
	29	////////////////////////////////////////////////////////////////////
	30	////////////////////////////////////////////////////////////////////
	31	// //
	32	// AliMUONRecoEvent //
	33	// //
	34	// This class handles an array of reconstructed tracks. //
	35	// It provides : //
	36	// - filling the tracks array according to the information //
	37	// stored in AliMUONEventReconstructor class ; //
	38	// - printing event and track informations : event numer, //
	39	// number of tracks, hits positions, reconstr. mometum. //
	40	// //
	41	////////////////////////////////////////////////////////////////////
c7ba256d	42
70479d0e	43	#include <Riostream.h>
c7ba256d	44	#include <TClonesArray.h>
83dbc640	45	#include <TMatrixD.h>
83dbc640	46
c7ba256d	47	#include "AliMUONRecoEvent.h"
9e43eec2	48	#include "AliMUONRecoTrack.h"
83dbc640	49	#include "AliMUONEventReconstructor.h"
c7ba256d	50	#include "AliMUONTrack.h"
83dbc640	51	#include "AliMUONTrackK.h"
c7ba256d	52	#include "AliMUONTrackParam.h"
	53	#include "AliMUONHitForRec.h"
	54	#include "AliMUONTrackHit.h"
30178c30	55	#include "AliRun.h"
9e1a0ddb	56	#include "AliHeader.h"
c7ba256d	57
c7ba256d	58	ClassImp(AliMUONRecoEvent)
	59
	60	//-------------------------------------------------------------------
	61	AliMUONRecoEvent::AliMUONRecoEvent(Int_t eventNo)
11ca64ac	62	: TObject()
c7ba256d	63	{
	64	// Reconstructed event constructor
	65	fTracks = new TClonesArray("AliMUONRecoTrack",200);
	66	fNevr = eventNo;
	67	fNtracks = 0;
	68	}
	69
11ca64ac	70	//-------------------------------------------------------------------
	71	AliMUONRecoEvent::AliMUONRecoEvent(const AliMUONRecoEvent& rhs)
	72	: TObject(rhs)
	73	{
	74	// Protected copy constructor
	75
	76	Fatal("AliMUONRecoEventModule", "Not implemented.");
	77	}
	78
c7ba256d	79	//-------------------------------------------------------------------
	80	AliMUONRecoEvent::~AliMUONRecoEvent()
	81	{
	82	// Destructor of AliMUONRecoEvent
	83	fTracks->Delete();
	84	delete fTracks;
	85	fTracks = 0;
	86	}
	87
11ca64ac	88	//-------------------------------------------------------------------
	89	AliMUONRecoEvent&
	90	AliMUONRecoEvent::operator=(const AliMUONRecoEvent& rhs)
	91	{
	92	// Protected assignement operator
	93
	94	if (this == &rhs) return *this;
	95
	96	Fatal("operator=", "Not implemented.");
	97
	98	return *this;
	99	}
	100
c7ba256d	101	//-------------------------------------------------------------------
	102	AliMUONRecoTrack* AliMUONRecoEvent::AddEmptyTrack()
	103	{
	104	// Add a empty AliMUONRecoTrackObject to the track list
	105	TClonesArray &dumptracks = *fTracks;
	106	return (new(dumptracks[fNtracks++])AliMUONRecoTrack(kTRUE));
	107	}
	108
	109	//-------------------------------------------------------------------
6aaf81e6	110	void AliMUONRecoEvent::Clear(Option_t * /option/)
c7ba256d	111	{
	112	// Clears all track pointers from the list
	113	// fTracks->Clear(option);
	114	fTracks->Delete();
	115	fNtracks=0;
	116	}
	117
	118	//-------------------------------------------------------------------
	119	void AliMUONRecoEvent::EventInfo()
	120	{
	121	// Prints reconstructed event information
	122	cout << "*******************Reco Dumper************************" << endl;
	123	cout << "Event number : " << fNevr << endl;
	124	cout << " Number of tracks : " << fNtracks << endl;
	125	AliMUONRecoTrack *currentTrack =0;
	126	Int_t trackIndex = 0;
	127	for(trackIndex=0; trackIndex<fNtracks; trackIndex++) {
	128	currentTrack = (AliMUONRecoTrack*)fTracks->UncheckedAt(trackIndex);
	129	cout << "Track : " << trackIndex << endl;
	130	cout << " Sign : " << currentTrack->GetSign() << endl;
	131	cout << " Vertex position : " << currentTrack->GetVertexPos() << endl;
	132	Double_t momreco[3];
	133	for (Int_t axis=0; axis<3; axis++) {
	134	momreco[axis] = currentTrack->GetMomReconstr(axis);
	135	}
	136	cout << " Reconstructed mom. : " << "Px=" << momreco[0] << "Py=" << momreco[1] << "Pz=" << momreco[2] << endl;
	137	cout << " Chi squared : " << currentTrack->GetChi2r() << endl;
	138	cout << " Hits positions : " << endl;
	139	Double_t xhit, yhit, zhit;
	140	for (Int_t chamber=0; chamber<10; chamber++) {
	141	xhit = currentTrack->GetPosX(chamber);
	142	yhit = currentTrack->GetPosY(chamber);
	143	zhit = currentTrack->GetPosZ(chamber);
	144	// cout <<" chamber" << chamber << " X=" << xhit << " Y=" << yhit << " Z=" << zhit << endl;
	145	}
	146	}
	147	cout << "**********************************************************" << endl;
	148	}
	149
	150	//-------------------------------------------------------------------
83dbc640	151	Bool_t AliMUONRecoEvent::MakeDumpTracks(Int_t muons, TClonesArray *tracksPtr,
83dbc640	152	AliMUONEventReconstructor *EventReco)
c7ba256d	153	{
	154	// This method takes the pointer of the list of reconstructed tracks from
	155	// AliMUONEventReconstructor and fill the reconstructed AliMUONRecoEvent
	156	// fields.
83dbc640	157
c7ba256d	158	cout << "Enter MakeDumpTracks..." << endl;
c7ba256d	159	Int_t nTracks = tracksPtr->GetEntriesFast();
83dbc640	160	cout << "nTracks = "<< nTracks << endl;
c7ba256d	161	if (nTracks == 0) {
c7ba256d	162	cout << "AliMUONRecoEvent::MakeDumpTracks: Number of tracks is zero !" << endl;
83dbc640	163	//AZ return kFALSE;
c7ba256d	164	}
	165	cout << tracksPtr << endl;
	166	if (!tracksPtr) {
	167	cout << "AliMUONRecoEvent::MakeDumpTracks() : You should call SetRecoTracksPtr() first..." << endl;
	168	return kFALSE;
	169	}
	170	// Get event number
7c85b268	171	Int_t noEvent = gAlice->GetHeader()->GetEvent();
83dbc640	172	cout << "noEvent = "<< nTracks << endl;
c7ba256d	173	tracksPtr->Compress(); // simple loop
c7ba256d	174	AliMUONRecoTrack *currentTrack;
83dbc640	175	Int_t trackIndex, nTrackHits = 0;
83dbc640	176	Double_t z, pYZ, bendingSlope, nonBendingSlope;
c7ba256d	177	Double_t pX, pY, pZ; // reconstructed momentum components
83dbc640	178	Int_t isign, flag=0; // charge sign, flag of reconstructed track
	179	Double_t alpha, beta;
	180	TObjArray *hitsOnTrack = 0;
	181	AliMUONTrackHit *trackHit = 0;
c7ba256d	182	AliMUONTrack *track = 0;
83dbc640	183	AliMUONTrackK *trackK = 0;
83dbc640	184	TMatrixD *trackParamK; //AZnon
c7ba256d	185	AliMUONTrackParam *trackParam = 0;
c7ba256d	186	// Fill event number and number of tracks
7c85b268	187	fNevr = noEvent;
83dbc640	188	fMuons = muons; //AZ - number of muons within acceptance
c7ba256d	189	// Loop over reconstructed tracks
c7ba256d	190	for (trackIndex=0; trackIndex<nTracks; trackIndex++) {
83dbc640	191	cout << " trackIndex = " << trackIndex << endl;
c7ba256d	192	currentTrack = AddEmptyTrack();
83dbc640	193	cout << " currentTrack = " << currentTrack << endl;
	194
	195	if (EventReco->GetTrackMethod() == 2) { // Kalman
	196
	197	trackK = (AliMUONTrackK) ((tracksPtr)[trackIndex]);
	198	nTrackHits = trackK->GetNTrackHits();
	199	trackParamK = trackK->GetTrackParameters();
	200	isign = Int_t(TMath::Sign(1., (*trackParamK)(4,0)));
	201	z = trackK->GetZ();
	202	alpha = (*trackParamK)(2,0);
	203	beta = (*trackParamK)(3,0);
	204	pYZ = TMath::Cos(beta)/TMath::Abs((*trackParamK)(4,0));
	205	pZ = pYZ/TMath::Cos(alpha);
	206	pX = TMath::Sin(beta)/TMath::Abs((*trackParamK)(4,0));
	207	pY = pYZ*TMath::Sin(alpha);
	208
	209	currentTrack->SetVertexPos(z);
	210	currentTrack->SetMomReconstr(pX,pY,pZ);
	211	currentTrack->SetSign(isign);
	212	currentTrack->SetChi2r(trackK->GetTrackQuality());
	213
	214	// Check hits on the track
	215	hitsOnTrack = trackK->GetHitOnTrack();
	216	Float_t signal = 0;
	217	Float_t tht = 0;
	218	for (int ihit = 0; ihit < nTrackHits; ihit++) {
	219	signal += ((AliMUONHitForRec)((hitsOnTrack)[ihit]))->GetGeantSignal();
	220	tht += TMath::Min (1,((AliMUONHitForRec)((hitsOnTrack)[ihit]))->GetTHTrack());
	221	}
	222	signal /= nTrackHits;
	223	tht /= nTrackHits;
	224	flag = 0;
	225	if (TMath::Nint(signal) > 0) { // signal muon
	226	for (int ihit = 0; ihit < nTrackHits ; ihit++) {
	227	if (((AliMUONHitForRec)((hitsOnTrack)[ihit]))->GetTHTrack() != TMath::Nint(tht)) flag++;
	228	}
	229	} else flag = -9; // background track
	230	//cout << TMath::Nint(signal) << " " << TMath::Nint(tht) << " " << recTrackNt->fFlag << endl;
	231	currentTrack->SetFlag(flag);
	232	} else { // default tracking
	233
	234	track = (AliMUONTrack) ((tracksPtr)[trackIndex]);
	235	nTrackHits = track->GetNTrackHits();
	236	// track parameters at Vertex
	237	trackParam = track->GetTrackParamAtVertex();
	238	bendingSlope = trackParam->GetBendingSlope();
	239	nonBendingSlope = trackParam->GetNonBendingSlope();
	240
	241	z = trackParam->GetZ();
	242	pYZ = 1/TMath::Abs(trackParam->GetInverseBendingMomentum());
	243	pZ = pYZ/TMath::Sqrt(1+bendingSlope*bendingSlope);
	244	pX = pZ * nonBendingSlope;
	245	pY = pZ * bendingSlope;
	246
	247	if (trackParam->GetInverseBendingMomentum()<0) isign=-1; else isign=1;
	248	currentTrack->SetVertexPos(z);
	249	currentTrack->SetMomReconstr(pX,pY,pZ);
	250	currentTrack->SetSign(isign);
	251	// currentTrack->SetChi2r(trackParam->GetChi2());
	252	currentTrack->SetChi2r(0);
	253
	254	// Check hits on the track
	255	hitsOnTrack = track->GetTrackHitsPtr();
	256	Float_t signal = 0;
257	Float_t tht = 0;
258	AliMUONHitForRec *hitForRec = 0;
259	for (int ihit = 0; ihit < nTrackHits; ihit++) {
260	hitForRec = ((AliMUONTrackHit)(hitsOnTrack)[ihit])->GetHitForRecPtr();
261	signal += hitForRec->GetGeantSignal();
262	tht += TMath::Min (1,hitForRec->GetTHTrack());
263	}
264	signal /= nTrackHits;
265	tht /= nTrackHits;
266	flag = 0;
267	if (TMath::Nint(signal) > 0) { // signal muon
268	for (int ihit = 0; ihit < nTrackHits ; ihit++) {
269	hitForRec = ((AliMUONTrackHit)(hitsOnTrack)[ihit])->GetHitForRecPtr();
270	if (hitForRec->GetTHTrack() != TMath::Nint(tht)) flag++;
271	}
272	} else flag = -9; // background track
273	//cout << TMath::Nint(signal) << " " << TMath::Nint(tht) << " " << recTrackNt->fFlag << endl;
274	currentTrack->SetFlag(flag);
275	}
276
c7ba256d	277	Double_t xhit,yhit,zhit;
83dbc640	278	// Loop over track hits
c7ba256d	279	for (Int_t trackHitIndex = 0; trackHitIndex < nTrackHits; trackHitIndex++) {
83dbc640	280	if (EventReco->GetTrackMethod() == 2) { // Kalman
	281	xhit = ((AliMUONHitForRec)((hitsOnTrack)[trackHitIndex]))->GetNonBendingCoor();
	282	yhit = ((AliMUONHitForRec)((hitsOnTrack)[trackHitIndex]))->GetBendingCoor();
	283	zhit = ((AliMUONHitForRec)((hitsOnTrack)[trackHitIndex]))->GetZ();
	284	} else {
	285	trackHit = (AliMUONTrackHit) ((track->GetTrackHitsPtr()))[trackHitIndex];
	286	xhit = trackHit->GetHitForRecPtr()->GetNonBendingCoor();
	287	yhit = trackHit->GetHitForRecPtr()->GetBendingCoor();
	288	zhit = trackHit->GetHitForRecPtr()->GetZ();
	289	}
	290	if (trackHitIndex >= 0 && trackHitIndex < 10) {
	291	currentTrack->SetHitPosition(trackHitIndex,xhit,yhit,zhit);
	292	} else { cout << "track " << trackIndex << " hit out of range" << endl;}
c7ba256d	293	}
83dbc640	294
c7ba256d	295	}
	296	cout << "Leave MakeDumpTracks..." << endl;
	297	return kTRUE;
	298	}
	299
	300	//-------------------------------------------------------------------
	301	void AliMUONRecoEvent::Streamer(TBuffer &R__b)
	302	{
	303	// Streams an object of class AliMUONRecoEvent
	304	if (R__b.IsReading()) {
c7ba256d	305	fTracks->Clear();
2ab0c725	306	AliMUONRecoEvent::Class()->ReadBuffer(R__b, this);
c7ba256d	307	} else {
c7ba256d	308	cout << "...writing event to file...\n";
2ab0c725	309	AliMUONRecoEvent::Class()->WriteBuffer(R__b, this);
c7ba256d	310	}
c7ba256d	311	}