[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisStatistics.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/* $Id$ */
// Author: Andrei Gheata, 20/12/2010

//==============================================================================
// AliAnalysisStatistics - basic class for storing statistics for the processed
//   events. The object is mergeable and can be used for general purpose. In case
//   a AliAnalysisTaskStat is used, this will set the global statistics object
//   to the analysis manager and will update it for the accepted events.
//==============================================================================

#include "AliAnalysisStatistics.h"

#include "Riostream.h"
#include "TObjArray.h"
#include "TStopwatch.h"

#include "AliVEvent.h"

using std::cout;
using std::endl;
ClassImp(AliAnalysisStatistics)

//______________________________________________________________________________
AliAnalysisStatistics::AliAnalysisStatistics(const AliAnalysisStatistics &other)
      :TNamed(other),
       fNinput(other.fNinput),
       fNprocessed(other.fNprocessed),
       fNfailed(other.fNfailed),
       fNaccepted(other.fNaccepted),
       fOfflineMask(other.fOfflineMask),
       fMaxTasks(other.fMaxTasks),
       fNtasks(other.fNtasks),
       fCurrentTask(other.fCurrentTask),
       fTaskTimeReal(0),
       fTaskTimeCPU(0),
       fTaskNames(0),
       fTaskTimer(0)
{
// Copy constructor.
  if (fNtasks) {
    fTaskTimer = new TStopwatch();
    fTaskTimeReal = new Double_t[fMaxTasks];
    memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
    memcpy(fTaskTimeReal, other.fTaskTimeReal, fNtasks*sizeof(Double_t));
    fTaskTimeCPU = new Double_t[fMaxTasks];
    memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
    memcpy(fTaskTimeCPU, other.fTaskTimeCPU, fNtasks*sizeof(Double_t));
    fTaskNames = new TObjArray(fMaxTasks);
    for (Int_t i=0; i<fNtasks; i++) fTaskNames->AddAt(new TObjString(other.GetTaskName(i)), i);
  }
}

//______________________________________________________________________________
AliAnalysisStatistics &AliAnalysisStatistics::operator=(const AliAnalysisStatistics &other)
{
// Assignment.
  if (&other == this) return *this;
  fNinput       = other.fNinput;
  fNprocessed   = other.fNprocessed;
  fNfailed      = other.fNfailed;
  fNaccepted    = other.fNaccepted;
  fOfflineMask  = other.fOfflineMask;
  fMaxTasks     = other.fMaxTasks;
  fNtasks       = other.fNtasks;
  fCurrentTask  = other.fCurrentTask;
  fTaskTimeReal = 0;
  fTaskTimeCPU  = 0;
  fTaskNames    = 0;
  fTaskTimer   = 0;
  if (fNtasks) {
    fTaskTimer = new TStopwatch();
    fTaskTimeReal = new Double_t[fMaxTasks];
    memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
    memcpy(fTaskTimeReal, other.fTaskTimeReal, fNtasks*sizeof(Double_t));
    fTaskTimeCPU = new Double_t[fMaxTasks];
    memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
    memcpy(fTaskTimeCPU, other.fTaskTimeCPU, fNtasks*sizeof(Double_t));
    fTaskNames = new TObjArray(fMaxTasks);
    for (Int_t i=0; i<fNtasks; i++) fTaskNames->AddAt(new TObjString(other.GetTaskName(i)), i);
  }  
  return *this;
}

//______________________________________________________________________________
void AliAnalysisStatistics::StartTimer(Int_t itask, const char *name, const char *classname)
{
// Measure the CPU time done by this task in the interval
  if (!fTaskTimer) {
    // Create the arrays with timings with the initial size
    if (!fMaxTasks) fMaxTasks = 100;
    fTaskTimer = new TStopwatch();
    fTaskTimeReal = new Double_t[fMaxTasks];
    memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
    fTaskTimeCPU = new Double_t[fMaxTasks];
    memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
    fTaskNames = new TObjArray(fMaxTasks);
  } else {
  // Stop the timer if it was timing some task
    StopTimer();
  }  
  
  if (fNtasks<itask+1) {
  // Double the array size
    if (itask>=fMaxTasks) {
      Int_t newsize = TMath::Max(2*fMaxTasks, itask+1);
      Double_t *taskTimeReal = new Double_t[newsize];
      memset(taskTimeReal, 0, newsize*sizeof(Double_t));
      memcpy(taskTimeReal, fTaskTimeReal, fMaxTasks*sizeof(Double_t));
      delete [] fTaskTimeReal;
      fTaskTimeReal = taskTimeReal;
      Double_t *taskTimeCPU = new Double_t[newsize];
      memset(taskTimeCPU, 0, newsize*sizeof(Double_t));
      memcpy(taskTimeCPU, fTaskTimeCPU, fMaxTasks*sizeof(Double_t));
      delete [] fTaskTimeCPU;
      fTaskTimeCPU = taskTimeCPU;
      fMaxTasks = newsize;
    }  
    fNtasks = itask+1;
  }
  // Start the timer for the new task
  fCurrentTask = itask;
  if (!fTaskNames->At(fCurrentTask)) {
    TString sname = name;
    if (strlen(classname)) sname += Form("(%s)", classname);
    fTaskNames->AddAt(new TObjString(sname), fCurrentTask);
  }  
  fTaskTimer->Start(kTRUE);  
}   

//______________________________________________________________________________
void AliAnalysisStatistics::StopTimer()
{
// Stop the current task timing.
  if (fCurrentTask>=0) {
    fTaskTimer->Stop();
    fTaskTimeReal[fCurrentTask] += fTaskTimer->RealTime();
    fTaskTimeCPU[fCurrentTask]  += fTaskTimer->CpuTime();
    fCurrentTask = -1;
  }
}  

//______________________________________________________________________________
Long64_t AliAnalysisStatistics::Merge(TCollection* list)
{
// Merge statistics objets from list on top of this.
  TIter next(list);
  AliAnalysisStatistics *current;
  Long64_t count = 1;
  while ((current = (AliAnalysisStatistics*)next())) {
    fNinput     += current->GetNinput();
    fNprocessed += current->GetNprocessed();
    fNfailed    += current->GetNfailed();
    fNaccepted  += current->GetNaccepted();
    for (Int_t i=0; i<fNtasks; i++) {
      fTaskTimeReal[i] += current->GetRealTime(i);
      fTaskTimeCPU[i] += current->GetCPUTime(i);
    }   
  }
  return count;
}

//______________________________________________________________________________
void AliAnalysisStatistics::Print(const Option_t *) const
{
// Print info about the processed statistics.
  cout << "### Input events                 : " << fNinput << endl;
  cout << "### Processed events w/o errors  : " << fNprocessed << endl;
  cout << "### Failed events                : " << fNfailed << endl;
  cout << "### Accepted events for mask: " << GetMaskAsString(fOfflineMask) << ": " << fNaccepted << endl;
  if (fNtasks) {
    cout << "Timing per task:" <<endl;
    TString s;
    for (Int_t i=0; i<fNtasks; i++) {
      s = Form("%03d:  real: %9.2f   cpu: %9.2f   => %s", i,fTaskTimeReal[i], fTaskTimeCPU[i], GetTaskName(i));
      cout << s << endl;
    }
  }  
}

//______________________________________________________________________________
const char *AliAnalysisStatistics::GetMaskAsString(UInt_t mask)
{
// Returns a string corresponding to the offline mask.
   static TString smask;
   smask = "ALL EVT.";
   if (!mask) return smask.Data();
   smask.Clear();
   if (mask & AliVEvent::kMB)   smask = "MB";
   if (mask & AliVEvent::kMUON) {
      if (!smask.IsNull()) smask += " | ";
      smask += "MUON";
   }
   if (mask & AliVEvent::kHighMult) {
      if (!smask.IsNull()) smask += " | ";
      smask += "HighMult";
   }
   if (mask & AliVEvent::kUserDefined) {
      if (!smask.IsNull()) smask += " | ";
      smask += "UserDefined";
   }
   if (mask ==  AliVEvent::kAny) smask = "ANY";
   return smask.Data();
}

//______________________________________________________________________________
const char *AliAnalysisStatistics::GetTaskName(Int_t itask) const
{
// Returns task name
  if (!fTaskNames || !fTaskNames->At(itask)) return 0;
  return fTaskNames->At(itask)->GetName();
}
Commit	Line	Data
f091ecb5	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17	// Author: Andrei Gheata, 20/12/2010
	18
	19	//==============================================================================
	20	// AliAnalysisStatistics - basic class for storing statistics for the processed
	21	// events. The object is mergeable and can be used for general purpose. In case
	22	// a AliAnalysisTaskStat is used, this will set the global statistics object
	23	// to the analysis manager and will update it for the accepted events.
	24	//==============================================================================
	25
	26	#include "AliAnalysisStatistics.h"
	27
	28	#include "Riostream.h"
ed37a9ae	29	#include "TObjArray.h"
ed37a9ae	30	#include "TStopwatch.h"
f091ecb5	31
c3732d79	32	#include "AliVEvent.h"
c3732d79	33
c82bb898	34	using std::cout;
c82bb898	35	using std::endl;
f091ecb5	36	ClassImp(AliAnalysisStatistics)
	37
	38	//______________________________________________________________________________
	39	AliAnalysisStatistics::AliAnalysisStatistics(const AliAnalysisStatistics &other)
	40	:TNamed(other),
	41	fNinput(other.fNinput),
	42	fNprocessed(other.fNprocessed),
	43	fNfailed(other.fNfailed),
c3732d79	44	fNaccepted(other.fNaccepted),
ed37a9ae	45	fOfflineMask(other.fOfflineMask),
	46	fMaxTasks(other.fMaxTasks),
	47	fNtasks(other.fNtasks),
	48	fCurrentTask(other.fCurrentTask),
	49	fTaskTimeReal(0),
	50	fTaskTimeCPU(0),
	51	fTaskNames(0),
	52	fTaskTimer(0)
f091ecb5	53	{
f091ecb5	54	// Copy constructor.
ed37a9ae	55	if (fNtasks) {
	56	fTaskTimer = new TStopwatch();
	57	fTaskTimeReal = new Double_t[fMaxTasks];
	58	memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
	59	memcpy(fTaskTimeReal, other.fTaskTimeReal, fNtasks*sizeof(Double_t));
	60	fTaskTimeCPU = new Double_t[fMaxTasks];
	61	memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
	62	memcpy(fTaskTimeCPU, other.fTaskTimeCPU, fNtasks*sizeof(Double_t));
	63	fTaskNames = new TObjArray(fMaxTasks);
	64	for (Int_t i=0; i<fNtasks; i++) fTaskNames->AddAt(new TObjString(other.GetTaskName(i)), i);
	65	}
f091ecb5	66	}
	67
	68	//______________________________________________________________________________
	69	AliAnalysisStatistics &AliAnalysisStatistics::operator=(const AliAnalysisStatistics &other)
	70	{
	71	// Assignment.
	72	if (&other == this) return *this;
ed37a9ae	73	fNinput = other.fNinput;
	74	fNprocessed = other.fNprocessed;
	75	fNfailed = other.fNfailed;
	76	fNaccepted = other.fNaccepted;
	77	fOfflineMask = other.fOfflineMask;
	78	fMaxTasks = other.fMaxTasks;
	79	fNtasks = other.fNtasks;
	80	fCurrentTask = other.fCurrentTask;
	81	fTaskTimeReal = 0;
	82	fTaskTimeCPU = 0;
	83	fTaskNames = 0;
	84	fTaskTimer = 0;
	85	if (fNtasks) {
	86	fTaskTimer = new TStopwatch();
	87	fTaskTimeReal = new Double_t[fMaxTasks];
	88	memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
	89	memcpy(fTaskTimeReal, other.fTaskTimeReal, fNtasks*sizeof(Double_t));
	90	fTaskTimeCPU = new Double_t[fMaxTasks];
	91	memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
	92	memcpy(fTaskTimeCPU, other.fTaskTimeCPU, fNtasks*sizeof(Double_t));
	93	fTaskNames = new TObjArray(fMaxTasks);
	94	for (Int_t i=0; i<fNtasks; i++) fTaskNames->AddAt(new TObjString(other.GetTaskName(i)), i);
	95	}
f091ecb5	96	return *this;
	97	}
	98
ed37a9ae	99	//______________________________________________________________________________
	100	void AliAnalysisStatistics::StartTimer(Int_t itask, const char name, const char classname)
	101	{
	102	// Measure the CPU time done by this task in the interval
	103	if (!fTaskTimer) {
	104	// Create the arrays with timings with the initial size
	105	if (!fMaxTasks) fMaxTasks = 100;
	106	fTaskTimer = new TStopwatch();
	107	fTaskTimeReal = new Double_t[fMaxTasks];
	108	memset(fTaskTimeReal, 0, fMaxTasks*sizeof(Double_t));
	109	fTaskTimeCPU = new Double_t[fMaxTasks];
	110	memset(fTaskTimeCPU, 0, fMaxTasks*sizeof(Double_t));
	111	fTaskNames = new TObjArray(fMaxTasks);
	112	} else {
	113	// Stop the timer if it was timing some task
	114	StopTimer();
	115	}
	116
	117	if (fNtasks<itask+1) {
	118	// Double the array size
	119	if (itask>=fMaxTasks) {
	120	Int_t newsize = TMath::Max(2*fMaxTasks, itask+1);
	121	Double_t *taskTimeReal = new Double_t[newsize];
	122	memset(taskTimeReal, 0, newsize*sizeof(Double_t));
	123	memcpy(taskTimeReal, fTaskTimeReal, fMaxTasks*sizeof(Double_t));
	124	delete [] fTaskTimeReal;
	125	fTaskTimeReal = taskTimeReal;
	126	Double_t *taskTimeCPU = new Double_t[newsize];
	127	memset(taskTimeCPU, 0, newsize*sizeof(Double_t));
	128	memcpy(taskTimeCPU, fTaskTimeCPU, fMaxTasks*sizeof(Double_t));
	129	delete [] fTaskTimeCPU;
	130	fTaskTimeCPU = taskTimeCPU;
	131	fMaxTasks = newsize;
	132	}
	133	fNtasks = itask+1;
	134	}
	135	// Start the timer for the new task
	136	fCurrentTask = itask;
	137	if (!fTaskNames->At(fCurrentTask)) {
	138	TString sname = name;
	139	if (strlen(classname)) sname += Form("(%s)", classname);
	140	fTaskNames->AddAt(new TObjString(sname), fCurrentTask);
	141	}
	142	fTaskTimer->Start(kTRUE);
	143	}
	144
	145	//______________________________________________________________________________
	146	void AliAnalysisStatistics::StopTimer()
	147	{
	148	// Stop the current task timing.
	149	if (fCurrentTask>=0) {
	150	fTaskTimer->Stop();
	151	fTaskTimeReal[fCurrentTask] += fTaskTimer->RealTime();
	152	fTaskTimeCPU[fCurrentTask] += fTaskTimer->CpuTime();
	153	fCurrentTask = -1;
	154	}
	155	}
	156
f091ecb5	157	//______________________________________________________________________________
	158	Long64_t AliAnalysisStatistics::Merge(TCollection* list)
	159	{
	160	// Merge statistics objets from list on top of this.
	161	TIter next(list);
	162	AliAnalysisStatistics *current;
	163	Long64_t count = 1;
	164	while ((current = (AliAnalysisStatistics*)next())) {
	165	fNinput += current->GetNinput();
	166	fNprocessed += current->GetNprocessed();
	167	fNfailed += current->GetNfailed();
	168	fNaccepted += current->GetNaccepted();
ed37a9ae	169	for (Int_t i=0; i<fNtasks; i++) {
	170	fTaskTimeReal[i] += current->GetRealTime(i);
	171	fTaskTimeCPU[i] += current->GetCPUTime(i);
	172	}
f091ecb5	173	}
	174	return count;
	175	}
	176
	177	//______________________________________________________________________________
	178	void AliAnalysisStatistics::Print(const Option_t *) const
	179	{
	180	// Print info about the processed statistics.
	181	cout << "### Input events : " << fNinput << endl;
	182	cout << "### Processed events w/o errors : " << fNprocessed << endl;
	183	cout << "### Failed events : " << fNfailed << endl;
c3732d79	184	cout << "### Accepted events for mask: " << GetMaskAsString(fOfflineMask) << ": " << fNaccepted << endl;
ed37a9ae	185	if (fNtasks) {
	186	cout << "Timing per task:" <<endl;
	187	TString s;
	188	for (Int_t i=0; i<fNtasks; i++) {
	189	s = Form("%03d: real: %9.2f cpu: %9.2f => %s", i,fTaskTimeReal[i], fTaskTimeCPU[i], GetTaskName(i));
	190	cout << s << endl;
	191	}
	192	}
c3732d79	193	}
	194
	195	//______________________________________________________________________________
	196	const char *AliAnalysisStatistics::GetMaskAsString(UInt_t mask)
	197	{
	198	// Returns a string corresponding to the offline mask.
	199	static TString smask;
	200	smask = "ALL EVT.";
	201	if (!mask) return smask.Data();
	202	smask.Clear();
	203	if (mask & AliVEvent::kMB) smask = "MB";
	204	if (mask & AliVEvent::kMUON) {
	205	if (!smask.IsNull()) smask += " \| ";
	206	smask += "MUON";
	207	}
	208	if (mask & AliVEvent::kHighMult) {
	209	if (!smask.IsNull()) smask += " \| ";
	210	smask += "HighMult";
	211	}
	212	if (mask & AliVEvent::kUserDefined) {
	213	if (!smask.IsNull()) smask += " \| ";
	214	smask += "UserDefined";
	215	}
	216	if (mask == AliVEvent::kAny) smask = "ANY";
	217	return smask.Data();
f091ecb5	218	}
ed37a9ae	219
	220	//______________________________________________________________________________
	221	const char *AliAnalysisStatistics::GetTaskName(Int_t itask) const
	222	{
	223	// Returns task name
	224	if (!fTaskNames \|\| !fTaskNames->At(itask)) return 0;
	225	return fTaskNames->At(itask)->GetName();
	226	}
	227