Bugfix: Factory parameters show up in parameters table

src/libraries/JANA/JApplication.cc

@@ -126,11 +126,14 @@ void JApplication::Initialize() {
     plugin_loader->attach_plugins(component_manager.get());
 
     // Give all components a JApplication pointer and a logger
-    component_manager->configure_components();
+    component_manager->preinitialize_components();
 
     // Resolve all event sources now that all plugins have been loaded
     component_manager->resolve_event_sources();
 
+    // Call Init() for all factories/multifactories. This populates the ParameterManager
+    component_manager->initialize_factories();
+
     // Set desired nthreads. We parse the 'nthreads' parameter two different ways for backwards compatibility.
     m_desired_nthreads = 1;
     m_params->SetDefaultParameter("nthreads", m_desired_nthreads, "Desired number of worker threads, or 'Ncores' to use all available cores.");

src/libraries/JANA/JEventSource.h

@@ -42,6 +42,10 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
     virtual ~JEventSource() = default;
 
 
+    // `Init` is where the user requests parameters and services. If the user requests all parameters and services here,
+    // JANA can report them back to the user without having to open the resource and run the topology.
+
+    virtual void Init() {}
 
     // To be implemented by the user
     /// `Open` is called by JANA when it is ready to accept events from this event source. The implementor should open
@@ -112,78 +116,98 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
     }
 
 
-    // Wrappers for calling Open and GetEvent in a safe way
+    virtual void DoInit() {
+        if (m_status == Status::Uninitialized) {
+            CallWithJExceptionWrapper("JEventSource::Init", [&](){ Init();});
+            m_status = Status::Initialized;
+            LOG_INFO(GetLogger()) << "Initialized JEventSource '" << GetTypeName() << "' ('" << GetResourceName() << "')" << LOG_END;
+        }
+        else {
+            throw JException("Attempted to initialize a JEventSource that is not uninitialized!");
+        }
+    }
 
-    virtual void DoInitialize(bool with_lock=true) {
+    virtual void DoOpen(bool with_lock=true) {
         if (with_lock) {
             std::lock_guard<std::mutex> lock(m_mutex);
-            if (m_status == Status::Uninitialized) {
-                CallWithJExceptionWrapper("JEventSource::Open", [&](){ Open();});
-                if (GetResourceName().empty()) {
-                    LOG_INFO(GetLogger()) << "Opened event source" << LOG_END;
-                }
-                else {
-                    LOG_INFO(GetLogger()) << "Opened event source '" << GetResourceName() << "'" << LOG_END;
-                }
-                m_status = Status::Initialized;
+            if (m_status != Status::Initialized) {
+                throw JException("Attempted to open a JEventSource that hasn't been initialized!");
             }
+            CallWithJExceptionWrapper("JEventSource::Open", [&](){ Open();});
+            if (GetResourceName().empty()) {
+                LOG_INFO(GetLogger()) << "Opened JEventSource '" << GetTypeName() << "'" << LOG_END;
+            }
+            else {
+                LOG_INFO(GetLogger()) << "Opened JEventSource '" << GetTypeName() << "' ('" << GetResourceName() << "')" << LOG_END;
+            }
+            m_status = Status::Opened;
         }
         else {
-            if (m_status == Status::Uninitialized) {
-                CallWithJExceptionWrapper("JEventSource::Open", [&](){ Open();});
-                if (GetResourceName().empty()) {
-                    LOG_INFO(GetLogger()) << "Opened event source" << LOG_END;
-                }
-                else {
-                    LOG_INFO(GetLogger()) << "Opened event source '" << GetResourceName() << "'" << LOG_END;
-                }
-                m_status = Status::Initialized;
+            if (m_status != Status::Initialized) {
+                throw JException("Attempted to open a JEventSource that hasn't been initialized!");
             }
+            CallWithJExceptionWrapper("JEventSource::Open", [&](){ Open();});
+            if (GetResourceName().empty()) {
+                LOG_INFO(GetLogger()) << "Opened JEventSource '" << GetTypeName() << "'" << LOG_END;
+            }
+            else {
+                LOG_INFO(GetLogger()) << "Opened JEventSource '" << GetTypeName() << "' ('" << GetResourceName() << "')" << LOG_END;
+            }
+            m_status = Status::Opened;
         }
     }
 
-    virtual void DoFinalize(bool with_lock=true) {
+    virtual void DoClose(bool with_lock=true) {
         if (with_lock) {
             std::lock_guard<std::mutex> lock(m_mutex);
+
+            if (m_status != JEventSource::Status::Opened) return;
+
             CallWithJExceptionWrapper("JEventSource::Close", [&](){ Close();});
             if (GetResourceName().empty()) {
-                LOG_INFO(GetLogger()) << "Closed event source" << LOG_END;
+                LOG_INFO(GetLogger()) << "Closed JEventSource '" << GetTypeName() << "'" << LOG_END;
             }
             else {
-                LOG_INFO(GetLogger()) << "Closed event source '" << GetResourceName() << "'" << LOG_END;
+                LOG_INFO(GetLogger()) << "Closed JEventSource '" << GetTypeName() << "' ('" << GetResourceName() << "')" << LOG_END;
             }
-            m_status = Status::Finalized;
+            m_status = Status::Closed;
         }
         else {
+            if (m_status != JEventSource::Status::Opened) return;
+
             CallWithJExceptionWrapper("JEventSource::Close", [&](){ Close();});
             if (GetResourceName().empty()) {
-                LOG_INFO(GetLogger()) << "Closed event source" << LOG_END;
+                LOG_INFO(GetLogger()) << "Closed JEventSource '" << GetTypeName() << "'" << LOG_END;
             }
             else {
-                LOG_INFO(GetLogger()) << "Closed event source '" << GetResourceName() << "'" << LOG_END;
+                LOG_INFO(GetLogger()) << "Closed JEventSource '" << GetTypeName() << "' ('" << GetResourceName() << "')" << LOG_END;
             }
-            m_status = Status::Finalized;
+            m_status = Status::Closed;
         }
     }
 
     Result DoNext(std::shared_ptr<JEvent> event) {
 
         std::lock_guard<std::mutex> lock(m_mutex); // In general, DoNext must be synchronized.
 
+        if (m_status == Status::Uninitialized) {
+            throw JException("JEventSource has not been initialized!");
+        }
+
         if (m_callback_style == CallbackStyle::LegacyMode) {
             return DoNextCompatibility(event);
         }
 
         auto first_evt_nr = m_nskip;
         auto last_evt_nr = m_nevents + m_nskip;
 
-        if (m_status == Status::Uninitialized) {
-            DoInitialize(false);
-        }
         if (m_status == Status::Initialized) {
+            DoOpen(false);
+        }
+        if (m_status == Status::Opened) {
             if (m_nevents != 0 && (m_event_count == last_evt_nr)) {
                 // We exit early (and recycle) because we hit our jana:nevents limit
-                DoFinalize(false);
+                DoClose(false);
                 return Result::FailureFinished;
             }
             // If we reach this point, we will need to actually read an event
@@ -219,7 +243,7 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
             else if (result == Result::FailureFinished) {
                 // We end up here if we tried to read an entry in a file, but found EOF
                 // or if we received a message from a socket that contained no data and indicated no more data will be coming
-                DoFinalize(false);
+                DoClose(false);
                 return Result::FailureFinished;
             }
             else if (result == Result::FailureTryAgain) {
@@ -231,7 +255,7 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
                 throw JException("Invalid JEventSource::Result value!");
             }
         }
-        else { // status == Finalized
+        else { // status == Closed
             return Result::FailureFinished;
         }
     }
@@ -242,10 +266,10 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
         auto last_evt_nr = m_nevents + m_nskip;
 
         try {
-            if (m_status == Status::Uninitialized) {
-                DoInitialize(false);
-            }
             if (m_status == Status::Initialized) {
+                DoOpen(false);
+            }
+            if (m_status == Status::Opened) {
                 if (m_event_count < first_evt_nr) {
                     // Skip these events due to nskip
                     event->SetEventNumber(m_event_count); // Default event number to event count
@@ -258,7 +282,7 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
                     return Result::FailureTryAgain;  // Reject this event and recycle it
                 } else if (m_nevents != 0 && (m_event_count == last_evt_nr)) {
                     // Declare ourselves finished due to nevents
-                    DoFinalize(false); // Close out the event source as soon as it declares itself finished
+                    DoClose(false); // Close out the event source as soon as it declares itself finished
                     return Result::FailureFinished;
                 } else {
                     // Actually emit an event.
@@ -279,7 +303,7 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
                     m_event_count += 1;
                     return Result::Success; // Don't reject this event!
                 }
-            } else if (m_status == Status::Finalized) {
+            } else if (m_status == Status::Closed) {
                 return Result::FailureFinished;
             } else {
                 throw JException("Invalid m_status");
@@ -288,7 +312,7 @@ class JEventSource : public jana::omni::JComponent, public jana::omni::JHasOutpu
         catch (RETURN_STATUS rs) {
 
             if (rs == RETURN_STATUS::kNO_MORE_EVENTS) {
-                DoFinalize(false);
+                DoClose(false);
                 return Result::FailureFinished;
             }
             else if (rs == RETURN_STATUS::kTRY_AGAIN || rs == RETURN_STATUS::kBUSY) {

src/libraries/JANA/JFactory.cc

@@ -9,10 +9,6 @@
 
 void JFactory::Create(const std::shared_ptr<const JEvent>& event) {
 
-    // We need this for JMultifactoryHelper. Eventually it should go away
-    auto app = event->GetJApplication();
-    if (app != nullptr) SetApplication(app);
-
     if (mStatus == Status::Uninitialized) {
         CallWithJExceptionWrapper("JFactory::Init", [&](){ Init(); });
         mStatus = Status::Unprocessed;
@@ -43,3 +39,13 @@ void JFactory::Create(const std::shared_ptr<const JEvent>& event) {
         mCreationStatus = CreationStatus::Created;
     }
 }
+
+void JFactory::DoInit() {
+    if (GetApplication() == nullptr) {
+        throw JException("JFactory::DoInit(): Null JApplication pointer");
+    }
+    if (mStatus == Status::Uninitialized) {
+        CallWithJExceptionWrapper("JFactory::Init", [&](){ Init(); });
+        mStatus = Status::Unprocessed;
+    }
+}

src/libraries/JANA/JFactory.h

@@ -168,10 +168,13 @@ class JFactory : public jana::omni::JComponent {
     template<typename S>
     std::vector<S*> GetAs();
 
+
+
     /// Create() calls JFactory::Init,BeginRun,Process in an invariant-preserving way without knowing the exact
-    /// type of object contained. It returns the number of objects created. In order to access said objects,
-    /// use JFactory::GetAs().
+    /// type of object contained. In order to access these objects when all you have is a JFactory*, use JFactory::GetAs().
     virtual void Create(const std::shared_ptr<const JEvent>& event);
+    void DoInit();
+
 
     virtual void Set(const std::vector<JObject *> &data) = 0;
     virtual void Insert(JObject *data) = 0;

src/libraries/JANA/JFactorySet.cc

@@ -105,6 +105,7 @@ bool JFactorySet::Add(JMultifactory *multifactory) {
 
     auto helpers = multifactory->GetHelpers();
     for (auto fac : helpers->GetAllFactories()) {
+        fac->SetApplication(multifactory->GetApplication());
         Add(fac);
     }
     helpers->mIsFactoryOwner = false;
@@ -142,6 +143,16 @@ std::vector<JFactory*> JFactorySet::GetAllFactories() const {
     return results;
 }
 
+//---------------------------------
+// GetAllMultifactories
+//---------------------------------
+std::vector<JMultifactory*> JFactorySet::GetAllMultifactories() const {
+    std::vector<JMultifactory*> results;
+    for (auto f : mMultifactories) {
+        results.push_back(f);
+    }
+    return results;
+}
 
 //---------------------------------
 // Merge

src/libraries/JANA/JFactorySet.h

@@ -35,6 +35,7 @@ class JFactorySet : public JResettable
         JFactory* GetFactory(const std::string& object_name, const std::string& tag="") const;
         template<typename T> JFactoryT<T>* GetFactory(const std::string& tag = "") const;
         std::vector<JFactory*> GetAllFactories() const;
+        std::vector<JMultifactory*> GetAllMultifactories() const;
         template<typename T> std::vector<JFactoryT<T>*> GetAllFactories() const;
 
         std::vector<JFactorySummary> Summarize() const;

src/libraries/JANA/JMultifactory.cc

@@ -63,3 +63,15 @@ JFactorySet* JMultifactory::GetHelpers() {
     return &mHelpers;
 }
 
+void JMultifactory::DoInit() {
+
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_status == Status::Uninitialized) {
+        CallWithJExceptionWrapper("JMultifactory::Init", [&](){
+            Init();
+        });
+        m_status = Status::Initialized;
+    }
+}
+
+

src/libraries/JANA/JMultifactory.h

@@ -111,6 +111,8 @@ class JMultifactory : public jana::omni::JComponent,
 #endif
 
     /// CALLED BY JANA
+
+    void DoInit();
 
     void Execute(const std::shared_ptr<const JEvent>&);
     // Should this be execute or create? Who is tracking that this is called at most once per event?

src/libraries/JANA/Omni/JComponentFwd.h

@@ -20,7 +20,7 @@ namespace omni {
 
 
 struct JComponent {
-    enum class Status { Uninitialized, Initialized, Finalized };
+    enum class Status { Uninitialized, Initialized, Opened, Closed, Finalized };
     enum class CallbackStyle { LegacyMode, ExpertMode, DeclarativeMode };
 
     struct ParameterBase;

src/libraries/JANA/Services/JComponentManager.cc

@@ -46,7 +46,7 @@ void JComponentManager::Init() {
     }
 }
 
-void JComponentManager::configure_components() {
+void JComponentManager::preinitialize_components() {
     for (auto* src : m_evt_srces) {
         src->SetApplication(GetApplication());
         src->SetLogger(m_logging->get_logger(src->GetLoggerName()));
@@ -69,6 +69,13 @@ void JComponentManager::configure_components() {
     }
 }
 
+void JComponentManager::initialize_factories() {
+    JFactorySet dummy_fac_set(m_fac_gens);
+    for (auto* fac : dummy_fac_set.GetAllFactories()) {
+        fac->DoInit();
+    }
+}
+
 void JComponentManager::next_plugin(std::string plugin_name) {
     // We defer resolving event sources until we have finished loading all plugins
     m_current_plugin_name = plugin_name;

src/libraries/JANA/Services/JComponentManager.h

@@ -31,8 +31,9 @@ class JComponentManager : public JService {
     void add(JEventProcessor* processor);
     void add(JEventUnfolder* unfolder);
 
-    void configure_components();
+    void preinitialize_components();
     void resolve_event_sources();
+    void initialize_factories();
     JEventSourceGenerator* resolve_user_event_source_generator() const;
     JEventSourceGenerator* resolve_event_source(std::string source_name) const;
 

src/libraries/JANA/Topology/JEventSourceArrow.cc

@@ -53,17 +53,17 @@ void JEventSourceArrow::process(Event* event, bool& success, JArrowMetrics::Stat
 }
 
 void JEventSourceArrow::initialize() {
-    // Initialization of individual sources happens on-demand, in order to keep us from having lots of open files
+    // We initialize everything immediately, but don't open any resources until we absolutely have to; see process(): source->DoNext()
+    for (JEventSource* source : m_sources) {
+        source->DoInit();
+    }
 }
 
 void JEventSourceArrow::finalize() {
     // Generally JEventSources finalize themselves as soon as they detect that they have run out of events.
     // However, we can't rely on the JEventSources turning themselves off since execution can be externally paused.
     // Instead we leave everything open until we finalize the whole topology, and finalize remaining event sources then.
     for (JEventSource* source : m_sources) {
-        if (source->GetStatus() == JEventSource::Status::Initialized) {
-            LOG_INFO(m_logger) << "Finalizing JEventSource '" << source->GetTypeName() << "' (" << source->GetResourceName() << ")" << LOG_END;
-            source->DoFinalize();
-        }
+        source->DoClose();
     }
 }