TPCElectronicsProcessor.h

#ifndef TPCElectronicsProcessor_h
#define TPCElectronicsProcessor_h 1

//MARLIN
#include <marlin/Processor.h>

//LCIO
#include <lcio.h>
#include <IMPL/LCCollectionVec.h>
#include <EVENT/TrackerRawData.h>

//C++
#include <string>
#include <list>

//GEAR
#include <gear/PadRowLayout2D.h>

//MARLINTPC
#include "VoxelTPC.h"
#include "ADCPulse.h"

namespace marlintpc
{

class TPCElectronicsProcessor : public marlin::Processor
{

    public:

        virtual Processor*  newProcessor()
        {
            return new TPCElectronicsProcessor ;
        }

        TPCElectronicsProcessor() ;
        virtual ~TPCElectronicsProcessor();

        /* Instantiate the ADCPulse with the parameters from the steering file.
         */
        virtual void init() ;

        virtual void processRunHeader(lcio::LCRunHeader* run) ;

        virtual void processEvent(lcio::LCEvent* evt) ;




    protected:

        static bool voxelPadComp(const std::pair< VoxelTPC::VoxelIndex, int >& left,
                                 const std::pair< VoxelTPC::VoxelIndex , int >& right)
        {
            return(left.first.moduleID == right.first.moduleID ?
                   (left.first.padIndex == right.first.padIndex  ?
                    left.first.zBin < right.first.zBin :
                    left.first.padIndex  < right.first.padIndex) :
                   left.first.moduleID < right.first.moduleID);
        }


        static bool voxelTimeComp(const std::pair< VoxelTPC::VoxelIndex, int >& left,
                                  const std::pair< VoxelTPC::VoxelIndex , int >& right)
        {
            return(left.first.zBin == right.first.zBin ?
                   (left.first.moduleID == right.first.moduleID  ?
                    left.first.padIndex < right.first.padIndex :
                    left.first.moduleID  < right.first.moduleID) :
                   left.first.zBin < right.first.zBin);
        }

        bool _outputIsPersistent;

        //Input-/output collection names
        std::string _inputColName;
        std::string _outputColName;

        double _frequency; 
        double _riseTime; 
        double _asym;//asymmetry of pulse shape: width left = _asym*width right
        int  _ADCMaxValue; 
        int _nElectronsDynamicRange;  
        double _voxelZLength; 
        int _ADCThreshold; 
        int _minimumPulseHeight; 

        int   _electronicsSwitch; 
        double _peakingTime; 
        // to be implemented later
        //  int _ADCThreshold; // /<Threshold of the ADC
        //  double _cutOff; // /<Cut off value for the integration

        int _noiseSwitch; 

        double _clockJitter; 
        std::map<int, double> _timeJitter; // map of time (zBin) and the clock jitter for that bin

        double _noiseLevel; 

        double _noiseWidth; 

        double _noiseCutoff; 

        ADCPulse* pulse;

        bool _improveMemoryFootprint; 

        double _integrationTime;
};



} //end of namespace marlintpc

#endif