draft.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from base import Particle\n",
    "from superellipsoid import SuperEllipsoid\n",
    "\n",
    "import sys\n",
    "sys.path.append(r'/mnt/Edisk/andrew/Self_learning_MC')\n",
    "from utils import *\n",
    "from pytorch3d import transforms\n",
    "from scipy import optimize\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[1 3]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.ones(9).reshape(3,3)\n",
    "\n",
    "b = np.zeros(2)\n",
    "a[0][1:3] = b[0:2]\n",
    "\n",
    "c = np.array([1, 2, 3])\n",
    "print(c)\n",
    "\n",
    "print(c[::2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 2\n",
    "b = a\n",
    "a = 3\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.483314773547883"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from packing import Packing\n",
    "\n",
    "packing = Packing()\n",
    "\n",
    "packing.particle_type = 'ellipsoid'\n",
    "packing.num_particles = 2\n",
    "\n",
    "packing.dim = 3\n",
    "packing.particles = [SuperEllipsoid(2., 1., 1., 1.) for i in range(packing.num_particles)]\n",
    "\n",
    "for i, particle in enumerate(packing.particles):\n",
    "    particle.name = 'superellipsoid %d' % i\n",
    "    particle.color = np.array([0.51,0.792,0.992])\n",
    "\n",
    "packing.particles[0].centroid = np.array([0., 0., 0.])\n",
    "packing.particles[1].centroid = np.array([1., 1., 1.])\n",
    "\n",
    "f = f'ellipsoid.xyz'\n",
    "packing.output_xyz(f, repeat=False)\n",
    "\n",
    "from utils import Transform\n",
    "y = Transform().mat2qua(packing.particles[0].rot_mat, \"JPL\")\n",
    "\n",
    "k = np.array([-2, -6, -2])\n",
    "#packing.particles[0].check(k)\n",
    "\n",
    "packing.particles[0].support_func(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from superellipsoid import min_d\n",
    "min_d(packing.particles[0], packing.particles[1])\n",
    "f = f'ellipsoid1.xyz'\n",
    "packing.output_xyz(f, repeat=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from superellipsoid import config_dis, resolve_overlap\n",
    "x0 = np.ones(9)\n",
    "res = optimize.minimize(lambda x: config_dis(x, packing.particles[0], packing.particles[1]), x0, method='SLSQP')\n",
    "res.x\n",
    "resolve_overlap(res.x, packing.particles[0], packing.particles[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: 5.156388491616472e-07\n",
       "     jac: array([-1.06587974e-04,  8.49815928e-05,  8.49814685e-05,  6.31870859e-05,\n",
       "       -4.63998366e-05, -4.63975887e-05,  6.31904453e-05, -4.64006829e-05,\n",
       "       -4.64028065e-05])\n",
       " message: 'Optimization terminated successfully'\n",
       "    nfev: 170\n",
       "     nit: 17\n",
       "    njev: 17\n",
       "  status: 0\n",
       " success: True\n",
       "       x: array([0.85393997, 2.87108649, 2.87108643, 0.59037382, 2.54062736,\n",
       "       2.54062727, 0.59037384, 2.54062738, 2.54062735])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from superellipsoid import config_dis\n",
    "\n",
    "x0 = np.ones(9)*2.\n",
    "optimize.minimize(lambda x: config_dis(x, packing.particles[0], packing.particles[1]), x0, method='SLSQP')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp = v1.T - np.matmul(u.T, packing.particles[0].rot_mat)\n",
    "temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#rot_mat_new = packing.particles[0].rot_mat + np.matmul(u, temp.T) / (np.linalg.norm(u)**2.)\n",
    "col = u.reshape(-1, 1)\n",
    "row = temp.reshape(1, -1)\n",
    "cc = np.matmul(col, row)\n",
    "cc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3., 5., 1.])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gg = np.array([3,2,1])\n",
    "ff = np.diag(np.ones(3))\n",
    "ff[0][1] = 1\n",
    "np.matmul(gg, ff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1],\n",
       "       [1, 1, 1],\n",
       "       [1, 1, 1]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u = np.array([1, 1, 1])\n",
    "v = np.array([1, 1, 1])\n",
    "col = u.reshape(-1, 1)\n",
    "row = v.reshape(1, -1)\n",
    "np.matmul(col, row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.zeros([3, 3])\n",
    "a"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.13 ('pytorch3d')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "5b14629d4c2508e12df5a608d99e923bb6a1a917a20383be71c5649ced98a298"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}