Computational Reality XV. Rotary viscometer. Determining material coefficients I. B. Emek Abali, Wilhelm LKM - TU Berlin

Transcription

1 Computational Reality XV Rotary viscometer Determining material coefficients I B. Emek Abali, Wilhelm LKM - TU Berlin Abstract A non-newtonian fluid can be modeled with three-parameter-constitutive relations. We have shown one model already in Comp.Real.VII, the arctan-model of Ziegler. Another model is the Herschel-Bulkley model and probably the most famous model among the rheological models for non-newtonian fluids. We will first give the equations and their coefficients physical meaning and then try to answer this important question: How can we determine the material coefficients in these models via experiments in a rotational viscometer? 1 Experimental setup and constitutive relations A three-parameter material model comprises three material dependent coefficients. These material coefficients change the response of the matter against the forces applied on the surface or volumetrically. In a viscometer the fluid is driven by applied forces on the surface and any volumetric forces, like gravitation or electromagnetic field, are ignored. In Fig. 1 the cone-plate viscometer used is shown. The force is brought as a torque on the shaft and the velocity gradient is measured optically again on the shaft. Since the force and the response is measured, we can determine the coefficients in the material model inversely. This is the parameter fit (regression analysis) problem where we are going to implement the knowledge from Comp.Real.XII & XIII. The material model for a fluid gives the relation between Cauchy stress tensor σ ij and (symmetric) velocitygradients d ij : σ ij = µd ij, d ij = v (i = 1 ( vi + v ) j. (1) x j) 2 x j x i Figure 1: Rotational cone-plate viscometer, on left without and right with the toothpaste 1

2 That relation looks similar to the Navier-Stokes as modeled in Comp.Real.VII but this time the pressure does not play a role, the motion is driven solely by the torque. We could easily left the pressure part pδ ij in the stress definition, however, by giving the values of the pressure on the boundaries like the outer pressure being 1 bar = 10 5 Pa in every particle of the fluid the same p = 10 5 Pa would be computed. Therefore it is not necessary and is always omitted. The machine can be controlled over stress input, this follows on an inductive rotor by controlling the input voltage and thus creating a magnetic field which creates a torque on the shaft. This force creates a stress and the stress is computed by the machine via given geometric dimensions of the sample. We can extract a surface and use a coordinate system x in horizontal and y in vertical on the outer shell. In Fig. 2 the machine and the outer shell is drawn as a sketch. Only a small part on the outer shell is chosen as the region and equipped with the Cartesian coordinate system, x on the horizontal and y on vertical. This means that we measure σ 12 and d 12 in the experiments. In the mid of 20 s Herschel and Bulkley proposed an apparent viscosity depending on the aforementioned component, d 12, given by a power law: σ 12 = µ(d 12 ) n + τ. (2) They simply have observed that type of a behavior in non-newtonian materials. The quantity τ mimics a yield stress, though the machine applies some torque there are no motion to be recorded. After this limit (to start yielding) stress τ has been reached, velocity gradient d 12 starts to build up exponentally. We need to transfer this equation to multiaxial tensor notation as follows: σ ij = (µ (II d) n/2 IId + τ IId )d ij, II d = 1 2 d ijd ij, (3) while its reduction to one-dimension is identical with Eq. (2) in case of a shear deformation in two-dimensions: ( ) 0 d12 d ij = II d 12 0 d = (d 12 ) 2, ( ) 0 σ12 = (µ (d 12) n + τ ) ( ) 0 d12, σ 12 0 d 12 d 12 d 12 0 ( ) ( ) 0 σ12 0 µ(d = 12 ) n + τ σ 12 0 µ(d 12 ) n. (4) + τ 0 Another three-parameter model is from the mid of 70 s, probably not thought for the first time, however, motivated from a theoretical point of view by Ziegler: σ ij = µ d ij + 2τ ( π II ) d arctan II d n d ij. (5) Its reduction to one-dimensional space since our experiment gives us only σ 12 and d 12, reads: σ 12 = µ d τ π arctan ( d12 n ) sign(d 12 ) = µ d τ π arctan ( d12 n ). (6) This model basically does the same as above, however, by using the sigmoid function 1 it is more smooth. Though it is not immediately obvious, both relations will turn into the Bingham material model introduced in start of 20 s reaching the limit case: n = 1, n = µ = µ, τ = τ, σ ij = µd ij + τ IId d ij. (7) In this representation the yield shear stress τ and viscosity µ are the physically meaningful rheology constants. In the aforementioned models it is neither easy nor necessary to find out the physical meaning of the material coefficients. The question is now, how can we fit the curve of the experimental data with these three parameter? 1 arctan() is a sigmoid function, cf. Comp.Real.XIV and try to plot the arctan() to see it shapes like S 2

3 Figure 2: Drawing of the experimental setup and the area for the 2D flow simulation 2 Inverse analysis Instead of calculating the response of the material by known parameters, here we measure the response and by using it obtain the parameters inversely. It is possible to find the three parameters µ, n, τ in the first model (Eq. (2)) or µ, n, τ in the second model (Eq. (6)) by measuring three different stress, velocity-gradient {σ 12, d 12 } states and then by solving the inverse problem directly. We place the matter between the cone and plate, start to increase the torque and record the d 12 many times, much more than just three! Mathematically only three would be sufficient, but we have got hundreds of data and naturally want to find the optimum fit. Hence, the inverse problem has many solutions, each of every one fits at least to three different states. The optimum solution can be determined in terms of an error prediction, i.e., cost, which is minimized numerically to obtain the best parameters. We programmed and solved in SciPy by using the Levenberg-Marquardt non-linear least squares error algorithm for a measurement using Eqs. (2) and (6). Unfortunately the optimization is non-linear since the parameters occur in multiplications. It is possible to solve after a Newton-Raphson linearization, alike the one which we use for FEM. The only difference is in the algorithm. For FEM we linearize on the partial differential equations level, so that the incremental part (we name it in the code as Gain) is found symbolically. In the optimization, however, the algorithm uses a numeric differentiation (it is already programmed in the scipy.optimization package) for it. In FEM we do not care much about the starting condition for the increments since we solve it transient, the solution from the last time step is the (correct) starting condition. Here by parameter fit, the choice is crucial and we have no idea how to find it! Therefore in a parameter-range, we randomly select starting parameters and compare the cost. Additionally, we compute the parameters by using the part of the data, known as training set and the cost with a different part of the data, known as test set. Having different training and test sets is known as generalization performance in graphical models. First we set the minimum cost artificially high and select a set of parameters to determine the cost. We save it if it is less than the artificially high set cost. Secondly, we select another set of parameters and solve and compare. If the cost is reduced than the minimum cost is updated. This procedure is looped subsequently, in the code shown below times. This is known as Monte Carlo method since the starting parameters are chosen randomly. The best solution is never guaranteed but the possibility of getting the optimum solution raises upon every new trial. At the end of the optimization the following results are obtained: σ 12 = µ(d 12 ) n + τ µ = Pa s, n = 0.599, τ = Pa, (8) σ ij = µ d τ π arctan ( d12 n ) µ = Pa s, n = 0.267, τ = Pa. (9) Here we clearly see that the physical relevance of the coefficients is rather not to question. They are just some values to model the material response. Though they look alike in the models, different models yield to quite different values. 3

4 Figure 3: Experiment, fit curve and simulation, Herschel-Bulkley on left and Ziegler on right 3 Variational form The numerical solution is achieved with the variational form exactly as been done in Comp.Real.VII. For an open system Ω filled with the fluid the balance of mass and linear momentum have to be satisfied: dρ dt + ρ v i x i = 0, ρ dv i dt σ ji x j = ρf i. (10) We contract them with the test functions from the same rank, i.e., the balance of mass with a scalar function and the balance of momentum with a tensor of rank one function. Since we do not compute the pressure, we use the mass balance to compute the mass density. We start with resting fluid and assume the mass is distributed equivalently, i.e., homogeneous. Though we do not show in here, the mass density stays quite homogeneous in the whole simulation. This is indeed the incompressibility of the fluid which is also an experimentally known fact. The form to be minimized reads after finding the residuals and contracting with appropriate test functions in the so-called Hilbert configuration space: ( dρ dt + ρ v ) (( i δρ + ρ dv i x i dt σ ) ) ji δv i dx = 0. (11) x j We discretize in time with a finite difference method: Ω d ( ) = ( ) + dx i ( ) ( ) ( )0 ( ) = dt t dt x i t t 0 + v i, dt = t t 0, v i = dx i x i dt, (12) and in space with a finite element method: ( ρ ρ 0 t t 0 δρ + v ρ i δρ + ρ v i δρ + ρ v i vi 0 x i x i t t 0 δv i+ elements Ω ele. ) v i δv i +ρv j δv i + σ ji dx σ ji δv i n j ds, (13) x j x j Ω where integration by parts have been used to get only first-order differentials in velocities v i. This form is nonlinear in velocities, hence the solution is incremental by using the abstract class NonlinearProblem of FEniCS project. All the boundaries except the top are set to traction-free, so that the last term vanishes. The rectangular cavity with periodic boundaries on right and left boundaries is mathematically the same as the outer cylindrical shell in Fig. 2. The periodic boundaries map the nodes on the right to the left such as the solution is the same on the right and left boundary, in every time. The rectangular cavity is driven on top with a linearly 4

5 raising traction and hold on bottom. On top the velocity gradient is computed and written out as a list. We have in Fig. 3 black plus symbols for the experimental data, red circle annotated line as the one from the one-dimensional parameter fit and blue lines with squares from the simulation. C o m p u t a t i o n a l r e a l i t y XIV, i n v e r s e a n a l y s i s a n d o b t a i n i n g t h e o p t i m u m p a r a m e t e r s f o r a non l i n e a r v i s c o u s f l u i d, w h i c h i s s i m u l a t e d a s d r i v e n l i d c a v i t y w i t h p e r i o d i c b o u n d a r i e s a u t h o r = B. Emek Abali ( abali@tu b e r l i n. de ) d a t e = c o p y r i g h t = Copyright (C) 2012, B. Emek Abali l i c e n s e = GNU GPL Version 3 or any l a t e r v e r s i o n # # r u n l i k e : p y t h o n f i t c o m p u t e p l o t. py # f r o m s h e l l a f t e r i n s t a l l i n g FEniCS a n d S c i P y ( m a t p l o t l i b ), s u c h t h a t : #s u d o a p t g e t i n s t a l l p y t h o n s c i p y p y t h o n m a t p l o t l i b #u n d e r U b u n t u # p l e a s e r e f e r t o : # www. f e n i c s p r o j e c t. o r g # www. s c i p y. o r g # from d o l f i n import import numpy # r e a d i n g t h e d a t a f r o m e x p e r i m e n t # t h e d a t a S i g n a l d a t a. py i s t o b e f o u n d u n d e r Comp. R e a l. w e b s i t e s h e a r s t r e s s, shear ratenew, s h e a r r a t e, v i s c o s i t y, t, temperature, n o r m a l s t r e s s = \ numpy. l o a d t x t ( S i g n a l d a t a. py, d e l i m i t e r=,, unpack=true ) import s c i p y import s c i p y. i n t e r p o l a t e import s c i p y. optimize s t r e s s = s c i p y. i n t e r p o l a t e. i n t e r p 1 d ( s h e a r r a t e, s h e a r s t r e s s, b o u n d s e r r o r=false, \ f i l l v a l u e =0.0) # p a r a m e t e r i d e n t i f i c a t i o n o f t h e f i t e q u a t i o n def f i t 2 f i n d p a r a m ( c o n s t i t u t i v e m o d e l ) : # m o d e l i n 1D t o b e u s e d def f i t ( d12,mu, n, tau ) : i f c o n s t i t u t i v e m o d e l== h e r s c h e l b u l k l e y : sigma = mu d12 n + tau i f c o n s t i t u t i v e m o d e l== arctan : sigma = mu d12 + \ 2. tau /numpy. p i numpy. arctan ( d12/n ) return sigma def r e s i d u a l ( param, h, G, h y p o t h e s i s ) : return h (G) h y p o t h e s i s (G, param ) def c o s t ( param, h, G, h y p o t h e s i s ) : return numpy. sum( r e s i d u a l ( param, h, G, h y p o t h e s i s ) 2, a x i s =0) # n u m b e r o f e x p e r i m e n t s m=s h e a r r a t e. s i z e # n u m b e r o f t h e m t o b e t a k e n f o r f i t m=round (m 0. 7 ) # i n i t i a l g u e s s #a s a r a n g e, p a r a m = [ mu, n, t a u ] d u e t o t h e d e f f i t ( d12, mu, n, t a u ) prange =[numpy. arange ( 0, , 1 ), numpy. arange ( 0, 1, 0. 1 ), numpy. arange ( 0, 1 0, 0. 5 ) ] numpy. s e t e r r ( a l l= i g n o r e ) # f i t t i n g o n a r a n d o m s e t a n d t e s t i n g w i t h a n o t h e r s e t 5

6 montecarlo = 6 n u m b e r o f t r i a l s = 0 e r r o r m i n = 10 e10 penalty = 10 e6 from copy import deepcopy r a t e s=deepcopy ( s h e a r r a t e ) while n u m b e r o f t r i a l s < : i f montecarlo >5: p1 = prange [ 0 ] [ numpy. random. random integers ( 0, l e n ( prange [ 0 ] ) 1 ) ] p2 = prange [ 0 ] [ numpy. random. random integers ( 0, l e n ( prange [ 0 ] ) 1 ) ] p3 = prange [ 0 ] [ numpy. random. random integers ( 0, l e n ( prange [ 0 ] ) 1 ) ] param0 = [ p1, p2, p3 ] montecarlo = 0 numpy. random. s h u f f l e ( r a t e s ) param lsq = s c i p y. optimize. l e a s t s q ( r e s i d u a l, param0, \ a r g s =( s t r e s s, r a t e s [ :m], f i t ) ) param=param lsq [ 0 ] montecarlo +=1 e r r o r=c o s t ( param, s t r e s s, r a t e s [ :m], f i t ) i f param [ 0 ] < 0 : e r r o r += penalty #we f o r c e t p g e t k >0 i f param [ 2 ] < 0 : e r r o r += penalty #we f o r c e t p g e t mu>0 i f e r r o r <e r r o r m i n : chosen param = param e r r o r m i n = e r r o r print parameters :, param, e r r o r on t e s t s e t :, e r r o r, n u m b e r o f t r i a l s n u m b e r o f t r i a l s +=1 return chosen param # p a r a m e t e r i d e n t i f i c a t i o n o f t h e f i t e q u a t i o n # n u m e r i c a l parameters [ form compiler ] [ cpp optimize ]=True parameters [ form compiler ] [ l o g l e v e l ] = ERROR+10 # s o l v e r f o r i n c r e m e n t a l n o n l i n e a r s c h e m e class i t e r a t e ( NonlinearProblem ) : def i n i t ( s e l f, a, L, bc, exter B ) : NonlinearProblem. i n i t ( s e l f ) s e l f. L = L s e l f. a = a s e l f. bc = bc s e l f. e x t e r = exter B def F( s e l f, b, x ) : assemble ( s e l f. L, t e n s o r=b, e x t e r i o r f a c e t d o m a i n s=s e l f. e x t e r ) for c o n d i t i o n in s e l f. bc : c o n d i t i o n. apply (b, x ) def J ( s e l f, A, x ) : assemble ( s e l f. a, t e n s o r=a, e x t e r i o r f a c e t d o m a i n s=s e l f. e x t e r ) for c o n d i t i o n in s e l f. bc : c o n d i t i o n. apply (A) c o m p u t a t i o n # i n i t i a l v a l u e s class i n i t v a l u e s ( Expression ) : def e v a l ( s e l f, vec, x ) : vec [ 0 ] = 0. 0 vec [ 1 ] = 0. 0 vec [ 2 ] = e 6 #g /mm3 def v a l u e s h a p e ( s e l f ) : return ( 3, ) # u n i t s # m a s s i n g # f o r c e i n mun # l e n g t h i n mm 6

7 # t i m e i n s e c # mun / mmˆ 2 = Pa # g e o m e t r y xlength = ylength = 4. 2 mesh=rectangle ( 0., 0., xlength, ylength, 40, 4) # f u n c t i o n a l s p a c e s V e l o c i t y = VectorFunctionSpace ( mesh, CG, 1) Massdensity = FunctionSpace ( mesh, CG, 1) Dim = mesh. topology ( ). dim ( ) space = MixedFunctionSpace ( [ Velocity, Massdensity ] ) # b o u n d a r i e s a n d t h e i r v a l u e s top = compile subdomains ( x [ 1 ] == l e n g t h ) top. l e n g t h = ylength bottom = compile subdomains ( x [ 1 ] == 0. 0 ) subdomains = MeshFunction ( u i n t, mesh, Dim 1) subdomains. s e t a l l ( 0 ) top. mark ( subdomains, 1 ) d r i v e = Expression ( ( amp, 0. 0 ),amp=0.) n u l l = Expression ( ( 0. 0, 0. 0 ) ) class PeriodicBoundary ( SubDomain ) : def i n s i d e ( s e l f, x, on boundary ) : # l e f t s i d e i s x [ 0 ] = x l e n g t h / 2 return x [ 0 ] < +1. e 5 and x [ 0 ] > 1. e 5 and on boundary def map( s e l f, y, x ) : # t h i s maps r i g h t s i d e x [ 0 ] = x l e n g t h t o t h e l e f t x [ 0 ] = y [0] xlength x [ 1 ] = y [ 1 ] bc = [ DirichletBC ( space. sub ( 0 ), n u l l, bottom ), \ PeriodicBC ( space. sub ( 0 ), PeriodicBoundary ( ) ) ] # how and w h e r e t o s a v e def compute ( c o n s t i t u t i v e m o d e l,mu, n, tau ) : pwd = / c a l c u l / t e l c / f i l e v = F i l e (pwd+c o n s t i t u t i v e m o d e l+ v e l o c i t y. pvd ) f i l e r = F i l e (pwd+c o n s t i t u t i v e m o d e l+ massdensity. pvd ) i, j, k, l =i n d i c e s ( 4 ) t, t end = 0., dt = 1 0. # s e t u p t e s t = TestFunction ( space ) dprimary = T rialfunction ( space ) Primary0 = Function ( space ) Primary = Function ( space ) P r i m a r y i n i t = i n i t v a l u e s ( ) Primary0. i n t e r p o l a t e ( P r i m a r y i n i t ) Primary. a s s i g n ( Primary0 ) v0, rho0 = s p l i t ( Primary0 ) v, rho = s p l i t ( Primary ) delv, d e l r h o = s p l i t ( t e s t ) d e l t a = I d e n t i t y (Dim) # m a t e r i a l def d ( v ) : return a s t e n s o r ( 1. 0 / 2. 0 ( v [ i ]. dx ( j )+v [ j ]. dx ( i ) ), ( i, j ) ) I I d = a s t e n s o r ( 1. 0 / 2. 0 d ( v ) [ k, l ] d ( v ) [ k, l ] , ( ) ) i f c o n s t i t u t i v e m o d e l== arctan : def sigma ( v ) : return a s t e n s o r (mu d ( v ) [ i, j ] + 2. tau / p i / I I d 0.5 \ 7

8 atan ( I I d 0.5/ n ) d ( v ) [ i, j ], ( i, j ) ) i f c o n s t i t u t i v e m o d e l== h e r s c h e l b u l k l e y : def sigma ( v ) : return a s t e n s o r (mu I I d ( ( n 1. ) / 2. ) d ( v ) [ i, j ] \ + tau / I I d 0.5 d ( v ) [ i, j ], ( i, j ) ) # v a r i a t i o n a l s t r u c t. Form = ( rho rho0 )/ dt d e l r h o dx\ + v [ i ] rho. dx ( i ) d e l r h o dx\ + rho v [ i ]. dx ( i ) d e l r h o dx\ + rho ( v v0 ) [ i ] / dt delv [ i ] dx \ + rho v [ j ] v [ i ]. dx ( j ) delv [ i ] dx \ + sigma ( v ) [ j, i ] delv [ i ]. dx ( j ) dx \ d r i v e [ i ] delv [ i ] ds ( 1 ) #+ r h o v [ j ] v [ k ]. dx ( k ) w [ j ] dx \ # l i n e a r i z a t i o n Gain = d e r i v a t i v e (Form, Primary, dprimary ) sigma values, v 1 x 2 v a l u e s = [ ], [ ] #t i m e s l i c i n g while t < t end : t = t + dt print time :, t, o f, t end d r i v e. amp = 250.0/ t end t problem = i t e r a t e ( Gain, Form, bc, subdomains ) s o l v e r = NewtonSolver ( l u ) s o l v e r. parameters [ c o n v e r g e n c e c r i t e r i o n ] = i n c r e m e n t a l s o l v e r. parameters [ r e l a t i v e t o l e r a n c e ] = 1. 0 e 1 s o l v e r. s o l v e ( problem, Primary. v e c t o r ( ) ) f i l e v << ( Primary. s p l i t ( ) [ 0 ], t ) f i l e r << ( Primary. s p l i t ( ) [ 1 ], t ) v e l=primary. s p l i t ( deepcopy=true ) [ 0 ] S=p r o j e c t ( sigma ( v e l ), TensorFunctionSpace ( mesh, CG, 1 ) ) velgrad=p r o j e c t ( d ( v e l ), TensorFunctionSpace ( mesh, CG, 1 ) ) P=(xlength, ylength / 2. ) # we m e a s u r e o n t o p s i g 1 2=S (P ) [ 1 ] velgrad12=velgrad (P ) [ 1 ] s i g m a v a l u e s. append ( s i g 1 2 ) v 1 x 2 v a l u e s. append ( velgrad12 ) # u p d a t e Primary0. a s s i g n ( Primary ) # e n d o f w h i l e return v1x2 values, s i g m a v a l u e s # n u m e r i c a l c o m p u t a t i o n # v i s u a l i z a t i o n import m a t p l o t l i b as mpl mpl. use ( Agg ) import m a t p l o t l i b. pyplot as pylab def v i s u a l i z e ( c o n s t i t u t i v e m o d e l, chosen param, f e m s h e a r r a t e, f e m s t r e s s ) : def f i t ( d12,mu, n, tau ) : i f c o n s t i t u t i v e m o d e l== h e r s c h e l b u l k l e y : sigma = mu d12 n + tau i f c o n s t i t u t i v e m o d e l== arctan : sigma = mu d tau /numpy. p i numpy. arctan ( d12/n ) return sigma pylab. c l a ( ) pylab. p l o t ( s h e a r r a t e, s h e a r s t r e s s, c o l o r= black, marker= +, \ m a r k e r s i z e =13, l a b e l= data ) pylab. p l o t ( s h e a r r a t e, f i t ( s h e a r r a t e, chosen param [ 0 ], chosen param [ 1 ], \ chosen param [ 2 ] ), c o l o r= red, marker= o, m a r k e r s i z e =5, l a b e l= f i t ) pylab. p l o t ( f e m s h e a r r a t e, f e m s t r e s s, c o l o r= blue, l i n e s t y l e=, l i n e w i d t h =6,\ l a b e l= s i m u l a t i o n ) pylab. y l a b e l ( s t r e s s $\ sigma {12} $ [ Pa ] ) pylab. x l a b e l ( v e l o c i t y g r a d i e n t $d {12} $ [ 1 / s ] ) 8

9 pylab. t i t l e ( Experiment vs. f i t vs. s i m u l a t i o n ) pylab. legend ( l o c= b e s t ) pylab. g r i d ( True ) return pylab # v i s u a l i z a t i o n # f i t & c o m p u t e & p l o t f i t a = f i t 2 f i n d p a r a m ( arctan ) f e m s h e a r r a t e a, f e m s t r e s s a = compute ( arctan, f i t a [ 0 ], f i t a [ 1 ], f i t a [ 2 ] ) f i g a = v i s u a l i z e ( arctan, f i t a, f e m s h e a r r a t e a, f e m s t r e s s a ) f i g a. s a v e f i g ( f i t a r c t a n. ps ) f i t h b = f i t 2 f i n d p a r a m ( h e r s c h e l b u l k l e y ) fem shearrate hb, f e m s t r e s s h b = compute ( h e r s c h e l b u l k l e y, f i t h b [ 0 ], f i t h b [ 1 ], f i t h b [ 2 ] ) f i g h b = v i s u a l i z e ( h e r s c h e l b u l k l e y, f i t h b, fem shearrate hb, f e m s t r e s s h b ) f i g h b. s a v e f i g ( f i t h e r s c h e l b u l k l e y. ps ) print For arctan model, mu:, f i t a [ 0 ], n :, f i t a [ 1 ], tau :, f i t a [ 2 ] print For H e r s c h e l Bulkley model, mu:, f i t h b [ 0 ], n :, f i t h b [ 1 ], tau :, f i t h b [ 2 ] # e n d o f f i l e 9