[u/mrichter/AliRoot.git] / HLT / PHOS / AliHLTPHOSBaselineAnalyzerComponent.cxx


/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * All rights reserved.                                                   *
 *                                                                        *
 * Primary Authors: Oystein Djuvsland                                                      *
 *                                                                        *
 * 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.                  *
 **************************************************************************/
#include "AliHLTPHOSBaselineAnalyzerComponent.h"
#include "AliHLTPHOSBaselineAnalyzer.h"
#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
#include "AliHLTPHOSBaseline.h"
#include "TTree.h"
#include "TChain.h"
#include "AliHLTPHOSProcessor.h"
#include "TClonesArray.h"
#include "TFile.h"
//#include <direct.h>
#include <sys/stat.h>
#include <sys/types.h>

/** 
 * Class does baseline analysis
 * 
 * @file   AliHLTPHOSBaselineAnalyzerComponent.cxx
 * @author Oystein Djuvsland
 * @date   
 * @brief  A baseline analyzer for PHOS HLT
*/

// see below for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

const AliHLTComponentDataType AliHLTPHOSBaselineAnalyzerComponent::fgkInputDataTypes[]={kAliHLTVoidDataType,{0,"",""}};

AliHLTPHOSBaselineAnalyzerComponent gAliHLTPHOSBaselineAnalyzerComponent;

AliHLTPHOSBaselineAnalyzerComponent::AliHLTPHOSBaselineAnalyzerComponent() :
  AliHLTPHOSProcessor(),
  fBaselineAnalyzerPtr(0),
  fTreePtr(0),
  fEvCnt(0),
  fWriteInterval(100),
  fFillInterval(100),
  fFilename(0),
  fDirectory(0),
  fHistPath(0),
  fRunNb(0)
{
   //See header file for documentation
}

AliHLTPHOSBaselineAnalyzerComponent::~AliHLTPHOSBaselineAnalyzerComponent()
{
 //See header file for documentation
}


int 
AliHLTPHOSBaselineAnalyzerComponent::Deinit()
{
  //See header file for documentation
  fBaselineAnalyzerPtr->CalculateChannelsBaselineRMS();
  char filename [50];
  cout << "Writing files...";
  sprintf(filename, "%s/run%d_baselineTree_%d.root", fDirectory, fRunNb,fEvCnt/fWriteInterval);
  fBaselineAnalyzerPtr->WriteAccumulatedBaselines(filename);
  sprintf(filename, "%s/run%d_channelHistograms.root", fHistPath, fRunNb);
  fBaselineAnalyzerPtr->WriteChannelHistograms(filename);
  sprintf(filename, "%s/run%d_RMSHistogram.root", fHistPath, fRunNb);
  fBaselineAnalyzerPtr->WriteRMSHistogram(filename);
  cout << "Done!\n";

  if(fCalculateAll)
    {
      CalculateAll(); 
    }
  if(fBaselineAnalyzerPtr)
    {
      delete fBaselineAnalyzerPtr;
      fBaselineAnalyzerPtr = 0;
    }
  if(fTreePtr)
    {
      //      delete fTreePtr;
      fTreePtr = 0;
    }
  if(fFilename)
    {
      delete fFilename;
      fFilename = 0;
    }
  return 0;
}

const char*
AliHLTPHOSBaselineAnalyzerComponent::GetComponentID()
{
 //See header file for documentation
  return "PhosBaselineAnalyzer";
}

void

AliHLTPHOSBaselineAnalyzerComponent::GetInputDataTypes(vector<AliHLTComponentDataType>& list)
{ 
 //Get datatypes for input
  const AliHLTComponentDataType* pType=fgkInputDataTypes;
  while (pType->fID!=0) {
    list.push_back(*pType); 
    pType++;
  }
}

AliHLTComponentDataType 
AliHLTPHOSBaselineAnalyzerComponent::GetOutputDataType()
{
 //See header file for documentation
  return AliHLTPHOSDefinitions::fgkAliHLTBaselineDataType;
}


void 
AliHLTPHOSBaselineAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
{
 //See header file for documentation
  constBase = 30;
  inputMultiplier = 1;
}

int 
AliHLTPHOSBaselineAnalyzerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
					AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& /*size*/,  //TODO: I think that not setting the size explicitly to zero when returning from this method may be a subtle bug in this component. Please check.
					std::vector<AliHLTComponentBlockData>& /*outputBlocks*/)
{
   //Do event
     
  //UInt_t tSize            = 0;
  //UInt_t offset           = 0; 
  //UInt_t mysize           = 0;
  //Int_t index             = 0;
  
  //Int_t fileCount = 0;
  //Int_t digitCount = 0;
  //char filename [50];


  AliHLTUInt8_t* outBPtr;
  outBPtr = outputPtr;
  const AliHLTComponentBlockData* iter = 0; 
  unsigned long ndx; 

  for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
    {
      iter = blocks+ndx;
      
      if(iter->fDataType != AliHLTPHOSDefinitions::fgkCellEnergyDataType)
	{
	  //	  cout << "Warning: data type is not fgkCellEnergyDataType " << endl;
	  continue;

	}
      fBaselineAnalyzerPtr->CalculateRcuBaselines(reinterpret_cast<AliHLTPHOSRcuCellEnergyDataStruct*>(iter->fPtr));
    }
  
  fEvCnt++;

  //PushBack(fDigitArrayPtr, kAliHLTAnyDataType, (AliHLTUInt32_t)0);
  
   if(fEvCnt % 10 == 0)
    {
      cout << "Event #: " << fEvCnt << endl;
    }

  if(fEvCnt % fFillInterval == 0)
    {
      fBaselineAnalyzerPtr->FillTree(); 
    }
  if(fEvCnt % fWriteInterval == 0)
    {
      char filename [50];
      cout << "Writing file...";
      sprintf(filename, "%s/run%d_baselineTree_%d.root", fDirectory, fRunNb,fEvCnt/fWriteInterval - 1);
      fBaselineAnalyzerPtr->WriteAccumulatedBaselines(filename);
      cout << "Done!\n";
      delete fTreePtr;
      fTreePtr = new TTree("baselineTree", "Baselines");
      fBaselineAnalyzerPtr->SetRootObjects(fTreePtr, fBaselineArrayPtr);
    }
  
  return 0;
}


int
AliHLTPHOSBaselineAnalyzerComponent::DoInit(int argc, const char** argv )
{
  //See header file for documentation
  
  Bool_t pathSet = false;
  Bool_t histPathSet = false;
  Bool_t nSamplesSet = false;
  
  
  fFilename = new char[50];
  fDirectory = new char[50];
  fHistPath = new char[50];
  

  fstream runNbFile;
  //char dir [10];
  
  //Int_t newRunNb;
  runNbFile.open("/opt/HLT-public/rundir/runNumber.txt");
  runNbFile >> fRunNb;
  runNbFile.close();
  /*  newRunNb = fRunNb + 1;
  runNbFile.open("/opt/HLT-public/rundir/runNumber.txt");
  runNbFile << newRunNb;
  runNbFile.close();*/
  
  //  sprintf(dir, "//tmp//phoshlt//aldaqpc019//hlt//data//baselines//run%d", fRunNb);
  // if(mkdir(dir, 0777))
  //{
  //  cerr << "WARNING! Could not create directory!\n";
  //}
  
  fBaselineAnalyzerPtr = new AliHLTPHOSBaselineAnalyzer();
    
  fTreePtr = new TTree("baselineTree", "Baselines");
  fBaselineArrayPtr = new TClonesArray("AliHLTPHOSBaseline",N_XCOLUMNS_MOD*N_ZROWS_MOD*N_GAINS);
  fBaselineAnalyzerPtr->SetRootObjects(fTreePtr, fBaselineArrayPtr);
  fBaselineAnalyzerPtr->SetMaxCrazyDifference(15);
  fBaselineAnalyzerPtr->SetMaxSignal(120);
   
  for(int i = 0; i < argc; i++)
    {
      if(!strcmp("-totalbaselineoutput", argv[i]))
	{
	  fCalculateAll = true;
	  strcpy(fFilename, argv[i+1]);
	}
      if(!strcmp("-path", argv[i]))
	{
	  strcpy(fDirectory, argv[i+1]);
	  pathSet = true;
	}
	if( !strcmp("-histpath", argv[i]))
	{
	  strcpy(fHistPath, argv[i+1]);
	  histPathSet = true;
	}     
      if(!strcmp("-nsamples", argv[i]))
	{
          fBaselineAnalyzerPtr->SetNumberOfSamples(atoi(argv[i+1]));
	  nSamplesSet = true;
	}	      
      if(!strcmp("-maxsignal", argv[i]))
	{
	  fBaselineAnalyzerPtr->SetMaxSignal(atoi(argv[i+1]));
	}
    }
	
  
  fWriteInterval = 100;
  fFillInterval = 100;
  if(fCalculateAll)
    cout << "Path to total baseline file: " << fFilename << endl;
  cout << endl << "Run number is: " << fRunNb  << "  -- Check that this is correct!!!\n";

  return 0;
}

AliHLTComponent*
AliHLTPHOSBaselineAnalyzerComponent::Spawn()
{
 //See header file for documentation
  return new AliHLTPHOSBaselineAnalyzerComponent();
}

void 
AliHLTPHOSBaselineAnalyzerComponent::CalculateAll()
{
 //See header file for documentation
  cout << "Calculating total baselines... \n";
  AliHLTPHOSBaseline *baselineObject = 0;
  TChain* chain = new TChain("baselineTree");
  TTree* totalTree = new TTree("baselineTree", "Baselines");
  TClonesArray* baselineArray = new TClonesArray("AliHLTPHOSBaseline", N_XCOLUMNS_MOD*N_ZROWS_MOD*N_GAINS);
  TClonesArray* totalBaselineArray = new TClonesArray("AliHLTPHOSBaseline", N_XCOLUMNS_MOD*N_ZROWS_MOD*N_GAINS);
      
  char filepath [50];

  Float_t tmpBaselines[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS][2];
  
  for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
    {
      for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
	{
	  for(UInt_t gain = 0; gain < N_GAINS; gain++)
	    {
	      for(UInt_t d = 0; d < 2; d++)
		{
		  tmpBaselines[x][z][gain][d] = 0;
		}
	    }
	}
    }

  sprintf(filepath, "%s/run%d*", fDirectory, fRunNb);
  cout << "Adding files from: " << filepath << endl;
  chain->Add(filepath);

  cout << "Gives a total number of " << chain->GetEntries() << " events.\n";

  chain->SetBranchAddress("Baselines", &baselineArray);
  totalTree->Branch("Baselines", &totalBaselineArray);

  Int_t nEntries = 0;
  Int_t totEntries = 0;
  Float_t baseline = 0;
  Float_t oldBaseline = 0;

  Int_t x = 0;
  Int_t z = 0;
  Int_t gain = 0;

  for(int i = 0; i < chain->GetEntries(); i++)
    {
      chain->GetEntry(i);
      for(int j = 0; j < baselineArray->GetEntriesFast(); j++)
	{
	  baselineObject = (AliHLTPHOSBaseline*)baselineArray->At(j);
	  x = baselineObject->GetX();
	  z = baselineObject->GetZ();
	  gain = baselineObject->GetGain();
	  nEntries = baselineObject->GetEntries();
	  baseline = baselineObject->GetBaseline();
	  oldBaseline =  tmpBaselines[x][z][gain][0];
	  totEntries =  (Int_t)tmpBaselines[x][z][gain][1];
	  tmpBaselines[x][z][gain][0] = (oldBaseline*totEntries + baseline)/(totEntries + 1);
	  tmpBaselines[x][z][gain][1] = totEntries + 1;
	}
    }

  Int_t n = 0;
  
  for(x = 0; x < (Int_t)N_XCOLUMNS_MOD; x++)
    {
      for(z = 0; z < (Int_t)N_ZROWS_MOD; z++)
	{
	  for(gain = 0; gain < (Int_t)N_GAINS; gain++)
	    {
	      baselineObject = (AliHLTPHOSBaseline*)totalBaselineArray->New(n);
	      baselineObject->SetBaseline(tmpBaselines[x][z][gain][0]);
	      baselineObject->SetX(x);
	      baselineObject->SetZ(z);
	      baselineObject->SetGain(gain);
	      if( tmpBaselines[x][z][gain][1] == 0)
	      {
		cout << "Warning! Number of entries for x: " << x << " - z: " << z << " - gain: " << gain << " = 0\n" 
		    << "Setting baseline to 40\n\n";
		baselineObject->SetBaseline(40);
		continue;
	      }
	      if( tmpBaselines[x][z][gain][1] == 0)
	      {
		cout << "Warning! Number of entries for x: " << x << " - z: " << z << " - gain: " << gain << " = " 
		     << tmpBaselines[x][z][gain][1] << endl;
	      }
	      baselineObject->SetEntries( Int_t(tmpBaselines[x][z][gain][1]) );
	      n++;
	    }
	}
    }

  totalTree->Fill();
 
  cout << "Writing to: " << fFilename << endl;
  TFile *outfile = new TFile(fFilename,"recreate");
  totalTree->Write();
  outfile->Close();
  cout << "Done!\n";

}
Commit	Line	Data
5c6503dc	1
ab38011b	2	/**************************************************************************
	3	* This file is property of and copyright by the ALICE HLT Project *
	4	* All rights reserved. *
	5	* *
	6	* Primary Authors: Oystein Djuvsland *
	7	* *
	8	* Permission to use, copy, modify and distribute this software and its *
	9	* documentation strictly for non-commercial purposes is hereby granted *
	10	* without fee, provided that the above copyright notice appears in all *
	11	* copies and that both the copyright notice and this permission notice *
	12	* appear in the supporting documentation. The authors make no claims *
	13	* about the suitability of this software for any purpose. It is *
	14	* provided "as is" without express or implied warranty. *
	15	**************************************************************************/
5c6503dc	16	#include "AliHLTPHOSBaselineAnalyzerComponent.h"
	17	#include "AliHLTPHOSBaselineAnalyzer.h"
	18	#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
	19	#include "AliHLTPHOSBaseline.h"
	20	#include "TTree.h"
	21	#include "TChain.h"
	22	#include "AliHLTPHOSProcessor.h"
	23	#include "TClonesArray.h"
	24	#include "TFile.h"
	25	//#include <direct.h>
	26	#include <sys/stat.h>
	27	#include <sys/types.h>
	28
2374af72	29	/**
	30	* Class does baseline analysis
	31	*
	32	* @file AliHLTPHOSBaselineAnalyzerComponent.cxx
	33	* @author Oystein Djuvsland
	34	* @date
	35	* @brief A baseline analyzer for PHOS HLT
	36	*/
	37
	38	// see below for class documentation
	39	// or
	40	// refer to README to build package
	41	// or
	42	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	43
5c6503dc	44	const AliHLTComponentDataType AliHLTPHOSBaselineAnalyzerComponent::fgkInputDataTypes[]={kAliHLTVoidDataType,{0,"",""}};
	45
	46	AliHLTPHOSBaselineAnalyzerComponent gAliHLTPHOSBaselineAnalyzerComponent;
	47
	48	AliHLTPHOSBaselineAnalyzerComponent::AliHLTPHOSBaselineAnalyzerComponent() :
	49	AliHLTPHOSProcessor(),
	50	fBaselineAnalyzerPtr(0),
	51	fTreePtr(0),
ab38011b	52	fEvCnt(0),
5c6503dc	53	fWriteInterval(100),
	54	fFillInterval(100),
	55	fFilename(0),
	56	fDirectory(0),
	57	fHistPath(0),
	58	fRunNb(0)
	59	{
2374af72	60	//See header file for documentation
5c6503dc	61	}
	62
	63	AliHLTPHOSBaselineAnalyzerComponent::~AliHLTPHOSBaselineAnalyzerComponent()
	64	{
2374af72	65	//See header file for documentation
5c6503dc	66	}
5c6503dc	67
ab38011b	68
ab38011b	69
5c6503dc	70	int
	71	AliHLTPHOSBaselineAnalyzerComponent::Deinit()
	72	{
2374af72	73	//See header file for documentation
5c6503dc	74	fBaselineAnalyzerPtr->CalculateChannelsBaselineRMS();
	75	char filename [50];
	76	cout << "Writing files...";
ab38011b	77	sprintf(filename, "%s/run%d_baselineTree_%d.root", fDirectory, fRunNb,fEvCnt/fWriteInterval);
5c6503dc	78	fBaselineAnalyzerPtr->WriteAccumulatedBaselines(filename);
	79	sprintf(filename, "%s/run%d_channelHistograms.root", fHistPath, fRunNb);
	80	fBaselineAnalyzerPtr->WriteChannelHistograms(filename);
	81	sprintf(filename, "%s/run%d_RMSHistogram.root", fHistPath, fRunNb);
	82	fBaselineAnalyzerPtr->WriteRMSHistogram(filename);
	83	cout << "Done!\n";
	84
	85	if(fCalculateAll)
	86	{
	87	CalculateAll();
	88	}
	89	if(fBaselineAnalyzerPtr)
	90	{
	91	delete fBaselineAnalyzerPtr;
	92	fBaselineAnalyzerPtr = 0;
	93	}
	94	if(fTreePtr)
	95	{
	96	// delete fTreePtr;
	97	fTreePtr = 0;
	98	}
	99	if(fFilename)
	100	{
	101	delete fFilename;
	102	fFilename = 0;
	103	}
52be7fb0	104	return 0;
5c6503dc	105	}
	106
	107	const char*
	108	AliHLTPHOSBaselineAnalyzerComponent::GetComponentID()
	109	{
2374af72	110	//See header file for documentation
5c6503dc	111	return "PhosBaselineAnalyzer";
	112	}
	113
	114	void
	115
	116	AliHLTPHOSBaselineAnalyzerComponent::GetInputDataTypes(vector<AliHLTComponentDataType>& list)
	117	{
	118	//Get datatypes for input
	119	const AliHLTComponentDataType* pType=fgkInputDataTypes;
	120	while (pType->fID!=0) {
	121	list.push_back(*pType);
	122	pType++;
	123	}
	124	}
	125
	126	AliHLTComponentDataType
	127	AliHLTPHOSBaselineAnalyzerComponent::GetOutputDataType()
	128	{
2374af72	129	//See header file for documentation
5c6503dc	130	return AliHLTPHOSDefinitions::fgkAliHLTBaselineDataType;
	131	}
	132
	133
	134	void
	135	AliHLTPHOSBaselineAnalyzerComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
	136	{
2374af72	137	//See header file for documentation
5c6503dc	138	constBase = 30;
	139	inputMultiplier = 1;
	140	}
	141
	142	int
	143	AliHLTPHOSBaselineAnalyzerComponent::DoEvent(const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks,
1804b020	144	AliHLTComponentTriggerData& /trigData/, AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& /size/, //TODO: I think that not setting the size explicitly to zero when returning from this method may be a subtle bug in this component. Please check.
1804b020	145	std::vector<AliHLTComponentBlockData>& /outputBlocks/)
5c6503dc	146	{
	147	//Do event
	148
1804b020	149	//UInt_t tSize = 0;
	150	//UInt_t offset = 0;
	151	//UInt_t mysize = 0;
	152	//Int_t index = 0;
5c6503dc	153
1804b020	154	//Int_t fileCount = 0;
	155	//Int_t digitCount = 0;
	156	//char filename [50];
5c6503dc	157
	158
	159	AliHLTUInt8_t* outBPtr;
	160	outBPtr = outputPtr;
	161	const AliHLTComponentBlockData* iter = 0;
	162	unsigned long ndx;
	163
	164	for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
	165	{
	166	iter = blocks+ndx;
	167
	168	if(iter->fDataType != AliHLTPHOSDefinitions::fgkCellEnergyDataType)
	169	{
	170	// cout << "Warning: data type is not fgkCellEnergyDataType " << endl;
	171	continue;
	172
	173	}
	174	fBaselineAnalyzerPtr->CalculateRcuBaselines(reinterpret_cast<AliHLTPHOSRcuCellEnergyDataStruct*>(iter->fPtr));
	175	}
	176
ab38011b	177	fEvCnt++;
5c6503dc	178
	179	//PushBack(fDigitArrayPtr, kAliHLTAnyDataType, (AliHLTUInt32_t)0);
	180
ab38011b	181	if(fEvCnt % 10 == 0)
5c6503dc	182	{
ab38011b	183	cout << "Event #: " << fEvCnt << endl;
5c6503dc	184	}
5c6503dc	185
ab38011b	186	if(fEvCnt % fFillInterval == 0)
5c6503dc	187	{
	188	fBaselineAnalyzerPtr->FillTree();
	189	}
ab38011b	190	if(fEvCnt % fWriteInterval == 0)
5c6503dc	191	{
	192	char filename [50];
	193	cout << "Writing file...";
ab38011b	194	sprintf(filename, "%s/run%d_baselineTree_%d.root", fDirectory, fRunNb,fEvCnt/fWriteInterval - 1);
5c6503dc	195	fBaselineAnalyzerPtr->WriteAccumulatedBaselines(filename);
	196	cout << "Done!\n";
	197	delete fTreePtr;
	198	fTreePtr = new TTree("baselineTree", "Baselines");
	199	fBaselineAnalyzerPtr->SetRootObjects(fTreePtr, fBaselineArrayPtr);
	200	}
	201
	202	return 0;
	203	}
	204
	205
	206	int
	207	AliHLTPHOSBaselineAnalyzerComponent::DoInit(int argc, const char** argv )
	208	{
2374af72	209	//See header file for documentation
5c6503dc	210
	211	Bool_t pathSet = false;
	212	Bool_t histPathSet = false;
	213	Bool_t nSamplesSet = false;
	214
	215
	216	fFilename = new char[50];
	217	fDirectory = new char[50];
	218	fHistPath = new char[50];
	219
	220
	221	fstream runNbFile;
	222	//char dir [10];
	223
1804b020	224	//Int_t newRunNb;
5c6503dc	225	runNbFile.open("/opt/HLT-public/rundir/runNumber.txt");
	226	runNbFile >> fRunNb;
	227	runNbFile.close();
	228	/* newRunNb = fRunNb + 1;
	229	runNbFile.open("/opt/HLT-public/rundir/runNumber.txt");
	230	runNbFile << newRunNb;
	231	runNbFile.close();*/
	232
	233	// sprintf(dir, "//tmp//phoshlt//aldaqpc019//hlt//data//baselines//run%d", fRunNb);
	234	// if(mkdir(dir, 0777))
	235	//{
	236	// cerr << "WARNING! Could not create directory!\n";
	237	//}
	238
	239	fBaselineAnalyzerPtr = new AliHLTPHOSBaselineAnalyzer();
	240
	241	fTreePtr = new TTree("baselineTree", "Baselines");
	242	fBaselineArrayPtr = new TClonesArray("AliHLTPHOSBaseline",N_XCOLUMNS_MODN_ZROWS_MODN_GAINS);
	243	fBaselineAnalyzerPtr->SetRootObjects(fTreePtr, fBaselineArrayPtr);
	244	fBaselineAnalyzerPtr->SetMaxCrazyDifference(15);
	245	fBaselineAnalyzerPtr->SetMaxSignal(120);
	246
	247	for(int i = 0; i < argc; i++)
	248	{
	249	if(!strcmp("-totalbaselineoutput", argv[i]))
	250	{
	251	fCalculateAll = true;
	252	strcpy(fFilename, argv[i+1]);
	253	}
	254	if(!strcmp("-path", argv[i]))
	255	{
	256	strcpy(fDirectory, argv[i+1]);
	257	pathSet = true;
	258	}
	259	if( !strcmp("-histpath", argv[i]))
	260	{
	261	strcpy(fHistPath, argv[i+1]);
	262	histPathSet = true;
	263	}
	264	if(!strcmp("-nsamples", argv[i]))
	265	{
	266	fBaselineAnalyzerPtr->SetNumberOfSamples(atoi(argv[i+1]));
	267	nSamplesSet = true;
	268	}
	269	if(!strcmp("-maxsignal", argv[i]))
	270	{
	271	fBaselineAnalyzerPtr->SetMaxSignal(atoi(argv[i+1]));
	272	}
	273	}
	274
	275
	276	fWriteInterval = 100;
	277	fFillInterval = 100;
	278	if(fCalculateAll)
	279	cout << "Path to total baseline file: " << fFilename << endl;
	280	cout << endl << "Run number is: " << fRunNb << " -- Check that this is correct!!!\n";
	281
	282	return 0;
	283	}
	284
	285	AliHLTComponent*
	286	AliHLTPHOSBaselineAnalyzerComponent::Spawn()
	287	{
2374af72	288	//See header file for documentation
5c6503dc	289	return new AliHLTPHOSBaselineAnalyzerComponent();
	290	}
	291
	292	void
	293	AliHLTPHOSBaselineAnalyzerComponent::CalculateAll()
	294	{
2374af72	295	//See header file for documentation
5c6503dc	296	cout << "Calculating total baselines... \n";
	297	AliHLTPHOSBaseline *baselineObject = 0;
	298	TChain* chain = new TChain("baselineTree");
	299	TTree* totalTree = new TTree("baselineTree", "Baselines");
	300	TClonesArray* baselineArray = new TClonesArray("AliHLTPHOSBaseline", N_XCOLUMNS_MODN_ZROWS_MODN_GAINS);
	301	TClonesArray* totalBaselineArray = new TClonesArray("AliHLTPHOSBaseline", N_XCOLUMNS_MODN_ZROWS_MODN_GAINS);
	302
	303	char filepath [50];
	304
	305	Float_t tmpBaselines[N_XCOLUMNS_MOD][N_ZROWS_MOD][N_GAINS][2];
	306
1804b020	307	for(UInt_t x = 0; x < N_XCOLUMNS_MOD; x++)
5c6503dc	308	{
1804b020	309	for(UInt_t z = 0; z < N_ZROWS_MOD; z++)
5c6503dc	310	{
1804b020	311	for(UInt_t gain = 0; gain < N_GAINS; gain++)
5c6503dc	312	{
1804b020	313	for(UInt_t d = 0; d < 2; d++)
5c6503dc	314	{
	315	tmpBaselines[x][z][gain][d] = 0;
	316	}
	317	}
	318	}
	319	}
	320
	321	sprintf(filepath, "%s/run%d*", fDirectory, fRunNb);
	322	cout << "Adding files from: " << filepath << endl;
	323	chain->Add(filepath);
	324
	325	cout << "Gives a total number of " << chain->GetEntries() << " events.\n";
	326
	327	chain->SetBranchAddress("Baselines", &baselineArray);
	328	totalTree->Branch("Baselines", &totalBaselineArray);
	329
	330	Int_t nEntries = 0;
	331	Int_t totEntries = 0;
	332	Float_t baseline = 0;
	333	Float_t oldBaseline = 0;
	334
	335	Int_t x = 0;
	336	Int_t z = 0;
	337	Int_t gain = 0;
	338
	339	for(int i = 0; i < chain->GetEntries(); i++)
	340	{
	341	chain->GetEntry(i);
	342	for(int j = 0; j < baselineArray->GetEntriesFast(); j++)
	343	{
	344	baselineObject = (AliHLTPHOSBaseline*)baselineArray->At(j);
	345	x = baselineObject->GetX();
	346	z = baselineObject->GetZ();
	347	gain = baselineObject->GetGain();
	348	nEntries = baselineObject->GetEntries();
	349	baseline = baselineObject->GetBaseline();
	350	oldBaseline = tmpBaselines[x][z][gain][0];
	351	totEntries = (Int_t)tmpBaselines[x][z][gain][1];
	352	tmpBaselines[x][z][gain][0] = (oldBaseline*totEntries + baseline)/(totEntries + 1);
	353	tmpBaselines[x][z][gain][1] = totEntries + 1;
	354	}
	355	}
	356
	357	Int_t n = 0;
	358
1804b020	359	for(x = 0; x < (Int_t)N_XCOLUMNS_MOD; x++)
5c6503dc	360	{
1804b020	361	for(z = 0; z < (Int_t)N_ZROWS_MOD; z++)
5c6503dc	362	{
1804b020	363	for(gain = 0; gain < (Int_t)N_GAINS; gain++)
5c6503dc	364	{
	365	baselineObject = (AliHLTPHOSBaseline*)totalBaselineArray->New(n);
	366	baselineObject->SetBaseline(tmpBaselines[x][z][gain][0]);
	367	baselineObject->SetX(x);
	368	baselineObject->SetZ(z);
	369	baselineObject->SetGain(gain);
	370	if( tmpBaselines[x][z][gain][1] == 0)
	371	{
	372	cout << "Warning! Number of entries for x: " << x << " - z: " << z << " - gain: " << gain << " = 0\n"
	373	<< "Setting baseline to 40\n\n";
	374	baselineObject->SetBaseline(40);
	375	continue;
	376	}
	377	if( tmpBaselines[x][z][gain][1] == 0)
	378	{
	379	cout << "Warning! Number of entries for x: " << x << " - z: " << z << " - gain: " << gain << " = "
	380	<< tmpBaselines[x][z][gain][1] << endl;
	381	}
1804b020	382	baselineObject->SetEntries( Int_t(tmpBaselines[x][z][gain][1]) );
5c6503dc	383	n++;
	384	}
	385	}
	386	}
	387
	388	totalTree->Fill();
	389
	390	cout << "Writing to: " << fFilename << endl;
	391	TFile *outfile = new TFile(fFilename,"recreate");
	392	totalTree->Write();
	393	outfile->Close();
	394	cout << "Done!\n";
	395
	396	}