chroma.cc

// $Id: chroma.cc,v 3.11 2007/09/21 04:38:45 edwards Exp $
/*! \file
 *  \brief Main program to run all measurement codes.
 */

#include "chroma.h"
 // New measurement headers go here

#include "inline_ex/inline_npr_vertex_pdf.h"
#include "actions_ex/target_quda/syssolver_linop_clover_quda_multigrid_w.h"
#include "meas_ex/momentum_volume_npr_source.h"
#include "inline_ex/inline_erase_quda_multigrid_space.h"
#include "inline_ex/inline_loop_w.h"
#include "inline_ex/inline_hadspec_w.h"
#include "inline_ex/inline_seqsource_fast_w.h"
#include "inline_ex/inline_pion_DA.h"
#include "inline_ex/inline_qpropadd_w.h"
#include "meas_ex/grid_source.h"
#include "meas_ex/simple_baryon_seqsrc_w.h"
#include "meas_ex/mom_quark_smearing.h"
#include "actions_ex/target_quda/syssolver_linop_clover_quda_w.h"
#include "inline_ex/inline_building_blocks_w.h"
#include "inline_ex/inline_building_x_w.h"
#include "inline_ex/inline_Xigauge.h"
#include "inline_ex/inline_vev.h"
#include "inline_ex/inline_eigen_maker.h"
#include "inline_ex/inline_propagator_multi_eigen.h"
#include "inline_ex/inline_FixObc.h"

using namespace Chroma;
extern "C" {
  void _mcleanup();
};

/*
 * Input
 */
struct Params_t
{
  multi1d<int> nrow;
  std::string  inline_measurement_xml;
};

struct Inline_input_t
{
  Params_t   param;
  GroupXML_t cfg;
  QDP::Seed  rng_seed;
};

void read( XMLReader& xml, const std::string& path, Params_t& p )
{
  XMLReader paramtop(xml, path);
  read(paramtop, "nrow", p.nrow);

  XMLReader measurements_xml(paramtop, "InlineMeasurements");
  std::ostringstream inline_os;
  measurements_xml.print(inline_os);
  p.inline_measurement_xml = inline_os.str();
  QDPIO::cout << "InlineMeasurements are: " << std::endl;
  QDPIO::cout << p.inline_measurement_xml << std::endl;
}

void read( XMLReader& xml, const std::string& path, Inline_input_t& p )
{
  try {
    XMLReader paramtop(xml, path);

    read(paramtop, "Param", p.param);
    p.cfg = readXMLGroup(paramtop, "Cfg", "cfg_type");

    if (paramtop.count("RNG") > 0)
      read(paramtop, "RNG", p.rng_seed);
    else
      p.rng_seed = 11;     // default seed
  }
  catch( const std::string& e )
  {
    QDPIO::cerr << "Error reading XML : " << e << std::endl;
    QDP_abort(1);
  }
}

bool linkageHack(void)
{
  bool foo = true;

  // Inline Measurements
  foo &= InlineAggregateEnv::registerAll();
  foo &= GaugeInitEnv::registerAll();
  
  // New measurement registrations go here
  foo &= InlineOBCEnv::registerAll();
  foo &= InlinePionDAEnv::registerAll();
  foo &= InlineBuildingBlocksIOGEnv::registerAll();
  foo &= InlineBuildingXIOGEnv::registerAll();
  foo &= InlineLoopEnv::registerAll();
  foo &= InlineHadSpec2Env::registerAll();
  foo &= InlineNprVertexPDFEnv::registerAll();
  foo &= InlineQpropAddCohenEnv::registerAll();
  foo &= InlineXiGaugeEnv::registerAll();
  foo &= InlineVEVEnv::registerAll();
  foo &= InlinePropagatorMultiEnv::registerAll();

  foo &= MomWallNPRQuarkSourceConstEnv::registerAll();
  foo &= GridQuarkSourceConstEnv::registerAll();
  foo &= MomQuarkSmearingEnv::registerAll();
  foo &= InlineSeqSourceFastEnv::registerAll();
  foo &= SimpleBaryonSeqSourceEnv::registerAll_extra();

#ifdef BUILD_QUDA
  foo &= LinOpSysSolverQUDAMULTIGRIDClover2Env::registerAll();
  foo &= LinOpSysSolverQUDAClover2Env::registerAll();
  foo &= InlineEraseQUDAMULTIGRIDSpace2Env::registerAll();
#endif  
  //foo &= InlineMyMeasEnv::registerAll();

  return foo;
}

//! Main program to run all measurement codes
/*! \defgroup chromamain Main program to run all measurement codes.
 *  \ingroup main
 *
 * Main program to run all measurement codes.
 */
int main(int argc, char *argv[])
{
  // Chroma Init stuff
  Chroma::initialize(&argc, &argv);

  START_CODE();

  QDPIO::cout << "Linkage = " << linkageHack() << std::endl;

  StopWatch snoop;
  snoop.reset();
  snoop.start();

  XMLReader xml_in;

  // Input parameter structure
  Inline_input_t input;
  try
  {
    xml_in.open(Chroma::getXMLInputFileName());
    read(xml_in, "/chroma", input);
  }
  catch(const std::string& e)
  {
    QDPIO::cerr << "CHROMA: Caught Exception reading XML: " << e << std::endl;
    QDP_abort(1);
  }
  catch(std::exception& e)
  {
    QDPIO::cerr << "CHROMA: Caught standard library exception: " << e.what() << std::endl;
    QDP_abort(1);
  }
  catch(...)
  {
    QDPIO::cerr << "CHROMA: caught generic exception reading XML" << std::endl;
    QDP_abort(1);
  }

  XMLFileWriter& xml_out = Chroma::getXMLOutputInstance();
  push(xml_out, "chroma");

  // Write out the input
  write(xml_out, "Input", xml_in);

  Layout::setLattSize(input.param.nrow);
  Layout::create();

  proginfo(xml_out);    // Print out basic program info

  // Initialise the RNG
  QDP::RNG::setrn(input.rng_seed);
  write(xml_out,"RNG", input.rng_seed);

  // Start up the config
  StopWatch swatch;
  swatch.reset();
  multi1d<LatticeColorMatrix> u(Nd);
  XMLReader gauge_file_xml, gauge_xml;

  // Start up the gauge field
  QDPIO::cout << "Attempt to read gauge field" << std::endl;
  swatch.start();
  try
  {
    std::istringstream xml_c(input.cfg.xml);
    XMLReader cfgtop(xml_c);
    QDPIO::cout << "Gauge initialization: cfg_type = " << input.cfg.id << std::endl;

    Handle<GaugeInit>
      gaugeInit(TheGaugeInitFactory::Instance().createObject(input.cfg.id,
                                                             cfgtop,
                                                             input.cfg.path));
    (*gaugeInit)(gauge_file_xml, gauge_xml, u);
  }
  catch(std::bad_cast)
  {
    QDPIO::cerr << "CHROMA: caught cast error" << std::endl;
    QDP_abort(1);
  }
  catch(std::bad_alloc)
  {
    // This might happen on any node, so report it
    QDPIO::cerr << "CHROMA: caught bad memory allocation" << std::endl;
    QDP_abort(1);
  }
  catch(const std::string& e)
  {
    QDPIO::cerr << "CHROMA: Caught Exception: " << e << std::endl;
    QDP_abort(1);
  }
  catch(std::exception& e)
  {
    QDPIO::cerr << "CHROMA: Caught standard library exception: " << e.what() << std::endl;
    QDP_abort(1);
  }
  catch(...)
  {
    // This might happen on any node, so report it
    QDPIO::cerr << "CHROMA: caught generic exception during gaugeInit" << std::endl;
    QDP_abort(1);
  }
  swatch.stop();

  QDPIO::cout << "Gauge field successfully read: time= "
        << swatch.getTimeInSeconds()
        << " secs" << std::endl;

  XMLBufferWriter config_xml;
  config_xml << gauge_xml;

  // Write out the config header
  write(xml_out, "Config_info", gauge_xml);

  // Calculate some gauge invariant observables
  MesPlq(xml_out, "Observables", u);

  // Get the measurements
  try
  {
    std::istringstream Measurements_is(input.param.inline_measurement_xml);
    XMLReader MeasXML(Measurements_is);
    multi1d < Handle< AbsInlineMeasurement > > the_measurements;
    read(MeasXML, "/InlineMeasurements", the_measurements);

    QDPIO::cout << "There are " << the_measurements.size() << " measurements " << std::endl;

    // Reset and set the default gauge field
    InlineDefaultGaugeField::reset();
    InlineDefaultGaugeField::set(u, config_xml);

    // Measure inline observables
    push(xml_out, "InlineObservables");
    xml_out.flush();

    QDPIO::cout << "Doing " << the_measurements.size()
    <<" measurements" << std::endl;
    swatch.start();
    unsigned long cur_update = 0;
    for(int m=0; m < the_measurements.size(); m++)
    {
      AbsInlineMeasurement& the_meas = *(the_measurements[m]);
      if( cur_update % the_meas.getFrequency() == 0 )
      {
        // Caller writes elem rule
        push(xml_out, "elem");
        the_meas(cur_update, xml_out);
        pop(xml_out);

        xml_out.flush();
      }
    }
    swatch.stop();

    QDPIO::cout << "CHROMA measurements: time= "
                << swatch.getTimeInSeconds()
                << " secs" << std::endl;

    pop(xml_out); // pop("InlineObservables");

    // Reset the default gauge field
    InlineDefaultGaugeField::reset();
  }
  catch(std::bad_cast)
  {
    QDPIO::cerr << "CHROMA: caught cast error" << std::endl;
    QDP_abort(1);
  }
  catch(std::bad_alloc)
  {
    // This might happen on any node, so report it
    QDPIO::cerr << "CHROMA: caught bad memory allocation" << std::endl;
    QDP_abort(1);
  }
  catch(const std::string& e)
  {
    QDPIO::cerr << "CHROMA: Caught Exception: " << e << std::endl;
    QDP_abort(1);
  }
  catch(std::exception& e)
  {
    QDPIO::cerr << "CHROMA: Caught standard library exception: " << e.what() << std::endl;
    QDP_abort(1);
  }
  catch(...)
  {
    // This might happen on any node, so report it
    QDPIO::cerr << "CHROMA: caught generic exception during measurement" << std::endl;
    QDP_abort(1);
  }
  pop(xml_out);

  snoop.stop();
  QDPIO::cout << "CHROMA: total time = "
              << snoop.getTimeInSeconds()
              << " secs" << std::endl;

  QDPIO::cout << "CHROMA: ran successfully" << std::endl;

  END_CODE();

  Chroma::finalize();
  exit(0);
}