analysis_ellipsoids_kappa_3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Principal components analysis for order parameter construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from analysis_tools.read_gsd import ReadGSD\n",
    "from analysis_tools.feature_creation import FrameToFeatures, TrajectoryToFeatures, TrajectoryToFeaturesBatch, TrajectoryToFeaturesBatchR\n",
    "from analysis_tools.feature_creation import FrameToFeaturesComposition, TrajectoryToFeaturesComposition\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import array, arange, floor, floor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Hard disks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Kappa=3\n",
    "particle_inc = 99 #skip this many particles in generating features; #wp: because it selects index 0 be default, rounds up to integer if not a mulptiple of Ntot\n",
    "N_nn = 2992 #number of nearest nighbors for pca analysis #wp:Should not be bigger than Ntotal\n",
    "nn_inc = 10 #reduces the number of nearest neighbors to include as features\n",
    "split = 2 #chunks the data up so it can be processed by the pca tool if really large\n",
    "N_batch=1\n",
    "frame_skip=4\n",
    "\n",
    "#method = ['distance']\n",
    "method = ['orientation']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#specify what data to read in and process\n",
    "#wp:there are 51 eta points given range below\n",
    "folder='ellipsoids/kappa_3.0_3N'; \n",
    "#file_data = [(arange(0.7000, 0.9000, 0.01), folder)]             \n",
    "file_data = [(arange(0.7000, 0.7600, 0.01), folder),\n",
    "             (arange(0.7650, 0.7950, 0.005), folder),\n",
    "             (arange(0.8000, 0.9001, 0.01), folder)        \n",
    "            ]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Density range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#wp: the `_' variable is a dummy return variable like `~' in matlab\n",
    "#wp: Here, the for loop returns two arguments but only keeps the first that contains all the numbers\n",
    "etas = []\n",
    "[etas.extend(etas_) for etas_, _ in file_data]\n",
    "etas = array(etas)\n",
    "#print(etas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Perfom PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import array_split\n",
    "from sklearn.decomposition import IncrementalPCA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train on ideal gas structure first to identify trivial variance contributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#n_components_ig = N_nn/nn_inc-1  #for this the more the better, however, 50 is probably enough\n",
    "n_components_ig = N_batch*N_nn/nn_inc  #for this the more the better, however, 50 is probably enough\n",
    "#n_components_ig = N_nn/nn_inc*(N_batch+2) #for this the more the better, however, 50 is probably enough\n",
    "#print n_components_ig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from analysis_tools.feature_creation import FrameToFeatures, TrajectoryToFeatures\n",
    "\n",
    "###wp: Ideal gas pca structure\n",
    "incpca_ig = IncrementalPCA(n_components=n_components_ig, whiten=True)  #NOTICE: whitening is on here\n",
    "\n",
    "frames = None\n",
    "features = None\n",
    "split_features = None\n",
    "#split=1\n",
    "\n",
    "#features_partial_ig=[];\n",
    "\n",
    "for etas_, file_base in file_data:\n",
    "    for eta in etas_:\n",
    "        print 'eta={}'.format(eta)\n",
    "        filename = \"{}/trajectory_{:.4f}.gsd\".format(file_base, eta)\n",
    "        frames = ReadGSD(filename, shuffle_data=True, randomize=True)        \n",
    "        #print frames[0]['orientation'][0:5]\n",
    "        \n",
    "        frames_split = array_split(frames, split)\n",
    "        \n",
    "        #frames = None\n",
    "        count = 0\n",
    "        \n",
    "        for frames_partial in frames_split:\n",
    "        #for frames_partial in frames_split[0:-1:2]:\n",
    "            #features_partial = TrajectoryToFeatures(frames_partial, N_nn=N_nn, method=method, \n",
    "            #                                        particle_inc=particle_inc, nn_inc=nn_inc)\n",
    "            #wp: Rather than using all frames by default, allow setting to skip some\n",
    "            \n",
    "            #if eta > 0.8200:\n",
    "            #    N_nni=N_nn2; particle_inci=particle_inc2; nn_inci=nn_inc2;\n",
    "            #else:\n",
    "            N_nni=N_nn; particle_inci=particle_inc; nn_inci=nn_inc;\n",
    "                \n",
    "            frames_partial=frames_partial[::frame_skip]\n",
    "            #frames_partial=frames_partial[0:200]\n",
    "        \n",
    "            features_partial = TrajectoryToFeaturesBatch(frames_partial, N_nn=N_nni, method=method, \n",
    "                                                         particle_inc=particle_inci, nn_inc=nn_inci,N_batch=N_batch)\n",
    "            \n",
    "            #features_partial = TrajectoryToFeaturesBatchR(frames_partial, N_nn=N_nni, method=method, \n",
    "             #                                            particle_inc=particle_inci, nn_inc=nn_inci,N_batch=N_batch)\n",
    "\n",
    "\n",
    "            \n",
    "            print features_partial.shape\n",
    "            incpca_ig.partial_fit(features_partial)\n",
    "            count = count + 1\n",
    "            print count\n",
    "            \n",
    "        clear_output()\n",
    "        frames_split = None\n",
    "        #features_partial_ig.append(features_partial)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train on actual data with trivial data variance removed by the ideal gas model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#n_components = N_nn/nn_inc-1 #this number will not affect the quality of the result just the computation time and amount of info returned\n",
    "n_components = N_batch*N_nn/nn_inc  #for this the more the better, however, 50 is probably enough\n",
    "#n_components = 2*N_nn/nn_inc  #for this the more the better, however, 50 is probably enough\n",
    "#n_components = N_nn/nn_inc*(N_batch+2) #for this the more the better, however, 50 is probably enough"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "incpca = IncrementalPCA(n_components=n_components , whiten=False)  #NOTE: not whitening here\n",
    "\n",
    "frames = None\n",
    "features = None\n",
    "split_features = None\n",
    "#split=1\n",
    "features_partial_ellipse=[]\n",
    "\n",
    "for etas_, file_base in file_data:\n",
    "    for eta in etas_:\n",
    "        print 'eta={}'.format(eta)\n",
    "        filename = \"{}/trajectory_{:.4f}.gsd\".format(file_base, eta)\n",
    "        frames = ReadGSD(filename, shuffle_data=True, randomize=False)\n",
    "        \n",
    "        frames_split = array_split(frames, split)\n",
    "        frames = None\n",
    "        count = 0\n",
    "        for frames_partial in frames_split:\n",
    "            #features_partial = TrajectoryToFeatures(frames_partial, \n",
    "            #                                        N_nn=N_nn, \n",
    "            #                                        method=method, \n",
    "            #                                        particle_inc=particle_inc, \n",
    "            #                                        nn_inc=nn_inc)\n",
    "            \n",
    "\n",
    "            #if eta > 0.8200:\n",
    "            #    N_nni=N_nn2; particle_inci=particle_inc2; nn_inci=nn_inc2;\n",
    "            #else:\n",
    "            N_nni=N_nn; particle_inci=particle_inc; nn_inci=nn_inc;\n",
    "                \n",
    "            frames_partial=frames_partial[::frame_skip]\n",
    "            #frames_partial=frames_partial[0:200]\n",
    "               \n",
    "            features_partial = TrajectoryToFeaturesBatch(frames_partial, N_nn=N_nni, method=method, \n",
    "                                                         particle_inc=particle_inci, nn_inc=nn_inci,N_batch=N_batch)\n",
    "            \n",
    "            #wp:project *hard disk* features onto ig eigenvectors\n",
    "            incpca.partial_fit(incpca_ig.transform(features_partial))\n",
    "            #count = count + 1\n",
    "            #print count\n",
    "        clear_output()\n",
    "        frames_split = None\n",
    "        #features_partial_ellipse.append(features_partial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### System train without ideal gas correction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "########wp: System fit *without ideal gas*\n",
    "incpca = IncrementalPCA(n_components=n_components , whiten=False)\n",
    "\n",
    "frames = None\n",
    "features = None\n",
    "split_features = None\n",
    "\n",
    "split=1\n",
    "for etas_, file_base in file_data:\n",
    "    for eta in etas_:\n",
    "        print 'eta={}'.format(eta)\n",
    "        filename = \"{}/trajectory_{:.4f}.gsd\".format(file_base, eta)\n",
    "        frames = ReadGSD(filename, shuffle_data=True, randomize=False)\n",
    "        \n",
    "        frames_split = array_split(frames, split)\n",
    "        frames = None\n",
    "        count = 0\n",
    "        for frames_partial in frames_split:\n",
    "            #features_partial = TrajectoryToFeatures(frames_partial, \n",
    "            #                                        N_nn=N_nn, \n",
    "            #                                        method=method, \n",
    "            #                                        particle_inc=particle_inc, \n",
    "            #                                        nn_inc=nn_inc)\n",
    "            \n",
    "            frames_partial=frames_partial[::frame_skip]\n",
    "            features_partial = TrajectoryToFeaturesBatchR(frames_partial, \n",
    "                                                    N_nn=N_nn, \n",
    "                                                   method=method, \n",
    "                                                    particle_inc=particle_inc, \n",
    "                                                    nn_inc=nn_inc,N_batch=N_batch)\n",
    "            \n",
    "            #wp: fits pure system features (no idea gas reduction)\n",
    "            incpca.partial_fit(features_partial)\n",
    "            count = count + 1\n",
    "            print \"Frame split: \", count\n",
    "        #wp:resets frame split\n",
    "        clear_output()\n",
    "        frames_split = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving trained models to files and reloading "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saves trained model to avoid retraining every time as well as memory issues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['trained_models/kappa_3.0.pca']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.externals import joblib\n",
    "folder_model='trained_models'\n",
    "model_ig=folder_model+'/kappa_3.0_ig.pca'; model=folder_model+'/kappa_3.0.pca';\n",
    "#wp: Saves model as file\n",
    "#ideal gas trained model\n",
    "joblib.dump(incpca_ig,model_ig)\n",
    "#full trained model\n",
    "joblib.dump(incpca,model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loads saved models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.externals import joblib\n",
    "#paths to where models are located\n",
    "folder_model='trained_models'\n",
    "model_ig=folder_model+'/kappa_3.0_ig.pca'; \n",
    "model=folder_model+'/kappa_3.0.pca';\n",
    "\n",
    "incpca_ig=joblib.load(model_ig);\n",
    "incpca=joblib.load(model);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fitting of models and analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute the order parameters based on two nested models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "frames = None\n",
    "features = None\n",
    "raw_OPs = []\n",
    "#split=1\n",
    "\n",
    "for etas_, file_base in file_data:\n",
    "    for eta in etas_:\n",
    "        print 'eta={}'.format(eta)\n",
    "        filename = \"{}/trajectory_{:.4f}.gsd\".format(file_base, eta)\n",
    "        #wp: randomize undefined here?\n",
    "        frames = ReadGSD(filename, shuffle_data=True, randomize=False)\n",
    "        \n",
    "        frames_split = array_split(frames, split)\n",
    "        frames = None\n",
    "        count = 0\n",
    "        means = []\n",
    "        raw_OPs_single = []\n",
    "        for frames_partial in frames_split:\n",
    "            #features_partial = TrajectoryToFeatures(frames_partial, \n",
    "            #                                        N_nn=N_nn, \n",
    "            #                                        method=method, \n",
    "            #                                        particle_inc=particle_inc,            \n",
    "            #                                       nn_inc=nn_inc)\n",
    "            \n",
    "            #if eta > 0.8200:\n",
    "            #    N_nni=N_nn2; particle_inci=particle_inc2; nn_inci=nn_inc2;\n",
    "            #else:\n",
    "            N_nni=N_nn; particle_inci=particle_inc; nn_inci=nn_inc;\n",
    "                \n",
    "            frames_partial=frames_partial[::frame_skip]\n",
    "            #frames_partial=frames_partial[0:50]\n",
    "        \n",
    "            features_partial = TrajectoryToFeaturesBatch(frames_partial, N_nn=N_nni, method=method, \n",
    "                                                         particle_inc=particle_inci, nn_inc=nn_inci,N_batch=N_batch)\n",
    "            \n",
    "            #wp: This returns the 'Z=X*U' matrix with mxn dimensions, where m=samples and n=feature vectors\n",
    "            transformed_features_partial = incpca.transform(incpca_ig.transform(features_partial))\n",
    "            #transformed_features_partial = incpca_ig.transform(features_partial)\n",
    "            #wp:No ideal gas correction\n",
    "            #transformed_features_partial = incpca.transform(features_partial)\n",
    "            raw_OPs_single.append(transformed_features_partial)\n",
    "            #count = count + 1\n",
    "            #print count\n",
    "        clear_output()\n",
    "        raw_OPs.append(raw_OPs_single)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute order parameter stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import array, mean, std, abs, asarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "OPs = []\n",
    "OPs_std = []\n",
    "OPs_abs = []\n",
    "\n",
    "for single_eta in raw_OPs:\n",
    "    merged_data = []\n",
    "    \n",
    "    #wp: here single_eta is just the feature vector of samples; the for loop below extracts it as array 'split'\n",
    "    for split_eta in single_eta:\n",
    "        merged_data.extend(split_eta)\n",
    "\n",
    "    #wp: averages over all samples m\n",
    "    OPs.append(mean((split_eta), axis=0))\n",
    "    OPs_std.append(std(split_eta, axis=0))\n",
    "    OPs_abs.append(mean(abs(split_eta), axis=0))\n",
    "\n",
    "OPs = array(OPs)\n",
    "OPs_std = array(OPs_std)\n",
    "OPs_abs = array(OPs_abs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The feature matrix input for each eta is of dimensions 15000 300\n",
      "Number of rows:  25\n",
      "Array size for each eta:  (15000, 299)\n",
      "[-1.00303441e+01 -1.77556249e+00  1.30781356e+00  2.03795414e-01\n",
      "  2.50251744e-01  6.27642025e-01 -1.64863411e+00 -3.62845784e-01\n",
      " -9.45259165e-01 -1.25129128e+00  1.99711483e+00 -1.11227122e+00\n",
      " -7.81434608e-01 -5.32036904e-01 -2.68644282e-01 -9.48330939e-01\n",
      " -6.43679540e-01 -5.57956690e-02  2.99958215e-01  5.59607093e-02\n",
      "  1.27101139e+00  2.90439357e-01 -1.95370069e+00  1.90829792e+00\n",
      " -5.43594333e-01  1.02595135e+00  2.13066613e+00  4.48223580e-01\n",
      "  1.26946395e+00  5.64154660e-03  8.56576975e-02  1.70423679e+00\n",
      " -1.77347972e-01  1.15237563e+00  1.01417854e+00 -9.23159115e-01\n",
      " -5.29846179e-01  1.43473882e+00 -6.40145346e-01 -7.58928757e-01\n",
      "  1.48086838e+00 -9.67280253e-01  1.35087100e+00  2.61573118e-01\n",
      "  1.74239012e-01 -1.19614816e-01 -4.30935450e-01 -1.98429991e+00\n",
      " -1.09323247e+00  1.15380070e+00  4.23927719e-02  5.80243584e-02\n",
      "  9.26227554e-02 -1.63183124e+00 -5.28956195e-02 -1.36147642e+00\n",
      "  7.53275187e-01  3.51552146e-01 -8.22863258e-01 -1.01575580e+00\n",
      "  2.13429990e-01  9.75057548e-01 -1.11021011e+00 -7.63735426e-01\n",
      " -8.39194686e-01 -1.02073570e+00  1.13993316e+00  5.42581819e-01\n",
      "  1.04944453e+00 -6.63348319e-01  3.59284602e-01 -3.05196112e-01\n",
      "  2.79166139e+00  7.26182581e-02 -5.60529314e-01 -2.28920580e+00\n",
      "  8.49198111e-01 -3.14411121e-02 -3.90648791e-01  1.35239825e-01\n",
      " -5.67983070e-01 -1.26694391e-01  9.52831014e-01 -6.04264923e-01\n",
      "  1.27179707e+00  1.43501940e+00 -9.49187742e-01 -2.64131543e-01\n",
      "  7.53441445e-01 -1.02474821e+00 -1.23820864e+00  6.50366412e-01\n",
      "  6.56633866e-02  9.83398570e-01  6.82856951e-01 -1.48419156e+00\n",
      "  8.29149114e-02  6.47963594e-01  1.25862065e+00  2.04535178e-01\n",
      "  4.11228150e-01  3.98804639e-01  7.07359698e-01 -1.01133393e+00\n",
      " -5.17499218e-01  1.88830930e-01  2.29393625e+00  1.20148313e+00\n",
      "  3.74912268e-01 -9.20152686e-01 -8.74277945e-01  1.61140540e+00\n",
      " -8.60192269e-01 -9.47401815e-02 -8.47756429e-01  3.79601604e-01\n",
      "  8.34964065e-02 -1.80176209e+00 -3.83776639e-01  1.84904441e+00\n",
      "  2.35653901e-01  5.05745764e-01 -4.83297693e-01  8.89514527e-01\n",
      " -1.12123783e-01 -1.07033954e-01 -5.43873655e-01  6.90991653e-01\n",
      " -1.13666272e-01  1.32167373e+00 -1.33270241e+00  7.31826007e-01\n",
      "  2.43152827e-02  5.38853441e-01 -7.29981278e-02 -7.98547491e-01\n",
      "  6.90708679e-01  3.63730821e-01  7.49006098e-01 -1.00362760e+00\n",
      " -1.22658976e+00  8.81608255e-01 -3.79860924e-01 -2.29777715e+00\n",
      "  1.54611106e+00 -1.00666541e+00 -1.96206600e-01 -1.52892048e+00\n",
      " -3.97521180e-02  1.29034532e+00 -4.45742953e-01  2.94184944e-01\n",
      "  1.87384176e-01 -2.31729067e-01 -9.39925374e-01 -6.10789323e-01\n",
      " -8.93976624e-01  1.05187593e+00 -5.43801543e-01 -1.91985889e-01\n",
      " -2.09178874e+00 -1.21355460e+00 -5.36265680e-01  4.19888468e-02\n",
      " -1.08832512e+00 -1.19724079e+00 -3.75661967e-02  8.84143287e-01\n",
      "  6.10794800e-01  8.54854111e-01 -1.92531368e-01 -5.18448803e-01\n",
      " -2.07580257e-01  3.74823722e-01  1.27789130e+00  1.69773162e+00\n",
      " -1.57223812e+00  1.56745708e+00  3.33465452e-01  1.49518102e-01\n",
      "  1.74165192e-01 -6.39198637e-01 -7.71047665e-01 -2.09718970e+00\n",
      " -7.88695951e-02 -1.67407327e+00  1.01224539e-01  1.06538712e+00\n",
      "  9.63114103e-01 -6.66010403e-01  1.07955974e+00  1.75130387e-02\n",
      "  1.64641699e+00 -2.92474898e-01  5.03404624e-01 -1.73328746e-01\n",
      "  1.70624870e+00 -8.60853234e-01 -1.51685122e+00 -6.57205856e-02\n",
      " -5.23240345e-01  4.74679463e-01 -2.73203890e-02 -7.82942399e-01\n",
      " -4.02060062e-01 -1.29362511e+00  1.32071694e+00  7.13415034e-01\n",
      " -1.12241470e+00  1.11416218e-01 -9.94942937e-01 -5.62158192e-01\n",
      "  4.10912383e-02  3.45095463e-01 -2.35424231e-01 -1.12967356e+00\n",
      " -7.92941959e-01 -5.05740806e-02 -6.61522743e-01 -1.01512384e+00\n",
      "  1.49940446e+00 -1.42787433e+00 -7.71165731e-01 -4.97835694e-01\n",
      "  4.75721897e-01  2.75047169e-01  2.55323104e-01  4.53034282e-01\n",
      " -4.03306567e-01 -4.90260851e-01  1.62284202e-01  1.29326383e+00\n",
      "  7.76968388e-01  2.37186588e-01  2.65853733e-01  8.73214214e-02\n",
      "  6.92673597e-01 -1.10175183e+00  1.48813351e+00  2.52886906e-01\n",
      " -6.34752864e-02  1.05969458e+00 -6.56744341e-01 -9.53131818e-01\n",
      " -3.23614832e-02  4.57689002e-01  1.36149238e+00 -1.18876935e-02\n",
      "  1.09386029e+00 -2.30008275e-01  5.76542299e-01  4.24087684e-01\n",
      "  6.37500407e-01 -1.50513870e-01  1.31235133e+00  8.25443682e-01\n",
      " -6.11741269e-01  8.20583153e-01 -2.14355831e-01 -3.22674593e-01\n",
      "  2.46115976e-02  3.30306660e-01  6.86181163e-01 -1.39155175e-02\n",
      " -8.26671404e-01 -1.42978701e-01  1.21213100e+00 -7.66822622e-01\n",
      " -7.29311301e-02  1.99084642e+00 -7.60062033e-02 -3.63906212e-01\n",
      " -3.81579264e-01  1.66885451e-01 -1.57599333e+00 -5.75389172e-01\n",
      "  2.75744819e-01  2.62682916e-01 -1.77961422e+00 -1.02976119e+00\n",
      " -7.80657543e-01 -7.93769804e-01  4.99990193e-01 -1.03211156e+00\n",
      " -4.28993877e-01 -2.30558634e-01  5.33617794e-02  1.56009157e+00\n",
      "  1.31788914e+00  1.06728787e-01  2.38932016e+00  1.36449346e+00\n",
      "  1.67257834e+00  3.95434131e-01 -9.85026894e-01 -1.72694326e+00\n",
      "  3.33459019e-01  1.43365812e+00 -1.70677523e-01]\n",
      "Shape of average order parameter (25, 299)\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'plt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m\u001b[0m",
      "\u001b[0;31mNameError\u001b[0mTraceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-c7c494c0fd0f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mraw_OP_samples\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0metas\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mraw_OP_samples\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'o-'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'plt' is not defined"
     ]
    }
   ],
   "source": [
    "#wp:figuring things out...\n",
    "print \"The feature matrix input for each eta is of dimensions\",len(features_partial),len(features_partial[0])\n",
    "\n",
    "eta_index=0\n",
    "print \"Number of rows: \", len(raw_OPs)\n",
    "print \"Array size for each eta: \", raw_OPs[eta_index][0].shape\n",
    "print raw_OPs[eta_index][0][0]\n",
    "\n",
    "raw_OP_sample=[]\n",
    "raw_OP_samples=[]\n",
    "samplenum=20\n",
    "for mi in range(samplenum):\n",
    "    for eta_index in range(len(raw_OPs)):\n",
    "        raw_OP_sample.append(raw_OPs[eta_index][0][mi][0])\n",
    "    raw_OP_samples.append(asarray(raw_OP_sample))\n",
    "    raw_OP_sample=[]\n",
    "\n",
    "#wp: for the averaged value\n",
    "print \"Shape of average order parameter\", OPs.shape\n",
    "\n",
    "for i in range(len(raw_OP_samples)):\n",
    "    plt.plot(etas,raw_OP_samples[i], 'o-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Check out the results of PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from random import randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f54a4038fd0>]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAFiCAYAAADiGfPoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvFvnyVgAAG8xJREFUeJzt3X+QXWd93/H3h5VlHKBgCJMG2QE7ETRySW2yUciQQBsMlklr0dYUkWbqtJ7ZcYonZJhkYg8ZkzrJDD+mpO3UCbiNO+SHqxAgrqYVcQHjdGhq0MY2NjKjsBYMlkLCDLYhCY5t2d/+cc/uPffeXemudWH3Wd6vmZ17ft77PbrSR88+5znnpKqQJG0dT9voAiRJs2WwS9IWY7BL0hZjsEvSFmOwS9IWY7BL0hazbaMLAEjimEtJegqqKuPLNkWwAzieXpLWJ5nIdMCuGEnacgx2SdpiDHZJ2mIMdknaYqYK9iR7khxJspTkmpNs98+TVJL53rJru/2OJLlkFkVLktZ2ylExSeaAG4DXAMeAQ0kOVNV9Y9s9C3gL8Knesl3APuAC4AXAx5K8uKqemN0hSJL6pmmx7waWqupoVT0G7Af2rrLdrwDvBP62t2wvsL+qHq2qLwBL3ftJkr5Jpgn2HcADvflj3bIVSV4GnFtV/2u9+0qSZuu0L1BK8jTgPcBPn877zM+vdMuzsLDAwsLC6RUmSd+mpgn248C5vflzumXLngX8feD27iqovwscSHLZFPuuWFxcnL5qSdKacqpL+ZNsA/4MeDWDUD4E/GRVHV5j+9uBn6+qxSQXADcz6Fd/AfBxYOf4ydMktd5bCtxy13HefesR/vzhR3jBc87iFy55Ca+/yF4eSd8+kjy1e8VU1YkkVwO3AnPATVV1OMn1wGJVHTjJvoeTfAC4DzgBvHkWI2Juues41374Xh55fPBWxx9+hGs/fC+A4S7p294pW+zfkiLW2WJ/xTtu4/jDj0ws3/Gcs/i/1/z4LEuTpE1rrRZ7k1ee/vkqoX6y5ZL07aTJYH/Bc85a13JJ+nbSZLD/wiUv4awz5kaWnXXGHL9wyUs2qCJJ2jw2zYM21mP5BOnb/vBe/uaxJ9jhqBhJWtFksMMg3O9+4GE+fOcxT5hKUk+TXTF9Gz+mR5I2l6aDPcFkl6QxbQc7qz/IVZK+nTUd7GCDXZLGNR3sCWyGK2claTNpO9ixxS5J49oO9oANdkka1Xiwh7LNLkkj2g52bLFL0rimg53Yxy5J45oO9pjskjSh7WD3+iRJmtB2sIMnTyVpTNPBDp48laRxTQd77GKXpAltBzvxlgKSNKbtYLfFLkkT2g527GOXpHFNB7vjHSVpUtPBvhzr9rNL0lDbwd4lu7kuSUNtB7uPxpOkCW0H+3KLfWPLkKRNpelgX2YfuyQNTRXsSfYkOZJkKck1q6y/Ksm9Se5O8skku7rlL0rySLf87iTvnWXxKydPZ/mmktS4bafaIMkccAPwGuAYcCjJgaq6r7fZzVX13m77y4D3AHu6dfdX1YWzLXu5tsGrDXZJGpqmxb4bWKqqo1X1GLAf2NvfoKq+3pt9Bt+iRnS6ZPcOj5I0NE2w7wAe6M0f65aNSPLmJPcD7wJ+trfqvCR3JfnjJD92WtWuwRa7JA3N7ORpVd1QVd8L/CLwS93iLwPfU1UXAW8Fbk7yd1bbf35+fuXnxhtvnOozvfBUkiadso8dOA6c25s/p1u2lv3AbwJU1aPAo930n3Yt+hcDi+M7LS5OLDql5XHsttglaWiaFvshYGeS85JsB/YBB/obJNnZm/0J4PPd8ud3J19Jcj6wEzg6i8IH7zl4tY9dkoZO2WKvqhNJrgZuBeaAm6rqcJLrgcWqOgBcneRi4HHgIeCKbvdXAtcneRx4Eriqqh6cVfH2xEjSpGm6Yqiqg8DBsWXX9abfssZ+HwI+dDoFnozDHSVp0ta48nSjC5CkTaTpYB+ePDXaJWlZ28HuTcAkaULTwb7MBrskDTUd7LHJLkkT2g727tVx7JI01HawO9xRkia0Hezdq7kuSUNtB7t3AZOkCY0H++DVceySNNR0sC8z1iVpqOlgX+ljN9klaUXTwY6PxpOkCU0H+8qpU3Ndkla0HexeeCpJE9oOdh+NJ0kT2g52H40nSRPaDvbu1Ra7JA21HexeeCpJE9oO9uU+9g2uQ5I2k6aDHW8pIEkT2g72jrkuSUNNB7td7JI0qe1gj+PYJWlc28HevTqOXZKG2g52H40nSRO2RrBvbBmStKm0Hewr94ox2iVpWdvB7rAYSZowVbAn2ZPkSJKlJNessv6qJPcmuTvJJ5Ps6q27ttvvSJJLZln8MtvrkjR0ymBPMgfcAFwK7ALe1A/uzs1V9dKquhB4F/Cebt9dwD7gAmAP8Bvd+82Ewx0ladI0LfbdwFJVHa2qx4D9wN7+BlX19d7sMxg2ovcC+6vq0ar6ArDUvd+MmeyStGzbFNvsAB7ozR8Dfnh8oyRvBt4KbAd+vLfvHWP77nhKla7C2/ZK0qSZnTytqhuq6nuBXwR+ab37z8/Pr/zceOONU+3jcEdJmjRNi/04cG5v/pxu2Vr2A7+53n0XFxenKGWUj8aTpEnTtNgPATuTnJdkO4OToQf6GyTZ2Zv9CeDz3fQBYF+SM5OcB+wEPn36ZS9/7uDVWwpI0tApW+xVdSLJ1cCtwBxwU1UdTnI9sFhVB4Crk1wMPA48BFzR7Xs4yQeA+4ATwJur6olZFW8fuyRNmqYrhqo6CBwcW3Zdb/otJ9n314Bfe6oFnoz3ipGkSU1feeod2SVpUtPBbh+7JE1qO9i7V7tiJGmo6WCXJE1qOti9V4wkTWo72LtX+9glaajtYHe4oyRN2BrBvrFlSNKm0naw+2g8SZrQdLBji12SJjQd7F53KkmT2g52hztK0oS2g31lymSXpGVNB/syW+ySNNR0sDvcUZImtR3sPhpPkia0HewrV56a7JK0rO1g716NdUkaajrY8V4xkjSh6WBf6WO3zS5JK9oOdi89laQJbQf78oQNdkla0XawL99SYIPrkKTNpOlgX+bJU0kaajrYh1eemuyStKztYO9ebbFL0lDbwe69YiRpQtPBjo/Gk6QJUwV7kj1JjiRZSnLNKuvfmuS+JPck+XiSF/bWPZHk7u7nwCyLt8UuSZO2nWqDJHPADcBrgGPAoSQHquq+3mZ3AfNV9Y0kPwO8C3hjt+6RqrpwxnUPalueMNklacU0LfbdwFJVHa2qx4D9wN7+BlX1iar6Rjd7B3DObMtcXbz0VJImTBPsO4AHevPHumVruRL4SG/+6UkWk9yR5PVPocY1De/uaJNdkpadsitmPZL8FDAPvKq3+IVVdTzJ+cBtSe6tqvvH952fn1+ZXlhYYGFhYYrPG7x67lSShqYJ9uPAub35c7plI5JcDLwNeFVVPbq8vKqOd69Hk9wOXARMBPvi4uK6CgefoCRJq5mmK+YQsDPJeUm2A/uAkdEtSS4C3gdcVlVf6S0/O8mZ3fR3Aq8A+iddZ8Jcl6ShU7bYq+pEkquBW4E54KaqOpzkemCxqg4A7waeCfxBd0LzS1V1GfD9wPuSPMngP5F3jI2mOS0+Gk+SJk3Vx15VB4GDY8uu601fvMZ+fwK89HQKnIaxLklDTV956slTSZrUdrD7OGtJmtB2sNtil6QJWyLYJUlDbQc7PhpPksa1Hex2xUjShLaDvXv1XjGSNNR0sC+zxS5JQ00Huw/akKRJTQe7j8aTpElNB7vDHSVpUtvB3r3aYJekobaDPcvj2E12SVrWdrBvdAGStAm1HexeoCRJE9oOdh+NJ0kT2g52x7FL0oSmg32Z49glaWhrBPtGFyBJm0jTwR4foCRJExoPdsexS9K4toO9e7WLXZKG2g52r1CSpAltB7uPxpOkCW0Hu1eeStKEtoO9e/XkqSQNNR3s2GKXpAltB3vHXJekoaaDPTbZJWnCVMGeZE+SI0mWklyzyvq3JrkvyT1JPp7khb11VyT5fPdzxSyL9yZgkjTplMGeZA64AbgU2AW8Kcmusc3uAuar6geADwLv6vZ9LvB24IeB3cDbk5w9q+K9QEmSJk3TYt8NLFXV0ap6DNgP7O1vUFWfqKpvdLN3AOd005cAH62qB6vqIeCjwJ7ZlN67pYDJLkkrpgn2HcADvflj3bK1XAl85Cnuuy5eeCpJk7bN8s2S/BQwD7xqvfvOz8+vTC8sLLCwsDDF5w1eba9L0tA0wX4cOLc3f063bESSi4G3Aa+qqkd7+/7DsX1vX+1DFhcXpyhl7DN9NJ4kTZimK+YQsDPJeUm2A/uAA/0NklwEvA+4rKq+0lt1K/DaJGd3J01f2y2bDVvskjThlC32qjqR5GoGgTwH3FRVh5NcDyxW1QHg3cAzgT/oTmh+qaouq6oHk/wKg/8cAK6vqgdnVfzwXjFGuyQtm6qPvaoOAgfHll3Xm774JPveBNz0VAuUJK1P41eeDthgl6ShtoPdR+NJ0oS2g717tcUuSUNtB7ujYiRpQtvB7rWnkjSh7WD3rr2SNKHpYF/myVNJGmo62G2xS9KktoPdPnZJmtB2sHtLAUma0HSwLzPXJWmo6WBfuUBpQ6uQpM2l7WCP92OXpHFtB3v36nBHSRpqO9gdFCNJExoPdrtiJGlc08G+zFyXpKHmgz3BJrsk9bQf7Nhil6S+9oM9scEuST3NBzs43FGS+poPdrvYJWlU+8Ee+9glqa/9YMc+dknqaz7YvSW7JI1qPtgHwx1tskvSsvaD3YHskjSi/WAn5rok9bQf7PHReJLUN1WwJ9mT5EiSpSTXrLL+lUnuTHIiyeVj655Icnf3c2BWha+8P45jl6S+bafaIMkccAPwGuAYcCjJgaq6r7fZl4CfBn5+lbd4pKounEGtazLXJWnolMEO7AaWquooQJL9wF5gJdir6ovduie/CTWelPeKkaRR03TF7AAe6M0f65ZN6+lJFpPckeT166puCg53lKRR07TYT9cLq+p4kvOB25LcW1X3j280Pz+/Mr2wsMDCwsJ07x772CWpb5pgPw6c25s/p1s2lao63r0eTXI7cBEwEeyLi4vTvuUILzyVpFHTdMUcAnYmOS/JdmAfMNXoliRnJzmzm/5O4BX0+uZnIT7RWpJGnDLYq+oEcDVwK/A54ANVdTjJ9UkuA0jyQ0mOAW8A3pfkcLf79wOLST4DfAJ4x9homtPmOHZJGjVVH3tVHQQOji27rjd9iEEXzfh+fwK89DRrPCnvKCBJo7bAlacOd5SkvvaDHYc7SlJf88EODneUpL7mg91H40nSqOaDHR+NJ0kjmg/2wTB2k12SlrUf7BtdgCRtMu0Hu/eKkaQR7Qe7feySNKL9YI/j2CWpr/1gx64YSeprP9gT2+uS1NN8sIMtdknq2xrBbptdklY0H+zxvr2SNGJLBLu5LklD7Qe7155K0oj2g91H40nSiPaDHbtiJKmv/WD30XiSNKL9YMcWuyT1NR/s2McuSSOaD3Zb7JI0qvlgB0x2SeppPtgHNwEz2SVpWfvBjjcBk6S+9oPdC08laUT7we6j8SRpxFTBnmRPkiNJlpJcs8r6Vya5M8mJJJePrbsiyee7nytmVfjw/b1tryT1nTLYk8wBNwCXAruANyXZNbbZl4CfBm4e2/e5wNuBHwZ2A29Pcvbplz3KFrskDU3TYt8NLFXV0ap6DNgP7O1vUFVfrKp7gCfH9r0E+GhVPVhVDwEfBfbMoO4VPhpPkkZNE+w7gAd688e6ZdM4nX2n4qgYSRq1baMLWDY/P78yvbCwwMLCwlT7DUbFmOyStGyaYD8OnNubP6dbNo3jwD8c2/f21TZcXFyc8i0n2WKXpKFpumIOATuTnJdkO7APODDl+98KvDbJ2d1J09d2y2bGR+NJ0qhTBntVnQCuZhDInwM+UFWHk1yf5DKAJD+U5BjwBuB9SQ53+z4I/AqD/xwOAdd3y2ZmMI7daJekZdkMoZiknmodl/3nT/K8Z2znv/3r3TOuSpI2t8GDhmri+vstcOWpXTGS1Nd8sOOj8SRpRPPBbotdkka1H+w+Gk+SRrQf7BtdgCRtMu0Hu33skjSi+WAHb9srSX3NB7s3AZOkUe0Hewx2SeprP9g9fSpJI5oPdnw0niSNaD7Y7WOXpFHtB7u37ZWkEe0HOya7JPW1H+z2sUvSiK0R7Oa6JK1oPtjBnhhJ6ms+2H00niSNaj/YPXcqSSOaD3ZJ0qjmg93b9krSqPaDHbtiJKmv/WD3ngKSNKL9YMcWuyT1tR/s9rFL0oj2gx1vKSBJfc0HO9jFLkl9zQe794qRpFHNBzs+Gk+SRkwV7En2JDmSZCnJNausPzPJ73frP5XkRd3yFyV5JMnd3c97Z1u+txSQpHHbTrVBkjngBuA1wDHgUJIDVXVfb7MrgYeq6vuS7APeCbyxW3d/VV0447qH9YE3AZOknmla7LuBpao6WlWPAfuBvWPb7AXe301/EHh1km9JH8m35lMkqR3TBPsO4IHe/LFu2arbVNUJ4GvA87p15yW5K8kfJ/mx06x3wuC2vbN+V0lq1ym7Yk7Tl4HvqaqvJvlB4JYkF1TV18c3nJ+fX5leWFhgYWFhqg/w0XiSNGqaYD8OnNubP6dbtto2x5JsA54NfLUGnd+PAlTVnya5H3gxsDj+IYuLE4um4nBHSRo1TVfMIWBnkvOSbAf2AQfGtjkAXNFNXw7cVlWV5PndyVeSnA/sBI7OpvSBENvrktRzyhZ7VZ1IcjVwKzAH3FRVh5NcDyxW1QHgt4DfSbIEPMgg/AFeCVyf5HHgSeCqqnpwpkcQR8VIUt9UfexVdRA4OLbsut703wJvWGW/DwEfOs0aT13fN/sDJKkhzV956mhHSRrVfrB76akkjWg/2DHXJamv/WD35KkkjWg/2LHFLkl97Qe7j8aTpBHtBzveUkCS+poPdrylgCSNaD7YvbujJI1qPtglSaOaD3YftCFJo9oPdhzHLkl97Qe7dxSQpBHtB7snTyVpRPvB7qPxJGnE1gh2c12SVjQf7PhoPEka0Xyw22KXpFHtBzvguBhJGmo+2MEWuyT1NR/sXnkqSaPaD3ZPnkrSiPaD3UfjSdKI9oMdT51KUl/TwX7LXcf54J3HePgbj/OKd9zGLXcd3+iSJGnDZTN0YySp9dZxy13HufbD9/LI408M3wf4ly//Hn719S+dcYWStPkMnvlcE0NImm2xv/vWIyOhDoMumd+940v80i33bkxRkrQJbNvoAp6qP3/4EZ7PQ7xv+6+zjROjK++Ee+6EuaeFFzz7LM7+jjNWf5O57fATvw7/8+fgyce/+UXPmvVvrJbrb7l22Fr1J/DG34NnfdfM3r7ZrphXvOM2rvrrG/ipuY+d1mcfqR28JO32zVv/xmq5/pZrh/brX8q5fB8PDK6en78S/vF71v0ea3XFTBXsSfYA/xGYA/5rVb1jbP2ZwG8DPwh8FXhjVX2xW3ctcCXwBPCzVXXrKu+/7mD/yP+7m4v/6B9xRp5c137jqtq+yMn6N1bL9bdcO2yt+h/lDG675GNc+iMXrus9nnIfe5I54AbgUmAX8KYku8Y2uxJ4qKq+D/h14J3dvruAfcAFwB7gN7r3O22XfvW3mTvNUJekzWBbneCrB391ZiP7pjl5uhtYqqqjVfUYsB/YO7bNXuD93fQHgVcnSbd8f1U9WlVfAJa69zs9f/UXcNfvzuTMb8v/44P1b7SW62+5dtha9c+luPxpt/Nbf3THTN57mmzcATzQmz/WLVt1m6o6AXwNeN6U+67fH78LnmjwhIkkreEMTvCGv7l5Ju+1aUbFzM/Pr0wvLCywsLCw9sbHPg3YDSNp65hL8fIz7p/Je00T7MeBc3vz53TLVtvmWJJtwLMZnESdZl8AFhcXpywZuOqTJ119y13H+eUDh3n4EVv1ktpwxlx49+X/gBfP4L1OOSqmC+o/A17NIJQPAT9ZVYd727wZeGlVXZVkH/DPqupfJLkAuJlBv/oLgI8DO6vqibHPWPeoGElq1Xjj8+zvOIO3/5MLeP1F6+upPt3hjq8D/gOD4Y43VdWvJbkeWKyqA0meDvwOcBHwILCvqo52+74N+DfACeDnquojq7y/wS5J63Rawf7NZrBL0vptuXvFSJJWZ7BL0hZjsEvSFmOwS9IWY7BL0hZjsEvSFtN8sN94440bXcLMeCybk8eyeW2l45nlsRjsm4jHsjl5LJvXVjoeg12StKZNc+XpRtcgSS3atLcUkCTNjl0xkrTFGOyStMU0HexJ9iQ5kmQpyTUbXc96JfliknuT3J1ksVv23CQfTfL57vXsja5zNUluSvKVJJ/tLVu19gz8p+57uifJyzau8klrHMsvJznefTd3d7euXl53bXcsR5JcsjFVry7JuUk+keS+JIeTvKVb3tx3c5Jjae67SfL0JJ9O8pnuWP5dt/y8JJ/qav79JNu75Wd280vd+het6wOrqskfBveGvx84H9gOfAbYtdF1rfMYvgh859iydwHXdNPXAO/c6DrXqP2VwMuAz56qduB1wEeAAC8HPrXR9U9xLL8M/Pwq2+7q/q6dCZzX/R2c2+hj6NX33cDLuulnMXhIzq4Wv5uTHEtz30335/vMbvoM4FPdn/cHGDy/AuC9wM900/8WeG83vQ/4/fV8Xsst9t3AUlUdrarHgP3A3g2uaRb2Au/vpt8PvH4Da1lTVf0fBg9V6Vur9r3Ab9fAHcBzknz3t6bSU1vjWNayF9hfVY9W1ReAJQZ/FzeFqvpyVd3ZTf8V8DkGD5Bv7rs5ybGsZdN+N92f7193s2d0PwX8OPDBbvn497L8fX0QeHWSidEva2k52HcAD/Tmj3HyL30zKuB/J/nTJMtP7/6uqvpyN/0XwHdtTGlPyVq1t/pdXd11T9zU6xJr5li6X98vYtA6bPq7GTsWaPC7STKX5G7gK8BHGfxG8XBVneg26de7cizd+q8Bz5v2s1oO9q3gR6vqZcClwJuTvLK/sga/hzU5HrXl2ju/CXwvcCHwZeDfb2w565PkmcCHGDyO8uv9da19N6scS5PfTVU9UVUXAucw+E3i732zPqvlYD8OnNubP6db1oyqOt69fgX4QwZf9l8u/yrcvX5l4ypct7Vqb+67qqq/7P4hPgn8F4a/0m/6Y0lyBoMg/L2q+nC3uMnvZrVjafm7Aaiqh4FPAD/CoOtrW7eqX+/KsXTrnw18ddrPaDnYDwE7u7PK2xmcYDiwwTVNLckzkjxreRp4LfBZBsdwRbfZFcD/2JgKn5K1aj8A/KtuBMbLga/1ugU2pbF+5n/K4LuBwbHs60YtnAfsBD79ra5vLV0/7G8Bn6uq9/RWNffdrHUsLX43SZ6f5Dnd9FnAaxicM/gEcHm32fj3svx9XQ7c1v2mNZ2NPlt8mmeaX8fgTPn9wNs2up511n4+gzP4nwEOL9fPoB/t48DngY8Bz93oWteo/78z+DX4cQZ9g1euVTuDEQE3dN/TvcD8Rtc/xbH8TlfrPd0/su/ubf+27liOAJdudP1jx/KjDLpZ7gHu7n5e1+J3c5Jjae67AX4AuKur+bPAdd3y8xn857ME/AFwZrf86d38Urf+/PV8nrcUkKQtpuWuGEnSKgx2SdpiDHZJ2mIMdknaYgx2SdpiDHZJ2mIMdknaYgx2Sdpi/j+Pqp2Lz7XRKAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "####wp: Comparing the component variance for the hard disk and ideal gas system\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.plot(incpca.explained_variance_ratio_,marker='o')\n",
    "plt.plot(incpca_ig.explained_variance_ratio_,marker='^')\n",
    "\n",
    "#plt.ylim(-0.1,0.1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explained variance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pineros/programs/local/miniconda2/lib/python2.7/site-packages/matplotlib/font_manager.py:1339: UserWarning: findfont: Font family [u'arial'] not found. Falling back to DejaVu Sans\n",
      "  (prop.get_family(), self.defaultFamily[fontext]))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the principal components\n",
    "colors = 200*['green', 'purple', 'orange', 'teal', 'black', 'red']\n",
    "\n",
    "#plt.plot(incpca.explained_variance_ratio_, marker='o', linewidth=1.0, markersize=12, color = 'red', markerfacecolor='None') \n",
    "plt.plot(incpca.explained_variance_ratio_, marker='o', linewidth=1.0, markersize=5) \n",
    "\n",
    "\n",
    "#backround grid details\n",
    "axes = plt.gca()\n",
    "#axes.grid(b = True, which = 'both', axis = 'both', color = 'gray', linestyle = '-', alpha = 0.5, linewidth = 0.5) \n",
    "#axes.set_axis_bgcolor('white')  \n",
    "\n",
    "#font scpecifications\n",
    "title_font = {'family' : 'arial', 'color'  : 'black', 'weight' : 'heavy','size': 20}\n",
    "axis_label_font = {'family' : 'arial', 'color'  : 'black', 'weight' : 'normal','size': 20}                                                   \n",
    "\n",
    "#figure size and tick style\n",
    "plt.rcParams[\"figure.figsize\"] = [12,12]\n",
    "plt.rc('axes',edgecolor='black',linewidth=1)\n",
    "plt.tick_params(which='both', axis='both', color='black', length=4, width=0.5)\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "\n",
    "#plt.yscale('log')\n",
    "#!!!wp: Why eta? #Shouldn't be features?\n",
    "plt.xlabel(r'component', y=3, fontsize=40, fontdict = axis_label_font)\n",
    "plt.ylabel(r'Explained variance', fontsize=40, fontdict = axis_label_font)\n",
    "\n",
    "#title and axis labels\n",
    "plt.tick_params(axis='both', labelsize=30)\n",
    "plt.tight_layout()\n",
    "#plt.title('Explained variance for principal components', y=1.05, fontdict = title_font)\n",
    "\n",
    "#saves\n",
    "#plt.savefig('figures/OP_variance_orientation_4_3N.svg')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Principal component weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import dot\n",
    "components = dot(incpca.components_, incpca_ig.components_)\n",
    "components_ig = incpca_ig.components_\n",
    "#components = incpca.components_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the principal components\n",
    "#colors = 200*['green', 'purple', 'orange', 'teal', 'black', 'red']\n",
    "for i in range(0,1):\n",
    "    p_data = components[i]\n",
    "    #plt.plot(range(len(p_data)), p_data, marker='o', linewidth = 1.0, markersize=5, color = colors[i])\n",
    "    plt.plot(range(len(p_data)), p_data, marker='o', linewidth = 1.0, markersize=5)\n",
    "    #p_data = components_ig[i]\n",
    "    #plt.plot(range(len(p_data)), p_data, marker='^', linewidth = 1.0, markersize=5, color = colors[i])  \n",
    "  \n",
    "\n",
    "#backround grid details\n",
    "axes = plt.gca()\n",
    "#axes.grid(b = True, which = 'both', axis = 'both', color = 'gray', linestyle = '-', alpha = 0.5, linewidth = 0.5) \n",
    "#axes.set_axis_bgcolor('white')  \n",
    "\n",
    "#font scpecifications\n",
    "title_font = {'family' : 'arial', 'color'  : 'black', 'weight' : 'heavy','size': 20}\n",
    "axis_label_font = {'family' : 'arial', 'color'  : 'black', 'weight' : 'normal','size': 20}                                                   \n",
    "\n",
    "#figure size and tick style\n",
    "plt.rcParams[\"figure.figsize\"] = [12,12]\n",
    "plt.rc('axes',edgecolor='black',linewidth=1)\n",
    "plt.tick_params(which='both', axis='both', color='black', length=4, width=0.5)\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "\n",
    "\n",
    "#axis range and labels (also specify if log or not)\n",
    "#plt.xlim(0.1,100)\n",
    "\n",
    "#plt.yscale('log')\n",
    "plt.xlabel(r'$n$th component', y=3, fontsize=40, fontdict = axis_label_font)\n",
    "plt.ylabel(r'$P_{1}$ weight', fontsize=40, fontdict = axis_label_font)\n",
    "\n",
    "#title and axis labels\n",
    "plt.tick_params(axis='both', labelsize=25)\n",
    "#plt.title('PCA feature weights', y=1.05, fontdict = title_font)\n",
    "\n",
    "#save figure\n",
    "fig=plt.figure(1)\n",
    "plt.tight_layout()\n",
    "#plt.savefig('figures/OP_orientation_batch_kappa_4_weights.svg',dpi=fig.dpi)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Order parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the principal components\n",
    "colors = 200*['green', 'purple', 'orange', 'teal', 'black', 'red']\n",
    "for i in range(0,1): #12,13\n",
    "    #p_data = (OPs[:,i]-OPs[0,i])/max(OPs[:,i]-OPs[0,i])\n",
    "    p_data = OPs[:,i]\n",
    "    #plt.plot(etas, (p_data), marker='o', linewidth = 1.0, markersize=10, color = colors[i], markerfacecolor='None')\n",
    "    #p_data = OPs_std[:,i]/max(OPs_std[:,i])\n",
    "    #plt.plot(etas, (p_data), marker='^', linewidth = 1.0, markersize=12, color = colors[i])\n",
    "    #p_data = OPs_abs[:,i]\n",
    "    plt.plot(etas, (p_data), marker='.', linewidth = 1.0, markersize=10, color = colors[i])\n",
    "\n",
    "#backround grid details\n",
    "axes = plt.gca()\n",
    "axes.grid(b = True, which = 'both', axis = 'both', color = 'gray', linestyle = '-', alpha = 0.5, linewidth = 0.5) \n",
    "\n",
    "\n",
    "#figure size and tick style\n",
    "plt.rcParams[\"figure.figsize\"] = [6,6]\n",
    "plt.rc('axes',edgecolor='black',linewidth=1)\n",
    "plt.tick_params(which='both', axis='both', color='black', length=4, width=0.5)\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "\n",
    "#axis range and labels (also specify if log or not)\n",
    "#plt.xlim(0.60, 0.84)\n",
    "\n",
    "#plt.yscale('log')\n",
    "plt.xlabel(r'$\\eta$', y=3, fontsize=20, fontdict = axis_label_font)\n",
    "plt.ylabel(r'$\\langle P_{i} \\rangle$ and $\\langle |P_{i}| \\rangle$', fontsize=20, fontdict = axis_label_font)\n",
    "\n",
    "#title and axis labels\n",
    "plt.tick_params(axis='both', labelsize=20)\n",
    "plt.title('PCA ellipsoids', y=1.05, fontdict = title_font)\n",
    "\n",
    "#save figure\n",
    "fig=plt.figure(1)\n",
    "plt.tight_layout()\n",
    "#plt.savefig('figures/OP_orientation_batch_kappa_4_ave_std.svg',dpi=fig.dpi)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save OPs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Append eta ranges\n",
    "etas2=etas.reshape(etas.shape[0],1)\n",
    "\n",
    "#etas2=etas[...,None] #wp: works just as fine\n",
    "OPsave=np.concatenate((etas2,OPs),1)\n",
    "\n",
    "#save to txt file\n",
    "np.savetxt('OPs_kappa3_30k_300_3N.dat',OPsave)\n",
    "np.savetxt('OPs_kappa3_30k_300_std_3N.dat',OPs_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}