diff --git a/RecoPixelVertexing/PixelTriplets/plugins/gpuPixelDoublets.h b/RecoPixelVertexing/PixelTriplets/plugins/gpuPixelDoublets.h index b17ed42cfb390..e46627bf2c322 100644 --- a/RecoPixelVertexing/PixelTriplets/plugins/gpuPixelDoublets.h +++ b/RecoPixelVertexing/PixelTriplets/plugins/gpuPixelDoublets.h @@ -20,11 +20,11 @@ namespace gpuPixelDoublets { template __device__ - void doubletsFromHisto(uint8_t const * layerPairs, uint32_t nPairs, GPUCACell * cells, uint32_t * nCells, - int16_t const * iphi, Hist const * hist, uint32_t const * offsets, - siPixelRecHitsHeterogeneousProduct::HitsOnGPU const & hh, + void doubletsFromHisto(uint8_t const * __restrict__ layerPairs, uint32_t nPairs, GPUCACell * cells, uint32_t * nCells, + int16_t const * __restrict__ iphi, Hist const * __restrict__ hist, uint32_t const * __restrict__ offsets, + siPixelRecHitsHeterogeneousProduct::HitsOnGPU const & __restrict__ hh, GPU::VecArray< unsigned int, 256> * isOuterHitOfCell, - int16_t const * phicuts, float const * minz, float const * maxz, float const * maxr) { + int16_t const * phicuts, float const * minz, float const * maxz, float const * maxr) { auto layerSize = [=](uint8_t li) { return offsets[li+1]-offsets[li]; }; @@ -41,7 +41,6 @@ namespace gpuPixelDoublets { auto idx = blockIdx.x*blockDim.x + threadIdx.x; for(auto j=idx;j=innerLayerCumulativeSize[pairLayerId++]); --pairLayerId; // move to lower_bound ?? @@ -68,18 +67,28 @@ namespace gpuPixelDoublets { auto mep = iphi[i]; auto mez = hh.zg_d[i]; auto mer = hh.rg_d[i]; - auto cutoff = [&](int j) { return + auto cutoff = [&](int j) { return abs(hh.zg_d[j]-mez) > maxz[pairLayerId] || abs(hh.zg_d[j]-mez) < minz[pairLayerId] || hh.rg_d[j]-mer > maxr[pairLayerId]; }; constexpr float z0cut = 12.f; + constexpr float hardPtCut = 0.5f; + constexpr float minRadius = hardPtCut * 87.f; + constexpr float minRadius2T4 = 4.f*minRadius*minRadius; + auto ptcut = [&](int j) { + auto r2t4 = minRadius2T4; + auto ri = mer; + auto ro = hh.rg_d[j]; + auto dphi = short2phi( min( abs(int16_t(mep-iphi[j])),abs(int16_t(iphi[j]-mep)) ) ); + return dphi*dphi*(r2t4 -ri*ro) > (ro-ri)*(ro-ri); + }; auto z0cutoff = [&](int j) { auto zo = hh.zg_d[j]; - auto ro = hh.rg_d[j]; + auto ro = hh.rg_d[j]; auto dr = ro-mer; - return dr > maxr[pairLayerId] || + return dr > maxr[pairLayerId] || dr<0 || std::abs((mez*ro - mer*zo)) > z0cut*dr; }; @@ -92,7 +101,7 @@ namespace gpuPixelDoublets { int nmin = 0; auto khh = kh; incr(khh); - + int tooMany=0; for (auto kk=kl; kk!=khh; incr(kk)) { if (kk!=kl && kk!=kh) nmin+=hist[outer].size(kk); @@ -103,7 +112,7 @@ namespace gpuPixelDoublets { if (std::min(std::abs(int16_t(iphi[oi]-mep)), std::abs(int16_t(mep-iphi[oi]))) > iphicut) continue; - if (z0cutoff(oi)) continue; + if (z0cutoff(oi) || ptcut(oi)) continue; auto ind = atomicInc(nCells,MaxNumOfDoublets); // int layerPairId, int doubletId, int innerHitId,int outerHitId) cells[ind].init(hh,pairLayerId,ind,i,oi); @@ -123,12 +132,13 @@ namespace gpuPixelDoublets { } // loop in block... } + __global__ - void getDoubletsFromHisto(GPUCACell * cells, uint32_t * nCells, siPixelRecHitsHeterogeneousProduct::HitsOnGPU const * hhp, + void getDoubletsFromHisto(GPUCACell * cells, uint32_t * nCells, siPixelRecHitsHeterogeneousProduct::HitsOnGPU const * __restrict__ hhp, GPU::VecArray< unsigned int, 256> *isOuterHitOfCell) { - uint8_t const layerPairs[2*13] = {0,1 ,1,2 ,2,3 - // ,0,4 ,1,4 ,2,4 ,4,5 ,5,6 + uint8_t const layerPairs[2*13] = {0,1 ,1,2 ,2,3 + // ,0,4 ,1,4 ,2,4 ,4,5 ,5,6 ,0,7 ,1,7 ,2,7 ,7,8 ,8,9 ,0,4 ,1,4 ,2,4 ,4,5 ,5,6 }; @@ -158,8 +168,8 @@ namespace gpuPixelDoublets { }; - auto const & hh = *hhp; - doubletsFromHisto(layerPairs, 13, cells, nCells, + auto const & __restrict__ hh = *hhp; + doubletsFromHisto(layerPairs, 13, cells, nCells, hh.iphi_d,hh.hist_d,hh.hitsLayerStart_d, hh, isOuterHitOfCell, phicuts, minz, maxz, maxr); diff --git a/RecoPixelVertexing/PixelTriplets/test/BuildFile.xml b/RecoPixelVertexing/PixelTriplets/test/BuildFile.xml index 54d7eaccd1760..1de3629887ec9 100644 --- a/RecoPixelVertexing/PixelTriplets/test/BuildFile.xml +++ b/RecoPixelVertexing/PixelTriplets/test/BuildFile.xml @@ -18,4 +18,6 @@ - \ No newline at end of file + + + diff --git a/RecoPixelVertexing/PixelTriplets/test/fastDPHI_t.cpp b/RecoPixelVertexing/PixelTriplets/test/fastDPHI_t.cpp new file mode 100644 index 0000000000000..58c7f832627fb --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/test/fastDPHI_t.cpp @@ -0,0 +1,197 @@ +// this test documents the derivation of the fast deltaphi used in gpu doublet code.. +// +// +// +#include +#include +#include +#include + +/** +| 1) circle is parameterized as: | +| C*[(X-Xp)**2+(Y-Yp)**2] - 2*alpha*(X-Xp) - 2*beta*(Y-Yp) = 0 | +| Xp,Yp is a point on the track (Yp is at the center of the chamber); | +| C = 1/r0 is the curvature ( sign of C is charge of particle ); | +| alpha & beta are the direction cosines of the radial vector at Xp,Yp | +| i.e. alpha = C*(X0-Xp), | +| beta = C*(Y0-Yp), | +| where center of circle is at X0,Y0. | +| Alpha > 0 | +| Slope dy/dx of tangent at Xp,Yp is -alpha/beta. | +| 2) the z dimension of the helix is parameterized by gamma = dZ/dSperp | +| this is also the tangent of the pitch angle of the helix. | +| with this parameterization, (alpha,beta,gamma) rotate like a vector. | +| 3) For tracks going inward at (Xp,Yp), C, alpha, beta, and gamma change sign| +| +*/ + +template +class FastCircle { + +public: + + FastCircle(){} + FastCircle(T x1, T y1, + T x2, T y2, + T x3, T y3) { + compute(x1,y1,x2,y2,x3,y3); + } + + void compute(T x1, T y1, + T x2, T y2, + T x3, T y3); + + + T m_xp; + T m_yp; + T m_c; + T m_alpha; + T m_beta; + +}; + + +template +void FastCircle::compute(T x1, T y1, + T x2, T y2, + T x3, T y3) { + bool flip = std::abs(x3-x1) > std::abs(y3-y1); + + auto x1p = x1-x2; + auto y1p = y1-y2; + auto d12 = x1p*x1p + y1p*y1p; + auto x3p = x3-x2; + auto y3p = y3-y2; + auto d32 = x3p*x3p + y3p*y3p; + + if (flip) { + std::swap(x1p,y1p); + std::swap(x3p,y3p); + } + + auto num = x1p*y3p-y1p*x3p; // num also gives correct sign for CT + auto det = d12*y3p-d32*y1p; + if( std::abs(det)==0 ) { + // and why we flip???? + } + auto ct = num/det; + auto sn = det>0 ? T(1.) : T(-1.); + auto st2 = (d12*x3p-d32*x1p)/det; + auto seq = T(1.) +st2*st2; + auto al2 = sn/std::sqrt(seq); + auto be2 = -st2*al2; + ct *= T(2.)*al2; + + if (flip) { + std::swap(x1p,y1p); + std::swap(al2,be2); + al2 = -al2; + be2 = -be2; + ct = -ct; + } + + m_xp = x1; + m_yp = y1; + m_c= ct; + m_alpha = al2 - ct*x1p; + m_beta = be2 - ct*y1p; + +} + + + +// compute curvature given two points (and origin) +float fastDPHI(float ri, float ro, float dphi) { + + /* + x3=0 y1=0 x1=0; + y3=ro + */ + + // auto x2 = ri*dphi; + // auto y2 = ri*(1.f-0.5f*dphi*dphi); + + + /* + auto x1p = x1-x2; + auto y1p = y1-y2; + auto d12 = x1p*x1p + y1p*y1p; + auto x3p = x3-x2; + auto y3p = y3-y2; + auto d32 = x3p*x3p + y3p*y3p; + */ + + /* + auto x1p = -x2; + auto y1p = -y2; + auto d12 = ri*ri; + auto x3p = -x2; + auto y3p = ro-y2; + auto d32 = ri*ri + ro*ro - 2.f*ro*y2; + */ + + + // auto rat = (ro -2.f*y2); + // auto det = ro - ri - (ro - 2.f*ri -0.5f*ro)*dphi*dphi; + + //auto det2 = (ro-ri)*(ro-ri) -2.*(ro-ri)*(ro - 2.f*ri -0.5f*ro)*dphi*dphi; + // auto seq = det2 + dphi*dphi*(ro-2.f*ri)*(ro-2.f*ri); // *rat2; + // auto seq = (ro-ri)*(ro-ri) + dphi*dphi*ri*ro; + + // and little by little simplifing and removing higher over terms + // we get + auto r2 = (ro-ri)*(ro-ri)/(dphi*dphi) + ri*ro; + + + // d2 = (ro-ri)*(ro-ri)/(4.f*r2 -ri*ro); + // return -2.f*dphi/std::sqrt(seq); + + return -1.f/std::sqrt(r2/4.f); + +} + + + +#include + +template +bool equal(T a, T b) { + // return float(a-b)==0; + return std::abs(float(a-b)) < std::abs(0.01f*a); +} + + + +int n=0; +void go(float ri, float ro, float dphi, bool print=false) { + ++n; + float x3 = 0.f, y3 = ro; + float x2 = ri*sin(dphi); + float y2 = ri*cos(dphi); + + + FastCircle c(0,0, + x2,y2, + x3,y3); + + auto cc = fastDPHI(ri,ro,dphi); + if (print) std::cout << c.m_c << ' ' << cc << std::endl; + assert(equal(c.m_c,cc)); + + +} + +int main() { + + + go(4.,7.,0.1, true); + + for (float r1=2; r1<15; r1+=1) + for (float dr=0.5; dr<10; dr+=0.5) + for (float dphi=0.02; dphi<0.2; dphi+=0.2) + go(r1,r1+dr,dphi); + + std::cout << "done " << n << std::endl; + return 0; +}; + diff --git a/RecoPixelVertexing/PixelTriplets/test/pixHits.ipynb b/RecoPixelVertexing/PixelTriplets/test/pixHits.ipynb new file mode 100644 index 0000000000000..ee8295f85a00a --- /dev/null +++ b/RecoPixelVertexing/PixelTriplets/test/pixHits.ipynb @@ -0,0 +1,2643 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "IPython.OutputArea.prototype._should_scroll = function(lines) {\n", + " return false;\n", + "}" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%javascript\n", + "IPython.OutputArea.prototype._should_scroll = function(lines) {\n", + " return false;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import glob\n", + "import math\n", + "import numpy as np\n", + "import pandas as pd\n", + "from bisect import *" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 1 1 2 2 9 10 10\n" + ] + } + ], + "source": [ + "layerStart = [0,96,320,672,1184,1296,1408,1520,1632,1744,1856]\n", + "layerName = [\"BL1\",\"BL2\",\"BL3\",\"BL4\",\"E+1\", \"E+2\", \"E+3\",\"E-1\", \"E-2\", \"E-3\"]\n", + "def layer(x) :\n", + " return bisect_right(layerStart, x)\n", + "\n", + "print layer(0),layer(1),layer(95),layer(96),layer(97),layer(1743),layer(1744),layer(1855)\n", + "\n", + "i2p = math.pi/32769.0" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def curvature(h, ptmin, region_origin_radius,hardPtCut, first, rad=False) :\n", + " region_origin_x = 0\n", + " region_origin_y = 0\n", + " x1 = h['r1']*np.cos(h['phi1']) if first else h['r2']*np.cos(h['phi2'])\n", + " y1 = h['r1']*np.sin(h['phi1']) if first else h['r2']*np.sin(h['phi2'])\n", + " x2 = h['r2']*np.cos(h['phi2']) if first else h['r3']*np.cos(h['phi3'])\n", + " y2 = h['r2']*np.sin(h['phi2']) if first else h['r3']*np.sin(h['phi3'])\n", + " x3 = h['r3']*np.cos(h['phi3']) if first else h['r4']*np.cos(h['phi4'])\n", + " y3 = h['r3']*np.sin(h['phi3']) if first else h['r4']*np.sin(h['phi4'])\n", + " \n", + " distance_13_squared = (x1 - x3)*(x1 - x3) + (y1 - y3)*(y1 - y3)\n", + " tan_12_13_half_mul_distance_13_squared = abs(y1 * (x2 - x3) + y2 * (x3 - x1) + y3 * (x1 - x2))\n", + " # high pt : just straight\n", + " straight = tan_12_13_half_mul_distance_13_squared * ptmin <= 1.0e-4*distance_13_squared\n", + " def ifStraight() :\n", + " distance_3_beamspot_squared = (x3-region_origin_x) * (x3-region_origin_x) + (y3-region_origin_y) * (y3-region_origin_y)\n", + " dot_bs3_13 = ((x1 - x3)*( region_origin_x - x3) + (y1 - y3) * (region_origin_y-y3))\n", + " proj_bs3_on_13_squared = dot_bs3_13*dot_bs3_13/distance_13_squared\n", + " distance_13_beamspot_squared = distance_3_beamspot_squared - proj_bs3_on_13_squared\n", + " return distance_13_beamspot_squared < (region_origin_radius+phiCut)*(region_origin_radius+phiCut)\n", + " \n", + " def standard() :\n", + " # 87 cm/GeV = 1/(3.8T * 0.3)\n", + " # 165 cm/GeV = 1/(2T * 0.3)\n", + " \n", + " # take less than radius given by the hardPtCut and reject everything below\n", + " minRadius = hardPtCut*87 # // FIXME move out and use real MagField\n", + " \n", + " det = (x1 - x2) * (y2 - y3) - (x2 - x3) * (y1 - y2)\n", + " \n", + " offset = x2 * x2 + y2*y2\n", + " \n", + " bc = (x1 * x1 + y1 * y1 - offset)*0.5\n", + " \n", + " cd = (offset - x3 * x3 - y3 * y3)*0.5\n", + " \n", + " \n", + " \n", + " idet = 1./ det;\n", + " \n", + " x_center = (bc * (y2 - y3) - cd * (y1 - y2)) * idet\n", + " y_center = (cd * (x1 - x2) - bc * (x2 - x3)) * idet\n", + " \n", + " radius = np.sqrt((x2 - x_center)*(x2 - x_center) + (y2 - y_center)*(y2 - y_center))\n", + " if rad: return radius\n", + " def domore() :\n", + " centers_distance_squared = (x_center - region_origin_x)*(x_center - region_origin_x) + (y_center - region_origin_y)*(y_center - region_origin_y)\n", + " #minimumOfIntersectionRange = (radius - region_origin_radius_plus_tolerance)*(radius - region_origin_radius_plus_tolerance)\n", + " #ok = centers_distance_squared >= minimumOfIntersectionRange\n", + " return np.sqrt(centers_distance_squared)-radius # - region_origin_radius\n", + "\n", + "\n", + " # return domore().where(radius > minRadius, radius <= minRadius)\n", + " return domore()\n", + " \n", + " #return ifStraight().where(straight,standard())\n", + " return standard()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def deltaphi(a,b,ch) :\n", + " ch *=ch\n", + " cb = ch*b\n", + " ca = ch*a\n", + " return np.arcsin(cb) - np.arcsin(ca)\n", + "\n", + "\n", + "def deltaphiA(a,b,ch) :\n", + " ch *=ch\n", + " d = b-a\n", + " cd = ch*d\n", + " ca = ch*a\n", + " return cd*(1.+0.5*ca*(ca+cd)+cd*cd*0.1667)\n", + "\n", + "\n", + "def eta(r,z) :\n", + " t = z/r\n", + " return np.arcsinh(t);\n", + "\n", + "def sag(r,c) :\n", + " return 0.5*c*r*r\n", + "\n", + "def phicutOld(a,b,c) :\n", + " o = np.maximum(a,b)\n", + " i = np.minimum(a,b)\n", + " d = np.minimum(i,o-i)\n", + " m = sag(o,c)\n", + " return d*m/(0.5*o*i)\n", + "\n", + "def phicut(a,b,c) :\n", + " ro = np.maximum(a,b)\n", + " ri = np.minimum(a,b)\n", + " dr = ro-ri\n", + " return dr/np.sqrt(4./(c*c) -ri*ro);\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def alignRZ(h, rp, ptmin, first) :\n", + " '''\n", + " float radius_diff = std::abs(r1 - ro);\n", + " float distance_13_squared = radius_diff*radius_diff + (z1 - zo)*(z1 - zo);\n", + " \n", + " float pMin = ptmin*std::sqrt(distance_13_squared); //this needs to be divided by radius_diff later\n", + " \n", + " float tan_12_13_half_mul_distance_13_squared = fabs(z1 * (getInnerR() - ro) + getInnerZ() * (ro - r1) + zo * (r1 - getInnerR())) ;\n", + " return tan_12_13_half_mul_distance_13_squared * pMin <= thetaCut * distance_13_squared * radius_diff;\n", + " '''\n", + " ri = h[rp+'1'] if first else h[rp+'2']\n", + " zi = h['z1'] if first else h['z2']\n", + " rm = h[rp+'2'] if first else h[rp+'3']\n", + " zm = h['z2'] if first else h['z3']\n", + " ro = h[rp+'3'] if first else h[rp+'4']\n", + " zo = h['z3'] if first else h['z4']\n", + " fact = 1. if (rp=='r') else 10.\n", + " radius_diff = fact*abs(ri - ro)\n", + " distance_13_squared = radius_diff*radius_diff + (zi - zo)*(zi - zo)\n", + " \n", + " pMin = ptmin*np.sqrt(distance_13_squared) #this needs to be divided by radius_diff later\n", + " \n", + " tan_12_13_half_mul_distance_13_squared = fact*abs(zi * (rm - ro) + zm * (ro - ri) + zo * (ri - rm)) \n", + " return tan_12_13_half_mul_distance_13_squared * pMin/(distance_13_squared * radius_diff)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def alignRPZ(h, rp, first) :\n", + " ri = h[rp+'1'] if first else h[rp+'2']\n", + " zi = h['z1'] if first else h['z2']\n", + " rm = h[rp+'2'] if first else h[rp+'3']\n", + " zm = h['z2'] if first else h['z3']\n", + " ro = h[rp+'3'] if first else h[rp+'4']\n", + " zo = h['z3'] if first else h['z4']\n", + " \n", + " return (rm-ri)*(zo-zm) - (ro-rm)*(zm-zi)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def doublets(hits,l1,l2,cut=0.2) :\n", + " nd=0\n", + " for h1 in l1.itertuples() :\n", + " phi = h1.phi\n", + " hh = l2['phi'].searchsorted([phi-cut,phi+cut])\n", + " hits.loc[h1.Index,'up0'] = hh[0]\n", + " hits.loc[h1.Index,'up1'] = hh[1]\n", + " nd += hh[1]-hh[0]\n", + " return nd" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def ml(pt1,pz1,pt2,pz2) :\n", + " dp = pt1*pt2+pz1*pz2\n", + " m1 = pt1*pt1+pz1*pz1\n", + " m2 = pt2*pt2+pz2*pz2\n", + " corr = pt1/np.sqrt(m1)\n", + " dp /=np.sqrt(m1*m2)\n", + " dt = np.arccos(dp[dp<1]) \n", + " dtn = dt*np.sqrt(m1)*corr\n", + " return dt,dtn" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#rawhits 6842643\n" + ] + } + ], + "source": [ + "file = '/Users/innocent/data/ttbarPU50Hits.csv'\n", + "# file = '/Users/innocent/data/ttbarPU0Hits.csv'\n", + "rawHits = pd.read_csv(file, delimiter=\" \")\n", + "print '#rawhits', len(rawHits)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#hits 2865257\n", + " ev ind det charge xg yg zg rg \\\n", + "2068 1 3380 261 39382 -0.719951 -7.235875 12.478751 7.271603 \n", + "5523 1 4947 582 61290 -0.775613 -11.347950 19.134975 11.374425 \n", + "109 1 1549 66 75059 -0.153022 -3.402119 -9.927705 3.405559 \n", + "2865 1 3345 256 114378 -0.533277 -7.253811 -22.095730 7.273387 \n", + "10198 1 9090 1567 25476 -1.101961 -10.707680 -33.038609 10.764234 \n", + "\n", + " iphi tkId pt n1 tkId2 pt2 n2 phi eta seq trackID \n", + "2068 -17419 0 769 3 0 0 0 -1.669967 1.308952 2 10000000 \n", + "5523 -17096 0 769 3 0 0 0 -1.639038 1.291801 3 10000000 \n", + "109 -16853 2 740 7 0 0 0 -1.615744 -1.791266 1 10000002 \n", + "2865 -17150 2 740 8 0 0 0 -1.644181 -1.830360 2 10000002 \n", + "10198 -17455 2 740 3 0 0 0 -1.673348 -1.840135 8 10000002 \n", + " ev ind det charge xg yg zg rg \\\n", + "6839298 500 9339 1420 34842 -9.546642 -3.838250 48.859261 10.289341 \n", + "6841294 500 9575 1449 27589 -9.140972 -3.633035 46.708469 9.836479 \n", + "6837952 500 10073 1505 23716 -9.103679 -3.615468 46.529385 9.795334 \n", + "6834639 500 7848 1239 24579 14.649280 -2.504236 30.849955 14.861783 \n", + "6838867 500 9420 1428 27807 3.696498 -3.074924 48.992340 4.808249 \n", + "\n", + " iphi tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "6839298 -28781 114033 685 3 0 0 0 -2.759318 2.261890 7 \n", + "6841294 -28822 114033 685 2 0 0 0 -2.763291 2.261882 7 \n", + "6837952 -28825 114033 685 3 0 0 0 -2.763551 2.262225 7 \n", + "6834639 -1767 114052 414 3 0 0 0 -0.169309 1.477025 5 \n", + "6838867 -7238 114059 556 2 0 0 0 -0.693861 3.016878 7 \n", + "\n", + " trackID \n", + "6839298 5000114033 \n", + "6841294 5000114033 \n", + "6837952 5000114033 \n", + "6834639 5000114052 \n", + "6838867 5000114059 \n" + ] + } + ], + "source": [ + "rawHits['phi'] = np.arctan2(rawHits['yg'],rawHits['xg']) # rawHits['iphi']*i2p\n", + "rawHits['eta'] = eta(rawHits['rg'],rawHits['zg'])\n", + "rawHits['seq'] = rawHits['det'].apply(layer)\n", + "rawHits['trackID'] = rawHits['tkId']+10000000*rawHits['ev']\n", + "rawHits.sort_values(by=['ev','tkId','det'],inplace=True)\n", + "hits = rawHits[rawHits['pt']>400]\n", + "print '#hits', len(hits)\n", + "print hits.head()\n", + "print hits.tail()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "#print hits[hits['tkId']==3].head(50)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "648743 455518 369878 305588 355791 363545 366194\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFAFJREFUeJzt3X+s3fV93/HnK0DSqqlmGJ7nGHtGjbfJqVqDroAp/YMlCxg2zWRaI+hUPIrmZgKtkbIfEKSShnlK1JasrATJLV5MReKhJgwrdUZclymLVAMmowRDGHchyLYMuDEhidBYTd7743wMZ869vufee+49957v8yEd3e/5fD/f7/187o/v63w+3+/5nlQVkqTueceoGyBJGg0DQJI6ygCQpI4yACSpowwASeooA0CSOsoAkKSOMgAkqaMMAEnqqLNH3YAzOf/882v9+vWjboYkLStPPPHEX1bVypnqLekAWL9+PQcPHhx1MyRpWUny4iD1nAKSpI4yACSpowwASeooA0CSOsoAkKSOMgAkqaMMAEnqKANAkjrKAJCkjlrS7wSWlrv1t/zJW8vf/fQ/HGFLpJ/kCECSOsoRgDSFxXzl7ihBo+IIQJI6yhGANIPZvkLvry8tZQaAtERNFyROE2lYDABpkTgy0FJjAEjNUjhAL4U2qDsMAI2t6ebul/tVN8u9/Vo6DAAtO3M5APrKWvpJBoA6bVjBYMBoOTIApGVsXKe5tDhmfCNYkp9K8liSv0hyKMlvtfLPJ3khyZPtsamVJ8ldSSaTPJXk4r59bU3yfHtsXbhuSZJmMsgI4A3gA1X1oyTnAN9I8tW27t9U1R+fVv8qYEN7XArcA1ya5DzgdmACKOCJJHuq6tVhdESSNDszjgCq50ft6TntUWfYZAtwX9vuALAiyWrgSmBfVZ1oB/19wOb5NV+SNFcDnQNIchbwBPBe4O6qejTJvwS2J/lNYD9wS1W9AawBDvdtfqSVTVcuaQGdfoLacwU6ZaAAqKo3gU1JVgAPJvl54FbgJeCdwA7g3wGfmm+DkmwDtgGsW7duvrvTEjLIwWY+BySvxJFmZ1ZXAVXV95M8Amyuqt9pxW8k+c/Av27PjwJr+za7oJUdBS4/rfy/T/E9dtALFCYmJs401aQO8eC+8BwNdM+MAZBkJfBX7eD/08CHgM8kWV1Vx5IEuAZ4um2yB7g5yW56J4Ffa/UeBv5DknNbvSvojSKkOTMYZs+fmU4ZZASwGtjVzgO8A3igqr6S5M9aOAR4Evhoq78XuBqYBF4HbgCoqhNJ7gAeb/U+VVUnhtcVLVcekKTRmDEAquop4KIpyj8wTf0Cbppm3U5g5yzbKGmReSvqbvATwSSpowwASeooA0CSOsqbwWlBeYK3G7yEdHkyACTNieG+/BkAGrpBDgwePJYnf2/jxXMAktRRBoAkdZQBIEkdZQBIUkd5ElhD4clBafkxADRnHvSl5c0AkDRUvils+TAANCu+6tdsTBcG3m10aTAANCVfxUnjzwAYYx7Etdz4N7u4vAxUkjrKEYBm5Ly/NJ4cAUhSR80YAEl+KsljSf4iyaEkv9XKL0zyaJLJJP8lyTtb+bva88m2fn3fvm5t5c8luXKhOqUzW3/Ln7z1kNRdg4wA3gA+UFW/CGwCNie5DPgM8Nmqei/wKnBjq38j8Gor/2yrR5KNwLXA+4DNwOeSnDXMzkiSBjfjOYCqKuBH7ek57VHAB4BfaeW7gE8C9wBb2jLAHwO/nyStfHdVvQG8kGQSuAT482F0RFoMXqWyePxZL7yBTgK3V+pPAO8F7gb+N/D9qjrZqhwB1rTlNcBhgKo6meQ14K+38gN9u+3fpv97bQO2Aaxbt26W3Rlf/jNIGraBAqCq3gQ2JVkBPAj83YVqUFXtAHYATExM1EJ9n3Fx+jz+dOHgfP/w+TPVcjery0Cr6vtJHgH+HrAiydltFHABcLRVOwqsBY4kORv4a8D3+spP6d9GQ+JBSeNokFtKODKevRkDIMlK4K/awf+ngQ/RO7H7CPBPgd3AVuChtsme9vzP2/o/q6pKsgf4QpI7gfcAG4DHhtwfSWPOFznDM8gIYDWwq50HeAfwQFV9JckzwO4k/x74n8C9rf69wB+1k7wn6F35Q1UdSvIA8AxwEripTS1J0rw5Gpi9Qa4Cegq4aIry79C7iuf08v8D/PI0+9oObJ99MyVJw+atICSNHW83PRgDYAmb7o94oeZAnVuVusV7AUlSRxkAktRRBoAkdZTnACSJbl5GagBI6owuHuTPxABYYrwSR9Ji8RyAJHWUI4AlwFf9kkbBAFhgzjlKy09X/m+dApKkjnIEIEkDGreRgQEwD/P5Y3DeX9KoGQDTGLeklzQ3g9yUcVjHiMU+7hgAs+Qrd0njwgAYgAd9SYNaTrMHXgUkSR01yIfCrwXuA1YBBeyoqt9L8kngXwDHW9VPVNXets2twI3Am8C/qqqHW/lm4PeAs4A/rKpPD7c78zOsV/qOGKRuWa7/84NMAZ0EPl5V30zys8ATSfa1dZ+tqt/pr5xkI70Pgn8f8B7gT5P87bb6buBDwBHg8SR7quqZYXRk1JbrH4CkhbPUp4MG+VD4Y8CxtvzDJM8Ca86wyRZgd1W9AbyQZJK3Pzx+sn2YPEl2t7oLFgBL/YcvSaM0q5PASdYDFwGPAu8Hbk5yPXCQ3ijhVXrhcKBvsyO8HRiHTyu/dE6tlqRlZim+IB04AJK8G/gS8LGq+kGSe4A76J0XuAP4XeDX5tugJNuAbQDr1q2b7+6m5HSNJA0YAEnOoXfwv7+qvgxQVS/3rf8D4Cvt6VFgbd/mF7QyzlD+lqraAewAmJiYqIF6IUnL1ChfkA5yFVCAe4Fnq+rOvvLV7fwAwIeBp9vyHuALSe6kdxJ4A/AYEGBDkgvpHfivBX5lWB2Zia/6JS0VS+V4NMgI4P3ArwLfSvJkK/sEcF2STfSmgL4L/DpAVR1K8gC9k7sngZuq6k2AJDcDD9O7DHRnVR0aYl8kSbMwyFVA36D36v10e8+wzXZg+xTle8+0nSRp8fhOYEnqKANAkjrKAJCkjjIAJKmjDABJ6igDQJI6ygCQpI4yACSpowwASeooA0CSOsoPhe+4pXJTKs2fv0vNliMASeooA0CSOsopIEmLwimqpccRgCR1lAEgSR3lFJCWLKcMpIXlCECSOmrGAEiyNskjSZ5JcijJb7Ty85LsS/J8+3puK0+Su5JMJnkqycV9+9ra6j+fZOvCdUuSNJNBRgAngY9X1UbgMuCmJBuBW4D9VbUB2N+eA1wFbGiPbcA90AsM4HbgUuAS4PZToSFJWnwzBkBVHauqb7blHwLPAmuALcCuVm0XcE1b3gLcVz0HgBVJVgNXAvuq6kRVvQrsAzYPtTeSpIHN6hxAkvXARcCjwKqqOtZWvQSsastrgMN9mx1pZdOVS5JGYOAASPJu4EvAx6rqB/3rqqqAGkaDkmxLcjDJwePHjw9jl5KkKQwUAEnOoXfwv7+qvtyKX25TO7Svr7Tyo8Davs0vaGXTlf9/qmpHVU1U1cTKlStn0xdJ0iwMchVQgHuBZ6vqzr5Ve4BTV/JsBR7qK7++XQ10GfBamyp6GLgiybnt5O8VrUySNAKDvBHs/cCvAt9K8mQr+wTwaeCBJDcCLwIfaev2AlcDk8DrwA0AVXUiyR3A463ep6rqxFB6IUmatRkDoKq+AWSa1R+con4BN02zr53Aztk0UJK0MHwnsCR1lAEgSR1lAEhSRxkAktRRBoAkdZQBIEkd5QfCSOokP3DIAFhU/sFJWkqcApKkjjIAJKmjDABJ6igDQJI6ygCQpI4yACSpowwASeooA0CSOsoAkKSOMgAkqaMG+VD4nUleSfJ0X9knkxxN8mR7XN237tYkk0meS3JlX/nmVjaZ5Jbhd0WSNBuDjAA+D2yeovyzVbWpPfYCJNkIXAu8r23zuSRnJTkLuBu4CtgIXNfqSpJGZJAPhf96kvUD7m8LsLuq3gBeSDIJXNLWTVbVdwCS7G51n5l1iyVJQzGfcwA3J3mqTRGd28rWAIf76hxpZdOVS5JGZK4BcA/wc8Am4Bjwu8NqUJJtSQ4mOXj8+PFh7VaSdJo5BUBVvVxVb1bVj4E/4O1pnqPA2r6qF7Sy6cqn2veOqpqoqomVK1fOpXmSpAHMKQCSrO57+mHg1BVCe4Brk7wryYXABuAx4HFgQ5ILk7yT3oniPXNvtiRpvmY8CZzki8DlwPlJjgC3A5cn2QQU8F3g1wGq6lCSB+id3D0J3FRVb7b93Aw8DJwF7KyqQ0PvjSRpYINcBXTdFMX3nqH+dmD7FOV7gb2zap0kacH4TmBJ6igDQJI6ygCQpI4yACSpowwASeooA0CSOsoAkKSOMgAkqaMMAEnqKANAkjrKAJCkjjIAJKmjDABJ6igDQJI6ygCQpI4yACSpowwASeooA0CSOsoAkKSOmjEAkuxM8kqSp/vKzkuyL8nz7eu5rTxJ7koymeSpJBf3bbO11X8+ydaF6Y4kaVCDjAA+D2w+rewWYH9VbQD2t+cAVwEb2mMbcA/0AgO4HbgUuAS4/VRoSJJGY8YAqKqvAydOK94C7GrLu4Br+srvq54DwIokq4ErgX1VdaKqXgX28ZOhIklaRHM9B7Cqqo615ZeAVW15DXC4r96RVjZd+U9Isi3JwSQHjx8/PsfmSZJmMu+TwFVVQA2hLaf2t6OqJqpqYuXKlcParSTpNHMNgJfb1A7t6yut/Ciwtq/eBa1sunJJ0ojMNQD2AKeu5NkKPNRXfn27Gugy4LU2VfQwcEWSc9vJ3ytamSRpRM6eqUKSLwKXA+cnOULvap5PAw8kuRF4EfhIq74XuBqYBF4HbgCoqhNJ7gAeb/U+VVWnn1iWJC2iGQOgqq6bZtUHp6hbwE3T7GcnsHNWrZMkLRjfCSxJHWUASFJHGQCS1FEGgCR1lAEgSR1lAEhSRxkAktRRBoAkdZQBIEkdZQBIUkcZAJLUUQaAJHWUASBJHWUASFJHGQCS1FEGgCR1lAEgSR1lAEhSR80rAJJ8N8m3kjyZ5GArOy/JviTPt6/ntvIkuSvJZJKnklw8jA5IkuZmGCOAv19Vm6pqoj2/BdhfVRuA/e05wFXAhvbYBtwzhO8tSZqjhZgC2gLsasu7gGv6yu+rngPAiiSrF+D7S5IGMN8AKOBrSZ5Isq2VraqqY235JWBVW14DHO7b9kgrkySNwNnz3P6Xqupokr8B7Evy7f6VVVVJajY7bEGyDWDdunXzbJ4kaTrzGgFU1dH29RXgQeAS4OVTUzvt6yut+lFgbd/mF7Sy0/e5o6omqmpi5cqV82meJOkM5hwASX4myc+eWgauAJ4G9gBbW7WtwENteQ9wfbsa6DLgtb6pIknSIpvPFNAq4MEkp/bzhar6b0keBx5IciPwIvCRVn8vcDUwCbwO3DCP7y1Jmqc5B0BVfQf4xSnKvwd8cIryAm6a6/eTJA2X7wSWpI4yACSpowwASeooA0CSOsoAkKSOMgAkqaMMAEnqKANAkjrKAJCkjjIAJKmjDABJ6igDQJI6ygCQpI4yACSpowwASeooA0CSOsoAkKSOMgAkqaMWPQCSbE7yXJLJJLcs9veXJPUsagAkOQu4G7gK2Ahcl2TjYrZBktSz2COAS4DJqvpOVf1fYDewZZHbIEli8QNgDXC47/mRViZJWmRnj7oBp0uyDdjWnv4oyfeAvxxhkxbD+djHcWAfx8OS6GM+M6/N/9YglRY7AI4Ca/ueX9DK3lJVO4Adp54nOVhVE4vTvNGwj+PBPo6HLvTxlMWeAnoc2JDkwiTvBK4F9ixyGyRJLPIIoKpOJrkZeBg4C9hZVYcWsw2SpJ5FPwdQVXuBvbPYZMfMVZY9+zge7ON46EIfAUhVjboNkqQR8FYQktRRSzYAktyR5KkkTyb5WpL3tPIkuavdSuKpJBePuq1zleS3k3y79ePBJCv61t3a+vhckitH2c75SPLLSQ4l+XGSidPWjUUfYTxvcZJkZ5JXkjzdV3Zekn1Jnm9fzx1lG+crydokjyR5pv2d/kYrH6t+TmfJBgDw21X1C1W1CfgK8Jut/CpgQ3tsA+4ZUfuGYR/w81X1C8D/Am4FaLfHuBZ4H7AZ+Fy7jcZy9DTwT4Cv9xeOUx/H+BYnn6f3u+l3C7C/qjYA+9vz5ewk8PGq2ghcBtzUfnfj1s8pLdkAqKof9D39GeDUyYotwH3VcwBYkWT1ojdwCKrqa1V1sj09QO99EdDr4+6qeqOqXgAm6d1GY9mpqmer6rkpVo1NHxnTW5xU1deBE6cVbwF2teVdwDWL2qghq6pjVfXNtvxD4Fl6dycYq35OZ8kGAECS7UkOA/+Mt0cA43o7iV8DvtqWx7WP/capj+PUl5msqqpjbfklYNUoGzNMSdYDFwGPMsb97DfSW0Ek+VPgb06x6raqeqiqbgNuS3IrcDNw+6I2cAhm6mOrcxu9oej9i9m2YRmkjxo/VVVJxuIywiTvBr4EfKyqfpDkrXXj1M/TjTQAquofDFj1fnrvHbidAW4nsZTM1Mck/xz4R8AH6+1rcseqj9NYVn2cwTj1ZSYvJ1ldVcfa1Osro27QfCU5h97B//6q+nIrHrt+TmXJTgEl2dD3dAvw7ba8B7i+XQ10GfBa31BtWUmyGfi3wD+uqtf7Vu0Brk3yriQX0jvh/dgo2riAxqmPXbrFyR5ga1veCizrEV56L/XvBZ6tqjv7Vo1VP6ezZN8IluRLwN8Bfgy8CHy0qo62X9jv07s64XXghqo6OLqWzl2SSeBdwPda0YGq+mhbdxu98wIn6Q1Lvzr1Xpa2JB8G/hOwEvg+8GRVXdnWjUUfAZJcDfxH3r7FyfYRN2neknwRuJze3TFfpjcC/6/AA8A6ev+XH6mq008ULxtJfgn4H8C36B1rAD5B7zzA2PRzOks2ACRJC2vJTgFJkhaWASBJHWUASFJHGQCS1FEGgCR1lAEgSR1lAEhSRxkAktRR/w+qS0lv9bkIQAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD8CAYAAAB+UHOxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFn9JREFUeJzt3X+w3XWd3/HnS7Ko0C0/JJtiEhpas+6gU1l6C1jbHSVrCOgY/lAGu63RZiadDro/ZqdrsJ3Sgjix3VkWZyudjGQJ1iVSqiUjVMyAdKczgoQfooCWLAJJGshdEtgfjGjcd/84n+Ah5HrPzT33nnvv9/mYuXO+38/5fL/n88mP+zqfz+d7zjdVhSSpe1436gZIkkbDAJCkjjIAJKmjDABJ6igDQJI6ygCQpI4yACSpowwASeooA0CSOmrRqBvw85x22mm1YsWKUTdDkuaVBx544M+ravFk9eZ0AKxYsYKdO3eOuhmSNK8keXqQek4BSVJHGQCS1FEGgCR1lAEgSR1lAEhSRxkAktRRBoAkdZQBIEkdZQBIUkcNFABJfifJo0m+l+TmJG9IcmaS+5LsSvLlJMe3uq9v+7va8yv6znNFK/9BkgtnpkuTW7Hx9ld+JKmrJg2AJEuB3wTGqurtwHHAZcBngWur6i3AQWB9O2Q9cLCVX9vqkeSsdtzbgDXA55McN9zuSJIGNegU0CLgjUkWAScA+4ALgFvb81uBS9r22rZPe35VkrTybVX1clX9ENgFnDv9LkiSjsWkAVBVe4HfB56h94v/ReAB4IWqOtSq7QGWtu2lwO527KFW/0395Uc5RpI0ywaZAjqF3rv3M4E3AyfSm8KZEUk2JNmZZOf4+PhMvYwkdd4gU0C/Dvywqsar6ifAV4B3ASe3KSGAZcDetr0XWA7Qnj8JeL6//CjHvKKqNlfVWFWNLV486ddZS5KO0SAB8AxwfpIT2lz+KuAx4JvAB1uddcBtbXt726c9f3dVVSu/rF0ldCawEvj2cLohSZqqSW8IU1X3JbkVeBA4BDwEbAZuB7Yl+XQru6EdcgPwxSS7gAP0rvyhqh5Ncgu98DgEXF5VPx1yfyRJAxrojmBVdSVw5RHFT3KUq3iq6kfAhyY4zzXANVNsoyRpBszpW0LOhv4Pgz216X0jbIkkzS6/CkKSOsoAkKSOMgAkqaMMAEnqKANAkjrKAJCkjjIAJKmjDABJ6igDQJI6ygCQpI4yACSpozr/XUD9/F4gSV3iCECSOsoAkKSOMgAkqaMGuSn8W5M83PfzF0l+O8mpSXYkeaI9ntLqJ8nnkuxK8kiSc/rOta7VfyLJuolfdfRWbLz9lR9JWogmDYCq+kFVnV1VZwP/EHgJ+CqwEbirqlYCd7V9gIvo3e93JbABuB4gyan07ip2Hr07iV15ODQkSbNvqlNAq4A/q6qngbXA1la+Fbikba8Fbqqee4GTk5wOXAjsqKoDVXUQ2AGsmXYPJEnHZKoBcBlwc9teUlX72vazwJK2vRTY3XfMnlY2UbkkaQQGDoAkxwMfAP77kc9VVQE1jAYl2ZBkZ5Kd4+PjwzilJOkopjICuAh4sKqea/vPtakd2uP+Vr4XWN533LJWNlH5q1TV5qoaq6qxxYsXT6F5kqSpmEoAfJifTf8AbAcOX8mzDritr/wj7Wqg84EX21TRncDqJKe0xd/VrWzO84ogSQvRQF8FkeRE4L3Av+or3gTckmQ98DRwaSu/A7gY2EXviqGPAVTVgSRXA/e3eldV1YFp90CSdEwGCoCq+mvgTUeUPU/vqqAj6xZw+QTn2QJsmXozJUnD5ieBJamjOvNtoM7fS9KrOQKQpI4yACSpowwASeqozqwBDIt3DZO0UDgCkKSOMgAkqaOcApoGp4MkzWeOACSpowwASeoop4DUKUd+ItypO3WZATAkrgdImm+cApKkjjIAJKmjnAJSpzl1py4zAKTGMFDXDDQFlOTkJLcm+X6Sx5O8M8mpSXYkeaI9ntLqJsnnkuxK8kiSc/rOs67VfyLJuolfUZI00wYdAVwHfL2qPpjkeOAE4FPAXVW1KclGYCPwSeAiYGX7OQ+4HjgvyanAlcAYUMADSbZX1cGh9mgO8J2kpPlg0gBIchLwa8BHAarqx8CPk6wF3t2qbQXuoRcAa4Gb2r2B722jh9Nb3R2HbwSfZAewBrh5eN2RhsMQVxcMMgV0JjAO/HGSh5J8IcmJwJKq2tfqPAssadtLgd19x+9pZROVv0qSDUl2Jtk5Pj4+td5IkgY2yBTQIuAc4BNVdV+S6+hN97yiqipJDaNBVbUZ2AwwNjY2lHNK0+FoQAvVICOAPcCeqrqv7d9KLxCea1M7tMf97fm9wPK+45e1sonKJUkjMGkAVNWzwO4kb21Fq4DHgO3A4St51gG3te3twEfa1UDnAy+2qaI7gdVJTmlXDK1uZdK8sWLj7a/8SPPdoFcBfQL4UrsC6EngY/TC45Yk64GngUtb3TuAi4FdwEutLlV1IMnVwP2t3lWHF4QXMqcPJM1VAwVAVT1M7/LNI606St0CLp/gPFuALVNpoCRpZvhJYOkYObrTfOeXwUlSRxkAktRRBoAkdZQBIEkdZQBIUkd5FZA0g7xSSHOZASANgZ8M1nzkFJAkdZQjgFnkdICkucQRgCR1lAEgSR3lFNAc4NSQpFFwBCBJHeUIYES8bLB7HOlprnEEIEkdNVAAJHkqyXeTPJxkZys7NcmOJE+0x1NaeZJ8LsmuJI8kOafvPOta/SeSrJvo9SRJM28qI4D3VNXZVXX4zmAbgbuqaiVwV9sHuAhY2X42ANdDLzCAK4HzgHOBKw+HhiRp9k1nCmgtsLVtbwUu6Su/qXruBU5OcjpwIbCjqg5U1UFgB7BmGq8vSZqGQQOggG8keSDJhla2pKr2te1ngSVteymwu+/YPa1sonJJ0ggMehXQP6mqvUl+CdiR5Pv9T1ZVJalhNKgFzAaAM844YxinXBC8gkTSsA0UAFW1tz3uT/JVenP4zyU5var2tSme/a36XmB53+HLWtle4N1HlN9zlNfaDGwGGBsbG0qozCf+opc0WyYNgCQnAq+rqr9s26uBq4DtwDpgU3u8rR2yHfh4km30FnxfbCFxJ/CZvoXf1cAVQ+3NAuNnBYbDP0fp6AYZASwBvprkcP0/qaqvJ7kfuCXJeuBp4NJW/w7gYmAX8BLwMYCqOpDkauD+Vu+qqjowtJ5IkqZk0gCoqieBdxyl/Hlg1VHKC7h8gnNtAbZMvZmSpGHzk8CS1FF+F9A85EKxpGFwBCBJHWUASFJHGQCS1FEGgCR1lAEgSR3lVUDznFcESTpWjgAkqaMMAEnqKANAkjrKAJCkjnIReIH6eV+B7GLx6Ll4r7nAEYAkdZQjgAXEG59ImgpHAJLUUQaAJHXUwAGQ5LgkDyX5Wts/M8l9SXYl+XKS41v569v+rvb8ir5zXNHKf5DkwmF3RoNZsfH2V34kdddURgC/BTzet/9Z4NqqegtwEFjfytcDB1v5ta0eSc4CLgPeBqwBPp/kuOk1X5J0rAYKgCTLgPcBX2j7AS4Abm1VtgKXtO21bZ/2/KpWfy2wraperqof0rtp/LnD6IQkaeoGHQH8IfB7wN+0/TcBL1TVoba/B1jatpcCuwHa8y+2+q+UH+WYVyTZkGRnkp3j4+NT6IokaSomDYAk7wf2V9UDs9AeqmpzVY1V1djixYtn4yUlqZMG+RzAu4APJLkYeAPwt4HrgJOTLGrv8pcBe1v9vcByYE+SRcBJwPN95Yf1H6MR8ROpUndNOgKoqiuqallVraC3iHt3Vf0G8E3gg63aOuC2tr297dOev7uqqpVf1q4SOhNYCXx7aD2RJE3JdD4J/ElgW5JPAw8BN7TyG4AvJtkFHKAXGlTVo0luAR4DDgGXV9VPp/H6GjJHA1K3TCkAquoe4J62/SRHuYqnqn4EfGiC468BrplqIyVJw+cngSWpo/wyOB2V00HSwucIQJI6ygCQpI4yACSpowwASeooF4E1qYkWhF0oluY3RwCS1FGOADQl3kRGWjgcAUhSRxkAktRRBoAkdZRrABo6rw6S5gcDQEPh4vCxMzA1Kk4BSVJHOQLQjPLdrTR3DXJT+Dck+XaS7yR5NMl/bOVnJrkvya4kX05yfCt/fdvf1Z5f0XeuK1r5D5JcOFOdkiRNbpApoJeBC6rqHcDZwJok5wOfBa6tqrcAB4H1rf564GArv7bVI8lZ9G4P+TZgDfD5JMcNszOSpMFNOgXUbuj+V233F9pPARcA/6yVbwX+A3A9sLZtA9wK/FGStPJtVfUy8MN2z+BzgW8NoyOaX5waOrpBvnepn392mo6BFoGTHJfkYWA/sAP4M+CFqjrUquwBlrbtpcBugPb8i8Cb+suPcowkaZYNFABV9dOqOhtYRu9d+6/MVIOSbEiyM8nO8fHxmXoZSeq8KV0FVFUvJPkm8E7g5CSL2rv8ZcDeVm0vsBzYk2QRcBLwfF/5Yf3H9L/GZmAzwNjYWE2tO5rLBvmswLCmhvxcgjS5SQMgyWLgJ+2X/xuB99Jb2P0m8EFgG7AOuK0dsr3tf6s9f3dVVZLtwJ8k+QPgzcBK4NtD7o/moan+snb94Gf8s9B0DDICOB3Y2q7YeR1wS1V9LcljwLYknwYeAm5o9W8AvtgWeQ/Qu/KHqno0yS3AY8Ah4PKq+ulwuyMtHI5iNNMGuQroEeBXj1L+JL31gCPLfwR8aIJzXQNcM/VmSpKGza+CkKSO8qsgNGc5BTI1rgdoqgwAaYEzGDQRp4AkqaMcAWhe892tdOwMAC0Yrhn8zHQ+WwGGaVcYAFKHOGJSPwNA6qifN0owKLrBRWBJ6igDQJI6yikgScfEaaL5zwCQNLCJ1g0Mg/nJAJD0c3l57cK1oAPAf7jS7HM0MH8s6ACQNFqGwdxmAEiaMwyM2TXILSGXAzcBS4ACNlfVdUlOBb4MrACeAi6tqoNJAlwHXAy8BHy0qh5s51oH/Lt26k9X1dbhdkfSXDXRlKy/6EdnkBHAIeB3q+rBJL8IPJBkB/BR4K6q2pRkI7AR+CRwEb37/a4EzgOuB85rgXElMEYvSB5Isr2qDg67U5LmD9fqRmeQW0LuA/a17b9M8jiwFFgLvLtV2wrcQy8A1gI3VVUB9yY5Ocnpre6OqjoA0EJkDXDzEPsjaYFwOmjmTWkNIMkKevcHvg9Y0sIB4Fl6U0TQC4fdfYftaWUTlUvSwAyG4Rk4AJL8LeB/AL9dVX/Rm+rvqapKUsNoUJINwAaAM844YxinlDTPOU00MwYKgCS/QO+X/5eq6iut+Lkkp1fVvjbFs7+V7wWW9x2+rJXt5WdTRofL7znytapqM7AZYGxsbCihImnhc2QwdYNcBRTgBuDxqvqDvqe2A+uATe3xtr7yjyfZRm8R+MUWEncCn0lySqu3GrhiON2Q1EWDjAwmCgYDY7ARwLuAfwF8N8nDrexT9H7x35JkPfA0cGl77g56l4DuoncZ6McAqupAkquB+1u9qw4vCEvSbHAq6dUGuQro/wCZ4OlVR6lfwOUTnGsLsGUqDZQkzQw/CSxpwZnOPZEnmiY68rmFwACQpGOwENYQDABJ6nMs6wTzNQwMAEka0EJbRDYAJGmI5tNowACQpBky178B1QCQpFk2V0YJrxvZK0uSRsoAkKSOMgAkqaMMAEnqKANAkjrKAJCkjvIyUEkaoVFeEuoIQJI6ygCQpI4yACSpoyYNgCRbkuxP8r2+slOT7EjyRHs8pZUnyeeS7ErySJJz+o5Z1+o/kWTdzHRHkjSoQUYANwJrjijbCNxVVSuBu9o+wEXAyvazAbgeeoEBXEnvJvHnAlf23RxekjQCkwZAVf0pcOTN29cCW9v2VuCSvvKbqude4OQkpwMXAjuq6kBVHQR28NpQkSTNomNdA1hSVfva9rPAkra9FNjdV29PK5uo/DWSbEiyM8nO8fHxY2yeJGky014ErqoCaghtOXy+zVU1VlVjixcvHtZpJUlHONYAeK5N7dAe97fyvcDyvnrLWtlE5ZKkETnWANgOHL6SZx1wW1/5R9rVQOcDL7apojuB1UlOaYu/q1uZJGlEJv0qiCQ3A+8GTkuyh97VPJuAW5KsB54GLm3V7wAuBnYBLwEfA6iqA0muBu5v9a6qqiMXliVJs2jSAKiqD0/w1Kqj1C3g8gnOswXYMqXWSZJmjJ8ElqSOMgAkqaMMAEnqKANAkjrKAJCkjjIAJKmjDABJ6igDQJI6ygCQpI4yACSpoyb9KghJ0uxYsfH2V7af2vS+GX89RwCS1FEGgCR1lAEgSR1lAEhSRxkAktRRsx4ASdYk+UGSXUk2zvbrS5J6ZjUAkhwH/BfgIuAs4MNJzprNNkiSemZ7BHAusKuqnqyqHwPbgLWz3AZJErMfAEuB3X37e1qZJGmWzblPAifZAGxou3+V5Hngz0fYpJlwGgurTwutP7Dw+rTQ+gMLr0+v6k8+O61z/d1BKs12AOwFlvftL2tlr6iqzcDmw/tJdlbV2Ow0b3YstD4ttP7AwuvTQusPLLw+jaI/sz0FdD+wMsmZSY4HLgO2z3IbJEnM8gigqg4l+ThwJ3AcsKWqHp3NNkiSemZ9DaCq7gDumMIhmyevMu8stD4ttP7AwuvTQusPLLw+zXp/UlWz/ZqSpDnAr4KQpI6a8wGQ5LgkDyX52qjbMl1JTk5ya5LvJ3k8yTtH3abpSvI7SR5N8r0kNyd5w6jbNFVJtiTZn+R7fWWnJtmR5In2eMoo2zgVE/TnP7d/d48k+WqSk0fZxqk6Wp/6nvvdJJXktFG07VhM1J8kn2h/T48m+U8z3Y45HwDAbwGPj7oRQ3Id8PWq+hXgHczzfiVZCvwmMFZVb6e3sH/ZaFt1TG4E1hxRthG4q6pWAne1/fniRl7bnx3A26vqHwD/F7hiths1TTfy2j6RZDmwGnhmths0TTdyRH+SvIfeNyO8o6reBvz+TDdiTgdAkmXA+4AvjLot05XkJODXgBsAqurHVfXCaFs1FIuANyZZBJwA/L8Rt2fKqupPgQNHFK8FtrbtrcAls9qoaThaf6rqG1V1qO3eS+8zOPPGBH9HANcCvwfMq8XMCfrzr4FNVfVyq7N/ptsxpwMA+EN6f7l/M+qGDMGZwDjwx21K6wtJThx1o6ajqvbSe5fyDLAPeLGqvjHaVg3Nkqra17afBZaMsjFD9i+B/zXqRkxXkrXA3qr6zqjbMiS/DPzTJPcl+d9J/tFMv+CcDYAk7wf2V9UDo27LkCwCzgGur6pfBf6a+TWt8BptXnwtvXB7M3Bikn8+2lYNX/UulZtX7zAnkuTfAoeAL426LdOR5ATgU8C/H3VbhmgRcCpwPvBvgFuSZCZfcM4GAPAu4ANJnqL3raEXJPlvo23StOwB9lTVfW3/VnqBMJ/9OvDDqhqvqp8AXwH+8YjbNCzPJTkdoD3O+HB8piX5KPB+4Ddq/l///ffpvfH4TvsdsQx4MMnfGWmrpmcP8JXq+Ta9mY8ZXdieswFQVVdU1bKqWkFvYfHuqpq37y6r6llgd5K3tqJVwGMjbNIwPAOcn+SE9k5lFfN8YbvPdmBd214H3DbCtkxbkjX0plM/UFUvjbo901VV362qX6qqFe13xB7gnPb/bL76n8B7AJL8MnA8M/xld3M2ABaoTwBfSvIIcDbwmRG3Z1raaOZW4EHgu/T+Pc27T2cmuRn4FvDWJHuSrAc2Ae9N8gS9kc6mUbZxKibozx8BvwjsSPJwkv860kZO0QR9mrcm6M8W4O+1S0O3AetmeqTmJ4ElqaMcAUhSRxkAktRRBoAkdZQBIEkdZQBIUkcZAJLUUQaAJHWUASBJHfX/AREp+9lGFIzOAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hb1 = hits.query('seq==1')\n", + "hb2 = hits.query('seq==2')\n", + "hb3 = hits.query('seq==3')\n", + "hb4 = hits.query('seq==4')\n", + "hf1 = hits.query('seq==5 or seq==8')\n", + "hf2 = hits.query('seq==6 or seq==9')\n", + "hf3 = hits.query('seq==7 or seq==10')\n", + "\n", + "print len(hb1), len(hb2), len(hb3), len(hb4), len(hf1), len(hf2), len(hf3)\n", + "plt.hist(hb1['zg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb1['eta'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb1['rg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb2['zg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb2['eta'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb2['rg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb3['zg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb3['eta'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb3['rg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb4['zg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hb4['eta'],log=False, bins=100)\n", + "plt.show()\n", + "data = [hb1['eta'],hb2['eta'],hb3['eta'],hb4['eta'],hf1['eta'],hf2['eta'],hf3['eta']]\n", + "plt.hist(data,log=False, bins=100, histtype='barstacked')\n", + "plt.show()\n", + "plt.hist(data,log=False, bins=100, histtype='step')\n", + "plt.show()\n", + "\n", + "\n", + "plt.hist(hb4['rg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hf1['zg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hf1['rg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hf2['zg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hf2['rg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hf3['zg'],log=False, bins=100)\n", + "plt.show()\n", + "plt.hist(hf3['rg'],log=False, bins=100)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "min/max\n", + " ev ind det charge xg yg zg rg iphi \\\n", + "min 1 0 0 696 -3.133961 -3.443828 -27.465214 2.664958 -32766 \n", + "max 500 4931 95 6379805 3.184488 3.305549 25.885403 3.443848 32766 \n", + "\n", + " tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "min 0 401 1 0 0 0 -3.141559 -3.027653 1 \n", + "max 145940 236569 173 144781 155324 70 3.141505 2.968422 1 \n", + "\n", + " trackID \n", + "min 10000002 \n", + "max 5000114033 \n", + " ev ind det charge xg yg zg rg iphi \\\n", + "min 1 1349 96 627 -6.956163 -7.319355 -27.465387 6.502839 -32767 \n", + "max 500 8491 319 6790313 7.005610 7.180817 25.886454 7.320724 32766 \n", + "\n", + " tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "min 0 401 1 0 0 0 -3.141582 -2.147105 2 \n", + "max 145940 255145 241 145934 81469 164 3.141493 2.089339 2 \n", + "\n", + " trackID \n", + "min 10000000 \n", + "max 5000114028 \n", + " ev ind det charge xg yg zg rg \\\n", + "min 1 2404 320 641 -11.041545 -11.406182 -27.465218 10.633793 \n", + "max 500 11579 671 4936108 11.091197 11.267007 25.886602 11.406182 \n", + "\n", + " iphi tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "min -32766 0 401 1 0 0 0 -3.141551 -1.677385 3 \n", + "max 32766 145940 255145 174 143437 60151 19 3.141545 1.622253 3 \n", + "\n", + " trackID \n", + "min 10000000 \n", + "max 5000114028 \n", + " ev ind det charge xg yg zg rg \\\n", + "min 1 3271 672 350 -16.142319 -16.506441 -27.465492 15.738359 \n", + "max 500 14303 1183 5762376 16.191597 16.367704 25.885468 16.526356 \n", + "\n", + " iphi tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "min -32766 0 401 1 0 0 0 -3.141524 -1.323260 4 \n", + "max 32767 145940 255145 175 140301 20956 54 3.141583 1.272212 4 \n", + "\n", + " trackID \n", + "min 10000005 \n", + "max 5000114028 \n", + " ev ind det charge xg yg zg rg \\\n", + "min 1 4041 1184 797 -16.040541 -16.070353 -35.943035 4.541135 \n", + "max 500 20919 1631 7674224 16.086744 15.934120 34.369064 16.135990 \n", + "\n", + " iphi tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "min -32767 0 401 1 0 0 0 -3.141586 -2.718763 5 \n", + "max 32767 146066 121703 324 140871 40124 65 3.141585 2.671790 8 \n", + "\n", + " trackID \n", + "min 10000002 \n", + "max 5000114052 \n", + " ev ind det charge xg yg zg rg \\\n", + "min 1 4487 1296 805 -16.04524 -16.070236 -43.468384 4.539285 \n", + "max 500 22665 1743 3752645 16.08004 15.932957 41.899700 16.137133 \n", + "\n", + " iphi tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "min -32766 0 401 1 0 0 0 -3.141546 -2.914465 6 \n", + "max 32767 146066 115736 233 143908 60793 59 3.141591 2.876371 9 \n", + "\n", + " trackID \n", + "min 10000002 \n", + "max 5000114033 \n", + " ev ind det charge xg yg zg rg \\\n", + "min 1 4974 1408 650 -16.038914 -16.070156 -52.979748 4.543934 \n", + "max 500 24450 1855 8573611 16.078123 15.933924 51.400307 16.140593 \n", + "\n", + " iphi tkId pt n1 tkId2 pt2 n2 phi eta seq \\\n", + "min -32766 0 401 1 0 0 0 -3.141555 -3.118078 7 \n", + "max 32766 146066 146147 417 141195 60793 50 3.141576 3.087029 10 \n", + "\n", + " trackID \n", + "min 10000010 \n", + "max 5000114059 \n" + ] + } + ], + "source": [ + "print 'min/max'\n", + "print hb1.agg(['min','max'])\n", + "print hb2.agg(['min','max'])\n", + "print hb3.agg(['min','max'])\n", + "print hb4.agg(['min','max'])\n", + "print hf1.agg(['min','max'])\n", + "print hf2.agg(['min','max'])\n", + "print hf3.agg(['min','max'])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def build(hh,n) :\n", + " return pd.DataFrame({ 'z'+n : hh['zg'],\n", + " 'r'+n : hh['rg'],\n", + " 'phi'+n : hh['phi'],\n", + " 'pt'+n : hh['pt'],\n", + " 'trackID' : hh['trackID']\n", + " })\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def fishBone(q,t,p,c) :\n", + " return pd.DataFrame({ 'th' : t,\n", + " 'pz' : p,\n", + " 'curv' : c,\n", + " 'trackID' : q['trackID']\n", + " })\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "548570\n", + "493149\n", + "434057\n", + "792527\n", + "2274850\n", + "540108\n", + "483260\n", + "931967\n", + "4230185\n", + " phi1 pt1 r1 trackID z1 phi2 pt2 r2 \\\n", + "0 -0.534839 1698 3.209876 10000005 -2.03853 -0.522814 1698 6.636066 \n", + "1 -0.534839 1698 3.209876 10000005 -2.03853 -0.522814 1698 6.636066 \n", + "2 -0.534839 1698 3.209876 10000005 -2.03853 -0.522814 1698 6.636066 \n", + "3 -0.534839 1698 3.209876 10000005 -2.03853 -0.522814 1698 6.636066 \n", + "4 -0.534839 1698 3.209876 10000005 -2.03853 -0.508068 1698 6.638935 \n", + "\n", + " z2 phi3 pt3 r3 z3 phi4 pt4 r4 \\\n", + "0 -5.024552 -0.506715 1698 11.091832 -8.901971 -0.469588 1698 16.203526 \n", + "1 -5.024552 -0.506715 1698 11.091832 -8.901971 -0.464408 1698 16.201468 \n", + "2 -5.024552 -0.506715 1698 11.091832 -8.901971 -0.488653 1698 16.214857 \n", + "3 -5.024552 -0.506715 1698 11.091832 -8.901971 -0.471780 1698 16.204531 \n", + "4 -5.171747 -0.506715 1698 11.091832 -8.901971 -0.469588 1698 16.203526 \n", + "\n", + " z4 \n", + "0 -13.062537 \n", + "1 -13.123804 \n", + "2 -13.366333 \n", + "3 -13.442224 \n", + "4 -13.062537 \n", + " phi1 pt1 r1 trackID z1 phi2 pt2 r2 \\\n", + "0 1.342908 791 3.215434 10000094 -6.674059 1.316544 791 6.533934 \n", + "1 0.042201 662 3.147929 10000100 -6.337495 0.071146 662 6.962423 \n", + "2 0.038396 662 3.150830 10000100 -6.388875 0.071146 662 6.962423 \n", + "3 -0.362996 487 2.798809 10000109 0.902371 -0.413166 487 7.010263 \n", + "4 -0.362996 487 2.798809 10000109 0.902371 -0.413166 487 7.010263 \n", + "\n", + " z2 phi3 pt3 r3 z3 phi4 pt4 r4 \\\n", + "0 -14.353554 1.287120 791 10.669562 -23.916361 1.260540 791 14.376982 \n", + "1 -14.991426 0.107237 662 11.064787 -24.246792 0.133849 662 14.090476 \n", + "2 -14.991426 0.107237 662 11.064787 -24.246792 0.133849 662 14.090476 \n", + "3 1.127291 -0.463537 487 11.100529 1.352261 -2.994291 487 8.460827 \n", + "4 1.127291 -0.463537 487 11.100529 1.352261 -2.864020 487 5.959154 \n", + "\n", + " z4 \n", + "0 -32.514194 \n", + "1 -31.091267 \n", + "2 -31.091267 \n", + "3 30.964153 \n", + "4 31.328598 \n", + " phi1 pt1 r1 trackID z1 phi2 pt2 r2 \\\n", + "0 -1.615744 740 3.405559 10000002 -9.927705 -1.644181 740 7.273387 \n", + "1 -1.615744 740 3.405559 10000002 -9.927705 -1.644181 740 7.273387 \n", + "2 1.914170 2464 2.671153 10000010 -9.608046 1.903031 2464 6.863056 \n", + "3 1.910948 2464 2.670602 10000010 -9.678793 1.903031 2464 6.863056 \n", + "4 1.922151 2464 2.672636 10000010 -9.662353 1.903031 2464 6.863056 \n", + "\n", + " z2 phi3 pt3 r3 z3 phi4 pt4 r4 \\\n", + "0 -22.09573 -1.673348 740 10.764234 -33.038609 -1.692311 740 13.137235 \n", + "1 -22.09573 -1.672782 740 10.705758 -32.855053 -1.692311 740 13.137235 \n", + "2 -26.02704 1.898713 2464 8.804473 -33.619747 1.895945 2464 10.021165 \n", + "3 -26.02704 1.898713 2464 8.804473 -33.619747 1.895945 2464 10.021165 \n", + "4 -26.02704 1.898713 2464 8.804473 -33.619747 1.895945 2464 10.021165 \n", + "\n", + " z4 \n", + "0 -40.457005 \n", + "1 -40.457005 \n", + "2 -38.362865 \n", + "3 -38.362865 \n", + "4 -38.362865 \n", + " phi1 pt1 r1 trackID z1 phi2 pt2 r2 \\\n", + "0 1.914170 2464 2.671153 10000010 -9.608046 1.898713 2464 8.804473 \n", + "1 1.910948 2464 2.670602 10000010 -9.678793 1.898713 2464 8.804473 \n", + "2 1.922151 2464 2.672636 10000010 -9.662353 1.898713 2464 8.804473 \n", + "3 2.955944 1148 2.702642 10000032 -10.496306 2.928084 1148 8.442572 \n", + "4 2.955944 1148 2.702642 10000032 -10.496306 2.928084 1148 8.442572 \n", + "\n", + " z2 phi3 pt3 r3 z3 phi4 pt4 r4 \\\n", + "0 -33.619747 1.895945 2464 10.021165 -38.362865 1.890452 2464 12.449927 \n", + "1 -33.619747 1.895945 2464 10.021165 -38.362865 1.890452 2464 12.449927 \n", + "2 -33.619747 1.895945 2464 10.021165 -38.362865 1.890452 2464 12.449927 \n", + "3 -34.392139 2.919404 1148 10.328422 -42.279213 2.910286 1148 12.075643 \n", + "4 -34.392139 2.921753 1148 9.830442 -40.189011 2.910286 1148 12.075643 \n", + "\n", + " z4 \n", + "0 -47.847328 \n", + "1 -47.847328 \n", + "2 -47.847328 \n", + "3 -49.587833 \n", + "4 -49.587833 \n" + ] + } + ], + "source": [ + "t12 = pd.merge(build(hb1,'1'),build(hb2,'2'),on='trackID')\n", + "t23 = pd.merge(build(hb2,'1'),build(hb3,'2'),on='trackID')\n", + "t34 = pd.merge(build(hb3,'1'),build(hb4,'2'),on='trackID')\n", + "t123 = pd.merge(t12,build(hb3,'3'),on='trackID')\n", + "print len(t12)\n", + "print len(t23)\n", + "print len(t34)\n", + "print len(t123)\n", + "t1234 = pd.merge(t123,build(hb4,'4'),on='trackID')\n", + "print len(t1234)\n", + "t1231 = pd.merge(t123,build(hf1,'4'),on='trackID')\n", + "print len(t1231)\n", + "t121 = pd.merge(t12,build(hf1,'3'),on='trackID')\n", + "t1212 = pd.merge(t121,build(hf2,'4'),on='trackID')\n", + "print len(t1212)\n", + "t11 = pd.merge(build(hb1,'1'),build(hf1,'2'),on='trackID')\n", + "t112 = pd.merge(t11,build(hf2,'3'),on='trackID')\n", + "t1123 = pd.merge(t112,build(hf3,'4'),on='trackID')\n", + "print len(t1123)\n", + "\n", + "qall = pd.concat([t1234,t1231,t1212,t1123])\n", + "print len(qall)\n", + "print t1234.head()\n", + "print t1231.head()\n", + "print t1212.head()\n", + "print t1123.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def plotTriplets(quad,mpt) :\n", + " \n", + " d1 = (quad['r1']*quad['z2']-quad['z1']*quad['r2'])/(quad['r1']-quad['r2'])\n", + " d2 = (quad['r2']*quad['z3']-quad['z2']*quad['r3'])/(quad['r2']-quad['r3'])\n", + " d3 = (quad['r3']*quad['z4']-quad['z3']*quad['r4'])/(quad['r3']-quad['r4'])\n", + " \n", + " z0cut = np.logical_and(abs(d1)<10.,np.logical_and(abs(d2)<10.,abs(d3)<10.))\n", + "\n", + " quadc = quad[np.logical_and(z0cut,quad['pt1']>mpt)]\n", + "\n", + "# print 'dpt'\n", + "# plt.hist(quad['pt1']-quad['pt2'],log=True, bins=100)\n", + "# plt.show()\n", + "# plt.hist(quad['pt2']-quad['pt3'],log=True, bins=100)\n", + "# plt.show()\n", + "# plt.hist(quad['pt3']-quad['pt4'],log=True, bins=100)\n", + "# plt.show()\n", + "\n", + "\n", + " print 'delta123', len(quadc)\n", + " \n", + "#dt,dtn = ml(t123['tpt'],t123['tpz'],t123['tpt2'],t123['tpz2'])\n", + "#plt.hist(dt[dt<0.1], log=True, bins=100)\n", + "#plt.show()\n", + "#plt.hist(dtn[dtn<0.1], log=True, bins=100)\n", + "#plt.show()\n", + "\n", + " \n", + " thcut = alignRZ(quadc,'r',0.6,True)\n", + " pzcut = alignRZ(quadc,'phi',1.0,True)\n", + " thcut2 = alignRPZ(quadc,'r',True)\n", + " pzcut2 = alignRPZ(quadc,'phi',True)\n", + "\n", + " curv = curvature(quadc,0.6,0.02,0.2,True)\n", + " rad = curvature(quadc,0.6,0.02,0.2,True,True)\n", + " field = rad/quadc['pt1']\n", + " print 'field'\n", + " plt.hist(field[abs(field)<500],log=True, bins=100)\n", + " plt.show()\n", + " print 'thcut,pzcut,curvcut',len(thcut)\n", + " plt.hist(thcut[thcut<0.004],log=True, bins=100)\n", + " plt.show()\n", + " plt.hist(pzcut[pzcut<0.4],log=True, bins=100)\n", + " plt.show()\n", + " plt.hist(curv[abs(curv)<0.4],log=True, bins=100)\n", + " plt.show()\n", + "\n", + " print 'thcut2,pzcut2',len(thcut2)\n", + " plt.hist(thcut2[abs(thcut2)<0.6],log=True, bins=100)\n", + " plt.show()\n", + " plt.hist(pzcut2[abs(pzcut2)<0.2],log=True, bins=100)\n", + " plt.show()\n", + " \n", + " print 'delta234'\n", + "\n", + " thcut = alignRZ(quadc,'r',0.6,False)\n", + " pzcut = alignRZ(quadc,'phi',1.0,False)\n", + " thcut2 = alignRPZ(quadc,'r',False)\n", + " pzcut2 = alignRPZ(quadc,'phi',False)\n", + " curv = curvature(quadc,0.6,0.02,0.2,False)\n", + " rad = curvature(quadc,0.6,0.02,0.2,False,True)\n", + " field = rad/quadc['pt1']\n", + " print 'field'\n", + " plt.hist(field[abs(field)<500],log=True, bins=100)\n", + " plt.show()\n", + " print 'thcut,pzcut,curvcut',len(thcut)\n", + " plt.hist(thcut[thcut<0.004],log=True, bins=100)\n", + " plt.show()\n", + " plt.hist(pzcut[pzcut<0.4],log=True, bins=100)\n", + " plt.show()\n", + " plt.hist(curv[abs(curv)<0.4],log=True, bins=100)\n", + " plt.show()\n", + "\n", + " \n", + " print 'thcut2,pzcut2',len(thcut2)\n", + " plt.hist(thcut2[abs(thcut2)<0.6],log=True, bins=100)\n", + " plt.show()\n", + " plt.hist(pzcut2[abs(pzcut2)<0.2],log=True, bins=100)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "def plotDoublets(quad,mpt) :\n", + " quadc = quad[quad['pt1']>mpt]\n", + "\n", + " maxc = 1000./(mpt*87.)\n", + "\n", + " print 'dphi'\n", + " d1 = quadc['phi2']-quadc['phi1']\n", + " plt.hist(d1[abs(d1)<.1], bins=100,log=True)\n", + " plt.show()\n", + " d2 = quadc['phi3']-quadc['phi2']\n", + " plt.hist(d2[abs(d2)<.1], bins=100,log=True)\n", + " plt.show()\n", + " d3 = quadc['phi4']-quadc['phi3']\n", + " plt.hist(d3[abs(d3)<.1], bins=100,log=True)\n", + " plt.show()\n", + "\n", + " pcut = np.logical_and(abs(d1)<0.05,np.logical_and(abs(d2)<0.05,abs(d3)<0.05))\n", + "\n", + "\n", + " print 'dphiNor'\n", + " \n", + " pc = phicut(quadc['r1'],quadc['r2'],maxc)\n", + " d1 = (quadc['phi2']-quadc['phi1'])/pc\n", + " plt.hist(d1[abs(d1)<2.], bins=100,log=True)\n", + " plt.show()\n", + " pc = phicut(quadc['r2'],quadc['r3'],maxc)\n", + " d2 = (quadc['phi3']-quadc['phi2'])/pc\n", + " plt.hist(d2[abs(d2)<2.], bins=100,log=True)\n", + " plt.show()\n", + " pc = phicut(quadc['r3'],quadc['r4'],maxc)\n", + " d3 = (quadc['phi4']-quadc['phi3'])/pc\n", + " plt.hist(d3[abs(d3)<2.], bins=100,log=True)\n", + " plt.show()\n", + "\n", + "\n", + " print 'dz'\n", + " d1 = quadc['z2']-quadc['z1']\n", + " plt.hist(d1[np.logical_and(pcut,abs(d1)<35)], bins=100,log=True)\n", + " plt.show()\n", + " d2 = quadc['z3']-quadc['z2']\n", + " plt.hist(d2[np.logical_and(pcut,abs(d2)<35)], bins=100,log=True)\n", + " plt.show()\n", + " d3 = quadc['z4']-quadc['z3']\n", + " plt.hist(d3[np.logical_and(pcut,abs(d3)<35)], bins=100,log=True)\n", + " plt.show()\n", + "\n", + " print 'z0'\n", + " d1 = (quadc['r1']*quadc['z2']-quadc['z1']*quadc['r2'])/(quadc['r1']-quadc['r2'])\n", + " plt.hist(d1[np.logical_and(pcut,abs(d1)<50)], bins=100,log=True)\n", + " plt.show()\n", + " d2 = (quadc['r2']*quadc['z3']-quadc['z2']*quadc['r3'])/(quadc['r2']-quadc['r3'])\n", + " plt.hist(d2[np.logical_and(pcut,abs(d2)<50)], bins=100,log=True)\n", + " plt.show()\n", + " d3 = (quadc['r3']*quadc['z4']-quadc['z3']*quadc['r4'])/(quadc['r3']-quadc['r4'])\n", + " plt.hist(d3[np.logical_and(pcut,abs(d3)<50)], bins=100,log=True)\n", + " plt.show()\n", + " \n", + "\n", + " pcut = np.logical_and(abs(d1)<10.,np.logical_and(abs(d2)<10.,abs(d3)<10.))\n", + "\n", + "\n", + " print 'dr'\n", + " d1 = quadc['r2']-quadc['r1']\n", + " plt.hist(d1[np.logical_and(pcut,abs(d1)<20)], bins=100,log=True)\n", + " plt.show()\n", + " d2 = quadc['r3']-quadc['r2']\n", + " plt.hist(d2[np.logical_and(pcut,abs(d2)<20)], bins=100,log=True)\n", + " plt.show()\n", + " d3 = quadc['r4']-quadc['r3']\n", + " plt.hist(d3[np.logical_and(pcut,abs(d3)<20)], bins=100,log=True)\n", + " plt.show()\n", + "\n", + " print 'dphi zcut'\n", + " d1 = quadc['phi2']-quadc['phi1']\n", + " plt.hist(d1[np.logical_and(pcut,abs(d1)<.1)], bins=100,log=True)\n", + " plt.show()\n", + " d2 = quadc['phi3']-quadc['phi2']\n", + " plt.hist(d2[np.logical_and(pcut,abs(d2)<.1)], bins=100,log=True)\n", + " plt.show()\n", + " d3 = quadc['phi4']-quadc['phi3']\n", + " plt.hist(d3[np.logical_and(pcut,abs(d3)<.1)], bins=100,log=True)\n", + " plt.show()\n", + "\n", + "\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta123 227975\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 227975\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADRZJREFUeJzt3W+MHPddx/H3N46SilBOKfajJM45ulDhVEiFJUVI/BOgOtBLEO2DBCG1EMUqNAKJJwSFR/Ck8ACpDyIqC1WhD6gbeIB8xFCVUjdCaqBOCU2TKNRxU8UWIiSgQ0ApCv3y4CbN+Hp33r2d2Zn93vslnTw7O7v39dj72d9+5zezkZlIkuq6ZugCJEn9MuglqTiDXpKKM+glqTiDXpKKM+glqTiDXpKKM+glqTiDXpKKu3boAgAOHz6cq6urQ5chSUvlqaeeejUzj1xtu1EE/erqKufPnx+6DElaKhHxtWm2s3UjScUZ9JJUnEEvScUZ9JJU3KBBHxHrEXFqc3NzyDIkqbRBgz4zNzLz5MrKypBlSFJptm4kqTiDXpKKG8UJU/NYfejxby2/9OGfHbASSRonR/SSVJxBL0nFGfSSVJxBL0nFGfSSVJxnxkpScYNOr8zMDWBjMpk80MXzOdVSkr6drRtJKs6gl6TiDHpJKs6gl6TiDHpJKs6gl6TiDHpJKs6gl6Tilv569Lvx5ClJ2uKIXpKKM+glqTiDXpKKM+glqTgvUyxJxQ0a9Jm5kZknV1ZWhixDkkqzdSNJxRn0klScQS9JxZU9M7bNs2QlHWSO6CWpOINekooz6CWpOINekooz6CWpOINekooz6CWpOINekooz6CWpOINekoo7EJdAaPNyCJIOGkf0klScQS9JxRn0klScQS9JxfUS9BFxQ0Scj4j39PH8kqTpTRX0EfGxiHglIr68bf2JiHghIi5ExEOtu34TeKzLQiVJ+zPtiP5R4ER7RUQcAh4B7gKOA/dFxPGI+GngOeCVDuuUJO3TVPPoM/OJiFjdtvpO4EJmXgSIiNPAPcB3AjewFf5fj4izmfnNziqWJM1knhOmbgJebt2+BLwrMx8EiIgPAK/uFvIRcRI4CXD06NE5ypAk7aW3WTeZ+Whm/sUe95/KzElmTo4cOdJXGZJ04M0zor8M3NK6fXOzbmm0L4cAXhJBUk3zjOi/ANweEcci4jrgXuBMN2VJkroy7fTKTwCfB94eEZci4v7MfB14EPgU8DzwWGY+O8svj4j1iDi1ubk5a92SpClNO+vmvl3WnwXO7veXZ+YGsDGZTB7Y73NIkvbmJRAkqTiDXpKKGzTo7dFLUv8GDfrM3MjMkysrK0OWIUml2bqRpOIMekkqzqCXpOI8GCtJxc1zrZu5je2Eqfa1b7zujaQqbN1IUnEGvSQVZ9BLUnEGvSQV56wbSSrOSyBIUnG2biSpOINekooz6CWpuEHPjB0zz5KVVIUjekkqzumVklSc0yslqThbN5JUnEEvScUZ9JJUnEEvScUZ9JJUnEEvScUNemZsRKwD62tra0OWcVWeJStpmTmPXpKKs3UjScUZ9JJUnEEvScUZ9JJUnEEvScUZ9JJUnN8wNSPn1EtaNo7oJak4v2FKkorzzFhJKs7WjSQVZ9BLUnHOupmDM3AkLQNH9JJUnEEvScXZuumIbRxJY+WIXpKKM+glqTiDXpKKM+glqTiDXpKKM+glqTiDXpKKG3QefUSsA+tra2tDltE559RLGhMvUyxJxdm6kaTiDHpJKs5r3fTMfr2koRn0C2ToSxqCrRtJKs6gl6TiDHpJKs4e/UDs10taFEf0klScQS9JxRn0klScPfoRsF8vqU+O6CWpOINekoqzdTNi7ZZOm+0dSbMw6Edmt3CXpP2ydSNJxRn0klScQS9JxRn0klRc5wdjI+J7gV8HDgOfycw/7Pp36E2ebCXpaqYK+oj4GPAe4JXMfEdr/QngI8Ah4I8y88OZ+TzwwYi4Bvg4YNB3zJk5kmYxbevmUeBEe0VEHAIeAe4CjgP3RcTx5r67gceBs51VKknal6lG9Jn5RESsblt9J3AhMy8CRMRp4B7gucw8A5yJiMeBP9npOSPiJHAS4OjRo/sqXleyjSNpJ/P06G8CXm7dvgS8KyJ+HPh54Hr2GNFn5ingFMBkMsk56tBV+AYgHWydH4zNzHPAua6fV7Oxjy/pDfNMr7wM3NK6fXOzTpI0IvME/ReA2yPiWERcB9wLnJnlCSJiPSJObW5uzlGGJGkvUwV9RHwC+Dzw9oi4FBH3Z+brwIPAp4Dngccy89lZfnlmbmTmyZWVlVnrVgdWH3r8Wz+S6pp21s19u6w/i1MoJWnUvEzxAePoXTp4DHoBTsGUKhv0omYejJWk/g06os/MDWBjMpk8MGQdutL29o4jfGm5eZliSSrOHr1mYi9fWj6DBn1ErAPra2trQ5ahq3CmjrTcBm3deMKUJPXP1o06MWtLxxaQtDgGvTpniEvjYtBr3+zdS8vBoNfC7PbG4CcAqV/OulGvHPVLw/PMWC0FR/3S/tm60ah0Fei+MUhv8hIIklScI3otNUfu0tUZ9BotD+RK3TDotXRmfQOYZtTvJwNV5hePSFJxXtRMkopz1o0kFWfQS1JxHoxVGdMcpPWgqw4iR/SSVJwjeh1YztPXQWHQS3vY683A1o+WhZcpljpg719j5mWKpX2y9aNlYetG2sYAVzXOupGk4gx6SSrOoJek4uzRSx3brcc/62wcZ/KoKwa9tCDTvAF4IFh9MOilJeNIX7OyRy9JxfkNU5JUnN8wJUnF2aOXBtbHAVj7+Goz6KUl0NWbgW8AB5NBL2kqvkksL4NeKm7WTwNDBrpvJv0w6KUlNoZg3P5GYkCPj0EvFTHPyF21ecKUJBXniF7S0hpD62oZGPSSZrZX22e38J0nlPsI9LHV0yeDXtKu7OPXYNBLWrhFjoiXbfTdB4NeUm/6vrzDbuv7CPRl/nRj0EsapXmCdahQHuunBy9TLEnFeZliSSrO1o2kA2/RrZ5Ft3g8M1aSinNEL2lQixxNL/PMmXk4opek4gx6SSrO1o0kzWEZ2kEGvST1YExfyGLQS9ICDDnyt0cvScUZ9JJUnEEvScUZ9JJUnEEvScUZ9JJUnEEvScUZ9JJUnEEvScVFZg5dAxHxr8DX9vnww8CrHZbTFeuajXXNbqy1Wdds5qnr1sw8crWNRhH084iI85k5GbqO7axrNtY1u7HWZl2zWURdtm4kqTiDXpKKqxD0p4YuYBfWNRvrmt1Ya7Ou2fRe19L36CVJe6swopck7WHUQR8RJyLihYi4EBEP7XD/9RHxyeb+v4uI1dZ9v9WsfyEi3j2GuiJiNSK+HhFPNz8fXXBdPxoRX4yI1yPifdvue39EfKX5ef+I6vq/1v46s+C6fiMinouIL0XEZyLi1tZ9Q+6vveoacn99MCKeaX7330bE8dZ9Q74ed6xr6Ndja7v3RkRGxKS1rtv9lZmj/AEOAS8CtwHXAf8IHN+2za8CH22W7wU+2Swfb7a/HjjWPM+hEdS1Cnx5wP21Cnwf8HHgfa31bwMuNn/e2CzfOHRdzX3/OeD++gngO5rlX2n9Ow69v3asawT767tay3cDf9UsD/163K2uQV+PzXZvBZ4AngQmfe2vMY/o7wQuZObFzPxf4DRwz7Zt7gH+uFn+M+AnIyKa9acz8xuZ+VXgQvN8Q9fVp6vWlZkvZeaXgG9ue+y7gU9n5r9l5r8DnwZOjKCuPk1T12cz87+bm08CNzfLQ++v3erq0zR1/Ufr5g3AGwcAB3097lFXn6bJCYDfBX4P+J/Wus7315iD/ibg5dbtS826HbfJzNeBTeC7p3zsEHUBHIuIf4iIz0XEj3RU07R19fHYvp/7LRFxPiKejIif66im/dR1P/CX+3zsouqCgfdXRHwoIl4Efh/4tVkeO0BdMODrMSK+H7glM7d/mWzn+8svB1+sfwaOZuZrEfEDwJ9HxB3bRhy60q2ZeTkibgP+JiKeycwXF1lARPwiMAF+bJG/92p2qWvQ/ZWZjwCPRMQvAL8NdHr8Yr92qWuw12NEXAP8AfCBvn8XjHtEfxm4pXX75mbdjttExLXACvDalI9deF3NR7HXADLzKbZ6b9+zwLr6eGyvz52Zl5s/LwLngHcusq6I+CngYeDuzPzGLI8doK7B91fLaeCNTxSD76+d6hr49fhW4B3AuYh4Cfgh4ExzQLb7/dXHgYiODmZcy9ZBrmO8eTDjjm3bfIgrD3o+1izfwZUHMy7S3cGfeeo68kYdbB2kuQy8bVF1tbZ9lG8/GPtVtg4s3tgsj6GuG4Hrm+XDwFfY4YBWj/+O72TrxX/7tvWD7q896hp6f93eWl4HzjfLQ78ed6trFK/HZvtzvHkwtvP9NfdfqM8f4GeAf2r+Uz/crPsdtkYxAG8B/pStgxV/D9zWeuzDzeNeAO4aQ13Ae4FngaeBLwLrC67rB9nq9/0XW598nm099pebei8AvzSGuoAfBp5p/tM/A9y/4Lr+GviX5t/raeDMSPbXjnWNYH99pPX/+7O0gm3g1+OOdQ39ety27TmaoO9jf3lmrCQVN+YevSSpAwa9JBVn0EtScQa9JBVn0EtScQa9JBVn0EtScQa9JBX3/65huqA+DjXjAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 227975\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta234\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 227975\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 227975\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta123 40709\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 40709\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 40709\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta234\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 40709\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 40709\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta123 152561\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 152561\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 152561\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta234\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 152561\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 152561\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta123 400905\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 400905\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 400905\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADnVJREFUeJzt3X+sZPVZx/H34yJLpHoL7lorsNwluzaiMTReaWKjRVtbUG5plCjYGlTCxhoSE2NSGuI/TUyq/5gmNuKmaSkaS7FG3Qso4UfX+gcoS6WUH6EstA27YimtvVYlVOTxjzmbDteduzN3ztxz5pn3K7m5M+fHzLNn5n7mO9/zPd+NzESSVNd3dF2AJGm2DHpJKs6gl6TiDHpJKs6gl6TiDHpJKs6gl6TiDHpJKs6gl6TiTuu6AIBdu3bl8vJy12VI0lx56KGHXsjM3afarhdBv7y8zJEjR7ouQ5LmSkR8eZzt7LqRpOIMekkqrtOgj4jViDi4vr7eZRmSVFqnQZ+Za5l5YGlpqcsyJKk0u24kqTiDXpKKM+glqTiDXpKK68UFU1KfLN9wx0mXf+mDP7/NlUjtsEUvScUZ9JJUnEEvScUZ9JJUXKcnYyNiFVjdt29fl2VII0/AShV0GvSZuQasraysXNdlHdI4Nn4YOApH88KuG0kqzqCXpOIMekkqzqCXpOIMekkqzqCXpOKc1EwLy7HzWhQGvbRFwx8UjqlXn9l1I0nFGfSSVJxBL0nFGfSSVJxBL0nFGfSSVFynQR8RqxFxcH19vcsyJKm0ToM+M9cy88DS0lKXZUhSaV4wpYXi1bBaRAa91AKvklWfeTJWkooz6CWpOINekooz6CWpOINekooz6CWpOINekooz6CWpOINekooz6CWpOKdAUHnOb6NFZ9BLLXPeG/WNXTeSVJxBL0nFGfSSVJxBL0nFGfSSVJxBL0nFGfSSVJxBL0nFzSToI+LMiDgSEZfP4vElSeMb68rYiPgocDnwfGb+yNDyS4EPATuAj2TmB5tV7wNua7lWaWxOeyB927hTINwM/DFwy4kFEbED+DDws8Ax4MGIOAScAzwOnNFqpdIccjoE9cFYQZ+Zn4mI5Q2LLwaOZuYzABFxK3AF8BrgTOBC4MWIuDMzX2mtYknSRKaZ1Owc4Nmh+8eAN2Xm9QAR8WvAC6NCPiIOAAcA9uzZM0UZkqTNzGzUTWbenJm3b7L+YGauZObK7t27Z1WGJC28aYL+OHDe0P1zm2WSpB6ZJugfBPZHxN6IOB24CjjUTlmSpLaMFfQR8QngfuANEXEsIq7NzJeB64G7gCeA2zLzsUmePCJWI+Lg+vr6pHVLksY07qibq0csvxO4c6tPnplrwNrKysp1W30MSdLmnAJBkooz6CWpuE6D3j56SZq9aS6Ympp99GqT89tIJ9dp0EuLxHlv1BX76CWpOINekooz6CWpOEfdSFJxnQZ9Zq5l5oGlpaUuy5Ck0uy6kaTiDHpJKs6gl6TiDHpJKs5RN5JUnHPdaK45v410anbdSFJxBr0kFefslVIHnMlS28kWvSQVZ9BLUnEOr5Sk4pzUTJKKs+tGkooz6CWpOINekooz6CWpOC+Y0txxfhtpMrboJak4g16Siuu06yYiVoHVffv2dVmG1CnnvdGsecGUJBVn140kFWfQS1JxBr0kFWfQS1JxBr0kFWfQS1JxToGgueC0B9LW2aKXpOJs0Us94lWymgX/z1hJKs4pECSpOPvoJak4g16SijPoJak4g16SijPoJak4x9Grt7waVmqHLXpJKs6gl6TiDHpJKs4+eqmnnPdGbbFFL0nFGfSSVJxBL0nF2UevXnHsvNQ+56OXpOI6bdFn5hqwtrKycl2XdUh95wgcTcM+ekkqzqCXpOIMekkqzqCXpOIMekkqzqCXpOK8YEqd8yIpabZs0UtScbbopTnjxVOalC16SSrOoJek4gx6SSrOoJek4gx6SSrOoJek4gx6SSrOcfTqhFfDStvHoJfmmBdPaRx23UhScQa9JBVn0EtSca330UfEDwG/DewC7s3MP2n7OTSfPAE7W/bXa5SxWvQR8dGIeD4iHt2w/NKIeDIijkbEDQCZ+URm/ibwS8Cb2y9ZkjSJcbtubgYuHV4QETuADwOXARcCV0fEhc26dwJ3AHe2VqkkaUvGCvrM/Azw9Q2LLwaOZuYzmfkt4Fbgimb7Q5l5GfDuNouVJE1umj76c4Bnh+4fA94UEZcAvwDsZJMWfUQcAA4A7NmzZ4oyJEmbaf1kbGYeBg6Psd1B4CDAyspKtl2HtMg8Math0wyvPA6cN3T/3GaZJKlHpmnRPwjsj4i9DAL+KuBXWqlKZTikUureuMMrPwHcD7whIo5FxLWZ+TJwPXAX8ARwW2Y+NsmTR8RqRBxcX1+ftG5J0pjGatFn5tUjlt/JFEMoM3MNWFtZWbluq48hSdqcUyBIUnFOUywV5wgc2aKXpOI6bdFHxCqwum/fvi7LUMscaSP1S6dB78lYqTt26SwO++jVClvx88HXaTHZRy9JxRn0klRcp0HvlbGSNHudBn1mrmXmgaWlpS7LkKTSPBmrLfPEnjQfDHpJr+Kwy3o8GStJxdmil2Q3XHFOgaCJGAjS/HHUjSQVZx+9JBVn0EtScZ6M1f+zsR/eIXYCh13OM4Nep+QJWGm+GfQCDHOpModXShppVAPAbpz54v8wtcBsxUuLwa6bBWO4S4vHoJfUKrt1+sdx9JJUnC36OTSqxTTOcqltvr/6z6CfE/4xad7ZpdMdg74oPxgknWDQ94AtHS0a3/Pbywum5pwtd827Ue9hPwDa4wVTHRknoA1xaWv8xvBqdt30jOEuqW0GvaSZmabhMukwYo1m0EuaW4b+eLwyVpKKs0Uvqfc8dzUdg34G/DopbT8/DEYz6CWVZsPLoG+N4+Kl+VX9oi2DfoRxWgGGuzRfFvXvsewUCG1+XfOrn6R5VmoKhElb2Ia2pEVg182EFvWrn6RT62tD0qCXpAn1NdBHWeig39g6n4cXTNL2mbdAH2Uhgt7uFkld6/JDYyGCflx+IEiqyKCXpDGMaghOurwLBr0kbbPt7sZxmmJJKs6gl6TiDHpJKm7u++j7dMJDkvrIFr0kFWfQS1JxBr0kFddp0EfEakQcXF9f77IMSSqt06DPzLXMPLC0tNRlGZJUml03klScQS9JxRn0klScQS9JxUVmdl0DEfFV4Mtb3H0X8EKL5bTFuiZjXZPpa13Q39oq1nV+Zu4+1Ua9CPppRMSRzFzpuo6NrGsy1jWZvtYF/a1tkeuy60aSijPoJam4CkF/sOsCRrCuyVjXZPpaF/S3toWta+776CVJm6vQopckbWIugj4izo6IuyPiqeb3WSfZ5qKIuD8iHouIRyLil4fW7Y2If4qIoxHxyYg4fbvqarb7+4j4RkTcvmH5zRHxxYh4uPm5qCd1dX28rmm2eSoirhlafjginhw6Xt83ZT2XNo93NCJuOMn6nc2//2hzPJaH1r2/Wf5kRLxjmjraqisiliPixaHjc9M21/VTEfHZiHg5Iq7csO6kr2kP6vrfoeN1aJvr+p2IeLzJq3sj4vyhde0er8zs/Q/wh8ANze0bgD84yTY/COxvbv8A8Bzw2ub+bcBVze2bgPduV13NurcCq8DtG5bfDFzZxfE6RV2dHS/gbOCZ5vdZze2zmnWHgZWWatkBPA1cAJwOfA64cMM2vwXc1Ny+Cvhkc/vCZvudwN7mcXb0oK5l4NG2308T1LUM/Chwy/D7erPXtMu6mnX/2eHx+mngu5rb7x16HVs/XnPRogeuAD7e3P448K6NG2TmFzLzqeb2vwLPA7sjIoCfAT612f6zqqup517gmy095zi2XFcPjtc7gLsz8+uZ+e/A3cClLT3/sIuBo5n5TGZ+C7i1qW9UvZ8C3tocnyuAWzPzpcz8InC0ebyu65qlU9aVmV/KzEeAVzbsO8vXdJq6Zmmcuj6dmf/d3H0AOLe53frxmpegf11mPtfc/jfgdZttHBEXM/gUfRr4XuAbmflys/oYcE4XdY3w+81Xtz+KiJ09qKvr43UO8OzQ/Y3P/7Hma/bvTRlup3qeV23THI91BsdnnH27qAtgb0T8S0T8Q0T8ZEs1jVvXLPad9WOfERFHIuKBiGirQbOVuq4F/m6L+55Sb/5z8Ii4B/j+k6y6cfhOZmZEjBwqFBGvB/4MuCYzX5m2odNWXSO8n0Hgnc5giNX7gA/0oK4tm3Fd787M4xHx3cBfAb/K4Ou4Bp4D9mTm1yLix4C/iYgfzsz/6LqwHju/eU9dANwXEZ/PzKe3s4CIeA+wArxlVs/Rm6DPzLeNWhcRX4mI12fmc02QPz9iu+8B7gBuzMwHmsVfA14bEac1rZ9zgePbWdcmj32idftSRHwM+N0e1NX18ToOXDJ0/1wGffNk5vHm9zcj4i8YfD3eatAfB87b8Dwb/50ntjkWEacBSwyOzzj7btWW68pBB+9LAJn5UEQ8zeDc1ZFtqmuzfS/ZsO/hFmo68dhbfi2G3lPPRMRh4I0MegK2pa6IeBuDRtBbMvOloX0v2bDv4WmKmZeum0PAiTPP1wB/u3GDGIwM+Wvglsw80b9M8+b/NHDlZvvPqq7NNGF3ol/8XcCjXdfVg+N1F/D2iDgrBqNy3g7cFRGnRcQugIj4TuBypjteDwL7YzDC6HQGJzU3jroYrvdK4L7m+BwCrmpGv+wF9gP/PEUtrdQVEbsjYgdA00Ldz+BE3nbVNcpJX9Ou62rq2dnc3gW8GXh8u+qKiDcCfwq8MzOHGz3tH69ZnHFu+4dB/+O9wFPAPcDZzfIV4CPN7fcA/wM8PPRzUbPuAgZ/iEeBvwR2blddzf1/BL4KvMigv+0dzfL7gM8zCKw/B17Tk7q6Pl6/0Tz3UeDXm2VnAg8BjwCPAR9iypEuwM8BX2DQgruxWfYBBn94AGc0//6jzfG4YGjfG5v9ngQua/n9vqW6gF9sjs3DwGeB1W2u68eb99F/Mfjm89hmr2nXdQE/0fz9fa75fe0213UP8BW+nVeHZnW8vDJWkoqbl64bSdIWGfSSVJxBL0nFGfSSVJxBL0nFGfSSVJxBL0nFGfSSVNz/Aala2/6PgVtuAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta234\n", + "field\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut,pzcut,curvcut 400905\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADXtJREFUeJzt3W+oZPdZwPHvY/5spZHbNgllyWa9iVtqU5FYxq1QkVApbtpuIlIk4ptCyGJqwD+I3VKQKAi1IvaFxbBKXNtq0rX6Ym9bKP1jjS9KzV2tMX9Yvdm2ZEPsmpauCtIa8/hizurc2Z07M/fOzDnzzPcDw849c+bMs7+955lnnt9vzkZmIkmq63vaDkCSNF8mekkqzkQvScWZ6CWpOBO9JBVnopek4kz0klSciV6SijPRS1JxV7cdAMANN9yQ6+vrbYchSUvlzJkzL2bmjeP260SiX19fZ3Nzs+0wJGmpRMTXJ9nP1o0kFWeil6TiTPSSVJyJXpKKM9FLUnEmekkqzkQvScWZ6CWpuE58YWov1o9/6orbv/aBdyw4EknqpqVP9KMMvgGY9CWtsrKJfpBJX9IqazXRR8RR4OihQ4cW9pomfUmrptXJ2MzcyMxja2trbYYhSaWtROtmlOGJXCt8SRWtdKIfZltHUkWuo5ek4kz0klScrZsRbONIqsKKXpKKs6KfgNW9pGVmRS9JxZnoJak4WzdTso0jadlY0UtScVb0e2B1L2kZWNFLUnEmekkqztbNjNjGkdRVVvSSVJyJXpKKs3UzB7ZxJHWJFb0kFWeil6TiTPSSVNxcevQR8Urgb4AHM/OT83iNZWG/XlLbJqroI+LhiLgQEU8ObT8SEWcjYisijg889F7g1CwDlSTtzqStm5PAkcENEXEV8GHgTuA24Oci4raIeBvwNHBhhnFKknZpotZNZj4WEetDmw8DW5l5DiAiHgXuBq4DXkk/+f9XRHw6M1+eWcRLzDaOpDbspUd/E/DcwM/ngTdn5gMAEfFu4MVRST4ijgHHAA4ePLiHMCRJO5nbF6Yy8+SYx08AJwB6vV7OK46usrqXtCh7WV75PHDzwM8Hmm2SpA7ZS6J/HHhdRNwSEdcC9wCnZxOWJGlWJl1e+QjwJeD1EXE+Iu7NzJeAB4DPAM8ApzLzqWlePCKORsSJixcvThu3JGlCkdl+e7zX6+Xm5uaunjvY667Afr2kSUXEmczsjdvPSyBIUnEmekkqzuvRd4zLLiXNWqsVvZOxkjR/rSb6zNzIzGNra2tthiFJpdmjl6TiTPSSVJyTsR3mxKykWXAyVpKKa7Wiz8wNYKPX693XZhzLwOpe0m7Zo5ek4kz0klSck7FLyDaOpGlY0UtSca66kaTivASCJBVnj37J2a+XNI49ekkqzkQvScXZuinENo6kK7Gil6TiXF4pScW5vFKSirN1I0nFORlblBOzki6xopek4kz0klScrZsVYBtHWm1W9JJUnIlekorzC1OSVJxfmJKk4pyMXTGDE7ODnKSV6rJHL0nFmeglqTgTvSQVZ6KXpOJM9JJUnKtuBHiZBKkyK3pJKs6KXpcZXmtvhS8tNy+BIEnFeQkESSrO1o3GcqJWWm5OxkpScSZ6SSrORC9Jxdmj11Ts10vLx4pekooz0UtScSZ6SSrORC9JxZnoJak4V91o11yBIy0HK3pJKs5EL0nF2brRTNjGkbrL69FLUnGtVvSZuQFs9Hq9+9qMQ7NldS91iz16SSrOHr3myupeap8VvSQVZ6KXpOJM9JJUnIlekopzMlYL48Ss1A4rekkqzoperbC6lxbHil6SijPRS1JxJnpJKs4evVpnv16aLyt6SSrORC9Jxdm6UafYxpFmz4pekooz0UtScSZ6SSrORC9JxZnoJak4V92oswZX4AxyNY40nZlX9BHxhoh4KCI+ERH3z/r4kqTpTJToI+LhiLgQEU8ObT8SEWcjYisijgNk5jOZ+QvAzwJvmX3IkqRpTNq6OQn8AfCRSxsi4irgw8DbgPPA4xFxOjOfjoi7gPuBj842XMkvVUnTmqiiz8zHgG8NbT4MbGXmucz8LvAocHez/+nMvBP4+VkGK0ma3l4mY28Cnhv4+Tzw5oi4A/gZYB/w6VFPjohjwDGAgwcP7iEMrTKre2m8ma+6ycwvAl+cYL8TwAmAXq+Xs45DktS3l1U3zwM3D/x8oNkmSeqQvST6x4HXRcQtEXEtcA9wejZhSZJmZdLllY8AXwJeHxHnI+LezHwJeAD4DPAMcCozn5rmxSPiaEScuHjx4rRxS5ImFJntt8d7vV5ubm7u6rmjvj2p1ebErFZBRJzJzN64/bzWjSQVZ6KXpOJaTfT26CVp/lq9emVmbgAbvV7vvjbjUD1e+VL6f7ZuJKk4E70kFWeil6Ti/B+mtFK8CJpWkatuJKk4V91oZVnda1XYupEw6as2J2MlqTgremkHVvqqwIpekoprtaKPiKPA0UOHDrUZhrSNl75WNa1W9Jm5kZnH1tbW2gxDkkqzdSNJxZnoJak4V91IExru3bsKR8vCil6SirOil3bJNfZaFl7UTJKKc3mlJBVnj16SirNHL82A/Xp1mYlemqNRbwC+MWiRbN1IUnFW9NKMzeqiaFb9mhUTvbQgXhVTbTHRSy2bVeXuJwCN4hemJKk4vzAlScW56kaSirNHL3WIK3Y0D1b0klSciV6SirN1Iy2BUS0d2zKahBW9JBVnopek4mzdSMW5AkcmemmJef0cTcJLIEhSca1W9Jm5AWz0er372oxDWhWTtHFs9dRj60aSLaDiTPSS5sZPB91gopc0kom6BtfRS1JxJnpJKs7WjbSinIBdHSZ6SVOzd79cbN1IUnEmekkqztaNpE6yPTQ7VvSSVJwVvaSJTLpKZ5L9rNYXy0QvaSHmvZzTN4/RTPSSOm9WSXxV3wy8Hr0kFef16CWtpFWq7m3dSFpaXsZhMiZ6SXsyy2Q7j8Ttm4GJXpImssytHr8wJUnFWdFLapWtlfkz0UvSjHS1vWOil6QRqnzaMNFLKmcvCXpWyX34OG1W+CZ6SdqD3bwxLLrF46obSSrOil7SUqnSN18kE70kTWnZ3mxM9JJW3iISd5tvDvboJak4E70kFWeil6TiTPSSVJyJXpKKM9FLUnEmekkqzkQvScWZ6CWpuMjMtmMgIv4N+Poun34D8OIMw5kV45qOcU2vq7EZ13T2Etf3Z+aN43bqRKLfi4jYzMxe23EMM67pGNf0uhqbcU1nEXHZupGk4kz0klRchUR/ou0ARjCu6RjX9Loam3FNZ+5xLX2PXpK0swoVvSRpJ5nZ+g04ApwFtoDjV3h8H/Dx5vEvA+sDj72v2X4W+KlxxwRuaY6x1Rzz2o7EdRL4KvCV5nb7guN6GLgAPDl0rNcAnwX+pfnz1R2J60Hg+YHxevui4gJuBv4aeBp4CvilLozXmLjaHK9XAH8H/GMT12924XwcE9dJWjwfm8euAv4B+ORuxmvbsSbZaZ635i/zLHArcG0z6LcN7fMe4KHm/j3Ax5v7tzX772sG4NnmeCOPCZwC7mnuPwTc35G4TgLvamO8msd+AngTlyfUD1765QWOA7/TkbgeBH6tpd+v/cCbmn2+D/jngX/H1sZrTFxtjlcA1zX7XEM/Uf1YB87HneI6SYvnY/P4rwJ/zvZEP9F4Dd+60Lo5DGxl5rnM/C7wKHD30D53A3/a3P8E8JMREc32RzPzO5n5VfrvcodHHbN5zlubY9Ac86fbjmvCcZpnXGTmY8C3rvB6g8da9HjtFNekZh5XZr6QmX/fxPcfwDPATVc41kLHa0xck5pHXJmZ/9nsf01zy7bPx1FxjR2hOccFEBEHgHcAf3zpIFOO1zZdSPQ3Ac8N/Hyey385/2+fzHwJuAhcv8NzR22/Hvh2c4xRr9VGXJf8dkQ8ERG/HxH7FhjXTl6bmS809/8VeG1H4gJ4oBmvhyPi1W3EFRHrwI/QrwahI+N1hbigxfGKiKsi4iv023Cfzcwv0/75OCquS9o8Hz8E/Drw8sDj04zXNl1I9Op7H/CDwI/S7/O+t91wLpf9z4tdWab1h8APALcDLwC/t+gAIuI64C+BX87Mfx9+vK3xGhFXq+OVmf+TmbcDB4DDEfFDi3z9UXaIq7XzMSLeCVzIzDOzOmYXEv3z9CeRLjnQbLviPhFxNbAGfHOH547a/k3gVc0xRr1WG3HRfOzOzPwO8Cc0H+EWFNdOvhER+5tj7adf+bQeV2Z+ozlJXwb+iAWPV0RcQz+Z/llm/tXAPq2O16i42h6vgTi+TX/C+Ajtn4+j4mr7fHwLcFdEfI1+K+itEfExphuv7SZp5M/zBlwNnKM/GXFpMuONQ/v8ItsnM04199/I9smMc/QnR0YeE/gLtk9mvKcjce1v/gz6H9s+sKi4Bp63zuWTnr/L9snFD3Ykrv0D93+Ffq9zUf+OAXwE+NAVXq+18RoTV5vjdSPwqmaf7wX+FnhnB87HneJq/Xxs9rmD7ZOxE43XZXFOstO8b8Db6a8QeBZ4f7Ptt4C7mvuvaP6CW/SXQ9068Nz3N887C9y50zGb7bc2x9hqjrmvI3F9Afgn4EngYzSrARYY1yP0P9L/N/3e373N9uuBz9NfLvg54DUdieujzXg9AZxmIJHNOy7gx+m3ZJ5gaLlim+M1Jq42x+uH6S8TfIL+7/dvdOF8HBNXq+fjwON3sD3RTzxegze/GStJxXWhRy9JmiMTvSQVZ6KXpOJM9JJUnIlekooz0UtScSZ6SSrORC9Jxf0vefVR7C2u4CoAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD9CAYAAACyYrxEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADvlJREFUeJzt3W+sZPVdx/H3p0uAiO2VusQHwHK3YSUuxKQ6gtFYMbZhsS6YlihLTVolbNCiJj4Rg4lGn7TGNGkjkWwswT5hi6ZpuLIVa+0WTUBZEAsL0i5bDLsx8q+5plrbIF8fzADDZe/dmTsz98z93fcrudmZM2dmvnt25zPnfn+/c06qCklSu97WdQGSpNky6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJatzUgz7JlUn+IckdSa6c9utLksYzUtAnuTPJ80meWLF8T5KnkxxLcutgcQHfAs4GTky3XEnSuDLKKRCSvId+eH+mqi4bLNsGfA14H/1AfxjYB/xbVb2a5AeAT1TVh073+tu3b6/FxcV1/yUkaSt65JFHXqyq80633hmjvFhVPZBkccXiy4FjVXUcIMlB4NqqenLw+DeBs0Z5/cXFRY4cOTLKqpKkgST/Psp6IwX9Ks4Hnhu6fwK4IskHgKuA7wP+dI0C9wP7AXbs2DFBGZKktUwS9KdUVZ8DPjfCegeAAwC9Xs9TaErSjEwy6+YkcOHQ/QsGyyRJc2SSoH8Y2JVkZ5IzgeuBe8d5gSR7kxxYXl6eoAxJ0lpGnV55N/AgcEmSE0lurKpXgFuA+4GngHuq6ug4b15VS1W1f2FhYdy6JUkjGnXWzb5Vlh8CDk21IknSVHkKBElqXKdBb49ekmZv6tMrx1FVS8BSr9e7ab2vsXjrfa/ffvZj759GWZLUFFs3ktQ4g16SGmePXpIa12nQO49ekmav08HYaXNgVpLeyh69JDXOoJekxjkYK0mNczBWkhpn60aSGtfUrJthzsCRpD736CWpcQ7GSlLjHIyVpMbZupGkxhn0ktQ4g16SGmfQS1LjDHpJapzTKyWpcZv+4uCj8ChZSVuZrRtJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhrnAVOS1LgtccDUMA+ekrTV2LqRpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNa7TA6a6NnzwFHgAlaQ2uUcvSY3zXDeS1LhOg76qlqpq/8LCQpdlSFLTbN1IUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxm3pI2NX8jKDklrkHr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcTM5YCrJOcBXgD+oqr+exXvMmgdPSWrFSHv0Se5M8nySJ1Ys35Pk6STHktw69NDvAPdMs1BJ0vqM2rq5C9gzvCDJNuB24GpgN7Avye4k7wOeBJ6fYp2SpHUaqXVTVQ8kWVyx+HLgWFUdB0hyELgW+F7gHPrh/+0kh6rq1alVLEkayyQ9+vOB54bunwCuqKpbAJJ8BHhxtZBPsh/YD7Bjx44JypAkrWVms26q6q61BmKr6kBV9aqqd955582qDEna8iYJ+pPAhUP3LxgskyTNkUlaNw8Du5LspB/w1wM3jPMCSfYCey+++OIJypg9p1pK2sxGnV55N/AgcEmSE0lurKpXgFuA+4GngHuq6ug4b15VS1W1f2FhYdy6JUkjGnXWzb5Vlh8CDk21IknSVHkKBElqXKdBn2RvkgPLy8tdliFJTes06O3RS9Ls2bqRpMbN5OyVLXOqpaTNxh69JDXOHr0kNc4evSQ1zqCXpMbZo5ekxtmjl6TGOb1yAk61lLQZ2KOXpMYZ9JLUOINekhrXaY9+s1xhahT26yXNK2fdSFLjbN1IUuMMeklqnEEvSY0z6CWpcQa9JDXOk5pJUuM6nUdfVUvAUq/Xu6nLOqbNOfWS5omtG0lqnEEvSY0z6CWpcQa9JDXOC4/MmAOzkrrmHr0kNc559JLUOOfRbyDbOJK6YOtGkhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc4jYzviVEtJG8U9eklqnEEvSY0z6CWpcQa9JDXOk5pJUuM8qdkccAaOpFmydSNJjTPoJalxBr0kNc4jY+eM/XpJ0+YevSQ1zqCXpMbZupljw22cYbZ0JI3DPXpJapx79JuQA7aSxuEevSQ1zqCXpMbZutnkbONIOh2DXmPxi0XafGzdSFLjDHpJatzUWzdJfgj4LWA78KWq+rNpv4c21moHbknaHEbao09yZ5LnkzyxYvmeJE8nOZbkVoCqeqqqbgZ+EfjJ6Zes1Szeet/rP5L0mlFbN3cBe4YXJNkG3A5cDewG9iXZPXjsGuA+4NDUKpUkrctIQV9VDwAvr1h8OXCsqo5X1XeBg8C1g/XvraqrgQ9Ns1hJ0vgm6dGfDzw3dP8EcEWSK4EPAGexxh59kv3AfoAdO3ZMUIYkaS1TH4ytqsPA4RHWOwAcAOj1ejXtOiRJfZME/UngwqH7FwyWac6McpCTB0JJ7Zok6B8GdiXZST/grwduGOcFkuwF9l588cUTlKH1Wm12jrN2pLaMFPRJ7gauBLYnOQH8flV9OsktwP3ANuDOqjo6zptX1RKw1Ov1bhqvbJ2OYS3pNSMFfVXtW2X5IZxCuan4BSBtPZ2eAiHJ3iQHlpeXuyxDkprWadBX1VJV7V9YWOiyDElqmqcp1rpNa6aOF0GXZsuzV0pS4+zRS1Lj7NFLUuNs3UhS4xyMVSeczy9tHPfoJalxne7Re66bdnhSNGl+ORgrSY2zdSNJjTPoJalxBr0kNc7plZo6B2al+eKsG82UoS91r9Og9wpTW8skB0n5hSGtn60bzS2PnpWmw8FYSWqcQS9JjTPoJalxzrrRpjPKwKyDt9IbUlVd10Cv16sjR46s67kO2Gkchr5akuSRquqdbj1bN5LUOINekhrnPHppDfb61QKDXluKwa2tyNaNJDXOPXptWe7da6sw6KV1cj6/NgsPmJJWWM+xGQa65pkXB5ekxtm6kabMo7U1bwx6aYOs9gUw3OqxBaRZMOilEbmnrs3KoJfoNsRHeW/39DUJg17axPwC0CgMemkL8Ytha/IUCJLUOPfopS3Kvfutw6CXNDa/JDYXg15qnNNC5blupEZMEujjHsylzaXToK+qJWCp1+vd1GUd0mZi4J6a7aTV2bqR5pSBvn6G/ps5vVKSGucevaRV+VtFGwx6SVPllbdOb6P//ga9pJkZ9zeClr4kVv7du6zVoJe0JY0ypbQVBr2kicyqj+/4wPQY9JI6NetAn1arZ7O0jE7FoJe0ac3DXv9m+AJwHr0kNc6gl6TGGfSS1Dh79JK2jEnm9c9i/Y1i0EvSkHkN60kY9JK0Abr8AplJ0Cf5BeD9wDuAT1fV387ifSRJpzdy0Ce5E/h54Pmqumxo+R7gk8A24M+r6mNV9Xng80nOBf4EMOglNWOztXfGmXVzF7BneEGSbcDtwNXAbmBfkt1Dq/ze4HFJUkdGDvqqegB4ecXiy4FjVXW8qr4LHASuTd/HgS9U1aPTK1eSNK5J59GfDzw3dP/EYNlvAO8Frkty86memGR/kiNJjrzwwgsTliFJWs1MBmOr6lPAp06zzgHgAECv16tZ1CFJmnyP/iRw4dD9CwbLJElzYtKgfxjYlWRnkjOB64F7Jy9LkjQtIwd9kruBB4FLkpxIcmNVvQLcAtwPPAXcU1VHx3jNvUkOLC8vj1u3JGlEI/foq2rfKssPAYfW8+ZVtQQs9Xq9m9bzfEnS6Xn2SklqXKq6m/CSZC+wF/gl4OvrfJntwItTK2p6rGs81jW+ea3NusYzSV0XVdV5p1up06CfhiRHqqrXdR0rWdd4rGt881qbdY1nI+qydSNJjTPoJalxLQT9ga4LWIV1jce6xjevtVnXeGZe16bv0UuS1tbCHr0kaQ1zHfRJ9iR5OsmxJLee4vGzknx28Pg/JVkceux3B8ufTnLVPNSVZDHJt5M8Nvi5Y4Prek+SR5O8kuS6FY99OMnXBz8fnqO6/m9oe0319Boj1PXbSZ5M8tUkX0py0dBjXW6vterqcnvdnOTxwXv/4/C1KTr+PJ6yrq4/j0PrfTBJJekNLZvu9qqqufyhf8WqZ4B3AWcC/wrsXrHOrwN3DG5fD3x2cHv3YP2zgJ2D19k2B3UtAk90uL0WgR8GPgNcN7T8ncDxwZ/nDm6f23Vdg8e+1eH2+hngewa3f23o37Hr7XXKuuZge71j6PY1wN8Mbnf9eVytrk4/j4P13g48ADwE9Ga1veZ5j/6UFzVZsc61wF8Mbv8V8LNJMlh+sKq+U1XfAI4NXq/rumbptHVV1bNV9VXg1RXPvQr4YlW9XFXfBL7IiquJdVTXLI1S15er6n8Gdx+if3ZW6H57rVbXLI1S138N3T0HeG0AsNPP4xp1zdIoOQHwR8DHgf8dWjb17TXPQb/aRU1OuU71T7C2DHz/iM/toi6AnUn+JclXkvzUlGoata5ZPHfWr312+heoeSj9i85Py7h13Qh8YZ3P3ai6oOPtleSjSZ4B/hj4zXGe20Fd0OHnMcmPABdW1coL0E59e83kwiNa1X8AO6rqpSQ/Sv8C6peu2OPQm11UVSeTvAv4+ySPV9UzG1lAkl8GesBPb+T7ns4qdXW6varqduD2JDfQv2b0VMcv1muVujr7PCZ5G/AJ4COzfi+Y7z36US5q8vo6Sc4AFoCXRnzuhtc1+FXsJYCqeoR+7+0HN7CuWTx3pq9dVScHfx4HDgPv3si6krwXuA24pqq+M85zO6ir8+015CDw2m8UnW+vU9XV8efx7cBlwOEkzwI/Dtw7GJCd/vaaxUDElAYzzqA/yLWTNwYzLl2xzkd586DnPYPbl/LmwYzjTG/wZ5K6znutDvqDNCeBd25UXUPr3sVbB2O/QX9g8dzB7Xmo61zgrMHt7fRPfPeWAa0Z/ju+m/6Hf9eK5Z1urzXq6np77Rq6vRc4Mrjd9edxtbrm4vM4WP8wbwzGTn17TfwXmuUP8HPA1wb/qW8bLPtD+nsxAGcDf0l/sOKfgXcNPfe2wfOeBq6eh7qADwJHgceAR4G9G1zXj9Hv9/03/d98jg4991cH9R4DfmUe6gJ+Anh88J/+ceDGDa7r74D/HPx7PQbcOyfb65R1zcH2+uTQ/+8vMxRsHX8eT1lX15/HFeseZhD0s9heHhkrSY2b5x69JGkKDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhr3/0VWnHTOeYC3AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "thcut2,pzcut2 400905\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for quad in [t1234,t1231,t1212,t1123] :\n", + " plotTriplets(quad,600)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphiNor\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dz\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADzxJREFUeJzt3X+s3fVdx/HnyzLQMNe5QZZZWltSgmuMceQEZjRmcZuWsdK5TG01cVNCwxL88Zd2wWwxZpFp4h9kGHKTEbYEQWT+aKUL2wyEfxijTIaFrluHLC3BFSSrPzNke/vH+RKOd/e2595zzv2e++nzkZxwzuece8475NxXP/f9/Xy/n1QVkqR2/UDfBUiSZsugl6TGGfSS1DiDXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXuvL4LALjoootq69atfZchSevKY4899kJVXXy2181F0G/dupXDhw/3XYYkrStJvjnO62zdSFLjDHpJapxBL0mNm0nQJ7kwyeEk75nF+0uSxjdW0Ce5PcmpJEcWje9McizJ8ST7R576A+CeaRYqSVqdcWf0dwA7RweSbABuBa4GdgB7k+xI8i7gKeDUFOuUJK3SWMsrq+qhJFsXDV8JHK+qpwGS3A3sBl4LXMgw/P8nyaGq+t7i90yyD9gHsGXLltXWL0k6i0nW0W8CTow8PglcVVU3AiT5IPDCUiEPUFULwALAYDBwP0NJmpGZnTBVVXfM6r2lPmzdf9//e/zMzdf0VIm0MpME/bPA5pHHl3RjY0uyC9i1ffv2CcqQZmdxuEvrUarG65p0Pfp/qKqf6B6fB3wNeAfDgH8U+LWqenKlRQwGg/ISCJoXk4a7M32tlSSPVdXgbK8ba0af5C7g7cBFSU4CH62qTya5Ebgf2ADcvtKQd0aveTHNmfty7+U/AOrL2DP6WXJGr7UyL60YQ1/TMO6M3ksgSFLjer1Msa0brYV5mcWPGq3J2b1mrdegr6qDwMHBYHB9n3WoPfMY7lJf5mLjEelc5uxes2aPXpIaZ49ezbBdIy3NHr00R2zjaBZs3UhS42zdaF2zXSOdXa8z+qo6WFX7Nm7c2GcZktQ0WzeS1DiDXpIaZ9BLUuM8GKt151w5AOtSS02LB2MlqXG2biSpcQa9JDXOoJekxhn0ktQ4g16SGtdr0CfZlWTh9OnTfZYhSU1zeaUkNc6tBKV1wJOnNAl79JLUOINekhpn60brwrlyfRtpFpzRS1LjDHpJapzr6CWpca6jl6TG2bqRpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGefVKaZ1xExKt1NRn9EnekuS2JPcm+dC031+StDJjBX2S25OcSnJk0fjOJMeSHE+yH6CqjlbVDcCvAD8z/ZIlSSsx7oz+DmDn6ECSDcCtwNXADmBvkh3dc9cC9wGHplapJGlVxurRV9VDSbYuGr4SOF5VTwMkuRvYDTxVVQeAA0nuA/5yqfdMsg/YB7Bly5ZVFa+2uauUNB2THIzdBJwYeXwSuCrJ24H3ARdwhhl9VS0ACwCDwaAmqEOSdAZTX3VTVQ8CD077fSVJqzPJqptngc0jjy/pxsbmDlOSNHuTBP2jwGVJtiU5H9gDHFjJG7jDlCTN3rjLK+8CHgYuT3IyyXVV9TJwI3A/cBS4p6qeXMmHO6OXpNkbd9XN3mXGDzHBEsqqOggcHAwG16/2PSRJZ+a1biSpcb0Gva0bSZq9XoPeg7GSNHu2biSpcbZuJKlxtm4kqXG2biSpcQa9JDXOHr0kNc4evSQ1zs3BpXXMjcI1Dnv0ktQ4g16SGufBWElqnAdjJalxtm4kqXGuutFcGV1FImk6nNFLUuMMeklqnKtuJKlxrrqRpMbZupGkxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXGeMCVJjfOEKUlqnK0bSWqcQS9JjTPoJalxBr0kNc6gl6TGuZWg1IjRbRifufmaHivRvHFGL0mNM+glqXEGvSQ1biY9+iTvBa4BXgd8sqo+N4vPkSSd3dgz+iS3JzmV5Mii8Z1JjiU5nmQ/QFX9XVVdD9wA/Op0S5YkrcRKZvR3AJ8APv3KQJINwK3Au4CTwKNJDlTVU91L/rB7XlrW6GoRSdM39oy+qh4CXlw0fCVwvKqerqqXgLuB3Rn6OPDZqvry9MqVJK3UpAdjNwEnRh6f7MZ+G3gn8P4kNyz1g0n2JTmc5PDzzz8/YRmSpOXM5GBsVd0C3HKW1ywACwCDwaBmUYckafIZ/bPA5pHHl3RjY3HjEUmavUmD/lHgsiTbkpwP7AEOjPvDbjwiSbO3kuWVdwEPA5cnOZnkuqp6GbgRuB84CtxTVU/OplRJ0mqM3aOvqr3LjB8CDq3mw5PsAnZt3759NT8uSRqDe8ZKUuO81o0kNa7X69Hbujl3eTastHZs3UhS42zdSFLjeg16T5iSpNmzdSNJjbN1I0mNM+glqXH26CWpcb2uo6+qg8DBwWBwfZ91SK0ZPU/hmZuv6bESzQNbN5LUOINekhpn0EtS4zwYK0mN84QpSWqcrRtJapxBL0mNM+glqXEGvSQ1zlU3ktQ4V91IUuN6vdaNpNnzujeyRy9JjTPoJalxBr0kNc6gl6TGGfSS1DhX3UjnkD5X4Lj6pz+eMCVJjXPPWM3U6CxO64Mz7/bYutH3WRzO/rJL65sHYyWpcc7oNXW2a6T5YtCfA9ai52q4S/PL1o0kNc6gl6TG2bpp1Fq0UmzXrG/jtPRcatkGg16S/2g3ztaNJDVu6jP6JJcCNwEbq+r9035/Sf2zpbO+jDWjT3J7klNJjiwa35nkWJLjSfYDVNXTVXXdLIqVJK3cuK2bO4CdowNJNgC3AlcDO4C9SXZMtTpJ0sTGCvqqegh4cdHwlcDxbgb/EnA3sHvK9UmSJjRJj34TcGLk8UngqiRvBD4GvDXJh6vqT5b64ST7gH0AW7ZsmaAMrSVXZ0jrz9QPxlbVvwE3jPG6BWABYDAY1LTrkCQNTRL0zwKbRx5f0o2NLckuYNf27dsnKEOrNe7s3Fm8tL5Nso7+UeCyJNuSnA/sAQ6s5A2q6mBV7du4ceMEZUiSzmTc5ZV3AQ8Dlyc5meS6qnoZuBG4HzgK3FNVT86uVEnSaozVuqmqvcuMHwIOrfbDbd1I64ctvPWr10sg2LqRpNnzWjeS1Lher15p62a6/NNa0lJs3UhS42zdSFLjbN1ImhnbifPB1o0kNc7WjSQ1zqCXpMbZo5c0Efvw888evSQ1ztaNJDXOoJekxhn0ktS4dX8wdvRA0DM3XzOFqtrmgTPNA39v15YHYyWpcbZuJKlxBr0kNc6gl6TGGfSS1Lh1v+rmXOSKBUkr4aobSWqcrRtJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhrnCVMzNsnJTV5SWOea5b7znhg4GU+YkqTG2bqRpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGTf0SCEkuBP4CeAl4sKrunPZnSJLGN9aMPsntSU4lObJofGeSY0mOJ9nfDb8PuLeqrgeunXK9kqQVGrd1cwewc3QgyQbgVuBqYAewN8kO4BLgRPey706nTEnSao0V9FX1EPDiouErgeNV9XRVvQTcDewGTjIM+7HfX5I0O5P06Dfx6swdhgF/FXAL8Ikk1wAHl/vhJPuAfQBbtmyZoIzpmeSSwtP6rJVemthLGWu9m+Q7PM7v7CSXPh7nZ1fz/muZNTCDg7FV9V/Ab47xugVgAWAwGNS065AkDU3SWnkW2Dzy+JJubGxJdiVZOH369ARlSJLOZJKgfxS4LMm2JOcDe4ADK3kDNx6RpNkbd3nlXcDDwOVJTia5rqpeBm4E7geOAvdU1ZOzK1WStBpj9eirau8y44eAQ6v98HNhz1hJ6pt7xkpS41znLkmN6zXoXXUjSbNn60aSGpeq/s9VSvI88M2+6xhxEfBC30WskDWvnfVYtzWvnbWs+8eq6uKzvWgugn7eJDlcVYO+61gJa14767Fua14781i3B2MlqXEGvSQ1zqBf2kLfBayCNa+d9Vi3Na+duavbHr0kNc4ZvSQ1zqAfkeSPkzyR5PEkn0vyo914ktzS7Y37RJIr+q71FUn+LMlXu7r+NsnrR577cFfzsSS/2Gedo5L8cpInk3wvyWDRc3NZMyy7R/LcWWqP5yRvSPL5JF/v/vsjfda4WJLNSR5I8lT33fjdbnxu607yg0m+lOQrXc1/1I1vS/JI9z35q+7qvv2qKm/dDXjdyP3fAW7r7r8b+CwQ4G3AI33XOlLnLwDndfc/Dny8u78D+ApwAbAN+Aawoe96u9reAlwOPAgMRsbnueYNXT2XAud3de7ou65lav054ArgyMjYnwL7u/v7X/mezMsNeDNwRXf/h4Gvdd+Hua27y4PXdvdfAzzS5cM9wJ5u/DbgQ33X6ox+RFX9+8jDC4FXDmDsBj5dQ18EXp/kzWte4BKq6nM1vGQ0wBd5db/e3cDdVfWdqvoX4DjDfX57V1VHq+rYEk/Nbc0sv0fy3Kml93jeDXyqu/8p4L1rWtRZVNVzVfXl7v5/MLz0+SbmuO4uD/6ze/ia7lbAzwP3duNzUbNBv0iSjyU5Afw68JFueKn9cTetdW1j+C2Gf3nA+ql51DzXPM+1jeNNVfVcd/9fgTf1WcyZJNkKvJXhDHmu606yIcnjwCng8wz/6vv2yORrLr4n51zQJ/lCkiNL3HYDVNVNVbUZuJPhxiq9O1vN3WtuAl5mWHfvxqlZ/ahhT2Eul9sleS3wGeD3Fv2FPZd1V9V3q+qnGP4lfSXw4z2XtKSpbw4+76rqnWO+9E6Gm6p8lCnsjzuJs9Wc5IPAe4B3dL8MMOc1L6PXms9inmsbx7eSvLmqnuvajqf6LmixJK9hGPJ3VtXfdMNzXzdAVX07yQPATzNs7Z7Xzern4ntyzs3ozyTJZSMPdwNf7e4fAH6jW33zNuD0yJ+TvUqyE/h94Nqq+u+Rpw4Ae5JckGQbcBnwpT5qXIF5rnniPZJ7dgD4QHf/A8Df91jL90kS4JPA0ar685Gn5rbuJBe/ssotyQ8B72J4bOEB4P3dy+aj5r6PBs/TjeFs4gjwBHAQ2FSvHl2/lWH/7Z8ZWSnS943hAcsTwOPd7baR527qaj4GXN13rSN1/RLD3uV3gG8B9897zV1t72a4GuQbwE1913OGOu8CngP+t/v/fB3wRuAfga8DXwDe0Hedi2r+WYZtmSdGvsvvnue6gZ8E/qmr+QjwkW78UoYTlOPAXwMX9F2rZ8ZKUuNs3UhS4wx6SWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIa9387EHRRm944HQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dr\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi zcut\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADexJREFUeJzt3XusHGUdxvHnsZV6iVageKPgKSkG7xqPl8RoKirgpWCEaAlR1CheYqJ/1qgxMSZe/lKDkTReayKgGLUVL0G0akxQKCKCipxWja2o4KUaJRjjzz/mPWZYz56ze3Z2Zva330/SdHd2Zva37+4+++47785xRAgAkNd9ui4AADBdBD0AJEfQA0ByBD0AJEfQA0ByBD0AJEfQA0ByBD0AJEfQA0ByG7suQJK2bNkSCwsLXZcBADPl4MGDd0XESWut14ugX1hY0A033NB1GQAwU2z/ZpT1GLoBgOQIegBIjqAHgOQIegBIjqAHgOQIegBIjqAHgOQIegBIrhc/mALQjoXdV//v8q/f/+IOK0Gb6NEDQHIEPQAkR9ADQHIEPQAkR9ADQHIEPQAkR9ADQHLMo0drmMM9HtoLTSHo0QlCDGgPQY/GEeJAv3Qa9LZ3Stq5ffv2LssA0uHDFnWdBn1E7Je0f3Fx8fVd1oH+I7jWVm+jcdenTXNj1g0AJMcYPTo37z3LSR7/uL14zCeCHlM1SRARYiubZIgG84mgB3qEUMY0MEYPAMnRo0ev0KMFmkfQA5j7A+LZEfQY2WBvm0AAZgNBD8wAhrQwCYIe68bXfWA2MOsGAJKjR49GMLQA9BdBj5kz7ENlloaP+GBEmwh6oCWEO7rCGD0AJEfQA0ByBD0AJEfQA0ByBD0AJEfQA0ByTK8EcC+c2iIfgh7pEVyYdwQ90iDQgZUR9Eipy1+h8oGDvuFgLAAkR9ADQHIM3WBVnIhrMrQf+oAePQAkR9ADQHIEPQAkR9ADQHIEPQAkx6wb/B9migC50KMHgOQIegBIjqAHgOQIegBIjqAHgOQIegBIjumVmCucKx7ziKAHMBQfjDkwdAMAyRH0AJAcQQ8AyRH0AJAcQQ8AyTU+68b2YyS9VdIWSddGxMeavg+gTzjbJ/pupB697U/a/qPtWwaWn2P7NttLtndLUkT8PCLeKOnlkp7VfMkAgHGM2qP/tKRLJe1dXmB7g6SPSnqBpCOSrre9LyJ+ZvtcSW+S9NlmywXQFebUz66RevQR8T1Jfx5Y/HRJSxFxOCL+JekKSeeV9fdFxAslXdRksQCA8U0yRn+ypN/Wrh+R9AzbOyS9TNImSV8btrHtSyRdIkmnnnrqBGUAAFbT+MHYiDgg6cAI6+2RtEeSFhcXo+k6AACVSaZXHpV0Su361rIMANAjkwT99ZJOt73N9nGSdkna10xZAICmjDR0Y/tySTskbbF9RNK7I+ITtt8i6ZuSNkj6ZETcOrVKgYYxiwTzYqSgj4gLhyz/mlY54AoA6B7no4ckft05LtoLs6TTc93Y3ml7z7Fjx7osAwBS6zToI2J/RFyyefPmLssAgNQ4eyUAJEfQA0ByBD0AJEfQA0ByBD0AJEfQA0ByBD0AJMcPpgAgOX4wBQDJMXQDAMkR9ACQHEEPAMlxmmJA/BES5EaPHgCSI+gBIDmGboABDOMgG3r0AJBcpz162zsl7dy+fXuXZaRHDxWYb50GfUTsl7R/cXHx9V3WAWD96Ej0H0M3AJAcB2MBjK3ei0f/0aMHgOQIegBIjqEbYBUcaEQG9OgBIDmCHgCSI+gBIDnG6IERMaUQs4o/Dg4AyfHHwQEgOcboASA5gh4AkuNgbMEPYwBkRY8eAJKjRz/HmC4IzAeCPilCHMAygh4AajIer2OMHgCSI+gBIDmCHgCSY4wewMzKOJ4+DfToASA5zl4JAMlx9koASI6hGwBIjqAHgOQIegBIbuanVzK9CgBWR48eAJKb+R49xsNZLdE3fCufPnr0AJAcQQ8AyRH0AJAcQQ8AyXEwFkAvcZC2OQQ9gMYQzv3E0A0AJEfQA0BynI8eAJLjfPQAkBwHY1cweJoADioBmGUE/YxgNgOA9SLoAUwF34z7g1k3AJDcXPfoJz1lbx+GU/pQA4B+m+ugbwNBDKBrDN0AQHIEPQAkR9ADQHKM0QNIgeNhwxH0AHqPEJ8MQzcAkBw9egDp8A3g3gj6RCb9ARiA5vTpw4ag70ifXgRA24Z1SuisTAdBDyA1OlUE/VTQKwH6aV5Dn1k3AJAcPfoW0dPHPOP13x3+ODgAJMcfBweA5BijB4DkGKMHgDHN2uwdevQAkBw9+hHM2qc3ANQR9D3ABwmAaWLoBgCSo0cPYO6NcpK1Wf62TY8eAJJL26PP8kkMYPZ1nUf06AEgubQ9+sw4ORSAcdCjB4DkCHoASI6hGwAzhaHL8aUKel4AAPD/GLoBgOQIegBIjqAHgOQIegBIjqAHgORSzboBgLZ1fR6bURD0ADCCWZ6+TdCPaZafbADziTF6AEiOoAeA5Ah6AEiOMfoe43gAgCbQoweA5DoNets7be85duxYl2UAQGqdBn1E7I+ISzZv3txlGQCQGmP0PcO4PICmEfQA0KLBzlwbp03gYCwAJEePHgAa0tehV3r0AJAcQQ8AyRH0AJAcQQ8AyRH0AJAcQQ8Ayc3F9MpZ+JuOADAt9OgBIDmCHgCSI+gBILm5GKOv6+tPlAG0a56yYO6Cflrm6UUDYLYwdAMAyRH0AJAcQQ8AyRH0AJAcQQ8AyRH0AJAcQQ8AyRH0AJAcQQ8AyTkiuq5Btu+U9Jt1br5F0l0NltMU6hoPdY2HusbT17qkyWp7VESctNZKvQj6Sdi+ISIWu65jEHWNh7rGQ13j6WtdUju1MXQDAMkR9ACQXIag39N1AUNQ13ioazzUNZ6+1iW1UNvMj9EDAFaXoUcPAFhFb4Pe9gm2r7F9e/n/+CHrfcP2X21/dWD5Nts/tL1k+0rbx5Xlm8r1pXL7wpTqurisc7vti8uyB9m+qfbvLtsfKre92vadtdte11ZdZfkB27fV7v+hZXmX7fUA21fb/oXtW22/v7b+utrL9jnlcS7Z3r3C7UMfr+23l+W32T571H1Osy7bL7B90PZPy/9n1rZZ8Tltqa4F23fX7vuy2jZPLfUu2f6IbbdY10UD78H/2H5yua2N9nqO7Rtt/9v2BQO3DXtvTtxeiohe/pP0QUm7y+Xdkj4wZL3nSdop6asDyz8vaVe5fJmkN5XLb5Z0Wbm8S9KVTdcl6QRJh8v/x5fLx6+w3kFJzymXXy3p0mm212p1STogaXGFbTprL0kPkPTcss5xkr4v6YXrbS9JGyQdknRa2d9PJD12lMcr6bFl/U2StpX9bBhln1Ou6ymSHlkuP17S0do2Kz6nLdW1IOmWIfv9kaRnSrKkry8/p23UNbDOEyQdarm9FiQ9UdJeSReM+N6cqL0ior89eknnSfpMufwZSS9daaWIuFbS3+vLyifemZKuWmH7+n6vkvS8MT8hR6nrbEnXRMSfI+Ivkq6RdM5AjY+W9FBV4dWERupaY7+ttldE/DMiviNJEfEvSTdK2jrGfQ96uqSliDhc9ndFqW9YvfXHe56kKyLinoj4laSlsr9R9jm1uiLixxHxu7L8Vkn3t71pzPtvvK5hO7T9CEkPjojrokqxvRry3m6hrgvLtk1Zs66I+HVE3CzpPwPbrvgeaKi9eh30D4uIO8rl30t62BjbnijprxHx73L9iKSTy+WTJf1Wksrtx8r6Tdb1v/tY4f6XLfcy6kfDz7d9s+2rbJ8yRk1N1fWp8pX1XbU3RS/ay/ZDVH1zu7a2eNz2GuV5GfZ4h207yj6nWVfd+ZJujIh7astWek7bqmub7R/b/q7tZ9fWP7LGPqdd17JXSLp8YNm022vcbZtor27/OLjtb0l6+Ao3vaN+JSLCdmvTg1qqa5ekV9au75d0eUTcY/sNqnojZ9Y3mHJdF0XEUdsPkvTFUtveUTacdnvZ3qjqDfmRiDhcFq/ZXvPE9uMkfUDSWbXF635OG3CHpFMj4k+2nyrpy6XGXrD9DEn/jIhbaou7bK+p6jToI+L5w26z/Qfbj4iIO8rXlz+Oses/SXqI7Y3l03yrpKPltqOSTpF0pATI5rJ+k3UdlbSjdn2rqvG/5X08SdLGiDhYu896DR9XNbZ9L9OsKyKOlv//bvtzqr6G7lUP2kvVPOPbI+JDtftcs72G3E+9519/XQyuM/h4V9t2rX1Osy7Z3irpS5JeFRGHljdY5Tmdel3lm+o95f4P2j4k6dFl/frwW+vtVezSQG++pfZabdsdA9seUDPt1euhm32Slo88XyzpK6NuWF5k35G0fFS7vn19vxdI+vbA8EkTdX1T0lm2j3c1y+SssmzZhRp4kZUQXHaupJ+PUdNEddneaHtLqeO+kl4iabmn02l72X6vqjfp2+obrLO9rpd0uqsZWceperPvW6Xe+uPdJ2mXq9kc2ySdruog2Sj7nFpdZUjralUHvH+wvPIaz2kbdZ1ke0O5/9NUtdfhMoz3N9vPLEMjr9IY7+1J6yr13EfSy1Ubn2+xvYZZ8T3QUHv1etbNiarGY2+X9C1JJ5Tli5I+Xlvv+5LulHS3qvGrs8vy01S9EZckfUHSprL8fuX6Urn9tCnV9dpyH0uSXjOwj8OSzhhY9j5VB9N+oupD6oy26pL0QFUzgG4uNXxY0oau20tV7yVUhfhN5d/rJmkvSS+S9EtVsyPeUZa9R9K5az1eVUNRhyTdptrMh5X2uY7X+7rqkvROSf+otc9Nqg7yD31OW6rr/HK/N6k6iL6zts9FVSF6SNKlKj/cbKOuctsOSdcN7K+t9nqaqpz6h6pvGLeulRlNtBe/jAWA5Po8dAMAaABBDwDJEfQAkBxBDwDJEfQAkBxBDwDJEfQAkBxBDwDJ/RfI+DxH4ZpSMwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphiNor\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADKZJREFUeJzt3V2MXHUZx/HfTxBIlCwvi4BAWMgSBK8kG0Qghogxpbjge0ATISKVGBK8Mk1IvPBG0MQLI2oaJGJCAEXRrpTw3nBjkS2hFChIISW0qbRIskpMQPTxYk5xst3ZndmZ8/bM95NsOjtzuvPM2elvnnnO/0wdEQIA5PW+ugsAAJSLoAeA5Ah6AEiOoAeA5Ah6AEiOoAeA5Ah6AEiOoAeA5Ah6AEju0LoLkKTJycmYmpqquwwAaJWtW7e+ERHHrbRdI4J+ampK8/PzdZcBAK1i+9V+tmN0AwDJEfQAkBxBDwDJEfQAkBxBDwDJEfQAkFytQW971vaGhYWFOssAgNRqDfqImIuIdRMTE3WWAQCpNeKEKTTX1Pr73ru866ZLa6wEwGoxoweA5OjogTHFu7XxQUcPAMnR0QNjpLuLx/gg6AH0xHgnB0Y3AJAcHT36tvhtfz8dXq9RAd3hygbtpnttz7gGBD0ARjTJEfSoHSEDlIugx6oR0Dkx6smHoMdIDDNPxuixf9GNoMfIETKr18++450UBkXQAy3Giyr6QdADLUCgYxgEPRqLEUWz8PtoL4IeB6F7BHIh6NEKdJPA6vFZNwCQHB09gIHxDqtdCHo0yjgeHxjHx4xqEfSQRNgAmTGjB4DkCHoASI6gB4DkmNGj1Vj9AayMoEfrcOAYGAyjGwBIjo4eqAjvRFAXOnoASI6gB4DkGN0gDVbgAEujoweA5OjoxxgHB4HxQEcPAMkR9ACQHEEPAMkxo0d6rMbBuCPogRJxwBtNwOgGAJIj6AEgOYIeAJIj6AEgOYIeAJJj1Q1SYrUL8H909ACQHB09MGK8m0DTEPQAhsKZx8038qC3fZakGyRNSnokIn4+6vsAVotQwjjqa0Zv+zbb+2w/u+j6NbZftL3T9npJiogdEXGdpK9IumD0JQMABtHvwdhfSVrTfYXtQyTdIukSSWdLutL22cVtl0m6T9KmkVUKAFiVvoI+Ih6X9Oaiq8+VtDMiXomIdyTdJenyYvuNEXGJpK/1+pm219metz2/f//+1VUPAFjRMDP6kyS91vX9bkkft32RpC9IOlzLdPQRsUHSBkmamZmJIeoAACxj5AdjI2KzpM2j/rkAgNUZ5oSpPZJO6fr+5OI6AECDDNPRPynpDNunqRPwV0j66kiqQmk4mQcYP/0ur7xT0p8lnWl7t+1rIuJdSddLekDSDkm/iYjnyisVALAafXX0EXFlj+s3iSWUANBofKgZACRXa9DbnrW9YWFhoc4yACC1WoM+IuYiYt3ExESdZQBAaoxuACA5PqYYGBJLVtF0dPQAkBxBDwDJEfQAkBxBDwDJEfQAkBwnTAFAcpwwBQDJMboBgOQ4YQpjq/tEp103XVpjJUC56OgBIDmCHgCSI+gBIDmCHgCS42DsGODTFYHxRkcPAMkR9ACQXK2jG9uzkmanp6frLAPAiHBuQjPxEQgAkByjGwBIjqAHgORYXgmsAktW0SZ09ACQHEEPAMkxugHEskDkRkcPAMnR0QNoDN5ZlYOgB5ZB8CCDWkc3tmdtb1hYWKizDABIjY9AAIDkOBgLAMkR9ACQHEEPAMkR9ACQHEEPAMmxjh5YhE+mRDZ09ACQHEEPAMkxugH6xEgHbUVHDwDJEfQAkByjm6QYMwA4oNagtz0raXZ6enokP4+PlAWAg9Ua9BExJ2luZmbm2jrraDNe3ACshBk9ACTHjL7B6NYBjAJBD6AUyy0IoHGpFqMbAEiOoAeA5Ah6AEiOoAeA5Fp/MLaKM0BZ/QKgzejoASA5gh4AkiPoASA5gh4Akmv9wVgAaKImLeKgoweA5Ah6AEgu1X88Mi56nTvA/yoFrE6TxixlqLWjj4i5iFg3MTFRZxkAkBqjGwBIjqAHgOQIegBIjqAHgOQIegBIjjNjAYyN7Msoe6GjB4DkCHoASI6gB4DkCHoASI6gB4DkCHoASI7llQAar9cnsw6zRHKcPu2VoAeAHrKsu2d0AwDJ0dEDSCdLJz4qBH1NeCJinPH8rxajGwBIjo4eQK2atvqlafWMAh09ACRXa0dve1bS7PT0dJ1lAGgpZv39qTXoI2JO0tzMzMy1ddYBAFVZPBqq4gWK0Q0AJEfQA0ByBD0AJMfyypbIuOQLQDXo6AEgOYIeAJIj6AEgOWb0S2AeDiCTtEHflDPmmlIHgPGVNugBjBfeifdG0I8InTuAphrroG9iONOVABi1sQ761WjiiwMALIfllQCQHEEPAMkR9ACQHEEPAMkR9ACQHEEPAMkR9ACQHOvoS8BJTwCahI4eAJKjo28A3gEAKBNBDwAlq7uZY3QDAMnR0Q+h7ldpAOgHHT0AJEdHDwB9aPNHlNPRA0BytXb0tmclzU5PT5d6P21+JQaAYdXa0UfEXESsm5iYqLMMAEiN0Q0AJEfQA0ByrLoBgBFp6rk1Yxf0Tf1FAEBZxi7oAbQDTdnoMKMHgOQIegBIjqAHgOQIegBIjqAHgOQIegBIjqAHgORYRw8gtTLW47ftE3EJegAYQhtO7GJ0AwDJEfQAkBxBDwDJEfQAkBwHYwttOKACAKtBRw8AyRH0AJAcQQ8AyTGjrxDHAQDUgY4eAJIj6AEgOYIeAJIj6AEgOYIeAJIj6AEgOYIeAJIj6AEgOYIeAJJzRNRdg2zvl/TqKv/6pKQ3RljOqFDXYKhrMNQ1mKbWJQ1X26kRcdxKGzUi6Idhez4iZuquYzHqGgx1DYa6BtPUuqRqamN0AwDJEfQAkFyGoN9QdwE9UNdgqGsw1DWYptYlVVBb62f0AIDlZejoAQDLaF3Q2/6R7RdsP2P7XttH9dhuje0Xbe+0vb6Cur5s+znb/7Xd8wi67V22t9t+2vZ8g+qqen8dY/sh2y8Vfx7dY7v/FPvqadsbS6xn2cdv+3Dbdxe3P2F7qqxaBqzratv7u/bRNyuq6zbb+2w/2+N22/5JUfczts9pSF0X2V7o2l/fq6CmU2w/Zvv54t/iDUtsU+7+iohWfUn6jKRDi8s3S7p5iW0OkfSypNMlHSZpm6SzS67rLElnStosaWaZ7XZJmqxwf61YV03764eS1heX1y/1eyxue6uCfbTi45f0bUm/KC5fIenuhtR1taSfVvV86rrfT0o6R9KzPW5fK+l+SZZ0nqQnGlLXRZL+VPG+OlHSOcXlIyX9dYnfY6n7q3UdfUQ8GBHvFt9ukXTyEpudK2lnRLwSEe9IukvS5SXXtSMiXizzPlajz7oq31/Fz7+9uHy7pM+VfH/L6efxd9d7j6SLbbsBddUiIh6X9OYym1wu6dfRsUXSUbZPbEBdlYuIvRHxVHH5n5J2SDpp0Wal7q/WBf0i31DnVXCxkyS91vX9bh28Y+sSkh60vdX2urqLKdSxv46PiL3F5b9JOr7HdkfYnre9xXZZLwb9PP73tikajQVJx5ZUzyB1SdIXi7f799g+peSa+tXkf4OfsL3N9v22P1rlHRcjv49JemLRTaXur0b+5+C2H5Z0whI33RgRfyy2uVHSu5LuaFJdfbgwIvbY/pCkh2y/UHQhddc1csvV1f1NRITtXsu/Ti321+mSHrW9PSJeHnWtLTYn6c6IeNv2t9R51/GpmmtqsqfUeU69ZXutpD9IOqOKO7b9QUm/k/SdiPhHFfd5QCODPiI+vdzttq+W9FlJF0cx4Fpkj6Tuzubk4rpS6+rzZ+wp/txn+1513p4PFfQjqKvy/WX7ddsnRsTe4i3qvh4/48D+esX2ZnW6oVEHfT+P/8A2u20fKmlC0t9HXMfAdUVEdw23qnPsowlKeU4NqztgI2KT7Z/ZnoyIUj8Hx/b71Qn5OyLi90tsUur+at3oxvYaSd+VdFlE/KvHZk9KOsP2abYPU+fgWWkrNvpl+wO2jzxwWZ0Dy0uuDqhYHftro6SristXSTronYfto20fXlyelHSBpOdLqKWfx99d75ckPdqjyai0rkVz3MvUmf82wUZJXy9Wk5wnaaFrVFcb2yccOLZi+1x1MrDUF+zi/n4paUdE/LjHZuXuryqPPo/iS9JOdWZZTxdfB1ZCfFjSpq7t1qpzdPtldUYYZdf1eXXmam9Lel3SA4vrUmf1xLbi67mm1FXT/jpW0iOSXpL0sKRjiutnJN1aXD5f0vZif22XdE2J9Rz0+CV9X52GQpKOkPTb4vn3F0mnl72P+qzrB8VzaZukxyR9pKK67pS0V9K/i+fXNZKuk3Rdcbsl3VLUvV3LrESruK7ru/bXFknnV1DTheocm3umK7fWVrm/ODMWAJJr3egGADAYgh4AkiPoASA5gh4AkiPoASA5gh4AkiPoASA5gh4AkvsfpYNiFQgmfDEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dz\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADm9JREFUeJzt3X+o3fddx/Hna+kPZXOZW8uoaWJSbqgLIq5c2gkiQ6cm624zx8TEgVNLQwf1x1+SUdkQGXYKgsVqCbZ0g9JaO38kLKPdpKX/dF3T2dXULC6rG0mpS2dZ/AWrnW//ON+44zU399x7zsn3nE+eD7j0nM899973Jz155Xvf38/3+0lVIUlq1+v6LkCSNF0GvSQ1zqCXpMYZ9JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxl/RdAMAVV1xRW7du7bsMSZorzzzzzDer6srVXjcTQb9161aOHDnSdxmSNFeSfH2U19m6kaTGGfSS1Lhegz7JUpIDZ86c6bMMSWpar0FfVYeqat/GjRv7LEOSmmbrRpIaZ9BLUuMMeklqnCdjJalxvV4wVVWHgEOLi4u39FmHNOu27v/0/z7+2h039liJ5tFMXBmr+WT4TNfwn680DoNeE2HoS7PLk7GS1DiDXpIaZ+tGa2LfeLr889U09Br0SZaApYWFhT7LkOaK50O0Vt7rRpIaZ49ekhpnj14TZ2tBmi0e0UtS4wx6SWqcrRutyiV/0nwz6KWe+Q+pps3WjSQ1zqCXpMZ5Zaw0x1zKqlF4ZawkNc6Tsfp/PDkotcUevSQ1ziN6TZU9ZKl/HtFLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ419FLjfCaBa1k4kf0Sd6W5O4kDyf50KS/vyRpbUY6ok9yL/Ae4HRV/fDQ+E7gj4ANwJ9V1R1VdQy4NcnrgE8Cfzr5sqX55v2EdCGNekR/H7BzeCDJBuAuYBewA9ibZEf3uZuATwOHJ1apJGldRgr6qnoCeGXZ8PXAiap6oapeBR4EdnevP1hVu4APTLJYSdLajXMydhNwcuj5KeCGJO8E3gdcznmO6JPsA/YBbNmyZYwyNAm2EqR2TXzVTVU9Djw+wusOAAcAFhcXa9J1SJIGxll18yKweej51d3YyJIsJTlw5syZMcqQJJ3POEH/NLA9ybYklwF7gINr+QZuJShJ0zdS0Cd5AHgSuDbJqSQ3V9VrwG3AI8Ax4KGqen56pUqS1mOkHn1V7V1h/DBjLKFMsgQsLSwsrPdbSJJW0eu9bmzdSNL0ea8bXTDei0XqR69H9K66kaTp6/WIvqoOAYcWFxdv6bMOqTX+9qRh3o9ekhpn0EtS4+zRS1LjXF4pSY1zeeVFzDtWShcHe/SS1Dh79JLUOHv0ktQ4WzeS1DiDXpIaZ9BLUuMMeklqXK/r6N14RBcTr1tQX1x1I0mNs3UjSY0z6CWpcQa9JDXOoJekxnmvG0lqnHvGSo1z/1h5P3r1wvCRLhx79JLUOINekhpn0EtS4wx6SWqcQS9JjTPoJalxBr0kNc4rYyWpcV4Ze5Fx8wvp4mPrRpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJatxU7nWT5L3AjcAbgXuq6tFp/BxJ0upGPqJPcm+S00mOLhvfmeR4khNJ9gNU1V9X1S3ArcAvTLZkSdJarKV1cx+wc3ggyQbgLmAXsAPYm2TH0Et+u/u8JKknI7duquqJJFuXDV8PnKiqFwCSPAjsTnIMuAP4TFV9cUK1ShrT8G2qv3bHjT1Wogtp3JOxm4CTQ89PdWO/BrwLeH+SW8/1hUn2JTmS5MjLL788ZhmSpJVM5WRsVd0J3LnKaw4ABwAWFxdrGnVIksY/on8R2Dz0/OpubCRuJShJ0zfuEf3TwPYk2xgE/B7gF0f9YrcSvDDcPlC6uI0c9EkeAN4JXJHkFPDRqronyW3AI8AG4N6qen4qlapZLZ8g9B9ZzYK1rLrZu8L4YeDwen54kiVgaWFhYT1fLmkMLf8Dq/+r11sgVNWhqtq3cePGPsuQpKZ5rxtJalyvQe+qG0maPls3ktQ4WzeS1DiDXpIaZ49ekhpnj16SGmfrRpIaZ9BLUuPs0UtS4+zRS1LjbN1IUuMMeklqnEEvSY0z6CWpca66kaTGuepGkho37ubg0kRNanu7aWyTt3z/V7ff07ywRy9JjTPoJalxtm6kCVve4pH65hG9JDXO5ZWS1LheWzdVdQg4tLi4eEufdUjr0VKLZhqrlDQ7bN1IUuM8GauZ5VGmNBke0UtS4wx6SWqcQS9JjTPoJalxBr0kNc4LpiSpcV4wpbnjsktpbWzdSFLjvGCqUS1dni9pPAa9muE/btK52bqRpMZ5RK+LiidydTHyiF6SGmfQS1LjbN1I2NJR2zyil6TGGfSS1DiDXpIaN/GgT3JNknuSPDzp7y1JWruRgj7JvUlOJzm6bHxnkuNJTiTZD1BVL1TVzdMoVpK0dqMe0d8H7BweSLIBuAvYBewA9ibZMdHqJEljGynoq+oJ4JVlw9cDJ7oj+FeBB4HdE65PkjSmcdbRbwJODj0/BdyQ5C3Ax4C3J/lwVf3eub44yT5gH8CWLVvGKKNdru3unzdKUwsmfsFUVf0LcOsIrzsAHABYXFysSdchSRoYJ+hfBDYPPb+6GxtZkiVgaWFhYYwypPNb61G5R/FqzTjLK58GtifZluQyYA9wcC3foKoOVdW+jRs3jlGGJOl8Rl1e+QDwJHBtklNJbq6q14DbgEeAY8BDVfX89EqVJK3HSK2bqtq7wvhh4PB6f7itG6k9LiKYPb3eAsHWjSRNn/e6kaTG9Xo/els3GpcrZKTV2bqRpMbZupGkxhn0ktQ4e/SaC/bi2+VyzOmzRy9JjbN1I0mNM+glqXH26BtiH3tt/PPSxcIevSQ1ztaNJDXOoJekxhn0ktQ4g16SGueqmxnglYGaJb4f2+OqG0lqnK0bSWqcQS9JjTPoJalxBr0kNc6gl6TGubxyDrn8TdJauLxSkhpn60aSGmfQS1LjDHpJapxBL0mNM+glqXEGvSQ1zqCXpMbN/QVT83rx0HDd0qwa5X06yb93o/x9nte/833ygilJapytG0lqnEEvSY0z6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapxBL0mNM+glqXETv6lZktcDfwK8CjxeVfdP+mdIkkY30hF9knuTnE5ydNn4ziTHk5xIsr8bfh/wcFXdAtw04XolSWs0auvmPmDn8ECSDcBdwC5gB7A3yQ7gauBk97LvTKZMSdJ6jRT0VfUE8Mqy4euBE1X1QlW9CjwI7AZOMQj7kb+/JGl6xunRb+K7R+4wCPgbgDuBP05yI3BopS9Osg/YB7Bly5Yxyli/5ZsqzPImBittAOEGJurbet6DF/v79kJvnjLxk7FV9R/Ar4zwugPAAYDFxcWadB2SpIFxWisvApuHnl/djY0syVKSA2fOnBmjDEnS+YwT9E8D25NsS3IZsAc4uJZv4FaCkjR9oy6vfAB4Erg2yakkN1fVa8BtwCPAMeChqnp+eqVKktZjpB59Ve1dYfwwcHi9PzzJErC0sLCw3m8hSVpFr8sfbd1I0vS5zl2SGtdr0LvqRpKmz9aNJDUuVf1fq5TkZeDr53nJFcA3L1A50+Q8ZkcLcwDnMUv6mMMPVtWVq71oJoJ+NUmOVNVi33WMy3nMjhbmAM5jlszyHDwZK0mNM+glqXHzEvQH+i5gQpzH7GhhDuA8ZsnMzmEuevSSpPWblyN6SdI6zXTQJ/ndJM8leTbJo0l+oBtPkju7vWqfS3Jd37WeT5I/SPLlrta/SvKmoc99uJvH8SQ/22ed55Pk55M8n+S/kywu+9xczOGsFfY6nnnn2rs5yZuTfDbJV7r/fn+fNa4myeYkjyX5h+799Bvd+LzN43uSfCHJl7p5/E43vi3JU91768+7O/v2r6pm9gN449DjXwfu7h6/G/gMEOAdwFN917rKPH4GuKR7/HHg493jHcCXgMuBbcBXgQ1917vCHN4GXAs8DiwOjc/NHLp6N3Q1XgNc1tW+o++6Rqz9J4DrgKNDY78P7O8e7z/73prVD+Aq4Lru8fcB/9i9h+ZtHgHe0D2+FHiqy6KHgD3d+N3Ah/qutapm+4i+qv516OnrgbMnFHYDn6yBzwNvSnLVBS9wRFX1aA1u6wzweb67p+5u4MGq+nZV/RNwgsFevDOnqo5V1fFzfGpu5tBZaa/jmVfn3rt5N/CJ7vEngPde0KLWqKpeqqovdo//jcEtzjcxf/Ooqvr37uml3UcBPwk83I3PzDxmOugBknwsyUngA8BHuuFz7Ve76ULXtk6/yuC3EZjveZw1b3OYt3pX89aqeql7/M/AW/ssZi2SbAXezuBoeO7mkWRDkmeB08BnGfym+K2hg7qZeW/1HvRJPpfk6Dk+dgNU1e1VtRm4n8FGJzNptXl0r7kdeI3BXGbOKHPQ7KpBv2AultEleQPwKeA3l/3mPjfzqKrvVNWPMvgN/Xrgh3ouaUUT3xx8rarqXSO+9H4Gm5x8lAnsVztpq80jyS8D7wF+qnsjw4zNYw3/L4bN1BxGMG/1ruYbSa6qqpe69uXpvgtaTZJLGYT8/VX1l93w3M3jrKr6VpLHgB9j0Ea+pDuqn5n3Vu9H9OeTZPvQ093Al7vHB4Ff6lbfvAM4M/Rr38xJshP4LeCmqvrPoU8dBPYkuTzJNmA78IU+ahzDvM1h7L2OZ8xB4IPd4w8Cf9NjLatKEuAe4FhV/eHQp+ZtHleeXT2X5HuBn2ZwvuEx4P3dy2ZnHn2fDV7lzPangKPAc8AhYNPQGe+7GPTE/p6hVSCz+MHgBOVJ4Nnu4+6hz93ezeM4sKvvWs8zh59j0HP8NvAN4JF5m8NQve9msNrjq8DtfdezhrofAF4C/qv7f3Ez8Bbgb4GvAJ8D3tx3navM4ccZtGWeG/r78O45nMePAH/XzeMo8JFu/BoGBzongL8ALu+71qryylhJat1Mt24kSeMz6CWpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJatz/AIoF96c76AzBAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dr\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi zcut\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphiNor\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dz\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADR9JREFUeJzt3V+slPldx/H3p5jtxaobFVwb/ggGshG9qMmE3nixJl3LuiJtUxW8qZEsbiLGS2lq0ia9WU2MsRZr0BK6F4VwU4Uuuq2bVG42EdY0yh+JJ7gNh1Rh3YQr4wb79eIMZjhwYM6ZmfPM/Ob9SghnnnPOzDfPDp/9zvf5Pc+TqkKS1K4PdF2AJGmyDHpJapxBL0mNM+glqXEGvSQ1zqCXpMYZ9JLUOINekhpn0EtS436g6wIANm7cWNu3b++6DEmaKW+//fa7VbXpST83FUG/fft2Ll261HUZkjRTknx3mJ9zdCNJjTPoJalxnQZ9kn1Jjt+9e7fLMiSpaZ0GfVWdq6rDzzzzTJdlSFLTHN1IUuMMeklqnEEvSY0z6CWpcVNxwpQkrcX2o6///9fvvPpSh5VMN4N+CvhmlTRJjm4kqXEGvSQ1zjNjJalxnhkrSY1zdCNJjTPoJalxBr0kNc519FPGNfWSxs2OXpIaZ9BLUuMMeklqnEEvSY0z6CWpcQa9JDVuIssrkzwN/APw+ar6xiReQ9J8GlyCrOEM1dEnOZHkdpLLy7bvTXI9yUKSowPf+n3gzDgLlSStzbCjm5PA3sENSTYAx4AXgd3AwSS7k7wAXAVuj7FOSdIaDTW6qaoLSbYv27wHWKiqGwBJTgP7gR8EnmYp/P87yfmq+v7y50xyGDgMsG3btrXWL0l6glFm9JuBmwOPF4GPVNURgCS/Cbz7qJAHqKrjwHGAXq9XI9QhSXqMiV3rpqpOTuq5JUnDG2V55S1g68DjLf1tQ/MOU5I0eaME/UVgV5IdSZ4CDgBnV/ME3mFKkiZv2OWVp4C3gOeSLCY5VFX3gCPAG8A14ExVXVnNi9vRS9LkDbvq5uAK288D59f64lV1DjjX6/VeXutzSJIez0sgSFLjvMNUR6btNG7vbCW1q9OO3hm9JE1epx29M/puTdunCkmT4ehGD1n+PwBHOdJs6zTok+wD9u3cubPLMiSt0uM+DXbVGHicaWWdzug9YUqSJs/llZLUOINekhrnjF7SUFylNbtcXqkn8iCXNNtcXjln7Mqk+eOMXpIaZ0cvaawc9U0fr3UjSY3zhClJapwzeklqnDN6SStylVYb7OglqXF29OvI7khSF+zoJalxXutGUnNcy/8gr3WjVfEfkDR7HN1IUuM8GDsHPAgszTeDXtLEOOqbDo5uJKlxdvSSHuCorz129JLUOINekhrn9eglqXFej16SGufoRpIa56qbGeTaZEmrYUcvSY0z6CWpcY5uJE0Nx5KTYUcvSY2zo9ea2X1Js8GOXpIaZ9BLUuMMeklq3Nhn9El+Gvg9YCPwZlV9edyvIWn2eEynO0MFfZITwC8Dt6vqZwe27wX+FNgA/FVVvVpV14BXknwAeA0w6DvgNcUl3Tfs6OYksHdwQ5INwDHgRWA3cDDJ7v73fgV4HTg/tkolSWsyVEdfVReSbF+2eQ+wUFU3AJKcBvYDV6vqLHA2yevA18ZX7uyxs9YsaPl96shotBn9ZuDmwONF4CNJngc+CXyQx3T0SQ4DhwG2bds2QhmSpMcZ+8HYqvo28O0hfu44cByg1+vVuOuQJC0ZZXnlLWDrwOMt/W1D8w5TkjR5owT9RWBXkh1JngIOAGdX8wTeYUqSJm+ooE9yCngLeC7JYpJDVXUPOAK8AVwDzlTVlcmVKklai2FX3RxcYft5RlhCmWQfsG/nzp1rfQpJ0hN4c3BJapzXupGkxnUa9K66kaTJ6/TGI1V1DjjX6/Ve7rKOaeUZfZLGwdGNJDXOoJekxnU6unF5paT1NK/jUJdXSlLjOu3oW9XyJV8lzR6DfsbN60dRScNzRi9p3dmgrC/X0UvqlKPOyXN5pSQ1zhl9Q7rsjPwoLk0vO3pJapwXNZOkxnkwdpUcUUiaNc7oJU0lm6rxcUYvSY0z6CWpcQa9JDXOVTeS1DgvUyxJjXN0I0mNM+glqXGuo5fmlFeNnB929JLUOINekhrn6GZG+DFb88z3/2js6CWpcQa9JDXOm4NL0oAWr5rpmbGS1DhHN5LUOINekhpn0EtS41xHPyau85VmS4sHXVdiRy9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaN5HllUk+DrwE/DDwlar65iReR5L0ZEN39ElOJLmd5PKy7XuTXE+ykOQoQFX9dVW9DLwC/Pp4S5YkrcZqOvqTwJeA1+5vSLIBOAa8ACwCF5Ocraqr/R/5g/73Z5onQ0maZUN39FV1AXhv2eY9wEJV3aiq94HTwP4s+UPgb6vqnx71fEkOJ7mU5NKdO3fWWr8k6QlGPRi7Gbg58Hixv+13gY8Cn0ryyqN+saqOV1WvqnqbNm0asQxJ0komcjC2qr4IfHESz63pN0/XEJFmwagd/S1g68DjLf1tQ0myL8nxu3fvjliGJGklo3b0F4FdSXawFPAHgN8Y9per6hxwrtfrvTxiHZI0dq18Oh066JOcAp4HNiZZBD5XVV9JcgR4A9gAnKiqKxOpVJImpPWVdUMHfVUdXGH7eeD8Wl7cm4NL0uR5c3BJapx3mBqw2nlc6x/3JLWh047eVTeSNHmddvSuupE0K2Z5BY6XKZakxjm6kaTGuepGkhrnqhtJWqVZm9cb9Ctw6eR4zNo/CKlFnQZ912fGGuaS5oEzeklqnKMbSRrBLIwnXUcvSY2zo5ekMZnW7n6uD8ZK0qQsX+zRZfB7rRtJWgdddvvO6CWpcQa9JDXOoJekxs3dqhvPhtU88/0/n+zoJalxXo9ekhrntW4kqXGObiSpcQa9JDXOoJekxhn0ktQ4g16SGmfQS1LjDHpJapwnTElS4zxhSpIa5+hGkhpn0EtS4wx6SWrcXFyP3mtwS5pndvSS1DiDXpIaZ9BLUuMMeklqXLMHYz0AK0lL7OglqXFj7+iT/BTwWeCZqvrUuJ9fkmbd4MThnVdfmvjrDdXRJzmR5HaSy8u2701yPclCkqMAVXWjqg5NolhJ0uoN29GfBL4EvHZ/Q5INwDHgBWARuJjkbFVdHXeRktbO41UaqqOvqgvAe8s27wEW+h38+8BpYP+Y65MkjWiUg7GbgZsDjxeBzUl+LMlfAD+X5DMr/XKSw0kuJbl0586dEcqQJD3O2A/GVtV/Aa8M8XPHgeMAvV6vxl2HJGnJKB39LWDrwOMt/W1D8w5TkjR5owT9RWBXkh1JngIOAGdX8wTeYUqSJm/Y5ZWngLeA55IsJjlUVfeAI8AbwDXgTFVdmVypkqS1GGpGX1UHV9h+Hji/1hdPsg/Yt3PnzrU+xbqfeCBJs8abg0tS47zWjSQ1rtOgd9WNJE2eoxtJapyjG0lqnEEvSY3r9A5T41heOcir9EnSw5zRS1LjHN1IUuMMeklqnOvoJalxzuglqXGObiSpcQa9JDXOoJekxjV1wpSmm/cOkLrhwVhJapyjG0lqnEEvSY0z6CWpcQa9JDXOSyBIUuNcdSNJjXN0I0mNM+glqXGpqq5rIMkd4LsdlrAReLfD159G7pMHuT8e5j55UBf74yeratOTfmgqgr5rSS5VVa/rOqaJ++RB7o+HuU8eNM37w9GNJDXOoJekxhn0S453XcAUcp88yP3xMPfJg6Z2fzijl6TG2dFLUuPmOuiT/GqSK0m+n6S37HufSbKQ5HqSj3VVY1eSfD7JrSTf6f/5pa5r6kqSvf33wUKSo13X07Uk7yT5l/774lLX9XQhyYkkt5NcHtj2o0m+leTf+n//SJc1DprroAcuA58ELgxuTLIbOAD8DLAX+PMkG9a/vM79SVV9uP/nfNfFdKH/3/0Y8CKwGzjYf3/Mu1/ovy+mcjnhOjjJUjYMOgq8WVW7gDf7j6fCXAd9VV2rquuP+NZ+4HRV/U9V/TuwAOxZ3+o0JfYAC1V1o6reB06z9P7QHKuqC8B7yzbvB77a//qrwMfXtajHmOugf4zNwM2Bx4v9bfPmSJJ/7n9MnZqPoevM98LDCvhmkreTHO66mCnybFV9r//1fwDPdlnMoE5vDr4ekvw98BOP+NZnq+pv1rueafK4fQN8GfgCS/+ovwD8MfBb61edptjPV9WtJD8OfCvJv/Y7XPVVVSWZmiWNzQd9VX10Db92C9g68HhLf1tTht03Sf4S+MaEy5lWc/FeWI2qutX/+3aSr7M03jLo4T+TfKiqvpfkQ8Dtrgu6z9HNo50FDiT5YJIdwC7gHzuuaV3136j3fYKlA9fz6CKwK8mOJE+xdJD+bMc1dSbJ00l+6P7XwC8yv++N5c4Cn+5//WlgaiYGzXf0j5PkE8CfAZuA15N8p6o+VlVXkpwBrgL3gN+pqv/tstYO/FGSD7M0unkH+O1uy+lGVd1LcgR4A9gAnKiqKx2X1aVnga8ngaX8+FpV/V23Ja2/JKeA54GNSRaBzwGvAmeSHGLpary/1l2FD/LMWElqnKMbSWqcQS9JjTPoJalxBr0kNc6gl6TGGfSS1DiDXpIaZ9BLUuP+D2ETIx7ZB26SAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dr\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADaRJREFUeJzt3X+IZeddx/H3x/yoQnUL3YBhN+tENgRTURsv20hAghpIjZuIBt3gr0jMkkq04h+SqigKov4jEhMsSxvSVE0aWim76YZY+oP8E2N2Y9Uka2QJLdlQ2DTBqaIYVr/+MTd1nOzsnJm59z73PvN+wcDcM2fnfPfZ5XOf+z3POSdVhSSpX9/UugBJ0nQZ9JLUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TOXdy6AIDdu3fX0tJS6zIkaaGcPHnya1V12Ub7zUXQLy0tceLEidZlSNJCSfKVIfvZupGkzjUN+iQHkxxZXl5uWYYkda1p0FfVsao6vGvXrpZlSFLXbN1IUuds3UhS52zdSFLnbN1IUucMeknqXNMLppIcBA7u37+/ZRkzs3TvZ867/ct/dPOMK5G0kzQN+qo6BhwbjUZ3tayjtdVvAIa+pEmbi1sg9Gy9WfyQ/Q19SZNgj16SOuc6eknqXKqqdQ2MRqPq6e6Vm23XDGEbR9JaSU5W1Wij/ezRLwh795K2yqCfkGnM4occy9CXtBGDXt1Y7w3QN0btdAa9urTeJywvWtNO5JWxWmizbJlJi8orY7VwphHutnfUM1s3C26nBJQnu6WtM+g1V+YtZOetHmkrvGBqG+a5P7yooTTPY7raoo6v+uIFU9IUOdPXIjHo1dyizOKlReXyyk4542zHsde8cXmlmuhpFt/T30V9snWjiRtyKwJJs2PQb9IihlXLy/4Xcbyk3hj0Aob1ldeGtrN1aTEY9DvYdsPZcN+YJ2Y1Dwx6vY3hNB2Oq1rx4eCS1Dln9Log2zPS4jPopQZs42iWmrZukhxMcmR5ebllGZLUtaZBX1XHqurwrl27WpYhSV2zdTOAfWpNk20cTZurbiSpc87opTni7F7T4Ixekjpn0EtS52zdSHPKNo4mxaCXFoChr+2wdSNJnTPoJalzBr0kdc6gl6TOTfxkbJLvAj4I7AY+V1V/PuljTJu3PNA888SsNmvQjD7Jg0nOJnl+zfabkryU5HSSewGq6lRV3Q38FHD95EuWJG3G0Bn9Q8D9wMNvbUhyEfAAcCNwBng2ydGqejHJLcAHgI9PtlxJqzm71xCDZvRV9RTwxprNB4DTVfVyVb0JPArcOt7/aFW9H/iZSRYrSdq87fTo9wCvrHp9BnhfkhuAnwDeARxf7w8nOQwcBti3b982ypAkXcjET8ZW1ReBLw7Y7whwBGA0GtWk65AkrdjO8spXgStWvd473iZJmiPbCfpngauSXJnkUuAQcHQzv8BnxkrS9A1dXvkI8DRwdZIzSe6sqnPAPcCTwCngsap6YTMH95mx0uQs3fuZb3xJqw3q0VfV7etsP84FTrhKktpregsEWzeSNH1Ng97WjSRNnzc1k6TONX3CVJKDwMH9+/e3LEPqjrdG0GpNg76qjgHHRqPRXS3rAO9YKalftm4kqXM+HFzqnG0cubxSkjpnj17aQZzd70z26CWpcwa9JHXOHr0kdc5bIEhS51xeKe1QnpjdOezRS1LnDHpJ6pytG0m2cTrn3Sslrcs3gD646kaSOmePXpI6Z9BLUucMeknqnEEvSZ3b0csrfXygpJ3A5ZWS/p/1JkAutVxcLq+UpM7Zo5ekzhn0ktQ5g16SOmfQS1LndvTySklb4wqcxeKMXpI6Z9BLUucMeknqXNOgT3IwyZHl5eWWZUhS17wyVpI6Z+tGkjpn0EtS5wx6SeqcQS9JnTPoJalzO+4WCD5VStJOs+OCXtL0eA+c+WTQS9oWPyXPP3v0ktQ5Z/SSpmLtTN9WTjvO6CWpcxOf0Sf5ceBm4NuAj1bV30z6GJKk4QbN6JM8mORskufXbL8pyUtJTie5F6CqPl1VdwF3Az89+ZIlSZsxtHXzEHDT6g1JLgIeAN4PXAPcnuSaVbv89vjnkqSGBgV9VT0FvLFm8wHgdFW9XFVvAo8Ct2bFHwNPVNVzky1XkrRZ2zkZuwd4ZdXrM+NtvwL8CHBbkrvX+8NJDic5keTEa6+9to0yJEkXMvGTsVV1H3DfgP2OAEcARqNRTboOSdKK7QT9q8AVq17vHW+TpLfx9gjtbKd18yxwVZIrk1wKHAKObuYX+MxYSZq+ocsrHwGeBq5OcibJnVV1DrgHeBI4BTxWVS9s5uA+M1aSpm9Q66aqbl9n+3Hg+EQrkiRNVNNbINi6kaTpa3pTs6o6BhwbjUZ3taxD0mx5Yna2vHulpKYM/emzdSNJnWsa9K66kaTp8370ktQ5g16SOmePXpI6l6r29xMbjUZ14sSJqf1+n1IvLR5X4GwsycmqGm20n60bSeqcQS9JnbNHL0mdcx29JHXO1o0kdc6gl6TOGfSS1DmDXpI656obSeqcDx6RNJe8T/3k+OARSXPP0N8ee/SS1DmDXpI6Z9BLUucMeknqnMsrJalz3tRMkjpn60aSOuc6ekkLy/X1wzijl6TOOaOXtFBWz+I1jDN6SeqcQS9JnTPoJalzBr0kdc4rYyWpc14ZK0mds3UjSZ1zHb2krnn1rDN6SeqeQS9JnTPoJalzBr0kdc6gl6TOdbvqxjvcSdIKZ/SS1LluZ/SSdq5pfKJf5PX4zuglqXMTn9En+U7gt4BdVXXbpH+/JJ2P5+XWN2hGn+TBJGeTPL9m+01JXkpyOsm9AFX1clXdOY1iJUmbN3RG/xBwP/DwWxuSXAQ8ANwInAGeTXK0ql6cdJFD+Y4uSW83aEZfVU8Bb6zZfAA4PZ7Bvwk8Ctw64fokSdu0nR79HuCVVa/PAO9L8m7gD4D3JvlQVf3h+f5wksPAYYB9+/ZtowxJ2rz1VtEs8uqa9Uz8ZGxVvQ7cPWC/I8ARgNFoVJOuQ5K0YjvLK18Frlj1eu94myRpjmwn6J8FrkpyZZJLgUPA0c38Ap8ZK0nTN3R55SPA08DVSc4kubOqzgH3AE8Cp4DHquqFzRzcZ8ZK0vQN6tFX1e3rbD8OHJ9oRZKkiWp6CwRbN5I0fU2D3taNJE2fNzWTpM7ZupGkztm6kaTO2bqRpM4Z9JLUuaaPEkxyEDi4f//+lmVI2iHWu5X5dm5xvgg3QbNHL0mds3UjSZ0z6CWpc66jl6TO2aOXpM7ZupGkzhn0ktQ5g16SOmfQS1LnXHUjSZ1z1Y0kdc7WjSR1zqCXpM4Z9JLUOYNekjpn0EtS53zwiCStY7MPJJnXh5C4vFKSOmfrRpI6Z9BLUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktS5hb8ydrNXrknSdm3nitm1ZnEFrVfGSlLnbN1IUucMeknqnEEvSZ0z6CWpcwa9JHXOoJekzhn0ktQ5g16SOpeqal0DSV4DvtLo8LuBrzU69kasbWusbWusbWta1vYdVXXZRjvNRdC3lOREVY1a13E+1rY11rY11rY181zbW2zdSFLnDHpJ6pxBD0daF3AB1rY11rY11rY181wbYI9ekrrnjF6SOrcjgj7Jg0nOJnl+nZ8nyX1JTif5xyTXzlFtNyRZTvKl8dfvzLC2K5J8IcmLSV5I8sHz7NNk7AbW1mTsknxzkr9L8g/j2n7vPPu8I8knxuP2TJKlOartjiSvrRq3X5pFbeNjX5Tk75M8fp6fNRmzgbU1G7NBqqr7L+AHgWuB59f5+Y8CTwABrgOemaPabgAebzRulwPXjr//VuBfgGvmYewG1tZk7MZj8c7x95cAzwDXrdnnl4EPj78/BHxijmq7A7i/0f+5Xwf+6nz/bq3GbGBtzcZsyNeOmNFX1VPAGxfY5Vbg4Vrxt8C7klw+J7U1U1Vfrarnxt//G3AK2LNmtyZjN7C2JsZj8e/jl5eMv9aeDLsV+Nj4+08CP5wkc1JbE0n2AjcDH1lnlyZjNrC2ubYjgn6APcArq16fYU5CY+wHxh+1n0jynhYFjD8mv5eVGeBqzcfuArVBo7Ebf8z/EnAW+GxVrTtuVXUOWAbePSe1AfzkuBX3ySRXzKIu4E+B3wD+Z52fNxszNq4N2ozZIAb9/HuOlcucvxf4M+DTsy4gyTuBTwG/VlVfn/XxL2SD2pqNXVX9d1V9H7AXOJDku2d17I0MqO0YsFRV3wN8lv+bRU9Nkh8DzlbVyWkfa7MG1jbzMdsMg37Fq8Dqd+C9423NVdXX3/qoXVXHgUuS7J7V8ZNcwkqQ/mVV/fV5dmk2dhvV1nrsxsf9V+ALwE1rfvSNcUtyMbALeH0eaquq16vqv8YvPwJ8/wzKuR64JcmXgUeBH0ryF2v2aTVmG9bWaMwGM+hXHAV+fryC5Dpguaq+2roogCTf/lYfMskBVv7NZhII4+N+FDhVVX+yzm5Nxm5Iba3GLsllSd41/v5bgBuBf16z21HgF8bf3wZ8vsZn9VrXtuYcyy2snP+Yqqr6UFXtraolVk60fr6qfnbNbk3GbEhtLcZsMy5uXcAsJHmElRUYu5OcAX6XlZNQVNWHgeOsrB45DfwH8ItzVNttwAeSnAP+Ezg0i//cY9cDPwf807inC/CbwL5V9bUauyG1tRq7y4GPJbmIlTeXx6rq8SS/D5yoqqOsvEl9PMlpVk7GH5pBXUNr+9UktwDnxrXdMaPa3mZOxmxIbXMzZufjlbGS1DlbN5LUOYNekjpn0EtS5wx6SeqcQS9JnTPoJalzBr0kdc6gl6TO/S9l+AQabllbAgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi zcut\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphiNor\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADaVJREFUeJzt3V2MXGUdx/HfTxBIgCwvrYCFspAlSPVGMgEEYoioKciC7wEvhIhUNCR6pU1IjPFG0MREI4Y0SMAEeRFFu1DCi4DcALIlQIGCFAKhTaWgySrRoJW/F3NKxu3O7szOnJf5z/eTbDpz5nTmP8/M/uaZ5zznWUeEAAB5vafuAgAA5SLoASA5gh4AkiPoASA5gh4AkiPoASA5gh4AkiPoASA5gh4Aktu37gIkacWKFTE5OVl3GQAwUjZv3vxmRKxcar9GBP3k5KRmZ2frLgMARortV3vZj6EbAEiOoAeA5Ah6AEiOoAeA5Ah6AEiOoAeA5Ah6AEiOoAeA5BpxwhSA4Zpcf9e7l1+56lM1VoImIOiB5Ah9MHQDAMnRo8fQ0YMcDZ2vUydes3wIevSlW4h3C41u2zsRLEC5CHpghPX77amXD17k44iouwa1Wq1gmeLRUHZQ0LtfWpVhzevRbLY3R0Rrqf04GAsAyTF0A4wAhlwwCHr0AJAcY/RYUhN6k+M4VtyEdu80jq9B0zFGDwCQRNADQHocjAUapGnDNciBoIckAgbIjKDHSGD9nPrxGowuxugBIDl69EDNGDZD2Qh6AH1jGGe0lBL0tg+U9EdJ34uIO8t4DIwv1lEH+tNT0Nu+XtJ5knZFxIc6tq+V9BNJ+0i6LiKuKm76jqTbhlwrhowhg/rQ9qhSrwdjb5C0tnOD7X0kXSPpHElrJF1ke43tT0h6TtKuIdYJAFimnnr0EfGw7cl5m0+RtC0iXpYk27dIukDSQZIOVDv8/2V7U0S8M7SKgS4YNwYWNsgY/SpJr3Vc3y7p1Ii4QpJsXyLpzW4hb3udpHWStHr16gHKAAAsprR59BFxw2IHYiNiQ0S0IqK1cuXKssoAgLE3SNDvkHRMx/Wji20AgAYZZOjmcUkn2D5O7YC/UNKXhlIVkBAzbVCXnnr0tm+W9IikE21vt31pROyWdIWkeyRtlXRbRDxbXqkAgOXoddbNRV22b5K0abkPbnta0vTU1NRy7wIAsIRaFzWLiJmIWDcxMVFnGQCQGqtXAkByBD0AJEfQA0ByBD0AJFfrevTMugFG3/zzA1hnqHlqDfqImJE002q1LquzjnEyLiftNGWBs3FpbzQbQzcAkBxBDwDJEfQAkBxBDwDJEfQAkFytQW972vaGubm5OssAgNRY1AwAkmPoBgCSI+gBIDmCHgCSq3UJBKAKTVkOAagLPXoASI4ePTBkLGSGpmEePQAkxzx6AEiOMXoASI6gB4DkCHoASI6gB4DkmF4JYKg4Qa156NEDQHIEPQAkxwlTAJAcJ0wBQHIM3QBAcsy6wVhhRgjGEUE/BlhNsXy0MZqMoRsASI6gB4DkCHoASI6gB4DkCHoASI6gB4DkWAIBAJJjCQQASI6hGwBIjqAHgOQIegBIjrVugGVifRuMCnr0AJAcQQ8AyRH0AJAcQQ8AyRH0AJAcQQ8AyRH0AJAc8+gxtvhD4RgXBD2A0vBh2gy1Br3taUnTU1NTdZaREmdtAtiDZYoBIDkOxgJAcozRAz1iOAyjih49ACRH0ANAcgQ9ACRH0ANAcgQ9ACRH0ANAcgQ9ACRH0ANAcpwwBYjFt5AbPXoASI6gB4DkCHoASI6gB4DkCHoASI6gB4DkCHoASK7WoLc9bXvD3NxcnWUAQGq1njAVETOSZlqt1mV11gF04uQpZMOZscAi+POByIAxegBIjqAHgOQYugFQCY591IcePQAkR9ADQHIEPQAkR9ADQHIEPQAkR9ADQHJMr0yEszgBLIQePQAkR9ADQHIEPQAkR9ADQHIEPQAkx6wbAJVjgbNq0aMHgOQIegBIjqAHgOQIegBIjqAHgOQIegBIjumVI46FzAAshR49ACRH0ANAcgQ9ACRH0ANAcgQ9ACQ39KC3fZLta23fbvvrw75/AEB/egp629fb3mX7mXnb19p+wfY22+slKSK2RsTlkr4o6YzhlwwA6EevPfobJK3t3GB7H0nXSDpH0hpJF9leU9x2vqS7JG0aWqUAgGXp6YSpiHjY9uS8zadI2hYRL0uS7VskXSDpuYjYKGmj7bsk/Wp45QLIhrXpyzfImbGrJL3WcX27pFNtnyXps5L21yI9etvrJK2TpNWrVw9QBgBgMUNfAiEiHpL0UA/7bZC0QZJarVYMu47MWPYAQD8GmXWzQ9IxHdePLrYBABpkkKB/XNIJto+zvZ+kCyVtHE5ZAIBh6XV65c2SHpF0ou3tti+NiN2SrpB0j6Stkm6LiGfLKxUAsBy9zrq5qMv2TRpgCqXtaUnTU1NTy70LAIkwA6ccta5HHxEzkmZardZlddYxCjgAC2C5WOsGAJIj6AEgOYIeAJIj6AEguVqD3va07Q1zc3N1lgEAqdUa9BExExHrJiYm6iwDAFJj6AYAkiPoASA5gh4Akqv1zFgsjrNhAQwDQd8whDuwN9bAGQzTKwEgORY1AzBS6N33j6GbPvEmAzBqmHUDAMkR9ACQHEM3ABppkBloDLH+P3r0AJAc0ysBIDlWrwSA5Bi6AYDkOBjbACx7AKBM9OgBIDmCHgCSY+gGQAoMgXZHjx4AkiPoASC5sR66mf9Vj1OlAWTEmbEAkBx/eGQA3RZOYkElAE0y1kM3dWKGAICqEPQA0KdR+9ZO0Hco+8WjFw/Ua9QCelgIegAjq5fOEx0sgr50vMkA1I2gHxICHUBTEfQ9IMQBjHIOsAQCACQ3dj36Xj+VR/nTG8DyZZyZwxIIAJCcI6LuGtRqtWJ2draSx6KnDmC+bkuYDHI/VbC9OSJaS+2Xdugm49cvAOWougNYdT5xMBYAkkvboweAJqlz2JgePQAkl6pHz4FWAE3RpDyiRw8AyaXq0XfTpE9WAKgaPXoASG4sevQAUIWmjh7QoweA5Ah6AEhu5IdumvpVCQCagtUrASC5WoM+ImYiYt3ExESdZQBAaozRA0ByBD0AJEfQA0ByBD0AJEfQA0ByBD0AJEfQA0Byjoi6a5DtNyS9usz/vkLSm0MsZ1ioqz/U1Z+m1iU1t7aMdR0bESuX2qkRQT8I27MR0aq7jvmoqz/U1Z+m1iU1t7ZxrouhGwBIjqAHgOQyBP2Gugvogrr6Q139aWpdUnNrG9u6Rn6MHgCwuAw9egDAIkYu6G3/yPbztp+2fYftQ7rst9b2C7a32V5fQV1fsP2s7Xdsdz2CbvsV21tsP2l7tkF1Vd1eh9m+z/aLxb+Hdtnvv0VbPWl7Y4n1LPr8be9v+9bi9sdsT5ZVS591XWL7jY42+mpFdV1ve5ftZ7rcbts/Lep+2vbJDanrLNtzHe313QpqOsb2g7afK34Xv7nAPuW2V0SM1I+kT0rat7h8taSrF9hnH0kvSTpe0n6SnpK0puS6TpJ0oqSHJLUW2e8VSSsqbK8l66qpvX4oaX1xef1Cr2Nx21sVtNGSz1/SNyRdW1y+UNKtDanrEkk/q+r91PG4H5V0sqRnutx+rqS7JVnSaZIea0hdZ0m6s+K2OkrSycXlgyX9eYHXsdT2GrkefUTcGxG7i6uPSjp6gd1OkbQtIl6OiH9LukXSBSXXtTUiXijzMZajx7oqb6/i/m8sLt8o6dMlP95ienn+nfXeLuls225AXbWIiIcl/W2RXS6Q9Mtoe1TSIbaPakBdlYuInRHxRHH5H5K2Slo1b7dS22vkgn6er6j9KTjfKkmvdVzfrr0bti4h6V7bm22vq7uYQh3tdURE7Cwu/0XSEV32O8D2rO1HbZf1YdDL8393n6KjMSfp8JLq6acuSfpc8XX/dtvHlFxTr5r8O/gR20/Zvtv2B6t84GLI78OSHpt3U6nt1cg/Dm77fklHLnDTlRHx+2KfKyXtlnRTk+rqwZkRscP2+yTdZ/v5ohdSd11Dt1hdnVciImx3m/51bNFex0t6wPaWiHhp2LWOsBlJN0fE27a/pva3jo/VXFOTPaH2e+ot2+dK+p2kE6p4YNsHSfqNpG9FxN+reMw9Ghn0EfHxxW63fYmk8ySdHcUA1zw7JHX2bI4utpVaV4/3saP4d5ftO9T+ej5Q0A+hrsrby/brto+KiJ3FV9RdXe5jT3u9bPshtXtDww76Xp7/nn22295X0oSkvw65jr7riojOGq5T+9hHE5TynhpUZ8BGxCbbP7e9IiJKXQPH9nvVDvmbIuK3C+xSanuN3NCN7bWSvi3p/Ij4Z5fdHpd0gu3jbO+n9sGz0mZs9Mr2gbYP3nNZ7QPLC84OqFgd7bVR0sXF5Ysl7fXNw/ahtvcvLq+QdIak50qopZfn31nv5yU90KWTUWld88Zxz1d7/LcJNkr6cjGb5DRJcx1DdbWxfeSeYyu2T1E7A0v9wC4e7xeStkbEj7vsVm57VXn0eRg/krapPZb1ZPGzZybE+yVt6tjvXLWPbr+k9hBG2XV9Ru1xtbclvS7pnvl1qT174qni59mm1FVTex0u6Q+SXpR0v6TDiu0tSdcVl0+XtKVory2SLi2xnr2ev6Tvq92hkKQDJP26eP/9SdLxZbdRj3X9oHgvPSXpQUkfqKiumyXtlPSf4v11qaTLJV1e3G5J1xR1b9EiM9EqruuKjvZ6VNLpFdR0ptrH5p7uyK1zq2wvzowFgORGbugGANAfgh4AkiPoASA5gh4AkiPoASA5gh4AkiPoASA5gh4AkvsfZTT2xLJwdLkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dz\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "z0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dr\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dphi zcut\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for quad in [t1234,t1231,t1212,t1123] :\n", + " plotDoublets(quad,500)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}