llnl / librom Goto Github PK

Model reduction library with an emphasis on large scale parallelism and linear subspace methods

License: Other

C 1.46% C++ 88.90% Shell 2.65% Fortran 2.13% CMake 3.65% MATLAB 0.73% Dockerfile 0.39% Python 0.08%

scientific simulation modeling model-reduction large-scale parallel-computing reduced-order-models subspace-learning math-physics

librom's Introduction

Introduction

libROM is a free, lightweight, scalable C++ library for data-driven physical simulation methods from the intrusive projection-based reduced order models to non-intrusive black-box approaches.

The best starting point for new users interested in libROM's features is to review the examples. The code documentation provides more details about libROM's classes and functions.

Features

Dynamic data collection
Dynamic mode decomposition (DMD)
Data compression
Physics-informed greedy algorithm
Projection-based hyper-reduction
EQP: quadrature-based hyper-reduction sampling algorithm

Features to be added

Python interface

Installation

To compile libROM with default build settings (Mac and LLNL LC Machines):

 ./scripts/compile.sh

Compilation options:

-a: Compile a special build for the LLNL codebase: Ardra
-d: Compile in debug mode.
-m: Compile with MFEM (required to run the libROM examples)
-t: Use your own cmake/toolchain
-u: Update all of libROM's dependencies.

Compiling on LC Machines

libROM provides several CMake toolchains which can be used to compile on LLNL LC machines. For more information on installing and using libROM on specific LC machines, refer to this wiki page.

Installing via Spack

There is a Spack package for libROM; however, the version it installs is the latest public release. See the spack documentation for details on how to use Spack.

To install libROM with default options using spack.

 spack install librom

To install libROM with MFEM using spack.

 spack install librom +mfem

Compiling and linking with libROM

To compile and link an existing code with libROM, follow these steps:

Add libROM/lib to the include path

 -I/path/to/libROM/lib

Add the following to the linker flags (LDFLAGS)

 -Wl,-rpath,/path/to/libROM/build/lib -L/path/to/libROM/build/lib

Add the following library

 -lROM

For example,

mpicxx myapp.cpp -I/path/to/libROM/lib -Wl,-rpath,/path/to/libROM/build/lib -L/path/to/libROM/build/lib -lROM -o myapp.out

Using Docker container

Docker container librom_env provides a containerized environment with all the prerequisites for libROM. For instruction on how to use it, check out the wiki page.

libROM CI

libROM leverages GitHub Actions for CI. The CI currently applies only to commits to pull requests. Unit tests run for all PR commits. Upon the addition of the LGTM label, both the unit tests and regression tests run. While the LGTM label is still present, all subsequent commits run both unit tests and regression tests.

License

libROM is distributed under the terms of both the MIT license and the Apache License (Version 2.0). Users may choose either license at their option.

All new contributions must be made under both the MIT and Apache-2.0 licenses.

See LICENSE-MIT, LICENSE-APACHE, COPYRIGHT, and NOTICE for details.

Up to commit 299876e0a0304f25db56f1f9e2eb2c61ef199048, libROM was previously released under the terms of the BSD-3 license.

SPDX_License-Identifier: (Apache-2.0 OR MIT)

LLNL-CODE-686965 (up to commit 299876e0a0304f25db56f1f9e2eb2c61ef199048) LLNL-CODE-766763

Authors

Robert W. Anderson (LLNL)
William Anderson (LLNL)
William Arrighi (LLNL)
Kyle Chand (LLNL)
Siu Wun Cheung (LLNL)
Eric Chin (LLNL)
Youngsoo Choi (LLNL)
"Kevin" Seung Whan Chung (LLNL)
Dylan Copeland (LLNL)
William Fries (University of Arizona)
Debojyoti Ghosh (LLNL)
Xiaolong He (UC San Diego)
Adrian Humphry (University of Toronto)
Kevin Huynh (LLNL)
Coleman Kendrick (LLNL)
Tanya Kostova-Vassilevska (LLNL)
Jessica Lauzon (Stanford)
Sean McBane (UT Austin)
Geoffrey Oxberry (LLNL)
Yeonjong Shin (KAIST)
Paul Tranquilli (LLNL)
Pranav Vempati (LLNL)
Masayuki Yano (University of Toronto)

librom's People

Contributors

Stargazers

Watchers

librom's Issues

Add parallel test runner

Add a parallel test runner, to start testing functionality that can really only be tested in parallel. A one-process version of this sort of thing is easy. An arbitrary-process version can use a patched up version of https://github.com/LLNL/gtest-mpi-listener.

Integrator for non-linear term

I'm trying to build a FOM for the non-linear heat conduction equation i.e. heat conduction equation in which the conductivity K depends on temperature. i.e. K = k0 + \alpha u where u is the temperature. Since I want it to be as close as possible to the nonlinear_elasticity_global_rom.cpp, I'd like to use a ParNonlinearForm for the term \div { \alpha u \grad u}. Is the ConvectionIntegrator the right one to use for this purpose?

Thanks,

-Nachiket

installing libROM

I have cloned the libROM repo and I'm trying to install it on WSL2 (Ubuntu) on Windows. I'm getting the following errors. Firstly, is it possible to install without MPI? Any help would be appreciated.

./compile.sh

gives

CMake Error at CMakeLists.txt:26 (project):
  The CMAKE_C_COMPILER:

    mpicc

  is not a full path and was not found in the PATH.

  Tell CMake where to find the compiler by setting either the environment
  variable "CC" or the CMake cache entry CMAKE_C_COMPILER to the full path to
  the compiler, or to the compiler name if it is in the PATH.


CMake Error at CMakeLists.txt:26 (project):
  The CMAKE_CXX_COMPILER:

    mpicxx

  is not a full path and was not found in the PATH.

  Tell CMake where to find the compiler by setting either the environment
  variable "CXX" or the CMake cache entry CMAKE_CXX_COMPILER to the full path
  to the compiler, or to the compiler name if it is in the PATH.

CMake Error at CMakeLists.txt:26 (project):
  The CMAKE_Fortran_COMPILER:

    mpif90

  is not a full path and was not found in the PATH.

  Tell CMake where to find the compiler by setting either the environment
  variable "FC" or the CMake cache entry CMAKE_Fortran_COMPILER to the full
  path to the compiler, or to the compiler name if it is in the PATH.

-- Configuring incomplete, errors occurred!
See also "/mnt/c/Work/Ubuntu/LSROM/libROM/libROM/build/CMakeFiles/CMakeOutput.log".
See also "/mnt/c/Work/Ubuntu/LSROM/libROM/libROM/build/CMakeFiles/CMakeError.log".
make: *** No targets specified and no makefile found.  Stop.
/mnt/c/Work/Ubuntu/LSROM/libROM/libROM/scripts

Contents of CMakeOutput.log

The system is: Linux - 5.10.16.3-microsoft-standard-WSL2 - x86_64

Contents of CMakeError.log

Checking whether the C compiler is IAR using "" did not match "IAR .+ Compiler":
Checking whether the C compiler is IAR using "" did not match "IAR .+ Compiler":
Checking whether the CXX compiler is IAR using "" did not match "IAR .+ Compiler":
Checking whether the CXX compiler is IAR using "" did not match "IAR .+ Compiler":
Checking whether the Fortran compiler is Compaq using "-what" did not match "Compaq Visual Fortran":
Checking whether the Fortran compiler is NAG using "-V" did not match "NAG Fortran Compiler":
Checking whether the Fortran compiler is Compaq using "-what" did not match "Compaq Visual Fortran":
Checking whether the Fortran compiler is NAG using "-V" did not match "NAG Fortran Compiler":

adding regression test suite

We need to add regression test suite. Strong candidates include mfem examples by Dylan Copeland and Bill Arrighi.

libROM with Dealii

Good afternoon,

I was wondering if libROM is compatible with the library Dealii. I would like to include a ROM implementation to an existing solver developed with Dealii.

Thank you very much.
H.

parametric basis generation

We need to add capabilities of building parametric basis generation. For a parametric basis, one needs to collect the snapshots or build incremental bases from multiple simulations.

For incremental ones, we must be able to read HDF5 output files from previous simulations as inputs and soft-start the incremental algorithms.

For static SVDs, I see two potential options. One is to build a static SVD at the end of the simulations and the other one is to save the snapshots collected throughout the simulation without any static SVD. If the second option is taken, we also need a capability in libROM to read a snapshot HDF5 file and just do a static SVD.

SPACK build failing

Hello.
Build fails on ubuntu20.04 after installing a bunch of libraries. Installation machine description:

linux-ubuntu20.04-skylake_avx512/gcc-9.3.0

Error message:

==> Warning: Missing a source id for librom@develop
==> Error: RuntimeError: Cannot generate configure: missing dependencies: autoconf, automake, libtool.

Please add the following lines to the package:

depends_on('autoconf', type='build', when='@develop')
depends_on('automake', type='build', when='@develop')
depends_on('libtool', type='build', when='@develop')

Update the version (when='@develop') as needed.

/home/user/git/spack/lib/spack/spack/build_systems/autotools.py:324, in _require_build_deps:
321 msg += (" depends_on('{0}', type='build', when='@{1}')\n"
322 .format(dep, spec.version))
323

324 msg += "\nUpdate the version (when='@@{0}') as needed.".format(spec.version)
325 raise RuntimeError(msg)

illegal value in interpolation

I'm developing some parametric DMD code based on parametric heat conduction. When I have 4 training points, everything seem to run ok. But with 25 training points, I'm getting the following error

 ** On entry to DGEBAL parameter number  3 had an illegal value
 ** On entry to DGEHRD parameter number  2 had an illegal value
 ** On entry to DORGHR parameter number  2 had an illegal value
 ** On entry to DHSEQR parameter number  4 had an illegal value

from the call

CAROM::getParametricDMD(dmd_interp,param_vectors,dmd_model_out,desired_param,
                                "G","LS",closest_rbf_val);

Any advice would be appreciated. Is there a choice of interpolation method that avoids these LAPACK/BLAS routines?

Edit: There seem to be no NaNs in my data, so I'm not sure where these illegal values are coming from.
Edit 2: I tried all combinations of RBF type and interpolation type and I get the illegal values in all of them.

-Nachiket

dmd prediction of initial condition

My DMD code seems to be working, but it seems to make a large error at the starting time. Shouldn't DMD be able to reproduce the initial condition exactly? Looking at

https://www.librom.net/features.html

I can see the last equation in the DMD section

$$ \mathbf{u}(t) = \mathbf{\Phi\Lambda}^{{t}/{\Delta t}}\mathbf{b}_0 $$

using $\mathbf{b}_0=\mathbf{\Phi}^\dagger\mathbf{u}_0$ we get

$$ \mathbf{u}(t) = \mathbf{\Phi\Lambda}^{{t}/{\Delta t}}\mathbf{\Phi}^\dagger\mathbf{u}_0 $$

At $t=0$ we have $\mathbf{\Lambda}^{{t}/{\Delta t}}=\mathbf{1}$ and hence,

$$ \mathbf{u}(0) = \mathbf{\Phi}\mathbf{\Phi}^\dagger\mathbf{u}_0 $$

Since $\mathbf{\Phi}\mathbf{\Phi}^\dagger=\mathbf{1}$ we get

$$ \mathbf{u}(0)=\mathbf{u}_0 $$

Hence, the initial condition is faithfully reproduced. Is my understanding correct?

understanding hyper-reduction in libROM

I've been going through

https://github.com/LLNL/libROM/blob/master/examples/prom/poisson_global_rom.cpp

and it seems understandable. I want to extend it by implementing hyper-reduction.

With that in mind I'm looking at the two hyper-reduction examples

https://github.com/LLNL/libROM/blob/master/examples/prom/nonlinear_elasticity_global_rom.cpp
https://github.com/LLNL/libROM/blob/master/examples/prom/mixed_nonlinear_diffusion.cpp

And trying to correlate the description of hyper-reduction with your JCP Paper:

A fast and accurate physics-informed neural network reduced order model with shallow masked autoencoder

and your SIAM paper

SNS: A Solution-Based Nonlinear Subspace Method For Time-Dependent Model Order Reduction

Is there a better approach to understanding, and later implementing, how hyper-reduction is done in libROM?

Building MFEM dependency frozen due to Cmake consuming too much RAM

Issue

Cmake creates too many parallel processes when installing MFEM. They consume all available RAM and causes the program to freeze.

Affected

I encountered this problem when installing libROM with MFEM dependency on two different laptops with 8Gb RAM.

Fix

Change the -j flag to -j8, or some other resonable finite number, in the cmake compilation of MFEM in /scripts/setup.sh

Make CAROM::Vector compliant with the rule of 3 (or 5)

python interface

Am I correct in assuming that libROM does not have a Python interface?

EDIT: Can our Full Order Model be in Python?

Thanks,

-Nachiket

Migrate build system from autotools to CMake

error in merge phase: bad submatrix

I'm trying to create a simple ROM for a transient heat conduction problem based on ex16.cpp in MFEM. I'm trying to base my ROM on nonlinear_elasticity_global_rom.cpp.

I seem to be able to generate basis snapshots but I have a problem merging the basis. With 2 basis snapshots generated by 2 offline runs, the merge is fine (at least there are no errors reported by libROM), but with 3 or 4 basis snapshots, I get the error message

??MR2D:Bad submatrix:i=0,j=0,m=1361,n=2000,M=1361,N=1361

Can someone tell me what is happening here?

Edit: FWIW, the basis files seem to have non-zero size.

-rw-r--r-- 1 root root 5.2M Mar 16 09:21 basis0_u_snapshot.000000
-rw-r--r-- 1 root root 5.2M Mar 16 09:21 basis1_u_snapshot.000000
-rw-r--r-- 1 root root 5.2M Mar 16 09:33 basis2_u_snapshot.000000
-rw-r--r-- 1 root root 5.2M Mar 16 09:22 basis3_u_snapshot.000000

When the merge succeeds, with 2 basis snapshots, I get

-rw-r--r-- 1 root root  11M Mar 16 11:49 basisu.000000

When the merge fails, with 3/4 basis snapshots, I get

-rw-r--r-- 1 root root 2.1K Mar 16 11:50 basisu.000000

Thanks,

Nachiket

Conventions for the output of SVD

This is also related to #195 .

I'm currently working on StaticSVD to support the case when the sample size is larger than the system dimension (so the snapshot matrix is transposed). However, there seems to be an inconsistency about the output of SVD, so I wasn't sure which convention to follow.

Is `d_basis_right` transposed or not?

In StaticSVD::computeSVD and RandomizedSVD::computeSVD, d_basis_right is initialized with the size of transposed matrix (ncolumns, d_num_samples). However, based on the gather_block and gather_transposed_block operations in computeSVD, the output matrix is not supposed to be the transpose, This has never been an issue in the unit tests, since in the tests d_basis_right (in the transposed case, d_basis) is always a square matrix.

Distribution of `d_basis`/`d_basis_right` among the processes

In the standard case where the snapshot matrix is not transposed, d_basis is always distributed among the processes, while d_basis_right is always not.

This is not true for RandomizedSVD when the snapshot matrix is transposed. The current implementation of RandomizedSVD::computeSVD simply switches d_basis and d_basis_right, so in this case d_basis_right is distributed among the processes, while d_basis is not.

Based on RandomizedSVD, the convention seems to be that we distribute the 'longer' matrix. In other words, if sample size is smaller than the system dimension, d_basis is distributed, otherwise d_basis_right is distributed. Is this correct? or is this behavior of RandomizedSVD is a bug?

possible small error in documentation

In https://www.librom.net/features.html
In Section 1 for DMD

$$ \Sigma \in \mathbb{C}^{r \times r} $$

should be

$$ \Omega \in \mathbb{C}^{r \times r} $$ $$

Add empty Fortran source file to force Fortran linkage in CMake

In the event that we use a CMake-based build system, CMake cannot detect whether BLAS or LAPACK require linking in libraries from a Fortran compiler. This issue does not arise with OpenBLAS or MKL, but does occur with reference BLAS in https://github.com/Reference-LAPACK/lapack.

A fix is discussed in https://cmake.org/pipermail/cmake/2010-July/038172.html by one of the CMake developers: add an empty Fortran source file to the library. This workaround ensures that Fortran libraries are added as dependencies when linking libROM to any executable.

I have a branch that implements this fix as part of work for Youngsoo, and hopefully I'll get around to submitting a PR later this week.

Hyperreduction: usage of SampleMeshManager

I am trying to implement a time independent non-linear reduced order model. The examples nonlinear_elacticity_global_rom.cpp and mixed_non-linear_diffusion.cpp provide good examples of the usage of the used classes. However, I cannot fully understand the usage of the class SampleMeshManager.

This class seems to register the sampled variables, which are especially important for the hyper reduced non-linear term. I do not understand what GetSampleFESpace() produces. As the name indicates this seems to be some kind of sampled finite element space and the number of true variables seems to be somewhere in between the number of FOM and ROM variables.

Quoting SampleMesh.hpp:
"The spaces defined on the sample mesh are referred to as sample mesh spaces, and they generally contain the sampled DOFs along with other unsampled DOFs."
An explanation for the number of variables being somewhere between the number of the FOM and the ROM variables would be the unsampled DOFs in the description above.

I have two questions:

To be sure "other unsampled variables" does not mean "all unsampled variables", right?
Why does it need the other unsampled variables? In nonlinear_elacticity_global_rom.cpp it produces a large non-linear vector first, which it samples again afterwards to a much smaller vector. In this way it seems to be very FOM size-ish dependent. This is in the lines:

fomSp->H->Mult(*psp_x, zH); // produces a large nonlin-vector zH, almost FOM size
smm->GetSampledValues("H", zH, zN); // produces a much smaller sampled nonlin-vector zN

Names collision

Hey guys!

This is somehow related with #154. You have a folders structure/naming problem. To explain that, let's consider lib/linalg/BasisWriter.h:16:

#include "utils/Database.h"

Since you are using quotes, the compiler is first looking for Database.h on lib/linalg/utils/. When that fails (because such folder does not exist), it start looking all around the include paths. Of course, the probabilities of having some other library with a utils/Database.h header file are large.

That names collision would be a problem while compiling the library, which might be eventually fixed by the user (if he really knows what he is doing). But of course that is unacceptable when installing the library.

The easiest solution is renaming the lib/ folder as libROM/, and replacing those includes (where the relative path is not working) by something like #include "libROM/utils/Database.h". It is still not a perfect solution, since collisions might yet happens with the installed library itself, but it is much safer.

Otherwise, you need to rethink the folders structure, so just subfolders are considered

reading a numpy matrix in libROM/mfem

Is there an easy way to read a numpy matrix into libROM or MFEM?

Thanks,

Nachiket

question about SampleMeshManager

I might be missing something, but I was looking at the following code to construct a sample mesh

libROM/examples/prom/nonlinear_elasticity_global_rom.cpp

Lines 885 to 900 in c3bfef5

 ParFiniteElementSpace* sp_XV_space; 

 smm = new CAROM::SampleMeshManager(spfespace); 

 vector<int> sample_dofs_empty; 

 vector<int> num_sample_dofs_per_proc_empty; 

 num_sample_dofs_per_proc_empty.assign(num_procs, 0); 

 smm->RegisterSampledVariable("V", 0, sample_dofs, 

 num_sample_dofs_per_proc); 

 smm->RegisterSampledVariable("X", 0, sample_dofs, 

 num_sample_dofs_per_proc); 

 smm->RegisterSampledVariable("H", 0, sample_dofs, 

 num_sample_dofs_per_proc); 

 smm->ConstructSampleMesh();

It is surprising to be that there is no code/argument to set the error bound in constructing the sample mesh. I'm thinking that one should be able set the error bound in constructing the sample mesh. e.g. If I wanted less than 1% error the sample mesh would contain much more elements than if I wanted less than 25% error.

Maybe I'm missing something. Maybe I should be reading the original papers.

Thanks,

Nachiket

ParMETIS website down => building libROM dependencies fail

Building the libROM dependencies fails due to the Glaros website being down.

I asked Prof. Karypis when he thought it will be up and he recommended getting ParMETIS from their GitHub page.
I assume that ParMETIS will not be hosted at Glaros anymore.

The build script for libROM should be updated to reflect this. It is beyond my knowledge to do so though.

@chldkdtn @kevinhkhuynh

scalapack error

I'm trying to install following the instruction here. I am getting the following message

CMake Error at /home/h206100a/cmake-3.26.4-linux-x86_64/share/cmake-3.26/Modules/FindPackageHandleStandardArgs.cmake:230 (message):
  Could NOT find ScaLAPACK (missing: ScaLAPACK_LIBRARY)
Call Stack (most recent call first):
  /home/h206100a/cmake-3.26.4-linux-x86_64/share/cmake-3.26/Modules/FindPackageHandleStandardArgs.cmake:600 (_FPHSA_FAILURE_MESSAGE)
  cmake/modules/FindScaLAPACK.cmake:38 (find_package_handle_standard_args)
  lib/CMakeLists.txt:99 (find_package)

I have installed scalapack-mpich.x86_64 scalapack-mpich-devel.x86_64 scalapack-mpich-static.x86_64 using yum.

Is there something like -DScalapack that I can use?

Any ideas?

Also

 ./scripts/compile.sh

does not seem to work. It says

~/libROM/build ~/libROM/scripts
./compile.sh: line 134: cmake: command not found
make: *** No targets specified and no makefile found.  Stop.
~/libROM/scripts

Thanks,

-Nachiket

Basis reader scope issue

Problem
In my code I want to read several basis and modify them in a certain way. I want to do this in a structured manner to be sure that I do the same for every basis. I have created the function ReadBasis for this. Unfortunately if I read a basis using this function, I get a seg fault uppon using the basis outside the function. This might be scope related. I have created an example script below.

The returned pointer to a basis in Matrix* BasisReader::getSpatialBasis(double time) is created in the function itself.

Matrix*
BasisReader::getSpatialBasis(
    double time)
{
...
    Matrix* spatial_basis_vectors = new Matrix(num_rows, num_cols, true);
    sprintf(tmp, "spatial_basis_%06d", i);
    d_database->getDoubleArray(tmp,
                               &spatial_basis_vectors->item(0, 0),
                               num_rows*num_cols);
    return spatial_basis_vectors;
}

I think that moving out of the function ReadBasis makes you move out of scope of this pointer and therefore it does not exist outside ReadBasis, but I am not sure about this.

Possible solutions

Make the pointer Matrix* spatial_basis_vectors a member variable of BasisReader.
Use the pointer Matrix* spatial_basis_vectors as an input of the function such that Matrix* BasisReader::getSpatialBasis( double time, Matrix* spatial_basis_vectors)
Others?

Do you agree that this is undesired behavior? If so, is there a preference for the solution?

Minimal example

void ReadBasis(CAROM::BasisReader *reader, const CAROM::Matrix* basis)
{
   basis = reader->getSpatialBasis(0.0);

   // This works
   printf("Basis dim. %d x %d\n", basis->numRows(), basis->numColumns());

   // This works
   basis->print("print_basis_in_scope");
}


int main()
{
      const CAROM::Matrix* V; // Spatial basis 
      CAROM::BasisReader *reader;

      reader = new CAROM::BasisReader(basisName);

      ReadBasis(reader, V);

      // This has gives a seg fault
      V->print("print_basis_out_scope");

      delete reader;
      delete V;
}

Generic SVD interface forces Σ to be a Matrix

Title. Is there a good reason that we should force the SVD algorithm to return singular values in a dense matrix instead of as a vector?

Add continuous integration

Add hooks for continuous integration testing of libROM.

Spack build fails with MFEM

Hello,

The Spack build does not appear to work with the MFEM option that is outlined in the librom README. Looking at the latest Spack recipe it does not appear that MFEM is an option.

Add developer/design documentation.

Add some documentation of the software's design, contribution guidelines, etc.

Questions about Nonlinear elasticity, PROM

I'm working with the nonlinear elasticity example:

https://github.com/LLNL/libROM/blob/master/examples/prom/nonlinear_elasticity_global_rom.cpp
https://www.librom.net/examples.html

My command line is

./nonlinear_elasticity_global_rom --mesh "../data/beam-hex-nurbs.mesh"  --online -dt 0.01 -tf 5.0 -s 14 -vs 5 -hyp -rvdim 40 -rxdim 10 -hdim 71 -nsr 200 -sc 4.0

I have the following questions:

I get relative error of ROM position at t_final as 0.00677831 which agrees well with the error reported in your example.
I get relative error of ROM velocity at t_final as 9.58099. Why is this so high? After looking at the code, it seems to be 950% error.
What do 'rvdim' , 'rxdim', and 'hdim' mean? Are 'rvdim' and 'rxdim' the number of basis vectors used to approximate the velocity and displacement respectively? And is 'hdim' the number of basis vectors used to approximate the non-linear term?

Edit: Changing the rvdim to 80 in the command line above increases the errors. The position error is 0.00749 and velocity error is 12.33 both of which have increased inspite of number of basis vectors increasing, and I fail to understand this.

Thanks,

Nachiket

NURBS in SampleMeshManager

I have been trying to work with a MFEM NURBS-mesh in our own code and the example nonlinear_elasticity_global_rom . (The latter just as in issues https://github.com/LLNL/libROM/issues/184 https://github.com/LLNL/libROM/issues/185.)

In our own code I cannot make it work to sample a FiniteElementSpace as which is construced using a NURBS mesh.
I wonder if it should is even possible to use a MFEM NURBS mesh in nonlinear_elasticity_global_rom as the used ParFiniteElementCollection is a H1_FECollection. So in case of using a NURBS mesh in this example in the line of

ParFiniteElementSpace fespace(pmesh, &fe_coll, dim);

around line 560-570, a ParFiniteElementSpace is created using a NURBS mesh but a H1_FECollection. Which seems counter intuitive and it seems that it falsely passes some checks deeper in MFEM ( void FiniteElementSpace::Constructor). Maybe I am missing something important here.

Has anyone used Hyperreduction / sampling of DOFs on a NURBS mesh and succesfully created a sampled FiniteElementSpace? If so, what kind of approach would you suggest?

Parallel snapshot generation with a custom MPI communicator

Currently BasisReader, BasisWriter, and BasisGenerator are initialized with only MPI_COMM_WORLD. This has been a limitation, particularly for generating samples in parallel. This happens when multiple samples can be run in parallel, but no communication is needed between each sample, so each sample can have a different communicator or even simply run with one process.

Did anybody come across with this situation, and how did you work around this? Or should we change the initializations so that each class can be initialized with a custom MPI Communicator?

Remove Perl dependency.

If we're using GNU Autotools or CMake, we shouldn't need Perl anymore. (I believe Doxygen requires Perl, but Perl is no longer a direct dependency of this project.) The Perl dependency was introduced by the depend.pl script, but this script is no longer needed.

Compiling LibROM

Hi All,

I am trying to compile libROM from source but I am not succesfull up to now. I work on Ubuntu 22.04.

When using ./scripts/compile.sh cmake is unable to find Blas and Lapack and the script fails:

CMake Error at /usr/share/cmake-3.22/Modules/FindPackageHandleStandardArgs.cmake:230 (message):
  Could NOT find BLAS (missing: BLAS_LIBRARIES) (Required is at least version
  "3.4.0")
Call Stack (most recent call first):
  /usr/share/cmake-3.22/Modules/FindPackageHandleStandardArgs.cmake:594 (_FPHSA_FAILURE_MESSAGE)
  /usr/share/cmake-3.22/Modules/FindBLAS.cmake:1337 (find_package_handle_standard_args)
  CMakeLists.txt:102 (find_package)

EDIT: This is problably obvious as it is meant for LLNL machines only.

When I build in a folder (FI build2) with cmake .. and make it can find Lapack and Blas but the build fails with:

/usr/bin/ld: CMakeFiles/combine_samples.dir/examples/misc/combine_samples.cpp.o: in function `MPI::Intracomm::Intracomm()':
combine_samples.cpp:(.text._ZN3MPI9IntracommC2Ev[_ZN3MPI9IntracommC5Ev]+0x18): undefined reference to `MPI::Comm::Comm()'
/usr/bin/ld: CMakeFiles/combine_samples.dir/examples/misc/combine_samples.cpp.o: in function `MPI::Intracomm::Intracomm(ompi_communicator_t*)':
combine_samples.cpp:(.text._ZN3MPI9IntracommC2EP19ompi_communicator_t[_ZN3MPI9IntracommC5EP19ompi_communicator_t]+0x2c): undefined reference to `MPI::Comm::Comm()'
/usr/bin/ld: CMakeFiles/combine_samples.dir/examples/misc/combine_samples.cpp.o: in function `MPI::Op::Init(void (*)(void const*, void*, int, MPI::Datatype const&), bool)':
combine_samples.cpp:(.text._ZN3MPI2Op4InitEPFvPKvPviRKNS_8DatatypeEEb[_ZN3MPI2Op4InitEPFvPKvPviRKNS_8DatatypeEEb]+0x2a): undefined reference to `ompi_mpi_cxx_op_intercept'
/usr/bin/ld: CMakeFiles/combine_samples.
dir/examples/misc/combine_samples.cpp.o:(.data.rel.ro._ZTVN3MPI3WinE[_ZTVN3MPI3WinE]+0x48): undefined reference to `MPI::Win::Free()'
/usr/bin/ld: CMakeFiles/combine_samples.dir/examples/misc/combine_samples.cpp.o:(.data.rel.ro._ZTVN3MPI8DatatypeE[_ZTVN3MPI8DatatypeE]+0x78): undefined reference to `MPI::Datatype::Free()'
collect2: error: ld returned 1 exit status

make[2]: *** [CMakeFiles/combine_samples.dir/build.make:119: examples/misc/combine_samples] Error 1
make[1]: *** [CMakeFiles/Makefile2:124: CMakeFiles/combine_samples.dir/all] Error 2
make: *** [Makefile:91: all] Error 2

I have attached the full logs:
log-cmake.txt
log-make.txt

I have liblapack-dev libblas-dev libscalapack-mpi-dev installed. Am I doing something wrong here?

EDIT: It fails when compiling combine_samples. We found it that it is somehow compiling it with a serial compiler usr/bin/c++ instead of a parallel one usr/bin/mpic++ therefore it cannot deal with the MPI stuff. If we update the commands given by make VERBOSE=1 combine_samples to the parallel compiler it does not give these errors. Maybe something should be updated in the CMake files?

Kind regards,

Jacob Lotz

spack build fails

A spack build fails on my machine when make determines that configure.ac is newer than aclocal.m4, and wants to rebuild aclocal.m4. This leads to problems with a version mismatch in the autotools on my local machine vs what was run to build what's in the repo.

I think there are two possible routes to solving this issue.

Have spack download a tarball instead of check out the git archive. The tarball will be a distribution tarball with a configure script and makefile, but no autotools stuff.
Remove all generated files from the repo, so automake rebuilds everything fresh, which should prevent problems with version mismatches.

I think solution 1. is preferable and will sidestep a lot of possible headaches with requiring autotools on the destination machine.

Add members and methods denoting comm ownership for Matrix and Vector methods

Specifically, add the following to each class T, where T is a CAROM::Vector or CAROM::Matrix, a CAROM::Vector is treated as a single column matrix, and none of the functions below should be templated:

a private MPI_Comm d_comm member
initialize that member in the constructor of each object
include a MPI_Comm getComm() const getter method
a free function of the form std::vector<int> GetDimensionOnEachProcess(T &input), that returns the number of rows of the object on each process
a free function of the form std::vector<int> GetRowSpanOnEachProcess(T &input), where T is a CAROM::Matrix or CAROM::Vector that returns the range of row indices of the object on each process. Let std::vector<int> result be the value returned by this function. The following postconditions should be satisfied: (1) result.size() should be one plus the number of processes on d_comm, and (2) if a disjoint contiguous index span of input resides on each process such that index 0 is owned by process 0, and the lowest index owned by each process is an increasing sequence when ordered by increasing process number, then process p contains rows result[p] through result[p + 1] - 1
a free function of the form int GetProcessContainingRow(T &input, int row) such that if int result is returned by this function, then row row is on process number result

These utility functions come up frequently in implementing linear algebraic operations. I suspect that if data objects are associated with communicators, the operations like matrix decompositions will not need to have communicators associated with them.

Remove support for Elemental and clean up the QDEIM support.

Given that #12 implements a distributed "static" SVD using ScaLAPACK and that Elemental is deprecated, Elemental support should probably be removed. The LLNL fork of Elemental has stripped everything but support for BLAS Level 1 subroutines, so that fork won't serve our purposes.

The QRCP and QDEIM functionality also needs cleaning up.

Which viewer to use in Visit?

Which viewer should I use in Visit in order to view the HDF5 files generated in the tutorial?
https://www.librom.net/poisson.html#tutorial-1

BasisGenerator not taking a trivial sample

BasisGenerator::takeSample does not take a trivial solution as sample, directed by the following if statement:

    // Check that u_in is not non-zero.
    Vector u_vec(u_in, getDim(), true);
    if (u_vec.norm() == 0.0) {
        return false;
    }

My intuition is that a trivial solution should be allowed to become a sample. Is there any special background or logic behind this?

`Matrix::orthogonalize()` works only for distributed case.

Based on the definition in lib/linalg/Matrix.cpp, void Matrix::orthogonalize() works only when the matrix is distributed (in parallel case). It should have a line:

CAROM_VERIFY(distributed());

Parallel offline stage to serial online stage

Hi all,
I have been working on implementation of libROM in our own code for some time now. With help of some of you I have thus far implemented a ROM of a non-linear equation with DEIM hyper-reduction with a NURBS discretisation as a full order model. Thank you for your help so far, especially @dylan-copeland deserves a shout-out! I am currently working on a parallel version of the code. The parallel offline sampling and merge stage work, but the online stage is a bit more tricky.

I think the easiest way to perform the online stage is to convert the whole parallel system to a serial system using the class SampleMeshManager::WriteVariableSampleMap using a "to-serial" step, some sort of second merge step. Then in the online stage I can use the class SampleDOFSelector. In the "to-serial" step I have to gather the parallel basis to the root process and export the sampled FiniteElementSpace and mesh. The sampled basis is luckily already gathered to the root process.

Is there any example code using SampleDOFSelector in the online phase? I hope to use it as inspiration but I cannot find an example in examples. I am interested in:

I think using SampleDOFSelector is quite straightforward but I am mostly interested in strategies to merge the parallel basis into a serial one. I think using SampleMeshManager can do the trick, but it is probably not the most straight forward way to do it.
Also printing and reading the sampled FiniteElementSpace is going to be difficult I think.

Do you have suggestions for these?

version of ComputeCtAB not involving HypreParMatrix

Is there a version of ComputeCtAB in which A is a serial matrix, perhaps just a mfem matrix? I'm asking this because, if such a routine were available, I would be able to write my code in serial, reducing complexity.

possible issue in documentation

https://www.librom.net/features.html

In Step 4 for DMD you say

$$ \tilde{A}_r X = \Lambda X $$

Shouldn't it be

$$ \tilde{A}_r X = X \Lambda $$

CMake package config for installation

Hi,

I have been working on a CMake package config for installation of this library as it was still unable to do a make install. Would you be interested in adding this to this library?
Also, is this project open for contributions? In other words, can I create a branch to implement this CMake installation config myself?

Kind regards and have a good Christmas,

Jacob Lotz

m4 macros are in two places in automake-dev branch

They should be consolidated under m4, and obsolete macros removed.

missing mesh in non-linear elasticity prom

I'm trying to run the non-linear elasticity prom

https://www.librom.net/examples.html

using @dreamer2368 's Docker container.

The command is

./nonlinear_elasticity_global_rom --mesh "../../../dependencies/mfem/data/beam-hex-nurbs.mesh" --offline -dt 0.01 -tf 5.0 -s 14 -vs 10 -sc 3.9 -id 0

I'm not able to find the mesh 'beam-hex-nurbs.mesh' in the Docker container.

In examples/data I see

./examples/data/periodic-hexagon.mesh
./examples/data/star.mesh
./examples/data/inline-quad.mesh
./examples/data/periodic-square.mesh
./examples/data/beam-quad.mesh
./examples/data/beam-tri.mesh
./build/examples/data/periodic-hexagon.mesh
./build/examples/data/star.mesh
./build/examples/data/inline-quad.mesh
./build/examples/data/periodic-square.mesh
./build/examples/data/beam-quad.mesh
./build/examples/data/beam-tri.mesh

But not the mesh beam-hex-nurbs.mesh that I require.

Any help is much appreciated.

Nachiket

code documentation

Is the code documentation at

https://software.llnl.gov/libROM/html/index.html

a little behind the current version of libROM?

For instance I cannot seem to find: "SampleMeshManager" in the documentation.

Nachiket

`test_RandomizedSVD` failure

The unit test test_RandomizedSVD fails. This is observed from both docker container librom_env and quartz.

This needs more investigations, but the issue seems to be a peculiar setup within the test.
For debug/test cases, rand_mat in RandomizedSVD::computeSVD is a matrix of 1.
As a result, the projected snapshot matrix rand_proj becomes 1-rank matrix.
The resulting Q matrix from qr factorization can have arbitrary orthonormal column basis except one column.
The result of SVD will depend on these arbitrary column basis of Q, although the answer is fixed to one case.

If this is the case, then the test rand_mat and the corresponding answer should be adjusted so that it may have some randomness (probably under the fixed random seed).

Following output is the result from test_RandomizedSVD:

[==========] Running 5 tests from 2 test suites.
[----------] Global test environment set-up.
[----------] 1 test from GoogleTestFramework
[ RUN      ] GoogleTestFramework.GoogleTestFrameworkFound
[       OK ] GoogleTestFramework.GoogleTestFrameworkFound (0 ms)
[----------] 1 test from GoogleTestFramework (0 ms total)

[----------] 4 tests from RandomizedSVDTest
[ RUN      ] RandomizedSVDTest.Test_RandomizedSVD
Distribution of sampler's A and U:
Local data: (  0.5377   -1.3077   -1.3499  
               1.8339   -0.4336    3.0349  
              -2.2588    0.3426    0.7254  
               0.8622    3.5784   -0.0631  
               0.3188    2.7694    0.7147  
             )
Process rank 0
=================
A->ctxt = 1
A->(m, n) = (5, 3)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (5, 5)
A->(mm, mn) = (5, 3)


Distribution of sampler's V:
Local data: ( -0.9093   -0.1798   -0.3752  
               0.4131   -0.2823   -0.8658  
              -0.0498    0.9423   -0.3310  
             )
Process rank 0
=================
A->ctxt = 2
A->(m, n) = (3, 3)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (5, 5)
A->(mm, mn) = (3, 3)


Computed singular values: 4.7698E+00  3.6011E+00  1.4576E+00  
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.1654678695838297, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.29609110552784845,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.46155897511167815, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.30832233292278777, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.12904302167895709,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.43736535460174486, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.77882650318085811, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.94545421529976204,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.16662771211890387, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.13884202231635007, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.18626762787368634,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.3251096501900364, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.20455937598306617, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.9622878546191842,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.75772847863611803, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.26120084453304221, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.19065741811692377,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.45185826264996598, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.17518683713505692, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.18257233495826697,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.0073854978232100466, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.44415745273978052, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.037611622210901322,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.48176907495068183, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.78549822817264658, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.085985452566386622,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.87148368073903315, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.088751412265948515, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.71182477196996774,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.62307335970401923, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.17705237494593254, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.21447709666524431,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.037424721719311764, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.135703802018661, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.20561196161382506,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.069908159595164068, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.039752393551045428, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.58103981322401277,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.54128741967296734, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.067161817549816108, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.0996740903599522,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.032512272810136092, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:111: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 3 + i]) is 0.081029550084531832, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.14176141533283554,
abs(basis_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.0607318652483037, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.072827062654433949, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.29220118965151742,
abs(basis_right_true_ans[i]) evaluates to 0.21937412699708347, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.4337083177025543, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.38701827790664817,
abs(basis_right_true_ans[i]) evaluates to 0.82072659560920247, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.34702342589123303, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.8745486363447208,
abs(basis_right_true_ans[i]) evaluates to 0.52752521045348777, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.038844274799944456, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.92250639604755147,
abs(basis_right_true_ans[i]) evaluates to 0.88366212124760701, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.041121452159888772, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.35520511662783122,
abs(basis_right_true_ans[i]) evaluates to 0.39632656878771999, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.098097486849904242, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.15103401727017279,
abs(basis_right_true_ans[i]) evaluates to 0.24913150412007704, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.16134988274320927, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.25219122510031233,
abs(basis_right_true_ans[i]) evaluates to 0.4135411078435216, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.43940798994975394, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.85090903020686104,
abs(basis_right_true_ans[i]) evaluates to 0.4115010402571071, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:116: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.35137060506876022, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.46081819440514998,
abs(basis_right_true_ans[i]) evaluates to 0.81218879947391021, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:120: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.023920151572226267, which exceeds 1e-7, where
sv->item(i) evaluates to 4.7698410058819114,
sv_true_ans[i] evaluates to 4.7459208543096851, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:120: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.34746642981073617, which exceeds 1e-7, where
sv->item(i) evaluates to 3.6011164288318369,
sv_true_ans[i] evaluates to 3.2536499990211007, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:120: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.68429221224446657, which exceeds 1e-7, where
sv->item(i) evaluates to 1.4575672872210159,
sv_true_ans[i] evaluates to 2.1418594994654825, and
1e-7 evaluates to 9.9999999999999995e-08.
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVD (7 ms)
[ RUN      ] RandomizedSVDTest.Test_RandomizedSVDTransposed
Distribution of sampler's A and U:
Local data: (  0.5377    1.8339   -2.2588    0.8622    0.3188  
              -1.3077   -0.4336    0.3426    3.5784    2.7694  
              -1.3499    3.0349    0.7254   -0.0631    0.7147  
             )
Process rank 0
=================
A->ctxt = 1
A->(m, n) = (3, 5)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (3, 3)
A->(mm, mn) = (3, 5)


Distribution of sampler's V:
Local data: ( -0.9093   -0.1798   -0.3752  
               0.4131   -0.2823   -0.8658  
              -0.0498    0.9423   -0.3310  
             )
Process rank 0
=================
A->ctxt = 2
A->(m, n) = (3, 3)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (3, 3)
A->(mm, mn) = (3, 3)


Computed singular values: 4.7698E+00  3.6011E+00  1.4576E+00  
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.1654678695838297, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.29609110552784845,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.46155897511167815, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.30832233292278777, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.12904302167895709,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.43736535460174486, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.77882650318085811, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.94545421529976204,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.16662771211890387, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.13884202231635007, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.18626762787368634,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.3251096501900364, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.20455937598306617, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.9622878546191842,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.75772847863611803, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.26120084453304221, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.19065741811692377,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.45185826264996598, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.17518683713505692, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.18257233495826697,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.0073854978232100466, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.44415745273978052, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.037611622210901322,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.48176907495068183, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.78549822817264658, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.085985452566386622,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.87148368073903315, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.088751412265948515, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.71182477196996774,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.62307335970401923, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.17705237494593254, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.21447709666524431,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.037424721719311764, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.135703802018661, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.20561196161382506,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.069908159595164068, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.039752393551045428, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.58103981322401277,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.54128741967296734, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.067161817549816108, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.0996740903599522,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.032512272810136092, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:228: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) is 0.081029550084531832, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.14176141533283554,
abs(basis_right_true_ans[row_offset[d_rank] * 3 + i]) evaluates to 0.0607318652483037, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.072827062654433949, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.29220118965151742,
abs(basis_true_ans[i]) evaluates to 0.21937412699708347, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.4337083177025543, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.38701827790664817,
abs(basis_true_ans[i]) evaluates to 0.82072659560920247, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.34702342589123303, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.8745486363447208,
abs(basis_true_ans[i]) evaluates to 0.52752521045348777, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.038844274799944456, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.92250639604755147,
abs(basis_true_ans[i]) evaluates to 0.88366212124760701, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.041121452159888772, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.35520511662783122,
abs(basis_true_ans[i]) evaluates to 0.39632656878771999, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.098097486849904242, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.15103401727017279,
abs(basis_true_ans[i]) evaluates to 0.24913150412007704, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.16134988274320927, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.25219122510031233,
abs(basis_true_ans[i]) evaluates to 0.4135411078435216, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.43940798994975394, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.85090903020686104,
abs(basis_true_ans[i]) evaluates to 0.4115010402571071, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:233: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.35137060506876022, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.46081819440514998,
abs(basis_true_ans[i]) evaluates to 0.81218879947391021, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:237: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.023920151572226267, which exceeds 1e-7, where
sv->item(i) evaluates to 4.7698410058819114,
sv_true_ans[i] evaluates to 4.7459208543096851, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:237: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.34746642981073617, which exceeds 1e-7, where
sv->item(i) evaluates to 3.6011164288318369,
sv_true_ans[i] evaluates to 3.2536499990211007, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:237: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.68429221224446657, which exceeds 1e-7, where
sv->item(i) evaluates to 1.4575672872210159,
sv_true_ans[i] evaluates to 2.1418594994654825, and
1e-7 evaluates to 9.9999999999999995e-08.
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVDTransposed (1 ms)
[ RUN      ] RandomizedSVDTest.Test_RandomizedSVDSmallerSubspace
Distribution of sampler's A and U:
Local data: (  0.5377   -1.3077   -1.3499  
               1.8339   -0.4336    3.0349  
              -2.2588    0.3426    0.7254  
               0.8622    3.5784   -0.0631  
               0.3188    2.7694    0.7147  
             )
Process rank 0
=================
A->ctxt = 1
A->(m, n) = (5, 3)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (5, 5)
A->(mm, mn) = (5, 3)


Distribution of sampler's V:
Local data: ( -0.9929   -0.1187  
               0.1187   -0.9929  
             )
Process rank 0
=================
A->ctxt = 2
A->(m, n) = (2, 2)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (5, 5)
A->(mm, mn) = (2, 2)


Computed singular values: 4.6133E+00  1.8448E+00  
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.043123229337106217, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.38134513245650903,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.42446836179361525, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.39115063109136156, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.86860933316093525,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.47745870206957369, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.1738629884761187, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.52271104896021103,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.34884806048409234, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.38702243794322316, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.48328714680626988,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.87030958474949305, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.018878134545858322, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.14919936487725943,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.16807749942311775, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.031391206376244291, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.055692772119600151,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.02430156574335586, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.053612574412784442, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.56425713815414369,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.61786971256692813, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.016596178215956006, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.072738810062126166,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.089334988278082172, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.04615242321809554, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.49061439115558148,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.53676681437367701, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:319: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[row_offset[d_rank] * 2 + i]) is 0.017953505050804619, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.059655181853300182,
abs(basis_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.077608686904104801, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:324: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.057201541154882296, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.37575362437256643,
abs(basis_right_true_ans[i]) evaluates to 0.31855208321768413, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:324: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.28294848190315069, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.84610008880356791,
abs(basis_right_true_ans[i]) evaluates to 0.56315160690041721, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:324: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.081541634825927578, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.78008150233388607,
abs(basis_right_true_ans[i]) evaluates to 0.86162313715981365, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:324: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[i]) is 0.0016730274655981647, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.50900770764497449,
abs(basis_right_true_ans[i]) evaluates to 0.50733468017937633, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:328: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.079844118486406934, which exceeds 1e-7, where
sv->item(i) evaluates to 4.6133218692500302,
sv_true_ans[i] evaluates to 4.6931659877364371, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:328: Failure
The difference between sv->item(i) and sv_true_ans[i] is 1.1670580542149882, which exceeds 1e-7, where
sv->item(i) evaluates to 1.8447981099375361,
sv_true_ans[i] evaluates to 3.0118561641525243, and
1e-7 evaluates to 9.9999999999999995e-08.
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVDSmallerSubspace (1 ms)
[ RUN      ] RandomizedSVDTest.Test_RandomizedSVDTransposedSmallerSubspace
Distribution of sampler's A and U:
Local data: (  0.5377    1.8339   -2.2588    0.8622    0.3188  
              -1.3077   -0.4336    0.3426    3.5784    2.7694  
              -1.3499    3.0349    0.7254   -0.0631    0.7147  
             )
Process rank 0
=================
A->ctxt = 1
A->(m, n) = (3, 5)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (3, 3)
A->(mm, mn) = (3, 5)


Distribution of sampler's V:
Local data: ( -0.9929   -0.1187  
               0.1187   -0.9929  
             )
Process rank 0
=================
A->ctxt = 2
A->(m, n) = (2, 2)
A->(nprow, npcol) = (1, 1)
A->(pi, pj) = (0, 0)
A->(mb, nb) = (3, 3)
A->(mm, mn) = (2, 2)


Computed singular values: 4.6133E+00  1.8448E+00  
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.043123229337106217, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.38134513245650903,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.42446836179361525, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.39115063109136156, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.86860933316093525,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.47745870206957369, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.1738629884761187, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.52271104896021103,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.34884806048409234, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.38702243794322316, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.48328714680626988,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.87030958474949305, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.018878134545858322, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.14919936487725943,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.16807749942311775, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.031391206376244291, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.055692772119600151,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.02430156574335586, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.053612574412784442, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.56425713815414369,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.61786971256692813, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.016596178215956006, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.072738810062126166,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.089334988278082172, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.04615242321809554, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.49061439115558148,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.53676681437367701, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:435: Failure
The difference between abs(d_basis_right_vals[i]) and abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) is 0.017953505050804619, which exceeds 1e-7, where
abs(d_basis_right_vals[i]) evaluates to 0.059655181853300182,
abs(basis_right_true_ans[row_offset[d_rank] * 2 + i]) evaluates to 0.077608686904104801, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:440: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.057201541154882296, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.37575362437256643,
abs(basis_true_ans[i]) evaluates to 0.31855208321768413, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:440: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.28294848190315069, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.84610008880356791,
abs(basis_true_ans[i]) evaluates to 0.56315160690041721, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:440: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.081541634825927578, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.78008150233388607,
abs(basis_true_ans[i]) evaluates to 0.86162313715981365, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:440: Failure
The difference between abs(d_basis_vals[i]) and abs(basis_true_ans[i]) is 0.0016730274655981647, which exceeds 1e-7, where
abs(d_basis_vals[i]) evaluates to 0.50900770764497449,
abs(basis_true_ans[i]) evaluates to 0.50733468017937633, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:444: Failure
The difference between sv->item(i) and sv_true_ans[i] is 0.079844118486406934, which exceeds 1e-7, where
sv->item(i) evaluates to 4.6133218692500302,
sv_true_ans[i] evaluates to 4.6931659877364371, and
1e-7 evaluates to 9.9999999999999995e-08.
/g/g92/chung28/libROM/unit_tests/test_RandomizedSVD.cpp:444: Failure
The difference between sv->item(i) and sv_true_ans[i] is 1.1670580542149882, which exceeds 1e-7, where
sv->item(i) evaluates to 1.8447981099375361,
sv_true_ans[i] evaluates to 3.0118561641525243, and
1e-7 evaluates to 9.9999999999999995e-08.
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVDTransposedSmallerSubspace (1 ms)
[----------] 4 tests from RandomizedSVDTest (11 ms total)

[----------] Global test environment tear-down
[==========] 5 tests from 2 test suites ran. (11 ms total)
[  PASSED  ] 1 test.
[  FAILED  ] 4 tests, listed below:
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVD
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVDTransposed
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVDSmallerSubspace
[  FAILED  ] RandomizedSVDTest.Test_RandomizedSVDTransposedSmallerSubspace

 4 FAILED TESTS

Add dependency version information to INSTALL

Dependency version information should include:

BLAS version required
LAPACK version required
HDF5 version required, along with any required configuration options
Google Test version required
MPI version required

There are other dependencies that require version information, but let's start with the most important ones.

Add a self-contained example

Add one or more self-contained examples.

	ParFiniteElementSpace* sp_XV_space;

	smm = new CAROM::SampleMeshManager(spfespace);

	vector<int> sample_dofs_empty;
	vector<int> num_sample_dofs_per_proc_empty;
	num_sample_dofs_per_proc_empty.assign(num_procs, 0);

	smm->RegisterSampledVariable("V", 0, sample_dofs,
	num_sample_dofs_per_proc);
	smm->RegisterSampledVariable("X", 0, sample_dofs,
	num_sample_dofs_per_proc);
	smm->RegisterSampledVariable("H", 0, sample_dofs,
	num_sample_dofs_per_proc);

	smm->ConstructSampleMesh();

llnl / librom Goto Github PK

librom's Introduction

Introduction

Features

Features to be added

Installation

Compiling on LC Machines

Installing via Spack

Compiling and linking with libROM

Using Docker container

libROM CI

License

Authors

librom's People

Contributors

Stargazers

Watchers

Forkers

librom's Issues

Issue

Affected

Fix

Is d_basis_right transposed or not?

Distribution of d_basis/d_basis_right among the processes

Recommend Projects

Recommend Topics

Recommend Org

Is `d_basis_right` transposed or not?

Distribution of `d_basis`/`d_basis_right` among the processes