ScanADF.C

Go to the documentation of this file.

// #ifndef ADF_ADFConfig
// #include "ADFConfig.h"
// #endif
#ifndef ADF_AgataKeyFactory
#include "AgataKeyFactory.h"
#endif
#ifndef ADF_AgataFrameFactory
#include "AgataFrameFactory.h"
#endif
#ifndef ADF_BufferIO
#include "BufferIO.h"
#endif
#ifndef ADF_ConfAgent
#include "ConfAgent.h"
#endif
#include "TTree.h"
#include <TRandom.h>
#include <iostream>

using namespace std;
using namespace ADF;

void ADFAnalyzerPrimary(const char *name)
{
        ConfAgent::theGlobalAgent();
        
        const UInt_t MaxSizeFrame = 100u*aMByte; 
        const UInt_t MaxSizeMessage = 20u*aByte;  
        
        FILE *fp = fopen(name,"r"); 
        if ( fp == NULL ) { printf("File %s does not exist \n",name); return; }

        // neeeded to initiate the message table.       
        KeyFactory &main_key_factory = KeyFactory::theMainFactory(); 
        KeyFactory::Register("Agata"); 
        
        // to read a frame
        ADF::BufferIO fBuffer;  
        
        // tree to store potential keys informations
        struct key {
                UInt_t lengthframe;     
                UInt_t eventnumber;
                ULong64_t timestamp;
                Char_t message[MaxSizeMessage];
        } akey;

        UInt_t messagetype; 

        TTree *tree = new TTree("AnalyzerPrimary",name);
        tree->Branch("key",&akey,"FrameLength/i:EventNumber/i:TimeStamp/l:MessageType/C");
        
        Bool_t ok = true;
        while ( ok ) {
        
                // reset everyting
                memset(&akey,0,sizeof(akey));
                fBuffer.SetOffset();
                
                akey.lengthframe = fBuffer.Import(fp,sizeof(akey.lengthframe)); 
                if ( akey.lengthframe != sizeof(akey.lengthframe) ) 
                        break; // cannot read anymore the file
                        
                fBuffer.SetOffset(); fBuffer >> akey.lengthframe;
                if ( akey.lengthframe > MaxSizeFrame ) {
                        cout << " limit for a frame to MaxSizeFrame=" 
                        << MaxSizeFrame/aMByte
                        <<" MBytes, likely to be the wrong endian " << endl;
                        break;
                }
                if ( akey.lengthframe == 0u ) return;
                        
                // add the rest of the frame
                fBuffer.Import(fp,akey.lengthframe-sizeof(akey.lengthframe));
                
                // if the size of the buffer is too small to read
                // all the field, the corresponding field is unchanged 
                fBuffer.SetOffset(); 
                if ( fBuffer.FreeSize() >= sizeof(akey.lengthframe) ) 
                        fBuffer >> akey.lengthframe;
                if ( fBuffer.FreeSize() >= sizeof(messagetype) )        
                        fBuffer >> messagetype;
                if ( fBuffer.FreeSize() >= sizeof(akey.eventnumber) )   
                        fBuffer >> akey.eventnumber;
                if ( fBuffer.FreeSize() >= sizeof(akey.timestamp) )     
                        fBuffer >> akey.timestamp;
                strcpy(akey.message,AgataKeyFactory::theFactory()->GetMessage(messagetype));
                
                tree->Fill();
        }       
        cout << "Entries in the tree " << tree->GetEntries() << endl;   
        fclose(fp);
        
        ConfAgent::KilltheGlobalAgent();        
}



void ADFAnalyzerEmbbeded(const char *name, 
                 const char *keytype = "agata", UShort_t v1 = 0,UShort_t v2 = 0)
{
        ConfAgent::theGlobalAgent();
        
        const UInt_t MaxSizeFrame = 100u*aMByte; 
        const UInt_t MaxSizeMessage = 20u*aByte; const Int_t MaxKey = 10u; 
                
        FILE *fp = fopen(name,"r"); 
        if ( fp == NULL ) { printf("File %s does not exist \n",name); return; }

        // neeeded to initiate the message table.
        KeyFactory &main_key_factory = KeyFactory::theMainFactory(); 
        KeyFactory::Register("Agata"); 
        AgataKey *pkey = dynamic_cast<AgataKey *>(main_key_factory.New("Agata",keytype,ADF::Version(v1,v2)));
        
        if ( pkey == NULL ) 
                { printf("AgataKey %s [%d,%d] does not exist \n",keytype,v1,v2); return; }
                        
        // to read a frame
        ADF::BufferIO fBuffer;  
        
        // tree to store potential keys informations
        struct key { 
                UInt_t lengthframe;     
                UInt_t eventnumber;
                ULong64_t timestamp;
                Char_t message[MaxSizeMessage];
        } akey, tmpkey;

        UInt_t N;
        UInt_t lengthframe[MaxKey];     
        UInt_t eventnumber[MaxKey];
        ULong64_t timestamp[MaxKey];    
        Char_t message[MaxKey][MaxSizeMessage];

        UInt_t messagetype; 

        TTree *tree = new TTree("AnalyserEmbedded",name);
        tree->Branch("PrimaryKey",&akey,"FrameLength/i:EventNumber/i:TimeStamp/l:MessageType/C");
        tree->Branch("NEmbedded",&N,"NEmbedded/i");     
        tree->Branch("EmbFrameLength",lengthframe,"EmbFrameLength[NEmbedded]/i");
        tree->Branch("EmbEventNumber",eventnumber,"EmbEventNumber[NEmbedded]/i");
        tree->Branch("EmbTimeStamp",timestamp,"EmbEventNumber[NEmbedded]/l");
                
        for (Int_t i = 0u; i < MaxKey; i++ ) {
                TString tmp1 = "EmbMessageType", tmp2 = "EmbMessageType"; 
                tmp1 += i;
                tmp2 += i; tmp2 += "/C";
                tree->Branch(tmp1.Data(),message[i],tmp2.Data());
        }
        
        Bool_t ok = true;
        while ( ok ) {
        
                // reset everyting
                memset(&akey,0,sizeof(akey)); 
                memset(lengthframe,0,MaxKey*sizeof(lengthframe[0]));
                memset(eventnumber,0,MaxKey*sizeof(eventnumber[0]));
                memset(timestamp,0,MaxKey*sizeof(timestamp[0]));
                memset(message,0,MaxKey*MaxSizeMessage);
                messagetype = 0u;
                        
                fBuffer.SetOffset();
                
                // read the next primary key
                UInt_t keylength = fBuffer.Import(fp,pkey->GetKeyLength()); 
                if ( keylength != pkey->GetKeyLength() ) 
                        break; // cannot read anymore the file
                        
                if ( pkey->GetFrameLength() == 0u ) return;
                
                fBuffer.SetOffset();
                pkey->Copy(fBuffer.GetAddress(),pkey->GetKeyLength());
                
                akey.lengthframe = pkey->GetFrameLength();
                messagetype = pkey->GetMessage();
                akey.eventnumber = pkey->GetEventNumber();
                akey.timestamp = pkey->GetTimeStamp();          
                strcpy(akey.message,AgataKeyFactory::theFactory()->GetMessage(messagetype));
                                
                if ( akey.lengthframe > MaxSizeFrame ) {
                        cout << " limit for a frame to MaxSizeFrame=" 
                        << MaxSizeFrame/aMByte
                        <<" MBytes, likely to be the wrong endian " << endl;
                        break;
                }               
                // add now the rest of the frame
                fBuffer.SetOffset();
                UInt_t rest = fBuffer.Import(fp,pkey->GetDataLength());
                if ( rest != pkey->GetDataLength() )
                        break;
                if ( gDebug == 1) pkey->Print();
                
                // now guess content of the buffer
                fBuffer.SetOffset(); fBuffer.SetStatus(BaseBuffer::kGood);
                N = 0u;
                while ( fBuffer.IsStatus(BaseBuffer::kGood) && fBuffer.Offset() < pkey->GetDataLength() ) {
                
                        UInt_t current = fBuffer.Offset();
                        // try to read
                        if ( fBuffer.FreeSize() >= sizeof(tmpkey.lengthframe) )         
                                { fBuffer >> tmpkey.lengthframe; }
                        else break;
                        if ( tmpkey.lengthframe == 0u ) 
                                break;
                        if ( fBuffer.FreeSize() >= sizeof(messagetype) )        
                                { fBuffer >> messagetype; }
                        else break;
                        if ( fBuffer.FreeSize() >= sizeof(tmpkey.eventnumber) )         
                                { fBuffer >> tmpkey.eventnumber; }
                        else break;     
                        if ( fBuffer.FreeSize() >= sizeof(tmpkey.timestamp) )   
                                { fBuffer >> tmpkey.timestamp; }
                        else break;
                        // cout << hex << messagetype << " " << tmpkey.lengthframe << dec << endl;
                        //cout << tmpkey.lengthframe << endl;
                                
                        if ( fBuffer.IsStatus(BaseBuffer::kGood) ) {
                                lengthframe[N] = tmpkey.lengthframe;
                                eventnumber[N] = tmpkey.eventnumber;
                                timestamp[N] = tmpkey.timestamp;                                
                                strcpy(message[N],AgataKeyFactory::theFactory()->GetMessage(messagetype));
                                        
                                if ( N < MaxKey ) 
                                        N++;
                                
                                fBuffer.SetOffset(current+tmpkey.lengthframe);
                                //printf("N %d %d\n",N,tmpkey.lengthframe);     
                        }
                        else { printf("NO\n"); break; }
                }
                if ( N > 0u ) tree->Fill();
        }       
        cout << "Entries in the tree " << tree->GetEntries() << endl;   
        fclose(fp);
        
        ConfAgent::KilltheGlobalAgent();        
}


/*
#include "TH1F.h"
#include "TH3S.h"

#include <FrameIO.h>
#include <PSAFrame.h>
#include <TrackedFrame.h>
#include <Trigger.h>

using namespace ADF;

void ROOTConsumeTRACK(const char *name = "AFC_0.adf")
{
        // check the file exists
        FILE *fp = fopen(name,"r");
        if ( fp == NULL )
                return;
                
        FileBlock inframe; inframe.SetFile(fp);
        FrameIO fio(name);
        fio.Attach(&inframe,NULL); fio.SetStatus(BaseFrameIO::kIdle);
                        
        // built the trigger on a tracked frame 
        AgataFrameTrigger trig(name); 
        trig.Add("event:data",Version(),Version(),true);        
        Frame *frame
                = trig.Add("data:tracked",Version(),Version(),true,true);
                
        if ( frame == NULL )
                return;
                
        EvoTrackedFrame *trackframe = dynamic_cast<EvoTrackedFrame *>(frame);
        if ( trackframe == NULL )
                return; 
        fio.Register(&trig);
        
        fio.GetConfAgent()->Add( );
        
        TH1F *he = new TH1F("emean","emean",2000,0,2000); 
        TH3S *pos = new TH3S("xyzmean","xyzmean",20,0,10,40,0,20,60,0,30);
        
        Float_t totbytesR = 0.f; UInt_t nbloop = 0u;
        while ( fio.Notify() ) {
        
                if ( ! trig.IsFired() ) continue; // in principle not needed if only one trigger has registered
        
                // Read from the Frame
                UInt_t bytesr = trackframe->Read(); totbytesR += bytesr;
//              trackframe->GetKey()->Print();          
                for (UInt_t h = 0; h < trackframe->Data()->GetNbGamma() ; h++) {
                
                        const TrackedHit *ahit = trackframe->Data()->GetGamma(h);
                        
                        he->Fill(ahit->GetE());
                        pos->Fill(ahit->GetX(),ahit->GetY(),ahit->GetZ());
                } 
                nbloop++;

                
        }
        // a log is also print out
        fio.Print(std::cout);
        
        he->Draw();
        fclose(fp);
}

*/