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

// $Id$
//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Gaute Ovrebekk <ovrebekk@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   AliHLTTPCClusterHistoComponent.cxx
    @author Gaute Ovrebekk
    @brief  Component for ploting charge in clusters
*/

#if __GNUC__>= 3
using namespace std;
#endif

#include "AliHLTTPCClusterHistoComponent.h"
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCClusterDataFormat.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCMemHandler.h"
#include "AliHLTTPCDefinitions.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include <TFile.h>
#include <TString.h>
#include "TObjString.h"
#include "TObjArray.h"

//#include "AliHLTTPC.h"
//#include <stdlib.h>
//#include <cerrno>

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

AliHLTTPCClusterHistoComponent::AliHLTTPCClusterHistoComponent()
:
fTotalClusterChargeOROCAll(NULL),                     
  fTotalClusterChargeIROCAll(NULL),                   
  fTotalClusterChargeROCSelection(NULL),               
  fTotalClusterChargePartitionSelection(NULL),         
  fQMaxPartitionAll(NULL),                             
  fQMaxROCAll(NULL),                              
  fNumberOfClusters(NULL),                        
  fPlotChargeOROCAll(kTRUE),   
  fPlotChargeIROCAll(kTRUE),
  fPlotChargeROCSel(kFALSE), 
  fPlotChargePartSel(kFALSE),
  fPlotQmaxPartAll(kTRUE),  
  fPlotQmaxROCAll(kTRUE),   
  fPlotNClusters(kTRUE)    
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

}

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

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

const char* AliHLTTPCClusterHistoComponent::GetComponentID()
{
  // see header file for class documentation
  
  return "TPCClusterHisto";
}

void AliHLTTPCClusterHistoComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
{
  // see header file for class documentation
  list.clear();
  list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
}

AliHLTComponentDataType AliHLTTPCClusterHistoComponent::GetOutputDataType()
{
  // see header file for class documentation
  return kAliHLTDataTypeHistogram;

}

void AliHLTTPCClusterHistoComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
  // see header file for class documentation
  // XXX TODO: Find more realistic values.
  constBase = 80000;
  inputMultiplier = 1;
}

AliHLTComponent* AliHLTTPCClusterHistoComponent::Spawn()
{
  // see header file for class documentation
  return new AliHLTTPCClusterHistoComponent;
}

int AliHLTTPCClusterHistoComponent::DoInit( int argc, const char** argv )
{
  //  HLTFatal("Initializing with log fatal");
  //  cout<<"Initializing with cout"<<endl;
  
  fPlotChargeOROCAll=kTRUE;   
  fPlotChargeIROCAll=kTRUE;
  fPlotChargeROCSel=kFALSE; 
  fPlotChargePartSel=kFALSE;
  fPlotQmaxPartAll=kTRUE;  
  fPlotQmaxROCAll=kTRUE;   
  fPlotNClusters=kTRUE;
   
  if(fPlotChargeOROCAll){fTotalClusterChargeOROCAll = new TH1F("fTotalClusterChargeOROCAll","Total Charge of clusters in all OROC",4000,0,4000);}
  if(fPlotChargeIROCAll){fTotalClusterChargeIROCAll = new TH1F("fTotalClusterChargeIROCAll","Total Charge of clusters in all IROC",4000,0,4000);}
  if(fPlotChargeROCSel){fTotalClusterChargeROCSelection = new TH1F("fTotalClusterChargeROCSelection","Total Charge of clusters in selection ROC",4000,0,4000);}
  if(fPlotChargePartSel){fTotalClusterChargePartitionSelection = new TH1F("fTotalClusterChargePartitionSelection","Total Charge of clusters in sel Part",4000,0,4000);}
  if(fPlotQmaxPartAll){fQMaxPartitionAll = new TH1F("fQMaxPartitionAll","QMax for All Partitions",216,0,216);}
  if(fPlotQmaxROCAll){fQMaxROCAll = new TH1F("fQMaxROCAll","QMax for All Partitions",72,0,72);}
  if(fPlotNClusters){fNumberOfClusters = new TH1F("fNumberOfClusters","Total Number of Clusters",1,0,1);}

  int iResult=0;
  TString configuration="";
  TString argument="";
  for (int i=0; i<argc && iResult>=0; i++) {
    argument=argv[i];
    if (!configuration.IsNull()) configuration+=" ";
    configuration+=argument;
  }
  
  if (!configuration.IsNull()) {
    iResult=Configure(configuration.Data());
  }  

  return iResult; 
}
  
int AliHLTTPCClusterHistoComponent::DoDeinit()
{
  // see header file for class documentation
  if(fTotalClusterChargeOROCAll!=NULL) delete fTotalClusterChargeOROCAll;
  if(fTotalClusterChargeIROCAll!=NULL) delete fTotalClusterChargeIROCAll;     
  if(fQMaxPartitionAll!=NULL) delete fQMaxPartitionAll;
  if(fQMaxROCAll!=NULL) delete fQMaxROCAll;
  return 0;
}

int AliHLTTPCClusterHistoComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
{
  
  int TotalSpacePoint = 0;
  
  const AliHLTComponentBlockData* iter = NULL;
  
  if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) )
    return 0;
  
  fQMaxPartitionAll->Reset();
  fQMaxROCAll->Reset();

  for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
    
    Int_t thisrow=-1,thissector=-1,row=-1;
    
    AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
    AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
    row = AliHLTTPCTransform::GetFirstRow(patch); 
    AliHLTTPCTransform::Slice2Sector(slice,row,thissector,thisrow);
    
    HLTDebug ( "Input Data - TPC cluster - Slice/Patch: %d/%d.", slice, patch );
    
    const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*) iter->fPtr;
    Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
    TotalSpacePoint += nSpacepoint;
    //HLTInfo("KryptonHisto found %d Spacepoints in slice %d patch %d", nSpacepoint, slice, patch);
    AliHLTTPCSpacePointData *clusters = (AliHLTTPCSpacePointData*) &clusterData->fSpacePoints;
    
    UInt_t tmpQPart = 0;//,tmpQROC = -1;
    
    for(int i=0;i<nSpacepoint;i++){
      if(fPlotChargeOROCAll){
	if(thissector>=36){
	  fTotalClusterChargeOROCAll->Fill(clusters[i].fCharge);
	}
      }
      if(fPlotChargeIROCAll){
	if(thissector<=35){
	  fTotalClusterChargeIROCAll->Fill(clusters[i].fCharge);
	}
      }
      if(fPlotChargeROCSel){
	
      }
      if(fPlotChargePartSel){
	
      }
      if(fPlotQmaxPartAll){
	if(clusters[i].fQMax>tmpQPart){
	  fQMaxPartitionAll->SetBinContent(patch+6*slice,clusters[i].fQMax);
	  tmpQPart=clusters[i].fQMax;
	}
      }
      if(fPlotQmaxROCAll){
	if(clusters[i].fQMax>fQMaxROCAll->GetBinContent(thissector)){
	  fQMaxROCAll->SetBinContent(thissector,clusters[i].fQMax);
	  //	  tmpQROC=clusters[i].fQMax;
	}
      }
    }
    if(fPlotNClusters){
      fNumberOfClusters->Fill(nSpacepoint);
    }
  }
  
  //delete til dodeinit
  if(fPlotChargeOROCAll){
    AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,2,5);
    PushBack( (TObject*) fTotalClusterChargeOROCAll,kAliHLTDataTypeHistogram,fSpecification);
  }
  if(fPlotChargeIROCAll){
    AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,1);
    PushBack( (TObject*) fTotalClusterChargeIROCAll,kAliHLTDataTypeHistogram,fSpecification);
  }
  if(fPlotChargeROCSel){
    
    
  }
  if(fPlotChargePartSel){
    
    
  }
  if(fPlotQmaxPartAll){
    AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
    PushBack( (TObject*) fQMaxPartitionAll,kAliHLTDataTypeHistogram,fSpecification);
    //delete fQMaxPartitionAll;
  }
  if(fPlotQmaxROCAll){
    AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
    PushBack( (TObject*) fQMaxROCAll,kAliHLTDataTypeHistogram,fSpecification);
    //delete fQMaxROCAll;
  }
  if(fPlotNClusters){
    
    
  }
  
  HLTInfo("KryptonHisto found %d Total Spacepoints", TotalSpacePoint);
  
  return 0;
}

int AliHLTTPCClusterHistoComponent::Configure(const char* arguments)
{
  
  int iResult=0;
  if (!arguments) return iResult;
  
  TString allArgs=arguments;
  TString argument;
  
  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("-plot-all")==0) {
	HLTInfo("Ploting charge of all clusters");
	//fPlotAll = kTRUE;
	continue;
      }
      
      else if (argument.CompareTo("-plot-trackclusters")==0) {
	HLTInfo("Ploting charge of clusters used on a track");
	//fPlotAll = kFALSE;
	continue;
      }
      else {
	HLTError("unknown argument %s", argument.Data());
	iResult=-EINVAL;
	break;
      }
    }
    delete pTokens;
  }
  
  //if hvis det eksisterer
  if(fPlotChargeOROCAll){fTotalClusterChargeOROCAll = new TH1F("fTotalClusterChargeOROCAll","Total Charge of clusters in all OROC",4000,0,4000);}
  if(fPlotChargeIROCAll){fTotalClusterChargeIROCAll = new TH1F("fTotalClusterChargeIROCAll","Total Charge of clusters in all IROC",4000,0,4000);}
  if(fPlotChargeROCSel){fTotalClusterChargeROCSelection = new TH1F("fTotalClusterChargeROCSelection","Total Charge of clusters in selection ROC",4000,0,4000);}
  if(fPlotChargePartSel){fTotalClusterChargePartitionSelection = new TH1F("fTotalClusterChargePartitionSelection","Total Charge of clusters in sel Part",4000,0,4000);}
  if(fPlotQmaxPartAll){fQMaxPartitionAll = new TH1F("fQMaxPartitionAll","QMax for All Partitions",216,0,216);}
  if(fPlotQmaxROCAll){fQMaxROCAll = new TH1F("fQMaxROCAll","QMax for All Partitions",72,0,72);}
  if(fPlotNClusters){fNumberOfClusters = new TH1F("fNumberOfClusters","Total Number of Clusters",100,0,100);}

  return iResult;
}

int AliHLTTPCClusterHistoComponent::Reconfigure(const char* cdbEntry, const char* chainId)
{
  // see header file for class documentation
  int iResult=0;
  const char* path="HLT/ConfigTPC/KryptonHistoComponent";
  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("can not fetch object \"%s\" from CDB", path);
    }
  }

  return iResult;
}
Commit	Line	Data
0efebbac	1	// $Id$
	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: Gaute Ovrebekk <ovrebekk@ift.uib.no> *
	7	//* for The ALICE HLT Project. *
	8	//* *
	9	//* Permission to use, copy, modify and distribute this software and its *
	10	//* documentation strictly for non-commercial purposes is hereby granted *
	11	//* without fee, provided that the above copyright notice appears in all *
	12	//* copies and that both the copyright notice and this permission notice *
	13	//* appear in the supporting documentation. The authors make no claims *
	14	//* about the suitability of this software for any purpose. It is *
	15	//* provided "as is" without express or implied warranty. *
	16	//**************************************************************************
	17
	18	/** @file AliHLTTPCClusterHistoComponent.cxx
	19	@author Gaute Ovrebekk
	20	@brief Component for ploting charge in clusters
	21	*/
	22
	23	#if __GNUC__>= 3
	24	using namespace std;
	25	#endif
	26
	27	#include "AliHLTTPCClusterHistoComponent.h"
	28	#include "AliHLTTPCTransform.h"
	29	#include "AliHLTTPCClusterDataFormat.h"
	30	#include "AliHLTTPCTrackletDataFormat.h"
	31	#include "AliHLTTPCMemHandler.h"
	32	#include "AliHLTTPCDefinitions.h"
	33	#include "AliCDBEntry.h"
	34	#include "AliCDBManager.h"
	35	#include <TFile.h>
	36	#include <TString.h>
	37	#include "TObjString.h"
	38	#include "TObjArray.h"
	39
	40	//#include "AliHLTTPC.h"
	41	//#include <stdlib.h>
	42	//#include <cerrno>
	43
	44	/** ROOT macro for the implementation of ROOT specific class methods */
	45	ClassImp(AliHLTTPCClusterHistoComponent)
	46
	47	AliHLTTPCClusterHistoComponent::AliHLTTPCClusterHistoComponent()
	48	:
	49	fTotalClusterChargeOROCAll(NULL),
	50	fTotalClusterChargeIROCAll(NULL),
	51	fTotalClusterChargeROCSelection(NULL),
	52	fTotalClusterChargePartitionSelection(NULL),
	53	fQMaxPartitionAll(NULL),
	54	fQMaxROCAll(NULL),
	55	fNumberOfClusters(NULL),
	56	fPlotChargeOROCAll(kTRUE),
	57	fPlotChargeIROCAll(kTRUE),
	58	fPlotChargeROCSel(kFALSE),
	59	fPlotChargePartSel(kFALSE),
	60	fPlotQmaxPartAll(kTRUE),
	61	fPlotQmaxROCAll(kTRUE),
0e588049	62	fPlotNClusters(kTRUE)
0efebbac	63	{
	64	// see header file for class documentation
	65	// or
	66	// refer to README to build package
	67	// or
	68	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	69
	70	}
	71
	72	AliHLTTPCClusterHistoComponent::~AliHLTTPCClusterHistoComponent()
	73	{
	74	// see header file for class documentation
	75	}
	76
	77	// Public functions to implement AliHLTComponent's interface.
	78	// These functions are required for the registration process
	79
	80	const char* AliHLTTPCClusterHistoComponent::GetComponentID()
	81	{
	82	// see header file for class documentation
	83
	84	return "TPCClusterHisto";
	85	}
	86
	87	void AliHLTTPCClusterHistoComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
	88	{
	89	// see header file for class documentation
	90	list.clear();
	91	list.push_back( AliHLTTPCDefinitions::fgkClustersDataType );
	92	}
	93
	94	AliHLTComponentDataType AliHLTTPCClusterHistoComponent::GetOutputDataType()
	95	{
	96	// see header file for class documentation
	97	return kAliHLTDataTypeHistogram;
	98
	99	}
	100
	101	void AliHLTTPCClusterHistoComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
	102	{
	103	// see header file for class documentation
	104	// XXX TODO: Find more realistic values.
	105	constBase = 80000;
	106	inputMultiplier = 1;
	107	}
	108
	109	AliHLTComponent* AliHLTTPCClusterHistoComponent::Spawn()
	110	{
	111	// see header file for class documentation
	112	return new AliHLTTPCClusterHistoComponent;
	113	}
	114
	115	int AliHLTTPCClusterHistoComponent::DoInit( int argc, const char** argv )
	116	{
	117	// HLTFatal("Initializing with log fatal");
	118	// cout<<"Initializing with cout"<<endl;
	119
	120	fPlotChargeOROCAll=kTRUE;
	121	fPlotChargeIROCAll=kTRUE;
	122	fPlotChargeROCSel=kFALSE;
	123	fPlotChargePartSel=kFALSE;
	124	fPlotQmaxPartAll=kTRUE;
	125	fPlotQmaxROCAll=kTRUE;
	126	fPlotNClusters=kTRUE;
127
128	if(fPlotChargeOROCAll){fTotalClusterChargeOROCAll = new TH1F("fTotalClusterChargeOROCAll","Total Charge of clusters in all OROC",4000,0,4000);}
129	if(fPlotChargeIROCAll){fTotalClusterChargeIROCAll = new TH1F("fTotalClusterChargeIROCAll","Total Charge of clusters in all IROC",4000,0,4000);}
130	if(fPlotChargeROCSel){fTotalClusterChargeROCSelection = new TH1F("fTotalClusterChargeROCSelection","Total Charge of clusters in selection ROC",4000,0,4000);}
131	if(fPlotChargePartSel){fTotalClusterChargePartitionSelection = new TH1F("fTotalClusterChargePartitionSelection","Total Charge of clusters in sel Part",4000,0,4000);}
132	if(fPlotQmaxPartAll){fQMaxPartitionAll = new TH1F("fQMaxPartitionAll","QMax for All Partitions",216,0,216);}
133	if(fPlotQmaxROCAll){fQMaxROCAll = new TH1F("fQMaxROCAll","QMax for All Partitions",72,0,72);}
134	if(fPlotNClusters){fNumberOfClusters = new TH1F("fNumberOfClusters","Total Number of Clusters",1,0,1);}
135
136	int iResult=0;
137	TString configuration="";
138	TString argument="";
139	for (int i=0; i<argc && iResult>=0; i++) {
140	argument=argv[i];
141	if (!configuration.IsNull()) configuration+=" ";
142	configuration+=argument;
143	}
144
145	if (!configuration.IsNull()) {
146	iResult=Configure(configuration.Data());
147	}
148
149	return iResult;
150	}
151
152	int AliHLTTPCClusterHistoComponent::DoDeinit()
153	{
154	// see header file for class documentation
155	if(fTotalClusterChargeOROCAll!=NULL) delete fTotalClusterChargeOROCAll;
156	if(fTotalClusterChargeIROCAll!=NULL) delete fTotalClusterChargeIROCAll;
157	if(fQMaxPartitionAll!=NULL) delete fQMaxPartitionAll;
158	if(fQMaxROCAll!=NULL) delete fQMaxROCAll;
159	return 0;
160	}
161
0e588049	162	int AliHLTTPCClusterHistoComponent::DoEvent(const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/)
0efebbac	163	{
	164
	165	int TotalSpacePoint = 0;
	166
	167	const AliHLTComponentBlockData* iter = NULL;
	168
	169	if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) \|\| GetFirstInputBlock( kAliHLTDataTypeEOR ) )
	170	return 0;
	171
	172	fQMaxPartitionAll->Reset();
	173	fQMaxROCAll->Reset();
	174
	175	for ( iter = GetFirstInputBlock(AliHLTTPCDefinitions::fgkClustersDataType); iter != NULL; iter = GetNextInputBlock() ) {
	176
	177	Int_t thisrow=-1,thissector=-1,row=-1;
	178
	179	AliHLTUInt8_t slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
	180	AliHLTUInt8_t patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
	181	row = AliHLTTPCTransform::GetFirstRow(patch);
	182	AliHLTTPCTransform::Slice2Sector(slice,row,thissector,thisrow);
	183
	184	HLTDebug ( "Input Data - TPC cluster - Slice/Patch: %d/%d.", slice, patch );
	185
	186	const AliHLTTPCClusterData* clusterData = (const AliHLTTPCClusterData*) iter->fPtr;
	187	Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
	188	TotalSpacePoint += nSpacepoint;
	189	//HLTInfo("KryptonHisto found %d Spacepoints in slice %d patch %d", nSpacepoint, slice, patch);
	190	AliHLTTPCSpacePointData clusters = (AliHLTTPCSpacePointData) &clusterData->fSpacePoints;
	191
	192	UInt_t tmpQPart = 0;//,tmpQROC = -1;
	193
	194	for(int i=0;i<nSpacepoint;i++){
	195	if(fPlotChargeOROCAll){
	196	if(thissector>=36){
	197	fTotalClusterChargeOROCAll->Fill(clusters[i].fCharge);
	198	}
	199	}
	200	if(fPlotChargeIROCAll){
	201	if(thissector<=35){
	202	fTotalClusterChargeIROCAll->Fill(clusters[i].fCharge);
	203	}
	204	}
	205	if(fPlotChargeROCSel){
	206
	207	}
	208	if(fPlotChargePartSel){
	209
	210	}
	211	if(fPlotQmaxPartAll){
a912b63b	212	if(clusters[i].fQMax>tmpQPart){
	213	fQMaxPartitionAll->SetBinContent(patch+6*slice,clusters[i].fQMax);
	214	tmpQPart=clusters[i].fQMax;
0efebbac	215	}
	216	}
	217	if(fPlotQmaxROCAll){
a912b63b	218	if(clusters[i].fQMax>fQMaxROCAll->GetBinContent(thissector)){
	219	fQMaxROCAll->SetBinContent(thissector,clusters[i].fQMax);
	220	// tmpQROC=clusters[i].fQMax;
0efebbac	221	}
	222	}
	223	}
	224	if(fPlotNClusters){
	225	fNumberOfClusters->Fill(nSpacepoint);
	226	}
	227	}
	228
	229	//delete til dodeinit
	230	if(fPlotChargeOROCAll){
	231	AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,2,5);
	232	PushBack( (TObject*) fTotalClusterChargeOROCAll,kAliHLTDataTypeHistogram,fSpecification);
	233	}
	234	if(fPlotChargeIROCAll){
	235	AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,1);
	236	PushBack( (TObject*) fTotalClusterChargeIROCAll,kAliHLTDataTypeHistogram,fSpecification);
	237	}
	238	if(fPlotChargeROCSel){
	239
	240
	241	}
	242	if(fPlotChargePartSel){
	243
	244
	245	}
	246	if(fPlotQmaxPartAll){
	247	AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
	248	PushBack( (TObject*) fQMaxPartitionAll,kAliHLTDataTypeHistogram,fSpecification);
	249	//delete fQMaxPartitionAll;
	250	}
	251	if(fPlotQmaxROCAll){
	252	AliHLTUInt32_t fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification(0,35,0,5);
	253	PushBack( (TObject*) fQMaxROCAll,kAliHLTDataTypeHistogram,fSpecification);
	254	//delete fQMaxROCAll;
	255	}
	256	if(fPlotNClusters){
	257
	258
	259	}
	260
	261	HLTInfo("KryptonHisto found %d Total Spacepoints", TotalSpacePoint);
	262
	263	return 0;
	264	}
	265
	266	int AliHLTTPCClusterHistoComponent::Configure(const char* arguments)
	267	{
	268
	269	int iResult=0;
	270	if (!arguments) return iResult;
	271
	272	TString allArgs=arguments;
	273	TString argument;
	274
	275	TObjArray* pTokens=allArgs.Tokenize(" ");
	276
	277	if (pTokens) {
	278	for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
	279	argument=((TObjString*)pTokens->At(i))->GetString();
	280	if (argument.IsNull()) continue;
	281
	282	if (argument.CompareTo("-plot-all")==0) {
	283	HLTInfo("Ploting charge of all clusters");
	284	//fPlotAll = kTRUE;
285	continue;
286	}
287
288	else if (argument.CompareTo("-plot-trackclusters")==0) {
289	HLTInfo("Ploting charge of clusters used on a track");
290	//fPlotAll = kFALSE;
291	continue;
292	}
293	else {
294	HLTError("unknown argument %s", argument.Data());
295	iResult=-EINVAL;
296	break;
297	}
298	}
299	delete pTokens;
300	}
301
302	//if hvis det eksisterer
303	if(fPlotChargeOROCAll){fTotalClusterChargeOROCAll = new TH1F("fTotalClusterChargeOROCAll","Total Charge of clusters in all OROC",4000,0,4000);}
304	if(fPlotChargeIROCAll){fTotalClusterChargeIROCAll = new TH1F("fTotalClusterChargeIROCAll","Total Charge of clusters in all IROC",4000,0,4000);}
305	if(fPlotChargeROCSel){fTotalClusterChargeROCSelection = new TH1F("fTotalClusterChargeROCSelection","Total Charge of clusters in selection ROC",4000,0,4000);}
306	if(fPlotChargePartSel){fTotalClusterChargePartitionSelection = new TH1F("fTotalClusterChargePartitionSelection","Total Charge of clusters in sel Part",4000,0,4000);}
307	if(fPlotQmaxPartAll){fQMaxPartitionAll = new TH1F("fQMaxPartitionAll","QMax for All Partitions",216,0,216);}
308	if(fPlotQmaxROCAll){fQMaxROCAll = new TH1F("fQMaxROCAll","QMax for All Partitions",72,0,72);}
309	if(fPlotNClusters){fNumberOfClusters = new TH1F("fNumberOfClusters","Total Number of Clusters",100,0,100);}
310
311	return iResult;
312	}
313
314	int AliHLTTPCClusterHistoComponent::Reconfigure(const char* cdbEntry, const char* chainId)
315	{
316	// see header file for class documentation
317	int iResult=0;
318	const char* path="HLT/ConfigTPC/KryptonHistoComponent";
319	const char* defaultNotify="";
320	if (cdbEntry) {
321	path=cdbEntry;
322	defaultNotify=" (default)";
323	}
324	if (path) {
325	HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
326	AliCDBEntry pEntry = AliCDBManager::Instance()->Get(path/,GetRunNo()*/);
327	if (pEntry) {
328	TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
329	if (pString) {
330	HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
331	iResult=Configure(pString->GetString().Data());
332	} else {
333	HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
334	}
335	} else {
336	HLTError("can not fetch object \"%s\" from CDB", path);
337	}
338	}
339
340	return iResult;
341	}