rom: Galerkin: masked problem

API, Parameters and Requirements

problem = galerkin.MaskedExplicitProblem(scheme, fom_adapter, decoder,
                                         rom_state, fom_ref_state, \      (1)
                                         projector, masker)

problem = galerkin.MaskedImplicitProblem(scheme, fom_adapter, decoder,
                                         rom_state, fom_ref_state, \      (2)
                                         projector, masker)

• scheme:
  • value from the ode.stepscheme enum setting the desired stepping scheme
  • (1) requires explicit value
  • (2) requires implicit value
• fom_adapter:
  • instance of your adapter class specifying the FOM problem.
    
  • must satisfy one of the APIs suitable for Galerkin, see API list
• decoder:
  • decoder object
  • must satify the requirements listed here
• rom_state:
  • currently, must be a rank-1 numpy.array
• fom_ref_state:
  • your FOM reference state that is used when reconstructing the FOM state
  • must be a rank-1 numpy.array
• projector:
  • performs the projection of the FOM operators onto the reduced space
  • must meet this specific API
• masker:
  • an functor responsible of "masking" the FOM operators
  • must be a functor with a specific API, see details below

class Masker:
  def __init__(self, sample_indices):
    self.sample_indices = sample_indices
    self.N = len(self.sample_indices)

  def createApplyMaskResult(self, operand):
      if (operand.ndim == 1):
        return np.zeros(N)
      else:
        return np.zeros((N, , operand.shape[1]))

  def __call__(self, operand, time, result):
    # time is not used, but you can potentially
    result[:] = np.take(operand, self.sample_indices)