QReader.cc

Go to the documentation of this file.

#include "QReader.hh"
#include "QBool.hh"
#include "QEvent.hh"
#include "QEventAssembler.hh"
#include <fstream>
#include "QGlobalReaderDispatcher.hh"
#include "QEventList.hh"
#include "QNeighboursFiller.hh"
#include "QReaderEventGeneratorFiller.hh"
#include "QSidePulses.hh"
 
using namespace std;
 
Q_BEGIN_NAMESPACE
 
std::list<std::string> QReader::fFullPathFilesList;
 
QReader::QReader():QBaseModule(Reader)
{
    fRWCommon = 0;
    fNeighboursFiller = 0;
}
 
QReader::~QReader()
{
}
 
void QReader::Begin(QEventAssembler& eva)
{
    fFullPathFilesList.clear();
    fReadNumber = 0;
    fProcessedNumber = 0; 
    fNeighboursOn = false;
 
    if(GetBool("NeighboursOn",false,false)) {
        fNeighboursOn = true;
        if(GetString("NeighbourAlgorithm","") != "NeverNeighbour") {
            fNeighboursFiller = new QNeighboursFiller(this);
            fNeighboursFiller->Init(eva);
        } else {
            fNeighboursFiller = 0;
            Init(eva); 
        }
    }  else {
        fNeighboursFiller = 0;
        Init(eva); 
    }
    fRWCommon->fEventGeneratorOn = GetBool("EventGeneratorOn",false,false);
    fRWCommon->fReaderModuleName = GetName();
    if(fRWCommon->fEventGeneratorOn) {
        fReaderEventGeneratorFiller = new QReaderEventGeneratorFiller(this);
        fReaderEventGeneratorFiller->Init(eva);
        // Add a variable to specify if this event has been read or generated
        eva.Add<QBool>("Reader","GeneratedEvent").SetWrite(false);
    } else {
        fReaderEventGeneratorFiller  = 0;
    }
 
    fEventNumberPrintStep = GetInt("EventNumberPrintStep",10000);
}
 
bool QReader::Process(QEventAssembler& eva, QEventList& neigh,const bool exec,QEventList& oneigh)
{
    neigh.Clear();
    oneigh.Clear();
 
    if(!exec) return exec;
 
    bool ret;
    if(fNeighboursFiller) {
        ret = fNeighboursFiller->Do(eva,neigh);
        oneigh = neigh;
    } else {
        ret = DoBase(eva);
    }
 
    fProcessedNumber++;
    if(fProcessedNumber % fEventNumberPrintStep == 0) {
        Info("Events processed: %d", fProcessedNumber);
    }
    fExecuted = true;
    return ret;
}
 
bool QReader::DoBase(QEventAssembler& eva)
{
 
    bool ret;
    fNewFileOpen = false;
    eva.Clear();
    if(fReaderEventGeneratorFiller) {
        // Set the event to be considered read by default
        eva.Get<QBool>("Reader","GeneratedEvent")=false;
        ret = fReaderEventGeneratorFiller->Do(eva);
    } else {
        ret = Do(eva);
    }
    if(ret) eva.SetReadNumber( fReadNumber );
    fReadNumber++;
    if(fReadNumberAtFileOpen.count(eva.GetEvent().GetReadNumber())) {
      NotifyOpenNewFile(fReadNumberAtFileOpen[eva.GetEvent().GetReadNumber()]);
    }
    return ret;
}
 
void QReader::End()
{
    if(fNeighboursFiller) {
        if(GetTimeProfilingOn()) {
            Info(fNeighboursFiller->GetTimeProfileReport("|->Neighbour Filler Time").c_str());
            Info(fNeighboursFiller->GetReaderNeighbour()->GetTimeProfileReport("  |->Neighbour Algorithm Time").c_str());
        }
        delete fNeighboursFiller;
    }
    if(fReaderEventGeneratorFiller) {
        if(GetTimeProfilingOn())
            Info(fReaderEventGeneratorFiller->GetTimeProfileReport("  |->Event Generator Time").c_str());
        delete fReaderEventGeneratorFiller;
    }
    fNeighboursFiller = 0;
    fReaderEventGeneratorFiller = 0;
    Done();
}
 
const QError& QReader::JumpToEvent(Long64_t event) 
{
    fErr=QERR_NOT_IMPLEMENTED;
    std::string errDescr;
    errDescr = "JumpToEvent is not implemented with reader " + GetName();
    fErr.SetDescription(errDescr);
    return fErr;
}
 
const QError& QReader::BaseJumpToEvent(Long64_t event) 
{
    if(fNeighboursFiller != 0) { 
        Panic("JumpToEvent is not compatible with NeighboursOn=true option");
    }
    const QError& err = JumpToEvent(event);
    if(err == QERR_SUCCESS) fReadNumber = event;
    return err;
}
 
void QReader::InitFileManager()
{
    fFileNumber = 0;
    fReadFileList = false;
    fFileList.clear();
    std::string inFile = GetString("InputFile","NODEFAULT");
    std::string fileExtension = "";
    size_t dotpos =  inFile.find_last_of(".");
    if(dotpos != std::string::npos)
        fileExtension = inFile.substr( dotpos+1 );
    if(fileExtension == "list") fReadFileList = true;
 
    if(GetIteration() == 1)   fRWCommon->fTempOutputFileList="";
    if(GetIteration() == 1 && fReadFileList)  {
        fFileListPath = inFile;
        fRWCommon->fTempOutputFileList = fFileListPath;
    }
    if( fRWCommon->fTempOutputFileList == "") {
        // Open single file
        fFileList.push_back(inFile);
        Debug("InputFileName is %s", inFile.c_str());
    } else {
        // open file list
        std::string listPath = fRWCommon->fTempOutputFileList;
        ReadFilesList(listPath);
        Debug("FileList is %s",listPath.c_str());
    }
}
 
 
void QReader::NotifyOpenNewFile(const std::string &fileName)
{
    fRWCommon->fReaderFileNumber = ++fFileNumber;
    fRWCommon->fReaderCurrentFileName = fileName;
    QGlobalReaderDispatcher::GetInstance().SetCurrentReaderFilename(fileName);
}
 
void QReader::OpenNewFile(const std::string& fileName)
{
    fNewFileOpen = true;
    fFullPathFilesList.push_back(fileName);
    fReadNumberAtFileOpen[fReadNumber]=fileName;
}
 
void QReader::ReadFilesList(std::string path)
{
    Debug("Opening filelist \"%s\"", path.c_str());
    ifstream inputFileList (path.c_str());
    if (inputFileList.is_open()) {
        bool startFound = false;
        std::string dataPath = ".";
        std::string line;
        while (! inputFileList.eof() ) {
            getline(inputFileList,line);    
            // start parsing code
            if(line == "") continue;
            else if(line.at(0) == '#') continue;
            else if(line == "END") break;
            else if(line == "START") startFound = true;
            else if(line.substr(0,8) == "DATAPATH") {
                int valStart = line.find_first_not_of(' ', 8);
                int valEnd = line.find_first_of(' ', valStart);
                if(valStart - valEnd > 0)
                    dataPath = line.substr(valStart,valEnd - valStart);
                Debug("DataPath is \"%s\"", dataPath.c_str());
            }
            else if(startFound) {
                if (line.size() > 5
                        && line.rfind(".list") != std::string::npos
                        && line.rfind(".list") == line.size() - 5) {
                    // line has extension ".list"
                    // parse it as a file list
                    Debug("Found file list %s", line.c_str());
                    ReadFilesList(dataPath + "/" + line);
                }
                else {
                    fFileList.push_back(dataPath + "/" + line);
                    Debug("Found file %s", line.c_str());
                }
            }
            // end of parsing code
        }
        if(!startFound) Panic("Could not find the START tag in yout filelist");
        inputFileList.close();
    } else {
        Panic("Error opening InputFilesList %s",path.c_str());
    }
}
 
Q_END_NAMESPACE