Problem 13 Visualizing the mesh quality
Mesh-Intro_14.5_L08_Mesh_Quality
– 16 000 cells (~DP2) – Delta P = 310 Pa (~DP3)
© 2012 ANSYS, Inc.
November 20, 2012
9
Release 14.5
Hexa vs. Tetra
Hexa
• Hexa: Concentration in one direction
• Mesh quality criteria are within correct range
– Orthogonal quality … • Mesh is valid for studied physics – Boundary layer … • Solution is grid independent • Important geometric details are well captured
November 20, 2012 10
Tetra
Prism
Tetra (in volume)
Prisms (near wall)
© 2012 ANSYS, Inc.
Release 14.5
Mesh Statistics and Mesh Metrics
Displays mesh information for Nodes and Elements List of quality criteria for the Mesh Metric
At boundaries and internal walls ci is ignored in the computations of OQ
© 2012 ANSYS, Inc. November 20, 2012 12
0 Worst
FIDIC银皮书(中英文对照)
CONTENTS目录1General Provisions一般规定 (5)1.1Definitions定义 (5)1。
2Interpretation解释 (10)1.3Communications通信交流 (11)1。
4Law and Language法律和语言 (12)1。
5Priority of Document文件优先次序 (12)1。
6Contract Agreement合同协议书 (12)1。
7Assignment权益转让 (13)1.8Care and Supply of Document文件的照管和提供 (13)1.9Confidentiality保密性 (14)1.10Emplo yer’s Use of Contractor’s Documents雇主使用承包商文件 (14)1。
11Contractor’s Use of Employer’s Documents承包商使用雇主文件 (15)1。
12Confidential Details保密事项 (15)1。
13Compliance with Laws遵守法律 (15)1.14Joint and Several Liability共同的和各自的责任 (16)2The Employer雇主 (16)2.1Right of Access to the Site现场进入权 (16)2。
2Permits, Licences or Approves许可、执照或批准 (17)2.3Employer’s personnel雇主人员 (18)2。
4Employer’s Financial Arrangements雇主的资金安排 (18)2。
5Employer's Claims雇主的索赔 (18)3The Employer’s Administration雇主的管理 (19)3.1The Employer’s Representative雇主代表 (19)3。
交互式计算机图形学(第五版)1-7章课后题答案
Angel: Interactive Computer Graphics, Fifth Edition Chapter 1 Solutions1.1 The main advantage of the pipeline is that each primitive can be processed independently. Not only does this architecture lead to fast performance, it reduces memory requirements because we need not keep all objects available. The main disadvantage is that we cannot handle most global effects such as shadows, reflections, and blending in a physically correct manner.1.3 We derive this algorithm later in Chapter 6. First, we can form the tetrahedron by finding four equally spaced points on a unit sphere centered at the origin. One approach is to start with one point on the z axis(0, 0, 1). We then can place the other three points in a plane of constant z. One of these three points can be placed on the y axis. To satisfy the requirement that the points be equidistant, the point must be at(0, 2p2/3,−1/3). The other two can be found by symmetry to be at(−p6/3,−p2/3,−1/3) and (p6/3,−p2/3,−1/3).We can subdivide each face of the tetrahedron into four equilateral triangles by bisecting the sides and connecting the bisectors. However, the bisectors of the sides are not on the unit circle so we must push thesepoints out to the unit circle by scaling the values. We can continue this process recursively on each of the triangles created by the bisection process.1.5 In Exercise 1.4, we saw that we could intersect the line of which theline segment is part independently against each of the sides of the window. We could do this process iteratively, each time shortening the line segment if it intersects one side of the window.1.7 In a one–point perspective, two faces of the cube is parallel to the projection plane, while in a two–point perspective only the edges of the cube in one direction are parallel to the projection. In the general case of a three–point perspective there are three vanishing points and none of the edges of the cube are parallel to the projection plane.1.9 Each frame for a 480 x 640 pixel video display contains only about300k pixels whereas the 2000 x 3000 pixel movie frame has 6M pixels, or about 18 times as many as the video display. Thus, it can take 18 times asmuch time to render each frame if there is a lot of pixel-level calculations.1.11 There are single beam CRTs. One scheme is to arrange the phosphors in vertical stripes (red, green, blue, red, green, ....). The major difficulty is that the beam must change very rapidly, approximately three times as fast a each beam in a three beam system. The electronics in such a system the electronic components must also be much faster (and more expensive). Chapter 2 Solutions2.9 We can solve this problem separately in the x and y directions. The transformation is linear, that is xs = ax + b, ys = cy + d. We must maintain proportions, so that xs in the same relative position in the viewport as x is in the window, hencex − xminxmax − xmin=xs − uw,xs = u + wx − xminxmax − xmin.Likewiseys = v + hx − xminymax − ymin.2.11 Most practical tests work on a line by line basis. Usually we use scanlines, each of which corresponds to a row of pixels in the frame buffer. If we compute the intersections of the edges of the polygon with a line passing through it, these intersections can be ordered. The first intersection begins a set of points inside the polygon. The second intersection leaves the polygon, the third reenters and so on.2.13 There are two fundamental approaches: vertex lists and edge lists. With vertex lists we store the vertex locations in an array. The mesh is represented as a list of interior polygons (those polygons with no otherpolygons inside them). Each interior polygon is represented as an array of pointers into the vertex array. To draw the mesh, we traverse the list of interior polygons, drawing each polygon.One disadvantage of the vertex list is that if we wish to draw the edges inthe mesh, by rendering each polygon shared edges are drawn twice. Wecan avoid this problem by forming an edge list or edge array, each elementis a pair of pointers to vertices in the vertex array. Thus, we can draw each edge once by simply traversing the edge list. However, the simple edge list has no information on polygons and thus if we want to render the mesh in some other way such as by filling interior polygons we must add somethingto this data structure that gives information as to which edges form each polygon.A flexible mesh representation would consist of an edge list, a vertex listand a polygon list with pointers so we could know which edges belong to which polygons and which polygons share a given vertex.2.15 The Maxwell triangle corresponds to the triangle that connects thered, green, and blue vertices in the color cube.2.19 Consider the lines defined by the sides of the polygon. We can assigna direction for each of these lines by traversing the vertices in acounter-clockwise order. One very simple test is obtained by noting thatany point inside the object is on the left of each of these lines. Thus, if we substitute the point into the equation for each of the lines (ax+by+c), we should always get the same sign.2.23 There are eight vertices and thus 256 = 28 possible black/white colorings. If we remove symmetries (black/white and rotational) there are14 unique cases. See Angel, Interactive Computer Graphics (Third Edition) or the paper by Lorensen and Kline in the references.Chapter 3 Solutions3.1 The general problem is how to describe a set of characters that might have thickness, curvature, and holes (such as in the letters a and q). Suppose that we consider a simple example where each character can be approximated by a sequence of line segments. One possibility is to use a move/line system where 0 is a move and 1 a line. Then a character can be described by a sequence of the form (x0, y0, b0), (x1, y1, b1), (x2, y2, b2), .....where bi is a 0 or 1. This approach is used in the example in the OpenGL Programming Guide. A more elaborate font can be developed by using polygons instead of line segments.3.11 There are a couple of potential problems. One is that the application program can map different points in object coordinates to the same point in screen coordinates. Second, a given position on the screen when transformed back into object coordinates may lie outside the user’s window.3.19 Each scan is allocated 1/60 second. For a given scan we have to take 10% of the time for the vertical retrace which means that we start to draw scan line n at .9n/(60*1024) seconds from the beginning of the refresh. But allocating 10% of this time for the horizontal retrace we are at pixel m on this line at time .81nm/(60*1024).3.25 When the display is changing, primitives that move or are removed from the display will leave a trace or motion blur on the display as the phosphors persist. Long persistence phosphors have been used in text only displays where motion blur is less of a problem and the long persistence gives a very stable flicker-free image.Chapter 4 Solutions4.1 If the scaling matrix is uniform thenRS = RS(α, α, α) = αR = SRConsider R x(θ), if we multiply and use the standard trigonometric identities for the sine and cosine of the sum of two angles, we findR x(θ)R x(φ) = R x(θ + φ)By simply multiplying the matrices we findT(x1, y1, z1)T(x2, y2, z2) = T(x1 + x2, y1 + y2, z1 + z2)4.5 There are 12 degrees of freedom in the three–dimensional affine transformation. Consider a point p = [x, y, z, 1]T that is transformed top_ = [x_y_, z_, 1]T by the matrix M. Hence we have the relationshipp_ = Mp where M has 12 unknown coefficients but p and p_ are known. Thus we have 3 equations in 12 unknowns (the fourth equation is simplythe identity 1=1). If we have 4 such pairs of points we will have 12equations in 12 unknowns which could be solved for the elements of M.Thus if we know how a quadrilateral is transformed we can determine theaffine transformation.In two dimensions, there are 6 degrees of freedom in M but p and p_ haveonly x and y components. Hence if we know 3 points both before and after transformation, we will have 6 equations in 6 unknowns and thus in two dimensions if we know how a triangle is transformed we can determine theaffine transformation.4.7 It is easy to show by simply multiplying the matrices that theconcatenation of two rotations yields a rotation and that the concatenationof two translations yields a translation. If we look at the product of arotation and a translation, we find that the left three columns of RT arethe left three columns of R and the right column of RT is the rightcolumn of the translation matrix. If we now consider RTR_ where R_ is arotation matrix, the left three columns are exactly the same as the leftthree columns of RR_ and the and right column still has 1 as its bottomelement. Thus, the form is the same as RT with an altered rotation (whichis the concatenation of the two rotations) and an altered translation.Inductively, we can see that any further concatenations with rotations and translations do not alter this form.4.9 If we do a translation by -h we convert the problem to reflection abouta line passing through the origin. From m we can find an angle by whichwe can rotate so the line is aligned with either the x or y axis. Now reflectabout the x or y axis. Finally we undo the rotation and translation so the sequence is of the form T−1R−1SRT.4.11 The most sensible place to put the shear is second so that the instance transformation becomes I = TRHS. We can see that this order makessense if we consider a cube centered at the origin whose sides are alignedwith the axes. The scale gives us the desired size and proportions. Theshear then converts the right parallelepiped to a general parallelepiped.Finally we can orient this parallelepiped with a rotation and place it wheredesired with a translation. Note that the order I = TRSH will work too.4.13R = R z(θz)R y(θy)R x(θx) =⎡⎢⎢⎢⎣cos θy cos θz cos θz sin θx sin θy −cos θx sin θz cos θx cos θz sin θy + sin θx sin θz 0cos θy sin θz cos θx cos θz + sin θx sin θy sin θz −cos θz sin θx + cos θx sin θy sin θz 0 −sin θy cos θy sin θx cos θx cos θy 00 0 0 1⎤⎥⎥⎥⎦4.17 One test is to use the first three vertices to find the equation of theplane ax + by + cz + d = 0. Although there are four coefficients in theequation only three are independent so we can select one arbitrarily ornormalize so that a2 + b2 + c2 = 1. Then we can successively evaluateax + bc + cz + d for the other vertices. A vertex will be on the plane if weevaluate to zero. An equivalent test is to form the matrix⎡⎢⎢⎢⎣1 1 1 1x1 x2 x3 x4y1 y2 y3 y4z1 z2 z3 z4⎤⎥⎥⎥⎦for each i = 4, ... If the determinant of this matrix is zero the ith vertex isin the plane determined by the first three.4.19 Although we will have the same number of degrees of freedom in theobjects we produce, the class of objects will be very different. For exampleif we rotate a square before we apply a nonuniform scale, we will shear the square, something we cannot do if we scale then rotate.4.21 The vector a = u ×v is orthogonal to u and v. The vector b = u ×a is orthogonal to u and a. Hence, u, a and b form an orthogonal coordinatesystem.4.23 Using r = cos θ2+ sin θ2v, with θ = 90 and v = (1, 0, 0), we find forrotation about the x-axisr =√22(1, 1, 0, 0).Likewise, for rotation about the y axisr =√22(1, 0, 1, 0).4.27 Possible reasons include (1) object-oriented systems are slower, (2)users are often comfortable working in world coordinates with higher-level objects and do not need the flexibility offered by a coordinate-free approach, (3) even a system that provides scalars, vectors, and points would have to have an underlying frame to use for the implementation. Chapter 5 Solutions5.1 Eclipses (both solar and lunar) are good examples of the projection of an object (the moon or the earth) onto a nonplanar surface. Any time a shadow is created on curved surface, there is a nonplanar projection. All the maps in an atlas are examples of the use of curved projectors. If the projectors were not curved we could not project the entire surface of a spherical object (the Earth) onto a rectangle.5.3 Suppose that we want the view of the Earth rotating about the sun. Before we draw the earth, we must rotate the Earth which is a rotation about the y axis. Next we translate the Earth away from the origin. Finally we do another rotation about the y axis to position the Earth in its desired location along its orbit. There are a number of interesting variants of this problem such as the view from the Earth of the rest of the solar system.5.5 Yes. Any sequence of rotations is equivalent to a single rotation abouta suitably chosen axis. One way to compute this rotation matrix is to form the matrix by sequence of simple rotations, such asR = RxRyRz.The desired axis is an eigenvector of this matrix.5.7 The result follows from the transformation being affine. We can also take a direct approach. Consider the line determined by the points(x1, y1, z1) and (x2, y2, z2). Any point along can be written parametrically as (_x1 + (1 − _)x2, _y1 + (1 − _)y2, _z1 + (1 − _)z2). Consider the simple projection of this point 1d(_z1+(1−_)z2) (_x1 + (1 − _)x2, _y1 + (1 − _)y2)which is of the form f(_)(_x1 + (1 − _)x2, _y1 + (1 − _)y2). This form describes a line because the slope is constant. Note that the function f(_) implies that we trace out the line at a nonlinear rate as _ increases from 0 to 1.5.9 The specification used in many graphics text is of the angles the projector makes with x,z and y, z planes, i.e the angles defined by the projection of a projector by a top view and a side view.Another approach is to specify the foreshortening of one or two sides of a cube aligned with the axes.5.11 The CORE system used this approach. Retained objects were kept in distorted form. Any transformation to any object that was defined with other than an orthographic view transformed the distorted object and the orthographic projection of the transformed distorted object was incorrect.5.15 If we use _ = _ = 45, we obtain the projection matrixP =266641 0 −1 00 1 −1 00 0 0 00 0 0 1377755.17 All the points on the projection of the point (x.y, z) in the direction dx, dy, dz) are of the form (x + _dx, y + _dy, z + _dz). Thus the shadow of the point (x, y, z) is found by determining the _ for which the line intersects the plane, that isaxs + bys + czs = dSubstituting and solving, we find_ =d − ax − by − czadx + bdy + cdz.However, what we want is a projection matrix, Using this value of _ we findxs = z + _dx =x(bdy + cdx) − dx(d − by − cz)adx + bdy + cdzwith similar equations for ys and zs. These results can be computed by multiplying the homogeneous coordinate point (x, y, z, 1) by the projection matrixM =26664bdy + cdz −bdx −cdx −ddx−ady adx + cdz −cdy −ddy−adz −bdz adx + bdy −ddz0 0 0 adx + bdy + cdz37775.5.21 Suppose that the average of the two eye positions is at (x, y, z) and the viewer is looking at the origin. We could form the images using the LookAt function twice, that isgluLookAt(x-dx/2, y, z, 0, 0, 0, 0, 1, 0);/* draw scene here *//* swap buffers and clear */gluLookAt(x+dx/2, y, z, 0, 0, 0, 0, 1, 0);/* draw scene again *//* swap buffers and clear */Chapter 6 Solutions6.1 Point sources produce a very harsh lighting. Such images are characterized by abrupt transitions between light and dark. The ambient light in a real scene is dependent on both the lights on the scene and the reflectivity properties of the objects in the scene, something that cannot be computed correctly with OpenGL. The Phong reflection term is not physically correct; the reflection term in the modified Phong model is even further from being physically correct.6.3 If we were to take into account a light source being obscured by an object, we would have to have all polygons available so as to test for this condition. Such a global calculation is incompatible with the pipeline model that assumes we can shade each polygon independently of all other polygons as it flows through the pipeline.6.5 Materials absorb light from sources. Thus, a surface that appears red under white light appears so because the surface absorbs all wavelengths of light except in the red range—a subtractive process. To be compatible with such a model, we should use surface absorbtion constants that define the materials for cyan, magenta and yellow, rather than red, green and blue. 6.7 Let ψ be the angle between the normal and the halfway vector, φ be the angle between the viewer and the reflection angle, and θ be the anglebetween the normal and the light source. If all the vectors lie in the same plane, the angle between the light source and the viewer can be computer either as φ + 2θ or as 2(θ + ψ). Setting the two equal, we find φ = 2ψ. Ifthe vectors are not coplanar then φ < 2ψ.6.13 Without loss of generality, we can consider the problem in two dimensions. Suppose that the first material has a velocity of light of v1 andthe second material has a light velocity of v2. Furthermore, assume thatthe axis y = 0 separates the two materials.Place a point light source at (0, h) where h > 0 and a viewer at (x, y)where y < 0. Light will travel in a straight line from the source to a point(t, 0) where it will leave the first material and enter the second. It willthen travel from this point in a straight line to (x, y). We must find the tthat minimizes the time travelled.Using some simple trigonometry, we find the line from the source to (t, 0)has length l1 = √h2 + t2 and the line from there to the viewer has length1l2 = _y2 + (x − t)2. The total time light travels is thus l1v1 + l2v2 .Minimizing over t gives desired result when we note the two desired sinesare sin θ1 = h√h2+t2 and sin θ2 = −y √(y2+(x−t)2 .6.19 Shading requires that when we transform normals and points, we maintain the angle between them or equivalently have the dot productp ·v = p_ ·v_ when p_ = Mp and n_ = Mp. If M T M is an identity matrix angles are preserved. Such a matrix (M−1 = M T ) is called orthogonal. Rotations and translations are orthogonal but scaling and shear are not.6.21 Probably the easiest approach to this problem is to rotate the givenplane to plane z = 0 and rotate the light source and objects in the sameway. Now we have the same problem we have solved and can rotate everything back at the end.6.23 A global rendering approach would generate all shadows correctly. Ina global renderer, as each point is shaded, a calculation is done to seewhich light sources shine on it. The projection approach assumes that wecan project each polygon onto all other polygons. If the shadow of a given polygon projects onto multiple polygons, we could not compute these shadow polygons very easily. In addition, we have not accounted for thedifferent shades we might see if there were intersecting shadows from multiple light sources.Chapter 7 Solutions7.1 First, consider the problem in two dimensions. We are looking for an _ and _ such that both parametric equations yield the same point, that isx(_) = (1 − _)x1 + _x2 = (1 − _)x3 + _x4,y(_) = (1 − _)y1 + _y2 = (1 − _)y3 + _y4.These are two equations in the two unknowns _ and _ and, as long as the line segments are not parallel (a condition that will lead to a division by zero), we can solve for _ _. If both these values are between 0 and 1, the segments intersect.If the equations are in 3D, we can solve two of them for the _ and _ where x and y meet. If when we use these values of the parameters in the two equations for z, the segments intersect if we get the same z from both equations.7.3 If we clip a convex region against a convex region, we produce the intersection of the two regions, that is the set of all points in both regions, which is a convex set and describes a convex region. To see this, consider any two points in the intersection. The line segment connecting them must be in both sets and therefore the intersection is convex.7.5 See Problem 6.22. Nonuniform scaling will not preserve the angle between the normal and other vectors.7.7 Note that we could use OpenGL to, produce a hidden line removed image by using the z buffer and drawing polygons with edges and interiors the same color as the background. But of course, this method was not used in pre–raster systems.Hidden–line removal algorithms work in object space, usually with either polygons or polyhedra. Back–facing polygons can be eliminated. In general, edges are intersected with polygons to determine any visible parts. Good algorithms (see Foley or Rogers) use various coherence strategies to minimize the number of intersections.7.9 The O(k) was based upon computing the intersection of rays with the planes containing the k polygons. We did not consider the cost of filling the polygons, which can be a large part of the rendering time. If we consider a scene which is viewed from a given point there will be some percentage of 1the area of the screen that is filled with polygons. As we move the viewer closer to the objects, fewer polygons will appear on the screen but eachwill occupy a larger area on the screen, thus leaving the area of the screen that is filled approximately the same. Thus the rendering time will be about the same even though there are fewer polygons displayed.7.11 There are a number of ways we can attempt to get O(k log k) performance. One is to use a better sorting algorithm for the depth sort. Other strategies are based on divide and conquer such a binary spatial partitioning.7.13 If we consider a ray tracer that only casts rays to the first intersection and does not compute shadow rays, reflected or transmitted rays, then the image produced using a Phong model at the point of intersection will be the same image as produced by our pipeline renderer. This approach is sometimes called ray casting and is used in volume rendering and CSG. However, the data are processed in a different order from the pipeline renderer. The ray tracer works ray by ray while the pipeline renderer works object by object.7.15 Consider a circle centered at the origin: x2 + y2 = r2. If we know thata point (x, y) is on the curve than, we also know (−x, y), (x,−y),(−x,−y), (y, x), (−y, x), (y,−x), and (−y,−x) are also on the curve. This observation is known as the eight–fold symmetry of the circle. Consequently, we need only generate 1/8 of the circle, a 45 degree wedge, and can obtain the rest by copying this part using the symmetries. If we consider the 45 degree wedge starting at the bottom, the slope of this curve starts at 0 and goes to 1, precisely the conditions used for Bresenham’s line algorithm. The tests are a bit more complex and we have to account for the possibility the slope will be one but the approach is the same as for line generation.7.17 Flood fill should work with arbitrary closed areas. In practice, we can get into trouble at corners if the edges are not clearly defined. Such can be the case with scanned images.7.19 Note that if we fill by scan lines vertical edges are not a problem. Probably the best way to handle the problem is to avoid it completely by never allowing vertices to be on scan lines. OpenGL does this by havingvertices placed halfway between scan lines. Other systems jitter the y value of any vertex where it is an integer.7.21 Although each pixel uses five rays, the total number of rays has only doubled, i.e. consider a second grid that is offset one half pixel in both the x and y directions.7.23 A mathematical answer can be investigated using the notion of reconstruction of a function from its samples (see Chapter 8). However, a very easy to see by simply drawing bitmap characters that small pixels lead to very unreadable characters. A readable character should have some overlap of the pixels.7.25 We want k levels between Imin and Imax that are distributed exponentially. Then I0 = Imin, I1 = Iminr,I2 = Iminr2, ..., Ik−1 = Imax = Iminrk−1. We can solve the last equation for the desired r = ( ImaxImin)1k−17.27 If there are very few levels, we cannot display a gradual change in brightness. Instead the viewer will see steps of intensity. A simple rule of thumb is that we need enough gray levels so that a change of one step is not visible. We can mitigate the problem by adding one bit of random noise to the least significant bit of a pixel. Thus if we have 3 bits (8 levels), the third bit will be noise. The effect of the noise will be to break up regions of almost constant intensity so the user will not be able to see a step because it will be masked by the noise. In a statistical sense the jittered image is a noisy (degraded) version of the original but in a visual sense it appears better.。
fdtd_numerical_methods
© 2012 Lumerical Solutions, Inc.
Conformal mesh technology
Gauss' law for magnetism (absence of magnetic monopoles): Faraday’s law of induction:
Ampère’s law (with Maxwell's extension):
© 2012 Lumerical Solutions, Inc.
Solutions
: Graded mesh (reduce mesh size near interfaces) : Conformal mesh technology : Combination of both
© 2012 Lumerical Solutions, Inc.
9
Conformal mesh technology
Our products can accurately simulate many technologies
Photonic crystals
Bandstructure
Plasmonics
CMOS Image sensors
Nanoparticles
Solar cells
Resonators
LED/OLEDs
t H n 3 2 H n 1 2 E n 1
E0
H1 2
Visualization enables the programmer to reduce cache misses
Visualization Enables the Programmer to Reduce Cache MissesKristof Beyls and Erik H.D’Hollander and Yijun YuElectronics and Information SystemsGhent UniversitySint-Pietersnieuwstraat41,Gent,Belgiumemail:{kristof.beyls,erik.dhollander,yijun.yu}@elis.rug.ac.beAbstractMany programs execution speed suffer from cache misses. These can be reduced on three different levels:the hard-ware level,the compiler level and the algorithm level. Much work has been done on the hardware level and the compiler level,however relatively little work has been done on assisting the programmer to increase the locality in his programs.In this paper,a method is proposed to visual-ize the locality which is not exploited by the cache hard-ware,based on the reuse distance metric.Visualizing the reuse distances allows the programmer to see the cache bottlenecks in its program at a single glance,which al-lows him to think about alternative ways to perform the same computation with increased cache efficiency.Fur-thermore,since the reuse distance is independent of cache size and associativity,the programmer will focus on op-timizations which increase cache effectiveness for a wide range of caches.As a case study,the cache behavior of the MCF program,which has the worst cache behavior in the SPEC2000benchmarks,is visualized.A simple op-timization,based on the visualization,leads to consistent speedups from24%to48%on different processors and cache architectures,such as PentiumII,Itanium and Alpha. KEY WORDSData cache,program visualization,reuse distance,program optimization,software tools1IntroductionThe execution time of many programs is dominated by cache stall time on current processors.In the future,this is going to aggravate due to the increasing gap between processor and memory speed.The processor speed is in-creasing by60%per year,while the memory speed only increases at about7%per year[6].This leads to a memory wall which doubles every two years.Currently,a processor can typically execute a thousand instructions while fetch-ing data from main memory.Therefore,in order to keep the processor from being data-starved,it must be assured that the data locality in the program is exploited maximally by the data cache hierar-chy.The two most occurring types of misses are the con-flict and the capacity misses.The conflict misses are those misses that occur because the associativity of the cache is too small.The capacity misses are those that exist because the size of the cache is too small.The optimization of the cache hierarchy utilization can be performed at three different levels:•At the hardware level,the cache hardware could be improved.Most of the proposed techniques in the lit-erature focus on reducing conflict misses by cheaply increasing the effective associativity of the cache.In order to decrease the capacity misses,the size of the cache should be increased.However,increasing the cache size makes it slower.Therefore,a tradeoff must be made between cache size and its response time.Currently,processors have a number of different cache levels,where thefirst cache level is small and fast and the levels below are increasingly larger and slower.•Since the capacity misses are hard to resolve at the hardware level,they should be focused at the com-piler level.At the compiler level,the conflict misses are diminished by improving the data layout,and ca-pacity misses are handled by increasing the locality of capacity misses.However,previous research[1] has shown that state-of-the-art compiler technology removes30%of the conflict misses and only1%of the capacity misses in numerical programs such as those in SPEC95fp.•A lot of cache misses exist,even after the hardware level has been optimized and the compiler has taken great effort to reduce them.Thefinal optimization level is the algorithm level,which is controlled by the programmer.In contrast to the extensive literature on cache hard-ware optimization and compiler optimizations for cache be-havior,relatively little work has been performed on helping the programmer to optimize its programs cache behavior. Therefore,in this paper,we focus on supporting the pro-grammer in his effort to reduce cache miss bottlenecks.Several studies on different benchmark suites have shown that capacity misses are the most dominant cate-gory of misses[9,1,3].However,as discussed above,at the hardware level and the compiler level,mostly the conflict misses are targeted.At the hardware level,capacity misses can only be reduced by making the cache larger,and gener-ally,slower.At the compiler level,capacity misses can bereduced,but only for regular array-based loops.Little com-piler work has been proposed to eliminate capacity missesfor pointer-based irregular programs.Because it is hard or impossible for the compiler to analyze or optimize a programs cache behavior,the job is delegated to the programmer.Of course,in order to be ef-fective,the following objectives should be reached:1.The cache behavior is not obvious from the sourcecode.Therefore,a tool should show the programmer where the real cache bottleneck in the program lays.The visualization of the cache behavior by the tool should be program-centric[14],so that the program-mer can relate the cache misses to program constructs.Also,if possible,the tool should give hints to the pro-grammer about how to resolve the bottlenecks.2.In the ideal case,the optimization should not be spe-cific to a single platform,but it should result in im-proved execution speed,irrespective of the precise cache structures or processor micro-architecture the program runs on.In order to reach thefirst goal,a tool should be de-vised which visualizes the cache behavior of the program. However,the amount of information about the cache be-havior that can be recorded is huge.For example,each access to the memory could be recorded as a cache hit or a cache miss.However,since a program typically accesses the memory hundreds of millions of times per second,it is unfeasible to throw all this information unfiltered to the programmer.Instead,the cache behavior should be mea-sured by a metric which allows to describe the cache bottle-necks accurately in a concise way.Ideally,the programmer should be able to identify the cache bottlenecks at a single glance.Furthermore,in order to reach the second goal,the metric which is used to visualize the cache behavior must indicate the cache behavior bottlenecks,independent from the precise cache structure implemented in the hardware. For example,it should be displayed irrespective of the pre-cise associativity of the cache or its exact size.These prop-erties are found in the reuse distance,which indicates cache behavior,independent from cache parameters such as asso-ciativity or size.The reuse distance metric is further discussed in sec-tion2.The measurement and the visualization of the cache behavior,based on the reuse distance metric is presented in section3.As a case study,the cache behavior of MCF, the program with the highest cache miss bottleneck in the SPEC2000benchmark is shown in section4.Based on the visualization,a small number of program transformations are proposed,which lead to a speedup of up to48%,on Ita-nium,PentiumII and Alpha-processors.A comparison to related work is made in section5,and a conclusion follows in section6.A23 1r r rFigure1.A memory access stream with indication of the reuses.A,W,X,Y and Z indicate the accessed memory location.The accesses to X,Z,Y and W are not part of a reuse pair,since W,X,Y and Z are accessed only once in the stream.The reuse distance of r1,r2 =4.The reuse distance of r2,r3 =0.The backward reuse distance of r1=∞,the backward reuse distance of r2=4.2Reuse DistanceSince the capacity misses are the dominant source of misses,and the hardware and compiler cannot reduce them very effectively,the programmer should focus on resolving those misses.The number of conflict misses is very depen-dent on both cache details,such as cache associativity,line size and cache size,and on compiler details such as how the data is layed out in the memory.Furthermore,the con-flict misses can be reduced substantially by the hardware and the compiler level.Therefore,we wish to only present the potential capacity misses to the programmer.The capacity misses can be represented by the reuse distance,irrespective of the actual cache size.The reuse distance is defined within the framework of the following definitions.Definition1.A reference is a read or a write in the source code,while a memory access is one particular execution of that read or write.A reuse pair r1,r2 is a pair of memory accesses in a memory access stream,which touch the same memory lo-cation,without intermediate accesses to that location.The reuse distance of a reuse pair r1,r2 is the number of unique memory locations accessed between references r1 and r2.Definition2.Consider the reuse pair r1,r2 .The back-ward reuse distance of r2is the reuse distance of r1,r2 . If there is no such pair,the backward reuse distance of r2 is∞.Example1.Figure1shows two reuse pairs in a short memory access stream.The reuse distance has the following property,which makes it an interesting metric for detecting capacity misses: Lemma1.In a fully associative LRU cache with n lines, an access with backward reuse distance d<n will hit.An access with backward reuse distance d≥n will miss. Proof.In a fully-associative LRU cache with n cache lines, the n most recently referenced memory lines are retained. When a reference has a backward reuse distance d,exactly d different memory lines were referenced previously.Ifcombine filtered dataand present it to the programmerto filter out the relevant data from the simulationby executinginstrumented binaryby compiler5the programmer thinks about ways to optimize it’s program, based on information provided by the visualizationFigure 2.Overview of the measurement,visualization and optimization cycle for cache optimization.d ≥n ,the referenced memory line is not one of the n most recently referenced lines,and consequently will not be found in the cache.Since all the cache misses in a fully associative cache are capacity misses,the backward reuse distance indicates what cache size is needed for a particular memory access to be a cache hit instead of a capacity miss.Furthermore,[1]showed that the reuse distance is also a good predic-tor of cache behavior for less associative caches,and even for direct mapped caches.Therefore,the reuse distance is a simple metric which,irrespective of cache parameters such as associativity or size,indicates the cache behavior of memory accesses.3Reuse pair visualizationThe different steps in the visualization and optimization process are shown in figure 2.First,the program that needs to be optimized is instrumented to measure the reuse dis-tances during the execution.In the second step,the instru-mented program is executed and the reuse distance is mea-sured.In the third step,the reuse distance information from the simulation is filtered,so that only those reuses leading to capacity misses are retained.In the fourth step,these long reuses are shown to the programmer,who can then start to think about ways to reduce the distance between use and reuse,in order to transform the capacity misses into cache hits.After optimizing his program,the programmer can measure it again,and try to resolve any left-over cache bottlenecks.The different steps are discussed in detail be-low.InstrumentationFirst,the memory access stream generated by the program is needed,so that the reuse pairs can be extracted from it.Furthermore,for every memory access,it is neces-sary to know which reference generated it,so that it can be tracked back to the source code.In our implementa-tion,we extended the ORC-compiler[5],so that for every instruction accessing the memory,such as loads,stores and prefetches,a function call is inserted.The memory address accessed and the identification of the instruction generating the memory access are given to the function as parameters.This instrumentation makes sure that the function is called for every memory access,and the necessary informa-tion about the memory location and the reference is given.SimulationThe instrumented program is linked with a library which implements the function which is called on every memory access.This function could just store the memory trace to disk.However,this would lead to an enormous trace file on disk,since typical programs access the memory bil-lions of times.Therefore,the trace is processed online.The backward reuse distance is calculated for the access,and the previous reference accessing the same location is looked up.For every pair of references in the program it is recorded how many reuse pairs with which reuse dis-tance were measured during the execution of the program.Only this histogram of reuse distances per pair of refer-ences retained,which reduces the amount of data needed to be stored on disk.In our implementation,the data is stored in an XML-format.A short example of the XML-data is shown in fig.3.Filtering &VisualizationLemma 1indicates that only those reuses which are larger than the cache size generate capacity misses.Therefore,the reuse pairs with a short reuse distance are eliminated,so that only the long reuses are leftover.It is exactly those long reuses which generate cache misses.The filtering will filter out those reuse distances which do not fit into the cache size.This is easily implemented with an XSLT-filter[13]which transforms the raw XML-data measured in the simulation step.The result of the filter on the example data in fig.3is shown in fig.4.After this,exactly the interesting information for the programmer has been extracted from the program.In or-der to increase the efficiency of the programmer,the data should be shown directly in the source code.In this way,the programmer can easily analyze the long reuse distances and the program constructs which lead to those long reuse distances.The long reuse distances are shown graphically by arrows between source and sink in the source code.In our prototype implementation,the VCG-graph layoutFigure5.Visualization of long-distance reuses in MCF,as produced by VCG.The visualization is a zoom of the locations where the majority of the long reuse distances occur.For48.09%of all long distance reuse pairs,thefirst access is generated by arc->ident on line190and the second access is generated by arc->ident on line186.Furthermore,For22.12%of the long distance reuse pairs,thefirst and second accesses are both generated by arc->ident on line186.So,70.21%of all capacity misses occur on the access of the identfield of the variable pointed to by arc on line186.<reference id="pbeampp.c/primal_bea_mpp:21"> <reuse><log2distance>16</log2distance><fromid>pbeampp.c/primal_bea_mpp:21</fromid><count>3310601</count></reuse><reuse><log2distance>17</log2distance><fromid>pbeampp.c/primal_bea_mpp:21</fromid><count>109607</count></reuse><reuse><log2distance>18</log2distance><fromid>pbeampp.c/primal_bea_mpp:21</fromid><count>513041</count></reuse><reuse><log2distance>19</log2distance><fromid>pbeampp.c/primal_bea_mpp:21</fromid><count>13477191</count></reuse><reuse><log2distance>20</log2distance><fromid>pbeampp.c/primal_bea_mpp:21</fromid><count>7218189</count></reuse></reference>Figure3.Example of some reuse distance data,recorded for the MCF program,beforefiltering.Only those reuses for which both thefirst and second access are generated by the21st memory instruction in the pbeampp.c sourcefile are shown here.The log2distancefield shows the log2 of the measured reuse distance,the countfield shows the number of times the reuse felt into this category.<reference id="pbeampp.c/primal_bea_mpp:21"> <reuse><log2distance>15</log2distance><fromid>pbeampp.c/primal_bea_mpp:21</fromid><count>24628629</count></reuse></reference>Figure4.The same reuse distance data as infigure3,after filtering with reuse distance≤15has been applied.This data leads to the edge with the22.12%-label in the visual-ization infig.5tool[7]was used to draw the long reuse distance arrows. An example of the resulting graph is shown infig.5. Program OptimizationThe previous steps were all automatically performed by the computer.Now,based on the measured reuse distances, it must be tried to reduce the distance between use and reuse for long reuse distances,which decreases the num-ber of capacity misses.In the introduction,it has been ar-gued that the compiler or the hardware cannot do this effec-tively.Therefore,programmer interaction is needed,since he knows how his program works,and how he can restruc-ture the program in order to reduce long reuse distances. An example of an optimization is shown in the case study, in the next section.for(;arc<stop_arcs;arc+=nr_group){/*prefetch arc!!*/#define PREFETCH_DISTANCE8PREFETCH(arc+nr_group*PREFETCH_DISTANCE);if(arc->ident>BASIC){red_cost=bea_compute_red_cost(arc);if(bea_is_dual_infeasible(arc,red_cost)){basket_size++;perm[basket_size]->a=arc;perm[basket_size]->cost=red_cost;perm[basket_size]->abs_cost=ABS(red_cost);}}}Figure6.The optimized code for the MCF program.A single prefetch instruction was inserted.4Case StudyHere,the long reuse distances for the MCF program are shown and the program is optimized.MCF is the pro-gram from the SPEC2000benchmark which has the highest cache bottleneck.On an Itanium processor,even after full compiler optimization,this processor is stalled waiting for data to return from the memory about90%of the execution time.Infig.5,the majority of the cache misses are shown in the code.Thefigure shows that about70%of the capac-ity misses are generated by a single load instruction on line 186.The best way to solve those capacity misses would be to shorten the distance between use and reuse.However, after analyzing the code a bit further,it is obvious that the reuse of arc-objects do not occur within a single iteration of the for-loop on line184.Additionally,the reuse doesn’t even occur between iterations of the outermost loop which goes from line181to line206.The reuse occurs between different invocations of this function.So,bringing use and reuse together would need a thorough understanding of the complete program,which we do not have,since we didn’t write the program ourselves.Therefore,instead of remov-ing the capacity misses,we tried to hide them using data prefetching.We decided to try to prefetch the data that is touched by the arc-pointer on line186.The optimized code is shown infigure6.The optimized code was compiled on3different pro-cessor architectures:PentiumII,Itanium and Alpha21264. For the PentiumII and the Itanium,the Intel compiler was used,for the Alpha the Alpha compiler was used.For all the experiments,the highest level of compiler optimization was chosen.The execution times and speedups of the orig-inal and optimized codes are shown in table2.The table shows that the insertion of two lines into the source code was able to speed up the program between24%and48% on CISC(PentiumII),RISC(Alpha)and EPIC(Itanium)pro-processor L1L2L3(size,assoc)(size,assoc)(size,assoc) PentiumII(16KB,4)(256KB,4)not present Itanium(16KB,4)(96KB,6)(2MB,4) Alpha21264(64KB,2)(8MB,1)not present Table1.Cache sizes and associativity for the different pro-cessors.processor original optimized speedup(seconds)(seconds)PentiumII147s105s40%Itanium98s66s48%Alpha2126456s45s24%Table2.The execution times and speedup of the original and the optimized MCF-program,on three different pro-cessor architectures.cessors.5Related WorkMost work on visualizing performance bottlenecks for the programmer has been done for parallel programs[15,4,11, 8,10].These visualizations mostly focus on visualizing the communication patterns between the parallel parts in the program.In contrast to visualization for parallel pro-grams,relatively little work has been proposed to visualize cache bottlenecks.In[2],the cache behavior is visualized through statistical histograms of the cache lines.The his-tograms show which cache lines are most frequently used. In[12],the cache lines are visualized,and the contents of that cache line are indicated by a color.Every time the con-tents of an address is copied into a cache line,the color of that cache line is updated so that it represents the cached ad-dress.Both[2]and[12]visualize the cache behavior cache-centric,i.e.the underlying cache structure and its operation is visualized.This doesn’t allow to clearly visualize the cache behavior of the whole program,because the cache contents is frequently refreshed and the huge data space of a program is observed through the tiny cache window. This problem is avoided in[14],where the cache behav-ior is visualized program-centric.The program locality is shown by assigning a single pixel to every memory access. The color of the pixel indicates whether the correspond-ing access was a hit or a cold,conflict or capacity miss. Furthermore,it is possible to relate the visualized mem-ory trace with the source code.However,this visualization is only feasible for programs which generate short mem-ory access traces.Furthermore,since the hits and misses are recorded for a particular cache,the programmer is not steered to optimize the locality independent of the cache parameters.In contrast,this work is able to visualize mem-ory access traces of arbitrary length.Furthermore,sincethe reuse distance is independent of the precise cache pa-rameters,it allows the programmer to clearly see the cache bottlenecks common to a wide range of caches.6ConclusionThe discrepancy between processor and memory speed af-fects processor performance substantially.On top of that, the speed difference is doubling every two years.There-fore,all possible means must be used to diminish the speed degradation due to cache misses.In the past,much work has been done on improving hardware and compiler tech-niques to reduce cache misses.However,there are still a substantial number of cache misses left over.Especially the capacity misses are hardly reduced.In this paper,it is proposed to complement the hard-ware and compiler techniques with programmer-driven program optimizations to improve the data locality.How-ever,the cache misses are not obvious from the source code,and therefore a tool must be devised which clearly indicates the causes of poor cache behavior in the source code.In order to make sure that the indicated cache bottle-necks are the bottlenecks for a wide range of cache config-urations,the reuse distance was used to measure the pro-grams data locality.It has the advantage that it is indepen-dent of cache size and associativity,and it predicts cache behavior for a wide range of cache architectures.The visu-alization of the long reuse distances steers the programmer to locality optimizations which are independent of the un-derlying cache.As a case study,the MCF program from SPEC2000was studied.A simple optimization,based on the visualization,resulted in a speedup between24%and 48%,on CISC,RISC and EPIC processors with different underlying cache architectures,even after full compiler op-timization.This shows that the reuse distance visualiza-tion gives a good insight in the poor locality patterns in the program,and enables portable and platform-independent cache optimizations.AcknowledgementsThis research was supported by the Flemish Institute for promotion of scientific and technological research in the industry(IWT).References[1]K.Beyls and E.H.D’Hollander.Reuse distanceas a metric for cache behavior.In Proceedings of PDCS’01,2001.[2]R.Bosch,C.Stolte,D.Tang,J.Gerth,M.Rosenblum,and P.Hanrahan.Rivet:Aflexible environment for computer systems puter Graphics-US,34(1):68–73,Feb.2000.[3]M.D.Hill and A.J.Smith.Evaluating associativityin CPU caches.IEEE Transactions on Computers, 38(12):1612–1630,Dec.1989.[4]W.M.Jr.,T.J.LeBlanc,and A.Poulos.Waitingtime analysis and performance visualization in carni-val.In ACM SIGMETRICS Symp.on Parallel and Distributed Tools,page1,May1996.[5]Open research compiler./projects/ipf-orc.[6]D.A.Patterson and puter Ar-chitecture–A Quantitative Approach.Morgan Kauf-mann Publishers,Los Altos,CA94022,USA,second edition,1995.[7]G.Sander.Graph layout through the vcg tool.In DI-MACS International Workshop GD’94,Proceedings, Lecture Notes in Computer Science894,pages194–205,1995.[8]S.R.Sarukkai,D.Kimelman,and L.Rudolph.Amethodology for visualizing performance of loosely synchronous programs.Journal of Parallel and Dis-tributed Computing,1993.[9]R.A.Sugumar and S.G.Abraham.Efficient simu-lation of caches under optimal replacement with ap-plications to miss characterization.In B.D.Gaither, editor,Proceedings of the ACM Sigmetrics Confer-ence on Measurement and Modeling of Computer Systems,volume21-1of Performance Evaluation Re-view,pages24–35,New York,NY,USA,May1993.ACM Press.[10]B.Topol,J.Stasko,and V.Sunderam.Pvanim:Atool for visualization in network computing environ-ments.Concurrency:Practice&Experience,page 1197,1998.[11]S.J.Turner and W.Cai.The‘logical clock’approachto the visualisation of parallel programs.In Proceed-ings of Workshop on Monitoring and Visualization of Parallel Processing System,1992.[12]E.Vanderdeijl,O.Temam,E.Granston,and G.Kan-bier.The cache visualization tool.IEEE Computer, 30(7):71,1997.[13]W3C.Xsl transformations(xslt)version 1.0./TR/xslt.[14]Y.Yu,K.Beyls,and E.D’Hollander.Visualizing theimpact of cache on the program execution.Ingezon-den naar Information Visualization2001.[15]O.Zaki,E.Lusk,W.Gropp,and D.Swider.To-ward scalable performance visualization with Jump-shot.High Performance Computing Applications, 13(2):277–288,Fall1999.。
Autodesk VR AR技术在工具路径和探头路径定义和可视化中的应用说明书
MFG124360Exploring Toolpath and Probe Path Definition and Visualization in VR/ARZhihao CuiAutodeskDescriptionVisualizing and defining 3D models on a 2D screen has always been a challenge for CAD and CAM users. Tool paths and probe paths add other levels of complexity to take into consideration, as the user cannot fully appreciate the problem on a 2D viewer. Imagine yourself trying to define a tool axis on a complex shape—it’s very hard to take every single aspect of the shape into account, except by guessing, calculating, and retrying repeatedly. With augmented reality (AR) and virtual reality (VR) technologies, the user gains the ability to inspect and define accurate 3D transformations (position and rotation) for machine tools in a much more natural way. We will demonstrate one potential workflow to address this during the class, which includes how to export relevant models from PowerMill software or PowerInspect projects; how to reconstruct, edit, and optimize models in PowerShape software and 3ds Max software; and eventually how to add simple model interactions and deploy them in AR/VR environments with game engines like Stingray or Unity.SpeakerZhihao is a Software Engineer in Advanced Consulting team within Autodesk. His focus for AR and VR technologies is in manufacturing industry and he wishes to continuously learn and contribute to it.Data PreparationThe first step of the journey to AR or VR is generating the content to be visualized. Toolpath and probe path need to be put into certain context to be meaningful, which could be models for the parts, tools, machines or even the entire factory.PowerMill ExportFigure 1 Typical PowerMill ProjectPartsExporting models of the part is relatively simple.1. Choose the part from the Explorer -> Models -> Right click on part name -> ExportModel…2. Follow the Export Model dialog to choose the name with DMT format1.1DGK file is also supported if additional CAD modification is needed later. See Convert PowerMill part mesh on page 7Figure 2 PowerMill – Export ModelToolTool in PowerMill consists three parts – Tip, Shank and Holder.To export the geometry of the tool, type in the macro commands shown in Figure 3, which would generate STL files2 contains the corresponding parts. Three lines of commands3 are used instead of exporting three in one file (See Figure 11), or one single mesh would be created instead of three which will make the coloring of the tool difficult.EDIT TOOL ; EXPORT_STL TIP "powermill_tool_tip.stl"EDIT TOOL ; EXPORT_STL SHANK "powermill_tool_shank.stl"EDIT TOOL ; EXPORT_STL HOLDER "powermill_tool_holder.stl"Figure 3 PowerMill Macro - Export ToolToolpathToolpath is the key part of the information generated by a CAM software. They are created based on the model of the part and various shapes of the tool for different stages (e.g. roughing, polishing, etc.). Toolpaths are assumed to be fully defined for visualization purposes in this class, and other classes might be useful around toolpath programming, listed on page 15. Since there doesn’t exist a workflow to directly stream data into AR/VR environment, a custom post-processor4 is used to extract minimal information needed to describe a toolpath, i.e. tool tip position, normal direction and feed rate (its format is described in Figure 17).The process is the same way as an NC program being generated for a real machine to operate. Firstly, create an NC program with the given post-processor shown in Figure 4. Then grab and drop the toolpath onto the NC program and write it out to a text file shown in Figure 5.2DDX file format can also be exported if geometry editing is needed later in PowerShape3 The macro is also available in addition al material PowerMill\ExportToolMesh.mac4 The file is in additional material PowerMill\simplepost_free.pmoptzFigure 4 PowerMill Create NC ProgramFigure 5 PowerMill Insert NC ProgramPowerInspect ExportFigure 6 Typical PowerInspect OMV ProjectCADCAD files can be found in the CAD tab of the left navigation panel. The model can be re-processed into a generic mesh format for visualization using PowerShape, which is discussed in Section Convert PowerMill part mesh on page 7.Figure 7 Find CAD file path in PowerInspectProbeDefault probe heads are installed at the following location:C:\Program Files\Autodesk\PowerInspect 2018\file\ProbeDatabaseCatalogueProbes shown in PowerInspect are defined in Catalogue.xml file and their corresponding mesh files are in probeheads folder. These files will be used to assemble the probe mentioned in Section Model PowerInspect probe on page 9.Probe toolAlthough probe tool is defined in PowerInspect, they cannot be exported as CAD geometries to be reused later. In Model PowerInspect probe section on page 9, steps to re-create the probe tool will be introduced in detail based on the stylus definition.Probe pathLike toolpath in PowerMill, probe path can be exported using post processor5 to a generic MSR file format, which contains information of nominal and actual probing points, measuring tolerance, etc.This can be achieved from Run tab -> NC Program, which is shown in Figure 8.Figure 8 Export Probe Path from PowerInspect5 The file is in additional materialPowerInspect\MSR_ResultsGenerator_1.022.pmoptzModelling using PowerShapeConvert PowerMill part meshDMT or DGK files can be converted to mesh in PowerShape to FBX format, which is a more widely adopted format.DMT file contains mesh definition, which can be exported again from PowerShape after color change and mesh decimation if needed (discussed in Section Exporting Mesh in PowerShape on page 10).Figure 9 PowerShape reduce meshDGK file exported from PowerMill / PowerInspect is still parametric CAD model not mesh, which means further editing on the shape is made possible. Theoretically, the shape of the model won’t be changed since the toolpath is calculated based on the original version, but further trimming operations could be carried here to keep minimal model to be rendered on the final device. For example, not all twelve blades of the impeller may be needed to visualize the toolpath defined on one single surface. It’s feasible to remove ten out of the twelve blades and still can verify what’s going on with the toolpath defined. After editing the model, PowerShape can convert the remaining to mesh and export to FBX format as shown below.Figure 10 Export FBX from PowerShapeModel PowerMill toolImport three parts of the tool’s STL files into PowerShape, and change the color of individual meshes to match PowerMill’s color scheme for easier recognition.Figure 11 PowerShape Model vs PowerMill assembly viewBefore exporting, move the assembled tool such that the origin is at the tool tip and oriented z-axis upwards, which saves unnecessary positional changes during AR/VR setup. Then follow Figure 10 to export FBX file from PowerShape to be used in later stages.Model PowerInspect probeTake the example Probe OMP400. OMP400.mtd file6 contains where the mesh of individual components of the probe head are located and their RGB color. For most of the probe heads, DMT mesh files will be located in its subfolder. They can be dragged and dropped into PowerShape in one go to form the correct shape, but all in the same color (left in Figure 14). To achieve similar looking in PowerInspect, it’s better to follow the definition fi le, and import each individual model and color it according to the rgb value one by one (right in Figure 14).<!-- Head --><machine_part NAME="head"><model_list><dmt_file><!-- Comment !--><path FILE="probeheads/OMP400/body.dmt"/><rgb R="192"G="192"B="192"/></dmt_file>Figure 12 Example probe definition MTD fileFigure 13 PowerShape apply custom colorFigure 14 Before and after coloring probe headFor the actual probe stylus, it’s been defined in ProbePartCatalogue.xml file. For theTP20x20x2 probe used in the example, TP20 probe body, TP20_STD module and M2_20x2_SS stylus are used. Construct them one by one in the order of probe body, module and stylus, and each of them contains the definition like the below, which is the TP20 probe body.6C:\Program Files\Autodesk\PowerInspect 2018\file\ProbeDatabaseCatalogue<ProbeBody name="TP20"from_mounting="m8"price="15.25"docking_height="0"to_mounting="AutoMagnetic"length="17.5"><Manufacturer>Renishaw</Manufacturer><Geometry><Cylinder height="14.5"diameter="13.2"offset="0"reference_length="14.5" material="Aluminium"color="#C8C8C8"/><Cylinder height="3.0"diameter="13.2"offset="0"reference_length="3.0" material="Stainless"color="#FAFAFA"/></Geometry></ProbeBody>Figure 15 Example TP20 probe body definitionAlmost all geometries needed are cylinder, cone and sphere to model a probing tool. Start with the first item in the Geometry section, and use the parameters shown in the definition to model each of the geometries with solid in PowerShape and then convert to mesh. To make the result look as close as it shows in PowerInspect, color parameter can also be utilized (Google “color #xxx” to convert the hex color).Figure 16 Model PowerInspect ToolU nlike PowerMill tool, PowerInspect probe’s model origin should be set to the probe center instead of tip, which is defined in the MSR file. But the orientation should still be tuned to be z-axis facing upwards.DiscussionsExporting Mesh in PowerShapeIn PowerShape, there are different ways that a mesh can be generated and exported. Take the impellor used in PowerMill project as an example, the end mesh polycount is 786,528 if it’s been converted from surfaces to solid and then mesh with a tolerance set to 0.01. However, if the model was converted straight from surface to mesh, the polycount is 554,630, where the 30% reduce makes a big impact on the performance of the final AR/VR visualization.Modifying the tolerance could be another choice. For visualization purposes, the visual quality will be the most impactable factor of choosing the tolerance value. If choosing the value is set too high, it may introduce undesired effect that the simulated tool is clipped into the model in certain position. However, setting the tolerance too small will quickly result in a ridiculous big mesh, which will dramatically slow down the end visualization.Choosing the balance of the tolerance here mainly depends on what kind of end devices will the visualization be running on. If it will be a well-equipped desktop PC running VR, going towards a large mesh won’t ne cessarily be a problem. On the other hand, if a mobile phone is chosen for AR, a low polycount mesh will be a better solution, or it can be completely ignored as a placeholder, which is discussed in Section On-machine simulation on page 12.Reading dataSame set of model and paths data can be used in multiple ways on different devices. The easiest way to achieve this is through game engines like Stingray or Unity 3D, which has built-in support for rendering in VR environment like HTC Vive and mobile VR, and AR environment like HoloLens and mobile AR.Most of the setup in the game engine will be the same for varies platform, like models and paths to be displayed. Small proportion will need to be implemented differently for each platform due to different user interaction availability. For example, for AR when using HoloLens, the user will mainly control the application with voice and gesture commands, while on the mobile phones, it will make more sense to offer on-screen controls.For part and tool models, FBX files can be directly imported into the game engines without problem. Unit of the model could be a problem here, where export from PowerShape is usually in millimeter but units in game engines are normally in meters. Unit change in this case could result in a thousand times bigger, which may cause the user seeing nothing when running the application.For toolpath data, three sets of toolpath information are exported from PowerMill with the given post-processor, i.e. tool tip position, tool normal vector and its feed rate. They can be read line by line, and its positions can be used to create toolpath lines. And together with the normal vector and feed rates, an animation of the tool head can be created.Position(x,y,z) Normal(i,j,k) Feed rate33.152,177.726,52.0,0.713,-0.208,0.67,3000.0Figure 17 Example toolpath output from PowerMillFor probe path data, similar concept could be applied with an additional piece of information7–actual measured point, which means not only the nominal probe path can be simulated ahead of time, but also the actual measured result could be visualized with the same setup.7 See page 14 for MSR file specification.STARTG330 N0 A0.0 B0.0 C0.0 X0.0 Y0.0 Z0.0 I0 R0G800 N1 X0 Y0 Z25.0I0 J0 K1 O0 U0.1 L-0.1G801 N1 X0.727 Y0.209 Z27.489 R2.5ENDFigure 18 Example probe path output from PowerInspectUse casesOn-machine simulationWhen running a new NC program with a machine tool, it’s common to see the machine operator tuning down the feed rate and carefully looking through the glass to see what is happening inside the box. After several levels of collision checking in CAM software and machine code simulator, why would they still not have enough confidence to run the program?Figure 19 Toolpath simulation with AR by Hans Kellner @ AutodeskOne potential solution to this problem is using AR on the machine. Since how the fixture is used nowadays is still fairly a manual job constrained by operator’s experience, variations of fixtures make it a very hard process to verify ahead of machining process. Before hitting the start button for the NC program, the operator could start the AR simulation on the machine bed, with fixtures and part held in place. It will become an intuitive task for the operator to check for collisions between part of the virtual tool and the real part and fixtures. Furthermore, a three-second in advance virtual simulation of the tool head can be shown during machining process to significantly increase the confidence and therefore leave the machine always running at full speed, which ultimately increases the process efficiency.Toolpath programming assistanceProgramming a toolpath within a CAM software can sometimes be a long iterative try and error process since the user always imagines how the tool will move with the input parameters. Especially with multi-axis ability, the user will often be asked to provide not only the basic parameters like step over values but also coordinate or direction in 3D for the calculation to start. Determining these 3D values on a screen becomes increasingly difficult when othersurfaces surround the places needed to be machined. Although there are various ways to let the user to navigate to those positions through hiding and sectioning, workarounds are always not ideal and time-consuming. As shown in Figure 20, there’s no easy and intuitive way to analyze the clearance around the tool within a tight space, which is one of the several places to be considering.Figure 20 Different angles of PowerMill simulation for a 5-axis toolpath in a tight spaceTaking the example toolpath in PowerMill, a user will need to recalculate the toolpath after each modification of the tool axis point, to balance between getting enough clearance8and achieving better machining result makes the user and verify the result is getting better or worth. However, this workflow can be changed entirely if the user can intuitively determine the position in VR. The tool can be attached to the surface and freely moved by hand in 3D, which would help to determine the position in one go.Post probing verificationProbing is a common process to follow a milling process on a machine tool, making sure the result of the manufacturing is within desired tolerance. Generating an examination report in PowerInspect is one of the various ways to control the quality. However, what often happens is that if an out of tolerance position is detected, the quality engineer will go between the PC screen and the actual part to determine what is the best treatment process depending on different kind of physical appearance.8 Distance between the tool and the partFigure 21 Overlay probing result on to a physical partOverlaying probing result with AR could dramatically increase the efficiency by avoiding this coming back and forth. Same color coded probed point can be positioned exactly at the place of occurrence, so that the surrounding area can be considered separately. The same technique could also be applied to scanning result, as shown in Figure 22.Figure 22 Overlaying scanning result on HoloLens by Thomas Gale @ AutodeskAppendixReference Autodesk University classesPowerMillMFG12196-L: PowerMILL Hands on - Multi Axis Machining by GORDON MAXWELL MP21049: How to Achieve Brilliant Surface Finishes for CNC Machining by JEFF JAJE MSR File format9G330 Orientation of the probeG800 Nominal valuesG801 Measured valuesN Item numberA Rotation about the X axisB Rotation about the Y axisC Rotation about the Z axisXYZ Translations along the X, Y and Z axes (these are always zero)U Upper toleranceL Lower toleranceO OffsetI and R (in G330) just reader valuesR (in G801) probe radius9 Credit to Stefano Damiano @ Autodesk。
Problem description
Preoperative Insertability Analysis and Visualization of Custom Hip Implant Designs
IBM T.J. Watson Research Center P.O. Box 704, Yorktown Heights, NY 10598, USA
solidworks气流仿真步骤
solidworks气流仿真步骤英文回答：As an engineer who has experience with Solidworks, I can provide a step-by-step guide for simulating airflow using this software. The first step is to create a new project in Solidworks and select the "Flow Simulation" option. Once the project is created, you can start by defining the boundaries of the airflow simulation. This involves specifying the inlet and outlet conditions, as well as any walls or obstacles that may affect the flow. For example, if you are simulating the airflow over a car, you would define the car's surface as a wall and the surrounding air as the inlet and outlet.After defining the boundaries, the next step is to set up the computational domain. This involves specifying the volume in which the airflow will be simulated. In the case of the car example, the computational domain would encompass the space around the car where the airflow is ofinterest. Solidworks provides tools for easily creatingthis computational domain based on the defined boundaries.Once the computational domain is set up, the next step is to define the fluid properties. This includes specifying the type of fluid (e.g. air, water, etc.), as well as its temperature, pressure, and other relevant properties. For the airflow over a car, the fluid properties would be those of the surrounding air. Solidworks allows for easy input of these properties through its user-friendly interface.With the boundaries, computational domain, and fluid properties defined, the next step is to mesh the computational domain. Meshing involves dividing the computational domain into small, discrete elements over which the airflow will be simulated. This is a crucial step as the accuracy of the simulation depends on the quality of the mesh. Solidworks provides tools for generating high-quality meshes with ease.Once the mesh is generated, the next step is to set up the simulation parameters. This involves specifying thetype of analysis (e.g. steady-state or transient), the solver settings, and any other relevant parameters. For the airflow over a car, a steady-state analysis would be appropriate as the airflow is not expected to changerapidly over time.After setting up the simulation parameters, the final step is to run the simulation and analyze the results. Solidworks provides tools for visualizing the airflow patterns, pressure distribution, velocity profiles, and other relevant data. This allows engineers to gain valuable insights into the behavior of the airflow and make informed design decisions.中文回答：作为一名有着Solidworks经验的工程师，我可以提供使用这款软件进行气流仿真的逐步指南。
基站（BTS）最短路径搜索应用程序的设计和开发：A 算法说明书
The Shortest Path Search Application for Base Transceiver Station (BTS) Using A* AlgorithmIkhthison Mekongga 1 Aryanti Aryanti 2,3,*1 Computer Engineering, Politeknik Negeri Sriwijaya, Palembang, Indonesia 2Electrical Engineering, Politeknik Negeri Sriwijaya, Palembang, Indonesia 3Electrical Engineering, Southern Taiwan University of science and Technology, Tainan, Taiwan *Corresponding author. Email:ABSTRACTLooking for the shortest path to a place is very necessary, especially when there is damage that requires immediate repair. This paper shows the design and development of an application of the shortest path search for Base Transceiver Station (BTS) using the A* algorithm. It has been designed an application that can help technicians in optimizing the distance to the base transceiver station (BTS) in case of damage and maintenance. In designing the Google Maps API (Application Programming Interface) system, the Global Positioning System (GPS), the Android SDK (Software Development Kit) has been used. A* algorithm was also successfully implemented. The result shows that there is no difference between the results of the shortest path produced by the application or the results of manual calculation. The shortest route is 0-3-1-2 which is 24.1km. It was chosen from the starting position BTS 37 -BTS 2 -BTS 29.Keywords: Shortest Path, Application, BTS, A* Algorithm1. INTRODUCTIONThe number of Base Transceiver Station (BTS) continues to increase along with the increase in communication needs. To meet customer needs and provide the best service, GCI Science & Technology Co. Ltd Palembang collaboration with other companies working on several operator projects in Indonesia. One of them is a maintenance project for Base Transceiver Station (BTS) cellular telephone operators spread throughout the city of Palembang. So that the signal quality of the Base Transceiver Station (BTS) network is maintained, GCI Science & Technology Co, Ltd must always check and support the Base Transceiver Station (BTS). Therefore, an application is needed to find the shortest base transceiver station (BTS) that can run on the Android platform so that it can help technicians in optimizing the distance to the location of theBase Transceiver Station (BTS) in case of damage and maintenance.Previous research related is A Poorva, R Gautam, and Rahul Kala [1] implemented A* algorithm to plan the path for the movement of a team of robots from source to goal for accomplishing a task. The removal ofa group of robots in a chain in a mapped environment successfully carried out using the proposed algorithm. Shrikant NA and Selvakumar AA. [2] proposed the A* algorithm in autonomous robots-A to find the optimal path for robots to avoid collisions. A* algorithm works by using a map, trying to find the track with the shortest route that has the lowest probability of collision with its surroundings.M Zikky. [3] presented Navigation Mesh (NavMesh) pathfinding as the alternative of Artificial Intelligent for Ghosts Agent on the Pacman Game. NavMesh implemented the A* algorithm and examined in the Unity 3D game engine.P Mehta et all. [4] proposed A* algorithms for pathfinding in computer games to avoid obstacles cleverly and seek the most efficient path between two endpoints. A* algorithm provides an optimal solution to the pathfinding problem when compared to Dijkstra's algorithm and the Greedy Best-First-Search algorithm. F Duchon et all. [5] design path planning of a mobile robot based on a grid map with functional and reliable reactive navigation and SLAM. A* algorithmProceedings of the 4th Forum in Research, Science, and Technology (FIRST-T1-T2-2020)modification carried out which focuses on computational time and path optimality.G Elizebeth Mathew. [6] presented A* algorithms for pathfinding in video games. It is solutions for pathfinding which results in a higher-quality path using less time and memory.Overall, the authors propose the A* algorithm to be used to find the path with the shortest route. A* algorithm applied in various fields including robotics, games, computer games, etc. A* algorithm provides an optimal solution to the pathfinding problem. However, no research applies the A star Algorithm to search for BTS.In this study, we design an application of the shortest path search for Base Transceiver Station (BTS) using the A* algorithm. In designing the Google Maps API (Application Programming Interface) system, the Global Positioning System (GPS), the Android SDK (Software Development Kit) used. We hope this can bea solution in optimizing the distance to the Base Transceiver Station (BTS) location if there are damage and maintenance.2. APPLICATION SYSTEM DESIGNThe proposed system designed application for searching the shortest path of Base Transceiver Station (BTS) Location using A* algorithm. It can help technicians in optimizing the distance to the Base Transceiver Station (BTS) location in case of damage and maintenance.It found that currently, there is no Base Transceiver Station (BTS) route search application by using the A* algorithm. A* algorithm is widely used in robotics, computer games, etc. [2,4,5]. A* algorithm used for pathfinding in-game AI, vehicle navigation systems but none of them targeted for Base Transceiver Station (BTS). Flowchart diagram system, as shown in Figure 1.StartInput BTSNameAlgorithm ARoute foundSearch analysisGet the routeShow RouteEndShortest route searchFigure 1. Flowchart DiagramGoogle Maps API (application programminginterface) is a computing interface commonly used by programmers to obtain geo-referenced informationbecause Google Maps API provides a tool for quicklyvisualizing map data [7,8]. APIs (application programming interfaces) can simplify programming byonly exposing objects or actions that developers need[7,8]—the API written for the Javascript programmingof websites.GPS is a navigation system based on the time andposition known from satellites [9]. Nowadays, GPSreceivers included in many commercial products, suchas automobiles, smartphones, exercise watches, and GISdevices. GPS devices can work when there is anexcellent connection to the satellite. GPS devices alsouse several types of location caching to speed up GPS detection. GPS devices can quickly determine whatsatellites are available when scanning GPS signals by remembering previous locations.Currently, the Android SDK build tool y usedbecause of its ability to debug, build, run and testAndroid applications and can work from the commandline or IDE (i.e. Eclipse or Android Studio) [10]. Application designed using Android studio.Algorithm A* is a combination of heuristic searchand search based on the shortest route applied to ametric or topology [5,11]. The formula for this algorithm:(1)Where h(n) is heuristic distance and g(n) is thelength of the path from the first state to the destinationstate. The advantages of this A* algorithm are thedistances can be modified, adapted and added to otherdistances [5].3. RESULT AND DISCUSSIONWe implemented the proposed application system, screen display starting from the application of determining the shortest route to find the location of the Base Transceiver Station (BTS) in the city of Palembang as shown in Figure 2.Figure 2 Display start the application In figure 2, the Base Transceiver Station (BTS) folder menu is used for the search process for the shortest path to find the location of the Base Transceiver Station (BTS). The menu consists of a map of the Base Transceiver Station (BTS) in Palembang, the BTS damage input menu, and the A * algorithm menu.Figure 3 shows the location of the Base Transceiver Station (BTS), which is the destination, where 128 BTS are belonging to XL and three operators scattered throughout the city of Palembang.Figure 3. Display the BTS folder menu Base Transceiver Station (BTS) damage input menu display used to input Base Transceiver Station (BTS) names that need to be done for maintenance and repairs, as shown in Figure 4 and Figure 5.Figure 4. Display the BTS damage input menuFigure 5. Display menu A*We tried 3 Examples of determining the shortest route in BTS 2, BTS 29, and BTS 37, as shown in Figure 6. The application worked to find the fastest way to BTS 2, BTS 29, and BTS 37 by applying the A * algorithm, as shown in Figure 7.Figure 6. Display of BTS 2, BTS 29, and BTS 37 inputsFigure 7. Display the shortest route to BTS 2, BTS 29, and BTS 37 by applying the A * algorithm Table 1. Value of route costs between BTS 2 nodes,No Start Node Destination NodeDistance (km)1 0 (StartPosition)1 (BTS 2)12 km2 0 (StartPosition)2 (BTS 29)9,0 km3 0 (StartPosition)3 (BTS 37)9,8 km4 1 (BTS 2) 3 (BTS 37)5,4 km5 3 (BTS 37) 1 (BTS 2)6,7 km6 3 (BTS 37) 2 (BTS 29)8,1 km7 2 (BTS 29)3(BTS 37)9,1 km8 2 (BTS 29) 1 (BTS 2)9,9 km9 1 (BTS 2) 2 (BTS 29)6,6 kmThe value of route costs between BTS 2 nodes, BTS 29, and BTS 37 tabulated in Table 1. The closest BTS distance is 5.4 km, and the farthest BTS distance is 9.9 km, which results made, as shown in Figure 8. This figure is the value of route costs and weighted distance graphs between BTS 2, BTS 29, and BTS 37 nodes.Figure 8. Weighted graph the distance between BTS 2,BTS 29, and BTS 370-1,f(n)=g(n)+h(n)= 12+1=130-2, f(n)=g(n)+h(n)=9,0+1=100-3,f(n)=g(n)+h(n)=9,8+1=10,80-1-2,f(n)=g(n)+h(n)= 18,6+1=19,60-1-3,f(n)=g(n)+h(n)= 17,4+1=18,40-2-1,f(n)=g(n)+h(n)= 18,9+1=19,90-2-3,f(n)=g(n)+h(n)= 18,1+1=19,10-3-1,f(n)=g(n)+h(n)= 16,5+1=17,50-3-2,f(n)=g(n)+h(n)= 17,9+1=18,90-1-2-3,f(n)=g(n)+h(n)= 27,7+1=28,70-1-3-2,f(n)=g(n)+h(n)= 25,5+1=26,50-2-1-3,f(n)=g(n)+h(n)= 24,3+1=25,30-2-3-1,f(n)=g(n)+h(n)= 24,8+1=25,80-3-1-2,f(n)=g(n)+h(n)= 23,1+1=24,10-3-2-1,f(n)=g(n)+h(n)= 27,8+1=28,8 Figure 9. Graph of A * algorithmIn Figure 9. the results of the manually A* algorithm. The shortest route is 0-3-1-2, which is 24.1km. It can be said that the quickest way chosen from the current technical position is the starting position - BTS 37 - BTS 2 - BTS 29 that is as far as 24.1 km.4. CONCLUSIONApplication of the shortest path search for the Base Transceiver Station (BTS) using the A* algorithm has been successfully designed. It produces the same indicator between the shortest path results generated by the android application with the shortest path results generated by calculations manually using the theory of algorithm A*. The speed of the application in processing data and finding the shortest path is very dependent on the quality of the internet telephone network used.In the future, we also want to modify our application system. Determining the best and fastest route is not only the shortest distance that counts, but also consider other variables such as road congestion so that it can predict the estimated time taken.AUTHORS’ CONTRIBUTI ONSIkhthison Mekongga conceived, designed, searches literature, analyzed data, and drafted the manuscript. Aryanti Aryanti supervised the analysis, reviewed the script, and contributed to the discussion. ACKNOWLEDGMENTSWe thank to VeraREFERENCES[1] A Poorva, R Gautam and Rahul Kala. 2018 MotionPlanning for a Chain of Mobile Robots Using A* and Potential Field. Intelligent system in robotic.Robotics Journal. 7(2), 20 MDPI.[2] Shrikant NA and Selvakumar AA. 2018Implementation of A* Algorithm to Autonomous Robots-A Simulation Study. Journal Engineering Technology. 1(3): 555564.[3] Moh. Zikky. 2016 Review of A* (A Star)Navigation Mesh Pathfinding as the Alternative of Artificial Intelligent for Ghosts Agent on the Pacman Game. EMITTER International Journal of Engineering Technology. Vol. 4, No. 1, pp 141-149[4] P Mehta, H Shah, S Shukla, S Verma. A Review onAlgorithms for Pathfinding in Computer Games.2015 IEEE Sponsored Intl Conf on Innovations in Information Embedded and Communication Systems.[5] F Duchon, A Babinec, M Kajan, P Beno, M Florek,T Fico, L Jurisica. 2014 Path planning with modified A star algorithm for a mobile robot.ScienceDirect. Elsevier Ltd. Procedia Engineering 96, pp 59 – 69[6] G Elizebeth Mathew. 2015 Direction BasedHeuristic for Pathfinding In Video Games.ScienceDirect. Elsevier Ltd. Procedia Computer Science 47, pp 262 – 271[7] Hu, S. & Dai, T. 2013 Online Map applicationdevelopmentusing Google Maps API, SQL database, and . International Journal of Information and Communication Technology Research 3(3), 102–110.[8] Udell S., 2008: Beginning Google Maps Mashupswith Mapplets, KML, and GeoRSS: From Novice to Professional. Apress[9] https:///systems/gps/Accessed on June 4 2020.[10] https:///studio/releases/sdk-tools Accessed on June 4 2020 [11] Cui, S. G., Wang, H., Yang, L., 2012. A SimulationStudy of A-star Algorithm for Robot Path Planning.16th international conference on mechatronics technology, pp. 506-510.。
SIMATIC Energy Manager PRO V7.2 - Operation Operat
2 Energy Manager PRO Client................................................................................................................. 19
2.1 2.1.1 2.1.2 2.1.3 2.1.4 2.1.5 2.1.5.1 2.1.5.2 2.1.6
Basics ................................................................................................................................ 19 Start Energy Manager ........................................................................................................ 19 Client as navigation tool..................................................................................................... 23 Basic configuration ............................................................................................................ 25 Search for object................................................................................................................ 31 Quicklinks.......................................................................................................................... 33 Create Quicklinks ............................................................................................................... 33 Editing Quicklinks .............................................................................................................. 35 Help .................................................................................................................................. 38
starccm网格重构操作流程
starccm网格重构操作流程英文回答：The process of mesh refinement in STAR-CCM+ involves several steps to ensure that the mesh accurately represents the geometry and captures the flow physics. Here is a general outline of the workflow:1. Pre-processing: Before starting the mesh refinement process, it is important to have a well-prepared geometry. This includes removing any unnecessary features, repairing any gaps or overlaps, and ensuring that the geometry is watertight. Once the geometry is ready, it can be imported into STAR-CCM+.2. Initial mesh generation: The next step is to generate an initial mesh using the default settings in STAR-CCM+. This initial mesh may not be suitable for accurate simulations, but it provides a starting point for refinement.3. Mesh quality assessment: Once the initial mesh is generated, it is important to assess its quality. STAR-CCM+ provides various tools and metrics to evaluate the mesh quality, such as skewness, aspect ratio, and orthogonality. These metrics help identify areas of the mesh that require refinement.4. Local mesh refinement: Based on the mesh quality assessment, local mesh refinement can be performed in STAR-CCM+. This involves adding more mesh cells in areas where the mesh quality is poor or where high resolution is required. Different refinement techniques, such as surface refinement, volume refinement, and inflation layers, can be used to improve the mesh quality in specific regions of interest.5. Global mesh refinement: In addition to local refinement, global mesh refinement can also be applied to improve the overall mesh quality. This involves increasing the mesh density throughout the domain, which helps capture the flow physics more accurately. However, it is importantto balance the mesh density with computational resources to avoid excessive computational cost.6. Iterative refinement: Mesh refinement is aniterative process, and it may require multiple cycles of refinement and assessment to achieve the desired mesh quality. After each refinement step, the mesh quality should be reassessed to ensure that the desired improvement has been achieved.7. Post-processing: Once the desired mesh quality is achieved, post-processing can be performed in STAR-CCM+. This includes visualizing the mesh, extracting relevant data, and analyzing the simulation results.In summary, the process of mesh refinement in STAR-CCM+ involves pre-processing, initial mesh generation, mesh quality assessment, local and global mesh refinement, iterative refinement, and post-processing. Each step is crucial in ensuring an accurate and reliable mesh for simulation.中文回答：在STAR-CCM+中进行网格重构的过程涉及多个步骤，以确保网格准确地表示几何形状并捕捉流动物理。
倾斜摄影测量数据处理流程
倾斜摄影测量数据处理流程（中英文版）英文文档内容：Tilted Photogrammetry Data Processing WorkflowThe process of tilted photogrammetry involves capturing images of objects from an angle, which provides a more comprehensive view compared to traditional horizontal photography.The data processing workflow for tilted photogrammetry typically includes the following steps:1.Data Collection: Gather a set of overlapping images of the object from different angles and distances.These images should cover the entire area of interest to ensure accurate results.2.Image Preprocessing: Import the images into a photogrammetry software package.Perform preprocessing tasks such as lens distortion correction, radiometric and geometric calibration, and image enhancement to improve the quality of the data.3.Feature Extraction: Automatically or manually extract relevant features from the images, such as points, lines, or areas.These features will be used for subsequent image alignment and 3D reconstruction.4.Image Alignment: Align the images to a common coordinate system using feature matching and bundle adjustment techniques.This step ensures that all images are correctly registered and can be used for 3D reconstruction.5.3D Reconstruction: Generate a 3D model of the object by triangulating the matched features from multiple images.The accuracy of the reconstruction depends on the quality and distribution of the images and the features extracted.6.Dense Point Cloud Generation: Using the 3D model as a reference, generate a dense point cloud by extracting pixel coordinates from the aligned images.This point cloud represents the object"s surface with high precision.7.Surface Reconstruction: Process the dense point cloud to create a continuous surface model of the object.This step may involve filtering out noise points, removing outliers, and填补缺失的数据.8.Mesh Generation: Convert the surface model into a triangular mesh, which can be used for visualizing the object"s surface and performing further analyses.9.Quality Assessment: Evaluate the accuracy and completeness of the resulting 3D model and point cloud.This step ensures that the data meets the required standards for the specific application.10.Data Output: Export the final 3D model, point cloud, and other relevant data in a suitable format for further analysis or visualization.中文文档内容：倾斜摄影测量数据处理流程倾斜摄影测量是通过从不同角度和距离拍摄对象的图像，以提供更全面的视角，与传统的水平摄影相比具有优势。
abaqus 插入cohesive element 原理 -回复
abaqus 插入cohesive element 原理-回复Abaqus is a powerful finite element analysis software widely used in the engineering field to solve complex structural problems. This software provides a wide range of capabilities, including the ability to simulate the behavior of cohesive elements. In this article, we will explore the principles of cohesive element insertion in Abaqus, step by step, shedding light on its significance and applications.1. Introduction to Cohesive Elements:Cohesive elements are specialized finite elements that model the behavior of interfaces between different materials or delamination within a material. These elements are particularly useful in simulating the fracture and failure of bonded joints, such as adhesive bonds in aerospace or automotive structures.2. Defining Material Properties:The first step in inserting cohesive elements in Abaqus is to define the material properties for the cohesive element behavior. This includes the cohesive material type, cohesive stress-displacement relationship, and failure criteria. Abaqus provides various cohesive material models such as Traction-separation laws, Cohesive zone models, and Virtual crack closure technique (VCCT), each suitablefor different fracture behaviors.3. Mesh Generation:After defining the cohesive material properties, the next step is to create a suitable finite element mesh for the model. The mesh should properly capture the regions of interest, such as the interface or delaminated areas. It is crucial to have an appropriate mesh density to obtain accurate and reliable results. For cohesive elements, it is essential to have enough elements across the interface to accurately capture the crack propagation.4. Inserting Cohesive Elements:Once the mesh is prepared, cohesive elements need to be inserted along the defined interfaces or delamination regions. Abaqus provides different techniques for inserting cohesive elements. The most common approach is by defining cohesive surfaces, which involves specifying the nodes or elements along the interface and assigning cohesive properties to them. Alternatively, cohesive elements can be placed manually by defining their locations and element connectivity.5. Defining the Interaction between Cohesive Elements and BulkElements:To ensure proper interaction between cohesive elements and the bulk material, it is necessary to define the contact behavior and interaction parameters. This includes specifying the contact stiffness, penalty parameters, and contact rules. These parameters determine how the cohesive elements and bulk elements interact during the simulation.6. Applying Loads and Boundary Conditions:After inserting the cohesive elements and defining their interaction with the bulk material, appropriate loads and boundary conditions need to be applied to simulate the desired scenario accurately. This may include applying displacements, forces, or thermal loads, depending on the nature of the problem under consideration.7. Running the Simulation:Once the model is prepared, the simulation can be executed using Abaqus. During the analysis, Abaqus solves the finite element equations considering the cohesive behavior and interactions between cohesive and bulk elements. The cohesive elements track the evolution of the interface or delamination region, allowing accurate prediction of fracture initiation and crack propagation.8. Post-processing:After completing the simulation, the results can be post-processed using Abaqus visualization tools. This includes analyzing fracture patterns, crack growth, stress distribution, and other relevant quantities of interest. Abaqus provides various tools for visualizing and analyzing the simulation results to understand the behavior of the cohesive elements accurately.In conclusion, the insertion of cohesive elements in Abaqus provides a powerful tool for simulating interface behavior and fracture in bonded structures. By accurately modeling the cohesive behavior and interactions with bulk materials, Abaqus enables engineers to analyze and predict the failure of adhesive bonds and other similar structural elements. By following the step-by-step process described above, engineers can effectively use cohesive elements in their Abaqus simulations to simulate complex fracture and failure scenarios, ultimately leading to improved designs and enhanced structural integrity in numerous industries.。
ContentsataGlance（PDF-10）
xBlender For Dummies, 2nd EditionNew Features in Blender’s 3D View Since 2.5 (45)Quad View (45)Regions (46)Don’t know how to do something? Hooray for fullyintegrated search! (48)Chapter 3: Getting Your Hands Dirty Working in Blender . . . . . . . . . .49Grabbing, Scaling, and Rotating (49)Differentiating Between Coordinate Systems (50)Transforming an Object by Using the 3D Manipulator (53)Switching manipulator modes (53)Using the manipulator (54)Saving Time by Using Hotkeys (56)Transforming with hotkeys (57)Hotkeys and coordinate systems (57)Numerical input (59)The Properties region (59)Chapter 4: Working in Edit Mode and Object Mode . . . . . . . . . . . . . . .61Making Changes by Using Edit Mode (61)Distinguishing between Object mode and Edit mode (62)Selecting vertices, edges, and faces (63)Working with linked vertices (65)Still Blender’s No. 1 modeling tool: Extrude (66)Creating a simple model with Extrude (70)Adding to a Scene (72)Adding objects (72)Meet Suzanne, the Blender monkey (74)Joining and separating objects (74)Creating duplicates and links (75)Discovering parents, children, and groups (80)Saving, opening, and appending (84)Part II: Creating Detailed 3D Scenes (89)Chapter 5: Creating Anything You Can Imagine with Meshes. . . . . . .91Pushing Vertices (91)Working with Loops and Rings (94)Understanding edge loops and face loops (94)Selecting edge rings (95)Creating new loops (96)Simplifying Your Life As a Modeler with Modifi ers (98)Doing half the work (and still looking good!) withthe Mirror modifi er (101)xiTable of ContentsSmoothing things out with the Subdivision Surface modifi er (103)Using the power of Arrays (107)Sculpting Multiresolution Meshes (111)Something new: The Multiresolution modifi er (111)Sculpting options (113)Practical Example: Modeling an Eye (119)Starting with a primitive (119)Creating the pupil and iris (120)Taking a knife to your pupil (122)Smoothing out the eye interior (123)Building the eye’s exterior (124)Chapter 6: Using Blender’s Nonmesh Primitives. . . . . . . . . . . . . . . . .129 Using Curves and Surfaces (129)Understanding the different types of curves (132)Working with curves (133)Understanding the strengths and limitations ofBlender’s surfaces (144)Using Meta Objects (145)Meta-wha? (146)What meta objects are useful for (148)Adding Text (149)Adding and editing text (150)Changing fonts (153)Deforming text with a curve (155)Converting to curves and meshes (155)Chapter 7: Changing That Boring Gray Default Material . . . . . . . . . .157 Playing with Materials (157)Changing colors (162)Adjusting shader values (163)Refl ection and transparency (166)Controlling how materials handle shadows (169)Assigning multiple materials to different parts of a mesh (170)Coloring Vertices with Vertex Paint (172)Practical Example: Coloring the Eye (174)Setting up a Materials screen (174)The easy part: Material slots (176)Getting more detailed with Vertex Paint (181)Chapter 8: Giving Models Texture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .185 Adding Textures (185)Using Procedural Textures (187)Understanding Texture Mapping (191)The Mapping panel (191)The Infl uence panel (195)xiiBlender For Dummies, 2nd EditionUnwrapping a Mesh (196)Marking seams on a mesh (196)Adding a test grid (197)Generating and editing UV coordinates (199)Painting Textures Directly on a Mesh (201)Baking Texture Maps from Your Mesh (203)Using UV Textures (205)Practical Example: Unwrapping Your Eye and Paintinga Detailed Texture (206)Marking seams and unwrapping (206)Reducing texture stretching (207)Baking vertex colors (210)Assigning textures to your material (212)Painting textures (212)Chapter 9: Lighting and Environment . . . . . . . . . . . . . . . . . . . . . . . . . . .215Lighting a Scene (215)Understanding a basic three-point lighting setup (216)Lighting for Speedy Renders (228)Working with three-point lighting in Blender (230)Creating a fake Area light with buffered Spots (231)Dealing with outdoor lighting (232)Setting Up the World (234)Changing the sky to something other than dull gray (234)Understanding ambient occlusion (236)Adding mist and stars (238)Creating sky textures (241)Part III: Get Animated! (243)Chapter 10: Animating Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .245Working with Animation Curves (246)Customizing your screen layout for animation (248)Working in the Graph Editor (249)Inserting keys (250)Editing motion curves (252)Using Constraints Effectively (255)The all-powerful Empty! (257)Adjusting the infl uence of a constraint (258)Using vertex groups in constraints (258)Copying the movement of another object (259)Putting limits on an object (261)Tracking the motion of another object (263)xiiiTable of ContentsPractical Example: Building and Animating a Simple Eye Rig (264)Creating your rig (265)Animating your eyes (269)Chapter 11: Rigging: The Art of Building an Animatable Puppet . . .273 Creating Shape Keys (273)Creating new shapes (274)Mixing shapes (276)Knowing where shape keys are helpful (278)Adding Hooks (278)Creating new hooks (278)Knowing where hooks are helpful (280)Using Armatures: Skeletons in the Mesh (280)Editing armatures (281)Putting skin on your skeleton (290)Practical Example: Rigging Stickman (295)Building Stickman’s centerline (295)Adding Stickman’s appendages (296)Taking advantage of parenting and constraints (299)Comparing inverse kinematics and forward kinematics (303)Making the rig more user friendly (308)Chapter 12: Animating Object Deformations. . . . . . . . . . . . . . . . . . . . .311 Working with the Dopesheet (311)Animating with Armatures (314)Principles of animation worth remembering (315)Making sense of quaternions (or, “Why are therefour rotation curves?!”) (317)Copying mirrored poses (318)Seeing the big picture with ghosting (320)Visualizing motion with paths (321)Doing Nonlinear Animation (322)Mixing actions to create complex animation (323)Taking advantage of looped animation (325)Chapter 13: Letting Blender Do the Work for You . . . . . . . . . . . . . . . .327 Using Particles in Blender (328)Knowing what particle systems are good for (329)Using force fi elds and collisions (332)Using particles for hair and fur (334)Giving Objects Some Jiggle and Bounce (337)Dropping Objects in a Scene with Rigid Body Dynamics (340)Simulating Cloth (343)Splashing Fluids in Your Scene (344)xivBlender For Dummies, 2nd EditionPart IV: Sharing Your Work with the World (349)Chapter 14: Exporting and Rendering Scenes. . . . . . . . . . . . . . . . . . . .351Exporting to External Formats (351)Rendering a Scene (352)Creating a still image (353)Creating a fi nished animation (356)Creating a sequence of still images for editing or compositing (358)Chapter 15: Compositing and Editing . . . . . . . . . . . . . . . . . . . . . . . . . . .359Comparing Editing to Compositing (359)Working with the Video Sequence Editor (360)Adding and editing strips (363)Adding effects (366)Rendering from the Video Sequence Editor (368)Working with the Node-Based Compositor (369)Understanding the benefi ts of rendering in passes (370)Working with nodes (374)Discovering the nodes available to you (379)Rendering from the Node Compositor (386)Part V: The Part of Tens (387)Chapter 16: Ten Problems for New Users in Blender(And Ways Around Them). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389Auto Saves and Session Recovery Don’t Work (389)Blender’s Interface Is Weird or Glitchy (390)A Notorious Black Stripe Appears on Models (391)Objects Go Missing (391)Edge Loop Select Doesn’t Work (393)A Background Image Disappears (393)Zooming Has Its Limits (393)Lost Simulation Data (394)Blender Doesn’t Create Faces As Expected (395)Disorientation in the 3D View (396)Chapter 17: Ten Tips for Working More Effectively in Blender. . . . .397Use Tooltips and Integrated Search (397)Look at Models from Different Views (398)Lock a Camera to an Animated Character (398)Don’t Forget about Add-Ons (398)Name Everything (399)xvTable of ContentsUse Layers Effectively (399)Do Low-Resolution Test Renders (400)Mind Your Mouse (401)Use Grease Pencil to Plan (402)Have Fun, but Take Breaks (402)Chapter 18: Ten Excellent Community Resources . . . . . . . . . . . . . . . .403 (403) (404)BlenderNation (404) (404)BlenderNewbies (405) (405)Blendswap (405)Blenderart Magazine (405) (405)Blender IRC Channels on (406)Appendix: About the DVD (407)Index (413)。
fluent-mdm-tut-01_2d-falling-box
Tutorial:Solving a2D Box Falling into WaterIntroductionThe purpose of this tutorial is to provide guidelines and recommendations for setting up and solving a moving deforming mesh(MDM)case along with the six degree of freedom (6DOF)solver and the volume offluid(VOF)multiphase model.The6DOF UDF is used to calculate the motion of the moving body which also experiences a buoyancy force as it hits the water(modeled using the VOF model).Gravity and the bouyancy forces drive the motion of the body and the dynamic mesh.This tutorial demonstrates how to do the following:•Use6DOF solver to calculate motion of the moving body.•Use VOF multiphase model to model the buoyancy force experienced by the movingbody.•Set up and solve the dynamic mesh case.•Create TIFFfiles for graphic visualization of the solution.•Postprocess the resulting data.PrerequisitesThis tutorial is written with the assumption that you have completed Tutorial1from ANSYS FLUENT13.0Tutorial Guide,and that you are familiar with the ANSYS FLUENT navigation pane and menu structure.Some steps in the setup and solution procedure will not be shown explicitly.In this tutorial,you will use the dynamic mesh model and the6DOF model.If you have not used these models before,see Sections11.3Using Dynamic Meshes and11.3.7Six DOF Solver Settings,respectively in the ANSYS FLUENT13.0User’s Guide.Problem DescriptionThe schematic of the problem is shown in Figure1.The tank is partiallyfilled with water.A box is dropped into the water at time t=0.The box is subjected to a viscous dragforce and a gravitational force.When the box is immersed in water,it is also subjected toa buoyancy force.Tutorial:Solving a2D Box Falling into WaterThe walls of the box undergoes a rigid body motion and displaces according to the calcu-lation performed by6DOF solver.Whenever the box and its surrounding boundary layer mesh are displaced,the mesh outside the boundary layer is smoothed and/or remeshed.Figure1:Schematic of the ProblemSetup and SolutionPreparation1.Copy thefiles(6dof-mesh.msh.gz and6dof2d.c)to your working folder.2.Create a subfolder(tiff-files)to store the tifffiles for postprocessing purpose.e FLUENT Launcher to start the2D version of ANSYS FLUENT.For more information about FLUENT Launcher see Section1.1.2StartingANSYS FLUENT Using FLUENT Launcher in ANSYS FLUENT13.0User’s Guide.4.Enable Double-Precision in the Options list.5.Click the UDF Compiler tab and ensure that the Setup Compilation Environment forUDF is enabled.The path to the.batfile which is required to compile the UDF will be displayed as soonas you enable Setup Compilation Environment for UDF.If the UDF Compiler tab does not appear in the FLUENT Launcher dialog box by default,click the Show Additional Options>>button to view the additional settings.Tutorial:Solving a2D Box Falling into Water The Display Options are enabled by default.Therefore,after you read in the mesh,it will be displayed in the embedded graphics window.Step1:Mesh1.Read the meshfile(6dof-mesh.msh.gz).File−→Read−→Mesh...As the meshfile is read,ANSYS FLUENT will report the progress in the console. Step2:General Settings1.Define the solver settings.−→Transient(a)Select Transient from the Time list.2.Check the mesh(see Figure2).−→CheckFigure2:Mesh DisplayANSYS FLUENT will perform various checks on the mesh and will report the progress in the console.Make sure the minimum volume reported is a positive number.Tutorial:Solving a2D Box Falling into WaterStep3:Models1.Define the multiphase model.−→−→Edit...(a)Select Volume of Fluid from the Model list to open Multiphase Model dialog box.(a)Ensure that Number of Eulerian Phases is set to2.(b)Retain the default value of Courant Number.(c)Enable Implicit Body Force in the Body Force Formulation group box.(d)Click OK to close the Multiphase Model dialog box.2.Enable the standard k- turbulence model.−→−→Edit...Step4:User-Defined FunctionsDefine−→User-Defined−→Functions−→Compiled...Tutorial:Solving a2D Box Falling into Water1.Click Add...for the Source Files.2.Select6dof2d.c in the Select File dialog box.ANSYS FLUENT displays a Warning dialog box warning you to ensure that the UDF sourcefiles are in the same folder that contains the case and datafiles.Click OK.ANSYS FLUENT sets up the folder structure and compiles the code.The compilation is displayed in the console.3.Click Load to load the UDF library.Step5:Materials−→Create/Edit...1.Retain the properties of air.2.Copy water-liquid(h2o<l>)from the FLUENT Database....3.Modify the properties of water-liquid(h2o<l>).(a)Select user-defined from the Density drop-down list.i.Select water density::libudf from the User-Defined Functions dialog box.(b)Select user-defined from the Speed of Sound drop-down list.i.Select water speed of sound::libudf from the User-Defined Functions dialogbox.(c)Click Change/Create and close the Create/Edit Materials dialog box.Step6:Phases1.Define the primary phase,water.−→phase-1−→Edit...Tutorial:Solving a2D Box Falling into Water(a)Enter water for Name.(b)Select water-liquid from the Phase Material drop-down list.(c)Click OK.2.Similarly,define the secondary phase,air.−→−→Edit...Tutorial:Solving a2D Box Falling into Water Step7:Boundary Conditions1.Define the boundary conditions for tank outlet.−→(a)Set the boundary conditions for the mixture phase.i.Ensure that mixture is selected from the Phase drop-down list and click Edit...ii.Select Intensity and Viscosity Ratio from the Specification Method drop-down list.iii.Enter1%for Backflow Turbulence Intensity and10for Backflow Turbulent Viscosity Ratio.iv.Click OK to close the Pressure Outlet dialog box.(b)Set the boundary conditions for the air phase.i.Select air from the Phase drop-down list and click Edit....ii.Click the Multiphase tab and enter1for Backflow Volume Fraction.iii.Click OK to close the Pressure Outlet dialog box.Step8:Operating Conditions−→Operating Conditions...1.Retain101325pascal for Operating Pressure.2.Enable Gravity.The dialog box expands to show additional inputs.3.Enter-9.81m/s2for Gravitational Acceleration in the Y direction.Tutorial:Solving a2D Box Falling into Water4.Enable Specified Operating Density and retain the default setting of1.225kg/m3forOperating Density.Step9:Dynamic Mesh Setup1.Set the dynamic mesh parameters.(a)Enable Dynamic Mesh.(b)Enable Six DOF Solver.(c)Ensure that Smoothing is enabled.(d)Enable Remeshing from the Mesh Methods group box ans click Settings....i.Click Smoothing tab and set the Spring Constant Factor to0.5.ii.Click Remeshing tab and set the remeshing parameters.Tutorial:Solving a2D Box Falling into WaterA.Enter0.056m for Minimum Length Scale and0.13m for MaximumLength Scale.The Minimum Length Scale and the Maximum Length Scale can be ob-tained from the Mesh Scale Info dialog box.Click on the Mesh ScaleInfo...button to open the Mesh Scale Info dialog box.B.Enter0.5for Maximum Cell Skewness.iii.Click OK to close Mesh Method Settings dialog box.Six DOF Solver Settings includes Gravitational Acceleration setting and the Write Motion History option.You already have set the Gravitational Acceleration in the Operating Conditions dialog box.If you want the motion history,enable Write Motion History and specify the File Name.Tutorial:Solving a2D Box Falling into Water2.Set up the moving zones.(Dynamic Mesh Zones)−→Create/Edit...(a)Create the dynamic zone,moving box.i.Select moving box from the Zone Names drop-down list.ii.Ensure that Rigid Body is selected in the Type group box.iii.Ensure that test box::libudf is selected from the Six DOF UDF drop-down list.iv.Ensure that On is enabled in the Six DOF Solver Options group box.v.Click Create.ANSYS FLUENT will create the dynamic zone moving box which will beavailable in the Dynamic Mesh Zones list.i.Similarly,create the dynamic zone,movingfluid by also enabling Passive fromthe Six DOF Solver Options group box.Ensure that you enable Passive from the Six DOF Solver Options group box.When Passive for the rigid body is enabled,ANSYS FLUENT does not takeforces and moments on the zone into consideration.ANSYS FLUENT will create the dynamic zone movingfluid which will beavailable in the Dynamic Mesh Zones list.(b)Close the Dynamic Mesh Zones dialog box.Step10:Mesh PreviewThe purpose of the preview is to verify the quality of the mesh yielded by the mesh motion parameters.Since theflow is not initialized,the motion of the box will be vertical due to gravity.1.Save the casefile(6dof-init.cas.gz).File−→Write−→Case...2.Display the mesh.−→−→Set Up...3.Preview the motion.−→Preview Mesh Motion...(a)Enter0.0005for Time Step Size.(b)Enter1000for Number of Time Steps.(c)Click Preview(see Figure3).Figure3:Mesh Motion at t=0.5sThe motion is acceptable.(d)Close the Mesh Motion dialog box.4.Exit ANSYS FLUENT without saving.Step11:Solution1.Start the2D version of ANSYS FLUENT and read the casefile(6dof-init.cas.gz).2.Set the solution method parameters.(a)Ensure that SIMPLE is selected from the Scheme drop-down list.(b)Select Green-Gauss Node Based from the Gradient drop-down list.(c)Select Second Order Upwind for all the equations except Volume Fraction.(d)Retain the default discretization method of Geo-Reconstruct for Volume Fraction.3.Set the solution control parameters.(a)Enter0.5for Body Forces in the Under-Relaxation Factors group box.(b)Enter0.8for Turbulent Viscosity.(c)Retain the default values for other parameters.4.Initialize the solution.(a)Enter0.001m2/s2for Turbulent Kinetic Energy and0.001m2/s3for TurbulentDissipation Rate.(b)Enter1for air Volume Fraction.(c)Click Initialize.5.Create an adaption register for patching.Adapt−→Region...(a)Set the Input Coordinates as follows:Parameters ValuesX Min(m),X Max(m)(-5,5)Y Min(m),Y Max(m)(-5,-1.5)(b)Click Mark.(c)Close the Region Adaption dialog box.6.Patch the air volume fraction.−→Patch...(a)Select air from the Phase drop-down list.(b)Select Volume Fraction from the Variable list.(c)Select hexahedron-r0from the Registers to Patch list.(d)Retain0for Value.(e)Click Patch.(f)Close the Patch dialog box.7.Enable the plotting of residuals.−→Residuals−→Edit...(a)Enter400for Iterations to Plot.(b)Click OK to close the Residual Monitors dialog box.8.Define a surface monitor for Y Velocity.(Surface Monitors)−→Create...(a)Enable Print to Console,Plot,and Write for surf-mon-1.(b)Retain the default setting of2for Window.(c)Enter6dof yvel.out for File Name.(d)Select Flow Time from the X Axis drop-down list.(e)Select Time Step from the Every drop-down list.(f)Select Area-Weighted Average from the Report Type drop-down list.(g)Select Velocity...and Y Velocity from the Field Variable drop-down lists.(h)Select moving box from the Surfaces list and click OK to close the Surface Monitordialog box.9.Set the auto save option.(a)Enter100for Autosave Every(Time Steps)and click Edit....i.Enable Retain Only the Most Recent Files.ii.Set the Maximum Number of Data Files to2.iii.Enter falling-box.gz for File Name.ANSYS FLUENT will append the timestep number so that eachfile will havea uniquefilename.iv.Click OK to close the Autosave dialog box.10.Save the hardcopy of display.File−→Save Picture...(a)Select TIFF from the Format list.(b)Ensure that Color is selected from the Coloring list.(c)Ensure that Raster is selected from the File Type list.(d)Enter800(pixels)for Width and600(pixels)for Height in the Resolution groupbox.(e)Click Apply and close the Save Picture dialog box.11.Execute commands for the animation setup.(Execute Commands)−→Create/Edit...(a)Set the Defined Commands to4.(b)Enable Active for all commands.(c)Enter100for Every and select Time Step from the When drop-down list.(d)Enter the commands as shown in the Execute Commands dialog box.Ensure to create the subfolder tiff-files before clicking the OK button.(e)Click OK to close the Execute Commands dialog box.12.Displayfilled contour plots,enter the following command in the ANSYS FLUENTconsole.>display set contours filled-contours yes13.Run the calculation.(a)Enter0.0005s for Time Step Size.(b)Enter10000for Number of Time Steps.(c)Set Max Iterations/Time Step to50.(d)Click Calculate.Step12:Postprocessing1.Convert the TIFFfiles in the subfolder tiff-files to form an animation sequence forpostprocessing purpose,using the software package like QuickTime or Fast Movie Player.The contours of volume fraction of water at different time steps are as shown in Figures4 through23.Figure 4:Contours at t =0.25sFigure 5:Contours at t =0.5sFigure 6:Contours at t =0.75sFigure 7:Contours at t =1.0sFigure 8:Contours t =1.25sFigure 9:Contours t =1.5sFigure 10:Contours at t =1.75sFigure 11:Contours at t =2.0sFigure 12:Contours of at t =2.25sFigure 13:Contours at t =2.5sFigure 14:Contours at t =2.75sFigure 15:Contours at t =3.0sTutorial:Solving a 2D Box Falling into WaterFigure 16:Contours at t =3.25sFigure 17:Contours at t =3.5sFigure 18:Contours at t =3.75sFigure 19:Contours at t =4.0sFigure 20:Contours at t =4.25sFigure 21:Contours at t =4.5s c ANSYS,Inc.November 24,201021Tutorial:Solving a 2D Box Falling into WaterFigure 22:Contours at t =4.75s Figure 23:Contours at t =5.0s SummaryThis tutorial demonstrated the setup and solution of a dynamic mesh case along with the 6DOF solver and the VOF multiphase model.The 6DOF UDF was used to calculate the motion of the box dropped into the water.The TIFF files created in the tutorial can be used to provide a graphic visualization of the solution.22c ANSYS,Inc.November 24,2010。
ICEM画飞机网格
• •
•
•
Disconnected Bar Elements: 杆单元存 在两个节点都没有和其他杆单元相连
9/9/05
ANSYS ICEMCFD V10
Inventory #002277
F1-4
Checking the Mesh: Possible Problems
• Multiple Edges:三个以上单元共享一条 • 边 – 在 “T” 连接中multiple edges是合 法的, “T” 连接存在于多曲面相交汇 • 时 Triangle Boxes: 4个三角形网格组构成一 个四面体 ，在其中没有实际的体积单元 • 2 -Single Edges: 面单元有两个自由的边 (没有另一个面单元相连) Single-Multiple Edges:同时拥有单边和 多连接边的单元 Stand-Alone Surface Mesh:不合体网格 单元分享面的面网格单元 Single Edges:至少有一条单边（不与其 它单元分享）的面网格单元 – 可能是合法的内部薄壁 • Delaunay Violation: 面网格单元的节点落在 相邻单元的外接圆内
Catia分析功能介绍
•Setting the environment
For this exercise you will need to change some Options In the Menu bar, select Tools + Options…
Under General+Parameters, in the Options Pop-up window, select Units tab Select the Length line and with the scroll down menu, choose the Inch(in) unit On the Force line, select the Pound Force (lbf) unit Finally on the Pressure line select the Lb. force per square inch (psi) unit Click OK to confirm the settings
WB
•Setting the Boundary Conditions
Before computing, you need to indicate the Boundary conditions Select Clamp icon from workbench
Select one of the internal faces of the screw thread (Choose one of the screw ends)
Icons
IBM Product Lifecycle Management Solutions / Dassault Systemes
Page 6
Step 2: Prepare the part for Analysis
ABAQUS常见错误与警告信息汇总
*************************错误与警告信息汇总*************************－－－－－－－－－－－－－－简称《错误汇总》%%%%%%%%%%%%%%% @@@ 布局 @@@ &&&&&&&&&&&&&&&&&&&&&&AB系列：常见错误信息C系列：常见警告信息D系列：cdstudio斑竹总结的fortran二次开发的错误表E系列：网格扭曲%%%%%%%%%%%%%%%%% @@@@@@ &&&&&&&&&&&&&&&&&&&&&&&&&模型不能算或不收敛，都需要去monitor，msg文件查看原因，如何分析这些信息呢？这个需要具体问题具体分析，但是也存在一些共性。
这里只是尝试做一个一般性的大概的总结。
如果你看见此贴就认为你的warning以为迎刃而解了，那恐怕令你失望了。
不收敛的问题千奇万状，往往需要头疼医脚。
接触、单元类型、边界条件、网格质量以及它们的组合能产生许多千奇百怪的警告信息。
企图凭一个警告信息就知道问题所在，那就只有神仙有这个本事了。
一个warning出现十次能有一回参考这个汇总而得到解决了，我们就颇为欣慰了。
我已霸占2楼3楼4楼，以便分类并续加整理。
斑竹可随意编辑或者添加你们觉得合适的条目和链接，其他版友有warning方面的疑问请回复到这个帖子，大家集思广益，斑竹们也可以集中讨论并定期汇总到1-4楼。
类似于：Fixed time is too largeToo many attamps have been madeTHE SOLUTION APPEARS TO BE DIVERGING.CONVERGENCE ISJUDGED UNLIKELY.Time increment required is less than the minimum specified这样的信息几乎是无用信息（除了告诉你的模型分析失败以外，没有告诉你任何有用的东西）。
ANSYS错误集锦-李
ANSYS错误集锦-李ansys分析出现问题NO.0052some contact elements overlap with the other contact element which can cause over constraint. 这是由于在同一实体上，即有绑定接触（MPC）的定义，又有刚性区或远场载荷（MPC）的定义，操作中注意在定义刚性区或远场载荷时避免选择不必要的DOF自由度，以消除过约束NO.0053Shape testing revealed that 450 of the 1500 new or modified elements violate shape warning limits.是什么原因造成的呢？单元网格质量不够好尽量，用规则化网格，或者再较为细密一点NO.0054在用Area Fillet对两空间曲面进行倒角时出现以下错误：Area 6 offset could not fully converge to offset distance 10. Maximum error between the two surfaces is 1% of offset distance.请问这是什么错误？怎么解决？其中一个是圆柱接管表面，一个是碟形封头表面。
ansys的布尔操作能力比较弱。
如果一定要在ansys里面做的话，那么你试试看先对线进行倒角，然后由倒角后的线形成倒角的面。
建议最好用UG、PRO/E这类软件生成实体模型然后导入到ansysNO.0055There are 21 small equation solver pivot terms.; SOLID45 wedges are recommended only in regions of relatively lowstress gradients.第一个问题我自己觉得是在建立contact时出现的错误，但自己还没有改正过来；第二个也不知道是什么原因。
网格划分策略与网格质量检查
网格划分策略与网格质量检查判断网格质量的方面有：Area单元面积,适用于2D单元，较为基本的单元质量特征。
Aspect Ratio长宽比,不同的网格单元有不同的计算方法，等于1是最好的单元，如正三角形，正四边形，正四面体，正六面体等;一般情况下不要超过5：1.Diagonal Ratio对角线之比，仅适用于四边形和六面体单元,默认是大于或等于1的，该值越高，说明单元越不规则，最好等于1,也就是正四边形或正六面体。
Edge Ratio长边与最短边长度之比,大于或等于1,最好等于1，解释同上.EquiAngle Skew通过单元夹角计算的歪斜度，在0到1之间，0为质量最好，1为质量最差.最好是要控制在0到0。
4之间.EquiSize Skew通过单元大小计算的歪斜度，在0到1之间,0为质量最好,1为质量最差。
2D质量好的单元该值最好在0。
1以内，3D单元在0。
4以内。
MidAngle Skew通过单元边中点连线夹角计算的歪斜度，仅适用于四边形和六面体单元，在0到1之间，0为质量最好，1为质量最差。
Size Chang e相邻单元大小之比,仅适用于3D单元，最好控制在2以内。
Stretch伸展度.通过单元的对角线长度与边长计算出来的，仅适用于四边形和六面体单元，在0到1之间，0为质量最好，1为质量最差。
Taper锥度。
仅适用于四边形和六面体单元，在0到1之间,0为质量最好，1为质量最差。
Volume单元体积，仅适用于3D单元，划分网格时应避免出现负体积。
Warpage翘曲。
仅适用于四边形和六面体单元，在0到1之间，0为质量最好，1为质量最差.以上只是针对Gambit帮助文件的简单归纳，不同的软件有不同的评价单元质量的指标，使用时最好仔细阅读帮助文件。
另外，在Fluent中的窗口键入：grid quality 然后回车，Fluent能检查网格的质量，主要有以下三个指标：1.Maxium cell squish：如果该值等于1,表示得到了很坏的单元;2.Maxium cell skewness：该值在0到1之间，0表示最好，1表示最坏；3.Maxium ’aspect-ratio’： 1表示最好.关于网格划分在数值仿真中的重要性，在此就不多说了，相信做这个的版友都了解。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Problem 13: Visualizing the mesh qualityProblem descriptionA plate with a hole is subjected to tension as shown:Thickness =1mmE =7.010N/mm ´42n =0.25p =25.0N/mm 2mesh56All lengths in mm.This is the same model and loading as problem 2. We deliberately solve the problem using the relatively ineffective 3 and 4-node elements (without incompatible modes), so that the results are inaccurate when a coarse mesh is used. In this way we can demonstrate the mesh quality visualization features of the AUI.In this problem solution, we will demonstrate the following topics:$ Plotting and listing error indicators $ Plotting repeating bandsWe assume that you have worked through problems 1 to 12, or have equivalent experience with the ADINA System. Therefore we will not describe every user selection or button press.Problem 13: Visualizing the mesh qualityBefore you beginPlease refer to the Icon Locator Tables chapter of the Primer for the locations of all of the AUI icons. Please refer to the Hints chapter of the Primer for useful hints.This problem can be solved with the 900 nodes version of the ADINA System.Invoking the AUI and choosing the finite element programInvoke the AUI and choose ADINA Structures from the Program Module drop-down list. Defining the modelAs the model is almost the same as problem 2, we only briefly give the steps needed to define the model.Problem heading: Choose Control→Heading, enter the heading “Problem 13: Visualizing the mesh quality” and click OK.Master degrees of freedom: Choose Control→Degrees of Freedom, uncheck theX-Translation, X-Rotation, Y-Rotation and Z-Rotation buttons and click OK.Geometry: Click the Define Points icon , define the following points (remember to keep the X1 column blank) and click OK.Point# X2 X312345678 1051010282810510We also need a point mid-way along the hole. The coordinates of this point are most conveniently entered using a cylindrical coordinate system. Click the Coordinate Systems icon , add coordinate system 1, set the Type to Cylindrical and click OK. Then click the Define Points icon , add the following information to the table, and click OK.Point # X1 X2 X39 5 45 0Problem 13: Visualizing the mesh qualityTo define the arc lines, click the Define Lines icon , add line 1, set the Type to Arc, set P1 to 4, P2 to 9, Center to 8 and click Save. Then add line 2, set P1 to 9, P2 to 5, Center to 8 and click OK.To define the surfaces, click the Define Surfaces icon , make sure that the Type is set to Vertex, define the following surfaces and click OK.Surface Number Point 1 Point 2 Point 3 Point 4123 771392453967Boundary conditions: We need two boundary conditions for modeling symmetry. Click the Apply Fixity icon and click the Define... button. In the Define Fixity dialog box, add fixity name ZT, check the Z-Translation button and click Save. Then add fixity name YT, check the Y-Translation button and click OK. In the Apply Fixity dialog box, set the “Apply to” field to Lines. Set the fixity for lines 4 and 9 to YT, the fixity for line 6 to ZT and click OK.Loads: Click the Apply Load icon , set the Load Type to Pressure and click the Define... button to the right of the Load Number field. In the Define Pressure dialog box, add pressure 1, set the Magnitude to -25 and click OK. In the Apply Load dialog box, make sure that the “Apply to” field is set to Line and, in the first row of the table, set the Line # to 8. Click OK to close the Apply Load dialog box.Material: Click the Manage Materials icon and click the Elastic Isotropic button. In the Define Isotropic Linear Elastic Material dialog box, add material 1, set the Young=s Modulus to 7E4, the Poisson=s ratio to 0.25 and click OK. Click Close to close the Manage Material Definitions dialog box.Element group: Click the Define Element Groups icon , add element group number 1, set the Type to 2-D Solid, set the Element Sub-Type to Plane Stress, set Incompatible Modes to No and click OK.Subdivision data: In this mesh, we will assign a uniform point size to all points and have the AUI automatically compute the subdivisions.Choose Meshing→Mesh Density→Complete Model, verify that the “Subdivision Mode ” is set to “Use End-Point Sizes” and click OK. Now choose Meshing→Mesh Density→Point Size, set the “Points Defined from” field to “All Geometry Points”, set the Maximum toProblem 13: Visualizing the mesh qualityElement generation: Click the Mesh Surfaces icon , set the “Nodes per Element” to 4, enter 1, 2, 3 in the first three rows of the table and click OK. When you click the Boundary Plot icon and the Load Plot icon , the graphics window should look something likethis:Generating the ADINA data file, running ADINA, loading the porthole fileClick the Save iconand save the database to file prob13. Click the Data File/Solutionicon , set the file name to prob13, make sure that the Run Solution button is checked and click Save. When ADINA is finished, close all open dialog boxes, choose Post-Processing from the Program Module drop-down list (you can discard all changes), click the Open iconand open porthole file prob13.Examining the solutionClick the Create Band Plot icon , set the Band Plot Variable to (Stress:STRESS-ZZ) and click OK. The graphics window should look something like the top figure on the next page.Note the jagged nature of the bands. To smooth the bands, click the Smooth Plots icon .The graphics window should look something like the bottom figure on the next page.Problem 13: Visualizing the mesh qualityProblem 13: Visualizing the mesh qualityError indicators: The AUI allows you to plot error indicators as a guide for determining where the mesh should be refined. To plot error indicators, click the Error Plots icon . The graphics window should look something like this:This plot shows that the maximum stress jump (difference between stresses evaluated at the same node) is about 24% of the maximum stress value.You can, if desired, scale the error indicator so that the stress jump is not divided by a reference value. Click the Modify Band Plot icon , click the ... button next to the Smoothing Technique field, set the Error Reference Value to 1 and click OK twice to close both dialog boxes. The graphics window should look something like the top figure on the next page.It is also possible to list the nodes for which the error indicator is highest. ChooseList→Extreme Values→Zone, set the Smoothing Technique to BANDPLOT00001, Variable 1 to (Stress:STRESS-ZZ) and click Apply. The AUI lists the value of 2.52870E+01 for node 21. Click Close to close the dialog box.Repeating bands: Another way to present the error is to plot repeating bands of unsmoothed stresses. Click the Modify Band Plot icon , set the Smoothing Technique to NONE, click the Band Table... button, set the Type to Repeating and click OK twice to close both dialog boxes. The graphics window should look something like the bottom figure on the next page.Problem 13: Visualizing the mesh qualityThe fact that the bands become indistinct near the hole shows that further mesh refinement is needed.Problem 13: Visualizing the mesh qualityRefining the meshPreparing to modify the model: Choose ADINA Structures from the Program Module drop-down list (you can discard all changes). Choose database file prob13 from the recent file list near the bottom of the File menu.Deleting the elements: Click the Delete Mesh icon , set the “Delete Mesh from” field to Surface if necessary, enter 1, 2, 3 in the first three rows of the table and click OK. Creating a refined mesh: In this mesh refinement, we would like to use fewer elements away from the hole and more elements closer to the hole. Choose Meshing→Mesh Density→ Point Size, set the “Points Defined From” field to “Vertices of Specified Surfaces”, enter 1, 0.5, 2, 0.5, 3, 2.0 in the first three rows of the table, then click OK.Now click the Mesh Surfaces icon , set the “Nodes per Element” to 4, enter 1, 2, 3 in the first three rows of the table and click OK. The graphics window should look something like this:Generating the ADINA data file, running ADINA, loading the porthole fileSave the database, generate the ADINA data file, run ADINA, choose Post-Processing and load the porthole file in the same way as before, this time using name prob13a.Problem 13: Visualizing the mesh quality Examining the solutionFollow the instructions given above to plot the stresses. We obtain the plots shown on pages 13-10 and 13-11.The numerical value of the error indicator has dropped, showing that the solution has in fact improved. Also the repeating bands are more distinct near the hole.Exiting the AUI:Choose File→Exit to exit the AUI. You can discard all changes.Problem 13: Visualizing the mesh qualityProblem 13: Visualizing the mesh qualityADINA R & D, Inc. 13-11Problem 13: Visualizing the mesh qualityThis page intentionally left blank.13-12ADINA Primer。