time_function.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue May 22 11:01:09 2018

@author: Sébastien Durand
"""
from astropy.time import Time
import numpy as np
second_day  = 24*60*60


def time_step_gen(time_interval, start_MJD, end_MJD, time_type = "mjd", input_type="vector", output_type="vector"):
    
    """
    Generate list of Julian date with time step
    
    Input:
        time_interval (float): setting the interval of iteration (unit: sec)
        start_MJD (list float 1x2): Vector for starting time in time_type format
        end_MJD (list float 1x2): Vector for ending time in time_type format
        time_type (string): mjd or jd for input and output
        output_type (string): vector, float, astropy
        input_type (string) : vector, float, astropy
    Output:
        MJD_date (list float Nx2, list float Nx1 or astropy): vector for MJD date [day,second], [day], astropy
        
    """
    # Load parameters from input and normalize the initial quaternion

    if input_type == "vector":
        #rien
        start_MJD = start_MJD
        end_MJD = end_MJD
    elif input_type == "float":
        start_MJD_new = np.zeros(2)
        start_MJD_new[0] = np.int(start_MJD)
        start_MJD_new[1] = (start_MJD%1)*second_day
        start_MJD = start_MJD_new
        end_MJD_new = np.zeros(2)
        end_MJD_new[0] = np.int(end_MJD)
        end_MJD_new[1] = (end_MJD%1)*second_day
        end_MJD = end_MJD_new
    elif input_type == "astropy":
        start_MJD_new = np.zeros(2)
        end_MJD_new = np.zeros(2)
        if time_type == "mjd":
            start_MJD_new[0] = np.int(start_MJD.mjd)
            start_MJD_new[1] = (start_MJD.mjd%1)*second_day
            end_MJD_new[0] = np.int(end_MJD.mjd)
            end_MJD_new[1] = (end_MJD.mjd%1)*second_day
        elif time_type == "jd":
            start_MJD_new[0] = np.int(start_MJD.jd)
            start_MJD_new[1] = (start_MJD.jd%1)*second_day
            end_MJD_new[0] = np.int(end_MJD.jd)
            end_MJD_new[1] = (end_MJD.jd%1)*second_day
            
        start_MJD = start_MJD_new
        end_MJD = end_MJD_new
        

        
    else : 
        raise AttributeError("undefined output format")
        
    # Calculate the period of time
    if( end_MJD[0] >= start_MJD[0] ):
        if((end_MJD[0] == start_MJD[0]) and (end_MJD[1] < start_MJD[1])):
            raise ValueError("the MJD beginning second is not before the MJD end second")
        else:
            time_duration = (end_MJD[0]-start_MJD[0]) * second_day + (end_MJD[1]-start_MJD[1])
    else:
        raise ValueError("the MJD beginning date is not before the MJD end date")
      
    # Initialize  
    #date_ = start_MJD[0]
    #sec_ = start_MJD[1]
    nb = np.int32(time_duration / time_interval)
    
    MJD_all_sec = (np.arange(nb)*time_interval)+start_MJD[1]
    MJD_sec = MJD_all_sec%second_day
    MJD_day = np.floor_divide(MJD_all_sec,second_day)+start_MJD[0]
    MJD_date_temp = np.zeros((nb,2),dtype=np.float64)
    MJD_date_temp[:,0] = MJD_day
    MJD_date_temp[:,1] = MJD_sec
    if output_type == "vector":
        MJD_date = MJD_date_temp
        
    elif output_type == "float" or output_type == "astropy":
        MJD_date = MJD_date_temp[:,0]+MJD_date_temp[:,1]/second_day
        
    elif output_type == "astropy":
        MJD_date = Time(MJD_date,format=time_type, scale='utc')
            
    else : 
        raise AttributeError("undefined output format")
    
    return MJD_date
            
  

def add_zero_to_str(num):
    """
    Convert List of float/int to string and add 0 for number < 10 and >= 0
    
    Input :
        num (list of int/float or Int/float number) : Int/float for converting

    Output :
        s_num (list of string or string) :converted number
        
    """
    
    if type(num) == list :
        correct_str = np.where((np.array(num)<10)&(np.array(num)>=0))[0]
        s_num = list(map(str, num))

        for i in correct_str:
            s_num[i]="0"+s_num[i]
    else:
        if (num<10 and num >= 0):
            s_num = "0"+str(num)
    
        else:
            s_num = str(num)
    return s_num

def julian_to_vector_julian(Julian_time):
    
    day, hour = np.divmod(Julian_time,1, dtype=np.float64)
    vector_julian = [np.int32(day),second_day*hour]
    
    return np.array(vector_julian).T

def time_to_mjd(utc_time_years, utc_time_month,utc_time_day,utc_time_hour,
                utc_time_minute,utc_time_second, julian_type='MJD', output_type="vector"):
    
    """
    Convert List or one UTC date to Julian date
    
    Input :
        utc_time_years (list int or int) : Number of years
        utc_time_month (list int or int) : Number of month
        utc_time_day (list int or int) : Number of day
        utc_time_hour (list int or int) : Number of hour
        utc_time_minute (list int or int) : Number of minute
        utc_time_second (list float or float) : Number of seconds
        julian_type (string, "MJD") : Output type of Julian Date ("MJD", "JD")
        output_type (string, "vector") : Output format of Julian Date ( "vector" or "float")
        
    Output :
        julian_time or vector_julian (list float or float array)
        
        
        if the input is a list of int/float then the output is a list of float
        if the input is a int/float then the output is a float
        
        for "vector" : [Julian_date(int),second(float)]
        for list "vector" : [[Julian_date1(int),Julian_date2(int)],[second1(float),second2(float)]]
        for "float" : [Julian_date(float)]
        for list "float" : [Julian_date+s1(float),Julian_date+s2(float)]
        
    """
    
    if ((((type(utc_time_years) == list) and (type(utc_time_month) == list)) and
        ((type(utc_time_day) == list) and (type(utc_time_hour) == list))) and 
        ((type(utc_time_minute) == list) and (type(utc_time_second) == list))):
        

        if (((len(utc_time_years)== len(utc_time_month)) and 
             (len(utc_time_day) == len(utc_time_hour))) and 
             (len(utc_time_minute) == len(utc_time_second))):
            
            if len(utc_time_years) == 1:
                s_utc_time_years = str(utc_time_years[0])
                s_utc_time_month = add_zero_to_str(utc_time_month[0])
                s_utc_time_day = add_zero_to_str(utc_time_day[0])
                s_utc_time_hour = add_zero_to_str(utc_time_hour[0])
                s_utc_time_minute = add_zero_to_str(utc_time_minute[0])
                s_utc_time_second = add_zero_to_str(utc_time_second[0])
                utc_time = s_utc_time_years+"-"+s_utc_time_month+"-"+s_utc_time_day+"T"+s_utc_time_hour+":"+s_utc_time_minute+":"+s_utc_time_second
                
            else:
                utc_time = []
                
                s_utc_time_years = list(map(str,utc_time_years))
                s_utc_time_month = add_zero_to_str(utc_time_month)
                s_utc_time_day = add_zero_to_str(utc_time_day)
                s_utc_time_hour = add_zero_to_str(utc_time_hour)
                s_utc_time_minute = add_zero_to_str(utc_time_minute)
                s_utc_time_second = add_zero_to_str(utc_time_second)
                
                for i in range(len(utc_time_years)):
                    utc_time.append(s_utc_time_years[i]+"-"+s_utc_time_month[i]+"-"+s_utc_time_day[i]+"T"+s_utc_time_hour[i]+":"+s_utc_time_minute[i]+":"+s_utc_time_second[i])
                
        else:
            raise IndexError("Len Error of input arguments")
        
    else:
        s_utc_time_years = str(utc_time_years)
        s_utc_time_month = add_zero_to_str(utc_time_month)
        s_utc_time_day = add_zero_to_str(utc_time_day)
        s_utc_time_hour = add_zero_to_str(utc_time_hour)
        s_utc_time_minute = add_zero_to_str(utc_time_minute)
        s_utc_time_second = add_zero_to_str(utc_time_second)
        utc_time = s_utc_time_years+"-"+s_utc_time_month+"-"+s_utc_time_day+"T"+s_utc_time_hour+":"+s_utc_time_minute+":"+s_utc_time_second
    
    time_astro_utc = Time(utc_time, format='isot', scale='utc')
    
    if (julian_type == 'MJD'):
        Julian_time = time_astro_utc.mjd
        
    elif(julian_type == 'JD'):
        Julian_time = time_astro_utc.jd
    
    else:
        raise AttributeError("undefined julian type")
        
    if (output_type == "vector"):
        #vector_julian = [np.int32(Julian_time),(60*60*24)*(Julian_time - np.int32(Julian_time))]
        vector_julian = [np.int32(Julian_time),np.array(utc_time_second)+60*np.array(utc_time_minute)+60*np.array(utc_time_hour)]
        return vector_julian
    elif(output_type == "float"):
        return Julian_time
    else:
        raise AttributeError("undefined output format")