FairMixedSource.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"                       *
 ********************************************************************************/
//
//  FairMixedSource.h
//  FAIRROOT
//
//  Created by Mohammad Al-Turany on 08/02/14.
//
//

#ifndef __FAIRROOT__FairMixedSource__
#define __FAIRROOT__FairMixedSource__

#include "FairSource.h"

#include <TArrayI.h>
#include <TChain.h>
#include <TF1.h>
#include <TFile.h>
#include <list>
#include <map>

class FairEventHeader;
class FairFileHeader;
class FairMCEventHeader;
class TString;
class FairRuntimeDb;
class TFolder;
class TObject;

class FairRootManager;

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

    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);
    void ReadBranchEvent(const char* BrName);
    void ReadBranchEvent(const char* BrName, Int_t Entry);

    void FillEventHeader(FairEventHeader* feh);

    const TFile* GetRootFile() { return fRootFile; }
    virtual Bool_t ActivateObject(TObject** obj, const char* BrName);

    virtual Bool_t ActivateObjectAny(void**, const std::type_info&, const char*);

    void ReadBKEvent(UInt_t i = 0);

    void SetSignalFile(TString name, UInt_t identifier);
    void SetBackgroundFile(TString name);
    void AddSignalFile(TString name, UInt_t identifier);
    void AddBackgroundFile(TString name);

    TChain* GetBGChain() { return fBackgroundChain; }
    TChain* GetSignalChainNo(UInt_t i);

    Bool_t OpenBackgroundChain();
    Bool_t OpenSignalChain();

    void BGWindowWidthNo(UInt_t background, UInt_t Signalid);
    void BGWindowWidthTime(Double_t background, UInt_t Signalid);

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

    Bool_t CompareBranchList(TFile* fileHandle, TString inputLevel);
    TObjArray* GetListOfFolders() { return fListFolder; }
    TFolder* GetBranchDescriptionFolder() { return fCbmroot; }
    UInt_t GetEntries() { return fNoOfEntries; }

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

    void UseRunIdFromBG();
    void UseRunIdfromSG(UInt_t identifier = 1);

  private:
    FairRootManager* fRootManager;

    TString fInputTitle;
    TFile* fRootFile;
    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;   

    TObjArray* fListFolder;   

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

    FairMCEventHeader* fMCHeader;   

    FairEventHeader* fEvtHeader;   

    FairEventHeader* fOutHeader;   

    FairFileHeader* fFileHeader;   

    Bool_t fEventTimeInMCHeader;   

    Bool_t fEvtHeaderIsNew;   

    UInt_t fCurrentEntryNo;   

    UInt_t fTimeforEntryNo;   
    /* /\**No of entries in BG Chain*\/ */
    UInt_t fNoOfBGEntries;   
    /* /\**Hold the current entry for each input chain*\/ */
    std::map<UInt_t, UInt_t> fCurrentEntry;   

    Double_t fEventTimeMin;   

    Double_t fEventTimeMax;   

    Double_t fEventTime;   

    Double_t fBeamTime;   

    Double_t fGapTime;   

    Double_t fEventMeanTime;   

    TF1* fTimeProb;   

    std::map<UInt_t, Double_t> fSignalBGN;   
    /* /\**True for background window in entry units*\/ */
    Bool_t fSBRatiobyN;   
    /* /\**True for background window in time units (ns) *\/ */
    Bool_t fSBRatiobyT;   

    UInt_t fActualSignalIdentifier;   

    UInt_t fNoOfSignals;   

    std::list<TString>* fSignalChainList;   

    TChain* fBackgroundChain;                    
    std::map<UInt_t, TChain*> fSignalTypeList;   

    Bool_t fRunIdFromBG;   

    Bool_t fRunIdFromSG;   

    UInt_t fRunIdFromSG_identifier;   

    Bool_t SpecifyRunId();

    FairMixedSource(const FairMixedSource&);
    FairMixedSource& operator=(const FairMixedSource&);

  public:
    ClassDef(FairMixedSource, 0);
};

#endif /* defined(__FAIRROOT__FairMixedSource__) */