[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCCalibTracksComponent.h

// -*- Mode: C++ -*-
// $Id$

#ifndef ALIHLTTPCALIBTRACKSCOMPONENT_H
#define ALIHLTTPCALIBTRACKSCOMPONENT_H

//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//* See cxx source for full Copyright notice                               *

/** @file   AliHLTTPCCalibTracksComponent.h
    @author Kalliopi Kanaki
    @date   
    @brief  A tracks gain calibration component for the TPC.
*/

#include "AliHLTCalibrationProcessor.h"
#include "AliHLTTPCDefinitions.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCTrackSegmentData.h"
#include "TObjArray.h"

class  AliTPCClusterParam;
class  AliTPCcalibTracksCuts;

class AliTPCcalibAlign;
class AliTPCcalibTracksGain;
class AliTPCcalibTracks;

class AliTPCseed;
class AliTPCclusterMI;
class AliHLTTPCOfflineCluster;

/**
 * @class AliHLTTPCCalibTracksComponent
 * 
 * This class is the calibration component for the AliTPCCalibPedestal class 
 * used for pedestal calibration of the TPC. 
 * 
 * It inherits from the AliHLTCalibrationProcessor and uses the high-level 
 * interface. The output is the class AliTPCCalibPedestal as a TObject.
 *
 * The component has the following component arguments:
 *   -enableanalysis : enable analysis before shipping data to FXS
 *
 * @ingroup alihlt_tpc_components
 */
class AliHLTTPCCalibTracksComponent : public AliHLTCalibrationProcessor{

  public:
    /** constructor */
    AliHLTTPCCalibTracksComponent();
    /** destructor */
    virtual ~AliHLTTPCCalibTracksComponent();
    
    // Public functions to implement AliHLTComponent's interface.
    // These functions are required for the registration process

    const char* GetComponentID();
    void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
    AliHLTComponentDataType GetOutputDataType();  
    Int_t GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
    virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
    AliHLTComponent* Spawn();

  protected:

    using AliHLTCalibrationProcessor::ProcessCalibration;
    using AliHLTCalibrationProcessor::ShipDataToFXS;
    
    //int Reconfigure(const char* /*cdbEntry*/, const char* /*chainId*/);

    // Protected functions to implement AliHLTComponent's interface.
    // These functions provide initialization as well as the actual processing
    // capabilities of the component. 
    
    /** Initialize the calibration component. */
    Int_t InitCalibration();

    /** Scan commandline arguments of the calibration component. */
    Int_t ScanArgument( Int_t argc, const char** argv );

    /** DeInitialize the calibration component. */
    Int_t DeinitCalibration();

    /** Process the data in the calibration component. */
    Int_t ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );

    /** Ship the data to the FXS at end of run or eventmodulo. */
    Int_t ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
    
    Int_t Reconfigure(const char* cdbEntry, const char* chainId);

  private:
    /** copy constructor prohibited */
    AliHLTTPCCalibTracksComponent(const AliHLTTPCCalibTracksComponent&);
    /** assignment operator prohibited */
    AliHLTTPCCalibTracksComponent& operator=(const AliHLTTPCCalibTracksComponent&);
  
    Int_t Configure(const char* arguments);
    void ReadTracks(const AliHLTComponentBlockData* iter, Int_t &tt);
    
    AliTPCClusterParam    *fClustParam; //! TPC cluster parameters
    AliTPCcalibTracksCuts *fTrackCuts;  //! TPC track cuts 

    AliTPCcalibTracksGain *fCalibTracksGain; //!transient 
    AliTPCcalibAlign      *fCalibAlign;	     //!transient
    AliTPCcalibTracks     *fCalibTracks;     //!transient

    /** Minimum patch specifcation for this component */
    AliHLTUInt8_t fMinPatch;	 // see above

    /** Minimum patch specifcation for this component */
    AliHLTUInt8_t fMaxPatch;	 // see above

    /** The Specification for this component */
    AliHLTUInt32_t fSpecification; // see above

    /** Analyze calibration data before shipping to FXS */
    Bool_t fEnableAnalysis; //! transient
    
    /** seed argument for the Process(AliTPCseed*) function */
    AliTPCseed  *fSeed;							 // see above
    
    vector<AliHLTTPCSpacePointData> fClusters;                       //! transient
    vector<AliHLTTPCTrackSegmentData> fTracks;                       //! transient
    vector<UInt_t> fTrackClusterID[36][6];                           //! transient
    
    
    AliHLTTPCOfflineCluster *pConv;  //! transient
    TObjArray fOffArray;             //! transient
    
    Bool_t fReadMergedTracks; //! transient
    Bool_t fReadSliceTracks;  //! transient
   
    ClassDef(AliHLTTPCCalibTracksComponent, 0)

};
#endif
Commit	Line	Data
3a3550fa	1	// -- Mode: C++ --
	2	// $Id$
	3
	4	#ifndef ALIHLTTPCALIBTRACKSCOMPONENT_H
	5	#define ALIHLTTPCALIBTRACKSCOMPONENT_H
	6
	7	//* This file is property of and copyright by the ALICE HLT Project *
	8	//* ALICE Experiment at CERN, All rights reserved. *
	9	//* See cxx source for full Copyright notice *
	10
	11	/** @file AliHLTTPCCalibTracksComponent.h
	12	@author Kalliopi Kanaki
	13	@date
	14	@brief A tracks gain calibration component for the TPC.
	15	*/
	16
	17	#include "AliHLTCalibrationProcessor.h"
	18	#include "AliHLTTPCDefinitions.h"
	19	#include "AliHLTTPCSpacePointData.h"
	20	#include "AliHLTTPCTrackSegmentData.h"
	21	#include "TObjArray.h"
	22
	23	class AliTPCClusterParam;
	24	class AliTPCcalibTracksCuts;
	25
	26	class AliTPCcalibAlign;
	27	class AliTPCcalibTracksGain;
	28	class AliTPCcalibTracks;
	29
	30	class AliTPCseed;
	31	class AliTPCclusterMI;
	32	class AliHLTTPCOfflineCluster;
	33
	34	/**
	35	* @class AliHLTTPCCalibTracksComponent
	36	*
	37	* This class is the calibration component for the AliTPCCalibPedestal class
	38	* used for pedestal calibration of the TPC.
	39	*
	40	* It inherits from the AliHLTCalibrationProcessor and uses the high-level
	41	* interface. The output is the class AliTPCCalibPedestal as a TObject.
	42	*
	43	* The component has the following component arguments:
	44	* -enableanalysis : enable analysis before shipping data to FXS
	45	*
	46	* @ingroup alihlt_tpc_components
	47	*/
	48	class AliHLTTPCCalibTracksComponent : public AliHLTCalibrationProcessor{
	49
	50	public:
	51	/** constructor */
	52	AliHLTTPCCalibTracksComponent();
	53	/** destructor */
	54	virtual ~AliHLTTPCCalibTracksComponent();
	55
	56	// Public functions to implement AliHLTComponent's interface.
	57	// These functions are required for the registration process
	58
	59	const char* GetComponentID();
	60	void GetInputDataTypes( vector<AliHLTComponentDataType>& list);
	61	AliHLTComponentDataType GetOutputDataType();
	62	Int_t GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
	63	virtual void GetOutputDataSize( unsigned long& constBase, double& inputMultiplier );
	64	AliHLTComponent* Spawn();
65
66	protected:
67
68	using AliHLTCalibrationProcessor::ProcessCalibration;
69	using AliHLTCalibrationProcessor::ShipDataToFXS;
70
71	//int Reconfigure(const char* /cdbEntry/, const char* /chainId/);
72
73	// Protected functions to implement AliHLTComponent's interface.
74	// These functions provide initialization as well as the actual processing
75	// capabilities of the component.
76
77	/** Initialize the calibration component. */
78	Int_t InitCalibration();
79
80	/** Scan commandline arguments of the calibration component. */
81	Int_t ScanArgument( Int_t argc, const char** argv );
82
83	/** DeInitialize the calibration component. */
84	Int_t DeinitCalibration();
85
86	/** Process the data in the calibration component. */
87	Int_t ProcessCalibration( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
88
89	/** Ship the data to the FXS at end of run or eventmodulo. */
90	Int_t ShipDataToFXS( const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData );
91
92	Int_t Reconfigure(const char* cdbEntry, const char* chainId);
93
94	private:
95	/** copy constructor prohibited */
96	AliHLTTPCCalibTracksComponent(const AliHLTTPCCalibTracksComponent&);
97	/** assignment operator prohibited */
98	AliHLTTPCCalibTracksComponent& operator=(const AliHLTTPCCalibTracksComponent&);
99
100	Int_t Configure(const char* arguments);
101	void ReadTracks(const AliHLTComponentBlockData* iter, Int_t &tt);
102
103	AliTPCClusterParam *fClustParam; //! TPC cluster parameters
104	AliTPCcalibTracksCuts *fTrackCuts; //! TPC track cuts
105
106	AliTPCcalibTracksGain *fCalibTracksGain; //!transient
107	AliTPCcalibAlign *fCalibAlign; //!transient
108	AliTPCcalibTracks *fCalibTracks; //!transient
109
110	/** Minimum patch specifcation for this component */
111	AliHLTUInt8_t fMinPatch; // see above
112
113	/** Minimum patch specifcation for this component */
114	AliHLTUInt8_t fMaxPatch; // see above
115
116	/** The Specification for this component */
117	AliHLTUInt32_t fSpecification; // see above
118
119	/** Analyze calibration data before shipping to FXS */
120	Bool_t fEnableAnalysis; //! transient
121
122	/** seed argument for the Process(AliTPCseed) function /
123	AliTPCseed *fSeed; // see above
124
125	vector<AliHLTTPCSpacePointData> fClusters; //! transient
126	vector<AliHLTTPCTrackSegmentData> fTracks; //! transient
127	vector<UInt_t> fTrackClusterID[36][6]; //! transient
128
129
130	AliHLTTPCOfflineCluster *pConv; //! transient
131	TObjArray fOffArray; //! transient
132
133	Bool_t fReadMergedTracks; //! transient
134	Bool_t fReadSliceTracks; //! transient
135
136	ClassDef(AliHLTTPCCalibTracksComponent, 0)
137
138	};
139	#endif