added option to specify save/load dir

Author: saforem2

worm_algorithm/count_bonds.py

@@ -31,7 +31,7 @@ class CountBonds(object):
             performed.
     """
     def __init__(self, L, block_val=None, num_blocks=10, data_dir=None,
-                 save_dir=None, save=True, verbose=False):
+                 save_dir=None, save=True, load=False, verbose=False):
         self._L = L
         self._block_val = block_val
         self._num_blocks = num_blocks
@@ -46,6 +46,8 @@ def __init__(self, L, block_val=None, num_blocks=10, data_dir=None,
                 self._data_dir = data_dir
             if save_dir is None:
                 self._save_dir = '../data/bond_stats/{}_lattice/'.format(L)
+            else:
+                self._save_dir = save_dir
         else:
             self._width = L
             if data_dir is None:
@@ -60,6 +62,8 @@ def __init__(self, L, block_val=None, num_blocks=10, data_dir=None,
                         L, block_val
                     )
                 )
+            else:
+                self._save_dir = save_dir
         config_files = os.listdir(self._data_dir)
         self._config_files = sorted([
             self._data_dir + i for i in config_files if i.endswith('.txt')
@@ -68,7 +72,11 @@ def __init__(self, L, block_val=None, num_blocks=10, data_dir=None,
             i.split('_')[-1].rstrip('.txt') for i in self._config_files
         ]
         self._temp_strings = [i.rstrip('0') for i in temp_strings]
-        self.count_bonds()
+        self.bond_stats = {}
+        if not load:
+            self.count_bonds()
+        else:
+            self._load()
         if save:
             self._save()
 
@@ -159,7 +167,6 @@ def _count_bonds_with_err(self, data, num_blocks=10):
 
     def count_bonds(self):
         """Calculate bond statistics for all configuration data."""
-        self.bond_stats = {}
         for idx, config_file in enumerate(self._config_files):
             if self._verbose:
                 print("Reading in from: {}\n".format(config_file))
@@ -193,6 +200,17 @@ def _save(self):
                                                   val[1],
                                                   val[2],
                                                   val[3]))
+    def _load(self, data_file=None):
+        """Load previously computed bond_stats data from .txt file."""
+        if data_file is None:
+            data_file = self._save_dir + 'bond_stats_{}.txt'.format(self._L)
+            raw_data = pd.read_csv(data_file, engine='c', header=None,
+                                   delim_whitespace=True).values
+        for row in raw_data:
+            key = str(row[0])
+            self.bond_stats[key] = [row[1], row[2], row[3], row[4]]
+
+
 
 def main(argv):
     parser = argparse.ArgumentParser()

worm_algorithm/pca.py

@@ -34,7 +34,7 @@ class PrincipalComponent(object):
             performed.
     """
     def __init__(self, L, block_val=None, num_blocks=10, data_dir=None,
-                 save_dir=None, save=True, verbose=False):
+                 save_dir=None, save=True, load=False, verbose=False):
         self._L = L
         self._block_val = block_val
         self._num_blocks = num_blocks
@@ -74,12 +74,12 @@ def __init__(self, L, block_val=None, num_blocks=10, data_dir=None,
         ])
         temp_strings = [i.split('_')[-1].rstrip('.txt') for i in config_files]
         self._temp_strings = [i.rstrip('0') for i in temp_strings]
-
-        self._PCA()
-        #  self._leading_eig_val_avg = self.average_data()
-        #  self._leading_eig_val_err = list(self._err.values())
-        if save:
-            self._save()
+        if not load:
+            self._PCA()
+            if save:
+                self._save()
+        else:
+            self._load()
 
     def _get_data(self, _file=None):
         """ Read in configuration data from file. """
@@ -145,28 +145,10 @@ def _PCA(self, num_components=1):
                 self._err[key] = jackknife_err(y_i=eig_pairs_rs,
                                                y_full=eig_pairs[0][0],
                                                num_blocks=self._num_blocks)
-        #  self._eig_vals = OrderedDict(
-        #      self._eig_vals.items(), key=lambda t: t[0]
-        #  )
-        #  self._leading_eig_val = OrderedDict(
-        #      self._leading_eig_val.items(), key=lambda t: t[0]
-        #  )
-
-    #  def average_data(self):
-    #      """ Average leading eigenvalue data and use jackknife resampling for
-    #      error bars.
-    #      """
-    #      leading_eig_val_avg = []
-    #      #leading_eig_val_err = []
-    #      for val in self._leading_eig_val.values():
-    #          if
-    #          leading_eig_val_avg.append(np.mean(val))
-    #          #  leading_eig_val_err.append(
-    #          #      jackknife_stats(np.array(val), np.std)[2]
-    #          #  t
-    #      return leading_eig_val_avg#, leading_eig_val_err
 
     def _save(self):
+        """Save PCA results from calculation to .txt file to avoid repeating
+        calculation."""
         if not os.path.exists(self._save_dir):
             os.makedirs(self._save_dir)
         save_file = self._save_dir + 'leading_eigenvalue_{}.txt'.format(self._L)
@@ -183,6 +165,24 @@ def _save(self):
             for key, val in self._eig_vals.items():
                 f.write("{} {} {}\n".format(key, val[0][0], self._err[key]))
 
+    def _load(self, data_dir=None):
+        """Load PCA results from .txt file instead of recalculating results."""
+        if data_dir is None:
+            data_file = (
+                self._save_dir + 'leading_eigenvalue_{}.txt'.format(self._L)
+            )
+            try:
+                raw_data = pd.read_csv(data_file, engine='c', header=None,
+                                       delim_whitespace=True).values
+            except:
+                print("Unable to read from {}".format(data_file))
+                raise
+        for row in raw_data:
+            key = str(row[0])
+            self._eig_vals[key] = [row[1], row[2]]
+            self._err[key] = row[2]
+
+
 def main(argv):
     parser = argparse.ArgumentParser()