Virtual stress testing machine and the cyber-infrastructure

Abstract

The virtual stress testing machine (VSTM) project demonstrates the use of the cyber-infrastructure to integrate the algorithms of computational mechanics and supplement virtual environments with physics. The VSTM is not a tool, nor is it intended to be; rather it is a pedagogical presentation of new research paradigms that should be comprehensible to mechanical engineers. VSTM encompasses a real stress testing machine, a virtual stress-testing machine, and a server that initiates and regulates all component physics and visualization processes the server also controls the real Instron. A series of benchmark tests were conducted for analysis of reliability and to demonstrate how such tests can and should be conducted so as to foster communication between mechanical engineers and their colleagues across disciplines. These tests have demonstrated the concept of creating a physics-based virtual environment by revealing both the accuracy and real-time functionality of the simulation. The tests also exposed some system vulnerabilities in network communication and remote memory access processes. VSTM provides a description for mechanical engineers, of the necessary core network technologies needed to solve mechanics problems in new ways and join the community of computer scientists already at work in this arena.

Appendix

1.1 Computer science definitions

1.1.1 Process

A program is a file containing an instruction set, while a process is the running instantiation of the instruction set. A user can execute a program an arbitrary number of times, and each time can create a unique process. The user owns the processes. There is a special type of process, a daemon, which is not owned by a user, but is owned and managed by the operating system.

1.1.2 Sockets

A socket is the standard underlying software interface for computer network communications. Sockets operate with four basic steps whose functionality can best be described with a “telephone” analogy. First, a process creates the socket with use of the socket function; this is analogous to installing a telephone jack in the wall. Next, the process invokes the bind function, which is analogous to associating a number with the telephone. The invocation of the listen function is analogous to notifying the telephone company that the telephone is ready to receive calls. At this point the process issues the accept function which is analogous to picking up the telephone once it rings. Meanwhile, a remote process invokes two functions—socket and connect—and then the two processes, can read and write to each other.

1.1.3 Fork/exec

A fork is a system function, which enables a process to copy of itself. Both the original and the copy continue execution from the point of the fork, and also enable a process to determine if it is the original or the copy. When a process makes an exec function call, it stops what it was doing and replaces itself with a new process; basically, the exec function instantiates an entirely new program. Used in conjunction with a fork, this is a powerful mechanism allowing one process to instantiate another. For example, after a process forks a child process, the child identifies itself and then execs a different process in its place. In this way, one parent process can control other processes.

1.1.4 Shared memory

Using shared memory technology, two or more different processes on the same computer can access a common block of memory. This is a convenient tool for allowing different processes to communicate and share data. Of course complications would arise if two or more processes wanted to write to the same common block of memory at the same time or if a process wanted access to results before they were ready—use of semaphores prevent this.

1.1.5 Semaphores

Semaphores can be used to regulate access to certain resources such as shared memory. A semaphore is basically a data structure, which can be shared by multiple processes. Each process can set values in this common data structure, and before the CPU enters a critical section of an instruction set (e.g., update shared memory), the CPU checks the value. If the semaphore is locked (perhaps set to a certain value), the CPU must wait. If the semaphore is not locked then the CPU raises the semaphore (to lock it) and enters the shared memory arena. Once it completes its work the CPU lowers the semaphore (to unlock it), freeing this critical resource for use by another process.

1.1.6 Client/server model

A server process is structured so that it runs on a certain computer, as a daemon, and waits for service requests from client processes running on other computers. The clients communicate with the server through a socket, and request functionality. Upon receipt of a request from a client the server will fork a copy of itself. The child copy then execs the requested functionality, while the original parent returns to receiving new requests from other clients.

1.1.7 Distributed processing

Distributed processing is a method for solving large-scale problems, which can be easily decomposed into smaller processes. The smaller processes are distributed on various remote computers, which must then deliver the results back to one central process. The main drawback of the distributed processing model is that memory cannot be readily shared between computers: it must be communicated via some method such as sockets or SSH.

1.1.8 Ssh

Secure shell (SSH) is a methodology that enables one process to log onto a remote computer over a network to execute commands on that remote computer. A process can also use SSH to transfer files between computers, but the goal here is to instantiate processes. User intervention is not required. SSH functionality is layered on top of the standard socket libraries.

1.2 The finite element (FE) method

The deformation of a continuum occupying the region Ω₀ at time t = 0 is described by a differentiable deformation map ϕ between the current position x in Ω_t at time t and the position X at time t = 0:

$$ x\, = \,\phi \,(X,\,t\,). $$

(1)

The formulation in Eq. 1 is referred to as the Lagrangian (material) formulation.

Let σ, ρ, b, v ≡∂X/∂t, and Dv/Dt denote the Cauchy stress tensor, mass density, body force per unit mass, velocity vector, and acceleration vector, respectively. The deforming continuum satisfies Cauchy’s equations of motion (2), the rate constitutive relations (3), and the flow rule for the irreversible (plastic) part of the rate of deformation tensor d _p, and the boundary conditions on velocity v, and traction h on ∂Ω_t (the boundary of Ω_t) (4).

$$ \nabla \cdot \,\sigma \, + \rho b = \rho \,\frac{{D\,v}} {{D\,t}}\,\,\,{\text{in}}\,\,\Omega _{{\,t}} , $$

(2)

$$ \,\frac{{D\,\sigma }} {{D\,t}} - \omega \, \cdot \,\sigma - \sigma \, \cdot \,\omega ^{{\,{\text{T}}}} = C_{{\,{\text{el}}}} \,:\,\,(d - d_{{\,p}} )\,{\text{in}}\,\,\Omega _{{\,t}} , $$

(3)

$$ v\,{\text{or}}\,h = \sigma \, \cdot n {\text{specified on }}\partial \,\Omega _{{\,t}} . $$

(4)

where D( )/Dt denotes the material time derivative (by keeping X fixed), C _el is the elastic modulus tensor, ω ≡∇ × v(= curl v), and d ≡(∇v + v∇) is the rate of deformation tensor. In the FE formulation, the deformation map is interpolated at each nodal point, i.e., at node k, x _k  = ϕ(X _k ,t). The weighted residual form (5) of (2) and (4) is integrated over each finite element with respect to the virtual velocity δv that vanishes on ∂Ω_t where v is prescribed:

$$ < \delta d,\,\sigma > _{{\,\Omega }} = \langle \delta v,\,\rho {\left( {b - \frac{{Dv}} {{Dt}}} \right)}\rangle _{{\,\Omega }} + < \delta v,\,h > _{{\,\partial \,\Omega }} ,\, $$

(5)

where < , > _Ω and < , > _∂Ω denote the inner product over Ω_t and ∂Ω_t, respectively.

In most FE computations for solids, the Lagrangian formulation, x(X, t) and v (X, t), is employed where the FE mesh moves with the material points. Therefore, the computation of the acceleration term Dv/Dt simply becomes the partial derivative with time ∂v/∂t.