Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F70464680
fix_atc.cpp
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Sun, Jul 7, 00:04
Size
30 KB
Mime Type
text/x-c
Expires
Tue, Jul 9, 00:04 (2 d)
Engine
blob
Format
Raw Data
Handle
18848287
Attached To
rLAMMPS lammps
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
);
}
Event Timeline
Log In to Comment