TestFIO.cpp

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_DUMMYFILTER_H
#include "TestFIO.h"
#endif

#ifndef ADF_AgataKeyFactory
#include "AgataKeyFactory.h"
#endif
#ifndef ADF_AgataFrameFactory
#include "AgataFrameFactory.h"
#endif

#include "CrystalFrame.h"

#include <iostream>
#include <fstream>

using namespace ADF; 

TestFIO::TestFIO() : 
        NarvalFilter(),
        fDoRead(false),
        fDoOutput(false),
        fDoWrite(false),
        fDoRecord(false),       
        fTrigger("Generic Trigger")
{       
        Log.GetProcessName() = "TestFIO";
        GetFrameIO().SetName("TestFIO");

        // Test exchange of parameters with Narval
        UShort_t t1 = 12u;
        SetGlobalParameter("NP_US",t1);
        std::string t2 = "152Dy";
        SetGlobalParameter("NP_STRING",t2);
}

TestFIO::~TestFIO() 
{  
        // in principle not needed ... just in case reset has not been called by narval
        UInt_t error = 0u; process_reset(&error) ; 
} 

void TestFIO::process_config (const Char_t *directory_path, UInt_t *error_code)
{
        // In case your algorithm needs to initiate globals, it should be done here
        // For instance, if you need an proper FrameFactory:
        //      FrameFactory &main_frame_factory = FrameFactory::theMainFactory(); 
        //      main_frame_factory.Register( new MyFrameFactory() );
        
        // Globals for ADF are read from ADF.conf (should be in your algo path !!)
        NarvalInterface::process_config(directory_path,error_code);
  
        if ( (*error_code) == 0u ) { // now init your stuff
        
                // here could come the reading of a file in which are stored the 
                // units (position,energy) you are working with i.e. modifications
                // of UnitPosition UnitEnergy defined in the base class AlgoDummy
                // + ....
                // NarvalInterface (through process_config(), so don't forget it) 
                // keeps the name of the directory_path. To get it back: GetConfPath()
        }
}


#include "TrackedFrame.h"

UInt_t TestFIO::SetInput()
{
//      GammaTrackedInterface *data = GetDataPointer<GammaTrackedInterface>(fTrigger.GetInputFrame(0u));
//      data->Global()->Print();
        
        if ( fDoRead )
          if ( fTrigger.GetInputFrame(0u)->Read() == 0 )
                return 1u;
                
//      CrystalInterface *data = GetDataPointer<CrystalInterface>(fTrigger.GetInputFrame(0u));
        
//      UShort_t val;
//      for (UInt_t i = 0u ; i < data->GetCore(0)->GetSignal()->GetLength(); i++ ) 
//              printf("%d \n",data->GetCore(0)->GetSignal()->Get(val,i));
//              
        return 0u;
}

UInt_t TestFIO::Process()
{
        return 0u;
}
        
#include "PSAFrame.h"
#include "CrystalFrame.h"

UInt_t TestFIO::SetOutput()
{
        if ( !fDoOutput )
                return 0u;      
        
        Frame *resultframe = fTrigger.GetOutputFrame();
        
//      PSAInterface *data = GetDataPointer<PSAInterface>(fTrigger.GetOutputFrame());
//      CrystalInterface *data = GetDataPointer<CrystalInterface>(fTrigger.GetOutputFrame());
//      data->Global()->Print();
                
        if ( resultframe ) {
                resultframe->Reset(); 
                resultframe->Stallion();        
        }
        else return 1u;
        
        return 0u;      
}

UInt_t TestFIO::ProcessBlock (ADF::FrameBlock &in, ADF::FrameBlock &out)
{
        Log.ClearMessage(); Log.SetProcessMethod("process_block");

        // attach the input/output buffer to the FrameIO system
        GetFrameIO().Attach(&in,&out);
                
        // start the processing
        UInt_t error_code = 0u;
        while ( GetFrameIO().Notify() ) { // process the input 
                        
                if ( ! (SetInput() == 0u && Process() == 0u && SetOutput() == 0u) )  
                        { error_code =  1u; break; } 
                else {
                        // ok, so send the produced frame to the ouput
                        if ( fDoRecord )
                          if ( !GetFrameIO().Record() )
                                { error_code =  2u; break; }
                }
        }
        if ( error_code == 1u ) {
                Log << error 
                    << "During processing : SetInput -> Process -> SetOuput() " << nline;
        }       
        if ( error_code == 2u ) {
                Log << error 
                    << "During Record() " << nline;
        }       
        GetFrameIO().Detach(&in,&out);
        
        // send messages to the central log
        Log << dolog;
        return error_code;
}             

void TestFIO::process_initialise (UInt_t *error_code)
{
        *error_code = 0; Log.ClearMessage(); Log.SetProcessMethod("process_initialise"); 
        
        // read an input file to get the base filename and the path  
        std::string conffile = GetConfPath(), tmp, type;
        conffile += "TestFIO.conf";
        
        // if true means the file has the correct format and the trigger could be defined
        Bool_t ok = false, is_universal = false; 
        
        std::ifstream filein(conffile.data());
        // read first the model 
        filein >> tmp; 
        if ( !filein.good() ) 
                ok = false;     
        else 
                GetFrameIO().SetModel( ConfAgent::GetModel(tmp) ) ;
                                
        while ( filein.good() ) { 

                UShort_t kmin, kmaj, fmin, fmaj, cons, proxy; Version vkey, vframe;
                
                filein >> tmp >> type >> kmin >> kmaj >> fmin >> fmaj >> cons >> proxy;
                if ( !filein.good() ) 
                        break;
                
//              std::cout << "read" << tmp << type << kmin << kmaj << fmin << fmaj << cons << proxy;

                vkey(kmin,kmaj); vframe(fmin,fmaj);
                if (tmp == "p:" ) {
                        if ( fTrigger.SetOutputFrame(type.data(),vkey,vframe) == 0x0 )
                                Log << "Cannot allocate output frame " << type.data() << nline ;
                }
                if (tmp == "c:" ) {
                        ok = true;
                        if ( fTrigger.Add(type.data(),vkey,vframe,cons==1u) == 0x0 )
                                Log << "Cannot allocate input frame " << type.data() << nline ;
                }
                if (tmp == "g:" ) {
                        GetFrameIO().SetModel( ConfAgent::GetModel(type) ) ;
                        is_universal = (kmin == 1u); 
                        fDoRead      = (kmaj == 1u); 
                        fDoOutput    = (fmin == 1u); 
                        fDoWrite     = (fmaj == 1u); 
                        fDoRecord    = (cons == 1u);    
                }
        };

        // if ok registers the trigger 
        if ( !ok )
                *error_code = 1;
        else {
                fTrigger.Universal(is_universal);
                GetFrameIO().Register(&fTrigger);
                GetFrameIO().SetStatus(BaseFrameIO::kIdle);
        }
        
        Log << dolog;           
}


void TestFIO::process_reset (UInt_t *error_code)
{
        Log.ClearMessage(); Log.SetProcessMethod("process_reset"); 
        
        NarvalFilter::process_reset(error_code);
                
        Log << dolog;

}
void TestFIO::process_start (UInt_t *error_code)
{
        Log.ClearMessage(); Log.SetProcessMethod("process_block"); 
        (*error_code) = 0;
}

void TestFIO::process_stop (UInt_t *error_code)
{
        Log.ClearMessage(); Log.SetProcessMethod("process_stop"); 
        
        *error_code = 0;
        
        // Test exchange of parameters with Narval      
        UShort_t t1 = 9u;
        if ( GetGlobalParameter("NP_US",t1) == 0 )
                Log << " Parameter NP_US from ADA " << t1 << nline;
        else 
                Log << " Cannot get Parameter NP_US from ADA " << t1 << nline ;

        std::string t2 = "-";
        if ( GetGlobalParameter("NP_STRING",t2) == 0 )
                Log << " Parameter NP_STRING from ADA " << t2 << nline ;
        else 
                Log << " Cannot get Parameter NP_STRING from ADA " << t2 << nline ;
        
        Log << dolog;
}
void TestFIO::process_pause (UInt_t *error_code)
{
        std::cout << "process_pause called with GetPID()" << GetPID() << std::endl;
        *error_code = 0;
}
void TestFIO::process_resume (UInt_t *error_code)
{
        std::cout << "process_resume called with GetPID()" << GetPID() << std::endl;
        *error_code = 0;
}
/*
void TestFIO::process_unload (UInt_terror_code)
{
  std::cout << "process_unload called with GetPID()" << GetPID() << std::endl;
  *error_code = 0;
} */

#if HAVE_NARVAL_H == 1 && DUMMY_FILTER == 1
void process_config (const char *directory_path, UInt_t *error_code)
{
  TestFIO::process_config (directory_path, error_code);
}

TestFIO *process_register (UInt_t *error_code) { return new TestFIO(); }

/*void process_unload (TestFIO *algo_data, UInt_t *error_code)
{
  algo_data->process_unload (error_code);
}*/

void process_block (TestFIO *algo_data,
                    void *input_buffer,
                    UInt_t size_of_input_buffer,
                    void *output_buffer,
                    UInt_t size_of_output_buffer,
                    UInt_t *used_size_of_output_buffer,
                    UInt_t *error_code)
{
  algo_data->process_block (input_buffer, size_of_input_buffer,
                            output_buffer, size_of_output_buffer,
                            used_size_of_output_buffer, error_code);
}

void process_initialise (TestFIO *algo_data, UInt_t *error_code)
{
  algo_data->process_initialise (error_code);
}
void process_reset (TestFIO *algo_data,UInt_t *error_code)
{
  algo_data->process_reset (error_code);
}
void process_start (TestFIO *algo_data, UInt_t *error_code)
{
  algo_data->process_start (error_code);
}
void process_stop (TestFIO *algo_data,UInt_t *error_code)
{
  algo_data->process_stop (error_code);
}
void process_pause (TestFIO *algo_data,UInt_t *error_code)
{
  algo_data->process_pause (error_code);
}
void process_resume (TestFIO *algo_data, UInt_t *error_code)
{
  algo_data->process_resume (error_code);
}
#endif