psiexenv.h

//
// psiexenv.h
//
// Copyright (C) 2002 Edward Valeev
//
// Author: Edward Valeev <evaleev@vt.edu>
// Maintainer: EV
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//
 
#ifndef _chemistry_qc_psi_exenv_h
#define _chemistry_qc_psi_exenv_h
 
#include <string>
#include <sstream>
#include <libpsio/psio.hpp>
#include <libchkpt/chkpt.hpp>
#include <chemistry/qc/psi/psiinput.h>
#include <chemistry/qc/psi/psifile11.h>
#include <chemistry/qc/wfn/spin.h>
 
namespace sc {
 
class PsiExEnv: public DescribedClass {
 
    PsiExEnv();
 
    static Ref<PsiExEnv> default_instance_;
 
    // Static Psi info
    static std::string defaultinputname_;
    static std::string defaultoutputname_;
    static std::string file11name_;
    static int ckptfile_;
 
    // Defaults
    static std::string defaultpsiprefix_;
    static std::string defaultcwd_;
    static std::string defaultfileprefix_;
    static std::string defaultstdout_;
    static std::string defaultstderr_;
 
    // Calculation-specific info
    std::string psiprefix_;
    std::string cwd_;        // working directory where all files will be placed
    std::string inputname_;
    std::string outputname_;
    std::string fileprefix_;
    std::string stdout_;     // Standard output of psi modules
    std::string stderr_;     // Standard error of psi modules
    int nscratch_;
    std::vector<std::string> scratch_;
    Ref<PsiInput> psiinput_;
    Ref<PsiFile11> psifile11_;
 
    bool keep_output_;
 
    void config_psio();
    psi::PSIO psio_;
    psi::Chkpt* chkpt_;
 
    // Add the following to the PATH environmental variable
    void add_to_path(const std::string &);
 
    // task id
    int me_;
 
  public:
    PsiExEnv(const Ref<KeyVal>&);
    ~PsiExEnv();
 
    static const Ref<PsiExEnv>& get_default_instance();
 
    Ref<PsiInput> psi_input() const { return psiinput_; }
    Ref<PsiFile11> psi_file11() const { return psifile11_; }
    Ref<PsiInput> get_psi_input();
    Ref<PsiFile11> get_psi_file11();
 
    void run_psi(bool skip_input = false);
    void run_psi_module(const char * module, const std::vector<std::string>& args = std::vector<std::string>());
    void run_psiclean(bool fullclean = true);
 
    const std::string& get_cwd() const { return cwd_;};
    const std::string& get_fileprefix() const { return fileprefix_; };
    int get_nscratch() const { return nscratch_; };
    const std::string& get_scratch(int i) const { return scratch_[i]; };
 
    psi::PSIO& psio() { return psio_; }
    psi::Chkpt& chkpt();
 
    void print(std::ostream&o=ExEnv::out0()) const;
 
    void keep_output();
};
 
class PsiChkpt : public RefCount {
  public:
    PsiChkpt(const Ref<PsiExEnv>& exenv,
             const Ref<Integral>& integral,
             int debug);
    ~PsiChkpt();
 
    int debug() const { return debug_; }
 
    const Ref<PsiExEnv>& exenv() const { return exenv_; }
    const Ref<Integral>& integral() const { return integral_; }
 
    bool have_spin_unrestricted_mos() const;
    RefDiagSCMatrix evals(SpinCase1 s,
                          bool spin_restricted = true) const;
    RefSCMatrix coefs(SpinCase1 s,
                      bool spin_restricted = true) const;
    std::vector< std::pair<unsigned int,unsigned int> > shell_map() const;
    std::vector<unsigned int> ao_map() const;
 
  private:
    Ref<PsiExEnv> exenv_;
    Ref<Integral> integral_;
    int debug_;
};
 
}
 
#endif