libROMInterface Class Reference

Class implementing interface with libROM. More...

#include <librom_interface.h>

Public Member Functions
	libROMInterface ()
	libROMInterface (void *a_s, int a_nsims, int a_rank, int a_nproc, double a_dt)
void	define (void *, int, int, int, double)
	~libROMInterface ()
int	samplingFrequency () const
const std::string &	mode () const
const std::string &	componentMode () const
const std::string &	type () const
double	trainWallclockTime () const
double	predictWallclockTime () const
void	takeSample (void *a_s, const double a_t)
void	projectInitialSolution (void *a_s)
void	train ()
void	predict (void *a_s, const double a_t) const
void	saveROM (const std::string &a_fname_root="") const
void	loadROM (const std::string &a_fname_root="")
void	copyFromHyPar (std::vector< CAROM::Vector * > &, void *)
void	copyToHyPar (const CAROM::Vector &, void *, int) const
void	copyToHyPar (const CAROM::Vector &, void *, int, int) const

Protected Attributes
bool	m_is_defined
int	m_rank
int	m_nproc
int	m_nsims
std::vector< int >	m_vec_size
int	m_rdim
int	m_sampling_freq
std::string	m_mode
std::string	m_comp_mode
std::string	m_rom_type
std::vector< int >	m_ncomps
std::vector< ROMObject * >	m_rom
std::vector< CAROM::Vector * >	m_U
struct timeval	m_train_start
struct timeval	m_train_end
struct timeval	m_predict_start
struct timeval	m_predict_end
double	m_train_wctime
double	m_predict_wctime
bool	m_save_ROM

Detailed Description

Class implementing interface with libROM.

Class implementing interface with libROM This class implements the interface between HyPar and libROM. For details on libROM, see: https://github.com/LLNL/libROM.

This class implements the interface between HyPar and libROM. For details on libROM, see: https://github.com/LLNL/libROM.

Definition at line 45 of file librom_interface.h.

Constructor & Destructor Documentation

libROMInterface ( )

inline

Default constructor

Definition at line 50 of file librom_interface.h.

    {
      m_is_defined = false;
      m_rank = -1;
      m_nproc = -1;
      m_nsims = -1;
      m_vec_size.clear();
      m_rdim = -1;
      m_sampling_freq = 1;
      m_mode = _ROM_MODE_TRAIN_;
      m_comp_mode = "monolithic";
      m_ncomps.clear();
      m_rom.clear();
      m_U.clear();
      m_train_wctime = 0;
      m_predict_wctime = 0;
      m_save_ROM = true;
    }

libROMInterface ( void *  a_s, int  a_nsims, int  a_rank, int  a_nproc, double  a_dt  )

inline

Constructor

Parameters

a_s	Array of simulation objects of type SimulationObject
a_nsims	number of simulation objects
a_rank	MPI rank of this process
a_nproc	Number of MPI processes
a_dt	Time step size

Definition at line 70 of file librom_interface.h.

    {
      define( a_s, a_nsims, a_rank, a_nproc, a_dt );
    }

~libROMInterface ( )

inline

Destructor

Definition at line 83 of file librom_interface.h.

    {
      for (int i = 0; i < m_rom.size(); i++) delete m_rom[i];
      m_rom.clear();
      for (int i = 0; i < m_U.size(); i++) delete m_U[i];
      m_U.clear();
    }

Member Function Documentation

void define	(	void *	a_s,
		int	a_nsims,
		int	a_rank,
		int	a_nproc,
		double	a_dt
	)

Define the interface

Define the libROM interface

This function also reads libROM-related inputs from the file librom.inp. Rank 0 reads in the inputs and broadcasts them to all the processors.

The format of librom.inp is as follows:

begin
    <keyword>   <value>
    ...
    <keyword>   <value>
end

where the list of keywords and their type that this function will read are:

Keyword name	Type	Variable	Default value
rdim	int	libROMInterface::m_rdim	-1
sampling_frequency	int	libROMInterface::m_sampling_freq	1
mode	string	libROMInterface::m_mode	"train"
component_mode	string	libROMInterface::m_comp_mode	"monolithic"
type	string	libROMInterface::m_rom_type	"DMD"
save_to_file	string	libROMInterface::m_save_ROM	"true"

Note: other keywords in this file may be read by other functions. The default value for rdim is invalid, so it must be specified.

Parameters

a_s	Array of simulation objects of type SimulationObject
a_nsims	number of simulation objects
a_rank	MPI rank of this process
a_nproc	Number of MPI processes
a_dt	Time step size

Definition at line 40 of file libROMInterface.cpp.

{
  const SimulationObject* sim = (const SimulationObject*) a_s;

  m_rank = a_rank;
  m_nproc = a_nproc;
  m_nsims = a_nsims;

  char mode_c_str[_MAX_STRING_SIZE_];
  char comp_mode_c_str[_MAX_STRING_SIZE_];
  char type_c_str[_MAX_STRING_SIZE_];
  char save_c_str[_MAX_STRING_SIZE_];

  if (!m_rank) {

    FILE *in;
    in = fopen(_LIBROM_INP_FNAME_,"r");

    if (!in) {

      strcpy( mode_c_str, _ROM_MODE_NONE_ );
      strcpy( comp_mode_c_str, _ROM_COMP_MODE_MONOLITHIC_ );
      strcpy( type_c_str, _ROM_TYPE_NONE_ );
      strcpy( save_c_str, "false" );

      m_rdim = -1;
      m_sampling_freq = 1;

    } else {

      strcpy( mode_c_str, _ROM_MODE_TRAIN_ );
      strcpy( comp_mode_c_str, _ROM_COMP_MODE_MONOLITHIC_ );
      strcpy( type_c_str,_ROM_TYPE_DMD_ );
      strcpy( save_c_str, "true" );

      int ferr;
      char word[_MAX_STRING_SIZE_];
      ferr = fscanf(in,"%s", word); if (ferr != 1) return;

      if (std::string(word) == "begin") {
        while (std::string(word) != "end") {
          ferr = fscanf(in,"%s",word); if (ferr != 1) return;
          if (std::string(word) == "rdim") {
            ferr = fscanf(in,"%d", &m_rdim); if (ferr != 1) return;
          } else if (std::string(word) == "sampling_frequency") {
            ferr = fscanf(in,"%d", &m_sampling_freq); if (ferr != 1) return;
          } else if (std::string(word) == "mode") {
            ferr = fscanf(in,"%s", mode_c_str); if (ferr != 1) return;
          } else if (std::string(word) == "component_mode") {
            ferr = fscanf(in,"%s", comp_mode_c_str); if (ferr != 1) return;
          } else if (std::string(word) == "type") {
            ferr = fscanf(in,"%s", type_c_str); if (ferr != 1) return;
          } else if (std::string(word) == "save_to_file") {
            ferr = fscanf(in,"%s", save_c_str); if (ferr != 1) return;
          }
          if (ferr != 1) return;
        }
      } else {
        fprintf( stderr, "Error: Illegal format in file \"%s\". Word read is: %s\n",
                 _LIBROM_INP_FNAME_, word);
        return;
      }

      fclose(in);

    }

    /* print useful stuff to screen */
    if (std::string(mode_c_str) != _ROM_MODE_NONE_) {
      printf("libROMInterface inputs and parameters:\n");
      printf("  reduced model dimensionality:  %d\n", m_rdim);
      printf("  sampling frequency:  %d\n", m_sampling_freq);
      printf("  mode: %s\n", mode_c_str);
      printf("  component mode: %s\n", comp_mode_c_str);
      printf("  type: %s\n", type_c_str);
      printf("  save to file: %s\n", save_c_str);
    }
  }

#ifndef serial
  MPI_Bcast(&m_rdim,1,MPI_INT,0,MPI_COMM_WORLD);
  MPI_Bcast(&m_sampling_freq,1,MPI_INT,0,MPI_COMM_WORLD);
  MPI_Bcast(mode_c_str,_MAX_STRING_SIZE_,MPI_CHAR,0,MPI_COMM_WORLD);
  MPI_Bcast(comp_mode_c_str,_MAX_STRING_SIZE_,MPI_CHAR,0,MPI_COMM_WORLD);
  MPI_Bcast(type_c_str,_MAX_STRING_SIZE_,MPI_CHAR,0,MPI_COMM_WORLD);
  MPI_Bcast(save_c_str,_MAX_STRING_SIZE_,MPI_CHAR,0,MPI_COMM_WORLD);
#endif

  m_mode = std::string( mode_c_str );
  m_comp_mode = std::string( comp_mode_c_str );
  m_rom_type = std::string( type_c_str );

  m_save_ROM = (((std::string(save_c_str) == "true")) && (m_mode == _ROM_MODE_TRAIN_));

  if (m_mode != _ROM_MODE_NONE_) {

    m_vec_size.resize(m_nsims);
    for (int ns = 0; ns < m_nsims; ns++) {
      m_vec_size[ns] = (sim[ns].solver.npoints_local);
      if (m_comp_mode == _ROM_COMP_MODE_MONOLITHIC_) {
        m_vec_size[ns] *= (sim[ns].solver.nvars);
      }
    }
  
    m_rom.clear();
    m_U.clear();
    if (m_comp_mode == _ROM_COMP_MODE_MONOLITHIC_) {
      for (int ns = 0; ns < m_nsims; ns++) {
        if (m_rom_type == _ROM_TYPE_DMD_) {
          m_rom.push_back(new DMDROMObject( m_vec_size[ns], 
                                            m_sampling_freq*a_dt, 
                                            m_rdim, 
                                            m_rank, 
                                            m_nproc, 
                                            ns ) );
        }
        m_U.push_back(new CAROM::Vector(m_vec_size[ns],true));
      }
    } else if (m_comp_mode == _ROM_COMP_MODE_COMPONENTWISE_) {
      for (int ns = 0; ns < m_nsims; ns++) {
        m_ncomps.push_back(sim[ns].solver.nvars);
        for (int v = 0; v < sim[ns].solver.nvars; v++) {
          if (m_rom_type == _ROM_TYPE_DMD_) {
            m_rom.push_back(new DMDROMObject( m_vec_size[ns], 
                                              m_sampling_freq*a_dt, 
                                              m_rdim, 
                                              m_rank, 
                                              m_nproc,
                                              ns,
                                              v ) );
          }
          m_U.push_back(new CAROM::Vector(m_vec_size[ns],true));
        }
      }
    }

  } else {

    m_rom.clear();
    m_U.clear();
    m_ncomps.clear();

  }

  m_train_wctime = 0;
  m_predict_wctime = 0;

  m_is_defined = true;
  return;
}

int samplingFrequency ( ) const

inline

return the sampling frequency

Definition at line 92 of file librom_interface.h.

{ return m_sampling_freq; }

const std::string& mode ( ) const

inline

return the mode

Definition at line 94 of file librom_interface.h.

{ return m_mode; }

const std::string& componentMode ( ) const

inline

return the component mode

Definition at line 96 of file librom_interface.h.

{ return m_comp_mode; }

const std::string& type ( ) const

inline

return the ROM type

Definition at line 98 of file librom_interface.h.

{ return m_rom_type; }

double trainWallclockTime ( ) const

inline

return the training wall clock time

Definition at line 100 of file librom_interface.h.

{ return m_train_wctime; }

double predictWallclockTime ( ) const

inline

return the prediction wall clock time

Definition at line 102 of file librom_interface.h.

{ return m_predict_wctime; }

void takeSample	(	void *	a_s,
		const double	a_t
	)

Take a sample for training

Parameters

a_s	Array of simulation objects of type SimulationObject
a_t	Current simulation time

Definition at line 196 of file libROMInterface.cpp.

{
  if (m_U.size() != m_rom.size()) {
    printf( "ERROR in libROMInterface::takeSample(): m_U.size != m_rom.size() on rank %d!!\n",
            m_rank );
  }

  copyFromHyPar( m_U, a_s );
  gettimeofday(&m_train_start, NULL);
  for (int i = 0; i < m_rom.size(); i++) {
    m_rom[i]->takeSample( *(m_U[i]), a_t );
  }
  gettimeofday(&m_train_end, NULL);

  long long walltime;
  walltime = (  (m_train_end.tv_sec*1000000 + m_train_end.tv_usec)
              - (m_train_start.tv_sec*1000000 + m_train_start.tv_usec) );
  m_train_wctime += (double) walltime / 1000000.0;

#ifndef serial
  MPI_Allreduce(  MPI_IN_PLACE,
                  &m_train_wctime,
                  1,
                  MPI_DOUBLE,
                  MPI_MAX,
                  MPI_COMM_WORLD );
#endif
}

void projectInitialSolution

(

void *

a_s

)

Project initial solution for prediction

Parameters

a_s	Array of simulation objects of type SimulationObject

Definition at line 228 of file libROMInterface.cpp.

{
  if (m_U.size() != m_rom.size()) {
    printf("ERROR in libROMInterface::projectInitialSolution(): m_U.size != m_rom.size() on rank %d!\n",
            m_rank );
  }

  copyFromHyPar( m_U, a_s );
  for (int i = 0; i < m_rom.size(); i++) {
    m_rom[i]->projectInitialSolution( *(m_U[i]) );
  }

  return;
}

void train

(

)

Train the ROM object

Definition at line 245 of file libROMInterface.cpp.

{
  gettimeofday(&m_train_start, NULL);
  for (int i = 0; i < m_rom.size(); i++) {
    m_rom[i]->train();
  }
  gettimeofday(&m_train_end, NULL);

  long long walltime;
  walltime = (  (m_train_end.tv_sec*1000000 + m_train_end.tv_usec)
              - (m_train_start.tv_sec*1000000 + m_train_start.tv_usec) );
  m_train_wctime += (double) walltime / 1000000.0;
#ifndef serial
  MPI_Allreduce(  MPI_IN_PLACE,
                  &m_train_wctime,
                  1,
                  MPI_DOUBLE,
                  MPI_MAX,
                  MPI_COMM_WORLD );
#endif
}

void predict	(	void *	a_s,
		const double	a_t
	)		const

Predict the solution at a given time

Parameters

a_s	Array of simulation objects of type SimulationObject
a_t	time at which to predict solution

Definition at line 268 of file libROMInterface.cpp.

{
  m_predict_wctime = 0.0;

  if (m_comp_mode == _ROM_COMP_MODE_MONOLITHIC_) {

    for (int ns = 0; ns < m_nsims; ns++) {
      gettimeofday(&m_predict_start, NULL);
      const CAROM::Vector* const u_predicted = m_rom[ns]->predict(a_t);
      gettimeofday(&m_predict_end, NULL);
      copyToHyPar( *u_predicted, a_s, ns );

      long long walltime;
      walltime = (  (m_predict_end.tv_sec*1000000 + m_predict_end.tv_usec)
                  - (m_predict_start.tv_sec*1000000 + m_predict_start.tv_usec) );
      m_predict_wctime += (double) walltime / 1000000.0;
    }

  } else if (m_comp_mode == _ROM_COMP_MODE_COMPONENTWISE_) {

    int count(0);
    for (int ns = 0; ns < m_nsims; ns++) {
      for (int v = 0; v < m_ncomps[ns]; v++) {
        gettimeofday(&m_predict_start, NULL);
        const CAROM::Vector* const u_predicted = m_rom[count]->predict(a_t);
        gettimeofday(&m_predict_end, NULL);
        copyToHyPar( *u_predicted, a_s, ns, v );

        long long walltime;
        walltime = (  (m_predict_end.tv_sec*1000000 + m_predict_end.tv_usec)
                    - (m_predict_start.tv_sec*1000000 + m_predict_start.tv_usec) );
        m_predict_wctime += (double) walltime / 1000000.0;
        count++;
      }
    }

  }

#ifndef serial
  MPI_Allreduce(  MPI_IN_PLACE,
                  &m_predict_wctime,
                  1,
                  MPI_DOUBLE,
                  MPI_MAX,
                  MPI_COMM_WORLD );
#endif
}

void saveROM

(

const std::string &

a_fname_root = ""

)

const

Save ROM object to file

Parameters

a_fname_root

filename root

Definition at line 318 of file libROMInterface.cpp.

{
  if (m_save_ROM) {      

    if (!m_rank) {
      printf("libROMInterface::saveROM() - saving ROM objects.\n");
    }

    if (m_comp_mode == _ROM_COMP_MODE_MONOLITHIC_) {

      for (int ns = 0; ns < m_nsims; ns++) {
        std::string fname_root = a_fname_root;
        if (m_nsims > 1) {
          char idx_string[_MAX_STRING_SIZE_];
          sprintf(idx_string, "sim%03d", ns);
          fname_root += std::string(idx_string);
        }
        m_rom[ns]->save(fname_root);
      }

    } else if (m_comp_mode == _ROM_COMP_MODE_COMPONENTWISE_) {

      int count(0);
      for (int ns = 0; ns < m_nsims; ns++) {
        for (int v = 0; v < m_ncomps[ns]; v++) {
          std::string fname_root = a_fname_root;
          if (m_nsims > 1) {
            char idx_string[_MAX_STRING_SIZE_];
            sprintf(idx_string, "sim%03d", ns);
            fname_root += std::string(idx_string);
          }
          if (m_ncomps[ns] > 1) {
            char idx_string[_MAX_STRING_SIZE_];
            sprintf(idx_string, "var%03d", v);
            fname_root += std::string(idx_string);
          }
          m_rom[count]->save(fname_root);
          count++;
        }
      }

    }

  }

  return;
}

void loadROM

(

const std::string &

a_fname_root = ""

)

load ROM object from file

Parameters

a_fname_root

filename root

Definition at line 367 of file libROMInterface.cpp.

{
  if (!m_rank) {
    printf("libROMInterface::loadROM() - loading ROM objects.\n");
  }

  if (m_comp_mode == _ROM_COMP_MODE_MONOLITHIC_) {

    for (int ns = 0; ns < m_nsims; ns++) {
      std::string fname_root = a_fname_root;
      if (m_nsims > 1) {
        char idx_string[_MAX_STRING_SIZE_];
        sprintf(idx_string, "sim%03d", ns);
        fname_root += std::string(idx_string);
      }
      m_rom[ns]->load(fname_root);
    }

  } else if (m_comp_mode == _ROM_COMP_MODE_COMPONENTWISE_) {

    int count(0);
    for (int ns = 0; ns < m_nsims; ns++) {
      for (int v = 0; v < m_ncomps[ns]; v++) {
        std::string fname_root = a_fname_root;
        if (m_nsims > 1) {
          char idx_string[_MAX_STRING_SIZE_];
          sprintf(idx_string, "sim%03d", ns);
          fname_root += std::string(idx_string);
        }
        if (m_ncomps[ns] > 1) {
          char idx_string[_MAX_STRING_SIZE_];
          sprintf(idx_string, "var%03d", v);
          fname_root += std::string(idx_string);
        }
        m_rom[count]->load(fname_root);
        count++;
      }
    }

  }

  return;
}

void copyFromHyPar	(	std::vector< CAROM::Vector * > &	a_U,
		void *	a_s
	)

Copy HyPar solution to the work vectors m_U

Copy HyPar solution to the work vectors a_U. Note that the HyPar solution has ghost points but the work vectors a_U is a serialized vector of the solution without ghost points

Parameters

a_U	work vector
a_s	Array of simulation objects of type SimulationObject

Definition at line 414 of file libROMInterface.cpp.

{
  const SimulationObject* sim = (const SimulationObject*) a_s;

  if (m_comp_mode == _ROM_COMP_MODE_MONOLITHIC_) {

    for (int ns = 0; ns < m_nsims; ns++) {
      double* vec = a_U[ns]->getData();
      const double* u = sim[ns].solver.u;
  
      std::vector<int> index(sim[ns].solver.ndims);
  
      ArrayCopynD(  sim[ns].solver.ndims,
                    u,
                    vec,
                    sim[ns].solver.dim_local,
                    sim[ns].solver.ghosts,
                    0,
                    index.data(),
                    sim[ns].solver.nvars );
    }

  } else if (m_comp_mode == _ROM_COMP_MODE_COMPONENTWISE_) {

    int count(0);
    for (int ns = 0; ns < m_nsims; ns++) {
      for (int v = 0; v < sim[ns].solver.nvars; v++) {
        double* vec = a_U[count]->getData();
        const double* u = sim[ns].solver.u;
  
        std::vector<int> index(sim[ns].solver.ndims);
  
        ArrayCopynDComponent( sim[ns].solver.ndims,
                              u,
                              vec,
                              sim[ns].solver.dim_local,
                              sim[ns].solver.ghosts,
                              0,
                              index.data(),
                              sim[ns].solver.nvars,
                              1,
                              v,
                              0 );
        count++;
      }
    }

  }

  return;
}

void copyToHyPar	(	const CAROM::Vector &	a_vec,
		void *	a_s,
		int	a_idx
	)		const

Copy a vector to HyPar

Copy a vector a_vec to HyPar solution. Note that the HyPar solution has ghost points but the vector a_vec is a serialized vector of the solution without ghost points.

Note: if libROMInterface::m_mode is "predict", then the vector will be copied into the main solution variable HyPar::u; otherwise it will be copied into the variable for ROM prediction HyPar::u_rom_predicted

Parameters

a_vec	Work vector
a_s	Array of simulation objects of type SimulationObject
a_idx	Simulation object index

Definition at line 475 of file libROMInterface.cpp.

{
  SimulationObject* sim = (SimulationObject*) a_s;

  double* u;
  if (m_mode == _ROM_MODE_TRAIN_) {
    u = sim[a_idx].solver.u_rom_predicted;
  } else {
    u = sim[a_idx].solver.u;
  }
  std::vector<int> index(sim[a_idx].solver.ndims);

  ArrayCopynD(  sim[a_idx].solver.ndims,
                a_vec.getData(),
                u,
                sim[a_idx].solver.dim_local,
                0,
                sim[a_idx].solver.ghosts,
                index.data(),
                sim[a_idx].solver.nvars );

  return;
}

void copyToHyPar	(	const CAROM::Vector &	a_vec,
		void *	a_s,
		int	a_idx,
		int	a_var
	)		const

Copy a vector to HyPar

Copy a vector a_vec to a component of the HyPar solution. Note that the HyPar solution has ghost points but the vector a_vec is a serialized vector of one of the solution components without ghost points.

Note: if libROMInterface::m_mode is "predict", then the vector will be copied into the main solution variable HyPar::u; otherwise it will be copied into the variable for ROM prediction HyPar::u_rom_predicted

Parameters

a_vec	Work vector
a_s	Array of simulation objects of type SimulationObject
a_idx	Simulation object index
a_var	Vector component to copy

Definition at line 509 of file libROMInterface.cpp.

{
  SimulationObject* sim = (SimulationObject*) a_s;

  double* u;
  if (m_mode == _ROM_MODE_TRAIN_) {
    u = sim[a_idx].solver.u_rom_predicted;
  } else {
    u = sim[a_idx].solver.u;
  }
  std::vector<int> index(sim[a_idx].solver.ndims);

  ArrayCopynDComponent(  sim[a_idx].solver.ndims,
                        a_vec.getData(),
                        u,
                        sim[a_idx].solver.dim_local,
                        0,
                        sim[a_idx].solver.ghosts,
                        index.data(),
                        1,
                        sim[a_idx].solver.nvars,
                        0,
                        a_var );

  return;
}

Field Documentation

bool m_is_defined

protected

Boolean to show if this object is defined

Definition at line 133 of file librom_interface.h.

int m_rank

protected

MPI rank

Definition at line 135 of file librom_interface.h.

int m_nproc

protected

Number of MPI ranks

Definition at line 136 of file librom_interface.h.

int m_nsims

protected

Number of simulations

Definition at line 137 of file librom_interface.h.

std::vector<int> m_vec_size

protected

Solution vector size for each simulation

Definition at line 139 of file librom_interface.h.

int m_rdim

protected

Reduced model dimensionality

Definition at line 141 of file librom_interface.h.

int m_sampling_freq

protected

Frequency at which to take samples

Definition at line 142 of file librom_interface.h.

std::string m_mode

protected

Mode: none, train, predict

Definition at line 144 of file librom_interface.h.

std::string m_comp_mode

protected

Component mode: monolithic, component-wise

Definition at line 145 of file librom_interface.h.

std::string m_rom_type

protected

Type of ROM (eg: DMD)

Definition at line 146 of file librom_interface.h.

std::vector<int> m_ncomps

protected

Number of vector components for each simulation

Definition at line 148 of file librom_interface.h.

std::vector<ROMObject*> m_rom

protected

ROM objects

Definition at line 150 of file librom_interface.h.

std::vector<CAROM::Vector*> m_U

protected

Work vectors

Definition at line 151 of file librom_interface.h.

struct timeval m_train_start

protected

Definition at line 153 of file librom_interface.h.

struct timeval m_train_end

protected

Definition at line 154 of file librom_interface.h.

struct timeval m_predict_start

protected

Definition at line 155 of file librom_interface.h.

struct timeval m_predict_end

protected

Definition at line 156 of file librom_interface.h.

double m_train_wctime

mutableprotected

Wallclock time for training

Definition at line 157 of file librom_interface.h.

double m_predict_wctime

mutableprotected

Wallclock time for prediction

Definition at line 158 of file librom_interface.h.

bool m_save_ROM

protected

Save ROM objects to file (default: yes)

Definition at line 160 of file librom_interface.h.

---

The documentation for this class was generated from the following files:

• include/librom_interface.h
• src/ROM/libROMInterface.cpp