[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCHistogramHandlerComponent.cxx

// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        *
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no>          *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* 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.                  *
//**************************************************************************

/** @file   AliHLTTPCHistogramHandlerComponent.cxx
    @author Kalliopi Kanaki
    @date   
    @brief  The Histogram Handler component
*/

#if __GNUC__>= 3
using namespace std;
#endif
#include "AliHLTTPCHistogramHandlerComponent.h"
#include "AliHLTTPCDefinitions.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliHLTTPCTransform.h"

#include <cstdlib>
#include <cerrno>
#include "TString.h"
#include "TFile.h"
#include "TObjArray.h"
#include "TObjString.h"
#include <sys/time.h>
#include "TH1.h"
#include "TH2.h"
#include "TLine.h"
#include "TMath.h"


AliHLTTPCHistogramHandlerComponent gAliHLTTPCHistogramHandlerComponent;

ClassImp(AliHLTTPCHistogramHandlerComponent) //ROOT macro for the implementation of ROOT specific class methods

AliHLTTPCHistogramHandlerComponent::AliHLTTPCHistogramHandlerComponent()
    :    
    fSpecification(0),
    fNoiseHistograms(0),
    fKryptonHistograms(0),
    fSlice(-99),
    
    fHistTH1Tmp(NULL),
    fTotalClusterChargeIROCAll(NULL),
    fTotalClusterChargeOROCAll(NULL),
    fQMaxPartitionAll(NULL),
    fPlotQmaxROCAll(NULL),
    fNumberOfClusters(NULL),
    
    fHistTH2Tmp(NULL),
    fHistTPCSideA(NULL),  
    fHistTPCSideC(NULL)    
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTTPCHistogramHandlerComponent::~AliHLTTPCHistogramHandlerComponent() { 
// see header file for class documentation

}

// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process

const char* AliHLTTPCHistogramHandlerComponent::GetComponentID() { 
// see header file for class documentation

  return "TPCHistogramHandler";
}

void AliHLTTPCHistogramHandlerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) { 
// see header file for class documentation

  list.clear(); 
  list.push_back( kAliHLTDataTypeHistogram );
}

AliHLTComponentDataType AliHLTTPCHistogramHandlerComponent::GetOutputDataType() { 
// see header file for class documentation

  return kAliHLTDataTypeHistogram;
}

int AliHLTTPCHistogramHandlerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) { 
// see header file for class documentation

  tgtList.clear();
  tgtList.push_back(kAliHLTDataTypeHistogram);
  return tgtList.size();
}

void AliHLTTPCHistogramHandlerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) { 
// see header file for class documentation

  constBase=0;
  inputMultiplier=2.0;
}

AliHLTComponent* AliHLTTPCHistogramHandlerComponent::Spawn() { 
// see header file for class documentation

  return new AliHLTTPCHistogramHandlerComponent();
}
	
int AliHLTTPCHistogramHandlerComponent::DoInit( int argc, const char** argv ) { 
// see header file for class documentation

  Int_t i = 0;
  Char_t* cpErr;
  
  int iResult=0;
  
  TString configuration="";
  TString argument="";
  for (int j=0; j<argc && iResult>=0; j++) {
    
    argument=argv[j];
    if (!configuration.IsNull()) configuration+=" ";
    configuration+=argument;    
  }
   
  if (!configuration.IsNull()) {
    iResult=Configure(configuration.Data());
  } else {
    iResult=Reconfigure(NULL, NULL);
  }

 
  while ( i < argc ) {      
    if (!strcmp( argv[i], "-sum-noise-histograms")) {
        fNoiseHistograms = strtoul( argv[i+1], &cpErr ,0);
            
    if ( *cpErr ) {
        HLTError("Cannot convert sum-noise-histograms specifier '%s'.", argv[i+1]);
        return EINVAL;
    }
      i+=2;
      continue;
    }
    
    if (!strcmp( argv[i], "-sum-krypton-histograms")) {
        fKryptonHistograms = strtoul( argv[i+1], &cpErr ,0);
            
    if ( *cpErr ) {
        HLTError("Cannot convert sum-krypton-histograms specifier '%s'.", argv[i+1]);
        return EINVAL;
    }
      i+=2;
      continue;
    }    
                  
    Logging(kHLTLogError, "HLT::TPCHistogramHandler::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
    return EINVAL;

  } // end while
  
  return 0;
} // end DoInit()

int AliHLTTPCHistogramHandlerComponent::DoDeinit() { 
// see header file for class documentation 
   
   return 0;
}

int AliHLTTPCHistogramHandlerComponent::DoEvent(const AliHLTComponentEventData&/* evtData*/, AliHLTComponentTriggerData& /*trigData*/){
// see header file for class documentation

  HLTInfo("--- Entering DoEvent() in TPCHistogramHandler ---");
  
  if(GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
 
  fTotalClusterChargeIROCAll = new TH1F("fTotalClusterChargeIROCAll","Total Charge of clusters in all IROC",4000,0,4000);  
  fTotalClusterChargeOROCAll = new TH1F("fTotalClusterChargeOROCAll","Total Charge of clusters in all OROC",4000,0,4000);
  fQMaxPartitionAll          = new TH1F("fQMaxPartitionAll",         "QMax for All Partitions",             216,0,216);
  fPlotQmaxROCAll            = new TH1F("fQMaxROCAll",               "QMax for All ROC",                    72,0,72);
  fNumberOfClusters          = new TH1F("fNumberOfClusters",         "Total Number of Clusters",            1,0,1);
    
  fHistTH2Tmp = new TH2F("fHistTH2Tmp","fHistTH2Tmp",250,-250,250,250,-250,250);    
  fHistTPCSideA = new TH2F("fHistTPCSideA","TPC side A (max signal)",250,-250,250,250,-250,250);
  fHistTPCSideA->SetXTitle("global X (cm)"); fHistTPCSideA->SetYTitle("global Y (cm)");
  fHistTPCSideC = new TH2F("fHistTPCSideC","TPC side C (max signal)",250,-250,250,250,-250,250);
  fHistTPCSideC->SetXTitle("global X (cm)"); fHistTPCSideC->SetYTitle("global Y (cm)");
  
  const TObject *iter = NULL;  
        
  for(iter = GetFirstInputObject(kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputObject()){
   
//      HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s", 
//               evtData.fEventID, evtData.fEventID,
//               DataType2Text(GetDataType(iter)).c_str(), 
//               DataType2Text(kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC).c_str());
   
//      if (GetDataType(iter) == (kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC) && GetEventCount()<2){
//          HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeHistogram)!", 
// 	 DataType2Text(kAliHLTDataTypeHistogram).c_str(),
//          DataType2Text(kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC).c_str());
//      }      
     
     if (GetDataType(iter) != (kAliHLTDataTypeHistogram | kAliHLTDataOriginTPC)) continue;
         
     // Summing the output histograms of the AliHLTTPCNoiseMapComponent (from partition to TPC sides)
     if(fNoiseHistograms){  
       
        fHistTH2Tmp = (TH2F*)iter;
        UInt_t minSlice     = AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(iter)); 
        UInt_t maxSlice     = AliHLTTPCDefinitions::GetMaxSliceNr(GetSpecification(iter)); 
        UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(iter)); 
        UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(GetSpecification(iter)); 
       
        if((minSlice!=maxSlice) || (minPartition!=maxPartition)){
            HLTWarning("TPCHistogramHandler::The Noise Map component is not running on partition level!");
        }

        // minSlice=maxSlice, when the Noise Map component runs on partition level (as it should)
        if(minSlice<18) fHistTPCSideA->Add(fHistTPCSideA,fHistTH2Tmp,1,1);
        else		fHistTPCSideC->Add(fHistTPCSideC,fHistTH2Tmp,1,1);
     } // endif fNoiseHistograms==kTRUE   
     
     
     // Summing the output of AliHLTTPCClusterHistoComponent
     if(fKryptonHistograms){
       Int_t thisrow=-1,thissector=-1,row=-1;
       
       AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(iter));
       AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(iter));
       row = AliHLTTPCTransform::GetFirstRow(patch); 
       AliHLTTPCTransform::Slice2Sector(slice,row,thissector,thisrow);
       
       fHistTH1Tmp = (TH1F*)iter;   	
       //cout << fHistTH1Tmp->GetName() << "\t" << fHistTH1Tmp->GetEntries() << endl;
       
	TString name = fHistTH1Tmp->GetName();
		
	if(name=="fTotalClusterChargeIROCAll"){
	   fTotalClusterChargeIROCAll->Add(fTotalClusterChargeIROCAll,fHistTH1Tmp,1,1);
	} 
	else if(name=="fTotalClusterChargeOROCAll"){
	   fTotalClusterChargeOROCAll->Add(fTotalClusterChargeOROCAll,fHistTH1Tmp,1,1);
	} 
	else if(name=="fQMaxPartitionAll"){
	  for(Int_t t=0;t<216;t++){
	    if(fHistTH1Tmp->GetBinContent(t)>fQMaxPartitionAll->GetBinContent(t)){
	      fQMaxPartitionAll->SetBinContent(t,fHistTH1Tmp->GetBinContent(t));
	    }
	  } 
	} 
	else if(name=="fQMaxROCAll"){
	  for(Int_t t=0;t<72;t++){
	    if(fHistTH1Tmp->GetBinContent(t)>fPlotQmaxROCAll->GetBinContent(t)){
	      fPlotQmaxROCAll->SetBinContent(t,fHistTH1Tmp->GetBinContent(t));
	    }
	  }
	} 
	else if(name=="fNumberOfClusters"){ 
	  fNumberOfClusters->Add(fNumberOfClusters,fHistTH1Tmp,1,1);
	} 
	else{
	  HLTWarning("No histogram names match. %s",name.Data());
	  continue;
	}     
     } //endif fKryptonHistograms==kTRUE	   	         
  } // end for loop over histogram blocks
  
  MakeHistosPublic();
  return 0;
} // end DoEvent()

void AliHLTTPCHistogramHandlerComponent::MakeHistosPublic() {
// see header file for class documentation
 
  if(fNoiseHistograms){ 
    PushBack((TObject*)fHistTPCSideA,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification( 0,17,0,5));
    PushBack((TObject*)fHistTPCSideC,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(18,35,0,5));

    if(fHistTH2Tmp){
      delete fHistTH2Tmp;
    }
    if(fHistTPCSideA){
      delete fHistTPCSideA;
    }
    if(fHistTPCSideC){
      delete fHistTPCSideC;
    }
    
    fHistTH2Tmp=NULL;
    fHistTPCSideA=NULL;
    fHistTPCSideC=NULL;
  }  
  
  if(fKryptonHistograms){
     PushBack((TObject*)fTotalClusterChargeIROCAll,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,17,0,1));
     PushBack((TObject*)fTotalClusterChargeOROCAll,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,17,2,5));
     PushBack((TObject*)fQMaxPartitionAll,	   kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
     PushBack((TObject*)fPlotQmaxROCAll,	   kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
     PushBack((TObject*)fNumberOfClusters,	   kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
          
     if(fTotalClusterChargeIROCAll){
       delete fTotalClusterChargeIROCAll;
       fTotalClusterChargeIROCAll=NULL;
     }
     if(fTotalClusterChargeOROCAll){
       delete fTotalClusterChargeOROCAll;
       fTotalClusterChargeOROCAll=NULL;
     }
     if(fQMaxPartitionAll){
       delete fQMaxPartitionAll;
       fQMaxPartitionAll=NULL;
     }
     if(fPlotQmaxROCAll){
       delete fPlotQmaxROCAll;
       fPlotQmaxROCAll=NULL;
     }
     if(fNumberOfClusters){
       delete fNumberOfClusters;
       fNumberOfClusters=NULL;
     }
     if(fHistTH1Tmp){
       delete fHistTH1Tmp;
       fHistTH1Tmp=NULL;
     }
  }
 
//  TObjArray histos;
   
//   if(fPlotSideA) histos.Add(fHistSideA);
//   if(fPlotSideC) histos.Add(fHistSideC);
//   if(fApplyNoiseMap) histos.Add(fHistCDBMap);
//   
//   TIter iterator(&histos);
//   while(TObject *pObj=iterator.Next()){
//   
//         PushBack(pObj, kAliHLTDataTypeHistogram|kAliHLTDataOriginTPC, fSpecification);
//   }
//   
//   
//   //PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);    
}

int AliHLTTPCHistogramHandlerComponent::Configure(const char* arguments) { 
// see header file for class documentation
  
  int iResult=0;
  if (!arguments) return iResult;
  HLTInfo("parsing configuration string \'%s\'", arguments);

  TString allArgs=arguments;
  TString argument;
  int bMissingParam=0;

  TObjArray* pTokens=allArgs.Tokenize(" ");
  if (pTokens) {
    for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
      argument=((TObjString*)pTokens->At(i))->GetString();
      if (argument.IsNull()) continue;
     
      if (argument.CompareTo("-sum-noise-histograms")==0) {
	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	HLTInfo("got \'-sum-noise-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
	
      } else if (argument.CompareTo("-sum-krypton-histograms")==0) {
	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	HLTInfo("got \'-sum-krypton-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
	
      } 
      else {
	HLTError("unknown argument %s", argument.Data());
	iResult=-EINVAL;
	break;
      }
    } // end for
  
    delete pTokens;
  
  } // end if pTokens
  
  if (bMissingParam) {
    HLTError("missing parameter for argument %s", argument.Data());
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTPCHistogramHandlerComponent::Reconfigure(const char* cdbEntry, const char* chainId) { 
// see header file for class documentation

  int iResult=0;
  const char* path="HLT/ConfigTPC/TPCHistogramHandlerComponent";
  const char* defaultNotify="";
  if (cdbEntry) {
      path=cdbEntry;
      defaultNotify=" (default)";
  }
  
  if (path) {
    HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
    AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
    if (pEntry) {
      TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
      if (pString) {
	HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
	iResult=Configure(pString->GetString().Data());
      } else {
	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
      }
    } else {
      HLTError("cannot fetch object \"%s\" from CDB", path);
    }
  }
  return iResult;
}
Commit	Line	Data
cdfe3c01	1	// $Id$
	2
	3	//**************************************************************************
	4	//* This file is property of and copyright by the ALICE HLT Project *
	5	//* ALICE Experiment at CERN, All rights reserved. *
	6	//* *
	7	//* Primary Authors: Kalliopi Kanaki <Kalliopi.Kanaki@ift.uib.no> *
	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	/** @file AliHLTTPCHistogramHandlerComponent.cxx
	20	@author Kalliopi Kanaki
	21	@date
	22	@brief The Histogram Handler component
	23	*/
	24
	25	#if __GNUC__>= 3
	26	using namespace std;
	27	#endif
	28	#include "AliHLTTPCHistogramHandlerComponent.h"
	29	#include "AliHLTTPCDefinitions.h"
	30	#include "AliCDBEntry.h"
	31	#include "AliCDBManager.h"
0efebbac	32	#include "AliHLTTPCTransform.h"
cdfe3c01	33
	34	#include <cstdlib>
	35	#include <cerrno>
	36	#include "TString.h"
	37	#include "TFile.h"
	38	#include "TObjArray.h"
	39	#include "TObjString.h"
	40	#include <sys/time.h>
	41	#include "TH1.h"
	42	#include "TH2.h"
	43	#include "TLine.h"
	44	#include "TMath.h"
	45
	46
	47	AliHLTTPCHistogramHandlerComponent gAliHLTTPCHistogramHandlerComponent;
	48
	49	ClassImp(AliHLTTPCHistogramHandlerComponent) //ROOT macro for the implementation of ROOT specific class methods
	50
	51	AliHLTTPCHistogramHandlerComponent::AliHLTTPCHistogramHandlerComponent()
	52	:
0e588049	53	fSpecification(0),
cdfe3c01	54	fNoiseHistograms(0),
cdfe3c01	55	fKryptonHistograms(0),
cdfe3c01	56	fSlice(-99),
0efebbac	57
cdfe3c01	58	fHistTH1Tmp(NULL),
0efebbac	59	fTotalClusterChargeIROCAll(NULL),
	60	fTotalClusterChargeOROCAll(NULL),
	61	fQMaxPartitionAll(NULL),
	62	fPlotQmaxROCAll(NULL),
	63	fNumberOfClusters(NULL),
	64
cdfe3c01	65	fHistTH2Tmp(NULL),
	66	fHistTPCSideA(NULL),
	67	fHistTPCSideC(NULL)
	68	{
	69	// see header file for class documentation
	70	// or
	71	// refer to README to build package
	72	// or
	73	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	74	}
	75
	76	AliHLTTPCHistogramHandlerComponent::~AliHLTTPCHistogramHandlerComponent() {
	77	// see header file for class documentation
	78
	79	}
	80
	81	// Public functions to implement AliHLTComponent's interface.
	82	// These functions are required for the registration process
	83
	84	const char* AliHLTTPCHistogramHandlerComponent::GetComponentID() {
	85	// see header file for class documentation
	86
	87	return "TPCHistogramHandler";
	88	}
	89
	90	void AliHLTTPCHistogramHandlerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) {
	91	// see header file for class documentation
	92
	93	list.clear();
	94	list.push_back( kAliHLTDataTypeHistogram );
	95	}
	96
	97	AliHLTComponentDataType AliHLTTPCHistogramHandlerComponent::GetOutputDataType() {
	98	// see header file for class documentation
	99
	100	return kAliHLTDataTypeHistogram;
	101	}
	102
	103	int AliHLTTPCHistogramHandlerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) {
	104	// see header file for class documentation
	105
	106	tgtList.clear();
	107	tgtList.push_back(kAliHLTDataTypeHistogram);
	108	return tgtList.size();
	109	}
	110
	111	void AliHLTTPCHistogramHandlerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
	112	// see header file for class documentation
	113
	114	constBase=0;
	115	inputMultiplier=2.0;
	116	}
	117
	118	AliHLTComponent* AliHLTTPCHistogramHandlerComponent::Spawn() {
	119	// see header file for class documentation
	120
	121	return new AliHLTTPCHistogramHandlerComponent();
	122	}
	123
	124	int AliHLTTPCHistogramHandlerComponent::DoInit( int argc, const char** argv ) {
	125	// see header file for class documentation
	126
	127	Int_t i = 0;
	128	Char_t* cpErr;
129
130	int iResult=0;
131
132	TString configuration="";
133	TString argument="";
0e588049	134	for (int j=0; j<argc && iResult>=0; j++) {
cdfe3c01	135
0e588049	136	argument=argv[j];
cdfe3c01	137	if (!configuration.IsNull()) configuration+=" ";
	138	configuration+=argument;
	139	}
	140
	141	if (!configuration.IsNull()) {
	142	iResult=Configure(configuration.Data());
	143	} else {
	144	iResult=Reconfigure(NULL, NULL);
	145	}
	146
	147
	148	while ( i < argc ) {
	149	if (!strcmp( argv[i], "-sum-noise-histograms")) {
	150	fNoiseHistograms = strtoul( argv[i+1], &cpErr ,0);
	151
	152	if ( *cpErr ) {
	153	HLTError("Cannot convert sum-noise-histograms specifier '%s'.", argv[i+1]);
	154	return EINVAL;
	155	}
	156	i+=2;
	157	continue;
	158	}
	159
	160	if (!strcmp( argv[i], "-sum-krypton-histograms")) {
	161	fKryptonHistograms = strtoul( argv[i+1], &cpErr ,0);
	162
	163	if ( *cpErr ) {
	164	HLTError("Cannot convert sum-krypton-histograms specifier '%s'.", argv[i+1]);
	165	return EINVAL;
	166	}
	167	i+=2;
	168	continue;
	169	}
	170
	171	Logging(kHLTLogError, "HLT::TPCHistogramHandler::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
	172	return EINVAL;
	173
	174	} // end while
	175
	176	return 0;
	177	} // end DoInit()
	178
	179	int AliHLTTPCHistogramHandlerComponent::DoDeinit() {
	180	// see header file for class documentation
	181
	182	return 0;
	183	}
	184
0e588049	185	int AliHLTTPCHistogramHandlerComponent::DoEvent(const AliHLTComponentEventData&/* evtData/, AliHLTComponentTriggerData& /trigData*/){
cdfe3c01	186	// see header file for class documentation
	187
	188	HLTInfo("--- Entering DoEvent() in TPCHistogramHandler ---");
	189
	190	if(GetFirstInputBlock( kAliHLTDataTypeSOR ) \|\| GetFirstInputBlock( kAliHLTDataTypeEOR )) return 0;
0efebbac	191
	192	fTotalClusterChargeIROCAll = new TH1F("fTotalClusterChargeIROCAll","Total Charge of clusters in all IROC",4000,0,4000);
	193	fTotalClusterChargeOROCAll = new TH1F("fTotalClusterChargeOROCAll","Total Charge of clusters in all OROC",4000,0,4000);
	194	fQMaxPartitionAll = new TH1F("fQMaxPartitionAll", "QMax for All Partitions", 216,0,216);
	195	fPlotQmaxROCAll = new TH1F("fQMaxROCAll", "QMax for All ROC", 72,0,72);
0e588049	196	fNumberOfClusters = new TH1F("fNumberOfClusters", "Total Number of Clusters", 1,0,1);
0efebbac	197
cdfe3c01	198	fHistTH2Tmp = new TH2F("fHistTH2Tmp","fHistTH2Tmp",250,-250,250,250,-250,250);
	199	fHistTPCSideA = new TH2F("fHistTPCSideA","TPC side A (max signal)",250,-250,250,250,-250,250);
	200	fHistTPCSideA->SetXTitle("global X (cm)"); fHistTPCSideA->SetYTitle("global Y (cm)");
	201	fHistTPCSideC = new TH2F("fHistTPCSideC","TPC side C (max signal)",250,-250,250,250,-250,250);
	202	fHistTPCSideC->SetXTitle("global X (cm)"); fHistTPCSideC->SetYTitle("global Y (cm)");
	203
	204	const TObject *iter = NULL;
	205
	206	for(iter = GetFirstInputObject(kAliHLTDataTypeHistogram\|kAliHLTDataOriginTPC); iter != NULL; iter = GetNextInputObject()){
	207
0efebbac	208	// HLTInfo("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
	209	// evtData.fEventID, evtData.fEventID,
	210	// DataType2Text(GetDataType(iter)).c_str(),
	211	// DataType2Text(kAliHLTDataTypeHistogram \| kAliHLTDataOriginTPC).c_str());
cdfe3c01	212
0efebbac	213	// if (GetDataType(iter) == (kAliHLTDataTypeHistogram \| kAliHLTDataOriginTPC) && GetEventCount()<2){
	214	// HLTWarning("data type %s is depricated, use %s (kAliHLTDataTypeHistogram)!",
	215	// DataType2Text(kAliHLTDataTypeHistogram).c_str(),
	216	// DataType2Text(kAliHLTDataTypeHistogram \| kAliHLTDataOriginTPC).c_str());
	217	// }
cdfe3c01	218
	219	if (GetDataType(iter) != (kAliHLTDataTypeHistogram \| kAliHLTDataOriginTPC)) continue;
	220
0efebbac	221	// Summing the output histograms of the AliHLTTPCNoiseMapComponent (from partition to TPC sides)
cdfe3c01	222	if(fNoiseHistograms){
cdfe3c01	223
0efebbac	224	fHistTH2Tmp = (TH2F*)iter;
	225	UInt_t minSlice = AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(iter));
	226	UInt_t maxSlice = AliHLTTPCDefinitions::GetMaxSliceNr(GetSpecification(iter));
	227	UInt_t minPartition = AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(iter));
	228	UInt_t maxPartition = AliHLTTPCDefinitions::GetMaxPatchNr(GetSpecification(iter));
cdfe3c01	229
0efebbac	230	if((minSlice!=maxSlice) \|\| (minPartition!=maxPartition)){
	231	HLTWarning("TPCHistogramHandler::The Noise Map component is not running on partition level!");
	232	}
cdfe3c01	233
0efebbac	234	// minSlice=maxSlice, when the Noise Map component runs on partition level (as it should)
	235	if(minSlice<18) fHistTPCSideA->Add(fHistTPCSideA,fHistTH2Tmp,1,1);
	236	else fHistTPCSideC->Add(fHistTPCSideC,fHistTH2Tmp,1,1);
cdfe3c01	237	} // endif fNoiseHistograms==kTRUE
	238
	239
0efebbac	240	// Summing the output of AliHLTTPCClusterHistoComponent
	241	if(fKryptonHistograms){
	242	Int_t thisrow=-1,thissector=-1,row=-1;
	243
	244	AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr(GetSpecification(iter));
	245	AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr(GetSpecification(iter));
	246	row = AliHLTTPCTransform::GetFirstRow(patch);
	247	AliHLTTPCTransform::Slice2Sector(slice,row,thissector,thisrow);
	248
	249	fHistTH1Tmp = (TH1F*)iter;
	250	//cout << fHistTH1Tmp->GetName() << "\t" << fHistTH1Tmp->GetEntries() << endl;
	251
	252	TString name = fHistTH1Tmp->GetName();
	253
	254	if(name=="fTotalClusterChargeIROCAll"){
	255	fTotalClusterChargeIROCAll->Add(fTotalClusterChargeIROCAll,fHistTH1Tmp,1,1);
	256	}
	257	else if(name=="fTotalClusterChargeOROCAll"){
	258	fTotalClusterChargeOROCAll->Add(fTotalClusterChargeOROCAll,fHistTH1Tmp,1,1);
	259	}
	260	else if(name=="fQMaxPartitionAll"){
0e588049	261	for(Int_t t=0;t<216;t++){
	262	if(fHistTH1Tmp->GetBinContent(t)>fQMaxPartitionAll->GetBinContent(t)){
	263	fQMaxPartitionAll->SetBinContent(t,fHistTH1Tmp->GetBinContent(t));
	264	}
	265	}
	266	}
	267	else if(name=="fQMaxROCAll"){
	268	for(Int_t t=0;t<72;t++){
	269	if(fHistTH1Tmp->GetBinContent(t)>fPlotQmaxROCAll->GetBinContent(t)){
	270	fPlotQmaxROCAll->SetBinContent(t,fHistTH1Tmp->GetBinContent(t));
	271	}
	272	}
0efebbac	273	}
0efebbac	274	else if(name=="fNumberOfClusters"){
0e588049	275	fNumberOfClusters->Add(fNumberOfClusters,fHistTH1Tmp,1,1);
	276	}
	277	else{
	278	HLTWarning("No histogram names match. %s",name.Data());
	279	continue;
	280	}
0efebbac	281	} //endif fKryptonHistograms==kTRUE
cdfe3c01	282	} // end for loop over histogram blocks
	283
	284	MakeHistosPublic();
cdfe3c01	285	return 0;
	286	} // end DoEvent()
	287
	288	void AliHLTTPCHistogramHandlerComponent::MakeHistosPublic() {
	289	// see header file for class documentation
cdfe3c01	290
cdfe3c01	291	if(fNoiseHistograms){
0efebbac	292	PushBack((TObject*)fHistTPCSideA,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification( 0,17,0,5));
0efebbac	293	PushBack((TObject*)fHistTPCSideC,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(18,35,0,5));
0e588049	294
	295	if(fHistTH2Tmp){
	296	delete fHistTH2Tmp;
	297	}
	298	if(fHistTPCSideA){
	299	delete fHistTPCSideA;
	300	}
	301	if(fHistTPCSideC){
	302	delete fHistTPCSideC;
	303	}
	304
	305	fHistTH2Tmp=NULL;
	306	fHistTPCSideA=NULL;
	307	fHistTPCSideC=NULL;
0efebbac	308	}
	309
	310	if(fKryptonHistograms){
	311	PushBack((TObject*)fTotalClusterChargeIROCAll,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,17,0,1));
	312	PushBack((TObject*)fTotalClusterChargeOROCAll,kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,17,2,5));
	313	PushBack((TObject*)fQMaxPartitionAll, kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
	314	PushBack((TObject*)fPlotQmaxROCAll, kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
	315	PushBack((TObject*)fNumberOfClusters, kAliHLTDataTypeHistogram,AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5));
	316
0e588049	317	if(fTotalClusterChargeIROCAll){
	318	delete fTotalClusterChargeIROCAll;
	319	fTotalClusterChargeIROCAll=NULL;
	320	}
	321	if(fTotalClusterChargeOROCAll){
	322	delete fTotalClusterChargeOROCAll;
	323	fTotalClusterChargeOROCAll=NULL;
	324	}
	325	if(fQMaxPartitionAll){
	326	delete fQMaxPartitionAll;
	327	fQMaxPartitionAll=NULL;
	328	}
	329	if(fPlotQmaxROCAll){
	330	delete fPlotQmaxROCAll;
	331	fPlotQmaxROCAll=NULL;
	332	}
	333	if(fNumberOfClusters){
	334	delete fNumberOfClusters;
	335	fNumberOfClusters=NULL;
	336	}
	337	if(fHistTH1Tmp){
	338	delete fHistTH1Tmp;
	339	fHistTH1Tmp=NULL;
	340	}
cdfe3c01	341	}
	342
	343	// TObjArray histos;
	344
	345	// if(fPlotSideA) histos.Add(fHistSideA);
	346	// if(fPlotSideC) histos.Add(fHistSideC);
	347	// if(fApplyNoiseMap) histos.Add(fHistCDBMap);
	348	//
	349	// TIter iterator(&histos);
	350	// while(TObject *pObj=iterator.Next()){
	351	//
	352	// PushBack(pObj, kAliHLTDataTypeHistogram\|kAliHLTDataOriginTPC, fSpecification);
	353	// }
	354	//
	355	//
	356	// //PushBack( (TObject*) &histos, kAliHLTDataTypeHistogram, fSpecification);
	357	}
	358
	359	int AliHLTTPCHistogramHandlerComponent::Configure(const char* arguments) {
	360	// see header file for class documentation
	361
	362	int iResult=0;
	363	if (!arguments) return iResult;
	364	HLTInfo("parsing configuration string \'%s\'", arguments);
	365
	366	TString allArgs=arguments;
	367	TString argument;
	368	int bMissingParam=0;
	369
	370	TObjArray* pTokens=allArgs.Tokenize(" ");
	371	if (pTokens) {
	372	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
	373	argument=((TObjString*)pTokens->At(i))->GetString();
	374	if (argument.IsNull()) continue;
	375
	376	if (argument.CompareTo("-sum-noise-histograms")==0) {
	377	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	378	HLTInfo("got \'-sum-noise-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
	379
	380	} else if (argument.CompareTo("-sum-krypton-histograms")==0) {
	381	if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
	382	HLTInfo("got \'-sum-krypton-histograms\': %s", ((TObjString*)pTokens->At(i))->GetString().Data());
	383
	384	}
	385	else {
	386	HLTError("unknown argument %s", argument.Data());
	387	iResult=-EINVAL;
	388	break;
	389	}
	390	} // end for
	391
	392	delete pTokens;
	393
	394	} // end if pTokens
	395
	396	if (bMissingParam) {
	397	HLTError("missing parameter for argument %s", argument.Data());
	398	iResult=-EINVAL;
	399	}
	400	return iResult;
	401	}
	402
	403	int AliHLTTPCHistogramHandlerComponent::Reconfigure(const char* cdbEntry, const char* chainId) {
	404	// see header file for class documentation
405
406	int iResult=0;
407	const char* path="HLT/ConfigTPC/TPCHistogramHandlerComponent";
408	const char* defaultNotify="";
409	if (cdbEntry) {
410	path=cdbEntry;
411	defaultNotify=" (default)";
412	}
413
414	if (path) {
415	HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
416	AliCDBEntry pEntry = AliCDBManager::Instance()->Get(path/,GetRunNo()*/);
417	if (pEntry) {
418	TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
419	if (pString) {
420	HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
421	iResult=Configure(pString->GetString().Data());
422	} else {
423	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
424	}
425	} else {
426	HLTError("cannot fetch object \"%s\" from CDB", path);
427	}
428	}
429	return iResult;
430	}