{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# How to create a simulation Model for cdsaxs?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First let's start by doing necessary imports (make sure that cdsaxs is installed in your environment)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from cdsaxs.simulations.base import Simulation, Geometry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the Simulation Class\n",
    "\n",
    "   Your simulation class should inherit from the `Simulation` protocol. This class is where the core logic of your simulation resides. It should use the geometric data from the `Geometry` class to set up and run the simulation.\n",
    "\n",
    "   Ensure that the `simulate_diffraction` method is implemented to perform the simulation. Depending on the complexity of your model, this method might involve extensive calculations or integrations.\n",
    "\n",
    "   If your simulation will be used in conjunction with a `Fitter` class, make sure to implement the `set_from_fitter` method. This will enable your simulation to correctly handle data provided by the `Fitter` and return results in a format that the `Fitter` can use.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CylinderSimulation(Simulation):\n",
    "    \"\"\"A class representing a simulation of a cylinder for diffraction pattern calculation.\"\"\"\n",
    "\n",
    "    def __init__(self, qys, qzs, from_fitter=False, initial_guess=None):\n",
    "        \"\"\"Initializes the CylinderSimulation object.\n",
    "\n",
    "        Args:\n",
    "            qys (array-like): The q-values in the y-direction for diffraction calculation.\n",
    "            qzs (array-like): The q-values in the z-direction for diffraction calculation.\n",
    "            from_fitter (bool, optional): Indicates if the parameters should be taken from the fitter. Defaults to False.\n",
    "\n",
    "        \"\"\"\n",
    "        self.qys = qys\n",
    "        self.qzs = qzs\n",
    "        self.from_fitter = from_fitter\n",
    "        self.CylinderGeometry = CylinderGeometry(from_fitter=from_fitter, initial_guess=initial_guess)\n",
    "        self.CylinderDiffraction = CylinderDiffraction(CylinderGeometry=self.CylinderGeometry)\n",
    "\n",
    "    def simulate_diffraction(self, params=None):\n",
    "        \"\"\"Simulates the diffraction pattern of the cylinder.\n",
    "\n",
    "        Args:\n",
    "            params (dict, optional): Parameters for the cylinder. Defaults to None.\n",
    "        Returns:\n",
    "            intensity (array-like): A 2D array of floats containing the intensity.\n",
    "        \"\"\"        \n",
    "        intensity = self.CylinderDiffraction.calculate_intensity(self.qys, self.qzs, params)\n",
    "\n",
    "        if not self.from_fitter:\n",
    "            return intensity[0]\n",
    "\n",
    "        return intensity\n",
    "    \n",
    "    def set_from_fitter(self, from_fitter):\n",
    "        \"\"\"Sets the parameters of the simulation from the fitter.\n",
    "\n",
    "        Args:\n",
    "            from_fitter (Fitter): The fitter object.\n",
    "        \"\"\"\n",
    "        self.from_fitter = from_fitter\n",
    "        self.CylinderGeometry.from_fitter = from_fitter\n",
    "        #You can also use this method to do all the intialization neccesary for fitting.\n",
    "        self.CylinderGeometry.set_initial_guess_dataframe()\n",
    "\n",
    "    @property\n",
    "    def geometry(self):\n",
    "        \"\"\"Returns the geometry of the simulation. This is necessary so that any external object can access the geometry of the simulation\n",
    "        without having to know the internal structure of the simulation object.\n",
    "\n",
    "        Returns:\n",
    "            CylinderGeometry: The geometry of the simulation.\n",
    "        \"\"\"\n",
    "        return self.CylinderGeometry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the Geometry Class\n",
    "\n",
    "   Create a class that implements the `Geometry` protocol. This class should define the specific geometric properties of the system being simulated. For example, in a model of stacked trapezoids, this class would define the dimensions, angles, and positions of the trapezoids.\n",
    "\n",
    "   Implement the `convert_to_dataframe` method to organize the input parameters into a structured format suitable for the simulation. This method is crucial for ensuring that the parameters can be easily interpreted and manipulated by the `Fitter` class.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CylinderGeometry(Geometry):\n",
    "    \"\"\"A class representing the geometry of a cylinder.\"\"\"\n",
    "\n",
    "    def __init__(self, from_fitter=False, initial_guess=None):\n",
    "        \"\"\"Initializes the CylinderGeometry object.\n",
    "\n",
    "        Args:\n",
    "            from_fitter (bool, optional): Indicates if the parameters should be taken from the fitter. Defaults to False.\n",
    "        \"\"\"\n",
    "        self.from_fitter = from_fitter\n",
    "        self.initial_guess = initial_guess\n",
    "        self.initial_guess_dataframe = None\n",
    "\n",
    "    def set_initial_guess_dataframe(self):\n",
    "        \"\"\"if the function is being called by the fitter this function sets the initial guess for the parameters.\n",
    "\n",
    "        Args:\n",
    "            initial_guess (dict): The initial guess for the parameters.\n",
    "        \"\"\"\n",
    "        self.initial_guess_dataframe = pd.DataFrame(self.initial_guess, index=[0])\n",
    "\n",
    "    def convert_to_dataframe(self, params):\n",
    "        \"\"\"Converts the parameters to a DataFrame.\n",
    "\n",
    "        Args:\n",
    "            params (dict or array): The parameters of the cylinder.\n",
    "        Returns:\n",
    "            df (DataFrame): A DataFrame containing the parameters.\n",
    "        \"\"\"\n",
    "        if self.from_fitter:\n",
    "            df = self.rescale_fitparams(params)\n",
    "            \n",
    "        else:\n",
    "            df = pd.DataFrame(params, index=[0])\n",
    "\n",
    "        return self.check_physical_validity(df)\n",
    "    \n",
    "    def check_physical_validity(self, params_df):\n",
    "        \"\"\"Checks if the parameters are physically valid. In this case, the radius and length of the cylinder should be positive.\n",
    "\n",
    "        Args:\n",
    "            params_df (DataFrame): A DataFrame containing the parameters.\n",
    "        Returns:\n",
    "            params_df_c (DataFrame): A DataFrame containing the parameters that are physically valid.\n",
    "        \n",
    "        \"\"\"\n",
    "\n",
    "        \n",
    "        params_df_c = params_df.copy()\n",
    "        keys = params_df_c.columns\n",
    "        \n",
    "        for key in keys:\n",
    "            if params_df[key].values[0] < 0:\n",
    "                params_df_c.loc[params_df_c[key] < 0, key] = np.nan\n",
    "\n",
    "        return params_df_c\n",
    "\n",
    "    def rescale_fitparams(self, params):\n",
    "        \"\"\"Rescales the parameters of the cylinder. Here the multiplier is hardcoded for ease but it should ideally be user input values.\n",
    "\n",
    "        Args:\n",
    "            df (DataFrame): A DataFrame containing the parameters.\n",
    "        Returns:\n",
    "            df (DataFrame): A DataFrame containing the rescaled parameters.\n",
    "        \"\"\"\n",
    "\n",
    "        multiples = np.array([5 , 5, 1])#hardcoded for now but user input values recommended\n",
    "\n",
    "        df = pd.DataFrame(params, columns=self.initial_guess_dataframe.columns)\n",
    "        \n",
    "        df = df * multiples\n",
    "        \n",
    "        df = df + self.initial_guess_dataframe.loc[0]\n",
    "\n",
    "        return df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Separating the diffraction logic from the geometry\n",
    "\n",
    "The following class is to separate the diffraction logic from the geometry. This is useful when you have a complex geometry and you want to separate the geometry from the diffraction logic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CylinderDiffraction():\n",
    "    \"\"\"Class for simulating diffraction from a cylinder.\"\"\"\n",
    "\n",
    "    def __init__(self, CylinderGeometry):\n",
    "        \"\"\"Initialize the CylinderDiffraction object.\n",
    "\n",
    "        Args:\n",
    "            CylinderGeometry: object containing the geometric properties of the cylinder.\n",
    "            xp: module, optional, Module to use for mathematical operations. Default is numpy.\n",
    "        \"\"\"\n",
    "        self.CylinderGeometry = CylinderGeometry\n",
    "\n",
    "    def bessel_j1(self, x):\n",
    "        \"\"\"\n",
    "        Approximate the Bessel function of the first kind J1(x).\n",
    "        The approximation is valid for small to moderately large x.\n",
    "        \"\"\"\n",
    "        # Use a series expansion for small x\n",
    "        result = 0\n",
    "        factorial = 1\n",
    "        x2 = x ** 2\n",
    "        term = x / 2\n",
    "        for n in range(1, 10):  # 10 terms for a decent approximation\n",
    "            factorial *= n\n",
    "            term *= (-1) * x2 / (4 * n * (n + 1))\n",
    "            result += term\n",
    "    \n",
    "        return result\n",
    "\n",
    "    def calculate_intensity(self, qys, qzs, params):\n",
    "        \"\"\"Calculate the diffraction intensity of the cylinder.\n",
    "\n",
    "        Args:\n",
    "            qys, qzs: array-like, The q-values in the y and z directions.\n",
    "            geometry_params: dict, Parameters for the cylinder geometry.\n",
    "\n",
    "        Returns:\n",
    "            intensity: array-like, Simulated diffraction intensity.\n",
    "        \"\"\"\n",
    "        #get the dataframe containing the parameters\n",
    "        params = self.CylinderGeometry.convert_to_dataframe(params)\n",
    "        height = params['height'].values\n",
    "        radius = params['radius'].values\n",
    "        density = params['density'].values\n",
    "\n",
    "        height = height[..., np.newaxis]\n",
    "        radius = radius[..., np.newaxis]\n",
    "        density = density[..., np.newaxis]\n",
    "\n",
    "        # Simplified form factor calculation for a cylinder\n",
    "        form_factor = np.sinc(qzs * height / 2) * self.bessel_j1( qys*radius ) / (qys * radius)\n",
    "        intensity = density * form_factor**2\n",
    "        \n",
    "        return intensity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's generate a set of data that we can use to fit the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Intensity(A.U.)')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Example Usage\n",
    "# Define the cylinder dimensions\n",
    "radius = 50.  # in arbitrary units\n",
    "height = 100.  # in arbitrary units\n",
    "density = 10.  # in arbitrary units\n",
    "\n",
    "# Define the q-space grid\n",
    "qys = np.linspace(-0.1, 0.1, 100)  # qy range\n",
    "qzs = np.linspace(-0.1, 0.1, 100)  # qz range\n",
    "\n",
    "# Create a simulation object\n",
    "cylinder_sim = CylinderSimulation(qys=qys, qzs=qzs)\n",
    "\n",
    "# Calculate the intensity\n",
    "intensity = cylinder_sim.simulate_diffraction(params={'radius': radius, 'height': height, 'density': density})\n",
    "\n",
    "# Output the intensity array\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(qys, intensity)\n",
    "plt.xlabel('qy')\n",
    "plt.ylabel('Intensity(A.U.)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will use the generated data to simulate the diffraction and we can use the `Fitter` class to fit. We will give a initial guess that is close to the actual values. How close is determined by the domain of search fixed by your `multipliers` in `rescale_fitparams` and value of `sigma` for `cmaes` method. In this case in the condition of choosing your initial guess is that: `sigma * multipliers + initial_guess < real_value < sigma * multipliers - initial_guess`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration terminated due to ngen criterion after 80 gens\n",
      "      radius  height    density\n",
      "0  50.011961   100.0  10.069623\n"
     ]
    }
   ],
   "source": [
    "from cdsaxs.fitter import Fitter\n",
    "Simulation2 = CylinderSimulation(qys=qys, qzs=qzs, initial_guess={'radius': 51, 'height': 101, 'density': 8})\n",
    "\n",
    "Fitter1 = Fitter(Simulation=Simulation2, exp_data=intensity)\n",
    "\n",
    "best_fit, best_fitness = Fitter1.cmaes(sigma=1, ngen=80, popsize=300, mu=10, n_default=3, restarts=0, tolhistfun=10E-5, ftarget=None, restart_from_best=True, verbose=False)\n",
    "\n",
    "print(best_fit)"
   ]
  }
 ],
 "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}