1 #define TRACE_NAME "BoardReaderApp"
3 #include "artdaq/Application/BoardReaderApp.hh"
6 : fragment_receiver_ptr_(nullptr)
19 external_request_status_ =
true;
25 TLOG_DEBUG(app_name +
"App") <<
"Initializing first deleting old instance " << (
void*)fragment_receiver_ptr_.get() << TLOG_ENDL;
26 fragment_receiver_ptr_.reset(
nullptr);
28 TLOG_DEBUG(app_name +
"App") <<
"Initializing new BoardReaderCore at " << (
void*)fragment_receiver_ptr_.get() <<
" with pset " << pset.to_string() << TLOG_ENDL;
29 external_request_status_ = fragment_receiver_ptr_->initialize(pset, timeout, timestamp);
30 if (! external_request_status_)
32 report_string_ =
"Error initializing ";
33 report_string_.append(app_name +
" ");
34 report_string_.append(
"with ParameterSet = \"" + pset.to_string() +
"\".");
37 TLOG_DEBUG(app_name +
"App") <<
"do_initialize(fhicl::ParameterSet, uint64_t, uint64_t): "
38 <<
"Done initializing." << TLOG_ENDL;
39 return external_request_status_;
45 external_request_status_ = fragment_receiver_ptr_->start(
id, timeout, timestamp);
46 if (! external_request_status_)
48 report_string_ =
"Error starting ";
49 report_string_.append(app_name +
" ");
50 report_string_.append(
"for run number ");
51 report_string_.append(boost::lexical_cast<std::string>(
id.run()));
52 report_string_.append(
", timeout ");
53 report_string_.append(boost::lexical_cast<std::string>(timeout));
54 report_string_.append(
", timestamp ");
55 report_string_.append(boost::lexical_cast<std::string>(timestamp));
56 report_string_.append(
".");
59 boost::thread::attributes attrs;
60 attrs.set_stack_size(4096 * 2000);
67 return external_request_status_;
73 external_request_status_ = fragment_receiver_ptr_->stop(timeout, timestamp);
74 if (! external_request_status_)
76 report_string_ =
"Error stopping ";
77 report_string_.append(app_name +
".");
81 int number_of_fragments_sent = fragment_receiver_ptr_->GetFragmentsProcessed();
82 TLOG_DEBUG(app_name +
"App") <<
"do_stop(uint64_t, uint64_t): "
83 <<
"Number of fragments sent = " << number_of_fragments_sent
86 return external_request_status_;
92 external_request_status_ = fragment_receiver_ptr_->pause(timeout, timestamp);
93 if (! external_request_status_)
95 report_string_ =
"Error pausing ";
96 report_string_.append(app_name +
".");
99 int number_of_fragments_sent = fragment_receiver_ptr_->GetFragmentsProcessed();
100 TLOG_DEBUG(app_name +
"App") <<
"do_pause(uint64_t, uint64_t): "
101 <<
"Number of fragments sent = " << number_of_fragments_sent
104 return external_request_status_;
110 external_request_status_ = fragment_receiver_ptr_->resume(timeout, timestamp);
111 if (! external_request_status_)
113 report_string_ =
"Error resuming ";
114 report_string_.append(app_name +
".");
117 boost::thread::attributes attrs;
118 attrs.set_stack_size(4096 * 2000);
125 return external_request_status_;
131 external_request_status_ = fragment_receiver_ptr_->shutdown(timeout);
132 if (! external_request_status_)
134 report_string_ =
"Error shutting down ";
135 report_string_.append(app_name +
".");
137 return external_request_status_;
143 external_request_status_ = fragment_receiver_ptr_->soft_initialize(pset, timeout, timestamp);
144 if (! external_request_status_)
146 report_string_ =
"Error soft-initializing ";
147 report_string_.append(app_name +
" ");
148 report_string_.append(
"with ParameterSet = \"" + pset.to_string() +
"\".");
150 return external_request_status_;
155 external_request_status_ = fragment_receiver_ptr_->reinitialize(pset, timeout, timestamp);
156 if (! external_request_status_)
158 report_string_ =
"Error reinitializing ";
159 report_string_.append(app_name +
" ");
160 report_string_.append(
"with ParameterSet = \"" + pset.to_string() +
"\".");
162 return external_request_status_;
167 TLOG_DEBUG(app_name +
"App") <<
"Booted state entry action called." << TLOG_ENDL;
173 fragment_receiver_ptr_.reset(
nullptr);
178 external_request_status_ = fragment_receiver_ptr_->metaCommand(command, arg);
179 if (!external_request_status_)
181 report_string_ =
"Error running meta-command on ";
182 report_string_.append(app_name +
" ");
183 report_string_.append(
"with command = \"" + command +
"\", arg = \"" + arg +
"\".");
185 return external_request_status_;
190 std::string resultString;
193 if (which ==
"transition_status")
195 if (report_string_.length() > 0) {
return report_string_; }
196 else {
return "Success"; }
208 if (fragment_receiver_ptr_.get() != 0)
210 resultString.append(fragment_receiver_ptr_->report(which));
214 resultString.append(
"This BoardReader has not yet been initialized and ");
215 resultString.append(
"therefore can not provide reporting.");
bool do_soft_initialize(fhicl::ParameterSet const &pset, uint64_t timeout, uint64_t timestamp) override
Soft-Initialize the BoardReaderCore.
bool do_resume(uint64_t timeout, uint64_t timestamp) override
Resume the BoardReaderCore.
bool do_stop(uint64_t timeout, uint64_t timestamp) override
Stop the BoardReaderCore.
BoardReaderCore implements the state machine for the BoardReader artdaq application. It contains a CommandableFragmentGenerator, which generates Fragments which are then sent to a DataSenderManager by BoardReaderCore.
bool do_meta_command(std::string const &command, std::string const &arg) override
Perform a user-defined command (passed to CommandableFragmentGenerator)
bool do_shutdown(uint64_t timeout) override
Shutdown the BoardReaderCore.
bool do_reinitialize(fhicl::ParameterSet const &pset, uint64_t timeout, uint64_t timestamp) override
Reinitialize the BoardReaderCore.
std::string report(std::string const &which) const override
If which is "transition_status", report the status of the last transition. Otherwise pass through to ...
void BootedEnter() override
Action taken upon entering the "Booted" state.
void process_fragments()
Main working loop of the BoardReaderCore.
bool do_start(art::RunID id, uint64_t timeout, uint64_t timestamp) override
Start the BoardReaderCore.
BoardReaderApp(int rank, std::string name)
BoardReaderApp Constructor.
bool do_initialize(fhicl::ParameterSet const &pset, uint64_t timeout, uint64_t timestamp) override
Initialize the BoardReaderCore.
bool do_pause(uint64_t timeout, uint64_t timestamp) override
Pause the BoardReaderCore.