CHROMA
inline_mesonspec_w.cc
Go to the documentation of this file.
1 /*! \file
2  * \brief Inline construction of meson spectrum
3  *
4  * Meson spectrum calculations
5  */
6 
7 #include "handle.h"
10 #include "meas/glue/mesplq.h"
11 #include "util/ft/sftmom.h"
12 #include "util/info/proginfo.h"
13 #include "io/param_io.h"
14 #include "io/qprop_io.h"
17 
20 
21 namespace Chroma
22 {
23  namespace InlineMesonSpecEnv
24  {
25  namespace
26  {
27  AbsInlineMeasurement* createMeasurement(XMLReader& xml_in,
28  const std::string& path)
29  {
30  return new InlineMesonSpec(InlineMesonSpecParams(xml_in, path));
31  }
32 
33  //! Local registration flag
34  bool registered = false;
35  }
36 
37  const std::string name = "MESON_SPECTRUM";
38 
39  //! Register all the factories
40  bool registerAll()
41  {
42  bool success = true;
43  if (! registered)
44  {
45  success &= SpinInsertionEnv::registerAll();
46  success &= TheInlineMeasurementFactory::Instance().registerObject(name, createMeasurement);
47  registered = true;
48  }
49  return success;
50  }
51  }
52 
53 
54 
55  //! Reader for parameters
56  void read(XMLReader& xml, const std::string& path,
58  {
59  XMLReader paramtop(xml, path);
60 
61  int version;
62  read(paramtop, "version", version);
63 
64  switch (version)
65  {
66  case 1:
67  break;
68 
69  default:
70  QDPIO::cerr << "Input parameter version " << version << " unsupported." << std::endl;
71  QDP_abort(1);
72  }
73 
74  read(paramtop, "mom2_max", param.mom2_max);
75  read(paramtop, "avg_equiv_mom", param.avg_equiv_mom);
76  }
77 
78 
79  //! Writer for parameters
80  void write(XMLWriter& xml, const std::string& path,
81  const InlineMesonSpecParams::Param_t& param)
82  {
83  push(xml, path);
84 
85  int version = 1;
86  write(xml, "version", version);
87 
88  write(xml, "mom2_max", param.mom2_max);
89  write(xml, "avg_equiv_mom", param.avg_equiv_mom);
90 
91  pop(xml);
92  }
93 
94 
95  //! Propagator input
96  void read(XMLReader& xml, const std::string& path,
98  {
99  XMLReader inputtop(xml, path);
100 
101  read(inputtop, "first_id", input.first_id);
102  read(inputtop, "second_id", input.second_id);
103  read(inputtop, "factor", input.factor);
104 
105  input.source_spin_insertion = readXMLGroup(inputtop, "SourceSpinInsertion", "SpinInsertionType");
106  input.sink_spin_insertion = readXMLGroup(inputtop, "SinkSpinInsertion", "SpinInsertionType");
107  }
108 
109  //! Propagator output
110  void write(XMLWriter& xml, const std::string& path,
112  {
113  push(xml, path);
114 
115  write(xml, "first_id", input.first_id);
116  write(xml, "second_id", input.second_id);
117  xml << input.source_spin_insertion.xml;
118  xml << input.sink_spin_insertion.xml;
119  write(xml, "factor", input.factor);
120 
121  pop(xml);
122  }
123 
124 
125  //! Propagator input
126  void read(XMLReader& xml, const std::string& path,
128  {
129  XMLReader inputtop(xml, path);
130 
131  read(inputtop, "source_particle", input.source_particle);
132  read(inputtop, "source_wavetype", input.source_wavetype);
133  read(inputtop, "sink_particle", input.sink_particle);
134  read(inputtop, "sink_wavetype", input.sink_wavetype);
135  read(inputtop, "correlator_terms", input.correlator_terms);
136  }
137 
138  //! Propagator output
139  void write(XMLWriter& xml, const std::string& path,
141  {
142  push(xml, path);
143 
144  write(xml, "source_particle", input.source_particle);
145  write(xml, "source_wavetype", input.source_wavetype);
146  write(xml, "sink_particle", input.sink_particle);
147  write(xml, "sink_wavetype", input.sink_wavetype);
148  write(xml, "correlator_terms", input.correlator_terms);
149 
150  pop(xml);
151  }
152 
153 
154  //! Propagator input
155  void read(XMLReader& xml, const std::string& path,
157  {
158  XMLReader inputtop(xml, path);
159 
160  read(inputtop, "gauge_id", input.gauge_id);
161  read(inputtop, "correlators", input.correlators);
162  }
163 
164  //! Propagator output
165  void write(XMLWriter& xml, const std::string& path,
167  {
168  push(xml, path);
169 
170  write(xml, "gauge_id", input.gauge_id);
171  write(xml, "correlators", input.correlators);
172 
173  pop(xml);
174  }
175 
176 
177  // Param stuff
179 
181  {
182  try
183  {
184  XMLReader paramtop(xml_in, path);
185 
186  if (paramtop.count("Frequency") == 1)
187  read(paramtop, "Frequency", frequency);
188  else
189  frequency = 1;
190 
191  // Parameters for source construction
192  read(paramtop, "Param", param);
193 
194  // Read in the output propagator/source configuration info
195  read(paramtop, "NamedObject", named_obj);
196 
197  // Possible alternate XML file pattern
198  if (paramtop.count("xml_file") != 0)
199  {
200  read(paramtop, "xml_file", xml_file);
201  }
202  }
203  catch(const std::string& e)
204  {
205  QDPIO::cerr << __func__ << ": Caught Exception reading XML: " << e << std::endl;
206  QDP_abort(1);
207  }
208  }
209 
210 
211  // Writer
212  void
213  InlineMesonSpecParams::write(XMLWriter& xml_out, const std::string& path)
214  {
215  push(xml_out, path);
216 
217  Chroma::write(xml_out, "Param", param);
218  Chroma::write(xml_out, "NamedObject", named_obj);
219  QDP::write(xml_out, "xml_file", xml_file);
220 
221  pop(xml_out);
222  }
223 
224 
225  // Anonymous namespace
226  namespace
227  {
228  //! Useful structure holding sink props
229  struct SinkPropContainer_t
230  {
231  ForwardProp_t prop_header;
233  Real Mass;
234 
235  // Now loop over the various fermion masses
240  };
241 
242 
243  //! Useful structure holding sink props
244  struct AllCorrelatorTerms_t
245  {
246  SinkPropContainer_t sink_prop_1;
247  SinkPropContainer_t sink_prop_2;
248  };
249 
250 
251  //! Read a sink prop
252  void readSinkProp(SinkPropContainer_t& s, const std::string& id)
253  {
254  try
255  {
256  // Try a cast to see if it succeeds
257  const LatticePropagator& foo =
258  TheNamedObjMap::Instance().getData<LatticePropagator>(id);
259 
260  // Snarf the data into a copy
261  s.quark_propagator_id = id;
262 
263  // Snarf the prop info. This is will throw if the prop_id is not there
264  XMLReader prop_file_xml, prop_record_xml;
265  TheNamedObjMap::Instance().get(id).getFileXML(prop_file_xml);
266  TheNamedObjMap::Instance().get(id).getRecordXML(prop_record_xml);
267 
268  // Try to invert this record XML into a ChromaProp struct
269  // Also pull out the id of this source
270  {
271  read(prop_record_xml, "/SinkSmear", s.prop_header);
272 
273  read(prop_record_xml, "/SinkSmear/PropSource/Source/SourceType", s.source_type);
274  read(prop_record_xml, "/SinkSmear/PropSource/Source/Displacement/DisplacementType",
275  s.source_disp_type);
276 
277  read(prop_record_xml, "/SinkSmear/PropSink/Sink/SinkType", s.sink_type);
278  read(prop_record_xml, "/SinkSmear/PropSink/Sink/Displacement/DisplacementType",
279  s.sink_disp_type);
280  }
281  }
282  catch( std::bad_cast )
283  {
284  QDPIO::cerr << InlineMesonSpecEnv::name << ": caught dynamic cast error"
285  << std::endl;
286  QDP_abort(1);
287  }
288  catch (const std::string& e)
289  {
290  QDPIO::cerr << InlineMesonSpecEnv::name << ": error message: " << e
291  << std::endl;
292  QDP_abort(1);
293  }
294 
295 
296  // Derived from input prop
297  // Hunt around to find the mass
298  // NOTE: this may be problematic in the future if actions are used with no
299  // clear def. of a Mass
300  QDPIO::cout << "Try action and mass" << std::endl;
301  s.Mass = getMass(s.prop_header.prop_header.fermact);
302 
303  QDPIO::cout << "FermAct = " << s.prop_header.prop_header.fermact.id << std::endl;
304  QDPIO::cout << "Mass = " << s.Mass << std::endl;
305  }
306 
307 
308  //! Read all sinks
309  void readAllSinks(multi1d<AllCorrelatorTerms_t>& s,
310  const multi1d<InlineMesonSpecParams::NamedObject_t::Correlators_t::CorrelatorTerms_t>& correlator_terms)
311  {
312  s.resize(correlator_terms.size());
313 
314  for(int i=0; i < correlator_terms.size(); ++i)
315  {
316  QDPIO::cout << "Attempt to parse forward propagator = " << correlator_terms[i].first_id << std::endl;
317  readSinkProp(s[i].sink_prop_1, correlator_terms[i].first_id);
318  QDPIO::cout << "Forward propagator successfully parsed" << std::endl;
319 
320  QDPIO::cout << "Attempt to parse forward propagator = " << correlator_terms[i].second_id << std::endl;
321  readSinkProp(s[i].sink_prop_2, correlator_terms[i].second_id);
322  QDPIO::cout << "Forward propagator successfully parsed" << std::endl;
323  }
324  }
325 
326  } // namespace anonymous
327 
328 
329 
330  // Function call
331  void
332  InlineMesonSpec::operator()(unsigned long update_no,
333  XMLWriter& xml_out)
334  {
335  // If xml file not empty, then use alternate
336  if (params.xml_file != "")
337  {
338  std::string xml_file = makeXMLFileName(params.xml_file, update_no);
339 
340  push(xml_out, "MesonSpectrum");
341  write(xml_out, "update_no", update_no);
342  write(xml_out, "xml_file", xml_file);
343  pop(xml_out);
344 
345  XMLFileWriter xml(xml_file);
346  func(update_no, xml);
347  }
348  else
349  {
350  func(update_no, xml_out);
351  }
352  }
353 
354 
355 
356  // Real work done here
357  void
358  InlineMesonSpec::func(unsigned long update_no,
359  XMLWriter& xml_out)
360  {
361  START_CODE();
362 
363  QDPIO::cout << InlineMesonSpecEnv::name << ": meson spectroscopy for Wilson-like fermions" << std::endl;
364 
365  StopWatch snoop;
366  snoop.reset();
367  snoop.start();
368 
369  // Test and grab a reference to the gauge field
370  XMLBufferWriter gauge_xml;
371  try
372  {
373  TheNamedObjMap::Instance().getData< multi1d<LatticeColorMatrix> >(params.named_obj.gauge_id);
374  TheNamedObjMap::Instance().get(params.named_obj.gauge_id).getRecordXML(gauge_xml);
375  }
376  catch( std::bad_cast )
377  {
378  QDPIO::cerr << InlineMesonSpecEnv::name << ": caught dynamic cast error"
379  << std::endl;
380  QDP_abort(1);
381  }
382  catch (const std::string& e)
383  {
384  QDPIO::cerr << InlineMesonSpecEnv::name << ": std::map call failed: " << e
385  << std::endl;
386  QDP_abort(1);
387  }
388  const multi1d<LatticeColorMatrix>& u =
389  TheNamedObjMap::Instance().getData< multi1d<LatticeColorMatrix> >(params.named_obj.gauge_id);
390 
391  push(xml_out, "MesonSpectrum");
392  write(xml_out, "update_no", update_no);
393 
394  proginfo(xml_out); // Print out basic program info
395 
396  QDPIO::cout << "xml_file = " << params.xml_file << std::endl;
397 
398  // Write out the input
399  params.write(xml_out, "Input");
400 
401  // Write out the config info
402  write(xml_out, "Config_info", gauge_xml);
403 
404  push(xml_out, "Output_version");
405  write(xml_out, "out_version", 3);
406  pop(xml_out);
407 
408 
409  // First calculate some gauge invariant observables just for info.
410  MesPlq(xml_out, "Observables", u);
411 
412  // Keep an array of all the xml output buffers
413  push(xml_out, "Wilson_hadron_measurements");
414 
415  // Now loop over the various fermion pairs
416  for(int lpair=0; lpair < params.named_obj.correlators.size(); ++lpair)
417  {
419 
420  push(xml_out, "elem");
421 
422  write(xml_out, "source_particle", named_obj.source_particle);
423  write(xml_out, "source_wavetype", named_obj.source_wavetype);
424  write(xml_out, "sink_particle", named_obj.sink_particle);
425  write(xml_out, "sink_wavetype", named_obj.sink_wavetype);
426 
427  multi1d<AllCorrelatorTerms_t> all_sinks;
428  readAllSinks(all_sinks, named_obj.correlator_terms);
429 
430  // Derived from input prop
431  multi1d<int> t_srce
432  = all_sinks[0].sink_prop_1.prop_header.source_header.getTSrce();
433  int j_decay = all_sinks[0].sink_prop_1.prop_header.source_header.j_decay;
434  int t0 = all_sinks[0].sink_prop_1.prop_header.source_header.t_source;
435 
436  // Sanity checks
437  for(int loop=0; loop < all_sinks.size(); ++loop)
438  {
439  if (all_sinks[loop].sink_prop_2.prop_header.source_header.j_decay != j_decay)
440  {
441  QDPIO::cerr << "Error!! j_decay must be the same for all propagators " << std::endl;
442  QDP_abort(1);
443  }
444  if (all_sinks[loop].sink_prop_2.prop_header.source_header.t_source !=
445  all_sinks[loop].sink_prop_1.prop_header.source_header.t_source)
446  {
447  QDPIO::cerr << "Error!! t_source must be the same for all propagators " << std::endl;
448  QDP_abort(1);
449  }
450  }
451 
452 
453  // Initialize the slow Fourier transform phases
455  j_decay);
456 
457  // Keep a copy of the phases with NO momenta
458  SftMom phases_nomom(0, true, j_decay);
459 
460  // Masses
461  write(xml_out, "Mass_1", all_sinks[0].sink_prop_1.Mass);
462  write(xml_out, "Mass_2", all_sinks[0].sink_prop_2.Mass);
463  write(xml_out, "t0", t0);
464 
465  // Save prop input
466  push(xml_out, "Forward_prop_headers");
467  for(int loop=0; loop < all_sinks.size(); ++loop)
468  {
469  push(xml_out, "elem");
470  write(xml_out, "First_forward_prop", all_sinks[loop].sink_prop_1.prop_header);
471  write(xml_out, "Second_forward_prop", all_sinks[loop].sink_prop_2.prop_header);
472  pop(xml_out);
473  }
474  pop(xml_out);
475 
476  // Sanity check - write out the norm2 of the forward prop in the j_decay direction
477  // Use this for any possible verification
478  push(xml_out, "Forward_prop_correlator");
479  for(int loop=0; loop < all_sinks.size(); ++loop)
480  {
481  const LatticePropagator& sink_prop_1 =
482  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks[loop].sink_prop_1.quark_propagator_id);
483  const LatticePropagator& sink_prop_2 =
484  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks[loop].sink_prop_2.quark_propagator_id);
485 
486  push(xml_out, "elem");
487  write(xml_out, "forward_prop_corr_1", sumMulti(localNorm2(sink_prop_1), phases.getSet()));
488  write(xml_out, "forward_prop_corr_2", sumMulti(localNorm2(sink_prop_2), phases.getSet()));
489  pop(xml_out);
490  }
491  pop(xml_out);
492 
493 
494  push(xml_out, "SourceSinkType");
495  for(int loop=0; loop < all_sinks.size(); ++loop)
496  {
497  push(xml_out, "elem");
498  QDPIO::cout << "Source_type_1 = " << all_sinks[loop].sink_prop_1.source_type << std::endl;
499  QDPIO::cout << "Sink_type_1 = " << all_sinks[loop].sink_prop_1.sink_type << std::endl;
500  QDPIO::cout << "Source_type_2 = " << all_sinks[loop].sink_prop_2.source_type << std::endl;
501  QDPIO::cout << "Sink_type_2 = " << all_sinks[loop].sink_prop_2.sink_type << std::endl;
502 
503  write(xml_out, "source_type_1", all_sinks[loop].sink_prop_1.source_type);
504  write(xml_out, "source_disp_type_1", all_sinks[loop].sink_prop_1.source_disp_type);
505  write(xml_out, "sink_type_1", all_sinks[loop].sink_prop_1.sink_type);
506  write(xml_out, "sink_disp_type_1", all_sinks[loop].sink_prop_1.sink_disp_type);
507 
508  write(xml_out, "source_type_2", all_sinks[loop].sink_prop_2.source_type);
509  write(xml_out, "source_disp_type_2", all_sinks[loop].sink_prop_2.source_disp_type);
510  write(xml_out, "sink_type_2", all_sinks[loop].sink_prop_2.sink_type);
511  write(xml_out, "sink_disp_type_2", all_sinks[loop].sink_prop_2.sink_disp_type);
512  pop(xml_out);
513  }
514  pop(xml_out);
515 
516 
517  // Do the mesons
518  push(xml_out, "Mesons");
519  {
520  // Length of lattice in decay direction
521  int length = phases.numSubsets();
522 
523  // Construct the anti-quark propagator from quark_propagator[1]
524  int G5 = Ns*Ns-1;
525 
526  // Construct the meson correlation function
527  LatticeComplex corr_fn = zero;
528 
529  for(int loop=0; loop < all_sinks.size(); ++loop)
530  {
531  const LatticePropagator& sink_prop_1 =
532  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks[loop].sink_prop_1.quark_propagator_id);
533  const LatticePropagator& sink_prop_2 =
534  TheNamedObjMap::Instance().getData<LatticePropagator>(all_sinks[loop].sink_prop_2.quark_propagator_id);
535 
536  LatticePropagator prop_1, prop_2;
537 
538  // Factory constructions
539  try
540  {
541  // Create the source spin insertion object
542  {
543  std::istringstream xml_s(named_obj.correlator_terms[loop].source_spin_insertion.xml);
544  XMLReader inserttop(xml_s);
545 // const std::string insert_path = "/SourceSpinInsertion";
546 
547  Handle< SpinInsertion<LatticePropagator> > sourceSpinInsertion(
549  named_obj.correlator_terms[loop].source_spin_insertion.id,
550  inserttop,
551  named_obj.correlator_terms[loop].source_spin_insertion.path));
552 
553  prop_1 = (*sourceSpinInsertion)(sink_prop_1);
554  }
555 
556  // Create the sink spin insertion object
557  {
558  std::istringstream xml_s(named_obj.correlator_terms[loop].sink_spin_insertion.xml);
559  XMLReader inserttop(xml_s);
560 // const std::string insert_path = "/SinkSpinInsertion";
561 
562  Handle< SpinInsertion<LatticePropagator> > sinkSpinInsertion(
564  named_obj.correlator_terms[loop].sink_spin_insertion.id,
565  inserttop,
566  named_obj.correlator_terms[loop].sink_spin_insertion.path));
567 
568  LatticePropagator prop_tmp = Gamma(G5) * adj(sink_prop_2) * Gamma(G5);
569 
570  prop_2 = (*sinkSpinInsertion)(prop_tmp);
571  }
572  }
573  catch(const std::string& e)
574  {
575  QDPIO::cerr << InlineMesonSpecEnv::name << ": Caught Exception inserting: "
576  << e << std::endl;
577  QDP_abort(1);
578  }
579 
580 
581  LatticeComplex tmp = trace(prop_2 * prop_1);
582 
583  corr_fn += named_obj.correlator_terms[loop].factor * tmp;
584  }
585 
586  multi2d<DComplex> hsum;
587  hsum = phases.sft(corr_fn);
588 
589  // Loop over sink momenta
590  XMLArrayWriter xml_sink_mom(xml_out,phases.numMom());
591  push(xml_sink_mom, "momenta");
592 
593  for (int sink_mom_num=0; sink_mom_num < phases.numMom(); ++sink_mom_num)
594  {
595  push(xml_sink_mom);
596  write(xml_sink_mom, "sink_mom_num", sink_mom_num);
597  write(xml_sink_mom, "sink_mom", phases.numToMom(sink_mom_num));
598 
599  multi1d<DComplex> mesprop(length);
600  for (int t=0; t < length; ++t)
601  {
602  int t_eff = (t - t0 + length) % length;
603  mesprop[t_eff] = hsum[sink_mom_num][t];
604  }
605 
606  write(xml_sink_mom, "mesprop", mesprop);
607  pop(xml_sink_mom);
608 
609  } // end for(sink_mom_num)
610 
611  pop(xml_sink_mom);
612  }
613  pop(xml_out); // Mesons
614 
615  pop(xml_out); // array element
616  }
617  pop(xml_out); // Wilson_spectroscopy
618  pop(xml_out); // mesonspec
619 
620  snoop.stop();
621  QDPIO::cout << InlineMesonSpecEnv::name << ": total time = "
622  << snoop.getTimeInSeconds()
623  << " secs" << std::endl;
624 
625  QDPIO::cout << InlineMesonSpecEnv::name << ": ran successfully" << std::endl;
626 
627  END_CODE();
628  }
629 
630 }
Inline measurement factory.
Class for counted reference semantics.
Definition: handle.h:33
Inline measurement of meson 2-pt functions.
InlineMesonSpecParams 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
int numSubsets() const
Number of subsets - length in decay direction.
Definition: sftmom.h:63
multi1d< int > numToMom(int mom_num) const
Convert momenta id to actual array of momenta.
Definition: sftmom.h:78
multi2d< DComplex > sft(const LatticeComplex &cf) const
Do a sumMulti(cf*phases,getSet())
Definition: sftmom.cc:524
int numMom() const
Number of momenta.
Definition: sftmom.h:60
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 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.
GroupXML_t readXMLGroup(XMLReader &xml_in, const std::string &path, const std::string &type_name)
Read group and return as a std::string.
Class for counted reference semantics.
multi1d< int > t_srce
std::string source_disp_type
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 meson spectrum calculations.
Make xml file writer.
int j_decay
Definition: meslate.cc:22
int t
Definition: meslate.cc:37
Named object function std::map.
static bool registered
Local registration flag.
bool registerAll()
Register all the factories.
bool registerAll()
Register all the factories.
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
int G5
Definition: pbg5p_w.cc:57
static multi1d< LatticeColorMatrix > u
const WilsonTypeFermAct< multi1d< LatticeFermion > > Handle< const ConnectState > const multi1d< Real > & Mass
Definition: pbg5p_w.cc:29
LatticeFermion tmp
Definition: mespbg5p_w.cc:36
push(xml_out,"Condensates")
int i
Definition: pbg5p_w.cc:55
void write(XMLWriter &xml, const std::string &path, const InlineMesonSpecParams::NamedObject_t &input)
Propagator output.
pop(xml_out)
void MesPlq(const multi1d< LatticeColorMatrixF3 > &u, multi2d< Double > &plane_plaq, Double &link)
Definition: mesplq.cc:83
START_CODE()
Double zero
Definition: invbicg.cc:106
multi1d< LatticeFermion > s(Ncb)
::std::string string
Definition: gtest.h:1979
Various parameter structs and reader/writers.
Print out basic info about this program.
Routines associated with Chroma propagator IO.
Fourier transform phase factor support.
All spin insertion constructors.
Factory for producing spin insertion objects.
struct Chroma::InlineMesonSpecParams::NamedObject_t named_obj
void write(XMLWriter &xml_out, const std::string &path)
struct Chroma::InlineMesonSpecParams::Param_t param