fast2h5_new_s2e.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Contact L.Samoylova <liubov.samoylova@xfel.eu>, A.Buzmakov <buzmakov@gmail.com>\n",
      "# SPB S2E simulation project, European XFEL Hamburg <www.xfel.eu>\n",
      "# May 2014\n",
      "# Wave optics software is based on \n",
      "# SRW core library <https://github.com/ochubar/SRW>, and \n",
      "# WPG framework <https://github.com/samoylv/WPG>"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "isIpynb = False\n",
      "isIpynb = True # !S2E, comment this line for python script!\n",
      "\n",
      "if isIpynb:\n",
      "    %pylab inline\n",
      "    \n",
      "#Importing necessary modules:\n",
      "import sys\n",
      "import os\n",
      "import errno\n",
      "\n",
      "if not isIpynb:\n",
      "    sys.path.insert(0,'/data/S2E/packages/WPG')\n",
      "else:\n",
      "    sys.path.insert(0,'../..')\n",
      "\n",
      "import shutil\n",
      "import uuid\n",
      "import numpy\n",
      "import h5py\n",
      "\n",
      "#Import base wavefront class\n",
      "from wpg import Wavefront\n",
      "\n",
      "#\n",
      "# if working with long pulse (LP)\n",
      "#\n",
      "isLP = True\n",
      "fel_data_path='/pnfs/desy.de/exfel/disk/XFEL/2013/SIM/FAST/2013-EXFEL-S1-5keV-14GeV-LongPulse/'\n",
      "nharm = 1\n",
      "\n",
      "#\n",
      "# switch on/off debug printing\n",
      "#\n",
      "doPrint = False     \n",
      "\n",
      "#\n",
      "# switch on/off copying results into FELsource/prop_in_XXX.h5 \n",
      "#\n",
      "doCopyRes = True    \n",
      "if isIpynb: \n",
      "    doCopyRes = False"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Populating the interactive namespace from numpy and matplotlib\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def mkdir_p(path):\n",
      "    \"\"\"\n",
      "    Create directory tree, if not exists (mkdir -p)\n",
      "    \"\"\"\n",
      "    try:\n",
      "        os.makedirs(path)\n",
      "    except OSError as exc:  # Python >2.5\n",
      "        if exc.errno == errno.EEXIST and os.path.isdir(path):\n",
      "            pass\n",
      "        else:\n",
      "            raise"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def set_pzname(namg,ifb):\n",
      "    # suppose that undulator position identifier, nz, has 2 digits\n",
      "    name = namg+'PZ1_'+str(ifb)+'000'\n",
      "    return name"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# set name of FEL input file\n",
      "# i.e. output of pproc-fast2xy-2013-v2-06.exe, for details see\n",
      "# its input (parameter) file PPROC_FAST2XY_2013.dat\n",
      "def set_iname_2014(namg,ifb,nz):\n",
      "    # suppose that undulator position identifier, nz, has 2 digits\n",
      "    name = namg+'T'+str(ifb)+'0'+str(nz) \n",
      "    return name"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# set name of FEL output ASCII file\n",
      "# i.e. output of pproc-fast2xy-2013-v2-06.exe, for details see\n",
      "# its input (parameter) file PPROC_FAST2XY_2013.dat\n",
      "def set_oname_2014(namg,namt,ifb,nz):\n",
      "    # suppose that undulator position identifier, nz, has 2 digits\n",
      "    name = namg+namt+str(ifb)+'0'+str(nz) \n",
      "    return name"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# set name of FEL output h5 file, i.e. add a suffix to a base name \n",
      "# bname - base name   \n",
      "# val - some value (e.g. a starting time point of pulse chunk)\n",
      "# return bname+'_'+str(val)\n",
      "def set_FELout_name(bname,val):\n",
      "    sval=str(int(numpy.floor(val)))\n",
      "    if (val+0.5) >(int(val) +1.):\n",
      "        sval=str(int(numpy.ceil(val)))\n",
      "        fname = bname + '_'+sval\n",
      "    if int(val) < 10:\n",
      "        fname = bname+'_00'+sval\n",
      "    if  (int(val) >= 10) and (int(val) < 100):\n",
      "        fname = bname+ '_0'+sval\n",
      "    return fname"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def parse_toe_file(f_name):\n",
      "    \"\"\" Parse *.res file to list of strings \"\"\"\n",
      "    #TODO: now all rows keeped in memory. We should store only slices we need.\n",
      "    rows = []\n",
      "    params = []\n",
      "    with open(f_name,'r') as f:\n",
      "        for il,l in enumerate(f.readlines()):    \n",
      "            try:\n",
      "                t=numpy.array(l.split(),dtype='float32')\n",
      "                if il<2:\n",
      "                    params.append(t)\n",
      "                else:\n",
      "                    rows.append(t)\n",
      "            except ValueError:\n",
      "                print 'Error pasing line #%s in file %s' %(il,f_name)\n",
      "    return params, rows\n",
      "\n",
      "\n",
      "#Example of usage:\n",
      "#params, rows=parse_toe_file(toe_file_name)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def create_numpy_array_from_rows(rows,slices=None):\n",
      "    # slice size (Re, Im)\n",
      "    N=len(rows[0])/2\n",
      "    \n",
      "    if slices is None:\n",
      "        slices=range(len(rows)/N)\n",
      "    slice_count=len(slices)\n",
      "\n",
      "    y = numpy.array(rows,dtype='float32').reshape((slice_count,N,N,2))\n",
      "    \n",
      "    if doPrint: print 'y=rows.reshape((nSlices,nx,nx,2)',y.shape\n",
      "    y=numpy.swapaxes(y,0,2)\n",
      "    if doPrint: print 'return swapaxes(y,0,2)',y.shape\n",
      "    return y"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#save 3d array to hdf5\n",
      "def store_wavefront_hdf5(wf_struct,file_name):\n",
      "    \"\"\" Store wavefront structure in hdf5 file\"\"\"\n",
      "    def store_group(group,pearent_goup):\n",
      "        for k,v in group.items():\n",
      "            if isinstance(v,dict):\n",
      "                tmp_group=pearent_goup.create_group(k)\n",
      "                store_group(v,tmp_group)\n",
      "            else:\n",
      "                store_value(k,v,pearent_goup)\n",
      "    \n",
      "    def store_value(name,value,group):\n",
      "        filed_data=value[0]\n",
      "        filed_type=value[1]\n",
      "        if filed_type=='s':\n",
      "            group.create_dataset(name,data=filed_data)\n",
      "        else:\n",
      "            try:\n",
      "                group.create_dataset(name,data=filed_data,dtype=filed_type,chunks=True,\n",
      "                             compression='gzip', compression_opts=9)\n",
      "            except TypeError:\n",
      "                group.create_dataset(name,data=filed_data,dtype=filed_type)\n",
      "                \n",
      "    with h5py.File(file_name, 'w') as res_file:\n",
      "        store_group(wf_struct,res_file)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def load_wavefront_hdf5(file_name):\n",
      "    \"\"\"Return dictionary with fields of wavefront\"\"\"\n",
      "    def load_group(group,d):\n",
      "        for k,v in dict(group).items():\n",
      "            if isinstance(v,h5py.Group):\n",
      "                d[k.encode()]={}\n",
      "                load_group(v,d[k.encode()])\n",
      "            elif isinstance(v,h5py.Dataset):\n",
      "                d[k.encode()]=v.value\n",
      "            else:\n",
      "                raise TypeError\n",
      "    \n",
      "    wf={}\n",
      "    with h5py.File(file_name, 'r') as h5_file:\n",
      "        load_group(h5_file,wf)\n",
      "        \n",
      "    return wf"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def _resample(wf, axis, data, x0, x1):\n",
      "    if axis.lower()=='x':\n",
      "        y = data[data.shape[0]/2,:]\n",
      "        x = numpy.linspace(wf.params.Mesh.xMin, wf.params.Mesh.xMax, y.shape[0])\n",
      "    elif axis.lower()=='y':\n",
      "        y = data[:,data.shape[1]/2]\n",
      "        x = numpy.linspace(wf.params.Mesh.yMin, wf.params.Mesh.yMax, y.shape[0])\n",
      "    else:\n",
      "        raise ValueError(\n",
      "            'Wrong axis {}, should be \"x\" or \"y\"'.format(axis))\n",
      "    \n",
      "    if not x0 is None:\n",
      "        xmin = x0\n",
      "    else:\n",
      "        xmin = x[0]\n",
      "    \n",
      "    if not x1 is None:\n",
      "        xmax = x1\n",
      "    else:\n",
      "        xmax = x[-1] \n",
      "    \n",
      "    x1 = numpy.linspace(xmin,xmax,len(y))\n",
      "    y1 = numpy.interp(x1, x,y)\n",
      "    return x1, y1\n",
      "    \n",
      "def intensity_cut(wf, axis, polarization, x0=None, x1=None, M=0):\n",
      "    \n",
      "    if polarization.lower()  == 'v' or polarization.lower() == 'vertical':\n",
      "        pol = 'vertical'\n",
      "    elif polarization.lower() == 'h' or polarization.lower() == 'horizontal':\n",
      "        pol = 'horizontal'\n",
      "    elif polarization.lower() == 't' or polarization.lower() == 'total':\n",
      "        pol = 'total'\n",
      "    else:\n",
      "        raise ValueError(\n",
      "            'Wrong polarization {}, should be \"v\" or \"vertical\"'+\n",
      "            ' or \"h\" or \"horizontal\" or \"t\" or \"total\"'.format(polarization))\n",
      "    \n",
      "    dx=(wf.params.Mesh.xMax - wf.params.Mesh.xMin)/(wf.params.Mesh.nx-1)\n",
      "    dy=(wf.params.Mesh.yMax - wf.params.Mesh.yMin)/(wf.params.Mesh.ny-1)\n",
      "    dt=(wf.params.Mesh.sliceMax - wf.params.Mesh.sliceMin)/(wf.params.Mesh.nSlices-1)\n",
      "\n",
      "    data = wf.get_intensity(slice_number=M, polarization=pol)\n",
      "    return _resample(wf, axis, data*dx*dy*dt*1e-6, x0, x1)\n",
      "\n",
      "def phase_cut(wf, axis, polarization, x0=None, x1=None, M=0):\n",
      "    \n",
      "    if polarization.lower()  == 'v' or polarization.lower() == 'vertical':\n",
      "        pol = 'vertical'\n",
      "    elif polarization.lower() == 'h' or polarization.lower() == 'horizontal':\n",
      "        pol = 'horizontal'\n",
      "    else:\n",
      "        raise ValueError(\n",
      "            'Wrong polarization {}, should be \"v\" or \"vertical\" or \"h\" or \"horizontal\"'.format(polarization))\n",
      "    \n",
      "    data = wf.get_phase(slice_number=M, polarization=pol)\n",
      "    return _resample(wf, axis, data, x0, x1)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def update(in_fast2xydat='PPROC-FAST2XY_2013_LP.DAT',trd1=0.,trd2=None,\n",
      "           nxy=None,nskip=None,ifb=None,nzc=None,namg=None):\n",
      "    f_in = open(in_fast2xydat,'r')\n",
      "    a = f_in.readlines()    \n",
      "    strInputPar = numpy.empty(len(a), dtype=object)\n",
      "    strComment  = numpy.empty(len(a), dtype=object)\n",
      "    if doPrint: print '==Beforehand=='\n",
      "    for idx in range(0,7): \n",
      "        strInputPar[idx] =  a[idx].split('#',1)[0]\n",
      "        strComment [idx]  = a[idx].split('#',1)[1]\n",
      "        if doPrint: print strInputPar[idx].rstrip()+strComment[idx].rstrip()\n",
      "    f_in.close()\n",
      "    strInputPar[0] = str(trd1)\n",
      "    if trd2 is not None:\n",
      "        strInputPar[1] = str(trd2)\n",
      "    if nxy <> None:\n",
      "        strInputPar[2] = str(nxy)\n",
      "    if nskip <> None:\n",
      "        strInputPar[3] = str(nskip)\n",
      "\n",
      "    if ifb <> None:\n",
      "        strInputPar[4] = str(ifb)\n",
      "    else:\n",
      "        ifb = int(float(strInputPar[4]))\n",
      "\n",
      "    if nzc <> None:\n",
      "        strInputPar[5] = str(nzc)\n",
      "    else:\n",
      "        nzc = int(float(strInputPar[5]))\n",
      "    if namg <> None:\n",
      "        strInputPar[6] = namg\n",
      "    else:\n",
      "        namg = strInputPar[6].strip()\n",
      "    if doPrint: print '==Afterwards=='\n",
      "    for idx in range(0,7): \n",
      "        a[idx] = strInputPar[idx].strip()+' #'+strComment[idx].rstrip()\n",
      "#    for idx in range(0,len(a)):\n",
      "    if doPrint: \n",
      "        for idx in range(0,7):\n",
      "            print a[idx]\n",
      "    aout=a[0:31]\n",
      "    numpy.savetxt( in_fast2xydat,aout,fmt='%s')  \n",
      "    os.system('chmod a+rw '+in_fast2xydat)\n",
      "    return namg,ifb,nzc"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def fill_wf_history_detail(wf_struct):\n",
      "    wf_struct['history/parent/detail/info']={\n",
      "        'contact':(r'''Mikhail Yurkov\n",
      "        Evgeny Schneidmiller\n",
      "\n",
      "        Deutsches Elektronen Synchrotron (DESY)\n",
      "        Notkestrasse 85\n",
      "        22607 Hamburg\n",
      "        Germany\n",
      "                                             \n",
      "        E-mail: mikhail.yurkov@desy.de\n",
      "        E-mail: evgeny.schneidmiller@desy.de\n",
      "        Tel. +49 40 8998 2676''','s'),\n",
      "        'data_description':(r'''SASE12, 5 keV, 14 GeV.\n",
      "        Current pulse lengthis 2.5 ps, or about 10^4 coherence time (0.25 fs) -\n",
      "        should be sufficient for any statistical analysis.\n",
      "        Test files are as usually temporal profile, intensity distributions in the near and far zone.\n",
      "        \n",
      "        Output data points for s2e simulations:\n",
      "        (see gain_curve):\n",
      "        No.    z(m)\n",
      "        15     35.5 (beginning of saturation regime)\n",
      "        18     42.7 (saturation regime)\n",
      "        25     59.5 (deep nonlinear)\n",
      "        33     78.7  -/-\n",
      "        42    100.3  -/- \n",
      "        \n",
      "        File naming: ABCD.RES\n",
      "        A == Name of group\n",
      "        B == File Type\n",
      "        C == Sequential number of statistical run\n",
      "        D == Sequential number of output point along undulator\n",
      "        h == Frequency harmonic, h = 1, 3, 5, ...\n",
      "                                                     \n",
      "        File Type B:\n",
      "        T == raw data from FAST\n",
      "        FXYh == raw data from FAST, cartesian coordinate\n",
      "        Ph == Temporal structure of the radiation pulse for frequency harmonic\n",
      "        PZh == Energy in the radiation pulse versus undulator length\n",
      "        SFh == Power spectrum of the radiation pulse\n",
      "        Fh == Intensity distribution in the far zone\n",
      "        Nh == Intensity distribution in the near zone\n",
      "        FWHMh == Evolution along the undulator of the spot size and \n",
      "        angular divirgence of the radiation\n",
      "        ***\n",
      "        Structure of data files\n",
      "        T == raw data from FAST\n",
      "                                             \n",
      "        FXYh == raw data from FAST, cartesian coordinate\n",
      "        NXY x NXY x MZ complex array produced by routine fast2xy from FAST file T\n",
      "                                                     \n",
      "        Ph == Temporal structure of the radiation pulse for frequency harmonic h\n",
      "        col[0] Position along bunch  [cm]\n",
      "        col[1] Total radiation power [W]\n",
      "        col[2] Power loss by electrons [W]\n",
      "        col[3] Radiation power in harmonic h [W]\n",
      "        -n\n",
      "        ...  radiation power for frequency harmonic h and azimuthal mode m [W], m = -n .. n\n",
      "        n\n",
      "                                             \n",
      "        PZh == Energy in the radiation pulse versus undulator length (gain curve)\n",
      "        col[0] Sequential number of output point along undulator\n",
      "        col[1] Position along undulator [cm]\n",
      "        col[2] Averaged power of the radiation pulse for frequency harmonic h [W]\n",
      "        col[3] Energy loss by electrons [J]\n",
      "        col[4:4+2*n] \n",
      "        -n\n",
      "        ...   Energy in the radiation pulse for frequency harmonic h and \n",
      "        ...   azimuthal harmonic m [J], m = -n .. n\n",
      "        n\n",
      "                                             \n",
      "        SFh == Power spectrum of the radiation pulse in the far zone at zero angle\n",
      "        col[0] frequency dw/w [%]\n",
      "        col[1] Spectral power [normalized]\n",
      "                                             \n",
      "        Fh == Intensity distribution in the far zone\n",
      "        col[0] Angle [rad]\n",
      "        col[1] Radiation intensity\n",
      "                                                     \n",
      "        Nh == Intensity distribution in the near zone\n",
      "        col[0] Radial coordinate [cm]\n",
      "        col[1] Radiation intensity\n",
      "                                             \n",
      "        FWHMh == Evolution along the undulator of the spot size and \n",
      "        col[0] angular divirgence of the radiation for frequency harmonic h\n",
      "        col[1] position along the undulator [cm]\n",
      "        col[2] FWHM spot size of the radiation [cm]\n",
      "        col[3] FWHM angular divergence of the radiation [rad]\n",
      "        col[4] Radiation pulse energy [J]\n",
      "                                             \n",
      "        all other columns as well as SNn files are internal control information.''','s'),\n",
      "        'method_description':('Code: FAST (Schneidmiller Yurkov)','s'),\n",
      "        'source_data_path': ('http://dcache-door-photon03:2980/2013-EXFEL-S1-5keV-14GeV-LongPulse/','s')}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def fill_wf_params(wf_struct,params,nrows):\n",
      "    wl = params[0][0]*1e-2\n",
      "    photonEnergy = 12.4e3/(wl*1e10)\n",
      "    slMin0 = 0.\n",
      "    slStep = params[0][1]\n",
      "    xStep = params[0][2]*1e-2\n",
      "    nx = int(params[0][3])\n",
      "    nStart=1\n",
      "    nEnd=nrows/(2*nx*nx)\n",
      "    xMin = -xStep*(nx-1)/2\n",
      "    xMax =  xStep*(nx-1)/2\n",
      "    slMin = slMin0 + (nStart-1)*slStep\n",
      "    slMax = slMin0 + (nEnd - 1)*slStep\n",
      "    if doPrint: print 'wl [nm], Eph [keV]',wl*1e9,photonEnergy*1e-3\n",
      "    if doPrint: print 'nStart,nEnd: ',nStart,nEnd\n",
      "    if doPrint: print 'nSlices,slMin,slMax [fs]: ',nEnd,slMin*1e15,slMax*1e15\n",
      "    if doPrint: print 'nx,xMin,xMax [um]',nx,xMin*1e6,xMax*1e6  \n",
      "    RK1 = params[0][4]\n",
      "    wf_struct['params']={\n",
      "                         'photonEnergy':(photonEnergy,'f'),\n",
      "                         'wDomain':('time','s'),\n",
      "                         'wSpace':('R-space','s'),\n",
      "                         'wEFieldUnit':('sqrt(W/mm^2)','s'),\n",
      "                         'Rx':(5.,'f'),\n",
      "                         'Ry':(5.,'f'),\n",
      "                         'dRx':(0.125,'f'),\n",
      "                         'dRy':(0.125,'f'),\n",
      "                         'xCentre':(0,'f'),\n",
      "                         'yCentre':(0,'f'),\n",
      "                         'nval':(2,'i')\n",
      "                         }\n",
      "  \n",
      "    wf_struct['params']['Mesh']={\n",
      "                                 'nx':(nx,'i'),\n",
      "                                 'ny':(nx,'i'),\n",
      "                                 'xMin':(xMin,'f'),\n",
      "                                 'xMax':(xMax,'f'),\n",
      "                                 'yMin':(xMin,'f'),\n",
      "                                 'yMax':(xMax,'f'),\n",
      "                                 'nSlices':(nEnd,'i'),\n",
      "                                 'sliceMin':(slMin,'f'),\n",
      "                                 'sliceMax':(slMax,'f'),\n",
      "                                 'zCoord':(0.0,'d')\n",
      "                                 }\n",
      "    #xStep*1e-3: |E|^2 in W/mm^2 but not W/m^2\n",
      "    return RK1/(xStep*1e3)**2,nStart,nEnd"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def add_wf_attributes(fname0):\n",
      "    # use srwlib glossary to add attributes to wavefront datasets \n",
      "    in_fname   = fname0+'.h5'\n",
      "    bare_fname = fname0+'_bare.h5'\n",
      "    if doPrint: print('Loading wavefront data from the file:     '+in_fname)\n",
      "    wf_struct=Wavefront()\n",
      "    wf_struct.load_hdf5(in_fname)\n",
      "    wfr = wf_struct._srwl_wf\n",
      "    wf_struct = Wavefront(wfr)\n",
      "    if doPrint: print('Saving the wavefront data with attributes:'+bare_fname)\n",
      "    wf_struct.store_hdf5(bare_fname)\n",
      "    if doPrint: print('Replacing data with attributes from  '+bare_fname)\n",
      "    with h5py.File(bare_fname) as h2:\n",
      "        with h5py.File(in_fname) as h1:\n",
      "            try:\n",
      "                del h1['params']  # delete group\n",
      "            except KeyError:\n",
      "                pass\n",
      "            h2.copy('params',h1) #copy h2['params'] to h1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def convert_fast2h5(fel_data_path,fast2xyexe,fast2xydat,namg,ifb,nzc):\n",
      "    ifname=set_iname_2014(namg,ifb,nzc)+'.RES'\n",
      "    fulltname=fel_data_path+ifname\n",
      "    if doPrint: print 'fulltname:',fulltname\n",
      "    if doPrint: print 'Create sym link:'\n",
      "    os.system(\"ln -s \"+fulltname+\" fort.4\")\n",
      "    outp=os.popen(fast2xyexe).read()\n",
      "    if doPrint: print 'Remove sym link:'\n",
      "    os.system(\"rm fort.4\")\n",
      "    if doPrint: print 'fast2xy.exe:\\n',outp\n",
      "\n",
      "    #loading data from text toe*.res file\n",
      "    nharm=1 # for fundamental\n",
      "    namt = 'FXY'+str(nharm)+'_'   # part of fast2xy.exe output file name \n",
      "    print 'Reading FEL data from:'+ set_oname_2014(namg,namt,ifb,nzc)+'.RES ...'\n",
      "    params, rows=parse_toe_file(set_oname_2014(namg,namt,ifb,nzc)+'.RES')\n",
      "    if doPrint: print '...done'\n",
      "\n",
      "    #wavefront structure based on glossary\n",
      "    wf_struct={'version':(0.1,'f')}\n",
      "    RK1,nStart,nEnd = fill_wf_params(wf_struct, params,numpy.size(rows))\n",
      "    #build numpy arrays from list of rows\n",
      "    wf_data=create_numpy_array_from_rows(rows,slices=range(nStart-1,nEnd))\n",
      "    del rows\n",
      "    wf_struct['data']={\n",
      "                       'arrEver':(wf_data*numpy.sqrt(RK1),'f'),\n",
      "                       'arrEhor':(numpy.zeros(shape=wf_data.shape,dtype='float32'),'f')\n",
      "                       }\n",
      "    wf_struct['misc']={\n",
      "                       }\n",
      "    fill_wf_history_detail(wf_struct)\n",
      "    f_in = open(fast2xydat,'r')\n",
      "    \n",
      "    e_data =    numpy.loadtxt(set_oname_2014(namg,'E'+str(nharm),ifb,nzc)+'.RES')\n",
      "    ff_data = numpy.loadtxt(fel_data_path+set_oname_2014(namg,'F'+str(nharm)+'_',ifb,nzc)+'.RES')\n",
      "    nf_data = numpy.loadtxt(fel_data_path+set_oname_2014(namg,'N'+str(nharm)+'_',ifb,nzc)+'.RES')\n",
      "    if not isLP:\n",
      "        #for LP fwhm_data not defined \n",
      "        fwhm_data = numpy.loadtxt(os.path.join(tmp_dir,set_oname_2014(namg,'FWHM'+str(nharm)+'_',ifb,0)+'0.RES'))\n",
      "    pz_data_file = set_pzname(namg,ifb)+'.RES'\n",
      "    #set_oname_2014(namg,'PZ'+str(nharm)+'_',ifb,0)+'0.RES'\n",
      "    pz_data = numpy.loadtxt(fel_data_path+pz_data_file)\n",
      "    wf_struct['history/parent/detail/misc']={\n",
      "                                             'nzc':(nzc,'f'),\n",
      "                                             'FAST2XY_DAT':(f_in.readlines(),'s'),\n",
      "                                             'temporal_struct':(e_data,'f'),\n",
      "                                             'spot_size':(nf_data,'f'),\n",
      "                                             'angular_distribution':(ff_data,'f'),\n",
      "                                             'gain_curve':(pz_data,'f'),\n",
      "                                             }\n",
      "                                             #'fwhm_curve':(fwhm_data,'f') #<- not defined for long pulse data\n",
      "    \n",
      "    #store wavefront in hdf5 file\n",
      "    fname0 = set_oname_2014(namg,namt,ifb,nzc)\n",
      "    if doPrint: print \"Store wavefront in hdf5 file: \"+fname0+'.h5'\n",
      "    store_wavefront_hdf5(wf_struct,fname0+'.h5')\n",
      "    add_wf_attributes(fname0)\n",
      "    return fname0"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def main():\n",
      "    # typical command line parameters:\n",
      "    # fast2xy_new.py -i'PPROC-FAST2XY_2013_LP.DAT' --time-start=3. --skip-nslices=8 --zc-point-num=33 --jmax=2\n",
      "    from optparse import OptionParser\n",
      "    parser = OptionParser()\n",
      "    parser.add_option(\"-o\", \"--output-dir\",          dest=\"out_dir\", help=\"Output directory\", )\n",
      "    parser.add_option(\"-f\", \"--file-id\",             dest=\"f_id\",     help=\"ID of the first of output files: FELsource_out_<ID+{0..JMAX-1}>\", )\n",
      "    parser.add_option(\"-j\", \"--jmax\",                dest=\"jmax\", help=\"how many output pulses should be provided (1 by default)\", )\n",
      "    parser.add_option(\"-t\", \"--time-start\",          dest=\"trd1\", help=\"Start time value for reading the pulse, fs\")\n",
      "    parser.add_option(\"-q\", \"--time-end\",            dest=\"trd2\", help=\"End time value for reading the pulse, fs\")\n",
      "    parser.add_option(\"-n\", \"--nxy\",                 dest=\"nxy\",  help=\"Number of xy nodes\")\n",
      "    parser.add_option(\"-s\", \"--skip-nslices\",        dest=\"nskip\",help=\"skip slices (1 - no skip)\")\n",
      "    parser.add_option(\"-r\", \"--run-number\",          dest=\"ifb\",  help=\"XXXX Run number (Input file name TXXXXYYY.RES)\")\n",
      "    parser.add_option(\"-z\", \"--zc-point-num\",        dest=\"nzc\",  help=\"YYY\tNumber of output point along undulator, zc\")\n",
      "    parser.add_option(\"-p\", \"--prefix\",              dest=\"namg\", help=\"Prefix of FEL data files\")\n",
      "\n",
      "    (options, args) = parser.parse_args()\n",
      "       \n",
      "    if not options.out_dir:   # if output directory not given\n",
      "        parser.error('Output directory is not specified')\n",
      "    else:\n",
      "        out_dir=options.out_dir\n",
      "\n",
      "    if not options.f_id:   # if time value not given\n",
      "        f_id = 1 #default value\n",
      "    else:\n",
      "        f_id=int(float(options.f_id))\n",
      "\n",
      "    if not options.trd1:   # if time value not given\n",
      "        parser.error('Start time value is not specified')\n",
      "    else:\n",
      "        trd1=float(options.trd1)\n",
      "\n",
      "    if not options.nzc:   # if nzc value not given\n",
      "        nzc=33 #default value\n",
      "    else:\n",
      "        nzc=int(float(options.nzc))\n",
      "\n",
      "    if not options.jmax:   # if jmax value not given\n",
      "        jmax=1 #default value\n",
      "    else:\n",
      "        jmax=int(float(options.jmax))\n",
      "\n",
      "    if not options.namg: # if prefix is not given\n",
      "        namg = 'SASE1_5keV_14GeV_LP_'\n",
      "    else:\n",
      "        namg=options.namg\n",
      "\n",
      "    in_fast2xydat='FELsource_params.txt'\n",
      "    #copy-paste from else block of the cell below\n",
      "    out_fast2xydat='PPROC-FAST2XY_2013.DAT'\n",
      "    #@\n",
      "    if isIpynb:\n",
      "        thepath = '/diskmnt/a/exflwgs03/lsamoylv/code/WPG-develop/samples/FELsource/' \n",
      "    else:\n",
      "        thepath ='/data/S2E/data/FELsource/'\n",
      "    \n",
      "    mkdir_p(out_dir)\n",
      "    os.chdir(thepath)\n",
      "\n",
      "\n",
      "    for idx in range(0,jmax):\n",
      "        trd2=trd1+9\n",
      "        namg,ifb,nzc = update(in_fast2xydat,trd1,trd2=trd2,nzc=nzc,namg='SASE1_5keV_14GeV_LP_')\n",
      "\n",
      "        fast2xyexe='pproc-fast2xy-2013-v2-06-wo-fname.exe'\n",
      "        work_dir = os.path.join(thepath,namg+str(ifb)+'0'+str(nzc))\n",
      "        tmp_dir = work_dir+'/tmp'\n",
      "    \n",
      "        mkdir_p(work_dir)\n",
      "        if doPrint: print 'The result hdf5 file will be saved in \\n'+ work_dir+'/'\n",
      "        mkdir_p(tmp_dir)\n",
      "        if doPrint: print 'All temporary files will be saved in \\n'+ tmp_dir+'/'\n",
      "        shutil.copy(os.path.join(thepath,in_fast2xydat), tmp_dir+'/'+out_fast2xydat)\n",
      "        shutil.copy(os.path.join(thepath,fast2xyexe), tmp_dir+'/')\n",
      "    \n",
      "        os.chdir(tmp_dir)\n",
      "        in_fname=convert_fast2h5(fel_data_path,fast2xyexe,out_fast2xydat,namg,ifb,nzc)\n",
      "        out_fname=set_FELout_name(in_fname,trd1)\n",
      "        prop_in_fname = 'FELsource_out_'+str(f_id+idx).zfill(6)\n",
      "        \n",
      "        if doPrint: print 'in_fname,out_fname,prop_in_fname:',in_fname,out_fname,prop_in_fname\n",
      "        os.system('chmod a+rw '+ tmp_dir+'/*.*')    \n",
      "        \n",
      "        shutil.copy(in_fname+'.h5', os.path.join(work_dir,out_fname+'.h5'))\n",
      "        shutil.rmtree(tmp_dir)\n",
      "    \n",
      "        if doCopyRes:\n",
      "            print 'The result hdf5 file  '+out_fname+'.h5 will be copied/moved to '\n",
      "            print out_dir+'/'+ prop_in_fname+'.h5'\n",
      "            if jmax == 1:\n",
      "                shutil.move(os.path.join(work_dir,out_fname+'.h5'), \n",
      "                            os.path.join(out_dir,prop_in_fname+'.h5'))\n",
      "            else:\n",
      "                shutil.copy(os.path.join(work_dir,out_fname+'.h5'), \n",
      "                            os.path.join(out_dir,prop_in_fname+'.h5'))\n",
      "        else:\n",
      "            print out_fname, prop_in_fname\n",
      "            print '... done'\n",
      "        trd1=trd2\n",
      "        os.chdir(thepath)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#$\n",
      "if not isIpynb:\n",
      "    if __name__ == '__main__':\n",
      "        main()\n",
      "else:\n",
      "    # typical command line parameters:\n",
      "    # fast2xy_new.py -i'PPROC-FAST2XY_2013_LP.DAT' --time-start=3. --skip-nslices=8 --zc-point-num=33 --jmax=2\n",
      "#    in_fast2xydat='PPROC-FAST2XY_2013_LP.DAT';f_id=2;trd1=3.;nskip=8;nzc=25;jmax=2\n",
      "    in_fast2xydat='FELsource_params.txt';f_id=2;trd1=3.;nskip=8;nzc=25;jmax=1\n",
      "    #!S2E\n",
      "    if isIpynb:\n",
      "        out_dir = '/diskmnt/a/exflwgs03/lsamoylv/code/sim_data/FELsource'\n",
      "        thepath = '/diskmnt/a/exflwgs03/lsamoylv/code/WPG-develop/samples/FELsource/' \n",
      "    else:\n",
      "        out_dir = './' # never used\n",
      "        thepath ='./'\n",
      "\n",
      "    mkdir_p(out_dir)\n",
      "\n",
      "    out_fast2xydat='PPROC-FAST2XY_2013.DAT'\n",
      "    \n",
      "    fel_data_path='/pnfs/desy.de/exfel/disk/XFEL/2013/SIM/FAST/2013-EXFEL-S1-5keV-14GeV-LongPulse/'\n",
      "    \n",
      "    os.chdir(thepath)\n",
      "\n",
      "    for idx in range(0,jmax):\n",
      "        trd2=trd1+9\n",
      "        namg,ifb,nzc = update(in_fast2xydat,trd1,trd2=trd2,nzc=nzc,namg='SASE1_5keV_14GeV_LP_')\n",
      "\n",
      "        fast2xyexe='pproc-fast2xy-2013-v2-06-wo-fname.exe'\n",
      "        work_dir = os.path.join(thepath,namg+str(ifb)+'0'+str(nzc))\n",
      "        tmp_dir = work_dir+'/tmp'\n",
      "    \n",
      "        mkdir_p(work_dir)\n",
      "        if doPrint: print 'The result hdf5 file will be saved in \\n'+ work_dir+'/'\n",
      "        mkdir_p(tmp_dir)\n",
      "        if doPrint: print 'All temporary files will be saved in \\n'+ tmp_dir+'/'\n",
      "        shutil.copy(os.path.join(thepath,in_fast2xydat), \n",
      "                    os.path.join(tmp_dir,out_fast2xydat))\n",
      "        shutil.copy(os.path.join(thepath,fast2xyexe), tmp_dir)\n",
      "    \n",
      "        os.chdir(tmp_dir)\n",
      "        in_fname=convert_fast2h5(fel_data_path,fast2xyexe,out_fast2xydat,namg,ifb,nzc)\n",
      "        out_fname=set_FELout_name(in_fname,trd1)\n",
      "        prop_in_fname = 'FELsource_out_'+str(f_id+idx).zfill(6)\n",
      "        \n",
      "        if doPrint: print 'in_fname,out_fname,prop_in_fname:',in_fname,out_fname,prop_in_fname\n",
      "        os.system('chmod a+rw '+ tmp_dir+'/*.*')    \n",
      "        \n",
      "        shutil.copy(in_fname+'.h5', os.path.join(work_dir,out_fname+'.h5'))\n",
      "        shutil.rmtree(tmp_dir)\n",
      "    \n",
      "        if doCopyRes:\n",
      "            print 'The result hdf5 file  '+out_fname+'.h5 will be copied/moved to '\n",
      "            #print out_dir+'/'+ set_FELout_name('prop_in',trd1)+'.h5'\n",
      "            print out_dir+'/'+ prop_in_fname+'.h5'\n",
      "            if jmax == 1:\n",
      "                shutil.move(os.path.join(work_dir,out_fname+'.h5'), \n",
      "                            os.path.join(out_dir,prop_in_fname+'.h5'))\n",
      "            else:\n",
      "                shutil.copy(os.path.join(work_dir,out_fname+'.h5'), \n",
      "                            os.path.join(out_dir,prop_in_fname+'.h5'))\n",
      "        else:\n",
      "            print out_fname, prop_in_fname\n",
      "            print '... done'\n",
      "        trd1=trd2\n",
      "        os.chdir(thepath)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Reading FEL data from:SASE1_5keV_14GeV_LP_FXY1_1001025.RES ...\n",
        "SASE1_5keV_14GeV_LP_FXY1_1001025_003"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " FELsource_out_000002\n",
        "... done\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#%tb"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#ls "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#ff_data = numpy.loadtxt(fel_data_path+set_oname_2014(namg,'F'+str(nharm)+'_',ifb,nzc)+'.RES')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print doCopyRes"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "False\n"
       ]
      }
     ],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "jmax"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 24,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 24
    }
   ],
   "metadata": {}
  }
 ]
}