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

// @(#) $Id$

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Matthias Richter <Matthias.Richter@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   AliHLTTPCEsdWriterComponent.cxx
    @author Matthias Richter
    @date   
    @brief  Writer component to store tracks of the HLT TPC conformal
            mapping tracker in the AliESD format

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

#include <cassert>
#include "AliHLTTPCEsdWriterComponent.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "TTree.h"
#include "TFile.h"
#include "AliHLTTPCTrack.h"
#include "AliHLTTPCTrackArray.h"
#include "AliHLTTPCTrackletDataFormat.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCTransform.h"

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

AliHLTTPCEsdWriterComponent::AliHLTTPCEsdWriterComponent()
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

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

AliHLTTPCEsdWriterComponent::AliWriter::AliWriter()
  :
  fTree(NULL),
  fESD(NULL),
  fBase(new AliHLTTPCEsdWriterComponent)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTTPCEsdWriterComponent::AliWriter::~AliWriter()
{
  // see header file for class documentation
  if (fBase) delete fBase;
  fBase=NULL;
}

void AliHLTTPCEsdWriterComponent::AliWriter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
{
  // see header file for class documentation
  list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
}

int AliHLTTPCEsdWriterComponent::AliWriter::InitWriter()
{
  // see header file for class documentation
  int iResult=0;
  fESD = new AliESDEvent;
  if (fESD) {
    fESD->CreateStdContent();
    // we have to open a TFile in order to avoid warnings related to
    // memory resident TTree's. Bad Root feature, yes ;-(
    // Unfortunatly, opening a dummy file leads to the file to be
    // created.
    //TFile dummy("/tmp/dummy-to-avoid-ttree-warnigs", "CRAETE");
    fTree = new TTree("esdTree", "Tree with HLT ESD objects");
    if (fTree) {
      fESD->WriteToTree(fTree);
    }
  }
  if (fTree==NULL) {
    iResult=-ENOMEM;
  }
  return iResult;
}

int AliHLTTPCEsdWriterComponent::AliWriter::CloseWriter()
{
  // see header file for class documentation
  int iResult=0;
  if (fTree) {
    WriteObject(kAliHLTVoidEventID, fTree);
    TTree* pTree=fTree;
    fTree=NULL;
    delete pTree;
  } else {
    HLTWarning("not initialized");
  }
  iResult=AliHLTRootFileWriterComponent::CloseWriter();
  return iResult;
}

int AliHLTTPCEsdWriterComponent::AliWriter::DumpEvent( const AliHLTComponentEventData& evtData,
					    const AliHLTComponentBlockData* blocks, 
					    AliHLTComponentTriggerData& /*trigData*/ )
{
  // see header file for class documentation
  int iResult=0;
  TTree* pTree=fTree;
  assert(fBase);
  if (pTree && fBase) {
    if (fESD) {
      AliESDEvent* pESD=fESD;

      iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt);

    } else {
      iResult=-ENOMEM;
    }
  }
  return iResult;
}

int AliHLTTPCEsdWriterComponent::AliWriter::ScanArgument(int argc, const char** argv)
{
  // see header file for class documentation
  int iResult=AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
  return iResult;
}

int AliHLTTPCEsdWriterComponent::ProcessBlocks(TTree* pTree, AliESDEvent* pESD,
					       const AliHLTComponentBlockData* blocks,
					       int nBlocks, int* pMinSlice,
					       int* pMaxSlice)
{
  // see header file for class documentation
  int iResult=0;
  if (pESD && blocks) {
      const AliHLTComponentBlockData* iter = NULL;
      AliHLTTPCTrackletData* inPtr=NULL;
      int bIsTrackSegs=0;
 
      for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
	iter = blocks+ndx;
	if ( (bIsTrackSegs=(iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType))==1 ||
	     iter->fDataType == AliHLTTPCDefinitions::fgkTracksDataType ) {
	  Int_t minslice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
	  Int_t maxslice=AliHLTTPCDefinitions::GetMaxSliceNr(iter->fSpecification);
	  if (bIsTrackSegs==0) {
	    // slice parameter and data specification ignored, tracks already in global coordinates
	    minslice=-1;
	    maxslice=-1;
	    if (pMinSlice) *pMinSlice=0;
	    if (pMaxSlice) *pMaxSlice=AliHLTTPCTransform::GetNSlice()-1;
	  } else {
	    if (pMinSlice && (*pMinSlice==-1 || *pMinSlice>minslice)) *pMinSlice=minslice;
	    if (pMaxSlice && (*pMaxSlice==-1 || *pMaxSlice<maxslice)) *pMaxSlice=maxslice;
	  }
	  //HLTDebug("dataspec %#x minslice %d", iter->fSpecification, minslice);
	  if (minslice >=-1 && minslice<AliHLTTPCTransform::GetNSlice()) {
	    if (minslice!=maxslice) {
	      HLTWarning("data from multiple sectors in one block: "
			 "possible missmatch in treatment of local coordinate system");
	    }
	    AliHLTTPCTrackArray tracks;
	    inPtr=(AliHLTTPCTrackletData*)iter->fPtr;
	    HLTDebug("reading block %d (slice %d): %d tracklets", ndx, minslice, inPtr->fTrackletCnt);
	    tracks.FillTracks(inPtr->fTrackletCnt, inPtr->fTracklets, minslice, 0/*don't rotate*/);
	    if ((iResult=Tracks2ESD(&tracks, pESD))>=0) {
	    }
	  } else {
	    HLTError("invalid sector number");
	    iResult=-EBADF;
	  }
	}
      }
      if (iResult>=0 && pTree) {
	pTree->Fill();
      }

      pESD->Reset();
    
  } else {
    HLTError("invalid paremeter");
    iResult=-EINVAL;
  }
  return iResult;
}

int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD)
{
  // see header file for class documentation
  int iResult=0;
  if (pTracks && pESD) {
    HLTDebug("converting %d tracks from track array", pTracks->GetNTracks());
    for (int i=0; i<pTracks->GetNTracks() && iResult>=0; i++) {
      AliHLTTPCTrack* pTrack=(*pTracks)[i];
      if (pTrack) {
	//HLTDebug("convert track %d", i);
	//pTrack->Print();
	int iLocal=pTrack->Convert2AliKalmanTrack();
	if (iLocal>=0) {
	AliESDtrack iotrack;
	iotrack.UpdateTrackParams(pTrack,AliESDtrack::kTPCin);
	iotrack.SetTPCPoints(pTrack->GetPoints());
	pESD->AddTrack(&iotrack);
	} else {
	  HLTError("conversion to AliKalmanTrack failed for track %d of %d", i, pTracks->GetNTracks());
	}
      } else {
	HLTError("internal missmatch in array");
	iResult=-EFAULT;
      }
    }
    
  } else {
    iResult=-EINVAL;
  }
  return iResult;
}

AliHLTTPCEsdWriterComponent::AliConverter::AliConverter()
  :
  fBase(new AliHLTTPCEsdWriterComponent),
  fWriteTree(1)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTTPCEsdWriterComponent::AliConverter::~AliConverter()
{
  // see header file for class documentation
  if (fBase) delete fBase;
  fBase=NULL;
}

void AliHLTTPCEsdWriterComponent::AliConverter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
{
  // see header file for class documentation
  list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
}

AliHLTComponentDataType AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataType()
{
  // see header file for class documentation
  return kAliHLTDataTypeESDTree;
}

void AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
{
  // see header file for class documentation
  constBase=1000000;
  inputMultiplier=1.0;
}

int AliHLTTPCEsdWriterComponent::AliConverter::DoInit(int argc, const char** argv)
{
  // see header file for class documentation
  int iResult=0;
  TString argument="";
  int bMissingParam=0;
  for (int i=0; i<argc && iResult>=0; i++) {
    argument=argv[i];
    if (argument.IsNull()) continue;

    // -notree
    if (argument.CompareTo("-notree")==0) {
      fWriteTree=0;

      // -tree
    } else if (argument.CompareTo("-tree")==0) {
      fWriteTree=1;

    } else {
      HLTError("unknown argument %s", argument.Data());
      break;
    }
  }
  if (bMissingParam) {
    HLTError("missing parameter for argument %s", argument.Data());
    iResult=-EINVAL;
  }

  return iResult;
}

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

int AliHLTTPCEsdWriterComponent::AliConverter::DoEvent(const AliHLTComponentEventData& evtData, 
						       const AliHLTComponentBlockData* blocks, 
						       AliHLTComponentTriggerData& /*trigData*/,
						       AliHLTUInt8_t* /*outputPtr*/, 
						       AliHLTUInt32_t& /*size*/,
						       AliHLTComponentBlockDataList& /*outputBlocks*/ )
{
  // see header file for class documentation
  int iResult=0;
  assert(fBase);
  // we have to open a TFile in order to avoid warnings related to
  // memory resident TTree's. Bad Root feature, yes ;-(
  // Unfortunatly, opening a dummy file leads to the file to be
  // created.
  //TFile dummy("/tmp/dummy-to-avoid-ttree-warnigs", "RECREATE");
  AliESDEvent* pESD = new AliESDEvent;
  if (pESD && fBase) {
    pESD->CreateStdContent();
    TTree* pTree = NULL;
    // TODO: Matthias 06.12.2007
    // Tried to write the ESD directly instead to a tree, but this did not work
    // out. Information in the ESD is different, needs investigation.
    if (fWriteTree)
      pTree = new TTree("esdTree", "Tree with HLT ESD objects");
    if (pTree) {
      pESD->WriteToTree(pTree);
    }

    if ((iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt))>=0) {
	// TODO: set the specification correctly
      if (pTree)
	iResult=PushBack(pTree, kAliHLTDataTypeESDTree|kAliHLTDataOriginTPC, 0);
      else
	iResult=PushBack(pESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginTPC, 0);
    }
    if (pTree)
      delete pTree;

    delete pESD;
  }
  return iResult;
}
Commit	Line	Data
3cde846d	1	// @(#) $Id$
3cde846d	2
2a083ac4	3	/**************************************************************************
9be2600f	4	* This file is property of and copyright by the ALICE HLT Project *
9be2600f	5	* ALICE Experiment at CERN, All rights reserved. *
2a083ac4	6	* *
9be2600f	7	* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
9be2600f	8	* for The ALICE HLT Project. *
2a083ac4	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
3cde846d	19	/** @file AliHLTTPCEsdWriterComponent.cxx
	20	@author Matthias Richter
	21	@date
	22	@brief Writer component to store tracks of the HLT TPC conformal
	23	mapping tracker in the AliESD format
	24
	25	*/
f32b83e1	26	// see header file for class documentation
	27	// or
	28	// refer to README to build package
	29	// or
	30	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	31
37513ae4	32	#include <cassert>
3cde846d	33	#include "AliHLTTPCEsdWriterComponent.h"
af885e0f	34	#include "AliESDEvent.h"
d523f52c	35	#include "AliESDtrack.h"
3cde846d	36	#include "TTree.h"
a978c0d5	37	#include "TFile.h"
3cde846d	38	#include "AliHLTTPCTrack.h"
	39	#include "AliHLTTPCTrackArray.h"
	40	#include "AliHLTTPCTrackletDataFormat.h"
	41	#include "AliHLTTPCDefinitions.h"
37513ae4	42	#include "AliHLTTPCTransform.h"
3cde846d	43
3cde846d	44	/** ROOT macro for the implementation of ROOT specific class methods */
	45	ClassImp(AliHLTTPCEsdWriterComponent)
	46
	47	AliHLTTPCEsdWriterComponent::AliHLTTPCEsdWriterComponent()
37513ae4	48	{
	49	// see header file for class documentation
	50	// or
	51	// refer to README to build package
	52	// or
	53	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	54	}
	55
	56	AliHLTTPCEsdWriterComponent::~AliHLTTPCEsdWriterComponent()
	57	{
	58	// see header file for class documentation
	59	}
	60
	61	AliHLTTPCEsdWriterComponent::AliWriter::AliWriter()
3cde846d	62	:
3cde846d	63	fTree(NULL),
37513ae4	64	fESD(NULL),
37513ae4	65	fBase(new AliHLTTPCEsdWriterComponent)
3cde846d	66	{
2a083ac4	67	// see header file for class documentation
	68	// or
	69	// refer to README to build package
	70	// or
	71	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
3cde846d	72	}
3cde846d	73
37513ae4	74	AliHLTTPCEsdWriterComponent::AliWriter::~AliWriter()
	75	{
	76	// see header file for class documentation
	77	if (fBase) delete fBase;
	78	fBase=NULL;
	79	}
	80
	81	void AliHLTTPCEsdWriterComponent::AliWriter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
3cde846d	82	{
2a083ac4	83	// see header file for class documentation
37513ae4	84	list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
3cde846d	85	}
3cde846d	86
37513ae4	87	int AliHLTTPCEsdWriterComponent::AliWriter::InitWriter()
3cde846d	88	{
2a083ac4	89	// see header file for class documentation
3cde846d	90	int iResult=0;
af885e0f	91	fESD = new AliESDEvent;
3cde846d	92	if (fESD) {
76e61c6e	93	fESD->CreateStdContent();
a978c0d5	94	// we have to open a TFile in order to avoid warnings related to
	95	// memory resident TTree's. Bad Root feature, yes ;-(
	96	// Unfortunatly, opening a dummy file leads to the file to be
	97	// created.
	98	//TFile dummy("/tmp/dummy-to-avoid-ttree-warnigs", "CRAETE");
3cde846d	99	fTree = new TTree("esdTree", "Tree with HLT ESD objects");
3cde846d	100	if (fTree) {
af885e0f	101	fESD->WriteToTree(fTree);
3cde846d	102	}
3cde846d	103	}
	104	if (fTree==NULL) {
	105	iResult=-ENOMEM;
	106	}
	107	return iResult;
	108	}
	109
37513ae4	110	int AliHLTTPCEsdWriterComponent::AliWriter::CloseWriter()
3cde846d	111	{
2a083ac4	112	// see header file for class documentation
3cde846d	113	int iResult=0;
	114	if (fTree) {
	115	WriteObject(kAliHLTVoidEventID, fTree);
	116	TTree* pTree=fTree;
	117	fTree=NULL;
	118	delete pTree;
	119	} else {
	120	HLTWarning("not initialized");
	121	}
2a083ac4	122	iResult=AliHLTRootFileWriterComponent::CloseWriter();
2a083ac4	123	return iResult;
3cde846d	124	}
3cde846d	125
37513ae4	126	int AliHLTTPCEsdWriterComponent::AliWriter::DumpEvent( const AliHLTComponentEventData& evtData,
3cde846d	127	const AliHLTComponentBlockData* blocks,
5d2abf3b	128	AliHLTComponentTriggerData& /trigData/ )
3cde846d	129	{
2a083ac4	130	// see header file for class documentation
3cde846d	131	int iResult=0;
3cde846d	132	TTree* pTree=fTree;
37513ae4	133	assert(fBase);
37513ae4	134	if (pTree && fBase) {
3cde846d	135	if (fESD) {
af885e0f	136	AliESDEvent* pESD=fESD;
3cde846d	137
37513ae4	138	iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt);
	139
	140	} else {
	141	iResult=-ENOMEM;
	142	}
	143	}
	144	return iResult;
	145	}
	146
	147	int AliHLTTPCEsdWriterComponent::AliWriter::ScanArgument(int argc, const char** argv)
	148	{
	149	// see header file for class documentation
	150	int iResult=AliHLTRootFileWriterComponent::ScanArgument(argc, argv);
	151	return iResult;
	152	}
	153
	154	int AliHLTTPCEsdWriterComponent::ProcessBlocks(TTree* pTree, AliESDEvent* pESD,
	155	const AliHLTComponentBlockData* blocks,
	156	int nBlocks, int* pMinSlice,
	157	int* pMaxSlice)
	158	{
	159	// see header file for class documentation
	160	int iResult=0;
a978c0d5	161	if (pESD && blocks) {
3cde846d	162	const AliHLTComponentBlockData* iter = NULL;
3cde846d	163	AliHLTTPCTrackletData* inPtr=NULL;
de554e07	164	int bIsTrackSegs=0;
3cde846d	165
37513ae4	166	for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
3cde846d	167	iter = blocks+ndx;
96bda103	168	if ( (bIsTrackSegs=(iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType))==1 \|\|
96bda103	169	iter->fDataType == AliHLTTPCDefinitions::fgkTracksDataType ) {
4fdaad1e	170	Int_t minslice=AliHLTTPCDefinitions::GetMinSliceNr(iter->fSpecification);
4fdaad1e	171	Int_t maxslice=AliHLTTPCDefinitions::GetMaxSliceNr(iter->fSpecification);
de554e07	172	if (bIsTrackSegs==0) {
de554e07	173	// slice parameter and data specification ignored, tracks already in global coordinates
b09663cd	174	minslice=-1;
b09663cd	175	maxslice=-1;
37513ae4	176	if (pMinSlice) *pMinSlice=0;
	177	if (pMaxSlice) *pMaxSlice=AliHLTTPCTransform::GetNSlice()-1;
	178	} else {
	179	if (pMinSlice && (pMinSlice==-1 \|\| pMinSlice>minslice)) *pMinSlice=minslice;
	180	if (pMaxSlice && (pMaxSlice==-1 \|\| pMaxSlice<maxslice)) *pMaxSlice=maxslice;
de554e07	181	}
4fdaad1e	182	//HLTDebug("dataspec %#x minslice %d", iter->fSpecification, minslice);
37513ae4	183	if (minslice >=-1 && minslice<AliHLTTPCTransform::GetNSlice()) {
4fdaad1e	184	if (minslice!=maxslice) {
	185	HLTWarning("data from multiple sectors in one block: "
	186	"possible missmatch in treatment of local coordinate system");
	187	}
	188	AliHLTTPCTrackArray tracks;
	189	inPtr=(AliHLTTPCTrackletData*)iter->fPtr;
	190	HLTDebug("reading block %d (slice %d): %d tracklets", ndx, minslice, inPtr->fTrackletCnt);
	191	tracks.FillTracks(inPtr->fTrackletCnt, inPtr->fTracklets, minslice, 0/don't rotate/);
	192	if ((iResult=Tracks2ESD(&tracks, pESD))>=0) {
3cde846d	193	}
3cde846d	194	} else {
4fdaad1e	195	HLTError("invalid sector number");
4fdaad1e	196	iResult=-EBADF;
3cde846d	197	}
	198	}
	199	}
a978c0d5	200	if (iResult>=0 && pTree) {
4fdaad1e	201	pTree->Fill();
4fdaad1e	202	}
3cde846d	203
37513ae4	204	pESD->Reset();
	205
	206	} else {
a978c0d5	207	HLTError("invalid paremeter");
37513ae4	208	iResult=-EINVAL;
3cde846d	209	}
	210	return iResult;
	211	}
	212
af885e0f	213	int AliHLTTPCEsdWriterComponent::Tracks2ESD(AliHLTTPCTrackArray* pTracks, AliESDEvent* pESD)
3cde846d	214	{
2a083ac4	215	// see header file for class documentation
3cde846d	216	int iResult=0;
	217	if (pTracks && pESD) {
	218	HLTDebug("converting %d tracks from track array", pTracks->GetNTracks());
	219	for (int i=0; i<pTracks->GetNTracks() && iResult>=0; i++) {
	220	AliHLTTPCTrack* pTrack=(*pTracks)[i];
	221	if (pTrack) {
04dbc9e4	222	//HLTDebug("convert track %d", i);
04dbc9e4	223	//pTrack->Print();
3cde846d	224	int iLocal=pTrack->Convert2AliKalmanTrack();
	225	if (iLocal>=0) {
	226	AliESDtrack iotrack;
	227	iotrack.UpdateTrackParams(pTrack,AliESDtrack::kTPCin);
	228	iotrack.SetTPCPoints(pTrack->GetPoints());
	229	pESD->AddTrack(&iotrack);
	230	} else {
	231	HLTError("conversion to AliKalmanTrack failed for track %d of %d", i, pTracks->GetNTracks());
	232	}
	233	} else {
	234	HLTError("internal missmatch in array");
	235	iResult=-EFAULT;
	236	}
	237	}
	238
	239	} else {
	240	iResult=-EINVAL;
	241	}
	242	return iResult;
	243	}
37513ae4	244
	245	AliHLTTPCEsdWriterComponent::AliConverter::AliConverter()
	246	:
a978c0d5	247	fBase(new AliHLTTPCEsdWriterComponent),
a978c0d5	248	fWriteTree(1)
37513ae4	249	{
	250	// see header file for class documentation
	251	// or
	252	// refer to README to build package
	253	// or
	254	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	255	}
	256
	257	AliHLTTPCEsdWriterComponent::AliConverter::~AliConverter()
	258	{
	259	// see header file for class documentation
	260	if (fBase) delete fBase;
	261	fBase=NULL;
	262	}
	263
	264	void AliHLTTPCEsdWriterComponent::AliConverter::GetInputDataTypes(AliHLTComponentDataTypeList& list)
	265	{
	266	// see header file for class documentation
	267	list.push_back(AliHLTTPCDefinitions::fgkTrackSegmentsDataType);
	268	}
	269
	270	AliHLTComponentDataType AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataType()
	271	{
	272	// see header file for class documentation
	273	return kAliHLTDataTypeESDTree;
	274	}
	275
	276	void AliHLTTPCEsdWriterComponent::AliConverter::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
	277	{
	278	// see header file for class documentation
	279	constBase=1000000;
	280	inputMultiplier=1.0;
	281	}
	282
	283	int AliHLTTPCEsdWriterComponent::AliConverter::DoInit(int argc, const char** argv)
	284	{
	285	// see header file for class documentation
a978c0d5	286	int iResult=0;
	287	TString argument="";
	288	int bMissingParam=0;
	289	for (int i=0; i<argc && iResult>=0; i++) {
	290	argument=argv[i];
	291	if (argument.IsNull()) continue;
	292
	293	// -notree
	294	if (argument.CompareTo("-notree")==0) {
	295	fWriteTree=0;
	296
	297	// -tree
	298	} else if (argument.CompareTo("-tree")==0) {
	299	fWriteTree=1;
	300
	301	} else {
	302	HLTError("unknown argument %s", argument.Data());
	303	break;
	304	}
	305	}
	306	if (bMissingParam) {
	307	HLTError("missing parameter for argument %s", argument.Data());
	308	iResult=-EINVAL;
	309	}
	310
	311	return iResult;
37513ae4	312	}
	313
	314	int AliHLTTPCEsdWriterComponent::AliConverter::DoDeinit()
	315	{
	316	// see header file for class documentation
	317	return 0;
	318	}
	319
	320	int AliHLTTPCEsdWriterComponent::AliConverter::DoEvent(const AliHLTComponentEventData& evtData,
	321	const AliHLTComponentBlockData* blocks,
	322	AliHLTComponentTriggerData& /trigData/,
	323	AliHLTUInt8_t* /outputPtr/,
	324	AliHLTUInt32_t& /size/,
	325	AliHLTComponentBlockDataList& /outputBlocks/ )
	326	{
	327	// see header file for class documentation
	328	int iResult=0;
	329	assert(fBase);
a978c0d5	330	// we have to open a TFile in order to avoid warnings related to
	331	// memory resident TTree's. Bad Root feature, yes ;-(
	332	// Unfortunatly, opening a dummy file leads to the file to be
	333	// created.
	334	//TFile dummy("/tmp/dummy-to-avoid-ttree-warnigs", "RECREATE");
37513ae4	335	AliESDEvent* pESD = new AliESDEvent;
	336	if (pESD && fBase) {
	337	pESD->CreateStdContent();
a978c0d5	338	TTree* pTree = NULL;
	339	// TODO: Matthias 06.12.2007
	340	// Tried to write the ESD directly instead to a tree, but this did not work
	341	// out. Information in the ESD is different, needs investigation.
	342	if (fWriteTree)
	343	pTree = new TTree("esdTree", "Tree with HLT ESD objects");
37513ae4	344	if (pTree) {
37513ae4	345	pESD->WriteToTree(pTree);
a978c0d5	346	}
37513ae4	347
a978c0d5	348	if ((iResult=fBase->ProcessBlocks(pTree, pESD, blocks, (int)evtData.fBlockCnt))>=0) {
37513ae4	349	// TODO: set the specification correctly
a978c0d5	350	if (pTree)
37513ae4	351	iResult=PushBack(pTree, kAliHLTDataTypeESDTree\|kAliHLTDataOriginTPC, 0);
a978c0d5	352	else
a978c0d5	353	iResult=PushBack(pESD, kAliHLTDataTypeESDObject\|kAliHLTDataOriginTPC, 0);
37513ae4	354	}
a978c0d5	355	if (pTree)
	356	delete pTree;
	357
37513ae4	358	delete pESD;
	359	}
	360	return iResult;
	361	}
	362