HLT component to write data to files. The directory where to write the files
authorphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Feb 2007 15:28:28 +0000 (15:28 +0000)
committerphille <phille@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 9 Feb 2007 15:28:28 +0000 (15:28 +0000)
has to be specified as component argumet with the -directory <directory> option.
At least one data type has to be specified as component argumet with the
-datatype <datatype>. Any number of valid datatype can be specified.
Example of usage.

-componentargs "-directory /home/perthi/HLT/phos/data/  -datatype gkCellEnergyDataType  -datatype gkDDLPackedRawDataType"

The command abowe will write both celle energies and untouched raw RCU data to separate files in the
directory /home/perthi/HLT/phos/data/. Currently one file will be written per event.

HLT/PHOS/AliHLTPHOSFileWriterComponent.cxx
HLT/PHOS/AliHLTPHOSFileWriterComponent.h

index a6559bb65755c800c77cf5cf4667f81794d7dbeb..2ea42c2c95297395b0c43ab2e4f106421157f3a0 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+//#include "AliHLTPHOSFileWriterComponent.h"
+
+
 #include "AliHLTPHOSFileWriterComponent.h"
 #include "AliHLTPHOSFileWriterComponent.h"
+#include <iostream>
+#include "stdio.h"
+#include <TObjString.h>
+
+#include "AliRawReaderMemory.h"
+#include "AliCaloRawStream.h"
+#include <cstdlib>
+#include "AliHLTPHOSRcuCellEnergyDataStruct.h"
+#include "AliHLTPHOSDataHeaderStruct.h"
+#include "AliHLTDataTypes.h"
+
+
+const AliHLTComponentDataType AliHLTPHOSFileWriterComponent::fInputDataTypes[]={kAliHLTVoidDataType,{0,"",""}}; //'zero' terminated array
 
 
 AliHLTPHOSFileWriterComponent gAliHLTPHOSFileWriterComponent;
 
 
 
 AliHLTPHOSFileWriterComponent gAliHLTPHOSFileWriterComponent;
 
-AliHLTPHOSFileWriterComponent::AliHLTPHOSFileWriterComponent():AliHLTFileWriter()
+AliHLTPHOSFileWriterComponent::AliHLTPHOSFileWriterComponent():AliHLTDataSink(), fCellEnergiesFileWriterPtr(0), fDDLPackedFileWriterPtr(0), fDirectory(0),fFilename(0), fEventCount(0)
 {
 {
-  //  cout <<"AliHLTPHOSFileWriterComponent: Creating new FILEWRTER"  << endl;
-  
-} 
+  for(int i=0; i<N_DATATYPES; i++)
+    {
+      fDataTypesToFile[i] = kAliHLTVoidDataType;
+    }
+
+  fCellEnergiesFileWriterPtr = new AliHLTPHOSCellEnergiesFileWriter();
+  fDDLPackedFileWriterPtr    = new AliHLTPHOSDDLPackedFileWriter();
 
 
+} 
 
 AliHLTPHOSFileWriterComponent::~AliHLTPHOSFileWriterComponent()
 {
 
 AliHLTPHOSFileWriterComponent::~AliHLTPHOSFileWriterComponent()
 {
+  delete fCellEnergiesFileWriterPtr;
+  delete fDDLPackedFileWriterPtr;
+}
+
+
+AliHLTPHOSFileWriterComponent::AliHLTPHOSFileWriterComponent(const AliHLTPHOSFileWriterComponent & ):AliHLTDataSink(), fCellEnergiesFileWriterPtr(0), fDDLPackedFileWriterPtr(0), fDirectory(0),fFilename(0), fEventCount(0)
+{
+
+}
 
 
+int 
+AliHLTPHOSFileWriterComponent::AddDataType(string dataType)
+{
+  int ret = -1;
+  int tmpCnt = 0;
+  for(int i=0; i< N_DATATYPES; i++)
+    {
+      if( fDataTypesToFile[i] != kAliHLTVoidDataType)
+       {
+         tmpCnt ++;
+       }
+    }
+  
+  string cmpString("gkCellEnergyDataType");
+
+  if(dataType.compare("gkCellEnergyDataType") == 0)
+    {
+      cout << "!!!!!!!!!!!!!!AliHLTPHOSFileWriterComponent::AddDataType"<< dataType << endl;
+      //    fDataTypesToFilePtr[N_DATATYPES] = new AliHLTPHOSDefinitions::gkCellEnergyDataType;
+      fDataTypesToFile[tmpCnt] = AliHLTPHOSDefinitions::gkCellEnergyDataType; 
+      cout <<"regsitring dataType for filewriting: fDataTypesToFile[" << tmpCnt <<"]"<<endl; 
+    } 
+  else if(dataType.compare("gkDDLPackedRawDataType") == 0)
+    {
+         fDataTypesToFile[tmpCnt] = AliHLTPHOSDefinitions::gkDDLPackedRawDataType; 
+    }
+
+  cout << "dataType.compare(cmpString) = " <<dataType.compare(cmpString)<<endl;
+  return ret;
+}
+
+
+
+
+int 
+AliHLTPHOSFileWriterComponent::Deinit()
+{
+  return 0;
+}
+
+int 
+AliHLTPHOSFileWriterComponent::DoDeinit()
+{
+  Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTPHOSFileWriterComponen DoDeinit");
+  return 0;
 }
 
 const char* 
 AliHLTPHOSFileWriterComponent::GetComponentID()
 {
 }
 
 const char* 
 AliHLTPHOSFileWriterComponent::GetComponentID()
 {
-  //  cout <<"AliHLTPHOSFileWriterComponent::GetComponentID(): Returning ID"  << endl; 
   return "PhosFileWriter";
 }
 
   return "PhosFileWriter";
 }
 
-AliHLTComponent* AliHLTPHOSFileWriterComponent::Spawn()
+AliHLTComponent*
+AliHLTPHOSFileWriterComponent::Spawn()
 {
 {
-  cout <<" AliHLTPHOSFileWriterComponent::Spawn()" << endl;
   return new AliHLTPHOSFileWriterComponent;
 }
 
   return new AliHLTPHOSFileWriterComponent;
 }
 
+
+void
+AliHLTPHOSFileWriterComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
+{
+  const AliHLTComponentDataType* pType=fInputDataTypes;
+  while (pType->fID!=0) {
+    list.push_back(*pType);
+    pType++;
+  }
+}
+
+AliHLTComponentDataType 
+AliHLTPHOSFileWriterComponent::GetOutputDataType()
+{
+  return AliHLTPHOSDefinitions::gkCellEnergyDataType;
+}
+
+void
+AliHLTPHOSFileWriterComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
+
+{
+  constBase = 30;
+  inputMultiplier = 0.1;
+}
+
 int 
 int 
+AliHLTPHOSFileWriterComponent::DumpEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData )
+{
+  UInt_t mysize           = 0;
+  UInt_t tSize            = 0;
+  Int_t tmpChannelCnt     = 0;
+  UInt_t offset           = 0;
+  const AliHLTComponentDataType *tmpDataType; 
+  const AliHLTComponentBlockData* iter = NULL; 
+  unsigned long ndx;
+  AliHLTPHOSDataHeaderStruct  dataHeader;
+  
+  dataHeader.fSize = sizeof(dataHeader); 
+  dataHeader.fEventID =  evtData.fEventID;
+  cout << "analyzing event: " << fEventCount << endl;
+
+  for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+    {
+      iter = blocks+ndx;
+      mysize = 0;
+      offset = tSize;
+      tmpDataType = &(iter->fDataType);
+
+      if(IsRegisteredDataType(*tmpDataType))
+       {
+         if(*tmpDataType == AliHLTPHOSDefinitions::gkCellEnergyDataType)
+           {
+
+             fCellEnergiesFileWriterPtr->WriteFile(evtData, blocks, trigData, fEventCount); 
+             cout <<"AliHLTPHOSFileWriterComponen: data type = is  gkCellEnergyDataType. block index = "<< ndx\
+                  <<" EventCount =" << fEventCount  << "Event ID"<<evtData.fEventID << endl;
+           }
+         else if(*tmpDataType == AliHLTPHOSDefinitions::gkDDLPackedRawDataType)
+           {
+
+              fDDLPackedFileWriterPtr->WriteFile(evtData, blocks, trigData, fEventCount); 
+           }
+       }
+
+      //  cout <<"AliHLTPHOSFileWriterComponen: data type = is  gkCellEnergyDataType. block index = "<< ndx\
+         //               <<" EventCount =" << fEventCount  << "Event ID"<<evtData.fEventID << endl;
+
+      fEventCount++;
+    } 
+  return 0;
+}//end DumpEvent
+
+
+int
 AliHLTPHOSFileWriterComponent::DoInit( int argc, const char** argv )
 {
 AliHLTPHOSFileWriterComponent::DoInit( int argc, const char** argv )
 {
-   cout <<" AliHLTPHOSFileWriterComponent::DoInit()" << endl;
-   return 0;
+  int iResult=0;
+  TString argument="";
+  Bool_t dirSet = kFALSE;
+  Bool_t dataSet = kFALSE;
+  string dataType="";
+  int bMissingParam=0;
+
+  fFilename.assign(256,0);
+
+  for(int i=0; i<argc; i++)
+    {
+      argument=argv[i];
+      if(argument.CompareTo("-directory")==0) 
+       {
+         if ((bMissingParam=(++i>=argc))) 
+           {
+             break;
+           }
+         fDirectory.assign(argv[i]);
+         fCellEnergiesFileWriterPtr->SetDirectory(fDirectory);
+         fDDLPackedFileWriterPtr->SetDirectory(fDirectory) ;
 
 
+         fFilename.insert(0, fDirectory);
+         dirSet = kTRUE;
+         
+         cout << "fDirectory=" << fDirectory << endl;
+       }
+
+      if(argument.CompareTo("-datatype")==0) 
+       {
+         if ((bMissingParam=(++i>=argc))) break;
+         cout << "datatype = " << argv[i] << endl;
+         dataType = argv[i];
+         
+         AddDataType(dataType);
+         dataSet = kTRUE;
+       }
+      
+      cout << "argv[" << i <<"] = " << argv[i] << endl;
+
+    }
+
+  /*
+   * We dont start the component if we don know what data to write
+   * or where to store it
+   */
+  if((dataSet != kTRUE || dataSet != kTRUE))
+    {
+      iResult = -1;
+      HLTFatal(" either direcory or datatype is not set, usage -datatype <datatype>  -driectory <directory>");
+    }
+  else
+    {
+      iResult = 0;
+    }
+  return iResult;
 }
 
 
 }
 
 
+Bool_t 
+AliHLTPHOSFileWriterComponent::IsRegisteredDataType(const AliHLTComponentDataType& dataType)
+{
+  Bool_t tmp = kFALSE;
+  for(int i =0; i<N_DATATYPES; i++)
+    {
+      if((fDataTypesToFile[i] == dataType) && (dataType !=  kAliHLTVoidDataType))
+       {
+         tmp = kTRUE;
+       }
+    }
+
+  return tmp;
+}
+
index 0239dc50f18850625021ef197ec5f2fa07a64dd1..c7080fdd17b1be1e9c83fe605e1b82d91ea46b24 100644 (file)
@@ -1,23 +1,53 @@
-#ifndef ALIHLTPHOSFILEWRITER_H
-#define ALIHLTPHOSFILEWRITER_H
+#ifndef ALIHLTPHOSFILEWRITERCOMPONENT_H
+#define ALIHLTPHOSFILEWRITERCOMPONENT_H
 
 
-#include "AliHLTComponent.h"
-#include "AliHLTFileWriter.h" 
+#include "AliHLTDataSink.h"
+#include "AliHLTPHOSFileWriterComponent.h"
+#include "AliRawReaderMemory.h"
+#include "AliCaloRawStream.h"
+#include "AliHLTPHOSDefinitions.h"
+#include <string>
+#include "AliHLTPHOSCommonDefs.h"
+#include "AliHLTPHOSFileWriter.h"
+#include "AliHLTPHOSCellEnergiesFileWriter.h"
+#include "AliHLTPHOSDDLPackedFileWriter.h"  
+#include "Rtypes.h"
 
 
-/* Copyright(c) 1998-2004, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
+using std::string;
 
 
-class AliHLTPHOSFileWriterComponent : public AliHLTFileWriter
+class AliHLTPHOSRcuCellEnergyDataStruct;
+class AliHLTPHOSFileWriterComponent:public AliHLTDataSink
 {
  public:
   AliHLTPHOSFileWriterComponent();
 {
  public:
   AliHLTPHOSFileWriterComponent();
-  ~AliHLTPHOSFileWriterComponent();
-  //  virtual AliHLTComponent* Spawn();
-  AliHLTComponent* Spawn();
+  virtual ~AliHLTPHOSFileWriterComponent();
+  int AddDataType(string dataType);
+  virtual int DoInit( int argc, const char** argv );
+  virtual int Deinit();
+  virtual int DoDeinit();
+  virtual int DumpEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& trigData );
+  virtual const char* GetComponentID();
+  virtual void GetInputDataTypes(std::vector<AliHLTComponentDataType, std::allocator<AliHLTComponentDataType> >&);
+  virtual AliHLTComponentDataType GetOutputDataType();
+  virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
+  virtual AliHLTComponent* Spawn();
 
 
-  int DoInit( int argc, const char** argv );
+ protected:
 
 
-  const char* GetComponentID();
+ private:
+  AliHLTPHOSFileWriterComponent(const AliHLTPHOSFileWriterComponent & );  
+  AliHLTPHOSFileWriterComponent & operator = (const AliHLTPHOSFileWriterComponent)
+    {
+      return *this;
+    };
+  AliHLTPHOSCellEnergiesFileWriter *fCellEnergiesFileWriterPtr;
+  AliHLTPHOSDDLPackedFileWriter    *fDDLPackedFileWriterPtr ;
+  string  fDirectory; /**<target directory for files*/
+  string  fFilename;  /**<the basename of the output file*/
+  AliHLTComponentDataType fDataTypesToFile[N_DATATYPES];
+  Bool_t IsRegisteredDataType(const AliHLTComponentDataType&);
+  int fEventCount;
+  static const AliHLTComponentDataType fInputDataTypes[];
 };
 };
-
 #endif
 #endif