/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/FWCore/Framework/interface/InputSource.h

Go to the documentation of this file.

#ifndef FWCore_Framework_InputSource_h
#define FWCore_Framework_InputSource_h

/*----------------------------------------------------------------------

InputSource: Abstract interface for all input sources. Input
sources are responsible for creating an EventPrincipal, using data
controlled by the source, and external to the EventPrincipal itself.

The InputSource is also responsible for dealing with the "process
name list" contained within the EventPrincipal. Each InputSource has
to know what "process" (HLT, PROD, USER, USER1, etc.) the program is
part of. The InputSource is repsonsible for pushing this process name
onto the end of the process name list.

For now, we specify this process name to the constructor of the
InputSource. This should be improved.

 Some questions about this remain:

   1. What should happen if we "rerun" a process? i.e., if "USER1" is
   already last in our input file, and we run again a job which claims
   to be "USER1", what should happen? For now, we just quietly add
   this to the history.

   2. Do we need to detect a problem with a history like:
         HLT PROD USER1 PROD
   or is it up to the user not to do something silly? Right now, there
   is no protection against such sillyness.

Some examples of InputSource subclasses may be:

 1) EmptySource: creates EventPrincipals which contain no EDProducts.
 2) PoolSource: creates EventPrincipals which "contain" the data
    read from a EDM/ROOT file. This source should provide for delayed loading
    of data, thus the quotation marks around contain.
 3) DAQSource: creats EventPrincipals which contain raw data, as
    delivered by the L1 trigger and event builder.

----------------------------------------------------------------------*/

#include "DataFormats/Provenance/interface/LuminosityBlockAuxiliary.h"
#include "DataFormats/Provenance/interface/LuminosityBlockID.h"
#include "DataFormats/Provenance/interface/ModuleDescription.h"
#include "DataFormats/Provenance/interface/RunAuxiliary.h"
#include "DataFormats/Provenance/interface/RunID.h"
#include "DataFormats/Provenance/interface/Timestamp.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/ProcessingController.h"
#include "FWCore/Framework/interface/ProductRegistryHelper.h"

#include "boost/shared_ptr.hpp"
#include "boost/utility.hpp"
#include "sigc++/signal.h"

#include <string>

namespace edm {
  class ActivityRegistry;
  class ConfigurationDescriptions;
  class ParameterSet;
  class ParameterSetDescription;
  namespace multicore {
    class MessageReceiverForSource;
  }

  class InputSource : private ProductRegistryHelper, private boost::noncopyable {
  public:
    enum ItemType {
      IsInvalid,
      IsStop,
      IsFile,
      IsRun,
      IsLumi,
      IsEvent,
      IsRepeat
    };

    enum ProcessingMode {
      Runs,
      RunsAndLumis,
      RunsLumisAndEvents
    };

    typedef ProductRegistryHelper::TypeLabelList TypeLabelList;
    explicit InputSource(ParameterSet const&, InputSourceDescription const&);

    virtual ~InputSource();

    static void fillDescriptions(ConfigurationDescriptions& descriptions);
    static const std::string& baseType();
    static void fillDescription(ParameterSetDescription& desc);

    ItemType nextItemType();

    EventPrincipal* readEvent(boost::shared_ptr<LuminosityBlockPrincipal> lbCache);

    EventPrincipal* readEvent(EventID const&);

    boost::shared_ptr<LuminosityBlockAuxiliary> readLuminosityBlockAuxiliary() {
      return readLuminosityBlockAuxiliary_();
    }

    boost::shared_ptr<RunAuxiliary> readRunAuxiliary() {return readRunAuxiliary_();}

    void readAndCacheRun();

    int markRun();

    void readAndCacheLumi();

    int markLumi();

    boost::shared_ptr<FileBlock> readFile();

    void closeFile(boost::shared_ptr<FileBlock>);

    void skipEvents(int offset);

    bool goToEvent(EventID const& eventID);

    void rewind() {
      doneReadAhead_ = false;
      state_ = IsInvalid;
      remainingEvents_ = maxEvents_;
      rewind_();
    }

    void wakeUp() {wakeUp_();}

    void setRunNumber(RunNumber_t r) {setRun(r);}

    void setLuminosityBlockNumber_t(LuminosityBlockNumber_t lb) {setLumi(lb);}

    void issueReports(EventID const& eventID);

    void registerProducts();

    boost::shared_ptr<ProductRegistry const> productRegistry() const {return productRegistry_;}

    void repeat() {
      remainingEvents_ = maxEvents_;
      remainingLumis_ = maxLumis_;
      doneReadAhead_ = false;
    }

    int maxEvents() const {return maxEvents_;}

    int remainingEvents() const {return remainingEvents_;}

    int maxLuminosityBlocks() const {return maxLumis_;}

    int remainingLuminosityBlocks() const {return remainingLumis_;}

    ModuleDescription const& moduleDescription() const {return moduleDescription_;}

    ProcessConfiguration const& processConfiguration() const {return moduleDescription().processConfiguration();}

    bool const primary() const {return primary_;}

    std::string const& processGUID() const {return processGUID_;}

    void doBeginJob();

    void doEndJob();

    void doBeginLumi(LuminosityBlockPrincipal& lbp);

    void doEndLumi(LuminosityBlockPrincipal& lbp);

    void doBeginRun(RunPrincipal& rp);

    void doEndRun(RunPrincipal& rp);

    void doPreForkReleaseResources();
    void doPostForkReacquireResources(boost::shared_ptr<multicore::MessageReceiverForSource>);

    Timestamp const& timestamp() const {return time_;}

    ProcessHistoryID const&  processHistoryID() const;

    RunNumber_t run() const;

    LuminosityBlockNumber_t luminosityBlock() const;

    ProcessingMode processingMode() const {return processingMode_;}

    boost::shared_ptr<ActivityRegistry> actReg() const {return actReg_;}

    boost::shared_ptr<RunAuxiliary> runAuxiliary() const {return runAuxiliary_;}

    boost::shared_ptr<LuminosityBlockAuxiliary> luminosityBlockAuxiliary() const {return lumiAuxiliary_;}

    bool randomAccess() const { return randomAccess_(); }
    ProcessingController::ForwardState forwardState() const { return forwardState_(); }
    ProcessingController::ReverseState reverseState() const { return reverseState_(); }

    using ProductRegistryHelper::produces;
    using ProductRegistryHelper::typeLabelList;

    class SourceSentry : private boost::noncopyable {
    public:
      typedef sigc::signal<void> Sig;
      SourceSentry(Sig& pre, Sig& post);
      ~SourceSentry();
    private:
      Sig& post_;
    };

    class EventSourceSentry {
    public:
      explicit EventSourceSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class LumiSourceSentry {
    public:
      explicit LumiSourceSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class RunSourceSentry {
    public:
      explicit RunSourceSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class FileOpenSentry {
    public:
      explicit FileOpenSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

    class FileCloseSentry {
    public:
      explicit FileCloseSentry(InputSource const& source);
    private:
      SourceSentry sentry_;
    };

  protected:
    void setTimestamp(Timestamp const& theTime) {time_ = theTime;}

    ProductRegistry& productRegistryUpdate() const {return const_cast<ProductRegistry&>(*productRegistry_);}
    ItemType state() const{return state_;}
    void setRunAuxiliary(RunAuxiliary* rp) {runAuxiliary_.reset(rp);}
    void setLuminosityBlockAuxiliary(LuminosityBlockAuxiliary* lbp) {lumiAuxiliary_.reset(lbp);}
    void resetRunAuxiliary() const {
      runAuxiliary_.reset();
    }
    void resetLuminosityBlockAuxiliary() const {
      lumiAuxiliary_.reset();
    }
    void reset() const {
      resetLuminosityBlockAuxiliary();
      resetRunAuxiliary();
      doneReadAhead_ = false;
      state_ = IsInvalid;
    }
    EventPrincipal* const eventPrincipalCache();
    PrincipalCache const& principalCache() const {return *principalCache_;}
    PrincipalCache& principalCache() {return *principalCache_;}
    boost::shared_ptr<LuminosityBlockPrincipal> const luminosityBlockPrincipal() const;
    boost::shared_ptr<RunPrincipal> const runPrincipal() const;

    void setRunPrematurelyRead() {runPrematurelyRead_ = true;}
    void setLumiPrematurelyRead() {lumiPrematurelyRead_ = true;}

    void decreaseRemainingEventsBy(int iSkipped);

  private:
    bool eventLimitReached() const {return remainingEvents_ == 0;}
    bool lumiLimitReached() const {return remainingLumis_ == 0;}
    bool limitReached() const {return eventLimitReached() || lumiLimitReached();}
    virtual ItemType getNextItemType() = 0;
    ItemType nextItemType_();
    virtual boost::shared_ptr<RunAuxiliary> readRunAuxiliary_() = 0;
    virtual boost::shared_ptr<LuminosityBlockAuxiliary> readLuminosityBlockAuxiliary_() = 0;
    virtual boost::shared_ptr<RunPrincipal> readRun_(boost::shared_ptr<RunPrincipal> rpCache);
    virtual boost::shared_ptr<LuminosityBlockPrincipal> readLuminosityBlock_(
        boost::shared_ptr<LuminosityBlockPrincipal> lbCache);
    virtual EventPrincipal* readEvent_() = 0;
    virtual EventPrincipal* readIt(EventID const&);
    virtual boost::shared_ptr<FileBlock> readFile_();
    virtual void closeFile_() {}
    virtual void skip(int);
    virtual bool goToEvent_(EventID const& eventID);
    virtual void setRun(RunNumber_t r);
    virtual void setLumi(LuminosityBlockNumber_t lb);
    virtual void rewind_();
    virtual void wakeUp_();
    void postRead(Event& event);
    virtual void beginLuminosityBlock(LuminosityBlock&);
    virtual void endLuminosityBlock(LuminosityBlock&);
    virtual void beginRun(Run&);
    virtual void endRun(Run&);
    virtual void beginJob();
    virtual void endJob();
    virtual void preForkReleaseResources();
     virtual void postForkReacquireResources(boost::shared_ptr<multicore::MessageReceiverForSource>);
    virtual bool randomAccess_() const;
    virtual ProcessingController::ForwardState forwardState_() const;
    virtual ProcessingController::ReverseState reverseState_() const;

  private:

    boost::shared_ptr<ActivityRegistry> actReg_;
    PrincipalCache* principalCache_;
    int maxEvents_;
    int remainingEvents_;
    int maxLumis_;
    int remainingLumis_;
    int readCount_;
    ProcessingMode processingMode_;
    ModuleDescription const moduleDescription_;
    boost::shared_ptr<ProductRegistry const> productRegistry_;
    bool const primary_;
    std::string processGUID_;
    Timestamp time_;
    mutable bool doneReadAhead_;
    mutable ItemType state_;
    mutable boost::shared_ptr<RunAuxiliary> runAuxiliary_;
    mutable boost::shared_ptr<LuminosityBlockAuxiliary>  lumiAuxiliary_;
    bool runPrematurelyRead_;
    bool lumiPrematurelyRead_;
    std::string statusFileName_;
  };
}

#endif