StogsAFP.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef _StogsAFP
#define _StogsAFP

#include "NarvalInterface.h"
#include "FrameBlock.h"
#include "Trigger.h"


class BashColor;
class TChain;
class SBREvent;
class TEntryList;

using namespace ADF;
using namespace std;


class StogsAFP : public ADF::NarvalProducer
{   
private:
        ADF::FileBlock fSourceOfFrames;
        
private:
        ADF::AgataFrameTrigger fEndOfFrame; 

public:
    void ResetStats(){fNEvts=0; fRejectedEvents=0;}

protected:
    ADF::SharedFP         *fFrameEventPsa_Out;
    ADF::SharedFP         *fSPSAFrame;
    ADF::AgataFrameTrigger fTrigger;        

private:
    bool fdebug;
    BashColor *fBashColor;

private:
    unsigned int fNEvts;

protected:      
    ULong64_t fNEntries;

    unsigned int fRejectedEvents;
    TChain    *fDataChain;
    TEntryList *fEntryList;

    ULong64_t fCurrentEntry;

    bool ReadConfFile(TString ConfFilePath);

    bool IsADHitTreeModeOn;
    void InitDataChainADHitTree();
    void InitDataChainStogs();

    bool ReadEventStogs();
    bool ReadEventADHitTree();

public:
    void SetADHitTreeMode(bool active){IsADHitTreeModeOn = active;}
    void Print();

private:
    static const Int_t MaxHits = 500; // Max number of hits in one event
    static const Int_t MaxCore = 180; // Max number of cores in one event

private:
    ULong64_t fTimestamp;
    unsigned int fEventNumber;

    Int_t   NbHits;                     // Number of hits in the array
    Int_t   LastNbHits;
    Float_t HitE[MaxHits];              // Energie of the hit
    Float_t HitX[MaxHits];              // X position of the hit in the Crystal Frame
    Float_t HitY[MaxHits];              // Y position of the hit in the Crystal Frame
    Float_t HitZ[MaxHits];              // Z position of the hit in the Crystal Frame
    Float_t HitGX[MaxHits];             // Position x of hit with , in global frame
    Float_t HitGY[MaxHits];             // Position y of hit with , in global frame
    Float_t HitGZ[MaxHits];             // Position z of hit with , in global frame
    Int_t   HitId[MaxHits];             // Crystal ID in which a hit occurs
    Int_t   HitSg[MaxHits];             // Segment ID in which a hit occurs

    Int_t   NbCores;                    // for more than 1 frame (built event)
    Int_t   LastNbCores;
    Int_t   NbHitsPerCrystal[MaxCore];  // Number of hits for each cryst ID i.e. dans each data:psa frames
    Float_t CoreE0[MaxCore];            // Core energie, high gain
    Float_t CoreE1[MaxCore];            // Core energie,  low gain
    Float_t CoreT0[MaxCore];            // Core time, high gain
    Float_t CoreT1[MaxCore];            // Core time,  low gain


    SBREvent *fStogsEv;

protected:
    bool fProcessPacking;
    double fSpatialResolution;

    void SetSpatialResolution(double res){fSpatialResolution = res;}
    SBREvent *ProcessPacking(SBREvent *StogsEvt);

protected:

    bool fApplyEnergyResolution;
    bool fApplySmearing;
    void ApplyEnergyResolution(SBREvent *StogsEvt);
    void ApplySmearing(SBREvent *StogsEvt);
    SBREvent *FilterEvent(SBREvent *GlobEvt);

public:
    StogsAFP();
    virtual ~StogsAFP();

    static void process_config (const char *, unsigned int *) ;
        
    virtual     void process_initialise (unsigned int *error_code);
        
    virtual     void process_reset (unsigned int *error_code);
                
    virtual unsigned int ProcessBlock (ADF::FrameBlock &) ;
};

#endif