CHROMA
inline_baryon_matelem_colorvec_w.cc
Go to the documentation of this file.
1 /*! \file
2  * \brief Inline measurement of baryon operators via colorstd::vector matrix elements
3  */
4 
5 
6 #include "handle.h"
11 #include "meas/glue/mesplq.h"
14 #include "util/ferm/key_val_db.h"
15 #include "util/ft/sftmom.h"
16 #include "util/info/proginfo.h"
18 
20 
21 #define COLORVEC_MATELEM_TYPE_ZERO 0
22 #define COLORVEC_MATELEM_TYPE_ONE 1
23 #define COLORVEC_MATELEM_TYPE_MONE -1
24 #define COLORVEC_MATELEM_TYPE_GENERIC 10
25 
26 namespace Chroma
27 {
28  /*!
29  * \ingroup hadron
30  *
31  * @{
32  */
33  namespace InlineBaryonMatElemColorVecEnv
34  {
35  // Reader for input parameters
37  {
38  XMLReader paramtop(xml, path);
39 
40  read(paramtop, "left", param.left);
41  read(paramtop, "middle", param.middle);
42  read(paramtop, "right", param.right);
43  }
44 
45 
46  // Writer for input parameters
48  {
49  push(xml, path);
50 
51  write(xml, "left", param.left);
52  write(xml, "middle", param.middle);
53  write(xml, "right", param.right);
54 
55  pop(xml);
56  }
57 
58 
59  // Reader for input parameters
60  void read(XMLReader& xml, const std::string& path, InlineBaryonMatElemColorVecEnv::Params::Param_t& param)
61  {
62  XMLReader paramtop(xml, path);
63 
64  int version;
65  read(paramtop, "version", version);
66 
67  switch (version)
68  {
69  case 1:
70  param.use_derivP = false;
71  break;
72 
73  case 2:
74  read(paramtop, "use_derivP", param.use_derivP);
75  break;
76 
77  default :
78  QDPIO::cerr << "Input parameter version " << version << " unsupported." << std::endl;
79  QDP_abort(1);
80  }
81 
82  read(paramtop, "mom2_max", param.mom2_max);
83  read(paramtop, "displacement_length", param.displacement_length);
84  read(paramtop, "displacement_list", param.displacement_list);
85  read(paramtop, "num_vecs", param.num_vecs);
86  read(paramtop, "decay_dir", param.decay_dir);
87  read(paramtop, "site_orthog_basis", param.site_orthog_basis);
88 
89  param.link_smearing = readXMLGroup(paramtop, "LinkSmearing", "LinkSmearingType");
90  }
91 
92 
93  // Writer for input parameters
94  void write(XMLWriter& xml, const std::string& path, const InlineBaryonMatElemColorVecEnv::Params::Param_t& param)
95  {
96  push(xml, path);
97 
98  int version = 2;
99 
100  write(xml, "version", version);
101  write(xml, "mom2_max", param.mom2_max);
102  write(xml, "use_derivP", param.use_derivP);
103  write(xml, "displacement_length", param.displacement_length);
104  write(xml, "displacement_list", param.displacement_list);
105  write(xml, "num_vecs", param.num_vecs);
106  write(xml, "decay_dir", param.decay_dir);
107  write(xml, "site_orthog_basis", param.site_orthog_basis);
108  xml << param.link_smearing.xml;
109 
110  pop(xml);
111  }
112 
113  //! Read named objects
115  {
116  XMLReader inputtop(xml, path);
117 
118  read(inputtop, "gauge_id", input.gauge_id);
119  read(inputtop, "colorvec_id", input.colorvec_id);
120  read(inputtop, "baryon_op_file", input.baryon_op_file);
121  }
122 
123  //! Write named objects
124  void write(XMLWriter& xml, const std::string& path, const InlineBaryonMatElemColorVecEnv::Params::NamedObject_t& input)
125  {
126  push(xml, path);
127 
128  write(xml, "gauge_id", input.gauge_id);
129  write(xml, "colorvec_id", input.colorvec_id);
130  write(xml, "baryon_op_file", input.baryon_op_file);
131 
132  pop(xml);
133  }
134 
135  // Writer for input parameters
136  void write(XMLWriter& xml, const std::string& path, const InlineBaryonMatElemColorVecEnv::Params& param)
137  {
138  param.writeXML(xml, path);
139  }
140  }
141 
142 
143  namespace InlineBaryonMatElemColorVecEnv
144  {
145  // Anonymous namespace for registration
146  namespace
147  {
148  AbsInlineMeasurement* createMeasurement(XMLReader& xml_in,
149  const std::string& path)
150  {
151  return new InlineMeas(Params(xml_in, path));
152  }
153 
154  //! Local registration flag
155  bool registered = false;
156  }
157 
158  const std::string name = "BARYON_MATELEM_COLORVEC";
159 
160  //! Register all the factories
161  bool registerAll()
162  {
163  bool success = true;
164  if (! registered)
165  {
166  success &= LinkSmearingEnv::registerAll();
167  success &= TheInlineMeasurementFactory::Instance().registerObject(name, createMeasurement);
168  registered = true;
169  }
170  return success;
171  }
172 
173 
174  //! Anonymous namespace
175  /*! Diagnostic stuff */
176  namespace
177  {
178  StandardOutputStream& operator<<(StandardOutputStream& os, const multi1d<int>& d)
179  {
180  if (d.size() > 0)
181  {
182  os << d[0];
183 
184  for(int i=1; i < d.size(); ++i)
185  os << " " << d[i];
186  }
187 
188  return os;
189  }
190 
191  StandardOutputStream& operator<<(StandardOutputStream& os, const Params::Param_t::Displacement_t& d)
192  {
193  os << "left= " << d.left
194  << " middle= " << d.middle
195  << " right= " << d.right;
196 
197  return os;
198  }
199  }
200 
201 
202  //----------------------------------------------------------------------------
203  // Param stuff
205  {
206  frequency = 0;
207  param.mom2_max = 0;
208  }
209 
210  Params::Params(XMLReader& xml_in, const std::string& path)
211  {
212  try
213  {
214  XMLReader paramtop(xml_in, path);
215 
216  if (paramtop.count("Frequency") == 1)
217  read(paramtop, "Frequency", frequency);
218  else
219  frequency = 1;
220 
221  // Read program parameters
222  read(paramtop, "Param", param);
223 
224  // Read in the output propagator/source configuration info
225  read(paramtop, "NamedObject", named_obj);
226 
227  // Possible alternate XML file pattern
228  if (paramtop.count("xml_file") != 0)
229  {
230  read(paramtop, "xml_file", xml_file);
231  }
232  }
233  catch(const std::string& e)
234  {
235  QDPIO::cerr << __func__ << ": Caught Exception reading XML: " << e << std::endl;
236  QDP_abort(1);
237  }
238  }
239 
240 
241  void
242  Params::writeXML(XMLWriter& xml_out, const std::string& path) const
243  {
244  push(xml_out, path);
245 
246  // Parameters for source construction
247  write(xml_out, "Param", param);
248 
249  // Write out the output propagator/source configuration info
250  write(xml_out, "NamedObject", named_obj);
251 
252  pop(xml_out);
253  }
254 
255 
256  //----------------------------------------------------------------------------
257  //! Baryon operator
259  {
260  int t_slice; /*!< Baryon operator time slice */
261  multi1d<int> left; /*!< Displacement dirs of left colorstd::vector */
262  multi1d<int> middle; /*!< Displacement dirs of middle colorstd::vector */
263  multi1d<int> right; /*!< Displacement dirs of right colorstd::vector */
264  multi1d<int> mom; /*!< D-1 momentum of this operator */
265  };
266 
267  //! Baryon operator
269  {
270  int type_of_data; /*!< Flag indicating type of data (maybe trivial) */
271  multi3d<ComplexD> op; /*!< Momentum projected operator */
272  };
273 
274 
275  //----------------------------------------------------------------------------
276  //! Holds key and value as temporaries
278  {
281  };
282 
283 
284  //----------------------------------------------------------------------------
285  //! BaryonElementalOperator reader
286  void read(BinaryReader& bin, KeyBaryonElementalOperator_t& param)
287  {
288  read(bin, param.t_slice);
289  read(bin, param.left);
290  read(bin, param.middle);
291  read(bin, param.right);
292  read(bin, param.mom);
293  }
294 
295  //! BaryonElementalOperator write
296  void write(BinaryWriter& bin, const KeyBaryonElementalOperator_t& param)
297  {
298  write(bin, param.t_slice);
299  write(bin, param.left);
300  write(bin, param.middle);
301  write(bin, param.right);
302  write(bin, param.mom);
303  }
304 
305  //! BaryonElementalOperator reader
306  void read(XMLReader& xml, const std::string& path, KeyBaryonElementalOperator_t& param)
307  {
308  XMLReader paramtop(xml, path);
309 
310  read(paramtop, "t_slice", param.t_slice);
311  read(paramtop, "left", param.left);
312  read(paramtop, "middle", param.middle);
313  read(paramtop, "right", param.right);
314  read(paramtop, "mom", param.mom);
315  }
316 
317  //! BaryonElementalOperator writer
318  void write(XMLWriter& xml, const std::string& path, const KeyBaryonElementalOperator_t& param)
319  {
320  push(xml, path);
321 
322  write(xml, "t_slice", param.t_slice);
323  write(xml, "left", param.left);
324  write(xml, "middle", param.middle);
325  write(xml, "right", param.right);
326  write(xml, "mom", param.mom);
327 
328  pop(xml);
329  }
330 
331 
332  //----------------------------------------------------------------------------
333  //! BaryonElementalOperator reader
334  void read(BinaryReader& bin, ValBaryonElementalOperator_t& param)
335  {
336  read(bin, param.type_of_data);
337 
338  int n;
339  read(bin, n); // the size is always written, even if 0
340  param.op.resize(n,n,n);
341 
342  for(int i=0; i < n; ++i)
343  {
344  for(int j=0; j < n; ++j)
345  {
346  for(int k=0; k < n; ++k)
347  {
348  read(bin, param.op(i,j,k));
349  }
350  }
351  }
352  }
353 
354  //! BaryonElementalOperator write
355  void write(BinaryWriter& bin, const ValBaryonElementalOperator_t& param)
356  {
357  write(bin, param.type_of_data);
358 
359  int n = param.op.size1(); // all sizes the same
360  write(bin, n);
361  for(int i=0; i < n; ++i)
362  {
363  for(int j=0; j < n; ++j)
364  {
365  for(int k=0; k < n; ++k)
366  {
367  write(bin, param.op(i,j,k));
368  }
369  }
370  }
371  }
372 
373 
374  //----------------------------------------------------------------------------
375  //! Normalize just one displacement array
376  multi1d<int> normDisp(const multi1d<int>& orig)
377  {
378  START_CODE();
379 
380  multi1d<int> disp;
381  multi1d<int> empty;
382  multi1d<int> no_disp(1); no_disp[0] = 0;
383 
384  // NOTE: a no-displacement is recorded as a zero-length array
385  // Convert a length one array with no displacement into a no-displacement array
386  if (orig.size() == 1)
387  {
388  if (orig == no_disp)
389  disp = empty;
390  else
391  disp = orig;
392  }
393  else
394  {
395  disp = orig;
396  }
397 
398  END_CODE();
399 
400  return disp;
401  } // void normDisp
402 
403 
404  //----------------------------------------------------------------------------
405  //! Make sure displacements are something sensible
406  multi1d<Params::Param_t::Displacement_t>
407  normalizeDisplacements(const multi1d<Params::Param_t::Displacement_t>& orig_list)
408  {
409  START_CODE();
410 
411  multi1d<Params::Param_t::Displacement_t> displacement_list(orig_list.size());
412 
413  // Loop over displacements
414  for(int n=0; n < orig_list.size(); ++n)
415  {
416  const Params::Param_t::Displacement_t& o = orig_list[n];
417  Params::Param_t::Displacement_t& d = displacement_list[n];
418 
419  d.left = normDisp(o.left);
420  d.middle = normDisp(o.middle);
421  d.right = normDisp(o.right);
422 
423 // QDPIO::cout << "disp[" << n << "]="
424 // << " left= " << d.left
425 // << " middle= " << d.middle
426 // << " right= " << d.right
427 // << std::endl;
428  }
429 
430  END_CODE();
431 
432  return displacement_list;
433  } // void normalizeDisplacements
434 
435 
436  //-------------------------------------------------------------------------------
437  // Function call
438  void
439  InlineMeas::operator()(unsigned long update_no,
440  XMLWriter& xml_out)
441  {
442  // If xml file not empty, then use alternate
443  if (params.xml_file != "")
444  {
445  std::string xml_file = makeXMLFileName(params.xml_file, update_no);
446 
447  push(xml_out, "BaryonMatElemColorVec");
448  write(xml_out, "update_no", update_no);
449  write(xml_out, "xml_file", xml_file);
450  pop(xml_out);
451 
452  XMLFileWriter xml(xml_file);
453  func(update_no, xml);
454  }
455  else
456  {
457  func(update_no, xml_out);
458  }
459  }
460 
461 
462  // Function call
463  void
464  InlineMeas::func(unsigned long update_no,
465  XMLWriter& xml_out)
466  {
467  START_CODE();
468  if ( Nc != 3 ){ /* Code is specific to Ns=4 and Nc=3. */
469  QDPIO::cerr<<" code only works for Nc=3 and Ns=4\n";
470  QDP_abort(111) ;
471  }
472 #if QDP_NC == 3
473 
474 
475 
476  StopWatch snoop;
477  snoop.reset();
478  snoop.start();
479 
480 
481  StopWatch swiss;
482 
483  // Test and grab a reference to the gauge field
484  XMLBufferWriter gauge_xml;
485  try
486  {
487  TheNamedObjMap::Instance().getData< multi1d<LatticeColorMatrix> >(params.named_obj.gauge_id);
488  TheNamedObjMap::Instance().get(params.named_obj.gauge_id).getRecordXML(gauge_xml);
489 
490  // NB We are just checking this is here.
492  }
493  catch( std::bad_cast )
494  {
495  QDPIO::cerr << name << ": caught dynamic cast error" << std::endl;
496  QDP_abort(1);
497  }
498  catch (const std::string& e)
499  {
500  QDPIO::cerr << name << ": std::map call failed: " << e << std::endl;
501  QDP_abort(1);
502  }
503 
504  // Cast should be valid now
505  const multi1d<LatticeColorMatrix>& u =
506  TheNamedObjMap::Instance().getData< multi1d<LatticeColorMatrix> >(params.named_obj.gauge_id);
507 
508  const MapObject<int,EVPair<LatticeColorVector> >& eigen_source =
510 
511  push(xml_out, "BaryonMatElemColorVec");
512  write(xml_out, "update_no", update_no);
513 
514  QDPIO::cout << name << ": Baryon color-std::vector matrix element" << std::endl;
515 
516  proginfo(xml_out); // Print out basic program info
517 
518  // Write out the input
519  params.writeXML(xml_out, "Input");
520 
521  // Write out the config info
522  write(xml_out, "Config_info", gauge_xml);
523 
524  push(xml_out, "Output_version");
525  write(xml_out, "out_version", 1);
526  pop(xml_out);
527 
528  //First calculate some gauge invariant observables just for info.
529  //This is really cheap.
530  MesPlq(xml_out, "Observables", u);
531 
532  //
533  // Initialize the slow Fourier transform phases
534  //
535  SftMom phases(params.param.mom2_max, false, params.param.decay_dir);
536 
537  //
538  // Smear the gauge field if needed
539  //
540  multi1d<LatticeColorMatrix> u_smr = u;
541 
542  try
543  {
544  std::istringstream xml_l(params.param.link_smearing.xml);
545  XMLReader linktop(xml_l);
546  QDPIO::cout << "Link smearing type = " << params.param.link_smearing.id << std::endl;
547 
548 
550  linkSmearing(TheLinkSmearingFactory::Instance().createObject(params.param.link_smearing.id,
551  linktop,
553 
554  (*linkSmearing)(u_smr);
555  }
556  catch(const std::string& e)
557  {
558  QDPIO::cerr << name << ": Caught Exception link smearing: " << e << std::endl;
559  QDP_abort(1);
560  }
561 
562  MesPlq(xml_out, "Smeared_Observables", u_smr);
563 
564  //
565  // Make sure displacements are something sensible
566  //
567  QDPIO::cout << "Normalize displacement lengths" << std::endl;
568  multi1d<Params::Param_t::Displacement_t> displacement_list(normalizeDisplacements(params.param.displacement_list));
569 
570  //
571  // The object holding the displaced color std::vector std::maps
572  //
573  DispColorVectorMap smrd_disp_vecs(params.param.use_derivP,
575  u_smr,
576  eigen_source);
577 
578  //
579  // DB storage
580  //
581  BinaryStoreDB< SerialDBKey<KeyBaryonElementalOperator_t>, SerialDBData<ValBaryonElementalOperator_t> >
582  qdp_db;
583 
584  // Open the file, and write the meta-data and the binary for this operator
585  if (! qdp_db.fileExists(params.named_obj.baryon_op_file))
586  {
587  XMLBufferWriter file_xml;
588 
589  push(file_xml, "DBMetaData");
590  write(file_xml, "id", std::string("baryonElemOp"));
591  write(file_xml, "lattSize", QDP::Layout::lattSize());
592  write(file_xml, "decay_dir", params.param.decay_dir);
593  proginfo(file_xml); // Print out basic program info
594  write(file_xml, "Params", params.param);
595  write(file_xml, "Op_Info",displacement_list);
596  write(file_xml, "Config_info", gauge_xml);
597  write(file_xml, "Weights", getEigenValues(eigen_source, params.param.num_vecs));
598  pop(file_xml);
599 
600  std::string file_str(file_xml.str());
601  qdp_db.setMaxUserInfoLen(file_str.size());
602 
603  qdp_db.open(params.named_obj.baryon_op_file, O_RDWR | O_CREAT, 0664);
604 
605  qdp_db.insertUserdata(file_str);
606  }
607  else
608  {
609  qdp_db.open(params.named_obj.baryon_op_file, O_RDWR, 0664);
610  }
611 
612 
613  //
614  // Baryon operators
615  //
616  // The creation and annihilation operators are the same without the
617  // spin matrices.
618  //
619  QDPIO::cout << "Building baryon operators" << std::endl;
620 
621  push(xml_out, "ElementalOps");
622 
623  // Loop over all time slices for the source. This is the same
624  // as the subsets for phases
625 
626  // Loop over each operator
627  for(int l=0; l < displacement_list.size(); ++l)
628  {
629  StopWatch watch;
630 
631  QDPIO::cout << "Elemental operator: op = " << l << std::endl;
632 
633  QDPIO::cout << "displacement: " << displacement_list[l] << std::endl;
634 
635  // Build the operator
636  swiss.reset();
637  swiss.start();
638 
639  // Big loop over the momentum projection
640  for(int mom_num = 0 ; mom_num < phases.numMom() ; ++mom_num)
641  {
642  // The keys for the displacements for this particular elemental operator
643  // Invert the time - make it an independent key
644  multi1d<KeyValBaryonElementalOperator_t> buf(phases.numSubsets());
645  for(int t=0; t < phases.numSubsets(); ++t)
646  {
647  buf[t].key.key().t_slice = t;
648  buf[t].key.key().left = displacement_list[l].left;
649  buf[t].key.key().middle = displacement_list[l].middle;
650  buf[t].key.key().right = displacement_list[l].right;
651  buf[t].key.key().mom = phases.numToMom(mom_num);
652  buf[t].val.data().op.resize(params.param.num_vecs,params.param.num_vecs,params.param.num_vecs);
653 
654  // Build in some optimizations.
655  // At this very moment, optimizations turned off
656  buf[t].val.data().type_of_data = COLORVEC_MATELEM_TYPE_GENERIC;
657  }
658 
659 
660  // The keys for the spin and displacements for this particular elemental operator
661  multi1d<KeyDispColorVector_t> keyDispColorVector(3);
662 
663  // Can displace each colorstd::vector
664  keyDispColorVector[0].displacement = displacement_list[l].left;
665  keyDispColorVector[1].displacement = displacement_list[l].middle;
666  keyDispColorVector[2].displacement = displacement_list[l].right;
667 
668  for(int i = 0 ; i < params.param.num_vecs; ++i)
669  {
670  for(int j = 0 ; j < params.param.num_vecs; ++j)
671  {
672  for(int k = 0 ; k < params.param.num_vecs; ++k)
673  {
674  keyDispColorVector[0].colvec = i;
675  keyDispColorVector[1].colvec = j;
676  keyDispColorVector[2].colvec = k;
677 
678  watch.reset();
679  watch.start();
680 
681  // Contract over color indices
682  // Do the relevant quark contraction
683  // Slow fourier-transform
684  LatticeComplex lop = colorContract(smrd_disp_vecs.getDispVector(keyDispColorVector[0]),
685  smrd_disp_vecs.getDispVector(keyDispColorVector[1]),
686  smrd_disp_vecs.getDispVector(keyDispColorVector[2]));
687 
688  // Slow fourier-transform
689  multi1d<ComplexD> op_sum = sumMulti(phases[mom_num] * lop, phases.getSet());
690 
691  watch.stop();
692 
693  for(int t=0; t < op_sum.size(); ++t)
694  {
695  buf[t].val.data().op(i,j,k) = op_sum[t];
696  }
697  } // end for k
698  } // end for j
699  } // end for i
700 
701  QDPIO::cout << "insert: mom_num= " << mom_num << " displacement num= " << l << std::endl;
702  for(int t=0; t < phases.numSubsets(); ++t)
703  {
704  qdp_db.insert(buf[t].key, buf[t].val);
705  }
706 
707  } // mom_num
708  swiss.stop();
709 
710  QDPIO::cout << "Baryon operator= " << l
711  << " time= "
712  << swiss.getTimeInSeconds()
713  << " secs" << std::endl;
714 
715  } // for l
716 
717  pop(xml_out); // ElementalOps
718 
719  // Close the namelist output file XMLDAT
720  pop(xml_out); // BaryonMatElemColorVector
721 
722  snoop.stop();
723  QDPIO::cout << name << ": total time = "
724  << snoop.getTimeInSeconds()
725  << " secs" << std::endl;
726 
727  QDPIO::cout << name << ": ran successfully" << std::endl;
728 
729 #endif
730 
731  END_CODE();
732  } // func
733  } // namespace InlineBaryonMatElemColorVecEnv
734 
735  /*! @} */ // end of group hadron
736 
737 } // namespace Chroma
738 
739 
740 
Inline measurement factory.
The displaced objects.
const LatticeColorVector getDispVector(const KeyDispColorVector_t &key)
Accessor.
Class for counted reference semantics.
Definition: handle.h:33
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.
Serializable value harness.
Definition: key_val_db.h:69
Serializable key harness.
Definition: key_val_db.h:21
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
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
Holds displaced color vectors.
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.
#define COLORVEC_MATELEM_TYPE_GENERIC
Inline measurement of baryon operators via colorstd::vector matrix elements.
MODS_t & eigen_source
Eigenvectors.
Key and values for DB.
unsigned j
Definition: ldumul_w.cc:35
unsigned n
Definition: ldumul_w.cc:36
Make xml file writer.
int t
Definition: meslate.cc:37
Named object function std::map.
static bool registered
Local registration flag.
multi1d< int > normDisp(const multi1d< int > &orig)
Normalize just one displacement array.
multi1d< Params::Param_t::Displacement_t > normalizeDisplacements(const multi1d< Params::Param_t::Displacement_t > &orig_list)
Make sure displacements are something sensible.
void read(XMLReader &xml, const std::string &path, InlineBaryonMatElemColorVecEnv::Params::Param_t::Displacement_t &param)
void write(XMLWriter &xml, const std::string &path, const InlineBaryonMatElemColorVecEnv::Params::Param_t::Displacement_t &param)
bool registerAll()
Register all the factories.
Asqtad Staggered-Dirac operator.
Definition: klein_gord.cc:10
QDP::StandardOutputStream & operator<<(QDP::StandardOutputStream &s, const multi1d< int > &d)
Definition: npr_vertex_w.cc:12
static multi1d< LatticeColorMatrix > u
push(xml_out,"Condensates")
int i
Definition: pbg5p_w.cc:55
multi1d< SubsetVectorWeight_t > getEigenValues(const MapObject< int, EVPair< LatticeColorVector > > &eigen_source, int num_vecs)
pop(xml_out)
void MesPlq(const multi1d< LatticeColorMatrixF3 > &u, multi2d< Double > &plane_plaq, Double &link)
Definition: mesplq.cc:83
DComplex d
Definition: invbicg.cc:99
START_CODE()
int k
Definition: invbicg.cc:119
::std::string string
Definition: gtest.h:1979
int l
Definition: pade_trln_w.cc:111
Print out basic info about this program.
Fourier transform phase factor support.
void writeXML(XMLWriter &xml_out, const std::string &path) const
Holds of vectors and weights.