MonteIO_impl.hh

Go to the documentation of this file.

#ifndef CASM_MonteIO_impl_HH
#define CASM_MonteIO_impl_HH

#include "casm/monte_carlo/MonteIO.hh"

namespace CASM {

  // --- Template definitions ---------------------

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloTFormatter() {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      ConstMonteCarloPtr ptr = mc;
      return static_cast<const MonteType *>(ptr)->conditions().temperature();
    };
    return GenericDatumFormatter<double, ConstMonteCarloPtr>("T", "Temperature", evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloBetaFormatter() {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      ConstMonteCarloPtr ptr = mc;
      return static_cast<const MonteType *>(ptr)->conditions().beta();
    };
    return GenericDatumFormatter<double, ConstMonteCarloPtr>("Beta", "Beta", evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloParamChemPotFormatter(const MonteType &mc, int index) {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      ConstMonteCarloPtr ptr = mc;
      return static_cast<const MonteType *>(ptr)->conditions().param_chem_pot()(index);
    };
    std::string header = std::string("param_chem_pot(") + CompositionConverter::comp_var(index) + ")";
    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloChemPotFormatter(const MonteType &mc, int index) {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      ConstMonteCarloPtr ptr = mc;
      return static_cast<const MonteType *>(ptr)->conditions().chem_pot(index);
    };
    std::string header = std::string("chem_pot(") + mc.primclex().get_prim().get_struc_molecule_name()[index] + ")";
    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloCompFormatter(const MonteType &mc, int index) {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      ConstMonteCarloPtr ptr = mc;
      return static_cast<const MonteType *>(ptr)->conditions().param_composition()(index);
    };
    std::string header = std::string("comp(") + CompositionConverter::comp_var(index) + ")";
    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloCompNFormatter(const MonteType &mc, int index) {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      ConstMonteCarloPtr ptr = mc;
      return static_cast<const MonteType *>(ptr)->conditions().mol_composition()(index);
    };
    std::string header = std::string("comp_n(") + mc.primclex().get_prim().get_struc_molecule_name()[index] + ")";
    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloSiteFracFormatter(const MonteType &mc, int index) {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      const MonteType *mc_ptr = static_cast<const MonteType *>(mc);
      Eigen::VectorXd comp_n = mc_ptr->comp_n();
      Eigen::VectorXd site_frac = comp_n / mc->primclex().get_prim().basis.size();
      return site_frac(index);
    };
    std::string header = std::string("site_frac(") + mc.primclex().get_prim().get_struc_molecule_name()[index] + ")";
    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloAtomFracFormatter(const MonteType &mc, int index) {
    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      const MonteType *mc_ptr = static_cast<const MonteType *>(mc);
      Eigen::VectorXd comp_n = mc_ptr->comp_n();
      if(mc->primclex().vacancy_allowed()) {
        comp_n(mc->primclex().vacancy_index()) = 0.0;
      }
      auto atom_frac = comp_n / comp_n.sum();
      return atom_frac[index];
    };
    std::string header = std::string("atom_frac(") + mc.primclex().get_prim().get_struc_molecule_name()[index] + ")";
    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloHeatCapacityFormatter() {

    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      CovEvaluator cov_evaluator("potential_energy", "potential_energy");
      auto N = mc->supercell().volume();
      ConstMonteCarloPtr ptr = mc;
      auto T = static_cast<const MonteType *>(ptr)->conditions().temperature();
      return cov_evaluator(mc) * N / (KB * T * T);
    };

    auto validator = [ = ](const ConstMonteCarloPtr & mc) {
      return mc->is_equilibrated().first;
    };

    std::string header = std::string("heat_capacity");

    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator, validator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloSuscXFormatter(std::string comp_var_i, std::string comp_var_j) {

    std::string name_i = "comp(" + comp_var_i + ")";
    std::string name_j = "comp(" + comp_var_j + ")";

    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      CovEvaluator cov_evaluator(name_i, name_j);
      auto N = mc->supercell().volume();
      ConstMonteCarloPtr ptr = mc;
      auto T = static_cast<const MonteType *>(ptr)->conditions().temperature();
      return cov_evaluator(mc) * N / (KB * T);
    };

    auto validator = [ = ](const ConstMonteCarloPtr & mc) {
      return mc->is_equilibrated().first;
    };

    std::string header = std::string("susc_x(" + comp_var_i + "," + comp_var_j + ")");

    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator, validator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr> MonteCarloSuscNFormatter(std::string species_i, std::string species_j) {

    std::string name_i = "comp_n(" + species_i + ")";
    std::string name_j = "comp_n(" + species_j + ")";

    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      CovEvaluator cov_evaluator(name_i, name_j);
      auto N = mc->supercell().volume();
      ConstMonteCarloPtr ptr = mc;
      auto T = static_cast<const MonteType *>(ptr)->conditions().temperature();
      return cov_evaluator(mc) * N / (KB * T);
    };

    auto validator = [ = ](const ConstMonteCarloPtr & mc) {
      return mc->is_equilibrated().first;
    };

    std::string header = std::string("susc_n(" + species_i + "," + species_j + ")");

    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator, validator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr>
  MonteCarloThermoChemSuscXFormatter(std::string comp_var_i) {

    std::string name_i = "comp(" + comp_var_i + ")";

    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      CovEvaluator cov_evaluator("potential_energy", name_i);
      auto N = mc->supercell().volume();
      ConstMonteCarloPtr ptr = mc;
      auto T = static_cast<const MonteType *>(ptr)->conditions().temperature();
      return cov_evaluator(mc) * N / (KB * T);
    };

    auto validator = [ = ](const ConstMonteCarloPtr & mc) {
      return mc->is_equilibrated().first;
    };

    std::string header = std::string("susc_x(S," + comp_var_i + ")");

    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator, validator);
  }

  template<typename MonteType>
  GenericDatumFormatter<double, ConstMonteCarloPtr>
  MonteCarloThermoChemSuscNFormatter(std::string species_i) {

    std::string name_i = "comp_n(" + species_i + ")";

    auto evaluator = [ = ](const ConstMonteCarloPtr & mc) {
      CovEvaluator cov_evaluator("potential_energy", name_i);
      auto N = mc->supercell().volume();
      ConstMonteCarloPtr ptr = mc;
      auto T = static_cast<const MonteType *>(ptr)->conditions().temperature();
      return cov_evaluator(mc) * N / (KB * T);
    };

    auto validator = [ = ](const ConstMonteCarloPtr & mc) {
      return mc->is_equilibrated().first;
    };

    std::string header = std::string("susc_n(S," + species_i + ")");

    return GenericDatumFormatter<double, ConstMonteCarloPtr>(header, header, evaluator, validator);
  }

  template<typename MonteType>
  void write_results(const MonteSettings &settings, const MonteType &mc, Log &_log) {
    try {

      fs::create_directories(settings.output_directory());
      MonteCarloDirectoryStructure dir(settings.output_directory());
      auto formatter = make_results_formatter(mc);

      // write csv path results
      if(settings.write_csv()) {
        _log << "write: " << dir.results_csv() << "\n";
        fs::path file = dir.results_csv();
        fs::ofstream sout;

        if(!fs::exists(file)) {
          sout.open(file);
          formatter.print_header(&mc, sout);
        }
        else {
          sout.open(file, std::ios::app);
        }

        formatter.print(&mc, sout);

        sout.close();
      }

      // write json path results
      if(settings.write_json()) {
        _log << "write: " << dir.results_json() << "\n";
        fs::path file = dir.results_json();

        jsonParser results;
        if(fs::exists(file)) {
          results.read(file);
        }
        else {
          results = jsonParser::object();
        }

        formatter.to_json_arrays(&mc, results);
        results.write(file);
      }
    }
    catch(...) {
      std::cerr << "ERROR writing results" << std::endl;
      throw;
    }

  }

  template<typename MonteType>
  void write_conditions_json(const MonteSettings &settings, const MonteType &mc, Index cond_index, Log &_log) {
    try {
      MonteCarloDirectoryStructure dir(settings.output_directory());
      fs::create_directories(dir.conditions_dir(cond_index));
      jsonParser json;
      to_json(mc.conditions(), json);
      _log << "write: " << dir.conditions_json(cond_index) << "\n";
      json.write(dir.conditions_json(cond_index));
    }
    catch(...) {
      std::cerr << "ERROR writing conditions.json" << std::endl;
      throw;
    }
  }

}

#endif