趣味で計算流砂水理

Computational Sediment Hydraulics for Fun

沖積河川の砂州形成の数値実験

今回の記事はブログレベルの話ではないですが、ずっと悩んでいるのでとりあえずまとめておこうかなというところです。


砂州の定義は以下の記事を参照下さい。

computational-sediment-hyd.hatenablog.jp


支配方程式

流水

  • 平面二次元水深平均流モデル

流砂、河床変動

  • 河床位方程式
  • 掃流砂のみ、単一粒径、平衡流砂量式MPM式
  • 限界掃流力に局所勾配の影響を考慮する。砂州の計算では最も重要な要素でこれがないと砂州が計算できない。 芦田, 江頭, 劉の方法を基本に若干の修正を加えた。
  • 斜面崩壊の影響を考慮する。後述するCASE3のみに影響する。 崩壊の向き、量の考え方は関根の方法を基本とするが、崩壊量は流砂量に付加するのではなく、瞬時に崩壊が生じるものとした。

計算条件

斐伊川下流部をモデルに設定した。初期水深を変えた3ケースの計算を行った。

  • 河床勾配:1/670

  • 河床材料:2mm

  • 川幅:90m

  • 延長:1800m

  • 格子サイズ: 5m

  • 境界条件

  • 初期条件

    • 河床:最大値を粒径とした乱数を与える
    • 初期水深
      • CASE1 : 1.0m
      • CASE2 : 0.6m
      • CASE3 : 0.3m
    • 無次元掃流力:
      • CASE1 : 0.452
      • CASE2 : 0.271
      • CASE3 : 0.136
  • 計算ケースごとの川幅水深比と無次元掃流力の関係を黒木, 岸 の線形安定化解析に基づく砂州形態の分類図にプロットした。

  • CASE1は単列砂州、CASE2、3は複列砂州の領域となる。

計算結果と考察

砂州形成開始時の水深、河床変動量の平面空間分布

  • 計算開始から300時間後の計算結果を下図に示す。
  • 砂州の列数は、CASE1:1列、CASE2:2列、CASE3:3列以上となっており、卓越する成分が明確に把握できる。
  • この状態が上記領域区分の示すところ?(与えた擾乱のうち、どの成分が卓越するか)
CASE1(拡大図はこちら

CASE2(拡大図はこちら

CASE3(拡大図はこちら

概ね平衡状態時の水深、河床変動量の平面空間分布

  • 計算開始から2000時間後の計算結果を下図に示す。
  • CASE1およびCASE2ともに、砂州の列数が1列となっている。一方、CASE3は周期性を持たない複雑な流路を示す。
  • CASE2は初期は列数が2列であったが時間の経過とともに個々の砂州が干渉し、1列の砂州が形成される。
  • CASE3では、初期は複数の流路が出現したが、浮州(ドライベッド)の出現をきっかけに流路の変化が複雑化し、最終的には複数の流路が粗発生する。
CASE1(拡大図はこちら

CASE2(拡大図はこちら

CASE3(拡大図はこちら

砂州形成過程:gif動画

CASE1(拡大図はこちら
  • 500時間後には平衡状態に達してそれ以降は周期的な変化を示す。

CASE2(拡大図はこちら
  • 1000時間後に状態に達する。CASE1と比べて砂州の移動速度が遅い。
  • 2列の砂州が維持できない。なぜ?

CASE3(拡大図はこちら
  • 5700時間後までの計算を実施しているが平衡状態に達していない。周期的な変動ではないため、平衡状態は存在しない可能性がある。
  • 流路変動は側岸浸食によって生じるため、その速度は非常に遅い。
  • もう少し分析が必要。さらに長期の計算を実施予定。

まとめと課題

  • 任意の条件下における砂州の平衡状態を数値計算によって検証した。
  • CASE1は形成条件のとおり、単列砂州が形成される。
  • CASE2は複列砂州条件では安定的な複列砂州は形成されず、長期的にはCASE1と同様に単列砂州となる。では、斐伊川のような多列砂州はなぜ維持されるのか?非定常の影響?他の乱れの影響?もう少し検討が必要。
  • CASE3は、浮州が出現、つまり砂州高>水深となり、複雑な地形を示す。個人的には、これが流路=河川が形成される機構ではないかと考えている。さらにテスト計算を実施予定。

GitHub

Jupyter Notebook Viewer


図の作成に使用したライブラリは以下です。

  • hvplot:計算結果の図化

computational-sediment-hyd.hatenablog.jp

また、はてブロへのhtmlグラフの埋め込みは以下を参照。

computational-sediment-hyd.hatenablog.jp


ご意見、質問等お願いします。

沖積河川の砂州について整理してみる

砂州についてしゃべることは多いのですがまとめたことが無かったので整理しておこうかと。 面白い数値計算結果が出たので、その準備だったりもしもます。


はじめに

  • 沖積河川の砂州(以降、砂州)とは、 川の流れに伴う土砂移動によって形成される川幅スケールの河床地形を示す。
  • 川幅(堤防間の幅)やその曲率等の平面的な河川地形の影響により砂州の形状が異なる。
  • 日本の土砂水理関連の書籍には砂州に関する項目は必ず記述されるが、海外の書籍には記述が少ない。理由は不明。

砂州の分類

砂州の分類

日本では土木学会水理委員会移動床流れの抵抗と河床形状研究小委員会 で定義された次の分類を用いることが多い。

土砂水理学1 POD版p.102より引用

また、河村は次のように整理している。

土砂水理学1 POD版p.101より引用

砂州の特徴

実河川を例にそれぞれの砂州形状の特徴を簡単に示す。

交互砂州(単列砂州)

左右交互に周期的に形成される砂州を示す。下流方向に伝播する。

多列砂州

上述の交互砂州が河道内に2つ以上形成される砂州形状を示す。

網状流路

洪水時に大きく変動しない(砂州上の流れの掃流力が小さい)砂州が部分的に出現することにより、周期性を持たない網状流路が形成される。

画像を右クリックで再生を選択

固定砂州

湾曲部にみられる砂州で経年的に形状が変化しない。砂州を形成する土砂は動いているが砂州形状は変化しない。

  • 例:太田川(左:2008年、右:1961-69年)

砂州の形成機構

  • 平面的な流れ場の影響によって砂州が形成される。
  • 流砂は局所的な地形勾配の影響を強く受ける。
  • 固定砂州を考える場合は、鉛直方向の二次流の流砂への影響を考慮する必要がある。

  • 黒木, 岸 の線形安定化解析より砂州形状は川幅と水深の比によって決定することがわかる。

21世紀の河川学p.119より引用

おわりに

  • サステイナブルな川とのつき合い方を考える上で砂州の概念は非常に重要です。
  • 砂州は流水断面を阻害するため、水位を下げる観点からは無い方が良いが、掘削してもわずか数年で元に戻ってしまいます。膨大な費用をかけて掘削したのに次の年には元に戻った事例もあります。
  • また、砂州の環境的な価値(生態系、景観、親水等)も重要視されております。
  • 近年の観測技術の向上により、水面下にも砂州が形成されていることが確認されており(例えば、秋田:水中の河床地形の面的計測とその活用方策について等)、今後より知見が増えていくと思われる。

GitHub

Jupyter Notebook Viewer

numba.jitの挑戦:SIMPLE法による3Dキャビテーション流れの計算はどこまで速くなるか!10分⇒?

モチベーション

関連記事

computational-sediment-hyd.hatenablog.jp

computational-sediment-hyd.hatenablog.jp

結果

  • 先に結果を示すと10分が6秒になりました。約100倍です。悪くないです。

f:id:SedimentHydraulics:20200619111552p:plain

プログラミング

ほとんど修正していません。 numbaモジュールをimportすることと

import numpy as np
import numba

各defの前に以下ように一行付け加えるだけです。

@numba.jit(nopython=True, parallel=False)
def calupre(p,u,v,w,Vdir,Vbound,alphaU,dx,dy,dz,nu,axis):
@numba.jit(nopython=True, parallel=False)
def caldp(p,u,v,w,acu,acv,acw,dx,dy,dz):
@numba.jit(nopython=True, parallel=False)
def SIMPLE(p,u,v,w,Uslip,Vslip,alphaU,alphaP,dx,dy,dz,nu):

コード全体はこちら

上記の関連記事のとおり、numba.jitが使えない条件は多々ありますが、慣れてくるとほとんど引っかからないです。

私は日頃からnumba.jitを愛用しているため、無意識にnumba.jitが適用できるようにコーディングしている気がします。

まとめ

  • 前記事では計算時間が10分でも十分速いと書きましたが、numba.jitを使うと6秒で回るので全く問題なしです。
  • 不明な点があればコメントをお願いします。

GitHub

github.com


前記事から久しぶりに新しいモデルを書いたので楽しかったです。ぜひ回してみて下さい。

SIMPLE法でもpythonならシンプルに書けるのか ⇒ かなりシンプルになるがやっぱり...(ソースコードあり)

最近科学技術計算を書いてなかったのでウォーミングアップにこんな感じの3次元キャビテーション流れをSIMPLE法で書いてみました。

f:id:SedimentHydraulics:20200610105620p:plain

f:id:SedimentHydraulics:20200610093542p:plain

大きいものはこちら


はじめに

  • SIMPLE法って複雑ですよね。そこで、pythonなら少しはわかりやすく書けるかと思いコードを書いてみました。
  • 参考になるソースコードはないかとググったけど意外とヒットしなくて仕方なく一から書きました。

計算モデル

単純な3次元のキャビテーション流れです。

計算条件

  • 計算範囲は1 x 1 x 1の直方体
  • dx=dy=dz=0.05、メッシュ数は20 x 20 x 20の8000メッシュ
  • 計算スキームは、スタッガードスキームのSIMPLE法、移流項は一次風上
  • 上面(z=max)以外はノンスリップ条件
  • 上面(z=max)はx方向流速として1を与える
  • 外力項は重力も含めて考慮しない
  • 非定常項はキャンセル(定常場を求める)
  • レイノルズ数は100

ソースコード

仮の速度の計算式
  • 3本の運動方程式をaxisで切り替えて1つの関数にしています。私の定番の書き方です。
  • 収束計算は不足緩和で係数は標準値を採用。ここは厳密じゃなくても良い。
  • 行数は150。運動方程式がこれだけで書けるのは立派だと思う。
  • スタッガードスキームつらい。コロケートならもっとスッキリするはず。
def calupre(p,u,v,w,Vdir,Vbound,alphaU,dx,dy,dz,nu,axis):
# x: axis = 0, y: axis = 1, z: axis = 2
    
    zero = float(0.0)
    V0 = np.copy(Vdir)
    
    nx, ny, nz = p.shape
    
    ac  = np.zeros_like(Vdir)
    axp = np.zeros_like(Vdir)
    axm = np.zeros_like(Vdir)
    ayp = np.zeros_like(Vdir)
    aym = np.zeros_like(Vdir)
    azp = np.zeros_like(Vdir)
    azm = np.zeros_like(Vdir)
    b   = np.zeros_like(Vdir)
    
    act  = np.zeros_like(Vdir)
    
    if axis == 0:
        xs, ys, zs = 1, 0, 0
        xmb, xpb, ymb, ypb, zmb, zpb = -1, -1, 0, ny-1, 0, nz-1
    elif axis == 1:
        xs, ys, zs = 0, 1, 0
        xmb, xpb, ymb, ypb, zmb, zpb = 0, nx-1, -1, -1, 0, nz-1
    elif axis == 2:
        xs, ys, zs = 0, 0, 1
        xmb, xpb, ymb, ypb, zmb, zpb = 0, nx-1, 0, ny-1, -1, -1
        
    for i in range(xs, nx):
        for j in range(ys, ny):
            for k in range(zs, nz):
                c = (i,j,k)
                
                if axis == 0:
                    uhxp = 0.5*u[i,j,k]   + 0.5*u[i+1,j,k]
                    uhxm = 0.5*u[i,j,k]   + 0.5*u[i-1,j,k]
                    vhyp = 0.5*v[i,j+1,k] + 0.5*v[i-1,j+1,k]
                    vhym = 0.5*v[i,j  ,k] + 0.5*v[i-1,j  ,k]
                    whzp = 0.5*w[i,j,k+1] + 0.5*w[i-1,j,k+1]
                    whzm = 0.5*w[i,j  ,k] + 0.5*w[i-1,j,k]
                elif axis == 1:
                    uhxp = 0.5*u[i+1,j,k] + 0.5*u[i+1,j-1,k]
                    uhxm = 0.5*u[i,j,k]   + 0.5*u[i,j-1,k]
                    vhyp = 0.5*v[i,j,k]   + 0.5*v[i,j+1,k]
                    vhym = 0.5*v[i,j,k]   + 0.5*v[i,j-1,k]
                    whzp = 0.5*w[i,j,k+1] + 0.5*w[i,j-1,k+1]
                    whzm = 0.5*w[i,j  ,k] + 0.5*w[i,j-1,k]
                elif axis == 2:
                    uhxp = 0.5*u[i+1,j,k] + 0.5*u[i+1,j,k-1]
                    uhxm = 0.5*u[i,j,k]   + 0.5*u[i,j,k-1]
                    vhyp = 0.5*v[i,j+1,k] + 0.5*v[i,j+1,k-1]
                    vhym = 0.5*v[i,j,k] + 0.5*v[i,j,k-1]
                    whzp = 0.5*w[i,j,k] + 0.5*w[i,j,k+1]
                    whzm = 0.5*w[i,j,k] + 0.5*w[i,j,k-1]
                
                axp[c] = (max([-uhxp,0.0]) + nu/dx)*dy*dz 
                axm[c] = (max([ uhxm,0.0]) + nu/dx)*dy*dz 
                ayp[c] = (max([-vhyp,0.0]) + nu/dy)*dx*dz 
                aym[c] = (max([ vhym,0.0]) + nu/dy)*dx*dz 
                azp[c] = (max([-whzp,0.0]) + nu/dz)*dx*dy 
                azm[c] = (max([ whzm,0.0]) + nu/dz)*dx*dy 
                
                ac[c] = axp[c]+axm[c]+ayp[c]+aym[c]+azp[c]+azm[c]
                
                if axis == 0:
                    b[c] = -dy*dz*( p[i,j,k] - p[i-1,j,k] ) + (1.0 - alphaU)/alphaU * ac[c] * V0[c]
                elif axis == 1:
                    b[c] = -dx*dz*( p[i,j,k] - p[i,j-1,k] ) + (1.0 - alphaU)/alphaU * ac[c] * V0[c]
                elif axis == 2:
                    b[c] = -dx*dy*( p[i,j,k] - p[i,j,k-1] ) + (1.0 - alphaU)/alphaU * ac[c] * V0[c]
                    
                ac[c] /= alphaU
                act[c] = ac[c]
                
                if i == xmb :
                    ac[c] += axm[c]
                elif i == xpb :
                    ac[c] += axp[c]
                
                if j == ymb :
                    ac[c] += aym[c]
                elif j == ypb :
                    ac[c] += ayp[c]
                    
                if k == zmb :
                    ac[c] += azm[c]
                elif k == zpb :
                    ac[c] += azp[c]
                    b[c] += 2.0*azp[c]*Vbound
    
    def sor(u):
        u0 = np.copy(u) # deep copy
        for i in range(xs, nx):
            for j in range(ys, ny):
                for k in range(zs, nz):
                    c = (i,j,k)
                    xp,xm,yp,ym,zp,zm = (i+1,j,k),(i-1,j,k),(i,j+1,k),(i,j-1,k),(i,j,k+1),(i,j,k-1)
                    
                    if i == xmb :
                        uxp ,uxm = u0[xp], zero
                    elif i == xpb :
                        uxp ,uxm = zero, u0[xm]
                    else:
                        uxp ,uxm = u0[xp], u0[xm]
                    
                    if j == ymb :
                        uyp ,uym = u0[yp], zero
                    elif j == ypb :
                        uyp ,uym = zero , u0[ym]
                    else:
                        uyp ,uym = u0[yp], u0[ym]
                        
                    if k == zmb :
                        uzp, uzm = u0[zp], zero
                    elif k == zpb :
                        uzp, uzm = zero, u0[zm]
                    else:
                        uzp ,uzm = u0[zp], u0[zm]
                    
                    ut = (axp[c]*uxp + axm[c]*uxm \
                        + ayp[c]*uyp + aym[c]*uym \
                        + azp[c]*uzp + azm[c]*uzm + b[c])/ac[c]
                    
                    u0[c] = ut
                    
        return u0
                    
    unew = np.copy(Vdir) # deep copy
    
    for _ in range(100):
        utmp = sor(unew)
        err = np.abs(unew - utmp).max() 
        unew = np.copy(utmp)
        if err < 10**(-3) : break
        
#     print(err)
        
    return unew, act
圧力補正値の計算式
  • 収束計算は厳密にSOR
  • こちらは式も単純なのですっきりと。上の運動方程式と同じく連立一次方程式を解く形なので上手く書けば一つの関数になるかも。
def caldp(p,u,v,w,acu,acv,acw,dx,dy,dz):
    
    zero = float(0.0)
    dp  = np.zeros_like(p)
    ac  = np.zeros_like(p)
    axp = np.zeros_like(p)
    axm = np.zeros_like(p)
    ayp = np.zeros_like(p)
    aym = np.zeros_like(p)
    azp = np.zeros_like(p)
    azm = np.zeros_like(p)
    b   = np.zeros_like(p)
    
    nx, ny, nz = p.shape
    
    for i in range(nx):
        for j in range(ny):
            for k in range(nz):
                c = (i, j, k)
                axp[c] =  zero if np.abs( acu[i+1,j,  k  ] ) < 10**(-8) else dy**2*dz**2/acu[i+1,j,  k  ] 
                axm[c] =  zero if np.abs( acu[i  ,j,  k  ] ) < 10**(-8) else dy**2*dz**2/acu[i  ,j,  k  ] 
                ayp[c] =  zero if np.abs( acv[i  ,j+1,k  ] ) < 10**(-8) else dx**2*dz**2/acv[i  ,j+1,k  ] 
                aym[c] =  zero if np.abs( acv[i  ,j,  k  ] ) < 10**(-8) else dx**2*dz**2/acv[i  ,j,  k  ] 
                azp[c] =  zero if np.abs( acw[i  ,j,  k+1] ) < 10**(-8) else dx**2*dy**2/acw[i  ,j,  k+1] 
                azm[c] =  zero if np.abs( acw[i  ,j,  k  ] ) < 10**(-8) else dx**2*dy**2/acw[i  ,j,  k  ] 
                
                ac[c] = axp[c]+axm[c]+ayp[c]+aym[c]+azp[c]+azm[c]
                
                b[c] = - (u[i+1,j,k] - u[i,j,k])*dy*dz \
                       - (v[i,j+1,k] - v[i,j,k])*dx*dz \
                       - (w[i,j,k+1] - w[i,j,k])*dx*dy
    
    def sor(dp0, omega):
        p0 = np.copy(dp0) # deep copy
        for i in range(nx):
            for j in range(ny):
                for k in range(nz):
                    c = (i,j,k)
                    xp,xm,yp,ym,zp,zm = (i+1,j,k),(i-1,j,k),(i,j+1,k),(i,j-1,k),(i,j,k+1),(i,j,k-1)
                    
                    if i == 0:
                        pxp ,pxm = p0[xp], zero
                    elif i == nx-1:
                        pxp ,pxm = zero, p0[xm]
                    else:
                        pxp ,pxm = p0[xp], p0[xm]
                    
                    if j == 0:
                        pyp ,pym = p0[yp], zero
                    elif j == ny-1:
                        pyp ,pym = zero , p0[ym]
                    else:
                        pyp ,pym = p0[yp], p0[ym]
                        
                    if k == 0:
                        pzp, pzm = p0[zp], zero
                    elif k == nz-1:
                        pzp, pzm = zero, p0[zm]
                    else:
                        pzp ,pzm = p0[zp], p0[zm]
                    
                    pt = (axp[c]*pxp + axm[c]*pxm \
                        + ayp[c]*pyp + aym[c]*pym \
                        + azp[c]*pzp + azm[c]*pzm + b[c])/ac[c]
                    
                    p0[c] += omega*(pt - p0[c])
    #                 p0[c] = ut
                    
        return p0
                    
    dpnew = np.copy(dp) # deep copy
    for nn in range(1000):
        dptmp = sor(dpnew, float(1.8))
        err =  np.abs(dpnew - dptmp).max() 
        dpnew = np.copy(dptmp)
        
        if err < 10**(-6) :
            print('SOR N =', nn)
            break
        
    return dpnew
全体のループ
  • 収束計算の係数は標準値を採用
def SIMPLE(p,u,v,w,Uslip,Vslip,alphaU,alphaP,dx,dy,dz,nu):
    
    zero = float(0.0)
    nx, ny, nz = p.shape
    
    for nn in range(1000):
        
        u, acu = calupre(p,u,v,w,u,Uslip,alphaU,dx,dy,dz,nu,axis=0)
        v, acv = calupre(p,u,v,w,v,Vslip,alphaU,dx,dy,dz,nu,axis=1)
        w, acw = calupre(p,u,v,w,w,zero,alphaU,dx,dy,dz ,nu,axis=2)
        dp = caldp(p,u,v,w,acu,acv,acw,dx,dy,dz)
        
        p += alphaP*dp
        
        unew = np.copy(u) # deep copy
        vnew = np.copy(v) # deep copy
        wnew = np.copy(w) # deep copy
        
        for i in range(nx):
            for j in range(ny):
                for k in range(nz):
                    if i !=0 : unew[i,j,k] = u[i,j,k] + (dp[i-1,j,k] - dp[i,j,k])*dy*dz/acu[i,j,k]
                    if j !=0 : vnew[i,j,k] = v[i,j,k] + (dp[i,j-1,k] - dp[i,j,k])*dx*dz/acv[i,j,k]
                    if k !=0 : wnew[i,j,k] = w[i,j,k] + (dp[i,j,k-1] - dp[i,j,k])*dx*dy/acw[i,j,k]
        
        err =  max([np.abs(unew - u).max(), np.abs(vnew - v).max(), np.abs(wnew - w).max()])
        print('N', nn, 'error =', err)
        
        u = np.copy(unew) # deep copy
        v = np.copy(vnew) # deep copy
        w = np.copy(wnew) # deep copy
        
        if err < 10**(-6) : break
        
    return p,u,v,w
コード全体

こちら

結論(タイトルの回収とか)

  • SIMPLE法の解法を理解していることを前提とするとpythonを使うことにより随分スッキリとコーディングできると思います。少なくともFortranやCのグローバル変数まみれのものよりはましだと思います。でも、やっぱりSIMPLE法は煩雑です。
  • 連立一次方程式の解法の部分を関数化すればもっとスッキリする。
  • ちなみに計算時間は私のノートPC(スペックはこちら)で10分程度。フル3Dの計算が、ノートPCで、スクリプト言語で、10分でできるっていい時代になりましたね。

SIMPLE法について思うこと

  • SIMPLE法は、高速に定常解を求めることが可能であり、OpenFOAMに採用される等実務的な解法だと思う。
  • 更に本領を発揮するのはコロケート格子や非構造格子の場合であり、Rhie and Chowの補間を用いることにより複雑な形状でも解析可能となる。 その場合、連立一次方程式の解法に非対称行列に適用可能なものを用いる必要がある。近年は共役勾配法ベースのもの(BiCGStab法とか)が一般的だと思う。 また、プログラミングとしてもオブジェクト指向に適している。
  • 欠点は高次精度のスキームが使えないこと。乱流問題とかには向いてないのかな。もちろん矩形格子なら可能です。
  • 非定常問題はPISO等もあるが基本的には向いてないのかな。でも、非定常問題で厳密な計算を行う機会は少ないのであまり考えなくてもいいかなと。

参考書籍

プログラミングは以下を参考にしました。

レンダリングについて

Holoviews

二次元の図はHoloviewsで書いてます。 ソースはこちら

関連記事

computational-sediment-hyd.hatenablog.jp

ParaView

三次元の図はParaViewで書きました。 XMLベースのvtk形式に関する覚書 - Qiita を参考にxmlベースのvtkを作成しました。 ソースはこちら

ParaView Glance

話題のParaView Glance(web版ParaView)でレンダリングしてみました。

以下のサイトを参考にParaViewで作った図をvtkjsでエクスポートしました。以下ではhtmlも作成していますが上手くいきませんでした。

描画はParaView Glanceにアクセスしてvtkjsファイル(サンプル)をロードするだけです。 手順をgif化しました。

f:id:SedimentHydraulics:20200610144316g:plain

GitHub

github.com

おわりに

  • 次はコロケート版を書こうかなと思ってます。
  • その前に高速化の話を書くかも。
  • 詳細な解説などリクエストがあればコメントをお願いします。

windows10環境のParaview ver.5.7 & ver.5.8でレイアウトがクラッシュする場合の解決策⇒「インテル グラフィックスの設定」のVUP

久しぶりにParaviewを使うおうとインストールしたら不具合が出たので。

元ネタIntel GPU driver update 26.20.100.6708 on windows breaks Qt GUI --> FIXED by UPGRADING intel drivers (#19364) · Issues · ParaView / ParaView · GitLab が英語しかなかったので日本語でまとめておきます。

不具合

データファイルを読み込み「Apply」ボタンをクリックするとこんな感じにtoolbarがクラッシュしてしまいます。

f:id:SedimentHydraulics:20200609114035p:plain

原因と解決策

インテル グラフィックスの設定」のバージョンが古いと発生するエラーのようです。 そのため、「インテル グラフィックスの設定」を最新版にバージョンアップすれば解決します。

バージョンによってインターフェイスやアップデート方法が異なります。「インテル グラフィックスの設定」を開いて手動でアップデートして下さい。

インテル グラフィックスの設定」はタスクバー右端のアイコンおよびコントロールパネルから開くことができます。

私の場合はバージョン27.20.100.8280にアップデートして解決しました。ちなみにプロキシ環境だと上手くいきませんでした。

アップデート後はこんな感じに無事解決しました。

f:id:SedimentHydraulics:20200609114100p:plain