SARAH-SSDM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/restrepo/BSM-Submodules/blob/master/SARAH-SSDM.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UEYIBMqNMaKq"
   },
   "source": [
    "# SARAH configuration files generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dwvQkLepvezi"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "if os.getcwd()=='/content':\n",
    "    !wget -O SARAH.py https://raw.githubusercontent.com/restrepo/BSM-Submodules/master/SARAH.py 2>/dev/null\n",
    "    !wget -O cmdlike.py https://raw.githubusercontent.com/restrepo/BSM-Submodules/master/cmdlike.py 2>/dev/null\n",
    "    !git clone https://github.com/restrepo/SARAH.git 2>/dev/null\n",
    "    !mkdir -p JSON\n",
    "    os.chdir('JSON')\n",
    "    !wget -O fullparticles.json https://raw.githubusercontent.com/restrepo/BSM-Submodules/master/JSON/fullparticles.json 2> /dev/null\n",
    "    !wget -O fullparticlesnames.json https://raw.githubusercontent.com/restrepo/BSM-Submodules/master/JSON/fullparticlesnames.json 2> /dev/null\n",
    "    !wget -O fullparametersnames.json https://raw.githubusercontent.com/restrepo/BSM-Submodules/master/JSON/fullparametersnames.json 2> /dev/null\n",
    "    os.chdir('../')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "a3WG8BLLtFzc"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import json\n",
    "import re\n",
    "import numpy as np\n",
    "import sys\n",
    "from SARAH import *\n",
    "pd.set_option('display.max_colwidth',200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2FIfQ5wEMaK-"
   },
   "source": [
    "## Choose step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9ue2BnB2MaLA",
    "outputId": "cad092f2-b96e-4dac-ed89-b96986773126"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False, False, False, True)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "PARTICLES =False\n",
    "PARAMETERS=True\n",
    "SPHENO    =False\n",
    "OUTPUT    =False\n",
    "BSM=True\n",
    "if PARAMETERS:\n",
    "    PARTICLES=False\n",
    "if SPHENO:\n",
    "    PARAMETERS=False\n",
    "    PARTICLES=False\n",
    "if OUTPUT:\n",
    "    SPHENO=False\n",
    "    PARAMETERS=False\n",
    "    PARTICLES=False    \n",
    "if not PARTICLES and not PARAMETERS and not SPHENO and not OUTPUT:\n",
    "    print('SETTING BSM True')\n",
    "    BSM=True\n",
    "if BSM:    \n",
    "    OUTPUT=False\n",
    "    SPHENO=False\n",
    "    PARAMETERS=False\n",
    "    PARTICLES=False\n",
    "PARTICLES,PARAMETERS,SPHENO,OUTPUT,BSM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8V7bm-AoMaLH"
   },
   "source": [
    "## Read `MODEL.m` file into an standarized list of dictionaries "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RHsNvaD9tFz3"
   },
   "source": [
    "### Design\n",
    "#### Class inheritance\n",
    "* Basic object\n",
    "```\n",
    "list_of_list_of_dictionaries -> Particles -> Parameters\n",
    "```\n",
    "* Methods\n",
    "```\n",
    "SARAH -> update_SARAH_particles -> update_SARAH_parameters -> update_SARAH_SPheno -> update_SARAH\n",
    "```\n",
    "\n",
    "\n",
    "#### USAGE:\n",
    "1. Load a `SARAH` Model File\n",
    "2. Warns if a `particle` or `parameter` is not yet defined\n",
    "3. Build missing `particles` or `parameters` and update predefined particles loaded in `__init__`\n",
    "4. Export `SARAH` auxiliarly files:\n",
    "   * `particles.m`   \n",
    "   * `parameters.m`\n",
    "   * `SPheno.m`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "j6TrPTTaMaLM"
   },
   "outputs": [],
   "source": [
    "from SARAH import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MlppmKPqIt7m"
   },
   "source": [
    "## Update particles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "X7lF-4pWm5TD"
   },
   "source": [
    "### How to build a function for the `self.update_particles` method\n",
    "For one Specific Type of Particles: `self.update_particles(f,Definition,Lorentz,args)` is expected to filter the set of particles\n",
    "by using the  `Definition`  and `Lorentz` arguments, and pass the resulting list of particles (as an object `Particles`) to function `f(particle,*args)`, where `particle` is each one of the elements of the filtered list of particles.  The function must return another `Particles` object with the help of the extra arguments passed through the optional tuple: `args=(...)`\n",
    "\n",
    "The main purpose of the generic function `f` is either to \n",
    "1. add additional info to an existing particle: Define a function with a mandatory `particle` argument which returns the  same particle with additional info like `p['Description]`. The recommended name for the function in such a case is `get_Specific_Type_of_Particles_Descriptions(particle,...)`\n",
    "1. generate a new non-existing particle. In such a case the recommended name for the function is `get_Specific_Type_of_Particles(particle,...)`. Each existing particle  must generare one and only one new particle\n",
    "\n",
    "__Example__:\n",
    "\n",
    "Define\n",
    "```python\n",
    "def get_WeylFermion_Description(p,particles):\n",
    "    p.get('Properties')['update_Description']={'LaTeX' : get_weylfermion_LaTeX( p.get('Field') )}\n",
    "    return p\n",
    "```\n",
    "and use\n",
    "```python\n",
    "self.update_particles( get_WeylFermion_Descriptions, \n",
    "                      Definition='WeylFermionAndIndermediate',\n",
    "                      Lorentz='WeylFermion')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "AtwKmTsDMaLd"
   },
   "outputs": [],
   "source": [
    "def get_4Spinor_Descriptions(particle,particles):\n",
    "    \"\"\"\n",
    "    Function which that take the dictionary particle and adds: \n",
    "    'Description' or 'Properties' -> 'update_Description'\n",
    "    To the particle with 'Field' some 4Spinor\n",
    "    \"\"\"\n",
    "    p=particle\n",
    "    gprt=particles.loc[ p.get('Parents') ]\n",
    "    if gprt[0].get('rotation'):\n",
    "        gprt=particles.loc[gprt[0].get('Parents')]\n",
    "    cmpt=gprt[0].get('Field')\n",
    "    gprt=particles.loc[gprt[0].get('Parents')]\n",
    "    if get_abs_groups( gprt[0].get('Properties').get('Groups'), u1_abs='1/6',su2='2',su3_abs='3' ):\n",
    "        if cmpt==gprt[0].get('Properties').get('multiplet')[0]:\n",
    "            p['Description']='Up-Quarks'\n",
    "        else:\n",
    "            p['Description']='Down-Quarks'\n",
    "    if get_abs_groups( gprt[0].get('Properties').get('Groups'), u1_abs='1/2',su2='2',su3_abs='1' ):\n",
    "        if cmpt==gprt[0].get('Properties').get('multiplet')[0]:\n",
    "            p['Description']='Neutrinos'\n",
    "        else:\n",
    "            p['Description']='Leptons'\n",
    "    return p\n",
    "\n",
    "def get_WeylFermion_Descriptions(p):\n",
    "    '''\n",
    "    All the Weyl Fermions are used. To filter simplified iso-singlet names, use:\n",
    "        if not p.get('Parents') and not p.get('Properties').get('multiplet'):\n",
    "            RETURN=False\n",
    "        #Empty dic: {}, must be returned when RETURN is False\n",
    "    '''\n",
    "    p.get('Properties')['update_Description']={'LaTeX' : get_weylfermion_LaTeX( p.get('Field') )}\n",
    "    return p\n",
    "\n",
    "def get_gauge_vectors_Descriptions(p,particles,\n",
    "                di={'U[1]' :{'Description':'B-Boson' ,'Ghost':'B-Boson Ghost' },\n",
    "                    'SU[2]':{'Description':'W-Bosons','Ghost':'W-Boson Ghost'},\n",
    "                    'SU[3]':{'Description':'Gluon'   ,'Ghost':'Gluon Ghost'}}):\n",
    "    gr=p.get('Properties').get('Group').strip()\n",
    "    if di.get( gr  ):\n",
    "        p['Description']=di.get(gr).get('Description')\n",
    "    return p\n",
    "\n",
    "def get_ghosts(p,particles,\n",
    "                di={'U[1]' :{'Description':'B-Boson' ,'Ghost':'B-Boson Ghost' },\n",
    "                    'SU[2]':{'Description':'W-Bosons','Ghost':'W-Boson Ghost'},\n",
    "                    'SU[3]':{'Description':'Gluon'   ,'Ghost':'Gluon Ghost'}}):\n",
    "    gr=p.get('Properties').get('Group').strip()\n",
    "    if di.get( gr  ):\n",
    "        p=particles.apply_filter(lambda d: d.get('Description')==di.get(gr).get('Ghost'))[0]\n",
    "        return p\n",
    "    else:\n",
    "        return {}\n",
    "    \n",
    "def get_boson_vectors_Descriptions(p,particles,partialparticles,\n",
    "                      di={'B-Boson':'Photon',\n",
    "                          'W-Bosons':{1:'W+ - Boson',3:'Z-Boson'}},\n",
    "                      goldston={\n",
    "                          'W-Bosons':{1:'Charged Higgs',3:'Pseudo-Scalar Higgs'}\n",
    "                                      }):\n",
    "    '''\n",
    "    Assumptions:\n",
    "    1) The Goldston bosons are the SM ones and this function\n",
    "    must be called after the scalar definitions\n",
    "    '''\n",
    "    pP=p.get('Parents')\n",
    "    if not pP:\n",
    "        pP=''\n",
    "    abelian=pP.split('[')\n",
    "    try:\n",
    "        BV=particles.loc[abelian[0]]\n",
    "        dscr=BV[0].get('Description')\n",
    "    except (IndexError,KeyError):\n",
    "        dscr=''\n",
    "        \n",
    "    la=len(abelian)\n",
    "    gltn=Particles([])\n",
    "    if la==1:\n",
    "        get_dscrp=di.get(dscr)\n",
    "    else:\n",
    "        try:\n",
    "            i=eval( re.search('\\[\\s*([0-9]+)\\s*\\]',pP).groups()[0] )\n",
    "        except (IndexError,AttributeError):\n",
    "            i=-1\n",
    "            \n",
    "        try:\n",
    "            get_dscrp=di.get(dscr).get(i)\n",
    "            gltn=partialparticles.apply_filter(\n",
    "                lambda d: d.get('Description')==goldston.get(dscr).get(i) \n",
    "                     )\n",
    "        except AttributeError:\n",
    "            get_dscrp=''\n",
    "            gltn=Particles([])\n",
    "            \n",
    "    if get_dscrp:\n",
    "        p['Description']=get_dscrp\n",
    "        \n",
    "    if gltn.size()==1:\n",
    "        p['Properties']['update_Description']={'Goldstone':gltn.get('Field')[0]}        \n",
    "        \n",
    "\n",
    "    return p\n",
    "\n",
    "def get_boson_vectors_ghosts(p,particles,\n",
    "                      di={'B-Boson':'Photon Ghost',\n",
    "                          'W-Bosons':{1:'Positive W+ - Boson Ghost',\n",
    "                                      3:'Z-Boson Ghost'}}):\n",
    "    np={}\n",
    "    pP=p.get('Parents')\n",
    "    if not pP:\n",
    "        pP=''\n",
    "    abelian=pP.split('[')\n",
    "    try:\n",
    "        BV=particles.loc[abelian[0]]\n",
    "        dscr=BV[0].get('Description')\n",
    "    except (IndexError,KeyError):\n",
    "        dscr=''    \n",
    "    la=len(abelian)\n",
    "    gltn=Particles([])\n",
    "    if la==1:\n",
    "        get_dscrp=di.get(dscr)\n",
    "    else:\n",
    "        try:\n",
    "            i=eval( re.search('\\[\\s*([0-9]+)\\s*\\]',pP).groups()[0] )\n",
    "        except (IndexError,AttributeError):\n",
    "            i=-1\n",
    "            \n",
    "        get_dscrp=di.get(dscr).get(i)\n",
    "\n",
    "    if get_dscrp:\n",
    "        np['Field']      =re.sub('^V','g',  p.get('Field'))\n",
    "        np['Description']=get_dscrp\n",
    "        np['Block']      = 'GaugeSector'\n",
    "        np['Definition'] = 'EWSB'\n",
    "        np['Properties'] ={'Lorentz': 'Ghost'}\n",
    "        return np\n",
    "    else:\n",
    "        return {}\n",
    "\n",
    "def get_IntermediateScalars_Definitions(p):\n",
    "    if get_abs_groups( \n",
    "         p.get('Properties').get('Groups'),u1_abs='1/2',su2='2',su3_abs='1'):\n",
    "        if p.get('Properties').get('Groups')[0].find('-')==-1:\n",
    "            p.get('Properties')['charge']=['Charged','Neutral']\n",
    "        else:\n",
    "            p.get('Properties')['charge']=['Neutral','Charged']\n",
    "\n",
    "    p.get('Properties')['update_Description']={\n",
    "                                               'PDG'       : [0],\n",
    "                                               'Width'     : 0,\n",
    "                                               'Mass'      : 'Automatic',\n",
    "                                               'LaTeX'     : p.get('Field'),\n",
    "                                               'OutputName': p.get('Field') }\n",
    "    return p\n",
    "\n",
    "def get_GaugeEScalars_Definitions(p,H):\n",
    "    if H.size()==1 and p.get('Parents')==H.get('Field')[0]:\n",
    "        #Standard model Higgs\n",
    "        p.get('Properties')['update_Description']={'PDG'  :[0],\n",
    "                                               'Width':0,\n",
    "                                               'Mass' : 'Automatic',\n",
    "                                               'OutputName' : p.get('Field')\n",
    "                                               }\n",
    "\n",
    "        l=H[0].get('Properties').get('multiplet')\n",
    "        Hp0=l.index(p.get('Field'))\n",
    "        if H[0].get('Properties').get('charge')[Hp0]=='Charged':\n",
    "            p.get('Properties')['ElectricCharge']=1\n",
    "            p.get('Properties')['update_Description']['FeynArtsNr']=2\n",
    "            p.get('Properties')['update_Description']['LaTeX']='H^+'\n",
    "        elif H[0].get('Properties').get('charge')[Hp0]=='Neutral':\n",
    "            p.get('Properties')['ElectricCharge']=0\n",
    "            p.get('Properties')['update_Description']['FeynArtsNr']=1\n",
    "            p.get('Properties')['update_Description']['LaTeX']='H^0'\n",
    "    return p\n",
    "\n",
    "def get_EWSBScalars_Definitions(p,particles):\n",
    "    if p.get('Properties').get('CP')=='Real':\n",
    "        pp=particles.apply_filter(lambda d: d.get('Description')=='Higgs')\n",
    "        try:\n",
    "            pphh=pp[0]\n",
    "        except IndexError:\n",
    "            pphh={}\n",
    "        if pphh:\n",
    "            p['Description']=pphh.get('Description')\n",
    "            p.get('Properties')['update_Description']=pphh.get('Properties').get(\n",
    "                                                            'update_Description')\n",
    "    elif p.get('Properties').get('CP')=='Imaginary':\n",
    "        pp=particles.apply_filter(lambda d: d.get('Description')==\n",
    "                                                        'Pseudo-Scalar Higgs')\n",
    "        try:\n",
    "            ppA0=pp[0]\n",
    "        except IndexError:\n",
    "            ppA0={}\n",
    "        if ppA0:\n",
    "            p['Description']=ppA0.get('Description')\n",
    "            p.get('Properties')['update_Description']=ppA0.get('Properties').get(\n",
    "                                                            'update_Description')\n",
    "        \n",
    "    return p    \n",
    "\n",
    "def get_EWSBScalars(p,H,particles):\n",
    "    '''\n",
    "    Only Works if \n",
    "    H=self.update_particles(get_IntermediateScalars_Definitions,\n",
    "                               Definition='WeylFermionAndIndermediate',\n",
    "                               Lorentz='Scalar').size()==1\n",
    "    '''\n",
    "    pp={}\n",
    "    if H.size()==1 and p.get('Field')==H.get('Field')[0]:\n",
    "        kk=particles.apply_filter(lambda d: d.get('Name')=='Charged Higgs')\n",
    "        pp=kk[0]\n",
    "        Hp=H[0].get('Properties').get('charge').index('Charged')\n",
    "        try:\n",
    "            Hpname=H[0].get('Properties').get('multiplet')[Hp]\n",
    "            pp['Field']  = Hpname\n",
    "            pp['Parents']= Hpname\n",
    "        except IndexError:\n",
    "            pass\n",
    "    return pp\n",
    "\n",
    "def fix_gluon(d):\n",
    "    if d.get('Description')=='Gluon':\n",
    "        d['Definition']='EWSB'\n",
    "    if d.get('Description')=='Gluon Ghost':\n",
    "        d['Definition']='EWSB'\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Z3vjcMl5m5TE"
   },
   "outputs": [],
   "source": [
    "class update_SARAH_particles(SARAH):\n",
    "    def __init__(self,*args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "\n",
    "    def update_fermions(self):\n",
    "        NP=Particles([])\n",
    "        NP=self.update_particles(get_4Spinor_Descriptions,\n",
    "                                Definition='EWSB',\n",
    "                                Lorentz='DiracSpinor',\n",
    "                                args=(self.modelparticles))\n",
    "        NP=NP+self.update_particles(get_4Spinor_Descriptions,\n",
    "              Definition='EWSB',Lorentz='MajoranaSpinor',args=(self.modelparticles))\n",
    "        NP=NP+self.update_particles( get_WeylFermion_Descriptions, \n",
    "                                Definition='WeylFermionAndIndermediate',\n",
    "                                Lorentz='WeylFermion')\n",
    "        return Particles(NP)\n",
    "\n",
    "    def update_gauge_bosons(self):\n",
    "        NP=Particles([])\n",
    "        NP=NP+self.update_particles(get_gauge_vectors_Descriptions,\n",
    "                                Definition='GaugeES',\n",
    "                                Lorentz='Vector',\n",
    "                                args=(self.modelparticles,\n",
    "                            {'U[1]'  :{'Description':'B-Boson' ,'Ghost':'B-Boson Ghost'},\n",
    "                             'SU[2]' :{'Description':'W-Bosons','Ghost':'W-Boson Ghost'},\n",
    "                             'SU[3]' :{'Description':'Gluon'   ,'Ghost':'Gluon Ghost'}}))\n",
    "        NP=NP+self.update_particles(get_ghosts,\n",
    "                                Definition='GaugeES',\n",
    "                                Lorentz='Vector',\n",
    "                                args=(self.particles,\n",
    "                            {'U[1]'  :{'Description':'B-Boson' ,'Ghost':'B-Boson Ghost'},\n",
    "                             'SU[2]' :{'Description':'W-Bosons','Ghost':'W-Boson Ghost'},\n",
    "                             'SU[3]' :{'Description':'Gluon'   ,'Ghost':'Gluon Ghost'}}))\n",
    "        NP=NP+self.update_particles(get_boson_vectors_Descriptions,\n",
    "                                Definition='EWSB',\n",
    "                                Lorentz='Vector',\n",
    "                                args=(NP,\n",
    "                                      self.updated_modelparticles,\n",
    "                            {'B-Boson':'Photon',\n",
    "                             'W-Bosons':{1:'W+ - Boson',3:'Z-Boson'}}))\n",
    "        NP=NP+self.update_particles(get_boson_vectors_ghosts,\n",
    "                                Definition='EWSB',\n",
    "                                Lorentz='Vector',\n",
    "                                args=(NP,\n",
    "                            {'B-Boson':'Photon Ghost',\n",
    "                             'W-Bosons':{1:'Positive W+ - Boson Ghost',\n",
    "                                         3:'Z-Boson Ghost'}}))\n",
    "        #Special case: Negative ghosts\n",
    "        negative_ghost='Negative W+ - Boson Ghost'\n",
    "        NP=NP+self.update_particles(get_boson_vectors_ghosts,\n",
    "                                Definition='EWSB',\n",
    "                                Lorentz='Vector',\n",
    "                                args=(NP,\n",
    "                            {'B-Boson':'',\n",
    "                             'W-Bosons':{1:negative_ghost,\n",
    "                                         3:''}})).apply_filter(\n",
    "                            lambda d: d.get('Description')==negative_ghost\n",
    "                                                      ).apply(fC)\n",
    "        \n",
    "        #Special case: copy GaugeES Gluon (Ghost) to  EWSB\n",
    "        #NP=Particles(NP.apply(fix_gluon))\n",
    "        G=[]\n",
    "        for d in NP.apply_filter(lambda d: d.get('Description').find('Gluon')>-1):\n",
    "            dd=d.copy()\n",
    "            dd['Definition']='EWSB'\n",
    "            G.append(dd )\n",
    "        G=Particles(G)\n",
    "        NP=NP+G\n",
    "        \n",
    "        return Particles(NP)\n",
    "\n",
    "    def update_scalars(self):\n",
    "        '''\n",
    "        The order matters!\n",
    "        '''\n",
    "        NP=Particles([])\n",
    "        \n",
    "        H=self.update_particles(get_IntermediateScalars_Definitions,\n",
    "                                    Definition='WeylFermionAndIndermediate',\n",
    "                                    Lorentz='Scalar')\n",
    "        NP=NP+H\n",
    "        \n",
    "        SMVEV=False\n",
    "        VEVs=self.modelparticles.apply_filter(\n",
    "            lambda d: d.get('Block')=='VEVs' )\n",
    "        if VEVs.size()==2:\n",
    "            SMVEV=True\n",
    "        \n",
    "        #SM-like 'WeylFermionAndIndermediate' (WFI) states, `HSM` + `INERTs` WFI states\n",
    "        if SMVEV:\n",
    "            HSM_name=self.modelparticles.loc[VEVs.get('Parents')[0]].get('Parents')[0]    \n",
    "            HSM=H.loc[HSM_name]\n",
    "            INERTs=H.apply_filter( lambda d: d.get('Field')!=HSM_name)\n",
    "        #TODO: Multi-vev potentials\n",
    "        else:\n",
    "            HSM=H\n",
    "            INERTs=Particles([])        \n",
    "\n",
    "        #Process EWSB standard model particles    \n",
    "        NP=NP+self.update_particles(get_EWSBScalars_Definitions,\n",
    "                                    Definition='EWSB',\n",
    "                                    Lorentz='Scalar',args=(self.particles))\n",
    "        \n",
    "            \n",
    "        #For SM-like Fields Descriptions added,\n",
    "        HpH0=self.update_particles(get_GaugeEScalars_Definitions,Definition='GaugeES',\n",
    "                                    Lorentz='Scalar',\n",
    "                                    args=(HSM))\n",
    "        NP=NP+HpH0\n",
    "\n",
    "        #Repeat 'WeylFermionAndIndermediate' Hp goldstone-field as EWSB field\n",
    "        # to accomodate weird SARAH design\n",
    "        kk=self.update_particles(get_EWSBScalars,\n",
    "                                    Definition='WeylFermionAndIndermediate',                    \n",
    "                                    Lorentz='Scalar',args=(HSM,self.particles))\n",
    "        kk=kk.apply_filter(lambda d: isinstance(d.get('Field'),str))\n",
    "\n",
    "        NP=NP+kk\n",
    "        \n",
    "        #non 'WeylFermionAndIndermediate' Beyond  SM scalar field\n",
    "\n",
    "        return Particles(NP)\n",
    "            \n",
    "    def update_modelparticles(self):            \n",
    "        #must be first\n",
    "        self.updated_modelparticles=self.update_scalars()\n",
    "\n",
    "        # GaugeBosons\n",
    "        self.updated_modelparticles=self.updated_modelparticles+self.update_gauge_bosons()\n",
    "\n",
    "        #Scalars\n",
    "        self.updated_modelparticles=Particles(self.updated_modelparticles+\n",
    "                                              self.update_fermions() )\n",
    "\n",
    "        return self.updated_modelparticles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ecBuz25QceDK"
   },
   "outputs": [],
   "source": [
    "if PARTICLES:\n",
    "    us=update_SARAH_particles(model='SSDM')\n",
    "    #us=update_SARAH_particles(model='SM')\n",
    "    #newp=us.parse_model_particles()\n",
    "    kk=us.update_modelparticles()\n",
    "    self=us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "us=update_SARAH_particles(model='SSDM')\n",
    "    #us=update_SARAH_particles(model='SM')\n",
    "    #newp=us.parse_model_particles()\n",
    "kk=us.update_modelparticles()\n",
    "self=us"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "jVCvJhLaMaLx"
   },
   "source": [
    "## Parse and update parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ghm8dcSIMaMA"
   },
   "outputs": [],
   "source": [
    "class update_SARAH_parameters(update_SARAH_particles):\n",
    "    def __init__(self,*args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "    \n",
    "    def Lagrangian_Couplings_Descriptions(self):\n",
    "        '''\n",
    "        '''\n",
    "        dd=self.Lagrangian\n",
    "        smdict=self.Lagrangian_Couplings\n",
    "        particles=self.updated_modelparticles\n",
    "\n",
    "        for k in dd.keys():\n",
    "            if (sorted_equality( smdict['Up-Yukawa-Coupling']['Lorentz'],dd[k]['Lorentz'] ) and\n",
    "                sorted_equality( smdict['Up-Yukawa-Coupling']['hypercharge'],dd[k]['hypercharge'] ) ):\n",
    "                #Get Higgs from scalar part\n",
    "                for i in range(len(dd[k]['Lorentz'])):\n",
    "                    if dd[k]['Lorentz'][i]=='Scalar':\n",
    "                        H=dd[k]['fields'][i]\n",
    "                        smdict['Up-Yukawa-Coupling']['Coupling']=k\n",
    "                        smdict['Up-Yukawa-Coupling']['Higgs']=H\n",
    "                        smdict['Up-Yukawa-Coupling']['fields']=dd[k]['fields']\n",
    "                #Use obtained Higgs to obtain diagonal form\n",
    "                if not H:\n",
    "                    sys.exit('Higgs doublet field symbol not found!')\n",
    "                for i in range(len(dd[k]['Lorentz'])):                \n",
    "                    if dd[k]['Lorentz'][i]=='WeylFermion':\n",
    "                        mltp=get_multiplet(dd[k]['fields'][i],particles)\n",
    "                        for p in mltp.keys():\n",
    "                            if mltp[p].get('pos')=='Up':\n",
    "                                vev=get_higgs_vev(H,particles)\n",
    "                                smdict['Up-Yukawa-Coupling'\n",
    "                                      ]['update_Description'\n",
    "                                      ]['DependenceNum']=get_diagonal_basis(\n",
    "                                                         vev,p,particles)                \n",
    "\n",
    "        if not smdict.get('Up-Yukawa-Coupling'):\n",
    "            sys.exit('\"Up-Yukawa-Coupling\" NOT FOUND!' )\n",
    "        lk=list(dd.keys())\n",
    "        try:\n",
    "            lk.remove( smdict['Up-Yukawa-Coupling']['Coupling'] )\n",
    "        except KeyError:\n",
    "            pass\n",
    "\n",
    "        lds=list(smdict.keys())\n",
    "        lds.remove('Up-Yukawa-Coupling')\n",
    "        for ds in lds:\n",
    "            for k in lk:\n",
    "                if smdict[ds].get('Lorentz'\n",
    "                    ) and (sorted_equality( smdict[ds]['Lorentz'],dd[k]['Lorentz'] ) and\n",
    "                    sorted_equality( smdict[ds]['hypercharge'],dd[k]['hypercharge'] ) ):\n",
    "                    smdict[ds]['Coupling']=k\n",
    "                    smdict[ds]['fields']=dd[k]['fields']\n",
    "                    #Fix Descriptions for Higgs mass potential parameter\n",
    "                    if ds=='SM Mu Parameter':\n",
    "                        if not smdict[ds].get('update_Description'):\n",
    "                            smdict[ds]['update_Description']={}\n",
    "                        smdict[ds]['update_Description']['OutputName']=smdict[ds]['Coupling']\n",
    "                        smdict[ds]['update_Description']['LaTeX']     =symbol_to_TeX(\n",
    "                                                                       smdict[ds]['Coupling'])\n",
    "                    #'SM Higgs Selfcouplings'                        \n",
    "                    if H:\n",
    "                        smdict[ds]['Higgs']=H\n",
    "                    for i in range(len(dd[k]['Lorentz'])):\n",
    "                        if dd[k]['Lorentz'][i]=='WeylFermion':\n",
    "                            mltp=get_multiplet(dd[k]['fields'][i],particles)\n",
    "                            for p in mltp.keys():\n",
    "                                if mltp[p].get('pos')=='Down':\n",
    "                                    Hk=[dd[k].get('fields')[i] for i in range(len( dd[k]['Lorentz'] ))\n",
    "                                         if dd[k]['Lorentz'][i]=='Scalar' ][0]\n",
    "                                    vev=get_higgs_vev(Hk,particles)\n",
    "                                    smdict[ds]['update_Description'\n",
    "                                          ]['DependenceNum']=get_diagonal_basis(\n",
    "                                                             vev,p,particles)\n",
    "        self.Lagrangian_Couplings=smdict\n",
    "        self.Scalar_Multiplets={'Higgs':H}\n",
    "        return smdict\n",
    "            \n",
    "    def get_rotations(self):\n",
    "        rotation={}\n",
    "        smdict=self.Lagrangian_Couplings\n",
    "        particles=self.updated_modelparticles\n",
    "        for k in smdict.keys():\n",
    "            try:\n",
    "                fields=range(len(smdict[k].get('fields')))\n",
    "            except TypeError:\n",
    "                fields=[]\n",
    "            for i in fields:\n",
    "                if smdict[k]['Lorentz'][i]=='WeylFermion':\n",
    "                    mltp=particles.apply_filter(lambda d: d.get('Parents')==smdict[k]['fields'][i])\n",
    "                    if mltp.size()==2:\n",
    "                        chiral='Left'\n",
    "                    elif mltp.size()==1:\n",
    "                        chiral='Right'\n",
    "                    else:\n",
    "                        chiral=None\n",
    "\n",
    "                    j=0\n",
    "                    for p in mltp.get('Field'):\n",
    "                        j=j+1\n",
    "                        prt=particles.loc[p]\n",
    "                        rot=particles.apply_filter(\n",
    "                            lambda d: str(d.get('Parents')).find(p)>-1\n",
    "                                                 ).get('rotation')[0]\n",
    "                        if isinstance(rot,str):\n",
    "                            rotation[p]={rot:{}}\n",
    "                            dscr='Mixing-Matrix'\n",
    "                            if chiral=='Left':\n",
    "                                if j==1:\n",
    "                                    dscr='{}-Up-{}'.format(chiral,dscr)\n",
    "                                elif j==2:\n",
    "                                    if re.search('^[dD]',p):\n",
    "                                        dscr='{}-Down-{}'.format(chiral,dscr)\n",
    "                                    elif re.search('^[eE]',p):\n",
    "                                        dscr='{}-Lepton-{}'.format(chiral,dscr)\n",
    "\n",
    "\n",
    "                            elif chiral=='Right':\n",
    "                                if re.search('^[uU]',p):\n",
    "                                    dscr='{}-Up-{}'.format(chiral,dscr)\n",
    "                                elif re.search('^[dD]',p):\n",
    "                                    dscr='{}-Down-{}'.format(chiral,dscr)\n",
    "                                elif re.search('^[eE]',p):\n",
    "                                    dscr='{}-Lepton-{}'.format(chiral,dscr)\n",
    "                                else:\n",
    "                                    dscr=None\n",
    "                            rotation[p][rot]['Description']=dscr\n",
    "\n",
    "        self.rotations=rotation\n",
    "        return rotation\n",
    "    \n",
    "    def get_couplings(self):\n",
    "        particles=self.updated_modelparticles\n",
    "        rotation=self.rotations\n",
    "\n",
    "        prtng=particles.apply_filter(\n",
    "                lambda d: str(d.get('Description')).lower().find('ghost')==-1\n",
    "                     )\n",
    "        grps=prtng.apply_filter(\n",
    "                lambda d: d.get('Properties').get('Group')!=None\n",
    "                     ).apply(\n",
    "                lambda d: d.get('Properties').get('Group')\n",
    "                )\n",
    "\n",
    "        G={}\n",
    "        coupling={}\n",
    "        for g in grps:\n",
    "            G=prtng.apply_filter(lambda d: d.get('Properties').get('Group')==g)\n",
    "            V=G[0].get('Field')\n",
    "            try:\n",
    "                VV=prtng.apply_filter(lambda d: str(d.get('Parents')).find(V)>-1)\n",
    "                # Non-Abelian case with SSB\n",
    "                if VV.size()==2:\n",
    "                    key='Properties'\n",
    "                    pattern='conj\\[\\w+\\]'\n",
    "                    VV=VV.apply_filter( lambda d: re.search( pattern, str(d.get(key))  ) )\n",
    "\n",
    "                f=VV[0]['Field']\n",
    "                r=VV[0]['rotation']\n",
    "            except IndexError:\n",
    "                f=''  \n",
    "            c=G[0].get('Properties').get('Coupling').strip()\n",
    "            if g.find('U[1]')>-1:\n",
    "                if f:\n",
    "                    rotation[f]={r: {'Description':\"Photon-Z Mixing Matrix\"}}\n",
    "                coupling[c]={'Description':'Hypercharge-Coupling'}\n",
    "            if g.find('SU[2]')>-1:\n",
    "                if f:\n",
    "                    rotation[f]={r: {'Description':\"W Mixing Matrix\",\n",
    "                                      'update_Description':\n",
    "                                            {'Dependence' :r'''1/Sqrt[2] {{1, 1},\n",
    "                                      {\\[ImaginaryI],-\\[ImaginaryI]}}''' }}}\n",
    "                coupling[c]={'Description':'Left-Coupling'}\n",
    "            if g.find('SU[3]')>-1:\n",
    "                coupling[c]={'Description':'Strong-Coupling'}\n",
    "        self.couplings=coupling\n",
    "        return coupling\n",
    "    \n",
    "    def get_constants(self):\n",
    "        self.constants={}\n",
    "        self.constants['AlphaS']= { 'Description'  : 'Alpha Strong'}\n",
    "        self.constants['e']     = { 'Description'  :  'electric charge'} \n",
    "        self.constants['Gf']    = { 'Description'  :  \"Fermi's constant\"}\n",
    "        self.constants['aEWinv']= { 'Description'  :  'inverse weak coupling constant at mZ'}\n",
    "        return self.constants\n",
    "    \n",
    "    def update_Lagrangian(self):\n",
    "        particles=self.updated_modelparticles\n",
    "        rotation=self.rotations\n",
    "        coupling=self.couplings\n",
    "        H=self.Lagrangian_Couplings['SM Higgs Selfcouplings'\n",
    "                                   ].get('Higgs')\n",
    "        if H:\n",
    "            H0=get_H0(H,particles)\n",
    "            if H0.size()>0:\n",
    "                hh=get_hh(H0,particles).get('Field')[0]\n",
    "                vev=get_hh(H0,particles).get('Properties')[0].get('vev')\n",
    "                if hh and vev:\n",
    "                    self.Lagrangian_Couplings['SM Higgs Selfcouplings'\n",
    "                          ]['update_Description']={\n",
    "                            'LaTeX': symbol_to_TeX(\n",
    "                                      self.Lagrangian_Couplings[\n",
    "                                          'SM Higgs Selfcouplings'\n",
    "                                           ].get('Coupling'),script='_' ),\n",
    "                            'OutputName': symbol_to_OutputName(\n",
    "                                      self.Lagrangian_Couplings[\n",
    "                                          'SM Higgs Selfcouplings'\n",
    "                                           ].get('Coupling') ),\n",
    "                            'DependenceNum': \n",
    "                                r'Mass[{}]^2/({}^2)'.format(hh,vev) }\n",
    "\n",
    "        self.Lagrangian_Couplings['EW-VEV']={}\n",
    "        self.Lagrangian_Couplings['EW-VEV']['Coupling']=vev\n",
    "        self.Lagrangian_Couplings['EW-VEV']['update_Description']={}\n",
    "        self.Lagrangian_Couplings['EW-VEV']['update_Description']['DependenceSPheno']=None\n",
    "        self.Lagrangian_Couplings['EW-VEV']['update_Description']['OutputName']='vvSM'\n",
    "        VWp=''\n",
    "        g2=''\n",
    "        for k in rotation.keys():\n",
    "            if list( rotation[k].values() )[0].get('Description')=='W Mixing Matrix':\n",
    "                VWp=k\n",
    "        for c in coupling.keys():\n",
    "            if coupling[c].get('Description')=='Left-Coupling':\n",
    "                g2=c\n",
    "        self.Lagrangian_Couplings['EW-VEV'\n",
    "                                 ]['update_Description'\n",
    "                                  ]['DependenceNum']=r'Sqrt[4*Mass[{}]^2/({}^2)]'.format(VWp,g2)\n",
    "\n",
    "        for k in rotation:\n",
    "            if list( rotation[k].values() )[0].get('Description')=='Photon-Z Mixing Matrix':\n",
    "                VP=k\n",
    "                ZZ=list(rotation[k].keys())[0]\n",
    "        fz=particles.apply_filter( lambda d: d.get('rotation')==ZZ )\n",
    "        VZ=fz.apply_filter(lambda d: d.get('Field')!=VP)[0]['Field']\n",
    "        self.Lagrangian_Couplings['Weinberg-Angle']={}\n",
    "        self.Lagrangian_Couplings['Weinberg-Angle']['Coupling']='ThetaW'\n",
    "        self.Lagrangian_Couplings['Weinberg-Angle']['update_Description']={}\n",
    "        self.Lagrangian_Couplings['Weinberg-Angle']['update_Description'\n",
    "             ]['DependenceNum']='ArcSin[Sqrt[1 - Mass[{}]^2/Mass[{}]^2]]'.format(\n",
    "                                                                   VWp,VZ )\n",
    "        \n",
    "    def update_modelparameters(self):\n",
    "        smdict=self.Lagrangian_Couplings\n",
    "        rotation=self.rotations\n",
    "        coupling=self.couplings\n",
    "        constants=self.constants\n",
    "        parameters=[]\n",
    "\n",
    "        parameters=append_Lagrangian_to_parameters(smdict,parameters)\n",
    "        \n",
    "        #rotation will be altered\n",
    "        rt=copy.deepcopy(rotation)\n",
    "        for k in rt.keys():\n",
    "            for r in rt[k].keys():\n",
    "                d={}\n",
    "                d['Symbol']=r\n",
    "                d['Description']=rt[k][r].get('Description')\n",
    "                d['Name']=d['Description']\n",
    "                d['Class']='Rotation'\n",
    "                kk=rt[k][r].pop('Description')\n",
    "                if rt[k][r]:\n",
    "                    d['Properties']=rt[k][r]\n",
    "                else:\n",
    "                    d['Properties']={}\n",
    "                parameters.append(d)\n",
    "        del(rt)\n",
    "        \n",
    "        for k in coupling.keys():\n",
    "            d={}\n",
    "            d['Symbol']=k\n",
    "            d['Description']=coupling[k].get('Description')\n",
    "            d['Name']=d['Description']\n",
    "            d['Class']='Coupling'\n",
    "            d['Properties']={}\n",
    "            parameters.append(d)\n",
    "            \n",
    "        for k in constants.keys():\n",
    "            d={}\n",
    "            d['Symbol']=k\n",
    "            d['Description']=constants[k].get('Description')\n",
    "            d['Name']=d['Description']\n",
    "            d['Class']='Constant'\n",
    "            d['Properties']={}\n",
    "            parameters.append(d)\n",
    "            \n",
    "        parameters=Parameters(parameters,index='Symbol')\n",
    "        self.updated_modelparameters=parameters\n",
    "        return parameters        \n",
    "\n",
    "    # Parse parameters\n",
    "    def parse_model_parameters(self):\n",
    "        #2)\n",
    "        kk=self.update_modelparticles()\n",
    "        kk=self.parse_Lagrangian()\n",
    "        kk=self.Lagrangian_Couplings_Descriptions()\n",
    "        kk=self.get_rotations()\n",
    "        kk=self.get_couplings()\n",
    "        kk=self.get_constants()\n",
    "        kk=self.update_Lagrangian()\n",
    "        kk=self.update_modelparameters()\n",
    "        return kk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "kk=self.update_modelparticles()\n",
    "kk=self.parse_Lagrangian() #Fill self.Lagrangian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'LamS': {'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
       "  'fields': ['S', 'S', 'S', 'S'],\n",
       "  'hypercharge': ['0', '0', '0', '0'],\n",
       "  'operator': 'S.S.S.S'},\n",
       " 'LamSH': {'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
       "  'fields': ['S', 'S', 'H', 'H'],\n",
       "  'hypercharge': ['0', '0', '1/2', '1/2'],\n",
       "  'operator': 'S.S.conj[H].H'},\n",
       " 'Lambda1': {'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
       "  'fields': ['H', 'H', 'H', 'H'],\n",
       "  'hypercharge': ['1/2', '1/2', '1/2', '1/2'],\n",
       "  'operator': 'conj[H].H.conj[H].H'},\n",
       " 'MS2': {'Lorentz': ['Scalar', 'Scalar'],\n",
       "  'fields': ['S', 'S'],\n",
       "  'hypercharge': ['0', '0'],\n",
       "  'operator': 'S.S'},\n",
       " 'Yd': {'Lorentz': ['Scalar', 'WeylFermion', 'WeylFermion'],\n",
       "  'fields': ['H', 'd', 'q'],\n",
       "  'hypercharge': ['1/2', '1/3', '1/6'],\n",
       "  'operator': 'conj[H].d.q'},\n",
       " 'Ye': {'Lorentz': ['Scalar', 'WeylFermion', 'WeylFermion'],\n",
       "  'fields': ['H', 'e', 'l'],\n",
       "  'hypercharge': ['1', '1/2', '1/2'],\n",
       "  'operator': 'conj[H].e.l'},\n",
       " 'Yu': {'Lorentz': ['Scalar', 'WeylFermion', 'WeylFermion'],\n",
       "  'fields': ['H', 'u', 'q'],\n",
       "  'hypercharge': ['1/2', '1/6', '2/3'],\n",
       "  'operator': 'H.u.q'},\n",
       " 'mu2': {'Lorentz': ['Scalar', 'Scalar'],\n",
       "  'fields': ['H', 'H'],\n",
       "  'hypercharge': ['1/2', '1/2'],\n",
       "  'operator': 'conj[H].H'}}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "self.Lagrangian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Down-Yukawa-Coupling': {'Lorentz': ['Scalar', 'WeylFermion', 'WeylFermion'],\n",
       "  'hypercharge': ['1/2', '1/3', '1/6'],\n",
       "  'update_Description': {}},\n",
       " 'Lepton-Yukawa-Coupling': {'Lorentz': ['Scalar',\n",
       "   'WeylFermion',\n",
       "   'WeylFermion'],\n",
       "  'hypercharge': ['1', '1/2', '1/2'],\n",
       "  'update_Description': {}},\n",
       " 'SM Higgs Selfcouplings': {'Lorentz': ['Scalar',\n",
       "   'Scalar',\n",
       "   'Scalar',\n",
       "   'Scalar'],\n",
       "  'hypercharge': ['1/2', '1/2', '1/2', '1/2'],\n",
       "  'update_Description': {}},\n",
       " 'SM Mu Parameter': {'Lorentz': ['Scalar', 'Scalar'],\n",
       "  'hypercharge': ['1/2', '1/2'],\n",
       "  'update_Description': {'OutputName': 'm2SM'}},\n",
       " 'Up-Yukawa-Coupling': {'Lorentz': ['WeylFermion', 'WeylFermion', 'Scalar'],\n",
       "  'hypercharge': ['1/2', '1/6', '2/3'],\n",
       "  'update_Description': {}}}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "self.Lagrangian_Couplings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Down-Yukawa-Coupling': {'Lorentz': ['Scalar', 'WeylFermion', 'WeylFermion'],\n",
       "  'hypercharge': ['1/2', '1/3', '1/6'],\n",
       "  'update_Description': {}},\n",
       " 'Lepton-Yukawa-Coupling': {'Lorentz': ['Scalar',\n",
       "   'WeylFermion',\n",
       "   'WeylFermion'],\n",
       "  'hypercharge': ['1', '1/2', '1/2'],\n",
       "  'update_Description': {}},\n",
       " 'SM Higgs Selfcouplings': {'Lorentz': ['Scalar',\n",
       "   'Scalar',\n",
       "   'Scalar',\n",
       "   'Scalar'],\n",
       "  'hypercharge': ['1/2', '1/2', '1/2', '1/2'],\n",
       "  'update_Description': {}},\n",
       " 'SM Mu Parameter': {'Lorentz': ['Scalar', 'Scalar'],\n",
       "  'hypercharge': ['1/2', '1/2'],\n",
       "  'update_Description': {'OutputName': 'm2SM'}},\n",
       " 'Up-Yukawa-Coupling': {'Lorentz': ['WeylFermion', 'WeylFermion', 'Scalar'],\n",
       "  'hypercharge': ['1/2', '1/6', '2/3'],\n",
       "  'update_Description': {}}}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "self.Lagrangian_Couplings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4M4OBLMBMaMF"
   },
   "outputs": [],
   "source": [
    "if PARAMETERS:\n",
    "    us=update_SARAH_parameters(model='SSDM')\n",
    "    #us=update_SARAH_parameters(model='SM')\n",
    "    #kk=us.parse_model_particles()\n",
    "    #kk=us.update_modelparticles()\n",
    "    kk=us.parse_model_parameters()\n",
    "    self=us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RDzdTC2yMaMK"
   },
   "outputs": [],
   "source": [
    "if PARAMETERS:\n",
    "    self.parse_Lagrangian() #Fill self.Lagrangian\n",
    "    self.Lagrangian_Couplings_Descriptions() # Fill self.Lagrangian_Couplings\n",
    "    self.get_rotations() #Fill self.rotations\n",
    "    self.get_couplings() #Fill self.couplings\n",
    "    self.get_constants() #Fill self.couplings \n",
    "    self.update_Lagrangian() #Convert some rotations, copuplings, constants to Lagrangian_Couplings\n",
    "    self.update_modelparameters() # Fill self.updated_modelparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "w57-I0TsMaMo"
   },
   "source": [
    "## SPheno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0tlLYWqiMaMp"
   },
   "outputs": [],
   "source": [
    "class update_SARAH(update_SARAH_parameters):\n",
    "    def __init__(self,*args, **kwargs):\n",
    "        self.SPheno={'Properties':{\n",
    "         'OnlyLowEnergySPheno' : True,\n",
    "         'AddTreeLevelUnitarityLimits':True,\n",
    "        'MINPAR':[],\n",
    "        'ParametersToSolveTadpoles':[],\n",
    "        'BoundaryLowScaleInput':[],\n",
    "        'ListDecayParticles':[],\n",
    "        'ListDecayParticles3B': [],\n",
    "        'RenConditionsDecays':[\n",
    "               ['dCosTW', '1/2*Cos[ThetaW] * (PiVWp/(MVWp^2) - PiVZ/(mVZ^2))'],\n",
    "               ['dSinTW', '-dCosTW/Tan[ThetaW]'],\n",
    "               ['dg2', '1/2*g2*(derPiVPheavy0 + PiVPlightMZ/MVZ^2 - (-(PiVWp/MVWp^2) + PiVZ/MVZ^2)/Tan[ThetaW]^2 + (2*PiVZVP*Tan[ThetaW])/MVZ^2)'],\n",
    "               ['dg1', 'dg2*Tan[ThetaW]+g2*dSinTW/Cos[ThetaW]- dCosTW*g2*Tan[ThetaW]/Cos[ThetaW]']\n",
    "             ],\n",
    "        'DEFINITION': {'MatchingConditions':\n",
    "                 []},\n",
    "        'DefaultInputValues' :{}\n",
    "           },\n",
    "        'Index':{'OnlyLowEnergySPheno':0,'MINPAR':1, 'ParametersToSolveTadpoles':2, \n",
    "                'BoundaryLowScaleInput':3, 'DEFINITION':4, 'ListDecayParticles':5, \n",
    "                'ListDecayParticles3B':6, 'DefaultInputValues':7, \n",
    "                'AddTreeLevelUnitarityLimits':8, 'RenConditionsDecays':9}   \n",
    "        }\n",
    "        super().__init__(*args,**kwargs)\n",
    "    \n",
    "    def update_SPheno(self):\n",
    "        parameters=self.updated_modelparameters\n",
    "        sci=extract_Lagrangian_terms(parameters,\n",
    "                                     Lagrangian_dimension=4,\n",
    "                                     Lorentz_structures=1).get('Symbol')\n",
    "\n",
    "        sciIN=get_input_parameters_IN(sci,suffix='IN')\n",
    "\n",
    "        self.SPheno['Properties'\n",
    "                   ]['BoundaryLowScaleInput']=get_BoundaryLowScaleInput(sci,sciIN)\n",
    "\n",
    "        self.SPheno['Properties'\n",
    "                   ]['MINPAR']=get_MINPAR(sciIN)\n",
    "\n",
    "        self.SPheno['Properties'\n",
    "                   ]['ParametersToSolveTadpoles'\n",
    "                    ]=get_tadpoles_and_bilinears(parameters,exclude=[])[0]\n",
    "\n",
    "        self.SPheno['Properties'][\n",
    "            'DEFINITION']['MatchingConditions']=get_SM_MatchingConditions(parameters)\n",
    "\n",
    "        DP,DP3B=get_decay_particles(DecayParticles   = ['Fu', 'Fe', 'Fd', 'hh'],\n",
    "                            DecayParticles3B = ['Fu', 'Fe', 'Fd'])\n",
    "        self.SPheno['Properties'\n",
    "                   ]['ListDecayParticles']=DP\n",
    "        self.SPheno['Properties'\n",
    "                   ]['ListDecayParticles3B']=DP3B\n",
    "\n",
    "        self.SPheno['Properties'][\n",
    "            'DefaultInputValues'].update( \n",
    "                             get_sm_DefaultInputValues(parameters,sci,sciIN) )\n",
    "        return self.SPheno\n",
    "    \n",
    "    def update_SARAH_full(self):\n",
    "        kk=self.parse_model_parameters()\n",
    "        kk=self.update_SPheno()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "k-kfnLy9MaMu"
   },
   "outputs": [],
   "source": [
    "if SPHENO:\n",
    "    us=update_SARAH(model='SSDM')\n",
    "    kk=us.update_SARAH_full()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aE9QDlBuMaM1"
   },
   "outputs": [],
   "source": [
    "if SPHENO:\n",
    "    pd.DataFrame(us.SPheno)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z_bChk8sMaM6"
   },
   "source": [
    "# Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QqkOUdgvMaM7"
   },
   "outputs": [],
   "source": [
    "class SARAH_output(update_SARAH):\n",
    "    def __init__(self,*args, **kwargs):\n",
    "        self.output_dir=kwargs.get('output_dir')\n",
    "        self.PARSE=False\n",
    "        super().__init__(*args,**kwargs)\n",
    "\n",
    "    def check_output_dir(self):\n",
    "        if not self.output_dir:\n",
    "            self.output_dir='{}{}'.format(\n",
    "                                self.model_dir,\n",
    "                                self.model_name\n",
    "                                        ).strip()\n",
    "\n",
    "        if not re.search('\\/$',self.output_dir):\n",
    "            self.output_dir='{}/'.format(self.output_dir)\n",
    "\n",
    "        if not os.path.exists(self.output_dir):\n",
    "            os.mkdir( self.output_dir )\n",
    "            \n",
    "    def parse_SARAH_full():\n",
    "        self.PARSE=True\n",
    "        kk=self.update_SARAH_full()\n",
    "\n",
    "\n",
    "    def to_math(self,particles_name ='particles.m',\n",
    "                     parameters_name='parameters.m',\n",
    "                     SPheno_name    ='SPheno.m'):\n",
    "        if not self.PARSE:\n",
    "            kk=self.parse_SARAH_full()\n",
    "        kk=self.check_output_dir()\n",
    "        # Prepare output files\n",
    "        dirpath='{}{}'.format(self.output_dir,self.model_name)\n",
    "        if not re.search('\\/$',dirpath):\n",
    "            dirpath='{}/'.format(dirpath)\n",
    "        if not os.path.isdir(dirpath):\n",
    "            os.mkdir(dirpath)\n",
    "        model_path     ='{}{}'.format(dirpath,self.model_file_name)\n",
    "        particles_path ='{}{}'.format(dirpath,particles_name)\n",
    "        parameters_path='{}{}'.format(dirpath,parameters_name)\n",
    "        SPheno_path    ='{}{}'.format(dirpath,SPheno_name)\n",
    "\n",
    "        #write output files\n",
    "        WRITE=True\n",
    "        if os.path.isfile(model_path):\n",
    "            CHKW=input('File {} exists.Overwrite? (y/n)'.format(\n",
    "                                  model_path ))\n",
    "            if re.search('^\\s*[nN][oOtT]{0,2}',CHKW):\n",
    "                WRITE=False\n",
    "        if WRITE:\n",
    "            f=open(model_path,'w')\n",
    "            f.write(self.model_file)\n",
    "            f.close()\n",
    "            \n",
    "        PDF=to_defintions(self.updated_modelparticles,symbol='Field')\n",
    "        dfnp=pd.DataFrame(PDF)\n",
    "        kk=to_math(dfnp,particles_path)\n",
    "        PDF=to_defintions(self.updated_modelparameters,symbol='Symbol')\n",
    "        dfnp=pd.DataFrame(PDF)\n",
    "        kk=to_math(dfnp,parameters_path,definitions='ParameterDefinitions')\n",
    "        SP=pd.DataFrame(self.SPheno)\n",
    "        kk=to_SPheno(SP,SPheno_path,dictentries=['DefaultInputValues'])        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ISg1_i51MaNB"
   },
   "outputs": [],
   "source": [
    "if OUTPUT:\n",
    "    us=SARAH_output(model='SSDM',output_dir='tmp')\n",
    "    kk=us.to_math()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hJloMgjUMaNF"
   },
   "outputs": [],
   "source": [
    "def get_inert_scalars(p,particles,\n",
    "                                      pids={'PDG':[6666635],\n",
    "                                           'PDG.IX':[101000002],\n",
    "                                           'FeynArtsNr':[10]\n",
    "                                           }):\n",
    "    #INERT scalars\n",
    "    kk=particles.loc[p.get('Parents')]\n",
    "    #singlet real scalar\n",
    "    if kk.get('Properties'\n",
    "        ) and get_abs_groups( kk.get('Properties').get('Groups')[0],\n",
    "                               u1_abs='0',su2='1',su3_abs='1'):\n",
    "        p['Definition']='EWSB'\n",
    "        p['Description']='Singlet Inert Scalar'\n",
    "        #TODO: Get from fullparticlesnames.json\n",
    "        if not p.get('Properties'):\n",
    "            p['Properties']={}\n",
    "        p['Properties']['update_Description']= {'PDG' : [pids.get('PDG')[0]],\n",
    "                                  'PDG.IX' : [pids.get('PDG.IX')[0]],\n",
    "                                  'FeynArtsNr' : pids.get('FeynArtsNr')[0],\n",
    "                                  'Mass': 'LesHouches',               \n",
    "                                  'LaTeX' : 'S',\n",
    "                                  'ElectricCharge' : 0,\n",
    "                                  'LHPC' : ['gold'],\n",
    "                                  'OutputName' : 'Ss'\n",
    "                                 }\n",
    "        return p\n",
    "    \n",
    "class bsm(SARAH_output):\n",
    "    def __init__(self,*args, **kwargs):\n",
    "        self.output_dir=kwargs.get('output_dir')\n",
    "        self.Lagrangian_Couplings_Singlet_Scalar={\n",
    "            'Scalar Singlet: Squared Mass': {\n",
    "            'Description':'Scalar Singlet Mass',\n",
    "              'Lorentz': ['Scalar', 'Scalar'],\n",
    "              'hypercharge': ['0', '0'],\n",
    "              'update_Description': {\n",
    "                  'Real':True,\n",
    "                  'Dependence': None, \n",
    "                  'Value':None, \n",
    "                  'LesHouches':['HDM',1]\n",
    "              }},\n",
    "            'Scalar Singlet: Selfcoupling': {\n",
    "              'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
    "              'hypercharge': ['0', '0', '0', '0'],\n",
    "              'update_Description': {\n",
    "                  'LesHouches':['HDM',3]\n",
    "                  }},\n",
    "            'Scalar Singlet - Higgs: quartic couplings': {\n",
    "              'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
    "              'hypercharge': ['0', '0', '1/2', '1/2'],\n",
    "              'update_Description': {\n",
    "                  'LesHouches':['HDM',2]\n",
    "              }}\n",
    "        }\n",
    "        super().__init__(*args,**kwargs)\n",
    "\n",
    "    def Lagrangian_Couplings_Descriptions_Singlet_Scalar(self):\n",
    "        \"\"\"\n",
    "        Strategy:\n",
    "        From sorted quality extract the symbol ->`k` for the coupling Definition (smdict below):\n",
    "              'Coupling':'Symbol'\n",
    "        Get Higgs -> H From the SM part\n",
    "        From  some selfcoupling extract the BSM Field: Scalar Singlet -> S\n",
    "        If Description include the semicolon separation, define the several Fields\n",
    "          Example: 'Scalar Singlet - Higgs: quartic couplings'.split(':')[0].split('-')...strip\n",
    "                         S             H\n",
    "               Add -> 'Scalar Singlet':'S', 'Higgs': 'H'\n",
    "        \"\"\"    \n",
    "        dd=self.Lagrangian\n",
    "        smdict=self.Lagrangian_Couplings_Singlet_Scalar\n",
    "        #First loop to identify the particles from the Squared Mass couplings\n",
    "        for ds in smdict.keys():\n",
    "            for k in dd.keys():\n",
    "                if smdict[ds].get('Lorentz'\n",
    "                 ) and (sorted_equality( smdict[ds]['Lorentz'],dd[k]['Lorentz'] ) and\n",
    "                        sorted_equality( smdict[ds]['hypercharge'],dd[k]['hypercharge'] ) ):\n",
    "                    ll=[l.strip() for l in ds.split(':')]\n",
    "                    prtcls=[l.strip() for l in ll[0].split('-')]\n",
    "                    if len(ll)>1:\n",
    "                        cplng=ll[1]\n",
    "                    if cplng=='Squared Mass':\n",
    "                        self.Scalar_Multiplets[prtcls[0]]=dd[k].get('fields')[0]\n",
    "\n",
    "        for ds in smdict.keys():            \n",
    "            for k in dd.keys():\n",
    "                if smdict[ds].get('Lorentz'\n",
    "                 ) and (sorted_equality( smdict[ds]['Lorentz'],dd[k]['Lorentz'] ) and\n",
    "                        sorted_equality( smdict[ds]['hypercharge'],dd[k]['hypercharge'] ) ):\n",
    "                    kk=k\n",
    "                    if re.search('^Lam[^bda]',k):\n",
    "                        kk=k.replace('Lam','lambda:')\n",
    "                    smdict[ds]['Coupling']=k\n",
    "                    # Get Lagrangian data\n",
    "                    for q in dd[k]:\n",
    "                        smdict[ds][q]=dd[k][q]\n",
    "                    #Include particle names\n",
    "                    for p in self.Scalar_Multiplets:\n",
    "                        if p in prtcls:\n",
    "                            smdict[ds][p]=self.Scalar_Multiplets[p]\n",
    "                    # Add 'OutputName' and 'LaTeX'\n",
    "                    if smdict[ds].get('update_Description'):\n",
    "                        smdict[ds]['update_Description'][\n",
    "                            'OutputName']=symbol_to_OutputName(k)\n",
    "                        smdict[ds]['update_Description'][\n",
    "                            'LaTeX']=symbol_to_TeX(kk)\n",
    "\n",
    "        self.Lagrangian_Couplings_Singlet_Scalar=smdict\n",
    "        return self.Lagrangian_Couplings_Singlet_Scalar\n",
    "        \n",
    "    def parse_bsm(self):\n",
    "        self.PARSE=True\n",
    "        kk=self.update_SARAH_full()\n",
    "        #New particle properties\n",
    "        kk=self.update_particles(get_inert_scalars,Definition='GaugeES',\n",
    "                                    Lorentz='Scalar',\n",
    "                                    args=(self.modelparticles,\n",
    "                                          {'PDG':[6666635],\n",
    "                                           'PDG.IX':[101000002],\n",
    "                                           'FeynArtsNr':[10]\n",
    "                                          }\n",
    "                                     ))\n",
    "        kk=self.Lagrangian_Couplings_Descriptions_Singlet_Scalar()\n",
    "        parameters=[]\n",
    "        parameters=append_Lagrangian_to_parameters(\n",
    "            self.Lagrangian_Couplings_Singlet_Scalar,parameters)\n",
    "        self.updated_modelparameters=Parameters(self.updated_modelparameters+parameters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JAoM4I-ZMaNP"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File tmp/SSDM/SSDM.m exists.Overwrite? (y/n)y\n"
     ]
    }
   ],
   "source": [
    "if BSM:\n",
    "    us=bsm(model='SSDM',output_dir='tmp')\n",
    "    kk=us.parse_bsm()\n",
    "    self=us\n",
    "    kk=us.to_math()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tIEBsB21MaNV"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'Class': 'Lagrangian',\n",
       "  'Description': 'Weinberg-Angle',\n",
       "  'Name': 'Weinberg-Angle',\n",
       "  'Properties': {'Coupling': 'ThetaW',\n",
       "   'update_Description': {'DependenceNum': 'ArcSin[Sqrt[1 - Mass[VWp]^2/Mass[VZ]^2]]'}},\n",
       "  'Symbol': 'ThetaW'},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'Lepton-Yukawa-Coupling',\n",
       "  'Lorentz_type': 2,\n",
       "  'Name': 'Lepton-Yukawa-Coupling',\n",
       "  'Properties': {'Coupling': 'Ye',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['Scalar', 'WeylFermion', 'WeylFermion'],\n",
       "   'fields': ['H', 'e', 'l'],\n",
       "   'hypercharge': ['1', '1/2', '1/2'],\n",
       "   'update_Description': {'DependenceNum': 'Sqrt[2]/v* {{Mass[Fe,1],0,0 },\\n                {0, Mass[Fe,2],0},\\n                {0, 0, Mass[Fe,3]}}'}},\n",
       "  'Symbol': 'Ye',\n",
       "  'dimL': 3},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'EW-VEV',\n",
       "  'Name': 'EW-VEV',\n",
       "  'Properties': {'Coupling': 'v',\n",
       "   'update_Description': {'DependenceNum': 'Sqrt[4*Mass[VWp]^2/(g2^2)]',\n",
       "    'DependenceSPheno': None,\n",
       "    'OutputName': 'vvSM'}},\n",
       "  'Symbol': 'v'},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'SM Higgs Selfcouplings',\n",
       "  'Lorentz_type': 1,\n",
       "  'Name': 'SM Higgs Selfcouplings',\n",
       "  'Properties': {'Coupling': 'Lambda1',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
       "   'fields': ['H', 'H', 'H', 'H'],\n",
       "   'hypercharge': ['1/2', '1/2', '1/2', '1/2'],\n",
       "   'update_Description': {'DependenceNum': 'Mass[hh]^2/(v^2)',\n",
       "    'LaTeX': '\\\\\\\\Lambda_1',\n",
       "    'OutputName': 'Lamb1'}},\n",
       "  'Symbol': 'Lambda1',\n",
       "  'dimL': 4},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'Down-Yukawa-Coupling',\n",
       "  'Lorentz_type': 2,\n",
       "  'Name': 'Down-Yukawa-Coupling',\n",
       "  'Properties': {'Coupling': 'Yd',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['Scalar', 'WeylFermion', 'WeylFermion'],\n",
       "   'fields': ['H', 'd', 'q'],\n",
       "   'hypercharge': ['1/2', '1/3', '1/6'],\n",
       "   'update_Description': {'DependenceNum': 'Sqrt[2]/v* {{Mass[Fd,1],0,0 },\\n                {0, Mass[Fd,2],0},\\n                {0, 0, Mass[Fd,3]}}'}},\n",
       "  'Symbol': 'Yd',\n",
       "  'dimL': 3},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'Up-Yukawa-Coupling',\n",
       "  'Lorentz_type': 2,\n",
       "  'Name': 'Up-Yukawa-Coupling',\n",
       "  'Properties': {'Coupling': 'Yu',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['WeylFermion', 'WeylFermion', 'Scalar'],\n",
       "   'fields': ['H', 'u', 'q'],\n",
       "   'hypercharge': ['1/2', '1/6', '2/3'],\n",
       "   'update_Description': {'DependenceNum': 'Sqrt[2]/v* {{Mass[Fu,1],0,0 },\\n                {0, Mass[Fu,2],0},\\n                {0, 0, Mass[Fu,3]}}'}},\n",
       "  'Symbol': 'Yu',\n",
       "  'dimL': 3},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'SM Mu Parameter',\n",
       "  'Lorentz_type': 1,\n",
       "  'Name': 'SM Mu Parameter',\n",
       "  'Properties': {'Coupling': 'mu2',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['Scalar', 'Scalar'],\n",
       "   'fields': ['H', 'H'],\n",
       "   'hypercharge': ['1/2', '1/2'],\n",
       "   'update_Description': {'LaTeX': '\\\\\\\\mu^2', 'OutputName': 'mu2'}},\n",
       "  'Symbol': 'mu2',\n",
       "  'dimL': 2},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'Right-Down-Mixing-Matrix',\n",
       "  'Name': 'Right-Down-Mixing-Matrix',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'Ud'},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'Right-Up-Mixing-Matrix',\n",
       "  'Name': 'Right-Up-Mixing-Matrix',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'Uu'},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'Left-Up-Mixing-Matrix',\n",
       "  'Name': 'Left-Up-Mixing-Matrix',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'Vu'},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'Right-Lepton-Mixing-Matrix',\n",
       "  'Name': 'Right-Lepton-Mixing-Matrix',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'Ue'},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'Left-Lepton-Mixing-Matrix',\n",
       "  'Name': 'Left-Lepton-Mixing-Matrix',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'Ve'},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'Photon-Z Mixing Matrix',\n",
       "  'Name': 'Photon-Z Mixing Matrix',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'ZZ'},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'W Mixing Matrix',\n",
       "  'Name': 'W Mixing Matrix',\n",
       "  'Properties': {'update_Description': {'Dependence': '1/Sqrt[2] {{1, 1},\\n                                      {\\\\[ImaginaryI],-\\\\[ImaginaryI]}}'}},\n",
       "  'Symbol': 'ZW'},\n",
       " {'Class': 'Rotation',\n",
       "  'Description': 'Left-Down-Mixing-Matrix',\n",
       "  'Name': 'Left-Down-Mixing-Matrix',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'Vd'},\n",
       " {'Class': 'Coupling',\n",
       "  'Description': 'Hypercharge-Coupling',\n",
       "  'Name': 'Hypercharge-Coupling',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'g1'},\n",
       " {'Class': 'Coupling',\n",
       "  'Description': 'Left-Coupling',\n",
       "  'Name': 'Left-Coupling',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'g2'},\n",
       " {'Class': 'Coupling',\n",
       "  'Description': 'Strong-Coupling',\n",
       "  'Name': 'Strong-Coupling',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'g3'},\n",
       " {'Class': 'Constant',\n",
       "  'Description': 'electric charge',\n",
       "  'Name': 'electric charge',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'e'},\n",
       " {'Class': 'Constant',\n",
       "  'Description': \"Fermi's constant\",\n",
       "  'Name': \"Fermi's constant\",\n",
       "  'Properties': {},\n",
       "  'Symbol': 'Gf'},\n",
       " {'Class': 'Constant',\n",
       "  'Description': 'inverse weak coupling constant at mZ',\n",
       "  'Name': 'inverse weak coupling constant at mZ',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'aEWinv'},\n",
       " {'Class': 'Constant',\n",
       "  'Description': 'Alpha Strong',\n",
       "  'Name': 'Alpha Strong',\n",
       "  'Properties': {},\n",
       "  'Symbol': 'AlphaS'},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'Scalar Singlet: Selfcoupling',\n",
       "  'Name': 'Scalar Singlet: Selfcoupling',\n",
       "  'Properties': {'Coupling': 'LamS',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
       "   'Scalar Singlet': 'S',\n",
       "   'fields': ['S', 'S', 'S', 'S'],\n",
       "   'hypercharge': ['0', '0', '0', '0'],\n",
       "   'operator': 'S.S.S.S',\n",
       "   'update_Description': {'LaTeX': '\\\\\\\\lambda_S',\n",
       "    'LesHouches': ['HDM', 3],\n",
       "    'OutputName': 'LamS'}},\n",
       "  'Symbol': 'LamS'},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'Scalar Singlet: Squared Mass',\n",
       "  'Name': 'Scalar Singlet: Squared Mass',\n",
       "  'Properties': {'Coupling': 'MS2',\n",
       "   'Description': 'Scalar Singlet Mass',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['Scalar', 'Scalar'],\n",
       "   'Scalar Singlet': 'S',\n",
       "   'fields': ['S', 'S'],\n",
       "   'hypercharge': ['0', '0'],\n",
       "   'operator': 'S.S',\n",
       "   'update_Description': {'Dependence': None,\n",
       "    'LaTeX': 'M_S^2',\n",
       "    'LesHouches': ['HDM', 1],\n",
       "    'OutputName': 'MS2',\n",
       "    'Real': True,\n",
       "    'Value': None}},\n",
       "  'Symbol': 'MS2'},\n",
       " {'Class': 'Lagrangian',\n",
       "  'Description': 'Scalar Singlet - Higgs: quartic couplings',\n",
       "  'Name': 'Scalar Singlet - Higgs: quartic couplings',\n",
       "  'Properties': {'Coupling': 'LamSH',\n",
       "   'Higgs': 'H',\n",
       "   'Lorentz': ['Scalar', 'Scalar', 'Scalar', 'Scalar'],\n",
       "   'Scalar Singlet': 'S',\n",
       "   'fields': ['S', 'S', 'H', 'H'],\n",
       "   'hypercharge': ['0', '0', '1/2', '1/2'],\n",
       "   'operator': 'S.S.conj[H].H',\n",
       "   'update_Description': {'LaTeX': '\\\\\\\\lambda_{SH}',\n",
       "    'LesHouches': ['HDM', 2],\n",
       "    'OutputName': 'LamSH'}},\n",
       "  'Symbol': 'LamSH'}]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "self.updated_modelparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YjcPYa7LMaNg"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'Definition': 'EWSB',\n",
       "  'Description': 'Singlet Inert Scalar',\n",
       "  'Field': 'ss',\n",
       "  'Parents': 'S',\n",
       "  'Properties': {'Lorentz': 'Scalar',\n",
       "   'NF': '1',\n",
       "   'update_Description': {'ElectricCharge': 0,\n",
       "    'FeynArtsNr': 10,\n",
       "    'LHPC': ['gold'],\n",
       "    'LaTeX': 'S',\n",
       "    'Mass': 'LesHouches',\n",
       "    'OutputName': 'Ss',\n",
       "    'PDG': [6666635],\n",
       "    'PDG.IX': [101000002]}}}]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "self.updated_modelparticles.loc['ss']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CsveGwi2MaNl"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'Block': 'VEVs',\n",
       "  'Definition': 'EWSB',\n",
       "  'Description': 'Higgs',\n",
       "  'Field': 'hh',\n",
       "  'Parents': 'H0',\n",
       "  'Properties': {'CP': 'Real',\n",
       "   'Coefficient': '1/Sqrt[2]',\n",
       "   'Lorentz': 'Scalar',\n",
       "   'update_Description': {'PDG': [25], 'PDG.IX': [101000001]},\n",
       "   'vev': 'v'}}]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "self.updated_modelparticles.loc['hh']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4LlQcBU7MaNy"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "SARAH.ipynb",
   "provenance": []
  },
  "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.5.3"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}