Refactoring and moving some PHOS code which will be used for both calorimeters to...
authorodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 5 Oct 2009 11:20:44 +0000 (11:20 +0000)
committerodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 5 Oct 2009 11:20:44 +0000 (11:20 +0000)
 This includes class involved with the extraction of energy and time from the raw data, mapping parameters, constants common
 for both calorimeters and some utilities. (Per Thomas/Svein)

35 files changed:
HLT/CALO/AliHLTCALODecoderWrapper.cxx
HLT/CALO/AliHLTCALODecoderWrapper.h
HLT/CALO/AliHLTCaloAltroConfig.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloChannelDataHeaderStruct.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloChannelDataStruct.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloChannelRawDataStruct.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloConstants.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloCoordinate.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloDefinitions.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloDefinitions.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloLinkDef.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloMapper.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloMapper.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloProcessor.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloProcessor.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzer.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzer.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerChiSquareFit.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerChiSquareFit.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerCrude.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerCrude.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerCrudeComponent.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerCrudeComponent.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerPeakFinder.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerPeakFinder.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerPeakFinderComponent.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRawAnalyzerPeakFinderComponent.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloRcuProcessor.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloRcuProcessor.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloSanityInspector.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloSanityInspector.h [new file with mode: 0644]
HLT/CALO/AliHLTCaloUtilities.cxx [new file with mode: 0644]
HLT/CALO/AliHLTCaloUtilities.h [new file with mode: 0644]

index cb77e46..ce1c7fd 100644 (file)
@@ -31,19 +31,21 @@ AliHLTCALODecoderWrapper::AliHLTCALODecoderWrapper() : fAltroRawStream(0),
                                                       //      fCaloRawStream(0),
                                                       fReaderMemory(0)
 {
+  // See header file for documentation
   fReaderMemory  = new AliRawReaderMemory();
 }
 
 
 AliHLTCALODecoderWrapper::~AliHLTCALODecoderWrapper()
 {
-
+  // See header file for documentation
 }
 
 
 void 
 AliHLTCALODecoderWrapper::SetMemory( AliHLTComponentBlockData *dtaptr    ) 
 {
+  // See header file for documentation
   if ( fAltroRawStream   !=  0 )
     {
       delete  fAltroRawStream;
index d5deaa5..b013c47 100644 (file)
@@ -19,6 +19,9 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+
+// TODO: Documentation
+
 #include "Rtypes.h"
 
 /*
diff --git a/HLT/CALO/AliHLTCaloAltroConfig.h b/HLT/CALO/AliHLTCaloAltroConfig.h
new file mode 100644 (file)
index 0000000..1e5df1e
--- /dev/null
@@ -0,0 +1,50 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloAltroConfig.h 29824 2008-11-10 13:43:55Z richterm $
+
+#ifndef ALIHLTCALOALTROCONFIG_H
+#define ALIHLTCALOALTROCONFIG_H
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+
+class  AliHLTCaloAltroConfig
+{
+public:
+  AliHLTCaloAltroConfig();
+  virtual ~AliHLTCaloAltroConfig();
+  void SetNPresSamples(const int presamples);
+  void SetNSamples(const int samples);
+  void SetAltroZeroSupression(const bool isZerosupressed);
+  void SetAltroBaselineSubtraction(const bool isAltroBaselineSubtraction);
+  //  void SetSoftwareBaselineSubtraction(bool isSoftwareBaselineSubtraction);
+  int  GetNPresSamples() const {return  fNPresamples;}; 
+  int  GetNSamples() const {return  fNSamples;}; 
+  bool GetIsAltroZroSupresses() const {return   fIsAltroZeroSupressed;}; 
+  bool GetIsAltroBaselineSubtraction() const {return fIsAltroBaselineSubtraction;};
+  void PrintAltroDefaultValues() const;
+
+protected:
+  //Altro Config
+  int fNPresamples; //comment
+  int fNSamples; //comment
+  int fNTotalSamples; //comment
+  bool fIsAltroZeroSupressed; //comment
+  bool fIsAltroBaselineSubtraction; //comment
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloChannelDataHeaderStruct.h b/HLT/CALO/AliHLTCaloChannelDataHeaderStruct.h
new file mode 100644 (file)
index 0000000..34c01b5
--- /dev/null
@@ -0,0 +1,34 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTPHOSChannelDataHeaderStruct.h 29824 2008-11-10 13:43:55Z richterm $
+
+#ifndef ALIHLTCALOCHANNELDATAHEADERSTRUCT_H
+#define ALIHLTCALOCHANNELDATAHEADERSTRUCT_H
+
+/**************************************************************************
+ * Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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 "AliHLTPHOSCommonDefs.h"
+
+#include "Rtypes.h"
+
+struct AliHLTCaloChannelDataHeaderStruct
+{
+  //  Int_t fShmAddress;
+  Short_t fNChannels;         //size in charcters
+  Short_t fAlgorithm;
+  Int_t fInfo;
+  Bool_t fHasRawData;
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloChannelDataStruct.h b/HLT/CALO/AliHLTCaloChannelDataStruct.h
new file mode 100644 (file)
index 0000000..9ca0ee8
--- /dev/null
@@ -0,0 +1,40 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTPHOSChannelDataStruct.h 35071 2009-09-29 05:26:09Z phille $
+
+#ifndef ALIHLTCALOCHANNELDATASTRUCT_H
+#define ALIHLTCALOCHANNELDATASTRUCT_H
+
+/**************************************************************************
+ * Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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 "AliHLTPHOSCommonDefs.h"
+
+// TODO: Needs to be changed to facilitate for EMCal's number of modules
+
+#include "Rtypes.h"
+
+//#include "AliHLTPHOSConstants.h"
+//using namespace PhosHLTConst;
+
+struct AliHLTCaloChannelDataStruct
+{
+  Float_t fEnergy;
+  Float_t fTime;
+  UShort_t fChannelID;
+  Short_t fCrazyness;
+  //  Short_t fRawDataSize; //the size of the raw data
+};
+
+#endif
+
diff --git a/HLT/CALO/AliHLTCaloChannelRawDataStruct.h b/HLT/CALO/AliHLTCaloChannelRawDataStruct.h
new file mode 100644 (file)
index 0000000..9f40702
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef ALIHLTCALOCHANNELRAWDATASTRUCT_H
+#define ALIHLTCALOCHANNELRAWDATASTRUCT_H
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * 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 "AliHLTCaloChannelDataStruct.h"
+#include "AliHLTCaloCoordinate.h"
+#include "Rtypes.h"
+#include "AliHLTCaloConstants.h"
+
+using namespace CaloHLTConst;
+
+
+// Contains the raw data signal for a single channel. 
+struct  AliHLTCaloChannelRawDataStruct : public AliHLTCaloChannelDataStruct
+{
+  AliHLTCaloCoordinate fCoordinate;
+  int nSamplesUsed;
+  UShort_t fDataPtr[ALTROMAXSAMPLES];
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloConstants.h b/HLT/CALO/AliHLTCaloConstants.h
new file mode 100644 (file)
index 0000000..f9000b5
--- /dev/null
@@ -0,0 +1,99 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCALOConstants.h 34622 2009-09-04 13:22:01Z odjuvsla $
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2006                                       *
+ *                                                                        * 
+ * Author: Per Thomas Hille perthi@fys.uio.no for the ALICE DCS Project.  *
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                * 
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+
+#ifndef ALIHLTCALOCONSTANTS_H
+#define ALIHLTCALOCONSTANTS_H
+
+namespace CaloHLTConst
+{
+  //  const int ALTROMAXTRALERSIZE = 7;  
+  //  const int  DDLBLOCKSIZE = 5;
+
+  //  const int NZROWSRCU     =   56;                    /**<Number of rows per module*/       
+  //  const int NXCOLUMNSRCU  =   16; 
+  //  const int NZROWSMOD      =  56;                    /**<Number of rows per module*/       
+  //  const int NXCOLUMNSMOD   =  64;                 /**<Number of columns per module*/ 
+  //  const int NGAINS         =   2;                             /**<Number of gains per ALTRO channel*/
+
+  const int NALTROS        =   4;                             /**<Number of ALTROs per frontend card*/
+  const int NALTROCHANNELS =  16;
+  const int NBRANCHES      =   2;      
+  const int CSPSPERFEE    = 32;
+  const int NGAINS         =   2;    
+  const int HIGHGAIN    =   1;
+  const int LOWGAIN     =   0;
+  const int MAXBINVALUE = 1023;
+  const int ALTROMAXSAMPLES = 1008;                           /**<The maximum number of samples of the ALTRO*/
+  const int ALTROMAXPRESAMPLES = 15;   
+  
+
+  //  const int NDATATYPES     =   10;    
+
+  //  const int  PFMAXPATHLENGTH = 256;
+
+
+#ifndef __CINT__
+  const unsigned char PFVECTORDIR[] = "/HLT/PHOS/PFVectors";
+#endif
+
+  //  const int PFDEFAULTNSAMPLES = 70;
+  //  const int PFDEFAULTSTARTINDEX = 0;
+
+  //  const int DEFAULTTAU = 2;    /**<Assume that the signal rise time of the altrp pulses is 2 us (nominal value of the electronics)*/
+  //  const int  DEFAULTFS = 10;   /**<Assume that the signal is samples with 10 MHZ samle rate*/
+
+  //  const int MODULE0     = 0;
+  //  const int MODULE1     = 1;
+  //  const int MODULE2     = 2;
+  // const int MODULE3     = 3;
+  // const int MODULE4     = 4;
+
+  //  const int CSPSPERFEE    = 32;
+
+  //  const int RCU0       = 0;
+  //  const int RCU1       = 1;
+  //  const int RCU2       = 2;
+  //  const int RCU3       = 3;
+
+  
+  //  const int Z0         = 0;
+  //  const int Z1         = 1;
+  //  const int X0         = 0;
+  //  const int X1         = 1;
+
+  //  const int NMODULES    =      5;                             /**<Number of modules of the PHOS detector*/
+  //  const int NRCUS       =      4;                             /**<Number of RCUs per Module*/
+  //              NRCUSPERMODULE
+
+  //  const int NRCUSPERMODULE =  4 ;                            /**<Number of RCUs per Module*/
+  //  const int NRCUSPERTOTAL =  NMODULES*NRCUSPERMODULE;   /**<Total number of RCUs for PHOS*/
+  //  const int NFEECS         =  14;                             /**<Number of Frontend cards per branch*/
+
+  
+  const int MAXHOSTS = 20;
+  const int DEFAULTEVENTPORT = 42001;
+}
+
+
+#endif
+
+
diff --git a/HLT/CALO/AliHLTCaloCoordinate.h b/HLT/CALO/AliHLTCaloCoordinate.h
new file mode 100644 (file)
index 0000000..90cc809
--- /dev/null
@@ -0,0 +1,34 @@
+#ifndef ALIHLTCALOCOORDINATE_H
+#define ALIHLTCALOCOORDINATE_H
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * 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 "Rtypes.h"
+
+// Describes the coordinates of a single channel
+struct  AliHLTCaloCoordinate
+{
+  UShort_t fX; // Local (in module)
+  UShort_t fZ; // Local (in module) 
+  UShort_t fGain; // Gain
+  UShort_t fModuleId; // Module ID
+
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloDefinitions.cxx b/HLT/CALO/AliHLTCaloDefinitions.cxx
new file mode 100644 (file)
index 0000000..1ff4ef6
--- /dev/null
@@ -0,0 +1,62 @@
+
+
+// $Id: AliHLTPHOSDefinitions.cxx 34264 2009-08-14 18:29:23Z odjuvsla $
+
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Authors: Per Thomas Hille <perthi@fys.uio.no>,                         *
+ *          ´┐Żystein Djuvsland <oysteind@ift.uib.no>after                  * 
+ *          Matthias Richter <Matthias.Richter@ift.uib.no>                *
+ *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
+ *          for the ALICE Offline Project.                                *
+ *                                                                       *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// Definitions for the HLT PHOS components                                    //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#include "AliHLTCaloDefinitions.h"
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkPhosHistDataType              = { sizeof(AliHLTComponentDataType),       {'H','I','S','T','O','G','R','A'},{'P','H','O','S'}};;
+//CRAP PTH
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkFourierTransform              = { sizeof(AliHLTComponentDataType),       {'F','O','U','R','I','E','R','T'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkChannelDataType               = { sizeof(AliHLTComponentDataType),       {'C','H','A','N','N','E','L','T'},{'P','H','O','S'}};;
+//const AliHLTComponentDataType AliHLTCaloDefinitions::fgkDDLPackedRawDataType          = { sizeof(AliHLTComponentDataType),       {'D','D','L','_','R','W','P','K'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkDDLPackedRawDataType          = { sizeof(AliHLTComponentDataType),       {'D','D','L','_','R','A','W',' '},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCellEnergyDataType            = { sizeof(AliHLTComponentDataType),       {'C','E','L','L','E','N','E','R'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCellEnergyHistogramDataType   = { sizeof(AliHLTComponentDataType),       {'E','N','E','R','H','I','S','T'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCellAverageEnergyDataType     = { sizeof(AliHLTComponentDataType),       {'E','N','E','R','A','V','E','R'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCellAccumulatedEnergyDataType = { sizeof(AliHLTComponentDataType),       {'E','N','E','R','A','C','C','U'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCellTimingHistogramDataType   = { sizeof(AliHLTComponentDataType),       {'T','I','M','E','H','I','S','T'},{'P','H','O','S'}};;    
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCellTimingAverageDataType     = { sizeof(AliHLTComponentDataType),       {'T','I','M','E','A','V','E','R'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCellChannelDataDataType       = { sizeof(AliHLTComponentDataType),       {'C','H','A','N','D','A','T','A'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkClusterDataType               = { sizeof(AliHLTComponentDataType),       {'C','L','U','S','T','R','T','Y'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkRecPointDataType              = { sizeof(AliHLTComponentDataType),       {'R','E','C','P','O','I','N','T'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkHistDataType                  = { sizeof(AliHLTComponentDataType),       {'H','I','S','T','O','G','R','A'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkSpectrumDataType              = { sizeof(AliHLTComponentDataType),       {'S','P','E','C','T','R','U','M'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkRootTreeDataType              = { sizeof(AliHLTComponentDataType),       {'R','O','O','T','T','R','E','E'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkBaselineDataType              = { sizeof(AliHLTComponentDataType),       {'B','A','S','E','L','I','N','E'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkDigitDataType                 = { sizeof(AliHLTComponentDataType),       {'D','I','G','I','T','T','Y','P'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkNoiseMapDataType              = { sizeof(AliHLTComponentDataType),       {'N','O','I','S','E','M','A','P'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkMIPDataType                   = { sizeof(AliHLTComponentDataType),       {'M','I','P','D','T','Y','P','E'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkSandboxDataType               = { sizeof(AliHLTComponentDataType),       {'S','A','N','D','B','O','X','T'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkEmcCalibDataType              = { sizeof(AliHLTComponentDataType),       {'C','A','L','I','T','Y','P','E'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkCaloClusterDataType           = { sizeof(AliHLTComponentDataType),       {'C','A','L','C','L','U','S','T'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkESDCaloClusterDataType        = { sizeof(AliHLTComponentDataType),       {'E','S','D','C','L','U','S','T'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkESDCaloCellsDataType          = { sizeof(AliHLTComponentDataType),       {'E','S','D','C','E','L','L','S'},{'P','H','O','S'}};;
+const AliHLTComponentDataType AliHLTCaloDefinitions::fgkPhysicsHistogramsDataType     = { sizeof(AliHLTComponentDataType),       {'P','H','Y','S','H','I','S','T'},{'P','H','O','S'}};;
+
+
diff --git a/HLT/CALO/AliHLTCaloDefinitions.h b/HLT/CALO/AliHLTCaloDefinitions.h
new file mode 100644 (file)
index 0000000..c0a8ab4
--- /dev/null
@@ -0,0 +1,48 @@
+//-*- Mode: C++ -*-
+// 1
+// 2
+// 3
+// XEmacs -*-C++-*-
+// @(#) $Id: AliHLTPHOSDefinitions.h 34264 2009-08-14 18:29:23Z odjuvsla $
+
+#ifndef ALIHLTCALODEFINITIONS_H
+#define ALIHLTCALODEFINITIONS_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+
+#include "AliHLTDataTypes.h"
+
+class AliHLTCaloDefinitions
+{
+public:
+  static const AliHLTComponentDataType fgkPhosHistDataType;    /**Fourier transform of time dependent signals*/
+  static const AliHLTComponentDataType fgkFourierTransform;    /**Fourier transform of time dependent signals*/
+  static const AliHLTComponentDataType fgkChannelDataType;    /**<Reconstructed channels*/
+  static const AliHLTComponentDataType fgkCellEnergyDataType;    /**<Reconstructed cell/crystal energies*/
+  static const AliHLTComponentDataType fgkDDLPackedRawDataType;  /**<DDL raw data on the RCU data format*/
+  static const AliHLTComponentDataType fgkCellEnergyHistogramDataType;  /**<Histogram for per cell/gain energy distribution*/
+  static const AliHLTComponentDataType fgkCellAverageEnergyDataType;  /**<Histogram for per cell/gain energy distribution*/
+  static const AliHLTComponentDataType fgkCellAccumulatedEnergyDataType;  /**<Histogram for per cell/gain energy distribution*/
+  static const AliHLTComponentDataType fgkCellTimingHistogramDataType;  /**<Histogram for per cell/gain time distribution*/      
+  static const AliHLTComponentDataType fgkCellTimingAverageDataType;  /**<Histogram for per cell/gain time distribution*/  
+  static const AliHLTComponentDataType fgkCellChannelDataDataType;  /**<Time dependent signal from the readout channels*/  
+  static const AliHLTComponentDataType fgkClusterDataType;  //Cluster data type
+  static const AliHLTComponentDataType fgkRecPointDataType; //RecPoint data type
+  static const AliHLTComponentDataType fgkHistDataType;     //hist data type
+  static const AliHLTComponentDataType fgkSpectrumDataType; //spectrum data type
+  static const AliHLTComponentDataType fgkDigitDataType; //Digit data type
+  static const AliHLTComponentDataType fgkRootTreeDataType; //Root tree type
+  static const AliHLTComponentDataType fgkBaselineDataType; //Baseline type
+  static const AliHLTComponentDataType fgkMIPDataType; //"MIP" data type
+  static const AliHLTComponentDataType fgkNoiseMapDataType; //Noise map data type
+  static const AliHLTComponentDataType fgkSandboxDataType; //General data type
+  static const AliHLTComponentDataType fgkEmcCalibDataType; //Calibration data type
+  static const AliHLTComponentDataType fgkCaloClusterDataType; //Calo cluster data type
+  static const AliHLTComponentDataType fgkESDCaloClusterDataType; //Calo cluster data type
+  static const AliHLTComponentDataType fgkESDCaloCellsDataType; //Calo cells data type
+  static const AliHLTComponentDataType fgkPhysicsHistogramsDataType; //hist data type
+
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloLinkDef.h b/HLT/CALO/AliHLTCaloLinkDef.h
new file mode 100644 (file)
index 0000000..9ff5102
--- /dev/null
@@ -0,0 +1,33 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTPHOSLinkDef.h 34542 2009-09-02 13:18:18Z odjuvsla $
+
+#ifdef __CINT__
+
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+//  //#pragma link C++ class AliHLTPHOSAgent+;
+//#pragma link C++ class AliHLTPHOSClusterizer+;  
+//#pragma link C++ class AliHLTPHOSEmcCalibData+;  
+//#pragma link C++ class AliHLTPHOSPhysicsAnalyzer+;  
+//#pragma link C++ class AliHLTPHOSPulseGenerator+;  
+#pragma link C++ class AliHLTCaloRawAnalyzerChiSquareFit+;  
+#pragma link C++ class AliHLTCaloRawAnalyzerCrude+;  
+//#pragma link C++ class AliHLTPHOSRawAnalyzerKLevel+;  
+//#pragma link C++ class AliHLTPHOSRawAnalyzerLMS+;  
+// #pragma link C++ class AliHLTPHOSRawAnalyzerPeakFinder+;  
+// #pragma link C++ class AliHLTPHOSDigitMaker+; 
+// #pragma link C++ class AliHLTPHOSSanityInspector+; 
+// #pragma link C++ class AliHLTPHOSESDMaker+; 
+// #pragma link C++ class AliHLTPHOSClusterAnalyser+; 
+// #pragma link C++ class AliHLTPHOSPhysicsHistogramProducer+;
+
+//#pragma link C++ class AliHLTPHOSChannelBadness+;
+
+
+//#pragma link C++ class AliHLTPHOSEmcCalibrationHistogramProducer+;
+
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloMapper.cxx b/HLT/CALO/AliHLTCaloMapper.cxx
new file mode 100644 (file)
index 0000000..499b522
--- /dev/null
@@ -0,0 +1,92 @@
+// $Id: AliHLTCalorimeterMapper.cxx 34622 2009-09-04 13:22:01Z odjuvsla $
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2006                                       *
+ *                                                                        * 
+ * Author: Per Thomas Hille perthi@fys.uio.no for the ALICE DCS Project.  *
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                * 
+ *                                                                        *
+ * 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.                  *
+ **************************************************************************/
+
+//
+// Mapping class fro mapping
+// from hardware address to geometrical address
+//
+//
+
+#include "AliHLTCaloMapper.h"
+#include "AliHLTLogging.h"
+#include "Rtypes.h"
+#include "unistd.h"
+#include <iostream>
+#include "AliHLTCaloCoordinate.h"
+
+using namespace CaloHLTConst;
+
+//ClassImp(AliHLTCaloMapper)
+
+AliHLTCaloMapper::AliHLTCaloMapper() :  
+  AliHLTLogging(), 
+  fHw2geomapPtr(0),
+  fIsInitializedMapping(false),
+  fSpecificationMapPtr(0)
+{  
+  //see header file for class documentation
+}
+
+
+AliHLTCaloMapper::~AliHLTCaloMapper()
+{
+  // See header file for documentation
+  delete []  fHw2geomapPtr;
+  fHw2geomapPtr = 0;
+}
+
+
+//void AliHLTCaloMapper::InitAltroMapping(){
+  //Virtual base class
+//}
+
+//void AliHLTCaloMapper::InitDDLSpecificationMapping() {
+  //Virtual base class
+//}
+
+
+
+bool 
+AliHLTCaloMapper::GetIsInitializedMapping()
+{
+  // See header file for documentation
+  return  fIsInitializedMapping;
+}
+
+
+char* 
+AliHLTCaloMapper::GetFilePath()
+{
+  // See header file for documentation
+  return  fFilepath;
+}
+
+
+void
+//AliHLTPHOSMapper::GetChannelCoord(const UShort_t channelId,    &AliHLTPHOSCoordinate channelCoord)
+AliHLTCaloMapper::ChannelId2Coordinate(const UShort_t channelId,    AliHLTCaloCoordinate &channelCoord)
+{
+  // TODO: change format to facilitate for EMCal (more modules)
+  channelCoord.fX = channelId&0x3f;
+  channelCoord.fZ = (channelId >> 6)&0x3f;
+  channelCoord.fGain = (channelId >> 12)&0x1;
+  channelCoord.fModuleId  = (channelId >> 13)&0x1f;
+  //  printf("Channel ID: 0x%X Coordinates: x = %d, z = %d, gain = %d\n", channelId, channelCoord[0], channelCoord[1], channelCoord[2]);
+}
diff --git a/HLT/CALO/AliHLTCaloMapper.h b/HLT/CALO/AliHLTCaloMapper.h
new file mode 100644 (file)
index 0000000..f74c3ef
--- /dev/null
@@ -0,0 +1,93 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloMapper.h 34264 2009-08-14 18:29:23Z odjuvsla $
+
+#ifndef ALIHLTCALOMAPPER_H
+#define ALIHLTCALOMAPPER_H
+
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2006                                       *
+ *                                                                        * 
+ * Author: Per Thomas Hille perthi@fys.uio.no for the ALICE DCS Project.  *
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                * 
+ *                                                                        *
+ * 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 "AliHLTCaloBase.h"
+
+#include "AliHLTCaloConstants.h"
+
+using namespace CaloHLTConst;
+
+#include "Rtypes.h"
+#include "AliHLTLogging.h"
+
+//#include "AliPHOSEMCAGeometry.h"
+
+class AliHLTCaloCoordinate;
+
+
+// TODO: Documentation!
+
+class AliHLTCaloMapper : public AliHLTLogging
+//class AliHLTCaloMapper 
+{
+ public:
+  AliHLTCaloMapper();
+  virtual ~AliHLTCaloMapper();
+  
+  virtual void InitAltroMapping() = 0; 
+  virtual void InitDDLSpecificationMapping() = 0;
+  
+  bool GetIsInitializedMapping();
+  char* GetFilePath();
+  const virtual int GetDDLFromSpec( const AliHLTUInt32_t spec )=0;
+  const virtual int GetChannelID(const AliHLTUInt32_t spec, const Int_t hadd) = 0;
+  void ChannelId2Coordinate(const UShort_t channelId,    AliHLTCaloCoordinate &channelCoord);
+  //  UShort_t GetChannelID(Int_t specification, Int_t hwAddress);
+  //  static void GetChannelCoord(UShort_t channelId, UShort_t* channelCoord);
+  //  static void GetLocalCoord(UShort_t channelId, Float_t* localCoord);
+  //  int GetDDLFromSpec(Int_t specification);
+
+  struct fAltromap{ 
+    int fZRow; // Coordinate in Z direction (beam direction) relatve too one RCU
+    int fXCol; // Coordinate in X direction (perpendicular too beam direction an parallell to ground) relatve too one RCU
+    int fGain; // Gain (high gain = 1, low gain = 0)
+  };
+  
+  struct fDDLSpecificationMap{ 
+    UInt_t fRcuX; // Coordinate in Z direction (beam direction) relatve too one RCU
+    UInt_t fRcuZ; // Coordinate in X direction (perpendicular too beam direction an parallell to ground) relatve too one RCU
+    UInt_t fRcuXOffset;
+    UInt_t fRcuZOffset;
+    int fModId; 
+  };
+
+  fAltromap *fHw2geomapPtr; //pointer to structure holding information about geometrical address 
+
+
+  char fFilepath[1024];
+
+protected:
+  bool fIsInitializedMapping;
+  fDDLSpecificationMap* fSpecificationMapPtr;
+
+
+ private:
+  AliHLTCaloMapper(const AliHLTCaloMapper & );
+  AliHLTCaloMapper & operator = (const AliHLTCaloMapper &);
+  //AliPHOSEMCAGeometry fPHOSGeometry;
+  //static const Float_t fCellStep = 2.2;//2.*fPHOSGeometry.GetAirCellHalfSize()[0];
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloProcessor.cxx b/HLT/CALO/AliHLTCaloProcessor.cxx
new file mode 100644 (file)
index 0000000..a92fbd5
--- /dev/null
@@ -0,0 +1,159 @@
+// $Id: AliHLTCaloProcessor.cxx 29824 2008-11-10 13:43:55Z richterm $
+
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Author:  Per Thomas Hille  <perthi@fys.uio.no>                 *
+ *                                                                        *
+ * 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 "AliHLTCaloProcessor.h"
+#include "unistd.h"
+
+
+
+const AliHLTComponentDataType AliHLTCaloProcessor::fgkInputDataTypes[]={kAliHLTVoidDataType,{0,"",""}}; //'zero' terminated array
+
+
+AliHLTCaloProcessor::AliHLTCaloProcessor():AliHLTProcessor(), 
+                                          //                                      AliHLTCaloBase(), 
+                                          fPhosEventCount(0), 
+                                          fModuleID(2), 
+                                          fPrintInfoModule(0), 
+                                          fPrintInfoFrequncyModule(1000), 
+                                          fRunNumber(0)
+{
+  //  ScanRunNumberFromFile();
+}
+
+
+
+AliHLTCaloProcessor::~AliHLTCaloProcessor()
+{
+
+}
+
+bool 
+AliHLTCaloProcessor::CheckFileLog(const char *origin,   const char *filename,  const char *opt)
+{
+  sprintf(fFilepath, "%s/%s", getenv("PWD"), filename);
+  FILE *fp = fopen(filename, opt);
+
+  if(fp == 0)
+    {
+      //      if( (opt == "w")  || (opt == "a")) \\OD
+      if( (!strcmp(opt,"w"))  || (!strcmp(opt,"a")))
+       {
+         sprintf(fMessage, "for writing  please check that the directory exists and that you have write access to it"  );
+       }
+      else
+       {
+         sprintf(fMessage, "for reading  please check that the directory exists and that you have read access to it"  );
+       }
+     Logging(kHLTLogFatal, origin , "cannot open file" , "Was not able to open file %s  %s", fFilepath, fMessage);
+     return false;
+    }
+  else
+    {
+      //      if( (opt == "w")  || (opt == "a")) \\OD
+      if( (!strcmp(opt,"w"))  || (!strcmp(opt,"a")))
+       {
+         sprintf(fMessage, "for writing" );
+       }
+      else
+       {
+         sprintf(fMessage, "for reading");
+       }
+      //    Logging(kHLTLogInfo, origin , "opening file" , "Sucessfully opening %s  %s", fFilepath, fMessage);
+      fclose(fp); 
+      return true;
+    }
+  
+}
+
+void 
+AliHLTCaloProcessor::DoneWritingLog(const char *origin, const char *filename)
+{
+  //  char filepath[1024];
+  sprintf(fFilepath, "%s/%s", getenv("PWD"), filename);
+  Logging(kHLTLogInfo, origin , "finnished writing file" , "wrote file %s", fFilepath);
+}
+
+
+void 
+AliHLTCaloProcessor::ScanRunNumberFromFile()
+{
+  char tmpDirectory[512];
+  char tmpFileName[512];
+  sprintf(tmpDirectory, "%s", getenv("HOME"));  
+
+  //TODO, remove hardcoded file path
+  
+  sprintf(tmpFileName, "%s%s", tmpDirectory, "/hlt/rundir/runNumber.txt");
+  int tmp = 0;
+  if(CheckFileLog( __FILE__ , tmpFileName , "r")== true) 
+    { 
+      FILE *fp = fopen(tmpFileName, "r");
+      tmp = fscanf(fp, "%d", &fRunNumber);
+      fclose(fp);
+    }
+
+  
+
+
+ }
+
+const char*
+AliHLTCaloProcessor::IntToChar(int number)
+{
+  sprintf(lineNumber,"%d", number);
+  return lineNumber;
+}
+
+
+
+int
+AliHLTCaloProcessor::ScanArgumentsModule(int argc, const char** argv)
+{
+  fPrintInfoModule = kFALSE;
+  int iResult=0;
+  TString argument="";
+
+  for(int i=0; i<argc && iResult>=0; i++) 
+    {
+      argument=argv[i];
+      
+      if (argument.IsNull()) 
+       {
+         continue;
+       }
+                         
+    if (argument.CompareTo("-printinfo") == 0) 
+      {
+       if(i+1 <= argc)
+         {
+           argument=argv[i+1];
+           fPrintInfoFrequncyModule = atoi(argv[i+1]);
+           fPrintInfoModule = kTRUE;
+         }
+       else
+         {
+           Logging(kHLTLogWarning, __FILE__ , "inconsistency during init" , "asking for event info, but no update frequency is specified, option is ignored");
+         }
+      }
+    }
+  return 0;
+}
+
diff --git a/HLT/CALO/AliHLTCaloProcessor.h b/HLT/CALO/AliHLTCaloProcessor.h
new file mode 100644 (file)
index 0000000..4269964
--- /dev/null
@@ -0,0 +1,63 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloProcessor.h 29824 2008-11-10 13:43:55Z richterm $
+
+#ifndef ALIHLTCALOPROCESSOR_H
+#define ALIHLTCALOPROCESSOR_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+#include "AliHLTProcessor.h"
+//#include "AliHLTCaloBase.h"
+#include "AliHLTCaloDefinitions.h"
+#include "AliHLTDataTypes.h"
+#include "AliHLTCaloConstants.h"
+
+using namespace CaloHLTConst;
+
+class AliHLTCaloProcessor:public AliHLTProcessor //public AliHLTCaloBase
+{
+
+ public:
+  AliHLTCaloProcessor();
+  virtual ~AliHLTCaloProcessor();
+  virtual int DoInit(int argc, const char** argv) = 0;
+  virtual int Deinit() = 0;
+  virtual const char* GetComponentID() = 0;
+  virtual void GetInputDataTypes( std::vector <AliHLTComponentDataType>& list) =0;
+  virtual AliHLTComponentDataType GetOutputDataType() =0;
+  virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier) =0;
+  virtual AliHLTComponent* Spawn() = 0; 
+
+
+  char lineNumber[256];
+  const char *IntToChar(int number);
+  /*
+   *Check file and write messages to AliLog system
+   */
+  bool CheckFileLog(const char *origin, const char *filename, const char *opt);
+  void DoneWritingLog(const char *origin, const char *filename);
+
+  using  AliHLTProcessor::DoEvent;
+
+ protected:
+  void ScanRunNumberFromFile();
+  virtual int ScanArgumentsModule(int argc, const char** argv);
+  int fPhosEventCount;                  /**<Global event counter for this component*/
+  AliHLTUInt8_t  fModuleID;             /**<ID of the module this component read data from (0-4)*/
+
+  Bool_t fPrintInfoModule;                    /**<wether or not to print debugg info to std out*/
+  int fPrintInfoFrequncyModule;               /**<Defines the update frequency for information printet to std out*/
+
+  static const AliHLTComponentDataType fgkInputDataTypes[]; /**<List of  datatypes that can be given to this component*/
+  int fRunNumber;
+  char fFilepath[1024];
+  char fMessage[1024];
+
+ private:
+  AliHLTCaloProcessor(const AliHLTCaloProcessor & );
+  AliHLTCaloProcessor & operator = (const AliHLTCaloProcessor &);
+
+};
+
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzer.cxx b/HLT/CALO/AliHLTCaloRawAnalyzer.cxx
new file mode 100644 (file)
index 0000000..fde23ae
--- /dev/null
@@ -0,0 +1,290 @@
+// $Id: AliHLTCaloRawAnalyzer.cxx 34264 2009-08-14 18:29:23Z odjuvsla $
+
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: Per Thomas Hille for the ALICE HLT Project.                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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 "AliHLTCaloRawAnalyzer.h"
+#include "AliHLTCaloUtilities.h" 
+
+AliHLTCaloRawAnalyzer:: AliHLTCaloRawAnalyzer(): //AliHLTCaloBase(),   
+                                                //      fDoCorrectBaselineUsingFirstFiveSamples(false),
+                                                fDoCorrectBaselineUsingFirstFiveSamples(true),
+                                                fDoubleDataPtr(0), 
+                                                fIntDataPtr(0), 
+                                                fShortDataPtr(0),
+                                                fSampleFrequency(10),
+                                                fDTofGuess(-1),
+                                                fDAmplGuess(-1),
+                                                fTau(2), 
+                                                fDTof(99999), 
+                                                fDAmpl(99999),
+                                                fStartIndex(0),
+                                                fUseShortValues(false),
+                                                fUtilitiesPtr(0)
+
+{
+  //  fIntDataPtr = new UInt_t[1008];
+
+  //  fDoubleDataPtr;   
+  fUtilitiesPtr = new  AliHLTCaloUtilities(); 
+}
+
+AliHLTCaloRawAnalyzer::~AliHLTCaloRawAnalyzer()
+{
+  //  delete[] fIntDataPtr;
+}
+
+
+
+
+
+/**
+* Main constructor
+* param dtaPtr Data array for wich a subarray will be taken to perform the fit
+* @param fs the sampling frequency in entities of MHz. Needed in order to calculate physical time
+**/
+AliHLTCaloRawAnalyzer::AliHLTCaloRawAnalyzer(double * /*dtaPtr*/, double fs): //AliHLTCaloBase(), 
+                                                                             fDoCorrectBaselineUsingFirstFiveSamples(false),
+                                                                             fDoubleDataPtr(0), 
+                                                                             fIntDataPtr(0), 
+                                                                             fShortDataPtr(0),
+                                                                             fSampleFrequency(10),
+                                                                             fDTofGuess(-1),
+                                                                             fDAmplGuess(-1),
+                                                                             fTau(2), 
+                                                                             fDTof(99999), 
+                                                                             fDAmpl(99999),
+                                                                             fStartIndex(0),
+                                                                             fUseShortValues(false),
+                                                                             fUtilitiesPtr(0)
+                                                                             
+{
+  fSampleFrequency = fs;
+} //end  
+
+
+
+void 
+AliHLTCaloRawAnalyzer::SetCorrectBaselineUsingFirstFiveSamples()
+{
+  fDoCorrectBaselineUsingFirstFiveSamples = true;
+}
+
+void 
+//AliHLTCaloRawAnalyzer::CorrectBaselineUsingFirstFiveSamples(double *data, int length)
+//AliHLTCaloRawAnalyzer::CorrectBaselineUsingFirstFiveSamples(int *data, int length)
+AliHLTCaloRawAnalyzer::CorrectBaselineUsingFirstFiveSamples(UInt_t */*data*/, const int /*length*/)
+{
+  //  cout << "AliHLTCaloRawAnalyzer::CorrectBaselineUsingFirstFiveSamples" << endl;
+
+  //CRAP PTH
+  /*
+  
+  unsigned int sumOfFirstFiveSamples = 0;
+
+  for(int i=0; i< 5; i++)
+    {
+      sumOfFirstFiveSamples += data[i];
+    }
+
+  unsigned int valueToSubtract = sumOfFirstFiveSamples/5;
+
+  for(int j = 0; j < length; j++)
+    {
+      if( (int)(data[j] - valueToSubtract) > 0)
+       {
+         data[j] = data[j] - valueToSubtract;
+       }
+      else
+       {
+         data[j] = 0;
+       }
+    }
+  */
+}
+
+
+
+// /**
+// * Attemps to level the basline to zero.
+// * The baseline will be calculated from the pretrigger samples and subtracted from the 
+// * data array. 
+// * If pretrigger samples are not present then the basline correction will be incorrect. 
+// * @param dataPtr array for wich to correct the basline 
+// * @param N the number of pretrigger samples used to calculate the baseline.
+// **/
+// void 
+// AliHLTCaloRawAnalyzer::BaselineCorrection(double * /*dataPtr*/, int /*N*/)
+// {
+
+// } //end BaselineCorrection
+
+
+/**
+* Shifts the baseline with the amount given by baselineValue
+* If pretrigger samples are not present then the basline correction will be incorrect. 
+* @param dataPtr array for wich to correct the basline 
+* @param baselineValue the basline value to subtract..
+**/
+void 
+AliHLTCaloRawAnalyzer::BaselineCorrection(double * /*dataPtr*/, double /*baselineValue*/)
+{
+
+} //end BaslineCorrection
+
+
+/**
+ * Gives the timing in entities of sample indexes
+ * Physical time is found by multiplying  with the sampling intervall (Ts).
+ **/
+float
+AliHLTCaloRawAnalyzer::GetTiming() const 
+{
+  return fDTof;
+} //end GetTiming
+
+
+/**
+ * Gives the time in entities of ADC channels (quantization levels).  
+ * Absolute enrgy is found by multiplying with offline calibration constants.
+ **/
+float
+AliHLTCaloRawAnalyzer::GetEnergy() const
+{
+  return fDAmpl;
+} //end GetEnergy
+
+
+
+/**
+ * Set data array. Overrides data data array set in the constructor.
+ **/
+ void 
+
+ AliHLTCaloRawAnalyzer::SetData(const UInt_t *data, const int length) 
+ // AliHLTCaloRawAnalyzer::SetData(UInt_t *data, const int length) 
+// AliHLTCaloRawAnalyzer::SetData(int *data, const int length) 
+ {
+   fIntDataPtr = const_cast<UInt_t *>(data);
+
+   if(fDoCorrectBaselineUsingFirstFiveSamples == true)
+     {
+       CorrectBaselineUsingFirstFiveSamples(fIntDataPtr, length);
+     }
+
+   //   fIntDataPtr = data;
+
+ }
+
+void
+ AliHLTCaloRawAnalyzer::SetData(const UShort_t *data, const int length) 
+ // AliHLTCaloRawAnalyzer::SetData(UInt_t *data, const int length) 
+// AliHLTCaloRawAnalyzer::SetData(int *data, const int length) 
+ {
+
+   fShortDataPtr = const_cast<UShort_t *>(data);
+   fUseShortValues = true;
+   if(fDoCorrectBaselineUsingFirstFiveSamples == true)
+     {
+       CorrectBaselineUsingFirstFiveSamples(fIntDataPtr, length);
+     }
+
+   //   fIntDataPtr = data;
+
+ }
+
+
+
+
+/**
+ * Set data array. Overrides data data array set in the constructor.
+ **/
+// void 
+// //AliHLTCaloRawAnalyzer::SetData(const double *data) 
+// AliHLTCaloRawAnalyzer::SetData(double *data, const int length) 
+// {
+//   if(fDoCorrectBaselineUsingFirstFiveSamples == true)
+//     {
+//       CorrectBaselineUsingFirstFiveSamples(data, length);
+//     }
+
+
+//   fDoubleDataPtr = data;
+// }
+
+
+
+void 
+AliHLTCaloRawAnalyzer::SetSampleFreq(double freq)
+{
+  fSampleFrequency = freq;
+}
+
+int 
+AliHLTCaloRawAnalyzer::FindStartIndex(double /*treshold*/)
+{
+  // cout << "Find Start index not yet implemented" << endl;
+  return 0;
+} //end FindStartIndex
+
+
+/**
+ * This function applies only to the Chi and Least mean square fit. An initial guess is made
+ * based on the average of the first 5 samples and the first value exeeding this value.
+ **/
+void 
+AliHLTCaloRawAnalyzer::MakeInitialGuess()
+{
+  //  cout << "Make initial guess not yet implemeted" << endl;
+}
+
+
+/**
+ * This function applies only to the Chi and Least mean square fit. An initial guess is made
+ * based on the average of the first 5 samples and the first value exeeding threshold + this value.
+ * @param treshold The index of the first value above treshold is ntaken to be the first value.
+ **/
+void 
+AliHLTCaloRawAnalyzer::MakeInitialGuess(int /*treshold*/)
+{
+  //  cout << "Make initial guess not yet implemeted" << endl;  
+}
+
+
+void
+AliHLTCaloRawAnalyzer::SetStartIndex(int index)
+{
+  fStartIndex = index;
+}
+
+
+
+void 
+AliHLTCaloRawAnalyzer::SetTVector(Double_t * /*tVector*/, Int_t /*size*/)
+{
+  //  cout <<"ERROR: AliHLTCaloRawAnalyzer::SetTVector:  You cannot set the peakfindervector here, must be set in derived class peakfinder"<<endl;
+}
+
+
+
+void
+AliHLTCaloRawAnalyzer::SetAVector(Double_t * /*aVector*/, Int_t /*size*/)
+{
+  // cout <<"ERROR: AliHLTCaloRawAnalyzer::SetAVector:  You cannot set the peakfindervector here, must be set in derived class peakfinder"<<endl;
+}
+
+
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzer.h b/HLT/CALO/AliHLTCaloRawAnalyzer.h
new file mode 100644 (file)
index 0000000..17984a3
--- /dev/null
@@ -0,0 +1,99 @@
+//-*- Mode: C++ -*-
+#ifndef ALIHLTCALORAWANALYZER_H
+#define ALIHLTCALORAWANALYZER_H
+/* Copyright(c) 1998-2004, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id: AliHLTCaloRawAnalyzer.h 34264 2009-08-14 18:29:23Z odjuvsla $ */
+
+#include "Rtypes.h"
+
+
+//#include "AliHLTCaloBase.h"
+
+class AliHLTCaloUtilities;
+
+class AliHLTCaloRawAnalyzer
+//: public AliHLTCaloBase
+//class AliHLTCaloRawAnalyzer
+{
+ public:
+  AliHLTCaloRawAnalyzer();
+  virtual ~AliHLTCaloRawAnalyzer();
+  AliHLTCaloRawAnalyzer(double *dataPtr, double fs);
+
+  void SetCorrectBaselineUsingFirstFiveSamples();
+  void CorrectBaselineUsingFirstFiveSamples(UInt_t *data, const int length);
+  // void CorrectBaselineUsingFirstFiveSamples(int *data, int length);
+  //void CorrectBaselineUsingFirstFiveSamples(double *data, int length);
+
+
+  //  void BaselineCorrection(double *dataPtr, int N);
+  void BaselineCorrection(double *dataPtr, double baselineValue);  
+
+  int FindStartIndex(double treshold);
+  float GetTiming() const;
+  float GetEnergy() const;
+
+  //  void SetData(const double *data);
+  void SetData(const UInt_t *data, const int length);
+  void SetData(const UShort_t *data, const int length);
+  // void SetData(UInt_t *data, const int length);
+
+  // void SetData(double *data, const int length);
+  //  void SetData(int *data, const int length);
+
+  void SetSampleFreq(double freq);
+  void SetStartIndex(int startIndex);
+  void MakeInitialGuess();
+  void MakeInitialGuess(int treshold);
+  
+  virtual void SetTVector(Double_t *tVector, Int_t size);
+  virtual void SetAVector(Double_t *aVector, Int_t size);
+
+  virtual void Evaluate(Int_t start = 0, Int_t lenght = 100) = 0;
+
+
+ protected:
+  bool fDoCorrectBaselineUsingFirstFiveSamples;
+
+  //  mutable  Double_t   *fFloatDataPtr;   /**<Float representation of data that should be fitted */
+  //  mutable  UInt_t     *fIntDataPtr;     /**<data that should be fitted */
+
+ /*  mutable const Double_t   *fFloatDataPtr;   /\**<Float representation of data that should be fitted *\/ */
+/*   mutable const unsigned int     *fIntDataPtr;     /\**<data that should be fitted *\/ */
+
+
+  //double   *fFloatDataPtr;   /**<Float representation of data that should be fitted */
+
+  double   *fDoubleDataPtr;   /**<Float representation of data that should be fitted */
+  UInt_t   *fIntDataPtr;     /**<data that should be fitted */
+  UShort_t   *fShortDataPtr;     /**<data that should be fitted */
+ //  int      *fIntDataPtr;     /**<data that should be fitted */
+
+
+  //  mutable const UInt_t     *fIntDataPtr;     /**<data that should be fitted */
+  
+  double     fSampleFrequency; /**<The ADC sample frequency in MHz used under data taking */
+  double     fDTofGuess;       /**<Initial guess for t0*/
+  double     fDAmplGuess;      /**<Initial guess for amplitude*/
+  double     fTau;            /**<The risetime in micro seconds*/               
+  double     fDTof;            /**<Time of flight in entities of sample intervals */
+  double     fDAmpl;           /**<Amplitude in entities of ADC levels*/
+  int        fStartIndex;      /**<Starindex of the time dependent altro signal*/
+
+  //  double unsigned fTest;
+
+  bool fUseShortValues;
+
+ protected:
+  AliHLTCaloUtilities *fUtilitiesPtr;
+
+ private:
+  AliHLTCaloRawAnalyzer(const AliHLTCaloRawAnalyzer & );
+  AliHLTCaloRawAnalyzer & operator = (const AliHLTCaloRawAnalyzer &);
+};
+
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerChiSquareFit.cxx b/HLT/CALO/AliHLTCaloRawAnalyzerChiSquareFit.cxx
new file mode 100644 (file)
index 0000000..735bbd4
--- /dev/null
@@ -0,0 +1,58 @@
+// $Id: AliHLTCaloRawAnalyzerChiSquareFit.cxx 30036 2008-11-24 16:43:44Z odjuvsla $
+
+
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: Per Thomas Hille for the ALICE HLT Project.                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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 "AliHLTCaloRawAnalyzerChiSquareFit.h"
+#include <iostream>
+
+using std::cout;
+using std::endl;
+
+//ClassImp(AliHLTCaloRawAnalyzerChiSquareFit) 
+
+AliHLTCaloRawAnalyzerChiSquareFit::AliHLTCaloRawAnalyzerChiSquareFit(const AliHLTCaloRawAnalyzerChiSquareFit&):AliHLTCaloRawAnalyzer()
+{
+  //comment
+}
+
+AliHLTCaloRawAnalyzerChiSquareFit::AliHLTCaloRawAnalyzerChiSquareFit():AliHLTCaloRawAnalyzer()
+{
+  //comment
+}
+
+
+AliHLTCaloRawAnalyzerChiSquareFit::~AliHLTCaloRawAnalyzerChiSquareFit()
+{
+
+} //end AliHLTCaloRawAnalyzerChiSquareFit
+
+
+void 
+AliHLTCaloRawAnalyzerChiSquareFit::Evaluate(int /*start*/, int /*length*/)
+{
+  /*
+
+  */
+
+  //thats all for the moment 
+} //end FitChiSquareFit
+
+
+
+
+
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerChiSquareFit.h b/HLT/CALO/AliHLTCaloRawAnalyzerChiSquareFit.h
new file mode 100644 (file)
index 0000000..8842aef
--- /dev/null
@@ -0,0 +1,56 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloRawAnalyzerChiSquareFit.h 30036 2008-11-24 16:43:44Z odjuvsla $
+
+#ifndef ALIHLTCALORAWANALYZERCHISQUAREFIT_H
+#define ALIHLTCALORAWANALYZERCHISQUAREFIT_H
+//#include <Rtypes.h>
+#include "TObject.h"
+#include "AliHLTCaloRawAnalyzer.h"
+
+/* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                          */
+
+
+
+/**
+ * The AliHLTCaloRawAnalyzerChiSquareFit class is the class for extracting the basic signal parameters
+ * "timing" and "energy" from the PHOS raw data. Physical data will for a given readout channel be
+ * a sequense of ADC digitized 10 bit integer values, however for performance reasons all values used in
+ * calculation is of type double.
+ **/
+
+class AliHLTCaloRawAnalyzerChiSquareFit : public AliHLTCaloRawAnalyzer
+{
+ public:
+
+  AliHLTCaloRawAnalyzerChiSquareFit();
+  AliHLTCaloRawAnalyzerChiSquareFit(const AliHLTCaloRawAnalyzerChiSquareFit & );
+
+  AliHLTCaloRawAnalyzerChiSquareFit & operator = (const AliHLTCaloRawAnalyzerChiSquareFit)
+    {
+      return *this; 
+    }
+  
+  virtual ~AliHLTCaloRawAnalyzerChiSquareFit();
+  
+  /**
+   * Extraction of timing and energy using Chi Square Fit.
+   * The. The parameters "start" and "length" defines a sub array  of the data array
+   * that will be used for the the fit. If start+length must not exeed the total length
+   * of the Data array. "start" must be chosen as close as possible to t0.
+   * The baseline must also be subtracted.
+   * The length of "tVector" and "aVector" mus be equal to length.
+   * "index + length" must not exeed the length of the data array set in the constructor.
+   * @param start the start index of the subarray of the data array. 
+   * @param length the number of samples to use starting from index 
+   **/
+  virtual void Evaluate(int start = 0, int length = 100);
+   
+
+ private:
+
+  // ClassDef(AliHLTCaloRawAnalyzerChiSquareFit, 2) 
+  
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.cxx b/HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.cxx
new file mode 100644 (file)
index 0000000..2396bd6
--- /dev/null
@@ -0,0 +1,463 @@
+
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Authors: Per Thomas Hille, 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 "AliHLTCaloRawAnalyzer.h"
+#include "AliHLTCaloRawAnalyzerComponentv3.h"
+#include "AliHLTCaloChannelDataHeaderStruct.h"
+#include "AliHLTCaloChannelDataStruct.h"
+#include "AliHLTCaloMapper.h"
+#include "AliHLTCaloSanityInspector.h"
+#include "AliAltroRawStreamV3.h"
+#include "AliRawReaderMemory.h"
+#include "AliAltroRawStreamV3.h"
+#include "AliCaloRawStreamV3.h"
+
+AliHLTCaloRawAnalyzerComponentv3::AliHLTCaloRawAnalyzerComponentv3():
+  AliHLTCaloRcuProcessor(), 
+  fAnalyzerPtr(0), 
+  fMapperPtr(0), 
+  fSanityInspectorPtr(0),
+  fRawReaderMemoryPtr(0),
+  fAltroRawStreamPtr(0),
+  fAlgorithm(0),
+  fOffset(0),
+  fBunchSizeCut(0),
+  fMinPeakPosition(0),
+  fMaxPeakPosition(100),
+  fkDoPushRawData(true)
+  // fMapperPtr(0)
+{
+  //comment
+
+  //  fMapperPtr = new AliHLTCaloMapper();
+
+  fRawReaderMemoryPtr = new AliRawReaderMemory();
+
+  fAltroRawStreamPtr = new AliAltroRawStreamV3(fRawReaderMemoryPtr);
+
+  fSanityInspectorPtr = new AliHLTCaloSanityInspector();
+  if( fkDoPushRawData == true  )
+    {
+      fRawDataWriter  = new RawDataWriter(); 
+    }
+}
+
+
+AliHLTCaloRawAnalyzerComponentv3::~AliHLTCaloRawAnalyzerComponentv3()
+{
+  //comment
+  Deinit();
+}
+
+
+
+int 
+AliHLTCaloRawAnalyzerComponentv3::Deinit()
+{
+  //comment
+  if(fAnalyzerPtr)
+    {
+      delete fAnalyzerPtr;
+      fAnalyzerPtr = 0;
+    }
+  if(fMapperPtr)
+    {
+      delete  fMapperPtr;
+      fMapperPtr = 0;
+    }
+  if(fRawReaderMemoryPtr)
+    {
+      delete fRawReaderMemoryPtr;
+      fRawReaderMemoryPtr = 0;
+    }
+  if(fAltroRawStreamPtr)
+    {
+      delete fAltroRawStreamPtr;
+      fAltroRawStreamPtr = 0;
+    }
+  return 0;
+}
+
+/*
+const char* 
+AliHLTCaloRawAnalyzerComponentv3::GetComponentID()
+{
+  //comment
+  return "CaloRawAnalyzerv3";
+}
+*/
+
+
+ /*
+void
+AliHLTCaloRawAnalyzerComponentv3::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
+{
+  //comment
+  list.clear();
+  list.push_back( AliHLTCaloDefinitions::fgkDDLPackedRawDataType | kAliHLTDataOriginPHOS);
+}
+ */
+
+AliHLTComponentDataType 
+AliHLTCaloRawAnalyzerComponentv3::GetOutputDataType()
+{
+  //comment
+  return AliHLTCaloDefinitions::fgkChannelDataType;
+}
+
+void
+AliHLTCaloRawAnalyzerComponentv3::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier )
+{
+  //comment
+  constBase = sizeof(AliHLTCaloChannelDataHeaderStruct);
+  inputMultiplier = 0.5;
+}
+
+int 
+AliHLTCaloRawAnalyzerComponentv3::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, AliHLTComponentTriggerData& /*trigData*/, 
+                                        AliHLTUInt8_t* outputPtr, AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
+{
+  Int_t blockSize          = 0;
+  UInt_t totSize           = 0;
+  const AliHLTComponentBlockData* iter = NULL; 
+  unsigned long ndx;
+
+  for( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
+    {
+      iter = blocks+ndx;
+      if( CheckInputDataType(  iter->fDataType ) == false )
+       {
+         //      cout << __FILE__  << ":" << __LINE__ <<  ": wrong !! datatype" << endl; 
+         //      cout << "The datatype recieved was"  << endl;
+         //      cout << "the datatype is " <<   iter->fDataType.fID << ":" << iter->fDataType.fOrigin  << endl;
+         continue;
+       }
+      else
+       {
+         //      cout << __FILE__  << ":" << __LINE__ <<  ":" << "data is of type fgkDDLPackedRawDataType, continue processing " << endl;
+         //      cout << "the datatype is " <<   iter->fDataType.fID << ":" << iter->fDataType.fOrigin  << endl;
+         blockSize = DoIt(iter, outputPtr, size, totSize); // Processing the block
+         if(blockSize == -1) // If the processing returns -1 we are out of buffer and return an error msg.
+           {
+             return -ENOBUFS;
+           }
+         
+         totSize += blockSize; //Keeping track of the used size
+         // HLTDebug("Output data size: %d - Input data size: %d", totSize, iter->fSize);
+         //Filling the block data
+         AliHLTComponentBlockData bdChannelData;
+         FillBlockData( bdChannelData );
+         bdChannelData.fOffset = 0; //FIXME
+         bdChannelData.fSize = blockSize;
+         
+         //      bdChannelData.fDataType = AliHLTPHOSDefinitions::fgkChannelDataType;
+         bdChannelData.fDataType = AliHLTCaloDefinitions::fgkChannelDataType;
+
+         bdChannelData.fSpecification = iter->fSpecification;
+         outputBlocks.push_back(bdChannelData);
+         outputPtr += blockSize; //Updating position of the output buffer
+       }
+
+      fPhosEventCount++; 
+      size = totSize; //telling the framework how much buffer space we have used.
+    }
+  return 0;
+  
+}//end DoEvent
+
+
+
+Int_t
+AliHLTCaloRawAnalyzerComponentv3::DoIt(const AliHLTComponentBlockData* iter, AliHLTUInt8_t* outputPtr, const AliHLTUInt32_t size, UInt_t& totSize)
+{
+  //comment
+  int tmpsize=  0;
+  Int_t crazyness          = 0;
+  Int_t nSamples           = 0;
+  Short_t channelCount     = 0;
+
+   // Firs we want to write a header to the output
+  AliHLTCaloChannelDataHeaderStruct *channelDataHeaderPtr = reinterpret_cast<AliHLTCaloChannelDataHeaderStruct*>(outputPtr); 
+  AliHLTCaloChannelDataStruct *channelDataPtr = reinterpret_cast<AliHLTCaloChannelDataStruct*>(outputPtr+sizeof(AliHLTCaloChannelDataHeaderStruct)); 
+  //Adding to the total size of data written
+  totSize += sizeof( AliHLTCaloChannelDataHeaderStruct );
+  fRawReaderMemoryPtr->SetMemory(         reinterpret_cast<UChar_t*>( iter->fPtr ),  static_cast<ULong_t>( iter->fSize )  );
+  fRawReaderMemoryPtr->SetEquipmentID(    fMapperPtr->GetDDLFromSpec(  iter->fSpecification) + 1792  );
+  fRawReaderMemoryPtr->Reset();
+  fRawReaderMemoryPtr->NextEvent();
+
+  if( fkDoPushRawData == true)
+    {
+     fRawDataWriter->NewEvent( );
+    }
+  if(fAltroRawStreamPtr != NULL)
+    {
+      delete fAltroRawStreamPtr;
+      fAltroRawStreamPtr=NULL;
+    }
+
+
+  fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, TString("PHOS"));
+
+  //  fAltroRawStreamPtr = new AliCaloRawStreamV3(fRawReaderMemoryPtr, TString("EMCAL"));
+  //  while( fAltroRawStreamPtr->NextDDL() )
+
+  fAltroRawStreamPtr->NextDDL();
+  {
+    int cnt = 0;
+    while( fAltroRawStreamPtr->NextChannel()  )
+      { 
+       // TODO: remove hardcoded values
+       if(  fAltroRawStreamPtr->GetHWAddress() < 128 || ( fAltroRawStreamPtr->GetHWAddress() ^ 0x800) < 128 ) 
+         {
+           continue; 
+         }
+       else
+         {
+           cnt ++;
+           UShort_t* firstBunchPtr;
+           UShort_t chId = fMapperPtr->GetChannelID(iter->fSpecification, fAltroRawStreamPtr->GetHWAddress()); 
+           
+           if( fkDoPushRawData == true)
+             {
+               fRawDataWriter->SetChannelId( chId );
+             }
+           while( fAltroRawStreamPtr->NextBunch() == true )
+             {
+               nSamples = fAltroRawStreamPtr->GetBunchLength();
+                 
+               if( fkDoPushRawData == true)
+                 {
+                   //                fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(), nSamples,  fAltroRawStreamPtr->GetStartTimeBin()  );
+                   fRawDataWriter->WriteBunchData( fAltroRawStreamPtr->GetSignals(), nSamples,  fAltroRawStreamPtr->GetEndTimeBin()  );
+                 }
+               firstBunchPtr = const_cast< UShort_t* >(  fAltroRawStreamPtr->GetSignals()  );
+             }
+             
+           totSize += sizeof( AliHLTCaloChannelDataStruct );
+           if(totSize > size)
+             {
+               HLTError("Buffer overflow: Trying to write data of size: %d bytes. Output buffer available: %d bytes.", totSize, size);
+               return -1;
+             }
+
+           fAnalyzerPtr->SetData( firstBunchPtr, nSamples);
+           fAnalyzerPtr->Evaluate(0, nSamples);  
+          
+           //        if(fAnalyzerPtr->GetTiming() > fMinPeakPosition && fAnalyzerPtr->GetTiming() < fMaxPeakPosition)
+           {
+             channelDataPtr->fChannelID =  chId;
+             channelDataPtr->fEnergy = static_cast<Float_t>(fAnalyzerPtr->GetEnergy()) - fOffset;
+               
+             if( channelDataPtr->fEnergy > 70 )
+               {
+                 //              cout << __FILE__ << __LINE__ << "The energy is of  channel  "<< chId << "  is "  <<  channelDataPtr->fEnergy << endl;
+               }
+               
+             channelDataPtr->fTime = static_cast<Float_t>(fAnalyzerPtr->GetTiming());
+             channelDataPtr->fCrazyness = static_cast<Short_t>(crazyness);
+             channelCount++;
+             channelDataPtr++; // Updating position of the free output.
+           }   
+         }
+       fRawDataWriter->NewChannel();
+      }
+  }
+
+  //Writing the header
+  channelDataHeaderPtr->fNChannels   =  channelCount;
+  channelDataHeaderPtr->fAlgorithm   = fAlgorithm;
+  channelDataHeaderPtr->fInfo        = 0;
+
+  if( fkDoPushRawData == true)
+    {
+      tmpsize += fRawDataWriter->CopyBufferToSharedMemory( (UShort_t *)channelDataPtr, size, totSize);
+    }
+
+  // channelDataHeaderPtr->fHasRawData  = false;
+  channelDataHeaderPtr->fHasRawData = fkDoPushRawData;
+
+  HLTDebug("Number of channels: %d", channelCount);
+  //returning the size used
+  // delete fAltroRawStreamPtr;
+  tmpsize += sizeof(AliHLTCaloChannelDataStruct)*channelCount + sizeof(AliHLTCaloChannelDataHeaderStruct); 
+
+  //  return sizeof(AliHLTPHOSChannelDataStruct)*channelCount + sizeof(AliHLTPHOSChannelDataHeaderStruct);
+  return  tmpsize;
+
+}
+
+int
+AliHLTCaloRawAnalyzerComponentv3::DoInit( int argc, const char** argv )
+{ 
+
+  //See base class for documentation
+  //  fPrintInfo = kFALSE;
+
+  int iResult=0;
+  
+  //  fMapperPtr = new AliHLTCaloMapper();
+  InitMapping(); 
+
+  for(int i = 0; i < argc; i++)
+    {
+      if(!strcmp("-offset", argv[i]))
+       {
+         fOffset = atoi(argv[i+1]);
+       }
+      if(!strcmp("-bunchsizecut", argv[i]))
+       {
+         fBunchSizeCut = atoi(argv[i+1]);
+       }
+      if(!strcmp("-minpeakposition", argv[i]))
+       {
+         fMinPeakPosition = atoi(argv[i+1]);
+       }
+      if(!strcmp("-maxpeakposition", argv[i]))
+       {
+         fMaxPeakPosition = atoi(argv[i+1]);
+       }  
+    }
+  if( fMapperPtr->GetIsInitializedMapping() == false)
+    {
+      Logging(kHLTLogFatal, __FILE__ , IntToChar(  __LINE__ ) , "AliHLTCaloMapper::Could not initialise mapping from file %s, aborting", fMapperPtr->GetFilePath());
+      return -4;
+    }
+
+  return iResult;
+}
+
+
+
+
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::RawDataWriter() :  //fIsFirstChannel(true),
+                                                                   fRawDataBuffer(0),
+                                                                   fCurrentChannelSize(0),
+                                                                   //    fIsFirstChannel(true),
+                                                                   fBufferIndex(0),
+                                                                   //      fBufferSize( NZROWSRCU*NXCOLUMNSRCU*ALTROMAXSAMPLES*NGAINS +1000 ),
+                                                                   fBufferSize( 64*56*ALTROMAXSAMPLES*NGAINS +1000 ),
+                                                                   fCurrentChannelIdPtr(0),
+                                                                   fCurrentChannelSizePtr(0),
+                                                                   fCurrentChannelDataPtr(0),
+                                                                   fTotalSize(0)
+{
+  // See header file for documentation
+  fRawDataBuffer = new UShort_t[fBufferSize];
+  Init();
+}
+
+
+   
+void  
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::Init()
+{
+  // See header file for documentation
+  fCurrentChannelIdPtr = fRawDataBuffer;
+  fCurrentChannelSizePtr = fRawDataBuffer +1;
+  fCurrentChannelDataPtr = fRawDataBuffer +2;
+  ResetBuffer();
+}
+
+void
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::NewEvent()
+{
+  // See header file for documentation
+  Init();
+  fTotalSize = 0;
+}
+
+
+void
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::NewChannel( )
+{
+  // See header file for documentation
+  *fCurrentChannelSizePtr   = fCurrentChannelSize;
+  fCurrentChannelIdPtr     += fCurrentChannelSize;
+  fCurrentChannelSizePtr    += fCurrentChannelSize;
+  fCurrentChannelDataPtr   += fCurrentChannelSize;
+  fBufferIndex = 0;
+  fCurrentChannelSize = 2;
+  fTotalSize += 2;
+}
+
+
+void 
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::WriteBunchData(const UShort_t *bunchdata,  const int length,   const UInt_t starttimebin )
+{
+  // See header file for documentation
+  fCurrentChannelDataPtr[fBufferIndex] = starttimebin;
+  fCurrentChannelSize ++;
+  fBufferIndex++;
+  fCurrentChannelDataPtr[fBufferIndex] = length;
+  fCurrentChannelSize ++;
+  fBufferIndex++;
+
+  fTotalSize +=2;
+
+  for(int i=0; i < length; i++)
+    {
+      fCurrentChannelDataPtr[ fBufferIndex + i ] =  bunchdata[i];
+    }
+
+  fCurrentChannelSize += length;
+  fTotalSize += length;
+  fBufferIndex += length;
+}
+
+
+void
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::SetChannelId( const UShort_t channeldid  )
+{
+  // See header file for documentation
+  *fCurrentChannelIdPtr =  channeldid;
+}
+
+
+void
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::ResetBuffer()
+{
+  // See header file for documentation
+  for(int i=0; i < fBufferSize ; i++ )
+    {
+      fRawDataBuffer[i] = 0;
+    }
+}
+
+
+int
+AliHLTCaloRawAnalyzerComponentv3::RawDataWriter::CopyBufferToSharedMemory(UShort_t *memPtr, const int sizetotal, const int sizeused )
+{
+  // See header file for documentation
+  int sizerequested =  (sizeof(int)*fTotalSize + sizeused);
+
+  if(  sizerequested   > sizetotal  )
+    {
+      return 0;
+  }
+  else
+    {
+      for(int i=0; i < fTotalSize; i++)
+       {
+         memPtr[i] = fRawDataBuffer[i]; 
+       }
+      return fTotalSize;
+   }
+}
+  
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.h b/HLT/CALO/AliHLTCaloRawAnalyzerComponentv3.h
new file mode 100644 (file)
index 0000000..a80ba96
--- /dev/null
@@ -0,0 +1,232 @@
+
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * Primary Authors: Per Thomas Hille, 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.                  *
+ **************************************************************************/
+
+
+#ifndef ALIHLTCALORAWANALYZERCOMPONENTV3_H
+#define ALIHLTCALORAWANALYZERCOMPONENTV3_H
+
+
+/**
+ * Raw data analyzer component base class for PHOS HLT
+ *
+ * @file   AliHLTCaloRawAnalyzerComponentv3.h
+ * @author Oystein Djuvsland
+ * @date   
+ * @brief  A clusterizer component 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
+
+#include "AliHLTCaloRcuProcessor.h"
+
+
+class AliHLTCaloRawAnalyzer;
+class AliHLTCaloRcuCellEnergyDataStruct;
+class AliHLTCaloMapper;
+class AliHLTCaloSanityInspector;
+class AliHLTCaloDigitMaker;
+class AliHLTCaloDigitContainerDataStruct;
+class AliRawReaderMemory;
+class AliAltroRawStreamV3;
+
+/**
+ * @class AliHLTCaloRawAnalyzerComponentv3
+ * This the new and fast version of the component taking care of the decoding and energy and timing 
+ * extraction of the raw data from PHOS.
+ *
+ * <h2>General properties:</h2>
+ *
+ * Component ID: \b PhosRawAnalyzerv3 <br>
+ * Library: \b libAliHLTCalo.so     <br>
+ * Input Data Types: @ref <br>
+ * Output Data Types: @ref AliHLTCaloDefinitions::fgkChannelDataType<br>
+ *
+ * <h2>Mandatory arguments:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * \li No mandatory arguments for component                           <br>
+ *
+ * <h2>Optional arguments:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * \li -offset      <i> value </i> <br>
+ *      gives the offset added to the data during zero suppression (default value: 0)
+ * \li -bunchsizecut <i> value </i> <br>
+ *      minimum number of samples a bunch must contain to be considered  (default value: 0)
+ * \li -minpeakposition <i> value </i> <br>
+ *      cut on minimum postion of the peak in the bunch (defaul value: 0)
+ * \li -maxpeakposition <i> value </i> <br>
+ *      cut on maximum postion of the peak in the bunch (defaul value: 100)
+ *
+ * <h2>Configuration:</h2>
+ * <!-- NOTE: ignore the \li. <i> and </i>: it's just doxygen formatting -->
+ * \li No configuration arguments 
+ *
+ * <h2>Default CDB entries:</h2>
+ * \li No CDB entry yet, will come.
+ *
+ * <h2>Performance:</h2>
+ * Pretty good (~ 3 kHz), depends on amount of data...
+ *
+ * <h2>Memory consumption:</h2>
+ * Depends on the amount of data, but pretty godd
+ *
+ * <h2>Output size:</h2>
+ * Depends on the amount of data...
+ *
+ * More detailed description. (Soon)
+ *
+ * @ingroup alihlt_phos
+ */ 
+
+class AliHLTCaloMapper;
+
+
+class AliHLTCaloRawAnalyzerComponentv3 : public AliHLTCaloRcuProcessor
+{
+ public:
+
+  /** Standard constructor */
+  AliHLTCaloRawAnalyzerComponentv3();
+
+  /** Destructor */
+  virtual ~AliHLTCaloRawAnalyzerComponentv3();
+
+  // virtual bool CheckInputDataType(const AliHLTComponentDataType &datatype) = 0;
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual int DoInit(int argc =0, const char** argv  = 0);
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual int Deinit();
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual const char* GetComponentID() = 0;
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual void GetInputDataTypes( vector <AliHLTComponentDataType>& list) = 0;
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual AliHLTComponentDataType GetOutputDataType();
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual AliHLTComponent* Spawn() = 0; 
+
+ protected:
+virtual bool CheckInputDataType(const AliHLTComponentDataType &datatype) = 0;
+  /** interface function, see @ref AliHLTComponent for description */
+  using AliHLTCaloRcuProcessor::DoEvent;
+
+  /** interface function, see @ref AliHLTComponent for description */
+  virtual int DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
+                    AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
+                      AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks );  
+
+  /** 
+   * Do the real processing in the component 
+   * @param iter is the pointer to the data blocks
+   * @param outputPtr is the pointer to the output buffer
+   * @param size is the available size for output
+   * @param totSize is the total size used for output
+   * @return the size output size used
+   */
+  virtual Int_t DoIt(const AliHLTComponentBlockData* iter, AliHLTUInt8_t* outputPtr, const AliHLTUInt32_t size, UInt_t& totSize); 
+
+
+  /** Pointer to an analyzer object used for raw data anlysis */ 
+  AliHLTCaloRawAnalyzer *fAnalyzerPtr;   //COMMENT
+  AliHLTCaloMapper *fMapperPtr;     
+ private:
+
+  /** Keep the copy constructor private since it should not be used */
+  AliHLTCaloRawAnalyzerComponentv3(const AliHLTCaloRawAnalyzerComponentv3 & );
+
+  /** Keep the assignement operator private since it should not be used */
+  AliHLTCaloRawAnalyzerComponentv3 & operator = (const AliHLTCaloRawAnalyzerComponentv3 &);
+
+  virtual void InitMapping() = 0;
+  const bool fkDoPushRawData;
+  /** Mapping from harware address to geometrical address */
+  //  AliHLTCaloMapper *fMapperPtr;                       //!transient 
+
+  /** Pointer to object which may check the integrity of the data */
+  AliHLTCaloSanityInspector *fSanityInspectorPtr;     //!transient
+
+  /** Pointer to the raw data reader which reads from memory */
+  AliRawReaderMemory* fRawReaderMemoryPtr;            //!transient
+  
+  /** Pointer to the raw stream */
+  AliAltroRawStreamV3* fAltroRawStreamPtr;              //!transient
+
+  /** Describing which algorithm we are using */
+  Short_t fAlgorithm;                                 //COMMENT
+
+  /** The offset applied before ZS */
+  Int_t fOffset;                                      //COMMENT
+
+  /** The minimum length a bunch can have to be considered */
+  Int_t fBunchSizeCut;                                //COMMENT
+
+  /** The lowest position a peak can have to be considered */
+  Int_t fMinPeakPosition;                             //COMMENT
+  
+  /** The maximum position a peak can have to be considered */
+  Int_t fMaxPeakPosition;                             //COMMENT
+  
+  // AliHLTCaloMapper *fMapperPtr;
+
+
+  // TODO: Documentation!
+  class RawDataWriter 
+  {
+  public:
+    RawDataWriter();
+    ~RawDataWriter();
+    //   void WriteChannelId(const UShort_t channeldid );
+    void NewChannel( );
+    void WriteBunchData(const UShort_t *bunchdata,  const int length,   const UInt_t starttimebin );
+    void ResetBuffer();
+    void SetChannelId( const UShort_t channeldid );
+    //void CopyBufferToSharedMemory(UShort_t *memPtr, const int sizetotal, const int sizeused );
+    int CopyBufferToSharedMemory(UShort_t *memPtr, const int sizetotal, const int sizeused );
+    void NewEvent();
+   
+  private:
+    RawDataWriter (const RawDataWriter  & );
+    RawDataWriter & operator = (const RawDataWriter &);
+    void Init();
+    //    bool fIsFirstChannel;
+    UShort_t* fRawDataBuffer;
+    int fCurrentChannelSize;
+    int fBufferIndex;
+    int fBufferSize;
+    UShort_t *fCurrentChannelIdPtr;
+    UShort_t *fCurrentChannelSizePtr; 
+    UShort_t *fCurrentChannelDataPtr; 
+    int fTotalSize;
+  };
+
+  RawDataWriter *fRawDataWriter; 
+
+};
+
+#endif
+
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerCrude.cxx b/HLT/CALO/AliHLTCaloRawAnalyzerCrude.cxx
new file mode 100644 (file)
index 0000000..15dc2a7
--- /dev/null
@@ -0,0 +1,146 @@
+// $Id: AliHLTCaloRawAnalyzerCrude.cxx 34622 2009-09-04 13:22:01Z odjuvsla $
+
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: Per Thomas Hille for the ALICE HLT Project.                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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 "AliHLTCaloRawAnalyzerCrude.h"
+
+#include <iostream>
+
+using namespace std;
+
+//ClassImp(AliHLTCaloRawAnalyzerCrude) 
+
+
+/**
+ * The AliHLTPHOSPeakfinder class is the class for extracting the basic signal parameters
+ * "timing" and "energy" from the PHOS raw data. Physical data will for a given readout channel be
+ * a sequense of ADC digitized 10 bit integer values, however for performance reasons all values used in
+ * calculation is of type double.
+ **/
+//____________________________________________________________________________
+AliHLTCaloRawAnalyzerCrude::AliHLTCaloRawAnalyzerCrude():AliHLTCaloRawAnalyzer() 
+{
+
+}
+
+
+//____________________________________________________________________________
+AliHLTCaloRawAnalyzerCrude::~AliHLTCaloRawAnalyzerCrude()
+{
+
+} //end AliHLTCaloRawAnalyzerCrude
+
+
+/**
+* Extraction of timing and energy using Crude estimate.
+* The. The parameters "start" and "length" defines a sub array  of the data array
+* that will be used for the the fit. If start+length must not exeed the total length
+* of the Data array. "start" must be chosen as close as possible to t0.
+* The baseline must also be subtracted.                                                              .
+* "index + length" must not exeed the length of the data array set in the constructor.
+* @param start the start index of the subarray of the data array. 
+* @param length the number of samples to use starting from index 
+**/
+// //____________________________________________________________________________
+// void 
+// AliHLTCaloRawAnalyzerCrude::Evaluate(int start, int length)
+// {
+//   double tmpAmplitudeMax =0; 
+//   double tmpTime = 0;
+
+//   for(int i=start; i<length; i++)
+//     {
+//       if(fIntDataPtr[i] >  tmpAmplitudeMax && i > 5)
+//     {
+//       tmpAmplitudeMax = fIntDataPtr[i];
+//       tmpTime = i;               
+//     }
+//     }
+       
+//   fDAmpl = tmpAmplitudeMax;
+//   fDTof =  tmpTime;
+//   //thats all 
+// } //end Crude
+
+
+void 
+AliHLTCaloRawAnalyzerCrude::Evaluate(int start, int length)
+{
+  //  cout << "AliHLTCaloRawAnalyzerCrude::Evaluate TP0"  << endl;
+
+  //DumpData(T
+
+  //  DumpData(fDoubleDataPtr,50, 25);
+
+  if(fUseShortValues == true)
+    {
+      EvaluateShort(start, length);
+    }
+  else
+    {
+
+      double tmpAmplitudeMax =0; 
+      double tmpTime = 0;
+
+      for(int i=start; i<length; i++)
+       {
+         //   if(fDoubleDataPtr[i] >  tmpAmplitudeMax && i > 5)
+         if(fIntDataPtr[i] >  tmpAmplitudeMax && i > 5)
+           {
+             //          tmpAmplitudeMax = fDoubleDataPtr[i];
+             tmpAmplitudeMax = fIntDataPtr[i];
+             tmpTime = i;                   
+           }
+       }
+
+      fDAmpl = tmpAmplitudeMax;
+      fDTof =  tmpTime;
+    }
+  //thats all 
+} //end Crude
+
+void 
+AliHLTCaloRawAnalyzerCrude::EvaluateShort(int start, int length)
+{
+  //  cout << "AliHLTCaloRawAnalyzerCrude::Evaluate TP0"  << endl;
+
+  //DumpData(T
+
+  //  DumpData(fDoubleDataPtr,50, 25);
+
+  double tmpAmplitudeMax =0; 
+  double tmpTime = 0;
+
+  for(int i=start; i<length; i++)
+    {
+      //      cout << "sample index: " << i << endl;
+        //   if(fDoubleDataPtr[i] >  tmpAmplitudeMax && i > 5)
+      if(fShortDataPtr[i] >  tmpAmplitudeMax && i > 5)
+       {
+         //      tmpAmplitudeMax = fDoubleDataPtr[i];
+         tmpAmplitudeMax = fShortDataPtr[i];
+         tmpTime = i;               
+       }
+    }
+
+  fDAmpl = tmpAmplitudeMax;
+  fDTof =  tmpTime;
+  //thats all 
+} //end Crude
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerCrude.h b/HLT/CALO/AliHLTCaloRawAnalyzerCrude.h
new file mode 100644 (file)
index 0000000..80c3700
--- /dev/null
@@ -0,0 +1,25 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloRawAnalyzerCrude.h 34264 2009-08-14 18:29:23Z odjuvsla $
+
+#ifndef ALIHLTCALORAWANALYZERCRUDE_H
+#define ALIHLTCALORAWANALYZERCRUDE_H
+#include "AliHLTCaloRawAnalyzer.h"
+
+
+/* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                          */
+
+
+class AliHLTCaloRawAnalyzerCrude : public AliHLTCaloRawAnalyzer
+{
+ public:
+  AliHLTCaloRawAnalyzerCrude();
+  virtual ~AliHLTCaloRawAnalyzerCrude();
+  virtual void Evaluate(int start = 0, int lenght = 100);
+  virtual void EvaluateShort(int start = 0, int lenght = 100);
+ private:
+  //  ClassDef(AliHLTCaloRawAnalyzerCrude, 2) 
+  
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerCrudeComponent.cxx b/HLT/CALO/AliHLTCaloRawAnalyzerCrudeComponent.cxx
new file mode 100644 (file)
index 0000000..a0f08a9
--- /dev/null
@@ -0,0 +1,75 @@
+// $Id: AliHLTCaloRawAnalyzerCrudeComponent.cxx 29824 2008-11-10 13:43:55Z richterm $
+
+
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: Per Thomas Hille for the ALICE HLT Project.                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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 "AliHLTCaloRawAnalyzerCrudeComponent.h"
+#include "AliHLTCaloRawAnalyzerCrude.h"
+
+//AliHLTCaloRawAnalyzerCrudeComponent gAliHLTCaloRawAnalyzerCrudeComponent;
+
+//___________________________________________________________________________
+AliHLTCaloRawAnalyzerCrudeComponent::AliHLTCaloRawAnalyzerCrudeComponent()
+{
+  fAnalyzerPtr = new AliHLTCaloRawAnalyzerCrude();
+} 
+
+//___________________________________________________________________________
+AliHLTCaloRawAnalyzerCrudeComponent::~AliHLTCaloRawAnalyzerCrudeComponent()
+{
+  if(fAnalyzerPtr)
+    {
+      delete fAnalyzerPtr;
+      fAnalyzerPtr = 0;
+    }
+}
+
+//___________________________________________________________________________
+AliHLTCaloRawAnalyzerCrudeComponent::AliHLTCaloRawAnalyzerCrudeComponent(const AliHLTCaloRawAnalyzerCrudeComponent & ):AliHLTCaloRawAnalyzerComponentv3()
+{
+
+}
+
+int
+AliHLTCaloRawAnalyzerCrudeComponent::Deinit()
+{
+  
+  if(fAnalyzerPtr)
+    {
+      delete fAnalyzerPtr;
+      fAnalyzerPtr = 0;
+    }
+  Logging(kHLTLogInfo, "HLT", "CALO", ",AliHLTCaloRawAnalyzerCrudeComponent Deinit");
+  return 0;
+}
+
+//___________________________________________________________________________
+const char* 
+AliHLTCaloRawAnalyzerCrudeComponent::GetComponentID()
+{
+  return "CaloRawCrude";
+}
+
+//___________________________________________________________________________
+
+/*
+AliHLTComponent*
+AliHLTCaloRawAnalyzerCrudeComponent::Spawn()
+{
+  return new AliHLTCaloRawAnalyzerCrudeComponent;
+}
+*/
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerCrudeComponent.h b/HLT/CALO/AliHLTCaloRawAnalyzerCrudeComponent.h
new file mode 100644 (file)
index 0000000..11cc3a0
--- /dev/null
@@ -0,0 +1,30 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTPHOSRawAnalyzerCrudeComponent.h 29824 2008-11-10 13:43:55Z richterm $
+
+#ifndef ALIHLTCALORAWANALYZERCRUDECOMPONENT_H
+#define ALIHLTCALORAWANALYZERCRUDECOMPONENT_H
+
+#include "AliHLTCaloRawAnalyzerComponentv3.h"
+
+/* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice  */ 
+
+
+
+class AliHLTCaloRawAnalyzerCrudeComponent: public AliHLTCaloRawAnalyzerComponentv3
+{
+ public:
+  AliHLTCaloRawAnalyzerCrudeComponent();
+  virtual ~AliHLTCaloRawAnalyzerCrudeComponent();
+  AliHLTCaloRawAnalyzerCrudeComponent(const AliHLTCaloRawAnalyzerCrudeComponent & );
+  // AliHLTCaloRawAnalyzerCrudeComponent & operator = (const AliHLTCaloRawAnalyzerCrudeComponent)
+  //  {
+  //   return *this;
+  // };
+
+  virtual int Deinit();
+  virtual const char* GetComponentID();
+  virtual AliHLTComponent* Spawn() = 0;
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinder.cxx b/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinder.cxx
new file mode 100644 (file)
index 0000000..0f439b4
--- /dev/null
@@ -0,0 +1,156 @@
+// $Id: AliHLTCaloRawAnalyzerPeakFinder.cxx 29824 2008-11-10 13:43:55Z richterm $
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        * 
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                * 
+ *                                                                        *
+ * 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 "AliHLTCaloRawAnalyzerPeakFinder.h"
+//#include <iostream>
+#include <cmath>
+#include "AliHLTCaloUtilities.h" 
+
+using std::cout;
+using std::endl;
+
+//ClassImp(AliHLTCaloRawAnalyzerPeakFinder) 
+
+
+
+/**
+ * The AliHLTCaloPeakfinder class is the class for extracting the basic signal parameters
+ * "timing" and "energy" from the Calorimeter's raw data. Physical data will for a given readout channel be
+ * a sequense of ADC digitized 10 bit integer values, however for performance reasons all values used in
+ * calculation is of type double.
+ **/
+AliHLTCaloRawAnalyzerPeakFinder::AliHLTCaloRawAnalyzerPeakFinder():AliHLTCaloRawAnalyzer(), 
+                                                                   fTVectorPtr(0), 
+                                                                  fAVectorPtr(0), 
+                                                                  fTVectorSize(0), 
+                                                                  fAVectorSize(0)
+//  fUtilitiesPtr(0)
+{
+  //  fUtilitiesPtr = new  AliHLTCaloUtilities(); 
+  //  cout <<"PeakFinder:You cannot invoke the Fitter without arguments"<<endl;;
+}
+
+
+//___________________________________________________________________
+AliHLTCaloRawAnalyzerPeakFinder::~AliHLTCaloRawAnalyzerPeakFinder()
+{
+
+} //end AliHLTCaloRawAnalyzerPeakFinder
+
+
+
+void 
+AliHLTCaloRawAnalyzerPeakFinder::SetTVector(Double_t *tVec, Int_t size)
+{
+  fTVectorSize = size;
+
+  if(fTVectorPtr != 0)
+    {
+      delete fTVectorPtr;
+    }
+  
+  fTVectorPtr = new Double_t[size];
+
+  for(int i=0; i< size; i++)
+    {
+      fTVectorPtr[i] = tVec[i];
+    }
+}
+
+
+//___________________________________________________________________
+void
+AliHLTCaloRawAnalyzerPeakFinder::SetAVector(Double_t *aVec, Int_t size)
+{
+    
+  fAVectorSize = size;
+
+  if(fAVectorPtr != 0)
+    {
+      delete fAVectorPtr;
+    }
+  
+  fAVectorPtr = new Double_t[size];
+
+  for(int i=0; i< size; i++)
+    {
+      fAVectorPtr[i] = aVec[i];
+    }
+}
+
+
+
+//___________________________________________________________________
+void 
+AliHLTCaloRawAnalyzerPeakFinder::Evaluate(Int_t /*start*/, Int_t length)
+{
+  fDTof = 0;
+  fDAmpl = 0;
+  Int_t tmpLength;
+
+  if(fTVectorPtr == 0 || fAVectorPtr == 0)
+    {
+
+    }
+  else
+    {
+      if(length <  fTVectorSize)
+       {
+         tmpLength = length;
+       }
+      else
+       {
+         tmpLength = fTVectorSize;
+       }
+      
+      for(int i=0; i < tmpLength; i++)
+       {  
+         //fDAmpl += fAVectorPtr[i]*fIntDataPtr[i]; removed 18 april 2008    
+         fDAmpl += fAVectorPtr[i]*fDoubleDataPtr[i];   
+       }
+
+      for(int i=0; i < tmpLength; i++)
+       {   
+         //  fDTof += fTVectorPtr[i]*fIntDataPtr[i];  removed 18 april 2008   
+         fDTof += fTVectorPtr[i]*fDoubleDataPtr[i]; 
+       }
+      
+      if(fDAmpl > 900)
+       {
+         //      Double_t tmpMax = MaxValue(const_cast<unsigned int*>(fIntDataPtr), tmpLength);  removed 18 april 2008   
+         double tmpMax = fUtilitiesPtr->MaxValue(fDoubleDataPtr, tmpLength); 
+
+         if(tmpMax == 1023)
+           {
+             fDAmpl = tmpMax;
+           }
+       }
+
+      fDTof = fDTof/fDAmpl;
+
+    }
+} //end Evaluate
+
+
+
+
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinder.h b/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinder.h
new file mode 100644 (file)
index 0000000..e146d23
--- /dev/null
@@ -0,0 +1,86 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloRawAnalyzerPeakFinder.h 29824 2008-11-10 13:43:55Z richterm $
+
+#ifndef ALIHLTCALORAWANALYZERPEAKFINDER_H
+#define ALIHLTCALORAWANALYZERPEAKFINDER_H
+/* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                          */
+
+//#include <Rtypes.h>
+//#include "TObject.h"
+#include "AliHLTCaloRawAnalyzer.h"
+//#include "AliHLTCaloBase.h"
+//class AliHLTCaloUtilities;
+
+class AliHLTCaloRawAnalyzerPeakFinder : public AliHLTCaloRawAnalyzer
+{
+ public:
+  AliHLTCaloRawAnalyzerPeakFinder();
+  //  AliHLTCaloRawAnalyzerPeakFinder(const AliHLTCaloRawAnalyzerPeakFinder & );
+  //  AliHLTCaloRawAnalyzerPeakFinder & operator = (const AliHLTCaloRawAnalyzerPeakFinder &)
+  //    {
+  //     return *this; 
+  //    }
+
+  virtual ~AliHLTCaloRawAnalyzerPeakFinder();
+
+
+/**
+* Extraction of timing and energy using the Peakfinde Algorithm.
+* The. The parameters "start" and "length" defines a sub array  of the data array
+* that will be used for the the fit. If start+length must not exeed the total length
+* of the Data array. "start" must be chosen as close as possible to t0.
+* The baseline must also be subtracted.
+* The length of "tVector" and "aVector" mus be equal to length.
+* "index + length" must not exeed the length of the data array set in the constructor.
+* @param tVectPtr the peakfinder vector for timing
+* @param size size in number of values of the time vector
+*/
+  virtual void SetTVector(Double_t *tVectPtr =0, Int_t size = 0);
+
+
+
+/**
+* Extraction of timing and energy using the Peakfinde Algorithm.
+* The. The parameters "start" and "length" defines a sub array  of the data array
+* that will be used for the the fit. If start+length must not exeed the total length
+* of the Data array. "start" must be chosen as close as possible to t0.
+* The baseline must also be subtracted.
+* The length of "tVector" and "aVector" mus be equal to length.
+* "index + length" must not exeed the length of the data array set in the constructor.
+* @param aVectPtr the peakfinder vector for timing
+* @param size size in number of values of the time vector
+*/
+  virtual void SetAVector(Double_t *aVectPtr =0, Int_t size =0);
+
+
+/**
+* Extraction of timing and energy using the Peakfinde Algorithm.
+* The. The parameters "start" and "length" defines a sub array  of the data array
+* that will be used for the the fit. If start+length must not exeed the total length
+* of the Data array. "start" must be chosen as close as possible to t0.
+* The baseline must also be subtracted.
+* The length of "tVector" and "aVector" mus be equal to length.
+* "index + length" must not exeed the length of the data array set in the constructor.
+* @param start the start index of the subarray of the data array. 
+* @param length the number of samples to use starting from index 
+**/
+  virtual void Evaluate(Int_t start = 0, Int_t length = 100);
+ private:
+ AliHLTCaloRawAnalyzerPeakFinder(const AliHLTCaloRawAnalyzerPeakFinder & );
+ AliHLTCaloRawAnalyzerPeakFinder & operator = (const AliHLTCaloRawAnalyzerPeakFinder &);
+
+ Double_t   *fTVectorPtr;  //[1008]        /**<Peakfinder vector for TOF reconstruction*/
+ Double_t   *fAVectorPtr;  //[1008]        /**<Peakfinder vector for Energy reconstruction*/  
+ Int_t       fTVectorSize;
+ Int_t       fAVectorSize;
+ // AliHLTCaloUtilities *fUtilitiesPtr;
+
+
+  //  ClassDef(AliHLTCaloRawAnalyzerPeakFinder, 2) 
+  
+    };
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinderComponent.cxx b/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinderComponent.cxx
new file mode 100644 (file)
index 0000000..f5569de
--- /dev/null
@@ -0,0 +1,148 @@
+// $Id: AliHLTPHOSRawAnalyzerPeakFinderComponent.cxx 31490 2009-03-15 16:27:11Z odjuvsla $
+
+/**************************************************************************
+ * Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved.      *
+ *                                                                        *
+ * Author: Per Thomas Hille for the ALICE HLT Project.                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * 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 "AliHLTCaloRawAnalyzerPeakFinderComponent.h"
+#include "AliHLTCaloRawAnalyzerPeakFinder.h"
+//#include <cstdlib>
+//#include "AliHLTCaloCommonDefs.h"
+
+
+
+//AliHLTCaloRawAnalyzerPeakFinderComponent gAliHLTCaloRawAnalyzerPeakFinderComponent;
+
+//___________________________________________________________________________________________________________
+AliHLTCaloRawAnalyzerPeakFinderComponent::AliHLTCaloRawAnalyzerPeakFinderComponent():AliHLTCaloRawAnalyzerComponentv3()
+{
+  fAnalyzerPtr = new AliHLTCaloRawAnalyzerPeakFinder();
+
+  if(LoadPFVector() == kFALSE)
+    {
+      //      cout << "Warning, could not load PF vectors" << endl;
+    }
+  else 
+    {
+      //    cout << "Loaded PF vectors" << endl;
+    }
+} 
+
+
+//___________________________________________________________________________________________________________
+AliHLTCaloRawAnalyzerPeakFinderComponent::~AliHLTCaloRawAnalyzerPeakFinderComponent()
+{
+
+  if(fAnalyzerPtr)
+    {
+      delete fAnalyzerPtr;
+      fAnalyzerPtr = 0;
+    }
+}
+
+
+//___________________________________________________________________________________________________________
+AliHLTCaloRawAnalyzerPeakFinderComponent::AliHLTCaloRawAnalyzerPeakFinderComponent(const AliHLTCaloRawAnalyzerPeakFinderComponent & ) : AliHLTCaloRawAnalyzerComponentv3()
+{
+
+}
+
+//-----------------------------------------------------------------------------------------------------------
+int
+AliHLTCaloRawAnalyzerPeakFinderComponent::Deinit()
+{
+  
+  if(fAnalyzerPtr)
+    {
+      delete fAnalyzerPtr;
+      fAnalyzerPtr = 0;
+    }
+  Logging(kHLTLogInfo, "HLT", "PHOS", ",AliHLTCaloRawAnalyzerCrudeComponent Deinit");
+  return 0;
+}
+
+//___________________________________________________________________________________________________________
+
+
+/*
+const char* 
+AliHLTCaloRawAnalyzerPeakFinderComponent::GetComponentID()
+{
+  return "PhosRawPeakFinder";
+}
+*/
+
+
+ /*
+//___________________________________________________________________________________________________________
+Bool_t 
+AliHLTCaloRawAnalyzerPeakFinderComponent::LoadPFVector()
+{
+  return LoadPFVector(PFDEFAULTSTARTINDEX,  PFDEFAULTNSAMPLES, DEFAULTTAU, DEFAULTFS );
+}
+
+
+//___________________________________________________________________________________________________________
+Bool_t 
+AliHLTCaloRawAnalyzerPeakFinderComponent::LoadPFVector(int startIndex, int nSamples, int tau, int fs)
+{
+  char tmpPFPath[PFMAXPATHLENGTH];
+  Double_t * tmpAVector = new Double_t[nSamples];
+  Double_t * tmpTVector = new Double_t[nSamples]; 
+  sprintf(tmpPFPath,"%s%s/start%dN%dtau%dfs%d.txt", getenv("ALICE_ROOT"), PFVECTORDIR, startIndex, nSamples, tau, fs);
+  FILE *fp;
+  fp = fopen(tmpPFPath, "r");
+  
+  Int_t res = 0; //OD to get rid of warnings
+  if(fp != 0)
+    {
+      for(int i=0; i <  nSamples; i++)
+       {
+         res = fscanf(fp, "%lf", &tmpAVector[i]);
+       }
+
+      res = fscanf(fp, "\n");
+
+      for(int i=0; i < nSamples; i++)
+       {
+         res = fscanf(fp, "%lf", &tmpTVector[i]);
+       }
+      fAnalyzerPtr->SetAVector(tmpAVector,  nSamples);
+      fAnalyzerPtr->SetTVector(tmpTVector,  nSamples);
+      fclose(fp);
+      delete [] tmpAVector;
+      delete [] tmpTVector;
+      return kTRUE;
+    }
+  
+  else
+    {
+      delete [] tmpAVector;
+      delete [] tmpTVector;
+      HLTFatal("ERROR: could not  open PF vector file");
+      return kFALSE;
+    }
+}
+ */
+
+
+//___________________________________________________________________________________________________________
+
+/*
+AliHLTComponent*
+AliHLTCaloRawAnalyzerPeakFinderComponent::Spawn()
+{
+  return new AliHLTCaloRawAnalyzerPeakFinderComponent;
+}
+*/
diff --git a/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinderComponent.h b/HLT/CALO/AliHLTCaloRawAnalyzerPeakFinderComponent.h
new file mode 100644 (file)
index 0000000..54f0503
--- /dev/null
@@ -0,0 +1,42 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTPHOSRawAnalyzerPeakFinderComponent.h 29824 2008-11-10 13:43:55Z richterm $
+
+#ifndef ALIHLTCALORAWANALYZERPEAKFINDERCOMPONENT_H
+#define ALIHLTCALORAWANALYZERPEAKFINDERCOMPONENT_H
+
+/* Copyright(c) 2006, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice  */ 
+
+
+
+#include "AliHLTCaloRawAnalyzerComponentv3.h"
+
+class AliHLTCaloRawAnalyzerPeakFinderComponent: public AliHLTCaloRawAnalyzerComponentv3
+{
+ public:
+  AliHLTCaloRawAnalyzerPeakFinderComponent();
+  virtual ~AliHLTCaloRawAnalyzerPeakFinderComponent();
+
+  virtual int Deinit();
+  virtual const char* GetComponentID() = 0;
+  virtual AliHLTComponent* Spawn() = 0;
+ private:
+  //  Bool_t LoadPFVector(); 
+  //  Bool_t LoadPFVector(int startindex, int Nsamples, int tau, int fs);
+  
+  virtual const Bool_t LoadPFVector() = 0; 
+  virtual const Bool_t LoadPFVector(const int startindex, const int Nsamples, const int tau, const int fs) = 0;
+
+  AliHLTCaloRawAnalyzerPeakFinderComponent(const AliHLTCaloRawAnalyzerPeakFinderComponent & ); 
+  
+  /*
+  AliHLTCaloRawAnalyzerPeakFinderComponent & operator = (const AliHLTCaloRawAnalyzerPeakFinderComponent)
+    {
+      return *this;
+    };
+  */
+};
+
+
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloRcuProcessor.cxx b/HLT/CALO/AliHLTCaloRcuProcessor.cxx
new file mode 100644 (file)
index 0000000..d0ea779
--- /dev/null
@@ -0,0 +1,35 @@
+// $Id: AliHLTCaloRcuProcessor.cxx 29824 2008-11-10 13:43:55Z richterm $
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * 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 "AliHLTCaloRcuProcessor.h"
+
+AliHLTCaloRcuProcessor::AliHLTCaloRcuProcessor():AliHLTCaloProcessor() 
+                                                //                                              AliHLTCaloRcuProperties()
+{
+
+}
+
+
+AliHLTCaloRcuProcessor::~AliHLTCaloRcuProcessor()
+{
+
+}
+
+
+
diff --git a/HLT/CALO/AliHLTCaloRcuProcessor.h b/HLT/CALO/AliHLTCaloRcuProcessor.h
new file mode 100644 (file)
index 0000000..b862922
--- /dev/null
@@ -0,0 +1,30 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloRcuProcessor.h 29824 2008-11-10 13:43:55Z richterm $
+
+#ifndef ALIHLTCALORCUPROCESSOR_H
+#define ALIHLTCALORCUPROCESSOR_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+
+#include "AliHLTCaloProcessor.h"
+//#include "AliHLTCaloRcuProperties.h"
+
+//class  AliHLTCaloRcuProcessor : public AliHLTCaloProcessor, public AliHLTCaloRcuProperties
+class  AliHLTCaloRcuProcessor : public AliHLTCaloProcessor
+{
+ public:
+  AliHLTCaloRcuProcessor();
+  virtual ~AliHLTCaloRcuProcessor();
+
+ private:
+  AliHLTCaloRcuProcessor (const AliHLTCaloRcuProcessor & );
+  AliHLTCaloRcuProcessor   & operator = (const  AliHLTCaloRcuProcessor  &);
+
+
+
+};
+
+#endif
+
+
diff --git a/HLT/CALO/AliHLTCaloSanityInspector.cxx b/HLT/CALO/AliHLTCaloSanityInspector.cxx
new file mode 100644 (file)
index 0000000..be22834
--- /dev/null
@@ -0,0 +1,210 @@
+// $Id: AliHLTPHOSSanityInspector.cxx 35107 2009-09-30 01:45:06Z phille $
+
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/** 
+ * @file   AliHLTCaloSanityInspector.cxx
+ * @author Oystein Djuvsland
+ * @date 
+ * @brief  Sanity inspector for Calo HLT 
+ */
+
+// 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 "AliHLTCaloSanityInspector.h"
+#include "Rtypes.h"
+
+//ClassImp(AliHLTCaloSanityInspector);
+
+
+AliHLTCaloSanityInspector::AliHLTCaloSanityInspector() : 
+  //  AliHLTCaloBase(),
+  fMaxDifference(120)
+{
+  //See header file for documentation
+}
+
+
+AliHLTCaloSanityInspector::~AliHLTCaloSanityInspector()
+{
+  //See header file for documentation
+}
+
+
+
+Int_t  
+AliHLTCaloSanityInspector::CheckInsanity(const UInt_t* data, const Int_t N) const
+{
+   //See header file for documentation
+
+  for(Int_t i = 1; i < N; i++)
+    {
+      if((((Int_t)data[i] - (Int_t)data[i-1]) > fMaxDifference) || (((Int_t)data[i-1] - (Int_t)data[i]) > fMaxDifference))
+       return 1;
+    }
+  return 0;
+}
+
+/*
+Int_t
+AliHLTCaloSanityInspector::CheckInsanity(Int_t* data, Int_t N)
+{
+   //See header file for documentation
+  for(Int_t i = 1; i < N; i++)
+  {
+    if((((Int_t)data[i] - (Int_t)data[i-1]) > fMaxDifference) || (((Int_t)data[i-1] - (Int_t)data[i]) > fMaxDifference))
+      return 1;
+  }
+  return 0;
+}
+*/
+
+
+Int_t 
+AliHLTCaloSanityInspector::CheckAndHealInsanity(UInt_t* data, Int_t N)
+  //
+{
+   //See header file for documentation
+
+  Int_t crazyness = 0;
+
+  if(N > 3)
+    {
+      //Require a stable start 
+      if((((Int_t)data[0] - (Int_t)data[1]) > fMaxDifference) || (((Int_t)data[1] - (Int_t)data[0]) > fMaxDifference))
+       return -1;
+      if((((Int_t)data[1] - (Int_t)data[2]) > fMaxDifference) || (((Int_t)data[2] - (Int_t)data[1]) > fMaxDifference))
+       return -1;
+
+
+      for(Int_t i = 2; i < N - 3; i++)
+       {
+         if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
+           {
+             i++;
+             if((((Int_t)data[i] -(Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
+               {
+                 i++;
+                 if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
+                   {
+                     return -2;  //Too crazy
+                   }
+                 data[i-1] = ((Int_t)data[i] + (Int_t)data[i-2])/2;
+                 crazyness++;
+               }
+             else 
+               return -3;    //Two spikes in a row? 
+           }
+       }
+      
+      
+      
+      if((((Int_t)data[N - 3] -(Int_t) data[N - 2]) > fMaxDifference) || 
+        (((Int_t)data[N - 2] - (Int_t)data[N - 3]) > fMaxDifference))
+       {
+         if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) || 
+            (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
+           {
+             data[N - 2] = ((Int_t)data[N - 3] +  (Int_t)data[N - 1])/2;
+             return crazyness++;
+           }
+         return -4;
+
+       }
+      
+      if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) || 
+        (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
+       {
+         //      (Int_t)data[N - 3] = (Int_t)data[N - 4] -(Int_t) data[N - 5] + (Int_t)data[N-4];
+         data[N - 1] = data[N - 2];
+         return crazyness++;
+       }
+      
+    }
+  
+  return crazyness;
+  
+}
+
+
+
+Int_t 
+AliHLTCaloSanityInspector::CheckAndHealInsanity(Int_t* data, Int_t N)
+{
+   //See header file for documentation
+
+  Int_t crazyness = 0;
+
+  if(N > 3)
+    {
+      if((((Int_t)data[0] - (Int_t)data[1]) > fMaxDifference) || (((Int_t)data[1] - (Int_t)data[0]) > fMaxDifference))
+       return -1;
+      if((((Int_t)data[1] - (Int_t)data[2]) > fMaxDifference) || (((Int_t)data[2] - (Int_t)data[1]) > fMaxDifference))
+       return -1;
+
+
+      for(Int_t i = 2; i < N - 3; i++)
+       {
+         if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
+           {
+             i++;
+             if((((Int_t)data[i] -(Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
+               {
+                 i++;
+                 if((((Int_t)data[i] - (Int_t)data[i+1]) > fMaxDifference) || (((Int_t)data[i+1] - (Int_t)data[i]) > fMaxDifference))
+                   {
+                     return -2;  //Too crazy
+                   }
+                 data[i-1] = ((Int_t)data[i] + (Int_t)data[i-2])/2;
+                 crazyness++;
+               }
+             else 
+               return -3;    //Two spikes in a row? 
+           }
+       }
+      
+      
+      
+      if((((Int_t)data[N - 3] -(Int_t) data[N - 2]) > fMaxDifference) || 
+        (((Int_t)data[N - 2] - (Int_t)data[N - 3]) > fMaxDifference))
+       {
+         if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) || 
+            (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
+           {
+             data[N - 2] = ((Int_t)data[N - 3] +  (Int_t)data[N - 1])/2;
+             return crazyness++;
+           }
+         return -4;
+
+       }
+      
+      if((((Int_t)data[N - 2] - (Int_t)data[N - 1]) > fMaxDifference) || 
+        (((Int_t)data[N - 1] - (Int_t)data[N - 2]) > fMaxDifference))
+       {
+         //      (Int_t)data[N - 3] = (Int_t)data[N - 4] -(Int_t) data[N - 5] + (Int_t)data[N-4];
+         data[N - 1] = data[N - 2];
+         return crazyness++;
+       }
+      
+    }
+  
+  return crazyness;
+  
+}
diff --git a/HLT/CALO/AliHLTCaloSanityInspector.h b/HLT/CALO/AliHLTCaloSanityInspector.h
new file mode 100644 (file)
index 0000000..709874e
--- /dev/null
@@ -0,0 +1,104 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTPHOSSanityInspector.h 35107 2009-09-30 01:45:06Z phille $
+
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+#ifndef ALIHLTCALOSANITYINSPECTOR_H
+#define ALIHLTCALOSANITYINSPECTOR_H
+
+
+// TODO: Class needs heavy re-writing. 
+
+/**
+ * Class checks data for insanity
+ * for use in HLT, but can also be used offline
+ *
+ * @file   AliHLTPHOSSanityInspector.h
+ * @author Oystein Djuvsland
+ * @date
+ * @brief  Sanity inspector for PHOS HLT
+ */
+
+//#include "AliHLTPHOSBase.h"
+#include "Rtypes.h"
+
+
+class AliHLTAltroData;
+
+/** 
+ * @class AliHLTPHOSSanityInspector
+ * Sanity inspector for PHOS HLT. It takes raw data as input and checks it for insanity
+ * It will then flag it.
+ *
+ * @ingroup alihlt_phos
+ */
+
+//class AliHLTCaloSanityInspector : public AliHLTCaloBase
+class AliHLTCaloSanityInspector
+{
+  
+public:
+
+  /** Constructor */
+  AliHLTCaloSanityInspector();
+  
+  /* Destructor */
+  virtual ~AliHLTCaloSanityInspector();
+
+  /** Copy constructor */  
+  AliHLTCaloSanityInspector(const AliHLTCaloSanityInspector &) : 
+    //    AliHLTCaloBase(),
+    fMaxDifference(0)
+  {
+    //Copy constructor not implemented
+  }
+  
+  /** Assignment */
+  AliHLTCaloSanityInspector & operator = (const AliHLTCaloSanityInspector)
+  {
+    //Assignment
+    return *this; 
+  }
+  
+  
+  //  Int_t CheckInsanity(UInt_t* data, Int_t nSamples);
+  
+  
+  // Int_t CheckInsanity(Int_t* data, Int_t nSamples);
+  
+  
+  
+  /** Check for insanity */
+  Int_t CheckInsanity(const UInt_t* data, const Int_t nSamples) const;
+  
+  /** Check for and heal insanity */
+  Int_t CheckAndHealInsanity(UInt_t* data, Int_t nSamples);  //Not completely reliable
+
+  /** Check for and heal insanity */
+  Int_t CheckAndHealInsanity(Int_t* data, Int_t nSamples);  //Not completely reliable
+
+  /** Set the max difference between 2 samples before flagging insanity */
+  void SetMaxDifference(Int_t maxDiff) { fMaxDifference = maxDiff; }
+    
+private:
+
+  /** The max difference between 2 samples */
+  Int_t fMaxDifference;           //COMMENT
+  // ClassDef(AliHLTCaloSanityInspector, 1);
+};
+
+#endif
diff --git a/HLT/CALO/AliHLTCaloUtilities.cxx b/HLT/CALO/AliHLTCaloUtilities.cxx
new file mode 100644 (file)
index 0000000..21488d0
--- /dev/null
@@ -0,0 +1,197 @@
+// $Id: AliHLTCaloUtilities.cxx 34264 2009-08-14 18:29:23Z odjuvsla $
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * 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 "AliHLTCaloUtilities.h"
+#include <cstdlib>
+#include <cstdio>
+
+AliHLTCaloUtilities::AliHLTCaloUtilities()
+{
+  // See header file for documentation
+}
+
+
+AliHLTCaloUtilities::~AliHLTCaloUtilities()
+{
+  // See header file for documentation
+}
+
+
+bool 
+AliHLTCaloUtilities::ScanSingleIntArgument(int argc, const char** argv, const char *name, int *value)
+{
+  // See header file for documentation
+  //  cout << "AliHLTCaloUtilities::ScanSingleIntArgument " << name <<" =  " << DoExistArgument(argc, argv, name) <<endl;  
+  int tmpIndex =  DoExistArgument(argc, argv, name);
+
+  if( tmpIndex  >= 0)
+    {
+      if(value == 0)
+       {
+         return true;
+       }
+           
+      else
+       {
+         if(tmpIndex +1 < argc)
+           {
+             *value =  atoi(argv[tmpIndex +1]);
+             return true;
+           }
+       }
+    }
+  else
+    {
+      return false;
+    }
+  return false;
+}
+bool 
+AliHLTCaloUtilities::ScanSingleFloatArgument(int argc, const char** argv, const char *name, float *value)
+{
+  // See header file for documentation
+  //  cout << "AliHLTCaloUtilities::ScanSingleFloatArgument " << name <<" =  " << DoExistArgument(argc, argv, name) <<endl; 
+
+  int tmpIndex =  DoExistArgument(argc, argv, name);
+
+  if( tmpIndex  >= 0)
+    {
+      if(value == 0)
+       {
+         return true;
+       }
+           
+      else
+       {
+         if(tmpIndex +1 < argc)
+           {
+             *value =  atof(argv[tmpIndex +1]);
+             return true;
+           }
+       }
+    }
+  else
+    {
+      return false;
+    }
+  return false;
+}
+
+bool 
+AliHLTCaloUtilities::ScanSingleNameArgument(int argc, const char** argv, const char *name, char *outname)
+{
+  // See header file for documentation
+  //  cout << "AliHLTCaloUtilities::ScanSingleNameArgument " << name <<" =  " << DoExistArgument(argc, argv, name) <<endl; 
+
+  int tmpIndex =  DoExistArgument(argc, argv, name);
+
+  if( tmpIndex  >= 0)
+    {
+      if(outname == 0)
+       {
+         return true;
+       }
+           
+      else
+       {
+         if(tmpIndex +1 < argc)
+           {
+             //    *value =  atoi(argv[tmpIndex +1]);
+             sprintf(outname, "%s", argv[tmpIndex +1] );
+
+             return true;
+           }
+       }
+    }
+  else
+    {
+      return false;
+    }
+  return false;
+}
+
+
+bool 
+AliHLTCaloUtilities::ScanSingleArgument(int argc, const char** argv, const char *name)
+{
+  // See header file for documentation
+  //  cout << "AliHLTCaloUtilities::ScanSingleArgument " << name <<" =  " << DoExistArgument(argc, argv, name) <<endl; 
+
+  if( DoExistArgument(argc, argv, name) >=0)
+    {
+      //     cout << "AliHLTCaloUtilities::ScanSingleArgument " << name <<" > 0" <<endl;
+      return true;
+    }
+  else
+    {
+      //    cout << "AliHLTCaloUtilities::ScanSingleArgument " << name <<" > 0" <<endl;
+      return false;
+    }
+
+}
+
+
+
+bool
+AliHLTCaloUtilities::CheckFile(const char *fileName, const char *opt) const
+{
+  //returns true if the file specified by "fileName exists  and has acceees rights specified  by "opt", 
+  //returns false if it doesnt exist, or it exists, but doesnt have the access right specified by "opt"
+  FILE *fp = fopen(fileName, opt);
+
+  if(fp == 0)
+    {
+      return false;
+    }
+  else
+    {
+      fclose(fp); 
+      return true;
+    }
+}
+
+
+
+int 
+AliHLTCaloUtilities::DoExistArgument(const int argc, const char** argv, const char *name) const
+{
+  // returns the index if the argument if it exists
+  // returns a negative value if it doesnt exist
+  string s1;
+
+  for(int i= 0; i< argc; i++)
+    {
+      s1.assign(argv[i]);
+      
+      if(s1 == name)
+       {
+         //      cout << "AliHLTCaloUtilities::DoExistArgumen , argument = " << name << "  Exists" <<endl;
+         return i;
+       }
+    }
+  
+  // cout << "AliHLTCaloUtilities::DoExistArgumen , argument = " << name << "  does not exist " <<endl;
+  return -1;
+
+
+}
diff --git a/HLT/CALO/AliHLTCaloUtilities.h b/HLT/CALO/AliHLTCaloUtilities.h
new file mode 100644 (file)
index 0000000..2d0cc38
--- /dev/null
@@ -0,0 +1,95 @@
+//-*- Mode: C++ -*-
+// $Id: AliHLTCaloUtilities.h 34264 2009-08-14 18:29:23Z odjuvsla $
+
+#ifndef ALIHLTCALOUTILITIES_H
+#define ALIHLTCALOUTILITIES_H
+
+/**************************************************************************
+ * This file is property of and copyright by the Experimental Nuclear     *
+ * Physics Group, Dep. of Physics                                         *
+ * University of Oslo, Norway, 2007                                       *
+ *                                                                        *
+ * Author: Per Thomas Hille <perthi@fys.uio.no> for the ALICE HLT Project.*
+ * Contributors are mentioned in the code where appropriate.              *
+ * Please report bugs to perthi@fys.uio.no                                *
+ *                                                                        *
+ * 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 <iostream>
+
+using namespace std;
+
+// TODO: Documentation!
+
+//      AliHLTCaloUtilities
+class  AliHLTCaloUtilities
+{
+ public:
+  AliHLTCaloUtilities();
+  virtual ~AliHLTCaloUtilities();
+  bool CheckFile(const char *fileName, const char *opt) const;
+
+  bool ScanSingleIntArgument(int argc, const char** argv, const char *name, int *value = 0 );
+  bool ScanSingleFloatArgument(int argc, const char** argv, const char *name, float *value = 0 );
+  bool ScanSingleNameArgument(int argc, const char** argv, const char *name, char *outname = 0 );
+  bool ScanSingleArgument(int argc, const char** argv, const char *name);
+
+  template<typename T> 
+    void  DumpData(T *array, int N, int nPerLine)
+    {
+      //   cout <<   "DumpData N=  " << N <<endl;
+      for(int i= 0; i< N; i++)
+       {
+         if((i%nPerLine == 0)  &&  (i != 0))
+           {
+             //printf("\n");
+             cout << endl;
+           }
+
+         cout << array[i]<< "\t";
+       }
+      //     printf("\n");
+      cout << endl;
+    }
+
+  template<typename T> 
+    void  ResetArray(T *array, int N) const
+    {
+      for(int i= 0; i< N; i++)
+       {
+         array[i] = 0;
+       }
+    }
+  template<typename T> 
+    T  MaxValue(T *array, int N) const
+    {
+      T tmpMax = 0;
+
+      for(int i = 0; i < N; i++)
+       {
+         if(array[i] > tmpMax)
+           {
+             tmpMax = array[i];
+           }
+       }
+      return tmpMax;
+    }
+
+
+
+  
+ private:
+  int DoExistArgument(const int argc, const char** argv, const char *argument) const;
+
+};
+
+#endif