Merge pull request #233 from bpuchala/v0.2a2_install

sample CASM project and some small Monte Carlo changes

Author: bpuchala

include/casm/casm_io/Log.hh

@@ -125,6 +125,13 @@ namespace CASM {
     int verbosity() const;
 
     void set_verbosity(int _verbosity);
+    
+    template<int _required_verbosity>
+    Log& require() {
+      static_assert(_required_verbosity >= none && _required_verbosity <= debug, "CASM::Log _required_verbosity must be <= 100");
+      m_print = (m_verbosity >= _required_verbosity);
+      return *this;
+    }
 
 
     void reset(std::ostream &_ostream = std::cout, int _verbosity = standard, bool _show_clock = false);
@@ -136,6 +143,10 @@ namespace CASM {
     friend Log &operator<<(Log &log, std::ostream & (*fptr)(std::ostream &));
 
     operator std::ostream &();
+    
+    explicit operator bool () {
+      return m_print;
+    }
 
     /// \brief Read verbosity level from a string
     static std::pair<bool, int> verbosity_level(std::string s);

include/casm/clex/Configuration.hh

@@ -185,8 +185,12 @@ namespace CASM {
       return multiplicity;
     }
 
+    /// \brief SCELV_A_B_C_D_E_F/i
     std::string name() const;
 
+    /// \brief SCELV_A_B_C_D_E_F.i (only use this when 'name' won't work)
+    std::string altname() const;
+
     std::string calc_status() const;
 
     std::string failure_type() const;

include/casm/completer/Complete.hh

@@ -65,7 +65,7 @@ namespace CASM {
       const ARG_TYPE m_expected_arg;
 
       ///Make sure values make sense
-      bool _sanity_throw() const;
+      void _sanity_throw() const;
     };
 
     namespace Suboption_impl {

include/casm/completer/Handlers.hh

@@ -146,6 +146,16 @@ namespace CASM {
 
       //-------------------------------------------------------------------------------------//
 
+      ///Add --config suboption (no default)
+      void add_configlist_nodefault_suboption();
+
+      //----------------------------//
+
+      ///Add --configs suboption (no default)
+      void add_configlists_nodefault_suboption();
+
+      //-------------------------------------------------------------------------------------//
+
       ///Add a plain --help suboption
       void add_help_suboption();
 

include/casm/monte_carlo/MCData.hh

@@ -117,7 +117,6 @@ namespace CASM {
     ///
     bool is_converged(double prec) const {
       return m_calculated_prec <= prec;
-
     }
 
     /// \brief <X>

include/casm/monte_carlo/MonteCarlo.hh

@@ -13,6 +13,14 @@
 #include "casm/monte_carlo/MonteCounter.hh"
 
 namespace CASM {
+  
+  struct SamplerNameCompare {
+    
+    SamplerNameCompare() {};
+    
+    bool operator()(const std::string& A, const std::string& B) const;
+    
+  };
 
 
   /// \brief Interface base class for all types of Monte Carlo simulations (not meant to be used polymorphically)
@@ -43,7 +51,7 @@ namespace CASM {
     /// - scalar example: m_sampler["formation_energy"]
     /// - vector example: m_sampler["corr(12)"]
     ///
-    typedef std::map<std::string, notstd::cloneable_ptr<MonteSampler> > SamplerMap;
+    typedef std::map<std::string, notstd::cloneable_ptr<MonteSampler>, SamplerNameCompare> SamplerMap;
 
     /// \brief a vector of std::pair(pass, step) indicating when samples were taken
     typedef std::vector<std::pair<MonteCounter::size_type, MonteCounter::size_type> > SampleTimes;
@@ -319,8 +327,6 @@ namespace CASM {
     }
   }
 
-  // canonical_equivalent_lattice(superlat, prim.point_group(), crystallography_tol())
-
 }
 #endif
 

include/casm/monte_carlo/MonteDriver.hh

@@ -151,54 +151,59 @@ namespace CASM {
     }
     m_log << std::endl;
 
-    // save initial configdof if not dependent runs
-    ConfigDoF initial_configdof;
-    if(!m_settings.dependent_runs()) {
-      initial_configdof = m_mc.configdof();
-    }
+    if(m_settings.dependent_runs()) {
 
-    // if starting from initial condition
-    if(start_i == 0) {
-      // perform any requested explicit equilibration passes
-      if(m_settings.is_equilibration_passes_first_run()) {
-        auto equil_passes = m_settings.equilibration_passes_first_run();
+      // if starting from initial condition
+      if(start_i == 0) {
 
-        m_log.write("DoF");
-        m_log << "write: " << m_dir.initial_state_firstruneq_json(0) << "\n" << std::endl;
+        // set intial state
+        m_mc.set_state(m_conditions_list[0], m_settings);
 
-        jsonParser json;
-        fs::create_directories(m_dir.conditions_dir(0));
-        to_json(m_mc.configdof(), json).write(m_dir.initial_state_firstruneq_json(0));
+        // perform any requested explicit equilibration passes
+        if(m_settings.dependent_runs() && m_settings.is_equilibration_passes_first_run()) {
 
-        m_log.begin("Equilibration passes");
-        m_log << equil_passes << " equilibration passes\n" << std::endl;
+          auto equil_passes = m_settings.equilibration_passes_first_run();
 
-        MonteCounter equil_counter(m_settings, m_mc.steps_per_pass());
-        while(equil_counter.pass() != equil_passes) {
-          monte_carlo_step(m_mc);
-          equil_counter++;
-        }
+          m_log.write("DoF");
+          m_log << "write: " << m_dir.initial_state_firstruneq_json(0) << "\n" << std::endl;
+
+          jsonParser json;
+          fs::create_directories(m_dir.conditions_dir(0));
+          to_json(m_mc.configdof(), json).write(m_dir.initial_state_firstruneq_json(0));
 
+          m_log.begin("Equilibration passes");
+          m_log << equil_passes << " equilibration passes\n" << std::endl;
+
+          MonteCounter equil_counter(m_settings, m_mc.steps_per_pass());
+          while(equil_counter.pass() != equil_passes) {
+            monte_carlo_step(m_mc);
+            equil_counter++;
+          }
+        }
       }
-    }
-    else if(m_settings.dependent_runs()) {
-      // read end state of previous condition
-      ConfigDoF configdof = m_mc.configdof();
-      from_json(configdof, jsonParser(m_dir.final_state_json(start_i - 1)));
+      else {
+
+        // read end state of previous condition
+        ConfigDoF configdof = m_mc.configdof();
+        from_json(configdof, jsonParser(m_dir.final_state_json(start_i - 1)));
 
-      m_mc.set_configdof(configdof, std::string("Using: ") + m_dir.final_state_json(start_i - 1).string());
+        m_mc.set_configdof(configdof, std::string("Using: ") + m_dir.final_state_json(start_i - 1).string());
+      }
     }
 
     // Run for all conditions, outputting data as you finish each one
     for(Index i = start_i; i < m_conditions_list.size(); i++) {
       if(!m_settings.dependent_runs()) {
-        m_mc.set_configdof(initial_configdof, "reset to initial DoF");
+        m_mc.set_state(m_conditions_list[i], m_settings);
       }
       else {
+        m_mc.set_conditions(m_conditions_list[i]);
+
         m_log.custom("Continue with existing DoF");
         m_log << std::endl;
       }
       single_run(i);
+      m_log << std::endl;
     }
 
     return;
@@ -293,8 +298,6 @@ namespace CASM {
 
     fs::create_directories(m_dir.conditions_dir(cond_index));
 
-    m_mc.set_conditions(m_conditions_list[cond_index]);
-
     // perform any requested explicit equilibration passes
     if(m_settings.is_equilibration_passes_each_run()) {
 
@@ -335,7 +338,7 @@ namespace CASM {
     while(true) {
 
       if(debug()) {
-        m_log.custom("Counter info");
+        m_log.custom<Log::debug>("Counter info");
         m_log << "pass: " << run_counter.pass() << "  "
               << "step: " << run_counter.step() << "  "
               << "samples: " << run_counter.samples() << "\n" << std::endl;
@@ -356,12 +359,12 @@ namespace CASM {
         else {
 
           if(m_mc.check_convergence_time()) {
-
-            m_log.check<Log::verbose>("Convergence");
-            m_log << std::boolalpha;
-            m_log << "is equilibrated: " << m_mc.is_equilibrated().first << std::endl;
-            m_log << "is converged: " << m_mc.is_converged() << std::endl;
-
+            
+            m_log.require<Log::verbose>() << "\n";
+            m_log.custom<Log::verbose>("Begin convergence checks");
+            m_log << "samples: " << m_mc.sample_times().size() << std::endl;
+            m_log << std::endl;
+            
             if(m_mc.is_converged()) {
               break;
             }
@@ -386,7 +389,7 @@ namespace CASM {
       run_counter++;
 
       if(run_counter.sample_time()) {
-        m_log.custom<Log::verbose>("Sample data");
+        m_log.custom<Log::debug>("Sample data");
         m_log << "pass: " << run_counter.pass() << "  "
               << "step: " << run_counter.step() << "  "
               << "take sample " << m_mc.sample_times().size() << "\n" << std::endl;

include/casm/monte_carlo/MonteSampler.hh

@@ -65,6 +65,11 @@ namespace CASM {
     bool must_converge() const {
       return m_must_converge;
     }
+    
+    /// \brief Returns requested precision on the mean
+    double requested_precision() const {
+      return m_prec;
+    }
 
     /// \brief Returns true if convergence criteria have been met for data sampled in range [equil_samples, end)
     ///

include/casm/monte_carlo/grand_canonical/GrandCanonical.hh

@@ -54,6 +54,16 @@ namespace CASM {
     /// \brief Set configdof and clear previously collected data
     void set_configdof(const ConfigDoF &configdof, const std::string &msg = "");
 
+    /// \brief Set configdof and conditions and clear previously collected data
+    std::pair<ConfigDoF, std::string> set_state(
+      const GrandCanonicalConditions &new_conditions,
+      const GrandCanonicalSettings &settings);
+
+    /// \brief Set configdof and conditions and clear previously collected data
+    void set_state(const CondType &new_conditions,
+                   const ConfigDoF &configdof,
+                   const std::string &msg = "");
+
     /// \brief Propose a new event, calculate delta properties, and return reference to it
     const EventType &propose();
 
@@ -133,6 +143,21 @@ namespace CASM {
       return m_formation_energy_clex.eci();
     }
 
+    /// \brief Calculate delta correlations for an event
+    void _set_dCorr(GrandCanonicalEvent &event,
+                    Index mutating_site,
+                    int sublat,
+                    int current_occupant,
+                    int new_occupant,
+                    bool use_deltas,
+                    bool all_correlations) const;
+
+    /// \brief Print correlations to _log()
+    void _print_correlations(const Eigen::VectorXd &corr,
+                             std::string title,
+                             std::string colheader,
+                             bool all_correlations) const;
+
     /// \brief Calculate delta properties for an event and update the event with those properties
     void _update_deltas(GrandCanonicalEvent &event,
                         Index mutating_site,
@@ -143,8 +168,17 @@ namespace CASM {
     /// \brief Calculate properties given current conditions
     void _update_properties();
 
-    /// \brief Select initial configdof
-    ConfigDoF _initial_configdof(const GrandCanonicalSettings &settings, Log &_log);
+    /// \brief Generate supercell filling ConfigDoF from default configuration
+    ConfigDoF _default_motif() const;
+
+    /// \brief Generate minimum potential energy ConfigDoF
+    std::pair<ConfigDoF, std::string> _auto_motif(const GrandCanonicalConditions &cond) const;
+
+    /// \brief Generate minimum potential energy ConfigDoF for this supercell
+    std::pair<ConfigDoF, std::string> _restricted_auto_motif(const GrandCanonicalConditions &cond) const;
+
+    /// \brief Generate supercell filling ConfigDoF from configuration
+    ConfigDoF _configname_motif(const std::string &configname) const;
 
 
     ///Keeps track of what sites can change to what

include/casm/monte_carlo/grand_canonical/GrandCanonicalIO.hh

@@ -55,7 +55,7 @@ namespace CASM {
   DataFormatter<ConstMonteCarloPtr> make_results_formatter(const GrandCanonical &mc);
 
   /// \brief Make a results formatter
-  DataFormatter<ConstMonteCarloPtr> make_lte_results_formatter(const GrandCanonical &mc, const double &phi_LTE1);
+  DataFormatter<ConstMonteCarloPtr> make_lte_results_formatter(const GrandCanonical &mc, const double &phi_LTE1, const std::string &configname);
 
   /// \brief Make a observation formatter
   DataFormatter<std::pair<ConstMonteCarloPtr, Index> > make_observation_formatter(const GrandCanonical &mc);
@@ -99,7 +99,7 @@ namespace CASM {
   GenericDatumFormatter<double, ConstMonteCarloPtr> GrandCanonicalLTEFormatter(const double &phi_LTE1);
 
   /// \brief Will create new file or append to existing results file the results of the latest run
-  void write_lte_results(const MonteSettings &settings, const GrandCanonical &mc, const double &phi_LTE1, Log &_log);
+  void write_lte_results(const MonteSettings &settings, const GrandCanonical &mc, const double &phi_LTE1, const std::string &configname, Log &_log);
 
 }