PetscPreTimeStep.cpp File Reference

Pre-time-step function. More...

#include <stdio.h>
#include <basic.h>
#include <arrayfunctions.h>
#include <mpivars_cpp.h>
#include <simulation_object.h>
#include <petscinterface.h>
#include <librom_interface.h>

Go to the source code of this file.

Macros
#define	__FUNCT__   "PetscPreTimeStep"

Functions
int	OutputSolution (void *, int, double)
PetscErrorCode	PetscPreTimeStep (TS ts)

Detailed Description

Pre-time-step function.

Author

Debojyoti Ghosh

Definition in file PetscPreTimeStep.cpp.

Macro Definition Documentation

__FUNCT__

#define __FUNCT__   "PetscPreTimeStep"

Definition at line 21 of file PetscPreTimeStep.cpp.

Function Documentation

OutputSolution()

int OutputSolution	(	void *	s,
		int	nsims,
		double	a_time
	)

Write solutions to file

Write out the solution to file

Parameters

s	Array of simulation objects of type SimulationObject
nsims	Number of simulation objects
a_time	Current simulation time

Definition at line 27 of file OutputSolution.cpp.

{
  SimulationObject* simobj = (SimulationObject*) s;
  int ns;
  _DECLARE_IERR_;

  for (ns = 0; ns < nsims; ns++) {

    HyPar*        solver = &(simobj[ns].solver);
    MPIVariables* mpi    = &(simobj[ns].mpi);

    if ((!solver->WriteOutput) && (strcmp(solver->plot_solution,"yes"))) continue;

    /* time integration module may have auxiliary arrays to write out, so get them */
    int NSolutions = 0;
    IERR TimeGetAuxSolutions(&NSolutions,NULL,solver,-1,ns); CHECKERR(ierr);
    if (NSolutions > 10) NSolutions = 10;

    int  nu;
    char fname_root[_MAX_STRING_SIZE_];
    char aux_fname_root[_MAX_STRING_SIZE_];
    strcpy(fname_root, solver->op_fname_root);
    strcpy(aux_fname_root, solver->aux_op_fname_root);

    if (nsims > 1) {
      char index[_MAX_STRING_SIZE_];
      GetStringFromInteger(ns, index, (int)log10(nsims)+1);
      strcat(fname_root, "_");
      strcat(fname_root, index);
      strcat(aux_fname_root, "_");
      strcat(aux_fname_root, index);
    }

    for (nu=0; nu<NSolutions; nu++) {

      double  *uaux = NULL;
      IERR TimeGetAuxSolutions(&NSolutions,&uaux,solver,nu,ns); CHECKERR(ierr);

      IERR WriteArray(  solver->ndims,
                        solver->nvars,
                        solver->dim_global,
                        solver->dim_local,
                        solver->ghosts,
                        solver->x,
                        uaux,
                        solver,
                        mpi,
                        aux_fname_root ); CHECKERR(ierr);

      aux_fname_root[2]++;
    }

#if defined(HAVE_CUDA)
    if (solver->use_gpu) {
      /* Copy values from GPU memory to CPU memory for writing. */
      gpuMemcpy(solver->x, solver->gpu_x, sizeof(double)*solver->size_x, gpuMemcpyDeviceToHost);

#ifdef CUDA_VAR_ORDERDING_AOS
      gpuMemcpy(  solver->u, 
                  solver->gpu_u, 
                  sizeof(double)*solver->ndof_cells_wghosts, 
                  gpuMemcpyDeviceToHost );
#else
      double *h_u = (double *) malloc(sizeof(double)*solver->ndof_cells_wghosts);
      gpuMemcpy(h_u, solver->gpu_u, sizeof(double)*solver->ndof_cells_wghosts, gpuMemcpyDeviceToHost);
      for (int i=0; i<solver->npoints_local_wghosts; i++) {
        for (int v=0; v<solver->nvars; v++) {
          solver->u[i*solver->nvars+v] = h_u[i+v*solver->npoints_local_wghosts];
        }
      }
      free(h_u);
#endif
    }
#endif

    WriteArray(  solver->ndims,
                 solver->nvars,
                 solver->dim_global,
                 solver->dim_local,
                 solver->ghosts,
                 solver->x,
                 solver->u,
                 solver,
                 mpi,
                 fname_root );

    if (!strcmp(solver->plot_solution, "yes")) {
      PlotArray(   solver->ndims,
                   solver->nvars,
                   solver->dim_global,
                   solver->dim_local,
                   solver->ghosts,
                   solver->x,
                   solver->u,
                   a_time,
                   solver,
                   mpi,
                   fname_root );
    }

    /* increment the index string, if required */
    if ((!strcmp(solver->output_mode,"serial")) && (!strcmp(solver->op_overwrite,"no"))) {
      IncrementFilenameIndex(solver->filename_index,solver->index_length);
    }

  }

  return(0);
}

PetscPreTimeStep()

PetscErrorCode PetscPreTimeStep

(

TS

ts

)

Function called before a time step

Parameters

ts	Time integration object

Definition at line 24 of file PetscPreTimeStep.cpp.

{
  PETScContext* context(nullptr);

  PetscFunctionBegin;

  TSGetApplicationContext(ts,&context);
  if (!context) {
    fprintf(stderr,"Error in PetscPreTimeStep: Null context!\n");
    return(1);
  }
  gettimeofday(&(context->iter_start_time),NULL);
  SimulationObject* sim = (SimulationObject*) context->simobj;
  int nsims = context->nsims;

  Vec Y;
  TSGetSolution(ts,&Y);

  double waqt;
  TSGetTime(ts,&waqt);
  double dt;
  TSGetTimeStep(ts,&dt);
  int iter;
  TSGetStepNumber(ts,&iter);

  context->dt = dt;
  context->waqt = waqt;
  context->t_start = waqt;

  TSType time_scheme;
  TSGetType(ts,&time_scheme);

  for (int ns = 0; ns < nsims; ns++) {

    HyPar* solver = &(sim[ns].solver);
    MPIVariables* mpi = &(sim[ns].mpi);

    /* get solution */
    TransferVecFromPETSc(solver->u,Y,context,ns,context->offsets[ns]);

    /* save a copy of the solution to compute norm at end of time step */
    _ArrayCopy1D_(solver->u,solver->u0,(solver->npoints_local_wghosts*solver->nvars));

    /* apply boundary conditions and exchange data over MPI interfaces */
    solver->ApplyBoundaryConditions(solver,mpi,solver->u,NULL,waqt);
    solver->ApplyIBConditions(solver,mpi,solver->u,waqt);
    MPIExchangeBoundariesnD(  solver->ndims,
                              solver->nvars,
                              solver->dim_local,
                              solver->ghosts,
                              mpi,
                              solver->u );

    /* Call any physics-specific pre-step function */
    if (solver->PreStep) solver->PreStep(solver->u,solver,mpi,waqt);

    /* If using a non-linear scheme with ARKIMEX methods, 
       compute the non-linear finite-difference operator */
    if (!strcmp(time_scheme,TSARKIMEX)) {
      solver->NonlinearInterp(solver->u,solver,mpi,waqt,solver->FFunction); 
    }
    
    /* set the step boundary flux integral value to zero */
    _ArraySetValue_(solver->StepBoundaryIntegral,2*solver->ndims*solver->nvars,0.0);

    TransferVecToPETSc(solver->u,Y,context,ns,context->offsets[ns]);

  }


  if (!iter) { 
    for (int ns = 0; ns < nsims; ns++) {
      HyPar* solver = &(sim[ns].solver);
      MPIVariables* mpi = &(sim[ns].mpi);
      if (solver->PhysicsOutput) solver->PhysicsOutput(solver,mpi,waqt);
    }
    OutputSolution(sim, nsims,waqt);
#ifdef with_librom
    context->op_times_arr.push_back(waqt);
#endif
  }

#ifdef with_librom
  if (      (context->rom_mode == _ROM_MODE_TRAIN_) 
        &&  (iter%((libROMInterface*)context->rom_interface)->samplingFrequency() == 0)  ) {
    ((libROMInterface*)context->rom_interface)->takeSample( sim, waqt );
  }
#endif

  PetscFunctionReturn(0);
}