BasicAFP.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_BasicAFP
#include "BasicAFP.h"
#endif

#include <iostream>
#include <iomanip>
#include <fstream>

using namespace ADF; 

BasicAFP::BasicAFP(Int_t id): 
NarvalProducer(),
fSourceOfFrames(aMByte,ConfAgent::kRead),
fPath("./"), 
fBaseForName("AFP_"),
fCurrentFile(0x0),
fCurrentFileNumber(0u),
fMaxSize(kMaxInt_t),
fMyID(id),
fEndOfFrame("EndOfFrame")
{
        Log.GetProcessName() = "BasicAFP";
        GetFrameIO().SetName("BasicAFP");
        
        // to be sure unknown frames are written in the ouput
        GetFrameIO().SetModel(ConfAgent::kSafe); 
        // to protect writings in the source of frames
        fSourceOfFrames.SetModeIO(ConfAgent::kRead);
        // the input datablock is owned by BasicAFP
        GetFrameIO().Attach(&fSourceOfFrames,0x0);
}

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

Bool_t BasicAFP::NewFile()
{       
        Bool_t ok = false;
        
        if ( fCurrentFile ) {
                ::fclose(fCurrentFile);
                fCurrentFile = 0x0;
                std::cout << "  -BasicAFP: the input file has just been closed " << fCurrentFileName << std::endl;
        }
        
        // open the first file to be ready to be run
        std::string tmp = fPath;
        if ( tmp.size() > 0 && !(tmp.at(tmp.size()-1) == '/') ) 
                tmp += '/';
        
        std::ostringstream filename;
        filename << tmp << fBaseForName
        << std::setfill('0') << std::setw(4) << fCurrentFileNumber++ << std::setfill(' ')
        << ".adf";
        fCurrentFileName = filename.str();
        
        fCurrentFile = ::fopen(fCurrentFileName.c_str(),"rb");
        if ( fCurrentFile != 0x0 ) {
                Log << "  -BasicAFP: the input file has just been opened " 
                << fCurrentFileName << nline;
                
                fSourceOfFrames.SetFile(fCurrentFile,fMaxSize);
                GetFrameIO().SetStatus(BaseFrameIO::kIdle);
                
                size_t len = fCurrentFileName.length();
                size_t lpt = fCurrentFileName.find_last_of('/');
                fCurrentName = fCurrentFileName.substr(lpt+1, len-lpt-1);
                ok = true;
        }
        else {
                Log << "Could not open input file " << fCurrentFileName << nline;
                GetFrameIO().SetStatus(BaseFrameIO::kFinished); 
                ok = false;
        }
        
        return ok;
}

void BasicAFP::process_config (const Char_t *directory_path, UInt_t *error_code)
{       
        // first init narval and ADF stuff (if required)
        NarvalInterface::process_config(directory_path, error_code);
        
        if ( (*error_code) == 0u ) {
                // now init your stuff
        }
}

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

    // attach the FrameBlock
    GetFrameIO().Attach(0x0,&out);

    // fill the output with successive frames read from the file until out is filled
    UInt_t nevtsIn = GetFrameIO().GetFramesRead();
    while ( GetFrameIO().Notify() ) {
    }
    Int_t nevtsOut = GetFrameIO().GetFramesRead();

    // interruption: means end of file or out is full
    if ( GetFrameIO().GetCurrentBlockIN()->IsEoB() ) { // the file has been read, try to open the next one
        if ( NewFile() == false )
            GetFrameIO().SetStatus(BaseFrameIO::kFinished);
    }

    if(fMyID >= 0) {
        std::cout << std::setw(2) << fMyID;
        std::cout << std::left << std::setw(24) << "-BasicAFP:" << std::right
      << " " << std::setw(5) << nevtsOut-nevtsIn
      << " evts (" << std::setw(8) << out.GetSize() << ")"
      << " Tot = " << std::setw(8) << nevtsOut
      << "           " << fCurrentName << std::endl;
    }

    if ( GetFrameIO().GetStatus() == BaseFrameIO::kFinished ) {
        // set a trigger to send end of frames (single shot) in case the producer is in finish mode and the user ask for an new frame
        if ( fEndOfFrame.GetOutputFrame() == 0x0 ) {
            // a eof frame
            FactoryItem key_item("Agata","meta:eof",Version(1,0)), frame_item("Agata","meta:eof",Version(0,0));
            // allocate and record it using trigger
            SharedFP *eof = fEndOfFrame.SetOutputFrame( key_item, frame_item );
            if ( eof ) {
                // add a eof
                GetFrameIO().Register(&fEndOfFrame);
                fEndOfFrame.Fired(true);
                fEndOfFrame.GetOutputFrame()->Write();

                GetFrameIO().Record(&fEndOfFrame);
                //
                Log << dolog;
                // return with this frame

                return 0u;
            }
        }
        Log << dolog;
        return 1u;
    }

    // detach the output block
    GetFrameIO().Detach(0x0,&out);
    //
    Log << dolog;
    return 0u;
}

void BasicAFP::process_initialise (UInt_t *error_code)
{
        *error_code = 0u;
        Log.ClearMessage(); Log.SetProcessMethod("process_initialise");
        
        // read an input file to get the base filename and the path  
        std::string conffile = GetConfPath() + "BasicAFP.conf";
        
        std::ifstream filein(conffile.data());
        if ( filein.is_open() == true ) { 
                
                std::string pathforfiles, basename; 
                UInt_t starting_number;
                
                filein >> pathforfiles >> basename >> starting_number;
                if ( filein.good() ) {
                        fPath = pathforfiles;
                        fBaseForName = basename;
                        fCurrentFileNumber = starting_number;
                        std::cout << "BasicAFP::process_initialise " << pathforfiles << " " << basename << " " << starting_number << std::endl;
                }
        }
        filein.close();
        
        // open the first file
        if ( !NewFile() )
                *error_code = 1u;
        
        Log << dolog;    
}


void BasicAFP::process_reset (UInt_t *error_code)
{
        *error_code = 0u;
        Log.ClearMessage(); Log.SetProcessMethod("process_reset");
        
        if ( fCurrentFile )
                ::fclose(fCurrentFile);
        
        GetFrameIO().Print( Log() );
        
        Log << dolog;
}
/*
 void BasicAFP::process_unload (UInt_terror_code)
 {
 std::cout << "process_unload called with GetPID()" << GetPID() << std::endl;
 *error_code = 0;
 } */