CrystalFrame.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 ADF_CrystalFrame
#define ADF_CrystalFrame

#ifndef ADF_AgataDataFrame
#include "AgataDataFrame.h"
#endif
#ifndef ADF_ADFObjects
#include "ADFObjects.h"
#endif

namespace ADF
{ 


class GeSegment
{
private:
        UShort_t        fStatus;        // segment status
        UShort_t        fID;            // segment ID
        Double32_t      fE;             // Energy in this segment
        
        Signal  *fSignal;       // signal associated to the segment
        
public:
        GeSegment(UInt_t length, const char *type) : fStatus(0u), fID(0u), fE(0.0), fSignal(0x0) 
                { fSignal = Signal::New(length,type) ;}
        virtual ~GeSegment(); 
        
        virtual Signal *GetSignal() 
                { return fSignal; }
        
        virtual UShort_t GetStatus() const 
                {return fStatus;}            
        virtual   void SetStatus(UShort_t s) 
                {fStatus=s;}      
        
        virtual Double_t GetE() const 
                {return fE;}            
        virtual void SetE(Double_t e) 
                { fE = e; } 
        
        virtual UShort_t GetID() const 
                {return fID;}            
        virtual   void SetID(UShort_t id) 
                {fID=id;} 
        
        virtual void Reset(UInt_t l = 0u) 
                { fStatus = fID = 0u; fE = 0.0; fSignal->Reset(l); }                 
};


class GeCore : public GeSegment
{
private:
        Double32_t fT;  // Time for the core
        
public:
        GeCore(UInt_t length, const char *type): 
                GeSegment(length,type), fT(0.0) {;}
        virtual ~GeCore() {;}
        
        virtual Double_t GetT() const 
                {return fT;}            
        virtual void SetT(Double_t t) 
                { fT = t; }   
        
        virtual void Reset(UInt_t l = 0u) 
                { fT = 0.0; GeSegment::Reset(l); }  
};


class CrystalInterface : public DataInterface
{
public: 
        static UInt_t kDefaultLength;
        static const UShort_t kNbSegments = 36u, kNbCores = 2u; 
        
public:
        CrystalInterface() : DataInterface() 
                {;} 
        virtual ~CrystalInterface() {;} 
        
        virtual Int_t GetUID() const = 0; 
        virtual void SetUID(Int_t) = 0;  
        

        virtual GeSegment  *GetSegment(UShort_t) = 0;   
        

        virtual GeCore     *GetCore(UShort_t) = 0; 
};


class ACrystalFrame : public AgataDataFrame< CrystalInterface >
{  
protected:
        ACrystalFrame(Key *akey):
                AgataDataFrame< CrystalInterface >(akey) {;} 
public:
        virtual ~ACrystalFrame() 
                {;} 
};

// typedef ProxyDataFrame<ACrystalFrame,CrystalInterface> CrystalFrame;
        
} // namespace ADF
#endif