In This Package:

ElecSimProc.h

Go to the documentation of this file.

#ifndef ELECSIMPROC_H
#define ELECSIMPROC_H

#include "Stage/StageProcessor.h"
#include "Event/SimHeader.h"
#include "Event/SimHit.h"
#include "Event/ElecHeader.h"

#include "ElecSim/IEsPulseTool.h"
#include "ElecSim/IEsFrontEndTool.h"

#include "Stage/IStage.h"
#include "Stage/FFTimeStamp.h"
#include "Stage/HeaderStageData.h"

#include <vector>

class ElecSimProc : public StageProcessor<DayaBay::ElecHeader> 
{
public:
    ElecSimProc(const std::string& name, ISvcLocator* pSvcLocator);
    virtual ~ElecSimProc();

    virtual StatusCode initialize();
    virtual StatusCode execute(); 
    
    
private:

    // properties/tools

    // Property Detectors - List of detector names to include in simulation
    std::vector<std::string> m_detectorNames;
    // Property PmtTool - Name of the PMT simulation tool
    std::string m_pmtToolName;
    // Property RpcTool - Name of the RPC simulation tool
    std::string m_rpcToolName;
    // Property FeeTool - Name of the PMT Front-end electronics simulation tool
    std::string m_feeToolName;
    // Property FecTool - Name of the RPC Front-end electronics simulation tool
    std::string m_fecToolName;

    // List of simulated detector IDs
    std::vector<DayaBay::Detector> m_detectors;
    // Tool for adding PMT effects to simulated hits
    IEsPulseTool*     m_pmtTool;
    // Tool for adding RPC effects to simulated hits
    IEsPulseTool*     m_rpcTool;
    // Tool for generating PMT Front-end electronics signals
    IEsFrontEndTool*  m_feeTool;
    // Tool for generating RPC Front-end card signals
    IEsFrontEndTool*  m_fecTool;

    FFTimeStamp m_currentTime;

private:  
    // implementation details

    typedef HeaderStageData<DayaBay::HeaderObject> HeaderData;
    typedef HeaderStageData<DayaBay::SimHeader> SimData;
    typedef HeaderStageData<DayaBay::ElecHeader> ElecData;

    // Get the next SimHeader
    StatusCode getSimData(DayaBay::SimHeader*& output);

    // Fill hit pipeline and our SimHitHeader with given SimHeader's
    // worth of hits
    StatusCode fillPipeLine(DayaBay::SimHeader* shead);

    // Gets more new data fills pipeline
    StatusCode moar(); 

    // Search pipeline for a gap
    // Nnoble particle with respect to Geant4 (i.e. muon from MuonProphet)
    // is treated as a giant hit
    StatusCode findGap();

    // Fills the fake SimHitHeader with hits that occured before gapStart time.
    StatusCode fillHitHeader();
    
    // Get all geant4-noble particles in time window
    StatusCode findGiantHitInTime();

    // Run the ElecSim tools and new data is push to its stage.
    // It should be close to EsFrontEndAlg.cc
    StatusCode ES_execute();

    // Fast electronic simulation, produce empty ElecHeader for MuonProphet muon
    StatusCode fastElecSim();

    // Process the data up to the gap and purge pipeline and current
    // headers of no longer needed objects.
    StatusCode blowChunks();

  // important data members
    // A fake SimHitHeader to hold current amalgamated hit
    // collections.
    DayaBay::SimHitHeader m_amalSimHitHeader;
    int m_count;  // count for how many hits add to the fake SimHitHeader

    // SimHeaders contributing the SimHits in current HitPipeline
    std::vector<const DayaBay::SimHeader*>  m_currentHeaders;
    
    // counting how many hits in a SimHeader is in use for 
    // current fake SimHitHeader.  Just for bookkeeping
    std::map<const DayaBay::SimHeader*,int> m_simHeaderCount;

    // Too many bookkeeping to do
    // Need to keep track the real latest time of all header objects.
    // extremely long delay, >1e12 second, cause time go backwards. 
    // Then latest can be early be earliest.
    std::map<const DayaBay::SimHeader*, TimeStamp /* latest */ > m_realLatest;

    // The pipeline of hits. Used to find TimeGap
    // The time in this pipiline is absolute time.
    typedef std::multimap<TimeStamp,DayaBay::SimHit*, std::less<TimeStamp> > HitPipeline;
    HitPipeline m_hitPipeline;
    
    // Minimum width of time gap that determines a chunk.
    double m_minTimeGap;

    // Chunk Start and Stop time
    // The hits are within this [m_chunkStart,m_chunkStop]
    TimeStamp m_chunkStart;
    TimeStamp m_chunkStop;
    // Fake hits are also in pipeline. This is the earliest and latest for real hits.
    TimeStamp m_realHitEarliest;
    TimeStamp m_realHitLatest;

    HitPipeline m_giantHits;
    std::map<const DayaBay::SimHit*, const DayaBay::SimHeader*> m_giantHitSheader;
    HitPipeline m_giantHitsInTime;

    TimeStamp m_realElecHeaderTime;
    TimeStamp m_emptyElecHeaderTime;

    double m_longest;
};

#endif  // ELECSIMPROC_H

---