TimePixHitCenterCalculatorProcessor.h

#ifndef TimePixHitCenterCalculatorProcessor_h
#define TimePixHitCenterCalculatorProcessor_h 1

// C++
#include <string>

// LCIO
#include "lcio.h"

// Aida
//#ifdef MARLIN_USE_AIDA // the whole processor does not make sense without aida
#include <AIDA/AIDA.h>
#include <marlin/AIDAProcessor.h>
#include <AIDA/IHistogramFactory.h>
#include <AIDA/IHistogram1D.h>
#include <AIDA/IHistogram2D.h>
// endif

//root
#include <TH1F.h>

// Marlin
#include "marlin/Processor.h"
#include "TimePixPixelMode.h"
#include "lccd/ConditionsMap.hh"
#include "TimePixMapListener.h"

namespace AIDA
{
  class IHistogram2D;
  class IHistogram3D;

}

namespace marlintpc
{

/* the following comment is tranfered to doxygen documentation
  * which begins with a second asterix, or in case of on line comment an extra third slash
  */
class TimePixHitCenterCalculatorProcessor : public marlin::Processor
{

    public:

        /* This method will be called by the marlin package
         * It returns a processor of the currend type (here TimePixHitCenterCalculatorProcessor)
         */
        virtual Processor*  newProcessor()
        {
            return new TimePixHitCenterCalculatorProcessor ;
        }

        /* the default constructor
         * here the processor parameters are registered to the marlin package
         * other initialisation should be placed in the init method
         */
        TimePixHitCenterCalculatorProcessor() ;

        /* Called at the beginning of the job before anything is read.
         * Use to initialize the processor, e.g. book histograms
         */
        virtual void init() ;

        /* Called for every run.
         * in this processor it is not used
         */
        virtual void processRunHeader(lcio::LCRunHeader* run) ;

        /* Called for every event - the working horse.
         * Here the real conversion take place
         */
        virtual void processEvent(lcio::LCEvent * evt) ;

        /* This method is only called if the check flag is set (default) in the main processor
         * (where the input files are given)
         * It should be used to create check plots which are not needed in a complete analysis
         * (where normaly the check flag is deactivated)
         */
        virtual void check(lcio::LCEvent * evt) ;


        /* Called after data processing for clean up.
         * e.g. saving control histogramms, delete created objects
         * (which are not stored in a collection/event), etc.
         */
        virtual void end() ;

    protected:

        /* normally the doxygen documentation is palced before the method/variable
         * but for one line comments in case of variables it may be more convenied for you
         * to place it after the variable. In this case you use an arrow to tell doxygen
         * to which variable the commet belongs to.
         */

        std::string _inputColName ;  
        std::string _outputColName ;  
        std::string _modeMapColName ;  
        std::string _modeMapCorrName ;  
        
        /*upper threshold of clock cycles, which a pixel is allowed to have to 
         *be part of the cluster center calculation
         */   
        int _max_zDiffusion_perCluster;
   
        double _shutter;  
        double _readoutFrequency; 
        double _driftVelocity; 
        bool _multiShutter; 
        bool _keepClusterHistoFlag; 
        
        /*if there are less than _minNrOfPixelsToCalcTime with 4 or more neighbors with charge 
         *all time pixels are taken into account for mean time calculation
         */
        int _minNrOfPixelsToCalcTime;
        
        /*threshold for the meancalculation, all pixel further away in z than 
         *rmsCut * RMSofDistributon are ignorred
         */
        int _rmsCut;

        /* give the status which is set to the transient flag of the output collection
         * it is an int instead of a boolean, because the processor parameter cannot be a boolean
         */
        int _outputIsTransient;
        
        AIDA::IHistogram1D * _zDistancesPixelsInClusters_beforeCleaning; 
        AIDA::IHistogram1D * _zDistancesPixelsInClusters_afterCleaning; 
        AIDA::IHistogram1D * _zclusterCenterBeforeMinusAfterCleaning; 
        TH1F * _clusterHisto; 
       
        tpcconddata::TimePixMap * _timePixMap;

        int countNrOfNeighboringPixelsWithHit( int chipID, int pixelID, std::vector<LCObject*> DataVec );


    private:
//  AIDA::IHistogram2D * histoCluster;
//  AIDA::IHistogram2D * histoSP;
//  AIDA::IHistogram3D * histo3D;

} ;

}

#endif