#include <BurnAgent.h>

Inheritance diagram for BurnAgent:

Collaboration diagram for BurnAgent:

Public Member Functions
	BurnAgent (Coupling *coup, std::string mod, std::string obj, MPI_Comm com, const std::string parent)

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 ()

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

virtual void	init_convergence (int iPredCorr)

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

virtual int	compute_integrals ()

double *	get_integrals ()

void	print (FILE *f)

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

Public Attributes
std::string	parentWin

std::string	iburn_all

std::string	iburn_ng

std::string	iburn

std::string	burn

std::string	burnSurfIN

std::string	burnVolIN

std::string	burnIntBak

std::string	burnBufOUT

bool	ignmodel

Protected Attributes
int	tbl_flag

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

Static Protected Attributes
static const char *	window_name = "BurnAgent"

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

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)

Detailed Description

Definition at line 29 of file BurnAgent.h.

Constructor & Destructor Documentation

BurnAgent	(	Coupling *	coup,
		std::string	mod,
		std::string	obj,
		MPI_Comm	com,
		const std::string	parent
	)

Definition at line 39 of file BurnAgent.C.

References burn, Control_parameters::burn_module, burnBufOUT, burnIntBak, burnSurfIN, burnVolIN, Coupling::get_control_param(), iburn, iburn_all, iburn_ng, ignmodel, load_module(), and Agent::tmp_window.

                                                                                                           :
   Agent(coup, mod, obj, "Burn-Agent", com, false), parentWin(parentwin)
 {
   load_module();
 
   ignmodel = false;
   std::string ModName(coup->get_control_param()->burn_module);
   if(ModName == "RocburnPY")
     ignmodel = true;
 
   iburn_all = "iburn_all";   //  for registering attributes
 
   iburn_ng = "iburn_ng";    //    burnBuf
 
   // Material names in files.
   iburn = "iburn";              //  for input
   burn = "burn";
 
   // Rocin windows
   burnSurfIN = "BurnSurfIN";
   burnVolIN  = "BurnVolIN";
 
   burnIntBak = "BurnIntBak";
 
   burnBufOUT = "BurnBufOUT";
 
   tmp_window = iburn_all;
 }

Here is the call graph for this function:

Member Function Documentation

void create_buffer_all ( )

virtual

Reimplemented from Agent.

Definition at line 149 of file BurnAgent.C.

References burnBufOUT, burnIntBak, COM_clone_attribute(), COM_get_attribute_handle(), COM_get_attribute_handle_const(), COM_new_window(), COM_use_attribute(), COM_window_init_done(), Agent::create_buffer_all(), Agent::create_registered_window_attributes(), Agent::get_coupling(), Coupling::get_max_ipc(), iburn_all, iburn_ng, MAN_DEBUG, parentWin, Agent::pc_count, Agent::pc_hdls, read_restart_data(), Agent::surf_window, and Agent::vol_window.

 {
   Agent::create_buffer_all();
 
   // Precondition: The window burnWin should have been defined and contain
   // the following variables: pf_alp, qc_alp, qr_alp, rhos_alp, Tf_alp,
   // rb, and Tflm. It should have uses the attributes rb,
   // pf, qc, qr, rhos_alp, Tf, and Tflm_alp from parent window.
 
   int with_qc = COM_get_attribute_handle_const( surf_window+".qc_alp") > 0;
   int with_qr = COM_get_attribute_handle_const( surf_window+".qr_alp") > 0;
   int with_Tf = COM_get_attribute_handle_const( surf_window+".Tf_alp") > 0;
   int with_Tv = COM_get_attribute_handle_const( surf_window+".Tv_alp") > 0;
   int with_dn = COM_get_attribute_handle_const( surf_window+".dn_alp") > 0;
   int with_rhos = COM_get_attribute_handle_const( surf_window+".rhos_alp") > 0;
 
   MAN_DEBUG(3, ("with_qc=%d with_qr=%d with_Tf=%d with_rhos=%d\n with_Tv=%d\n with_dn=%d\n", 
                 with_qc, with_qr, with_Tf,with_rhos,with_Tv,with_dn));
 
   COM_use_attribute( iburn_all, parentWin+".Tflm_alp");
   COM_clone_attribute( iburn_all+".Tflm_old", surf_window+".Tflm");
 
   COM_use_attribute( iburn_all, parentWin+".pf");
   COM_use_attribute( iburn_all, parentWin+".rhos");
   if (with_qc) COM_use_attribute( iburn_all, parentWin+".qc");
   if (with_qr) COM_use_attribute( iburn_all, parentWin+".qr");
   if (with_Tf) COM_use_attribute( iburn_all, parentWin+".Tf");
   if (with_Tv) COM_use_attribute( iburn_all, parentWin+".Tv");
   if (with_dn) COM_use_attribute( iburn_all, parentWin+".dn");
 
   COM_clone_attribute( iburn_all+".rb_alp", surf_window+".rb");
   COM_clone_attribute( iburn_all+".rb_old", surf_window+".rb");
   COM_clone_attribute( iburn_all+".rb_grad", surf_window+".rb");
 
     // Create back-up data fields if predictor-corrector iteration is on
   COM_clone_attribute( iburn_all+".pf_old", surf_window+".pf_alp");
   if ( with_qc ) {
        COM_clone_attribute( iburn_all+".qc_old", surf_window+".qc_alp");
        COM_clone_attribute( iburn_all+".qc_grad", surf_window+".qc_alp");
   }
   if ( with_qr) {
        COM_clone_attribute( iburn_all+".qr_old", surf_window+".qr_alp");
        COM_clone_attribute( iburn_all+".qr_grad", surf_window+".qr_alp");
   }
   if ( with_rhos) 
        COM_clone_attribute( iburn_all+".rhos_old", surf_window+".rhos_alp");
   if (with_Tf) 
        COM_clone_attribute( iburn_all+".Tf_old", surf_window+".Tf_alp");
   if (with_Tv) 
        COM_clone_attribute( iburn_all+".Tv_old", surf_window+".Tv_alp");
   if (with_dn) 
        COM_clone_attribute( iburn_all+".dn_old", surf_window+".dn_alp");
 
   create_registered_window_attributes( iburn_all);
   COM_window_init_done( iburn_all);
 
    // no ghost
   COM_new_window( iburn_ng);
   COM_use_attribute( iburn_ng+".all", surf_window+".all", 0);
   COM_use_attribute( iburn_ng, iburn_all+".atts");
   create_registered_window_attributes( iburn_ng);
   COM_window_init_done( iburn_ng);
 
   // Create windows for writing interface data
   COM_new_window( burnBufOUT);
   COM_use_attribute( burnBufOUT, surf_window+".all");
 
   COM_use_attribute( burnBufOUT, iburn_all+".rb_old");
   COM_use_attribute( burnBufOUT, iburn_all+".pf_old");
   COM_use_attribute( burnBufOUT, iburn_all+".Tflm_old");
   if ( with_qc)
          COM_use_attribute( burnBufOUT, iburn_all+".qc_old");
   if ( with_qr) 
          COM_use_attribute( burnBufOUT, iburn_all+".qr_old");
   if (with_Tf) 
          COM_use_attribute( burnBufOUT, iburn_all+".Tf_old");
   if (with_Tv) 
          COM_use_attribute( burnBufOUT, iburn_all+".Tv_old");
   if (with_dn) 
          COM_use_attribute( burnBufOUT, iburn_all+".dn_old");
   COM_window_init_done( burnBufOUT);
 
     // Create a window for backing up the internal data of Rocburn
     //    if predictor-corrector iteration is on.
   int maxPredCorr = get_coupling()->get_max_ipc();
   if ( maxPredCorr>1) {
        // Create window for backing up Rocburn's internal data
      COM_new_window( burnIntBak);
      COM_use_attribute( burnIntBak+".mesh", vol_window+".mesh");
      COM_clone_attribute( burnIntBak, vol_window+".atts");
 
      COM_window_init_done( burnIntBak);
 
      pc_hdls[0][0] = COM_get_attribute_handle( vol_window+".atts");
      pc_hdls[1][0] = COM_get_attribute_handle( burnIntBak+".atts");
      pc_count = 1;
   }
 
   if (!get_coupling()->initial_start()) read_restart_data();
 }

Here is the call graph for this function:

void finalize ( )

virtual

Reimplemented from Agent.

Definition at line 284 of file BurnAgent.C.

References burnIntBak, COM_delete_window(), Agent::finalize(), Agent::get_coupling(), Coupling::get_max_ipc(), iburn_all, and iburn_ng.

 {
   COM_delete_window( iburn_ng);
   COM_delete_window( iburn_all);
   int maxPredCorr = get_coupling()->get_max_ipc();
   if ( maxPredCorr>1) 
        COM_delete_window( burnIntBak);
 
   Agent::finalize();
 }

Here is the call graph for this function:

void init_module	(	double	t,
		double	dt
	)

virtual

Reimplemented from Agent.

Definition at line 110 of file BurnAgent.C.

References burnSurfIN, burnVolIN, COM_call_function(), COM_delete_window(), COM_get_attribute_handle_const(), COM_use_attribute(), COM_window_init_done(), Agent::communicator, Agent::get_coupling(), Agent::ic_handle, Agent::init_handle, Agent::init_module(), Coupling::initial_start(), MAN_DEBUG, Agent::obtain_attr_handle, Agent::option_data, parentWin, and tbl_flag.

                                                 {
   MAN_DEBUG(3, ("BurnAgent::init_module called t:%f.\n", t));
 
   Agent::init_module(t, dt);
 
   int initial_start = get_coupling()->initial_start();
 
   if (initial_start || 
            COM_get_attribute_handle_const( burnSurfIN+".bflag") <= 0) 
   {
     COM_use_attribute( burnSurfIN+".mesh", parentWin+".mesh", 0);
     COM_use_attribute( burnSurfIN+".bflag", parentWin+".bflag", 0);
 //    COM_window_init_done( burnSurfIN);
   }
 
   COM_window_init_done( burnSurfIN);
 
   if (initial_start)
   {
     // Change burnVolIN to use parent windows' mesh without ghost
     COM_use_attribute( burnVolIN+".mesh", parentWin+".mesh", 0);
     COM_window_init_done( burnVolIN);
   }
 
   // Call initialization routine of physics module
   // rocman.f90:INITIALIZE()
   // call to INIT_WRAPPER() in rocburn_2D.f90
   COM_call_function( init_handle, &t, &communicator, &ic_handle, 
                      burnSurfIN.c_str(), burnVolIN.c_str(), 
                      &obtain_attr_handle);
 
   tbl_flag = *(int *)option_data;
   MAN_DEBUG(3, ("BurnAgent: tbl_flag = %d.\n", tbl_flag));
 
   // Delete input buffer windows
   COM_delete_window( burnSurfIN);
   COM_delete_window( burnVolIN);
 }

Here is the call graph for this function:

void input ( double t )

virtual

Implements Agent.

Definition at line 95 of file BurnAgent.C.

References burn, burnSurfIN, burnVolIN, COM_new_window(), COM_window_init_done(), iburn, and Agent::read_by_control_file().

                                {
   int status;
   status = read_by_control_file( t, iburn, burnSurfIN);
   if (status == -1) {
     COM_new_window(burnSurfIN);
     COM_window_init_done(burnSurfIN);
   }
 
   status = read_by_control_file( t, burn, burnVolIN);
   if (status == -1) {
     COM_new_window(burnVolIN);
     COM_window_init_done(burnVolIN);
   }
 }

Here is the call graph for this function:

void load_module ( )

virtual

Reimplemented from Agent.

Definition at line 68 of file BurnAgent.C.

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

Referenced by BurnAgent().

 {
   MAN_DEBUG(3, ("[%d] Rocstar: BurnAgent::load_module %s %s.\n", comm_rank, rocmod_name.c_str(), mod_instance.c_str()));
 #ifdef STATIC_LINK
   COM_assertion_msg(rocmod_name == "Rocburn", "Unknown BurnAgent mod!");
   COM_F_FUNC2( rocburn_load_module, ROCBURN_LOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #else
   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 257 of file BurnAgent.C.

References burn, burnBufOUT, Agent::surf_window, Agent::vol_window, Agent::write_control_file(), and Agent::write_data_files().

                                               {
   static const std::string iburn_prefix = "iburn_all";
 
   // Write out surface sub-windows
   //write_data_files( t, iburn_prefix, iburn_all+".all");
   write_data_files( t, iburn_prefix, burnBufOUT+".all");
   write_control_file( t, "iburn*", surf_window.c_str());
 
   // Write out volume window
   write_data_files( t, burn, (vol_window+".all").c_str());
   write_control_file( t, burn, vol_window.c_str());
 }

Here is the call graph for this function:

void output_visualization_files ( double t )

virtual

Implements Agent.

Definition at line 280 of file BurnAgent.C.

                                                     {
   // TODO: Define visualization sub-windows
 }

void read_restart_data ( )

virtual

Reimplemented from Agent.

Definition at line 250 of file BurnAgent.C.

References burnSurfIN, COM_call_function(), COM_get_attribute_handle(), COM_get_attribute_handle_const(), iburn_all, and Agent::obtain_attr_handle.

Referenced by create_buffer_all().

 {
   int atts_hdl = COM_get_attribute_handle_const(burnSurfIN+".atts");
   int buf_hdl = COM_get_attribute_handle( iburn_all+".atts");
   COM_call_function( obtain_attr_handle, &atts_hdl, &buf_hdl);
 }

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 81 of file BurnAgent.C.

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

 {
   MAN_DEBUG(3, ("Rocstar: BurnAgent::unload_module %s %s.\n", rocmod_name.c_str(), mod_instance.c_str()));
 #ifdef STATIC_LINK
   COM_assertion_msg(rocmod_name == "Rocburn", "Unknown BurnAgent mod!");
   COM_F_FUNC2( rocburn_unload_module, ROCBURN_UNLOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #else
   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
 }