When Pt is bad defined (ex. no field), the multiple scattering effect is calculated...
[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCATrackerFramework.cxx
1 // @(#) $Id: AliHLTTPCCATracker.cxx 34611 2009-09-04 00:22:05Z sgorbuno $
2 // **************************************************************************
3 // This file is property of and copyright by the ALICE HLT Project          *
4 // ALICE Experiment at CERN, All rights reserved.                           *
5 //                                                                          *
6 // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
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 #include "AliHLTTPCCADef.h"
21 #include "AliHLTTPCCAGPUConfig.h"
22 #include "AliHLTTPCCATrackerFramework.h"
23 #include "AliHLTTPCCAGPUTracker.h"
24 #include "AliHLTTPCCATracker.h"
25 #include "AliHLTTPCCAMath.h"
26 #include "AliHLTTPCCAClusterData.h"
27
28 #ifdef HLTCA_STANDALONE
29 #include <omp.h>
30 #endif
31
32 int AliHLTTPCCATrackerFramework::InitGPU(int sliceCount, int forceDeviceID)
33 {
34         //Initialize GPU Tracker and determine if GPU available
35         int retVal;
36         if (fGPUTrackerAvailable && (retVal = ExitGPU())) return(retVal);
37         retVal = fGPUTracker.InitGPU(sliceCount, forceDeviceID);
38         fUseGPUTracker = fGPUTrackerAvailable = retVal == 0;
39         fGPUSliceCount = sliceCount;
40         return(retVal);
41 }
42
43 int AliHLTTPCCATrackerFramework::ExitGPU()
44 {
45         //Uninitialize GPU Tracker
46         if (!fGPUTrackerAvailable) return(0);
47         fUseGPUTracker = false;
48         fGPUTrackerAvailable = false;
49         return(fGPUTracker.ExitGPU());
50 }
51
52 void AliHLTTPCCATrackerFramework::SetGPUDebugLevel(int Level, std::ostream *OutFile, std::ostream *GPUOutFile)
53 {
54         //Set Debug Level for GPU Tracker and also for CPU Tracker for comparison reasons
55         fGPUTracker.SetDebugLevel(Level, GPUOutFile);
56         fGPUDebugLevel = Level;
57         for (int i = 0;i < fgkNSlices;i++)
58         {
59                 fCPUTrackers[i].SetGPUDebugLevel(Level, OutFile);
60         }
61 }
62
63 int AliHLTTPCCATrackerFramework::SetGPUTracker(bool enable)
64 {
65         //Enable / disable GPU Tracker
66         if (enable && !fGPUTrackerAvailable)
67         {
68                 fUseGPUTracker = false;
69                 return(1);
70         }
71         fUseGPUTracker = enable;
72         return(0);
73 }
74
75 GPUhd() void AliHLTTPCCATrackerFramework::SetOutputControl( AliHLTTPCCASliceOutput::outputControlStruct* val)
76 {
77         fOutputControl = val;
78         fGPUTracker.SetOutputControl(val);
79         for (int i = 0;i < fgkNSlices;i++)
80         {
81                 fCPUTrackers[i].SetOutputControl(val);
82         }
83 }
84
85 int AliHLTTPCCATrackerFramework::ProcessSlices(int firstSlice, int sliceCount, AliHLTTPCCAClusterData* pClusterData, AliHLTTPCCASliceOutput** pOutput)
86 {
87         //Process sliceCount slices starting from firstslice, in is pClusterData array, out pOutput array
88         if (fUseGPUTracker)
89         {
90                 if (fGPUTracker.Reconstruct(pOutput, pClusterData, firstSlice, CAMath::Min(sliceCount, fgkNSlices - firstSlice))) return(1);
91         }
92         else
93         {
94 #ifdef HLTCA_STANDALONE
95                 if (fOutputControl->fOutputPtr && omp_get_max_threads() > 1)
96                 {
97                         printf("fOutputPtr must not be used with OpenMP\n");
98                         return(1);
99                 }
100
101 #pragma omp parallel for
102 #endif
103                 for (int iSlice = 0;iSlice < CAMath::Min(sliceCount, fgkNSlices - firstSlice);iSlice++)
104                 {
105                         fCPUTrackers[firstSlice + iSlice].ReadEvent(&pClusterData[iSlice]);
106                         fCPUTrackers[firstSlice + iSlice].SetOutput(&pOutput[iSlice]);
107                         fCPUTrackers[firstSlice + iSlice].Reconstruct();
108                         fCPUTrackers[firstSlice + iSlice].SetupCommonMemory();
109                 }
110         }
111         
112         if (fGPUDebugLevel >= 6 && fUseGPUTracker)
113         {
114             fUseGPUTracker = 0;
115             ProcessSlices(firstSlice, sliceCount, pClusterData, pOutput);
116             fUseGPUTracker = 1;
117         }
118
119         //printf("Slice Tracks Output: %d\n", pOutput[0].NTracks());
120         return(0);
121 }
122
123 unsigned long long int* AliHLTTPCCATrackerFramework::PerfTimer(int GPU, int iSlice, int iTimer)
124 {
125         //Performance information for slice trackers
126         return(GPU ? fGPUTracker.PerfTimer(iSlice, iTimer) : fCPUTrackers[iSlice].PerfTimer(iTimer));
127 }
128
129 int AliHLTTPCCATrackerFramework::InitializeSliceParam(int iSlice, AliHLTTPCCAParam &param)
130 {
131         //Initialize Tracker Parameters for a slice
132         if (fGPUTrackerAvailable && fGPUTracker.InitializeSliceParam(iSlice, param)) return(1);
133         fCPUTrackers[iSlice].Initialize(param);
134         return(0);
135 }