lcm_tst_leapfrog_recursive.cc

Go to the documentation of this file.

#include "chromabase.h"
#include "update/molecdyn/integrator/md_integrator_factory.h"
#include "update/molecdyn/integrator/lcm_tst_leapfrog_recursive.h"
#include "update/molecdyn/integrator/lcm_exp_sdt.h"
#include "io/xmllog_io.h"
 
#include <string>
 
namespace Chroma 
{ 
  
  namespace LatColMatTSTLeapfrogRecursiveIntegratorEnv 
  {
    namespace
    {
      AbsComponentIntegrator<multi1d<LatticeColorMatrix>, 
                             multi1d<LatticeColorMatrix> >* 
      createMDIntegrator(
                         XMLReader& xml, 
                         const std::string& path)
      {
        // Read the integrator params
        LatColMatTSTLeapfrogRecursiveIntegratorParams p(xml, path);
    
        return new LatColMatTSTLeapfrogRecursiveIntegrator(p);
      }
      
      //! Local registration flag
      bool registered = false;
    }
 
    const std::string name = "LCM_TST_LEAPFROG";
 
    //! Register all the factories
    bool registerAll() 
    {
      bool success = true; 
      if (! registered)
      {
        success &= TheMDComponentIntegratorFactory::Instance().registerObject(name, createMDIntegrator); 
        registered = true;
      }
      return success;
    }
  }
  
  
  LatColMatTSTLeapfrogRecursiveIntegratorParams::LatColMatTSTLeapfrogRecursiveIntegratorParams(XMLReader& xml_in, const std::string& path) 
  {
    XMLReader paramtop(xml_in, path);
    try {
      read(paramtop, "./n_steps", n_steps);
      read(paramtop, "./monomial_ids", monomial_ids);
      if( paramtop.count("./SubIntegrator") == 0 ) {
        // BASE CASE: User does not supply sub-integrator 
        //
        // Sneaky way - create an XML document for EXP_T
        XMLBufferWriter subintegrator_writer;
        int one_sub_step=1;
 
        push(subintegrator_writer, "SubIntegrator");
        write(subintegrator_writer, "Name", "LCM_EXP_T");
        write(subintegrator_writer, "n_steps", one_sub_step);
        pop(subintegrator_writer);
 
        subintegrator_xml = subintegrator_writer.str();
 
      }
      else {
        // RECURSIVE CASE: User Does Supply Sub Integrator
        //
        // Read it
        XMLReader subint_reader(paramtop, "./SubIntegrator");
      
        std::ostringstream subintegrator_os;
      
        subint_reader.print(subintegrator_os);
        subintegrator_xml = subintegrator_os.str();
        QDPIO::cout << "Subintegrator XML is: " << std::endl;
        QDPIO::cout << subintegrator_xml << std::endl;
      }
    }
    catch ( const std::string& e ) { 
      QDPIO::cout << "Error reading XML in LatColMatTSTLeapfrogRecursiveIntegratorParams " << e << std::endl;
      QDP_abort(1);
    }
  }
  
  void read(XMLReader& xml, 
            const std::string& path, 
            LatColMatTSTLeapfrogRecursiveIntegratorParams& p) {
    LatColMatTSTLeapfrogRecursiveIntegratorParams tmp(xml, path);
    p = tmp;
  }
 
  void write(XMLWriter& xml, 
             const std::string& path, 
             const LatColMatTSTLeapfrogRecursiveIntegratorParams& p) {
    push(xml, path);
    write(xml, "n_steps", p.n_steps);
    write(xml, "monomial_ids", p.monomial_ids);
    xml << p.subintegrator_xml;
    pop(xml);
  }
 
  
  void LatColMatTSTLeapfrogRecursiveIntegrator::operator()( 
                                             AbsFieldState<multi1d<LatticeColorMatrix>,
                                             multi1d<LatticeColorMatrix> >& s, 
                                             const Real& traj_length) const
  {
   
    START_CODE();
    LatColMatExpSdtIntegrator expSdt(1,
                                     monomials); // Single Step
 
    const AbsComponentIntegrator< multi1d<LatticeColorMatrix>,
      multi1d<LatticeColorMatrix> >& subIntegrator = getSubIntegrator();
 
                                     
 
 
    Real dtau = traj_length / n_steps;
    Real dtauby2 = dtau/2;
 
    // Its sts so:
    subIntegrator(s, dtauby2);  // First half step
    expSdt(s, dtau); 
    for(int i=0; i < n_steps-1; i++) {  // N-1 full steps
       subIntegrator(s, dtau);
       expSdt(s, dtau);
    }
    subIntegrator(s, dtauby2);  // Last Half Step
 
    END_CODE();
 
  }
 
 
}