import article2_time_resolved_routines as trr

import case_dict_overall_correction as cdoc

from os.path import join

from numpy import arange

root = '/media/carlos/6E34D2CD34D29783/2015-02_SerrationPIV/'\

+'TR_Data_Location_Calibrated'

case_dict = cdoc.return_case_df()

for case in case_dict.iterrows():

case_file = case[1].file

skip = False

if len(exceptions):

for ex in exceptions:

if ex in case_file:

skip = True

if not skip:

#x_locs = [float(f) for f in case[1].x_loc.split(',')]

if 'z00' in case_file and 'Sr' in case_file:

x_locs = arange( 36, 40.2, 0.2 )

elif 'z05' in case_file and 'Sr' in case_file:

x_locs = arange( 16, 20.2, 0.2 )

elif 'z10' in case_file or 'STE' in case_file:

x_locs = arange( -5, -0.8, 0.2 )

trr.wall_normal_data_to_reserved_pickles_from_pandas_hdf(

join(root, case_file), x_locs , overwrite = False, append = True

from os import listdir

from re import findall

import pandas as pd

available_reserved_files = [

f for f in listdir(root) if f.endswith(".p")

]

cases_df = pd.DataFrame( columns = ['file','x','y'] )

for res_file in available_reserved_files:

cases_df = cases_df.append(

pd.DataFrame(

data = {

'x' : float(findall(

'x[-0-9][0-9]?.[0-9]', res_file

)[0].replace('x','')),

'y' : float(findall(

'y[-0-9][0-9]?.?[0-9]?', res_file

)[0].replace('y','')),

'file' : findall(

'[A-Za-z0-9_]+_x', res_file

)[0]\

.replace('_x','')\

.replace('5','')\

.replace('_AirfoilNormal','') ,

},

index = [0]

),

ignore_index = True)

from os import listdir

from os.path import join

from pandas import read_pickle

all_pickles = [f for f in listdir(root) if f.endswith('.p')]

case_time_series_dfs = []

for case in cases_df.iterrows():

for pickle in [p for p in all_pickles\

if case[1].file in p\

and "x{0:.0f}".format(case[1].x) in p\

and "y{0:.0f}".format(case[1].y) in p]:

df = read_pickle( join( root, pickle ) )

df['case_name'] = case[1].file

case_time_series_dfs.append( df )

import pandas as pd

from os.path import join

import article2_data_analysis_routines as dar

def do_the_frequency_plot(df,plot_name, schematic = ''):

for y in df.near_y_delta.unique():

df_y_cases = df[ df.near_y_delta == y ]

dar.do_the_frequency_analysis(

df_y_cases,

y = y,

plot_name = plot_name,

schematic = schematic

)

def do_the_Reynolds_quadrant_analysis(df, plot_name):

for y in df.near_y_delta.unique():

if round( y, 2 ) in [0.9]:#, 0.3, 0.6, 0.9]:

df_y_cases = df[ df.near_y_delta == y ]

dar.do_the_reynolds_stress_quadrant_analysis(

df_y_cases,

y_delta = y,

plot_name = plot_name,

)

def do_the_coherence_analysis(df_upstream, df_downstream

,plot_name,schematic = ''):

coherence_df = pd.DataFrame()

for y_up, y_down in zip(

sorted(df_upstream.near_y_delta.unique()),

sorted(df_downstream.near_y_delta.unique())

):

partial_coherence_df = dar.do_the_coherence_analysis(

df_upstream[ df_upstream.near_y_delta == y_up ],

df_downstream[ df_downstream.near_y_delta == y_down ],

)

if not partial_coherence_df.empty:

coherence_df = coherence_df.append(

partial_coherence_df, ignore_index = True

)

dar.plot_coherence_Uc_phi( coherence_df ,

plot_name = plot_name,

schematic = schematic)

all_cases_pickle = pd.read_pickle( join( root, 'AllPointPickle.p' ) )

#x0_cases = all_cases_pickle[

# all_cases_pickle.near_x == -1

#]

#x0_coherence_cases = all_cases_pickle[

# (all_cases_pickle.near_x == -3) | (all_cases_pickle.near_x == -1)

#]

#x0_coherence_cases = x0_coherence_cases[

# x0_coherence_cases.case_name != "STE_a0_p0_U20_z00_tr"

#]

# TE locations # ###########################################################

#TE_cases = all_cases_pickle[

# (all_cases_pickle.near_x == -1) & \

# (all_cases_pickle.case_name == 'STE_a0_p0_U20_z00_tr')

#]

TE_cases = \

all_cases_pickle[

#(all_cases_pickle.near_x == -1) & \

(all_cases_pickle.case_name == \

'Sr20R21_a0_p0_U20_z10_tr')

]

TE_cases = TE_cases.append(

all_cases_pickle[

#(all_cases_pickle.near_x == 20) & \

(all_cases_pickle.case_name == \

'Sr20R21_a0_p0_U20_z05_tr_New')

], ignore_index = True

)

TE_cases = TE_cases.append(

all_cases_pickle[

#(all_cases_pickle.near_x == 40) & \

(all_cases_pickle.case_name == \

'Sr20R21_a0_p0_U20_z00_tr')

], ignore_index = True

)

TE_cases = TE_cases.append(

all_cases_pickle[

#(all_cases_pickle.near_x == -1) & \

(all_cases_pickle.case_name == \

'STE_a0_p0_U20_z00_tr')

], ignore_index = True

)

## upstream locations ######################################################

##TE_cases_upstream = all_cases_pickle[

## (all_cases_pickle.near_x == -3) & \

## (all_cases_pickle.case_name == 'STE_a0_p0_U20_z00_tr')

##]

##up_shift = -4

#up_shift = -2

#TE_cases_upstream = \

# all_cases_pickle[

# (all_cases_pickle.near_x == -1 + up_shift) & \

# (all_cases_pickle.case_name == \

# 'Sr20R21_a0_p0_U20_z10_tr')

# ]

#TE_cases_upstream = TE_cases_upstream.append(

# all_cases_pickle[

# (all_cases_pickle.near_x == 20 + up_shift) & \

# (all_cases_pickle.case_name == \

# 'Sr20R21_a0_p0_U20_z05_tr_New')

# ], ignore_index = True

#)

#TE_cases_upstream = TE_cases_upstream.append(

# all_cases_pickle[

# (all_cases_pickle.near_x == 40 + up_shift) & \

# (all_cases_pickle.case_name == \

# 'Sr20R21_a0_p0_U20_z00_tr')

# ], ignore_index = True

#)

#TE_cases_upstream = TE_cases_upstream.append(

# all_cases_pickle[

# (all_cases_pickle.near_x == -1 + up_shift) & \

# (all_cases_pickle.case_name == \

# 'STE_a0_p0_U20_z00_tr')

# ], ignore_index = True

#)

#TE_cases = correct_heights( TE_cases )

#TE_cases_upstream = correct_heights( TE_cases_upstream )

schematic_TE = '/home/carlos/Documents/PhD/Articles/Article_2/'+\

'Figures/measurement_locations_TE_m2_with_edge_normal.png'

#do_the_frequency_plot( TE_cases, 'TE', schematic = schematic_TE)

schematic_x0 = '/home/carlos/Documents/PhD/Articles/Article_2/'+\

'Figures/measurement_locations_x0_m2.png'

schematic_TE = '/home/carlos/Documents/PhD/Articles/Article_2/'+\

'Figures/measurement_locations_TE_m2_noSTE.png'

#TE_cases = TE_cases[ TE_cases.case_name != 'STE_a0_p0_U20_z00_tr' ]

do_the_Reynolds_quadrant_analysis( TE_cases, 'TE' )

#do_the_coherence_analysis( TE_cases_upstream, TE_cases, 'TE' ,

# schematic = schematic_TE)

#dar.plot_mean_and_std( TE_cases )

#do_the_frequency_plot( x0_cases, 'x0', schematic = schematic_x0 )

#do_the_Reynolds_quadrant_analysis( x0_cases, 'x0' )

#do_the_coherence_analysis( x0_coherence_cases , "x0",

import article2_data_analysis_routines as dar

from os.path import join

root = '/home/carlos/Documents/PhD/Articles/Article_2/' + \

'Article2_Scripts/time_resolved_scripts/Results_v2'

source_root = '/home/carlos/Documents/PhD/Articles/Article_2/' + \

'Article2_Scripts/time_resolved_scripts/ReservedData'

def do_the_vertical_coherence_analysis(

hdfs ,

plot_individual = False,

overwrite = False

):

#dar.get_vertical_correlation(

# [ join( source_root, h ) for h in hdfs ],

# root = root,

# plot_individual = plot_individual ,

# overwrite = overwrite

#)

#for hdf in hdfs:

# dar.plot_vertical_correlation_from_pickle(

# join(

# root,

# 'WallNormalCorrelation_Values_' + hdf.replace(

# '.hdf5', '.p'

# )

# ),

# root = root

# )

#dar.get_vertical_length_scale( root = root )

dar.print_vertical_length_scale_bl_integration( )

def do_the_streamwise_coherence_analysis( hdfs , overwrite = False ):

#for hdf in hdfs:

#dar.get_streamwise_coherence_and_correlation(

# join( source_root, hdf ),

# overwrite = overwrite

#)

#dar.plot_streamwise_correlation_from_pickle(

# 'StreamwiseCorrelation_Values_' + hdf.replace( '.hdf5', '.p' )

#)

#dar.do_the_streamwise_coherence_analysis(

# 'StreamwiseCoherence_Values_' + hdf.replace( '.hdf5', '.p' ),

# overwrite = overwrite

#)

#dar.get_streamwise_length_scale_and_ke()

#dar.plot_pickled_Uc(

# [ 'Uc_data_Values_' + f.replace('.hdf5','.p') for f in hdfs ],

# print_integration = True

#)

dar.plot_wavenumber_spectra(

[ join( source_root, h ) for h in hdfs ],

var = 'u'

)

#dar.plot_phi()

hdf_list_to_process = [

'STE_a0_p0_U20_z00_tr.hdf5',

'Sr20R21_a0_p0_U20_z10_tr.hdf5',

'Sr20R21_a0_p0_U20_z05_tr.hdf5',

'Sr20R21_a0_p0_U20_z00_tr.hdf5',

]

do_the_streamwise_coherence_analysis(

hdf_list_to_process,

overwrite = True

)

#do_the_vertical_coherence_analysis(

# hdf_list_to_process,

# plot_individual = False,

# overwrite = True