QGFileHandler.cc

Go to the documentation of this file.

#include "QGFileHandler.hh"
#include <algorithm>
#include <iostream>
#include <map>
#include <string>
 
#ifndef WIN32
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <unistd.h>
#endif
 
#include "QBaseTree.hh"
#include "QChain.hh"
#include "QRawEvent.hh"
#include "QRunData.hh"
#include "QRunDataHandle.hh"
#include "QGDefaultsHandler.hh"
#include "QGTextFileHandler.hh"
#include <TAuthenticate.h>
#include <TCollection.h>
#include <TCut.h>
#include <TDirectory.h>
#include <TEventList.h>
#include <TFile.h>
#include <TGClient.h>
#include <TGFileDialog.h>
#include <TGInputDialog.h>
#include <TKey.h>
#include <TLeaf.h>
#include <TList.h>
#include <TString.h>
#include "QGlobalDataManager.hh"
#include "QVectorI.hh"
#include "TDataMember.h"
 
ClassImp(QGFileHandler)
 
using std::cout;
using std::endl;
using std::flush;
using std::map;
using std::string;
using std::vector;
using std::pair;
using std::set;
using Diana::QVector;
using Diana::QVectorI;
 
QGFileHandler::QGFileHandler()
    : fFile(0), fFileOpen(false), fHeader(0),  fPulseInfo(0), fQChain(0)
{
    fDefaultPulseLabel = "";
    SetUpNumericTypes();
    SetUpChain();
    fDataManager = new Diana::QGlobalDataManager;
    fDataManager->SetOwner("GUI");
    fGenericObject = 0;
} 
 
QGFileHandler::~QGFileHandler() 
{ 
  if (fQChain) delete fQChain; 
}
 
bool QGFileHandler::CheckForModifiedFiles()
{
    bool foundModifiedFile = false;
 
#ifndef WIN32
    map<string, time_t>::const_iterator fileIter;
    for (fileIter  = fModificationTime.begin();
         fileIter != fModificationTime.end() && foundModifiedFile == false;
         ++fileIter) {
        if (ModificationTime(fileIter->first) > fileIter->second) {
            foundModifiedFile = true;
        }
    }
    if (foundModifiedFile) {
        cout << "Some open files were modified.  Reopening files." << endl;
        ReopenFiles();
    }
#endif
 
    return foundModifiedFile;
}
 
void QGFileHandler::CloseFiles() 
{
    fFileOpen = false;
    fFilenames.clear();
    fModificationTime.clear();
    if (fQChain) delete fQChain; 
    fQChain = 0;
    fHeader = 0;
    fPulseInfo = 0;
    
    fTreeClass = "";
    SetUpChain();
    fLowestStartTimeUnix = 0;
}
 
void QGFileHandler::GetEvent(const Long64_t eventNumber, const std::string& samplesname) 
{
    fQChain->GetEntry(eventNumber);
 
    TBranch* br = 0;
    if(!samplesname.empty() && fQChain->FindBranch(samplesname.c_str())) {
        std::string brname = samplesname;
        br = fQChain->GetBranch(brname.c_str());
        TLeaf* leaf = br->GetLeaf(brname.c_str());
        if(leaf) {
            const char* leafType = leaf->GetTypeName();
            TClass thisClass(leafType);
            bool isQVector = std::string("Diana::QVector") == thisClass.GetName();
            bool isQVectorI = std::string("Diana::QVectorI") == thisClass.GetName();
            bool isQPulse = std::string("QPulse") == thisClass.GetName();
            if(isQVector) {
                QVector* samples = 0;
                fQChain->SetBranchAddress(samplesname.c_str(),&samples);
                fQChain->GetEntry(eventNumber);
                fSamples = *samples; 
            } else if(isQVectorI) {
                QVectorI* samples = 0;
                fQChain->SetBranchAddress(samplesname.c_str(),&samples);
                fQChain->GetEntry(eventNumber);
                fSamples = *samples;
            } else if(isQPulse) {
                QPulse* samples = 0;
                fQChain->SetBranchAddress(samplesname.c_str(),&samples);
                fQChain->GetEntry(eventNumber);
                fSamples = samples->GetSamples();
            } else {
                fGenericObject = 0;
                fQChain->SetBranchAddress(samplesname.c_str(),&fGenericObject);
                fQChain->GetEntry(eventNumber);
            }
        } // leaf
    } 
    if(br) fQChain->ResetBranchAddress(br);
}
 
TEventList QGFileHandler::GetEventList(TCut cuts) 
{
        fQChain->Draw(">>eList", cuts, "goff same");
        // FIX ME:  this may create a TEntryList in future releases of ROOT
        TEventList *eventListPtr = (TEventList*) gDirectory->Get("eList");
        TEventList eventList = *eventListPtr;
        eventList.SetName("eventList");
        delete eventListPtr;
        return eventList;
}
 
const QSampleInfo& QGFileHandler::GetMasterSample(const Long64_t eventNumber) {
        if(fPulseInfo) fPulseInfo->Clear();
        GetEvent(eventNumber);
        static QSampleInfo empty;
        if (fPulseInfo) {
                return fPulseInfo->GetMasterSample();
        }
        else {
                return empty;
        }
}
 
const QVector& QGFileHandler::GetPulse(const Long64_t eventNumber, const std::string& samplesname)
{
        fSamples.Clear();
        GetEvent(eventNumber,samplesname);
        return fSamples;
}
 
TObject* QGFileHandler::GetGenericObject(const Long64_t eventNumber, const std::string& samplesname)
{
        fGenericObject = 0;
        GetEvent(eventNumber,samplesname);
        return fGenericObject;
}
 
 
const vector<QSampleInfo>& QGFileHandler::GetSignificantSamples(
                const Long64_t eventNumber)
{
        if(fPulseInfo) fPulseInfo->Clear();
        GetEvent(eventNumber);
        static vector<QSampleInfo> empty;
        if (fPulseInfo) {
                return fPulseInfo->GetSamplesInfo();
        }
        else {
                return empty;
        }
}
 
 
const QRunData* QGFileHandler::GetRunData(const Long64_t eventNumber)
{
        GetEvent(eventNumber);
 
        if (fHeader && fPulseInfo) {
                const Int_t run = fHeader->GetRun();
                // check if already taken for this run
                QRunDataHandle rh(run);
                fDataManager->Get("DAQ",&rh,"");
                if(rh.IsValid()) return &rh.Get();
                // not found, look in files
                // clear cache
                fDataManager->Clear();
                fQChain->LoadTree(eventNumber);
                TTree *tree = fQChain->GetTree();
                if (tree) {
                        TDirectory *directory = tree->GetDirectory();
                        if (directory) {
                                fDataManager->Get("DAQ",&rh,directory->GetName());
                        }
                        if (!rh.IsValid()) {
                                // did not find run data in the file
                                // possibly because the file is not the first partial file
                                // try looking for run data in the first partial file
                                string currentFile = directory->GetName();
                                string firstPartial = currentFile;
                                firstPartial.replace(firstPartial.size() - 8, 3, "001");
                                fDataManager->Get("DAQ",&rh,firstPartial);
                        }
                }
        if(rh.IsValid()) return &(rh.Get());
    }
    return 0;
 
 
}
const QChannelRunData* QGFileHandler::GetChannelRunData(const Long64_t eventNumber)
{
    const QRunData* runData = GetRunData(eventNumber);
    if(!runData) return 0;
    const Int_t chan = fPulseInfo->GetChannelId();
    const QChannelRunData* chanRunData = 0;
    try{
        chanRunData = &runData->GetChannelRunData(chan);
    }
    catch(...) {
        chanRunData = 0;
    }
    return chanRunData;
 
}
 
set<string> QGFileHandler::GetSetOfAliases() {
    set<string> aliases;
    if (fFileOpen) {
        TList* aliasList = fQChain->GetListOfAllAliases();
        if (aliasList) {
            int N = aliasList->GetSize();
            for (int i = 0; i < N; ++i) {
                string alias
                    = aliasList->At(i)->GetName();
                bool notSamples = (alias != "Samples");
                if (notSamples) {
                    aliases.insert(alias);
                }
            }
        }
        if ( fQChain->GetListOfAliases() ) {
            int N = fQChain->GetListOfAliases()->GetSize();
            for (int i = 0; i < N; ++i) {
                string alias = fQChain->GetListOfAliases()->At(i)->GetName();
                aliases.insert(alias);
            }
        }
    }
    return aliases;
}
std::set<std::string> QGFileHandler::GetSetOfQVectorAliases()
{
    set<string> aliases;
    return aliases;
}
 
set<string> QGFileHandler::GetSetOfLeaves() {
    set<string> leaves;
    if (fFileOpen) {
        TObjArray* leafList = fQChain->GetListOfAllLeaves();
        int N = leafList->GetSize();
        for (int i = 0; i < N; ++i) {
            TLeaf *leaf = (TLeaf*) leafList->At(i);
            if (leaf) {
                string type = leaf->GetTypeName();
                string name = leaf->GetName();
                bool numericType = fNumericTypes.count(type) > 0;
                bool notfUniqueID = name.find(".fUniqueID") == string::npos;
                bool notfBits = name.find(".fBits") == string::npos;
                if (numericType && notfUniqueID && notfBits) {
                    leaves.insert(name);
                }
            }
        }
    }
    return leaves;
}
 
set<string> QGFileHandler::GetSetOfQVectorLeaves() {
    set<string> leaves;
    if (fFileOpen) {
        TObjArray* leafList = fQChain->GetListOfAllLeaves();
        TIter next(leafList);
        while(TLeaf* leaf = (TLeaf*)next()) {
            if (leaf) {
                string type = leaf->GetTypeName();
                string name = leaf->GetName();
                TClass thisClass(type.c_str(),kTRUE);
                bool isQVector = std::string("Diana::QVector") == thisClass.GetName();
                bool isQVectorI = std::string("Diana::QVectorI") == thisClass.GetName();
                bool isQPulse = std::string("QPulse") == thisClass.GetName();
                bool isQPulseC = std::string("QPulseC") == thisClass.GetName();
                if (isQVector || isQVectorI || isQPulse || isQPulseC) {
                    leaves.insert(name);
                }     
            }
        }
        leaves.insert(fDefaultPulseLabel);
    }
    return leaves;
}
 
 
 
void QGFileHandler::ListOpenFiles()
{
    cout << endl << endl;
    if (fFileOpen) {
        if (fFilenames.size() == 1) 
            cout << "There is 1 open file:" << endl;
        else
            cout << "There are " << fFilenames.size() << " open files:" << endl;
        for (unsigned int i = 0; i != fFilenames.size(); ++i) {
            cout << fFilenames[i] << endl;
        }
    } else {
        cout << "There are no open files." << endl;
    }
    cout << endl;
}
 
#ifndef WIN32
time_t QGFileHandler::ModificationTime(const std::string& filename)
{
    time_t mtime = 0;
 
    // create a file attribute structure
    struct stat attrib;
 
    // get the attributes of filename
    if (stat(filename.c_str(), &attrib) != -1) {
        mtime = attrib.st_mtime;
    }
 
    return mtime;
}
#endif
 
void QGFileHandler::OpenFile()
{
    fDataDirectory = QGDefaultsHandler::Instance()->GetDataDirectory();
    TString dir(fDataDirectory.c_str());
    TGFileInfo fi;
    fi.fIniDir = StrDup(dir);
    const char *filetypes[] = { "ROOT files",    "*.root",
        "File lists",    "*.list",
        0,               0 };
    fi.fFileTypes = filetypes;
    new TGFileDialog(gClient->GetRoot(), 0, kFDOpen, &fi);
 
    if (fi.fMultipleSelection) {
        if (fi.fFileNamesList) {
            int N = fi.fFileNamesList->GetEntries();
            for (int i = 0; i < N; ++i) {
                OpenFile(fi.fFileNamesList->At(i)->GetName());
            }
        }
    }
    else if (fi.fFilename) {
        OpenFile(fi.fFilename);
    }
 
    if (fi.fFilename || fi.fFileNamesList) {
        string currentDirectory = fi.fIniDir;
        if (currentDirectory != fDataDirectory) {
            fDataDirectory = currentDirectory;
            QGDefaultsHandler::Instance()->SetDataDirectory(currentDirectory);
        }
    }
}
 
void QGFileHandler::OpenFile(string filename) 
{
    //cout << "Opening file " << filename << endl;
 
    string prefixRemovedFilename = filename;
    if (prefixRemovedFilename.find(":\\") != string::npos) {
        // filename begins with something like C:\ on Windows
        // remove the C:
        prefixRemovedFilename
            = prefixRemovedFilename.substr(prefixRemovedFilename.find(":\\")
                    + 1);
    }
    if (prefixRemovedFilename.find("root://") == string::npos
            && prefixRemovedFilename.find(':') != string::npos) {
        string server
            = prefixRemovedFilename.substr(0, prefixRemovedFilename.find(':'));
        if (server.find_last_of("/\\") != string::npos) {
            server = server.substr(server.find_last_of("/\\") + 1);
        }
        string file
            = prefixRemovedFilename.substr(prefixRemovedFilename.find(':') + 1);
        if (server == "corc") {
            server = "corleone.roma1.infn.it";
            file = "/data/dianadata/ntp_cuoricino/" + file;
        }
        else if (server == "apollo") {
            server = "dianadaqha1.lngs.infn.it";
            file = "/data/daq/rawdata/" + file;
        }
        filename = "root://" + server + '/' + file;
        TAuthenticate::SetGlobalUser("diana");
        static char* passwd = NULL;
        if (!passwd) {
            passwd = TAuthenticate::PromptPasswd("Password for user diana:  ");
            TAuthenticate::SetGlobalPasswd(passwd);
        }
    }
    TString filenameTString(filename);
    if (filenameTString.EndsWith(".list")) {
        ParseFileList(filename);
    } else if (filenameTString.EndsWith(".root")) {
        // Check whether file is already open
        bool alreadyOpen = (find(fFilenames.begin(), fFilenames.end(), filename)
                != fFilenames.end());
        if (alreadyOpen) {
            cout << "Warning:  The file " << filename 
                << " is already open and will not be added to the chain again."
                << endl;
        } else if (filename != "") {
            fFile = TFile::Open(filename.c_str(), "READ");
            if (!fFile || fFile->IsZombie()) { // failed to open file
                cout << "File " << filename
                    << " does not appear to be a valid ROOT file." << endl;
            }
            else { // file opened successfully
                // if the file contains a key named QTREE_NAME, try to use it
                TKey *key = fFile->FindKey(QTREE_NAME);
                if (!key) { // file does not contain a key called QTREE_NAME
                    // try to find the tree in the file
                    // if the file contains a unique tree, use it
                    // otherwise, prompt for the name of the tree
                    unsigned int numberOfTreesFound = 0;
                    TList *listOfKeys = fFile->GetListOfKeys();
                    TIter keyIter(listOfKeys);
                    while ( TKey *currentKey = dynamic_cast<TKey*>(keyIter()) ) {
                        if ( TObject *currentObj
                                = dynamic_cast<TObject*>(currentKey->ReadObj()) ) {
                            if (currentObj->InheritsFrom("TTree")) {
                                key = currentKey;
                                ++numberOfTreesFound;
                            }
                        }
                    }
                    if (numberOfTreesFound != 1) {
                        cout << "File " << filename
                            << " does not contain a tree named " << QTREE_NAME
                            << endl;
                        fFile->ls();
                        char treeName[80];
                        new TGInputDialog(gClient->GetRoot(), gClient->GetRoot(),
                                "Enter the name of the tree:", 0,
                                treeName);
                        key = fFile->FindKey(treeName);
                    }
                }
                if (key) {
                    string keyClass = key->GetClassName();
                    if (fFileOpen) {
                        if (keyClass == fTreeClass) {
                            if (fQChain->Add(filename.c_str())) {
                                fFilenames.push_back(filename);
                                fModificationTime[filename] = ModificationTime(filename);
                                SetLowestStartTimeUnix(key->GetName());
                            }
                        } else {
                            cout << "Tree class " << keyClass << " in file "
                                << filename
                                << " does not match existing tree class "
                                << fTreeClass
                                << ".  "
                                << "The tree will not be added to the chain."
                                << endl;
                        }
                    } else if (fQChain->Add(filename.c_str())) {
                        fFilenames.push_back(filename);
                        fModificationTime[filename] = ModificationTime(filename);
                        fTreeClass = keyClass;
                        fFileOpen = true;
                        if (fTreeClass == "QTree"
                                || fTreeClass == "QiTree"
                                || fTreeClass == "QATree") {
                            // current diana
                            fQChain->SetBranchAddress("DAQ@Header.",&fHeader);
                            fQChain->SetBranchAddress("DAQ@PulseInfo.",&fPulseInfo);
                            if(fQChain->FindBranch("DAQ@Pulse.")) fDefaultPulseLabel = "DAQ@Pulse.";
                            const char* pulserPath = fQChain->GetAlias("IsHeater");
                            if(pulserPath) {
                                fQChain->SetAlias("IsPulser",pulserPath);
                            }
                        }
                        SetLowestStartTimeUnix(key->GetName());
                    }
                } else {
                    cout << "The file " << filename
                        << " does not contain a tree with the given name."
                        << endl;
                }
            }
            if (fFile) {
                fFile->Close();
                delete fFile;
                fFile = 0;
            }
        }
    }
}
 
void QGFileHandler::OpenFiles(const std::vector<std::string>& files)
{
    vector<string>::const_iterator fileIter;
    for (fileIter = files.begin(); fileIter != files.end(); ++fileIter) {
        OpenFile(*fileIter);
    }
}
 
void QGFileHandler::ParseFileList(const std::string& filename)
{
    QGTextFileHandler textFileHandler;
    if (textFileHandler.ReadFile(filename)) {
        string dataPath;
        if (textFileHandler.DoesKeyExist("DATAPATH")) {
            dataPath = textFileHandler.GetValue("DATAPATH");
 
            // if dataPath does not end with a "/", append a "/"
            if ( dataPath.rfind("/") + 1 != dataPath.size() ) {
                dataPath = dataPath + "/";
            }
        }
        else if ( filename.find_last_of("/\\") != std::string::npos ) {
            dataPath
                = filename.substr( 0, filename.find_last_of("/\\") + 1 );
            // dataPath will end in a "/" or "\" unless the filename was given
            // without a directory, in which case dataPath will be empty
        }
 
        const vector<pair<string, string> >& lines = textFileHandler.GetLines();
        vector<pair<string, string> >::const_iterator lineIter = lines.begin();
        while (lineIter != lines.end() && lineIter->first != "START") {
            ++lineIter;
        }
        ++lineIter;
        while (lineIter != lines.end() && lineIter->first != "END") {
            string dataFile = lineIter->first;
            if (!dataFile.empty() && dataFile[0] != '#') {
                OpenFile(dataPath + dataFile);
                // dataPath already ends in "/" or is empty
            }
            ++lineIter;
        }
    }
}
 
void QGFileHandler::ReopenFiles()
{
    vector<string> filenames = fFilenames;
    CloseFiles();
    fDataManager->Clear();
    QGlobalReaderDispatcher::GetInstance().Clear();
    OpenFiles(filenames);
}
 
void QGFileHandler::SetLowestStartTimeUnix(const string& treeName)
{
    if (fFile && !fFile->IsZombie()) {
        const TKey* key = fFile->FindKey(treeName.c_str());
        string treeClass = key->GetClassName();
 
        if (treeClass == "QTree"
                || treeClass == "QiTree"
                || treeClass == "QATree") {
            TTree* tree = NULL;
            fFile->GetObject(treeName.c_str(), tree);
 
            TObject* utv = fQChain->GetListOfAllAliases() ? fQChain->GetListOfAllAliases()->FindObject("StartRunUnixTime") : 0;
            const char* unixTimeVar = utv ? utv->GetTitle() : "";
            double minTime = tree->GetMinimum(unixTimeVar);
            if (fFilenames.size() == 1 || minTime < fLowestStartTimeUnix) {
                fQChain->SetAlias( "LowestStartRunUnixTime", Form("%.9g", minTime) );
                fLowestStartTimeUnix = minTime;
            }
        }
    }
}
 
void QGFileHandler::SetUpChain()
{
    fQChain = new QChain();
    fQChain->SetDirectory(0);
} 
 
void QGFileHandler::SetUpNumericTypes() {
    fNumericTypes.insert("double");
    fNumericTypes.insert("Double_t");
    fNumericTypes.insert("Double32_t");
    fNumericTypes.insert("float");
    fNumericTypes.insert("Float_t");
    fNumericTypes.insert("int");
    fNumericTypes.insert("Int_t");
    fNumericTypes.insert("UInt_t");
    fNumericTypes.insert("long");
    fNumericTypes.insert("Long64_t");
    fNumericTypes.insert("ULong64_t");
    fNumericTypes.insert("Short_t");
    fNumericTypes.insert("UShort_t");
    fNumericTypes.insert("bool");
    fNumericTypes.insert("Bool_t");
}