effBPIX1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%javascript\n",
    "IPython.OutputArea.prototype._should_scroll = function(lines) {\n",
    "    return false;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "uname -a\n",
    "whoami\n",
    "\n",
    "edmFileUtil root://eoscms.cern.ch///store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/C0D83139-4A6E-E711-B1A9-02163E0137FC.root\n",
    "edmFileUtil root://eoscms.cern.ch///store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/4269D74E-4A6E-E711-847B-02163E01A487.root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import math\n",
    "import time\n",
    "from multiprocessing import Pool\n",
    "from DataFormats.FWLite import Handle, Events"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xrd = 'root://cms-xrd-global.cern.ch//'\n",
    "tier0 = 'root://cms-xrd-tzero.cern.ch//' # 'file:/eos/cms/tier0'\n",
    "tier2 = 'root://eoscms.cern.ch//' #'file:/eos/cms'\n",
    "myTracking = 'root://eoscms.cern.ch///store/group/phys_tracking/vincenzo/run2017/'\n",
    "\n",
    "def run300742() :\n",
    "    files = [\\\n",
    "    'file:/data/data/vin/run2017/DoubleMuon_aod300742.root'\\\n",
    "              ]\n",
    "    return files\n",
    "\n",
    "               \n",
    "def mc() :\n",
    "    files = [\\\n",
    "    '/store/relval/CMSSW_9_3_0_pre2/RelValTTbar_13/GEN-SIM-RECO/PU25ns_92X_upgrade2017_realistic_v7-v1/00000/4C90EDAC-3169-E711-94DA-0CC47A7452D0.root',\\\n",
    "            ]\n",
    "    return map(lambda x : xrd+x,files)\n",
    "\n",
    "\n",
    "def oldStuff() :\n",
    "    files = [\\\n",
    "    '/store/data/Run2016H/JetHT/AOD/PromptReco-v2/000/283/408/00000/AE49FDAB-8398-E611-9B98-02163E014388.root',\\\n",
    "    '/store/data/Run2016H/JetHT/AOD/PromptReco-v2/000/283/408/00000/88FB6BA5-7B98-E611-B25E-FA163EE1CC08.root',\\\n",
    "    '/store/data/Run2017B/SingleMuon/AOD/PromptReco-v2/000/299/061/00000/5C4984B0-B86A-E711-837F-02163E01A792.root',\n",
    "    '/store/data/Run2017B/SingleMuon/AOD/PromptReco-v2/000/299/067/00000/B4146406-F66A-E711-B9C9-02163E014389.root',\\\n",
    "            ]\n",
    "    return map(lambda x : xrd+x,files)\n",
    "\n",
    "\n",
    "def jetHT2017C() :\n",
    "    files = [\\\n",
    "    '/store/data/Run2017C/JetHT/AOD/PromptReco-v1/000/299/443/00000/7C92F761-A270-E711-90A8-02163E014506.root',\\\n",
    "    '/store/data/Run2017C/JetHT/AOD/PromptReco-v1/000/299/649/00000/D0BA6C4A-DB71-E711-99BC-02163E013910.root',\\\n",
    "    '/store/data/Run2017C/JetHT/AOD/PromptReco-v1/000/299/592/00000/44735821-ED70-E711-A9F3-02163E019C7D.root',\\\n",
    "    '/store/data/Run2017C/JetHT/AOD/PromptReco-v1/000/299/478/00000/7C39B1F9-A970-E711-AC40-02163E0138D5.root',\\\n",
    "    '/store/data/Run2017C/JetHT/AOD/PromptReco-v1/000/299/480/00000/9276CDF3-B870-E711-9878-02163E019D8F.root',\\\n",
    "    #'/store/data/Run2017C/JetHT/AOD/PromptReco-v1/000/299/478/00000/E2BB4D9E-A870-E711-8684-02163E0142DF.root',\\\n",
    "    #'/store/data/Run2017C/JetHT/AOD/PromptReco-v1/000/299/420/00000/5EC981C1-426E-E711-9C05-02163E0135F2.root',\\\n",
    "            ]\n",
    "    return map(lambda x : tier0+x,files)\n",
    "    \n",
    "def express2017C() :\n",
    "    files = [\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/592/00000/1482C818-456E-E711-A4AC-02163E01A3E1.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/4CA2B934-716E-E711-B4F0-02163E01A3E5.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/523D4165-4A6E-E711-B186-02163E012A87.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/C0D83139-4A6E-E711-B1A9-02163E0137FC.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/C6AE7442-4A6E-E711-864C-02163E019D7E.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/4269D74E-4A6E-E711-847B-02163E01A487.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/2449BE69-4A6E-E711-BCD5-02163E0128FE.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/593/00000/9C51DE1E-4A6E-E711-9701-02163E019E83.root',\\\n",
    "    '/store/express/Run2017C/ExpressPhysics/FEVT/Express-v1/000/299/649/00000/28D1AE00-2170-E711-96CA-02163E019D3B.root'\\\n",
    "    ]\n",
    "    return map(lambda x : tier2+x,files)\n",
    "\n",
    "def myFiles() :\n",
    "    files = [\\\n",
    "             'JetHT_reco299592.root',\\\n",
    "             'JetHT_tkreco299592.root',\\\n",
    "             ]\n",
    "    return map(lambda x : myTracking+x,files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "label = \"generalTracks\"\n",
    "quality = \"highPurity\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def runid(event,lumi) :\n",
    "    id = event.object().id()\n",
    "    a=event.getByLabel('scalersRawToDigi', lumi)\n",
    "    return '{:d}:{:d}:{:.2e}'.format(int(id.run()),int(id.luminosityBlock()),\\\n",
    "                                     lumi.product()[0].instantLumi() if not lumi.product().empty() else 0)\n",
    "def skip2Lumi(events,ls):\n",
    "    for i in range(0,events.size()):\n",
    "        a= events.to(i)\n",
    "        id = events.object().id()\n",
    "        if (int(id.luminosityBlock())==ls) : return i\n",
    "    return events.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loadTk(events,tracks,vertices, fe) :\n",
    "    tkParsA = []\n",
    "    tkHitsA = []\n",
    "    for i in range(fe,events.size()):\n",
    "      if (len(tkParsA) > 1000000) : break\n",
    "      a= events.to(i)\n",
    "      if (i%1000==0) : \n",
    "        id = events.object().id()\n",
    "        evid = '{:d}:{:d}:{:d}'.format(int(id.run()),int(id.luminosityBlock()), int(id.event()))\n",
    "        print \"Event\", i , evid\n",
    "      a=events.getByLabel(label, tracks)\n",
    "      a=events.getByLabel(\"offlinePrimaryVertices\",vertices)\n",
    "      pv = vertices.product()[0]\n",
    "      if (not pv.isValid()) : continue\n",
    "      pvp = pv.position()\n",
    "      for tk in tracks.product() :\n",
    "        if (not tk.quality(tk.qualityByName(quality))) : continue\n",
    "        if (tk.pt()<0.7) : continue\n",
    "        if (abs(tk.dz(pvp))>0.5) : continue # only PV tracks\n",
    "        pattern = tk.hitPattern()\n",
    "        if (pattern.numberOfValidHits()<8) : continue\n",
    "        if (pattern.numberOfValidPixelHits()<1) : continue\n",
    "        tkParsA.append([tk.eta(),tk.phi(),tk.pt(),\\\n",
    "                        tk.dxy(pvp),tk.dxyError(), tk.dz(pvp), tk.dzError(),\\\n",
    "                        pattern.numberOfValidHits(),pattern.numberOfValidPixelHits(),tk.ndof(),tk.chi2(),tk.originalAlgo()-4])\n",
    "        tkHitsA.append([pattern.getTrackerLayerCase(0,1,1), pattern.getTrackerLayerCase(1,1,1),\\\n",
    "                        pattern.getTrackerLayerCase(0,1,2), pattern.getTrackerLayerCase(1,1,2),\\\n",
    "                        pattern.getTrackerLayerCase(0,2,1), pattern.getTrackerLayerCase(1,2,1)])\n",
    "\n",
    "    print len(tkParsA)\n",
    "    tkPars = np.array(zip(*tkParsA), dtype=np.float)\n",
    "    print len(tkPars)\n",
    "    tkHits = np.array(zip(*tkHitsA), np.int32)\n",
    "    print len(tkHits)\n",
    "    return tkPars,tkHits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def loadFile(name) :\n",
    "    loaded = np.load('/tmp/'+name+'.npz')\n",
    "    runid = loaded['arr_0']\n",
    "    n = len(runid)\n",
    "    tkPars = [loaded['arr_'+str(i+1)] for i in range(0,n)]\n",
    "    tkHits = [loaded['arr_'+str(i+1+n)] for i in range(0,n)]\n",
    "    return runid,tkPars,tkHits\n",
    "def saveFile(name,runid,tkPars,tkHits) :\n",
    "    np.savez_compressed('/tmp/'+name,runid,*(tkPars+tkHits))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def processIt(fevents) :\n",
    "    print fevents\n",
    "    events = Events(fevents)\n",
    "    tracks = Handle(\"std::vector<reco::Track>\")\n",
    "    lumi = Handle(\"std::vector<LumiScalers>\")\n",
    "    vertices = Handle(\"vector<reco::Vertex>\")\n",
    "    a= events.to(0)\n",
    "    ls = int(events.object().id().luminosityBlock())\n",
    "    if (ls==103) : ls=105\n",
    "    fe = skip2Lumi(events,ls)\n",
    "    a= events.to(fe)\n",
    "    runid0 = runid(events,lumi)\n",
    "    print runid0\n",
    "    tkPars, tkHits = loadTk(events,tracks,vertices,fe)\n",
    "    runidl = runid(events,lumi)\n",
    "    print runidl\n",
    "    return (runid0+'-->'+runidl, tkPars, tkHits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readAOD() :\n",
    "    p = Pool(4)\n",
    "    files = run300742() # jetHT2017C() + mc() # jetHT2017C() # express2017C() # myFiles() # oldStuff() #\n",
    "    t = -time.time()\n",
    "    ret = p.map(processIt,files)\n",
    "    t +=time.time()\n",
    "    print t\n",
    "    runid0, tkPars, tkHits = zip(*ret)\n",
    "    print runid0\n",
    "    print len(tkHits)\n",
    "    p.terminate()\n",
    "    return runid0, tkPars, tkHits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = -time.time()\n",
    "fromAOD = True\n",
    "runid0, tkPars, tkHits = readAOD() if fromAOD else loadFile('run300742')\n",
    "t +=time.time()\n",
    "print 'time to read', t\n",
    "print len(tkHits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = -time.time()\n",
    "if fromAOD :\n",
    "    saveFile('run300742',runid0, tkPars, tkHits)\n",
    "t += time.time()\n",
    "print 'time to write',t\n",
    "print len(tkHits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "ls -l /tmp/*.npz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#loaded = np.load('/tmp/bha.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#dict(loaded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def corr(tkPars) :\n",
    "    print len(tkPars)\n",
    "    print np.corrcoef(tkPars)\n",
    "#map(corr,tkPars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eff(var,tkPars,tkHits) :\n",
    "    hp = np.greater(tkPars[2],4.0)\n",
    "    pv = np.less(abs(tkPars[5]),0.1) # &np.less(abs(tkPars[3]),0.01)\n",
    "    valL2 = np.equal(tkHits[2],0)\n",
    "    valF1 = np.equal(tkHits[4],0)\n",
    "    hp = hp&(valL2)&pv # |valF1)\n",
    "    nbins = 62\n",
    "    yv,x = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp*np.equal(tkHits[0],0)) \n",
    "    yl,x = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp*np.equal(tkHits[0],1)) \n",
    "    #yi,x = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp*np.equal(tkHits[0],2)) \n",
    "    ym,x = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp*np.equal(tkHits[1],1)) \n",
    "    ya=yv+ym # +yl\n",
    "    # y2,x = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp)\n",
    "    x.resize(len(yv))\n",
    "    return x,yv/ya"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import norm\n",
    "import numpy.ma as ma\n",
    "def sip(var,tkPars,tkHits) :\n",
    "    off = math.pi - math.pi/24.\n",
    "    io = (6.*(tkPars[1]+off)/math.pi).astype(int)\n",
    "    io = io%2\n",
    "    hp = np.greater(tkPars[2],4.0)  # &np.equal(io,0)\n",
    "    pvz = np.less(abs(tkPars[5]),0.1)\n",
    "    pvt = np.less(abs(tkPars[3]),0.05)\n",
    "    valL1 = np.equal(tkHits[0],0)\n",
    "    valL2 = np.equal(tkHits[2],0)\n",
    "    valF1 = np.equal(tkHits[4],0)\n",
    "    hp1 = hp&(valL1)\n",
    "    hp2 = hp&((valL2) & np.logical_not(valL1))\n",
    "    \n",
    "    core = np.less(abs(tkPars[3]/tkPars[4]),2.5)&np.less(abs(tkPars[5]/tkPars[6]),2.5)\n",
    "    \n",
    "    nbins = 62\n",
    "    ye1,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=tkPars[4]*hp1*pvz)\n",
    "    ye2,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=tkPars[4]*hp2*pvz)\n",
    "    ya1,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp1*pvz)\n",
    "    ya2,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp2*pvz)\n",
    "\n",
    "    yv1,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=tkPars[3]*hp1*pvz*core)\n",
    "    yv2,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=tkPars[3]*hp2*pvz*core)\n",
    "    yb1,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp1*pvz*core)\n",
    "    yb2,vx = np.histogram(tkPars[var],np.linspace(-3.1,3.1,nbins),weights=1.*hp2*pvz*core)\n",
    "\n",
    "\n",
    "    \n",
    "    vx.resize(len(ye2))\n",
    "\n",
    "\n",
    "    nbins = 100\n",
    "    yt1,x = np.histogram(tkPars[3]/tkPars[4],np.linspace(-10.,10.,nbins),weights=1.*hp1*pvz,density=True)\n",
    "    masked = ma.masked_where(~(hp1&pvz),ma.masked_outside(tkPars[3]/tkPars[4],-2.5,2.5))\n",
    "    print 'dxy with L1',norm.fit(masked[~masked.mask])\n",
    "    yz1,x = np.histogram(tkPars[5]/tkPars[6],np.linspace(-10.,10.,nbins),weights=1.*hp1*pvt,density=True) \n",
    "    yt2,x = np.histogram(tkPars[3]/tkPars[4],np.linspace(-10.,10.,nbins),weights=1.*hp2*pvz,density=True) \n",
    "    masked = ma.masked_where(~(hp2&pvz),ma.masked_outside(tkPars[3]/tkPars[4],-2.5,2.5))\n",
    "    print 'dxy w/o L1', norm.fit(masked[~masked.mask])\n",
    "    yz2,x = np.histogram(tkPars[5]/tkPars[6],np.linspace(-10.,10.,nbins),weights=1.*hp2*pvt,density=True)\n",
    "    x.resize(len(yt1))\n",
    "    return x,yt1,yz1,yt2,yz2,vx,ye1/ya1,ye2/ya2,yv1/yb1,yv2,yb2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eta=0\n",
    "phi=1\n",
    "pt=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "effH = map(eff,[phi]*len(tkPars),tkPars, tkHits)\n",
    "print len(effH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sipH = map(sip,[eta]*len(tkPars),tkPars, tkHits)\n",
    "print len(sipH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.optimize import leastsq\n",
    "fitfunc  = lambda p, x: p[0]*np.exp(-0.5*((x-p[1])/p[2])**2) # +p[3]\n",
    "errfunc  = lambda p, x, y: (y - fitfunc(p, x))  #   /np.sqrt(np.clip(y,a_min=0.00001,a_max=None))\n",
    "init  = [0.5, 0.0, 1.0] # , 0.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "for b in sipH:\n",
    "    plt.step(b[5],b[6],where='post',label=runid0[i]+'   dxyErr with L1')\n",
    "    plt.step(b[5],b[7],where='post',label=runid0[i]+'   dxyErr w/o L1')\n",
    "    plt.xlim(-3.1, 3.1)\n",
    "    plt.ylim(0.001, 0.006)\n",
    "    plt.grid(True)\n",
    "    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "#    plt.legend(loc='upper right')\n",
    "    plt.show()\n",
    "\n",
    "    plt.step(b[5],b[8],where='post',label=runid0[i]+'   dxy with L1')\n",
    "    plt.step(b[5],b[9],where='post',label=runid0[i]+'   dxy w/o L1')\n",
    "    plt.xlim(-3.1, 3.1)\n",
    "    #plt.ylim(0.001, 0.006)\n",
    "    plt.grid(True)\n",
    "    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "#    plt.legend(loc='upper right')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "    \n",
    "    \n",
    "    plt.step(b[0],b[1],where='post',label=runid0[i]+'   dxy with L1')\n",
    "    out   = leastsq( errfunc, init, args=(b[0][30:70], b[1][30:70]))\n",
    "    c = out[0]\n",
    "    print c\n",
    "    plt.plot(b[0], fitfunc(c, b[0]))\n",
    "    plt.step(b[0],b[3],where='post',label=runid0[i]+'   dxy w/o L1')\n",
    "    out   = leastsq( errfunc, init, args=(b[0][30:70], b[3][30:70]))\n",
    "    c = out[0]\n",
    "    print c\n",
    "    plt.plot(b[0], fitfunc(c, b[0]))\n",
    "    plt.xlim(-10., 10.)\n",
    "    plt.grid(True)\n",
    "    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "#    plt.legend(loc='upper right')\n",
    "    plt.xlabel('dxy/err')\n",
    "#    i+=1\n",
    "    plt.show()\n",
    "\n",
    "    plt.step(b[0],b[2],where='post',label=runid0[i]+'   dz with L1')\n",
    "    out   = leastsq( errfunc, init, args=(b[0][30:70], b[2][30:70]))\n",
    "    c = out[0]\n",
    "    print c\n",
    "    plt.plot(b[0], fitfunc(c, b[0]))\n",
    "    plt.step(b[0],b[4],where='post',label=runid0[i]+'   dz w/o L1')\n",
    "    out   = leastsq( errfunc, init, args=(b[0][30:70], b[4][30:70]))\n",
    "    c = out[0]\n",
    "    print c\n",
    "    plt.xlim(-10., 10.)\n",
    "    plt.grid(True)\n",
    "    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "#    plt.legend(loc='upper right')\n",
    "    plt.xlabel('dz/err')\n",
    "    i+=1\n",
    "        plt.show()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "for b in effH:\n",
    "    plt.step(b[0],b[1],where='post',label=runid0[i])\n",
    "    plt.xlim(-3.1, 3.1)\n",
    "    plt.ylim(0.5, 1.1)\n",
    "    plt.grid(True)\n",
    "#    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n",
    "    plt.legend(loc='upper right')\n",
    "    plt.ylabel('eff')\n",
    "    i+=1\n",
    "    plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}