PedestalCalculator.h

#ifndef PedestalCalculator_h
#define PedestalCalculator_h 1
/* PedestalCalculator.h
 * $Id: PedestalCalculator.h,v 1.1 2006/07/07 08:58:52 mjanssen Exp $
 */
// #define USE_CONDDB
//c++ stl 
#include <utility>

//LCIO
#include "lcio.h"

//MARLIN
#include "marlin/Processor.h"

//TPCCondData
#include "Pedestal.h"

//LCCD
#include <lccd.h>
#include <lccd/DBInterface.hh>

namespace marlintpc
{


    class PedestalCalculator : public marlin::Processor
    {

        public:
                        

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

            PedestalCalculator();

//            PedestalCalculator( const std::string &typeName ) : DBEntryMaker( typeName ){};

            virtual void init();

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

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

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

            virtual void end() ;

        protected:

            struct StcPedestal
            {
                float Mean;
                float Width;
            };
            

            typedef std::vector<StcPedestal*> PedestalVector_t;
            
            struct ChannelPedestal
            {
                int                 ChannelID;
                int                 ReadoutGroup;
                FloatVec*           Data;
                PedestalVector_t*   PedestalCol;
                StcPedestal*        Average;
                StcPedestal*        AverageError;
            };    
            
                      

            typedef std::map< std::pair<int, int>, ChannelPedestal* > PedestalMap_t;

            
            PedestalMap_t*               _PedestalMap;
            
            std::pair<int, int>          _ChannelPair;

            

            StcPedestal* calcPedestal(FloatVec* Data);

            

            virtual void calcAverage(ChannelPedestal* thisChannelPedestal);

            virtual void       CreatePedestalCollection( PedestalMap_t*
                thisChannelPedestalCollection);

            virtual void                   printPedestal(PedestalMap_t*
                thisChannelPedestalCollection);

            virtual void                   printPedestalShort(PedestalMap_t*
                thisChannelPedestalCollection);

            virtual void                   printPedestal(LCCollection* thisCollection);

            virtual void makeLCCDData();

                        
            // Member variables for the processor parameters.
            std::string _inputColName;
            std::string _pedestalColName;
            std::string _simpleFileName;
            std::string _dbFolder;
            std::string _dbInitString;
            std::string _conditionsTag;
            int _writeEveryNEvents;
            std::string _validFrom;
            std::string _validTill;
            int _calculationIterations;
            int _ignoreSurrounding;
            float  _initCalcWidth;
            double _precision;
            double _signalThreshold;
            bool _makeRunNumberFolder;
            
            // count the number of events
            int _NRun ;
            int _NEvt ;
            lcio::long64  _validFromInt;
            lcio::long64  _validTillInt;
            lcio::long64 _lastSinceTime;
            lcio::long64 _lastEventTime;            
            
        private:  
            
            void writePedestals(); 
            bool _doTagging;
            int _runNumber;
            int _writingIteration;
            std::string _detectorName;
            std::string _folderName;
            IMPL::LCCollectionVec* _outputCollection;
    };
}
#endif