Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F78600943
InterscaleOperators.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
Wed, Aug 21, 21:55
Size
24 KB
Mime Type
text/x-c
Expires
Fri, Aug 23, 21:55 (2 d)
Engine
blob
Format
Raw Data
Handle
19944295
Attached To
rLAMMPS lammps
InterscaleOperators.cpp
View Options
// ATC transfer headers
#include "InterscaleOperators.h"
#include "PerAtomQuantity.h"
#include "TransferOperator.h"
#include "MoleculeSet.h"
#include "ATC_Method.h"
//#include <typeinfo>
using
std
::
set
;
using
std
::
map
;
using
std
::
string
;
namespace
ATC
{
//--------------------------------------------------------
//--------------------------------------------------------
// Class InterscaleManager
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
InterscaleManager
::
InterscaleManager
(
ATC_Method
*
atc
)
:
atc_
(
atc
),
initialized_
(
false
),
prefix_
(
":fix_atc:"
)
{
fundamentalAtomQuantities_
.
resize
(
NUM_ATOM_TYPES
);
for
(
unsigned
int
i
=
0
;
i
<
NUM_ATOM_TYPES
;
i
++
)
{
fundamentalAtomQuantities_
[
i
].
resize
(
LammpsInterface
::
NUM_FUNDAMENTAL_ATOM_QUANTITIES
);
for
(
unsigned
int
j
=
0
;
j
<
LammpsInterface
::
NUM_FUNDAMENTAL_ATOM_QUANTITIES
;
j
++
)
fundamentalAtomQuantities_
[
i
][
j
]
=
NULL
;
}
}
//----------------------------------------------------
// Set_lammps_data_prefix
//--------------------------------------------------------
void
InterscaleManager
::
set_lammps_data_prefix
()
{
prefix_
=
(
atc_
->
lammps_interface
())
->
fix_id
()
+
prefix_
;
}
//--------------------------------------------------------
// Destructor
//--------------------------------------------------------
InterscaleManager
::~
InterscaleManager
()
{
clear
();
}
//--------------------------------------------------------
// clear
//--------------------------------------------------------
void
InterscaleManager
::
clear
()
{
// set all memory types to temporary
for
(
unsigned
int
i
=
0
;
i
<
NUM_ATOM_TYPES
;
i
++
)
{
for
(
unsigned
int
j
=
0
;
j
<
LammpsInterface
::
NUM_FUNDAMENTAL_ATOM_QUANTITIES
;
j
++
)
{
if
(
fundamentalAtomQuantities_
[
i
][
j
])
{
fundamentalAtomQuantities_
[
i
][
j
]
->
set_memory_type
(
TEMPORARY
);
}
}
}
set_memory_temporary
(
perAtomQuantities_
);
set_memory_temporary
(
perAtomIntQuantities_
);
set_memory_temporary
(
perAtomDiagonalMatrices_
);
set_memory_temporary
(
perAtomSparseMatrices_
);
set_memory_temporary
(
pairMaps_
);
set_memory_temporary
(
denseMatrices_
);
set_memory_temporary
(
denseMatricesInt_
);
set_memory_temporary
(
denseMatricesBool_
);
set_memory_temporary
(
sparseMatrices_
);
set_memory_temporary
(
diagonalMatrices_
);
set_memory_temporary
(
vectorSparMat_
);
set_memory_temporary
(
setInt_
);
set_memory_temporary
(
smallMoleculeSets_
);
// clean up maps and vectors
clear_temporary_data
();
}
//--------------------------------------------------------
// clear
//--------------------------------------------------------
void
InterscaleManager
::
clear_temporary_data
()
{
deletionList_
.
clear
();
int
listSize
=
fundamentalAtomQuantities_
.
size
()
+
perAtomQuantities_
.
size
()
+
perAtomIntQuantities_
.
size
()
+
perAtomDiagonalMatrices_
.
size
()
+
perAtomSparseMatrices_
.
size
();
listSize
+=
pairMaps_
.
size
()
+
denseMatrices_
.
size
()
+
denseMatricesInt_
.
size
()
+
denseMatricesBool_
.
size
()
+
sparseMatrices_
.
size
()
+
diagonalMatrices_
.
size
()
+
vectorSparMat_
.
size
()
+
setInt_
.
size
()
+
smallMoleculeSets_
.
size
();
deletionList_
.
reserve
(
listSize
);
create_deletion_list
();
for
(
unsigned
int
i
=
0
;
i
<
deletionList_
.
size
();
i
++
)
{
if
(
deletionList_
[
i
])
{
delete
deletionList_
[
i
];
}
}
}
//--------------------------------------------------------
// create_deletion_list
//--------------------------------------------------------
void
InterscaleManager
::
create_deletion_list
()
{
// set all quantities to unfound
dfs_prepare_loop
(
perAtomQuantities_
);
dfs_prepare_loop
(
perAtomIntQuantities_
);
dfs_prepare_loop
(
perAtomDiagonalMatrices_
);
dfs_prepare_loop
(
perAtomSparseMatrices_
);
dfs_prepare_loop
(
perAtomQuantities_
);
dfs_prepare_loop
(
pairMaps_
);
dfs_prepare_loop
(
denseMatrices_
);
dfs_prepare_loop
(
denseMatricesInt_
);
dfs_prepare_loop
(
denseMatricesBool_
);
dfs_prepare_loop
(
sparseMatrices_
);
dfs_prepare_loop
(
diagonalMatrices_
);
dfs_prepare_loop
(
vectorSparMat_
);
dfs_prepare_loop
(
setInt_
);
dfs_prepare_loop
(
smallMoleculeSets_
);
// perform dfs, special case for fundamental atom quantities
int
index
=
0
;
for
(
unsigned
int
i
=
0
;
i
<
NUM_ATOM_TYPES
;
i
++
)
{
for
(
unsigned
int
j
=
0
;
j
<
LammpsInterface
::
NUM_FUNDAMENTAL_ATOM_QUANTITIES
;
j
++
)
{
if
(
fundamentalAtomQuantities_
[
i
][
j
])
{
index
=
dfs_visit
(
fundamentalAtomQuantities_
[
i
][
j
],
index
);
if
((
fundamentalAtomQuantities_
[
i
][
j
])
->
memory_type
()
==
TEMPORARY
)
{
fundamentalAtomQuantities_
[
i
][
j
]
=
NULL
;
}
}
}
}
// dfs for everything else
dfs_visit_loop
(
perAtomQuantities_
,
index
);
dfs_visit_loop
(
perAtomIntQuantities_
,
index
);
dfs_visit_loop
(
perAtomDiagonalMatrices_
,
index
);
dfs_visit_loop
(
perAtomSparseMatrices_
,
index
);
dfs_visit_loop
(
pairMaps_
,
index
);
dfs_visit_loop
(
denseMatrices_
,
index
);
dfs_visit_loop
(
denseMatricesInt_
,
index
);
dfs_visit_loop
(
denseMatricesBool_
,
index
);
dfs_visit_loop
(
sparseMatrices_
,
index
);
dfs_visit_loop
(
diagonalMatrices_
,
index
);
dfs_visit_loop
(
vectorSparMat_
,
index
);
dfs_visit_loop
(
setInt_
,
index
);
dfs_visit_loop
(
smallMoleculeSets_
,
index
);
}
//--------------------------------------------------------
// dfs_visit
//--------------------------------------------------------
int
InterscaleManager
::
dfs_visit
(
DependencyManager
*
quantity
,
const
int
index
)
{
int
myIndex
=
index
;
set
<
DependencyManager
*
>::
iterator
it
;
bool
isTemporary
=
(
quantity
->
memory_type
()
==
TEMPORARY
);
for
(
it
=
(
quantity
->
dependentQuantities_
).
begin
();
it
!=
(
quantity
->
dependentQuantities_
).
end
();
it
++
)
{
// make sure that if quantity isn't persistent, none of it's depedencies are
if
((
*
it
)
->
memory_type
()
==
PERSISTENT
&&
isTemporary
)
{
throw
ATC_Error
(
"InterscaleManager::dfs_visit - a persistent quantity has a temporary dependency"
);
}
if
(
!
((
*
it
)
->
dfsFound_
))
{
myIndex
=
dfs_visit
(
*
it
,
myIndex
);
}
}
quantity
->
dfsFound_
=
true
;
if
(
isTemporary
)
deletionList_
.
push_back
(
quantity
);
return
++
myIndex
;
}
//--------------------------------------------------------
// initialize
//--------------------------------------------------------
void
InterscaleManager
::
initialize
()
{
// force all existing objects to reset
for
(
unsigned
int
i
=
0
;
i
<
NUM_ATOM_TYPES
;
i
++
)
{
for
(
unsigned
int
j
=
0
;
j
<
LammpsInterface
::
NUM_FUNDAMENTAL_ATOM_QUANTITIES
;
j
++
)
{
if
(
fundamentalAtomQuantities_
[
i
][
j
])
{
fundamentalAtomQuantities_
[
i
][
j
]
->
force_reset
();
}
}
}
force_reset_loop
(
perAtomQuantities_
);
force_reset_loop
(
perAtomIntQuantities_
);
force_reset_loop
(
perAtomDiagonalMatrices_
);
force_reset_loop
(
perAtomSparseMatrices_
);
force_reset_loop
(
perAtomQuantities_
);
force_reset_loop
(
pairMaps_
);
force_reset_loop
(
denseMatrices_
);
force_reset_loop
(
denseMatricesInt_
);
force_reset_loop
(
denseMatricesBool_
);
force_reset_loop
(
sparseMatrices_
);
force_reset_loop
(
diagonalMatrices_
);
force_reset_loop
(
vectorSparMat_
);
force_reset_loop
(
setInt_
);
force_reset_loop
(
smallMoleculeSets_
);
}
// access methods for atomic quantities
//--------------------------------------------------------
// fundamental_atom_quantity
//--------------------------------------------------------
FundamentalAtomQuantity
*
InterscaleManager
::
fundamental_atom_quantity
(
LammpsInterface
::
FundamentalAtomQuantity
id
,
AtomType
atomType
)
{
if
(
!
fundamentalAtomQuantities_
[
atomType
][
id
])
{
// create a new one if it doesn't exist
if
(
id
==
LammpsInterface
::
ATOM_MASS
)
{
double
*
mass
=
LammpsInterface
::
instance
()
->
atom_mass
();
if
(
mass
)
fundamentalAtomQuantities_
[
atomType
][
id
]
=
new
AtomMass
(
atc_
,
atomType
);
else
fundamentalAtomQuantities_
[
atomType
][
id
]
=
new
FundamentalAtomQuantity
(
atc_
,
id
,
atomType
);
}
else
fundamentalAtomQuantities_
[
atomType
][
id
]
=
new
FundamentalAtomQuantity
(
atc_
,
id
,
atomType
);
fundamentalAtomQuantities_
[
atomType
][
id
]
->
set_memory_type
(
PERSISTENT
);
}
return
fundamentalAtomQuantities_
[
atomType
][
id
];
}
//--------------------------------------------------------
// per_atom_quantity
//--------------------------------------------------------
PerAtomQuantity
<
double
>
*
InterscaleManager
::
per_atom_quantity
(
const
string
&
tag
)
{
return
return_quantity
(
perAtomQuantities_
,
tag
);
}
//--------------------------------------------------------
// per_atom_int_quantity
//--------------------------------------------------------
PerAtomQuantity
<
int
>
*
InterscaleManager
::
per_atom_int_quantity
(
const
string
&
tag
)
{
return
return_quantity
(
perAtomIntQuantities_
,
tag
);
}
//--------------------------------------------------------
// per_atom_diagonal_matrix
//--------------------------------------------------------
PerAtomDiagonalMatrix
<
double
>
*
InterscaleManager
::
per_atom_diagonal_matrix
(
const
string
&
tag
)
{
return
return_quantity
(
perAtomDiagonalMatrices_
,
tag
);
}
//--------------------------------------------------------
// per_atom_sparse_matrix
//--------------------------------------------------------
PerAtomSparseMatrix
<
double
>
*
InterscaleManager
::
per_atom_sparse_matrix
(
const
string
&
tag
)
{
return
return_quantity
(
perAtomSparseMatrices_
,
tag
);
}
//--------------------------------------------------------
// pair_map
//--------------------------------------------------------
PairMap
*
InterscaleManager
::
pair_map
(
const
string
&
tag
)
{
return
return_quantity
(
pairMaps_
,
tag
);
}
//--------------------------------------------------------
// add_per_atom_quantity
//--------------------------------------------------------
void
InterscaleManager
::
add_per_atom_quantity
(
PerAtomQuantity
<
double
>
*
atomQuantity
,
const
string
&
tag
)
{
add_comm_quantity
(
perAtomQuantities_
,
commList_
,
atomQuantity
,
tag
);
}
//--------------------------------------------------------
// add_per_atom_int_quantity
//--------------------------------------------------------
void
InterscaleManager
::
add_per_atom_int_quantity
(
PerAtomQuantity
<
int
>
*
atomQuantity
,
const
string
&
tag
)
{
add_comm_quantity
(
perAtomIntQuantities_
,
commIntList_
,
atomQuantity
,
tag
);
}
//--------------------------------------------------------
// add_per_atom_diagonal_matrix
//--------------------------------------------------------
void
InterscaleManager
::
add_per_atom_diagonal_matrix
(
PerAtomDiagonalMatrix
<
double
>
*
atomQuantity
,
const
string
&
tag
)
{
add_comm_quantity
(
perAtomDiagonalMatrices_
,
commDmList_
,
atomQuantity
,
tag
);
}
//--------------------------------------------------------
// add_per_atom_sparse_matrix
//--------------------------------------------------------
void
InterscaleManager
::
add_per_atom_sparse_matrix
(
PerAtomSparseMatrix
<
double
>
*
atomQuantity
,
const
string
&
tag
)
{
add_comm_quantity
(
perAtomSparseMatrices_
,
commSmList_
,
atomQuantity
,
tag
);
}
//--------------------------------------------------------
// add_pair_map
//--------------------------------------------------------
void
InterscaleManager
::
add_pair_map
(
PairMap
*
pairMap
,
const
string
&
tag
)
{
add_quantity
(
pairMaps_
,
pairMap
,
tag
);
}
//--------------------------------------------------------
// dense_matrix
//--------------------------------------------------------
DENS_MAN
*
InterscaleManager
::
dense_matrix
(
const
string
&
tag
)
{
return
return_quantity
(
denseMatrices_
,
tag
);
}
//--------------------------------------------------------
// add_dense_matrix
//--------------------------------------------------------
void
InterscaleManager
::
add_dense_matrix
(
DENS_MAN
*
denseMatrix
,
const
string
&
tag
)
{
add_quantity
(
denseMatrices_
,
denseMatrix
,
tag
);
}
//--------------------------------------------------------
// dense_matrix_int
//--------------------------------------------------------
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
InterscaleManager
::
dense_matrix_int
(
const
string
&
tag
)
{
return
return_quantity
(
denseMatricesInt_
,
tag
);
}
//--------------------------------------------------------
// add_dense_matrix_int
//--------------------------------------------------------
void
InterscaleManager
::
add_dense_matrix_int
(
MatrixDependencyManager
<
DenseMatrix
,
int
>
*
denseMatrix
,
const
string
&
tag
)
{
add_quantity
(
denseMatricesInt_
,
denseMatrix
,
tag
);
}
//--------------------------------------------------------
// dense_matrix_bool
//--------------------------------------------------------
MatrixDependencyManager
<
DenseMatrix
,
bool
>
*
InterscaleManager
::
dense_matrix_bool
(
const
string
&
tag
)
{
return
return_quantity
(
denseMatricesBool_
,
tag
);
}
//--------------------------------------------------------
// add_dense_matrix_bool
//--------------------------------------------------------
void
InterscaleManager
::
add_dense_matrix_bool
(
MatrixDependencyManager
<
DenseMatrix
,
bool
>
*
denseMatrix
,
const
string
&
tag
)
{
add_quantity
(
denseMatricesBool_
,
denseMatrix
,
tag
);
}
//--------------------------------------------------------
// sparse_matrix
//--------------------------------------------------------
SPAR_MAN
*
InterscaleManager
::
sparse_matrix
(
const
string
&
tag
)
{
return
return_quantity
(
sparseMatrices_
,
tag
);
}
//--------------------------------------------------------
// add_sparse_matrix
//--------------------------------------------------------
void
InterscaleManager
::
add_sparse_matrix
(
SPAR_MAN
*
sparseMatrix
,
const
string
&
tag
)
{
add_quantity
(
sparseMatrices_
,
sparseMatrix
,
tag
);
}
//--------------------------------------------------------
// diagonal_matrix
//--------------------------------------------------------
DIAG_MAN
*
InterscaleManager
::
diagonal_matrix
(
const
string
&
tag
)
{
return
return_quantity
(
diagonalMatrices_
,
tag
);
}
//--------------------------------------------------------
// add_sparse_matrix
//--------------------------------------------------------
void
InterscaleManager
::
add_diagonal_matrix
(
DIAG_MAN
*
diagonalMatrix
,
const
string
&
tag
)
{
add_quantity
(
diagonalMatrices_
,
diagonalMatrix
,
tag
);
}
//--------------------------------------------------------
// vector_spar_mat
//--------------------------------------------------------
VectorDependencyManager
<
SPAR_MAT
*
>
*
InterscaleManager
::
vector_sparse_matrix
(
const
string
&
tag
)
{
return
return_quantity
(
vectorSparMat_
,
tag
);
}
//--------------------------------------------------------
// add_vector_spar_mat
//--------------------------------------------------------
void
InterscaleManager
::
add_vector_sparse_matrix
(
VectorDependencyManager
<
SPAR_MAT
*
>
*
vectorSparMat
,
const
string
&
tag
)
{
add_quantity
(
vectorSparMat_
,
vectorSparMat
,
tag
);
}
//--------------------------------------------------------
// set_int
//--------------------------------------------------------
SetDependencyManager
<
int
>
*
InterscaleManager
::
set_int
(
const
string
&
tag
)
{
return
return_quantity
(
setInt_
,
tag
);
}
//--------------------------------------------------------
// add_set_int
//--------------------------------------------------------
void
InterscaleManager
::
add_set_int
(
SetDependencyManager
<
int
>
*
setInt
,
const
string
&
tag
)
{
add_quantity
(
setInt_
,
setInt
,
tag
);
}
//--------------------------------------------------------
// molecule_set
//--------------------------------------------------------
SmallMoleculeSet
*
InterscaleManager
::
small_molecule_set
(
const
string
&
tag
)
{
return
return_quantity
(
smallMoleculeSets_
,
tag
);
}
//--------------------------------------------------------
// add_molecule_set
//--------------------------------------------------------
void
InterscaleManager
::
add_small_molecule_set
(
SmallMoleculeSet
*
moleculeSet
,
const
string
&
tag
)
{
add_quantity
(
smallMoleculeSets_
,
moleculeSet
,
tag
);
moleculeSet
->
initialize
();
}
//--------------------------------------------------------
// find_tag
//--------------------------------------------------------
DependencyManager
*
InterscaleManager
::
find
(
const
string
&
tag
)
{
// REFACTOR add check for duplicate entries
DependencyManager
*
quantity
=
NULL
;
quantity
=
find_in_list
(
perAtomQuantities_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
perAtomIntQuantities_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
perAtomDiagonalMatrices_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
perAtomSparseMatrices_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
pairMaps_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
denseMatrices_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
denseMatricesInt_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
denseMatricesBool_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
sparseMatrices_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
diagonalMatrices_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
vectorSparMat_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
setInt_
,
tag
);
if
(
quantity
)
return
quantity
;
quantity
=
find_in_list
(
smallMoleculeSets_
,
tag
);
if
(
quantity
)
return
quantity
;
return
NULL
;
}
//--------------------------------------------------------
// remove
//--------------------------------------------------------
void
InterscaleManager
::
remove
(
const
string
&
tag
)
{
DependencyManager
*
toBeDeleted
=
find
(
tag
);
if
(
toBeDeleted
)
{
toBeDeleted
->
set_memory_type
(
TEMPORARY
);
}
}
//--------------------------------------------------------
// reset_nlocal
//--------------------------------------------------------
void
InterscaleManager
::
reset_nlocal
()
{
reset_nlocal_loop
(
perAtomSparseMatrices_
);
// this goes in between diagonal matrices and molecule sets above
}
//--------------------------------------------------------
// computes_force_reset
//--------------------------------------------------------
void
InterscaleManager
::
fundamental_force_reset
(
unsigned
quantity
)
{
for
(
unsigned
int
i
=
0
;
i
<
NUM_ATOM_TYPES
;
i
++
)
{
if
(
fundamentalAtomQuantities_
[
i
][
quantity
])
{
fundamentalAtomQuantities_
[
i
][
quantity
]
->
lammps_force_reset
();
}
}
}
//--------------------------------------------------------
// computes_force_reset
//--------------------------------------------------------
void
InterscaleManager
::
lammps_force_reset
()
{
for
(
unsigned
int
j
=
0
;
j
<
LammpsInterface
::
NUM_FUNDAMENTAL_ATOM_QUANTITIES
;
j
++
)
{
fundamental_force_reset
(
j
);
}
lammps_reset_loop
(
perAtomQuantities_
);
lammps_reset_loop
(
perAtomIntQuantities_
);
lammps_reset_loop
(
perAtomDiagonalMatrices_
);
lammps_reset_loop
(
perAtomSparseMatrices_
);
}
//--------------------------------------------------------
// size_comm_quantities
//--------------------------------------------------------
void
InterscaleManager
::
size_comm_quantities
()
{
size_comm_loop
(
commList_
);
size_comm_loop
(
commIntList_
);
size_comm_loop
(
commDmList_
);
size_comm_loop
(
commSmList_
);
}
//--------------------------------------------------------
// prepare_exchange
//--------------------------------------------------------
void
InterscaleManager
::
prepare_exchange
()
{
prepare_exchange_loop
(
perAtomIntQuantities_
);
prepare_exchange_loop
(
perAtomQuantities_
);
prepare_exchange_loop
(
perAtomDiagonalMatrices_
);
prepare_exchange_loop
(
perAtomSparseMatrices_
);
}
//--------------------------------------------------------
// post_exchange
//--------------------------------------------------------
void
InterscaleManager
::
post_exchange
()
{
post_exchange_loop
(
perAtomIntQuantities_
);
post_exchange_loop
(
perAtomQuantities_
);
post_exchange_loop
(
perAtomDiagonalMatrices_
);
post_exchange_loop
(
perAtomSparseMatrices_
);
post_exchange_loop
(
smallMoleculeSets_
);
post_exchange_loop
(
pairMaps_
);
}
//--------------------------------------------------------
// memory_usage
//--------------------------------------------------------
int
InterscaleManager
::
memory_usage
()
const
{
int
usage
=
0
;
memory_usage_loop
(
perAtomQuantities_
,
usage
);
memory_usage_loop
(
perAtomIntQuantities_
,
usage
);
memory_usage_loop
(
perAtomDiagonalMatrices_
,
usage
);
memory_usage_loop
(
perAtomSparseMatrices_
,
usage
);
return
usage
;
}
//--------------------------------------------------------
// pack_exchange
//--------------------------------------------------------
int
InterscaleManager
::
pack_exchange
(
int
i
,
double
*
buffer
)
{
int
index
=
0
;
pack_exchange_loop
(
perAtomQuantities_
,
index
,
i
,
&
buffer
[
index
]);
pack_exchange_loop
(
perAtomIntQuantities_
,
index
,
i
,
&
buffer
[
index
]);
pack_exchange_loop
(
perAtomDiagonalMatrices_
,
index
,
i
,
&
buffer
[
index
]);
pack_exchange_loop
(
perAtomSparseMatrices_
,
index
,
i
,
&
buffer
[
index
]);
return
index
;
}
//--------------------------------------------------------
// unpack_exchange
//--------------------------------------------------------
int
InterscaleManager
::
unpack_exchange
(
int
i
,
double
*
buffer
)
{
int
index
=
0
;
unpack_exchange_loop
(
perAtomQuantities_
,
index
,
i
,
&
buffer
[
index
]);
unpack_exchange_loop
(
perAtomIntQuantities_
,
index
,
i
,
&
buffer
[
index
]);
unpack_exchange_loop
(
perAtomDiagonalMatrices_
,
index
,
i
,
&
buffer
[
index
]);
unpack_exchange_loop
(
perAtomSparseMatrices_
,
index
,
i
,
&
buffer
[
index
]);
return
index
;
}
//--------------------------------------------------------
// pack_comm
//--------------------------------------------------------
int
InterscaleManager
::
pack_comm
(
int
index
,
double
*
buf
,
int
pbc_flag
,
int
*
pbc
)
{
int
size
=
0
;
//pack_comm_loop(commList_,size,index,buf,pbc_flag,pbc);
pack_comm_loop
(
commIntList_
,
size
,
index
,
buf
,
pbc_flag
,
pbc
);
//pack_comm_loop(commDmList_,size,index,buf,pbc_flag,pbc);
//pack_comm_loop(commSmList_,size,index,buf,pbc_flag,pbc);
return
size
;
}
//--------------------------------------------------------
// unpack_comm
//--------------------------------------------------------
int
InterscaleManager
::
unpack_comm
(
int
index
,
double
*
buf
)
{
int
size
=
0
;
//unpack_comm_loop(commList_,size,index,buf);
unpack_comm_loop
(
commIntList_
,
size
,
index
,
buf
);
//unpack_comm_loop(commDmList_,size,index,buf);
//unpack_comm_loop(commSmList_,size,index,buf);
return
size
;
}
//--------------------------------------------------------
// grow_array
//--------------------------------------------------------
void
InterscaleManager
::
grow_arrays
(
int
nmax
)
{
grow_arrays_loop
(
perAtomQuantities_
,
nmax
);
grow_arrays_loop
(
perAtomIntQuantities_
,
nmax
);
grow_arrays_loop
(
perAtomDiagonalMatrices_
,
nmax
);
grow_arrays_loop
(
perAtomSparseMatrices_
,
nmax
);
}
//--------------------------------------------------------
// copy_array
//--------------------------------------------------------
void
InterscaleManager
::
copy_arrays
(
int
i
,
int
j
)
{
copy_arrays_loop
(
perAtomQuantities_
,
i
,
j
);
copy_arrays_loop
(
perAtomIntQuantities_
,
i
,
j
);
copy_arrays_loop
(
perAtomDiagonalMatrices_
,
i
,
j
);
copy_arrays_loop
(
perAtomSparseMatrices_
,
i
,
j
);
}
};
Event Timeline
Log In to Comment