montecalro_gui.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SAVED SETTING\n",
      "calculate ends\n",
      "END\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "import pandas as pd\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "from scipy import interpolate\n",
    "import copy\n",
    "from multiprocessing import Pool\n",
    "import PyMieScatt as ps\n",
    "import tkinter\n",
    "from tkinter import ttk\n",
    "\n",
    "#0:transmission、1:forward scattering 2:sideward scattering 3:backward scattering 4:absorption\n",
    "TRANSMISSION = 0\n",
    "FORWARD_SCATTERING = 1\n",
    "SIDEWARD_SCATTERING = 2\n",
    "SIDEWARD_SCATTERING_X = 2\n",
    "SIDEWARD_SCATTERING_Y = 2\n",
    "BACKWARD_SCATTERING = 3\n",
    "ABSORPTION = 4\n",
    "IN_SYSTEM = 9\n",
    "\n",
    "MAX_PARICLE_TYPES = 3\n",
    "RANDOM_SEED = 1\n",
    "\n",
    "WID =  5\n",
    "\n",
    "ANGLE_ARR_NUMBER = 1801\n",
    "ANGLE_ARR = np.linspace(0,math.pi,ANGLE_ARR_NUMBER)\n",
    "\n",
    "INITIAL_SETTING  = pd.read_csv(\"setting/initial_setting.csv\",index_col = 0)\n",
    "\n",
    "def save_initial_setting():\n",
    "    INITIAL_SETTING[\"NUMBER_OF_TYPES\"] = setting.particle_types.get()\n",
    "    INITIAL_SETTING[\"MIN_WAVE\"] = round_sig(float(setting.min_wave.get()))\n",
    "    INITIAL_SETTING[\"MAX_WAVE\"] = round_sig(float(setting.max_wave.get()))\n",
    "    INITIAL_SETTING[\"INTERVAL_WAVE\"] = round_sig(float(setting.interval_wave.get()))\n",
    "    INITIAL_SETTING[\"NUMBER_OF_INCIDENT_PHOTONS\"] = int(setting.incident_photons.get()) \n",
    "    INITIAL_SETTING[\"BLOCK_X\"] = setting.block_x.get()\n",
    "    INITIAL_SETTING[\"BLOCK_Y\"] = setting.block_y.get()\n",
    "    INITIAL_SETTING[\"BLOCK_Z\"] = setting.block_z.get()\n",
    "    INITIAL_SETTING[\"HOST_REFRACTIVE_INDEX\"] = float(setting.host_refractive_index.get())\n",
    "    INITIAL_SETTING[\"PERIODIC_BOUNDARY_MODE\"] = str(setting.PERIODIC_BOUNDARY_MODE.get())\n",
    "    INITIAL_SETTING[\"LOG_MODE\"] = str(setting.LOG_MODE.get())\n",
    "    for num in range(MAX_PARICLE_TYPES):\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_HAVESHELL\"] = str(particles[num].haveshell.get())\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_CORE_MATERIAL\"] =  material_files.index(particles[num].core_material_combo.get())\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_SHELL_MATERIAL\"] = material_files.index(particles[num].shell_material_combo.get())\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_IMPORT_FILE\"] = custom_files.index(particles[num].import_file_combo.get())\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_CUSTOM_VALUE1\"] = particles[num].custom_value1.get()\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_CUSTOM_VALUE2\"] = particles[num].custom_value2.get()\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_CUSTOM_VALUE3\"] = particles[num].custom_value3.get()\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_CUSTOM_VALUE4\"] = particles[num].custom_value4.get()\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_CONCENTRATION\"] = particles[num].concentration.get()\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_CORE_DIAMETER\"] = particles[num].core_diameter.get()\n",
    "        INITIAL_SETTING[\"NO\"+str(num+1)+\"_SHELL_THICKNESS\"]  = particles[num].shell_thickness.get()\n",
    "    INITIAL_SETTING.to_csv(\"setting/initial_setting.csv\")\n",
    "    print(\"SAVED SETTING\")\n",
    "    \n",
    "def round_sig(x, sig=5):\n",
    "    if(x==0):\n",
    "        return 0\n",
    "    return round(x, sig-int(math.floor(math.log10(abs(x))))-1)\n",
    "\n",
    "class Setting(tkinter.Frame):\n",
    "    start_row = None   \n",
    "    num = None\n",
    "    #define UI\n",
    "    def __init__(self, master=None):\n",
    "        super().__init__(master)\n",
    "        \n",
    "    def particle_types(self):\n",
    "        first_label = tkinter.Label(text=\"##################################Particle Information##################################\")\n",
    "        first_label.grid(row=self.start_row, column=0,columnspan = 5, padx=5,)\n",
    "        labeler(self.start_row+1,0,1,\"  \")\n",
    "        particle_types_label = tkinter.Label(text=\"number of types of particles\")\n",
    "        particle_types_label.grid(row=self.start_row+2, column=1, padx=10,)\n",
    "        self.particle_types = tkinter.Entry(width=WID)\n",
    "        self.particle_types.insert(tkinter.END,INITIAL_SETTING[\"NUMBER_OF_TYPES\"].values[0])\n",
    "        self.particle_types.grid(row=self.start_row+2, column=2)\n",
    "\n",
    "    def simulation(self):\n",
    "        second_label = tkinter.Label(text=\"##################################Simulation Settings##################################\")\n",
    "        second_label.grid(row=self.start_row, column=0,columnspan = 5, padx=5,pady = 10)\n",
    "\n",
    "        #wavelength\n",
    "        min_wave_label = tkinter.Label(text=\"min wave (nm)\").grid(row=self.start_row+1, column=1, padx=5,)\n",
    "        self.min_wave = tkinter.Entry(width=WID)\n",
    "        self.min_wave.insert(tkinter.END,INITIAL_SETTING[\"MIN_WAVE\"].values[0])\n",
    "        self.min_wave.grid(row=self.start_row+1, column=2)\n",
    "\n",
    "        max_wave_label = tkinter.Label(text=\"max wave (nm)\").grid(row=self.start_row+1, column=3, padx=5,)\n",
    "        self.max_wave = tkinter.Entry(width=WID)\n",
    "        self.max_wave.insert(tkinter.END,INITIAL_SETTING[\"MAX_WAVE\"].values[0])\n",
    "        self.max_wave.grid(row=self.start_row+1, column=4)\n",
    "\n",
    "        interval_wave_label = tkinter.Label(text=\"interval wave (nm)\").grid(row=self.start_row+1, column=5, padx=5,)\n",
    "        self.interval_wave = tkinter.Entry(width=WID)\n",
    "        self.interval_wave.insert(tkinter.END,INITIAL_SETTING[\"INTERVAL_WAVE\"].values[0])\n",
    "        self.interval_wave.grid(row=self.start_row+1, column=6)\n",
    "\n",
    "        #number of incident photons\n",
    "        incident_photons_label = tkinter.Label(text=\"number of incident photons\")\n",
    "        incident_photons_label.grid(row=self.start_row+2, column=1, padx=10,)\n",
    "        self.incident_photons = tkinter.Entry(width=WID)\n",
    "        self.incident_photons.insert(tkinter.END,INITIAL_SETTING[\"NUMBER_OF_INCIDENT_PHOTONS\"].values[0])\n",
    "        self.incident_photons.grid(row=self.start_row+2, column=2)\n",
    "\n",
    "        #system\n",
    "        block_x_label = tkinter.Label(text=\"x (um)\").grid(row=self.start_row+3, column=1, padx=10,)\n",
    "        self.block_x = tkinter.Entry(width=WID)\n",
    "        self.block_x.insert(tkinter.END,INITIAL_SETTING[\"BLOCK_X\"].values[0])\n",
    "        self.block_x.grid(row=self.start_row+3, column=2)\n",
    "\n",
    "        block_y_label = tkinter.Label(text=\"y (um)\").grid(row=self.start_row+3, column=3, padx=10,)\n",
    "        self.block_y = tkinter.Entry(width=WID)\n",
    "        self.block_y.grid(row=self.start_row+3, column=4)\n",
    "        self.block_y.insert(tkinter.END,INITIAL_SETTING[\"BLOCK_Y\"].values[0])\n",
    "\n",
    "        block_z_label = tkinter.Label(text=\"z (um)\").grid(row=self.start_row+3, column=5, padx=10,)\n",
    "        self.block_z = tkinter.Entry(width=WID)\n",
    "        self.block_z.grid(row=self.start_row+3, column=6)\n",
    "        self.block_z.insert(tkinter.END,INITIAL_SETTING[\"BLOCK_Z\"].values[0])\n",
    "\n",
    "        #host refractive index\n",
    "        host_refractive_index_label = tkinter.Label(text=\"host refractive index\")\n",
    "        host_refractive_index_label.grid(row=self.start_row+4, column=1, padx=10,)\n",
    "        self.host_refractive_index = tkinter.Entry(width=WID)\n",
    "        self.host_refractive_index.insert(tkinter.END,INITIAL_SETTING[\"HOST_REFRACTIVE_INDEX\"].values[0])\n",
    "        self.host_refractive_index.grid(row=self.start_row+4, column=2)\n",
    "\n",
    "        #PERIODIC_BOUNDARY\n",
    "        self.PERIODIC_BOUNDARY_label = tkinter.Label(text=\"PERIODIC BOUNDARY MODE\").grid(row=self.start_row+5, column=0,columnspan = 3, padx=5,)\n",
    "        self.PERIODIC_BOUNDARY_MODE = tkinter.BooleanVar()\n",
    "        self.PERIODIC_BOUNDARY_MODE.set(bool(INITIAL_SETTING[\"PERIODIC_BOUNDARY_MODE\"].values[0]))\n",
    "        self.PERIODIC_BOUNDARY_MODE_button = tkinter.Checkbutton(text=u\"\", variable=self.PERIODIC_BOUNDARY_MODE)\n",
    "        self.PERIODIC_BOUNDARY_MODE_button.grid(row=self.start_row+5, column=3)\n",
    "\n",
    "        #LOG_MODE\n",
    "        LOG_MODE_label = tkinter.Label(text=\"OUTPUT LOG FILE\").grid(row=self.start_row+6, column=0, padx=5,columnspan = 3)\n",
    "        self.LOG_MODE = tkinter.BooleanVar()\n",
    "        self.LOG_MODE.set(bool(INITIAL_SETTING[\"LOG_MODE\"].values[0]))\n",
    "        self.LOG_MODE_button = tkinter.Checkbutton(text=u\"\", variable=self.LOG_MODE)\n",
    "        self.LOG_MODE_button.grid(row=self.start_row+6, column=3)\n",
    "\n",
    "        none_label2 = tkinter.Label(text=\"\").grid(row=self.start_row+7, column=0,columnspan = 5, padx=5,pady = 10)\n",
    "\n",
    "        third_label = tkinter.Label(text=\"##################################Output Files##################################\")\n",
    "        third_label.grid(row=self.start_row+8, column=0,columnspan = 5, padx=5,pady = 10)\n",
    "\n",
    "        #Start and Stop\n",
    "        self.start_button = tkinter.Button(text=\"Start\",command = start)\n",
    "        self.start_button.grid(row=self.start_row+9, column=1)\n",
    "        self.end_button = tkinter.Button(text = \"Quit\", command = quit)\n",
    "        self.end_button.grid(row=self.start_row+9, column=4)\n",
    "\n",
    "\n",
    "class ParticleInfo(tkinter.Frame):\n",
    "    start_row = None   \n",
    "    num = None\n",
    "    #defineUI\n",
    "    def __init__(self, master=None):\n",
    "        super().__init__(master)\n",
    "        \n",
    "    #Define widgets\n",
    "    def define_widget(self):\n",
    "        self.haveshell = tkinter.BooleanVar()\n",
    "        self.haveshell.set(bool(INITIAL_SETTING[\"NO\"+str(self.num)+\"_HAVESHELL\"].values[0]))\n",
    "        \n",
    "        self.core_only_radio  = tkinter.Radiobutton(root,text='Core-Only ',variable=self.haveshell, value=False,command = self.delete_core_shell_label)\n",
    "        self.core_shell_radio = tkinter.Radiobutton(root,text='Core-Shell',variable=self.haveshell, value=True ,command = self.core_shell_label)\n",
    "        \n",
    "        self.core_material_combo = ttk.Combobox(root, values = material_files)\n",
    "        self.core_material_combo.current(INITIAL_SETTING[\"NO\"+str(self.num)+\"_CORE_MATERIAL\"].values[0])\n",
    "        self.core_material_combo.bind(\"<<ComboboxSelected>>\", self.core_material_callbackfunc)\n",
    "        \n",
    "        self.shell_material_combo = ttk.Combobox(root, values = material_files[0:-2])\n",
    "        self.shell_material_combo.current(INITIAL_SETTING[\"NO\"+str(self.num)+\"_SHELL_MATERIAL\"].values[0])\n",
    "        self.shell_material_combo.bind(\"<<ComboboxSelected>>\", self.shell_material_callbackfunc)\n",
    "        \n",
    "        self.custom_value1 = tkinter.Entry(width=WID)\n",
    "        self.custom_value1.insert(tkinter.END,INITIAL_SETTING[\"NO\"+str(self.num)+\"_CUSTOM_VALUE1\"].values[0])\n",
    "        self.custom_value2 = tkinter.Entry(width=WID)\n",
    "        self.custom_value2.insert(tkinter.END,INITIAL_SETTING[\"NO\"+str(self.num)+\"_CUSTOM_VALUE2\"].values[0])\n",
    "        self.custom_value3 = tkinter.Entry(width=WID)\n",
    "        self.custom_value3.insert(tkinter.END,INITIAL_SETTING[\"NO\"+str(self.num)+\"_CUSTOM_VALUE3\"].values[0])\n",
    "        self.custom_value4 = tkinter.Entry(width=WID)\n",
    "        self.custom_value4.insert(tkinter.END,INITIAL_SETTING[\"NO\"+str(self.num)+\"_CUSTOM_VALUE4\"].values[0])\n",
    "        \n",
    "        self.import_file_combo = ttk.Combobox(root, values = custom_files,width=20)\n",
    "        self.import_file_combo.current(INITIAL_SETTING[\"NO\"+str(self.num)+\"_IMPORT_FILE\"].values[0])\n",
    "        \n",
    "        self.concentration   = tkinter.Entry(width=WID)\n",
    "        self.concentration.insert(tkinter.END,INITIAL_SETTING[\"NO\"+str(self.num)+\"_CONCENTRATION\"].values[0])\n",
    "        self.core_diameter   = tkinter.Entry(width=WID)\n",
    "        self.core_diameter.insert(tkinter.END,INITIAL_SETTING[\"NO\"+str(self.num)+\"_CORE_DIAMETER\"].values[0])\n",
    "        self.shell_thickness = tkinter.Entry(width=WID)\n",
    "        self.shell_thickness.insert(tkinter.END,INITIAL_SETTING[\"NO\"+str(self.num)+\"_SHELL_THICKNESS\"].values[0])\n",
    "        \n",
    "        self.conversion_button = tkinter.Button(text=\"Conversion\",command = self.conversion)\n",
    "        \n",
    "        self.min_free_path      = tkinter.Entry(width=WID)\n",
    "        self.min_free_path_wave = tkinter.Entry(width=WID)\n",
    "        \n",
    "    #Place widgets\n",
    "    def place_widget(self):\n",
    "        labeler(self.start_row,1,1,\" Particle No\"+str(self.num)+\" ##\")\n",
    "        labeler(self.start_row+1,3,1,\"material\")\n",
    "        labeler(self.start_row+1,5,1,\"           \")\n",
    "        labeler(self.start_row+1,6,1,\"           \")\n",
    "        \n",
    "        self.core_only_radio.grid(row=self.start_row+2,column=1)\n",
    "        labeler(self.start_row+2,2,1,\"Core\")\n",
    "        self.core_material_combo.grid(row=self.start_row+2,column=3)\n",
    "        labeler(self.start_row+2,7,1,\"diameter (nm)\")\n",
    "        self.core_diameter.grid(row=self.start_row+2, column=8)\n",
    "        self.core_shell_radio.grid(row=self.start_row+3,column=1)\n",
    "        labeler(self.start_row+4,2,1,\"concentration (*10^9 num/mL)\")\n",
    "        self.concentration.grid(row=self.start_row+4, column=3)\n",
    "        self.conversion_button.grid(row=self.start_row+4, column=4)\n",
    "        labeler(self.start_row+4,5,2,\"min mean free path (mm)\")\n",
    "        self.min_free_path.grid(row=self.start_row+4, column=7)\n",
    "        labeler(self.start_row+4,8,1,\"at wavelength (nm)\")\n",
    "        self.min_free_path_wave.grid(row=self.start_row+4, column=9)\n",
    "\n",
    "    #Check all inputs for conversion from min_free_path to concentration\n",
    "    def check_input(self):       \n",
    "        flag = True\n",
    "        if((self.min_free_path.get() == \"\") or(self.min_free_path.get() == 0)):\n",
    "            flag = False\n",
    "        if(self.core_diameter.get() == \"\"):\n",
    "            flag = False\n",
    "        #Core-only\n",
    "        if(self.haveshell.get() == False):\n",
    "            if(self.core_material_combo.get() == \"Absorber - Constant Qabs\"):\n",
    "                if(self.custom_value1.get() == \"\"):\n",
    "                    flag = False\n",
    "            elif(self.core_material_combo.get() == \"Absorber - Custom Qabs\"):\n",
    "                if(self.import_file_combo.get() == \"\"):\n",
    "                    flag = False\n",
    "            elif(self.core_material_combo.get() == \"Constant\"):\n",
    "                if(self.custom_value1.get() == \"\" or self.custom_value2.get() == \"\"):\n",
    "                    flag = False\n",
    "        #Core-shell\n",
    "        elif(self.haveshell.get() == True):\n",
    "            if(self.shell_thickness.get() == \"\"):\n",
    "                flag = False\n",
    "            if(self.core_material_combo.get() == \"Constant\"):\n",
    "                if(self.custom_value1.get() == \"\" or self.custom_value2.get() == \"\"):\n",
    "                    flag = False\n",
    "            if(self.shell_material_combo.get() == \"Constant\"):\n",
    "                if(self.custom_value3.get() == \"\" or self.custom_value4.get() == \"\"):\n",
    "                    flag = False\n",
    "        return flag\n",
    "        \n",
    "    def core_material_callbackfunc(self,event):\n",
    "        val = self.core_material_combo.get()\n",
    "        #Core\n",
    "        if(val == \"Constant\"):\n",
    "            labeler(self.start_row+1,4,1,\"     n     \")\n",
    "            labeler(self.start_row+1,5,1,\"     k     \")\n",
    "            self.custom_value1.grid(row=self.start_row+2, column=4)\n",
    "            self.custom_value2.grid(row=self.start_row+2, column=5)\n",
    "            self.import_file_combo.grid_forget()\n",
    "            \n",
    "        elif(val ==  \"Absorber - Constant Qabs\"):\n",
    "            labeler(self.start_row+1,4,1,\"    Qabs   \")\n",
    "            labeler(self.start_row+1,5,1,\"           \")\n",
    "            self.custom_value1.grid(row=self.start_row+2, column=4)\n",
    "            self.custom_value2.grid_forget()\n",
    "            self.import_file_combo.grid_forget()\n",
    "            self.haveshell.set(0)\n",
    "            self.delete_core_shell_label()\n",
    "\n",
    "        elif(val == \"Absorber - Custom Qabs\"):\n",
    "            labeler(self.start_row+1,4,1,\" import \")\n",
    "            labeler(self.start_row+1,5,1,\"             \")\n",
    "            self.custom_value1.grid_forget()\n",
    "            self.custom_value2.grid_forget()\n",
    "            self.import_file_combo.grid(row=self.start_row+2,column=4,columnspan=3)\n",
    "            self.haveshell.set(0)\n",
    "            self.delete_core_shell_label()\n",
    "\n",
    "        else:#import refractive index file\n",
    "            if(self.shell_material_combo.get() != \"Constant\"):\n",
    "                labeler(self.start_row+1,4,1,\"            \")\n",
    "                labeler(self.start_row+1,5,1,\"            \")\n",
    "            self.custom_value1.grid_forget()\n",
    "            self.custom_value2.grid_forget()\n",
    "            self.import_file_combo.grid_forget()\n",
    "\n",
    "    def shell_material_callbackfunc(self,event):\n",
    "        val = self.shell_material_combo.get()\n",
    "        \n",
    "        if(val == \"Constant\"):\n",
    "            labeler(self.start_row+1,4,1,\"     n     \")\n",
    "            labeler(self.start_row+1,5,1,\"     k     \")\n",
    "            self.custom_value3.grid(row=self.start_row+3, column=4)\n",
    "            self.custom_value4.grid(row=self.start_row+3, column=5)\n",
    "            \n",
    "        else:\n",
    "            if(self.core_material_combo.get() != \"Constant\"):\n",
    "                labeler(self.start_row+1,4,1,\"            \")\n",
    "                labeler(self.start_row+1,5,1,\"            \")\n",
    "            self.custom_value3.grid_forget()\n",
    "            self.custom_value4.grid_forget()\n",
    "\n",
    "    def core_shell_label(self):\n",
    "        if((self.core_material_combo.get() ==  \"Absorber - Constant Qabs\") or (self.core_material_combo.get() == \"Absorber - Custom Qabs\")):\n",
    "            self.haveshell.set(0)\n",
    "        else:\n",
    "            labeler(self.start_row+3,2,1,\"Shell\")\n",
    "            self.shell_material_combo.grid(row=self.start_row+3,column=3)\n",
    "            self.shell_thickness.grid(row=self.start_row+3, column=8)\n",
    "            labeler(self.start_row+3,7,1,\"thickness (nm)\")\n",
    "\n",
    "    def delete_core_shell_label(self):\n",
    "        labeler(self.start_row+3,2,1,\"            \")\n",
    "        labeler(self.start_row+3,7,1,\"                                     \")\n",
    "        self.shell_material_combo.grid_forget()\n",
    "        self.shell_thickness.grid_forget()\n",
    "        self.custom_value3.grid_forget()\n",
    "        self.custom_value4.grid_forget()\n",
    "    \n",
    "    def conversion(self):\n",
    "        min_wave = round_sig(float(setting.min_wave.get()))\n",
    "        max_wave = round_sig(float(setting.max_wave.get()))\n",
    "        interval = round_sig(float(setting.interval_wave.get()))\n",
    "        if(self.check_input()):\n",
    "            all_eff = all_eff_dataframe(self)\n",
    "            max_extinction_cross = 0\n",
    "            max_wavelength = 0\n",
    "            for wave in np.arange(min_wave,max_wave+interval,interval):\n",
    "                extinction_eff = all_eff[\"Qext\"][wave] \n",
    "                extinction_cross = float(self.core_diameter.get()) **2 * math.pi / 4 * extinction_eff\n",
    "                if(extinction_cross > max_extinction_cross):\n",
    "                    max_extinction_cross  = extinction_cross\n",
    "                    max_wavelength = wave\n",
    "            self.min_free_path_wave.delete(0, tkinter.END)\n",
    "            self.min_free_path_wave.insert(tkinter.END,max_wavelength)\n",
    "            self.concentration.delete(0, tkinter.END)\n",
    "            self.concentration.insert(tkinter.END,round_sig(1 / float(self.min_free_path.get()) / max_extinction_cross * 1000000))\n",
    "    \n",
    "    def namer(self):\n",
    "         #Core-only\n",
    "        if(self.haveshell.get() == False):\n",
    "            if(self.core_material_combo.get() == \"Absorber - Constant Qabs\"):\n",
    "                return \"Qabs=\"+self.custom_value1.get()\n",
    "            elif(self.core_material_combo.get() == \"Absorber - Custom Qabs\"):\n",
    "                return self.import_file_combo.get()[0:-4]\n",
    "            elif(self.core_material_combo.get() == \"Constant\"):\n",
    "                return self.custom_value1.get() +\"+i\" + self.custom_value2.get()\n",
    "            else:\n",
    "                return self.core_material_combo.get()[0:-4]\n",
    "            \n",
    "        #Core-shell\n",
    "        elif(self.haveshell.get() == True):\n",
    "            if(self.core_material_combo.get() == \"Constant\"):\n",
    "                core_name = self.custom_value1.get() +\"+i\" + self.custom_value2.get()\n",
    "            else:\n",
    "                core_name = self.core_material_combo.get()[0:-4]\n",
    "            if(self.shell_material_combo.get() == \"Constant\"):\n",
    "                shell_name = self.custom_value3.get() +\"+i\" + self.custom_value4.get()\n",
    "            else:\n",
    "                shell_name = self.shell_material_combo.get()[0:-4]\n",
    "            return core_name +\"@\"+shell_name\n",
    "\n",
    "#simple label\n",
    "def labeler(r,c,span,label):\n",
    "    labe = tkinter.Label(text=label)\n",
    "    labe.grid(row=r, column=c,columnspan = span, padx=5)\n",
    "    \n",
    "#return[Qsca,Qabs,Qeff]\n",
    "def all_eff_dataframe(particle):\n",
    "    Qeff = []\n",
    "    waves = []\n",
    "    min_wave = round_sig(float(setting.min_wave.get()))\n",
    "    max_wave = round_sig(float(setting.max_wave.get()))\n",
    "    interval = round_sig(float(setting.interval_wave.get()))\n",
    "    nmedium = float(setting.host_refractive_index.get())\n",
    "    for wave in np.arange(min_wave,max_wave+interval,interval):\n",
    "        waves.append(wave)\n",
    "    #Core-only\n",
    "    if(particle.haveshell.get() == False):\n",
    "        if(particle.core_material_combo.get() == \"Absorber - Constant Qabs\"):\n",
    "            for wave in np.arange(min_wave,max_wave+interval,interval):\n",
    "                Qeff.append([0,float(custom_value1_rec2.get()),float(custom_value1_rec2.get())])\n",
    "\n",
    "        elif(particle.core_material_combo.get() == \"Absorber - Custom Qabs\"):\n",
    "            Qabs = spline_custom(min_wave,max_wave,\"custom/\" + particle.import_file_combo.get(),2)\n",
    "            for wave in np.arange(min_wave,max_wave+interval,interval):\n",
    "                Qeff.append([0,Qabs[\"Qabs\"][wave],Qabs[\"Qabs\"][wave]])\n",
    "                \n",
    "        elif(particle.core_material_combo.get() == \"Constant\"):\n",
    "            ref =  complex(float(particle.custom_value1.get()),float(particle.custom_value2.get()))\n",
    "            res = ps.MieQ(ref,100,float(particle.core_diameter.get()),asDict=True,nMedium = nmedium)\n",
    "            for wave in np.arange(min_wave,max_wave+interval,interval):\n",
    "                Qeff.append([res[\"Qsca\"],res[\"Qabs\"],res[\"Qext\"]])\n",
    "            \n",
    "        else:\n",
    "            ref_df = spline(min_wave,max_wave,\"material/\" +particle.core_material_combo.get(),2)\n",
    "            for wave in np.arange(min_wave,max_wave+interval,interval):\n",
    "                ref  = complex(ref_df[\"n\"][wave],ref_df[\"k\"][wave])\n",
    "                res = ps.MieQ(ref,wave,float(particle.core_diameter.get()),asDict=True,nMedium = nmedium)\n",
    "                Qeff.append([res[\"Qsca\"],res[\"Qabs\"],res[\"Qext\"]])\n",
    "                \n",
    "    #Core-shell\n",
    "    elif(particle.haveshell.get() == True):\n",
    "        if(particle.core_material_combo.get() != \"Constant\"):\n",
    "            ref_core_df  = spline(min_wave,max_wave,\"material/\" + particle.core_material_combo.get(),2)\n",
    "        if(particle.shell_material_combo.get() != \"Constant\"):\n",
    "            ref_shell_df = spline(min_wave,max_wave,\"material/\" + particle.shell_material_combo.get(),2)\n",
    "            \n",
    "        for wave in np.arange(min_wave,max_wave+interval,interval):\n",
    "            if(particle.core_material_combo.get() == \"Constant\"):\n",
    "                ref_core = complex(float(particle.custom_value1.get()),float(particle.custom_value2.get()))\n",
    "            else:\n",
    "                ref_core = complex(ref_core_df[\"n\"][wave],ref_core_df[\"k\"][wave])\n",
    "                \n",
    "            if(particle.shell_material_combo.get() == \"Constant\"):\n",
    "                ref_shell = complex(float(particle.custom_value3.get()),float(particle.custom_value4.get()))\n",
    "            else:\n",
    "                ref_shell = complex(ref_shell_df[\"n\"][wave],ref_shell_df[\"k\"][wave])\n",
    "            outer_diameter = float(particle.shell_thickness.get()) * 2 + float(particle.core_diameter.get())\n",
    "            res = ps.MieQCoreShell(ref_core / nmedium, ref_shell / nmedium, wave / nmedium, float(particle.core_diameter.get()),outer_diameter,asDict=True)\n",
    "            if(type(res) == tuple):\n",
    "                Qeff.append([res[1],res[2],res[0]])\n",
    "            else:\n",
    "                Qeff.append([res[\"Qsca\"],res[\"Qabs\"],res[\"Qext\"]])\n",
    "            \n",
    "    return pd.DataFrame(np.array(Qeff),index = waves,columns = [\"Qsca\",\"Qabs\",\"Qext\"])\n",
    "\n",
    "#np.array(angle_dependency) size = ANGLE_ARR_NUMBER\n",
    "def angle_dataframe(particle,wavelength):\n",
    "    min_wave = round_sig(float(setting.min_wave.get()))\n",
    "    max_wave = round_sig(float(setting.max_wave.get()))\n",
    "    interval = round_sig(float(setting.interval_wave.get()))\n",
    "    #Core-only\n",
    "    if(particle.haveshell.get() == False):\n",
    "        if(particle.core_material_combo.get() == \"Absorber - Constant Qabs\"):\n",
    "            return np.array([0 for i in range(ANGLE_ARR_NUMBER)])\n",
    "\n",
    "        elif(particle.core_material_combo.get() == \"Absorber - Custom Qabs\"):\n",
    "            return np.array([0 for i in range(ANGLE_ARR_NUMBER)])\n",
    "                \n",
    "        elif(particle.core_material_combo.get() == \"Constant\"):\n",
    "            ref =  complex(float(particle.custom_value1.get()),float(particle.custom_value2.get()))\n",
    "            return ps.ScatteringFunction(ref,wavelength,float(particle.core_diameter.get()),angularResolution = 0.1,nMedium = float(setting.host_refractive_index.get()))[3]\n",
    "        else:\n",
    "            ref_df = spline(round_sig(float(setting.min_wave.get())),round_sig(float(setting.max_wave.get())),\"material/\" + particle.core_material_combo.get() ,2)\n",
    "            ref  = complex(ref_df[\"n\"][wavelength],ref_df[\"k\"][wavelength])\n",
    "            return ps.ScatteringFunction(ref,wavelength,float(particle.core_diameter.get()),angularResolution = 0.1,nMedium = float(setting.host_refractive_index.get()))[3]\n",
    "                \n",
    "    #Core-shell\n",
    "    elif(particle.haveshell.get() == True):\n",
    "        if(particle.core_material_combo.get() != \"Constant\"):\n",
    "            ref_core_df  = spline(round_sig(float(setting.min_wave.get())),round_sig(float(setting.max_wave.get())),\"material/\" + particle.core_material_combo.get() ,2)\n",
    "        if(particle.shell_material_combo.get() != \"Constant\"):\n",
    "            ref_shell_df = spline(round_sig(float(setting.min_wave.get())),round_sig(float(setting.max_wave.get())),\"material/\" + particle.shell_material_combo.get(),2)\n",
    "            \n",
    "        if(particle.core_material_combo.get() == \"Constant\"):\n",
    "            ref_core = complex(float(particle.custom_value1.get()),float(particle.custom_value2.get()))\n",
    "        else:\n",
    "            ref_core = complex(ref_core_df[\"n\"][wavelength],ref_core_df[\"k\"][wavelength])\n",
    "\n",
    "        if(particle.shell_material_combo.get() == \"Constant\"):\n",
    "            ref_shell = complex(float(particle.custom_value3.get()),float(particle.custom_value4.get()))\n",
    "        else:\n",
    "            ref_shell = complex(ref_shell_df[\"n\"][wavelength],ref_shell_df[\"k\"][wavelength])\n",
    "        outer_diameter = float(particle.shell_thickness.get()) * 2 + float(particle.core_diameter.get())\n",
    "        return ps.CoreShellScatteringFunction(ref_core,ref_shell,wavelength,float(particle.core_dimaeter.get()),outer_diameter,angularResolution=0.1)[3]\n",
    "                \n",
    "#return material and custom files arr\n",
    "def get_files():\n",
    "    all_material_files = os.listdir(\"material\")\n",
    "    material_files = []\n",
    "    for i in range(len(all_material_files)):\n",
    "        if(\".csv\" in all_material_files[i] or \".txt\" in all_material_files[i]):\n",
    "             material_files.append(all_material_files[i])\n",
    "                \n",
    "    all_custom_files = os.listdir(\"custom\")\n",
    "    custom_files = []\n",
    "    for i in range(len(all_custom_files)):\n",
    "        if(\".csv\" in all_custom_files[i] or \".txt\" in all_custom_files[i]):\n",
    "             custom_files.append(all_custom_files[i])\n",
    "                \n",
    "    material_files.append(\"Constant\")\n",
    "    material_files.append(\"Absorber - Constant Qabs\")\n",
    "    material_files.append(\"Absorber - Custom Qabs\")\n",
    "    \n",
    "    return [material_files,custom_files]\n",
    "\n",
    "#interpolate import file\n",
    "def spline(min_wave,max_wave,file,columns):\n",
    "    interval = round_sig(float(setting.interval_wave.get()))\n",
    "    lbd0 = np.arange(round_sig(float(setting.min_wave.get())),round_sig(float(setting.max_wave.get()))+interval,interval)\n",
    "    if(file[-1] == \"t\"):\n",
    "        deli='\\t'\n",
    "    if(file[-1] == \"v\"):\n",
    "        deli=','   \n",
    "    rawdata = np.loadtxt(file,delimiter=deli, comments='%',skiprows=1)  # delimiter='\\t' may not be needed\n",
    "    values = []\n",
    "    for i in range(1,columns+1):\n",
    "        interp = interpolate.interp1d(rawdata[:,0],rawdata[:,i],kind=\"cubic\")\n",
    "        values.append(interp(lbd0))\n",
    "    \n",
    "    if(columns == 1):\n",
    "        return pd.DataFrame(np.array(values).T,index = lbd0,columns = [\"Qabs\"])\n",
    "    elif(columns == 2):\n",
    "        return pd.DataFrame(np.array(values).T,index = lbd0,columns = [\"n\",\"k\"])\n",
    "    else:\n",
    "        print(\"imported file has too much columns\")\n",
    "        \n",
    "#r=1\n",
    "def spherical2cartesian(position):\n",
    "    newPosition = [0,0,0]\n",
    "    newPosition[0] = np.sin(position[0]) * np.cos(position[1])\n",
    "    newPosition[1] = np.sin(position[0]) * np.sin(position[1])\n",
    "    newPosition[2] = np.cos(position[0])\n",
    "    return newPosition\n",
    "\n",
    "#r=1\n",
    "def cartesian2spherical(position):\n",
    "    newPosition = np.empty([2], dtype=np.float64)\n",
    "    newPosition[0] = np.arccos(position[2])\n",
    "    newPosition[1] = np.arctan2(position[1], position[0])\n",
    "    nan_index = np.isnan(newPosition[0])\n",
    "    newPosition[nan_index,1] = 0\n",
    "    return [newPosition[0],newPosition[1]]\n",
    "\n",
    "#x_rotation_matrix\n",
    "def rotate_x(radian):\n",
    "    return np.matrix([[1,0,0],[0,np.cos(radian),-1*np.sin(radian)],[0,np.sin(radian),np.cos(radian)]])\n",
    "#y_rotation_matrix\n",
    "def rotate_y(radian):\n",
    "    return np.matrix([[np.cos(radian),0,np.sin(radian)],[0,1,0],[-1*np.sin(radian),0,np.cos(radian)]])\n",
    "#z_rotation_matrix\n",
    "def rotate_z(radian):\n",
    "    return np.matrix([[np.cos(radian),-1*np.sin(radian),0],[np.sin(radian),np.cos(radian),0],[0,0,1]])\n",
    "\n",
    "#rotation matrix from inpur vector to [0,0,1]\n",
    "def rotate2z_matrix(vector):\n",
    "    a = vector / np.linalg.norm(vector)\n",
    "    b = np.array([a[0],0,a[2]])\n",
    "    c = b / np.linalg.norm(b)\n",
    "    d = np.array(np.dot(rotate_y(-1*np.sign(c[0])*math.acos(c[2])),a))[0]\n",
    "    if(d[2] > 1):\n",
    "        d[2] = 1\n",
    "    if(d[2] < -1):\n",
    "        d[2] = -1\n",
    "    e = np.array(np.dot(rotate_x(np.sign(d[1])*np.sign(d[2])*math.acos(d[2])),d))[0]\n",
    "    return np.dot(rotate_x(np.sign(d[1])*np.sign(d[2])*math.acos(d[2]))    ,   rotate_y(-1*np.sign(c[0])*math.acos(c[2])) )\n",
    "\n",
    "#incident photons position\n",
    "def incident_posi():\n",
    "    flux = np.empty((0,3), int)\n",
    "    for i in np.linspace(-1* setting.block_xy/2,setting.block_xy/2, 1000):\n",
    "        for j in np.linspace(-1*setting.block_xy/2, setting.block_xy/2, 1000):\n",
    "            flux = np.append(flux,np.array([[i,j, -1 * float(setting.block_z.get())*1000/2]]),axis = 0)\n",
    "    return flux\n",
    "\n",
    "#incident photons position\n",
    "def incident_posi2():\n",
    "    flux = np.empty((0,3), int)\n",
    "    for i in np.linspace(-1*float(setting.block_x.get())*1000/2,float(setting.block_x.get())*1000/2,100):\n",
    "        for j in np.linspace(-1*float(setting.block_y.get())*1000/2, float(setting.block_y.get())*1000/2, 250 ):\n",
    "            flux = np.append(flux,np.array([[i,j, -1 * float(setting.block_z.get())*1000/2]]),axis = 0)\n",
    "    return flux\n",
    "\n",
    "#create randam vector scattering isotropic\n",
    "def scattering_isotropic():\n",
    "    scattering=np.array([np.random.rand()-0.5,np.random.rand()-0.5,np.random.rand()-0.5])\n",
    "    return  np.array([scattering / np.linalg.norm(scattering)])\n",
    "    \n",
    "#place after appling periodic boundary condition\n",
    "def periodic_boudary(place):\n",
    "    block_half_x,block_half_y = float(setting.block_x.get())*1000/2,float(setting.block_y.get())*1000/2\n",
    "    while(True):\n",
    "        if(place[0] < -1* block_half_x):\n",
    "            place[0] = place[0] + 2 * block_half_x\n",
    "        if(place[0] >   block_half_x):\n",
    "            place[0] = place[0] - 2 * block_half_x\n",
    "        \n",
    "        if(place[1] < -1* block_half_y):\n",
    "            place[1] = place[1] + 2 * block_half_y\n",
    "            \n",
    "        if(place[1] >  block_half_y):\n",
    "            place[1] = place[1] - 2 * block_half_y\n",
    "            \n",
    "        if((place[0]>=-1*block_half_x)and(place[0]<=block_half_x)and(place[1] >= -1 * block_half_y)and(place[1] <= block_half_y)):\n",
    "            return place\n",
    "\n",
    "#return photon's place(PERIODIC BOUNDARY MODE)\n",
    "def escape_judge_periodic(place):\n",
    "    place = periodic_boudary(place)\n",
    "    if(place[2] > float(setting.block_z.get())*1000/2):\n",
    "        return FORWARD_SCATTERING\n",
    "    if(place[2] < -1 * float(setting.block_z.get())*1000/2):\n",
    "        return BACKWARD_SCATTERING\n",
    "    return IN_SYSTEM\n",
    "\n",
    "#return photon's place(not PERIODIC BOUNDARY MODE)\n",
    "def escape_judge(origin,vector):\n",
    "    if(\n",
    "        (collision_x < block_half_x)  and (collision_x > -1*block_half_x)\n",
    "        and(collision_y<block_half_y) and (collision_y > -1*block_half_y)\n",
    "        and(collision_z<block_half_z) and (collision_z > -1*block_half_z)\n",
    "    ):\n",
    "        return IN_SYSTEM\n",
    "    \n",
    "    if(vector[0] == 0):\n",
    "        escape_time_x = 100000000000\n",
    "    else:\n",
    "        escape_time_x = (np.sign(vector[0]) *  float(setting.block_x.get())*1000/2 - origin[0]) / vector[0]\n",
    "    if(vector[1] == 0):\n",
    "        escape_time_y = 100000000000\n",
    "    else:\n",
    "        escape_time_y = (np.sign(vector[1]) *  float(setting.block_y.get())*1000/2 - origin[1]) / vector[1]\n",
    "    if(vector[2] == 0):\n",
    "        escape_time_z = 100000000000\n",
    "    else:\n",
    "        escape_time_z = (np.sign(vector[2]) *  float(setting.block_z.get())*1000/2 - origin[2]) / vector[2]\n",
    "    if((escape_time_z < escape_time_x)and (escape_time_z < escape_time_y)):\n",
    "        if(vector[2] > 0):\n",
    "            return FORWARD_SCATTERING\n",
    "        else:\n",
    "            return BACKWARD_SCATTERING\n",
    "    if(escape_time_x < escape_time_y):\n",
    "        return SIDEWARD_SCATTERING_X\n",
    "    else:\n",
    "        return SIDEWARD_SCATTERING_Y\n",
    "\n",
    "def getNearestValue(list, num):    \n",
    "    idx = np.abs(np.asarray(list) - num).argmin()\n",
    "    return idx\n",
    "\n",
    "def result_file_write_columns(result_file):\n",
    "    particle_types = int(setting.particle_types.get()) \n",
    "    with open(result_file, mode='a') as result:\n",
    "        #result file\n",
    "        result.write(\"wavelength,transmission,scattering,absorption,mean_events,mean_optical_path(um),mean_free_path(um),,\")\n",
    "        result.write(\"forward_scattering,forward_scattering_events,forward_scattering_multiple_rate,mean_forward_scattering_optical_path(um),,\")\n",
    "        result.write(\"backword_scattering,backward_scattering_events,backward_scattering_multiple_rate,mean_backward_scattering_optical_path(um),,\")\n",
    "        result.write(\"sideword_scattering,sideward_scattering_events,sideward_scattering_multiple_rate,mean_sideward_scattering_optical_path(um),,\")\n",
    "        result.write(\"absorption,absorption_events,absorption_multiple_rate,mean_absorption_optical_path(um),,\")\n",
    "        for particle in range(particle_types):\n",
    "            result.write(particles[particle].namer()+\"_mean_free_path(um),\")\n",
    "        for particle in range(particle_types):\n",
    "            result.write(particles[particle].namer()+\"_collision_rate,\")\n",
    "        for particle in range(particle_types):\n",
    "            result.write(particles[particle].namer()+\"_collision_events_per_photon,\")\n",
    "        result.write(\",,SIMULATION_SETTING,\")\n",
    "        for particle in range(particle_types):\n",
    "            result.write(particles[particle].namer()+\"Core_diameter(nm):\"+particles[particle].core_diameter.get()+\"   Shell_thickness(nm):\"+particles[particle].shell_thickness.get())\n",
    "            result.write(\"    Concentration(*10^9 number/ml):\" + particles[particle].concentration.get() + \",\")\n",
    "        result.write(\",block_x(um):\"+setting.block_x.get()+\",block_y(um):\"+setting.block_y.get()+\",block_z(um):\"+setting.block_z.get())\n",
    "        result.write(\",incident_photons:\"+ str(int(setting.incident_photons.get()))+\",host_refractive_index:\"+setting.host_refractive_index.get())\n",
    "        result.write(\",random_seed:\"+str(RANDOM_SEED))\n",
    "        result.write(\",PERIODIC BOUNDARY MODE:\"+str(setting.PERIODIC_BOUNDARY_MODE.get()))\n",
    "        result.write(\",LOG_MODE:\"+str(setting.LOG_MODE.get()))\n",
    "        result.write(\"\\n\")\n",
    "\n",
    "def writer(shen,result_file):\n",
    "    with open(result_file, mode='a') as result:\n",
    "        for i in range(len(shen)):\n",
    "            result.write(str(shen[i]) + \",\")\n",
    "\n",
    "#return [photons end,optical path,[each particle scattering events]]\n",
    "def photon(num,angles,sca_rates,cross_section_densities,total_cross_section_density,log_file):\n",
    "    LOG_MODE = setting.LOG_MODE.get()\n",
    "    PERIODIC_BOUNDARY_MODE = setting.PERIODIC_BOUNDARY_MODE.get()\n",
    "    block_half_x,block_half_y,block_half_z = float(setting.block_x.get())*1000/2,float(setting.block_y.get())*1000/2,float(setting.block_z.get())*1000/2\n",
    "    generation = 0\n",
    "    collision_x,collision_y,collision_z = 0,0,0\n",
    "    origin_x,origin_y = 0,0\n",
    "    origin_z = -1 * block_half_z\n",
    "    vector_x,vector_y,vector_z = 0,0,1\n",
    "    path = 0\n",
    "    total_path = 0\n",
    "    material_events = [0 for i in range(int(setting.particle_types.get()))]\n",
    "\n",
    "    while(True):#loop until photon death\n",
    "        free_path = random.expovariate(total_cross_section_density)\n",
    "        #new place\n",
    "        collision_x = origin_x + vector_x * free_path\n",
    "        collision_y = origin_y + vector_y * free_path\n",
    "        collision_z = origin_z + vector_z * free_path\n",
    "        if(LOG_MODE):\n",
    "            with open(log_file, mode='a') as log:\n",
    "                log.write(str(num)+\",\" +str(round_sig(free_path/1000)) + \",\" + str(round_sig(origin_x/1000))+\",\"+str(round_sig(origin_y/1000))+\",\")\n",
    "                log.write(str(round_sig(origin_z/1000))+\",\")\n",
    "                log.write(str(round_sig(collision_x/1000))+\",\"+str(round_sig(collision_y/1000))+\",\"+str(round_sig(collision_z/1000)) + \",\")\n",
    "                log.write(str(round_sig(vector_x)) + \",\" + str(round_sig(vector_y)) + \",\"+str(round_sig(vector_z)) + \",\")\n",
    "\n",
    "        if(PERIODIC_BOUNDARY_MODE):\n",
    "            judge = escape_judge_periodic([collision_x,collision_y,collision_z]) \n",
    "        ##not periodic boundary mode\n",
    "        else:\n",
    "            judge = escape_judge([origin_x,origin_y,origin_z],[vector_x,vector_y,vector_z])\n",
    "\n",
    "        #forward\n",
    "        if(judge == FORWARD_SCATTERING):\n",
    "            if(generation == 0):\n",
    "                total_path = block_half_z*2\n",
    "                if(LOG_MODE):\n",
    "                    with open(log_file, mode='a') as log:\n",
    "                        log.write(\"None,None,transmission\\n\")\n",
    "                return [TRANSMISSION,total_path,generation,material_events]\n",
    "            else:\n",
    "                #angle[getNearestValue(angle_arr,cartesian2spherical([vector_x,vector_y,vector_z])[0])] += 1 \n",
    "                total_path = path+(block_half_z - origin_z)  /  vector_z-free_path \n",
    "                if(LOG_MODE):\n",
    "                    with open(log_file, mode='a') as log:\n",
    "                        log.write(\"None,None,forward_scattering\\n\")\n",
    "                #0:transmission、1:forward scattering 2:sideward scattering 3:backward scattering 4:absorption\n",
    "                return [FORWARD_SCATTERING,total_path,generation,material_events]\n",
    "\n",
    "        #backward scattering\n",
    "        elif(judge == BACKWARD_SCATTERING):\n",
    "            #angle[getNearestValue(angle_arr,cartesian2spherical([vector_x,vector_y,vector_z])[0])] += 1\n",
    "            total_path = path + (-1*block_half_z - origin_z)  /  vector_z - free_path #計算式\n",
    "\n",
    "            if(LOG_MODE):\n",
    "                with open(log_file, mode='a') as log:\n",
    "                    log.write(\"None,None,backward_scattering\\n\")\n",
    "            return [BACKWARD_SCATTERING,total_path,generation,material_events]\n",
    "\n",
    "        #sideward scattering \n",
    "        elif((judge == SIDEWARD_SCATTERING_X) or (judge == SIDEWARD_SCATTERING_X)):\n",
    "            if(judge ==  SIDEWARD_SCATTERING_X):       \n",
    "                total_path = path + (np.sign(vector_x)*block_half_x - origin_x)  /  vector_x - free_path #計算式\n",
    "            if(judge ==  SIDEWARD_SCATTERING_Y):       \n",
    "                total_path = path + (np.sign(vector_y)*block_half_y - origin_y)  /  vector_y - free_path #計算式\n",
    "            if(LOG_MODE):\n",
    "                with open(log_file, mode='a') as log:\n",
    "                    log.write(\"None,None,sideward_scattering\\n\")\n",
    "            return [SIDEWARD_SCATTERING,total_path,generation,material_events]\n",
    "\n",
    "        #photon still in system\n",
    "        elif(judge == IN_SYSTEM):\n",
    "            collision_particle = random.choices(range(int(setting.particle_types.get())),weights = cross_section_densities)[0]\n",
    "            sca_rate = sca_rates[collision_particle]\n",
    "            material_events[collision_particle]+=1\n",
    "            #scattering\n",
    "            if(np.random.rand() < sca_rate):\n",
    "                sca_vector = spherical2cartesian([random.choices(ANGLE_ARR,weights=angles[collision_particle])[0],(random.random()-0.5)*2 * math.pi])\n",
    "                original_angle_cartesian = np.array([vector_x,vector_y,vector_z])\n",
    "                vector_x,vector_y,vector_z = np.array(np.dot(rotate2z_matrix(original_angle_cartesian),sca_vector))[0]\n",
    "                if(LOG_MODE):\n",
    "                    with open(log_file, mode='a') as log:\n",
    "                        log.write(particles[collision_particle].namer() + \",scattering\\n\")\n",
    "            #absorption\n",
    "            else:\n",
    "                total_path += path\n",
    "                if(LOG_MODE):\n",
    "                    with open(log_file, mode='a') as log:\n",
    "                        log.write(particles[collision_particle].namer() + \",absorption,absorption\\n\")\n",
    "                return [ABSORPTION,total_path,generation+1,material_events]\n",
    "            generation += 1\n",
    "            origin_x = collision_x\n",
    "            origin_y = collision_y\n",
    "            origin_z = collision_z\n",
    "            path += free_path\n",
    "            \n",
    "def start():\n",
    "    \"\"\"\n",
    "    Initial Settings\n",
    "    \"\"\"\n",
    "    ##############################################Save INITIAL_SETTING###########################################################\n",
    "    save_initial_setting()\n",
    "    np.random.seed(RANDOM_SEED)\n",
    "    ##############################################Result file directory###########################################################\n",
    "    result_path = \"montecarlo/\"\n",
    "    #####Make folder\n",
    "    if(os.path.exists(result_path[0:-1])==False):\n",
    "        os.mkdir(result_path[0:-1])\n",
    "    ##################################################LOG_MODE##############################################################\n",
    "    LOG_MODE = setting.LOG_MODE.get()\n",
    "    ############################################number of cpu (when you try multicore process)##############################################################\n",
    "    number_of_cpu = 4\n",
    "    if(LOG_MODE):\n",
    "        number_of_cpu = 1\n",
    "    ##################################################num##########################################################\n",
    "    incident_photons = int(setting.incident_photons.get()) \n",
    "    flux_power = 1 / incident_photons #power per one photon\n",
    "    #################################################wavelength setting#############################################################\n",
    "    min_wave = round_sig(float(setting.min_wave.get()))\n",
    "    max_wave = round_sig(float(setting.max_wave.get()))\n",
    "    interval = round_sig(float(setting.interval_wave.get()))\n",
    "    ##############################################number of particle types###########################################################\n",
    "    particle_types = int(setting.particle_types.get()) \n",
    "    ##############################################################################################################\n",
    "    all_eff = []\n",
    "    diameters = []\n",
    "    concentrations = []\n",
    "    for particle in range(particle_types):\n",
    "        if(particles[particle].haveshell.get()):\n",
    "            diameters.append(float(particles[particle].core_diameter.get()) + 2 * float(particles[particle].shell_thickness.get()))\n",
    "        else:\n",
    "            diameters.append(float(particles[particle].core_diameter.get()))\n",
    "        concentrations.append(float(particles[particle].concentration.get())  * 10**9 * 10**(-21))\n",
    "        all_eff.append(all_eff_dataframe(particles[particle]))\n",
    "    \n",
    "    result_file = result_path+\"test.csv\"\n",
    "    result = open(result_file,\"w\")\n",
    "    result.close()\n",
    "    result_file_write_columns(result_file)        \n",
    "\n",
    "    \"\"\"\n",
    "    start calculating\n",
    "    \"\"\"\n",
    "    for wavelength in np.arange(min_wave,max_wave+interval,interval):\n",
    "        angles = []\n",
    "        sca_rates = []\n",
    "        cross_section_densities = []\n",
    "        log_file = result_file[0:-4] + \"_log_at\"+str(wavelength)+\"nm.csv\"\n",
    "        if(LOG_MODE):\n",
    "            log = open(log_file,\"w\")\n",
    "            with open(log_file, mode='a') as log:\n",
    "                log.write(\"Photon number,free path(um),origin_x(um),origin_y(um),origin_z(um),end_x(um),end_y(um),end_z(um),\")       \n",
    "                log.write(\"vector_x,vector_y,vector_z,collision_particle,phenomena,photon death by,\\n\")\n",
    "        for particle in range(particle_types):\n",
    "            angles.append(angle_dataframe(particles[particle],wavelength))\n",
    "            sca_rates.append(all_eff[particle][\"Qsca\"][wavelength] / all_eff[particle][\"Qext\"][wavelength])\n",
    "            cross_section_densities.append(all_eff[particle][\"Qext\"][wavelength]*diameters[particle]**2*math.pi /4* concentrations[particle])\n",
    "        \n",
    "        total_cross_section_density = sum(cross_section_densities)\n",
    "        \n",
    "        boundary_times = 0\n",
    "        result_list = []\n",
    "        iterator = range(incident_photons),angles,sca_rates,cross_section_densities,total_cross_section_density,log_file\n",
    "        #################################not good now(you can try if you want to calculate faster)########################################\n",
    "        #with Pool(processes = number_of_cpu) as p:\n",
    "        #    print(\"ds\")\n",
    "        #    result_list.append(p.map(func = photon,iterable = iterator))\n",
    "        #result = result_list[0]\n",
    "        for i in range(incident_photons):\n",
    "             result_list.append(photon(i,angles,sca_rates,cross_section_densities,total_cross_section_density,log_file))\n",
    "        result = result_list\n",
    "        total_events = 0\n",
    "        transmission = 0\n",
    "        total_path = 0\n",
    "        forward_sca,  forward_events, forward_mean_path, forward_multiple_rate, forward_number = 0,0,0,0,0\n",
    "        sideward_sca,sideward_events,sideward_mean_path,sideward_multiple_rate,sideward_number = 0,0,0,0,0\n",
    "        backward_sca,backward_events,backward_mean_path,backward_multiple_rate,backward_number = 0,0,0,0,0\n",
    "        absorption,absorption_events,absorption_mean_path,absorption_multiple_rate,absorption_number = 0,0,0,0,0\n",
    "        material_events = [0 for i in range(int(setting.particle_types.get()))]\n",
    "        \n",
    "        #[photon destiny,optical path,events,events of each material]\n",
    "        for i in range(incident_photons):\n",
    "            total_path += result[i][1]\n",
    "            total_events += result[i][2]\n",
    "            for material in range(int(setting.particle_types.get())):\n",
    "                material_events[material] += result[i][3][material]\n",
    "\n",
    "            if(result[i][0] == TRANSMISSION):#transmission\n",
    "                transmission+=flux_power\n",
    "                \n",
    "            elif(result[i][0] == FORWARD_SCATTERING):#forward\n",
    "                forward_number += 1\n",
    "                forward_sca +=flux_power\n",
    "                forward_events += result[i][2]\n",
    "                forward_mean_path += result[i][1]\n",
    "                if(result[i][2] >= 2):\n",
    "                    forward_multiple_rate += 1\n",
    "\n",
    "            elif(result[i][0] == SIDEWARD_SCATTERING):#sideward\n",
    "                sideward_number += 1\n",
    "                sideward_sca +=flux_power\n",
    "                sideward_events += result[i][2]\n",
    "                sideward_mean_path += result[i][1]\n",
    "                if(result[i][2] >= 2):\n",
    "                    sideward_multiple_rate += 1\n",
    "\n",
    "            elif(result[i][0] == BACKWARD_SCATTERING):#backscattering\n",
    "                backward_number += 1\n",
    "                backward_sca += flux_power\n",
    "                backward_events += result[i][2]\n",
    "                backward_mean_path += result[i][1]\n",
    "                if(result[i][2] >= 2):\n",
    "                    backward_multiple_rate += 1\n",
    "\n",
    "            elif(result[i][0] == ABSORPTION):#absorption\n",
    "                absorption_number += 1\n",
    "                absorption += flux_power\n",
    "                absorption_events += result[i][2]\n",
    "                absorption_mean_path += result[i][1]\n",
    "                if(result[i][2] >= 2):\n",
    "                    absorption_multiple_rate += 1\n",
    "                    \n",
    "        #calculate each parameters\n",
    "        mean_total_events = round_sig(total_events / incident_photons)\n",
    "        mean_total_path = round_sig(total_path / (incident_photons*1000))\n",
    "        mean_free_path = round_sig(1 / (total_cross_section_density * 1000))\n",
    "        if(forward_number > 0):\n",
    "            forward_events = round_sig(forward_events/forward_number)\n",
    "            forward_mean_path = round_sig(forward_mean_path/forward_number/1000)\n",
    "            forward_multiple_rate =round_sig(forward_multiple_rate/forward_number)\n",
    "        if(sideward_number > 0):\n",
    "            sideward_events = round_sig(sideward_events / sideward_number)\n",
    "            sideward_mean_path = round_sig(sideward_mean_path /sideward_number/1000)\n",
    "            sideward_multiple_rate = round_sig(sideward_multiple_rate/sideward_number)\n",
    "        if(backward_number > 0):\n",
    "            backward_events = round_sig(backward_events/backward_number)\n",
    "            backward_mean_path = round_sig(backward_mean_path/backward_number/1000)\n",
    "            backward_multiple_rate = round_sig(backward_multiple_rate/backward_number)\n",
    "        if(absorption_number > 0):\n",
    "            absorption_events = round_sig(absorption_events/absorption_number)\n",
    "            absorption_mean_path = round_sig(absorption_mean_path/absorption_number/1000)\n",
    "            absorption_multiple_rate = round_sig(absorption_multiple_rate/absorption_number)\n",
    "      \n",
    "        writer([wavelength,transmission,forward_sca+sideward_sca+backward_sca,absorption,mean_total_events,mean_total_path,mean_free_path,\"\"],result_file)\n",
    "        writer([ forward_sca, forward_events, forward_multiple_rate, forward_mean_path,\"\"],result_file)\n",
    "        writer([backward_sca,backward_events,backward_multiple_rate,backward_mean_path,\"\"],result_file)\n",
    "        writer([sideward_sca,sideward_events,sideward_multiple_rate,sideward_mean_path,\"\"],result_file)\n",
    "        writer([absorption, absorption_events,absorption_multiple_rate,absorption_mean_path,\"\"],result_file)\n",
    "        \n",
    "        for particle in range(particle_types):\n",
    "            writer([round_sig(1 / (cross_section_densities[particle]*1000))] , result_file)\n",
    "        for particle in range(particle_types):\n",
    "            if(sum(material_events) > 0):\n",
    "                writer([round_sig(material_events[particle]/sum(material_events))] , result_file)\n",
    "            else:\n",
    "                writer([0] , result_file)\n",
    "        for particle in range(particle_types):\n",
    "            writer([round_sig(material_events[particle]/incident_photons)] , result_file)\n",
    "        \n",
    "        with open(result_file, mode='a') as result:\n",
    "            result.write(\"\\n\")\n",
    "    print(\"calculate ends\")\n",
    "    \n",
    "def quit():\n",
    "    root.destroy()\n",
    "    exit()\n",
    "\n",
    "material_files,custom_files = get_files()\n",
    "root = tkinter.Tk()\n",
    "root.geometry(\"1300x800\")\n",
    "root.title(\"Python GUI\")\n",
    "\n",
    "setting = Setting(master = root)\n",
    "setting.start_row =  0\n",
    "setting.particle_types()\n",
    "particles = []\n",
    "for num in range(MAX_PARICLE_TYPES):\n",
    "    thisparticle = ParticleInfo(master=root)\n",
    "    thisparticle.start_row = 4+9*num\n",
    "    thisparticle.num = num + 1\n",
    "    particles.append(thisparticle)\n",
    "    particles[num].define_widget()\n",
    "    particles[num].place_widget()\n",
    "    \n",
    "setting.start_row =   MAX_PARICLE_TYPES*8+8 #max_particles*8+8\n",
    "setting.simulation()\n",
    "root.mainloop()\n",
    "\n",
    "print(\"END\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "import pandas as pd\n",
    "import math\n",
    "import os\n",
    "import random\n",
    "from scipy import interpolate\n",
    "import copy\n",
    "from multiprocessing import Pool\n",
    "import PyMieScatt as ps\n",
    "import tkinter\n",
    "from tkinter import ttk\n",
    "import inspect\n",
    "\n",
    "a = pd.read_csv(\"setting/initial_setting.csv\",index_col = 0)\n",
    "a.to_csv(\"test.csv\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}