downloadversionIRdata.py

# -*- coding: utf-8 -*-
"""
Created on Wed Oct 25 15:51:46 2017

@author: holn
"""

import numpy as np
#import holn.archivedb as AKF_2
import W7Xrest.read_restdb as AKF_1
#import holn.functions as fu
import datetime
import urllib
import json

archivepath="http://archive-webapi.ipp-hgw.mpg.de/Test/raw/W7X/"

def TimeToNs(date,time):
    """
    TimeToNs(date,time)
    (list)  date    [year,month,day]
    (list)  time    [hours,minutes,seconds,microseconds]
    """ 
    date_time=datetime.datetime(date[0],date[1],date[2],time[0],time[1],time[2],time[3])
    div=date_time-datetime.datetime(1970,1,1,0,0,0)
    nsdate=div.total_seconds()*1e9
    return nsdate

def read_program(timestampstart,timestamp_end=0,tol=60):
    """
    read_program()
    """
    program_url = 'http://archive-webapi.ipp-hgw.mpg.de/programs.json?from'
    if timestamp_end!=0:
        jsonurl=program_url+"="+str(int(timestampstart-tol*1e9))+"&upto="+str(int(timestamp_end+tol*1e9))
    else:
        jsonurl=program_url+"="+str(int(timestampstart-tol*1e9))+"&upto="+str(int(timestampstart+tol*1e9))
    try:
        res = urllib.request.urlopen(jsonurl)
        prog_raw=res.read()
        res.close()
    except urllib.error.URLError as e:
        print('!get_program: Error opening URL')
        print(e)
        return False,0
    else:
        prog_string=prog_raw.decode(encoding='UTF-8')
        prog_list = json.loads(prog_string)
        pl=prog_list['programs'][0]
        return True, pl

def read_restdb_old(request_url):
    """
    Reads JSON data from W7-X REST API
    Returns: 
        valid: access ok
        t: numpy-array of time
        signal: numpy-array of requested signals
    by Thomsen
    """
    try:
        res = urllib.request.urlopen(request_url)
    except urllib.error.URLError as e:
        print(e)
        return False, 0, -1
    else:
        signal_raw=res.read()
        res.close()
        signal_string=signal_raw.decode(encoding='UTF-8')
        signal_list = json.loads(signal_string)
        signal0=np.array(signal_list['values'])
        t=np.array(signal_list['dimensions'])
        return True, t, signal0

def download_LUT(port,time,exposure=0,emissivity=0,camera_filter=0,version=1):
    """
    download_LUT(camera,port,time,exposure=0,emissivity=0,camera_filter=0,version=1):
        time in ns
    """    
    if port==50:# camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_LUT_"
        query="Filter_"+str(camera_filter)+"_Texp_"+str(int(exposure))+"us_e_"+str(float(emissivity))
    elif port in [10,11,20,21,30,31,40,41,51]:#camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_LUT_"
        query="Texp_"+str(int(exposure))+"us_e_"+str(float(emissivity))
    else:
        print("camera unknown, stopping here")
        raise Exception
    #time=int(fu.TimeToNs([2017,9,26],[8,0,0,0]))
    LUTpar=AKF_1.read_restdb_old(larchivepath+"PARLOG/V"+str(version)+"/_signal.json?from="+str(time-10)+"&upto="+str(time+20))
    if LUTpar[0]:
        LUTid=LUTpar[2][0]['structure'][query]
        LUTs=read_restdb_old(larchivepath+"DATASTREAM/V"+str(version)+"/_signal.json?from="+str(time-10)+"&upto="+str(time+20))
        if LUTs[0]:
            LUTs=LUTs[2][0]
            LUT=[LUTs[0],LUTs[LUTid],LUTs[LUTid+1]]
            del LUTpar, LUTs
            return True,LUT
        else:
            print("unable to download the LUTs")
            del LUTpar, LUTs
            return False,0
    else:
        del LUTpar
        print("unable to find LUTs, check your request")
        return False,0

def download_NUC_by_program(port,program,exposure,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['0'][0]
        stoptime=prog[1]['trigger']['1'][0]
        return download_NUC_by_times(port,starttime,stoptime,exposure,version)
    else:
        print("cannot find the program")
        return False,0,0

def download_NUC_by_times(port,starttime,stoptime,exposure,version=1):
    larchivepath=archivepath+"QRT_IRCAM/AEF"+str(port)+"_NUC_"
#    NUC_parlog=AKF_1.read_restdb_old(archivepath+"PARLOG/V"+str(version)+"/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
    try:
        res = urllib.request.urlopen(larchivepath+"PARLOG/V"+str(version)+"/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
        signal_list = json.loads(res.read().decode('utf-8'))
        res.close()
        goon=True
    except urllib.error.URLError as e:
        print(e)
        goon=False
    if goon:        
        n=0
        nuctimes=[0]
        for NUCpar in signal_list['values']:
            if NUCpar['structure']['Texp']==exposure:
                nuctimes=[signal_list['dimensions'][2*n],signal_list['dimensions'][2*n+1]]
#                gain_i=NUCpar['structure']['gain_index']
                offset_i=NUCpar['structure']['offset_index']                
            n+=1 
        if nuctimes[0]!=0:
            NUC=AKF_1.read_restdb(larchivepath+"DATASTREAM/V"+str(version)+"/_signal.json?from="+str(nuctimes[0]-10)+"&upto="+str(nuctimes[1]+10))
            if NUC[0]:
                images=np.vsplit(NUC[2],np.shape(NUC[2])[0]/offset_i)                    
                return True,images,['gain','offset','cold','badpixels','gain_error','offset_error']
            else:
                print("NUC image for requested exposure time not found")
                return False, 0, 0
        else:
            print("NUC image for requested exposure time not found")
            return False,0,0
    else:
        return False,0,0
    
def download_background_by_program(port,program,exposure,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['0'][0]
        stoptime=prog[1]['trigger']['1'][0]
        return download_background_by_times(port,starttime,stoptime,exposure,version)
    else:
        print("cannot find the program")
        return False,0,0
    
def download_background_by_times(port,starttime,stoptime,exposure,camera_filter=0,version=1):
    if port==50:#camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_background_"      
    elif port in [10,11,20,21,30,31,40,41,51]:#camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_background_"   
    else:
        print("camera unknown, stopping here")
        raise Exception
    try:
        res = urllib.request.urlopen(larchivepath+"PARLOG/V"+str(version)+"/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
        signal_list = json.loads(res.read().decode('utf-8'))
        res.close()
        goon=True
    except urllib.error.URLError as e:
        print(e)
        goon=False
    if goon: 
        n=0
        backtimes=[0]
        for backpar in signal_list['values']:
            if backpar['structure']['Texp']==exposure:
                if port==50:# camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
                    if backpar['structure']['filter']==camera_filter:
                        backtimes=[signal_list['dimensions'][2*n],signal_list['dimensions'][2*n+1]]                             
                else:
                    backtimes=[signal_list['dimensions'][2*n],signal_list['dimensions'][2*n+1]]                             
            n+=1
        if backtimes[0]!=0:
            backdat=AKF_1.read_restdb(larchivepath+"DATASTREAM/V"+str(version)+"/_signal.json?from="+str(backtimes[0]-10)+"&upto="+str(backtimes[1]+10))
            if backdat[0]:                                    
                return backdat#[True,backdat[2]]
            else:
                print("background image for requested exposure time(, filter) not found")
                return False,0,0
        else:
            print("background image for requested exposure time(, filter) not found")
            return False,0,0
    else:
        return False,0,0

def download_raw_images_by_program(port,program,time_s=0,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['1'][0]
        stoptime=prog[1]['trigger']['6'][0]
        if time_s==0:
            return download_raw_images_by_times(port,starttime,stoptime,version)
        else:
            return download_raw_images_by_times(port,starttime,int(starttime+time_s*1e9),version)
    else:
        print("cannot find the program")
        return False,0,0

def download_raw_images_by_times(port,starttime,stoptime,version=1,intervalSize=1E9):
    if port==50:#camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_raw_DATASTREAM/V"+str(version)+"/0/raw"
    elif port in [10,11,20,21,30,31,40,41,51]:#camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_raw_DATASTREAM/V"+str(version)+"/0/raw"
    else:
        print("camera unknown, stopping here")
        raise Exception
    if (stoptime-starttime)/intervalSize>1:        
        nrinterv=int(np.ceil((stoptime-starttime)/intervalSize))
        print("timewindow to large, put it into smaller fractions ("+str(nrinterv)+")")
        intervalls=[]
        for i in range(nrinterv):
            intervalls.append(int(starttime-10+i*intervalSize))
        intervalls.append(stoptime)
        for i in range(nrinterv):
            try:
                res = urllib.request.urlopen(larchivepath+"/_signal.json?from="+str(intervalls[i])+"&upto="+str(intervalls[i+1]))
                signal_list = json.loads(res.read().decode('utf-8'))
                res.close()
                signal=np.array(signal_list['values'],dtype=np.uint16)
                t=np.array(signal_list['dimensions'])
                del signal_list
                if i==0:
                    ressignal=signal
                    time=t
                else:
                    ressignal=np.append(ressignal,signal,axis=0)
                    time=np.append(time,t)
                del signal,t
            except urllib.error.URLError as e:
                print(e)
        return True,time,ressignal
    else:
        try:
            res = urllib.request.urlopen(larchivepath+"/_signal.json?from="+str(starttime-10)+"&upto="+str(stoptime))
            signal_list = json.loads(res.read().decode('utf-8'))
            res.close()
            signal=np.array(signal_list['values'],dtype=np.uint16)
            t=np.array(signal_list['dimensions'])
            del signal_list
            return True, t, signal
        except urllib.error.URLError as e:
            print(e)
            return False, 0,-1
    
def download_raw_parlog_by_program(port,program,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['1'][0]
        stoptime=prog[1]['trigger']['6'][0]
        return download_raw_parlog_by_times(port,starttime,stoptime,version)    
    else:
        print("cannot find the program")
        return False,0,0
    
def download_raw_parlog_by_times(port,starttime,stoptime,version=1):
    if port==50:#camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_raw_PARLOG/V"+str(version)
    elif port in [10,11,20,21,30,31,40,41,51]:#elif camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_raw_PARLOG/V"+str(version)   
    else:
        print("camera unknown, stopping here")
        raise Exception
    try:
        res = urllib.request.urlopen(larchivepath+"/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
        signal_list = json.loads(res.read().decode('utf-8'))
        res.close()
        goon=True
    except urllib.error.URLError as e:
        print(e)
        goon=False
    if goon: 
        return True, signal_list['dimensions'],signal_list['values'][0]['meta-data']
    

def get_INFRATEC_filter_by_program(program,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['1'][0]
        stoptime=prog[1]['trigger']['6'][0]
        return  get_INFRATEC_filter_by_times(starttime,stoptime,50,version)
    else:
        print("cannot find the program")
        return False,0,0

def get_INFRATEC_filter_by_times(starttime,stoptime,port=50,version=1):
    larchivepath=archivepath+"QRT_INFRATEC/AEF"+str(port)+"_raw_PARLOG/V"+str(version)
    try:
        res = urllib.request.urlopen(larchivepath+"/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
        signal_list = json.loads(res.read().decode('utf-8'))
        res.close()
        goon=True
    except urllib.error.URLError as e:
        print(e)
        goon=False
    if goon: 
        return True, signal_list['dimensions'],signal_list['values'][0]['meta-data']['filter']  
    else:
        return False, 0,-1
    
def get_exposure_by_program(port,program,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['1'][0]
        stoptime=prog[1]['trigger']['6'][0]
        return get_exposure_by_times(port,starttime,stoptime,version)
    else:
        print("cannot find the program")
        return False,0,0
        
def get_exposure_by_times(port,starttime,stoptime,version=1):
    if port==50:#camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_meta_"      
    elif port in [10,11,20,21,30,31,40,41,51]:#camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_meta_"   
    return AKF_1.read_restdb(larchivepath+"DATASTREAM/V"+str(version)+"/3/exposuretime"+"/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
      
def get_camera_temp_by_program(port,program,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['1'][0]
        stoptime=prog[1]['trigger']['6'][0]
        return get_camera_temp_by_times(port,starttime,stoptime,version)
    else:
        print("cannot find the program")
        return False,0,0
        
def get_camera_temp_by_times(port,starttime,stoptime,version=1):
    if port==50:#camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_meta_"      
    elif port in [10,11,20,21,30,31,40,41,51]:#camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_meta_"
    else:
        print("Port unknown")
        raise Exception
    return AKF_1.read_restdb(larchivepath+"DATASTREAM/V"+str(version)+"/1/cameratemperature/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
    
def get_sensor_temp_by_program(port,program,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['1'][0]
        stoptime=prog[1]['trigger']['6'][0]
        return get_sensor_by_times(port,starttime,stoptime,version)
    else:
        print("cannot find the program")
        return False,0,0
        
def get_sensor_by_times(port,starttime,stoptime,version=1):
    if port==50:#camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_meta_"      
    elif port in [10,11,20,21,30,31,40,41,51]:#camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_meta_"
    return AKF_1.read_restdb(larchivepath+"DATASTREAM/V"+str(version)+"/0/sensortemperature/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))

def get_camera_framerate_by_program(port,program,version=1):
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        starttime=prog[1]['trigger']['1'][0]
        stoptime=prog[1]['trigger']['6'][0]
        return get_camera_framerate_by_times(port,starttime,stoptime,version)
    else:
        print("cannot find the program")
        return False,0,0
        
def get_camera_framerate_by_times(port,starttime,stoptime,version=1):
    if port==50:#camera=="INFRATEC" or camera=="infratec" or camera=="Infratec":
        larchivepath=archivepath+"QRT_INFRATEC/"+"AEF"+str(port)+"_meta_"      
    elif port in [10,11,20,21,30,31,40,41,51]:#camera=="IRCAM" or camera=="IRcam" or camera=="ircam":
        larchivepath=archivepath+"QRT_IRCAM/"+"AEF"+str(port)+"_meta_"
    return AKF_1.read_restdb(larchivepath+"DATASTREAM/V"+str(version)+"/2/framerate/_signal.json?from="+str(starttime)+"&upto="+str(stoptime))
    

def get_average_divertor_TC_for_camtemp(port,starttime,endtime,part="all",TC=0):
    urlstart="http://archive-webapi.ipp-hgw.mpg.de/ArchiveDB/raw/W7X/CoDaStationDesc.115/"
    if port==50 or port==51:
        urlstart=urlstart+"DataModuleDesc.19471_DATASTREAM/"
    else:
        urlstart=urlstart+"DataModuleDesc.262_DATASTREAM/"
    if port %10==1:##uneven cameraport, even TC port
        portnr=port-1
        offset=(port//10-1)*32
    elif port%10==0:##even cameraport, uneven TC port
        portnr=port+1
        offset=(port//10-1)*32+16
    else:
        print("unknown port!")
        raise Exception
    if portnr==50:
        offset=0
    elif portnr==51:
        offset=16
    ext="/ActV1QRD"+str(portnr)+"CT1"
    n=0
    signal=0
    success=True
    if portnr==21:
        skip=True
        skipnr=1
    else:
        skip=False
        skipnr=0
    if part=="all":
        rs=0
        re=10
    elif part in ["h","horizontal","full h","full horizontal"]:
        rs=0
        re=7
    elif part in ["v","vertical","vertikal"]: 
        rs=7
        re=10
    elif part in ["hli","horizontal low iota"]:
        rs=0#4
        re=4#7
    elif part in ["hhi","horizontal high iota","high iota","hi"]:
        rs=4#0
        re=7#4
    elif part in [0,1,2,3,4,5,6,7,8,9,10]:
        rs=part
        re=part+1
    elif part in ["Single","s","single"]:
        rs=TC
        re=TC+1
    else:
        rs=0
        re=0
    if rs!=re:
        for i in range(rs,re,1):
            if skip and i==skipnr:
                i+=1
            url=urlstart+str(offset+i)+ext+"0"+str(i)+"_TC"+str(i%8+1)
            try:
                result=AKF_1.read_restdb(url+"/_signal.json?from="+str(starttime)+"&upto="+str(endtime))
    #                res.append(result)
                if result[0]:
                    n+=1            
                    time=result[1]
                    signal=signal+np.array(result[2])
                else:
                    time=0
                    success=False
            except Exception as E:
                print(E)        
                success=False
        return success,time,signal/n
    else:
        return False,0,-1
"""
end of download functions, below combination to get temperature
"""

def apply_LUT_to_images(LUT,images):
    LUTd={LUT[0][i]: LUT[1][i] for i in range(0, len(LUT[0]))}
    return np.vectorize(LUTd.get)(images)

def get_temp_from_raw_by_program_V1(portnr,program,time_s=0,emi=0.8,divertorpart="all",version=1,intervalSize=1E9):
    if portnr==50:
        cf=get_INFRATEC_filter_by_program(program,version)
        if cf[0]:
            cfilter=cf[2]
        else:
            cfilter=-1
            print("Filter not found for INFRATEC Camera")
            raise Exception
    else:
        cfilter=0
    prog=AKF_1.get_program_from_PID(program)
    if prog[0]:
        t0=prog[1]['trigger']['0'][0]
        t1=prog[1]['trigger']['1'][0]
        t6=prog[1]['trigger']['1'][0]
        expoDL=get_exposure_by_times(portnr,t1,t6,version)
        if expoDL[0]:
            t_exp=expoDL[2][0]
            del expoDL
            time=int(TimeToNs([2017,9,26],[8,0,0,0]))   
            LUT_DL=download_LUT(portnr,time,t_exp,emi,cfilter,version)
            if LUT_DL[0]:
                LUT=LUT_DL[1]
                del LUT_DL
                back_dl=download_background_by_times(portnr,t0,t1,t_exp,version)
                if back_dl[0]:
                    background=back_dl[2]
    #                background=background.swapaxes(0,1)
                    backtime=back_dl[1]
                    backtime=backtime.tolist()
                    TCT_dl=get_average_divertor_TC_for_camtemp(portnr,int(backtime-1e9),int(backtime+1e9),divertorpart)
                    if TCT_dl[0]:
                        TCT=np.average(TCT_dl[2])
                    else:
                        print("loading TC data was not successfull")
                        TCT=0
                    del back_dl
                    if portnr!=50:
                        #tempcalc for the IRCAMs
                        NUC_DL=download_NUC_by_times(portnr,t0,t1,t_exp,version)
                        if NUC_DL[0]==False:
                            print("NUC was not found")
                            return False,0,-1
                            raise Exception
                        else:
                            gain=NUC_DL[1][0]
                            offset=NUC_DL[1][1]
                            starttime=t1
                            if time_s==0:                                
                                stoptime=t6
                            else:
                                stoptime=int(starttime+time_s*1e9)
                            print(datetime.datetime.now(),"Start download of raw images")
                            success=True
                            if (stoptime-starttime)/intervalSize>1:        
                                nrinterv=int(np.ceil((stoptime-starttime)/intervalSize))
                                print("timewindow to large, put it into smaller fractions ("+str(nrinterv)+")")
                                intervalls=[]
                                for i in range(nrinterv):
                                    intervalls.append(int(starttime-10+i*intervalSize))
                                intervalls.append(stoptime)
                                
                                for i in range(nrinterv):                            
                                    raw_dl=download_raw_images_by_times(portnr,program,time_s,version,intervalSize)
                                    print(datetime.datetime.now(),"download of raw images part "+str(i+1)+" of "+str(nrinterv)+" finished")
                                    if raw_dl[0]:
                                        time=raw_dl[1]
                                        images=raw_dl[2]
            #                            del raw_dl
                                        images=images.swapaxes(1,2)
                                        images=images[:]*gain
                                        images=images[:]+offset
                                        images=images[:]-background
                                        images=images.clip(min=0)
                                        images=np.array(images,dtype=np.uint16)
                                        images=apply_LUT_to_images(LUT,images)
                                        images=images+(TCT+273.15)
                                        if i==0:
                                            temperatureimages=images
                                            times=time
                                        else:
                                            temperatureimages=np.append(temperatureimages,images,axis=0)
                                            times=np.append(times,times)                                        
                                    else:
                                        print("cannot download the raw images")
                                        success=False
                            else:
                                raw_dl=download_raw_images_by_times(portnr,program,time_s,version,intervalSize)
                                if raw_dl[0]:
                                    times=raw_dl[1]
                                    temperatureimages=raw_dl[2]
        #                            del raw_dl
                                    temperatureimages=temperatureimages.swapaxes(1,2)
                                    temperatureimages=temperatureimages[:]*gain
                                    temperatureimages=temperatureimages[:]+offset
                                    temperatureimages=temperatureimages[:]-background
                                    temperatureimages=temperatureimages.clip(min=0)
                                    temperatureimages=np.array(temperatureimages,dtype=np.uint16)
                                    temperatureimages=apply_LUT_to_images(LUT,temperatureimages)
                                    temperatureimages=temperatureimages+(TCT+273.15)                                    
                                else:
                                    print("cannot download the raw images")
                                    success=False
                                    times=0
                                    temperatureimages=-1
                            return success,times,temperatureimages                                
                    else:
                        #tempcalc for infratec
                        print(datetime.datetime.now(),"Start download of raw images")
                        raw_dl=download_raw_images_by_program(portnr,program,time_s,version)
                        print(datetime.datetime.now(),"download of raw images finished")
                        if (stoptime-starttime)/intervalSize>1:    
                            nrinterv=int(np.ceil((stoptime-starttime)/intervalSize))
                            print("timewindow to large, put it into smaller fractions ("+str(nrinterv)+")")
                            intervalls=[]
                            for i in range(nrinterv):
                                intervalls.append(int(starttime-10+i*intervalSize))
                            intervalls.append(stoptime)
                            
                            for i in range(nrinterv):                            
                                raw_dl=download_raw_images_by_times(portnr,program,time_s,version,intervalSize)
                                print(datetime.datetime.now(),"download of raw images part "+str(i+1)+" of "+str(nrinterv)+" finished")
                                if raw_dl[0]:
                                    time=raw_dl[1]
                                    images=raw_dl[2]
        #                            del raw_dl
                                    images=images.swapaxes(1,2)
                                    images=images[:]-background
                                    images=images.clip(min=0)
                                    images=np.array(images,dtype=np.uint16)
                                    images=apply_LUT_to_images(LUT,images)
                                    images=images+(TCT+273.15)
                                    if i==0:
                                        temperatureimages=images
                                        times=time
                                    else:
                                        temperatureimages=np.append(temperatureimages,images,axis=0)
                                        times=np.append(times,times)                                        
                                else:
                                    print("cannot download the raw images")
                                    success=False
                            return success,times,temperatureimages
                        else:
                            if raw_dl[0]:
                                time=raw_dl[1]
                                images=raw_dl[2]
                                images=images.swapaxes(1,2)
                                images=images[:]-background
                                images=images.clip(min=0)
                                images=np.array(images,dtype=np.uint16)
                                images=apply_LUT_to_images(LUT,images)
                                images=images+(TCT+273.15)
                                return True,time,images
                            else:
                                print("cannot download the raw images")
                                return False,0,-1
                else:
                    print("Background image not found for temperature calculation!")
                    return False,0,-1
            else:
                print("LUT not found, cannot calculate temperature")
                return False,0,-1
        else:
            print("cannot get the used exposure time")
            return False,0,-1
    else:
        print("cannot find program")
        return False,0,-1
    
if __name__=='__main__':
    status,time,images=get_temp_from_raw_by_program_V1(51,"20171018.019",time_s=0,emi=0.8,divertorpart="all",version=1)