CHROMA
inline_hadspec_w.cc
Go to the documentation of this file.
1 /*! \file
2  * \brief Inline construction of hadron spectrum
3  *
4  * Spectrum calculations
5  */
6 
9 #include "meas/glue/mesplq.h"
10 #include "util/ft/sftmom.h"
11 #include "util/info/proginfo.h"
12 #include "io/param_io.h"
13 #include "io/qprop_io.h"
14 #include "meas/hadron/mesons2_w.h"
15 #include "meas/hadron/barhqlq_w.h"
16 #include "meas/hadron/curcor2_w.h"
20 
21 namespace Chroma
22 {
23  namespace InlineHadSpecEnv
24  {
25  namespace
26  {
27  AbsInlineMeasurement* createMeasurement(XMLReader& xml_in,
28  const std::string& path)
29  {
30  return new InlineHadSpec(InlineHadSpecParams(xml_in, path));
31  }
32 
33  //! Local registration flag
34  bool registered = false;
35  }
36 
37  const std::string name = "HADRON_SPECTRUM";
38 
39  //! Register all the factories
40  bool registerAll()
41  {
42  bool success = true;
43  if (! registered)
44  {
45  success &= TheInlineMeasurementFactory::Instance().registerObject(name, createMeasurement);
46  registered = true;
47  }
48  return success;
49  }
50  }
51 
52 
53 
54  //! Reader for parameters
55  void read(XMLReader& xml, const std::string& path, InlineHadSpecParams::Param_t& param)
56  {
57  XMLReader paramtop(xml, path);
58 
59  int version;
60  read(paramtop, "version", version);
61 
62  switch (version)
63  {
64  case 1:
65  break;
66 
67  default:
68  QDPIO::cerr << "Input parameter version " << version << " unsupported." << std::endl;
69  QDP_abort(1);
70  }
71 
72  read(paramtop, "MesonP", param.MesonP);
73  read(paramtop, "CurrentP", param.CurrentP);
74  read(paramtop, "BaryonP", param.BaryonP);
75  read(paramtop, "time_rev", param.time_rev);
76 
77  read(paramtop, "mom2_max", param.mom2_max);
78  read(paramtop, "avg_equiv_mom", param.avg_equiv_mom);
79  }
80 
81 
82  //! Writer for parameters
83  void write(XMLWriter& xml, const std::string& path, const InlineHadSpecParams::Param_t& param)
84  {
85  push(xml, path);
86 
87  int version = 1;
88  write(xml, "version", version);
89 
90  write(xml, "MesonP", param.MesonP);
91  write(xml, "CurrentP", param.CurrentP);
92  write(xml, "BaryonP", param.BaryonP);
93 
94  write(xml, "time_rev", param.time_rev);
95 
96  write(xml, "mom2_max", param.mom2_max);
97  write(xml, "avg_equiv_mom", param.avg_equiv_mom);
98 
99  pop(xml);
100  }
101 
102 
103  //! Propagator input
104  void read(XMLReader& xml, const std::string& path, InlineHadSpecParams::NamedObject_t::Props_t& input)
105  {
106  XMLReader inputtop(xml, path);
107 
108  read(inputtop, "first_id", input.first_id);
109  read(inputtop, "second_id", input.second_id);
110  }
111 
112  //! Propagator output
113  void write(XMLWriter& xml, const std::string& path, const InlineHadSpecParams::NamedObject_t::Props_t& input)
114  {
115  push(xml, path);
116 
117  write(xml, "first_id", input.first_id);
118  write(xml, "second_id", input.second_id);
119 
120  pop(xml);
121  }
122 
123 
124  //! Propagator input
125  void read(XMLReader& xml, const std::string& path, InlineHadSpecParams::NamedObject_t& input)
126  {
127  XMLReader inputtop(xml, path);
128 
129  read(inputtop, "gauge_id", input.gauge_id);
130  read(inputtop, "sink_pairs", input.sink_pairs);
131  }
132 
133  //! Propagator output
134  void write(XMLWriter& xml, const std::string& path, const InlineHadSpecParams::NamedObject_t& input)
135  {
136  push(xml, path);
137 
138  write(xml, "gauge_id", input.gauge_id);
139  write(xml, "sink_pairs", input.sink_pairs);
140 
141  pop(xml);
142  }
143 
144 
145  // Param stuff
147  {
148  frequency = 0;
149  }
150 
151  InlineHadSpecParams::InlineHadSpecParams(XMLReader& xml_in, const std::string& path)
152  {
153  try
154  {
155  XMLReader paramtop(xml_in, path);
156 
157  if (paramtop.count("Frequency") == 1)
158  read(paramtop, "Frequency", frequency);
159  else
160  frequency = 1;
161 
162  // Parameters for source construction
163  read(paramtop, "Param", param);
164 
165  // Read in the output propagator/source configuration info
166  read(paramtop, "NamedObject", named_obj);
167 
168  // Possible alternate XML file pattern
169  if (paramtop.count("xml_file") != 0)
170  {
171  read(paramtop, "xml_file", xml_file);
172  }
173  }
174  catch(const std::string& e)
175  {
176  QDPIO::cerr << __func__ << ": Caught Exception reading XML: " << e << std::endl;
177  QDP_abort(1);
178  }
179  }
180 
181 
182  void
183  InlineHadSpecParams::write(XMLWriter& xml_out, const std::string& path)
184  {
185  push(xml_out, path);
186 
187  Chroma::write(xml_out, "Param", param);
188  Chroma::write(xml_out, "NamedObject", named_obj);
189  QDP::write(xml_out, "xml_file", xml_file);
190 
191  pop(xml_out);
192  }
193 
194 
195 
196  // Anonymous namespace
197  namespace
198  {
199  //! Useful structure holding sink props
200  struct SinkPropContainer_t
201  {
202  ForwardProp_t prop_header;
204  Real Mass;
205 
206  multi1d<int> bc;
207 
212  };
213 
214 
215  //! Useful structure holding sink props
216  struct AllSinkProps_t
217  {
218  SinkPropContainer_t sink_prop_1;
219  SinkPropContainer_t sink_prop_2;
220  };
221 
222 
223  //! Read a sink prop
224  void readSinkProp(SinkPropContainer_t& s, const std::string& id)
225  {
226  try
227  {
228  // Try a cast to see if it succeeds
229  const LatticePropagator& foo =
230  TheNamedObjMap::Instance().getData<LatticePropagator>(id);
231 
232  // Snarf the data into a copy
233  s.quark_propagator_id = id;
234 
235  // Snarf the prop info. This is will throw if the prop_id is not there
236  XMLReader prop_file_xml, prop_record_xml;
237  TheNamedObjMap::Instance().get(id).getFileXML(prop_file_xml);
238  TheNamedObjMap::Instance().get(id).getRecordXML(prop_record_xml);
239 
240  // Try to invert this record XML into a ChromaProp struct
241  // Also pull out the id of this source
242  {
243  std::string xpath;
244  read(prop_record_xml, "/SinkSmear", s.prop_header);
245 
246  read(prop_record_xml, "/SinkSmear/PropSource/Source/SourceType", s.source_type);
247  xpath = "/SinkSmear/PropSource/Source/Displacement/DisplacementType";
248  if (prop_record_xml.count(xpath) != 0)
249  read(prop_record_xml, xpath, s.source_disp_type);
250  else
251  s.source_disp_type = NoQuarkDisplacementEnv::getName();
252 
253  read(prop_record_xml, "/SinkSmear/PropSink/Sink/SinkType", s.sink_type);
254  xpath = "/SinkSmear/PropSink/Sink/Displacement/DisplacementType";
255  if (prop_record_xml.count(xpath) != 0)
256  read(prop_record_xml, xpath, s.sink_disp_type);
257  else
258  s.sink_disp_type = NoQuarkDisplacementEnv::getName();
259  }
260  }
261  catch( std::bad_cast )
262  {
263  QDPIO::cerr << InlineHadSpecEnv::name << ": caught dynamic cast error"
264  << std::endl;
265  QDP_abort(1);
266  }
267  catch (const std::string& e)
268  {
269  QDPIO::cerr << InlineHadSpecEnv::name << ": error message: " << e
270  << std::endl;
271  QDP_abort(1);
272  }
273 
274 
275  // Derived from input prop
276  // Hunt around to find the mass
277  // NOTE: this may be problematic in the future if actions are used with no
278  // clear def. of a Mass
279  QDPIO::cout << "Try action and mass" << std::endl;
280  s.Mass = getMass(s.prop_header.prop_header.fermact);
281 
282  // Only baryons care about boundaries
283  // Try to find them. If not present, assume dirichlet.
284  // This turns off any attempt to time reverse which is the
285  // only thing that the BC are affecting.
286  s.bc.resize(Nd);
287  s.bc = 0;
288 
289  try
290  {
291  s.bc = getFermActBoundary(s.prop_header.prop_header.fermact);
292  }
293  catch (const std::string& e)
294  {
295  QDPIO::cerr << InlineHadSpecEnv::name
296  << ": caught exception. No BC found in these headers. Will assume dirichlet: " << e
297  << std::endl;
298  }
299 
300  QDPIO::cout << "FermAct = " << s.prop_header.prop_header.fermact.id << std::endl;
301  QDPIO::cout << "Mass = " << s.Mass << std::endl;
302  }
303 
304 
305  //! Read all sinks
306  void readAllSinks(AllSinkProps_t& s,
307  InlineHadSpecParams::NamedObject_t::Props_t sink_pair)
308  {
309  QDPIO::cout << "Attempt to parse forward propagator = " << sink_pair.first_id << std::endl;
310  readSinkProp(s.sink_prop_1, sink_pair.first_id);
311  QDPIO::cout << "Forward propagator successfully parsed" << std::endl;
312 
313  QDPIO::cout << "Attempt to parse forward propagator = " << sink_pair.second_id << std::endl;
314  readSinkProp(s.sink_prop_2, sink_pair.second_id);
315  QDPIO::cout << "Forward propagator successfully parsed" << std::endl;
316  }
317 
318  } // namespace anonymous
319 
320 
321 
322  // Function call
323  void
324  InlineHadSpec::operator()(unsigned long update_no,
325  XMLWriter& xml_out)
326  {
327  // If xml file not empty, then use alternate
328  if (params.xml_file != "")
329  {
330  std::string xml_file = makeXMLFileName(params.xml_file, update_no);
331 
332  push(xml_out, "hadspec");
333  write(xml_out, "update_no", update_no);
334  write(xml_out, "xml_file", xml_file);
335  pop(xml_out);
336 
337  XMLFileWriter xml(xml_file);
338  func(update_no, xml);
339  }
340  else
341  {
342  func(update_no, xml_out);
343  }
344  }
345 
346 
347  // Real work done here
348  void
349  InlineHadSpec::func(unsigned long update_no,
350  XMLWriter& xml_out)
351  {
352  START_CODE();
353 
354  StopWatch snoop;
355  snoop.reset();
356  snoop.start();
357 
358  // Test and grab a reference to the gauge field
359  XMLBufferWriter gauge_xml;
360  try
361  {
362  TheNamedObjMap::Instance().getData< multi1d<LatticeColorMatrix> >(params.named_obj.gauge_id);
363  TheNamedObjMap::Instance().get(params.named_obj.gauge_id).getRecordXML(gauge_xml);
364  }
365  catch( std::bad_cast )
366  {
367  QDPIO::cerr << InlineHadSpecEnv::name << ": caught dynamic cast error"
368  << std::endl;
369  QDP_abort(1);
370  }
371  catch (const std::string& e)
372  {
373  QDPIO::cerr << InlineHadSpecEnv::name << ": std::map call failed: " << e
374  << std::endl;
375  QDP_abort(1);
376  }
377  const multi1d<LatticeColorMatrix>& u =
378  TheNamedObjMap::Instance().getData< multi1d<LatticeColorMatrix> >(params.named_obj.gauge_id);
379 
380  push(xml_out, "hadspec");
381  write(xml_out, "update_no", update_no);
382 
383  QDPIO::cout << " HADSPEC: Spectroscopy for Wilson-like fermions" << std::endl;
384  QDPIO::cout << std::endl << " Gauge group: SU(" << Nc << ")" << std::endl;
385  QDPIO::cout << " volume: " << Layout::lattSize()[0];
386  for (int i=1; i<Nd; ++i) {
387  QDPIO::cout << " x " << Layout::lattSize()[i];
388  }
389  QDPIO::cout << std::endl;
390 
391  proginfo(xml_out); // Print out basic program info
392 
393  // Write out the input
394  params.write(xml_out, "Input");
395 
396  // Write out the config info
397  write(xml_out, "Config_info", gauge_xml);
398 
399  push(xml_out, "Output_version");
400  write(xml_out, "out_version", 15);
401  pop(xml_out);
402 
403 
404  // First calculate some gauge invariant observables just for info.
405  MesPlq(xml_out, "Observables", u);
406 
407  // Keep an array of all the xml output buffers
408  push(xml_out, "Wilson_hadron_measurements");
409 
410  // Now loop over the various fermion pairs
411  for(int lpair=0; lpair < params.named_obj.sink_pairs.size(); ++lpair)
412  {
414 
415  push(xml_out, "elem");
416 
417  AllSinkProps_t all_sinks;
418  readAllSinks(all_sinks, named_obj);
419 
420  // Derived from input prop
421  multi1d<int> t_srce
422  = all_sinks.sink_prop_1.prop_header.source_header.getTSrce();
423  int j_decay = all_sinks.sink_prop_1.prop_header.source_header.j_decay;
424  int t0 = all_sinks.sink_prop_1.prop_header.source_header.t_source;
425 
426  // Sanity checks
427  {
428  if (all_sinks.sink_prop_2.prop_header.source_header.j_decay != j_decay)
429  {
430  QDPIO::cerr << "Error!! j_decay must be the same for all propagators " << std::endl;
431  QDP_abort(1);
432  }
433  if (all_sinks.sink_prop_2.prop_header.source_header.t_source !=
434  all_sinks.sink_prop_1.prop_header.source_header.t_source)
435  {
436  QDPIO::cerr << "Error!! t_source must be the same for all propagators " << std::endl;
437  QDP_abort(1);
438  }
439  if (all_sinks.sink_prop_1.source_type != all_sinks.sink_prop_2.source_type)
440  {
441  QDPIO::cerr << "Error!! source_type must be the same in a pair " << std::endl;
442  QDP_abort(1);
443  }
444  if (all_sinks.sink_prop_1.sink_type != all_sinks.sink_prop_2.sink_type)
445  {
446  QDPIO::cerr << "Error!! source_type must be the same in a pair " << std::endl;
447  QDP_abort(1);
448  }
449  }
450 
451  // Only baryons care about bc
452  int bc_spec = 0;
453  if (params.param.BaryonP)
454  {
455  bc_spec = all_sinks.sink_prop_1.bc[j_decay] ;
456  if (all_sinks.sink_prop_2.bc[j_decay] != bc_spec)
457  {
458  QDPIO::cerr << "Error!! bc must be the same for all propagators " << std::endl;
459  QDP_abort(1);
460  }
461  }
462 
463 
464  // Initialize the slow Fourier transform phases
466  j_decay);
467 
468  // Keep a copy of the phases with NO momenta
469  SftMom phases_nomom(0, true, j_decay);
470 
471  // Masses
472  write(xml_out, "Mass_1", all_sinks.sink_prop_1.Mass);
473  write(xml_out, "Mass_2", all_sinks.sink_prop_2.Mass);
474  write(xml_out, "t0", t0);
475 
476  // Save prop input
477  push(xml_out, "Forward_prop_headers");
478  write(xml_out, "First_forward_prop", all_sinks.sink_prop_1.prop_header);
479  write(xml_out, "Second_forward_prop", all_sinks.sink_prop_2.prop_header);
480  pop(xml_out);
481 
482  // Sanity check - write out the norm2 of the forward prop in the j_decay direction
483  // Use this for any possible verification
484  push(xml_out, "Forward_prop_correlator");
485  {
486  const LatticePropagator& sink_prop_1 =
487  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks.sink_prop_1.quark_propagator_id);
488  const LatticePropagator& sink_prop_2 =
489  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks.sink_prop_2.quark_propagator_id);
490 
491  write(xml_out, "forward_prop_corr_1", sumMulti(localNorm2(sink_prop_1), phases.getSet()));
492  write(xml_out, "forward_prop_corr_2", sumMulti(localNorm2(sink_prop_2), phases.getSet()));
493  }
494  pop(xml_out);
495 
496 
497  push(xml_out, "SourceSinkType");
498  {
499  QDPIO::cout << "Source_type_1 = " << all_sinks.sink_prop_1.source_type << std::endl;
500  QDPIO::cout << "Sink_type_1 = " << all_sinks.sink_prop_1.sink_type << std::endl;
501  QDPIO::cout << "Source_type_2 = " << all_sinks.sink_prop_2.source_type << std::endl;
502  QDPIO::cout << "Sink_type_2 = " << all_sinks.sink_prop_2.sink_type << std::endl;
503 
504  write(xml_out, "source_type_1", all_sinks.sink_prop_1.source_type);
505  write(xml_out, "source_disp_type_1", all_sinks.sink_prop_1.source_disp_type);
506  write(xml_out, "sink_type_1", all_sinks.sink_prop_1.sink_type);
507  write(xml_out, "sink_disp_type_1", all_sinks.sink_prop_1.sink_disp_type);
508 
509  write(xml_out, "source_type_2", all_sinks.sink_prop_2.source_type);
510  write(xml_out, "source_disp_type_2", all_sinks.sink_prop_2.source_disp_type);
511  write(xml_out, "sink_type_2", all_sinks.sink_prop_2.sink_type);
512  write(xml_out, "sink_disp_type_2", all_sinks.sink_prop_2.sink_disp_type);
513  }
514  pop(xml_out);
515 
516 
517  // References for use later
518  const LatticePropagator& sink_prop_1 =
519  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks.sink_prop_1.quark_propagator_id);
520  const LatticePropagator& sink_prop_2 =
521  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks.sink_prop_2.quark_propagator_id);
522 
523 
524  // Construct group name for output
525  std::string src_type;
526  if (all_sinks.sink_prop_1.source_type == "POINT_SOURCE")
527  src_type = "Point";
528  else if (all_sinks.sink_prop_1.source_type == "SF_POINT_SOURCE")
529  src_type = "Point";
530  else if (all_sinks.sink_prop_1.source_type == "SHELL_SOURCE")
531  src_type = "Shell";
532  else if (all_sinks.sink_prop_1.source_type == "NORM_SHELL_SOURCE")
533  src_type = "Shell";
534  else if (all_sinks.sink_prop_1.source_type == "SF_SHELL_SOURCE")
535  src_type = "Shell";
536  else if (all_sinks.sink_prop_1.source_type == "WALL_SOURCE")
537  src_type = "Wall";
538  else if (all_sinks.sink_prop_1.source_type == "SF_WALL_SOURCE")
539  src_type = "Wall";
540  else if (all_sinks.sink_prop_1.source_type == "RAND_ZN_WALL_SOURCE")
541  src_type = "Wall";
542  else
543  {
544  QDPIO::cerr << "Unsupported source type = " << all_sinks.sink_prop_1.source_type << std::endl;
545  QDP_abort(1);
546  }
547 
548  std::string snk_type;
549  if (all_sinks.sink_prop_1.sink_type == "POINT_SINK")
550  snk_type = "Point";
551  else if (all_sinks.sink_prop_1.sink_type == "SHELL_SINK")
552  snk_type = "Shell";
553  else if (all_sinks.sink_prop_1.sink_type == "NORM_SHELL_SINK")
554  snk_type = "Shell";
555  else if (all_sinks.sink_prop_1.sink_type == "WALL_SINK")
556  snk_type = "Wall";
557  else
558  {
559  QDPIO::cerr << "Unsupported sink type = " << all_sinks.sink_prop_1.sink_type << std::endl;
560  QDP_abort(1);
561  }
562 
563  std::string source_sink_type = src_type + "_" + snk_type;
564  QDPIO::cout << "Source type = " << src_type << std::endl;
565  QDPIO::cout << "Sink type = " << snk_type << std::endl;
566 
567  // Do the mesons first
568  if (params.param.MesonP)
569  {
570  mesons2(sink_prop_1, sink_prop_2, phases, t0,
571  xml_out, source_sink_type + "_Wilson_Mesons");
572  } // end if (MesonP)
573 
574 
575  // Do the currents next
576  if (params.param.CurrentP)
577  {
578  // Construct the rho std::vector-current and the pion axial current divergence
579  if (snk_type == "Point")
580  {
581  curcor2(u, sink_prop_1, sink_prop_2, phases,
582  t0, 3,
583  xml_out, src_type + "_Point_Meson_Currents");
584  }
585  } // end if (CurrentP)
586 
587 
588  // Do the baryons
589  if (params.param.BaryonP)
590  {
591  barhqlq(sink_prop_2, sink_prop_1, phases,
593  xml_out, source_sink_type + "_Wilson_Baryons");
594  } // end if (BaryonP)
595 
596  pop(xml_out); // array element
597  }
598  pop(xml_out); // Wilson_spectroscopy
599  pop(xml_out); // hadspec
600 
601  snoop.stop();
602  QDPIO::cout << InlineHadSpecEnv::name << ": total time = "
603  << snoop.getTimeInSeconds()
604  << " secs" << std::endl;
605 
606  QDPIO::cout << InlineHadSpecEnv::name << ": ran successfully" << std::endl;
607 
608  END_CODE();
609  }
610 
611 }
Inline measurement factory.
Heavy-light baryon 2-pt functions.
Inline measurement of hadron spectrum.
InlineHadSpecParams params
void operator()(const unsigned long update_no, XMLWriter &xml_out)
Do the measurement.
void func(const unsigned long update_no, XMLWriter &xml_out)
Do the measurement.
Fourier transform phase factor support.
Definition: sftmom.h:35
const Set & getSet() const
The set to be used in sumMulti.
Definition: sftmom.h:57
static T & Instance()
Definition: singleton.h:432
void read(XMLReader &xml, const std::string &path, AsqtadFermActParams &param)
Read parameters.
void write(XMLWriter &xml, const std::string &path, const AsqtadFermActParams &param)
Writer parameters.
void curcor2(const multi1d< LatticeColorMatrix > &u, const LatticePropagator &quark_prop_1, const LatticePropagator &quark_prop_2, const SftMom &phases, int t0, int no_vec_cur, XMLWriter &xml, const std::string &xml_group)
Construct current correlators.
Definition: curcor2_w.cc:44
void barhqlq(const LatticePropagator &propagator_1, const LatticePropagator &propagator_2, const SftMom &phases, int t0, int bc_spec, bool time_rev, XMLWriter &xml, const std::string &xml_group)
Heavy-light baryon 2-pt functions.
Definition: barhqlq_w.cc:170
void proginfo(XMLWriter &xml)
Print out basic information about this program.
Definition: proginfo.cc:24
std::string makeXMLFileName(std::string xml_file, unsigned long update_no)
Return a xml file name for inline measurements.
int bc_spec
multi1d< int > t_srce
std::string source_disp_type
multi1d< int > bc
std::string source_type
std::string quark_propagator_id
SinkPropContainer_t sink_prop_2
std::string sink_type
SinkPropContainer_t sink_prop_1
ForwardProp_t prop_header
std::string sink_disp_type
Inline hadron spectrum calculations.
Make xml file writer.
int j_decay
Definition: meslate.cc:22
Nd
Definition: meslate.cc:74
Meson 2-pt functions.
Named object function std::map.
static bool registered
Local registration flag.
bool registerAll()
Register all the factories.
std::string getName()
Return the name.
Asqtad Staggered-Dirac operator.
Definition: klein_gord.cc:10
Real getMass(const GroupXML_t &fermact)
Given a fermion action in std::string form, return the Mass.
Definition: qprop_io.cc:16
static multi1d< LatticeColorMatrix > u
const WilsonTypeFermAct< multi1d< LatticeFermion > > Handle< const ConnectState > const multi1d< Real > & Mass
Definition: pbg5p_w.cc:29
push(xml_out,"Condensates")
int i
Definition: pbg5p_w.cc:55
multi1d< int > getFermActBoundary(const GroupXML_t &fermact)
Given a fermion action in std::string form, return the boundary.
Definition: qprop_io.cc:61
void mesons2(const LatticePropagator &quark_prop_1, const LatticePropagator &quark_prop_2, const SftMom &phases, int t0, XMLWriter &xml, const std::string &xml_group)
Meson 2-pt functions.
Definition: mesons2_w.cc:107
pop(xml_out)
void MesPlq(const multi1d< LatticeColorMatrixF3 > &u, multi2d< Double > &plane_plaq, Double &link)
Definition: mesplq.cc:83
START_CODE()
void write(XMLWriter &xml, const std::string &path, const InlineHadSpecParams::NamedObject_t &input)
Propagator output.
multi1d< LatticeFermion > s(Ncb)
::std::string string
Definition: gtest.h:1979
No quark displacement.
Various parameter structs and reader/writers.
Print out basic info about this program.
Routines associated with Chroma propagator IO.
Fourier transform phase factor support.
Parameter structure.
void write(XMLWriter &xml_out, const std::string &path)
struct Chroma::InlineHadSpecParams::Param_t param
struct Chroma::InlineHadSpecParams::NamedObject_t named_obj