What's new in WARP3D 17.5.9
May 22, 2015
- A significant new capability is now available to output key state variables for the material models, including user-provided UMATs. Such variables include, for example, the backstress components for kinematic hardening in plasticity, elastic strain components for plasticity, equivalent plastic strain rates, detailed slip system status for the crystal plasticity model, etc. State variable output is provided in flat files of element results (text or stream format).
- The WARP3D interface to UMATs and other Abaqus compatible user-routines has been expanded and re-organized. Appendix I on User-Routines has been re-written to describe these improvements.
- The warp3d2exii post-processing program has undergone significant updates and improvements. Earlier versions of this program were named pat2exii. This is a Python program that reads a WARP3D generated flat file for the model description and flat files of nodal and elements results (including new state variables mentioned above) then produces an ExodusII (.exo) database file. We use this capability to enable post-processing with ParaView.
- Processing of user-delined multi-point constraints and those generated automatically by tied mesh operations is much improved. Earlier code versions forced an un-necessary increase on the number of global Newton iterations required for convergence (solutions were correct by computations required un-necessary time).
- Two new tests are now available for the global Newton iterations in each load (time) step. The new tests examine absolute, rather than relative, values of the corrective displacements in each Newton iteration. Multiple tests may be declined and all must be satisfied for convergence. The description of convergence tests has been expanded and clarified.
- The command to request a user-routine to generate incremental nodal loads/temperatures for a load(time) step may now supply a file name to be passed to the user nodal loads routine.
- The batch messages command is extended to support a user-specified file name in addition to the previously used default name based on the structure name specified in the input.
- The user list command now has an option to display the coordinates of nodes in the specified/generated list.
- Much internal re-structuring, not visible to users, to improve maintainability of the source code.
New in WARP3D 17.5.6 (Feb 11, 2015)
- The plane option of the constraints command now offers more control over the distance proximity checks and provides additional output on the distance checking. Similar improvements are included in the list command (Section 2.16).
- A new output capability that simplifies significantly the specification of analyses with many load(time) steps. A file of output commands may be defined that will be executed automatically after each step in a specified list of steps. Such automatic output can also be mixed with additional output commands given after specific load steps as in the past.
- Asymmetric equation solvers are now available for the systems of equations that derive from the crystal plasticity model. Asymmetric systems have symmetry of the non-zero locations in the as- sembled equations but non-symmetric numerical values. The asymmetric solver requires twice the amount of memory and twice the equation solving time for each global Newton iteration { the savings in solution time can arise from the reduced number of global Newton iterations. The asymmetric option is available in threads only execution via the Intel Pardiso solver direct and iterative options Section 2.10.2).
- Output strain values for solid element in finite strain/rotation analyses are now given by the summed increments of unrotated strain, delta d rotated to the fixed-global axes using R from the polar de-composition, F = RU. These values match closely those output by Abaqus which uses summed, incrementally rotated values over the loading history. See Section 1.8.6 for additional details.
- A new output capability to write at files of nodal and element results. These files have the simplest possible structure of a 2D array with no other readable information. The at files are provided in text or stream binary) forms. The text files may be read directly using Python ( loadtxt imported into Excel, Matlab, Mathematica or read easily with C, C++, Fortran programs. The stream files may be read with fromfile in Python; Matlab and Mathematica using binary stream I/O, and using standard stream operators in C, C++ and Fortran (2003 and later).
- Similar to the at results files, a new output capability is available to write a simple, flat fille for the model description. The .text file includes the number of nodes/elements, coordinates of nodes and element data (type, material assigned to element and nodes to which the element connects). The file structure is designed to be read very efficiently by Python, imported into spreadsheets, read by C, C++, ... programs. Appendix K includes sample Python programs to read this model description file and the various at results files.
- Manual Chapter 1 has been re-written, updated and expanded with a wider range of example analyses/discussion and an expanded discussion of theoretical developments implemented in the code. A new capability is available to release absolute constraints on nodes during the solution. The corresponding reactions are relaxed uniformly to zero over the specified number of load (time) steps.
- Node releases are continued across analysis restarts if required and are integrated into the adaptive step subdivision of the nonlinear solution.
- The capability to write the equilibrium equations to a file at any time during a nonlinear analysis is described in Section 2.10.16. These files may become quite large (10s GB) for large models. Moreover, users may want to read the equations for processing with C and C++ programs. The solver file now uses the access=stream capability now available in Fortran.
- The manual section on multipoint constraints is updated to clarify the more general command syntax, limitations that the equations must be homogeneous, and assumptions the WARP3D equation solver makes about dependent vs independent displacement components.
New in WARP3D 17.5.0 (Mar 26, 2014)
- A new capability is available during the global Newton iterations to detect a likely diverging solution. This option is “on” by default. When a divergent sequence of iterations is detected, the adaptive solution procedure is triggered immediately (if enabled).
- A user solution parameters routine is now available. See Section 2.10 and Appendix I for full details. This routine is called before the analysis of each load (time) step. The routine may change (1) values of variables that control the nonlinear solution process and (2) the incremental loading definition or the upcoming step. May be valuable, for example, in complex nonlinear simulations to modify load (time) step definitions on-the-?y based on the convergence history of the last few load steps. \
- All user-routines are now collected into the user routines.f ?le replacing the older umats.file. The distributed version of this .f ?le has example implementations of all user routines.
- The crystal plasticity (CP) model now has an exact consistent tangent to accelerate convergence of global Newton iterations. Computational efficiency in the CP routines is also improved.
- The Pardiso equation solver now (automatically) uses threaded reordering to increase performance.
- The routines to write a restart file and to read a restart ?le now use a segmental structuring of data which improves performance and eliminates occasional runtime issues with file buffering.
- Increased to 5,000 the maximum number of loading conditions (patterns)
New in WARP3D 17.4.0 (Aug 20, 2013)
- New crystal plasticity material model for rate and temperature dependent simulation of microscale
- plastic
- ow in metals. Includes options for simple gradient-based geometric hardening, which incor-
- porates the e ect of necessary dislocations on the hardening properties of the material.
- Expanded solution capabilities during MPI-based execution: (1) the sti ness assembly process is now
- performed using a distributed approach across the MPI ranks, (2) the hypre solver now includes an
- option for the BoomerAMG pre-conditioner (parallel implementation of algebraic multigrid).
- The interface-cohesive elements now support hardcopy and binary packet le results for tractions
- and displacement jumps. Derived values applicable to each type of cohesive material option, e.g.,
- linear, ppr, etc. are also provided in the output. Manual Section 3.3 has been re-written to better
- describe the formulation and various options for the interface elements.
- Nodal temperatures may now be requested in printed output, Patran compatible result les and in
- binary packet les.
- A new option for the linear sti ness on iteration 1 of a load step has been added that often simpli es
- input. The new option invokes the linear sti ness only for the next load step.
- The extrapolate displacements option often improves convergence characteristics of the global Newton
- solution. However, when the compute processors detect the next step is non-proportional with the
- prior step, the displacement extrapolation is suspended just for the new step. The linear sti ness
- for iteration 1 is also invoked. Both measures tend to improve convergence of the global Newton
- iterations for strong load direction changes between steps.
- The batch message system that writes messages to a le during execution has been streamlined to
- compress the messages. The batch message le summarizes the solution status during each global
- Newton iteration. The le enables simple monitoring of long executions executed in batch (back-
- ground) job management systems often used on shared computer systems.
- The cpu time limit option has been changed to the wall time limit option to re
- ect that most all
- modern analyses run in parallel. Wall clock time, not CPU time, becomes the relevant measure of
- solution resources consumed. The batch message les now provide wall clock time rather than CPU
- time.
- Older solvers removed: element-by-element (EBE) conjugate gradient, NASA, VSS sparse direct
- solvers. The hypre iterative solver for MPI-based execution replaces the EBE solver. The MKL-
- Pardiso solver has direct and iterative capabilities for threads-only execution.
- With removal of older solvers, user input requirements for solution parameters are much simpler.
- Requirements for vectorized blocking of elements in certain situations has been removed with sim-
- pli cation of options for equation solving.
- The startup process (Bash shell script) for MPI-based (+ threads) executions has improved reliability
- and speed in starting MPI processes.
- patwarp updated-simpli ed to remove vectorized blocking options and to remove options for EBE
- solver.
- Signi cant cleanup, streamlining, error- xes and re-writing of code throughout.
New in WARP3D 17.3.2 (Oct 18, 2012)
- The blocking command has been extended to provide automatic assignment of elements to blocks for the most common analyses performed with WARP3D. The automatic blocking feature is applicable for: (1) threads-only parallel execution on Windows, Linux, Mac OS X, (2) use of the Pardiso sparse equation solver (either direct or iterative). For other, much less common situations (EBE solver and/or MPI+threads execution), the blocking information must be provided in the input as in prior versions of the code.
- The recently added UMAT feature provides a very convenient means to incorporate new material constitutive behaviors. WARP3D expects the UMAT routine and all supporting routines to be written using thread-safe principles – parallel processing of element blocks will invariably invoke multiple instances of the UMAT concurrently. Many older UMATs use COMMON blocks (not thread-safe), are often exceedingly complex and cannot be easily re-written to make them thread-safe. An option in the nonlinear analysis parameters command is now available to request serial (1 thread) execution of element blocks using the UMAT during only the stress update for non thread-safe UMATs. See
- Appendix J.
New in WARP3D 17.3.1 (Oct 18, 2012)
- Nodal forces and temperatures for loading patterns may now be set by a user-defined nodal loads subroutine. This option replaces the often lengthy text-based definition of forces and temperatures in the model definition. The user nodal routine is invoked by the solution processor at the beginning of each load step which enables the routine to provide a potentially complex history of nodal force/temperature increments over the analysis.
- For material models that require access to the deformation gradient, [F], an [ ¯ F] formulation is now used for the linear (8-node) brick element. The computations to set [ ¯ F] employ a mean-dilatation approach.
- The displacement extrapolation algorithm now detects when non-proportional, incremental loading exists for a step. The extrapolation procedure is suspended temporarily just for that step. This simplifies managing solution options when load reversals occur in cyclic loading protocols.
New in WARP3D 17.3 (Oct 18, 2012)
- WARP3D can now integrate existing Abaqus compatible UMAT routines to support user-defined material behavior. The UMAT routines are invoked from within (thread) parallel processing of element blocks. The UMAT thus has full benefit of parallel processing already designed into WARP3D. See Section 3.11 and Appendix J.
- Major changes have been made to internal data structures and algorithms that impose non-zero displacement and temperature increments over a load step. Testing reveals a generally reduced number of equilibrium iterations for convergence. No changes in the manual.
- Updated descriptions of element blocking requirements. See Section 2.6 specifically if you make use of computational material models cyclic, mises hydrogen, and umat.
New in WARP3D 17.2 (Oct 18, 2012)
- A new feature called user named lists of integers is now available as described in the new Section 2.16. The list command generates named lists of nodes or elements using a variety of geometric procedures, e.g., define a list containing the nodes that lie on the surface of a cylinder. The named lists can be referenced in all other commands that require input of an < integerlist > such as constraints definition, output requests, loading definitions, domain integral definitions, etc.
- An option to simplify the use of input files constructed partly from Abaqus models is available. The definition of face loadings on hex elements and the definition of surfaces for tied-meshing now have an abaqus option to convert Abaqus face numbers during input to WARP3D face numbers. See
- Sections 2.7.6 and 3.1.5.The ordering of element nodes is the same in Abaqus and WARP3D.
- Lines beginning with ! or # in column one are now treated as comment lines in the input. Lines beginning with c or C in column 1 followed by a blank continue to be treated as comment lines as well. Blank lines in the input are ignored.
- The definition and interpretation of strain output for nonlinear geometry analyses have been updated. Output values now correspond to the approximate logarithmic strain on the current configuration.
- See manual section 3.1.6.
- More sections of the manual are now in LaTeX format and include revisions and corrections. Recently converted sections include 1.3, 1.7, 2.1-7, 2.10, 2.13-16, 3.1-3, 3.8, 3.10, 5.1, 5.4, Chapter 7 and the Appendices. Eventually the entire manual will be in LaTeX. Source files for the manual will be included in the distribution.
New in WARP3D 17.1 (Oct 18, 2012)
- A new feature called “tables” is implemented with the table command (new Section 2.14). This is a general capability now and for future to define large 2D tables of floating point data values for use in various aspects of model definition. For now, tables are used to define parameters for “piston”
- loading on surfaces of solid elements.
- Piston theory loadings define unsteady aerodynamic pressures applied on the surfaces of solid elements. Piston theory provides a simplified (quasi-1D) model to estimate local pressures (center of element surface) for the current velocity of the surface and orientation relative to airflow direction.
- The piston pressures are time varying and strongly dependent upon instantaneous motion of the element surface. The availability of piston loadings can eliminate costly and inconvenient coupling/
- iterations between structural analysis and separate loading programs in large-scale simulation work. See updated descriptions of hex and tet elements in Sections 3.1 and 3.2 (and required use of the table command in Section 2.14).
- The model solution time is now output with messages issued about completion of the solution for loads steps. Model solution time is the integral of the user-specified time increment, R dt, specified in nonlinear solution parameters.
- Various messages issued during solution displayed the cpu time consumed by the code to that point in execution. With nearly all analyses running now in parallel, these messages have been changed to display elapsed wall-clock time since the start of execution.
New in WARP3D 17.0 (Oct 18, 2012)
- A new approach to execution on hybrid (MPI+threads) computers is now available with inclusion of the hypre equation solver from Lawrence Livermore National Labs. Hypre solves the linear equations for each global Newton iteration using variants of preconditioned conjugate gradients. The solver is designed specifically to maintain very high scaling efficiency as the number of MPI ranks increases into the hundreds and perhaps thousands. Our implementation runs WARP3D on MPI rank 0 with threaded parallel execution and invokes hypre for each equation solve. Hypre spawns/releases
- additional MPI ranks for just the equation solving phase. This approach maintains the simplicity of WARP3D input files for threads-only execution (no domain decomposition) with the opportunity for very high parallel efficiency across tens-to-hundreds (perhaps a thousand) of processors during
- equation solving phases.
- The generalized plasticity option of the cyclic plasticity model has been extended to include temperaturedependent material properties (E, , 0, ...). This model offers behavioral and computational advantages over the more traditional Armstrong-Frederick model (also available as an option of the cyclic material model).
- Updated manual sections: 1.7 (Equation Solvers), 2.2 (Material Definitions), 2.6 (Element Blocking), 2.10 (Solution Parameters), 3.10 (Cyclic Plasticity Model), Chapter 7 is entirely re-written to introduce the hypre solver option and the needed details to start execution of WARP3D, Appendix I now
- contains material describing the element-by-element conjugate gradient solver, Executive Summary, Contents, etc. We are still in the transition phase to eventually convert the manual to LaTeX.
- README files for each platform and the general file included in the distribution have been significantly updated.
- A number of stubborn bugs that previously slowed threaded execution during stress update have been eliminated (we had work around code to force serialization in a few locations). All work around code is now removed.
- We are building interfaces between WARP3D and the Exodus II database system used by a number of pre- post-processor codes. Watch for new developments.
- The compilation process on all three platforms (Windows, Linux, OS X) is updated to use the current releases of the Intel compilers and the Math Kernel Library (which has the Pardiso solver).
New in WARP3D 16.3.1 (Oct 18, 2012)
- The cohesive material model is expanded significantly to incorporate the Paulino-Park-Roesler formulation (ppr ) that properly models mixed-mode fracture. The model supports independent specification of the fracture energies and peak tractions for normal and shear deformation modes. The
- model couples normal and shear fracture processes through the use of a polynomial-based potential function.
- The interface-cohesive, crack growth processors and adaptive algorithms are updated to include the ppr option.
- The binary packets file now includes results from interface-cohesive elements with the ppr option
- The WARP3D interface to the Intel (Pardiso) solver is re-written to also support the Krylov iterative option in addition to the previously support, continually improving, sparse direct solver in Pardiso.
- The iterative version uses occasional sparse Choleski factorization of assembled equations to define the pre-conditioner. When the iterative process develops convergence issues, Pardiso switches to the direct solver automatically.
- The conversion of binary packets files to ASCII files has been deleted as no longer needed to move files across hardware platforms.
- Updated manual sections: Appendix F (binary packets file):
- Introduction to Crack Growth,
- Crack Growth Using Interface-Cohesive Elements,
- Interface-Cohesive Elements (re-written for improved clarity),
- Material Model Type: cohesive,
- Solution Parameters,
- Output
- Requests, Table of Contents
- The compilation process for WARP3D on all three supported platforms has been moved to Intel Composer XE system.
New in WARP3D 16.2.7 (Oct 18, 2012)
- The domain integral processor has a new feature that enables user-defined tangent vectors at crack front nodes. This option provides a means to remedy domain dependent J-values, for example, when the crack front in the discrete mesh intersects a symmetry plane with a kink angle, rather than smoothly at a right angle. This can occur when quadratic elements on the crack front are created with straight edges that define a chordal approximation to an otherwise smooth curve. Coarse meshes of linear elements also have this same issue. This feature will prove most useful for J evaluation at symmetry planes and where the crack front intersects a free surface. For meshes with sufficient
- resolution and/or front elements with curved edges, the automatic tangent vectors computed by WARP3D are adequate.