agapro/ApplyTracking/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 "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:
        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, const char *run_pat, Option_t *opt_adf_pattern)
    {
        return BaseEmulatorChain::Init(which_run,experiment,which_adf_data,run_pat, 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(),
        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;

    // just in case a actor forget to call it and it is required.
    NarvalInterface::process_config(fPathProd.data(),&err);
    if ( err > 0u ) {
    }

        err = 0u;
        // it creates and inits the different actors
        // producer
        Prod_actor::process_config(fPathProd.data(),&err); 
        if ( err > 0u ) {
                return false;
        }
        fProducer = new Prod_actor(); 
        fProducer->process_initialise(&err);
        if ( err > 0u )  {
                return false;
        }
                
        // filter
        Filt_actor::process_config(fPathFilt.data(),&err);
        if ( err > 0u ) {
        return false;
        }       
        fFilter = new Filt_actor() ; 
        fFilter->process_initialise(&err);      
        if ( err > 0u )  {
                return false;
        }

        // consumer
        Cons_actor::process_config(fPathCons.data(),&err); 
        if ( err > 0u ) {
                return false;
        } 
        fConsumer = new Cons_actor(); 
        fConsumer->process_initialise(&err);
        if ( err > 0u )  {
                return false;
        }
        
    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");

        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 ) {
            if ( nb_try > 1 ) { // up to XX tries of consecutive empty output before stooping
                break;
            }
            else {
                nb_try++;
                continue;
            }
        }
        else nb_try = 0u;

        int Filterstatus = fFilter->ProcessBlock(fBProd,fBFilt);
        int FilterSize = fBFilt.GetSize();

//        cout<<"Filter status = "<<Filterstatus<<endl;
//        cout<<"Filter size   = "<<FilterSize<<endl;

        if ( FilterSize == 0u ) break;

        int ConsStatus = fConsumer->ProcessBlock(fBFilt);

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

        if(Prodstatus != 0 || Filterstatus !=0 || ConsStatus != 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:
        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(),
        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;

    // just in case a actor forget to call it and it is required.
    NarvalInterface::process_config(fPathProd.data(),&err);
    if ( err > 0u ) {
    }

        err = 0u;
        // it creates and inits the different actors
        // producer
        Prod_actor::process_config(fPathProd.data(),&err); 
        if ( err > 0u ) {
                return false;
        }
        fProducer = new Prod_actor(); 
        fProducer->process_initialise(&err);
        if ( err > 0u )  {
                return false;
        }
        
        // consumer
        Cons_actor::process_config(fPathCons.data(),&err); 
        if ( err > 0u ) {
                return false;
        } 
        fConsumer = new Cons_actor(); 
        fConsumer->process_initialise(&err);
        if ( err > 0u )  {
                return false;
        }

    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");
        if ( fProducer->ProcessBlock(fBProd) != 0u )
        {
            fConsumer->ProcessBlock(fBProd);
            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());*/
        //printf("Call consumer \n");
        if ( fConsumer->ProcessBlock(fBProd) != 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);

    return true;
}

#endif