PSAFrame.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_PSAFrame
#define ADF_PSAFrame

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

namespace ADF
{ 
        

        class PSAHit : public FullHit
        {   
        private: 
                Double32_t fTrapCCe;   // trapping correction parameter for CC electrons
                Double32_t fTrapCCh;   // trapping correction parameter for CC holes
                Double32_t fTrapSGe;   // trapping correction parameter for SG electrons
                Double32_t fTrapSGh;   // trapping correction parameter for SG holes
                Int_t      fID[2];   // Segment ID, followed by Crystal ID in which this hit occured
                UShort_t   fStatus;  // Hit status   
                
        public: 
                PSAHit() : 
                FullHit(), fTrapCCe(0), fTrapCCh(0), fTrapSGe(0), fTrapSGh(0), fStatus(0u) {fID[0] = fID[1] = 0;}
                virtual ~PSAHit() 
                {;}
                
                virtual Double_t GetTrapCCe() const 
                {return fTrapCCe;}             
                virtual void SetTrapCCe(Double_t v) 
                {fTrapCCe = v;}  
                
                virtual Double_t GetTrapCCh() const 
                {return fTrapCCh;}             
                virtual void SetTrapCCh(Double_t v) 
                {fTrapCCh = v;}  
                
                virtual Double_t GetTrapSGe() const 
                {return fTrapSGe;}             
                virtual void SetTrapSGe(Double_t v) 
                {fTrapSGe = v;}  
                
                virtual Double_t GetTrapSGh() const 
                {return fTrapSGh;}             
                virtual void SetTrapSGh(Double_t v) 
                {fTrapSGh = v;}  
                
                virtual void SetHit(const Hit &ahit) {
                        FullHit::SetHit(ahit);
                }

                virtual void SetHit(const PSAHit &ahit) {
                        SetXYZ(ahit.GetX(),ahit.GetY(),ahit.GetZ());
                        SetDXYZ(ahit.GetDX(),ahit.GetDY(),ahit.GetDZ());
                        SetE(ahit.GetE()); SetDE(ahit.GetDE());
                        SetT(ahit.GetT()); SetDT(ahit.GetDT());
                        SetTrapCCe(ahit.GetTrapCCe());
                        SetTrapCCh(ahit.GetTrapCCh());
                        SetTrapSGe(ahit.GetTrapSGe());
                        SetTrapSGh(ahit.GetTrapSGh());
                        SetStatus(ahit.GetStatus());
                        SetID(ahit.GetID(0),0);
                        SetID(ahit.GetID(1),1);
                }
                
                virtual Int_t GetID(Int_t which_id = 0) const 
                { 
                        if ( which_id == 0 ) {
                                return fID[0];
                        }
                        else {
                                return fID[1];
                        }
                }  
                virtual void SetID(Int_t id, Int_t which_id = 0) 
                { 
                        if ( which_id == 0 ) {
                                fID[0] = id;
                        }
                        else {
                                fID[1] = id;
                        }
                }       
                
                virtual UShort_t GetStatus() const 
                {return fStatus;}            
                virtual   void SetStatus(UShort_t s) 
                {fStatus=s;}  
                
                virtual void  Reset() 
                { FullHit::Reset(); fTrapCCe=fTrapCCh=fTrapSGe=fTrapSGh=0; fID[0]=fID[1]=0;  fStatus=0;}                     
        };  
        
        class AgataFrameFactory;
        

        class PSAInterface : public DataInterface
        {        
        public:
                PSAInterface(): 
                DataInterface() {;} 
                virtual ~PSAInterface() 
                {;} 
                
                virtual Int_t GetUID() const = 0; 
                virtual void SetUID(Int_t) = 0;         
                
                virtual Double_t GetE(UInt_t = 0u) const = 0; 
                virtual void SetE(Double_t, UInt_t = 0u) = 0;  
                
                virtual Double_t GetT(UInt_t = 0u) const = 0; 
                virtual void SetT(Double_t, UInt_t = 0u) = 0;  
                
                virtual Hit *NewHit() = 0;
                
                virtual UShort_t  GetNbHits() const = 0;  
                virtual Hit *GetHit(UShort_t) = 0;              
                virtual const Hit *GetHit(UShort_t) const = 0;    
        };
        

        class APSAFrame : public AgataDataFrame< PSAInterface >
        {
                friend class AgataFrameFactory;
                
        private:
                //     Digitizer fDigitXYZ, fDigitDXYZ, fDigitE, fDigitDE, fDigitT, fDigitDT ;   
                
        protected: 
                APSAFrame(Key *key): 
                AgataDataFrame< PSAInterface >(key) {;}
                
                virtual Bool_t DoConfigure(std::istream &);
                virtual Bool_t DoConfigure(std::ostream &);
                
        public:         
                virtual ~APSAFrame() 
                {;}
                //     virtual void SetDigitizer(const Char_t *, Double_t, Double_t, UInt_t) {;}
        };
        
        // typedef ProxyDataFrame<APSAFrame,PSAInterface> PSAFrame;
        
} // namespace ADF
#endif