Various improvements
[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliForwardCorrectionManager.h
1 //
2 // Manager (singleton) of corrections 
3 // 
4 #ifndef ALIFORWARDCORRECTIONMANAGER_H
5 #define ALIFORWARDCORRECTIONMANAGER_H
6 #include <TObject.h>
7 #include "AliFMDCorrELossFit.h"
8 #include "AliFMDCorrSecondaryMap.h"
9 #include "AliFMDCorrDoubleHit.h"
10 #include "AliFMDCorrVertexBias.h"
11 #include "AliFMDCorrMergingEfficiency.h"
12 #include "AliFMDCorrAcceptance.h"
13 #include <TString.h>
14 class TFile;
15
16 /**
17  * Manager (singleton) of corrections 
18  * 
19  * @ingroup pwg2_forward_corr 
20  */
21 class AliForwardCorrectionManager : public TObject
22 {
23 public:
24   /**
25    * Enumeration of things that can be read in 
26    */
27   enum ECorrection { 
28     kSecondaryMap              = 0x01, 
29     kELossFits                 = 0x02, 
30     kVertexBias                = 0x04, 
31     kMergingEfficiency         = 0x08,
32     kDoubleHit                 = 0x10,
33     kAcceptance                = 0x20,
34     kAll                       = (kSecondaryMap| 
35                                   kELossFits|
36                                   kVertexBias|
37                                   kMergingEfficiency|
38                                   kDoubleHit|
39                                   kAcceptance)
40   };
41   /** 
42    * Access to the singleton object 
43    * 
44    * @return Reference to the singleton object 
45    */
46   static AliForwardCorrectionManager& Instance();
47   /** 
48    *
49    * @param prefix Prefix to correction objects. 
50    */
51   void SetPrefix(const char* prefix);
52   void SetFileDir(ECorrection what, const char* dirname);
53   void SetSecondaryMapPath(const char* d) { SetFileDir(kSecondaryMap, d); }
54   void SetDoubleHitPath(const char* d)    { SetFileDir(kDoubleHit, d); }
55   void SetELossFitsPath(const char* d)    { SetFileDir(kELossFits, d); }
56   void SetVertexBiasPath(const char* d)   { SetFileDir(kVertexBias, d); }
57   void SetMergingEffPath(const char* d)   { SetFileDir(kMergingEfficiency, d); }
58   void SetAcceptancePath(const char* d)   { SetFileDir(kAcceptance, d); }
59   /** 
60    * Read in corrections based on the parameters given 
61    * 
62    * @param collisionSystem Collision system
63    * @param cmsNN           Center of mass energy per nuclean pair [GeV]
64    * @param field           Magnetic field setting [kG]
65    * @param mc              Monte-carlo switch
66    * @param what            What to read in. 
67    * @param force           Force (re-)reading of specified things
68    * 
69    * @return 
70    */
71   Bool_t Init(UShort_t collisionSystem, 
72               UShort_t cmsNN, 
73               Short_t  field, 
74               Bool_t   mc=false,
75               UInt_t   what=kAll,
76               Bool_t   force=false);
77   /** 
78    * Read in correction based on passed parameters
79    * 
80    * @param collisionSystem Collision system string 
81    * @param cmsNN           Center of mass energy per nucleon pair [GeV]
82    * @param field           Magnetic field [kG]
83    * @param mc              Monte-carlo switch
84    * @param what            What to read in 
85    * @param force           Force (re-)reading of specified things
86    * 
87    * @return true on success
88    */
89   Bool_t Init(const char* collisionSystem, 
90               Float_t     cmsNN, 
91               Float_t     field, 
92               Bool_t      mc=false,
93               UInt_t      what=kAll,
94               Bool_t      force=false);
95   /** 
96    * Get the eta axis 
97    * 
98    * @return Eta axis or null
99    */
100   const TAxis* GetEtaAxis() const;
101   /** 
102    * Get the vertex axis 
103    * 
104    * @return The vertex axis or null
105    */
106   const TAxis* GetVertexAxis() const;
107   /** 
108    * Get the energy loss fit correction object. 
109    * 
110    * @return Get the energy loss fits corrections object or null pointer
111    */
112   AliFMDCorrELossFit* GetELossFit() const { return fELossFit; }
113   /** 
114    * Get the secondary correction map
115    * 
116    * @return Get the secondary correction map object or null
117    */
118   AliFMDCorrSecondaryMap* GetSecondaryMap() const { return fSecondaryMap; }
119   /** 
120    * Get the double hit correction object
121    * 
122    * @return Get the double hit correction object or null 
123    */
124   AliFMDCorrDoubleHit* GetDoubleHit() const { return fDoubleHit; }
125   /** 
126    * Get the vertex bias correction object
127    * 
128    * @return Get the vertex bias correction object or null 
129    */
130   AliFMDCorrVertexBias* GetVertexBias() const { return fVertexBias; }
131   /** 
132    * Get the merging efficiency 
133    * 
134    * 
135    * @return Get the vertex efficiency correction 
136    */
137   AliFMDCorrMergingEfficiency* GetMergingEfficiency() const 
138   {
139     return fMergingEfficiency;
140   }
141   /** 
142    * Get the acceptance correction due to dead channels 
143    * 
144    * 
145    * @return Acceptance correction due to dead channels 
146    */
147   AliFMDCorrAcceptance* GetAcceptance() const { return fAcceptance; }
148   /** 
149    * @{ 
150    * @name Path, file, and object access utilities 
151    */
152   /** 
153    * Get the path to the specified object 
154    *
155    * @param what  Which stuff to get the path for 
156    * @param sys   Collision system
157    * @param sNN   Center of mass energy [GeV]
158    * @param field Magnetic field in the L3 magnet [kG]
159    * @param mc    Whether the correction objects should be valid for MC
160    * 
161    * @return The file name (sans directory) or null 
162    */
163   TString GetFileName(ECorrection what, 
164                       UShort_t    sys, 
165                       UShort_t    sNN, 
166                       Short_t     field,
167                       Bool_t      mc) const;
168   /** 
169    * Get the file name of the specified object
170    * 
171    * @param what Which stuff to get the path for 
172    * 
173    * @return The file name (sans directory) or null
174    */
175   TString GetFileName(ECorrection what) const;
176   /** 
177    * Get the path to the specified object 
178    *
179    * @param what  Which stuff to get the path for 
180    * 
181    * @return The files directory full path or null 
182    */
183   const Char_t* GetFileDir(ECorrection what) const;
184   /** 
185    * Get the path to the specified object 
186    *
187    * @param what  Which stuff to get the path for 
188    * @param sys   Collision system
189    * @param sNN   Center of mass energy [GeV]
190    * @param field Magnetic field in the L3 magnet [kG]
191    * @param mc    Whether the correction objects should be valid for MC
192    * 
193    * @return The full path or null 
194    */
195   TString GetFilePath(ECorrection what, 
196                       UShort_t    sys, 
197                       UShort_t    sNN, 
198                       Short_t     field,
199                       Bool_t      mc) const;
200   /** 
201    * Get the full path to the object.  Note, the manager must be
202    * initialised for this to work
203    * 
204    * @param what Which stuff to get the path for 
205    * 
206    * @return The full path or null
207    */
208   TString GetFilePath(ECorrection what) const;
209   /** 
210    * Open the file that contains the correction object specified 
211    * 
212    * @param what  Which stuff to get the path for 
213    * @param sys   Collision system
214    * @param sNN   Center of mass energy [GeV]
215    * @param field Magnetic field in the L3 magnet [kG]
216    * @param mc    Whether the correction objects should be valid for MC
217    * @param rw    Whether to open the file in read/write
218    * @param newfile Wheter to make the file if it doesn't exist
219    * 
220    * @return The file that contains the correction object or null 
221    */
222   TFile* GetFile(ECorrection what, 
223                  UShort_t    sys, 
224                  UShort_t    sNN, 
225                  Short_t     field,
226                  Bool_t      mc=false, 
227                  Bool_t      rw=false, 
228                  Bool_t      newfile=false) const;
229   /** 
230    * Get the file that contains the object specifed.  Note, the manager
231    * must be initialised for this to work. 
232    * 
233    * @param what Which stuff to get the path for 
234    * 
235    * @return The file that contains the correction object or null
236    */
237   TFile* GetFile(ECorrection what) const;
238   /** 
239    * Get the object name corresponding to correction type 
240    * 
241    * @param what Correction 
242    * 
243    * @return Object name or null
244    */
245   const Char_t* GetObjectName(ECorrection what) const;
246   /** 
247    * Check if the specified objet exists in the file, and return it
248    * 
249    * @param file File to query 
250    * @param what Correction type 
251    * 
252    * @return Object found, or null
253    */
254   TObject* CheckObject(TFile* file,  ECorrection what) const;
255   /** 
256    * Get the path to the specified object 
257    *
258    * @param what  Which stuff to get the path for 
259    * @param sys   Collision system
260    * @param sNN   Center of mass energy [GeV]
261    * @param field Magnetic field in the L3 magnet [kG]
262    * @param mc    Whether the correction objects should be valid for MC
263    * 
264    * @return The full path or null 
265    */
266   TObject* GetObject(ECorrection what, 
267                      UShort_t    sys, 
268                      UShort_t    sNN, 
269                      Short_t     field,
270                      Bool_t      mc) const;
271   /** 
272    * Get the object that contaisn the specified correction
273    * 
274    * @param what Which object to get
275    * 
276    * @return The object or null
277    */
278   TObject* GetObject(ECorrection what) const;
279   /* 
280    * @} 
281    */
282 private:
283   /** 
284    * Default constructor 
285    */
286   AliForwardCorrectionManager();
287   /** 
288    * Copy constructor 
289    * 
290    * @param o Object to copy from 
291    */
292   AliForwardCorrectionManager(const AliForwardCorrectionManager& o);
293   /** 
294    * Assignment operator 
295    * 
296    * @param o Object to assign from 
297    * 
298    * @return Reference to this object 
299    */
300   AliForwardCorrectionManager& operator=(const AliForwardCorrectionManager& o);
301   /** 
302    * @{ 
303    * @name Read in corrections 
304    */
305   /** 
306    * Read in the secondary map 
307    * 
308    * @param sys   Collision system
309    * @param sNN   Center of mass energy [GeV]
310    * @param field Magnetic field in the L3 magnet [kG]
311    * 
312    * @return True on success, false otherwise 
313    */
314   Bool_t ReadSecondaryMap(UShort_t sys, UShort_t sNN, Short_t field);
315   /** 
316    * Read in the double hit correction
317    * 
318    * @param sys   Collision system
319    * @param sNN   Center of mass energy [GeV]
320    * @param field Magnetic field in the L3 magnet [kG]
321    * 
322    * @return True on success, false otherwise 
323    */
324   Bool_t ReadDoubleHit(UShort_t sys, UShort_t sNN, Short_t field);
325   /** 
326    * Read in the energy loss fits 
327    * 
328    * @param sys   Collision system
329    * @param sNN   Center of mass energy [GeV]
330    * @param field Magnetic field in the L3 magnet [kG]
331    * @param mc    Whether the correction objects should be valid for MC
332    * 
333    * @return True on success, false otherwise 
334    */
335   Bool_t ReadELossFits(UShort_t sys, UShort_t sNN, Short_t field, Bool_t mc);
336   /** 
337    * Read in the event selection efficiency 
338    * 
339    * @param sys   Collision system
340    * @param sNN   Center of mass energy [GeV]
341    * @param field Magnetic field in the L3 magnet [kG]
342    * 
343    * @return True on success, false otherwise 
344    */
345   Bool_t ReadVertexBias(UShort_t sys, UShort_t sNN, Short_t field);
346   /** 
347    * Read in the merging efficiency 
348    * 
349    * @param sys   Collision system
350    * @param sNN   Center of mass energy [GeV]
351    * @param field Magnetic field in the L3 magnet [kG]
352    * 
353    * @return True on success, false otherwise 
354    */
355   Bool_t ReadMergingEfficiency(UShort_t sys, UShort_t sNN, Short_t field);
356   /** 
357    * Read in the acceptance correction due to dead-channels 
358    * 
359    * @param sys   Collision system                    
360    * @param sNN   Center of mass energy [GeV]         
361    * @param field Magnetic field in the L3 magnet [kG]
362    * 
363    * @return True on success, false otherwise 
364    */
365   Bool_t ReadAcceptance(UShort_t sys, UShort_t sNN, Short_t field);
366   /* 
367    * @} 
368    */
369   
370   /** Static singleton instance */
371   static AliForwardCorrectionManager* fgInstance;
372   Bool_t    fInit;  // whether we have been initialised 
373   UShort_t  fSys;   // Collision System
374   UShort_t  fSNN;   // Collision energy per nucleon (GeV)
375   Short_t   fField; // L3 magnetic field (kG)
376   
377   /** 
378    * @{
379    * @name Paths 
380    */ 
381   TString fELossFitsPath;    // Path to energy loss fit correction 
382   TString fMergingEffPath;   // Path to sharing efficiency correction 
383   TString fSecondaryMapPath; // Path to secondary efficiency correction
384   TString fDoubleHitPath;    // Path to double hit correction
385   TString fVertexBiasPath;   // Path to event selection efficiency correction
386   TString fAcceptancePath;   // Path to acceptance correction from dead areas
387   /* 
388    * @}
389    */
390   /** 
391    * @{ 
392    * @name Object name 
393    */
394   static const Char_t* fgkSecondaryMapSkel;  // Name of correction object 
395   static const Char_t* fgkDoubleHitSkel;     // Name of correction object 
396   static const Char_t* fgkELossFitsSkel;     // Name of correction object 
397   static const Char_t* fgkVertexBiasSkel;    // Name of correction object 
398   static const Char_t* fgkMergingEffSkel;    // Name of correction object 
399   static const Char_t* fgkAcceptanceSkel;    // Name of correction object 
400   /* 
401    * @} 
402    */
403   /** 
404    * @{ 
405    * @name Correction objects 
406    */
407   AliFMDCorrELossFit*          fELossFit;     // Energy loss fits 
408   AliFMDCorrSecondaryMap*      fSecondaryMap; // Secondary particle correction
409   AliFMDCorrDoubleHit*         fDoubleHit;    // Double hit corr. (low flux)
410   AliFMDCorrVertexBias*        fVertexBias;   // Vertex bias correction
411   AliFMDCorrMergingEfficiency* fMergingEfficiency; // Merging eff. 
412   AliFMDCorrAcceptance*        fAcceptance;   // Acceptance corr. 
413   /* 
414    * @}
415    */
416
417   ClassDef(AliForwardCorrectionManager,1) // Manager of corrections 
418 };
419 //____________________________________________________________________
420 inline const TAxis* 
421 AliForwardCorrectionManager::GetEtaAxis() const
422 {
423   if (!fSecondaryMap) return 0;
424   return &(fSecondaryMap->GetEtaAxis());
425 }
426 //____________________________________________________________________
427 inline const TAxis* 
428 AliForwardCorrectionManager::GetVertexAxis() const
429 {
430   if (!fSecondaryMap) return 0;
431   return &(fSecondaryMap->GetVertexAxis());
432 }
433
434 #endif
435 // Local Variables:
436 //   mode: C++ 
437 // End: 
438