analiza_18-08-2016-gene.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# %matplotlib inline\n",
    "# -*- coding: utf-8 -*-\n",
    "from __future__ import division #~ Domysle dzielenie int jako liczb float\n",
    "# from igraph import *     #~ Do symulacji grafu\n",
    "# import random            #~ Do wybierania losowych elementow z listy\n",
    "# from  matplotlib import rc\n",
    "# import itertools        #~ do list i iteratorow\n",
    "# import numpy as np        #~ Do np.arange\n",
    "# import time                #~ Do diagnostyki czasu wykonania\n",
    "# import os                #~ Do sprawdzania istnienia folderów\n",
    "# import gzip                #~ Do pakowania plikow wynikowych\n",
    "# import cPickle as pickle   #~ Do pakowania plikow wynikowych\n",
    "# from FilesManagment import CheckFolder, CompressFile, CompressData, FindFileNumber, SaveToFileNumberOfFiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'SimulateClique' from '/dmj/fizmed/pkowalczyk/now/licencjat/SimulateClique.pyc'>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append('/dmj/fizmed/pkowalczyk/now/complex_networks_sim')\n",
    "import SimulateClique\n",
    "reload(SimulateClique)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# rc('font', family='Arial') #Plotowanie polskich liter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "stg = {\n",
    "    'CONST_PRINT'     : False,  #~ Czy drukowac magnetyzacje co CONST_VERTICES krokow?\n",
    "    'CONST_OVERRIDEN' : False,  #~ Czy ma nadpisywac pliki podczas zapisywania wynikow \n",
    "    'CONST_DUMP'      : True,   # czy ma zrzucac wektory wynikow \n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Rozpoczynam symulacje nr: 0 dla: \n",
      "ilosci wierzcholkow: 10000\n",
      "ilosci polaczen: 160000\n",
      "sredniego stopnia: 32.0\n",
      "ilosci klik: 5494\n",
      "wielkosc klik: 3\n",
      "start_mag: 0.5\n",
      "Magnetyzacja koncowa 140100  :  0.5016\n"
     ]
    }
   ],
   "source": [
    "# podstawowy skrypt do badania wlasnosci\n",
    "#~ Definicje stalych symulacji\n",
    "stg = {\n",
    "    'CONST_CLIQUE'    : 3,      #~ Wielkosc kliki\n",
    "    'CONST_VERTICES'  : 10000,    #~ Ilosc wezlow\n",
    "    'CONST_SIM_COUNT' : 1,      #~ Ilosc powtorzen symulacji\n",
    "    'CONST_SIM_LONG'  : 14,     # ile wielkosci N ma liczyc\n",
    "    'CONST_PATH_BASIC_FOLDER' : 'Wyniki_fazowe',\n",
    "    'CONST_START_MAGNETIZATION' : 0.5\n",
    "}\n",
    "\n",
    "k = 36\n",
    "stg['CONST_EDGES'] = int(round(k * stg['CONST_VERTICES'] // 2, 0)) #~ Ilosc polaczen\n",
    "stg['stopienG']    = round(stg['CONST_EDGES']/stg['CONST_VERTICES']*2, 1)\n",
    "\n",
    "START, STOP, STEP = 0.50, 0.50, 0.01\n",
    "for p in list(np.arange(START,STOP + STEP,STEP)):\n",
    "    stg['CONST_START_MAGNETIZATION'] = p\n",
    "    SimulateClique.jedna_symulacja(stg)\n",
    "\n",
    "print 'Koniec Programu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# with dview.sync_imports():\n",
    "#     import SimulateClique #[1]\n",
    "# from ipyparallel.util import interactive\n",
    "\n",
    "%px %matplotlib inline\n",
    "# import matplotlib\n",
    "# dview.apply_sync(matplotlib.use, 'agg')\n",
    "\n",
    "def ippsim(p):\n",
    "    def simulation(x):\n",
    "        stg = {\n",
    "            'CONST_CLIQUE'    : 3,      #~ Wielkosc kliki\n",
    "            'CONST_VERTICES'  : 10000,    #~ Ilosc wezlow\n",
    "            'CONST_SIM_COUNT' : 2,      #~ Ilosc powtorzen symulacji\n",
    "            'CONST_SIM_LONG'  : 11,     # ile wielkosci N ma liczyc\n",
    "            'CONST_PATH_BASIC_FOLDER' : 'now/Wyniki_fazowe',\n",
    "            'CONST_START_MAGNETIZATION' : 0.5\n",
    "        }\n",
    "\n",
    "        k = 77\n",
    "        stg['CONST_EDGES']  = int(round(k * stg['CONST_VERTICES'] // 2, 0)) #~ Ilosc polaczen\n",
    "        stg['CONST_MEAN_k'] = round(stg['CONST_EDGES']/stg['CONST_VERTICES']*2, 1)    \n",
    "        stg['CONST_START_MAGNETIZATION'] = p\n",
    "\n",
    "        import sys\n",
    "        sys.path.append('/dmj/fizmed/pkowalczyk/now/complex_networks_sim')\n",
    "        import SimulateClique\n",
    "        return SimulateClique.jedna_symulacja(stg)\n",
    "    return simulation\n",
    "\n",
    "START, STOP, STEP = 0.5050, 0.52, 0.0025\n",
    "for p in np.arange(START,STOP + STEP,STEP):\n",
    "    print p\n",
    "    results = dview.map_sync(ippsim(p), range(8))\n",
    "    print results\n",
    "\n",
    "print 'Koniec Programu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import division #~ Domysle dzielenie int jako liczb float\n",
    "import numpy as np        #~ Do np.arange\n",
    "import ipyparallel\n",
    "clients = ipyparallel.Client()\n",
    "# dview = clients.direct_view()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<AsyncMapResult: <lambda>>\n"
     ]
    }
   ],
   "source": [
    "dview = clients.load_balanced_view()\n",
    "results = dview.map(lambda x: int(1), range(20))\n",
    "print results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'ipyparallel.client.asyncresult.AsyncMapResult'>\n",
      "<AsyncHubResult: unknown>\n",
      "<AsyncMapResult: <lambda>:finished>\n"
     ]
    }
   ],
   "source": [
    "print type(results)\n",
    "print clients.get_result()\n",
    "print results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[None, None, None, None, None, None, None, None]\n",
      "Koniec Programu\n"
     ]
    }
   ],
   "source": [
    "# Do \n",
    "%px %matplotlib inline\n",
    "# import matplotlib\n",
    "# dview.apply_sync(matplotlib.use, 'agg')\n",
    "\n",
    "def ippsim(p):\n",
    "    def simulation(x):\n",
    "        stg = {\n",
    "            # 'CONST_CLIQUE'    : 3,      #~ Wielkosc kliki            \n",
    "            'CONST_PRINT'     : False,  #~ Czy drukowac magnetyzacje co CONST_VERTICES krokow?\n",
    "            'CONST_OVERRIDEN' : False,  #~ Czy ma nadpisywac pliki podczas zapisywania wynikow \n",
    "            'CONST_VERTICES'  : 10000,    #~ Ilosc wezlow\n",
    "            'CONST_SIM_COUNT' : 5,      #~ Ilosc powtorzen symulacji\n",
    "            'CONST_SIM_LONG'  : 1000,     # ile wielkosci N ma liczyc            \n",
    "            'CONST_PATH_BASIC_FOLDER' : 'now/Wyniki_lazy_meanK',\n",
    "            'CONST_MODEL'     : 'lazy',             \n",
    "#             'CONST_MODEL'     : 'clique',\n",
    "            'CONST_LAZY_CUT'  : 0.003,\n",
    "            'CONST_MODEL_BASIC_VAL' : 'CONST_MEAN_k'\n",
    "        }\n",
    "\n",
    "        k = x\n",
    "        stg['CONST_EDGES']  = int(round(k * stg['CONST_VERTICES'] // 2, 0)) #~ Ilosc polaczen\n",
    "        stg['CONST_MEAN_k'] = round(stg['CONST_EDGES']/stg['CONST_VERTICES']*2, 1)    \n",
    "#         stg['CONST_START_MAGNETIZATION'] = p\n",
    "        \n",
    "        import sys\n",
    "        sys.path.append('/dmj/fizmed/pkowalczyk/now/complex_networks_sim')\n",
    "        import SimulateClique\n",
    "        result = SimulateClique.jedna_symulacja(stg)        \n",
    "        print 'end', k\n",
    "    return simulation\n",
    "\n",
    "p = None\n",
    "results = dview.map_sync(ippsim(p), np.array(range(8))+70)\n",
    "print results\n",
    "print 'Koniec Programu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None]\n",
      "Koniec Programu\n"
     ]
    }
   ],
   "source": [
    "%px %matplotlib inline\n",
    "# import matplotlib\n",
    "# dview.apply_sync(matplotlib.use, 'agg')\n",
    "\n",
    "def ippsim(p):\n",
    "    def simulation(x):\n",
    "        stg = {\n",
    "            # 'CONST_CLIQUE'    : 3,      #~ Wielkosc kliki            \n",
    "            'CONST_PRINT'     : False,  #~ Czy drukowac magnetyzacje co CONST_VERTICES krokow?\n",
    "            'CONST_OVERRIDEN' : False,  #~ Czy ma nadpisywac pliki podczas zapisywania wynikow \n",
    "            'CONST_VERTICES'  : 10000,    #~ Ilosc wezlow\n",
    "            'CONST_SIM_COUNT' : 1,      #~ Ilosc powtorzen symulacji\n",
    "            'CONST_SIM_LONG'  : 10000,     # ile wielkosci N ma liczyc            \n",
    "            'CONST_PATH_BASIC_FOLDER' : 'now/Wyniki_lazy_fazowe',\n",
    "            'CONST_MODEL'     : 'lazy',             \n",
    "#             'CONST_MODEL'     : 'clique',\n",
    "            'CONST_LAZY_CUT'  : 0.003,\n",
    "            'CONST_MODEL_BASIC_VAL' : 'CONST_START_MAGNETIZATION',\n",
    "            'CONST_START_MAGNETIZATION' : x\n",
    "        }\n",
    "\n",
    "        k = 77\n",
    "        stg['CONST_EDGES']  = int(round(k * stg['CONST_VERTICES'] // 2, 0)) #~ Ilosc polaczen\n",
    "        stg['CONST_MEAN_k'] = round(stg['CONST_EDGES']/stg['CONST_VERTICES']*2, 1)    \n",
    "        \n",
    "        import sys\n",
    "        sys.path.append('/dmj/fizmed/pkowalczyk/now/complex_networks_sim')\n",
    "        import SimulateClique\n",
    "        result = SimulateClique.jedna_symulacja(stg)        \n",
    "        print 'end', k\n",
    "    return simulation\n",
    "\n",
    "p = 77\n",
    "# results = dview.map_sync(ippsim(p), np.arange(0.05,0.76,0.1))\n",
    "results = dview.map(ippsim(p), [0.5]*8+[0.6]*8+[0.4]*8+[0.3]*8+[0.7]*8+[0.8]*8)\n",
    "print list(results)\n",
    "print 'Koniec Programu'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import division #~ Domysle dzielenie int jako liczb float\n",
    "%matplotlib inline\n",
    "\n",
    "import sys\n",
    "import os\n",
    "import json\n",
    "sys.path.append('/dmj/fizmed/pkowalczyk/now/complex_networks_sim')\n",
    "from FilesManagment import CheckFolder\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def plotuj(stg, data):\n",
    "    fig = plt.figure()\n",
    "    plt.plot(data[0],data[1], '--o')\n",
    "    plt.ylim(0,1)\n",
    "    plt.xlim(0,1)\n",
    "    plt.ylabel('Prawdopodobienstwo uzyskanie koncowego stanu sieci *w gore*')\n",
    "    plt.xlabel('Poczatkowa magnetyzacja, N=6000')\n",
    "    fig.suptitle('Zaleznosc koncowej magnetyzacji od sredniego stopnia wiercholkow sieci')\n",
    "    fig.savefig(os.path.join(stg['CONST_STANDARD_PATH_ANALYZE'],'faza_dla_k{}N{}.png'.format(stg['CONST_CLIQUE'],stg['CONST_VERTICES'])), dpi = 200)\n",
    "    fig.clf()\n",
    "\n",
    "def check_folder_k(spin, path_file, basic_dir, stg):\n",
    "    path_k = os.path.join(basic_dir, path_file, 'k{}'.format(spin))\n",
    "    result = 0\n",
    "    if os.path.exists(path_k):\n",
    "        for path_opis in filter(lambda name: name.endswith('.json'), os.listdir(path_k)):\n",
    "            with open(os.path.join(path_k, path_opis), 'r') as f:\n",
    "                dic = json.load(f)\n",
    "            if dic['CONST_VERTICES'] == stg['CONST_VERTICES'] and dic['WYN_meanG'] == stg['WYN_meanG']:\n",
    "                result += 1\n",
    "    return result\n",
    "\n",
    "def analyze(stg):\n",
    "    stg['CONST_STANDARD_PATH_ANALYZE'] = os.path.join(stg['CONST_PATH_BASIC_FOLDER'], 'analyze')\n",
    "    CheckFolder(stg['CONST_STANDARD_PATH_ANALYZE'])\n",
    "    stg['CONST_SHORT_RAW_PATH'] = os.path.join(stg['CONST_PATH_BASIC_FOLDER'], 'RawDataMag', 'klik' + str(stg['CONST_CLIQUE']), 'mag_start')\n",
    "\n",
    "    x, y = [], []\n",
    "    basic_dir = stg['CONST_SHORT_RAW_PATH']\n",
    "    for path_file in sorted(os.listdir(basic_dir)):\n",
    "        down = check_folder_k(0, path_file, basic_dir, stg)\n",
    "        up   = check_folder_k(1, path_file, basic_dir, stg)\n",
    "        if up + down != 0:\n",
    "            x.append(float(path_file))\n",
    "            y.append(up/(up+down))  \n",
    "\n",
    "    wynik = (x,y)\n",
    "    print wynik\n",
    "    if stg['CONST_DUMP']:\n",
    "        with open(os.path.join(stg['CONST_STANDARD_PATH_ANALYZE'], 'raw_1.data') , 'w') as f:\n",
    "            f.writelines(str(wynik))\n",
    "    plotuj(stg, wynik)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, 0.54, 0.55, 0.56], [0.0, 0.0, 0.0, 0.0, 0.1875, 0.625, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f01f80a2750>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "stg = {\n",
    "#         'CONST_CLIQUE'    : 3,      #~ Wielkosc kliki\n",
    "        'CONST_VERTICES'  : 10000,   #~ Ilosc wezlow\n",
    "        'CONST_PATH_BASIC_FOLDER' : 'Wyniki_fazowe',\n",
    "        'CONST_MEAN_k' : 77\n",
    "    }\n",
    "\n",
    "analyze(stg)"
   ]
  }
 ],
 "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}