Require SLGridSlab to have a non-default cachename for consistency with SLGridSph and provenance policy

Author: Martin D. Weinberg

expui/BiorthBasis.cc

@@ -3421,7 +3421,8 @@ namespace BasisClasses
     "verbose",
     "check",
     "method",
-    "self_consistent"
+    "self_consistent",
+    "cachename"
   };
 
   Slab::Slab(const YAML::Node& CONF) : BiorthBasis(CONF, "slab")
@@ -3482,6 +3483,8 @@ namespace BasisClasses
       if (conf["knots"])      knots = conf["knots"].as<int>();
 
       if (conf["check"])      check = conf["check"].as<bool>();
+
+      if (conf["cachename"])  cachename = conf["cachename"].as<std::string>();
     } 
     catch (YAML::Exception & error) {
       if (myid==0) std::cout << "Error parsing parameter stanza for <"
@@ -3494,6 +3497,19 @@ namespace BasisClasses
       throw std::runtime_error("Slab: error parsing YAML");
     }
 
+    // Check for non-null cache file name.  This must be specified
+    // to prevent recomputation and unexpected behavior.
+    //
+    if (cachename.size() == 0) {
+      throw std::runtime_error
+	("SlabSL requires a specified cachename in your YAML config\n"
+	 "for consistency with previous invocations and existing coefficient\n"
+	 "sets.  Please add explicitly add 'cachename: name' to your config\n"
+	 "with new 'name' for creating a basis or an existing 'name' for\n"
+	 "reading a previously generated basis cache\n");
+    }
+
+
     // Finally, make the basis
     //
     SLGridSlab::mpi  = 0;
@@ -3503,7 +3519,7 @@ namespace BasisClasses
 
     int nnmax = (nmaxx > nmaxy) ? nmaxx : nmaxy;
 
-    ortho = std::make_shared<SLGridSlab>(nnmax, nmaxz, ngrid, zmax, type);
+    ortho = std::make_shared<SLGridSlab>(nnmax, nmaxz, ngrid, zmax, cachename, type);
 
     // Orthogonality sanity check
     //

exputil/SLGridMP2.cc

@@ -1973,8 +1973,12 @@ void SLGridSlab::bomb(string oops)
 				// Constructors
 
 SLGridSlab::SLGridSlab(int NUMK, int NMAX, int NUMZ, double ZMAX,
-		       const std::string TYPE, bool VERBOSE)
+		       const std::string cachename, const std::string TYPE,
+		       bool VERBOSE)
 {
+  if (cachename.size()) slab_cache_name  = cachename;
+  else throw std::runtime_error("SLGridSlab: you must specify a cachename");
+  
   int kx, ky;
 
   numk = NUMK;
@@ -2210,9 +2214,6 @@ SLGridSlab::SLGridSlab(int NUMK, int NMAX, int NUMZ, double ZMAX,
 }
 
 
-const string slab_cache_name = ".slgrid_slab_cache";
-
-
 bool SLGridSlab::ReadH5Cache(void)
 {
   if (!cache) return false;

include/SLGridMP2.H

@@ -305,6 +305,9 @@ private:
   void WriteH5Cache(void);
   //@}
 
+  //! Cache file name
+  std::string slab_cache_name;
+
   //! Cache versioning
   inline static const std::string Version = "1.0";
 
@@ -412,7 +415,8 @@ public:
 
   //! Constructor
   SLGridSlab(int kmax, int nmax, int numz, double zmax,
-	     const std::string type="isothermal", bool Verbose=false);
+	     const std::string cachename, const std::string type="isothermal",
+	     bool Verbose=false);
 
   //! Destructor
   ~SLGridSlab();

src/SlabSL.H

@@ -48,6 +48,8 @@
     under the time-dependent basis expansion. For a basis fixed in time to
     the initial time: set to false.
 
+    @param cachename is the name of the basis cache file.  This is a
+    required parameter.
 */
 class SlabSL : public PotAccel
 {
@@ -86,6 +88,7 @@ private:
   int imx, imy, imz, jmax, nnmax;
   double  dfac;
   std::complex<double> kfac;
+  std::string cachename;
 
   std::vector<Eigen::VectorXd> zfrc, zpot;
 

src/SlabSL.cc

@@ -18,7 +18,8 @@ SlabSL::valid_keys = {
   "zmax",
   "ngrid",
   "type",
-  "self_consistent"
+  "self_consistent",
+  "cachename"
 };
 
 //@{
@@ -35,13 +36,17 @@ SlabSL::SlabSL(Component* c0, const YAML::Node& conf) : PotAccel(c0, conf)
   zmax      = 10.0;
   hslab     = 0.2;
   coef_dump = true;
+  cachename = "";
 
 #if HAVE_LIBCUDA==1
   cuda_aware = true;
 #endif
 
   initialize();
 
+  if (cachename.size()==0)
+    throw std::runtime_error("SlabSL: you must specify a cachename");
+
   SLGridSlab::mpi  = 1;
   SLGridSlab::ZBEG = 0.0;
   SLGridSlab::ZEND = 0.1;
@@ -51,7 +56,7 @@ SlabSL::SlabSL(Component* c0, const YAML::Node& conf) : PotAccel(c0, conf)
 
   // Make the Sturm-Liouville grid and basis functions
   //
-  grid = std::make_shared<SLGridSlab>(nnmax, nmaxz, ngrid, zmax, type);
+  grid = std::make_shared<SLGridSlab>(nnmax, nmaxz, ngrid, zmax, cachename, type);
 
   // Test for basis consistency (will generate an exception if maximum
   // error is out of tolerance)
@@ -167,6 +172,7 @@ void SlabSL::initialize()
     if (conf["hslab"])          hslab       = conf["hslab"].as<double>();
     if (conf["zmax" ])          zmax        = conf["zmax" ].as<double>();
     if (conf["type" ])          type        = conf["type" ].as<std::string>();
+    if (conf["cachename"])      cachename   = conf["cachename"].as<std::string>();
 
     if (conf["self_consistent"]) {
       self_consistent = conf["self_consistent"].as<bool>();

utils/SL/orthochk.cc

@@ -4,171 +4,59 @@
 #include <string>
 #include <cmath>
 
-#include <getopt.h>
-
 #include "biorth1d.H"
 #include "SLGridMP2.H"
 #include "gaussQ.H"
 #include "localmpi.H"
+#include "cxxopts.H"
 
-//===========================================================================
-
-void usage(char *prog)
-{
-  cout << "Usage:\n\n"
-       << prog << " [options]\n\n"
-       << setw(15) << "Option" << setw(10) << "Argument" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Description" << endl << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-m or --mpi" << setw(10) << "No" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Turn on MPI for SL computation" << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-t or --Trig" << setw(10) << "No" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Use trigonometric basis" << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-s or --SL" << setw(10) << "No" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Use Sturm-Liouville basis" << endl
-       << setw(15) << "-T or --type" << setw(10) << "string" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Density target (isothermal, constant, parabolic)" << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-n " << setw(10) << "int" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Number of basis functions" << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-H " << setw(10) << "double" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Slab scale height" << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-k " << setw(10) << "double" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Wave number for Trig basis" << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-x " << setw(10) << "double" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Wave number in X for SL basis" << endl
-       << resetiosflags(ios::left)
-       << setw(15) << "-y " << setw(10) << "double" << setw(10) << " " 
-       << setiosflags(ios::left)
-       << setw(40) << "Wave number in Y for SL basis" << endl
-       << resetiosflags(ios::left)
-       << "" << endl;
-
-  exit(0);
-}
 
 enum BioType1d {Trig, SL};
 
 int 
 main(int argc, char** argv)
 {
-  bool use_mpi = false;
   double KX = 0.5;
   double H = 0.1;
   double ZMAX = 1.0;
   int NMAX = 10;
   int IKX = 1;
   int IKY = 3;
   BioType1d Type = Trig;
+  std::string cachename = ".slab_sl_cache";
   std::string slabID = "iso";
+  bool use_mpi = false;
 
-  int c;
-  while (1) {
-    int this_option_optind = optind ? optind : 1;
-    int option_index = 0;
-    static struct option long_options[] = {
-      {"mpi", 0, 0, 0},
-      {"Trig", 0, 0, 0},
-      {"SL", 0, 0, 0},
-      {0, 0, 0, 0}
-    };
-
-    c = getopt_long (argc, argv, "msT:tx:y:k:n:z:H:h",
-		     long_options, &option_index);
-
-    if (c == -1) break;
-
-    switch (c) {
-    case 0:
-      {
-	string optname(long_options[option_index].name);
-
-	if (!optname.compare("mpi")) {
-	  use_mpi = true;
-	} else if (!optname.compare("Trig")) {
-	  Type = Trig;
-	} else if (!optname.compare("SL")) {
-	  Type = SL;
-	} else if (!optname.compare("type")) {
-	  slabID = optarg;
-	} else {
-	  cout << "Option " << long_options[option_index].name;
-	  if (optarg) cout << " with arg " << optarg;
-	  cout << " is not defined " << endl;
-	  exit(0);
-	}
-      }
-      break;
-
-    case 'm':
-      use_mpi = true;
-      break;
-
-    case 's':
-      Type = SL;
-      break;
-
-    case 'T':
-      slabID = optarg;
-      break;
-
-    case 't':
-      Type = Trig;
-      break;
-
-    case 'x':
-      IKX = atoi(optarg);
-      break;
-
-    case 'y':
-      IKY = atoi(optarg);
-      break;
-
-    case 'k':
-      KX = atof(optarg);
-      break;
-
-    case 'z':
-      ZMAX = atof(optarg);
-      break;
-
-    case 'H':
-      H = atof(optarg);
-      break;
-
-    case 'n':
-      NMAX = atoi(optarg);
-      break;
-
-    case 'h':
-    default:
-      usage(argv[0]);
-    }
-
+  cxxopts::Options options("orthochk", "Check orthogonality of 1D basis functions");
+
+  options.add_options()
+    ("m,mpi", "Use MPI")
+    ("s,SL", "Use Sturm-Liouville slab basis")
+    ("T,type", "Slab type (iso, parabolic, or constant)", cxxopts::value<std::string>())
+    ("t,Trig", "Use trigonometric basis")
+    ("x,ikx", "IKX for SLGridSlab (default: 1)", cxxopts::value<int>())
+    ("y,iky", "IKY for SLGridSlab (default: 3)", cxxopts::value<int>())
+    ("k,kx", "KX for OneDTrig (default: 0.5)", cxxopts::value<double>())
+    ("z,zmax", "ZMAX for OneDTrig and SLGridSlab (default: 1.0)", cxxopts::value<double>())
+    ("H,h", "Scale height H for SLGridSlab (default: 0.1)", cxxopts::value<double>())
+    ("n,nmax", "NMAX for SLGridSlab (default: 10)", cxxopts::value<int>())
+    ("c,cachename", "Cache file name for SLGridSlab (default: .slab_sl_cache)", cxxopts::value<std::string>())
+    ("h,help", "Print usage");
+
+  auto result = options.parse(argc, argv);
+
+  if (result.count("mpi")) {
+    local_init_mpi(argc, argv);
+    use_mpi = true;
   }
 
-  //===================
-  // MPI preliminaries 
-  //===================
-
-  if (use_mpi) {
-    local_init_mpi(argc, argv);
+  if (result.count("help")) {
+    if (myid==0)
+      std::cout << options.help() << std::endl;
+    return 0;
   }
 
+
   //===================
   // Construct ortho
   //===================
@@ -190,7 +78,7 @@ main(int argc, char** argv)
       SLGridSlab::H = H;
       if (use_mpi) SLGridSlab::mpi = 1;
 
-      orthoSL = std::make_shared<SLGridSlab>(KMAX, NMAX, NUMZ, ZMAX, slabID, true);
+      orthoSL = std::make_shared<SLGridSlab>(KMAX, NMAX, NUMZ, ZMAX, cachename, slabID, true);
     }
     break;