#include <FluidAgent.h>

Inheritance diagram for FluidAgent:

Collaboration diagram for FluidAgent:

Public Member Functions
	FluidAgent (Coupling *coup, std::string mod, std::string obj, MPI_Comm com, int withSolid=0)

virtual void	input (double t)

virtual void	load_module ()

virtual void	unload_module ()

virtual void	init_module (double t, double dt)

virtual void	finalize ()

virtual void	read_restart_data ()

virtual void	output_restart_files (double t)

virtual void	output_visualization_files (double t)

virtual void	create_buffer_all ()

virtual void	init_convergence (int iPredCorr)

virtual int	check_convergence (double tolerMass, double tolerTract, double tolerVelo)

virtual int	compute_integrals ()

Public Member Functions inherited from Agent
	Agent (Coupling cp, std::string mod, std::string obj, const char agent_name, MPI_Comm com, bool wgm=false, bool skipio=false)

virtual	~Agent ()

void	init_subscheduler (double t)

void	callMethod (Scheduler_voidfn1_t fn, double t)

void	schedule ()

double	max_timestep (double t, double dt)

Action *	get_main_action ()

void	register_new_attribute (std::string target_window_, std::string attr_, char loc_, int type_, int ncomp_, const char *unit_)

void	register_clone_attribute (int cond, std::string target_window_, std::string attr_, std::string parent_window_, std::string parent_attr_, int wg_=1, const char *ptnname_=0, int val_=0)

void	register_use_attribute (std::string target_window_, std::string attr_, std::string parent_window_, std::string parent_attr_, int wg_=1, const char *ptnname_=0, int val_=0)

void	create_registered_attributes (std::string tmpBuf)

void	create_registered_window_attributes (std::string target_window)

void	assign_attributes ()

void	add_data ()

void	add_icaction (Action *act)

void	add_bcaction (Action *act, int l=1)

void	add_bcinitaction (Action *act)

void	add_gmaction (Action *act)

void	init_callback (const char surf_win, const char vol_win, void *option=NULL)

void	init_bcactions (double t)

void	obtain_bc (double a, int l=NULL)

void	init_gmactions (double t)

void	obtain_gm (double *da)

void	init_bcinitaction (double t)

void	run_bcinitaction (double t, double dt)

Coupling *	get_coupling ()

void	register_interpolate (InterpolateBase *ip)

std::string	get_surface_window () const

std::string	get_volume_window () const

MPI_Comm	get_communicator () const

std::string	get_rocmod_name () const

std::string	get_modinstance_name () const

std::string	get_agent_name () const

int	get_comm_rank () const

double	get_old_dt () const

double *	get_integrals ()

void	print (FILE *f)

void	get_time_string (double t, std::string &s)

Public Attributes
std::string	ifluid

std::string	fluid

std::string	fluid_plag

std::string	fluidSurfIn

std::string	fluidVolIn

std::string	fluidPlagIn

std::string	fluidVPIn

std::string	ifluid_all

std::string	ifluid_i

std::string	ifluid_b

std::string	ifluid_nb

std::string	ifluid_ni

std::string	propBufAll

std::string	fluidBufNG

std::string	propBuf

std::string	fluidBufB

std::string	fluidBufNB

std::string	fluidBufPC

std::string	fluidBufBak

std::string	fluidBufPRE

std::string	fluidVolBak

std::string	fluidPlagBak

int	f_mdot_hdl

int	f_mdot_pre_hdl

int	f_ts_hdl

int	f_ts_pre_hdl

int	f_vm_hdl

int	f_vm_pre_hdl

int	nc_hdl

int	nc_tmp_hdl

int	sq_dist_hdl

Protected Attributes
bool	with_plag

string	plag_window

int	with_solid

Protected Attributes inherited from Agent
const std::string	agent_name

MPI_Comm	communicator

Coupling *	coupling

PhysicsAction	action

SchdulerList	bcScheduler

UserScheduler	bcInitScheduler

UserScheduler	gmScheduler

UserScheduler	icScheduler

int	comm_rank

int	init_handle

int	update_handle

int	pre_hdf_handle

int	post_hdf_handle

int	finalize_handle

int	compute_integrals_handle

int	ic_handle

int	bc_handle

int	gm_handle

bool	withgm

int	dobackup

string	rocmod_name

string	mod_instance

string	inDir

string	outDir

string	suffix

double	initial_time

double	timestamp

double	current_time

double	current_deltatime

double	old_dt

std::string	surf_window

std::string	vol_window

std::string	tmp_window

void *	option_data

InterpolateList	interpolateList

AttributeList	attributeList

int	pc_hdls [2][3]

int	pc_count

double	integrals [MAN_INTEG_SIZE]

bool	skipInputIO

Additional Inherited Members
Protected Types inherited from Agent
typedef vector< InterpolateBase * >	InterpolateList

typedef vector< AttributeBase * >	AttributeList

Protected Member Functions inherited from Agent
Scheduler *	get_bcScheduler (unsigned int level)

void	init_function_handles ()

void	create_window (const char *window_name)

void	split_surface_window (const std::string surfAll, const std::string surf_i, const std::string surf_nb, const std::string surf_b, const std::string surf_ni)

int	read_by_control_file (double t, const std::string base, const std::string window)

void	write_data_files (double t, const std::string base, const std::string attr, const char *ref=NULL)

void	write_control_file (double t, const std::string base, const std::string window)

virtual void	store_solutions (int converged)

int	check_convergence_help (int vcur, int vpre, double tol, std::string str)

Static Protected Attributes inherited from Agent
static int	read_by_control_handle =0

static int	read_files_handle =0

static int	obtain_attr_handle =0

static int	write_attr_handle =0

static int	write_ctrl_handle =0

Detailed Description

Definition at line 29 of file FluidAgent.h.

Constructor & Destructor Documentation

FluidAgent	(	Coupling *	coup,
		std::string	mod,
		std::string	obj,
		MPI_Comm	com,
		int	withSolid = `0`
	)

Definition at line 41 of file FluidAgent.C.

References Agent::dobackup, fluid, fluid_plag, fluidBufB, fluidBufBak, fluidBufNB, fluidBufNG, fluidBufPC, fluidBufPRE, fluidPlagBak, fluidPlagIn, fluidSurfIn, fluidVolBak, fluidVolIn, fluidVPIn, ifluid, ifluid_all, ifluid_b, ifluid_i, ifluid_nb, ifluid_ni, load_module(), propBuf, propBufAll, Agent::tmp_window, and with_solid.

                                                                                               :
     Agent(cp, mod, obj, "Fluid", com, true), 
     with_plag(false), with_solid(withSolid)
 {
   load_module();
 
   ifluid = "ifluid";           // for input
   fluid = "fluid";          
   fluid_plag = "fluid_plag";
 
   // Rocin windows, Input buffer windows
   fluidSurfIn = "fluidSurfIn";
   fluidVolIn = "fluidVolIn";
   fluidPlagIn = "fluidPlagIn";
   fluidVPIn = "fluidVolIn fluidPlagIn";
 
   ifluid_all = "ifluid_all";    // tmp buffer
   ifluid_i = "ifluid";         // FluidBuf
 
     // Surface windows for Rocout, Surface window buffers
   ifluid_b = "ifluid_b";                // fluidBufBOUT
   ifluid_nb = "ifluid_nb";              // fluidBufNBOUT
   ifluid_ni = "ifluid_ni";              // fluidBufNIOUT
 
   propBufAll = "FluidPropAll";
   fluidBufNG = "FluidBufNG";            // fluidBufNG
   propBuf = "FluidProp";
   fluidBufB      = "FluidBufB";
   fluidBufNB      = "FluidBufNB";
 
   fluidBufPC     = "FluidBufPC";        // surface data to be backed up
   fluidBufBak     = "fluidBufBak";      // back up PC iterations
   fluidBufPRE    = "FluidBufPRE";       //  for convergence check
 
   fluidVolBak    = "FluidVolBak";       // backup of volume data
   fluidPlagBak    = "FluidPlagBak";     // backup of volume data
 
   tmp_window = ifluid_all;
 
   if (!with_solid) dobackup = 0;
 }

Here is the call graph for this function:

Member Function Documentation

int check_convergence	(	double	tolerMass,
		double	tolerTract,
		double	tolerVelo
	)

virtual

Reimplemented from Agent.

Definition at line 551 of file FluidAgent.C.

References Agent::check_convergence_help(), f_mdot_hdl, f_mdot_pre_hdl, f_ts_hdl, f_ts_pre_hdl, f_vm_hdl, f_vm_pre_hdl, and MAN_DEBUG.

 {
   MAN_DEBUG(3, ("Rocstar: FluidAgent::check_convergence .\n"));
 
   int result = 0;
   if (!check_convergence_help(f_vm_hdl, f_vm_pre_hdl, tolerVelo, "vm")) return result;
   if (!check_convergence_help(f_ts_hdl, f_ts_pre_hdl, tolerTract, "ts")) return result;
   if (!check_convergence_help(f_mdot_hdl, f_mdot_pre_hdl, tolerMass, "mdot")) return result;
   return 1;
 }

Here is the call graph for this function:

int compute_integrals ( )

virtual

Reimplemented from Agent.

Definition at line 562 of file FluidAgent.C.

References COM_call_function(), Agent::compute_integrals_handle, Agent::integrals, and MAN_DEBUG.

 {
   if (compute_integrals_handle > 0) {
     MAN_DEBUG(3, ("Rocstar: FluidAgent::compute_integrals.\n"));
     COM_call_function(compute_integrals_handle, integrals);
   }
   return 1;
 }

Here is the call graph for this function:

void create_buffer_all ( )

virtual

Reimplemented from Agent.

Definition at line 202 of file FluidAgent.C.

References COM_call_function(), COM_clone_attribute(), COM_DOUBLE, COM_get_attribute_handle(), COM_INTEGER, COM_new_attribute(), COM_new_window(), COM_resize_array(), COM_use_attribute(), COM_window_init_done(), RocBlas::copy, Agent::create_buffer_all(), Agent::create_registered_window_attributes(), f_mdot_hdl, f_mdot_pre_hdl, f_ts_hdl, f_ts_pre_hdl, f_vm_hdl, f_vm_pre_hdl, fluidBufB, fluidBufBak, fluidBufNB, fluidBufNG, fluidBufPC, fluidBufPRE, fluidPlagBak, fluidVolBak, Agent::get_coupling(), Coupling::get_max_ipc(), ifluid_b, ifluid_i, ifluid_nb, ifluid_ni, nc_hdl, nc_tmp_hdl, Agent::pc_count, Agent::pc_hdls, plag_window, propBuf, propBufAll, read_restart_data(), sq_dist_hdl, Agent::surf_window, Agent::vol_window, with_plag, and with_solid.

 {
   Agent::create_buffer_all();
 
   COM_new_window( propBufAll);
   COM_use_attribute( propBufAll, surf_window+".mesh",  1);
   //  COM_use_attribute( propBufAll, surf_window+".bcflag");
     // Mesh motion velocities
   COM_new_attribute( propBufAll+".vm", 'n', COM_DOUBLE, 3, "m/s");
   COM_new_attribute( propBufAll+".rb", 'e', COM_DOUBLE, 1, "m/s");
   COM_new_attribute( propBufAll+".positions",'n',COM_DOUBLE,3,"m");
   COM_new_attribute( propBufAll+".cflag",'n',COM_INTEGER,1,"");
   COM_resize_array(propBufAll+".atts");
   if ( COM_get_attribute_handle( surf_window+".cnstr_type") >0) {
     COM_use_attribute( propBufAll, surf_window+".bflag", 1);
     COM_use_attribute( propBufAll, surf_window+".cnstr_type");
     COM_use_attribute( propBufAll, surf_window+".bcflag");
      // a temporary buffer to store ".cnstr_type" of fluid at restart
     COM_clone_attribute( propBufAll+".cnstr_type_bak", surf_window+".cnstr_type");
   }
   create_registered_window_attributes( propBufAll);
   COM_window_init_done( propBufAll);
 
   std::string bcflag = surf_window+".bcflag";
     // create a window for surface propagation if run in fluid-alone
   if ( !with_solid)  {
     COM_new_window( propBuf);
     COM_use_attribute( propBuf, surf_window+".mesh", 0, bcflag.c_str(), 1);
     COM_use_attribute( propBuf, propBufAll+".pconn");
     COM_use_attribute( propBuf, propBufAll+".atts");
     create_registered_window_attributes(propBuf);
     COM_window_init_done( propBuf);
   }
 
   // update
   //split_surface_window( ifluid_all, ifluid_i, ifluid_nb, ifluid_b, ifluid_ni);
 
   // ifluid_i is the fluidBuf in old rocman
   // Precondition: The window fluidSurf should have been defined and contain
   // the following variables: pf, qc, qr, rhof_alp, nf_alp, tf, Tf, mdot_alp,
   // Tflm_alp, du_alp, and rhofvf_alp.
 
   COM_new_window( ifluid_i);
   COM_use_attribute( ifluid_i, surf_window+".mesh", 1, bcflag.c_str(), 0);
   COM_use_attribute( ifluid_i, surf_window+".mesh", 1, bcflag.c_str(), 1);
 
   COM_new_attribute(ifluid_i+".rhos", 'e', COM_DOUBLE, 1, "kg/(m^3)");
   COM_new_attribute(ifluid_i+".mdot", 'e', COM_DOUBLE, 1, "kg/(m^2 s)");
   COM_new_attribute(ifluid_i+".mdot_old", 'e', COM_DOUBLE, 1, "kg/(m^2 s)");
   COM_new_attribute(ifluid_i+".mdot_grad", 'e', COM_DOUBLE, 1, "kg/(m^2 s)");
   COM_new_attribute(ifluid_i+".mdot_tmp", 'e', COM_DOUBLE, 1, "kg/(m^2 s)");
   COM_resize_array(ifluid_i+".rhos");
   COM_resize_array(ifluid_i+".mdot");
   COM_resize_array(ifluid_i+".mdot_old");
   COM_resize_array(ifluid_i+".mdot_grad");
   COM_resize_array(ifluid_i+".mdot_tmp");
 
   COM_new_attribute( ifluid_i+".vs", 'e', COM_DOUBLE, 3, "m/s");
   COM_new_attribute( ifluid_i+".vs_alp", 'e', COM_DOUBLE, 3, "m/s");
   COM_new_attribute( ifluid_i+".vs_old", 'e', COM_DOUBLE, 3, "m/s");
   COM_resize_array( ifluid_i+".vs");
   COM_resize_array( ifluid_i+".vs_alp");
   COM_resize_array( ifluid_i+".vs_old");
 
     // for compute distances
   if ( with_solid) {
     COM_clone_attribute( ifluid_i+".nc_tmp", surf_window+".nc");
     COM_new_attribute( ifluid_i+".sq_dist", 'n', COM_DOUBLE, 1, "m");
     COM_resize_array( ifluid_i+".sq_dist");
   }
 
   create_registered_window_attributes(ifluid_i);
 //  COM_resize_array( ifluid_i+".atts");
   COM_window_init_done( ifluid_i);
 
   COM_new_window( fluidBufNG);
   COM_use_attribute( fluidBufNG, ifluid_i+".mesh", 0, "", 0);
   COM_use_attribute( fluidBufNG, surf_window+".atts");
   COM_use_attribute( fluidBufNG, ifluid_i+".atts");
   COM_use_attribute( fluidBufNG, propBufAll+".atts");
   create_registered_window_attributes(fluidBufNG);
   COM_window_init_done( fluidBufNG);
 
   COM_new_window( fluidBufB);
   COM_use_attribute( fluidBufB, surf_window+".mesh", 0, bcflag.c_str(), 1);
   COM_use_attribute( fluidBufB, surf_window+".atts");
   COM_use_attribute( fluidBufB, ifluid_i+".atts");
   COM_use_attribute( fluidBufB, propBufAll+".atts");
   create_registered_window_attributes(fluidBufB);
   COM_window_init_done( fluidBufB);
 
   COM_new_window( fluidBufNB);
   COM_use_attribute( fluidBufNB, surf_window+".mesh", 0, bcflag.c_str(), 0);
   COM_use_attribute( fluidBufNB, surf_window+".atts");
   COM_use_attribute( fluidBufNB, ifluid_i+".atts");
   COM_use_attribute( fluidBufNB, propBufAll+".atts");
   create_registered_window_attributes(fluidBufNB);
   COM_window_init_done( fluidBufNB);
 
   //COM_delete_window( ifluid_b);
   //COM_delete_window( ifluid_nb);
   //COM_delete_window( ifluid_ni);
   
   //   Create windows for output of burning patches, including ghost nodes/cells
   //   (variables include all of fluidSurf, and mdot, mdot_old, vm,
   //    vs, vs_old, ts, nc_t0, sq_dist)
   COM_new_window( ifluid_b);
   COM_use_attribute( ifluid_b, surf_window+".mesh", 1, bcflag.c_str(), 1);
   COM_use_attribute( ifluid_b, surf_window+".atts");
 
   COM_use_attribute( ifluid_b, propBufAll+".pconn");
   COM_use_attribute( ifluid_b, propBufAll+".vm");
 
   if ( with_solid) {
        COM_use_attribute( ifluid_b, ifluid_i+".vs");
        COM_use_attribute( ifluid_b, ifluid_i+".vs_old");
        if (COM_get_attribute_handle( ifluid_i+".ts")>0) {
          COM_use_attribute( ifluid_b, ifluid_i+".ts");
          COM_use_attribute( ifluid_b, ifluid_i+".nc_t0");
          COM_use_attribute( ifluid_b, ifluid_i+".sq_dist");
        }
   } 
 
   COM_use_attribute( ifluid_b, ifluid_i+".mdot");
   COM_use_attribute( ifluid_b, ifluid_i+".mdot_old");
 
   COM_window_init_done( ifluid_b);
 
     //  Create windows for output of nonburning patches, including ghosts.
     // (variables include all of fluidSurf, and vm, vm_old, vs, vs_old,
     //  ts, nc_t0, sq_dist)
   COM_new_window( ifluid_nb);
   COM_use_attribute( ifluid_nb, surf_window+".mesh", 1, bcflag.c_str(),0);
   COM_use_attribute( ifluid_nb, surf_window+".atts");
 
   COM_use_attribute( ifluid_nb, propBufAll+".pconn");
   COM_use_attribute( ifluid_nb, propBufAll+".vm");
 
   if ( with_solid) {
        COM_use_attribute( ifluid_nb, ifluid_i+".vs");
        COM_use_attribute( ifluid_nb, ifluid_i+".vs_old");
        if (COM_get_attribute_handle( ifluid_i+".ts")>0) {
          COM_use_attribute( ifluid_nb, ifluid_i+".ts");
          COM_use_attribute( ifluid_nb, ifluid_i+".nc_t0");
          COM_use_attribute( ifluid_nb, ifluid_i+".sq_dist");
        }
   }
   COM_window_init_done( ifluid_nb);
 
   //   Create windows for output of nonburning patches, including ghosts.
   //   (variables include all of fluidSurf)
   COM_new_window( ifluid_ni);
   COM_use_attribute( ifluid_ni, surf_window+".mesh", 1, bcflag.c_str(),2);
   COM_use_attribute( ifluid_ni, surf_window+".atts");
 
   COM_use_attribute( ifluid_ni, propBufAll+".pconn");
   COM_use_attribute( ifluid_ni, propBufAll+".vm");
 
   COM_window_init_done( ifluid_ni);
 
     // setup for pc iterations
   int maxPredCorr = get_coupling()->get_max_ipc();
   if ( maxPredCorr>1) {
          // Create a window to encapsulate the surface data to be backed up
        COM_new_window( fluidBufPC);
        COM_use_attribute( fluidBufPC, ifluid_i+".mesh");
        COM_use_attribute( fluidBufPC, ifluid_i+".nc");
        COM_window_init_done( fluidBufPC);
                                                                                 
          // Create a window to store backed-up surface data
        COM_new_window( fluidBufBak);
        COM_use_attribute( fluidBufBak, fluidBufPC+".mesh");
        COM_clone_attribute( fluidBufBak, fluidBufPC+".nc");
        COM_window_init_done( fluidBufBak);
                                                                                 
          // Create window for backing up volume data
        COM_new_window( fluidVolBak);
        COM_use_attribute( fluidVolBak, vol_window+".mesh");
        COM_clone_attribute( fluidVolBak, vol_window+".nc");
        COM_clone_attribute( fluidVolBak, vol_window+".atts");
        COM_window_init_done( fluidVolBak);
   
          // Create window for backing up Plag data
        if ( with_plag) {
           COM_new_window( fluidPlagBak);
           COM_use_attribute( fluidPlagBak, plag_window+".mesh");
           COM_clone_attribute( fluidPlagBak, plag_window+".nc");
           COM_clone_attribute( fluidPlagBak, plag_window+".atts");
           COM_window_init_done( fluidPlagBak);
        }
 
          // Create window for convergence check
        COM_new_window( fluidBufPRE);
        COM_use_attribute( fluidBufPRE, fluidBufNG+".mesh");
        COM_clone_attribute( fluidBufPRE, fluidBufNG+".vm");
        COM_clone_attribute( fluidBufPRE, fluidBufNG+".vs");
        COM_clone_attribute( fluidBufPRE, fluidBufNG+".mdot");
        COM_clone_attribute( fluidBufPRE, fluidBufNG+".ts");
        COM_window_init_done( fluidBufPRE);
 
         // Initlaize the attribute handles to be stored/restored
        pc_hdls[0][0] = COM_get_attribute_handle( fluidBufPC+".all");
        pc_hdls[1][0] = COM_get_attribute_handle( fluidBufBak+".all");
                                                                                 
        pc_hdls[0][1] = COM_get_attribute_handle( vol_window+".all");
        pc_hdls[1][1] = COM_get_attribute_handle( fluidVolBak+".all");
                                                                                 
        pc_count = 2;
        if ( with_plag) {
           pc_hdls[0][2] = COM_get_attribute_handle( plag_window+".all");
           pc_hdls[1][2] = COM_get_attribute_handle( fluidPlagBak+".all");
           pc_count ++;
        }
        f_mdot_hdl = COM_get_attribute_handle( fluidBufNG+".mdot");
        f_mdot_pre_hdl = COM_get_attribute_handle( fluidBufPRE+".mdot");
        f_ts_hdl = COM_get_attribute_handle( fluidBufNG+".ts");
        f_ts_pre_hdl = COM_get_attribute_handle( fluidBufPRE+".ts");
        f_vm_hdl = COM_get_attribute_handle( fluidBufNG+".vm");
        f_vm_pre_hdl = COM_get_attribute_handle( fluidBufPRE+".vm");
   }
 
   // Split surface window for output
   // ifluid is fluidBuf in INITIALIZE_FLUID() ???
   // update
 //  split_surface_window( ifluid_all, ifluid_i, ifluid_nb, ifluid_b, ifluid_ni);
 
   // for compute_distances
   nc_hdl = COM_get_attribute_handle( fluidBufNG+".nc");
   nc_tmp_hdl = COM_get_attribute_handle( fluidBufNG+".nc_tmp");
   sq_dist_hdl = COM_get_attribute_handle( fluidBufNG+".sq_dist");
 
   if (!get_coupling()->initial_start()) {
        int cnstr_type_hdl = COM_get_attribute_handle( surf_window+".cnstr_type");
        int cnstr_type_bak_hdl = COM_get_attribute_handle( propBufAll+".cnstr_type_bak");
        if (cnstr_type_hdl > 0) {
            // backup ".cnstr_type" of fluid and restore it later
            // this will discard the values in HDF restart files!
          COM_call_function( RocBlas::copy, &cnstr_type_hdl, &cnstr_type_bak_hdl);
        }
        read_restart_data();
        if (cnstr_type_hdl > 0) {
          COM_call_function( RocBlas::copy, &cnstr_type_bak_hdl, &cnstr_type_hdl);
        }
   }
 }

Here is the call graph for this function:

void finalize ( )

virtual

Reimplemented from Agent.

Definition at line 511 of file FluidAgent.C.

References COM_delete_window(), Agent::finalize(), fluidBufB, fluidBufBak, fluidBufNG, fluidBufPC, fluidBufPRE, fluidPlagBak, fluidVolBak, Agent::get_coupling(), Coupling::get_max_ipc(), ifluid_all, ifluid_b, ifluid_i, ifluid_nb, ifluid_ni, propBuf, propBufAll, with_plag, and with_solid.

 {
   if ( !with_solid) 
        COM_delete_window( propBuf);
   COM_delete_window( propBufAll);
   COM_delete_window( ifluid_all);
   COM_delete_window( ifluid_i);
   COM_delete_window( fluidBufB);
   COM_delete_window( fluidBufNG);
   COM_delete_window( ifluid_nb);
   COM_delete_window( ifluid_b);
   COM_delete_window( ifluid_ni);
                                                                                 
   int maxPredCorr = get_coupling()->get_max_ipc();
   if ( maxPredCorr>1) {
        COM_delete_window( fluidBufPC);
        COM_delete_window( fluidBufBak);
        COM_delete_window( fluidVolBak);
        if ( with_plag) COM_delete_window( fluidPlagBak);
        COM_delete_window( fluidBufPRE);
   }
 
   Agent::finalize();
 }

Here is the call graph for this function:

void init_convergence ( int iPredCorr )

virtual

Reimplemented from Agent.

Definition at line 536 of file FluidAgent.C.

References COM_call_function(), RocBlas::copy, f_mdot_hdl, f_mdot_pre_hdl, f_ts_hdl, f_ts_pre_hdl, f_vm_hdl, f_vm_pre_hdl, Agent::init_convergence(), and MAN_DEBUG.

 {
   MAN_DEBUG(2, ("Rocstar: FluidAgent::init_convergence at %d.\n", iPredCorr));
 
     // Copy current solution to pre for convergence check
   COM_call_function( RocBlas::copy, &f_mdot_hdl, &f_mdot_pre_hdl);
 
   COM_call_function( RocBlas::copy, &f_ts_hdl, &f_ts_pre_hdl);
 
   COM_call_function( RocBlas::copy, &f_vm_hdl, &f_vm_pre_hdl);
 
     // STORE_SOLUTIONS
   Agent::init_convergence( iPredCorr);
 }

Here is the call graph for this function:

void init_module	(	double	t,
		double	dt
	)

virtual

Reimplemented from Agent.

Definition at line 159 of file FluidAgent.C.

References COM_call_function(), COM_delete_window(), Agent::communicator, fluidPlagIn, fluidSurfIn, fluidVolIn, fluidVPIn, Agent::ic_handle, Agent::init_handle, Agent::init_module(), MAN_DEBUG, Agent::obtain_attr_handle, plag_window, Agent::vol_window, and with_plag.

Referenced by Coupling::init().

                                                  {
   MAN_DEBUG(3, ("Rocstar: FluidAgent::init_module t=%e dt=%e.\n", t, dt));
 
   Agent::init_module(t, dt);
 
   // Call initialization routine of physics module
   // was in Rocman.f90
   COM_call_function( init_handle, &t, &communicator, &ic_handle, 
                      fluidSurfIn.c_str(), fluidVPIn.c_str(), 
                      &obtain_attr_handle);
 
   // Delete input buffer windows
   COM_delete_window( fluidSurfIn);
   COM_delete_window( fluidVolIn);
 #ifndef NATIVE_MP_IO
   COM_delete_window( fluidPlagIn);
 #endif
   // INITIALIZE_XXX common portion
 
   // Reassign vol_window
   std::string::size_type pos = vol_window.find( " ");
   if ( pos != std::string::npos) {
     plag_window = vol_window.substr( pos+1, vol_window.size());
     vol_window = vol_window.substr( 0, pos);
   }
   with_plag = !plag_window.empty();
 #ifdef NATIVE_MP_IO
   with_plag = false;
 #endif
   MAN_DEBUG(3, ("Rocstar: vol_window = %s with_plag = %d.\n", vol_window.c_str(), with_plag));
 
   // Split surface window for output
   // ifluid is fluidBuf in INITIALIZE_FLUID() ???
   //split_surface_window( ifluid_all, ifluid_i, ifluid_nb, ifluid_b, ifluid_ni);
 /*
   std::string bcflag = surf_window+".bcflag";
   COM_use_attribute( ifluid_i, surf_window+".mesh", 1, bcflag.c_str(), 0);
   COM_use_attribute( ifluid_i, surf_window+".mesh", 1, bcflag.c_str(), 1);
   COM_window_init_done( ifluid_i);
 */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void input ( double t )

virtual

Implements Agent.

Definition at line 128 of file FluidAgent.C.

References COM_new_window(), COM_window_init_done(), Agent::communicator, fluid, fluid_plag, fluidPlagIn, fluidSurfIn, fluidVolIn, ifluid, and Agent::read_by_control_file().

                                 {
   
   MPI_Barrier(communicator);
   //  if(!comm_rank)
   //    std::cout << "Fluid agent reading surface input." << std::endl;
   read_by_control_file( t, ifluid, fluidSurfIn);
   //  std::cout << comm_rank << ": done reading surface." << std::endl;
   MPI_Barrier(communicator);
   //  if(!comm_rank)
   //    std::cout << "Fluid agent done reading surface input, reading volume" << std::endl;
   read_by_control_file( t, fluid, fluidVolIn);
   //  std::cout << comm_rank << ": done reading volume." << std::endl;
   MPI_Barrier(communicator);
   //  if(!comm_rank)
   //    std::cout << "Fluid agent done reading volume" << std::endl;
 
 #ifndef NATIVE_MP_IO
   if (read_by_control_file( t, fluid_plag, fluidPlagIn)==-1) {
     COM_new_window(fluidPlagIn);
     COM_window_init_done(fluidPlagIn);
   }
 #else
   COM_new_window(fluidPlagIn);
   COM_window_init_done(fluidPlagIn);
 #endif
 
   MPI_Barrier(communicator);
   //  std::cout << "All processors made it past reading" << std::endl;
 }

Here is the call graph for this function:

void load_module ( )

virtual

Reimplemented from Agent.

Definition at line 83 of file FluidAgent.C.

References COM_assertion_msg, COM_F_FUNC2, COM_load_module(), Agent::comm_rank, Agent::init_function_handles(), MAN_DEBUG, Agent::mod_instance, rocflo_load_module(), rocflu_load_module(), and Agent::rocmod_name.

Referenced by FluidAgent().

 {
   MAN_DEBUG(3, ("[%d] Rocstar: FluidAgent::load_module %s %s.\n", comm_rank, rocmod_name.c_str(), mod_instance.c_str()));
 
 #ifdef STATIC_LINK
 # ifdef RFLO
   if (rocmod_name == "Rocflo")
     COM_F_FUNC2( rocflo_load_module, ROCFLO_LOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 # elif defined(RFLU)
   if (rocmod_name == "Rocflu")
     COM_F_FUNC2( rocflu_load_module, ROCFLU_LOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 # else
     COM_assertion_msg(0, "Unknown FluidAgent mod!");
 # endif
 #else     // dynamic loading
   COM_assertion_msg(rocmod_name == "Rocflo" || rocmod_name == "Rocflu", 
                (std::string("Unknown FluidAgent module:")+rocmod_name).c_str());
   COM_load_module(rocmod_name.c_str(), mod_instance.c_str());
 #endif
 
   init_function_handles();      // defined in Agent
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void output_restart_files ( double t )

virtual

Implements Agent.

Definition at line 466 of file FluidAgent.C.

References COM_call_function(), fluid, fluid_plag, ifluid_all, ifluid_b, ifluid_nb, ifluid_ni, plag_window, Agent::post_hdf_handle, Agent::pre_hdf_handle, Agent::surf_window, Agent::vol_window, with_plag, Agent::write_control_file(), and Agent::write_data_files().

Referenced by SurfDiver::run().

                                                {
   static const std::string ifluid_prefix = "ifluid_all";
 
   if (pre_hdf_handle != -1)
     COM_call_function( pre_hdf_handle);
 
   // Write out surface sub-windows
 #if 1
   write_data_files( t, ifluid_b, ifluid_b+".all");
   write_data_files( t, ifluid_nb, ifluid_nb+".all");
   write_data_files( t, ifluid_ni, ifluid_ni+".all");
 #else
   write_data_files( t, ifluid_prefix, ifluid_all+".all");
 #endif
   write_control_file( t, "ifluid*", surf_window.c_str());
 
   // Write out volume window
   write_data_files( t, fluid, (vol_window+".all").c_str());
   write_control_file( t, fluid, vol_window.c_str());
 
   // Write out Plag window
   if ( with_plag) {
     write_data_files( t, fluid_plag, (plag_window+".all").c_str());
     write_control_file( t, fluid_plag, plag_window.c_str());
   }
 
   if (post_hdf_handle != -1)
     COM_call_function( post_hdf_handle);
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void output_visualization_files ( double t )

virtual

Implements Agent.

Definition at line 507 of file FluidAgent.C.

                                                      {
   // TODO: Define visualization sub-windows
 }

void read_restart_data ( )

virtual

Reimplemented from Agent.

Definition at line 448 of file FluidAgent.C.

References COM_call_function(), COM_clone_attribute(), COM_get_attribute_handle(), COM_get_attribute_handle_const(), fluidSurfIn, ifluid_i, Agent::obtain_attr_handle, and propBufAll.

Referenced by create_buffer_all().

 {
     // Obtain data for fluidBuf
   int atts_hdl = COM_get_attribute_handle_const(fluidSurfIn+".atts");
   int buf_hdl = COM_get_attribute_handle( ifluid_i+".atts");
   COM_call_function( obtain_attr_handle, &atts_hdl, &buf_hdl);
 
     // Obtain data for propBufAll
   int propBufAll_hdl = COM_get_attribute_handle( propBufAll+".atts");
   COM_call_function( obtain_attr_handle, &atts_hdl, &propBufAll_hdl);
 
     // Obtain pconn for surface propagation
   int pconn_hdl_const = COM_get_attribute_handle_const( fluidSurfIn+".pconn");
   int pconn_hdl = COM_get_attribute_handle( fluidSurfIn+".pconn");
   COM_call_function( obtain_attr_handle, &pconn_hdl_const, &pconn_hdl);
   COM_clone_attribute( propBufAll, fluidSurfIn+".pconn");
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void unload_module ( )

virtual

Reimplemented from Agent.

Definition at line 106 of file FluidAgent.C.

References COM_close_module(), COM_F_FUNC2, COM_unload_module(), Agent::get_coupling(), Coupling::in_restart(), MAN_DEBUG, Agent::mod_instance, rocflo_unload_module(), rocflu_unload_module(), and Agent::rocmod_name.

 {
   MAN_DEBUG(3, ("Rocstar: FluidAgent::unload_module %s.\n", rocmod_name.c_str()));
 #ifdef STATIC_LINK
 # ifdef RFLO
   if (rocmod_name == "Rocflo")
     COM_F_FUNC2( rocflo_unload_module, ROCFLO_UNLOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 # else
 #  ifdef RFLU
   if (rocmod_name == "Rocflu")
     COM_F_FUNC2( rocflu_unload_module, ROCFLU_UNLOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #  endif
 # endif
 #else
     // in restarting, close_module does not dlclose the shared lib
   if (get_coupling()->in_restart())
     COM_close_module(rocmod_name.c_str(), mod_instance.c_str());
   else
     COM_unload_module(rocmod_name.c_str(), mod_instance.c_str());
 #endif
 }