LDMX Software
Public Member Functions | Private Attributes | List of all members
trigscint::QIEAnalyzer Class Reference

Public Member Functions

 QIEAnalyzer (const std::string &name, framework::Process &process)
 
void configure (framework::config::Parameters &parameters) override
 Callback for the EventProcessor to configure itself from the given set of parameters.
 
void analyze (const framework::Event &event) override
 Process the event and make histograms or summaries.
 
void onProcessStart () override
 Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.
 
void onProcessEnd () override
 Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.
 
float convertToID (float yVal)
 
- Public Member Functions inherited from framework::Analyzer
 Analyzer (const std::string &name, Process &process)
 Class constructor.
 
virtual void process (Event &event) final
 Processing an event for an Analyzer is calling analyze.
 
virtual void beforeNewRun (ldmx::RunHeader &run_header) final
 Don't allow Analyzers to add parameters to the run header.
 
- Public Member Functions inherited from framework::EventProcessor
 DECLARE_FACTORY (EventProcessor, EventProcessor *, const std::string &, Process &)
 declare that we have a factory for this class
 
 EventProcessor (const std::string &name, Process &process)
 Class constructor.
 
virtual ~EventProcessor ()=default
 Class destructor.
 
virtual void onNewRun (const ldmx::RunHeader &run_header)
 Callback for the EventProcessor to take any necessary action when the run being processed changes.
 
virtual void onFileOpen (EventFile &event_file)
 Callback for the EventProcessor to take any necessary action when a new event input ROOT file is opened.
 
virtual void onFileClose (EventFile &event_file)
 Callback for the EventProcessor to take any necessary action when a event input ROOT file is closed.
 
template<class T >
const T & getCondition (const std::string &condition_name)
 Access a conditions object for the current event.
 
TDirectory * getHistoDirectory ()
 Access/create a directory in the histogram file for this event processor to create histograms and analysis tuples.
 
void setStorageHint (framework::StorageControl::Hint hint)
 Mark the current event as having the given storage control hint from this module_.
 
void setStorageHint (framework::StorageControl::Hint hint, const std::string &purposeString)
 Mark the current event as having the given storage control hint from this module and the given purpose string.
 
int getLogFrequency () const
 Get the current logging frequency from the process.
 
int getRunNumber () const
 Get the run number from the process.
 
std::string getName () const
 Get the processor name.
 
void createHistograms (const std::vector< framework::config::Parameters > &histos)
 Internal function which is used to create histograms passed from the python configuration @parma histos vector of Parameters that configure histograms to create.
 

Private Attributes

std::vector< std::vector< TH1F * > > v_charge_vs_time_
 
std::string input_col_
 
std::string input_pass_name_ {""}
 
std::vector< double > peds_
 
std::vector< double > gain_
 
int start_sample_ {0}
 
int n_ev_ {200}
 
int n_ev_tdc_ {200}
 
int n_channels_ {24}
 
TH1F * h_out_ [200][24] {}
 
TH1F * h_pe_ [24]
 
TH2F * h_pe_vs_t_ [24]
 
TH2F * h_ped_subtracted_avg_q_vs_t_ [24]
 
TH2F * h_ped_subtracted_tot_q_vs_ped_ [24]
 
TH2F * h_ped_subtracted_tot_q_vs_n_ [24]
 
TH2F * h_tot_q_vs_ped_ [24]
 
TH2F * h_ped_subtracted_pe_vs_n_ [24]
 
TH2F * h_ped_subtracted_pe_vs_t_ [24]
 
TH2F * h_avg_q_vs_t_ [24]
 
TH2F * h_tdc_fire_chan_vs_event_
 
double y_offset_ {35.}
 
double y_to_id_factor_ {50. / 80.}
 

Additional Inherited Members

- Protected Member Functions inherited from framework::EventProcessor
void abortEvent ()
 Abort the event immediately.
 
- Protected Attributes inherited from framework::EventProcessor
HistogramPool histograms_
 helper object for making and filling histograms
 
NtupleManager & ntuple_ {NtupleManager::getInstance()}
 Manager for any ntuples.
 
logging::logger the_log_
 The logger for this EventProcessor.
 

Detailed Description

Definition at line 23 of file QIEAnalyzer.h.

Constructor & Destructor Documentation

◆ QIEAnalyzer()

trigscint::QIEAnalyzer::QIEAnalyzer ( const std::string & name,
framework::Process & process )

Definition at line 14 of file QIEAnalyzer.cxx.

15 : Analyzer(name, process) {}
framework::Analyzer::process
virtual void process(Event &event) final
Processing an event for an Analyzer is calling analyze.
Definition EventProcessor.h:316
framework::Analyzer::Analyzer
Analyzer(const std::string &name, Process &process)
Class constructor.
Definition EventProcessor.cxx:57

Member Function Documentation

◆ analyze()

void trigscint::QIEAnalyzer::analyze ( const framework::Event & event)
overridevirtual

Process the event and make histograms or summaries.

Parameters
eventThe Event to analyze

Implements framework::Analyzer.

Definition at line 36 of file QIEAnalyzer.cxx.

36 {
37 const auto channels{event.getCollection<trigscint::EventReadout>(
38 input_col_, input_pass_name_)};
39
40 int ev_nb = event.getEventNumber();
41 // while (evNb < 0 ) {
42 // ldmx_log(debug) << "event number = " << evNb << " < 0; incrementing event
43 // number "; evNb++;
44 //}
45 int num_chan = channels.size();
46 ldmx_log(debug) << "in event " << ev_nb << "; num_channels = " << num_chan;
47
48 for (auto chan : channels) {
49 std::vector<float> q = chan.getQ();
50 std::vector<float> q_err = chan.getQError();
51 std::vector<int> tdc = chan.getTDC();
52 // int nTimeSamp = q.size();
53 int bar = chan.getChanID();
54 float q_tot = 0;
55 float q_ped_subtracted_avg = 0;
56 int first_t = start_sample_ - 1;
57 int n_samp_above = 0;
58 int n_samp_above_event_ped = 0;
59 float subtr_pe = 0;
60 float subtr_q = 0;
61 float ped = chan.getPedestal();
62 for (int i_t = 0; i_t < q.size(); i_t++) {
63 ldmx_log(debug) << "in event " << ev_nb << "; channel " << bar
64 << ", got charge[" << i_t << "] = " << q.at(i_t);
65 if (ev_nb < n_ev_tdc_ && bar < n_channels_) {
66 // stick within the predefined histogram array
67 const bool display{ev_nb < n_ev_};
68 // h_out_[evNb][bar]->Fill(iT+start_sample_, q.at(iT));
69 if (display) {
70 h_out_[ev_nb][bar]->SetBinContent(i_t + start_sample_, q.at(i_t));
71 h_out_[ev_nb][bar]->SetBinError(i_t + start_sample_,
72 fabs(q_err.at(i_t)));
73 }
74 if (tdc.at(i_t) < 63) {
75 ldmx_log(info) << "Found fired TDC = " << tdc.at(i_t)
76 << " at time sample " << i_t << " in channel " << bar
77 << " and event " << ev_nb;
78 // for some reason, the style settings are washed out later...
79 if (display) {
80 h_out_[ev_nb][bar]->SetLineColor(kRed + 1);
81 h_out_[ev_nb][bar]->SetMarkerColor(
82 h_out_[ev_nb][bar]->GetLineColor());
83 h_out_[ev_nb][bar]->SetMarkerSize(0.2);
84 }
85
86 if (i_t + start_sample_ > 0)
87 h_tdc_fire_chan_vs_event_->Fill(bar, ev_nb, i_t + start_sample_);
88 else
89 h_tdc_fire_chan_vs_event_->Fill(bar, ev_nb);
90 }
91 } // if within the number of events to plot individually
92 if (q.at(i_t) > 2 * fabs(peds_[bar])) {
93 // integrate all charge well above
94 // ped to convert to a PE count
95 q_tot += q.at(i_t);
96 q_ped_subtracted_avg += q.at(i_t) - chan.getPedestal();
97 // peds_[ bar ];
98 n_samp_above++;
99 ldmx_log(debug) << " above channel overall pedestal: " << q.at(i_t)
100 << " > " << 2 * fabs(peds_[bar]);
101
102 // keep track of first time sample above threshold
103 if (first_t == start_sample_ - 1) first_t = start_sample_ + i_t;
104 } // if above threshold
105 if (q.at(i_t) > ped) {
106 subtr_q += q.at(i_t) - peds_[bar];
107 n_samp_above_event_ped++;
108 ldmx_log(debug) << " above channel event pedestal: " << q.at(i_t)
109 << " > " << ped;
110 } // if above channel event pedestal
111 } // over time samples
112 float pe = q_tot * 6250. / gain_[bar];
113 subtr_pe = subtr_q * 6250. / gain_[bar];
114 h_tot_q_vs_ped_[bar]->Fill(ped, q_tot);
115 h_pe_[bar]->Fill(pe);
116 h_pe_vs_t_[bar]->Fill(first_t, pe);
117 if (n_samp_above > 0) {
118 q_ped_subtracted_avg /= n_samp_above;
119 h_ped_subtracted_avg_q_vs_t_[bar]->Fill(first_t, q_ped_subtracted_avg);
120 h_avg_q_vs_t_[bar]->Fill(first_t, q_tot / n_samp_above);
121 }
122 // if (chan.getPedestal() < 40. ) {
123 // subtrQ = subtrPE/(6250./4.e6); //undo conversion
124 ldmx_log(debug) << "filling qTot histograms";
125 h_ped_subtracted_tot_q_vs_ped_[bar]->Fill(ped, subtr_q);
126 if (ped < 40) // avoid case where we have saturation and a plateau as much
127 // as possible
128 h_ped_subtracted_tot_q_vs_n_[bar]->Fill(n_samp_above_event_ped, subtr_q);
129 h_ped_subtracted_pe_vs_n_[bar]->Fill(n_samp_above_event_ped, subtr_pe);
130 h_ped_subtracted_pe_vs_t_[bar]->Fill(first_t, subtr_pe);
131 ldmx_log(debug) << " done filling qTot histograms";
132 // }
133 } // over channels
134
135 return;
136}
trigscint::EventReadout
This class represents the linearised QIE output from the trigger scintillator, in charge (fC).
Definition EventReadout.h:24

◆ configure()

void trigscint::QIEAnalyzer::configure ( framework::config::Parameters & parameters)
overridevirtual

Callback for the EventProcessor to configure itself from the given set of parameters.

The parameters a processor has access to are the member variables of the python class in the sequence that has class_name equal to the EventProcessor class name.

For an example, look at MyProcessor.

Parameters
parametersParameters for configuration.

Reimplemented from framework::EventProcessor.

Definition at line 17 of file QIEAnalyzer.cxx.

17 {
18 input_col_ = parameters.get<std::string>("input_collection");
19 input_pass_name_ = parameters.get<std::string>("input_pass_name");
20 peds_ = parameters.get<std::vector<double> >("pedestals");
21 gain_ = parameters.get<std::vector<double> >("gain");
22 start_sample_ = parameters.get<int>("start_sample");
23 // bounded by the h_out_ array size
24 n_ev_ = std::clamp(parameters.get<int>("n_event_displays"), 0, n_ev_tdc_);
25
26 ldmx_log(trace) << "In configure(), got parameters "
27 << "\n\t inputCollection = " << input_col_
28 << "\n\t inputPassName = " << input_pass_name_
29 << "\n\t startSample = " << start_sample_
30 << "\n\t pedestals[0] = " << peds_[0]
31 << "\n\t gain[0] = " << gain_[0] << "\t.";
32
33 return;
34}
framework::config::Parameters::get
const T & get(const std::string &name) const
Retrieve the parameter of the given name.
Definition Parameters.h:78

References framework::config::Parameters::get().

◆ convertToID()

float trigscint::QIEAnalyzer::convertToID ( float yVal)
inline

Definition at line 37 of file QIEAnalyzer.h.

37{ return (yVal + y_offset_) * y_to_id_factor_; }

◆ onProcessEnd()

void trigscint::QIEAnalyzer::onProcessEnd ( )
overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events finishes, such as calculating job-summary quantities.

Reimplemented from framework::EventProcessor.

Definition at line 222 of file QIEAnalyzer.cxx.

222{ return; }

◆ onProcessStart()

void trigscint::QIEAnalyzer::onProcessStart ( )
overridevirtual

Callback for the EventProcessor to take any necessary action when the processing of events starts, such as creating histograms.

Reimplemented from framework::EventProcessor.

Definition at line 138 of file QIEAnalyzer.cxx.

138 {
139 ldmx_log(trace)
140 << "\n\n Process starts! My analyzer should do something -- like "
141 "print this \n\n";
142 getHistoDirectory();
143
144 int n_time_samp = 68; // 40
145 int p_emax = 100;
146 int n_p_ebins = 5 * p_emax;
147 float qmax = p_emax / (6250. / 4.e6);
148 float qmin = -10;
149 int n_qbins = (qmax - qmin) / 4;
150
151 ldmx_log(debug) << "Setting up histograms... ";
152
153 for (int i_b = 0; i_b < n_channels_; i_b++) {
154 h_pe_[i_b] = new TH1F(Form("h_pe_chan%i", i_b), Form(";PE, chan%i", i_b),
155 n_p_ebins, 0, p_emax);
156 h_pe_vs_t_[i_b] = new TH2F(
157 Form("h_pe_vs_t__chan%i", i_b),
158 Form(";First time sample above summing threshold;PE, chan%i", i_b),
159 n_time_samp + 1, -1.5, n_time_samp - 0.5, n_p_ebins, 0, p_emax);
160 h_ped_subtracted_avg_q_vs_t_[i_b] = new TH2F(
161 Form("hPedSubtrAvgQvsT_chan%i", i_b),
162 Form(";First time sample above threshold;Pedestal subtracted average "
163 "Q, chan%i [fC]",
164 i_b),
165 n_time_samp + 1, -1.5, n_time_samp - 0.5, n_qbins / 10, qmin,
166 qmax / 10.);
167 h_ped_subtracted_tot_q_vs_ped_[i_b] =
168 new TH2F(Form("hPedSubtrTotQvsPed_chan%i", i_b),
169 Form(";Channel event pedestal [fC];Event pedestal subtracted "
170 "total Q, chan%i [fC]",
171 i_b),
172 1010, qmin, 1000, 10010, -10,
173 10000); // nQbins/2,Qmin,Qmax/5., nQbins,Qmin,2*Qmax);
174 h_ped_subtracted_tot_q_vs_n_[i_b] =
175 new TH2F(Form("hPedSubtrTotQvsN_chan%i", i_b),
176 Form(";Number of time samples added; Event pedestal "
177 "subtracted total Q, chan%i [fC]",
178 i_b),
179 n_time_samp + 1, -1.5, n_time_samp - 0.5, 10010, -10, 10000);
180 h_tot_q_vs_ped_[i_b] = new TH2F(
181 Form("h_tot_q_vs_ped__chan%i", i_b),
182 Form(";Channel event pedestal [fC];Event total Q, chan%i [fC]", i_b),
183 1010, qmin, 1000, 10010, -10,
184 10000); // nQbins/2,Qmin,Qmax/5., nQbins,Qmin,2*Qmax);
185 h_ped_subtracted_pe_vs_n_[i_b] = new TH2F(
186 Form("hPedSubtrPEvsN_chan%i", i_b),
187 Form(";Number of time samples above threshold;Pedestal "
188 "subtracted PE, chan%i [fC]",
189 i_b),
190 n_time_samp + 1, -1.5, n_time_samp - 0.5, n_p_ebins, 0, p_emax);
191 h_ped_subtracted_pe_vs_t_[i_b] = new TH2F(
192 Form("hPedSubtrPEvsT_chan%i", i_b),
193 Form(";First time sample above threshold;Pedestal subtracted "
194 "PE, chan%i [fC]",
195 i_b),
196 n_time_samp + 1, -1.5, n_time_samp - 0.5, n_p_ebins, 0, p_emax);
197 h_avg_q_vs_t_[i_b] = new TH2F(
198 Form("h_avg_q_vs_t_chan%i", i_b),
199 Form(";First time sample above threshold;Average Q, chan%i [fC]", i_b),
200 n_time_samp + 1, -1.5, n_time_samp - 0.5, n_qbins / 10, qmin,
201 qmax / 10);
202 }
203
204 for (int i_e = 0; i_e < n_ev_; i_e++) {
205 for (int i_b = 0; i_b < n_channels_; i_b++) {
206 h_out_[i_e][i_b] =
207 new TH1F(Form("hCharge_chan%i_ev%i", i_b, i_e),
208 Form(";time sample; Q, channel %i, event %i [fC]", i_b, i_e),
209 n_time_samp, -0.5, n_time_samp - 0.5);
210 }
211 }
212
213 h_tdc_fire_chan_vs_event_ = new TH2F(
214 "h_tdc_fire_chan_vs_event", ";channel with TDC < 63;event number",
215 n_channels_, -0.5, n_channels_ - 0.5, n_ev_tdc_, 0, n_ev_tdc_);
216
217 ldmx_log(debug) << "done setting up histograms";
218
219 return;
220}
framework::EventProcessor::getHistoDirectory
TDirectory * getHistoDirectory()
Access/create a directory in the histogram file for this event processor to create histograms and ana...
Definition EventProcessor.cxx:26

Member Data Documentation

◆ gain_

std::vector<double> trigscint::QIEAnalyzer::gain_
private

Definition at line 46 of file QIEAnalyzer.h.

◆ h_avg_q_vs_t_

TH2F* trigscint::QIEAnalyzer::h_avg_q_vs_t_[24]
private

Definition at line 67 of file QIEAnalyzer.h.

◆ h_out_

TH1F* trigscint::QIEAnalyzer::h_out_[200][24] {}
private

Definition at line 58 of file QIEAnalyzer.h.

58{};

◆ h_pe_

TH1F* trigscint::QIEAnalyzer::h_pe_[24]
private

Definition at line 59 of file QIEAnalyzer.h.

◆ h_pe_vs_t_

TH2F* trigscint::QIEAnalyzer::h_pe_vs_t_[24]
private

Definition at line 60 of file QIEAnalyzer.h.

◆ h_ped_subtracted_avg_q_vs_t_

TH2F* trigscint::QIEAnalyzer::h_ped_subtracted_avg_q_vs_t_[24]
private

Definition at line 61 of file QIEAnalyzer.h.

◆ h_ped_subtracted_pe_vs_n_

TH2F* trigscint::QIEAnalyzer::h_ped_subtracted_pe_vs_n_[24]
private

Definition at line 65 of file QIEAnalyzer.h.

◆ h_ped_subtracted_pe_vs_t_

TH2F* trigscint::QIEAnalyzer::h_ped_subtracted_pe_vs_t_[24]
private

Definition at line 66 of file QIEAnalyzer.h.

◆ h_ped_subtracted_tot_q_vs_n_

TH2F* trigscint::QIEAnalyzer::h_ped_subtracted_tot_q_vs_n_[24]
private

Definition at line 63 of file QIEAnalyzer.h.

◆ h_ped_subtracted_tot_q_vs_ped_

TH2F* trigscint::QIEAnalyzer::h_ped_subtracted_tot_q_vs_ped_[24]
private

Definition at line 62 of file QIEAnalyzer.h.

◆ h_tdc_fire_chan_vs_event_

TH2F* trigscint::QIEAnalyzer::h_tdc_fire_chan_vs_event_
private

Definition at line 69 of file QIEAnalyzer.h.

◆ h_tot_q_vs_ped_

TH2F* trigscint::QIEAnalyzer::h_tot_q_vs_ped_[24]
private

Definition at line 64 of file QIEAnalyzer.h.

◆ input_col_

std::string trigscint::QIEAnalyzer::input_col_
private

Definition at line 43 of file QIEAnalyzer.h.

◆ input_pass_name_

std::string trigscint::QIEAnalyzer::input_pass_name_ {""}
private

Definition at line 44 of file QIEAnalyzer.h.

44{""};

◆ n_channels_

int trigscint::QIEAnalyzer::n_channels_ {24}
private

Definition at line 54 of file QIEAnalyzer.h.

54{24};

◆ n_ev_

int trigscint::QIEAnalyzer::n_ev_ {200}
private

Definition at line 51 of file QIEAnalyzer.h.

51{200};

◆ n_ev_tdc_

int trigscint::QIEAnalyzer::n_ev_tdc_ {200}
private

Definition at line 53 of file QIEAnalyzer.h.

53{200};

◆ peds_

std::vector<double> trigscint::QIEAnalyzer::peds_
private

Definition at line 45 of file QIEAnalyzer.h.

◆ start_sample_

int trigscint::QIEAnalyzer::start_sample_ {0}
private

Definition at line 47 of file QIEAnalyzer.h.

47{0};

◆ v_charge_vs_time_

std::vector<std::vector<TH1F*> > trigscint::QIEAnalyzer::v_charge_vs_time_
private

Definition at line 40 of file QIEAnalyzer.h.

◆ y_offset_

double trigscint::QIEAnalyzer::y_offset_ {35.}
private

Definition at line 70 of file QIEAnalyzer.h.

70{35.};

◆ y_to_id_factor_

double trigscint::QIEAnalyzer::y_to_id_factor_ {50. / 80.}
private

Definition at line 71 of file QIEAnalyzer.h.

71{50. / 80.};
The documentation for this class was generated from the following files:
Generated by doxygen 1.12.0