[u/mrichter/AliRoot.git] / HLT / EVE / AliHLTEveMuon.cxx

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Svein Lindal <slindal@fys.uio.no   >                  *
 *                  for The ALICE HLT Project.                            *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/// @file   AliHLTEvePhos.cxx
/// @author Svein Lindal <slindal@fys.uio.no>
/// @brief  Muon processor for the HLT EVE display

#include "AliHLTEveMuon.h"
#include "AliHLTMUONDataBlockReader.h"
#include "AliHLTHOMERBlockDesc.h"
#include "TCanvas.h"
#include "TEveStraightLineSet.h"
#include "TEvePointSet.h"
#include "AliEveHLTEventManager.h"
#include "TEveManager.h"


#include "TEveVSDStructs.h"
#include "TGeoGlobalMagField.h"
#include "AliMUONTrack.h"
#include "AliMUONTrackParam.h"
#include "AliMUONESDInterface.h"
#include "AliMUONVTrackReconstructor.h"
#include "AliEveMUONTrack.h"
#include "AliHLTMUONConstants.h"
#include "AliHLTMUONUtils.h"
#include "AliMUONVCluster.h"
#include "AliMUONVClusterStore.h"
#include "AliMUONConstants.h"
#include "TEveTrackPropagator.h"

using namespace std;

class AliHLTMUONUtils;
class AliEveMuonTrack;

ClassImp(AliHLTEveMuon);

AliHLTEveMuon::AliHLTEveMuon() : 
  AliHLTEveBase("Muon"),
  fFullTrackList(NULL),
  fTracks(NULL),
  fClusters(NULL)
{
  // Constructor.
  SetMaxHistograms(6);
}

AliHLTEveMuon::~AliHLTEveMuon()
{
  //Destructor
  if (fFullTrackList)
    delete fFullTrackList;
  fFullTrackList = NULL;
  
  if (fTracks)
    delete fTracks;
  fTracks = NULL;

  if(fClusters)
    delete fClusters;
  fClusters = NULL;
}


void AliHLTEveMuon::ProcessBlock(AliHLTHOMERBlockDesc * block) {
  //See header file for documentation
  if ( (block->GetDataType().CompareTo("RECHITS") == 0) || (block->GetDataType().CompareTo("TRIGRECS") == 0) ) {
    if(!fClusters) {
      fClusters = CreateClusters();
      AddElement(fClusters);
    }
    ProcessClusters( block, fClusters );
    
  }else if(block->GetDataType().CompareTo("MANTRACK") == 0){
    
    if ( !fTracks ) {
      fTracks = CreateTrackSet(); 
      AddElement(fTracks);
    }
    
    ProcessTracks( block, fTracks );

  }else if(block->GetDataType().CompareTo("TRACKS") == 0){
    
    if ( !fFullTrackList ) {
      fFullTrackList = CreateFullTrackList(); 
      AddElement(fFullTrackList);
    }
    
    ProcessFullTracks( block,  fFullTrackList );

  } else if(block->GetDataType().CompareTo("ROOTHIST") == 0) {
    ProcessHistogram(block);
  }
 
}

TEvePointSet * AliHLTEveMuon::CreateClusters() {
  //See header file for documentation
  TEvePointSet * ps = new TEvePointSet("MUON RecHits");
  ps->SetMainColor(kBlue);
  ps->SetMarkerStyle(20);
  return ps;
}

TEveStraightLineSet * AliHLTEveMuon::CreateTrackSet() {
  // See header file
  TEveStraightLineSet * lineset = new TEveStraightLineSet("MUON Tracks");
  lineset->SetMainColor(kRed);
  lineset->SetLineWidth(3);
  return lineset;
}

TEveTrackList * AliHLTEveMuon::CreateFullTrackList(){
  // See header file
  TEveTrackList * lineset = new TEveTrackList("MUON Full Tracks");
  lineset->SetMainColor(kBlue);
  return lineset;
}

void AliHLTEveMuon::ProcessHistogram(AliHLTHOMERBlockDesc * block ) {
  //See header file for documentation
  if(!fCanvas) {
    fCanvas = CreateCanvas("MUON QA", "MUON QA");
    fCanvas->Divide(3, 2);
  }
  AddHistogramsToCanvas(block, fCanvas, fHistoCount);
}

void AliHLTEveMuon::UpdateElements() {
  //See header file for documentation
  if(fCanvas) fCanvas->Update();
  if(fClusters) fClusters->ResetBBox();
  if(fTracks) fTracks->ElementChanged();
}

void AliHLTEveMuon::ResetElements(){
  //See header file for documentation
  fHistoCount = 0;
  
  if ( fClusters ) fClusters->Reset();
  if ( fTracks ){
    fTracks->Destroy();
    fTracks = NULL;
  }
  if ( fFullTrackList ){
    fFullTrackList->Destroy();
    fFullTrackList = NULL;
  }


}

void AliHLTEveMuon::ProcessClusters(AliHLTHOMERBlockDesc * block, TEvePointSet * clusters) {
    //See header file for documentation
  unsigned long size = block->GetSize();
  Int_t * buffer ;
  
  buffer = (Int_t *)block->GetData();
  //cout<<"block size : "<<size<<", buffer : "<<buffer<<", DataType : "<<block->GetDataType()<<endl;

  if(block->GetDataType().CompareTo("RECHITS") == 0){
    
    AliHLTMUONRecHitsBlockReader trackblock((char*)buffer, size);
    const AliHLTMUONRecHitStruct* hit = trackblock.GetArray();
    
    for(AliHLTUInt32_t ientry = 0; ientry < trackblock.Nentries(); ientry++){
      if(hit->fX!=0.0 && hit->fY!=0.0 && hit->fZ!=0.0)
	clusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
      hit++;
      
    }// track hit loop
  }
  
  else{// if rechits
    //     if(!strcmp((BlockType(ULong64_t(reader->GetBlockDataType(i)))).Data(),"TRIGRECS")){
    
    AliHLTMUONTriggerRecordsBlockReader trigblock(buffer, size);
    const AliHLTMUONTriggerRecordStruct* trigrec = trigblock.GetArray();
    for(AliHLTUInt32_t ientry = 0; ientry < trigblock.Nentries(); ientry++){
      
      const AliHLTMUONRecHitStruct* hit = &trigrec->fHit[0];
      for(AliHLTUInt32_t ch = 0; ch < 4; ch++)
	{
	  if(hit->fX!=0.0 && hit->fY!=0.0 && hit->fZ!=0.0)
	    clusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
	  hit++;
	}// trig chamber loop
      trigrec++;
    }//trig hit loop
  }//else trigger
  
}

void AliHLTEveMuon::ProcessTracks(AliHLTHOMERBlockDesc * block, TEveStraightLineSet * tracks) {
  //See header file for documentation  
  unsigned long size = block->GetSize();
  Int_t * buffer = (Int_t *)block->GetData();
  AliHLTMUONRecHitStruct hit1,hit2;
  hit1.fX = hit1.fY = hit1.fZ = hit2.fX = hit2.fY = hit2.fZ = 0;
  Int_t ch1=0, ch2=0;
  Float_t x0=0.0,y0=0.0,z0=0.0;
  Float_t x3=0.0,y3=0.0,z3=0.0;
  if(block->GetDataType().CompareTo("MANTRACK") == 0){  
    AliHLTMUONMansoTracksBlockReader mantrackblock(buffer, size);
    const AliHLTMUONMansoTrackStruct* mtrack = mantrackblock.GetArray();
    for(AliHLTUInt32_t ientry = 0; ientry < mantrackblock.Nentries(); ientry++){
      const AliHLTMUONRecHitStruct* hit = &mtrack->fHit[0];
      for(AliHLTUInt32_t ch = 0; ch < 4; ch++){
	// cout << setw(10) << left << ch + 7 << setw(0);
	// cout << setw(13) << left << hit->fX << setw(0);
	// cout << setw(13) << left << hit->fY << setw(0);
	// cout << hit->fZ << setw(0) << endl;
	if(hit->fZ != 0.0){
	  if(ch==0 || ch==1){
	    hit1 = *hit; ch1 = ch+6;
	  }else{
	    hit2 = *hit; ch2 = ch+6;
	  }
	}
	hit++;
      }// trig chamber loop
      // printf("ch : %d, (X,Y,Z) : (%f,%f,%f)\n",ch1,hit1.fX,hit1.fY,hit1.fZ);
      // printf("ch : %d, (X,Y,Z) : (%f,%f,%f)\n",ch2,hit2.fX,hit2.fY,hit2.fZ);
      // meminfo();
      z3 = AliMUONConstants::DefaultChamberZ(ch2+4);
      y3 =  hit1.fY - (hit1.fZ-z3)*(hit1.fY - hit2.fY)/(hit1.fZ - hit2.fZ) ;
      x3 =  hit1.fX - (hit1.fZ-z3)*(hit1.fX - hit2.fX)/(hit1.fZ - hit2.fZ) ;

      z0 = AliMUONConstants::DefaultChamberZ(ch1);
      y0 =  hit1.fY - (hit1.fZ-z0)*(hit1.fY - hit2.fY)/(hit1.fZ - hit2.fZ) ;
      x0 =  hit1.fX - (hit1.fZ-z0)*(hit1.fX - hit2.fX)/(hit1.fZ - hit2.fZ) ;
      

      tracks->AddLine(x0,y0,z0,x3,y3,z3);
      mtrack++;
    }
    //    cout<<"NofManso Tracks : "<<mantrackblock.Nentries()<<endl;
  }
}

int AliHLTEveMuon::MakeMUONTrack(AliMUONTrack *muonTrack, const AliHLTMUONTrackStruct *muonHLTTrack)
{
  // See header for documentation
  AliHLTUInt32_t clusterIndex = 0;  // for the cluster unique ID.			
  AliHLTMUONParticleSign sign;
  bool hitset[16];
  AliHLTMUONUtils::UnpackTrackFlags(
  				    muonHLTTrack->fFlags, sign, hitset
  				    );
  
  // add track parameters at vertex
  TVector3 mom(muonHLTTrack->fPx, muonHLTTrack->fPy, muonHLTTrack->fPz);
  AliMUONTrackParam paramAtVtx;
  if (mom.Mag() != 0)
    paramAtVtx.SetInverseBendingMomentum(muonHLTTrack->fInverseBendingMomentum);
  else
    paramAtVtx.SetInverseBendingMomentum(0.);
  paramAtVtx.SetNonBendingSlope(TMath::Tan(muonHLTTrack->fThetaX));
  paramAtVtx.SetBendingSlope(TMath::Tan(muonHLTTrack->fThetaY));
  paramAtVtx.SetZ(muonHLTTrack->fZ);
  paramAtVtx.SetBendingCoor(muonHLTTrack->fY);
  paramAtVtx.SetNonBendingCoor(muonHLTTrack->fX);
  muonTrack->SetTrackParamAtVertex(&paramAtVtx);

  //printf("(X,Y,Z) : (%8.3f,%8.3f,%8.3f)\n",muonHLTTrack->fX,muonHLTTrack->fY,muonHLTTrack->fZ);

  // add clusters
  Int_t nHits = 0;
  AliMUONVClusterStore* cStore = AliMUONESDInterface::NewClusterStore();
  if (!cStore) return -1;
  AliMUONVCluster* cluster = cStore->CreateCluster(0,0,0);
  AliMUONTrackParam trackParam;
  for (int i = 0; i < 16; i++)
    {
      if (not hitset[i]) continue;
				
      AliHLTUInt8_t chamber;
      AliHLTUInt16_t detElemId;
      AliHLTMUONUtils::UnpackRecHitFlags((muonHLTTrack->fHit[i]).fFlags, chamber, detElemId);
      
      cluster->SetUniqueID(AliMUONVCluster::BuildUniqueID(chamber, detElemId, clusterIndex++));
      cluster->SetXYZ((muonHLTTrack->fHit[i]).fX, (muonHLTTrack->fHit[i]).fY, (muonHLTTrack->fHit[i]).fZ);
      cluster->SetErrXY(    // Use nominal values.
			AliHLTMUONConstants::DefaultNonBendingReso(),
			AliHLTMUONConstants::DefaultBendingReso()
			);
      cluster->SetCharge(-1.);   // Indicate no total charge calculated.
      cluster->SetChi2(-1.);   // Indicate no fit made.
      trackParam.SetZ(cluster->GetZ());
      muonTrack->AddTrackParamAtCluster(trackParam, *cluster, kTRUE);
      nHits++;
    }
  
  // compute track parameters at each cluster
  if (nHits > 0) {
    AliMUONTrackParam *firstTrackParam = (AliMUONTrackParam*) muonTrack->GetTrackParamAtCluster()->First();
    trackParam = (*firstTrackParam);
    if (!AliMUONESDInterface::GetTracker()) AliMUONESDInterface::ResetTracker();
    if (!AliMUONESDInterface::GetTracker()->RefitTrack(*muonTrack, kFALSE) &&
	muonTrack->GetGlobalChi2() < AliMUONTrack::MaxChi2()) {
      *firstTrackParam = trackParam;
      muonTrack->UpdateCovTrackParamAtCluster();
    }
  }

  muonTrack->SetGlobalChi2(muonHLTTrack->fChi2);
  
  return 0;
}

Int_t AliHLTEveMuon::ProcessFullTracks(AliHLTHOMERBlockDesc * block, TEveTrackList * fullTracks) {

  // See header for documentation 

  Int_t iResult = 0;

  Double_t b[3], x[3];
  x[0] = 0.0 ; x[1] = 0.0 ; x[2] = -950.0;
  TGeoGlobalMagField::Instance()->Field(x,b);
  //" Field at (0.0, 0.0, -950.0) [at the middle of dipole magnet] 
  //should be (6.79, 0.03, -0.17) or similar value with change of sign"
  if(TMath::AreEqualAbs(b[0],0.0,1.0e-5) and TMath::AreEqualAbs(b[1],0.0,1.0e-5) and TMath::AreEqualAbs(b[2],0.0,1.0e-5)){
    printf("At (X,Y,Z) : (%6.2lf,%6.2lf,%6.2lf) Field (Bx,By,Bz) is (%6.2lf,%6.2lf,%6.2lf)\n",
	   x[0],x[1],x[2],b[0],b[1],b[2]);    
    cerr<<"Magnetic field is not properly set, MUON tracking will not possble"<<endl;
    return 1;
  }
  
  
  TEveRecTrack rt;
  
  unsigned long size = block->GetSize();
  Int_t * buffer = (Int_t *)block->GetData();

  AliHLTMUONTracksBlockReader muontrackblock(buffer, size);
  const AliHLTMUONTrackStruct* mtrack = muontrackblock.GetArray();
  //cout<<"NofTracks : "<<muontrackblock.Nentries()<<endl;
  for(AliHLTUInt32_t ientry = 0; ientry < muontrackblock.Nentries(); ientry++){
    
    AliMUONTrack *muonTrack = new AliMUONTrack();
    MakeMUONTrack(muonTrack,mtrack);
    if(muonTrack->GetNClusters()==0){
      delete muonTrack;
      continue;
    }
    
    rt.fLabel = ientry;
    AliEveMUONTrack* track = new AliEveMUONTrack(&rt, fullTracks->GetPropagator());
    track->MakeMUONTrack(muonTrack);
    //track->SetTitle(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));
    track->SetName(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));
    fullTracks->AddElement(track);
    
    mtrack++;
  }//track loop
  
  return iResult;

}
Commit	Line	Data
a65a7e70	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* ALICE Experiment at CERN, All rights reserved. *
	4	* *
	5	* Primary Authors: Svein Lindal <slindal@fys.uio.no > *
	6	* for The ALICE HLT Project. *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
	16
	17	/// @file AliHLTEvePhos.cxx
	18	/// @author Svein Lindal <slindal@fys.uio.no>
	19	/// @brief Muon processor for the HLT EVE display
	20
	21	#include "AliHLTEveMuon.h"
	22	#include "AliHLTMUONDataBlockReader.h"
	23	#include "AliHLTHOMERBlockDesc.h"
	24	#include "TCanvas.h"
	25	#include "TEveStraightLineSet.h"
	26	#include "TEvePointSet.h"
	27	#include "AliEveHLTEventManager.h"
	28	#include "TEveManager.h"
	29
	30
	31	#include "TEveVSDStructs.h"
	32	#include "TGeoGlobalMagField.h"
	33	#include "AliMUONTrack.h"
	34	#include "AliMUONTrackParam.h"
	35	#include "AliMUONESDInterface.h"
	36	#include "AliMUONVTrackReconstructor.h"
	37	#include "AliEveMUONTrack.h"
	38	#include "AliHLTMUONConstants.h"
	39	#include "AliHLTMUONUtils.h"
	40	#include "AliMUONVCluster.h"
	41	#include "AliMUONVClusterStore.h"
	42	#include "AliMUONConstants.h"
	43	#include "TEveTrackPropagator.h"
	44
	45	using namespace std;
	46
	47	class AliHLTMUONUtils;
	48	class AliEveMuonTrack;
	49
	50	ClassImp(AliHLTEveMuon);
	51
	52	AliHLTEveMuon::AliHLTEveMuon() :
	53	AliHLTEveBase("Muon"),
	54	fFullTrackList(NULL),
	55	fTracks(NULL),
	56	fClusters(NULL)
	57	{
	58	// Constructor.
	59	SetMaxHistograms(6);
	60	}
	61
	62	AliHLTEveMuon::~AliHLTEveMuon()
	63	{
	64	//Destructor
65	if (fFullTrackList)
66	delete fFullTrackList;
67	fFullTrackList = NULL;
68
69	if (fTracks)
70	delete fTracks;
71	fTracks = NULL;
72
73	if(fClusters)
74	delete fClusters;
75	fClusters = NULL;
76	}
77
78
79	void AliHLTEveMuon::ProcessBlock(AliHLTHOMERBlockDesc * block) {
80	//See header file for documentation
81	if ( (block->GetDataType().CompareTo("RECHITS") == 0) \|\| (block->GetDataType().CompareTo("TRIGRECS") == 0) ) {
82	if(!fClusters) {
83	fClusters = CreateClusters();
84	AddElement(fClusters);
85	}
86	ProcessClusters( block, fClusters );
87
88	}else if(block->GetDataType().CompareTo("MANTRACK") == 0){
89
90	if ( !fTracks ) {
91	fTracks = CreateTrackSet();
92	AddElement(fTracks);
93	}
94
95	ProcessTracks( block, fTracks );
96
97	}else if(block->GetDataType().CompareTo("TRACKS") == 0){
98
99	if ( !fFullTrackList ) {
100	fFullTrackList = CreateFullTrackList();
101	AddElement(fFullTrackList);
102	}
103
104	ProcessFullTracks( block, fFullTrackList );
105
106	} else if(block->GetDataType().CompareTo("ROOTHIST") == 0) {
107	ProcessHistogram(block);
108	}
109
110	}
111
112	TEvePointSet * AliHLTEveMuon::CreateClusters() {
113	//See header file for documentation
114	TEvePointSet * ps = new TEvePointSet("MUON RecHits");
115	ps->SetMainColor(kBlue);
116	ps->SetMarkerStyle(20);
117	return ps;
118	}
119
120	TEveStraightLineSet * AliHLTEveMuon::CreateTrackSet() {
121	// See header file
122	TEveStraightLineSet * lineset = new TEveStraightLineSet("MUON Tracks");
123	lineset->SetMainColor(kRed);
124	lineset->SetLineWidth(3);
125	return lineset;
126	}
127
128	TEveTrackList * AliHLTEveMuon::CreateFullTrackList(){
129	// See header file
130	TEveTrackList * lineset = new TEveTrackList("MUON Full Tracks");
131	lineset->SetMainColor(kBlue);
132	return lineset;
133	}
134
135	void AliHLTEveMuon::ProcessHistogram(AliHLTHOMERBlockDesc * block ) {
136	//See header file for documentation
137	if(!fCanvas) {
138	fCanvas = CreateCanvas("MUON QA", "MUON QA");
139	fCanvas->Divide(3, 2);
140	}
141	AddHistogramsToCanvas(block, fCanvas, fHistoCount);
142	}
143
144	void AliHLTEveMuon::UpdateElements() {
145	//See header file for documentation
146	if(fCanvas) fCanvas->Update();
147	if(fClusters) fClusters->ResetBBox();
148	if(fTracks) fTracks->ElementChanged();
149	}
150
151	void AliHLTEveMuon::ResetElements(){
152	//See header file for documentation
153	fHistoCount = 0;
154
155	if ( fClusters ) fClusters->Reset();
156	if ( fTracks ){
157	fTracks->Destroy();
158	fTracks = NULL;
159	}
160	if ( fFullTrackList ){
161	fFullTrackList->Destroy();
162	fFullTrackList = NULL;
163	}
164
165
166	}
167
168	void AliHLTEveMuon::ProcessClusters(AliHLTHOMERBlockDesc * block, TEvePointSet * clusters) {
169	//See header file for documentation
170	unsigned long size = block->GetSize();
171	Int_t * buffer ;
172
173	buffer = (Int_t *)block->GetData();
174	//cout<<"block size : "<<size<<", buffer : "<<buffer<<", DataType : "<<block->GetDataType()<<endl;
175
176	if(block->GetDataType().CompareTo("RECHITS") == 0){
177
178	AliHLTMUONRecHitsBlockReader trackblock((char*)buffer, size);
179	const AliHLTMUONRecHitStruct* hit = trackblock.GetArray();
180
181	for(AliHLTUInt32_t ientry = 0; ientry < trackblock.Nentries(); ientry++){
182	if(hit->fX!=0.0 && hit->fY!=0.0 && hit->fZ!=0.0)
183	clusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
184	hit++;
185
186	}// track hit loop
187	}
188
189	else{// if rechits
190	// if(!strcmp((BlockType(ULong64_t(reader->GetBlockDataType(i)))).Data(),"TRIGRECS")){
191
192	AliHLTMUONTriggerRecordsBlockReader trigblock(buffer, size);
193	const AliHLTMUONTriggerRecordStruct* trigrec = trigblock.GetArray();
194	for(AliHLTUInt32_t ientry = 0; ientry < trigblock.Nentries(); ientry++){
195
196	const AliHLTMUONRecHitStruct* hit = &trigrec->fHit[0];
197	for(AliHLTUInt32_t ch = 0; ch < 4; ch++)
198	{
199	if(hit->fX!=0.0 && hit->fY!=0.0 && hit->fZ!=0.0)
200	clusters->SetNextPoint(hit->fX,hit->fY,hit->fZ);
201	hit++;
202	}// trig chamber loop
203	trigrec++;
204	}//trig hit loop
205	}//else trigger
206
207	}
208
209	void AliHLTEveMuon::ProcessTracks(AliHLTHOMERBlockDesc * block, TEveStraightLineSet * tracks) {
210	//See header file for documentation
211	unsigned long size = block->GetSize();
212	Int_t * buffer = (Int_t *)block->GetData();
213	AliHLTMUONRecHitStruct hit1,hit2;
214	hit1.fX = hit1.fY = hit1.fZ = hit2.fX = hit2.fY = hit2.fZ = 0;
215	Int_t ch1=0, ch2=0;
216	Float_t x0=0.0,y0=0.0,z0=0.0;
217	Float_t x3=0.0,y3=0.0,z3=0.0;
218	if(block->GetDataType().CompareTo("MANTRACK") == 0){
219	AliHLTMUONMansoTracksBlockReader mantrackblock(buffer, size);
220	const AliHLTMUONMansoTrackStruct* mtrack = mantrackblock.GetArray();
221	for(AliHLTUInt32_t ientry = 0; ientry < mantrackblock.Nentries(); ientry++){
222	const AliHLTMUONRecHitStruct* hit = &mtrack->fHit[0];
223	for(AliHLTUInt32_t ch = 0; ch < 4; ch++){
224	// cout << setw(10) << left << ch + 7 << setw(0);
225	// cout << setw(13) << left << hit->fX << setw(0);
226	// cout << setw(13) << left << hit->fY << setw(0);
227	// cout << hit->fZ << setw(0) << endl;
228	if(hit->fZ != 0.0){
229	if(ch==0 \|\| ch==1){
230	hit1 = *hit; ch1 = ch+6;
231	}else{
232	hit2 = *hit; ch2 = ch+6;
233	}
234	}
235	hit++;
236	}// trig chamber loop
237	// printf("ch : %d, (X,Y,Z) : (%f,%f,%f)\n",ch1,hit1.fX,hit1.fY,hit1.fZ);
238	// printf("ch : %d, (X,Y,Z) : (%f,%f,%f)\n",ch2,hit2.fX,hit2.fY,hit2.fZ);
239	// meminfo();
240	z3 = AliMUONConstants::DefaultChamberZ(ch2+4);
241	y3 = hit1.fY - (hit1.fZ-z3)*(hit1.fY - hit2.fY)/(hit1.fZ - hit2.fZ) ;
242	x3 = hit1.fX - (hit1.fZ-z3)*(hit1.fX - hit2.fX)/(hit1.fZ - hit2.fZ) ;
243
244	z0 = AliMUONConstants::DefaultChamberZ(ch1);
245	y0 = hit1.fY - (hit1.fZ-z0)*(hit1.fY - hit2.fY)/(hit1.fZ - hit2.fZ) ;
246	x0 = hit1.fX - (hit1.fZ-z0)*(hit1.fX - hit2.fX)/(hit1.fZ - hit2.fZ) ;
247
248
249	tracks->AddLine(x0,y0,z0,x3,y3,z3);
250	mtrack++;
251	}
252	// cout<<"NofManso Tracks : "<<mantrackblock.Nentries()<<endl;
253	}
254	}
255
256	int AliHLTEveMuon::MakeMUONTrack(AliMUONTrack muonTrack, const AliHLTMUONTrackStruct muonHLTTrack)
257	{
258	// See header for documentation
259	AliHLTUInt32_t clusterIndex = 0; // for the cluster unique ID.
260	AliHLTMUONParticleSign sign;
261	bool hitset[16];
262	AliHLTMUONUtils::UnpackTrackFlags(
263	muonHLTTrack->fFlags, sign, hitset
264	);
265
266	// add track parameters at vertex
267	TVector3 mom(muonHLTTrack->fPx, muonHLTTrack->fPy, muonHLTTrack->fPz);
268	AliMUONTrackParam paramAtVtx;
269	if (mom.Mag() != 0)
270	paramAtVtx.SetInverseBendingMomentum(muonHLTTrack->fInverseBendingMomentum);
271	else
272	paramAtVtx.SetInverseBendingMomentum(0.);
273	paramAtVtx.SetNonBendingSlope(TMath::Tan(muonHLTTrack->fThetaX));
274	paramAtVtx.SetBendingSlope(TMath::Tan(muonHLTTrack->fThetaY));
275	paramAtVtx.SetZ(muonHLTTrack->fZ);
276	paramAtVtx.SetBendingCoor(muonHLTTrack->fY);
277	paramAtVtx.SetNonBendingCoor(muonHLTTrack->fX);
278	muonTrack->SetTrackParamAtVertex(&paramAtVtx);
279
280	//printf("(X,Y,Z) : (%8.3f,%8.3f,%8.3f)\n",muonHLTTrack->fX,muonHLTTrack->fY,muonHLTTrack->fZ);
281
282	// add clusters
283	Int_t nHits = 0;
284	AliMUONVClusterStore* cStore = AliMUONESDInterface::NewClusterStore();
285	if (!cStore) return -1;
286	AliMUONVCluster* cluster = cStore->CreateCluster(0,0,0);
287	AliMUONTrackParam trackParam;
288	for (int i = 0; i < 16; i++)
289	{
290	if (not hitset[i]) continue;
291
292	AliHLTUInt8_t chamber;
293	AliHLTUInt16_t detElemId;
294	AliHLTMUONUtils::UnpackRecHitFlags((muonHLTTrack->fHit[i]).fFlags, chamber, detElemId);
295
296	cluster->SetUniqueID(AliMUONVCluster::BuildUniqueID(chamber, detElemId, clusterIndex++));
297	cluster->SetXYZ((muonHLTTrack->fHit[i]).fX, (muonHLTTrack->fHit[i]).fY, (muonHLTTrack->fHit[i]).fZ);
298	cluster->SetErrXY( // Use nominal values.
299	AliHLTMUONConstants::DefaultNonBendingReso(),
300	AliHLTMUONConstants::DefaultBendingReso()
301	);
302	cluster->SetCharge(-1.); // Indicate no total charge calculated.
303	cluster->SetChi2(-1.); // Indicate no fit made.
304	trackParam.SetZ(cluster->GetZ());
305	muonTrack->AddTrackParamAtCluster(trackParam, *cluster, kTRUE);
306	nHits++;
307	}
308
309	// compute track parameters at each cluster
310	if (nHits > 0) {
311	AliMUONTrackParam firstTrackParam = (AliMUONTrackParam) muonTrack->GetTrackParamAtCluster()->First();
312	trackParam = (*firstTrackParam);
313	if (!AliMUONESDInterface::GetTracker()) AliMUONESDInterface::ResetTracker();
314	if (!AliMUONESDInterface::GetTracker()->RefitTrack(*muonTrack, kFALSE) &&
315	muonTrack->GetGlobalChi2() < AliMUONTrack::MaxChi2()) {
316	*firstTrackParam = trackParam;
317	muonTrack->UpdateCovTrackParamAtCluster();
318	}
319	}
320
321	muonTrack->SetGlobalChi2(muonHLTTrack->fChi2);
322
323	return 0;
324	}
325
326	Int_t AliHLTEveMuon::ProcessFullTracks(AliHLTHOMERBlockDesc * block, TEveTrackList * fullTracks) {
327
328	// See header for documentation
329
330	Int_t iResult = 0;
331
332	Double_t b[3], x[3];
333	x[0] = 0.0 ; x[1] = 0.0 ; x[2] = -950.0;
334	TGeoGlobalMagField::Instance()->Field(x,b);
335	//" Field at (0.0, 0.0, -950.0) [at the middle of dipole magnet]
336	//should be (6.79, 0.03, -0.17) or similar value with change of sign"
337	if(TMath::AreEqualAbs(b[0],0.0,1.0e-5) and TMath::AreEqualAbs(b[1],0.0,1.0e-5) and TMath::AreEqualAbs(b[2],0.0,1.0e-5)){
338	printf("At (X,Y,Z) : (%6.2lf,%6.2lf,%6.2lf) Field (Bx,By,Bz) is (%6.2lf,%6.2lf,%6.2lf)\n",
339	x[0],x[1],x[2],b[0],b[1],b[2]);
340	cerr<<"Magnetic field is not properly set, MUON tracking will not possble"<<endl;
341	return 1;
342	}
343
344
345
346	TEveRecTrack rt;
347
348	unsigned long size = block->GetSize();
349	Int_t * buffer = (Int_t *)block->GetData();
350
351	AliHLTMUONTracksBlockReader muontrackblock(buffer, size);
352	const AliHLTMUONTrackStruct* mtrack = muontrackblock.GetArray();
353	//cout<<"NofTracks : "<<muontrackblock.Nentries()<<endl;
354	for(AliHLTUInt32_t ientry = 0; ientry < muontrackblock.Nentries(); ientry++){
355
356	AliMUONTrack *muonTrack = new AliMUONTrack();
357	MakeMUONTrack(muonTrack,mtrack);
358	if(muonTrack->GetNClusters()==0){
359	delete muonTrack;
360	continue;
361	}
362
363	rt.fLabel = ientry;
364	AliEveMUONTrack* track = new AliEveMUONTrack(&rt, fullTracks->GetPropagator());
365	track->MakeMUONTrack(muonTrack);
366	//track->SetTitle(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));
367	track->SetName(Form("HLT Track : %d, pt : %lf",ientry,TMath::Sqrt(((mtrack->fPx * mtrack->fPx) + (mtrack->fPy * mtrack->fPy)))));
368	fullTracks->AddElement(track);
369
370	mtrack++;
371	}//track loop
372
373	return iResult;
374
375	}