FairFileSource.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
//
//  FairFileSource.h
//  FAIRROOT
//
//  Created by Mohammad Al-Turany on 08/02/14.
//
//

#ifndef __FAIRROOT__FairFileSource__
#define __FAIRROOT__FairFileSource__

#include "FairSource.h"

#include <TArrayI.h>
#include <TChain.h>
#include <TFile.h>
#include <TFolder.h>
#include <TString.h>
#include <list>
#include <map>

class FairEventHeader;
class FairFileHeader;
class FairMCEventHeader;
class FairRuntimeDb;
class TF1;
class TTree;

class FairFileSource : public FairSource
{
  public:
    FairFileSource(TFile* f, const char* Title = "InputRootFile", UInt_t identifier = 0);
    FairFileSource(const TString* RootFileName, const char* Title = "InputRootFile", UInt_t identifier = 0);
    FairFileSource(const TString RootFileName, const char* Title = "InputRootFile", UInt_t identifier = 0);
    // FairFileSource(const FairFileSource& file);
    virtual ~FairFileSource();

    Bool_t Init();
    Int_t ReadEvent(UInt_t i = 0);
    void Close();
    void Reset();

    virtual Source_Type GetSourceType() { return kFILE; }

    virtual void SetParUnpackers() {}

    virtual Bool_t InitUnpackers() { return kTRUE; }

    virtual Bool_t ReInitUnpackers() { return kTRUE; }

    virtual Int_t CheckMaxEventNo(Int_t EvtEnd = 0);
    virtual void ReadBranchEvent(const char* BrName);
    virtual void ReadBranchEvent(const char* BrName, Int_t Entry);
    virtual void FillEventHeader(FairEventHeader* feh);

    const TFile* GetRootFile() { return fRootFile; }
    void AddFriend(TString FileName);
    void AddFile(TString FileName);
    void AddFriendsToChain();
    void PrintFriendList();
    Bool_t CompareBranchList(TFile* fileHandle, TString inputLevel);
    void CheckFriendChains();
    void CreateNewFriendChain(TString inputFile, TString inputLevel);
    TTree* GetInTree() { return fInChain->GetTree(); }
    TChain* GetInChain() { return fInChain; }
    TFile* GetInFile() { return fRootFile; }
    void CloseInFile()
    {
        if (fRootFile) {
            fRootFile->Close();
        }
    }
    void SetInTree(TTree* tempTree);
    TObjArray* GetListOfFolders() { return fListFolder; }
    TFolder* GetBranchDescriptionFolder() { return fCbmroot; }
    UInt_t GetEntries() { return fNoOfEntries; }

    //    TList*              GetBranchNameList() {return fBranchNameList;}

    void SetInputFile(TString name);

    void SetBeamTime(Double_t beamTime, Double_t gapTime);
    void SetEventTimeInterval(Double_t min, Double_t max);
    void SetEventMeanTime(Double_t mean);
    void SetEventTime();
    Double_t GetDeltaEventTime();
    void SetFileHeader(FairFileHeader* f) { fFileHeader = f; }
    Double_t GetEventTime();

    virtual Bool_t ActivateObject(TObject** obj, const char* BrName);
    virtual Bool_t ActivateObjectAny(void**, const std::type_info&, const char*);

    void SetEvtHeaderNew(Bool_t Status) { fEvtHeaderIsNew = Status; }
    Bool_t IsEvtHeaderNew() { return fEvtHeaderIsNew; }

    void SetCheckFileLayout(Bool_t enable) { fCheckFileLayout = enable; }

    Bool_t SpecifyRunId();

  private:
    TString fInputTitle;
    TFile* fRootFile;
    Int_t fCurrentEntryNr;   

    std::list<TString> fFriendFileList;                                 
    std::list<TString> fInputChainList;                                 
    std::map<TString, TChain*> fFriendTypeList;                         
    std::map<TString, std::list<TString>*> fCheckInputBranches;         
    std::list<TString> fInputLevel;                                     
    std::map<TString, std::multimap<TString, TArrayI>> fRunIdInfoAll;   

    TChain* fInChain;
    TTree* fInTree;
    TObjArray* fListFolder;   

    FairRuntimeDb* fRtdb;
    TFolder* fCbmout;
    TFolder* fCbmroot;
    /***/
    UInt_t fSourceIdentifier;
    UInt_t fNoOfEntries;
    Bool_t IsInitialized;

    FairFileSource(const FairFileSource&);
    FairFileSource operator=(const FairFileSource&);

    FairMCEventHeader* fMCHeader;   

    FairEventHeader* fEvtHeader;   

    FairFileHeader* fFileHeader;   

    Bool_t fEventTimeInMCHeader;   

    Bool_t fEvtHeaderIsNew;   

    UInt_t fCurrentEntryNo;   

    UInt_t fTimeforEntryNo;   

    Double_t fEventTimeMin;   

    Double_t fEventTimeMax;   

    Double_t fEventTime;   

    Double_t fBeamTime;   

    Double_t fGapTime;   

    Double_t fEventMeanTime;   

    TF1* fTimeProb;            

    Bool_t fCheckFileLayout;   

    ClassDef(FairFileSource, 3);
};

#endif /* defined(__FAIRROOT__FairFileSource__) */