Main Page | Namespace List | Class Hierarchy | Class List | File List | Namespace Members | Class Members | File Members

LSMDD::DislocationDynamicsModule Class Reference

The DislocationDynamicsModule class is the main class of the Level Set Method Dislocation Dynamics (LSMDD) library that orchestrates the simulation of dislocation lines represented as the intersection of the zero level set of two level set functions. LSMDD has been specifically designed to run on parallel architectures so that ensembles of many dislocations may be simulated in a reasonable amount of time. More...

#include <DislocationDynamicsModule.h>

List of all members.

Public Types

Type and constant definitions
enum  VISUALIZATION_FILE_FORMAT { ASCII = 0, BINARY = 1 }

Public Member Functions

Constructor and destructor
 DislocationDynamicsModule (Pointer< Database > input_db, Pointer< PatchHierarchy< 3 > > patch_hierarchy, ElasticStressStrategy *elastic_stress_strategy, LSMDD_PhysicsStrategy *lsmdd_physics_strategy)
virtual ~DislocationDynamicsModule ()
Accessor methods for level set functions and related data
virtual int getPhiPatchDataHandle () const
virtual int getPsiPatchDataHandle () const
virtual int getVelocityPatchDataHandle () const
virtual int getControlVolumePatchDataHandle () const
Accessor methods for simulation state
virtual double getStartTime () const
virtual double getEndTime () const
virtual double getCurrentTime () const
virtual bool endTimeReached () const
virtual int numSimulationStepsTaken () const
virtual void printClassData (ostream &os) const
Methods for time advancing dislocation lines
virtual void initializeDislocationLevelSetFunctions ()
virtual double computeNextDt ()
virtual void advanceDislocations (const double dt)
virtual bool toggleUpwindDirection ()
Visualization methods
virtual void writeAllDislocationLinesToFile (const string &base_name, const VISUALIZATION_FILE_FORMAT file_type=ASCII)
virtual void writeOneDislocationLineToFile (const int line_handle, const string &base_name, const VISUALIZATION_FILE_FORMAT file_type=ASCII, const bool overwrite_file=true, const bool allocate_scratch_data=true)
Inherited methods
Methods inherited from the LevelSetMethodPatchStrategy and LevelSetMethodVelocityStrategy Classes. Users need not be concerned with these methods.

virtual void initializeLevelSetFunctionsOnPatch (Patch< 3 > &patch, const double time, const int phi_handle, const int psi_handle)
virtual void setLevelSetFunctionBoundaryConditions (Patch< 3 > &patch, const double fill_time, const int phi_handle, const int psi_handle, const IntVector< 3 > &ghost_width_to_fill)
virtual double computeStableDtOnPatch (Patch< 3 > &patch, LevelSetFunctionIntegrator< 3 > *lsm_integrator, LevelSetMethodVelocityFieldStrategy< 3 > *lsm_velocity_field_strategy)
virtual bool providesExternalVelocityField () const
virtual bool providesNormalVelocityField () const
virtual int getExternalVelocityFieldPatchDataHandle (int component) const
virtual int getNormalVelocityFieldPatchDataHandle (LEVEL_SET_FCN_TYPE level_set_fcn, int component) const
virtual void setCurrentTime (const double time)
virtual double computeStableDt ()
virtual void computeVelocityField (const double time, const int phi_handle, const int psi_handle, const int line_handle)
virtual void initializeLevelData (const Pointer< PatchHierarchy< 3 > > hierarchy, const int level_number, const double init_data_time, const int phi_handle, const int psi_handle, const bool can_be_refined, const bool initial_time, const Pointer< PatchLevel< 3 > > old_level=Pointer< PatchLevel< 3 > >((0)), const bool allocate_data=true)
virtual void resetHierarchyConfiguration (Pointer< PatchHierarchy< 3 > > hierarchy, const int coarsest_level, const int finest_level)

Protected Member Functions

Utility methods
virtual void getFromInput (Pointer< Database > input_db)
virtual void computeDislocationLineField (const int line_handle, const int phi_handle, const int psi_handle)
virtual void computeUnitTangentVectorForDislocationLine (const int tangent_vector_handle, const int line_handle, const int phi_handle, const int psi_handle)
virtual void initializeVariables ()
virtual void initializeCommunicationObjects ()
virtual void fillGhostCellsForLevelSetFunctions (const int line_handle, const int phi_handle, const int psi_handle)
virtual void writeOneDislocationLineToAsciiFile (const string &base_name, const int line_handle, const bool overwrite_file=true)
virtual void writeOneDislocationLineToBinaryFile (const string &base_name, const int line_handle, const bool overwrite_file=true)

Protected Attributes

double d_start_time
double d_end_time
SPATIAL_DERIVATIVE_TYPE d_spatial_derivative_type
int d_spatial_derivative_order
int d_num_stabilization_iterations
int d_reinitialization_interval
int d_use_reinitialization
int d_orthogonalization_interval
int d_use_orthogonalization
bool d_use_persistent_velocity_data
LSMDD_Parameters d_lsmdd_params
Pointer< PatchHierarchy< 3 > > d_patch_hierarchy
Pointer< CartesianGridGeometry< 3 > > d_grid_geometry
Array< BurgersVectord_burgers_vectors
int d_num_dislocation_lines
Pointer< LevelSetMethodAlgorithm< 3 > > d_lsm_algorithm
Pointer< FieldExtensionAlgorithm< 3 > > d_lsm_phi_field_extension_alg
Pointer< FieldExtensionAlgorithm< 3 > > d_lsm_psi_field_extension_alg
ElasticStressStrategyd_elastic_stress_strategy
LSMDD_PhysicsStrategyd_lsmdd_physics_strategy
Pointer< BoundaryConditionModule< 3 > > d_level_set_fcn_bc_module
Array< IntVector< 3 > > d_lower_bc_phi
Array< IntVector< 3 > > d_upper_bc_phi
Array< IntVector< 3 > > d_lower_bc_psi
Array< IntVector< 3 > > d_upper_bc_psi
IntVector< 3 > d_lower_bc_velocity
IntVector< 3 > d_upper_bc_velocity
IntVector< 3 > d_level_set_fcn_scratch_ghostcell_width
int d_phi_scratch_handle
int d_psi_scratch_handle
int d_grad_phi_plus_handle
int d_grad_phi_minus_handle
int d_grad_phi_central_handle
int d_grad_psi_plus_handle
int d_grad_psi_minus_handle
int d_grad_psi_central_handle
int d_dislocation_line_field_handle
int d_velocity_handle
int d_aux_stress_field_handle
int d_force_handle
vector< int > d_tangent_vector_handles
int d_distance_handle
ComponentSelector d_tangent_vectors
Pointer< RefineAlgorithm< 3 > > d_level_set_fcn_fill_bdry_alg
Array< Pointer< RefineSchedule< 3 > > > d_level_set_fcn_fill_bdry_sched
Pointer< RefineAlgorithm< 3 > > d_force_interp_fill_bdry_alg
Array< Pointer< RefineSchedule< 3 > > > d_force_interp_fill_bdry_sched
Pointer< RefineAlgorithm< 3 > > d_tangent_fill_bdry_alg
Array< Pointer< RefineSchedule< 3 > > > d_tangent_fill_bdry_sched
double d_current_time
double d_last_stress_update_time
int d_num_simulation_steps_taken
bool d_upwind_spatial_derivative_flag
bool d_hierarchy_configuration_needs_reset
bool d_velocity_data_allocated

Static Protected Attributes

const int s_lsmdd_version
const int s_lsmdd_binary_output_max_num_dislocations


Detailed Description

The DislocationDynamicsModule class is the main class of the Level Set Method Dislocation Dynamics (LSMDD) library that orchestrates the simulation of dislocation lines represented as the intersection of the zero level set of two level set functions. LSMDD has been specifically designed to run on parallel architectures so that ensembles of many dislocations may be simulated in a reasonable amount of time.

The numerical algorithms underlying the LSMDD were originally developed by Xiang et. al. in their series of papers on level set method approaches for simulating dislocation dynamics. However, because there are still open research questions about how various aspects of dislocation motion and interactions, the LSMDD library has been designed to allow flexibility in how the physics of dislocations are computationally modeled. For example, the library has been designed to allow a user to supply his/her algorithms for computing the forces on and velocity on dislocation lines.

The parallel level set method calculations required by LSMDD are provided by the Level Set Method Library (LSMLIB). We have leveraged the vector level set method calculations and standard level set method discretizations provided by LSMLIB. The parallel and restart capabilities of LSMDD are provided by the Structured Adaptive Mesh Refinement Application Infrastructure (SAMRAI) developed in the Center for Applied Scientific Computing at Lawrence Livermore National Laboratory. It is worth mentioning that the LSMLIB also relies heavily on SAMRAI for its parallel and restart capabilities.

For more details about the numerical algorithms used by specific elastic stress modules or dislocation force modules, see the documentation for those modules.

User-specified parameters (input database field)

When using the DislocationDynamicsModule, it is possible to modify the behavior of the module through an input file. The input data parameters available for/required by the user are described below. In the input file, the parameters for the components of the DislocationDynamicsModule must each have their own separate sub-databases. That is, the input file should have the following form:

DislocationDynamicsModule {

... input parameters for DislocationDynamicsModule ...

LSMDD_Parameters { ... input parameters for LSMDD_Parameters ... }

LevelSetMethodAlgorithm {

LevelSetFunctionIntegrator { ... input parameters for LevelSetFunctionIntegrator ... }

LevelSetMethodGriddingAlgorithm { ... input parameters LevelSetMethodGriddingAlgorithm ... }

} // end input database for LevelSetMethodAlgorithm

FieldExtensionAlgorithm { ... input parameters FieldExtensionAlgorithm ... }

} // end input database for DislocationDynamicsModule

DislocationDynamicsModule Input Database Parameters

Dislocation Dynamics Module Parameters:

LSMDD Parameters:

Level Set Method Algorithm Parameters:

There are two parts to the input for the LevelSetMethodAlgorithm: LevelSetFunctionIntegrator and LevelSetMethodGriddingAlgorithm.

The input parameters for the LevelSetFunctionIntegrator are:

The input parameters for the LevelSetMethodGriddingAlgorithm are:

Velocity Field Extension Parameters:

Sample Input File

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ DislocationDynamicsModule {

num_stabilization_iterations = 4 use_persistent_velocity_data = TRUE spatial_derivative_type = WENO spatial_derivative_order = 5

LSMDD_Parameters {

shear_modulus = 1.0 poisson_ratio = 0.33333

climb_mobility = 1 glide_mobility = 1

core_radius = 3

min_dislocation_segment_length = 1e-6 max_angle_for_pure_screw = .1

debug_on = FALSE

}

LevelSetMethodAlgorithm{

LevelSetFunctionIntegrator { start_time = 0.0 end_time = 2000.0

spatial_derivative_type = "WENO" spatial_derivative_order = 5 tvd_runge_kutta_order = 3 cfl_number = 0.5

reinitialization_interval = 50 reinitialization_max_iters = 20 orthogonalization_interval = 50 orthogonalization_max_iters = 20

verbose = FALSE

} // end of LevelSetFunctionIntegrator database

LevelSetMethodGriddingAlgorithm { max_levels = 1

largest_patch_size { level_0 = 10000, 10000, 10000 }

} // end of LevelSetMethodGriddingAlgorithm database

} // end of LevelSetMethodAlgorithm database

FieldExtensionAlgorithm {

spatial_derivative_type = "WENO" spatial_derivative_order = 1 tvd_runge_kutta_order = 1 cfl_number = 0.5

max_iterations = 20

verbose_mode = TRUE

} // end of FieldExtensionAlgorithm database

} // end of DislocationDynanmicsModule database

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

NOTES


Member Enumeration Documentation

enum LSMDD::DislocationDynamicsModule::VISUALIZATION_FILE_FORMAT
 

Enumerated type for the different visualization file formats

Enumeration values:
ASCII 
BINARY 


Constructor & Destructor Documentation

LSMDD::DislocationDynamicsModule::DislocationDynamicsModule Pointer< Database >  input_db,
Pointer< PatchHierarchy< 3 > >  patch_hierarchy,
ElasticStressStrategy elastic_stress_strategy,
LSMDD_PhysicsStrategy lsmdd_physics_strategy
 

The constructor creates a LevelSetMethodAlgorithm to track the motion of dislocation lines during the simulation, creates FieldExtensionAlgorithms to extend the velocity field off of dislocation lines, and initializes the state of the DislocationDynamicsModule using the parameters from the input database.

Arguments:

virtual LSMDD::DislocationDynamicsModule::~DislocationDynamicsModule  )  [virtual]
 

The destructor deallocates memory used during the simulation.


Member Function Documentation

virtual void LSMDD::DislocationDynamicsModule::advanceDislocations const double  dt  )  [virtual]
 

advanceDislocations() advances all of the dislocations in the simulation by computing the stress field associated with the dislocations, using this stress field to compute the forces and velocities on each of the dislocations, and advancing the dislocation level set functions with the calculated velocities.

Arguments:

  • dt (in): time step size by which to advance dislocations

Return value: none

virtual void LSMDD::DislocationDynamicsModule::computeDislocationLineField const int  line_handle,
const int  phi_handle,
const int  psi_handle
[protected, virtual]
 

computeDislocationLineField() computes the dislocation line field ( delta(phi)*delta(psi)*unit_tangent_vector ) required to calculate the elastic stress field due to dislocation lines for a single dislocation line.

Arguments:

  • line_handle (in): the handle of the dislocation line to use
  • phi_handle(in): PatchData handle for phi
  • psi_handle(in): PatchData handle for psi

Return value: none

virtual double LSMDD::DislocationDynamicsModule::computeNextDt  )  [virtual]
 

computeNextDt() computes the maximum stable dt for the next time step.

Arguments: none

Return value: dt

virtual double LSMDD::DislocationDynamicsModule::computeStableDt  )  [inline, virtual]
 

computeStableDt() just returns the largest double value because there is no dynamics in the elastic stress calculation that would impact the time step size (i.e. the material is assumed to respond instantaneously).

Arguments: none

Return value: maximum acceptable (stable) time step

virtual double LSMDD::DislocationDynamicsModule::computeStableDtOnPatch Patch< 3 > &  patch,
LevelSetFunctionIntegrator< 3 > *  lsm_integrator,
LevelSetMethodVelocityFieldStrategy< 3 > *  lsm_velocity_field_strategy
[virtual]
 

computeStableDtOnPatch() passes the request to the LSMDD_PhysicsStrategy object.

Arguments:

  • patch (in): Patch on which to compute a stable time step size
  • lsm_integrator (in): pointer to LevelSetFunctionIntegrator
  • lsm_velocity_field_strategy (in): pointer to LevelSetMethodVelocityFieldStrategy

Return value: user-specified time step dt

virtual void LSMDD::DislocationDynamicsModule::computeUnitTangentVectorForDislocationLine const int  tangent_vector_handle,
const int  line_handle,
const int  phi_handle,
const int  psi_handle
[protected, virtual]
 

computeUnitTangentVectorForDislocationLine() computes the tangent vector for the dislocation line associated with a single Burgers vector which is used to compute the force on a dislocation line via the formula:

(sigma dot b) cross tangent

Arguments:

  • line_handle (in): handle of the dislocation line for which to compute tangent vector
  • phi_handle(in): PatchData handle for phi
  • psi_handle(in): PatchData handle for psi

Return value: none

NOTES:

  • This is the tangent vector that is passed to the method computeForceOnDislocationLineOnPatch() that is defined by the application developer in a concrete subclass of the LSMDD_PhysicsStrategy class.

virtual void LSMDD::DislocationDynamicsModule::computeVelocityField const double  time,
const int  phi_handle,
const int  psi_handle,
const int  line_handle
[virtual]
 

computeVelocityField() computes all necessary level set method velocity fields on the entire hierarchy.

Arguments:

  • time (in): time that velocity field is to be computed
  • phi_handle (in): PatchData handle for phi
  • psi_handle (in): PatchData handle for psi
  • line_handle (in): handle for dislocation line for which to compute velocity field

Return value: none

virtual bool LSMDD::DislocationDynamicsModule::endTimeReached  )  const [virtual]
 

endTimeReached() returns true if the end time for the simulation has been reached; otherwise, it returns false.

Arguments: none

Return value: true if the current time is equal to or after the end time for the simulation; false otherwise

virtual void LSMDD::DislocationDynamicsModule::fillGhostCellsForLevelSetFunctions const int  line_handle,
const int  phi_handle,
const int  psi_handle
[protected, virtual]
 

fillGhostCellsForLevelSetFunctions() fills the ghostcells for the level set functions phi and psi. Ghostcells corresponding to grid cells in the interior of the computational domain are filled by copying data from neighboring patches. Ghostcells corresponding to cells outside of the computational domain are filled either by (1) copying data from the appropriate grid cells for periodic boundary conditions or (2) calling the setLevelSetFunctionBoundaryConditions() method in the user-defined subclass of the LSMDD_PhysicsStrategy class.

Arguments:

  • line_handle (in): handle of dislocation level set functions that need to have ghostcells filled
  • phi_handle(in): PatchData handle for phi
  • psi_handle(in): PatchData handle for psi

Return value: none

NOTES:

  • Periodic boundary conditions are applied in a special manner to avoid the introduction of artificial dislocations (which arise from the introduction of artificial zero level sets in phi and psi). When the sign of the level set function in the interior of the computational domain is the same on both sides of a periodic boundary, then the values in the ghostcells outside of the physical domain are set equal to the value of the grid cells taken from grid cells on the other side of the computational domain (i.e. periodic boundary conditions). However, when the sign of the level set function in the interior of the computational domain changes across a periodic boundary, the values in the ghostcells outside of the physical domain are set to minus the value of the grid cells taken from grid cells on the other side of the computational domain (i.e. anti-periodic boundary conditions).

virtual int LSMDD::DislocationDynamicsModule::getControlVolumePatchDataHandle  )  const [virtual]
 

getControlVolumePatchDataHandle() returns the patch data handle for the control volume.

Arguments: none

Return value: PatchData handle for control volume

virtual double LSMDD::DislocationDynamicsModule::getCurrentTime  )  const [virtual]
 

getCurrentTime() returns the current simulation time.

Arguments: none

Return value: current time

virtual double LSMDD::DislocationDynamicsModule::getEndTime  )  const [virtual]
 

getEndTime() returns the simulation end time.

Arguments: none

Return value: end time

virtual int LSMDD::DislocationDynamicsModule::getExternalVelocityFieldPatchDataHandle int  component  )  const [inline, virtual]
 

Accessor method for the external (vector) velocity field PatchData handle.

Arguments:

  • component (in): component of vector level set function for which the velocity field handle is being requested

Return value: PatchData handle for the external velocity field data

virtual void LSMDD::DislocationDynamicsModule::getFromInput Pointer< Database >  input_db  )  [protected, virtual]
 

getFromInput()

Arguments:

  • input_db (in):

Return value: none

virtual int LSMDD::DislocationDynamicsModule::getNormalVelocityFieldPatchDataHandle LEVEL_SET_FCN_TYPE  level_set_fcn,
int  component
const [inline, virtual]
 

getNormalVelocityFieldPatchDataHandle() returns a bogus PatchData handle since the dislocation dynamics requires a vector velocity field, not just the normal velocity.

Arguments:

  • level_set_fcn (in): level set function for which to get normal velocity field PatchData handle
  • component (in): component of vector level set function for which the velocity field handle is being requested

Return value: -1

virtual int LSMDD::DislocationDynamicsModule::getPhiPatchDataHandle  )  const [virtual]
 

getPhiPatchDataHandle() returns the patch data handle for phi.

Arguments: none

Return value: PatchData handle for phi

virtual int LSMDD::DislocationDynamicsModule::getPsiPatchDataHandle  )  const [virtual]
 

getPsiPatchDataHandle() returns the patch data handle for psi.

Arguments: none

Return value: PatchData handle for psi

virtual double LSMDD::DislocationDynamicsModule::getStartTime  )  const [virtual]
 

getStartTime() returns the simulation start time.

Arguments: none

Return value: start time

virtual int LSMDD::DislocationDynamicsModule::getVelocityPatchDataHandle  )  const [virtual]
 

getVelocityPatchDataHandle() returns the patch data handle for the velocity.

Arguments: none

Return value: PatchData handle for velocity

virtual void LSMDD::DislocationDynamicsModule::initializeCommunicationObjects  )  [protected, virtual]
 

initializeCommunicationObjects() initializes the objects involved in communication between patches (including inter-node data transfers).

Arguments: none

Return value: none

virtual void LSMDD::DislocationDynamicsModule::initializeDislocationLevelSetFunctions  )  [virtual]
 

initializeDislocationsLevelSetFunctions() initializes the level set functions associated with each dislocation line in the simulation.

Arguments: none

Return value: none

virtual void LSMDD::DislocationDynamicsModule::initializeLevelData const Pointer< PatchHierarchy< 3 > >  hierarchy,
const int  level_number,
const double  init_data_time,
const int  phi_handle,
const int  psi_handle,
const bool  can_be_refined,
const bool  initial_time,
const Pointer< PatchLevel< 3 > >  old_level = Pointer< PatchLevel<3> >((0)),
const bool  allocate_data = true
[inline, virtual]
 

initializeLevelData() does not do anything since there are no fields that need to be initialized for the velocity field calculation.

Arguments:

  • hierarchy (in): PatchHierarchy on which to tag cells for refinement
  • level_number (in): PatchLevel number on which to tag cells for refinement
  • init_data_time (in): simulation time at which data is to be initialized
  • phi_handle (in): PatchData handle for phi
  • psi_handle (in): PatchData handle for psi
  • can_be_refined (in): true if this is NOT the finest level in the PatchHierarchy; false it if is
  • initial_time (in): true if the PatchLevel is being introduced for the first time; false otherwise
  • old_level (in): old PatchLevel from which data for new PatchLevel should be taken
  • allocate_data (in): true if PatchData needs to be allocated before it is initialized; false otherwise

Return value: none

virtual void LSMDD::DislocationDynamicsModule::initializeLevelSetFunctionsOnPatch Patch< 3 > &  patch,
const double  time,
const int  phi_handle,
const int  psi_handle
[virtual]
 

initializeLevelSetFunctionsOnPatch() passes the request to the LSMDD_PhysicsStrategy object.

Arguments:

  • patch (in): Patch on which to initialize level set functions
  • current_time (in): current time
  • phi_handle (in): PatchData handle for phi
  • psi_handle (in): PatchData handle for psi

Return value: none

virtual void LSMDD::DislocationDynamicsModule::initializeVariables  )  [protected, virtual]
 

initializeVariables() sets up the variables and PatchData handles for the dislocation dynamics simulation.

Arguments: none

Return value: none

virtual int LSMDD::DislocationDynamicsModule::numSimulationStepsTaken  )  const [virtual]
 

numSimulationStepsTaken() returns the number of time steps taken in the simulation.

Arguments: none

Return value: number of simulation steps taken

virtual void LSMDD::DislocationDynamicsModule::printClassData ostream &  os  )  const [virtual]
 

printClassData() prints the value of the data members for an instance of the DislocationDynamicsModule class.

Arguments:

  • os (in): output stream to write object information

Return value: none

virtual bool LSMDD::DislocationDynamicsModule::providesExternalVelocityField  )  const [inline, virtual]
 

providesExternalVelocityField() returns true.

Arguments: none

Return value: true

virtual bool LSMDD::DislocationDynamicsModule::providesNormalVelocityField  )  const [inline, virtual]
 

providesNormalVelocityField() returns false.

Arguments: none

Return value: false

virtual void LSMDD::DislocationDynamicsModule::resetHierarchyConfiguration Pointer< PatchHierarchy< 3 > >  hierarchy,
const int  coarsest_level,
const int  finest_level
[virtual]
 

resetHierarchyConfiguration() updates resets the communication schedules to be consistent with the new configuration of the PatchHierarchy. This method should be invoked any time the PatchHierarchy has been changed.

Arguments:

  • hierarchy (in): Pointer to new PatchHierarchy
  • coarsest_level (in): coarsest level in the hierarchy to be updated
  • finest_level (in): finest level in the hierarchy to be updated

Return value: none

virtual void LSMDD::DislocationDynamicsModule::setCurrentTime const double  time  )  [inline, virtual]
 

setCurrentTime() sets the current simulation time to the specified time.

Arguments:

  • time (in): new current time

Return value: none

virtual void LSMDD::DislocationDynamicsModule::setLevelSetFunctionBoundaryConditions Patch< 3 > &  patch,
const double  fill_time,
const int  phi_handle,
const int  psi_handle,
const IntVector< 3 > &  ghost_width_to_fill
[virtual]
 

setLevelSetFunctionBoundaryConditions() passes the request to the LSMDD_PhysicsStrategy object.

Arguments:

  • patch (in): Patch on which to set boundary conditions for the level set functions
  • fill_time (in): time at which boundary data are being filled
  • phi_handle (in): PatchData handle for phi
  • psi_handle (in): PatchData handle for psi
  • ghost_width_to_fill (in): width of ghost cells to fill

Return value: none

virtual bool LSMDD::DislocationDynamicsModule::toggleUpwindDirection  )  [virtual]
 

toggleUpwindDirection() toggles the upwind direction used to compute the dislocation line field.

Arguments: none

Return value: current upwind direction

virtual void LSMDD::DislocationDynamicsModule::writeAllDislocationLinesToFile const string &  base_name,
const VISUALIZATION_FILE_FORMAT  file_type = ASCII
[virtual]
 

writeAllDislocationLinesToFile() outputs all of the current dislocation lines as a series of dislocation line segments.

Arguments:

  • base_name (in): base name for output files
  • file_type (in): type of output file (default = ASCII)

Return value: none

NOTES:

  • If the specified file already exists, it will be overwritten.

virtual void LSMDD::DislocationDynamicsModule::writeOneDislocationLineToAsciiFile const string &  base_name,
const int  line_handle,
const bool  overwrite_file = true
[protected, virtual]
 

writeOneDislocationLineToAsciiFile() outputs the specified dislocation line to an ASCII text file as a series of dislocation line segments.

Arguments:

  • base_name (in): base name for output files
  • line_handle (in): handle for dislocation to write to file
  • overwrite_file (in): true if the specified file should be overwritten (if it exists); false if the dislocation data should be appended to the specified file (default = true)

Return value: none

NOTES:

  • Each line of the output file contains the coordinates of the two ends of a dislocation line segment separated by white space:

x_1 y_1 z_1 x_2 y_2 z_2

  • The last line of the output for the specified dislocation line is a row containing five NaNs and the dislocation number (line_handle). This is used indicate that the data for the specified dislocation line has ended.

virtual void LSMDD::DislocationDynamicsModule::writeOneDislocationLineToBinaryFile const string &  base_name,
const int  line_handle,
const bool  overwrite_file = true
[protected, virtual]
 

writeOneDislocationLineToBinaryFile() outputs the specified dislocation line to a binary file.

Arguments:

  • base_name (in): base name for output files
  • line_handle (in): handle for dislocation to write to file
  • overwrite_file (in): true if the specified file should be overwritten (if it exists); false if the dislocation data should be appended to the specified file (default = true)

Return value: none

NOTES:

  • Binary output files have the following format:
    • LSMDD Version (int)
    • number of dislocations (int)
    • array of s_lsmdd_binary_output_max_num_dislocations integers that stores information about where in the file each dislocation line begins
    • the data for each dislocation line has the following format:
      • line_handle (int)
      • number of dislocation segments (int)
      • list of dislocation segments stored as endpt1 followed by endpt2. Both endpt1 and endpt2 are stored as the three doubles representing the x, y, and z components of the position of the end point.

virtual void LSMDD::DislocationDynamicsModule::writeOneDislocationLineToFile const int  line_handle,
const string &  base_name,
const VISUALIZATION_FILE_FORMAT  file_type = ASCII,
const bool  overwrite_file = true,
const bool  allocate_scratch_data = true
[virtual]
 

writeOneDislocationLineToFile() outputs the specified dislocation line as a series of dislocation line segments.

Arguments:

  • line_handle (in): handle for dislocation to write to file
  • base_name (in): base name for output files
  • file_type(in): type of output file (default = ASCII)
  • overwrite_file (in): true if the specified file should be overwritten (if it exists); false if the dislocation data should be appended to the specified file (default = true)
  • allocate_scratch_space (in): true if scratch data needs to be allocated for computing the dislocation line (default = true)

Return value: none

NOTES:

  • For ASCII output, each line of the output file contains the coordinates of the two ends of a dislocation line segment separated by white space:

x_1 y_1 z_1 x_2 y_2 z_2

The last line of the output for the specified dislocation line is a row containing five NaNs and the dislocation number (line_handle). This is used indicate that the data for the specified dislocation line has ended.

  • Binary output files have the following format:
    • LSMDD Version (int)
    • number of dislocations (int)
    • array of s_lsmdd_binary_output_max_num_dislocations integers that stores information about where in the file each dislocation line begins
    • the data for each dislocation line has the following format:
      • line_handle (int)
      • number of dislocation segments (int)
      • list of dislocation segments stored as endpt1 followed by endpt2. Both endpt1 and endpt2 are stored as the three doubles representing the x, y, and z components of the position of the end point.


Member Data Documentation

int LSMDD::DislocationDynamicsModule::d_aux_stress_field_handle [protected]
 

Array< BurgersVector > LSMDD::DislocationDynamicsModule::d_burgers_vectors [protected]
 

double LSMDD::DislocationDynamicsModule::d_current_time [protected]
 

int LSMDD::DislocationDynamicsModule::d_dislocation_line_field_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_distance_handle [protected]
 

ElasticStressStrategy* LSMDD::DislocationDynamicsModule::d_elastic_stress_strategy [protected]
 

double LSMDD::DislocationDynamicsModule::d_end_time [protected]
 

int LSMDD::DislocationDynamicsModule::d_force_handle [protected]
 

Pointer< RefineAlgorithm<3> > LSMDD::DislocationDynamicsModule::d_force_interp_fill_bdry_alg [protected]
 

Array< Pointer< RefineSchedule<3> > > LSMDD::DislocationDynamicsModule::d_force_interp_fill_bdry_sched [protected]
 

int LSMDD::DislocationDynamicsModule::d_grad_phi_central_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_grad_phi_minus_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_grad_phi_plus_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_grad_psi_central_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_grad_psi_minus_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_grad_psi_plus_handle [protected]
 

Pointer< CartesianGridGeometry<3> > LSMDD::DislocationDynamicsModule::d_grid_geometry [protected]
 

bool LSMDD::DislocationDynamicsModule::d_hierarchy_configuration_needs_reset [protected]
 

double LSMDD::DislocationDynamicsModule::d_last_stress_update_time [protected]
 

Pointer< BoundaryConditionModule<3> > LSMDD::DislocationDynamicsModule::d_level_set_fcn_bc_module [protected]
 

Pointer< RefineAlgorithm<3> > LSMDD::DislocationDynamicsModule::d_level_set_fcn_fill_bdry_alg [protected]
 

Array< Pointer< RefineSchedule<3> > > LSMDD::DislocationDynamicsModule::d_level_set_fcn_fill_bdry_sched [protected]
 

IntVector<3> LSMDD::DislocationDynamicsModule::d_level_set_fcn_scratch_ghostcell_width [protected]
 

Array< IntVector<3> > LSMDD::DislocationDynamicsModule::d_lower_bc_phi [protected]
 

Array< IntVector<3> > LSMDD::DislocationDynamicsModule::d_lower_bc_psi [protected]
 

IntVector<3> LSMDD::DislocationDynamicsModule::d_lower_bc_velocity [protected]
 

Pointer< LevelSetMethodAlgorithm<3> > LSMDD::DislocationDynamicsModule::d_lsm_algorithm [protected]
 

Pointer< FieldExtensionAlgorithm<3> > LSMDD::DislocationDynamicsModule::d_lsm_phi_field_extension_alg [protected]
 

Pointer< FieldExtensionAlgorithm<3> > LSMDD::DislocationDynamicsModule::d_lsm_psi_field_extension_alg [protected]
 

LSMDD_Parameters LSMDD::DislocationDynamicsModule::d_lsmdd_params [protected]
 

LSMDD_PhysicsStrategy* LSMDD::DislocationDynamicsModule::d_lsmdd_physics_strategy [protected]
 

int LSMDD::DislocationDynamicsModule::d_num_dislocation_lines [protected]
 

int LSMDD::DislocationDynamicsModule::d_num_simulation_steps_taken [protected]
 

int LSMDD::DislocationDynamicsModule::d_num_stabilization_iterations [protected]
 

int LSMDD::DislocationDynamicsModule::d_orthogonalization_interval [protected]
 

Pointer< PatchHierarchy<3> > LSMDD::DislocationDynamicsModule::d_patch_hierarchy [protected]
 

int LSMDD::DislocationDynamicsModule::d_phi_scratch_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_psi_scratch_handle [protected]
 

int LSMDD::DislocationDynamicsModule::d_reinitialization_interval [protected]
 

int LSMDD::DislocationDynamicsModule::d_spatial_derivative_order [protected]
 

SPATIAL_DERIVATIVE_TYPE LSMDD::DislocationDynamicsModule::d_spatial_derivative_type [protected]
 

double LSMDD::DislocationDynamicsModule::d_start_time [protected]
 

Pointer< RefineAlgorithm<3> > LSMDD::DislocationDynamicsModule::d_tangent_fill_bdry_alg [protected]
 

Array< Pointer< RefineSchedule<3> > > LSMDD::DislocationDynamicsModule::d_tangent_fill_bdry_sched [protected]
 

vector<int> LSMDD::DislocationDynamicsModule::d_tangent_vector_handles [protected]
 

ComponentSelector LSMDD::DislocationDynamicsModule::d_tangent_vectors [protected]
 

Array< IntVector<3> > LSMDD::DislocationDynamicsModule::d_upper_bc_phi [protected]
 

Array< IntVector<3> > LSMDD::DislocationDynamicsModule::d_upper_bc_psi [protected]
 

IntVector<3> LSMDD::DislocationDynamicsModule::d_upper_bc_velocity [protected]
 

bool LSMDD::DislocationDynamicsModule::d_upwind_spatial_derivative_flag [protected]
 

int LSMDD::DislocationDynamicsModule::d_use_orthogonalization [protected]
 

bool LSMDD::DislocationDynamicsModule::d_use_persistent_velocity_data [protected]
 

int LSMDD::DislocationDynamicsModule::d_use_reinitialization [protected]
 

bool LSMDD::DislocationDynamicsModule::d_velocity_data_allocated [protected]
 

int LSMDD::DislocationDynamicsModule::d_velocity_handle [protected]
 

const int LSMDD::DislocationDynamicsModule::s_lsmdd_binary_output_max_num_dislocations [static, protected]
 

const int LSMDD::DislocationDynamicsModule::s_lsmdd_version [static, protected]
 


The documentation for this class was generated from the following file:
Generated on Tue Aug 7 15:43:41 2007 for LSMDD by doxygen 1.3.4