{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.integrate\n",
    "import numpy\n",
    "import matplotlib.pyplot\n",
    "import os\n",
    "import json\n",
    "import scipy.interpolate\n",
    "\n",
    "def dfdy(y,t,system):\n",
    "    dfdy=system.M.dot(y)+system.u(t)\n",
    "    return dfdy\n",
    "\n",
    "def jacobi(y,t,system):\n",
    "    return system.M\n",
    "\n",
    "#SE post calculation\n",
    "def dfdyS(S,t,system):\n",
    "    #unwrap S to NxM where M is number of parameters\n",
    "    mS=numpy.reshape(S,(system.n,system.m))\n",
    "    mOut=system.M.dot(mS)+system.fS(t)\n",
    "    return numpy.ravel(mOut)\n",
    "\n",
    "def jacobiSE(S,t,system):\n",
    "    N=system.n*(system.m)\n",
    "    fJ=numpy.zeros((N,N))\n",
    "    #print('fJ shape {}'.format(fJ.shape))\n",
    "    for i in range(system.m):\n",
    "        fJ[i*system.n:(i+1)*system.n,i*system.n:(i+1)*system.n]=system.M\n",
    "    return fJ\n",
    "\n",
    "#SE simultaeneous calculation\n",
    "def dfdySFull(S,t,system):\n",
    "    #unwrap S to NxM where M is number of parameters\n",
    "    mS=numpy.reshape(S,(system.n,system.m+1))\n",
    "    #system.fS(y,t) is NxM matrix where M are parameters\n",
    "    y=mS[:,0]\n",
    "    mOut=system.M.dot(mS)+system.fSY(y,t)\n",
    "    return numpy.ravel(mOut)\n",
    "\n",
    "def jacobiSEFull(S,t,system):\n",
    "    N=system.n*(system.m+1)\n",
    "    fJ=numpy.zeros((N,N))\n",
    "    #print('fJ shape {}'.format(fJ.shape))\n",
    "    for i in range(system.m+1):\n",
    "        fJ[i*system.n:(i+1)*system.n,i*system.n:(i+1)*system.n]=system.M\n",
    "    return fJ\n",
    "\n",
    "class model:\n",
    "    def __init__(self):\n",
    "        self.compartments={}\n",
    "        self.seJ={}\n",
    "        \n",
    "    def add_source(self,compartmentName,formula):\n",
    "        self.compartments[compartmentName]['source']=formula\n",
    "\n",
    "    def add_compartment(self,compartmentName):\n",
    "        self.compartments[compartmentName]={}\n",
    "        self.compartments[compartmentName]['targets']={}\n",
    "        self.compartments[compartmentName]['sensTargets']={}\n",
    "\n",
    "    def bind(self,sourceCompartment,targetCompartment,k,scaleToVolume=0):\n",
    "        #establish a flow from one compartment to the other\n",
    "        cSrc=self.compartments[sourceCompartment]\n",
    "        cTarg=self.compartments[targetCompartment]\n",
    "        vS=1\n",
    "        vT=1\n",
    "        if scaleToVolume:\n",
    "            vS=self.mod[\"volumes\"][sourceCompartment]\n",
    "            vT=self.mod[\"volumes\"][targetCompartment]\n",
    "        \n",
    "        #the source equation (where we subtract the current)\n",
    "        addValue(cSrc['targets'],sourceCompartment,-k/vS)\n",
    "        #the target equation (where we add the current)\n",
    "        addValue(cTarg['targets'],sourceCompartment,k/vT)\n",
    "                    \n",
    "    def getDerivative(self,variable, source, target, q, pc, useVolume):\n",
    "        v=1\n",
    "        if useVolume:\n",
    "            v=self.mod[\"volumes\"][target]\n",
    "        #the target equation (where we add the current)\n",
    "        sign=1\n",
    "        #the source equation (where we subtract the current)\n",
    "        if source==target:\n",
    "            sign=-1\n",
    "            \n",
    "        #for flow based transfer, k=Q/vS/pc, and jacobian derivative is -Q/V/pc/pc\n",
    "        #for diffusion dominated transfer, k=k1/pc\n",
    "        if variable==\"partitionCoefficient\":\n",
    "            return sign*(-1)*q/v/pc/pc\n",
    "        if variable==\"diffusionCoefficient\":\n",
    "            return sign/pc/v\n",
    "        if variable==\"flow\":\n",
    "            return sign/pc/v\n",
    "        if variable==\"volume\":\n",
    "            return sign*(-1)*q/pc/v/v\n",
    "            \n",
    "    def bindDerivative(self,parameterName,variable,src,target,q,pc,useVolume=1):\n",
    "        parName=parameterName\n",
    "        if variable==\"volume\":\n",
    "            parName='{}_V'.format(src)\n",
    "        #the source equation (where we subtract the current)\n",
    "        csrc=self.getSEJ_comp(parName,src)\n",
    "        addValue(csrc,src,self.getDerivative(variable,src,src,q,pc,useVolume))\n",
    "        \n",
    "        if variable==\"volume\":\n",
    "            parName='{}_V'.format(target)\n",
    "        #the target equation (where we add the current)\n",
    "        ctarget=self.getSEJ_comp(parName,target)\n",
    "        addValue(ctarget,src,self.getDerivative(variable,src,target,q,pc,useVolume))\n",
    "        \n",
    "        \n",
    "        \n",
    "    def build(self):\n",
    "        comps=self.compartments\n",
    "        self.n=len(comps)\n",
    "        self.M=numpy.zeros((self.n,self.n))\n",
    "        self.fu=[lambda t:0]*self.n\n",
    "        self.lut={c:i for (i,c) in zip(range(self.n),comps.keys())}\n",
    "        for c in comps:\n",
    "            comp=comps[c]\n",
    "            if 'source' in comp:\n",
    "                self.fu[self.lut[c]]=parseFunction(comp['source'])\n",
    "                               \n",
    "            for t in comp['targets']:\n",
    "                self.M[self.lut[c],self.lut[t]]=comp['targets'][t]\n",
    "        #build SE part\n",
    "        self.m=len(self.seJ)\n",
    "        #MxNxN matrix\n",
    "        self.lutSE={c:i for (i,c) in zip(range(self.m),self.seJ.keys())}\n",
    "        self.fSS=numpy.zeros((self.m,self.n,self.n))\n",
    "        for par in self.seJ:\n",
    "            sources=self.seJ[par]\n",
    "            for compartment in sources:\n",
    "                targets=sources[compartment]\n",
    "                for t in targets:\n",
    "                    #print('FSS: Adding {}/{},{}/{},{}/{}:{}'.\\\n",
    "                    #      format(par,self.lutSE[par],compartment,self.lut[compartment],t,self.lut[t],targets[t]))\n",
    "                    self.fSS[self.lutSE[par],self.lut[compartment],self.lut[t]]=targets[t]\n",
    "        \n",
    "                      \n",
    "        \n",
    "        #print('Done')\n",
    "    \n",
    "    def inspect(self):\n",
    "        comps=self.compartments\n",
    "        print('Compartments')\n",
    "        for c in comps:\n",
    "            print('{}/{}:'.format(c,self.lut[c]))\n",
    "            comp=comps[c]\n",
    "            if 'source' in comp:\n",
    "                print('\\tsource\\n\\t\\t{}'.format(comp['source']))\n",
    "            print('\\ttargets')\n",
    "            for t in comp['targets']:\n",
    "                print('\\t\\t{}[{},{}]: {}'.format(t,self.lut[c],self.lut[t],comp['targets'][t]))\n",
    "        print('Flows')\n",
    "        for f in self.flows:\n",
    "            print('\\t{}:{}'.format(f,self.flows[f]))\n",
    "        print('SE parameters')\n",
    "        for p in self.seJ:\n",
    "            print(p)\n",
    "            sources=self.seJ[p]\n",
    "            for compartment in sources:\n",
    "                targets=sources[compartment]\n",
    "                for t in targets:\n",
    "                    print('\\t SE bind {}/{}:{}'.format(compartment,t,targets[t]))\n",
    "        #print('Done')\n",
    "    \n",
    "    def parse(self,file):\n",
    "                    \n",
    "        with open(file,'r') as f:\n",
    "            self.mod=json.load(f)\n",
    "        for m in self.mod['compartments']:\n",
    "            self.add_compartment(m)\n",
    "        for s in self.mod['sources']:\n",
    "            #src=mod['sources'][s]\n",
    "            self.add_source(s,self.mod['sources'][s])\n",
    "        self.flows={}\n",
    "        for f in self.mod['flows']:\n",
    "            if f.find(':')<0:\n",
    "                continue\n",
    "            comps=f.split(':')\n",
    "            c0=splitVector(comps[0])\n",
    "            c1=splitVector(comps[1])\n",
    "            for x in c0:\n",
    "                for y in c1:\n",
    "                    pairName='{}:{}'.format(x,y)\n",
    "                    self.flows[pairName]=f\n",
    "                    \n",
    "        parsSE=self.mod['sensitivityCalculation']['parameters']\n",
    "        for b in self.mod['bindings']['diffusion']:\n",
    "            comps=b.split('->')\n",
    "            try:\n",
    "                pc=self.mod['partitionCoefficients'][b][\"value\"]\n",
    "            except KeyError:\n",
    "                pc=1\n",
    "            k1=self.mod['bindings']['diffusion'][b]\n",
    "            self.bind(comps[0],comps[1],k1/pc)\n",
    "            if \"diffusions\" in parsSE:\n",
    "                self.bindDerivative(b,\"diffusionParameter\",comps[0],comps[1],k1,pc,0)\n",
    "            if \"partitionCoefficients\" in parsSE:\n",
    "                if b in self.mod['partitionCoefficients']:\n",
    "                    parName='{}:PC'.format(b)\n",
    "                    self.bindDerivative(parName,\"partitionCoefficient\",comps[0],comps[1],k1,pc,0)\n",
    "            \n",
    "        for q in self.mod['bindings']['flow']:\n",
    "            comps=q.split('->')\n",
    "            srcs=splitVector(comps[0])\n",
    "            tgts=splitVector(comps[1])\n",
    "            for cs in srcs:\n",
    "                for ct in tgts:\n",
    "                    try:\n",
    "                        pc=self.mod['partitionCoefficients'][cs]\n",
    "                    except KeyError:\n",
    "                        pc=1\n",
    "                    try:\n",
    "                        qName=self.flows['{}:{}'.format(cs,ct)]\n",
    "                    except KeyError:\n",
    "                        qName=self.flows['{}:{}'.format(ct,cs)]\n",
    "                    #convert to seconds\n",
    "                    q=self.mod['flows'][qName]\n",
    "                    try:\n",
    "                        if self.mod['flows']['unit'].split('/')[1]=='min':\n",
    "                            q/=60\n",
    "                    except KeyError:\n",
    "                        pass\n",
    "                    self.bind(cs,ct,q/pc,1)\n",
    "                    if \"partitionCoefficients\" in parsSE:\n",
    "                        if cs in self.mod['partitionCoefficients']:\n",
    "                             #associate parameter name in sensitivity table\n",
    "                             parName=cs+'PC'\n",
    "                             self.bindDerivative(parName,\"partitionCoefficient\",cs,ct,q,pc)\n",
    "                    if \"flows\" in parsSE:\n",
    "                        self.bindDerivative(qName,\"flow\",cs,ct,q,pc)\n",
    "                    if \"volumes\" in parsSE:\n",
    "                        self.bindDerivative(\"x\",\"volume\",cs,ct,q,pc)\n",
    "                         \n",
    "                    #print('bind: {}:(q={},vt={},pc={}):{}'.format(bind,q,vt,pc,q/vt/pc))\n",
    "                \n",
    "        self.build()\n",
    "        \n",
    "    def u(self,t):\n",
    "        ub=[f(t) for f in self.fu]\n",
    "        return numpy.array(ub)\n",
    "                     \n",
    "    def fSY(self,y,t):\n",
    "        #M number of sensitivity parameters\n",
    "        #N number of equations\n",
    "        #fSS is MxNxN\n",
    "        \n",
    "        #assume a tabulated solution y(t) at t spaced intervals\n",
    "        \n",
    "        qS=self.fSS.dot(y)\n",
    "        #qS is MxN\n",
    "        #but NxM is expected, so do a transpose\n",
    "        \n",
    "        #for simultaneous calculation, a Nx(M+1) matrix is expected\n",
    "        tS=numpy.zeros((self.n,self.m+1))\n",
    "        #columns from 2..M+1 are the partial derivatives \n",
    "        tS[:,1:]=numpy.transpose(qS)\n",
    "        #first column is the original function\n",
    "        tS[:,0]=self.u(t)\n",
    "        return tS\n",
    "    \n",
    "    def fS(self,t):\n",
    "        #M number of sensitivity parameters\n",
    "        #N number of equations\n",
    "        #fSS is MxNxN\n",
    "        \n",
    "        #assume a tabulated solution y(t) at t spaced intervals\n",
    "        \n",
    "        qS=self.fSS.dot(self.getY(t))\n",
    "        return numpy.transpose(qS)\n",
    "                     \n",
    "    def getSEJ(self,parName):\n",
    "        #find the sensitivity (SE) derivative of Jacobi with respect to parameter  \n",
    "        try:\n",
    "            return self.seJ[parName]\n",
    "        except KeyError:\n",
    "            self.seJ[parName]={}\n",
    "            return self.seJ[parName]\n",
    "    \n",
    "    def getSEJ_comp(self,parName,compartmentName):\n",
    "        #find equation dictating concentration in compartmentName for jacobi-parameter derivative\n",
    "        seJ=self.getSEJ(parName)\n",
    "        \n",
    "        try:\n",
    "            return seJ[compartmentName]\n",
    "        except KeyError:\n",
    "            seJ[compartmentName]={}\n",
    "            return seJ[compartmentName]\n",
    "    def setY(self,t,y):\n",
    "        self.tck=[None]*self.n\n",
    "        for i in range(self.n):\n",
    "            self.tck[i] = scipy.interpolate.splrep(t, y[:,i], s=0)\n",
    "    \n",
    "    def getY(self,t):\n",
    "        fY=numpy.zeros(self.n)\n",
    "        for i in range(self.n):\n",
    "            fY[i]=scipy.interpolate.splev(t, self.tck[i], der=0)\n",
    "        return fY\n",
    "        \n",
    "def splitVector(v):\n",
    "    if v.find('(')<0:\n",
    "        return [v]\n",
    "    return v[1:-1].split(',')\n",
    "\n",
    "def parseFunction(formula):\n",
    "    if formula['name']=='exponential':\n",
    "        c0=formula['constant']\n",
    "        k=formula['k']\n",
    "        return lambda t:c0*numpy.exp(k*t)\n",
    "    if formula['name']=='constant':\n",
    "        c0=formula['value']\n",
    "        return lambda t:c0\n",
    "    if formula['name']=='Heavyside':\n",
    "        t0=formula['limit']\n",
    "        v=formula['value']\n",
    "        return lambda t:v if t<t0 else 0\n",
    "    return lambda t:1\n",
    "\n",
    "def addValue(qdict,compName,v):\n",
    "    #add real number v to attribute compName of dictionary qdict, check if compName exists and handle the potential error\n",
    "    try:\n",
    "        qdict[compName]+=v\n",
    "    except KeyError:\n",
    "        qdict[compName]=v\n",
    "\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done simultaneous SE\n"
     ]
    }
   ],
   "source": [
    "sys=model()\n",
    "fh=os.path.expanduser('~')\n",
    "#sys.parse(os.path.join(fh,'software','src','Integra','models','cDiazepam.json'))\n",
    "sys.parse(os.path.join(fh,'software','src','Integra','models','cCotinine.json'))\n",
    "#print(sys.u(10)[sys.lut['venous']])\n",
    "#sys.inspect()         \n",
    "nt=1001\n",
    "t = numpy.linspace(0, 4*3600, nt)\n",
    "#first column is the solution y\n",
    "#initial condition\n",
    "y0=numpy.zeros(sys.n)\n",
    "    \n",
    "doSequential=0\n",
    "\n",
    "if doSequential:\n",
    "#sequential SE (first true solution, then parameter derivatives)\n",
    "    y0=numpy.zeros(sys.n)\n",
    "    sol = scipy.integrate.odeint(dfdy, y0, t, args=(sys,),Dfun=jacobi)\n",
    "    sys.setY(t,sol)\n",
    "    S0=numpy.zeros((sys.n,sys.m))\n",
    "    S0=S0.ravel()\n",
    "    #print('lut {}'.format(sys.lut))\n",
    "    #print('lutSE {}'.format(sys.lutSE))\n",
    "    #fJ=sys.fSS[sys.lutSE['brainPC']]\n",
    "    #print('X shape {}\\n {}'.format(fJ.shape,fJ))\n",
    "    solSE=scipy.integrate.odeint(dfdyS, S0, t, args=(sys,),Dfun=jacobiSE)\n",
    "    s1=numpy.reshape(solSE,(len(t),sys.n,sys.m))\n",
    "    print('Done sequential SE')\n",
    "    \n",
    "\n",
    "else:\n",
    "#simultaneous SE\n",
    "    S1=numpy.zeros((sys.n,sys.m+1))\n",
    "    #set initial condition\n",
    "    S1[:,0]=y0\n",
    "    S1=S1.ravel()\n",
    "    solSE1=scipy.integrate.odeint(dfdySFull, S1, t, args=(sys,),Dfun=jacobiSEFull)\n",
    "    sFull=numpy.reshape(solSE1,(len(t),sys.n,sys.m+1))\n",
    "    s1=sFull[:,:,1:]\n",
    "    sol=sFull[:,:,0]\n",
    "    print('Done simultaneous SE')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1800 with 15 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#copy output of Thompson et al\n",
    "fig, axs = matplotlib.pyplot.subplots(5, 3,figsize=(15,25))\n",
    "name=['arterial','adipose','brain','heart','kidney','liver','lung','muscle','skin',\n",
    "      'splanchnic','stomach','testes']\n",
    "#diazepam\n",
    "max=[1.5,2.6,3,4,5,2.5,6.8,1.5,1.5,4,4.2,3]\n",
    "#cotinine\n",
    "max=[9]*12\n",
    "\n",
    "max=[1000*x for x in max]\n",
    "for i in range(len(name)):\n",
    "    row=i//3\n",
    "    col=i%3\n",
    "    axs[row,col].plot(t/60,sol[:,sys.lut[name[i]]])\n",
    "    axs[row,col].plot(t/60,s1[:,sys.lut[name[i]],0])\n",
    "    axs[row,col].set_title(name[i])\n",
    "    axs[row,col].set_ylim([0,max[i]])\n",
    "    axs[row,col].set_xlim([0,250])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 422/(9.1/0.15)/60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.interpolate\n",
    "x = numpy.arange(0, 2*numpy.pi+numpy.pi/4, 2*numpy.pi/8)\n",
    "Y=numpy.zeros((len(x),2))\n",
    "Y[:,0] = numpy.sin(x)\n",
    "Y[:,1] = numpy.sin(x)\n",
    "\n",
    "tck = scipy.interpolate.splrep(x, Y[:,0], s=0)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3. 2.]\n",
      " [2. 4.]\n",
      " [2. 6.]]\n",
      "[[3. 2.]\n",
      " [2. 4.]\n",
      " [2. 6.]]\n"
     ]
    }
   ],
   "source": [
    "M=numpy.ones((3,2,2))\n",
    "M[0,0,1]=2\n",
    "M[1,1,0]=3\n",
    "M[2,1,1]=5\n",
    "v=numpy.ones(2)\n",
    "q=M.dot(v)\n",
    "q1=q.ravel()\n",
    "q2=numpy.reshape(q1,q.shape)\n",
    "print(q)\n",
    "print(q2)"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}