assert (1 + randomVec).DataSet is randomVec.DataSet # Test slicing and indexing compare(randomVec[randomVec[:,0] > 0.2].Arrays[0] - npa[npa[:,0] > 0.2], 1E-7) compare(randomVec[algs.where(randomVec[:,0] > 0.2)].Arrays[0] - npa[numpy.where(npa[:,0] > 0.2)], 1E-7) compare(randomVec[dsa.VTKCompositeDataArray([(slice(None, None, None), slice(0,2,None)), 2])].Arrays[0] - npa[:, 0:2], 1E-6) # Test ufunc compare(algs.cos(randomVec) - numpy.cos(npa), 1E-7) assert algs.cos(randomVec).DataSet is randomVec.DataSet assert algs.in1d(elev, [0,1]) == [item in [0, 1] for item in elev] # Various numerical ops implemented in VTK g = algs.gradient(elev) assert algs.all(g[0] == (1, 0, 0)) v = algs.make_vector(elev, g[:,0], elev) assert algs.all(algs.gradient(v) == [[1, 0, 1], [0, 0, 0], [0, 0, 0]]) v = algs.make_vector(elev, g[:,0], elev2) assert algs.all(algs.curl(v) == [1, 0, 0]) v = algs.make_vector(elev, elev2, 2*elev3) g = algs.gradient(v) assert g.DataSet is v.DataSet assert algs.all(algs.det(g) == 2) assert algs.all(algs.eigenvalue(g) == [2, 1, 1])
Wdash = Wdash.dot(Q.T) REF = abs(Sdash[0,1]*Wdash[0,1]) REF+= abs(Sdash[1,2]*Wdash[1,2]) REF+= abs(Sdash[2,0]*Wdash[2,0]) return -1*REF/1e6 # Negative so that we can use fmin u = get_array('u') v = get_array('v') w = get_array('w') nx = u.size neq = 3 print "Starting with nx", nx du = zeros((neq,neq,nx)) # du[i,j] = du_i / dx_j du[0] = algs.gradient(u).T # Paraview's damn convention [nx,neq] du[1] = algs.gradient(v).T du[2] = algs.gradient(w).T W = zeros((neq,neq,nx)) S = zeros((neq,neq,nx)) L2= zeros(nx) for i in range(neq): for j in range(neq): S[i,j] = 0.5*(du[i,j] + du[j,i]) W[i,j] = 0.5*(du[i,j] - du[j,i]) print "du: " print du[:,:,0]
PRINT("grad var 0:", (algs.var(grad, 0) - numpy.var(grad2, 0)) / numpy.var(grad2, 0)) w = vtk.vtkRTAnalyticSource() # Update with ghost level because gradient needs it # to be piece independent w.UpdatePiece(rank, size, 1) print(w.GetOutput()) print(w.GetOutputInformation(0)) # The parallel arrays that we care about ds = dsa.WrapDataObject(w.GetOutput()) rtData = ds.PointData['RTData'] grad = algs.gradient(rtData) ds.PointData.append(grad, 'gradient') # Crop the any ghost points out org_ext = w.GetOutput().GetExtent() ext = list(org_ext) wext = w.GetOutputInformation(0).Get( vtk.vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT()) for i in range(3): if ext[2 * i] != wext[2 * i]: ext[2 * i] = ext[2 * i] + 2 if ext[2 * i + 1] != wext[2 * i + 1]: ext[2 * i + 1] = ext[2 * i + 1] - 1 if ext != list(org_ext): w.GetOutput().Crop(ext)
PRINT( "grad max 1:", algs.sum(algs.max(grad, 1)) - numpy.sum(numpy.max(grad2, 1)) ) PRINT( "grad sum 1:", algs.sum(algs.sum(grad, 1)) - numpy.sum(numpy.sum(grad2, 1)) ) PRINT( "grad var:", (algs.var(grad) - numpy.var(grad2)) / numpy.var(grad2) ) PRINT( "grad var 0:", (algs.var(grad, 0) - numpy.var(grad2, 0)) / numpy.var(grad2, 0) ) w = vtk.vtkRTAnalyticSource() w.UpdateInformation() # Update with ghost level because gradient needs it # to be piece independent w.SetUpdateExtent(rank, size, 1) w.Update() # The parallel arrays that we care about ds = dsa.WrapDataObject(w.GetOutput()) rtData = ds.PointData['RTData'] grad = algs.gradient(rtData) ds.PointData.append(grad, 'gradient') # Crop the any ghost points out org_ext = w.GetOutput().GetExtent() ext = list(org_ext) wext = w.GetOutputInformation(0).Get(vtk.vtkStreamingDemandDrivenPipeline.WHOLE_EXTENT()) for i in range(3): if ext[2*i] != wext[2*i]: ext[2*i] = ext[2*i] + 2 if ext[2*i+1] != wext[2*i+1]: ext[2*i+1] = ext[2*i+1] - 1 if ext != list(org_ext): w.GetOutput().Crop(ext) # Croppped arrays
import vtk from vtk.numpy_interface import dataset_adapter as dsa from vtk.numpy_interface import algorithms as algs # Create a dataset w = vtk.vtkRTAnalyticSource() t = vtk.vtkDataSetTriangleFilter() t.SetInputConnection(w.GetOutputPort()) t.Update() # Compute gradient of RTData array ugrid = dsa.WrapDataObject(t.GetOutput()) print algs.gradient(ugrid.PointData['RTData'])
def make_features_inv(rans_vtk, Ls=1, Us=1, ros=1, nondim='local'): from cfd2ml.utilities import eijk small = np.finfo(float).tiny rans_nnode = rans_vtk.number_of_points # Wrap vista object in dsa wrapper rans_dsa = dsa.WrapDataObject(rans_vtk) print('Feature:') # nfeat = 21 nfeat = 50 q = np.empty([rans_nnode, nfeat]) feature_labels = np.empty(nfeat, dtype='object') # strain and vorticity ############################## print('Constructing strain and vorticity tensor') # Velocity vector U = rans_dsa.PointData[ 'U'] # NOTE - Getting variables from dsa obj not vtk obj as want to use algs etc later # Velocity gradient tensor and its transpose # J[:,i-1,j-1] is dUidxj # Jt[:,i-1,j-1] is dUjdxi Jt = algs.gradient(U) # Jt is this one as algs uses j,i ordering J = algs.apply_dfunc(np.transpose, Jt, (0, 2, 1)) # Strain and vorticity tensors Sij = 0.5 * (J + Jt) Oij = 0.5 * (J - Jt) # Frob. norm of Sij and Oij (Snorm and Onorm are actually S^2 and O^2, sqrt needed to get norms) Snorm = algs.sum(2.0 * Sij**2, axis=1) # sum i axis Snorm = algs.sum(Snorm, axis=1) # sum previous summations i.e. along j axis Onorm = algs.sum(2.0 * Oij**2, axis=1) # sum i axis Onorm = algs.sum(Onorm, axis=1) # sum previous summations i.e. along j axis Snorm = algs.sqrt(Snorm) Onorm = algs.sqrt(Onorm) ######################################## # Calculating pressure and tke gradients ######################################## print('Calculating pressure and tke gradients') tke = rans_dsa.PointData['k'] dkdx = algs.gradient(tke) dpdx = algs.gradient(rans_dsa.PointData['p']) ################################################# # Non-dim everything here. Either local or global ################################################# if nondim == 'local': # Non-dim Sij by eps/k w = rans_dsa.PointData['w'] #/0.09 eps = w * tke Sij_h = Sij / w # Non-dim Oij by Onorm Oij_h = Oij / Onorm # Non-dim pressure gradient ro = rans_dsa.PointData['ro'] DUDt = U[:, 0] * J[:, :, 0] + U[:, 1] * J[:, :, 1] + U[:, 2] * J[:, :, 2] dpdx_h = dpdx / ro * algs.mag(DUDt) # Non-dim tke gradient dkdx_h = dkdx / (eps / algs.sqrt(tke)) # Global non-dim on top Ps = ros * Us**2 Sij_h = Sij_h / (Us / Ls) Oij_h = Oij_h / (Us / Ls) dpdx_h = dpdx_h / (Ps / Ls) dkdx_h = dkdx_h / (Us**2 / Ls) # q[:,0] = Sij_h[:,0,0] # q[:,1] = Sij_h[:,1,1] # q[:,2] = Sij_h[:,2,2] # q[:,3] = Sij_h[:,0,1] # q[:,4] = Sij_h[:,0,2] # q[:,5] = Sij_h[:,1,2] # q[:,6] = Oij_h[:,0,0] # q[:,7] = Oij_h[:,1,1] # q[:,8] = Oij_h[:,2,2] # q[:,9] = Oij_h[:,0,1] # q[:,10] = Oij_h[:,0,2] # q[:,11] = Oij_h[:,1,2] # q[:,12] = dpdx_h[:,0] # q[:,13] = dpdx_h[:,1] # q[:,14] = dpdx_h[:,2] # q[:,15] = dkdx_h[:,0] # q[:,16] = dkdx_h[:,1] # q[:,17] = dkdx_h[:,2] # feature_labels[0] = 'S11' # feature_labels[1] = 'S22' # feature_labels[2] = 'S33' # feature_labels[3] = 'S12' # feature_labels[4] = 'S13' # feature_labels[5] = 'S23' # feature_labels[6] = 'O11' # feature_labels[7] = 'O22' # feature_labels[8] = 'O33' # feature_labels[9] = 'O12' # feature_labels[10] = 'O13' # feature_labels[11] = 'O23' # feature_labels[12] = 'dpdx' # feature_labels[13] = 'dpdy' # feature_labels[14] = 'dpdz' # feature_labels[15] = 'dkdx' # feature_labels[16] = 'dkdy' # feature_labels[17] = 'dkdz' # feat = 18 # Transform dpdx into ani-symmetric tensor Ap=-I x dpdx Ap = np.zeros([rans_nnode, 3, 3]) I = np.eye(3) for a in range(3): for b in range(3): for c in range(3): for d in range(3): Ap[:, a, b] -= eijk(b, c, d) * I[a, c] * dpdx_h[:, d] # Transform dkdx into ani-symmetric tensor Ak=-I x dkdx Ak = np.zeros([rans_nnode, 3, 3]) for a in range(3): for b in range(3): for c in range(3): for d in range(3): Ak[:, a, b] -= eijk(b, c, d) * I[a, c] * dkdx_h[:, d] # Construct all invariant bases ############################### # Use numpy matmul to construct S^2, S^3 etc as we use these alot # (matmul can be used as for arrays of dim>2 as "it is treated as a stack of matrices residing in the last two indexes and is broadcast accordingly") S = Sij_h O = Oij_h S2 = np.matmul(S, S) S3 = np.matmul(S2, S) O2 = np.matmul(O, O) Ap2 = np.matmul(Ap, Ap) Ak2 = np.matmul(Ak, Ak) # 1-2 q[:, 0] = algs.trace(S2) feature_labels[0] = 'S2' q[:, 1] = algs.trace(S3) feature_labels[1] = 'S3' # 3-5 q[:, 2] = algs.trace(O2) feature_labels[2] = 'O2' q[:, 3] = algs.trace(Ap2) feature_labels[3] = 'Ap2' q[:, 4] = algs.trace(Ak2) feature_labels[4] = 'Ak2' # 6-14 q[:, 5] = algs.trace(np.matmul(O2, S)) feature_labels[5] = 'O2*S' q[:, 6] = algs.trace(np.matmul(O2, S2)) feature_labels[6] = 'O2*S2' q[:, 7] = algs.trace(np.matmul(np.matmul(O2, S), np.matmul(O, S2))) feature_labels[7] = 'O2*S*O*S2' q[:, 8] = algs.trace(np.matmul(Ap2, S)) feature_labels[8] = 'Ap2*S' q[:, 9] = algs.trace(np.matmul(Ap2, S2)) feature_labels[9] = 'Ap2*S2' q[:, 10] = algs.trace(np.matmul(np.matmul(Ap2, S), np.matmul(Ap, S2))) feature_labels[10] = 'Ap2*S*Ap*S2' q[:, 11] = algs.trace(np.matmul(Ak2, S)) feature_labels[11] = 'Ak2*S' q[:, 12] = algs.trace(np.matmul(Ak2, S2)) feature_labels[12] = 'Ak2*S2' q[:, 13] = algs.trace(np.matmul(np.matmul(Ak2, S), np.matmul(Ak, S2))) feature_labels[13] = 'Ak2*S*Ak*S2' # 15-17 q[:, 14] = algs.trace(np.matmul(O, Ap)) feature_labels[14] = 'O*Ap' q[:, 15] = algs.trace(np.matmul(Ap, Ak)) feature_labels[15] = 'Ap*Ak' q[:, 16] = algs.trace(np.matmul(O, Ak)) feature_labels[16] = 'O*Ak' # 18-41 q[:, 17] = algs.trace(np.matmul(O, np.matmul(Ap, S))) feature_labels[17] = 'O*Ap*S' q[:, 18] = algs.trace(np.matmul(O, np.matmul(Ap, S2))) feature_labels[18] = 'O*Ap*S2' q[:, 19] = algs.trace(np.matmul(O2, np.matmul(Ap, S))) feature_labels[19] = 'O2*Ap*S' q[:, 20] = algs.trace(np.matmul(Ap2, np.matmul(O, S))) feature_labels[20] = 'Ap2*O*S' q[:, 21] = algs.trace(np.matmul(O2, np.matmul(Ap, S2))) feature_labels[21] = 'O2*Ap*S2' q[:, 22] = algs.trace(np.matmul(Ap2, np.matmul(O, S2))) feature_labels[22] = 'Ap2*O*S2' q[:, 23] = algs.trace(np.matmul(np.matmul(O2, S), np.matmul(Ap, S2))) feature_labels[23] = 'O2*S*Ap*S2' q[:, 24] = algs.trace(np.matmul(np.matmul(Ap2, S), np.matmul(O, S2))) feature_labels[24] = 'Ap2*S*O*S2' q[:, 25] = algs.trace(np.matmul(O, np.matmul(Ak, S))) feature_labels[25] = 'O*Ak*S' q[:, 26] = algs.trace(np.matmul(O, np.matmul(Ak, S2))) feature_labels[26] = 'O*Ak*S2' q[:, 27] = algs.trace(np.matmul(O2, np.matmul(Ak, S))) feature_labels[27] = 'O2*Ak*S' q[:, 28] = algs.trace(np.matmul(Ak2, np.matmul(O, S))) feature_labels[28] = 'Ak2*O*S' q[:, 29] = algs.trace(np.matmul(O2, np.matmul(Ak, S2))) feature_labels[29] = 'O2*Ak*S2' q[:, 30] = algs.trace(np.matmul(Ak2, np.matmul(O, S2))) feature_labels[30] = 'Ak2*O*S2' q[:, 31] = algs.trace(np.matmul(np.matmul(O2, S), np.matmul(Ak, S2))) feature_labels[31] = 'O2*S*Ak*S2' q[:, 32] = algs.trace(np.matmul(np.matmul(Ak2, S), np.matmul(O, S2))) feature_labels[32] = 'Ak2*S*O*S2' q[:, 33] = algs.trace(np.matmul(Ap, np.matmul(Ak, S))) feature_labels[33] = 'Ap*Ak*S' q[:, 34] = algs.trace(np.matmul(Ap, np.matmul(Ak, S2))) feature_labels[34] = 'Ap*Ak*S2' q[:, 35] = algs.trace(np.matmul(Ap2, np.matmul(Ak, S))) feature_labels[35] = 'Ap2*Ak*S' q[:, 36] = algs.trace(np.matmul(Ak2, np.matmul(Ap, S))) feature_labels[36] = 'Ak2*Ap*S' q[:, 37] = algs.trace(np.matmul(Ap2, np.matmul(Ak, S2))) feature_labels[37] = 'Ap2*Ak*S2' q[:, 38] = algs.trace(np.matmul(Ak2, np.matmul(Ap, S2))) feature_labels[38] = 'Ak2*Ap*S2' q[:, 39] = algs.trace(np.matmul(np.matmul(Ap2, S), np.matmul(Ak, S2))) feature_labels[39] = 'Ap2*S*Ak*S2' q[:, 40] = algs.trace(np.matmul(np.matmul(Ak2, S), np.matmul(Ap, S2))) feature_labels[40] = 'Ak2*S*Ap*S2' # # 42 q[:, 41] = algs.trace(np.matmul(O, np.matmul(Ap, Ak))) feature_labels[41] = 'O*Ap*Ak' # # 43-47 q[:, 42] = algs.trace(np.matmul(np.matmul(O, Ap), np.matmul(Ak, S))) feature_labels[42] = 'O*Ap*Ak*S' q[:, 43] = algs.trace(np.matmul(np.matmul(O, Ak), np.matmul(Ap, S))) feature_labels[43] = 'O*Ak*Ap*S' q[:, 44] = algs.trace(np.matmul(np.matmul(O, Ap), np.matmul(Ak, S2))) feature_labels[44] = 'O*Ap*Ak*S2' q[:, 45] = algs.trace(np.matmul(np.matmul(O, Ak), np.matmul(Ap, S2))) feature_labels[45] = 'O*Ak*Ap*S2' q[:, 46] = algs.trace( np.matmul(np.matmul(np.matmul(O, Ap), np.matmul(S, Ak)), S2)) feature_labels[46] = 'O*Ap*S*Ak*S2' feat = 47 # Supplementary features ######################## print('Calculating supplementary features: ') # Wall distanced based Re print('Turbulence Reynolds number') nu = rans_dsa.PointData['mu_l'] / rans_dsa.PointData['ro'] Red = (algs.sqrt(tke) * rans_dsa.PointData['d']) / (50.0 * nu) q[:, feat] = algs.apply_dfunc(np.minimum, Red, 2.0) feature_labels[feat] = 'Turbulence Re' feat += 1 # Turbulence intensity print('Turbulence intensity') UiUi = algs.mag(U)**2.0 q[:, feat] = tke / (0.5 * UiUi + tke + small) feature_labels[feat] = 'Turbulence intensity' feat += 1 # Ratio of turb time scale to mean strain time scale print('Ratio of turb time scale to mean strain time scale') A = 1.0 / rans_dsa.PointData[ 'w'] #Turbulent time scale (eps = k*w therefore also A = k/eps) B = 1.0 / Snorm q[:, feat] = A / (A + B + small) feature_labels[feat] = 'turb/strain time-scale' feat += 1 return q, feature_labels
# Test operators assert algs.all(1 + randomVec - 1 - randomVec < 1E-4) assert (1 + randomVec).DataSet is randomVec.DataSet # Test slicing and indexing assert algs.all(randomVec[randomVec[:,0] > 0.2].Arrays[0] - npa[npa[:,0] > 0.2] < 1E-7) assert algs.all(randomVec[algs.where(randomVec[:,0] > 0.2)].Arrays[0] - npa[numpy.where(npa[:,0] > 0.2)] < 1E-7) assert algs.all(randomVec[dsa.VTKCompositeDataArray([(slice(None, None, None), slice(0,2,None)), 2])].Arrays[0] - npa[:, 0:2] < 1E-6) # Test ufunc assert algs.all(algs.cos(randomVec) - numpy.cos(npa) < 1E-7) assert algs.cos(randomVec).DataSet is randomVec.DataSet # Various numerical ops implemented in VTK g = algs.gradient(elev) assert algs.all(g[0] == (1, 0, 0)) v = algs.make_vector(elev, g[:,0], elev) assert algs.all(algs.gradient(v) == [[1, 0, 0], [0, 0, 0], [1, 0, 0]]) v = algs.make_vector(elev, g[:,0], elev2) assert algs.all(algs.curl(v) == [1, 0, 0]) v = algs.make_vector(elev, elev2, 2*elev3) g = algs.gradient(v) assert g.DataSet is v.DataSet assert algs.all(algs.det(g) == 2) assert algs.all(algs.eigenvalue(g) == [2, 1, 1])
def rans_les_uiuj_err(rans_vtk, les_vtk, thrsh, Ls=1, Us=1): small = np.cbrt(np.finfo(float).tiny) nnode = les_vtk.number_of_points delij = np.zeros([nnode, 3, 3]) for i in range(0, 3): delij[:, i, i] = 1.0 ############### # Get RANS uiuj ############### rans_dsa = dsa.WrapDataObject(rans_vtk) U = rans_dsa.PointData[ 'U'] # NOTE - Getting variables from dsa obj not vtk obj as want to use algs etc later # Velocity gradient tensor and its transpose # J[:,i-1,j-1] is dUidxj # Jt[:,i-1,j-1] is dUjdxi Jt = algs.gradient(U) # Jt is this one as algs uses j,i ordering J = algs.apply_dfunc(np.transpose, Jt, (0, 2, 1)) # Strain and vorticity tensors Sij = 0.5 * (J + Jt) nu_t = rans_dsa.PointData['mu_t'] / rans_dsa.PointData['ro'] tke = rans_dsa.PointData['k'] uiuj_rans = (2.0 / 3.0) * tke * delij - 2.0 * nu_t * Sij # Find Caniso from linear EVM aij = copy.deepcopy(Sij) * 0.0 for i in range(0, 3): for j in range(0, 3): aij[:, i, j] = uiuj_rans[:, i, j] / (2.0 * tke + small) - delij[:, i, j] / 3.0 # Get eigenvalues of aij eig = algs.eigenvalue(aij) eig1 = eig[:, 0] eig2 = eig[:, 1] eig3 = eig[:, 2] # Get coords on barycentric triangle from eigenvalues xc = [1.0, 0.0, 0.5] #x,y coords of corner of triangle yc = [0.0, 0.0, np.cos(np.pi / 6.0)] C1c = eig1 - eig2 C2c = 2 * (eig2 - eig3) C3c = 3 * eig3 + 1 Caniso = 1.0 - C3c rans_vtk.point_arrays['Caniso'] = Caniso ############### # Get LES uiuj ############### # Wrap vista object in dsa wrapper les_dsa = dsa.WrapDataObject(les_vtk) # Copy Reynolds stresses to tensor # uiuj_les = np.zeros([nnode,3,3]) uiuj_les = copy.deepcopy(uiuj_rans) * 0.0 uiuj_les[:, 0, 0] = les_dsa.PointData['uu'] uiuj_les[:, 1, 1] = les_dsa.PointData['vv'] uiuj_les[:, 2, 2] = les_dsa.PointData['ww'] uiuj_les[:, 0, 1] = les_dsa.PointData['uv'] uiuj_les[:, 0, 2] = les_dsa.PointData['uw'] uiuj_les[:, 1, 2] = les_dsa.PointData['vw'] uiuj_les[:, 1, 0] = uiuj_les[:, 0, 1] uiuj_les[:, 2, 0] = uiuj_les[:, 0, 2] uiuj_les[:, 2, 1] = uiuj_les[:, 1, 2] tke_les = 0.5 * (uiuj_les[:, 0, 0] + uiuj_les[:, 1, 1] + uiuj_les[:, 2, 2]) # Calc divergence of DNS and RANS uiuj div_RANS = np.zeros([nnode, 3]) div_LES = np.zeros([nnode, 3]) for i in range(3): for j in range(3): div_RANS[:, i] += algs.gradient(uiuj_rans[:, i, j])[:, i] div_LES[:, i] += algs.gradient(uiuj_les[:, i, j])[:, i] div_err = 1.0 * div_LES - rans_dsa.PointData['ro'] * div_RANS err = np.sqrt(div_err[:, 0]**2 + div_err[:, 1]**2 + div_err[:, 2]**2) # err = err/(tke_les+small) err = err * Ls / Us**2 # # Calc Frobenius norm distance between RANS and LES # err = np.zeros(nnode) # for i in range(3): # for j in range(3): # err[:] += ( (uiuj_rans[:,i,j]-uiuj_les[:,i,j]) )**2. # err = np.sqrt(err) # err = err/(tke_les+small) index = algs.where(err > thrsh) err_bool = np.zeros(nnode, dtype=int) err_bool[index] = 1 y_raw = les_vtk.point_arrays['raw'] y_targ = les_vtk.point_arrays['target'] les_vtk.point_arrays['raw'] = np.append(y_raw, err.reshape(-1, 1), axis=1) les_vtk.point_arrays['target'] = np.append(y_targ, err_bool.reshape(-1, 1), axis=1)
def make_targets(les_vtk, y_type, Ls=1, Us=1, ros=1): from tqdm import tqdm small = np.cbrt(np.finfo(float).tiny) Ps = 0.5 * ros * Us**2 les_nnode = les_vtk.number_of_points delij = np.zeros([les_nnode, 3, 3]) for i in range(0, 3): delij[:, i, i] = 1.0 # Wrap vista object in dsa wrapper les_dsa = dsa.WrapDataObject(les_vtk) if (y_type == 'classification'): ntarg = 5 y_targ = np.zeros([les_nnode, ntarg], dtype=int) print('Classifier targets:') elif (y_type == 'regression'): ntarg = 2 y_targ = np.zeros([les_nnode, ntarg], dtype=float) print('regressor targets:') y_raw = np.zeros([les_nnode, ntarg]) target_labels = np.empty(ntarg, dtype='object') targ = 0 # Copy Reynolds stresses to tensor uiuj = np.zeros([les_nnode, 3, 3]) uiuj[:, 0, 0] = les_dsa.PointData['uu'] uiuj[:, 1, 1] = les_dsa.PointData['vv'] uiuj[:, 2, 2] = les_dsa.PointData['ww'] uiuj[:, 0, 1] = les_dsa.PointData['uv'] uiuj[:, 0, 2] = les_dsa.PointData['uw'] uiuj[:, 1, 2] = les_dsa.PointData['vw'] uiuj[:, 1, 0] = uiuj[:, 0, 1] uiuj[:, 2, 0] = uiuj[:, 0, 2] uiuj[:, 2, 1] = uiuj[:, 1, 2] # resolved TKE tke = 0.5 * (uiuj[:, 0, 0] + uiuj[:, 1, 1] + uiuj[:, 2, 2]) # Velocity vector U = algs.make_vector(les_dsa.PointData['U'], les_dsa.PointData['V'], les_dsa.PointData['W']) # Velocity gradient tensor and its transpose # J[:,i-1,j-1] is dUidxj # Jt[:,i-1,j-1] is dUjdxi Jt = algs.gradient(U) # Jt is this one as algs uses j,i ordering J = algs.apply_dfunc(np.transpose, Jt, (0, 2, 1)) # Strain and vorticity tensors Sij = 0.5 * (J + Jt) Oij = 0.5 * (J - Jt) # Anisotropy tensor and eigenvalues aij = copy.deepcopy(Sij) * 0.0 inv2 = np.zeros(les_nnode) inv3 = np.zeros(les_nnode) for i in range(0, 3): for j in range(0, 3): aij[:, i, j] = uiuj[:, i, j] / (2.0 * tke + small) - delij[:, i, j] / 3.0 # Get eigenvalues of aij eig = algs.eigenvalue(aij) eig1 = eig[:, 0] eig2 = eig[:, 1] eig3 = eig[:, 2] # Get coords on barycentric triangle from eigenvalues xc = [1.0, 0.0, 0.5] #x,y coords of corner of triangle yc = [0.0, 0.0, np.cos(np.pi / 6.0)] C1c = eig1 - eig2 C2c = 2 * (eig2 - eig3) C3c = 3 * eig3 + 1 x0 = C1c * xc[0] + C2c * xc[1] + C3c * xc[2] y0 = C1c * yc[0] + C2c * yc[1] + C3c * yc[2] if (y_type == 'Classification'): # Target 1: Negative eddy viscosity ######################################### print('1: Negative eddy viscosity') A = np.zeros(les_nnode) B = np.zeros(les_nnode) for i in range(0, 3): for j in range(0, 3): A += -uiuj[:, i, j] * Sij[:, i, j] + ( 2.0 / 3.0) * tke * delij[:, i, j] * Sij[:, i, j] B += 2.0 * Sij[:, i, j] * Sij[:, i, j] Str = algs.sqrt(B) # magnitude of Sij strain tensor (used later) nu_t = A / (B + small) nu_t = nu_t / (Us * Ls) y_raw[:, targ] = nu_t index = algs.where(nu_t < 0.0) y_targ[index, targ] = 1 target_labels[targ] = 'Negative eddy viscosity' targ += 1 # Target 2: Deviation from plane shear ################################################# print('2: Deviation from plane shear turbulence') # Get distance from plane shear line p1 = (1 / 3, 0) p2 = (0.5, np.sqrt(3) / 2) dist = abs((p2[1] - p1[1]) * x0 - (p2[0] - p1[0]) * y0 + p2[0] * p1[1] - p2[1] * p1[0]) / np.sqrt((p2[1] - p1[1])**2 + (p2[0] - p1[0])**2) y_raw[:, targ] = dist index = algs.where(dist > 0.25) y_targ[index, targ] = 1 target_labels[targ] = 'Deviation from plane shar turbulence' targ += 1 # Target 3: Anisotropy of turbulence ########################################## print('3: Anisotropy of turbulence') Caniso = 1.0 - C3c y_raw[:, targ] = Caniso index = algs.where(Caniso > 0.5) y_targ[index, targ] = 1 target_labels[targ] = 'Stress anisotropy' targ += 1 # Target 4: Negative Pk ############################################ print('4: Negative Pk') A = np.zeros(les_nnode) for i in range(0, 3): for j in range(0, 3): A[:] += (-uiuj[:, i, j] * J[:, i, j]) A = A * Ls / Us**3 y_raw[:, targ] = A index = algs.where(A < -0.0005) y_targ[index, targ] = 1 target_labels[targ] = 'Negative Pk' targ += 1 # Target 5: 2-eqn Cmu constant ############################################ print('5: 2-equation Cmu constant') A = np.zeros(les_nnode) for i in range(0, 3): for j in range(0, 3): A[:] += aij[:, i, j] * Sij[:, i, j] Cmu = nu_t**2.0 * (Str / (tke + small))**2.0 y_raw[:, targ] = Cmu allow_err = 0.25 #i.e. 10% err Cmu_dist = algs.abs(Cmu - 0.09) # index = algs.where(Cmu_dist>allow_err*0.09) index = algs.where(Cmu > 1.1 * 0.09) y_targ[index, targ] = 1 target_labels[targ] = 'Cmu != 0.09' targ += 1 # ab = ((uiuj[:,1,1]-uiuj[:,0,0])*U[:,0]*U[:,1] + uiuj[:,0,1]*(U[:,0]**2-U[:,1]**2))/(U[:,0]**2+U[:,1]**2) # y_raw[:,err] = ab # # Target 3: Non-linearity # ############################### # print('3: Non-linearity') # # # Build cevm equation in form A*nut**3 + B*nut**2 + C*nut + D = 0 # B, A = build_cevm(Sij,Oij) # B = B/(tke +1e-12) # A = A/(tke**2.0 +1e-12) # # C = np.zeros_like(A) # D = np.zeros_like(A) # for i in range(0,3): # for j in range(0,3): # C += -2.0*Sij[:,i,j]*Sij[:,i,j] # D += (2.0/3.0)*tke*Sij[:,i,j]*delij[:,i,j] - uiuj[:,i,j]*Sij[:,i,j] # # nu_t_cevm = np.empty_like(nu_t) # for i in tqdm(range(0,les_nnode)): # # Find the roots of the cubic equation (i.e. potential values for nu_t_cevm) # roots = np.roots([A[i],B[i],C[i],D[i]]) # roots_orig = roots # # # Remove complex solutions (with imaginary part > a small number, to allow for numerical error) # #roots = roots.real[abs(roots.imag)<1e-5] #NOTE - Matches nu_t much better without this?! # # # Out of remaining solutions(s), pick one that is closest to linear nu_t # if(roots.size==0): # nu_t_cevm[i] = nu_t[i] # else: # nu_t_cevm[i] = roots.real[np.argmin( np.abs(roots - np.full(roots.size,nu_t[i])) )] # # normdiff = algs.abs(nu_t_cevm - nu_t) / (algs.abs(nu_t_cevm) + algs.abs(nu_t) + 1e-12) # y_raw[:,err] = nu_t_cevm # # index = algs.where(normdiff>0.15) # y_targ[index,err] = 1 # error_labels[err] = 'Non-linearity' # err += 1 elif (y_type == 'regression'): # Target 3: Anisotropy of turbulence ########################################## print('1: Anisotropy of turbulence') Caniso = 1.0 - C3c y_raw[:, targ] = Caniso y_targ[:, targ] = Caniso target_labels[targ] = 'Stress anisotropy' targ += 1 return y_raw, y_targ, target_labels
def make_features(rans_vtk, Ls=1, Us=1, ros=1, nondim='local'): from cfd2ml.utilities import build_cevm small = np.cbrt(np.finfo(float).tiny) Ps = 0.5 * ros * Us**2 rans_nnode = rans_vtk.number_of_points delij = np.zeros([rans_nnode, 3, 3]) for i in range(0, 3): delij[:, i, i] = 1.0 # Wrap vista object in dsa wrapper rans_dsa = dsa.WrapDataObject(rans_vtk) print('Feature:') nfeat = 15 feat = 0 q = np.empty([rans_nnode, nfeat]) feature_labels = np.empty(nfeat, dtype='object') # Feature 1: non-dim Q-criterion ################################ print('1: non-dim Q-criterion...') # Velocity vector U = rans_dsa.PointData[ 'U'] # NOTE - Getting variables from dsa obj not vtk obj as want to use algs etc later # Velocity gradient tensor and its transpose # J[:,i-1,j-1] is dUidxj # Jt[:,i-1,j-1] is dUjdxi Jt = algs.gradient(U) # Jt is this one as algs uses j,i ordering J = algs.apply_dfunc(np.transpose, Jt, (0, 2, 1)) # Strain and vorticity tensors Sij = 0.5 * (J + Jt) Oij = 0.5 * (J - Jt) # Frob. norm of Sij and Oij (Snorm and Onorm are actually S^2 and O^2, sqrt needed to get norms) Snorm = algs.sum(2.0 * Sij**2, axis=1) # sum i axis Snorm = algs.sum(Snorm, axis=1) # sum previous summations i.e. along j axis Onorm = algs.sum(2.0 * Oij**2, axis=1) # sum i axis Onorm = algs.sum(Onorm, axis=1) # sum previous summations i.e. along j axis # Store q1 q[:, feat] = (Onorm - 0.5 * Snorm) / (Onorm + 0.5 * Snorm + small) feature_labels[feat] = 'Normalised strain' feat += 1 # clean up Snorm = algs.sqrt(Snorm) #revert to revert to real Snorm for use later Onorm = algs.sqrt(Onorm) #revert to revert to real Onorm for use later # Feature 2: Turbulence intensity ################################# print('2: Turbulence intensity') tke = rans_dsa.PointData['k'] UiUi = algs.mag(U)**2.0 # q[:,feat] = tke/(0.5*UiUi+tke+small) q[:, feat] = tke / (0.5 * UiUi + small) feature_labels[feat] = 'Turbulence intensity' feat += 1 # Feature 3: Turbulence Reynolds number ####################################### print('3: Turbulence Reynolds number') nu = rans_dsa.PointData['mu_l'] / rans_dsa.PointData['ro'] Red = (algs.sqrt(tke) * rans_dsa.PointData['d']) / (50.0 * nu) q[:, feat] = algs.apply_dfunc(np.minimum, Red, 2.0) #Red = 0.09**0.25*algs.sqrt(tke)*rans_dsa.PointData['d']/nu #q[:,feat] = algs.apply_dfunc(np.minimum, Red, 100.0) feature_labels[feat] = 'Turbulence Re' feat += 1 # Feature 4: Pressure gradient along streamline ############################################### print('4: Stream-wise pressure gradient') A = np.zeros(rans_nnode) B = np.zeros(rans_nnode) dpdx = algs.gradient(rans_dsa.PointData['p']) ro = rans_dsa.PointData['ro'] Umag = algs.mag(U) for k in range(0, 3): A += U[:, k] * dpdx[:, k] if nondim == 'global': A = A / Umag q[:, feat] = A * Ls / Ps elif nondim == 'local': for i in range(0, 3): for j in range(0, 3): B += U[:, i] * U[:, i] * dpdx[:, j] * dpdx[:, j] q[:, feat] = A / (algs.sqrt(B) + algs.abs(A) + small) feature_labels[feat] = 'Stream-wise Pgrad' feat += 1 # Feature 5: Ratio of turb time scale to mean strain time scale ############################################################### print('5: Ratio of turb time scale to mean strain time scale') # A = 1.0/rans_dsa.PointData['w'] #Turbulent time scale (eps = k*w therefore also A = k/eps) # B = 1.0/Snorm # q[:,feat] = A/(A+B+small) q[:, feat] = Snorm / (rans_dsa.PointData['w'] + small) feature_labels[feat] = 'turb/strain time-scale' feat += 1 # Feature 6: Viscosity ratio ############################ print('6: Viscosity ratio') nu_t = rans_dsa.PointData['mu_t'] / ro # q[:,feat] = nu_t/(100.0*nu + nu_t) q[:, feat] = nu_t / (nu + small) feature_labels[feat] = 'Viscosity ratio' feat += 1 # Feature 7: Vortex stretching ############################## print('7: Vortex stretching') A = np.zeros(rans_nnode) B = np.zeros(rans_nnode) vortvec = algs.vorticity(U) for j in range(0, 3): for i in range(0, 3): for k in range(0, 3): A += vortvec[:, j] * J[:, i, j] * vortvec[:, k] * J[:, i, k] B = Snorm # q[:,feat] = algs.sqrt(A)/(algs.sqrt(A)+B+small) q[:, feat] = algs.sqrt(A) #/(algs.sqrt(A)+B+small) feature_labels[feat] = 'Vortex stretching' feat += 1 # Feature 8: Marker of Gorle et al. (deviation from parallel shear flow) ######################################################################## print('8: Marker of Gorle et al. (deviation from parallel shear flow)') if nondim == 'global': g = np.zeros([rans_nnode, 3]) m = np.zeros(rans_nnode) s = U / Umag for j in range(3): for i in range(3): g[:, j] += s[:, i] * J[:, i, j] m += g[:, j] * s[:, j] m = np.abs(m) q[:, feat] = m * Ls / Us elif nondim == 'local': A = np.zeros(rans_nnode) B = np.zeros(rans_nnode) for i in range(0, 3): for j in range(0, 3): A += U[:, i] * U[:, j] * J[:, i, j] for n in range(0, 3): for i in range(0, 3): for j in range(0, 3): for m in range(0, 3): B += U[:, n] * U[:, n] * U[:, i] * J[:, i, j] * U[:, m] * J[:, m, j] q[:, feat] = algs.abs(A) / (algs.sqrt(B) + algs.abs(A) + small) feature_labels[feat] = 'Deviation from parallel shear' feat += 1 # Feature 9: Ratio of convection to production of k #################################################### print('9: Ratio of convection to production of k') uiuj = (2.0 / 3.0) * tke * delij - 2.0 * nu_t * Sij dkdx = algs.gradient(tke) A = np.zeros(rans_nnode) B = np.zeros(rans_nnode) for i in range(0, 3): A += U[:, i] * dkdx[:, i] for j in range(0, 3): for l in range(0, 3): B += uiuj[:, j, l] * Sij[:, j, l] q[:, feat] = A / (algs.abs(B) + small) feature_labels[feat] = 'Convection/production of k' feat += 1 # Feature 10: Ratio of total Reynolds stresses to normal Reynolds stresses ########################################################################## print('10: Ratio of total Reynolds stresses to normal Reynolds stresses') # Frob. norm of uiuj A = algs.sum(uiuj**2, axis=1) # sum i axis A = algs.sum(A, axis=1) # sum previous summations i.e. along j axis A = algs.sqrt(A) B = tke q[:, feat] = A / (B + small) feature_labels[feat] = 'total/normal stresses' feat += 1 # Feature 11: Cubic eddy viscosity comparision ############################################## print('11: Cubic eddy viscosity comparision') # Add quadratic and cubic terms to linear evm cevm_2nd, cevm_3rd = build_cevm(Sij, Oij) uiujSij = np.zeros(rans_nnode) for i in range(0, 3): for j in range(0, 3): uiujSij += uiuj[:, i, j] * Sij[:, i, j] uiujcevmSij = uiujSij + (cevm_2nd / tke) * nu_t**2.0 + ( cevm_3rd / tke**2.0) * nu_t**3.0 q[:, feat] = (uiujcevmSij - uiujSij) / (0.5 * (np.abs(uiujcevmSij) + np.abs(uiujSij)) + small) feature_labels[feat] = 'CEV comparison' feat += 1 # Feature 12: Streamline normal pressure gradient ################################################# print('12: Stream-normal pressure gradient') A = algs.cross(U, dpdx) A = np.sqrt(A[:, 0]**2 + A[:, 1]**2 + A[:, 2]**2) if nondim == 'global': A = A / Umag q[:, feat] = A * Ls / Ps elif nondim == 'local': B = np.zeros(rans_nnode) for i in range(0, 3): for j in range(0, 3): B += U[:, i] * U[:, i] * dpdx[:, j] * dpdx[:, j] q[:, feat] = A / (A + algs.sqrt(B) + small) feature_labels[feat] = 'Stream-normal Pgrad' feat += 1 # Feature 13: Streamline curvature ################################## print('13: Streamline curvature') # A = np.zeros([rans_nnode,3]) # # # Gradient of Gamma # Gamma = U#/algs.mag(U) # dGammadx = algs.gradient(Gamma) # # for i in range(0,3): # for j in range(0,3): # A[:,i] += U[:,j]*dGammadx[:,j,i] # A = algs.mag(A/algs.mag(U)*algs.mag(U)) # # q[:,feat] = A # feature_labels[feat] = 'Streamline curvature' # feat += 1 D2 = 0.5 * (Snorm**2 + Onorm**2) # cr1 = 1.0 # cr2 = 12.0 # cr3 = 1.0 cr2 = 12 cr3 = 1 / np.pi rstar = Snorm / (Onorm + small) dSijdx1 = algs.gradient(Sij[:, :, 0]) dSijdx2 = algs.gradient(Sij[:, :, 1]) dSijdx3 = algs.gradient(Sij[:, :, 2]) DSijDt = np.zeros([rans_nnode, 3, 3]) for i in range(3): for j in range(3): DSijDt[:, i, j] = U[:, 0] * dSijdx1[:, j, i] + U[:, 1] * dSijdx2[:, j, i] + U[:, 2] * dSijdx3[:, j, i] rhat = np.zeros(rans_nnode) for i in range(3): for j in range(3): for k in range(3): rhat += (2 * Oij[:, i, k] * Sij[:, j, k] / D2**2) * DSijDt[:, i, j] # fr1 = -((2*rstar)/(1+rstar))*(cr3*algs.arctan(cr2*rhat)) # fr1 = ( (1+cr1)*((2*rstar)/(1+rstar))*(1-cr3*algs.arctan(cr2*rhat)) ) - cr1 rhathat = algs.arctan(0.25 * rhat) * 2 / np.pi q[:, feat] = rhathat #fr1 feature_labels[feat] = 'Streamline curvature' feat += 1 # Feature 14: Anisotropy of pressure hessian ############################################ print('14: Anisotropy of pressure hessian') # Calculate pressure hessian Hij = algs.gradient(dpdx) Hij = algs.apply_dfunc(np.transpose, Hij, (0, 2, 1)) aniso = np.zeros(rans_nnode) iso = np.zeros(rans_nnode) # Frob. norm of Hij for i in range(3): for j in range(3): aniso += (Hij[:, i, j] - Hij[:, i, j] * delij[:, i, j])**2 iso += Hij[:, i, i]**2 aniso = np.sqrt(aniso) iso = np.sqrt(iso) q[:, feat] = (aniso) / (iso + small) feature_labels[feat] = 'Anisotropy of pressure hessian' feat += 1 # Feature 15: White noise ######################### print('15: White noise') q[:, feat] = np.random.uniform(low=-1.0, high=1.0, size=rans_nnode) feature_labels[feat] = 'White noise' feat += 1 return q, feature_labels
def post_array(arr, name): print("Saving", name, "...") output.CellData.append(arr, name) return u = get_array('um') v = get_array('vm') w = get_array('wm') nx = u.size neq = 3 print "Starting with nx", nx du = zeros((nx, neq, neq)) # du[0,i,j] = du_i / dx_j du[:, 0, :] = algs.gradient(u) du[:, 1, :] = algs.gradient(v) du[:, 2, :] = algs.gradient(w) save('du.npy', du) del du t0 = time() call([ 'mpirun', '-np', '4', 'python3', '../scripts/vortscripts/mpidrivevort.py' ]) t1 = time() print "Time taken was: ", t1 - t0, " sec" #L2TDM = load('L2TDM.npy') #L2 = load('L2.npy')
def Gradient(self, name): ''' return the gradient of the specified field ''' ind = self.data_np.PointData.keys().index(name) return algs.gradient(self.data_np.PointData.GetArray(ind))