In the conversion to AliHLTTPCTrack, the error of Pt is set to the error of q/Pt...
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCAGlobalMergerComponent.cxx
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: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
6 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
7 //                  Matthias Kretz <kretz@kde.org>                          *
8 //                  for The ALICE HLT Project.                              *
9 //                                                                          *
10 // Permission to use, copy, modify and distribute this software and its     *
11 // documentation strictly for non-commercial purposes is hereby granted     *
12 // without fee, provided that the above copyright notice appears in all     *
13 // copies and that both the copyright notice and this permission notice     *
14 // appear in the supporting documentation. The authors make no claims       *
15 // about the suitability of this software for any purpose. It is            *
16 // provided "as is" without express or implied warranty.                    *
17 //                                                                          *
18 //***************************************************************************
19
20
21 /** @file   AliHLTTPCCAGlobalMergerComponent.cxx
22     @author Matthias Kretz
23     @date
24     @brief  HLT TPC CA global merger component.
25 */
26
27 #if __GNUC__>= 3
28 using namespace std;
29 #endif
30
31 #include "AliHLTTPCCAGlobalMergerComponent.h"
32 #include "AliHLTTPCCAMergerOutput.h"
33 #include "AliHLTTPCTransform.h"
34 #include "AliHLTTPCCAMerger.h"
35 #include "AliHLTTPCVertex.h"
36 #include "AliHLTTPCVertexData.h"
37 #include "AliHLTTPCTrackSegmentData.h"
38 #include "AliHLTTPCTrack.h"
39 #include "AliHLTTPCTrackArray.h"
40 #include "AliHLTTPCTrackletDataFormat.h"
41 #include "AliHLTTPCCADef.h"
42 #include "AliHLTTPCDefinitions.h"
43 #include "AliHLTTPCCATrackConvertor.h"
44 #include "AliHLTTPCCASliceOutput.h"
45
46 #include "AliCDBEntry.h"
47 #include "AliCDBManager.h"
48 #include "TObjString.h"
49 #include "TObjArray.h"
50
51 #include <climits>
52 #include <cstdlib>
53 #include <cerrno>
54
55
56 // ROOT macro for the implementation of ROOT specific class methods
57 ClassImp( AliHLTTPCCAGlobalMergerComponent )
58
59
60 // global object for registration
61 AliHLTTPCCAGlobalMergerComponent AliHLTTPCCAGlobalMergerComponent::fgAliHLTTPCCAGlobalMergerComponent;
62
63 AliHLTTPCCAGlobalMergerComponent::AliHLTTPCCAGlobalMergerComponent()
64     : fGlobalMerger( 0 ), fSolenoidBz( 5 )
65 {
66   // see header file for class documentation
67 }
68
69 // Public functions to implement AliHLTComponent's interface.
70 // These functions are required for the registration process
71
72 const char *AliHLTTPCCAGlobalMergerComponent::GetComponentID()
73 {
74   // see header file for class documentation
75   return "TPCCAGlobalMerger";
76 }
77
78 void AliHLTTPCCAGlobalMergerComponent::GetInputDataTypes( AliHLTComponentDataTypeList &list )
79 {
80   // see header file for class documentation
81   list.clear();
82   list.push_back( AliHLTTPCCADefinitions::fgkTrackletsDataType );
83   //list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
84   //list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
85 }
86
87 AliHLTComponentDataType AliHLTTPCCAGlobalMergerComponent::GetOutputDataType()
88 {
89   // see header file for class documentation
90   return AliHLTTPCDefinitions::fgkTracksDataType;
91 }
92
93 void AliHLTTPCCAGlobalMergerComponent::GetOutputDataSize( unsigned long &constBase, double &inputMultiplier )
94 {
95   // see header file for class documentation
96   // XXX TODO: Find more realistic values.
97   constBase = 0;
98   inputMultiplier = 1.0;
99 }
100
101 AliHLTComponent *AliHLTTPCCAGlobalMergerComponent::Spawn()
102 {
103   // see header file for class documentation
104   return new AliHLTTPCCAGlobalMergerComponent;
105 }
106
107 int AliHLTTPCCAGlobalMergerComponent::DoInit( int argc, const char** argv )
108 {
109   // see header file for class documentation
110   if ( fGlobalMerger ) {
111     return EINPROGRESS;
112   }
113
114   // Initialize the merger
115
116   fGlobalMerger = new AliHLTTPCCAMerger();
117
118   AliHLTTPCCAParam param;
119
120   {
121     // get gemetry
122     int iSec = 0;
123     float inRmin = 83.65;
124     float outRmax = 247.7;
125     float plusZmin = 0.0529937;
126     float plusZmax = 249.778;
127     float minusZmin = -249.645;
128     float minusZmax = -0.0799937;
129     float dalpha = 0.349066;
130     float alpha = 0.174533 + dalpha * iSec;
131     bool zPlus = ( iSec < 18 );
132     float zMin =  zPlus ? plusZmin : minusZmin;
133     float zMax =  zPlus ? plusZmax : minusZmax;
134     int nRows = AliHLTTPCTransform::GetNRows();
135     float padPitch = 0.4;
136     float sigmaZ = 0.228808;
137     float *rowX = new float [nRows];
138     for ( int irow = 0; irow < nRows; irow++ ) {
139       rowX[irow] = AliHLTTPCTransform::Row2X( irow );
140     }
141
142     param.Initialize( iSec, nRows, rowX, alpha, dalpha,
143                       inRmin, outRmax, zMin, zMax, padPitch, sigmaZ, fSolenoidBz );
144     delete[] rowX;
145   }
146
147
148   fGlobalMerger->SetSliceParam( param );
149
150   int iResult = 0;
151
152   TString arguments = "";
153   for ( int i = 0; i < argc; i++ ) {
154     TString argument = argv[i];
155     if ( !arguments.IsNull() ) arguments += " ";
156     arguments += argument;
157   }
158   if ( !arguments.IsNull() ) {
159     iResult = Configure( arguments.Data() );
160   } else {
161     iResult = Reconfigure( NULL, NULL );
162   }
163   return iResult;
164 }
165
166 int AliHLTTPCCAGlobalMergerComponent::DoDeinit()
167 {
168   // see header file for class documentation
169   delete fGlobalMerger;
170   fGlobalMerger = 0;
171
172   return 0;
173 }
174
175 int AliHLTTPCCAGlobalMergerComponent::DoEvent( const AliHLTComponentEventData &evtData,
176     const AliHLTComponentBlockData *blocks, AliHLTComponentTriggerData &/*trigData*/,
177     AliHLTUInt8_t *outputPtr, AliHLTUInt32_t &size, AliHLTComponentBlockDataList &outputBlocks )
178 {
179   // see header file for class documentation
180   int iResult = 0;
181   unsigned int maxBufferSize = size;
182
183   size = 0;
184
185   if ( !outputPtr ) {
186     return -ENOSPC;
187   }
188   if ( !IsDataEvent() ) {
189     return 0;
190   }
191
192   fGlobalMerger->Clear();
193
194   const AliHLTComponentBlockData *const blocksEnd = blocks + evtData.fBlockCnt;
195   for ( const AliHLTComponentBlockData *block = blocks; block < blocksEnd; ++block ) {
196     if ( block->fDataType != AliHLTTPCCADefinitions::fgkTrackletsDataType ) {
197       continue;
198     }
199
200     int slice = AliHLTTPCDefinitions::GetMinSliceNr( *block );
201     if ( slice < 0 || slice >= AliHLTTPCTransform::GetNSlice() ) {
202       HLTError( "invalid slice number %d extracted from specification 0x%08lx,  skipping block of type %s",
203                 slice, block->fSpecification, DataType2Text( block->fDataType ).c_str() );
204       // just remember the error, if there are other valid blocks ignore the error, return code otherwise
205       iResult = -EBADF;
206       continue;
207     }
208
209     if ( slice != AliHLTTPCDefinitions::GetMaxSliceNr( *block ) ) {
210       // the code was not written for/ never used with multiple slices in one data block/ specification
211       HLTWarning( "specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code",
212                   block->fSpecification, DataType2Text( block->fDataType ).c_str() );
213     }
214     AliHLTTPCCASliceOutput *sliceOut =  reinterpret_cast<AliHLTTPCCASliceOutput *>( block->fPtr );
215     sliceOut->SetPointers();
216     fGlobalMerger->SetSliceData( slice, sliceOut );
217   }
218   fGlobalMerger->Reconstruct();
219
220   const AliHLTTPCCAMergerOutput *mergerOutput = fGlobalMerger->Output();
221
222
223   // Fill output tracks
224
225   unsigned int mySize = 0;
226
227   {
228     // check if there was enough space in the output buffer
229
230     int nTracks = mergerOutput->NTracks();
231
232     AliHLTTPCTrackArray array( nTracks );
233
234     int nClusters = 0;
235     for ( int itr = 0; itr < nTracks; itr++ ) {
236
237       // convert AliHLTTPCCAMergedTrack to AliHLTTPCTrack
238
239       const AliHLTTPCCAMergedTrack &track = mergerOutput->Track( itr );
240       AliHLTTPCTrack out;
241
242       // first convert to AliExternalTrackParam ( Kappa to Pt )
243
244       AliExternalTrackParam tp, tpEnd;
245       AliHLTTPCCATrackConvertor::GetExtParam( track.InnerParam(), tp, 0 );
246       AliHLTTPCCATrackConvertor::GetExtParam( track.OuterParam(), tpEnd, 0 );
247
248       // set parameters, with rotation to global coordinates
249
250       out.SetCharge( ( int ) tp.GetSign() );
251       out.SetPt( TMath::Abs( tp.GetSignedPt() ) );
252       out.SetPsi( fmod( TMath::ASin( tp.GetSnp() ) + track.InnerAlpha() , 2*TMath::Pi() ) );
253       out.SetTgl( tp.GetTgl() );
254       {
255         float sinA = TMath::Sin( track.InnerAlpha() );
256         float cosA = TMath::Cos( track.InnerAlpha() );
257
258         out.SetFirstPoint( tp.GetX()*cosA - tp.GetY()*sinA,
259                            tp.GetX()*sinA + tp.GetY()*cosA,
260                            tp.GetZ() );
261       }
262
263       {
264         float sinA = TMath::Sin( track.OuterAlpha() );
265         float cosA = TMath::Cos( track.OuterAlpha() );
266
267         out.SetLastPoint( tpEnd.GetX()*cosA - tpEnd.GetY()*sinA,
268                           tpEnd.GetX()*sinA + tpEnd.GetY()*cosA,
269                           tpEnd.GetZ() );
270       }
271
272       // set parameter errors w/o rotation, as it is done in AliHLTTPCTrackArray
273
274       out.SetY0err( tp.GetSigmaY2() );
275       out.SetZ0err( tp.GetSigmaZ2() );
276       out.SetPterr( tp.GetSigma1Pt2() );      
277       out.SetPsierr( tp.GetSigmaSnp2() );
278       out.SetTglerr( tp.GetSigmaTgl2() );
279
280       // set cluster ID's
281
282       unsigned int hitID[1000];
283       for ( int i = 0; i < track.NClusters(); i++ ) hitID[i] = mergerOutput->ClusterId( track.FirstClusterRef() + i );
284
285       out.SetNHits( track.NClusters() );
286       out.SetHits( track.NClusters(), hitID );
287
288       out.SetSector( -1 );
289       out.CalculateHelix();
290       if ( !out.CheckConsistency() )  *( array.NextTrack() ) = out;
291       nClusters += track.NClusters();
292     }
293
294
295     if ( sizeof( AliHLTTPCTrackletData ) + nTracks*sizeof( AliHLTTPCTrackSegmentData ) + nClusters*sizeof( unsigned int )
296          > maxBufferSize ) {
297       iResult = -ENOSPC;
298     } else {
299       AliHLTTPCTrackletData *outPtr = ( AliHLTTPCTrackletData* )( outputPtr );
300       unsigned int nOutTracks = 0;
301       mySize = array.WriteTracks( nOutTracks, outPtr->fTracklets );
302       mySize += sizeof( AliHLTTPCTrackletData );
303       outPtr->fTrackletCnt = nOutTracks;
304     }
305   }
306
307   AliHLTComponentBlockData resultData;
308   FillBlockData( resultData );
309   resultData.fOffset = 0;
310   resultData.fSize = mySize;
311   resultData.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( 0, 35, 0, 5 );
312   outputBlocks.push_back( resultData );
313   size = resultData.fSize;
314
315   HLTInfo( "CAGlobalMerger:: output %d tracks", mergerOutput->NTracks() );
316
317   return iResult;
318 }
319
320
321
322 int AliHLTTPCCAGlobalMergerComponent::Reconfigure( const char* /*cdbEntry*/, const char* /*chainId*/ )
323 {
324   // see header file for class documentation
325
326
327   HLTInfo( "TODO: dummy Reconfigure() method" );
328   return 0;
329   /*
330
331   int iResult=0;
332   const char* pathBField=kAliHLTCDBSolenoidBz;
333
334   if (pathBField) {
335     HLTInfo("reconfigure B-Field from entry %s, chain id %s", pathBField,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
336     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField);//,GetRunNo());
337     if (pEntry) {
338       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
339       if (pString) {
340   HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
341   iResult=Configure(pString->GetString().Data());
342       } else {
343   HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField);
344       }
345     } else {
346       HLTError("cannot fetch object \"%s\" from CDB", pathBField);
347     }
348   }
349   return iResult;
350   */
351 }
352
353
354 int AliHLTTPCCAGlobalMergerComponent::Configure( const char* arguments )
355 {
356   //* Set parameters
357
358   int iResult = 0;
359   if ( !arguments ) return iResult;
360
361   TString allArgs = arguments;
362   TString argument;
363   int bMissingParam = 0;
364
365   TObjArray* pTokens = allArgs.Tokenize( " " );
366
367   int nArgs =  pTokens ? pTokens->GetEntries() : 0;
368
369   for ( int i = 0; i < nArgs; i++ ) {
370     argument = ( ( TObjString* )pTokens->At( i ) )->GetString();
371     if ( argument.IsNull() ) {
372     } else if ( argument.CompareTo( "-solenoidBz" ) == 0 ) {
373       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
374       fSolenoidBz = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
375       HLTInfo( "Magnetic Field set to: %f", fSolenoidBz );
376     } else {
377       HLTError( "Unknown option %s ", argument.Data() );
378       iResult = -EINVAL;
379     }
380   }
381   delete pTokens;
382
383   if ( bMissingParam ) {
384     HLTError( "Specifier missed for %s", argument.Data() );
385     iResult = -EINVAL;
386   }
387
388   return iResult;
389 }
390