Deprecated/MFM2ADF.C

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.             *
 ***************************************************************************/

#include "MFM2ADF.h"

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

using namespace std;

#include <fcntl.h>
#include "MFMCommonFrame.h"

using namespace ADF;

namespace {
    struct ANC_KEY {
        UInt_t length;
        UInt_t type;
        UInt_t eventnumber;
        ULong64_t timestamp;
    } the_anc_key;
}

MFM2ADF::MFM2ADF():
    NarvalProducer(),
    fCurrentFile(0),
    fCurrentFileNumber(0u),
    fFiles2Read(),
    fMFMFrame(0x0),
    fMFMVector(0x0),
    fBufferIO(aMByte),
    fTotBytesRead(0UL),
    fEventsRead(0UL)
{
        Log.GetProcessName() = "MFM2ADF";
}

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

Bool_t MFM2ADF::NewFile()
{
        Bool_t ok = false;
        
        if ( fCurrentFile > 0 ) {
                ::close(fCurrentFile);
                fCurrentFile = 0;
                Log << info << "the input file " << fFiles2Read[fCurrentFileNumber-1]
            << " has just been closed " << fTotBytesRead << " Bytes read " << nline;
        }
        
        while ( fCurrentFileNumber < fFiles2Read.size() ) {
                
                fCurrentFile = ::open(fFiles2Read[fCurrentFileNumber].data(),(O_RDONLY));
                if ( fCurrentFile < 0 ) {
            fCurrentFile = 0;
                        Log << warning << "File " << fFiles2Read[fCurrentFileNumber] << " is not a valid file " << nline ;
                        fCurrentFileNumber++;
                        continue;
                }
                Log << info << "A new input file has just been open " << fFiles2Read[fCurrentFileNumber] << nline;
                // decode the header part. For the moment just jump
        
        GetFrameIO().SetStatus(BaseFrameIO::kIdle);
                ok = true;
                fCurrentFileNumber++;
                break;
        }
        if ( fCurrentFile == 0 ) {
                GetFrameIO().SetStatus(BaseFrameIO::kFinished);
                Log << info << "All input file have been read " << nline;
        }
        //
        Log << dolog;
        
        return ok;
}

void MFM2ADF::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 MFM2ADF::ProcessBlock(ADF::FrameBlock &out)
{
        Log.ClearMessage(); Log.SetProcessMethod("process_block");
        
        // make sure length is 0 before starting anything
        out.Rewind(ConfAgent::kWrite);
        //
        if ( GetFrameIO().GetStatus() == BaseFrameIO::kFinished ) { // set in NewFile once list is over
                out.SetEoB(true);
                return 0u;
        }

    Bool_t ok = true, check_previous = true; Int_t framesize = 0, vectorsize; char **pvector;
    while (ok) {
        
        vectorsize = MFM_BLOB_HEADER_SIZE; pvector = &fMFMVector;
        
        if (check_previous) {
            if ( fBufferIO.Offset() ) { // read previously so stream it out. No check, assume enough place in the newly given out
                out.AddFrame(fBufferIO);
                fBufferIO.FastReset();
            }
            check_previous = false;
        }

        framesize = fMFMFrame->ReadInFile(&fCurrentFile, pvector, &vectorsize);
        if (framesize <= 0) {
            // if ( ::eof(fCurrentFile) ) {
            if ( NewFile() )
                break ;
            else return 1u;
            // }
            // else return 1u;
        }
        //fMFMFrame->HeaderDisplay((char*)"-- Header of Frame --");
        fEventsRead++;
        fTotBytesRead+=framesize;
        //
        the_anc_key.length = framesize + sizeof(ANC_KEY);
        the_anc_key.type   = 0xFA0201A0;
        the_anc_key.eventnumber = fMFMFrame->GetEventNumber();
        the_anc_key.timestamp   = fMFMFrame->GetTimeStamp();
        
        fBufferIO.Import((Char_t *)(&the_anc_key),20);
        fBufferIO.Import((Char_t *)fMFMFrame->GetPointHeader(),framesize);
                
        fBufferIO.SetEffectiveSize(the_anc_key.length);
        if ( out.AddFrame(fBufferIO) == false )
            break;
        fBufferIO.FastReset();
    }
        //
        out.SetEoB(true);
        
        Log << dolog; return 0u;
}

void MFM2ADF::process_initialise (UInt_t *error_code)
{
        std::string tmp, option, filename;
        //
        *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() + "MFM2ADF.conf";
        
        std::ifstream filein(conffile.data());
        if ( filein.is_open() == true ) {
                getline(filein,tmp);
                tmp += " ";
                while ( filein.good() && !filein.eof() ) { // read input stream line by line
                        if ( tmp[0] == '#' ) {
                                getline(filein,tmp);
                                tmp += " ";
                                continue;
                        } // this line is a comment
                        
                        std::istringstream decode(tmp);
                        
                        if( tmp[0] == 'l' ) { // the .conf file contains the list of file to be read
                                decode >> option >> filename;
                                if( decode.good() )
                                        fFiles2Read.push_back(filename);
                        }
                        getline(filein,tmp);
                        tmp += " ";
                }
        }
        filein.close();
        
        Log << " " << fFiles2Read.size() << " file(s) is(are) to be read by MFM2ADF Producer " << nline;
    
        // open the first file, try up to the first good one. if nothing retrun error
        if ( !NewFile() )
                *error_code = 1u;
    
    // the current read MFM frame
    fMFMFrame = new MFMCommonFrame();
    //
    fMFMVector = (char*) (malloc(MFM_BLOB_HEADER_SIZE));

        Log << dolog;
}


void MFM2ADF::process_reset (UInt_t *error_code)
{
        *error_code = 0u;
        Log.ClearMessage(); Log.SetProcessMethod("process_reset");
        
        if ( fCurrentFile ) {
                ::close(fCurrentFile); fCurrentFile = 0;
        }
        
        Log << fCurrentFileNumber << " file(s) read "
        << " Total number of events " << fEventsRead << " within " << fTotBytesRead << " bytes read"
        << dolog;
    
    if ( fMFMVector ) {
        delete fMFMVector; fMFMVector = 0x0;
    }
    if ( fMFMFrame ) {
        delete fMFMFrame; fMFMFrame = 0x0;
    }
}