Jpp 19.3.0-rc.1
the software that should make you happy
Loading...
Searching...
No Matches
Functions | Variables
JMakePD0.cc File Reference

Program to create interpolation tables of the PDF of the arrival time of the Cherenkov light from a bright point. More...

#include <string>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <set>
#include <map>
#include <cmath>
#include "JTools/JFunction1D_t.hh"
#include "JTools/JFunctionalMap_t.hh"
#include "JTools/JQuadrature.hh"
#include "JPhysics/JPDF.hh"
#include "JPhysics/JPDFTable.hh"
#include "JPhysics/Antares.hh"
#include "JPhysics/KM3NeT.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions

double getAbsorptionLength (const double lambda)
 
double getScatteringLength (const double lambda)
 
int main (int argc, char **argv)
 

Variables

double absorptionLengthFactor
 Scaling of absorption and scattering length.
 
double scatteringLengthFactor
 

Detailed Description

Program to create interpolation tables of the PDF of the arrival time of the Cherenkov light from a bright point.

The PDFs are tabulated as a function of (D, cos(theta), t), where:

  • D is the distance between the bright point and the PMT;
  • cos(theta) the cosine of the PMT angle;
  • t the arrival time of the light with respect to the Cherenkov hypothesis.

The orientation of the PMT is defined in the coordinate system in which the position of the bright point and that of the PMT are along the x-axis and the PMT is oriented in the x-y plane.

Author
mdejong

Definition in file JMakePD0.cc.

Function Documentation

◆ getAbsorptionLength()

double getAbsorptionLength ( const double lambda)
inline

Definition at line 28 of file JMakePD0.cc.

29{
30 return absorptionLengthFactor * NAMESPACE::getAbsorptionLength(lambda);
31}
absorptionLengthFactor
double absorptionLengthFactor
Scaling of absorption and scattering length.
Definition JMakePD0.cc:24

◆ getScatteringLength()

double getScatteringLength ( const double lambda)
inline

Definition at line 34 of file JMakePD0.cc.

35{
36 return scatteringLengthFactor * NAMESPACE::getScatteringLength(lambda);
37}
scatteringLengthFactor
double scatteringLengthFactor
Definition JMakePD0.cc:25

◆ main()

int main ( int argc,
char ** argv )

Definition at line 54 of file JMakePD0.cc.

55{
56 using namespace std;
57 using namespace JPP;
58
59 string outputFile;
60 int numberOfPoints;
61 double epsilon;
62 int function;
63 set<double> D; // distance [m]
64 int debug;
65
66 try {
67
68 JParser<> zap("Program to create interpolation tables of the PDF of the arrival time of the Cherenkov light from a bright point.");
69
70 zap['o'] = make_field(outputFile);
71 zap['n'] = make_field(numberOfPoints, "points for integration") = 25;
72 zap['e'] = make_field(epsilon, "precision for integration") = 1.0e-10;
73 zap['A'] = make_field(absorptionLengthFactor, "scaling factor") = 1.0;
74 zap['S'] = make_field(scatteringLengthFactor, "scaling factor") = 1.0;
75 zap['F'] = make_field(function, "PDF type") =
76 DIRECT_LIGHT_FROM_BRIGHT_POINT,
77 SCATTERED_LIGHT_FROM_BRIGHT_POINT;
78 zap['D'] = make_field(D, "distance [m]") = JPARSER::initialised();
79 zap['d'] = make_field(debug) = 0;
80
81 zap['F'] = JPARSER::not_initialised();
82
83 zap(argc, argv);
84 }
85 catch(const exception &error) {
86 FATAL(error.what() << endl);
87 }
88
89
90 typedef double (JPDF::*fcn)(const double,
91 const double,
92 const double) const;
93
94
95 // set global parameters
96
97 const double P_atm = NAMESPACE::getAmbientPressure();
98 const double wmin = getMinimalWavelength();
99 const double wmax = getMaximalWavelength();
100
101
102 const JPDF_C
103 pdf_c(NAMESPACE::getPhotocathodeArea(),
104 NAMESPACE::getQE,
105 NAMESPACE::getAngularAcceptance,
106 getAbsorptionLength,
107 getScatteringLength,
108 NAMESPACE::getScatteringProbability,
109 P_atm,
110 wmin,
111 wmax,
112 numberOfPoints,
113 epsilon);
114
115
116 typedef JSplineFunction1D_t JFunction1D_t;
117 typedef JMAPLIST<JPolint1FunctionalMap,
118 JPolint1FunctionalGridMap>::maplist JMapList_t;
119 typedef JPDFTable<JFunction1D_t, JMapList_t> JPDF_t;
120
121 typedef JPDFTransformer<2, JFunction1D_t::argument_type> JFunction2DTransformer_t;
122 typedef JArray<2, JFunction1D_t::argument_type> JArray_t;
123
124 JPDF_t pdf;
125
126
127 NOTICE("building multi-dimensional function object <" << function << ">... " << flush);
128
129 const double ng[] = { pdf_c.getIndexOfRefractionGroup(wmax),
130 pdf_c.getIndexOfRefractionGroup(wmin) };
131
132 map<int, pair<fcn,JFunction2DTransformer_t> > zmap;
133
134 zmap[DIRECT_LIGHT_FROM_BRIGHT_POINT] = make_pair((fcn) &JPDF::getDirectLightFromBrightPoint, JFunction2DTransformer_t(21.5, 2, ng[0], ng[1]));
135 zmap[SCATTERED_LIGHT_FROM_BRIGHT_POINT] = make_pair((fcn) &JPDF::getScatteredLightFromBrightPoint, JFunction2DTransformer_t(21.5, 2, ng[0], 0.0));
136
137 if (zmap.find(function) == zmap.end()) {
138 FATAL("illegal function specifier" << endl);
139 }
140
141 fcn f = zmap[function].first; // PDF
142 JFunction2DTransformer_t transformer = zmap[function].second; // transformer
143
144
145 if (D.empty()) {
146 D.insert( 0.10);
147 D.insert( 0.50);
148 D.insert( 1.00);
149 D.insert( 5.00);
150 D.insert( 10.00);
151 D.insert( 20.00);
152 D.insert( 30.00);
153 D.insert( 40.00);
154 D.insert( 50.00);
155 D.insert( 60.00);
156 D.insert( 70.00);
157 D.insert( 80.00);
158 D.insert( 90.00);
159 D.insert(100.00);
160 }
161
162 set<double> X; // time [ns]
163
164 if (function == DIRECT_LIGHT_FROM_BRIGHT_POINT) {
165
166 for (double buffer[] = { 0.0, 0.005, 0.01, 0.015, -1 }, *x = buffer; *x >= 0; ++x) {
167 X.insert(0.0 + *x);
168 X.insert(1.0 - *x);
169 }
170
171 for (double x = 0.02; x < 0.99; x += 0.01)
172 X.insert(x);
173
174 } else {
175
176 X.insert( 0.00);
177 X.insert( 0.10);
178 X.insert( 0.20);
179 X.insert( 0.30);
180 X.insert( 0.40);
181 X.insert( 0.50);
182 X.insert( 0.60);
183 X.insert( 0.70);
184 X.insert( 0.80);
185 X.insert( 0.90);
186 X.insert( 1.00);
187 X.insert( 1.00);
188 X.insert( 1.10);
189 X.insert( 1.20);
190 X.insert( 1.30);
191 X.insert( 1.40);
192 X.insert( 1.50);
193 X.insert( 1.60);
194 X.insert( 1.70);
195 X.insert( 1.80);
196 X.insert( 1.90);
197 X.insert( 2.00);
198 X.insert( 2.20);
199 X.insert( 2.40);
200 X.insert( 2.60);
201 X.insert( 2.80);
202 X.insert( 3.00);
203 X.insert( 3.25);
204 X.insert( 3.50);
205 X.insert( 3.75);
206 X.insert( 4.00);
207 X.insert( 4.25);
208 X.insert( 4.50);
209 X.insert( 4.75);
210 X.insert( 5.0);
211 X.insert( 6.0);
212 X.insert( 7.0);
213 X.insert( 8.0);
214 X.insert( 9.0);
215 X.insert( 10.0);
216 X.insert( 15.0);
217 X.insert( 20.0);
218 X.insert( 25.0);
219 X.insert( 30.0);
220 X.insert( 40.0);
221 X.insert( 50.0);
222 X.insert( 60.0);
223 X.insert( 70.0);
224 X.insert( 80.0);
225 X.insert( 90.0);
226 X.insert(100.0);
227 X.insert(120.0);
228 X.insert(140.0);
229 X.insert(160.0);
230 X.insert(180.0);
231 X.insert(200.0);
232 }
233
234
235 for (set<double>::const_iterator d = D.begin(); d != D.end(); ++d) {
236
237 const double D_m = *d;
238
239 for (double dc = 0.1, ct = -1.0; ct < +1.0 + 0.5*dc; ct += dc) {
240
241 JFunction1D_t& f1 = pdf[D_m][ct];
242
243 const JArray_t array(D_m, ct);
244
245 double t_old = transformer.getXn(array, *X.begin());
246 double y_old = 0.0;
247
248 for (set<double>::const_iterator x = X.begin(); x != X.end(); ++x) {
249
250 const double t = transformer.getXn(array, *x);
251 const double y = (pdf_c.*f)(D_m, ct, t);
252
253 if (y != 0.0) {
254
255 if (*x < 0.0) {
256 WARNING("dt < 0 " << *x << ' ' << D_m << ' ' << t << ' ' << y << endl);
257 }
258
259 if (y_old == 0.0) {
260 f1[t_old] = y_old;
261 }
262
263 f1[t] = y;
264
265 } else {
266
267 if (y_old != 0.0) {
268 f1[t] = y;
269 }
270 }
271
272 t_old = t;
273 y_old = y;
274 }
275 }
276 }
277
278 pdf.transform(transformer);
279 pdf.compile();
280
281 NOTICE("OK" << endl);
282
283 try {
284
285 NOTICE("storing output to file " << outputFile << "... " << flush);
286
287 pdf.store(outputFile.c_str());
288
289 NOTICE("OK" << endl);
290 }
291 catch(const JException& error) {
292 FATAL(error.what() << endl);
293 }
294}
outputFile
string outputFile
Definition JDAQTimesliceSelector.cc:37
getAbsorptionLength
double getAbsorptionLength(const double lambda)
Definition JMakePD0.cc:28
getScatteringLength
double getScatteringLength(const double lambda)
Definition JMakePD0.cc:34
NOTICE
#define NOTICE(A)
Definition JMessage.hh:64
FATAL
#define FATAL(A)
Definition JMessage.hh:67
debug
int debug
debug level
Definition JSirene.cc:72
WARNING
#define WARNING(A)
Definition JMessage.hh:65
make_field
#define make_field(A,...)
macro to convert parameter to JParserTemplateElement object
Definition JParser.hh:2142
numberOfPoints
int numberOfPoints
Definition JResultPDF.cc:22
JLANG::JException
General exception.
Definition JException.hh:24
JLANG::JException::what
virtual const char * what() const override
Get error message.
Definition JException.hh:64
JPARSER::JParser
Utility class to parse command line options.
Definition JParser.hh:1698
JPHYSICS::JPDFTable
Multi-dimensional PDF table for arrival time of Cherenkov light.
Definition JPDFTable.hh:44
JPHYSICS::JPDFTransformer
Template definition of transformer of the probability density function (PDF) of the time response of ...
Definition JPDFTransformer.hh:620
JPHYSICS::JPDF_C
Probability Density Functions of the time response of a PMT with an implementation of the JAbstractPM...
Definition JPDF.hh:2185
JTOOLS::JArray
One dimensional array of template objects with fixed length.
Definition JArray.hh:43
GAUSS_LEGENDRE::f1
const JPolynome f1(1.0, 2.0, 3.0)
Function.
GAUSS_LEGENDRE::epsilon
const double epsilon
Definition JQuadrature.cc:21
JPHYSICS::getMinimalWavelength
double getMinimalWavelength()
Get minimal wavelength for PDF evaluations.
Definition JPDFToolkit.hh:35
JPHYSICS::getMaximalWavelength
double getMaximalWavelength()
Get maximal wavelength for PDF evaluations.
Definition JPDFToolkit.hh:46
JPP
This name space includes all other name spaces (except KM3NETDAQ, KM3NET and ANTARES).
Definition JAAnetToolkit.hh:43
JPARSER::initialised
Empty structure for specification of parser element that is initialised (i.e. does not require input)...
Definition JParser.hh:68
JPARSER::not_initialised
Empty structure for specification of parser element that is not initialised (i.e. does require input)...
Definition JParser.hh:74
JPDF
Auxiliary data structure for muon PDF.
Definition JPDF_t.hh:26
JTOOLS::JMAPLIST
Auxiliary class for recursive map list generation.
Definition JMapList.hh:109
JTOOLS::JPolint1FunctionalGridMap
Type definition of a 1st degree polynomial interpolation based on a JGridMap implementation.
Definition JFunctionalMap_t.hh:93
JTOOLS::JPolint1FunctionalMap
Type definition of a 1st degree polynomial interpolation based on a JMap implementation.
Definition JFunctionalMap_t.hh:57
JTOOLS::JSplineFunction1D_t
Type definition of a spline interpolation method based on a JCollection with double result type.
Definition JFunction1D_t.hh:37

Variable Documentation

◆ absorptionLengthFactor

double absorptionLengthFactor

Scaling of absorption and scattering length.

Definition at line 24 of file JMakePD0.cc.

◆ scatteringLengthFactor

double scatteringLengthFactor

Definition at line 25 of file JMakePD0.cc.

Generated by doxygen 1.12.0