HepMC3 event record library
convert_example.cc
1 // -*- C++ -*-
2 //
3 // This file is part of HepMC
4 // Copyright (C) 2014-2019 The HepMC collaboration (see AUTHORS for details)
5 //
6 /// @example convert_example.cc
7 /// @brief Utility to convert between different types of event records
8 ///
9 #include "HepMC3/Print.h"
10 #include "HepMC3/GenEvent.h"
11 #include "HepMC3/Reader.h"
14 #include "HepMC3/ReaderAscii.h"
15 #include "HepMC3/WriterAscii.h"
16 #include "HepMC3/WriterHEPEVT.h"
17 #include "HepMC3/WriterPlugin.h"
18 #include "HepMC3/ReaderHEPEVT.h"
19 #include "HepMC3/ReaderLHEF.h"
20 #include "HepMC3/ReaderPlugin.h"
21 #include "HepMC3/ReaderFactory.h"
22 
23 #ifdef HEPMC3_ROOTIO
24 #include "HepMC3/ReaderRoot.h"
25 #include "HepMC3/WriterRoot.h"
26 #include "HepMC3/ReaderRootTree.h"
27 #include "HepMC3/WriterRootTree.h"
28 #endif
29 
30 /* Extension example*/
31 #ifdef HEPMCCONVERT_EXTENSION_ROOTTREEOPAL
32 #ifndef HEPMC3_ROOTIO
33 #warning "HEPMCCONVERT_EXTENSION_ROOTTREEOPAL requires compilation with of HepMC with ROOT, i.e. HEPMC3_ROOTIO.This extension will be disabled."
34 #undef HEPMCCONVERT_EXTENSION_ROOTTREEOPAL
35 #else
36 #include "WriterRootTreeOPAL.h"
37 #endif
38 #endif
39 #ifdef HEPMCCONVERT_EXTENSION_HEPEVTZEUS
40 #include "WriterHEPEVTZEUS.h"
41 #endif
42 #ifdef HEPMCCONVERT_EXTENSION_DOT
43 #include "WriterDOT.h"
44 #endif
45 #ifdef HEPMCCONVERT_EXTENSION_GZ
46 #include "ReaderGZ.h"
47 #endif
48 
49 
50 
51 #include "cmdline.h"
52 using namespace HepMC3;
53 enum formats {autodetect, hepmc2, hepmc3, hpe ,root, treeroot ,treerootopal, hpezeus, lhef, dump, dot, gz, plugin, none};
54 int main(int argc, char** argv)
55 {
56  gengetopt_args_info ai;
57  if (cmdline_parser (argc, argv, &ai) != 0) {
58  exit(1);
59  }
60  if (ai.inputs_num!=2)
61  {
62  printf("Exactly two arguments are requred: the name of input and output files\n");
63  exit(1);
64  }
65  std::map<std::string,formats> format_map;
66  format_map.insert(std::pair<std::string,formats> ( "auto", autodetect ));
67  format_map.insert(std::pair<std::string,formats> ( "hepmc2", hepmc2 ));
68  format_map.insert(std::pair<std::string,formats> ( "hepmc3", hepmc3 ));
69  format_map.insert(std::pair<std::string,formats> ( "hpe", hpe ));
70  format_map.insert(std::pair<std::string,formats> ( "root", root ));
71  format_map.insert(std::pair<std::string,formats> ( "treeroot", treeroot ));
72  format_map.insert(std::pair<std::string,formats> ( "treerootopal", treerootopal ));
73  format_map.insert(std::pair<std::string,formats> ( "hpezeus", hpezeus ));
74  format_map.insert(std::pair<std::string,formats> ( "lhef", lhef ));
75  format_map.insert(std::pair<std::string,formats> ( "dump", dump ));
76  format_map.insert(std::pair<std::string,formats> ( "dot", dot ));
77  format_map.insert(std::pair<std::string,formats> ( "gz", gz ));
78  format_map.insert(std::pair<std::string,formats> ( "plugin", plugin ));
79  format_map.insert(std::pair<std::string,formats> ( "none", none ));
80  std::map<std::string, std::string> options;
81  for (size_t i=0; i<ai.extensions_given; i++)
82  {
83  std::string optarg=std::string(ai.extensions_arg[i]);
84  size_t pos=optarg.find_first_of('=');
85  if (pos<optarg.length())
86  options[std::string(optarg,0,pos)]=std::string(optarg,pos+1,optarg.length());
87  }
88  long int events_parsed = 0;
89  long int events_limit = ai.events_limit_arg;
90  long int first_event_number = ai.first_event_number_arg;
91  long int last_event_number = ai.last_event_number_arg;
92  long int print_each_events_parsed = ai.print_every_events_parsed_arg;
93  std::string InputPluginLibrary;
94  std::string InputPluginName;
95 
96  std::string OutputPluginLibrary;
97  std::string OutputPluginName;
98 
99  std::shared_ptr<Reader> input_file;
100  bool input_is_stdin=(std::string(ai.inputs[0])==std::string("-"));
101  if (input_is_stdin) std::ios_base::sync_with_stdio(false);
102  bool ignore_writer=false;
103  switch (format_map.at(std::string(ai.input_format_arg)))
104  {
105  case autodetect:
106  input_file=(input_is_stdin?deduce_reader(std::cin):deduce_reader(ai.inputs[0]));
107  if (!input_file)
108  {
109  input_is_stdin?printf("Input format detection for std input has failed\n"):printf("Input format detection for file %s has failed\n",ai.inputs[0]);
110  exit(2);
111  }
112  break;
113  case hepmc2:
114  input_file=(input_is_stdin?std::make_shared<ReaderAsciiHepMC2>(std::cin):std::make_shared<ReaderAsciiHepMC2>(ai.inputs[0]));
115  break;
116  case hepmc3:
117  input_file=(input_is_stdin?std::make_shared<ReaderAscii>(std::cin):std::make_shared<ReaderAscii>(ai.inputs[0]));
118  break;
119  case hpe:
120  input_file=(input_is_stdin?std::make_shared<ReaderHEPEVT>(std::cin):std::make_shared<ReaderHEPEVT>(ai.inputs[0]));
121  break;
122  case lhef:
123  input_file=(input_is_stdin?std::make_shared<ReaderLHEF>(std::cin):std::make_shared<ReaderLHEF>(ai.inputs[0]));
124  break;
125  case gz:
126 #ifdef HEPMCCONVERT_EXTENSION_GZ
127  input_file=std::make_shared<ReaderGZ>(ai.inputs[0]);
128  break;
129 #else
130  printf("Input format %s is not supported\n",ai.input_format_arg);
131  exit(2);
132 #endif
133  case treeroot:
134 #ifdef HEPMC3_ROOTIO
135  input_file=std::make_shared<ReaderRootTree>(ai.inputs[0]);
136  break;
137 #else
138  printf("Input format %s is not supported\n",ai.input_format_arg);
139  exit(2);
140 #endif
141  case root:
142 #ifdef HEPMC3_ROOTIO
143  input_file=std::make_shared<ReaderRoot>(ai.inputs[0]);
144  break;
145 #else
146  printf("Input format %s is not supported\n",ai.input_format_arg);
147  exit(2);
148 #endif
149  case plugin:
150  if (options.find("InputPluginLibrary")==options.end()) { printf("InputPluginLibrary option required\n"); exit(2);} else InputPluginLibrary=options.at("InputPluginLibrary");
151  if (options.find("InputPluginName")==options.end()) { printf("InputPluginName option required\n"); exit(2);} else InputPluginName=options.at("InputPluginName");
152  input_file=std::make_shared<ReaderPlugin>(std::string(ai.inputs[0]),InputPluginLibrary,InputPluginName);
153  if (input_file->failed()) { printf("Plugin initialization failed\n"); exit(2);}
154  break;
155  default:
156  printf("Input format %s is not known\n",ai.input_format_arg);
157  exit(2);
158  break;
159  }
160  std::shared_ptr<Writer> output_file;
161  switch (format_map.at(std::string(ai.output_format_arg)))
162  {
163  case hepmc2:
164  output_file=std::make_shared<WriterAsciiHepMC2>(ai.inputs[1]);
165  break;
166  case hepmc3:
167  output_file=std::make_shared<WriterAscii>(ai.inputs[1]);
168  break;
169  case hpe:
170  output_file=std::make_shared<WriterHEPEVT>(ai.inputs[1]);
171  break;
172  case root:
173 #ifdef HEPMC3_ROOTIO
174  output_file=std::make_shared<WriterRoot>(ai.inputs[1]);
175  break;
176 #else
177  printf("Output format %s is not supported\n",ai.output_format_arg);
178  exit(2);
179 #endif
180  case treeroot:
181 #ifdef HEPMC3_ROOTIO
182  output_file=std::make_shared<WriterRootTree>(ai.inputs[1]);
183  break;
184 #else
185  printf("Output format %s is not supported\n",ai.output_format_arg);
186  exit(2);
187 #endif
188  /* Extension example*/
189  case treerootopal:
190 #ifdef HEPMCCONVERT_EXTENSION_ROOTTREEOPAL
191  output_file=std::make_shared<WriterRootTreeOPAL>(ai.inputs[1]);
192  (std::dynamic_pointer_cast<WriterRootTreeOPAL>(output_file))->init_branches();
193  if (options.find("Run")!=options.end()) (std::dynamic_pointer_cast<WriterRootTreeOPAL>(output_file))->set_run_number(std::atoi(options.at("Run").c_str()));
194  break;
195 #else
196  printf("Output format %s is not supported\n",ai.output_format_arg);
197  exit(2);
198  break;
199 #endif
200  case hpezeus:
201 #ifdef HEPMCCONVERT_EXTENSION_HEPEVTZEUS
202  output_file=std::make_shared<WriterHEPEVTZEUS>(ai.inputs[1]);
203  break;
204 #else
205  printf("Output format %s is not supported\n",ai.output_format_arg);
206  exit(2);
207 #endif
208  case dot:
209 #ifdef HEPMCCONVERT_EXTENSION_DOT
210  output_file=std::make_shared<WriterDOT>(ai.inputs[1]);
211  if (options.find("Style")!=options.end()) (std::dynamic_pointer_cast<WriterDOT>(output_file))->set_style(std::atoi(options.at("Style").c_str()));
212  break;
213 #else
214  printf("Output format %s is not supported\n",ai.output_format_arg);
215  exit(2);
216  break;
217 #endif
218  case plugin:
219  if (options.find("OutputPluginLibrary")==options.end()) { printf("OutputPluginLibrary option required, e.g. OutputPluginLibrary=libAnalysis.so\n"); exit(2);} else OutputPluginLibrary=options.at("OutputPluginLibrary");
220  if (options.find("OutputPluginName")==options.end()) { printf("OutputPluginName option required, e.g. OutputPluginName=newAnalysisExamplefile\n"); exit(2);} else OutputPluginName=options.at("OutputPluginName");
221  output_file=std::make_shared<WriterPlugin>(std::string(ai.inputs[1]),OutputPluginLibrary,OutputPluginName);
222  if (output_file->failed()) { printf("Plugin initialization failed\n"); exit(2);}
223  break;
224  case dump:
225  output_file=NULL;
226  break;
227  case none:
228  output_file=NULL;
229  ignore_writer=true;
230  break;
231  default:
232  printf("Output format %s is not known\n",ai.output_format_arg);
233  exit(2);
234  break;
235  }
236  while( !input_file->failed() )
237  {
238  GenEvent evt(Units::GEV,Units::MM);
239  input_file->read_event(evt);
240  if( input_file->failed() ) {
241  printf("End of file reached. Exit.\n");
242  break;
243  }
244  if (evt.event_number()<first_event_number) continue;
245  if (evt.event_number()>last_event_number) continue;
246  evt.set_run_info(input_file->run_info());
247  //Note the difference between ROOT and Ascii readers. The former read GenRunInfo before first event and the later at the same time as first event.
248  if (!ignore_writer)
249  {
250  if (output_file)
251  {
252  output_file->write_event(evt);
253  }
254  else
255  {
256  Print::content(evt);
257  }
258  }
259  evt.clear();
260  ++events_parsed;
261  if( events_parsed%print_each_events_parsed == 0 ) printf("Events parsed: %li\n",events_parsed);
262  if( events_parsed >= events_limit ) {
263  printf("Event limit reached:->events_parsed(%li) >= events_limit(%li)<-. Exit.\n",events_parsed , events_limit);
264  break;
265  }
266  }
267 
268  if (input_file) input_file->close();
269  if (output_file) output_file->close();
270  cmdline_parser_free(&ai);
271  return EXIT_SUCCESS;
272 }
Definition of class WriterHEPEVT.
Definition of class ReaderHEPEVT.
Definition of interface Reader.
GenEvent I/O output to files similar to these produced by OPAL software.
Definition of class WriterRootTree.
Definition of class WriterAscii.
Definition: pytypes.h:1064
Definition of class ReaderRootTree.
Definition of class ReaderRoot.
std::shared_ptr< Reader > deduce_reader(std::istream &stream)
This function will deduce the type of input stream based on its content and will return appropriate R...
Definition of class ReaderAsciiHepMC2.
Stores event-related information.
Definition: GenEvent.h:41
Definition of class WriterPlugin.
Definition of class ReaderAscii.
Definition of class WriterAsciiHepMC2.
Definition of class WriterRoot.
Definition of class ReaderPlugin.
int main(int argc, char **argv)
Definition of class WriterRootTreeOPAL.
Definition of class WriterDOT.
Definition of class GenEvent.
Definition of class WriterHEPEVTZEUS.
Definition of class ReaderLHEF.
Definition of class ReaderGZ.
static void content(std::ostream &os, const GenEvent &event)
Print content of all GenEvent containers.
Definition: Print.cc:17