simulation with large number of wall-bounded regions?

LAMMPS LAMMPS Mailing List Mirror
1

Hi. I would like to do a simulation with a large # of small “molecules” with each molecule confined to a box bounded by reflecting walls. In other words, I’d like to run MD on an ensemble of confined molecules using one LAMMPS simulation.

Commands like “region” and “fix wall/reflect” seem designed for such a simulation (i.e. a cubic confining “block” region would be defined by 6 reflecting walls).

However — I want to study a large ensemble of molecules, say 10^3-10^6 molecules. For 10^3, I’d need 111111 = 1331 walls to confine each molecule to a box. For 10^6, I’d need (101^3) walls. I’m not sure that defining these “one wall at a time” would be sensible. It might be very inefficient, for example (both in memory use and parallelization), or even impossible if the number of regions is too high.

Also, I want to make sure atoms in different boxes don’t interact even if their spatial positions are within the cutoff radius. I could do this with double walls that create gaps between the confining boxes, but that would worsen the abovementioned problems.

So, in summary, I want to simulate an ensemble of confined molecules with no intermolecular interactions. Not sure if confining them using walls is the best way to do this, but if it is, I have several questions:

  1. Is there a command to create a “lattice” of walls and/or confining regions?

2a) If so, what is the most efficient way to implement the condition that different molecules won’t interact with each other? There used to be a command ~ “pair_modify exclude molecule” that disabled _intra_molecular pair interactions. I want to disable _inter_molecular pair interactions.

2b) Given 2a, what is the most efficient way to parallelize this? For example, suppose I wanted each processor to handle 101010=1000 molecules and boxes, and run a simulation on 64 processors (for a total of 64000 molecules). This simulation would run on eight 8-processor nodes. The key thing for the purposes of these simulations is that atoms belonging to different molecules need not be included in each others’ neighbor lists, so I assume this would greatly reduce the amount of necessary interprocessor and internode communication.

Given the large ensemble, not sure of the most efficient way to implement this type of simulation in LAMMPS. Not sure if it’s set up to to this – has anyone used it for similar projects?

Thanks,
Rob

2

Hi. I would like to do a simulation with a large # of small "molecules"
with each molecule confined to a box bounded by reflecting walls. In other
words, I'd like to run MD on an ensemble of confined molecules using one
LAMMPS simulation.

Commands like "region" and "fix wall/reflect" seem designed for such a
simulation (i.e. a cubic confining "block" region would be defined by 6
reflecting walls).

However --- I want to study a large ensemble of molecules, say 10^3-10^6
molecules. For 10^3, I'd need 11*11*11 = 1331 walls to confine each
molecule to a box. For 10^6, I'd need (101^3) walls. I'm not sure that
defining these "one wall at a time" would be sensible. It might be very
inefficient, for example (both in memory use and parallelization), or even
impossible if the number of regions is too high.

Also, I want to make sure atoms in different boxes don't interact even if
their spatial positions are within the cutoff radius. I could do this with
double walls that create gaps between the confining boxes, but that would
worsen the abovementioned problems.

So, in summary, I want to simulate an ensemble of confined molecules with no
intermolecular interactions. Not sure if confining them using walls is the
best way to do this, but if it is, I have several questions:

1) Is there a command to create a "lattice" of walls and/or confining
regions?

2a) If so, what is the most efficient way to implement the condition that
different molecules won't interact with each other? There used to be a
command ~ "pair_modify exclude molecule" that disabled _intra_molecular pair
interactions. I want to disable _inter_molecular pair interactions.

2b) Given 2a, what is the most efficient way to parallelize this? For
example, suppose I wanted each processor to handle 10*10*10=1000 molecules
and boxes, and run a simulation on 64 processors (for a total of 64000
molecules). This simulation would run on eight 8-processor nodes. The key
thing for the purposes of these simulations is that atoms belonging to
different molecules need not be included in each others' neighbor lists, so
I assume this would greatly reduce the amount of necessary interprocessor
and internode communication.

Given the large ensemble, not sure of the most efficient way to implement
this type of simulation in LAMMPS. Not sure if it's set up to to this --
has anyone used it for similar projects?

i have not heard of anybody doing something like this.
a few thoughts on the subject.

your best shot - in my opinion - is to write a custom fix
(i would call it "fix cubicle") that allows you to separately
set the dimensions of the individual box and the spacing
between them.

the spacing would be necessary to place the molecules
so far apart, that they are outside of the cutoff range and
thus won't interact.

i would would do inter-node/inter-processor parallelization
by using LAMMPS' -partition mechanism. since there are
no interactions and thus no communication are needed,
you can also just run independent calculations.

come to think of it. it may be even simpler to write a small
custom MD code and hardcode the force field. since the
molecules are all independent, you don't really need neighbor
lists (unless the molecules are *very* large). you can then
very efficiently parallelize over the molecules instead of
doing domain decomposition and even do MPI+OpenMP

cheers,
    axel.

3

Here is my 2 cents. I don't think I see what is to be gained by
trying to run multiple molecules in the same
simulation. If you have N molecules, why
not just run N independent simulations?

From your description it sounds like there

is no intereaction between the different simulations,
so trying to overlay
multiple simulations in one simulation box means you have to jump
through hoops, and there is no real advantage
to it.

Assuming you can get LAMMPS to run one simulation
fast (and if you can't, then I don't think you have much chance
of getting LAMMPS to run a bunch of them together fast),
then it is not hard to write one script that will run all N
independently on P processors, where P <= N, and each
simualtion will run on a single processor until complete.

If the molecules are small, you might want to use an Nsq neigh
list.

Steve