adf/Macros/Emulator.h

Go to the documentation of this file.

#ifndef _Emulator
#define _Emulator

#ifndef _LogMessage
#include "LogMessage.h"
#endif
#ifndef ADF_FrameBlock
#include "FrameBlock.h"
#endif

#include "ReadMezzAFP.h"
#include "EmulatorControl.h"

#include "TROOT.h"

#include <string>

using namespace ADF;


template <typename Prod_actor, typename Filt_actor, typename Cons_actor>
class EmulatorPFC : public BaseEmulatorChain
{
private:
    Gw::LogMessage fLog;
        
private:
        Prod_actor *fProducer;
        Filt_actor *fFilter;
        Cons_actor *fConsumer;  
        
private:
        OneBlock fBProd;
        ExpandableBlock fBFilt;

private:
        std::string fPathProd;
        std::string fPathFilt;
        std::string fPathCons; 

public:
        EmulatorPFC(const char *path, UInt_t bsize = aMByte);
/*      EmulatorPFC(const char *path_prod, const char *path_filt, const char * path_cons, 
                        UInt_t bsize_prod = aMByte, UInt_t bsize_filter = aMByte, UInt_t bsize_cons = aMByte) ; */
    ~EmulatorPFC();

    NarvalProducer *GetBaseProducer()
        { return fProducer; }

        NarvalConsumer *GetBaseConsumer() 
                { return fConsumer; }

        Cons_actor *GetConsumer() 
                { return fConsumer; }
        
    virtual Bool_t Init(const Char_t *rootafp)
    {
        return BaseEmulatorChain::Init(rootafp);
    }
    virtual Bool_t Init(Int_t which_run, const char *experiment, const char *which_adf_data, Option_t *opt_adf_pattern)
    {
        return BaseEmulatorChain::Init(which_run,experiment,which_adf_data,opt_adf_pattern);
    }
    
        virtual Bool_t Init();  
        virtual Bool_t Run(UInt_t max_loop = kMaxUInt_t);
};

template <typename Prod_actor, typename Filt_actor, typename Cons_actor> 
EmulatorPFC<Prod_actor,Filt_actor,Cons_actor>::EmulatorPFC(const char *path, UInt_t bsize):
        BaseEmulatorChain(),
        fLog("EmulatorPFC"),
        fProducer(0x0),
        fFilter(0x0),
        fConsumer(0x0),
        fBProd(bsize),
        fBFilt(bsize),
        fPathProd(path),
        fPathFilt(path),
        fPathCons(path)
{

}
template <typename Prod_actor, typename Filt_actor, typename Cons_actor> 
EmulatorPFC<Prod_actor,Filt_actor,Cons_actor>::~EmulatorPFC()
{
        if ( fProducer ) 
                delete fProducer; 
        if ( fFilter )
                delete fFilter;
        if ( fConsumer )
                delete fConsumer;
}
        
template <typename Prod_actor, typename Filt_actor, typename Cons_actor> 
Bool_t EmulatorPFC<Prod_actor,Filt_actor,Cons_actor>::Init()
{
        UInt_t err = 0u;
        fLog.SetProcessMethod("Init");
        
        // just in case a actor forget to call it and it is required.
        NarvalInterface::process_config(fPathProd.data(),&err);
        if ( err > 0u ) {
                fLog << warning << " in NarvalInterface::process_config " << nline; 
        } 
        
        err = 0u;
        // it creates and inits the different actors
        // producer
        Prod_actor::process_config(fPathProd.data(),&err); 
        if ( err > 0u ) {
                fLog << error << " in process_config for Producer " << dolog; 
                return false;
        }
        fProducer = new Prod_actor(); 
        fProducer->process_initialise(&err);
        if ( err > 0u )  {
                fLog << error << " in process_initialise for Producer " << dolog; 
                return false;
        }
                
        // filter
        Filt_actor::process_config(fPathFilt.data(),&err);
        if ( err > 0u ) {
                fLog << err << " in process_config for Filter " << dolog; 
                return false;
        }       
        fFilter = new Filt_actor() ; 
        fFilter->process_initialise(&err);      
        if ( err > 0u )  {
                fLog << error << " in process_initialise for Filter " << dolog; 
                return false;
        }

        // consumer
        Cons_actor::process_config(fPathCons.data(),&err); 
        if ( err > 0u ) {
                fLog << error << " in process_config for Consumer " << dolog; 
                return false;
        } 
        fConsumer = new Cons_actor(); 
        fConsumer->process_initialise(&err);
        if ( err > 0u )  {
                fLog << error << " in process_initialise for Consumer  " << dolog; 
                return false;
        }
        
        fLog << dolog; return true;
}


template <typename Prod_actor, typename Filt_actor, typename Cons_actor> 
Bool_t EmulatorPFC<Prod_actor,Filt_actor,Cons_actor>::Run(UInt_t max_loop)
{
        printf("************** EMULATOR MAIN LOOP ************** \n");
        
        // loop on events
        UInt_t nb_loop = 0u, err = 0u, nb_try = 0;      
        while ( err == 0u ) {
                // to get an input block
                //printf("Call producer \n");
                if ( fProducer->ProcessBlock(fBProd) != 0u ) 
                        break;
                if ( fBProd.GetSize() == 0u ) {
                        if ( nb_try > 1 ) { // up to XX tries of consecutive empty output before stooping 
                                break;
                        }
                        else { 
                                nb_try++; 
                                continue;
                        }
                }
                else nb_try = 0u;
/*              else
                        printf("Produced block with size %d \n",FB0_1.GetSize());*/     
                // to apply the algorithm
                //printf("Call filter \n");             
                if ( fFilter->ProcessBlock(fBProd,fBFilt) != 0u )
                        break;                  
                if ( fBFilt.GetSize() == 0u )
                        break;
//              else
//                      printf("Output filter size %d \n",FB1_2.GetSize());
        // to save the outpout of the algori
                //printf("Call consumer \n");
                if ( fConsumer->ProcessBlock(fBFilt) != 0u ) 
                        break;  
                
                nb_loop++;
                if ( nb_loop == max_loop )
                        break;
        }
        printf("nb_loop %d error %d\n",nb_loop,err);
        printf("************** EMULATOR MAIN LOOP ************** \n");
        return true;
}

template <typename Prod_actor, typename Cons_actor>
class EmulatorPC  : public BaseEmulatorChain
{
private:
    Gw::LogMessage fLog;
        
private:
        Prod_actor *fProducer;
        Cons_actor *fConsumer;  
        
private:
        OneBlock fBProd;
        
private:
        std::string fPathProd;
        std::string fPathCons; 
        
public:
        EmulatorPC(const char *path, UInt_t bsize = aMByte);
        /*      EmulatorPC(const char *path_prod,const char * path_cons, UInt_t bsize_prod = aMByte, UInt_t bsize_cons = aMByte) ; */
        ~EmulatorPC();

    NarvalProducer *GetBaseProducer()
        { return fProducer; }

    NarvalConsumer *GetBaseConsumer()
                { return fConsumer; }

        Cons_actor *GetConsumer() 
                { return fConsumer; }

    Prod_actor *GetProducer()
        { return fProducer; }

    virtual Bool_t Init(const Char_t *rootafp)
    {
        return BaseEmulatorChain::Init(rootafp);
    }
    virtual Bool_t Init(Int_t which_run, const char *experiment, const char *which_adf_data, const char *run_name_pattern, Option_t *opt_adf_pattern)
    {
        return BaseEmulatorChain::Init(which_run,experiment,which_adf_data,run_name_pattern,opt_adf_pattern);
    }
        virtual Bool_t Init();
    virtual Bool_t Run(UInt_t max_loop = kMaxUInt_t);
};

template <typename Prod_actor, typename Cons_actor> 
EmulatorPC<Prod_actor,Cons_actor>::EmulatorPC(const char *path, UInt_t bsize):
        BaseEmulatorChain(),
        fLog("EmulatorPC"),
        fProducer(0x0),
        fConsumer(0x0),
        fBProd(bsize),
        fPathProd(path),
        fPathCons(path)
{
        
}

template <typename Prod_actor, typename Cons_actor> 
EmulatorPC<Prod_actor,Cons_actor>::~EmulatorPC()
{
        if ( fProducer ) 
                delete fProducer; 
        if ( fConsumer )
                delete fConsumer;
}

template <typename Prod_actor, typename Cons_actor> 
Bool_t EmulatorPC<Prod_actor,Cons_actor>::Init()
{
        UInt_t err = 0u;
        fLog.SetProcessMethod("Init");
        
        // just in case a actor forget to call it and it is required.
        NarvalInterface::process_config(fPathProd.data(),&err);
        if ( err > 0u ) {
                fLog << warning << " in NarvalInterface::process_config " << nline; 
        } 
        
        err = 0u;
        // it creates and inits the different actors
        // producer
        Prod_actor::process_config(fPathProd.data(),&err); 
        if ( err > 0u ) {
                fLog << error << " in process_config for Producer " << dolog; 
                return false;
        }
        fProducer = new Prod_actor(); 
        fProducer->process_initialise(&err);
        if ( err > 0u )  {
                fLog << error << " in process_initialise for Producer " << dolog; 
                return false;
        }
        
        // consumer
        Cons_actor::process_config(fPathCons.data(),&err); 
        if ( err > 0u ) {
                fLog << error << " in process_config for Consumer " << dolog; 
                return false;
        } 
        fConsumer = new Cons_actor(); 
        fConsumer->process_initialise(&err);
        if ( err > 0u )  {
                fLog << error << " in process_initialise for Consumer  " << dolog; 
                return false;
        }
        
        fLog << dolog; return true;
}

template <typename Prod_actor, typename Cons_actor>
Bool_t EmulatorPC<Prod_actor,Cons_actor>::Run(UInt_t max_loop)
{
    printf("\n*********** EMULATOR MAIN LOOP : START ... \n\n");
    // loop on events
    UInt_t nb_loop = 0u, err = 0u, nb_try = 0;
    while ( err == 0u ) {
        // to get an input block
        //printf("Call producer \n");

        int Prodstatus = fProducer->ProcessBlock(fBProd);
        int ProdSize = fBProd.GetSize();

//        cout<<"Loop Nbr "<<nb_loop<<endl;
//        cout<<"Producer status = "<<Prodstatus<<endl;
//        cout<<"Producer size   = "<<ProdSize<<endl;

        if ( ProdSize == 0u && Prodstatus ==0) {
            if ( nb_try > 1 ) { // up to XX tries of consecutive empty output before stooping
                break;
            }
            else {
                nb_try++;
                continue;
            }
        }
        else nb_try = 0u;

        int ConsStatus = fConsumer->ProcessBlock(fBProd);

//        cout<<"Consumer status = "<<ConsStatus<<endl;

        if(Prodstatus != 0 || ConsStatus != 0u) break;

        nb_loop++;
        if ( nb_loop == max_loop )
            break;
    }
    printf("\n*********** EMULATOR MAIN LOOP : ... STOP after %d loops (error %d)\n\n",nb_loop,err);

    ReadMezzAFP *MezzAFP_Prod = dynamic_cast<ReadMezzAFP*> (GetProducer());
    if(MezzAFP_Prod && MezzAFP_Prod->IsUsingFiler())
    {
        MezzAFP_Prod->PrintStats();
        MezzAFP_Prod->ResetStats();
    }

    EmulatorControl *ec = (EmulatorControl*)gROOT->GetListOfTasks()->FindObject("_EmulatorControl");
    if(ec)
    {
        ec->Stop();
        ec->Print();
    }


    return true;
}

#endif