source: svn/trunk/Utilities/FROG/Includes/FROG/FROG_Element_Event.h@ 238

// FROG_Events.h: interface for the FROG_Events class.
//
//////////////////////////////////////////////////////////////////////

#ifndef _FROG_ELEMENT_EVENTS_H__
#define _FROG_ELEMENT_EVENTS_H__

#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <time.h>

#include "FROG_Chunk.h"
#include "FROG_Element_Base_With_DetId.h"

class FROG_Element_Event : public FROG_Element_Base {
private : 
        long int EventPosInFile_;       
        unsigned int EventNBytesToRead_;        

public :
        unsigned int       NRun_;
        unsigned int       NEvent_;
        unsigned long long TimeStamp_;
        char                       EventDate_[40];

        typedef std::map<unsigned int,FROG_Element_Base*,std::less<unsigned int> >               Frog_map;  
        typedef std::map<unsigned int,FROG_Element_Base*,std::less<unsigned int> >::iterator Frog_map_it;  

        virtual bool isCompactible(){ return false; }
        static unsigned int sizeOf(){ return FROG_Element_Base::sizeOf() + 2*sizeof(unsigned int) + sizeof(unsigned long long); }

        FROG_Element_Event() : FROG_Element_Base(C_EVENTRT){NRun_=0;NEvent_=0;TimeStamp_=0;size_ = sizeOf();SetUpDate();}       
        FROG_Element_Event(unsigned int Run, unsigned int Event, unsigned long long TimeStamp = 0) : FROG_Element_Base(C_EVENTRT){
                NRun_     = Run;
                NEvent_   = Event;
                TimeStamp_= TimeStamp;
                size_     = sizeOf();
                SetUpDate();
        }


        FROG_Element_Event(FILE* pFile, unsigned int ChunkId) : FROG_Element_Base(ChunkId){
        size_ = sizeOf();               
                fread(&NRun_               ,sizeof(NRun_)                       ,1,pFile);
                fread(&NEvent_             ,sizeof(NEvent_)                     ,1,pFile);
                if(ChunkId==C_EVENTRT){
                        fread(&TimeStamp_  ,sizeof(TimeStamp_)      ,1,pFile);                  
                }else{
                        TimeStamp_ = 0;
                }
                SetUpDate();
    }

        unsigned int PostPonedEventReading(FILE* pFile, unsigned int EventNBytesToRead){
                EventPosInFile_    = ftell (pFile);     
                EventNBytesToRead_ = EventNBytesToRead;

                fseek (pFile,EventNBytesToRead,SEEK_CUR);
                return EventNBytesToRead;
        }


    virtual void write(){
                std::vector< std::pair<unsigned int, unsigned int > >* blockOfDaughters = write_init();
                if(blockOfDaughters==NULL)return;                               
                data_ = FillBuffer(data_, &NRun_                 , sizeof(NRun_));
                data_ = FillBuffer(data_, &NEvent_               , sizeof(NEvent_));            
                data_ = FillBuffer(data_, &TimeStamp_, sizeof(TimeStamp_));
                write_daughters(blockOfDaughters);
        }

        long int EventPosInFile(){return EventPosInFile_;}      
        unsigned int EventNBytesToRead(){return EventNBytesToRead_;}

        void SetUpDate(){                               
                if(TimeStamp_==0){
                        sprintf(EventDate_,"No TimeStamp");
                        return;
                }

                unsigned int Temp = TimeStamp_>>32;
                if(Temp == 0){
                        sprintf(EventDate_,"Simulated Data");
                        return;
                }else{
                        time_t rawtime(TimeStamp_>>32);
                        tm* timeinfo = localtime ( &rawtime );          
                        strftime(EventDate_,40,"%a %b %d %H:%M:%S %Y",timeinfo);
                }
        }

        void FillMap(FROG_Element_Base* mother=NULL) {  
                if(mother==NULL){
                        if(name_map .size() > 0) name_map .clear();
                        if(event_map.size() > 0) event_map.clear(); 
                        mother = this;
                }

                const std::vector<FROG_Element_Base*>& dau = mother->daughters();       
                for( unsigned int i=0; i<dau.size(); ++i) {     
                        if(FROG_Element_Base_With_DetId* mod = dynamic_cast<FROG_Element_Base_With_DetId*>(dau[i])){
                                event_map[ mod->DetId() ] = dau[i];
                                FillMap(dau[i]);
                        }
                }       
        }

        FROG_Element_Base* FindByDetId (unsigned int DetId) {
                if(DetId==0)return NULL;
                Frog_map_it it = event_map.find(DetId);
                if(it==event_map.end())return NULL;             
                return it->second;
        }

public :
   Frog_map  event_map;
   std::vector<FROG_Element_Base*>  name_map;
};

#endif