LinearGeometricMeanResolutionProcessor.h

#ifndef LinearGeometricMeanResolutionProcessor_h
#define LinearGeometricMeanResolutionProcessor_h 1

#define N_1D_HISTOS_GEOMETRIC_MEAN_RESOLUTION_PROCESSOR 4
#define N_2D_HISTOS_GEOMETRIC_MEAN_RESOLUTION_PROCESSOR 0

// C++
#include <string>
#include <iostream>
#include <sstream>
#include <cmath>
#include <vector>

// LCIO
#include "lcio.h"
#include <EVENT/TrackerHit.h>
#include <EVENT/LCCollection.h>
#include <EVENT/Track.h>
#include <IMPL/LCCollectionVec.h>
#include <IMPL/TrackerHitImpl.h>
#include "UTIL/LCTOOLS.h"
#include "IntersectionCalculator.h"

// Marlin
#include "marlin/Processor.h"
#include "ZBinTemplateProcessor.h"
#include "TimePixEventDisplayCreator.h"
#include "TrackFitterFactory.h"
#include "TrackFitterBase.h"
#include "LinearRegressionProcessor.h"
#include "LinearTrackRegression.h"

// Aida
#ifdef MARLIN_USE_AIDA
//AIDA
#include <marlin/AIDAProcessor.h>
#include <AIDA/IHistogramFactory.h>
#include <AIDA/IHistogram1D.h>
#include <AIDA/IHistogram2D.h>
#endif

//root
#include "TH2F.h"
#include "TF1.h"
#include "TList.h"

namespace AIDA{
  class IHistogram1D;
  class IHistogram2D;
}

namespace marlintpc{

  class TrackFitterFactory;

  /* 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 LinearGeometricMeanResolutionProcessor : 
  public ZBinTemplateProcessor<N_1D_HISTOS_GEOMETRIC_MEAN_RESOLUTION_PROCESSOR, 
                               N_2D_HISTOS_GEOMETRIC_MEAN_RESOLUTION_PROCESSOR>{

//public marlin::Processor {
        
    public:
        
        /* This method will be called by the marlin package
         * It returns a processor of the currend type (here LinearGeometricMeanResolutionProcessor)
         */
        virtual Processor*  newProcessor() { return new LinearGeometricMeanResolutionProcessor ; }
        
        /* the default constructor
         * here the processor parameters are registered to the marlin package
         * other initialisation should be placed in the init method
         */
        LinearGeometricMeanResolutionProcessor() ;

        ~LinearGeometricMeanResolutionProcessor() ;
        
        /* 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() ;

        static bool compareHit(const std::pair<TrackerHit*, double> & pair1,
          const std::pair<TrackerHit*, double> & pair2)
        {
          return pair1.second < pair2.second;
        }

        
        
    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 ;  
        int _histoBin;               
        float _histoRange;           

        static const unsigned int _histoGeoNIndex;
        static const unsigned int _histoGeoNminus1Index;
        static const unsigned int _histoGeoZNIndex;
        static const unsigned int _histoGeoZNminus1Index;


        bool isFirstCollection;

private:

        AIDA::IHistogram1D* _histoGeoN;
        AIDA::IHistogram1D* _histoGeoNminus1;
        AIDA::IHistogram1D* _histoGeoZN;
        AIDA::IHistogram1D* _histoGeoZNminus1;

        int _applyZCut;
        float _zMin, _zMax;
        bool _DisplayAllEvents; 

        std::string _histoGeoNName; 
        std::string _histoGeoZNName;
        std::string _histoGeoNminus1Name;
        std::string _histoGeoZNminus1Name;

        TH2F * _xyResidualsScatterPlot;
        TH2F * _zResidualsScatterPlot;  
        
        double _transDiff;
        double _longDiff;
        
        TimePixEventDisplayCreator *_eventDisplayCreator;
    } ;
    
}

#endif