#### import the simple module from the paraview
from paraview.simple import *
#### disable automatic camera reset on 'Show'
paraview.simple._DisableFirstRenderCameraReset()

# create a new 'VisItNek5000Reader'
VisItNek5000Reader1 = VisItNek5000Reader(FileName='/cluster/scratch/pcorso/nek_Re2100_newInflow/allInstF/stnInst.nek5000')
VisItNek5000Reader1.Meshes = ['mesh']
VisItNek5000Reader1.PointArrays = ['pressure','velocity']

SetActiveSource(VisItNek5000Reader1)

gradInst = GradientOfUnstructuredDataSet(Input=VisItNek5000Reader1)
gradInst.ScalarArray = ['POINTS', 'velocity']
gradInst.ResultArrayName = 'Gradients1'

SetActiveSource(gradInst)

print "Gradients done"

# get active view
# renderView1 = GetActiveViewOrCreate('RenderView')
# uncomment following to set a specific view size
# renderView1.ViewSize = [1032, 399]

# show data in view
# VisItNek5000Reader1_Display = Show(VisItNek5000Reader1, renderView1)
# trace defaults for the display properties.
# VisItNek5000Reader1_Display.Representation = 'Outline'
#VisItNek5000Reader1_Display.AmbientColor = [0.0, 0.0, 0.0]
#VisItNek5000Reader1_Display.ColorArrayName = [None, '']
#VisItNek5000Reader1Display.GlyphType = 'Arrow'
#VisItNek5000Reader1Display.CubeAxesColor = [0.0, 0.0, 0.0]
#VisItNek5000Reader1_Display.ScalarOpacityUnitDistance = 0.0014000092831692186

velOff = Calculator(Input=gradInst)
velOff.ResultArrayName = 'velocityOff'
velOff.Function = 'velocity_X*velocity_Y*iHat + velocity_X*velocity_Z*jHat + velocity_Y*velocity_Z*kHat'

SetActiveSource(velOff)

print "VelOff done"

velDiag = Calculator(Input=velOff)
velDiag.ResultArrayName = 'velocityDiag'
velDiag.Function = 'velocity_X*velocity_X*iHat + velocity_Y*velocity_Y*jHat + velocity_Z*velocity_Z*kHat'

SetActiveSource(velDiag)

print "VelDiag done"

calcSxx = Calculator(Input=velDiag)
calcSxx.ResultArrayName = 'Sinst_XX'
calcSxx.Function = 'Gradients1_0'

SetActiveSource(calcSxx)

print "Sxx done"

calcSxy = Calculator(Input=calcSxx)
calcSxy.ResultArrayName = 'Sinst_XY'
calcSxy.Function = '(1/2*(Gradients1_1+Gradients1_3))'

SetActiveSource(calcSxy)

print "Sxy done"

calcSxz = Calculator(Input=calcSxy)
calcSxz.ResultArrayName = 'Sinst_XZ'
calcSxz.Function = '(1/2*(Gradients1_2+Gradients1_6))'

SetActiveSource(calcSxz)

print "Sxz done"

calcSyy = Calculator(Input=calcSxz)
calcSyy.ResultArrayName = 'Sinst_YY'
calcSyy.Function = 'Gradients1_4'

SetActiveSource(calcSyy)

print "Syy done"

calcSyz = Calculator(Input=calcSyy)
calcSyz.ResultArrayName = 'Sinst_YZ'
calcSyz.Function = '(1/2*(Gradients1_5+Gradients1_7))'

SetActiveSource(calcSyz)

print "Syz done"

calcSzz = Calculator(Input=calcSyz)
calcSzz.ResultArrayName = 'Sinst_ZZ'
calcSzz.Function = 'Gradients1_8'

SetActiveSource(calcSzz)

print "Szz done"

calcVelxFilt = Calculator(Input=calcSzz)
calcVelxFilt.ResultArrayName = 'Velx'
calcVelxFilt.Function = 'velocity_X'

SetActiveSource(calcVelxFilt)

VelxG = GaussianResampling(Input=calcVelxFilt)
VelxG.ResampleField = ['POINTS', 'Velx']
VelxG.ResamplingGrid = [62, 57, 86]
VelxG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelxG.GaussianSplatRadius = 0.0117
VelxG.GaussianExponentFactor = -1.0
VelxG.EllipticalSplats = 0

SetActiveSource(VelxG)

calcVelxFilt2 = Calculator(Input=VelxG)
calcVelxFilt2.ResultArrayName = 'Velx_filt'
calcVelxFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelxFilt2)

print "velX filtered"

calcVelyFilt = Calculator(Input=calcSzz)
calcVelyFilt.ResultArrayName = 'Vely'
calcVelyFilt.Function = 'velocity_Y'

SetActiveSource(calcVelyFilt)

VelyG = GaussianResampling(Input=calcVelyFilt)
VelyG.ResampleField = ['POINTS', 'Vely']
VelyG.ResamplingGrid = [62, 57, 86]
VelyG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelyG.GaussianSplatRadius = 0.0117
VelyG.GaussianExponentFactor = -1.0
VelyG.EllipticalSplats = 0

SetActiveSource(VelyG)

calcVelyFilt2 = Calculator(Input=VelyG)
calcVelyFilt2.ResultArrayName = 'Vely_filt'
calcVelyFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelyFilt2)

print "velY filtered"

calcVelzFilt = Calculator(Input=calcSzz)
calcVelzFilt.ResultArrayName = 'Velz'
calcVelzFilt.Function = 'velocity_Z'

SetActiveSource(calcVelzFilt)

VelzG = GaussianResampling(Input=calcVelzFilt)
VelzG.ResampleField = ['POINTS', 'Velz']
VelzG.ResamplingGrid = [62, 57, 86]
VelzG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelzG.GaussianSplatRadius = 0.0117
VelzG.GaussianExponentFactor = -1.0
VelzG.EllipticalSplats = 0

SetActiveSource(VelzG)

calcVelzFilt2 = Calculator(Input=VelzG)
calcVelzFilt2.ResultArrayName = 'Velz_filt'
calcVelzFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelzFilt2)

print "velZ filtered"

calcVelxyFilt = Calculator(Input=calcSzz)
calcVelxyFilt.ResultArrayName = 'Velxy'
calcVelxyFilt.Function = 'velocityOff_X'

SetActiveSource(calcVelxyFilt)

VelxyG = GaussianResampling(Input=calcVelxyFilt)
VelxyG.ResampleField = ['POINTS', 'Velxy']
VelxyG.ResamplingGrid = [62, 57, 86]
VelxyG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelxyG.GaussianSplatRadius = 0.0117
VelxyG.GaussianExponentFactor = -1.0
VelxyG.EllipticalSplats = 0

SetActiveSource(VelxyG)

calcVelxyFilt2 = Calculator(Input=VelxyG)
calcVelxyFilt2.ResultArrayName = 'Velxy_filt'
calcVelxyFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelxyFilt2)

print "velXY filtered"

calcVelxzFilt = Calculator(Input=calcSzz)
calcVelxzFilt.ResultArrayName = 'Velxz'
calcVelxzFilt.Function = 'velocityOff_Y'

SetActiveSource(calcVelxzFilt)

VelxzG = GaussianResampling(Input=calcVelxzFilt)
VelxzG.ResampleField = ['POINTS', 'Velxz']
VelxzG.ResamplingGrid = [62, 57, 86]
VelxzG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelxzG.GaussianSplatRadius = 0.0117
VelxzG.GaussianExponentFactor = -1.0
VelxzG.EllipticalSplats = 0

SetActiveSource(VelxzG)

calcVelxzFilt2 = Calculator(Input=VelxzG)
calcVelxzFilt2.ResultArrayName = 'Velxz_filt'
calcVelxzFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelxzFilt2)

print "velXZ filtered"

calcVelyzFilt = Calculator(Input=calcSzz)
calcVelyzFilt.ResultArrayName = 'Velyz'
calcVelyzFilt.Function = 'velocityOff_Z'

SetActiveSource(calcVelyzFilt)

VelyzG = GaussianResampling(Input=calcVelyzFilt)
VelyzG.ResampleField = ['POINTS', 'Velyz']
VelyzG.ResamplingGrid = [62, 57, 86]
VelyzG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelyzG.GaussianSplatRadius = 0.0117
VelyzG.GaussianExponentFactor = -1.0
VelyzG.EllipticalSplats = 0

SetActiveSource(VelyzG)

calcVelyzFilt2 = Calculator(Input=VelyzG)
calcVelyzFilt2.ResultArrayName = 'Velyz_filt'
calcVelyzFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelyzFilt2)

print "velYZ filtered"

calcVelxxFilt = Calculator(Input=calcSzz)
calcVelxxFilt.ResultArrayName = 'Velxx'
calcVelxxFilt.Function = 'velocityDiag_X'

SetActiveSource(calcVelxxFilt)

VelxxG = GaussianResampling(Input=calcVelxxFilt)
VelxxG.ResampleField = ['POINTS', 'Velxx']
VelxxG.ResamplingGrid = [62, 57, 86]
VelxxG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelxxG.GaussianSplatRadius = 0.0117
VelxxG.GaussianExponentFactor = -1.0
VelxxG.EllipticalSplats = 0

SetActiveSource(VelxxG)

calcVelxxFilt2 = Calculator(Input=VelxxG)
calcVelxxFilt2.ResultArrayName = 'Velxx_filt'
calcVelxxFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelxxFilt2)

print "velXX filtered"

calcVelyyFilt = Calculator(Input=calcSzz)
calcVelyyFilt.ResultArrayName = 'Velyy'
calcVelyyFilt.Function = 'velocityDiag_Y'

SetActiveSource(calcVelyyFilt)

VelyyG = GaussianResampling(Input=calcVelyyFilt)
VelyyG.ResampleField = ['POINTS', 'Velyy']
VelyyG.ResamplingGrid = [62, 57, 86]
VelyyG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelyyG.GaussianSplatRadius = 0.0117
VelyyG.GaussianExponentFactor = -1.0
VelyyG.EllipticalSplats = 0

SetActiveSource(VelyyG)

calcVelyyFilt2 = Calculator(Input=VelyyG)
calcVelyyFilt2.ResultArrayName = 'Velyy_filt'
calcVelyyFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelyyFilt2)

print "velYY filtered"

calcVelzzFilt = Calculator(Input=calcSzz)
calcVelzzFilt.ResultArrayName = 'Velzz'
calcVelzzFilt.Function = 'velocityDiag_Z'

SetActiveSource(calcVelzzFilt)

VelzzG = GaussianResampling(Input=calcVelzzFilt)
VelzzG.ResampleField = ['POINTS', 'Velzz']
VelzzG.ResamplingGrid = [62, 57, 86]
VelzzG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
VelzzG.GaussianSplatRadius = 0.0117
VelzzG.GaussianExponentFactor = -1.0
VelzzG.EllipticalSplats = 0

SetActiveSource(VelzzG)

calcVelzzFilt2 = Calculator(Input=VelzzG)
calcVelzzFilt2.ResultArrayName = 'Velzz_filt'
calcVelzzFilt2.Function = 'SplatterValues'

SetActiveSource(calcVelzzFilt2)

print "velZZ filtered"

SxxFilt = GaussianResampling(Input=calcSzz)
SxxFilt.ResampleField = ['POINTS', 'Sinst_XX']
SxxFilt.ResamplingGrid = [62, 57, 86]
SxxFilt.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
SxxFilt.GaussianSplatRadius = 0.0117
SxxFilt.GaussianExponentFactor = -1.0
SxxFilt.EllipticalSplats = 0

SetActiveSource(SxxFilt)

SxxG = Calculator(Input=SxxFilt)
SxxG.ResultArrayName = 'Sxx_filt'
SxxG.Function = 'SplatterValues'

SetActiveSource(SxxG)

print "Sxx filtered"

SxyFilt = GaussianResampling(Input=calcSzz)
SxyFilt.ResampleField = ['POINTS', 'Sinst_XY']
SxyFilt.ResamplingGrid = [62, 57, 86]
SxyFilt.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
SxyFilt.GaussianSplatRadius = 0.0117
SxyFilt.GaussianExponentFactor = -1.0
SxyFilt.EllipticalSplats = 0

SetActiveSource(SxyFilt)

SxyG = Calculator(Input=SxyFilt)
SxyG.ResultArrayName = 'Sxy_filt'
SxyG.Function = 'SplatterValues'

SetActiveSource(SxyG)

print "Sxy filtered"

SxzFilt = GaussianResampling(Input=calcSzz)
SxzFilt.ResampleField = ['POINTS', 'Sinst_XZ']
SxzFilt.ResamplingGrid = [62, 57, 86]
SxzFilt.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
SxzFilt.GaussianSplatRadius = 0.0117
SxzFilt.GaussianExponentFactor = -1.0
SxzFilt.EllipticalSplats = 0

SetActiveSource(SxzFilt)

SxzG = Calculator(Input=SxzFilt)
SxzG.ResultArrayName = 'Sxz_filt'
SxzG.Function = 'SplatterValues'

SetActiveSource(SxzG)

print "Sxz filtered"

SyyFilt = GaussianResampling(Input=calcSzz)
SyyFilt.ResampleField = ['POINTS', 'Sinst_YY']
SyyFilt.ResamplingGrid = [62, 57, 86]
SyyFilt.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
SyyFilt.GaussianSplatRadius = 0.0117
SyyFilt.GaussianExponentFactor = -1.0
SyyFilt.EllipticalSplats = 0

SetActiveSource(SyyFilt)

SyyG = Calculator(Input=SyyFilt)
SyyG.ResultArrayName = 'Syy_filt'
SyyG.Function = 'SplatterValues'

SetActiveSource(SyyG)

print "Syy filtered"

SyzFilt = GaussianResampling(Input=calcSzz)
SyzFilt.ResampleField = ['POINTS', 'Sinst_YZ']
SyzFilt.ResamplingGrid = [62, 57, 86]
SyzFilt.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
SyzFilt.GaussianSplatRadius = 0.0117
SyzFilt.GaussianExponentFactor = -1.0
SyzFilt.EllipticalSplats = 0

SetActiveSource(SyzFilt)

SyzG = Calculator(Input=SyzFilt)
SyzG.ResultArrayName = 'Syz_filt'
SyzG.Function = 'SplatterValues'

SetActiveSource(SyzG)

print "Syz filtered"

SzzFilt = GaussianResampling(Input=calcSzz)
SzzFilt.ResampleField = ['POINTS', 'Sinst_ZZ']
SzzFilt.ResamplingGrid = [62, 57, 86]
SzzFilt.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
SzzFilt.GaussianSplatRadius = 0.0117
SzzFilt.GaussianExponentFactor = -1.0
SzzFilt.EllipticalSplats = 0

SetActiveSource(SzzFilt)

SzzG = Calculator(Input=SzzFilt)
SzzG.ResultArrayName = 'Szz_filt'
SzzG.Function = 'SplatterValues'

SetActiveSource(SzzG)

print "Szz filtered"

presG = GaussianResampling(Input=calcSzz)
presG.ResampleField = ['POINTS', 'pressure']
presG.ResamplingGrid = [62, 57, 86]
presG.ExtenttoResample = [-3.8, 1.1, -3.0, 1.5, 0.8, 7.6]
presG.GaussianSplatRadius = 0.0117
presG.GaussianExponentFactor = -1.0
presG.EllipticalSplats = 0

SetActiveSource(presG)

calcPres = Calculator(Input=presG)
calcPres.ResultArrayName = 'pressure_filt'
calcPres.Function = 'SplatterValues'

SetActiveSource(calcPres)

print "pressure filtered"

appendQ = AppendAttributes(Input=[SxxG,SxyG,SxzG,SyyG,SyzG,SzzG,calcVelxFilt2,calcVelyFilt2,calcVelzFilt2,calcVelxyFilt2,calcVelxzFilt2,calcVelyzFilt2,calcVelxxFilt2,calcVelyyFilt2,calcVelzzFilt2,calcPres])

SetActiveSource(appendQ)

print "Attributes appended"

calcSqSxx = Calculator(Input=appendQ)
calcSqSxx.ResultArrayName = 'SqSxx_filt'
calcSqSxx.Function = 'Sxx_filt^2'

SetActiveSource(calcSqSxx)

calcSqSyy = Calculator(Input=calcSqSxx)
calcSqSyy.ResultArrayName = 'SqSyy_filt'
calcSqSyy.Function = 'Syy_filt^2'

SetActiveSource(calcSqSyy)

calcSqSzz = Calculator(Input=calcSqSyy)
calcSqSzz.ResultArrayName = 'SqSzz_filt'
calcSqSzz.Function = 'Szz_filt^2'

SetActiveSource(calcSqSzz)

calcSqSxy = Calculator(Input=calcSqSzz)
calcSqSxy.ResultArrayName = 'SqSxy_filt'
calcSqSxy.Function = 'Sxy_filt^2'

SetActiveSource(calcSqSxy)

calcSqSxz = Calculator(Input=calcSqSxy)
calcSqSxz.ResultArrayName = 'SqSxz_filt'
calcSqSxz.Function = 'Sxz_filt^2'

SetActiveSource(calcSqSxz)

calcSqSyz = Calculator(Input=calcSqSxz)
calcSqSyz.ResultArrayName = 'SqSyz_filt'
calcSqSyz.Function = 'Syz_filt^2'

SetActiveSource(calcSqSyz)

print "SqS done"

temporalStat = TemporalStatistics(Input=calcSqSyz)
temporalStat.ComputeMinimum = 0
temporalStat.ComputeMaximum = 0
temporalStat.ComputeStandardDeviation = 0

SetActiveSource(temporalStat)

print "Temporal stastistics done"

#slice1 = Slice(Input=temporalStat)
#slice1.SliceType = 'Plane'
#slice1.SliceOffsetValues = [0.0]
#slice1.SliceType.Origin = [-0.9578917746932955, -0.778772098232473, 3.750692805789275]
#slice1.SliceType.Normal = [0.8385608217394656, -0.5314718814268357, 0.11980562380895057]

#SetActiveSource(slice1)

#print "Slice done"

#mergeBlock1 = MergeBlocks(Input=calcTauyz)

#SetActiveSource(mergeBlock1)

#print "Merger of blocks done"

# save data
SaveData('/cluster/scratch/pcorso/nek_Re2100_newInflow/allInstF/timeAvFiltDNS_Dx008_tot.e', proxy=temporalStat )
#writer = CreateWriter("/cluster/scratch/pcorso/nek_Re2100/mean_only_highRes/stenosis/Re_2100/mean_only/allInst/timeAvFiltDNS.vtk",mergeBlock1)
#writer.UpdatePipeline()

print "Data saved"

# # hide data in view
# Hide(calcepsSGS, renderView1)

# # create a new 'Calculator'
# calcRxx = Calculator(Input=temporalStat)
# calcRxx.ResultArrayName = 'Rxx'
# calcRxx.Function = 'velocity_stddev_X^2'

# # set active source
# SetActiveSource(calcRxx)

# # hide data in view
# Hide(temporalStat, renderView1)

# # create a new 'Calculator'
# calcRyy = Calculator(Input=calcRxx)
# calcRyy.ResultArrayName = 'Ryy'
# calcRyy.Function = 'velocity_stddev_Y^2'

# # set active source
# SetAct:iveSource(calcRyy)

# # hide data in view
# Hide(calcRxx, renderView1)

# # create a new 'Calculator'
# calcRzz = Calculator(Input=calcRyy)
# calcRzz.ResultArrayName = 'Rzz'
# calcRzz.Function = 'velocity_stddev_Z^2'

# # set active source
# SetActiveSource(calcRzz)

# # hide data in view
# Hide(calcRyy, renderView1)

# # create a new 'Calculator'
# calcRxy = Calculator(Input=calcRzz)
# calcRxy.ResultArrayName = 'Rxy'
# calcRxy.Function = 'velOff_average_X-velocity_average_X*velocity_average_Y'

# # set active source
# SetActiveSource(calcRxy)

# # hide data in view
# Hide(calcRzz, renderView1)

# # create a new 'Calculator'
# calcRxz = Calculator(Input=calcRxy)
# calcRxz.ResultArrayName = 'Rxz'
# calcRxz.Function = 'velOff_average_Y-velocity_average_X*velocity_average_Z'

# # set active source
# SetActiveSource(calcRxz)

# # hide data in view
# Hide(calcRxy, renderView1)

# # create a new 'Calculator'
# calcRyz = Calculator(Input=calcRxz)
# calcRyz.ResultArrayName = 'Ryz'
# calcRyz.Function = 'velOff_average_Z-velocity_average_Y*velocity_average_Z'

# # set active source
# SetActiveSource(calcRyz)

# # hide data in view
# Hide(calcRxz, renderView1)

# # create a new 'Calculator'
# calcLNH = Calculator(Input=calcRyz)
# calcLNH.ResultArrayName = 'LNH'
# calcLNH.Function = '(velocity_average_X*Vorticity_average_X+velocity_average_Y*Vorticity_average_Y+velocity_average_Z*Vorticity_average_Z)/(mag(Vorticity_average)*mag(velocity_average))'

# # set active source
# SetActiveSource(calcLNH)

# # hide data in view
# Hide(calcRyz, renderView1)

# # create a new 'Calculator'
# calcTKE = Calculator(Input=calcLNH)
# calcTKE.ResultArrayName = 'TKE'
# calcTKE.Function = '1/2*(Rxx+Ryy+Rzz)'

# # set active source
# SetActiveSource(calcTKE)

# # hide data in view
# Hide(calcLNH, renderView1)

# # create a new 'Calculator'
# calcMKE = Calculator(Input=calcTKE)
# calcMKE.ResultArrayName = 'MKE'
# calcMKE.Function = '1/2*(velocity_average_X^2+velocity_average_Y^2+velocity_average_Z^2)'

# # set active source
# SetActiveSource(calcMKE)

# # hide data in view
# Hide(calcTKE, renderView1)

# # create a new 'Calculator'
# calcEnRatio = Calculator(Input=calcMKE)
# calcEnRatio.ResultArrayName = 'TKE/MKE'
# calcEnRatio.Function = 'TKE/MKE'

# # set active source
# SetActiveSource(calcEnRatio)

# # hide data in view
# Hide(calcMKE, renderView1)

# # create a new 'Calculator'
# calcMagVel = Calculator(Input=calcEnRatio)
# calcMagVel.ResultArrayName = 'MagMeanVel'
# calcMagVel.Function = 'mag(velocity_average)'

# # set active source
# SetActiveSource(calcMagVel)

# # hide data in view
# Hide(calcEnRatio, renderView1)

# # create a new 'Gradient Of Unstructured DataSet'
# gradMean = GradientOfUnstructuredDataSet(Input=calcMagVel)
# gradMean.ResultArrayName = 'GradientsMean'
# gradMean.FasterApproximation = 1
# gradMean.ComputeDivergence = 1
# gradMean.ComputeVorticity = 1
# gradMean.ComputeQCriterion = 1
# gradMean.ScalarArray = ['POINTS', 'velocity_average']

# # set active source
# SetActiveSource(gradMean)

# # hide data in view
# Hide(calcMagVel, renderView1)

# # create a new 'Calculator'
# calcmeanSxy = Calculator(Input=gradMean)
# calcmeanSxy.ResultArrayName = 'meanStress_XY'
# calcmeanSxy.Function = '1/2*(GradientsMean_1+GradientsMean_3)'

# # set active source
# SetActiveSource(calcmeanSxy)

# # hide data in view
# Hide(gradMean, renderView1)

# # create a new 'Calculator'
# calcmeanSxz = Calculator(Input=calcmeanSxy)
# calcmeanSxz.ResultArrayName = 'meanStress_XZ'
# calcmeanSxz.Function = '1/2*(GradientsMean_2+GradientsMean_6)'

# # set active source
# SetActiveSource(calcmeanSxz)

# # hide data in view
# Hide(calcmeanSxy, renderView1)

# # create a new 'Calculator'
# calcmeanSyz = Calculator(Input=calcmeanSxz)
# calcmeanSyz.ResultArrayName = 'meanStress_YZ'
# calcmeanSyz.Function = '1/2*(GradientsMean_5+GradientsMean_7)'

# # set active source
# SetActiveSource(calcmeanSyz)

# # hide data in view
# Hide(calcmeanSxz, renderView1)

# # create a new 'Calculator'
# calcNormMeanS = Calculator(Input=calcmeanSyz)
# calcNormMeanS.ResultArrayName = 'normMeanStress'
# calcNormMeanS.Function = 'sqrt(GradientsMean_0^2+2*meanStress_XY^2+2*meanStress_XZ^2+2*meanStress_YZ^2+GradientsMean_4^2+GradientsMean_8^2)'

# # set active source
# SetActiveSource(calcNormMeanS)

# # hide data in view
# Hide(calcmeanSyz, renderView1)

# # create a new 'Calculator'
# calcmeanSPa = Calculator(Input=calcNormMeanS)
# calcmeanSPa.ResultArrayName = 'meanStressPa'
# calcmeanSPa.Function = '1200*4.85e-6*normMeanStress'

# # set active source
# SetActiveSource(calcmeanSPa)

# # hide data in view
# Hide(calcNormMeanS, renderView1)

# # create a new 'Calculator'
# calcinstS = Calculator(Input=calcmeanSPa)
# calcinstS.ResultArrayName = 'instStress'
# calcinstS.Function = 'sqrt((1200*4.85e-6)^2*SqNormSinst_average)'

# # set active source
# SetActiveSource(calcinstS)

# # hide data in view
# Hide(calcmeanSPa, renderView1)

# # create a new 'Calculator'
# calcSgsS = Calculator(Input=calcinstS)
# calcSgsS.ResultArrayName = 'SgsStress'
# calcSgsS.Function = 'sqrt(1200^2*4.85e-6*epsilonSGSInst_average)'

# # set active source
# SetActiveSource(calcSgsS)

# # hide data in view
# Hide(calcinstS, renderView1)

# # create a new 'Calculator'
# calcTotS = Calculator(Input=calcSgsS)
# calcTotS.ResultArrayName = 'totStress'
# calcTotS.Function = 'meanStressPa+instStress+SgsStress'

# # set active source
# SetActiveSource(calcTotS)

# # hide data in view
# Hide(calcSgsS, renderView1)