Various fixes to deal with centrality
[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliFMDEventInspector.cxx
1 // 
2 // This class inspects the event 
3 //
4 // Input:
5 //   - AliESDFMD object possibly corrected for sharing
6 //
7 // Output:
8 //   - A histogram of v_z of events with triggers. 
9 //   - A histogram of v_z of events with vertex and triggers 
10 //   - A histogram of trigger counters 
11 // 
12 // Note, that these are added to the master output list 
13 //
14 // Corrections used: 
15 //   - None
16 //
17 #include "AliFMDEventInspector.h"
18 #include "AliLog.h"
19 #include "AliESDEvent.h"
20 #include "AliMultiplicity.h"
21 #include "AliAnalysisManager.h"
22 #include "AliInputEventHandler.h"
23 #include "AliTriggerAnalysis.h"
24 #include "AliPhysicsSelection.h"
25 #include "AliAODForwardMult.h"
26 #include "AliForwardUtil.h"
27 #include "AliCentrality.h"
28 #include <TH1.h>
29 #include <TList.h>
30 #include <TDirectory.h>
31 #include <TROOT.h>
32 #include <iostream>
33 #include <iomanip>
34
35 //====================================================================
36 AliFMDEventInspector::AliFMDEventInspector()
37   : TNamed(),
38     fHEventsTr(0), 
39     fHEventsTrVtx(0),
40     fHTriggers(0),
41     fHType(0),
42     fHWords(0),
43     fHCent(0),
44     fHCentVsQual(0),
45     fLowFluxCut(1000),
46     fMaxVzErr(0.2),
47     fList(0),
48     fEnergy(0),
49     fField(999), 
50     fCollisionSystem(kUnknown),
51     fDebug(0),
52     fCentAxis(0)
53 {
54   // 
55   // Constructor 
56   //
57 }
58
59 //____________________________________________________________________
60 AliFMDEventInspector::AliFMDEventInspector(const char* name)
61   : TNamed("fmdEventInspector", name),
62     fHEventsTr(0), 
63     fHEventsTrVtx(0), 
64     fHTriggers(0),
65     fHType(0),
66     fHWords(0),
67     fHCent(0),
68     fHCentVsQual(0),
69     fLowFluxCut(1000),
70     fMaxVzErr(0.2),
71     fList(0),
72     fEnergy(0),
73     fField(999), 
74     fCollisionSystem(kUnknown),
75     fDebug(0),
76     fCentAxis(0)
77 {
78   // 
79   // Constructor 
80   // 
81   // Parameters:
82   //   name Name of object
83   //
84 }
85
86 //____________________________________________________________________
87 AliFMDEventInspector::AliFMDEventInspector(const AliFMDEventInspector& o)
88   : TNamed(o), 
89     fHEventsTr(o.fHEventsTr), 
90     fHEventsTrVtx(o.fHEventsTrVtx), 
91     fHTriggers(o.fHTriggers),
92     fHType(o.fHType),
93     fHWords(o.fHWords),
94     fHCent(o.fHCent),
95     fHCentVsQual(o.fHCentVsQual),
96     fLowFluxCut(o.fLowFluxCut),
97     fMaxVzErr(o.fMaxVzErr),
98     fList(o.fList),
99     fEnergy(o.fEnergy),
100     fField(o.fField), 
101     fCollisionSystem(o.fCollisionSystem),
102     fDebug(0),
103     fCentAxis(0)
104 {
105   // 
106   // Copy constructor 
107   // 
108   // Parameters:
109   //   o Object to copy from 
110   //
111 }
112
113 //____________________________________________________________________
114 AliFMDEventInspector::~AliFMDEventInspector()
115 {
116   // 
117   // Destructor 
118   //
119   if (fList)         delete fList;
120 }
121 //____________________________________________________________________
122 AliFMDEventInspector&
123 AliFMDEventInspector::operator=(const AliFMDEventInspector& o)
124 {
125   // 
126   // Assignement operator
127   // 
128   // Parameters:
129   //   o Object to assign from 
130   // 
131   // Return:
132   //    Reference to this object
133   //
134   TNamed::operator=(o);
135   fHEventsTr         = o.fHEventsTr;
136   fHEventsTrVtx      = o.fHEventsTrVtx;
137   fHTriggers         = o.fHTriggers;
138   fHType             = o.fHType;
139   fHWords            = o.fHWords;
140   fHCent             = o.fHCent;
141   fHCentVsQual       = o.fHCentVsQual;
142   fLowFluxCut        = o.fLowFluxCut;
143   fMaxVzErr          = o.fMaxVzErr;
144   fDebug             = o.fDebug;
145   fList              = (o.fList ? new TList : 0);
146   fEnergy            = o.fEnergy;
147   fField             = o.fField;
148   fCollisionSystem   = o.fCollisionSystem;
149   if (fList) { 
150     fList->SetName(GetName());
151     if (fHEventsTr)    fList->Add(fHEventsTr);
152     if (fHEventsTrVtx) fList->Add(fHEventsTrVtx);
153     if (fHTriggers)    fList->Add(fHTriggers);
154     if (fHType)        fList->Add(fHType);
155     if (fHWords)       fList->Add(fHWords);
156     if (fHCent)        fList->Add(fHCent);
157     if (fHCentVsQual)  fList->Add(fHCentVsQual);
158   }
159   return *this;
160 }
161
162 //____________________________________________________________________
163 Bool_t
164 AliFMDEventInspector::FetchHistograms(const TList* d, 
165                                       TH1I*& hEventsTr, 
166                                       TH1I*& hEventsTrVtx, 
167                                       TH1I*& hTriggers) const
168 {
169   // 
170   // Fetch our histograms from the passed list 
171   // 
172   // Parameters:
173   //   d             Input
174   //   hEventsTr     On return, pointer to histogram, or null
175   //   hEventsTrVtx  On return, pointer to histogram, or null
176   //   hTriggers     On return, pointer to histogram, or null
177   // 
178   // Return:
179   //    true on success, false otherwise 
180   //
181   hEventsTr    = 0;
182   hEventsTrVtx = 0;
183   hTriggers    = 0;
184   TList* dd    = dynamic_cast<TList*>(d->FindObject(GetName()));
185   if (!dd) return kFALSE;
186   
187   hEventsTr    = dynamic_cast<TH1I*>(dd->FindObject("nEventsTr"));
188   hEventsTrVtx = dynamic_cast<TH1I*>(dd->FindObject("nEventsTrVtx"));
189   hTriggers    = dynamic_cast<TH1I*>(dd->FindObject("triggers"));
190
191   if (!hEventsTr || !hEventsTrVtx || !hTriggers) return kFALSE;
192   return kTRUE;
193 }
194 //____________________________________________________________________
195 void
196 AliFMDEventInspector::Init(const TAxis& vtxAxis)
197 {
198   // 
199   // Initialize the object 
200   // 
201   // Parameters:
202   //   vtxAxis Vertex axis in use 
203   //
204   
205   // -1.5 -0.5 0.5 1.5 ... 89.5 ... 100.5
206   // ----- 92 number --------- ---- 1 ---
207   TArrayD limits(93);
208   for (Int_t i = 0; i < 92; i++) limits[i] = -1.5 + i;
209   
210   fCentAxis  = new TAxis(limits.GetSize()-1, limits.GetArray());
211   fHEventsTr = new TH1I("nEventsTr", "Number of events w/trigger", 
212                         vtxAxis.GetNbins(), 
213                         vtxAxis.GetXmin(), 
214                         vtxAxis.GetXmax());
215   fHEventsTr->SetXTitle("v_{z} [cm]");
216   fHEventsTr->SetYTitle("# of events");
217   fHEventsTr->SetFillColor(kRed+1);
218   fHEventsTr->SetFillStyle(3001);
219   fHEventsTr->SetDirectory(0);
220   // fHEventsTr->Sumw2();
221   fList->Add(fHEventsTr);
222
223   fHEventsTrVtx = new TH1I("nEventsTrVtx", 
224                            "Number of events w/trigger and vertex", 
225                            vtxAxis.GetNbins(), 
226                            vtxAxis.GetXmin(), 
227                            vtxAxis.GetXmax());
228   fHEventsTrVtx->SetXTitle("v_{z} [cm]");
229   fHEventsTrVtx->SetYTitle("# of events");
230   fHEventsTrVtx->SetFillColor(kBlue+1);
231   fHEventsTrVtx->SetFillStyle(3001);
232   fHEventsTrVtx->SetDirectory(0);
233   // fHEventsTrVtx->Sumw2();
234   fList->Add(fHEventsTrVtx);
235
236       
237   fHTriggers = new TH1I("triggers", "Triggers", 10, 0, 10);
238   fHTriggers->SetFillColor(kRed+1);
239   fHTriggers->SetFillStyle(3001);
240   fHTriggers->SetStats(0);
241   fHTriggers->SetDirectory(0);
242   fHTriggers->GetXaxis()->SetBinLabel(kInel   +1,"INEL");
243   fHTriggers->GetXaxis()->SetBinLabel(kInelGt0+1,"INEL>0");
244   fHTriggers->GetXaxis()->SetBinLabel(kNSD    +1,"NSD");
245   fHTriggers->GetXaxis()->SetBinLabel(kEmpty  +1,"Empty");
246   fHTriggers->GetXaxis()->SetBinLabel(kA      +1,"A");
247   fHTriggers->GetXaxis()->SetBinLabel(kB      +1,"B");
248   fHTriggers->GetXaxis()->SetBinLabel(kC      +1,"C");
249   fHTriggers->GetXaxis()->SetBinLabel(kE      +1,"E");
250   fHTriggers->GetXaxis()->SetBinLabel(kPileUp +1,"Pileup");
251   fHTriggers->GetXaxis()->SetBinLabel(kMCNSD  +1,"nsd");
252   fList->Add(fHTriggers);
253
254   fHType = new TH1I("type", Form("Event type (cut: SPD mult>%d)", 
255                                  fLowFluxCut), 2, -.5, 1.5);
256   fHType->SetFillColor(kRed+1);
257   fHType->SetFillStyle(3001);
258   fHType->SetStats(0);
259   fHType->SetDirectory(0);
260   fHType->GetXaxis()->SetBinLabel(1,"Low-flux");
261   fHType->GetXaxis()->SetBinLabel(2,"High-flux");
262   fList->Add(fHType);
263
264
265   fHWords = new TH1I("words", "Trigger words seen", 1, 0, 0); 
266   fHWords->SetFillColor(kBlue+1);
267   fHWords->SetFillStyle(3001);
268   fHWords->SetStats(0);
269   fHWords->SetDirectory(0);
270   fHWords->SetBit(TH1::kCanRebin);
271   fList->Add(fHWords);
272
273   fHCent = new TH1F("cent", "Centrality", limits.GetSize()-1,limits.GetArray());
274   fHCent->SetFillColor(kBlue+1);
275   fHCent->SetFillStyle(3001);
276   fHCent->SetStats(0);
277   fHCent->SetDirectory(0);
278   fHCent->SetXTitle("Centrality [%]");
279   fHCent->SetYTitle("Events");
280   fList->Add(fHCent);
281
282   fHCentVsQual = new TH2F("centVsQuality", "Quality vs Centrality", 
283                           5, 0, 5, limits.GetSize()-1, limits.GetArray());
284   fHCentVsQual->SetXTitle("Quality");
285   fHCentVsQual->SetYTitle("Centrality [%]");
286   fHCentVsQual->SetZTitle("Events");
287   fHCentVsQual->GetXaxis()->SetBinLabel(1, "OK");
288   fHCentVsQual->GetXaxis()->SetBinLabel(2, "Outside v_{z} cut");
289   fHCentVsQual->GetXaxis()->SetBinLabel(3, "V0 vs SPD outlier");
290   fHCentVsQual->GetXaxis()->SetBinLabel(4, "V0 vs TPC outlier");
291   fHCentVsQual->GetXaxis()->SetBinLabel(5, "V0 vs ZDC outlier");
292   fList->Add(fHCentVsQual);
293 }
294
295 //____________________________________________________________________
296 void
297 AliFMDEventInspector::DefineOutput(TList* dir)
298 {
299   // 
300   // Define the output histograms.  These are put in a sub list of the
301   // passed list.   The histograms are merged before the parent task calls 
302   // AliAnalysisTaskSE::Terminate 
303   // 
304   //   dir Directory to add to 
305   //
306   fList = new TList;
307   fList->SetName(GetName());
308   dir->Add(fList);
309 }
310
311 //____________________________________________________________________
312 UInt_t
313 AliFMDEventInspector::Process(const AliESDEvent* event, 
314                               UInt_t&            triggers,
315                               Bool_t&            lowFlux,
316                               UShort_t&          ivz, 
317                               Double_t&          vz,
318                               Double_t&          cent)
319 {
320   // 
321   // Process the event 
322   // 
323   // Parameters:
324   //   event     Input event 
325   //   triggers  On return, the triggers fired 
326   //   lowFlux   On return, true if the event is considered a low-flux 
327   //                  event (according to the setting of fLowFluxCut) 
328   //   ivz       On return, the found vertex bin (1-based).  A zero
329   //                  means outside of the defined vertex range
330   //   vz        On return, the z position of the interaction
331   //   cent      On return, the centrality - if not available < 0
332   // 
333   // Return:
334   //    0 (or kOk) on success, otherwise a bit mask of error codes 
335   //
336
337   // --- Check that we have an event ---------------------------------
338   if (!event) { 
339     AliWarning("No ESD event found for input event");
340     return kNoEvent;
341   }
342
343   // --- Read trigger information from the ESD and store in AOD object
344   if (!ReadTriggers(event, triggers)) { 
345     if (fDebug > 2) {
346       AliWarning("Failed to read triggers from ESD"); }
347     return kNoTriggers;
348   }
349
350   // --- Check if this is a high-flux event --------------------------
351   const AliMultiplicity* testmult = event->GetMultiplicity();
352   if (!testmult) {
353     if (fDebug > 3) {
354       AliWarning("No central multiplicity object found"); }
355   }
356   else 
357     lowFlux = testmult->GetNumberOfTracklets() < fLowFluxCut;
358
359   fHType->Fill(lowFlux ? 0 : 1);
360   
361   // --- Read centrality information 
362   cent          = -10;
363   UShort_t qual = 0;
364   if (!ReadCentrality(event, cent, qual)) {
365     if (fDebug > 3) 
366       AliWarning("Failed to get centrality");
367   }
368   fHCent->Fill(cent);
369   if (qual == 0) fHCentVsQual->Fill(0., cent);
370   else { 
371     for (UShort_t i = 0; i < 4; i++) 
372       if (qual & (1 << i)) fHCentVsQual->Fill(Double_t(i+1), cent);
373   }
374
375   // --- Get the vertex information ----------------------------------
376   vz          = 0;
377   Bool_t vzOk = ReadVertex(event, vz);
378
379   fHEventsTr->Fill(vz);
380   if (!vzOk) { 
381     if (fDebug > 3) {
382       AliWarning("Failed to read vertex from ESD"); }
383     return kNoVertex;
384   }
385   fHEventsTrVtx->Fill(vz);
386
387   // --- Get the vertex bin ------------------------------------------
388   ivz = fHEventsTr->GetXaxis()->FindBin(vz);
389   if (ivz <= 0 || ivz > fHEventsTr->GetXaxis()->GetNbins()) { 
390     if (fDebug > 3) {
391       AliWarning(Form("Vertex @ %f outside of range [%f,%f]", 
392                       vz, fHEventsTr->GetXaxis()->GetXmin(), 
393                       fHEventsTr->GetXaxis()->GetXmax())); }
394     ivz = 0;
395     return kBadVertex;
396   }
397   
398   // --- Check the FMD ESD data --------------------------------------
399   if (!event->GetFMDData()) { 
400     if (fDebug > 3) {
401       AliWarning("No FMD data found in ESD"); }
402     return kNoFMD;
403   }
404
405   
406   return kOk;
407 }
408
409 //____________________________________________________________________
410 Bool_t
411 AliFMDEventInspector::ReadCentrality(const AliESDEvent* esd, 
412                                      Double_t& cent, 
413                                      UShort_t& qual) const
414 {
415   // 
416   // Read centrality from event 
417   // 
418   // Parameters:
419   //    esd  Event 
420   //    cent On return, the centrality or negative if not found
421   // 
422   // Return:
423   //    False on error, true otherwise 
424   //
425   cent = -1;
426   qual = 0;
427   AliCentrality* centObj = const_cast<AliESDEvent*>(esd)->GetCentrality();
428   if (!centObj)  return true;
429
430   // AliInfo(Form("Got centrality object %p with quality %d", 
431   //              centObj, centObj->GetQuality()));
432   // centObj->Print();
433   cent = centObj->GetCentralityPercentile("V0M");  
434   qual = centObj->GetQuality();
435
436   return true;
437 }
438
439 //____________________________________________________________________
440 Bool_t
441 AliFMDEventInspector::ReadTriggers(const AliESDEvent* esd, UInt_t& triggers)
442 {
443   // 
444   // Read the trigger information from the ESD event 
445   // 
446   // Parameters:
447   //   esd        ESD event 
448   //   triggers   On return, contains the trigger bits 
449   // 
450   // Return:
451   //    @c true on success, @c false otherwise 
452   //
453   triggers = 0;
454
455   // Get the analysis manager - should always be there 
456   AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
457   if (!am) { 
458     AliWarning("No analysis manager defined!");
459     return kFALSE;
460   }
461
462   // Get the input handler - should always be there 
463   AliInputEventHandler* ih = 
464     static_cast<AliInputEventHandler*>(am->GetInputEventHandler());
465   if (!ih) { 
466     AliWarning("No input handler");
467     return kFALSE;
468   }
469     
470   // Check if this is a collision candidate (MB)
471   // Note, that we should use the value cached in the input 
472   // handler rather than calling IsCollisionCandiate directly 
473   // on the AliPhysicsSelection obejct.  If we called the latter
474   // then the AliPhysicsSelection object would overcount by a 
475   // factor of 2! :-(
476   Bool_t inel = ih->IsEventSelected();
477   if (inel) { 
478     triggers |= AliAODForwardMult::kInel;
479     fHTriggers->Fill(kInel+0.5);
480   }
481
482   // If this is inel, see if we have a tracklet 
483   if (inel) { 
484     const AliMultiplicity* spdmult = esd->GetMultiplicity();
485     if (!spdmult) {
486       AliWarning("No SPD multiplicity");
487     }
488     else { 
489       // Check if we have one or more tracklets 
490       // in the range -1 < eta < 1 to set the INEL>0 
491       // trigger flag. 
492       Int_t n = spdmult->GetNumberOfTracklets();
493       for (Int_t j = 0; j < n; j++) { 
494         if(TMath::Abs(spdmult->GetEta(j)) < 1) { 
495           triggers |= AliAODForwardMult::kInelGt0;
496           fHTriggers->Fill(kInelGt0+.5);
497           break;
498         }
499       }
500     }
501   }
502
503   // Analyse some trigger stuff 
504   AliTriggerAnalysis ta;
505   if (ta.IsOfflineTriggerFired(esd, AliTriggerAnalysis::kNSD1)) {
506     triggers |= AliAODForwardMult::kNSD;
507     fHTriggers->Fill(kNSD+.5);
508   }
509   //Check pileup
510   Bool_t pileup =  esd->IsPileupFromSPD(3,0.8);
511   if (pileup) {
512     triggers |= AliAODForwardMult::kPileUp;
513     fHTriggers->Fill(kPileUp+.5);
514   }
515     
516   // Get trigger stuff 
517   TString trigStr = esd->GetFiredTriggerClasses();
518   // AliWarning(Form("Fired trigger classes: %s", trigStr.Data()));
519   fHWords->Fill(trigStr.Data(), 1);
520 #if 0
521   if (trigStr.Contains("MB1") || trigStr.Contains("MBBG3"))
522       triggers |= AliAOODForwardMult::kB;
523   if (trigStr.Contains("COTA")) 
524     triggers |= AliAODForwardMult::kA;
525   if (trigStr.Contains("COTC")) 
526     triggers |= AliAODForwardMult::kC;
527 #endif
528   if (trigStr.Contains("CBEAMB-ABCE-NOPF-ALL")) {
529     triggers |= AliAODForwardMult::kEmpty;
530     fHTriggers->Fill(kEmpty+.5);
531   }
532
533   if (trigStr.Contains("CINT1A-ABCE-NOPF-ALL")) {
534     triggers |= AliAODForwardMult::kA;
535     fHTriggers->Fill(kA+.5);
536   }
537
538   if (trigStr.Contains("CINT1B-ABCE-NOPF-ALL")) {
539     triggers |= AliAODForwardMult::kB;
540     fHTriggers->Fill(kB+.5);
541   }
542
543
544   if (trigStr.Contains("CINT1C-ABCE-NOPF-ALL")) {
545     triggers |= AliAODForwardMult::kC;
546     fHTriggers->Fill(kC+.5);
547   }
548
549   if (trigStr.Contains("CINT1-E-NOPF-ALL")) {
550     triggers |= AliAODForwardMult::kE;
551     fHTriggers->Fill(kE+.5);
552   }
553
554   return kTRUE;
555 }
556 //____________________________________________________________________
557 Bool_t
558 AliFMDEventInspector::ReadVertex(const AliESDEvent* esd, Double_t& vz)
559 {
560   // 
561   // Read the vertex information from the ESD event 
562   // 
563   // Parameters:
564   //   esd  ESD event 
565   //   vz   On return, the vertex Z position 
566   // 
567   // Return:
568   //    @c true on success, @c false otherwise 
569   //
570   vz = 0;
571   // Get the vertex 
572   const AliESDVertex* vertex = esd->GetPrimaryVertexSPD();
573   if (!vertex) { 
574     if (fDebug > 2) {
575       AliWarning("No SPD vertex found in ESD"); }
576     return kFALSE;
577   }
578   
579   // Check that enough tracklets contributed 
580   if(vertex->GetNContributors() <= 0) {
581     if (fDebug > 2) {
582       AliWarning(Form("Number of contributors to vertex is %d<=0",
583                       vertex->GetNContributors())); }
584     vz = 0;
585     return kFALSE;
586   }
587
588   // Check that the uncertainty isn't too large 
589   if (vertex->GetZRes() > fMaxVzErr) { 
590     if (fDebug > 2) {
591       AliWarning(Form("Uncertaintity in Z of vertex is too large %f > %f", 
592                       vertex->GetZRes(), fMaxVzErr)); }
593     return kFALSE;
594   }
595
596   // Get the z coordiante 
597   vz = vertex->GetZ();
598   return kTRUE;
599 }
600
601 //____________________________________________________________________
602 Bool_t
603 AliFMDEventInspector::ReadRunDetails(const AliESDEvent* esd)
604 {
605   // 
606   // Read the collision system, collision energy, and L3 field setting
607   // from the ESD
608   // 
609   // Parameters:
610   //   esd ESD to get information from 
611   // 
612   // Return:
613   //    true on success, false 
614   //
615   // AliInfo(Form("Parameters from 1st ESD event: cms=%s, sNN=%f, field=%f",
616   //           esd->GetBeamType(), 2*esd->GetBeamEnergy(), 
617   //           esd->GetMagneticField()));
618   fCollisionSystem = 
619     AliForwardUtil::ParseCollisionSystem(esd->GetBeamType());
620   fEnergy          = 
621     AliForwardUtil::ParseCenterOfMassEnergy(fCollisionSystem,   
622                                               2 * esd->GetBeamEnergy());
623   fField           = 
624     AliForwardUtil::ParseMagneticField(esd->GetMagneticField());
625   
626   if (fCollisionSystem   == AliForwardUtil::kUnknown || 
627       fEnergy            <= 0                        || 
628       TMath::Abs(fField) >  10) 
629     return kFALSE;
630
631   return kTRUE;
632 }
633
634 //____________________________________________________________________
635 void
636 AliFMDEventInspector::Print(Option_t*) const
637 {
638   // 
639   // Print information
640   // 
641   //   option Not used 
642   //
643   char ind[gROOT->GetDirLevel()+1];
644   for (Int_t i = 0; i < gROOT->GetDirLevel(); i++) ind[i] = ' ';
645   ind[gROOT->GetDirLevel()] = '\0';
646   TString sNN(AliForwardUtil::CenterOfMassEnergyString(fEnergy));
647   sNN.Strip(TString::kBoth, '0');
648   sNN.ReplaceAll("GeV", " GeV");
649   TString field(AliForwardUtil::MagneticFieldString(fField));
650   field.ReplaceAll("p",  "+");
651   field.ReplaceAll("m",  "-");
652   field.ReplaceAll("kG", " kG");
653   
654   std::cout << ind << ClassName() << ": " << GetName() << '\n'
655             << ind << " Low flux cut:           " << fLowFluxCut << '\n'
656             << ind << " Max(delta v_z):         " << fMaxVzErr << " cm\n"
657             << ind << " System:                 " 
658             << AliForwardUtil::CollisionSystemString(fCollisionSystem) << '\n'
659             << ind << " CMS energy per nucleon: " << sNN << '\n'
660             << ind << " Field:                  " <<  field << std::endl;
661 }
662
663   
664 //
665 // EOF
666 //
667