#include <SolidAgent.h>

Inheritance diagram for SolidAgent:

Collaboration diagram for SolidAgent:

Public Member Functions
	SolidAgent (Coupling *coup, std::string mod, std::string obj, MPI_Comm com, int withFluid=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	create_buffer_all ()

virtual void	read_restart_data ()

virtual void	output_restart_files (double t)

virtual int	compute_integrals ()

virtual void	output_visualization_files (double t)

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)

double *	get_integrals ()

void	print (FILE *f)

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

Public Attributes
std::string	isolid_i

std::string	isolid_all

std::string	isolid_b

std::string	isolid_nb

std::string	isolid_ni

std::string	solidBufBase

std::string	solidBuf

std::string	propBufAll

std::string	propBuf

std::string	isolid

std::string	solid

std::string	solidSurfIN

std::string	solidVolIN

std::string	solidBufBak

std::string	solidVolBak

int	with_fluid

int	withALE

int	rhos_mode

int	size_ts

int	traction_mode

int	y_hdl

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)

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 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 34 of file SolidAgent.h.

Constructor & Destructor Documentation

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

Definition at line 48 of file SolidAgent.C.

References agentCount, isolid, isolid_all, isolid_b, isolid_i, isolid_nb, isolid_ni, load_module(), propBuf, propBufAll, solid, solidBuf, solidBufBak, solidBufBase, solidSurfIN, solidVolBak, solidVolIN, Agent::tmp_window, and withALE.

                                                                                                 :
   Agent(coup, mod, obj, "Solid", com, false), with_fluid(withFluid)
 {
   load_module();
 
   withALE = 0;
 
     // TODO: need to personalize these variables
   if (agentCount.length()==1) agentCount[0] ++;
   isolid_i = "isolid";  isolid_i += agentCount;    // "SolidBuf"
   isolid_all = "isolid_all"; isolid_all += agentCount; //for registering attributes
 
   solidBufBase = "SolidBufBase"; solidBufBase += agentCount;  
   solidBuf = "SolidBuf"; solidBuf += agentCount; //  for registering attributes
   propBufAll = "SolidPropAll"; // for surface propagation (containing all panes)
   propBufAll += agentCount;
   propBuf = "SolidProp"; propBuf += agentCount;
 
   // Surface windows for Rocout
   isolid_b = "isolid_b";        // buring
   isolid_b += agentCount;
   isolid_nb = "isolid_nb";     // non-buring
   isolid_nb += agentCount;
   isolid_ni = "isolid_ni";     // noninteracting
   isolid_ni += agentCount;
 
   // Material names in files.
   isolid = "isolid";            //  for input
   solid = "solid";
 
   // Rocin windows
   solidSurfIN = "SolidSurfIN"; solidSurfIN += agentCount;
   solidVolIN = "SolidVolIN";   solidVolIN += agentCount;
 
   solidBufBak    = "SolidBufBak"; solidBufBak += agentCount;
   solidVolBak    = "SolidVolBak"; solidVolBak += agentCount;
 
   tmp_window = isolid_all;
 }

Here is the call graph for this function:

Member Function Documentation

int compute_integrals ( )

virtual

Reimplemented from Agent.

Definition at line 417 of file SolidAgent.C.

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

 {
   if (compute_integrals_handle > 0) {
     MAN_DEBUG(3, ("Rocstar: SolidAgent::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 162 of file SolidAgent.C.

References COM_assertion_msg, COM_clone_attribute(), COM_delete_window(), COM_DOUBLE, COM_get_attribute(), COM_get_attribute_handle(), COM_get_attribute_handle_const(), COM_INTEGER, COM_new_attribute(), COM_new_window(), COM_resize_array(), COM_use_attribute(), COM_window_init_done(), Agent::comm_rank, Agent::create_buffer_all(), Agent::create_registered_window_attributes(), Agent::get_coupling(), Coupling::get_max_ipc(), Coupling::get_rocmancontrol_param(), isolid_all, isolid_b, isolid_i, isolid_nb, isolid_ni, MAN_DEBUG, MPI_COMM_WORLD, NO_SHEER, Agent::pc_count, Agent::pc_hdls, propBuf, propBufAll, read_restart_data(), rhos_mode, size_ts, solidBuf, solidBufBak, solidBufBase, solidVolBak, Agent::split_surface_window(), Agent::surf_window, RocmanControl_parameters::traction_mode, traction_mode, Agent::vol_window, with_fluid, withALE, and y_hdl.

 {
 
   int dummy = COM_get_attribute_handle_const( surf_window+".vbar_alp");
   withALE = (dummy > 0);
 
   if (comm_rank == 0)
    MAN_DEBUG(2, ("Rocstar: *** Solid with ALE is %d \n", withALE));
 
   Agent::create_buffer_all();
   split_surface_window( isolid_all, isolid_i, isolid_nb, isolid_b, isolid_ni);
 
   if (withALE) {
     COM_new_window( propBufAll);
     COM_use_attribute( propBufAll+".mesh", surf_window+".mesh");
     COM_use_attribute( propBufAll+".vbar_alp", surf_window+".vbar_alp");
     COM_clone_attribute( propBufAll+".vbar", surf_window+".vbar_alp");
     COM_clone_attribute( propBufAll+".vbar_old", surf_window+".vbar_alp");
     COM_clone_attribute( propBufAll+".vbar_grad", surf_window+".vbar_alp");
     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+".constrained",'n',COM_INTEGER,1,"");
     COM_resize_array( propBufAll+".positions" );
     COM_resize_array( propBufAll+".constrained");
     COM_resize_array( propBufAll+".rb" );
     create_registered_window_attributes( propBufAll);
     COM_window_init_done( propBufAll);
 
     COM_new_window( propBuf);
     std::string bc_str = surf_window+".bcflag";
     COM_use_attribute( propBuf+".mesh", surf_window+".mesh", 1, bc_str.c_str(), 1);
     COM_use_attribute( propBuf+".pconn", propBufAll+".pconn");
     if ( COM_get_attribute_handle( surf_window+".cnstr_type") >0) {
        COM_use_attribute( propBuf, surf_window+".cnstr_type");
     }
     COM_use_attribute( propBuf+".vbar_alp", propBufAll+".vbar_alp");
     COM_use_attribute( propBuf+".vbar", propBufAll+".vbar");
     COM_use_attribute( propBuf+".vbar_old", propBufAll+".vbar_old");
     COM_use_attribute( propBuf+".vbar_grad", propBufAll+".vbar_grad");
     COM_use_attribute( propBuf+".rb", propBufAll+".rb");
     create_registered_window_attributes( propBuf);
     COM_window_init_done( propBuf);
   }
 
   COM_new_window( solidBufBase);
   std::string bcflag = surf_window+".bcflag";
   COM_use_attribute( solidBufBase+".mesh", surf_window+".mesh", 1, bcflag.c_str(), 0);
   COM_use_attribute( solidBufBase+".mesh", surf_window+".mesh", 1, bcflag.c_str(), 1);
   if (withALE) {
     COM_new_attribute(solidBufBase+".areas", 'e', COM_DOUBLE, 1, "m^2");
     COM_resize_array(solidBufBase+".areas");
     COM_new_attribute(solidBufBase+".mdot", 'e', COM_DOUBLE, 1, "kg/(m^2 s)");
     COM_resize_array(solidBufBase+".mdot");
   }
   COM_clone_attribute( solidBufBase+".ts", surf_window+".ts_alp");
   COM_clone_attribute( solidBufBase+".ts_old", surf_window+".ts_alp");
   COM_clone_attribute( solidBufBase+".ts_grad", surf_window+".ts_alp");
   create_registered_window_attributes( solidBufBase);
   COM_window_init_done( solidBufBase);
 
   COM_new_window( solidBuf);
   COM_use_attribute( solidBuf, solidBufBase+".all");
   COM_use_attribute( solidBuf, surf_window+".atts");
   if (withALE) 
     COM_use_attribute( solidBuf, propBufAll+".atts");
   if (with_fluid == 1) {    // coupled
     COM_use_attribute( solidBuf+".x", solidBufBase+".nc");
     COM_clone_attribute( solidBuf+".nc", surf_window+".nc");
   }
   create_registered_window_attributes( solidBuf);
   COM_window_init_done( solidBuf);
 
   split_surface_window( isolid_all, isolid_i, isolid_nb, isolid_b, isolid_ni);
 
   COM_delete_window( isolid_b);
   COM_delete_window( isolid_nb);
   COM_delete_window( isolid_ni);
 
   // Create a window for output solid non-burning patch data
   COM_new_window( isolid_nb);
   COM_use_attribute( isolid_nb+".mesh", surf_window+".mesh", 1, bcflag.c_str(), 0);
   COM_use_attribute( isolid_nb, surf_window+".atts");
 
   if ( withALE) {
     COM_use_attribute( isolid_nb+".pconn", propBufAll+".pconn");
     COM_use_attribute( isolid_nb, propBufAll+".vbar");
     COM_use_attribute( isolid_nb, propBufAll+".vbar_old");
     COM_use_attribute( isolid_nb, propBufAll+".rb");
   }
 
   COM_use_attribute( isolid_nb, solidBufBase+".ts");
   COM_use_attribute( isolid_nb, solidBufBase+".ts_old");
   COM_window_init_done( isolid_nb);
 
   // Create a window for output solid interface data
   COM_new_window( isolid_b);
   COM_use_attribute( isolid_b+".mesh", surf_window+".mesh", 1, bcflag.c_str(), 1);
   COM_use_attribute( isolid_b, surf_window+".atts");
 
   if ( withALE) {
        COM_use_attribute( isolid_b+".pconn", propBufAll+".pconn");
        COM_use_attribute( isolid_b, propBufAll+".vbar");
        COM_use_attribute( isolid_b, propBufAll+".vbar_old");
        COM_use_attribute( isolid_b, propBufAll+".rb");
   }
 
   COM_use_attribute( isolid_b, solidBufBase+".ts");
   COM_use_attribute( isolid_b, solidBufBase+".ts_old");
   COM_window_init_done( isolid_b);
 
   //   Create a window for non-solid/fluid interface
   COM_new_window( isolid_ni);
   COM_use_attribute( isolid_ni+".mesh", surf_window+".mesh", 1, bcflag.c_str(), 2);
   COM_use_attribute( isolid_ni, surf_window+".atts");
   if ( withALE) {
        COM_use_attribute( isolid_ni+".pconn", propBufAll+".pconn");
        COM_use_attribute( isolid_ni, propBufAll+".vbar");
        COM_use_attribute( isolid_ni, propBufAll+".vbar_old");
        COM_use_attribute( isolid_ni, propBufAll+".rb");
   }
   COM_window_init_done( isolid_ni);
 
     //  setup for pc iterations
   int maxPredCorr = get_coupling()->get_max_ipc();
   if ( maxPredCorr>1) {
        // Create window for backing surface data
        COM_new_window( solidBufBak);
        COM_use_attribute( solidBufBak+".mesh", solidBuf+".mesh");
        COM_clone_attribute( solidBufBak+".x", solidBuf+".x");
        COM_clone_attribute( solidBufBak+".y", solidBuf+".nc");
        COM_window_init_done( solidBufBak);
 
        // Create window for backing up volume data
        COM_new_window( solidVolBak);
        COM_use_attribute( solidVolBak+".mesh", vol_window+".mesh");
        COM_clone_attribute( solidVolBak, vol_window+".nc");
        COM_clone_attribute( solidVolBak, vol_window+".atts");
        COM_window_init_done( solidVolBak);
 
        // Initlaize the attribute handles to be stored/restored
        pc_hdls[0][0] = COM_get_attribute_handle( vol_window+".all");
        pc_hdls[1][0] = COM_get_attribute_handle( solidVolBak+".all");
 
        pc_hdls[0][1] = COM_get_attribute_handle( solidBuf+".x");
        pc_hdls[1][1] = COM_get_attribute_handle( solidBufBak+".x");
        pc_hdls[0][2] = COM_get_attribute_handle( solidBuf+".nc");
        pc_hdls[1][2] = COM_get_attribute_handle( solidBufBak+".y");
        pc_count = 3;
   }
 
   // update
   split_surface_window( isolid_all, isolid_i, isolid_nb, isolid_b, isolid_ni);
 
     // setup variables
   traction_mode = get_coupling()->get_rocmancontrol_param()->traction_mode;
 
   std::string unit;
   char loc;
   COM_get_attribute( isolid_all+".rhos", &loc, &dummy, &dummy, &unit);
   if (loc=='w' || loc=='p')
     rhos_mode = 1;
   else {
     if (loc != 'n' && loc != 'e') {
       printf("Rocstar: Error: Unknown type of location of rohs: %c\n", loc);
       exit(1);
     }
     rhos_mode = 2;
   }
 
   COM_get_attribute( solidBufBase+".ts", &loc, &dummy, &size_ts, &unit);
   if (size_ts == 1 && traction_mode != NO_SHEER) {
     COM_assertion_msg(0, "If traction mode is with sheer, then solid tractions must be vectors!");
     MPI_Abort(MPI_COMM_WORLD, -1);
   }
 
   // for compute_distances
   y_hdl = COM_get_attribute_handle( solidBuf+".nc");
 
   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 394 of file SolidAgent.C.

References COM_delete_window(), Agent::finalize(), Agent::get_coupling(), Coupling::get_max_ipc(), isolid_all, isolid_b, isolid_i, isolid_nb, isolid_ni, propBuf, propBufAll, solidBuf, solidBufBak, solidBufBase, solidVolBak, and withALE.

 {
   int maxPredCorr = get_coupling()->get_max_ipc();
   if ( maxPredCorr>1) {
        COM_delete_window( solidBufBak);
        COM_delete_window( solidVolBak);
   }
                                                                                 
   COM_delete_window( solidBufBase);
   COM_delete_window( isolid_nb);
   COM_delete_window( isolid_b);
   COM_delete_window( isolid_ni);
   COM_delete_window( solidBuf);
   COM_delete_window( isolid_i);
   COM_delete_window( isolid_all);
   if ( withALE) {
       COM_delete_window( propBufAll);
       COM_delete_window( propBuf);
   }
 
   Agent::finalize();
 }

Here is the call graph for this function:

void init_module	(	double	t,
		double	dt
	)

virtual

Reimplemented from Agent.

Definition at line 141 of file SolidAgent.C.

References COM_call_function(), COM_delete_window(), Agent::communicator, Agent::ic_handle, Agent::init_handle, Agent::init_module(), MAN_DEBUG, Agent::obtain_attr_handle, solidSurfIN, and solidVolIN.

                                                  {
   MAN_DEBUG(3, ("Rocstar: SolidAgent::init_module t=%e dt=%e.\n", t, dt));
 
   Agent::init_module(t, dt);
 
   // Call initialization routine of physics module
   // rocman.f90:INITIALIZE()
   COM_call_function( init_handle, &t, &communicator, &ic_handle, 
                      solidSurfIN.c_str(), solidVolIN.c_str(), 
                      &obtain_attr_handle);
 
   // Delete input buffer windows
   COM_delete_window( solidSurfIN);
   COM_delete_window( solidVolIN);
 
   // Split surface window for output
   // ifluid is fluidBuf in INITIALIZE_FLUID() ???
   //split_surface_window( isolid_all, isolid_i, isolid_nb, isolid_b, isolid_ni);
 }

Here is the call graph for this function:

void input ( double t )

virtual

Implements Agent.

Definition at line 136 of file SolidAgent.C.

References isolid, Agent::read_by_control_file(), solid, solidSurfIN, and solidVolIN.

                                 {
   read_by_control_file( t, isolid, solidSurfIN);
   read_by_control_file( t, solid, solidVolIN);
 }

Here is the call graph for this function:

void load_module ( )

virtual

Reimplemented from Agent.

Definition at line 88 of file SolidAgent.C.

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

Referenced by SolidAgent().

 {
   MAN_DEBUG(3, ("[%d] Rocstar: SolidAgent::load_module %s %s.\n", comm_rank, rocmod_name.c_str(), mod_instance.c_str()));
 
 #ifdef STATIC_LINK
   if (rocmod_name == "Rocsolid")
     COM_F_FUNC2( rocsolid_load_module, ROCSOLID_LOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #ifdef ROCFRAC3
   else if (rocmod_name == "Rocfrac3")
     COM_F_FUNC2( rocfrac3_load_module, ROCFRAC3_LOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #else
   else if (rocmod_name == "Rocfrac")
     COM_F_FUNC2( rocfrac_load_module, ROCFRAC_LOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #endif
   else
     COM_assertion_msg(0, "Unknown SolidAgent mod!");
 #else
     // dynamic loading
   COM_assertion_msg(rocmod_name == "Rocsolid" || rocmod_name == "Rocfrac" 
                     || rocmod_name == "Rocfrac3", 
                (std::string("Unknown SolidAgent 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 362 of file SolidAgent.C.

References isolid_all, isolid_b, isolid_nb, isolid_ni, solid, Agent::surf_window, Agent::vol_window, Agent::write_control_file(), and Agent::write_data_files().

Referenced by SurfDiver::run().

                                                {
   static const std::string isolid_prefix = "isolid_all";
 
   // Write out surface sub-windows
 #if 1
   write_data_files( t, isolid_b, isolid_b+".all");
   write_data_files( t, isolid_nb, isolid_nb+".all");
   write_data_files( t, isolid_ni, isolid_ni+".all");
 #else
   write_data_files( t, isolid_prefix, isolid_all+".all");
 #endif
   write_control_file( t, "isolid*", surf_window.c_str());
 
   // Write out volume window
   write_data_files( t, solid, (vol_window+".all").c_str());
   write_control_file( t, solid, vol_window.c_str());
 }

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 390 of file SolidAgent.C.

                                                      {
   // TODO: Define visualization sub-windows
 }

void read_restart_data ( )

virtual

Reimplemented from Agent.

Definition at line 343 of file SolidAgent.C.

References COM_call_function(), COM_clone_attribute(), COM_get_attribute_handle(), COM_get_attribute_handle_const(), Agent::obtain_attr_handle, propBufAll, solidBufBase, solidSurfIN, and withALE.

Referenced by create_buffer_all().

 {
   int atts_hdl = COM_get_attribute_handle_const( solidSurfIN+".atts");
   int buf_hdl = COM_get_attribute_handle( solidBufBase+".atts");
   COM_call_function( obtain_attr_handle, &atts_hdl, &buf_hdl);
 
   if ( withALE) {
           // Obtain data for surface propagation if ALE is enabled
         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( solidSurfIN+".pconn");
         int pconn_hdl = COM_get_attribute_handle( solidSurfIN+".pconn");
         COM_call_function( obtain_attr_handle, &pconn_hdl_const, &pconn_hdl);
         COM_clone_attribute( propBufAll+".pconn", solidSurfIN+".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 115 of file SolidAgent.C.

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

 {
   MAN_DEBUG(3, ("[%d] Rocstar: SolidAgent::unload_module %s.\n", comm_rank, rocmod_name.c_str()));
 #ifdef STATIC_LINK
   if (rocmod_name == "Rocsolid")
     COM_F_FUNC2( rocsolid_unload_module, ROCSOLID_UNLOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #ifdef ROCFRAC3
   else if (rocmod_name == "Rocfrac3")
     COM_F_FUNC2( rocfrac3_unload_module, ROCFRAC3_UNLOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #else
   else if (rocmod_name == "Rocfrac")
     COM_F_FUNC2( rocfrac_unload_module, ROCFRAC_UNLOAD_MODULE)( mod_instance.c_str(), mod_instance.length());
 #endif
 #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
 }