GENIEGenerator
Loading...
Searching...
No Matches
gtestINukeHadroData.cxx
Go to the documentation of this file.
1//____________________________________________________________________________
2/*!
3
4\program testINukeHadroData
5
6\brief test program used for testing the hadron cross section data used in
7 INTRANUKE.
8 The program will save all the hadron cross section splines at an output
9 ROOT file (hadxs.root).
10 If a hadron kinetic energy is passed as command line argument then,
11 rather than saving the cross section splines at an output file, the
12 program will print out the cross section values at the specified
13 kinetic energy.
14
15\syntax gtestINukeHadroData [-e energy(MeV)]
16
17 [] denotes an optionan argument
18 -e can be used to pass a kinetic energy for which all the hadron
19 cross sections will be printed out
20
21\author Costas Andreopoulos <c.andreopoulos \at cern.ch>
22 University of Liverpool
23
24\created May 12, 2004
25
26\cpright Copyright (c) 2003-2025, The GENIE Collaboration
27 For the full text of the license visit http://copyright.genie-mc.org
28
29
30Important Revisions:
31@ Aug 17, 2010 - AM, SD
32Update to print out xs for p and n separately to match what is used in
33propagation. Add photon and kaon xs ouputs.
34
35*/
36//____________________________________________________________________________
37
38#include <cmath>
39#include <cstdlib>
40#include <sstream>
41#include <string>
42#include <fstream>
43
44#include "Framework/Conventions/Constants.h"
45#include "Physics/HadronTransport/INukeHadroData.h"
46#include "Framework/Messenger/Messenger.h"
47#include "Framework/Numerical/Spline.h"
48#include "Framework/ParticleData/PDGCodes.h"
49#include "Framework/Utils/CmdLnArgParser.h"
50
51#include <TSystem.h>
52#include <TFile.h>
53#include <TGraph2D.h>
54
55using std::ostringstream;
56using std::istream;
57using std::ios;
58using std::endl;
59
60using namespace genie;
61using namespace genie::constants;
62
63void SaveDataToRootFile (bool test_intbounce);
64void SaveSplinesToRootFile (void);
65void PrintOutForInputKE (double ke);
66
67int main(int argc, char ** argv)
68{
69 double ke = -1; // input hadron kinetic energy
70 bool save_data=true;
71
72 CmdLnArgParser parser(argc,argv);
73
74 // neutrino energy
75 if( parser.OptionExists('e') ) {
76 LOG("testINukeHadroData", pINFO) << "Reading Event Energy";
77 ke = parser.ArgAsLong('e');
78 } else {
79 LOG("testINukeHadroData", pINFO) << "Unspecified energy, write to file";
80 }
81
82 if(ke<0) {
83 SaveSplinesToRootFile();
84 if(save_data) SaveDataToRootFile(true);
85 }
86 else {
87 PrintOutForInputKE(ke);
88 }
89
90 return 0;
91}
92//____________________________________________________________________________
93void SaveDataToRootFile(bool test_intbounce)
94{
95
96 string filename = "hadxs.root";
97
98 string data_dir = (gSystem->Getenv("GINUKEHADRONDATA")) ?
99 string(gSystem->Getenv("GINUKEHADRONDATA")) :
100 string(gSystem->Getenv("GENIE")) + string("/data/intranuke/");
101
102 LOG("testINukeHadroData", pNOTICE)
103 << "Saving INTRANUKE hadron x-section data to file: " << filename;
104
105 TFile f(filename.c_str(), "UPDATE");
106
107 INukeHadroData * inukd = INukeHadroData::Instance();
108 int numPoints = 80;
109 double cstep = 2.0 / (numPoints);
110
111 // kIHNFtElas, kpn :
112 {
113 const int hN_kpNelas_nfiles = 18;
114 const int hN_kpNelas_points_per_file = 37;
115 const int hN_kpNelas_npoints = hN_kpNelas_points_per_file * hN_kpNelas_nfiles;
116
117 int hN_kpNelas_energies[hN_kpNelas_nfiles] = {
118 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000,
119 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800
120 };
121
122 TGraph2D * hN_kpNelas_graph = new TGraph2D(hN_kpNelas_npoints);
123 TGraph2D * hN_kpNelas_int = new TGraph2D(hN_kpNelas_nfiles*numPoints);
124
125 int ipoint=0;
126 double x, y;
127
128 for(int ifile = 0; ifile < hN_kpNelas_nfiles; ifile++) {
129 // build filename
130 ostringstream hN_datafile;
131 int ke = hN_kpNelas_energies[ifile];
132 hN_datafile << data_dir << "/diff_ang/kpn/kpn" << ke << ".txt";
133 // read data
134 TGraph * buff = new TGraph(hN_datafile.str().c_str());
135 for(int i=0; i<buff->GetN(); i++) {
136 buff -> GetPoint(i,x,y);
137 hN_kpNelas_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
138 ipoint++;
139 }
140 delete buff;
141 }//loop over files
142
143 //hN_kpNelas_graph -> Write("d_kpN_elas_data");
144 //if (test_intbounce) {
145 // hN_kpNelas_int -> Write("d_kpN_elas_int");
146 //}
147 //delete hN_kpNelas_graph;
148 //delete hN_kpNelas_int;
149 //TGraph2D * hN_kpNelas_fudge = new TGraph2D(hN_kpNelas_nfiles*numPoints);
150
151 if (test_intbounce)
152 {
153 for (int ifile=0;ifile<hN_kpNelas_nfiles;ifile++) {
154 int subdiv = numPoints*ifile;
155 int ke = hN_kpNelas_energies[ifile];
156 for(int j=0;j<numPoints; j++)
157 {
158 hN_kpNelas_int -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
159 inukd->XSec(kPdgKP,kPdgNeutron,kPdgKP,kIHNFtElas,double(ke)+.05,-1+j*cstep));
160 }
161 }
162 }
163 hN_kpNelas_graph -> Write("d_kpN_elas_data");
164 if (test_intbounce) {
165 hN_kpNelas_int -> Write("d_kpN_elas_int");
166 }
167 delete hN_kpNelas_graph;
168 delete hN_kpNelas_int;
169 }
170
171 // kIHNFtElas, kpp :
172 {
173 const int hN_kpPelas_nfiles = 18;
174 const int hN_kpPelas_points_per_file = 37;
175 const int hN_kpPelas_npoints = hN_kpPelas_points_per_file * hN_kpPelas_nfiles;
176
177 int hN_kpPelas_energies[hN_kpPelas_nfiles] = {
178 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000,
179 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800
180 };
181
182 TGraph2D * hN_kpPelas_graph = new TGraph2D(hN_kpPelas_npoints);
183 //TGraph2D * hN_kpPelas_fudge = new TGraph2D(hN_kpPelas_nfiles*numPoints);
184 TGraph2D * hN_kpPelas_int = new TGraph2D(hN_kpPelas_nfiles*numPoints);
185
186 int ipoint=0;
187 double x, y;
188
189 for(int ifile = 0; ifile < hN_kpPelas_nfiles; ifile++) {
190 // build filename
191 ostringstream hN_datafile;
192 int ke = hN_kpPelas_energies[ifile];
193 hN_datafile << data_dir << "/diff_ang/kpp/kpp" << ke << ".txt";
194 // read data
195 TGraph * buff = new TGraph(hN_datafile.str().c_str());
196 for(int i=0; i<buff->GetN(); i++) {
197 buff -> GetPoint(i,x,y);
198 hN_kpPelas_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
199 ipoint++;
200 }
201 delete buff;
202
203 if (test_intbounce)
204 {
205 int subdiv = numPoints*ifile;
206 //double * buffpt=0x0;
207 for(int j=0;j<numPoints; j++)
208 {
209 /*if (ifile==6||ifile==7) {/ *hN_kpPelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,0);
210 else * /hN_kpPelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
211 inukd->XSec(kPdgKP,kPdgProton,kPdgKP,kIHNFtElas,double(ke)+.05,-1+j*cstep));}*/
212 hN_kpPelas_int -> SetPoint(subdiv+j,double(ke),-1.+double(j)*cstep,
213 inukd->XSec(kPdgKP,kPdgProton,kPdgKP,kIHNFtElas,double(ke),-1+j*cstep));
214 //if ((ifile>=3&&ifile<=5)&&(j<20||j>60)) { buffpt=hN_kpPelas_int -> GetZ();
215 //LOG("testINukeHadroData",pWARN)<<subdiv+j<<" "<<buffpt[subdiv+j]<<" "<<inukd->XSec(kPdgKP,kPdgProton,kPdgKP,kIHNFtElas,double(ke),-1+j*cstep);}
216 //hN_kpPelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,0);
217 /*if (j%3==0&&ifile%2==0) hN_kpPelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
218 inukd->XSec(kPdgKP,kPdgProton,kPdgKP,kIHNFtElas,double(ke)+.05,-1+j*cstep));
219 else hN_kpPelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,0);*/
220 /*if (ifile==3||ifile==4) hN_kpPelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,0);
221 else hN_kpPelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
222 inukd->XSec(kPdgKP,kPdgProton,kPdgKP,kIHNFtElas,double(ke)+.05,-1+j*cstep));*/
223
224 }
225 }
226 }//loop over files
227
228 hN_kpPelas_graph -> Write("d_kpP_elas_data");
229 if (test_intbounce)
230 {
231 hN_kpPelas_int -> Write("d_kpP_elas_int");
232 //hN_kpPelas_fudge -> Write("d_kpP_elas_fudge");
233 }
234 delete hN_kpPelas_graph;
235 delete hN_kpPelas_int;
236 //delete hN_kpPelas_fudge;
237 }
238
239 // kIHNFtElas, pp&nn :
240 {
241 const int hN_ppelas_nfiles = 20;
242 const int hN_ppelas_points_per_file = 21;
243 const int hN_ppelas_npoints = hN_ppelas_points_per_file * hN_ppelas_nfiles;
244
245 int hN_ppelas_energies[hN_ppelas_nfiles] = {
246 50, 100, 150, 200, 250, 300, 350, 400, 450, 500,
247 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000
248 };
249
250 TGraph2D * hN_ppelas_graph = new TGraph2D(hN_ppelas_npoints);
251 TGraph2D * hN_ppelas_int = new TGraph2D(hN_ppelas_nfiles*numPoints);
252 //TGraph2D * hN_ppelas_fudge = new TGraph2D(hN_ppelas_nfiles*numPoints);
253
254 int ipoint=0;
255 double x, y;
256
257 for(int ifile = 0; ifile < hN_ppelas_nfiles; ifile++) {
258 // build filename
259 ostringstream hN_datafile;
260 int ke = hN_ppelas_energies[ifile];
261 hN_datafile << data_dir << "/diff_ang/pp/pp" << ke << ".txt";
262 // read data
263 TGraph * buff = new TGraph(hN_datafile.str().c_str());
264 for(int i=0; i<buff->GetN(); i++) {
265 buff -> GetPoint(i,x,y);
266 hN_ppelas_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
267 ipoint++;
268 }
269 delete buff;
270
271 if (test_intbounce)
272 {
273 int subdiv = numPoints*ifile;
274 for(int j=0;j<numPoints; j++)
275 {
276 hN_ppelas_int -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
277 inukd->XSec(kPdgProton,kPdgProton,kPdgProton,kIHNFtElas,double(ke),-1+j*cstep));
278 }
279 }
280 }//loop over files
281
282 hN_ppelas_graph -> Write("d_pp_elas_data");
283 if (test_intbounce)
284 {
285 hN_ppelas_int -> Write("d_pp_elas_int");
286 //hN_ppelas_fudge -> Write("d_pp_elas_fudge");
287 }
288 delete hN_ppelas_graph;
289 delete hN_ppelas_int;
290 //delete hN_ppelas_fudge;
291 }
292
293 // kIHNFtElas, pn&np :
294 {
295 const int hN_npelas_nfiles = 20;
296 const int hN_npelas_points_per_file = 21;
297 const int hN_npelas_npoints = hN_npelas_points_per_file * hN_npelas_nfiles;
298
299 int hN_npelas_energies[hN_npelas_nfiles] = {
300 50, 100, 150, 200, 250, 300, 350, 400, 450, 500,
301 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000
302 };
303
304 TGraph2D * hN_npelas_graph = new TGraph2D(hN_npelas_npoints);
305 TGraph2D * hN_npelas_int = new TGraph2D(hN_npelas_nfiles*numPoints);
306 //TGraph2D * hN_npelas_fudge = new TGraph2D(hN_npelas_nfiles*numPoints);
307
308 int ipoint=0;
309 double x, y;
310
311 for(int ifile = 0; ifile < hN_npelas_nfiles; ifile++) {
312 // build filename
313 ostringstream hN_datafile;
314 int ke = hN_npelas_energies[ifile];
315 hN_datafile << data_dir << "/diff_ang/pn/pn" << ke << ".txt";
316 // read data
317 TGraph * buff = new TGraph(hN_datafile.str().c_str());
318 for(int i=0; i<buff->GetN(); i++) {
319 buff -> GetPoint(i,x,y);
320 hN_npelas_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
321 ipoint++;
322 }
323 delete buff;
324
325 if (test_intbounce)
326 {
327 int subdiv = numPoints*ifile;
328 for(int j=0;j<numPoints; j++)
329 {
330 hN_npelas_int -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
331 inukd->XSec(kPdgProton,kPdgNeutron,kPdgProton,kIHNFtElas,double(ke),-1+j*cstep));
332 }
333 }
334 }//loop over files
335
336 hN_npelas_graph -> Write("d_np_elas_data");
337 if (test_intbounce)
338 {
339 hN_npelas_int -> Write("d_np_elas_int");
340 //hN_npelas_fudge -> Write("d_np_elas_fudge");
341 }
342 delete hN_npelas_graph;
343 delete hN_npelas_int;
344 //delete hN_npelas_fudge;
345 }
346
347 // kIHNFtElas, pipN :
348 {
349 const int hN_pipNelas_nfiles = 60;
350 const int hN_pipNelas_points_per_file = 21;
351 const int hN_pipNelas_npoints = hN_pipNelas_points_per_file * hN_pipNelas_nfiles;
352
353 int hN_pipNelas_energies[hN_pipNelas_nfiles] = {
354 10, 20, 30, 40, 50, 60, 70, 80, 90,
355 100, 110, 120, 130, 140, 150, 160, 170, 180, 190,
356 200, 210, 220, 230, 240, 250, 260, 270, 280, 290,
357 300, 340, 380, 420, 460, 500, 540, 580, 620, 660,
358 700, 740, 780, 820, 860, 900, 940, 980,
359 1020, 1060, 1100, 1140, 1180, 1220, 1260,
360 1300, 1340, 1380, 1420, 1460, 1500
361 };
362
363 TGraph2D * hN_pipNelas_graph = new TGraph2D(hN_pipNelas_npoints);
364 TGraph2D * hN_pipNelas_int = new TGraph2D(hN_pipNelas_nfiles*numPoints);
365 //TGraph2D * hN_pipNelas_fudge = new TGraph2D(hN_pipNelas_nfiles*numPoints);
366
367 int ipoint=0;
368 double x, y;
369
370 for(int ifile = 0; ifile < hN_pipNelas_nfiles; ifile++) {
371 // build filename
372 ostringstream hN_datafile;
373 int ke = hN_pipNelas_energies[ifile];
374 hN_datafile << data_dir << "/diff_ang/pip/pip" << ke << ".txt";
375 // read data
376 TGraph * buff = new TGraph(hN_datafile.str().c_str());
377 for(int i=0; i<buff->GetN(); i++) {
378 buff -> GetPoint(i,x,y);
379 hN_pipNelas_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
380 ipoint++;
381 }
382 delete buff;
383
384 if (test_intbounce)
385 {
386 int subdiv = numPoints*ifile;
387 for(int j=0;j<numPoints; j++)
388 {
389 hN_pipNelas_int -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
390 inukd->XSec(kPdgPiP,kPdgProton,kPdgPiP,kIHNFtElas,double(ke),-1+j*cstep));
391 //hN_pipNelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
392 //inukd->XSec(kPdgPiP,kPdgProton,kPdgPiP,kIHNFtElas,double(ke)+.05,-1+j*cstep));
393 }
394 }
395 }//loop over files
396
397 hN_pipNelas_graph -> Write("d_pipN_elas_data");
398 if (test_intbounce)
399 {
400 hN_pipNelas_int -> Write("d_pipN_elas_int");
401 //hN_pipNelas_fudge -> Write("d_pipN_elas_fudge");
402 }
403 delete hN_pipNelas_graph;
404 delete hN_pipNelas_int;
405 //delete hN_pipNelas_fudge;
406 }
407
408 // kIHNFtElas, pi0N :
409 {
410 const int hN_pi0Nelas_nfiles = 60;
411 const int hN_pi0Nelas_points_per_file = 21;
412 const int hN_pi0Nelas_npoints = hN_pi0Nelas_points_per_file * hN_pi0Nelas_nfiles;
413
414 int hN_pi0Nelas_energies[hN_pi0Nelas_nfiles] = {
415 10, 20, 30, 40, 50, 60, 70, 80, 90,
416 100, 110, 120, 130, 140, 150, 160, 170, 180, 190,
417 200, 210, 220, 230, 240, 250, 260, 270, 280, 290,
418 300, 340, 380, 420, 460, 500, 540, 580, 620, 660,
419 700, 740, 780, 820, 860, 900, 940, 980,
420 1020, 1060, 1100, 1140, 1180, 1220, 1260,
421 1300, 1340, 1380, 1420, 1460, 1500
422 };
423
424 TGraph2D * hN_pi0Nelas_graph = new TGraph2D(hN_pi0Nelas_npoints);
425 TGraph2D * hN_pi0Nelas_int = new TGraph2D(hN_pi0Nelas_nfiles*numPoints);
426 //TGraph2D * hN_pi0Nelas_fudge = new TGraph2D(hN_pi0Nelas_nfiles*numPoints);
427
428 int ipoint=0;
429 double x, y;
430
431 for(int ifile = 0; ifile < hN_pi0Nelas_nfiles; ifile++) {
432 // build filename
433 ostringstream hN_datafile;
434 int ke = hN_pi0Nelas_energies[ifile];
435 hN_datafile << data_dir << "/diff_ang/pip/pip" << ke << ".txt";
436 // read data
437 TGraph * buff = new TGraph(hN_datafile.str().c_str());
438 for(int i=0; i<buff->GetN(); i++) {
439 buff -> GetPoint(i,x,y);
440 hN_pi0Nelas_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
441 ipoint++;
442 }
443 delete buff;
444
445 if (test_intbounce)
446 {
447 int subdiv = numPoints*ifile;
448 for(int j=0;j<numPoints; j++)
449 {
450 hN_pi0Nelas_int -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
451 inukd->XSec(kPdgPi0,kPdgProton,kPdgPi0,kIHNFtElas,double(ke),-1+j*cstep));
452 //hN_pi0Nelas_fudge -> SetPoint(subdiv+j,double(ke),-1+j*cstep,
453 // inukd->XSec(kPdgPi0,kPdgProton,kPdgPi0,kIHNFtElas,double(ke)+.05,-1+j*cstep));
454 }
455 }
456 }//loop over files
457
458 hN_pi0Nelas_graph -> Write("d_pi0N_elas_data");
459 if (test_intbounce)
460 {
461 hN_pi0Nelas_int -> Write("d_pi0N_elas_int");
462 //hN_pi0Nelas_fudge -> Write("d_pi0N_elas_fudge");
463 }
464 delete hN_pi0Nelas_graph;
465 delete hN_pi0Nelas_int;
466 //delete hN_pi0Nelas_fudge;
467 }
468
469 // kIHNFtElas, pimN :
470 {
471 const int hN_pimNelas_nfiles = 60;
472 const int hN_pimNelas_points_per_file = 21;
473 const int hN_pimNelas_npoints = hN_pimNelas_points_per_file * hN_pimNelas_nfiles;
474
475 int hN_pimNelas_energies[hN_pimNelas_nfiles] = {
476 10, 20, 30, 40, 50, 60, 70, 80, 90,
477 100, 110, 120, 130, 140, 150, 160, 170, 180, 190,
478 200, 210, 220, 230, 240, 250, 260, 270, 280, 290,
479 300, 340, 380, 420, 460, 500, 540, 580, 620, 660,
480 700, 740, 780, 820, 860, 900, 940, 980,
481 1020, 1060, 1100, 1140, 1180, 1220, 1260,
482 1300, 1340, 1380, 1420, 1460, 1500
483 };
484
485 TGraph2D * hN_pimNelas_graph = new TGraph2D(hN_pimNelas_npoints);
486
487 int ipoint=0;
488 double x, y;
489
490 for(int ifile = 0; ifile < hN_pimNelas_nfiles; ifile++) {
491 // build filename
492 ostringstream hN_datafile;
493 int ke = hN_pimNelas_energies[ifile];
494 hN_datafile << data_dir << "/diff_ang/pim/pim" << ke << ".txt";
495 // read data
496 TGraph * buff = new TGraph(hN_datafile.str().c_str());
497 for(int i=0; i<buff->GetN(); i++) {
498 buff -> GetPoint(i,x,y);
499 hN_pimNelas_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
500 ipoint++;
501 }
502 delete buff;
503 }//loop over files
504
505 hN_pimNelas_graph -> Write("d_pimN_elas_data");
506 delete hN_pimNelas_graph;
507 }
508
509 // kIHNFtCEx, (pi+, pi0, pi-) N
510 {
511 const int hN_piNcex_nfiles = 60;
512 const int hN_piNcex_points_per_file = 21;
513 const int hN_piNcex_npoints = hN_piNcex_points_per_file * hN_piNcex_nfiles;
514
515 int hN_piNcex_energies[hN_piNcex_nfiles] = {
516 10, 20, 30, 40, 50, 60, 70, 80, 90,
517 100, 110, 120, 130, 140, 150, 160, 170, 180, 190,
518 200, 210, 220, 230, 240, 250, 260, 270, 280, 290,
519 300, 340, 380, 420, 460, 500, 540, 580, 620, 660,
520 700, 740, 780, 820, 860, 900, 940, 980,
521 1020, 1060, 1100, 1140, 1180, 1220, 1260,
522 1300, 1340, 1380, 1420, 1460, 1500
523 };
524
525 TGraph2D * hN_piNcex_graph = new TGraph2D(hN_piNcex_npoints);
526
527 int ipoint=0;
528 double x, y;
529
530 for(int ifile = 0; ifile < hN_piNcex_nfiles; ifile++) {
531 // build filename
532 ostringstream hN_datafile;
533 int ke = hN_piNcex_energies[ifile];
534 hN_datafile << data_dir << "/diff_ang/pie/pie" << ke << ".txt";
535 // read data
536 TGraph * buff = new TGraph(hN_datafile.str().c_str());
537 for(int i=0; i<buff->GetN(); i++) {
538 buff -> GetPoint(i,x,y);
539 hN_piNcex_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
540 ipoint++;
541 }
542 delete buff;
543 }//loop over files
544
545 hN_piNcex_graph -> Write("d_piN_cex_data");
546 delete hN_piNcex_graph;
547 }
548
549 // kIHNFtAbs, (pi+, pi0, pi-) N
550 {
551 const int hN_piNabs_nfiles = 19;
552 const int hN_piNabs_points_per_file = 21;
553 const int hN_piNabs_npoints = hN_piNabs_points_per_file * hN_piNabs_nfiles;
554
555 int hN_piNabs_energies[hN_piNabs_nfiles] = {
556 50, 75, 100, 125, 150, 175, 200, 225, 250, 275,
557 300, 325, 350, 375, 400, 425, 450, 475, 500
558 };
559
560 TGraph2D * hN_piNabs_graph = new TGraph2D(hN_piNabs_npoints);
561
562 int ipoint=0;
563 double x, y;
564
565 for(int ifile = 0; ifile < hN_piNabs_nfiles; ifile++) {
566 // build filename
567 ostringstream hN_datafile;
568 int ke = hN_piNabs_energies[ifile];
569 hN_datafile << data_dir << "/diff_ang/pid2p/pid2p" << ke << ".txt";
570 // read data
571 TGraph * buff = new TGraph(hN_datafile.str().c_str());
572 for(int i=0; i<buff->GetN(); i++) {
573 buff -> GetPoint(i,x,y);
574 hN_piNabs_graph -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
575 ipoint++;
576 }
577 delete buff;
578 }//loop over files
579
580 hN_piNabs_graph -> Write("d_piN_abs_data");
581 delete hN_piNabs_graph;
582 }
583
584 // kIHNFtInelas, gamma p -> p pi0
585 {
586 const int hN_gampi0pInelas_nfiles = 29;
587 const int hN_gampi0pInelas_points_per_file = 37;
588 const int hN_gampi0pInelas_npoints = hN_gampi0pInelas_points_per_file * hN_gampi0pInelas_nfiles;
589
590 int hN_gampi0pInelas_energies[hN_gampi0pInelas_nfiles] = {
591 160, 180, 200, 220, 240, 260, 280, 300, 320, 340,
592 360, 380, 400, 450, 500, 550, 600, 650, 700, 750,
593 800, 850, 900, 950, 1000, 1050, 1100, 1150, 1200
594 };
595
596 TGraph2D * fhN2dXSecGamPi0P_Inelas = new TGraph2D(hN_gampi0pInelas_npoints);
597
598 int ipoint=0;
599 double x, y;
600
601 for(int ifile = 0; ifile < hN_gampi0pInelas_nfiles; ifile++) {
602 // build filename
603 ostringstream hN_datafile;
604 int ke = hN_gampi0pInelas_energies[ifile];
605 hN_datafile << data_dir << "/diff_ang/gampi0p/" << ke << "-pi0p.txt";
606 // read data
607 TGraph * buff = new TGraph(hN_datafile.str().c_str());
608 for(int i=0; i<buff->GetN(); i++) {
609 buff -> GetPoint(i,x,y);
610 fhN2dXSecGamPi0P_Inelas -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
611 ipoint++;
612 }
613 delete buff;
614 }//loop over files
615
616 fhN2dXSecGamPi0P_Inelas -> Write("d_gam_pi0p_inel_data");
617 delete fhN2dXSecGamPi0P_Inelas;
618 }
619
620 // kIHNFtInelas, gamma n -> n pi0
621 {
622 const int hN_gampi0nInelas_nfiles = 29;
623 const int hN_gampi0nInelas_points_per_file = 37;
624 const int hN_gampi0nInelas_npoints = hN_gampi0nInelas_points_per_file * hN_gampi0nInelas_nfiles;
625
626 int hN_gampi0nInelas_energies[hN_gampi0nInelas_nfiles] = {
627 160, 180, 200, 220, 240, 260, 280, 300, 320, 340,
628 360, 380, 400, 450, 500, 550, 600, 650, 700, 750,
629 800, 850, 900, 950, 1000, 1050, 1100, 1150, 1200
630 };
631
632 TGraph2D * fhN2dXSecGamPi0N_Inelas = new TGraph2D(hN_gampi0nInelas_npoints);
633
634 int ipoint=0;
635 double x, y;
636
637 for(int ifile = 0; ifile < hN_gampi0nInelas_nfiles; ifile++) {
638 // build filename
639 ostringstream hN_datafile;
640 int ke = hN_gampi0nInelas_energies[ifile];
641 hN_datafile << data_dir << "/diff_ang/gampi0n/" << ke << "-pi0n.txt";
642 // read data
643 TGraph * buff = new TGraph(hN_datafile.str().c_str());
644 for(int i=0; i<buff->GetN(); i++) {
645 buff -> GetPoint(i,x,y);
646 fhN2dXSecGamPi0N_Inelas -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
647 ipoint++;
648 }
649 delete buff;
650 }//loop over files
651
652 fhN2dXSecGamPi0N_Inelas -> Write("d_gam_pi0n_inel_data");
653 delete fhN2dXSecGamPi0N_Inelas;
654 }
655
656 // kIHNFtInelas, gamma p -> n pi+
657 {
658 const int hN_gampipnInelas_nfiles = 29;
659 const int hN_gampipnInelas_points_per_file = 37;
660 const int hN_gampipnInelas_npoints = hN_gampipnInelas_points_per_file * hN_gampipnInelas_nfiles;
661
662 int hN_gampipnInelas_energies[hN_gampipnInelas_nfiles] = {
663 160, 180, 200, 220, 240, 260, 280, 300, 320, 340,
664 360, 380, 400, 450, 500, 550, 600, 650, 700, 750,
665 800, 850, 900, 950, 1000, 1050, 1100, 1150, 1200
666 };
667
668 TGraph2D * fhN2dXSecGamPipN_Inelas = new TGraph2D(hN_gampipnInelas_npoints);
669
670 int ipoint=0;
671 double x, y;
672
673 for(int ifile = 0; ifile < hN_gampipnInelas_nfiles; ifile++) {
674 // build filename
675 ostringstream hN_datafile;
676 int ke = hN_gampipnInelas_energies[ifile];
677 hN_datafile << data_dir << "/diff_ang/gampi+n/" << ke << "-pi+n.txt";
678 // read data
679 TGraph * buff = new TGraph(hN_datafile.str().c_str());
680 for(int i=0; i<buff->GetN(); i++) {
681 buff -> GetPoint(i,x,y);
682 fhN2dXSecGamPipN_Inelas -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
683 ipoint++;
684 }
685 delete buff;
686 }//loop over files
687
688 fhN2dXSecGamPipN_Inelas -> Write("d_gam_pipn_inel_data");
689 delete fhN2dXSecGamPipN_Inelas;
690 }
691
692 // kIHNFtInelas, gamma n -> p pi-
693 {
694 const int hN_gampimpInelas_nfiles = 29;
695 const int hN_gampimpInelas_points_per_file = 37;
696 const int hN_gampimpInelas_npoints = hN_gampimpInelas_points_per_file * hN_gampimpInelas_nfiles;
697
698 int hN_gampimpInelas_energies[hN_gampimpInelas_nfiles] = {
699 160, 180, 200, 220, 240, 260, 280, 300, 320, 340,
700 360, 380, 400, 450, 500, 550, 600, 650, 700, 750,
701 800, 850, 900, 950, 1000, 1050, 1100, 1150, 1200
702 };
703
704 TGraph2D * fhN2dXSecGamPimP_Inelas = new TGraph2D(hN_gampimpInelas_npoints);
705
706 int ipoint=0;
707 double x, y;
708
709 for(int ifile = 0; ifile < hN_gampimpInelas_nfiles; ifile++) {
710 // build filename
711 ostringstream hN_datafile;
712 int ke = hN_gampimpInelas_energies[ifile];
713 hN_datafile << data_dir << "/diff_ang/gampi-p/" << ke << "-pi-p.txt";
714 // read data
715 TGraph * buff = new TGraph(hN_datafile.str().c_str());
716 for(int i=0; i<buff->GetN(); i++) {
717 buff -> GetPoint(i,x,y);
718 fhN2dXSecGamPimP_Inelas -> SetPoint(ipoint,(double)ke,TMath::Cos(x*kPi/180.),y);
719 ipoint++;
720 }
721 delete buff;
722 }//loop over files
723
724 fhN2dXSecGamPimP_Inelas -> Write("d_gam_pimp_inel_data");
725 delete fhN2dXSecGamPimP_Inelas;
726 }
727
728 f.Close();
729}
730//____________________________________________________________________________
731void SaveSplinesToRootFile(void)
732{
733 string filename = "hadxs.root";
734
735 LOG("testINukeHadroData", pNOTICE)
736 << "Saving INTRANUKE hadron x-section splines to file: " << filename;
737
738 //-- load SAID hadron cross section data
739 INukeHadroData * inukd = INukeHadroData::Instance();
740
741 //-- save splines to a ROOT file
742 //
743 // Note: splines are beeing saved to the ROOT files as genie::Spline
744 // objects. To read them back, one in a ROOT session load the GENIE
745 // libraries first using the $GENIE/src/scripts/loadlibs.C script
746 // eg:
747 // root [0] .x $GENIE/src/scripts/loadlibs.C
748 // root [1] TFile f("./hdxs.root");
749 // root [2] pN_tot->Draw();
750 // root [3] pi0N_tot->Draw("same");
751 //
752
753 inukd -> XSecPn_Tot () -> SaveAsROOT(filename, "pn_tot", true);
754 inukd -> XSecPn_Elas () -> SaveAsROOT(filename, "pn_elas", false);
755 inukd -> XSecPn_Reac () -> SaveAsROOT(filename, "pn_reac", false);
756 inukd -> XSecNn_Tot () -> SaveAsROOT(filename, "nn_tot", false);
757 inukd -> XSecNn_Elas () -> SaveAsROOT(filename, "nn_elas", false);
758 inukd -> XSecNn_Reac () -> SaveAsROOT(filename, "nn_reac", false);
759 inukd -> XSecPp_Tot () -> SaveAsROOT(filename, "pp_tot", true);
760 inukd -> XSecPp_Elas () -> SaveAsROOT(filename, "pp_elas", false);
761 inukd -> XSecPp_Reac () -> SaveAsROOT(filename, "pp_reac", false);
762
763 inukd -> XSecPipn_Tot () -> SaveAsROOT(filename, "pipn_tot", false);
764 inukd -> XSecPipn_CEx () -> SaveAsROOT(filename, "pipn_cex", false);
765 inukd -> XSecPipn_Elas () -> SaveAsROOT(filename, "pipn_elas", false);
766 inukd -> XSecPipn_Reac () -> SaveAsROOT(filename, "pipn_reac", false);
767 inukd -> XSecPi0n_Tot () -> SaveAsROOT(filename, "pi0n_tot", false);
768 inukd -> XSecPi0n_CEx () -> SaveAsROOT(filename, "pi0n_cex", false);
769 inukd -> XSecPi0n_Elas () -> SaveAsROOT(filename, "pi0n_elas", false);
770 inukd -> XSecPi0n_Reac () -> SaveAsROOT(filename, "pi0n_reac", false);
771 inukd -> XSecPipp_Tot () -> SaveAsROOT(filename, "pipp_tot", false);
772 inukd -> XSecPipp_CEx () -> SaveAsROOT(filename, "pipp_cex", false);
773 inukd -> XSecPipp_Elas () -> SaveAsROOT(filename, "pipp_elas", false);
774 inukd -> XSecPipp_Reac () -> SaveAsROOT(filename, "pipp_reac", false);
775 inukd -> XSecPipp_Abs () -> SaveAsROOT(filename, "pipp_abs", false);
776 inukd -> XSecPi0p_Tot () -> SaveAsROOT(filename, "pi0p_tot", false);
777 inukd -> XSecPi0p_CEx () -> SaveAsROOT(filename, "pi0p_cex", false);
778 inukd -> XSecPi0p_Elas () -> SaveAsROOT(filename, "pi0p_elas", false);
779 inukd -> XSecPi0p_Reac () -> SaveAsROOT(filename, "pi0p_reac", false);
780 inukd -> XSecPi0p_Abs () -> SaveAsROOT(filename, "pi0p_abs", false);
781
782 inukd -> XSecKpn_Elas () -> SaveAsROOT(filename, "kpn_elas", false);
783 inukd -> XSecKpp_Elas () -> SaveAsROOT(filename, "kpp_elas", false);
784 inukd -> XSecGamp_fs () -> SaveAsROOT(filename, "gamp_fs", false);
785 inukd -> XSecGamn_fs () -> SaveAsROOT(filename, "gamn_fs", false);
786 inukd -> XSecGamN_Tot () -> SaveAsROOT(filename, "gamN_tot", false);
787
788 inukd -> FracPA_Tot () -> SaveAsROOT(filename, "pA_tot", false);
789 inukd -> FracPA_Elas () -> SaveAsROOT(filename, "pA_elas", false);
790 inukd -> FracPA_Inel () -> SaveAsROOT(filename, "pA_inel", false);
791 inukd -> FracPA_CEx () -> SaveAsROOT(filename, "pA_cex", false);
792 inukd -> FracPA_Abs () -> SaveAsROOT(filename, "pA_abs", false);
793 inukd -> FracPA_Pipro () -> SaveAsROOT(filename, "pA_pipro", false);
794 inukd -> FracNA_Tot () -> SaveAsROOT(filename, "nA_tot", false);
795 inukd -> FracNA_Elas () -> SaveAsROOT(filename, "nA_elas", false);
796 inukd -> FracNA_Inel () -> SaveAsROOT(filename, "nA_inel", false);
797 inukd -> FracNA_CEx () -> SaveAsROOT(filename, "nA_cex", false);
798 inukd -> FracNA_Abs () -> SaveAsROOT(filename, "nA_abs", false);
799 inukd -> FracNA_Pipro () -> SaveAsROOT(filename, "nA_pipro", false);
800 inukd -> FracPipA_Tot () -> SaveAsROOT(filename, "pipA_tot", false);
801 inukd -> FracPipA_Elas () -> SaveAsROOT(filename, "pipA_elas", false);
802 inukd -> FracPipA_Inel () -> SaveAsROOT(filename, "pipA_inel", false);
803 inukd -> FracPipA_CEx () -> SaveAsROOT(filename, "pipA_cex", false);
804 inukd -> FracPipA_Abs () -> SaveAsROOT(filename, "pipA_abs", false);
805 inukd -> FracPimA_Tot () -> SaveAsROOT(filename, "pimA_tot", false);
806 inukd -> FracPimA_Elas () -> SaveAsROOT(filename, "pimA_elas", false);
807 inukd -> FracPimA_Inel () -> SaveAsROOT(filename, "pimA_inel", false);
808 inukd -> FracPimA_CEx () -> SaveAsROOT(filename, "pimA_cex", false);
809 inukd -> FracPimA_Abs () -> SaveAsROOT(filename, "pimA_abs", false);
810 inukd -> FracPi0A_Tot () -> SaveAsROOT(filename, "pi0A_tot", false);
811 inukd -> FracPi0A_Elas () -> SaveAsROOT(filename, "pi0A_elas", false);
812 inukd -> FracPi0A_Inel () -> SaveAsROOT(filename, "pi0A_inel", false);
813 inukd -> FracPi0A_CEx () -> SaveAsROOT(filename, "pi0A_cex", false);
814 inukd -> FracPi0A_Abs () -> SaveAsROOT(filename, "pi0A_abs", false);
815}
816//____________________________________________________________________________
817void PrintOutForInputKE(double ke)
818{
819 LOG("testINukeHadroData", pNOTICE)
820 << "Printing out INTRANUKE hadron x-sections";
821
822 //-- load SAID hadron cross section data
823 INukeHadroData * inukd = INukeHadroData::Instance();
824
825 //-- Print out the hN mode hadron x-section
826 LOG("testINukeHadroData", pNOTICE)
827 << "\n hN mode x-sections:"
828 << "\n XSec[pn/tot] (K=" << ke << " MeV) = " << inukd -> XSecPn_Tot () -> Evaluate(ke) << " mbarn"
829 << "\n XSec[pn/elas] (K=" << ke << " MeV) = " << inukd -> XSecPn_Elas () -> Evaluate(ke) << " mbarn"
830 << "\n XSec[pn/reac] (K=" << ke << " MeV) = " << inukd -> XSecPn_Reac () -> Evaluate(ke) << " mbarn"
831 << "\n XSec[nn/tot] (K=" << ke << " MeV) = " << inukd -> XSecNn_Tot () -> Evaluate(ke) << " mbarn"
832 << "\n XSec[nn/elas] (K=" << ke << " MeV) = " << inukd -> XSecNn_Elas () -> Evaluate(ke) << " mbarn"
833 << "\n XSec[nn/reac] (K=" << ke << " MeV) = " << inukd -> XSecNn_Reac () -> Evaluate(ke) << " mbarn"
834 << "\n XSec[pp/tot] (K=" << ke << " MeV) = " << inukd -> XSecPp_Tot () -> Evaluate(ke) << " mbarn"
835 << "\n XSec[pp/elas] (K=" << ke << " MeV) = " << inukd -> XSecPp_Elas () -> Evaluate(ke) << " mbarn"
836 << "\n XSec[pp/reac] (K=" << ke << " MeV) = " << inukd -> XSecPp_Reac () -> Evaluate(ke) << " mbarn"
837 << "\n XSec[pipn/tot] (K=" << ke << " MeV) = " << inukd -> XSecPipn_Tot () -> Evaluate(ke) << " mbarn"
838 << "\n XSec[pipn/cex] (K=" << ke << " MeV) = " << inukd -> XSecPipn_CEx () -> Evaluate(ke) << " mbarn"
839 << "\n XSec[pipn/elas] (K=" << ke << " MeV) = " << inukd -> XSecPipn_Elas () -> Evaluate(ke) << " mbarn"
840 << "\n XSec[pipn/reac] (K=" << ke << " MeV) = " << inukd -> XSecPipn_Reac () -> Evaluate(ke) << " mbarn"
841 << "\n XSec[pi0n/tot] (K=" << ke << " MeV) = " << inukd -> XSecPi0n_Tot () -> Evaluate(ke) << " mbarn"
842 << "\n XSec[pi0n/cex] (K=" << ke << " MeV) = " << inukd -> XSecPi0n_CEx () -> Evaluate(ke) << " mbarn"
843 << "\n XSec[pi0n/elas] (K=" << ke << " MeV) = " << inukd -> XSecPi0n_Elas () -> Evaluate(ke) << " mbarn"
844 << "\n XSec[pi0n/reac] (K=" << ke << " MeV) = " << inukd -> XSecPi0n_Reac () -> Evaluate(ke) << " mbarn"
845 << "\n XSec[pipp/tot] (K=" << ke << " MeV) = " << inukd -> XSecPipp_Tot () -> Evaluate(ke) << " mbarn"
846 << "\n XSec[pipp/cex] (K=" << ke << " MeV) = " << inukd -> XSecPipp_CEx () -> Evaluate(ke) << " mbarn"
847 << "\n XSec[pipp/elas] (K=" << ke << " MeV) = " << inukd -> XSecPipp_Elas () -> Evaluate(ke) << " mbarn"
848 << "\n XSec[pipp/reac] (K=" << ke << " MeV) = " << inukd -> XSecPipp_Reac () -> Evaluate(ke) << " mbarn"
849 << "\n XSec[pipp/abs] (K=" << ke << " MeV) = " << inukd -> XSecPipp_Abs () -> Evaluate(ke) << " mbarn"
850 << "\n XSec[pi0p/tot] (K=" << ke << " MeV) = " << inukd -> XSecPi0p_Tot () -> Evaluate(ke) << " mbarn"
851 << "\n XSec[pi0p/cex] (K=" << ke << " MeV) = " << inukd -> XSecPi0p_CEx () -> Evaluate(ke) << " mbarn"
852 << "\n XSec[pi0p/elas] (K=" << ke << " MeV) = " << inukd -> XSecPi0p_Elas () -> Evaluate(ke) << " mbarn"
853 << "\n XSec[pi0p/reac] (K=" << ke << " MeV) = " << inukd -> XSecPi0p_Reac () -> Evaluate(ke) << " mbarn"
854 << "\n XSec[pi0p/abs] (K=" << ke << " MeV) = " << inukd -> XSecPi0p_Abs () -> Evaluate(ke) << " mbarn"
855 << "\n"
856 << "\n hA mode x-sections:"
857 << "\n Frac[pA/tot] (K=" << ke << " MeV) = " << inukd -> FracPA_Tot () -> Evaluate(ke) << " mbarn"
858 << "\n Frac[pA/elas] (K=" << ke << " MeV) = " << inukd -> FracPA_Elas () -> Evaluate(ke) << " mbarn"
859 << "\n Frac[pA/inel] (K=" << ke << " MeV) = " << inukd -> FracPA_Inel () -> Evaluate(ke) << " mbarn"
860 << "\n Frac[pA/cex] (K=" << ke << " MeV) = " << inukd -> FracPA_CEx () -> Evaluate(ke) << " mbarn"
861 << "\n Frac[pA/abs] (K=" << ke << " MeV) = " << inukd -> FracPA_Abs () -> Evaluate(ke) << " mbarn"
862 << "\n Frac[pA/pipro] (K=" << ke << " MeV) = " << inukd -> FracPA_Pipro () -> Evaluate(ke) << " mbarn"
863 << "\n Frac[nA/tot] (K=" << ke << " MeV) = " << inukd -> FracNA_Tot () -> Evaluate(ke) << " mbarn"
864 << "\n Frac[nA/elas] (K=" << ke << " MeV) = " << inukd -> FracNA_Elas () -> Evaluate(ke) << " mbarn"
865 << "\n Frac[nA/inel] (K=" << ke << " MeV) = " << inukd -> FracNA_Inel () -> Evaluate(ke) << " mbarn"
866 << "\n Frac[nA/reac] (K=" << ke << " MeV) = " << inukd -> FracNA_CEx () -> Evaluate(ke) << " mbarn"
867 << "\n Frac[nA/abs] (K=" << ke << " MeV) = " << inukd -> FracNA_Abs () -> Evaluate(ke) << " mbarn"
868 << "\n Frac[nA/pipro] (K=" << ke << " MeV) = " << inukd -> FracNA_Pipro () -> Evaluate(ke) << " mbarn"
869 << "\n Frac[pipA/tot] (K=" << ke << " MeV) = " << inukd -> FracPipA_Tot () -> Evaluate(ke) << " mbarn"
870 << "\n Frac[pipA/elas] (K=" << ke << " MeV) = " << inukd -> FracPipA_Elas () -> Evaluate(ke) << " mbarn"
871 << "\n Frac[pipA/inel] (K=" << ke << " MeV) = " << inukd -> FracPipA_Inel () -> Evaluate(ke) << " mbarn"
872 << "\n Frac[pipA/cex] (K=" << ke << " MeV) = " << inukd -> FracPipA_CEx () -> Evaluate(ke) << " mbarn"
873 << "\n Frac[pipA/abs] (K=" << ke << " MeV) = " << inukd -> FracPipA_Abs () -> Evaluate(ke) << " mbarn"
874 << "\n Frac[pimA/tot] (K=" << ke << " MeV) = " << inukd -> FracPimA_Tot () -> Evaluate(ke) << " mbarn"
875 << "\n Frac[pimA/elas] (K=" << ke << " MeV) = " << inukd -> FracPimA_Elas () -> Evaluate(ke) << " mbarn"
876 << "\n Frac[pimA/inel] (K=" << ke << " MeV) = " << inukd -> FracPimA_Inel () -> Evaluate(ke) << " mbarn"
877 << "\n Frac[pimA/cex] (K=" << ke << " MeV) = " << inukd -> FracPimA_CEx () -> Evaluate(ke) << " mbarn"
878 << "\n Frac[pimA/abs] (K=" << ke << " MeV) = " << inukd -> FracPimA_Abs () -> Evaluate(ke) << " mbarn"
879 << "\n Frac[pi0A/tot] (K=" << ke << " MeV) = " << inukd -> FracPi0A_Tot () -> Evaluate(ke) << " mbarn"
880 << "\n Frac[pi0A/elas] (K=" << ke << " MeV) = " << inukd -> FracPi0A_Elas () -> Evaluate(ke) << " mbarn"
881 << "\n Frac[pi0A/inel] (K=" << ke << " MeV) = " << inukd -> FracPi0A_Inel () -> Evaluate(ke) << " mbarn"
882 << "\n Frac[pi0A/cex] (K=" << ke << " MeV) = " << inukd -> FracPi0A_CEx () -> Evaluate(ke) << " mbarn"
883 << "\n Frac[pi0A/abs] (K=" << ke << " MeV) = " << inukd -> FracPi0A_Abs () -> Evaluate(ke) << " mbarn";
884}
885//____________________________________________________________________________
886
pNOTICE
#define pNOTICE
Definition Messenger.h:61
pINFO
#define pINFO
Definition Messenger.h:62
LOG
#define LOG(stream, priority)
A macro that returns the requested log4cpp::Category appending a string (using the FILE,...
Definition Messenger.h:96
PDGCodes.h
Most commonly used PDG codes. A set of utility functions to handle PDG codes is provided in PDGUtils.
main
int main()
Definition Validation.cpp:290
genie::CmdLnArgParser
Command line argument parser.
Definition CmdLnArgParser.h:29
genie::CmdLnArgParser::OptionExists
bool OptionExists(char opt)
was option set?
Definition CmdLnArgParser.cxx:88
genie::INukeHadroData
Singleton class to load & serve hadron x-section splines used by GENIE's version of the INTRANUKE cas...
Definition INukeHadroData.h:52
genie::INukeHadroData::XSec
double XSec(int hpdgc, int tgt, int nprod, INukeFateHN_t rxnType, double ke, double costh) const
Definition INukeHadroData.cxx:911
genie::INukeHadroData::Instance
static INukeHadroData * Instance(void)
Definition INukeHadroData.cxx:172
Write
hadnt Write("hadnt")
PrintOutForInputKE
void PrintOutForInputKE(double ke)
Definition gtestINukeHadroData.cxx:817
SaveSplinesToRootFile
void SaveSplinesToRootFile(void)
Definition gtestINukeHadroData.cxx:731
SaveDataToRootFile
void SaveDataToRootFile(bool test_intbounce)
Definition gtestINukeHadroData.cxx:93
genie::constants
Basic constants.
genie
THE MAIN GENIE PROJECT NAMESPACE
Definition AlgCmp.h:25
genie::kPdgProton
const int kPdgProton
Definition PDGCodes.h:81
genie::kPdgPi0
const int kPdgPi0
Definition PDGCodes.h:160
genie::kPdgKP
const int kPdgKP
Definition PDGCodes.h:172
genie::kPdgNeutron
const int kPdgNeutron
Definition PDGCodes.h:83
genie::kPdgPiP
const int kPdgPiP
Definition PDGCodes.h:158
Generated on for GENIEGenerator by doxygen 1.14.0