fix_atc.cpp
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Fri, Jun 28, 13:45

fix_atc.cpp
View Options

	/* ----------------------------------------------------------------------
	LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
	www.cs.sandia.gov/~sjplimp/lammps.html
	Steve Plimpton, sjplimp@sandia.gov, Sandia National Laboratories

	Copyright (2003) Sandia Corporation. Under the terms of Contract
	DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
	certain rights in this software. This software is distributed under
	the GNU General Public License.

	See the README file in the top-level LAMMPS directory.
	------------------------------------------------------------------------- */

	// LAMMPS
	#include "fix_atc.h"
	#include "fix_nve.h"
	#include "atom.h"
	#include "force.h"
	#include "update.h"
	#include "respa.h"
	#include "error.h"
	#include "neighbor.h"
	#include "neigh_request.h"
	#include "pointers.h"
	#include "comm.h"
	#include "group.h"
	// ATC
	#include "ATC_Method.h"
	#include "ATC_Transfer.h"
	#include "ATC_TransferKernel.h"
	#include "ATC_TransferPartitionOfUnity.h"
	#include "ATC_CouplingEnergy.h"
	#include "ATC_CouplingMomentum.h"
	#include "ATC_CouplingMass.h"
	#include "ATC_CouplingMomentumEnergy.h"
	#include "LammpsInterface.h"
	// other
	#include <stdio.h>
	#include <string.h>
	#include <sstream>

	using namespace LAMMPS_NS;
	using namespace FixConst;
	using std::string;

	#ifdef LAMMPS_BIGBIG
	#error "The USER-ATC package is not compatible with -DLAMMPS_BIGBIG"
	#endif

	// main page of doxygen documentation
	/*! \mainpage AtC : Atom-to-Continuum methods
	fix commands:
	- \ref man_fix_atc (links to all related commands)
	*/

	/* ------------------------------------------------------------------------- */

	FixATC::FixATC(LAMMPS lmp, int narg, char *arg) : Fix(lmp, narg, arg),
	lammps_(lmp), atc_(NULL)
	{
	// ID GROUP atc PHYSICSTYPE [PARAMETERFILE]
	if (narg < 4 \|\| narg > 5) lmp->error->all(FLERR,"Illegal fix atc command");

	// Set LAMMPS pointer on LammpsInterface
	ATC::LammpsInterface::instance()->set_lammps(lmp);

	/*! \page man_fix_atc fix atc command
	\section syntax
	fix <fixID> <group> atc <type> <parameter_file>
	- fixID = name of fix
	- group = name of group fix is to be applied
	- type\n
	= thermal : thermal coupling with fields: temperature \n
	= two_temperature : electron-phonon coupling with field: temperature and electron_temperature \n
	= hardy : on-the-fly post-processing using kernel localization functions (see "related" section for possible fields) \n
	= field : on-the-fly post-processing using mesh-based localization functions (see "related" section for possible fields) \n
	- parameter_file = name of the file with material parameters. \n
	note: Neither hardy nor field requires a parameter file
	\section examples
	<TT> fix AtC internal atc thermal Ar_thermal.dat </TT> \n
	<TT> fix AtC internal atc two_temperature Ar_ttm.mat </TT> \n
	<TT> fix AtC internal atc hardy </TT> \n
	<TT> fix AtC internal atc field </TT> \n
	\section description
	This fix is the beginning to creating a coupled FE/MD simulation and/or
	an on-the-fly estimation of continuum fields. The coupled versions of this
	fix do Verlet integration and the /post-processing does not.
	After instantiating this fix, several other fix_modify commands will be
	needed to set up the problem, e.g. define the finite element mesh and
	prescribe initial and boundary conditions.

	The following coupling example is typical, but non-exhaustive:\n

	<TT>
	# ... commands to create and initialize the MD system \n

	# initial fix to designate coupling type and group to apply it to \n
	# tag group physics material_file \n
	fix AtC internal atc thermal Ar_thermal.mat\n \n
	# create a uniform 12 x 2 x 2 mesh that covers region contain the group \n
	# nx ny nz region periodicity \n
	fix_modify AtC mesh create 12 2 2 mdRegion f p p\n \n
	# specify the control method for the type of coupling \n
	# physics control_type \n
	fix_modify AtC thermal control flux \n \n
	# specify the initial values for the empirical field "temperature" \n
	# field node_group value \n
	fix_modify AtC initial temperature all 30.\n \n
	# create an output stream for nodal fields \n
	# filename output_frequency \n
	fix_modify AtC output atc_fe_output 100\n \n

	run 1000 \n
	</TT>

	likewise for this post-processing example: \n

	<TT>
	# ... commands to create and initialize the MD system \n

	# initial fix to designate post-processing and the group to apply it to \n
	# no material file is allowed nor required \n
	fix AtC internal atc hardy \n \n
	# for hardy fix, specific kernel function (function type and range) to
	# be used as a localization function \n
	fix AtC kernel quartic_sphere 10.0 \n \n
	# create a uniform 1 x 1 x 1 mesh that covers region contain the group \n
	# with periodicity this effectively creats a system average \n
	fix_modify AtC mesh create 1 1 1 box p p p \n\n
	# change from default lagrangian map to eulerian \n
	# refreshed every 100 steps \n
	fix_modify AtC atom_element_map eulerian 100 \n \n
	# start with no field defined \n
	# add mass density, potential energy density, stress and temperature \n
	fix_modify AtC fields add density energy stress temperature \n\n
	# create an output stream for nodal fields \n
	# filename output_frequency \n
	fix_modify AtC output nvtFE 100 text \n

	run 1000 \n
	</TT>

	the mesh's linear interpolation functions can be used as the localization function \n
	by using the field option: \n

	<TT>
	fix AtC internal atc field \n \n
	fix_modify AtC mesh create 1 1 1 box p p p \n\n
	... \n\n
	</TT>

	Note coupling and post-processing can be combined in the same simulations
	using separate fixes.
	\n
	For detailed exposition of the theory and algorithms please see:\n
	- Wagner, GJ; Jones, RE; Templeton, JA; Parks, MA, <VAR> An
	atomistic-to-continuum coupling method for heat transfer in solids. </VAR>
	Special Issue of Computer Methods and Applied Mechanics (2008) 197:3351. \n
	- Zimmerman, JA; Webb, EB; Hoyt, JJ;. Jones, RE; Klein, PA; Bammann, DJ,
	<VAR> Calculation of stress in atomistic simulation. </VAR>
	Special Issue of Modelling and Simulation in Materials Science and
	Engineering (2004), 12:S319. \n
	- Zimmerman, JA; Jones, RE; Templeton, JA,
	<VAR> A material frame approach for evaluating continuum variables in
	atomistic simulations. </VAR>
	Journal of Computational Physics (2010), 229:2364. \n
	- Templeton, JA; Jones, RE; Wagner, GJ, <VAR> Application of a field-based method
	to spatially varying thermal transport problems in molecular dynamics. </VAR>
	Modelling and Simulation in Materials Science and Engineering (2010), 18:085007. \n
	- Jones, RE; Templeton, JA; Wagner, GJ; Olmsted, D; Modine, JA, <VAR>
	Electron transport enhanced molecular dynamics for metals and semi-metals. </VAR>
	International Journal for Numerical Methods in Engineering (2010), 83:940. \n
	- Templeton, JA; Jones, RE; Lee, JW; Zimmerman, JA; Wong, BM,
	<VAR> A long-range electric field solver for molecular dynamics based on
	atomistic-to-continuum modeling. </VAR>
	Journal of Chemical Theory and Computation (2011), 7:1736. \n
	- Mandadapu, KK; Templeton, JA; Lee, JW, <VAR> Polarization as a field variable
	from molecular dynamics simulations. </VAR>
	Journal of Chemical Physics (2013), 139:054115. \n

	Please refer to the standard
	finite element (FE) texts, e.g. T.J.R Hughes <VAR> The finite element
	method </VAR>, Dover 2003, for the basics of FE simulation.

	\section restrictions
	Thermal and two_temperature (coupling) types use a Verlet time-integration
	algorithm.
	The hardy type does not contain its own time-integrator and must be used
	with a separate fix that does contain one, e.g. nve, nvt, etc.

	Currently,
	- the coupling is restricted to thermal physics
	- the FE computations are done in serial on each processor.

	\section related
	fix_modify commands for setup: \n
	- \ref man_mesh_create
	- \ref man_mesh_quadrature
	- \ref man_mesh_read
	- \ref man_mesh_write
	- \ref man_mesh_create_nodeset
	- \ref man_mesh_add_to_nodeset
	- \ref man_mesh_create_faceset_box
	- \ref man_mesh_create_faceset_plane
	- \ref man_mesh_create_elementset
	- \ref man_mesh_delete_elements
	- \ref man_mesh_nodeset_to_elementset
	- \ref man_boundary
	- \ref man_internal_quadrature
	- \ref man_thermal_time_integration
	- \ref man_momentum_time_integration
	- \ref man_electron_integration
	- \ref man_internal_element_set
	- \ref man_decomposition

	fix_modify commands for boundary and initial conditions:\n
	- \ref man_initial
	- \ref man_fix_nodes
	- \ref man_unfix_nodes
	- \ref man_fix_flux
	- \ref man_unfix_flux
	- \ref man_source
	- \ref man_remove_source

	fix_modify commands for control and filtering: \n
	- \ref man_control
	- \ref man_control_thermal
	- \ref man_control_thermal_correction_max_iterations
	- \ref man_control_momentum
	- \ref man_localized_lambda
	- \ref man_lumped_lambda_solve
	- \ref man_mask_direction
	- \ref man_time_filter
	- \ref man_filter_scale
	- \ref man_filter_type
	- \ref man_equilibrium_start
	- \ref man_extrinsic_exchange
	- \ref man_poisson_solver

	fix_modify commands for output: \n
	- \ref man_output
	- \ref man_output_nodeset
	- \ref man_output_elementset
	- \ref man_boundary_integral
	- \ref man_contour_integral
	- \ref man_mesh_output
	- \ref man_write_restart
	- \ref man_read_restart

	fix_modify commands for post-processing: \n
	- \ref man_hardy_kernel
	- \ref man_hardy_fields
	- \ref man_hardy_gradients
	- \ref man_hardy_rates
	- \ref man_hardy_computes
	- \ref man_hardy_on_the_fly
	- \ref man_pair_interactions
	- \ref man_sample_frequency
	- \ref man_set

	miscellaneous fix_modify commands: \n
	- \ref man_atom_element_map
	- \ref man_atom_weight
	- \ref man_write_atom_weights
	- \ref man_reset_time
	- \ref man_reset_atomic_reference_positions
	- \ref man_fe_md_boundary
	- \ref man_boundary_faceset
	- \ref man_consistent_fe_initialization
	- \ref man_mass_matrix
	- \ref man_material
	- \ref man_atomic_charge
	- \ref man_source_integration
	- \ref man_temperature_definition
	- \ref man_track_displacement
	- \ref man_boundary_dynamics
	- \ref man_add_species
	- \ref man_add_molecule
	- \ref man_remove_species
	- \ref man_remove_molecule

	Note: a set of example input files with the attendant material files are
	included with this package
	\section default
	none
	*/


	// Construct new ATC_Method object
	// note use "unfix" to destroy

	int me = ATC::LammpsInterface::instance()->comm_rank();

	string groupName(arg[1]);
	int igroup = group->find(groupName.c_str());
	int atomCount = group->count(igroup);

	try {
	// Postprocessing
	if (strcmp(arg[3],"field")==0)
	{
	if (atomCount == 0) {
	if (me==0) printf("ATC: can't construct transfer, no atoms in group \n");
	throw;
	}
	if (narg < 5) {
	if (me==0) printf("ATC: constructing shape function field estimate\n");
	atc_ = new ATC::ATC_TransferPartitionOfUnity(groupName,
	array_atom,
	this);
	}
	else {
	if (me==0) printf("ATC: constructing shape function field estimate with parameter file %s\n",arg[4]);
	string matParamFile = arg[4];
	atc_ = new ATC::ATC_TransferPartitionOfUnity(groupName,
	array_atom, this,
	matParamFile);
	}
	}
	else if (strcmp(arg[3],"hardy")==0)
	{
	if (atomCount == 0) {
	if (me==0) printf("ATC: Can't construct transfer, no atoms in group \n");
	throw;
	}
	if (narg < 5) {
	if (me==0) printf("ATC: constructing kernel field estimate\n");
	atc_ = new ATC::ATC_TransferKernel(groupName,
	array_atom,
	this);
	}
	else {
	if (me==0) printf("ATC: constructing kernel field estimate with parameter file %s\n",arg[4]);
	string matParamFile = arg[4];
	atc_ = new ATC::ATC_TransferKernel(groupName,
	array_atom, this,
	matParamFile);
	}
	}
	// PhysicsTypes
	else if (strcmp(arg[3],"thermal")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing thermal coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile);
	}
	else if (strcmp(arg[3],"two_temperature")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing two_temperature coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::TWO_TEMPERATURE);
	}
	else if (strcmp(arg[3],"drift_diffusion")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing drift_diffusion coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::DRIFT_DIFFUSION);
	}
	else if (strcmp(arg[3],"drift_diffusion-equilibrium")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing drift_diffusion-equilibrium coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::DRIFT_DIFFUSION_EQUILIBRIUM);
	}
	else if (strcmp(arg[3],"drift_diffusion-schrodinger")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing drift_diffusion-schrodinger coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::DRIFT_DIFFUSION_SCHRODINGER);
	}
	else if (strcmp(arg[3],"drift_diffusion-schrodinger-slice")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("Constructing ATC transfer (drift_diffusion-schrodinger-slice) with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::DRIFT_DIFFUSION_SCHRODINGER_SLICE);
	}
	else if (strcmp(arg[3],"convective_drift_diffusion")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing convective_drift_diffusion coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::CONVECTIVE_DRIFT_DIFFUSION);
	}
	else if (strcmp(arg[3],"convective_drift_diffusion-equilibrium")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing convective_drift_diffusion-equilibrium coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::CONVECTIVE_DRIFT_DIFFUSION_EQUILIBRIUM);
	}
	else if (strcmp(arg[3],"convective_drift_diffusion-schrodinger")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing convective_drift_diffusion-schrodinger coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingEnergy(groupName,
	array_atom, this,
	matParamFile, ATC::CONVECTIVE_DRIFT_DIFFUSION_SCHRODINGER);
	}
	else if (strcmp(arg[3],"elastic")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing elastic coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingMomentum(groupName,
	array_atom, this,
	matParamFile,
	ATC::ELASTIC);
	}
	else if (strcmp(arg[3],"electrostatic")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing electrostatic mechanical coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingMomentum(groupName,
	array_atom, this,
	matParamFile,
	ATC::ELASTIC,
	ATC::ELECTROSTATIC);
	}
	else if (strcmp(arg[3],"electrostatic-equilibrium")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing equilibrium electrostatic coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingMomentum(groupName,
	array_atom, this,
	matParamFile,
	ATC::ELASTIC,
	ATC::ELECTROSTATIC_EQUILIBRIUM);
	}
	else if (strcmp(arg[3],"shear")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing viscous/shear coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingMomentum(groupName,
	array_atom, this,
	matParamFile,
	ATC::SHEAR);
	}
	else if (strcmp(arg[3],"species")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing species diffusion coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingMass(groupName,
	array_atom, this,
	matParamFile);
	}
	else if (strcmp(arg[3],"species_electrostatic")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing electrostatic species coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingMass(groupName,
	array_atom, this,
	matParamFile, ATC::FEM_EFIELD);
	}
	else if (strcmp(arg[3],"thermo_elastic")==0)
	{
	string matParamFile = arg[4];
	if (me==0) printf("ATC: constructing thermo-mechanical coupling with parameter file %s\n",arg[4]);
	atc_ = new ATC::ATC_CouplingMomentumEnergy(groupName,
	array_atom, this,
	matParamFile);
	}
	else
	{
	lmp->error->all(FLERR,"Unknown physics type in ATC");
	}
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}

	lmp->atom->add_callback(0);

	// we write our own restart file
	restart_global = 0;



	// Set output computation data based on transfer info
	scalar_flag = atc_->scalar_flag();
	vector_flag = atc_->vector_flag();
	size_vector = atc_->size_vector();
	global_freq = atc_->global_freq();
	extscalar = atc_->extscalar();
	extvector = atc_->extvector();
	extlist = atc_->extlist();
	thermo_energy = atc_->thermo_energy_flag();

	// set pointer for output
	peratom_flag = atc_->peratom_flag();
	size_peratom_cols = atc_->size_peratom_cols();
	peratom_freq = atc_->peratom_freq();


	// set comm size needed by this fix
	comm_forward = atc_->comm_forward();

	// call this fix every step
	nevery = 1;
	}

	/----------------------------------------------------------------------- /
	FixATC::~FixATC()
	{
	if (lmp->atom) lmp->atom->delete_callback(id,0);
	if (atc_) delete atc_;
	}

	/* ---------------------------------------------------------------------- */

	int FixATC::setmask()
	{
	int mask = 0;
	mask \|= INITIAL_INTEGRATE;
	mask \|= POST_INTEGRATE;
	mask \|= FINAL_INTEGRATE;
	mask \|= PRE_EXCHANGE;
	mask \|= PRE_NEIGHBOR;
	mask \|= PRE_FORCE;
	mask \|= POST_FORCE;
	mask \|= MIN_PRE_EXCHANGE;
	mask \|= MIN_PRE_NEIGHBOR;
	mask \|= MIN_PRE_FORCE;
	mask \|= MIN_POST_FORCE;
	mask \|= THERMO_ENERGY;
	mask \|= POST_RUN;
	mask \|= END_OF_STEP;
	return mask;
	}

	/* ---------------------------------------------------------------------- */

	int FixATC::modify_param(int narg, char** arg)
	{
	bool match;

	// pass on to transfer layer
	try {
	match = atc_->modify(narg,arg);
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}

	if (!match) return 0;
	return narg;
	}

	/* ----------------------------------------------------------------------
	create initial list of neighbor partners via call to neighbor->build()
	must be done in setup (not init) since fix init comes before neigh init
	------------------------------------------------------------------------- */

	void FixATC::init()
	{
	// Guarantee construction of full neighborlist
	int irequest = neighbor->request(this,instance_me);
	neighbor->requests[irequest]->pair = 0;
	neighbor->requests[irequest]->fix = 1;
	neighbor->requests[irequest]->half = 0;
	neighbor->requests[irequest]->full = 1;

	// create computes, if necessary
	atc_->init_computes();
	}

	void FixATC::min_setup(int vflag)
	{
	setup(vflag);
	}

	void FixATC::setup(int vflag)
	{
	comm->forward_comm_fix(this);

	try {
	atc_->initialize();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	/* ----------------------------------------------------------------------
	pass throughs to atc functions to handle swapping atom data on
	when they move processors
	------------------------------------------------------------------------- */
	void FixATC::pre_exchange()
	{
	try {
	atc_->pre_exchange();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	void FixATC::setup_pre_exchange()
	{
	if (atc_->is_initialized()) {
	try {
	atc_->setup_pre_exchange();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	}
	void FixATC::min_pre_exchange()
	{
	try {
	atc_->pre_exchange();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	void FixATC::min_setup_pre_exchange()
	{
	try {
	atc_->setup_pre_exchange();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	double FixATC::memory_usage()
	{
	double bytes = (double) atc_->memory_usage() * sizeof(double);
	return bytes;
	}

	void FixATC::grow_arrays(int nmax)
	{
	atc_->grow_arrays(nmax);
	}

	void FixATC::copy_arrays(int i, int j, int delflag)
	{
	atc_->copy_arrays(i,j);
	}

	int FixATC::pack_exchange(int i, double * buf)
	{
	int num = atc_->pack_exchange(i,buf);
	return num;
	}

	int FixATC::unpack_exchange(int nlocal, double * buf)
	{
	int num = atc_->unpack_exchange(nlocal,buf);
	return num;
	}

	int FixATC::pack_forward_comm(int n, int list, double buf, int pbc_flag, int *pbc)
	{
	int num = atc_->pack_comm(n, list, buf, pbc_flag, pbc);
	return num;
	}

	void FixATC::unpack_forward_comm(int n, int first, double *buf)
	{
	atc_->unpack_comm(n, first, buf);
	}


	/* ----------------------------------------------------------------------
	pack values in local atom-based arrays for restart file
	------------------------------------------------------------------------- */

	int FixATC::pack_restart(int i, double *buf){
	return 0;
	}

	/* ----------------------------------------------------------------------
	unpack values from atom->extra array to restart the fix
	------------------------------------------------------------------------- */

	void FixATC::unpack_restart(int nlocal, int nth){
	}

	/* ----------------------------------------------------------------------
	maxsize of any atom's restart data
	------------------------------------------------------------------------- */

	int FixATC::maxsize_restart(){
	return 0;
	}

	/* ----------------------------------------------------------------------
	size of atom nlocal's restart data
	------------------------------------------------------------------------- */

	int FixATC::size_restart(int nlocal){
	return 0;
	}

	/* ----------------------------------------------------------------------
	pack entire state of Fix into one write
	------------------------------------------------------------------------- */

	void FixATC::write_restart(FILE *fp){

	char ** args = new char*[2];
	args[0] = new char[50];
	args[1] = new char[50];
	sprintf(args[0],"write_restart");
	sprintf(args[1],"ATC.restart");

	// Then call all objects I own to write their data
	if (comm->me == 0) {
	atc_->modify(2,args);
	}

	delete [] args[0];
	delete [] args[1];
	delete [] args;
	}

	/* ----------------------------------------------------------------------
	use state info from restart file to restart the Fix
	------------------------------------------------------------------------- */

	void FixATC::restart(char *buf){

	char ** args = new char*[2];
	args[0] = new char[50];
	args[1] = new char[50];
	sprintf(args[0],"read_restart");
	sprintf(args[1],"ATC.restart");

	// Then call all objects I own to write their data
	if (comm->me == 0) {
	atc_->modify(2,args);
	}

	delete [] args[0];
	delete [] args[1];
	delete [] args;
	}

	/* ----------------------------------------------------------------------
	allow for both per-type and per-atom mass
	------------------------------------------------------------------------- */

	void FixATC::initial_integrate(int vflag)
	{
	try {
	atc_->pre_init_integrate();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	// integration of atoms, if desired
	try {
	atc_->init_integrate();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	void FixATC::post_integrate()
	{
	try {
	atc_->post_init_integrate();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	/* ---------------------------------------------------------------------- */

	void FixATC::final_integrate()
	{
	try {
	atc_->pre_final_integrate();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}

	try {
	atc_->final_integrate();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	void FixATC::end_of_step()
	{
	try {
	atc_->post_final_integrate();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	try {
	atc_->end_of_step();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	/* ---------------------------------------------------------------------- */
	void FixATC::init_list(int id, NeighList *ptr) {
	ATC::LammpsInterface::instance()->set_list(id,ptr);
	}
	/* ---------------------------------------------------------------------- */
	void FixATC::pre_neighbor()
	{
	try {
	atc_->pre_neighbor();
	comm->forward_comm_fix(this);
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	/* ---------------------------------------------------------------------- */
	void FixATC::pre_force(int vflag)
	{

	try {
	atc_->pre_force();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	/* ---------------------------------------------------------------------- */
	void FixATC::post_force(int vflag)
	{

	try {
	atc_->post_force();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	/* ---------------------------------------------------------------------- */
	void FixATC::post_run()
	{
	try {
	atc_->finish();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	/* ---------------------------------------------------------------------- */
	void FixATC::setup_pre_neighbor()
	{
	if (atc_->is_initialized()) {
	try {
	atc_->pre_neighbor();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	}
	/* ---------------------------------------------------------------------- */
	void FixATC::min_setup_pre_neighbor()
	{
	if (atc_->is_initialized()) {
	try {
	atc_->pre_neighbor();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}
	}
	/* ---------------------------------------------------------------------- */
	void FixATC::min_pre_force(int vflag)
	{
	try {
	atc_->min_pre_force();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	/* ---------------------------------------------------------------------- */
	void FixATC::min_post_force(int vflag)
	{
	try {
	atc_->min_post_force();
	}
	catch (ATC::ATC_Error& atcError) {
	ATC::LammpsInterface::instance()->print_msg(atcError.error_description());
	throw;
	}
	}

	/* ---------------------------------------------------------------------- */
	double FixATC::compute_scalar()
	{
	return atc_->compute_scalar();
	}
	/* ---------------------------------------------------------------------- */
	double FixATC::compute_vector(int n)
	{
	return atc_->compute_vector(n);
	}
	/* ---------------------------------------------------------------------- */
	double FixATC::compute_array(int irow, int icol)
	{
	return atc_->compute_array(irow,icol);
	}

fix_atc.cppNo OneTemporaryActions

File Metadata

fix_atc.cppView Options

Event Timeline

fix_atc.cpp
No OneTemporary
Actions

fix_atc.cpp
View Options