CRATE - CRATE v1.0.6

New Features and Improvements

• Introduce a finite-strain self-consistent scheme for the estimation of the (fictitious) reference material properties.

• A set including 2D and 3D examples is also added, along with the required documentation.

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira 8 months ago

CRATE - CRATE v1.0.5

New Features and Improvements

None

Bug Fixes

• Implemented handling of neglectable imaginary parts (tolerance with respect to machine epsilon of input type) stemming from spectral decomposition of symmetric second-order tensors;
• A new boolean parameter can be optionally passed to spectral_decomposition() to drop imaginary parts of eigenvalues and eigenvectors when these are close to zero (set False by default);

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 2 years ago

CRATE - CRATE v1.0.4

New Features and Improvements

• Avoid overhead cost by default when performing matrix condensation.

Bug Fixes

Some bugs were fixed in this release version:

• Fixed bug when building first Piola-Kirchhoff stress tensor for Paraview output under finite strains.
• Avoid state update kinematic post-processing when state update fails under finite strains.
• Fixed bug (missing argument) when writting voxels output file under finite strains.
• Fixed bug when checking adaptivity input parameters type.
• Fixed clusters strains initial iterative guess under clustering adaptivity.

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 2 years ago

CRATE - CRATE v1.0.3

New Features and Improvements

• JOSS publication. This release follows the review process of the Journal of Open Source Software.

• Improved documentation. Included CONTRIBUTING.md and CODEOFCONDUCT.md files.

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 2 years ago

CRATE - CRATE v1.0.2

New Features and Improvements

• Renaming Python package to cratepy. Given that there is already a Python package called crate deployed in PyPI, CRATE's Python package was renamed to cratepy.

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira almost 3 years ago

CRATE - CRATE v1.0.1

New Features and Improvements

• Included workflow to host Sphinx documentation on GitHub Pages. Documentation is deployed automatically whenever there is a push to the master branch.

Bug Fixes

• Hosting README.md images as GitHub gists. Images in the README.md file are now read from GitHub gists in order to be successfully displayed in PyPI.

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira almost 3 years ago

CRATE - CRATE v1.0.0

New Features and Improvements

This Pull Request includes a massive development of CRATE and yields the first version deemed ready for its open-source release. Besides many new code features and improvements, the new version includes a proper src/ layout, all the required Python package distribution files, a complete Sphinx documentation (with automatically generated API) and a directory of benchmarks. The coding style has also been improved, closely following the PEP8 guidelines, and a Flake8 configuration file has been included for the sake of coding style uniformity and automatic checking.

Below is a brief list of the main developments introduced in this version:

• Massive OOP refactorization.

• Extension of CRATE to finite strains.

• Enrichment of available matricial and tensorial operations and procedures.

• Improvement of FFT basic scheme implementation.

• Enrichment of homogenized strain-stress output file.

• Implementation of St.Venant-Kirchhoff anisotropic hyperelastic constitutive model.

• Implementation of general isotropic elasticity.

• Initial guess of RVE effective elastic tangent modulus available from the offline-stage.

• ASCA equilibrium problem converted to total formulation (total strains as primary unknowns).

• ASCA equilibrium formulation without the far-field strain was removed.

• Add input data file option to keep the reference material properties constant.

• The spatial discretization file directory can now be specified as a calling argument.

• Removed some clustering algorithms implementations (not validated).

• Removed some optimizers implementations (not validated).

• Add new output file with the CRVE effective tangent modulus.

• Add new input data file option to minimize the output to the essential.

• Generalized Swift strain hardening law to Nadai-Ludwik.

Bug Fixes

Several bugs were fixed during this development cycle.

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira almost 3 years ago

CRATE - CRATE v0.9.0

Description

A whole new Adaptive Clustering-based Reduced-Order Modeling (ACROM) framework is now implemented and working smoothly. Several new output files are now available and the output during the analysis is significantly enriched. New tools include a analysis rewinding framework and the storage of the CRVE final clustering. An important locking strategy is implemented to deal with the self-consistent scheme convergence issues. Additional progress is made in the OOP refactorization of the initial code modules. Some important bugs have been found and are now fixed.

New Features and Improvements

• Offline-stage flexibility. It is now possible to perform the offline-stage elastic analyses with Links (Finite Element Method) but the online-stage with CRATE. This procedure relies on a constitutive model source conversion that converts the material-related objects (properties and models) between Links and CRATE. This option is left turned ON by default, given that the SUCT procedures are more efficiently performed in CRATE (avoiding Python-Fortran-Python bridges). Later this option should be revisited and implemented in a more robust way.

• Reference material properties locking strategy. The admissibility of the self-consistent iterative solution is now always evaluated. If not admissible, then the last converged increment reference material elastic properties are considered to obtain an accepted solution. In the following macroscale loading increment, the self-consistent scheme is performed again as usual, being the solution admissibility evaluated again. The admissibility tolerance of the Young modulus is made relative to the reference material elastic tangent in the first increment and empirically set as 2.5%.

• New reference material output file. A new output file contains data associated with the reference material, namely its properties, incremental farfield strain and convergence metrics (normalized norm of difference between the incremental farfield strain tensor and incremental macroscale load strain tensor, normalized self-consistent scheme cost function, normalized norm of difference between the effective tangent modulus and reference material tangent modulus). Two output modes are available: 'iterative' outputs the reference material quantities at every self-consistent scheme iteration; 'converged' outputs the reference material quantities that converged at each macroscale loading increment (default).

• New voxel material-related output. A new output file contains material-related data at the voxels level every converged macroscale loading increment. This file is output as described in the section Voxel material-related output of CRATE's input data file and stored in the post-processing directory. A material-related quantities computer class is now available to compute standard strain and/or stress related quantities.

• CRVE effective tangent modulus. Implemented new option to compute the CRVE effective tangent modulus based on the solution of a linear system of equations (same results, more efficient). This computation is now only performed after convergence of the equilibrium Newton-Raphson iterative scheme. In addition, implemented validation procedure of the cluster strain concentration tensors (available for the SCA far-field formulation).

• Generalized Adaptive CRMP (GACRMP). Implemented a new user-defined parameter that is a threshold of the number of clusters of a given material phase. As soon as this threshold is surpassed, adaptivity procedures are locked and the material phase remains static up to the end of the simulation.

• Clustering adaptivity output file. A new output file contains data associated with the clustering adaptivity, namely the number of clusters and clustering adaptive step of each adaptive material phase, and several time measures (partial and total clustering adaptivity step times).

• Clustering adaptivity summary. A clustering adaptivity summary is now presented in the '.screen' file at the end of the online-stage., containing the partial and total number of clusters, and the partial and total computational times.

• VTK enrichment. Clusters adaptive level is now available for visualization in the VTK output, together with the equivalent von Mises stress and strain.

• Clustering adaptivity trigger. Macroscale loading increment where adaptivity conditions are triggered is now repeated with the new clustering. The alternative strategy, where the clustering adaptivity is performed in between increments, is still left in the code but is deactivated. Together with the new strategy is the option of an improved initial iterative guess for the clusters incremental strain after the clustering adaptivity is performed. The adaptivity manager now keeps count of the number of clustering adaptive steps performed on each macroscale loading increment. It is defined a maximum number of clustering adaptive steps per macroscale loading increment (set to 1, can be later converted to input file optional parameter if need).

• Pool of clustering adaptivity features. The pool of clustering adaptivity features is expanded, accounting for new features as well as the increment and/or norm options.

• Clustering adaptivity criterion class. A superclass AdaptivityCriterion is implemented to implement new clustering adaptivity criteria. Each adaptive material phase is now associated with a given instance of AdaptivityCriterion. The old 'non-spatial' criterion has been renamed 'Adaptive cluster grouping' and has now a dedicated class. A new clustering adaptivity criterion based on the evaluation of spatial discontinuities is implemented.

• Enriched Adaptive Cluster Grouping adaptivity criterion. New optional parameter ismergeadapt_groups: True if the adaptive cluster groups of the same adaptive level are to be merged, False if each adaptive cluster group follows an independent hierarchy.

• Number of child clusters. Redefined maximum number of child clusters based on parent cluster's volume fraction.

• Power dynamic split function. Implemented dynamic adaptivity split factor power function that allows a proper control of the number of child clusters (set linear by default). Magnitude is now employed to closely enforce the threshold number of clusters by sorting clusters in descending order (prioritizes higher magnitude clusters). Also, a new parameter is implemented for the spatial discontinuities selection criterion, whereby the magnitude associated to the lower valued targeted cluster is multiplied by a given factor comprised between 0 and 1 (default).

• Refinement of execution time summary. CRATE's execution time summary is further refined, being the accumulated post-processing time (both offline and online stages) accounted independently.

• Storing CRVE final clustering. The CRVE final clustering state can now be stored (overwrite) the '.crve' file after the online stage is performed. This procedure is only relevant if clustering adaptivity procedures are considered. Although the clustering adaptivity parameters can be updated in the following analysis, the clustering type of each material phase cannot be changed. If is required to consider a given adaptive material phase as 'static', simply set the associated clustering adaptivity frequency to None. This output can be performed as described in the section Final clustering state storage of CRATE's input data file.

• Cluster labels VTK output. Cluster labels are now relabeled from zero in the VTK output. This new relabeling method only affects the VTK output, maintains the relative position of the existent cluster labels and does not have any effect in static clustering analyses.

• Analysis rewind framework. New analysis rewinding framework that is controlled by two new classes (RewindManager and IncrementRewinder) and that allows the rewinding of the solution to a previously stored state while preserving the CRVE clustering. This framework can be properly used as documented in the section Analysis rewinding of CRATE's input data file, namely by selecting an appropriate rewind state and analysis rewinding criteria.

• OOP refactorization. Object-oriented refactorization of homogenized results output module and VTK output module.

Bug Fixes

• Reference material elastic tangent and compliance. Fixed the update of reference material elastic tangent and compliance tensor in the first SCS iteration after a macroscale loading increment cut.

• GACRMP parent class. Set GACRMP parent class as ACRMP.

• VTK collection file. VTK collection file ('.pvd' file) is now always working, even if the simulation is interrupted or does not converge successfully up to the end. In addition, time steps file path is now relative (VTK/...) so that '.pvd' file keeps working smoothly even when the analysis directory changes.

• CRVE number of clusters. The CRVE class has a new attribute (basephasenclusters) which stores the prescribed (base clustering) number of clusters for each material phase and that is now used to perform the base clustering. The CRVE attribute phasen_clusters is now continuously updated if there are new clusters coming from adaptive procedures.

• Cluster labels of different ACRMP. Cluster labeling was raising errors with two or more adaptive material phases. A new CRVE method has been implemented to get the CRVE maximum cluster label to solve this issue.

• Matrix condensation function. Turned off check validation procedures in matrix condensation function: insane computational costs when dealing with large data matrices!

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 4 years ago

CRATE - CRATE v0.8.0

Description

Implemented a Generalized Adaptive Cluster-Reduced Material Phase (GACRMP).

New Features and Improvements

• Generalized Adaptive Cluster-Reduced Material Phase. Implemented a new type of clustering adaptivity coined Generalized Adaptive Cluster-Reduced Material Phase (HACRMP) that essentially performs the adaptivity of each target cluster by performing the prescribed adaptive clustering scheme (similar to the base clustering scheme for the material phase domain). Taking advantage of the recently introduced CRMP class, which ensured that all the clustering procedures can now be prescribed independently and in a total general way for each material phase, this type of adaptivity is deemed as the most simple and general in the sense that a complete cluster analysis is performed for each target cluster.

• Adaptivity hyperparameters. It is important to remark that no studies have been made yet in order to evaluate the impact or best suited values for the clustering adaptivity hyperparameters (for both adaptivity criterion and adaptivity types). The default values left in the code have been established based on some preliminary examples, but are by no means the optimal values.

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira about 5 years ago

CRATE - CRATE v0.7.0

Description

This new release version accounts for a significant improvement of the clustering related code OOP design and brings 2 main improvements: (1) the generalization of the CRVE class as a composition of cluster-reduced material phases (CRMP) and (2) the introduction of adaptive cluster-reduced material phases and associated online clustering adaptivity.

New Features and Improvements

• Massive clustering OOP refactoring. The code structure associated with the Cluster-Reduced Representative Volume Element (CRVE) has been massively refactored with significant changes in the underlying classes and methods. The CRVE has a main class containing all the required public methods and is composed by one or more Cluster-Reduced Material Phases (CRMP).

• Cluster-Reduced Material Phases. A new abstract class (CRMP) has been implemented allowing that each material phase is treated in a truly independent manner. This results in a significant increase of CRATE's flexibility, given that all the clustering procedures can now be prescribed independently for each material phase (clustering algorithm, clustering features, clustering parameters, etc.). The most basic type of CRMP is coined Static Cluster-Reduced Material Phase (SCRMP), meaning that the base clustering computed in the offline stage is kept constant during the solution procedure.

• Clustering adaptivity. Besides the above improvements, CRATE has now the first clustering adaptivity scheme in the world! A coined Adaptive Cluster-Reduced Material Phase (ACRMP) has been implemented as a new abstract class and a particular type of ACRMP, coined Hierarchical Agglomerative Adaptive Cluster-Reduced Material Phase (HAACRMP), has been derived. This ACRMP performs the clustering adaptivity by resorting to an hierarchical agglomerative clustering algorithm and to the underlying linkage matrix. Although it behaves as expected and shows that the idea is feasible, this approach is severely limited due to prohibitive memory requirements associated with the computation of the distance matrix of the base clustering dataset (around 50000 voxels). In addition, a naive non-spatial adaptivity criterion has been developed and implemented in order to select the adaptivity target clusters.

• New keywords. Associated with the new features and improvements is a set of new keywords whose specification is documented in CRATE's input data file in the sections Cluster Analysis Scheme, Clustering Adaptivity Frequency and Clustering Adaptivity Output. The first allows a completely general prescription of each material phase clustering procedures, including the definition of base and/or adaptive clustering schemes (clustering algorithms and clustering features) and clustering adaptivity parameters. The second controls the frequency of the clustering adaptivity analysis of each adaptive material phase relative to the macroscale loading incrementation. Finally, the last switches on the output of data to the '.screen' file associated to each clustering adaptivity step (execution of adaptivity procedures, number of clusters and execution time table).

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira about 5 years ago

CRATE - CRATE v0.6.0

Description

Included additional clustering algorithms to compute the Cluster-reduced Representative Volume Element (CRVE) and two algorithms to perform the standardization of the global clustering data matrix.

New Features and Improvements

• New clustering algorithms. Among the myriad of clustering algorithms proposed in the literature, some clustering algorithms have been selected and are now available in CRATE besides the standard k-Means clustering algorithm. These clustering algorithms were added following three criteria: (1) first, their implementation availability in open source packages or repositories, (2) second, their suitability to efficiently handle large datasets and (3) third, their potential to develop advanced clustering-based analysis strategies. In this regard, it is important to remark that the appropriate characterization of the feature data space and clusters shape, and the actual performance of clustering algorithms has not yet been made. Such studies may reveal that some of the clustering algorithms included in this version are in fact not suitable or, in alternative, suggest that additional clustering algorithms are required. The clustering algorithms available in this version are:

1. K-Means (source: scikit-learn);
2. K-Means (source: pyclustering);
3. Mini-Batch K-Means (source: scikit-learn);
4. Agglomerative (source: scikit-learn)
5. Agglomerative (source: scipy)
6. Agglomerative (source: fastcluster)
7. Birch (source: scikit-learn)
8. Birch (source: pyclustering)
9. Cure (source: pyclustering)
10. X-Means (source: pyclustering)

• Different implementations of the same clustering algorithm are included for non-dependence of a single source and/or to benefit from additional methods available from different sources. Moreover, most of the clustering algorithm's hyperparameters are left with the default values from the original implementation source (i.e., have not been tuned by any means). The choice of a given clustering algorithm is made from the already existent clustering scheme keyword (specification documented in CRATE's input data file in the section Clustering scheme) .

• Clustering data standardization. The global clustering data matrix is now standardized before the cluster analysis procedure through one of two available and commonly used standardization procedures: (1) Min-Max Scaler (default); (2) Standard Normal Distribution Scaler. The standardization method can be prescribed as usual through an associated keyword specification (specification documented in CRATE's input data file in the section Clustering data standardization).

Bug Fixes

• Self-Consistent Scheme. The default self-consistent scheme has been changed to the regression-based scheme and CRATE's input data file documentation has been updated to reflect the optional nature of this parameter.

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 5 years ago

CRATE - CRATE v0.5.0

Description

Generalization of the clustering scheme underlying the computation of the Cluster-reduced Representative Volume Element (CRVE), bringing new interfaces to implement additional cluster analysis' features and clustering algorithms.

New Features and Improvements

• General clustering scheme. A fairly general clustering scheme can now be prescribed (specification documented in CRATE's input data file in the section Clustering scheme) to generate the Cluster-reduced Representative Volume Element (CRVE). It is possible to prescribe one or more RVE clustering solutions where each is obtained with a given clustering algorithm and based on a specified set of physical-based clustering features. If more than one RVE clustering solution is prescribed, then a clustering ensemble strategy or method must be prescribed (specification documented in CRATE's input data file in the section Clustering ensemble method) in order to get a unique RVE clustering solution (consensus clustering solution).

• Refactoring and OOP reimplementation. Both old clusteringdata and clustering modules have been completely refactored and implemented under the OOP paradigm. The implemented classes deal effectively with the general clustering scheme previously described and bring two major advantages: (1) it is now pretty easy to implement new physical-based clustering features to be used as a basis for the RVE cluster analysis and (2) it is equally straightforward to implement (from scratch or from open sources) additional clustering algorithms. An interface has also been implemented for the homogenization-based multiscale methods required to compute the RVE local elastic strain response database. Despite being working properly, this interface still needs to be further improved in a later version.

• Output update. The output to the default standard output device (generally the terminal command window), stored in the output .screen file, has been updated and provides more information about the computation of the cluster analysis' features and the generation of the CRVE.

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 5 years ago

CRATE - CRATE v0.4.0

Description

Significant efficiency upgrade associated with the computation of the clustering interaction tensors (accounting for cluster-symmetry).

New Features and Improvements

• Cluster interaction tensors cluster-symmetry. The cluster interaction tensors are symmetric relative to the associated clusters when weighted with the corresponding cluster volume fractions. The implementation of the cluster interaction tensors computation has been updated to take into account this cluster-symmetry. By avoiding the explicit computation of all cluster interaction tensors, the new implementation leads to a significant decrease of the computational time required to perform this operation: the speedup mainly depends on the problem dimension and on the total number of clusters, increasing with an increase of either one of these parameters.

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 5 years ago

CRATE - CRATE v0.3.0

Description

This release brings a powerful algorithmic technique in order to deal with convergence failures arising from different sources (equilibrium iterative scheme, self-consistent iterative scheme, state update, etc.): macroscale loading subincrementation. Instead of simply aborting the analysis under such circumstances, a macroscale increment cut procedure is raised with the goal of achieving the solution through a more discretized loading path. Given that the loading incrementation is dinamically adapted during the solution procedure, this technique may also significantly improve the efficiency of nonlinear microscale equilibrium analyses by reducing the total number of load increments to perform the complete analysis.

New Features and Improvements

• Macroscale loading subincrementation. In order to deal with potential convergence failures (equilibrium iterative scheme, self-consistent iterative scheme, state update, etc.), an automatic subincrementation strategy has been implemented. When a converge failure occurs, the current macroscale load increment magnitude is cut in half in an attempt to ease the solution convergence by performing a smaller step in the deformation path. Each time the increment magnitude is cut in half, the subincrementation level is incremented by 1, being decremented by 1 when the increment magnitude is doubled. The level 0 corresponds to the actual prescribed increment magnitude.

• Progressive subincrementation. The subincrementation procedure follows a progressive recovery strategy to be as efficient as possible. When a convergence failure occurs, the required number of increment cuts is performed until convergence is (hopefully) achieved, incrementing the subincrementation level accordingly. However, when both subincrements resulting from an increment cut converged, the following increment magnitude is doubled (subincrementation level is decremented by 1) in order to recover towards the prescribed increment magnitude (level 0).

• Subincrementation limits. Two parameters are implemented to control the extent of the subincrementation scheme. The first is the maximum subincrementation level (specification documented in CRATE's input data file in the section Maximum loading subincrementation level) and the second is the maximum number of consecutive increment cuts (specification documented in CRATE's input data file in the section Maximum loading consecutive increment cuts). Both these parameters are optional and assume default values if not specified.

• Output update. The output to the default standard output device (generally the terminal command window), stored in the output .screen file, has been updated to account for the new macroscale loading subincrementation strategy. When the subincrementation level is greater than 0 (i.e., the increment magnitude is lower that the prescribed one), the current subincrementation level is displayed after the global increment number.

• Vanished errors. Some previously implemented errors have been removed because the convergence failure handling is now done by activating the increment cut procedure.

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 5 years ago

CRATE - CRATE v0.2.0

Description

This release essentially brings enhancements associated to the macroscale loading constraints: (1) it is now possible to enforce general non-monotonic loading paths of strain and/or stress constraints by specifying one or more loading subpaths; (2) a completely general incrementation scheme is now available for one or more loading subpaths; (3) the (pseudo-)time associated with the macroscale loading enforcement can now be prescribed. The output to the default standard output device is also being updated to include further information about the current loading increment status!

New Features and Improvements

• Non-monotonic loading paths. It is now possible to enforce general non-monotonic loading paths of strain and/or stress macroscale constraints. The global loading path is now composed by one or several loading subpaths, being each loading subpath completely general (strain/stress components prescriptions) and independent from each other. The specification of the macroscale loading is documented in CRATE's input data file in the section Macroscale loading.

• General incrementation option. Besides the previous macroscale loading incrementation option (keyword Number_of_Load_Increments, whereby it is prescribed an equal-magnitude number of increments in all loading subpaths, it is now possible to prescribe a completely general incrementation scheme for each loading subpath (keyword Increment_List). The specification of the macroscale loading incrementation is documented in CRATE's input data file in the section Load Incrementation.

• Loading (pseudo-)time. The (pseudo-)time associated with the macroscale loading incremental enforcement can now be optionally prescribed either explicitly (through the Increment_List incremental scheme) or through the keyword `LoadingTimeFactor' (coefficient that is multiplied by the incremental load factor to get the incremental load time). Unless overwritten by any of the previous options, the incremental load time is made equal to the incremental load factor. The specification of the macroscale loading (pseudo-)time is documented in CRATE's input data file in the section Loading Time.

• Output update. The output to the default standard output device (generally the terminal command window), stored in the output .screen file, has been updated to account for the new macroscale loading enforcement features. Besides the global increment number, each macroscale increment header now contains useful data from the current loading subpath (subpath id, increment, total and incremental load factors, total and incremental times).

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 5 years ago

CRATE - CRATE v0.1.0

Description

This is the first release of CRATE, a hopefully stable version that serves as a solid foundation for future developments.

New Features and Improvements

None

Bug Fixes

None

Scientific Software - Peer-reviewed - Python
Published by BernardoFerreira over 5 years ago