Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F75202642
SpeciesTimeIntegrator.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, Jul 31, 23:25
Size
9 KB
Mime Type
text/x-c
Expires
Fri, Aug 2, 23:25 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
19494224
Attached To
rLAMMPS lammps
SpeciesTimeIntegrator.cpp
View Options
// ATC transfer headers
#include "SpeciesTimeIntegrator.h"
#include "TransferOperator.h"
#include "ATC_CouplingMass.h"
#include "TimeFilter.h"
#include "LammpsInterface.h"
#include "ATC_Error.h"
#include "PerAtomQuantityLibrary.h"
#include "AtomToMoleculeTransfer.h"
#include "MoleculeSet.h"
using
std
::
pair
;
using
std
::
map
;
using
std
::
string
;
namespace
ATC
{
//--------------------------------------------------------
//--------------------------------------------------------
// Class SpeciesTimeIntegrator
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
// Grab data from ATC
//--------------------------------------------------------
SpeciesTimeIntegrator
::
SpeciesTimeIntegrator
(
ATC_CouplingMass
*
atc
,
TimeIntegrationType
timeIntegrationType
)
:
TimeIntegrator
(
atc
,
timeIntegrationType
),
moleculeIds_
(
atc
->
molecule_ids
())
{
// do nothing
}
//--------------------------------------------------------
// modify
// parses inputs and modifies state of the filter
//--------------------------------------------------------
bool
SpeciesTimeIntegrator
::
modify
(
int
narg
,
char
**
arg
)
{
bool
match
=
false
;
// no parsing needed
return
match
;
}
//--------------------------------------------------------
// construct_methods
// creates algorithm objects
//--------------------------------------------------------
void
SpeciesTimeIntegrator
::
construct_methods
()
{
if
(
atc_
->
reset_methods
())
{
if
(
timeIntegrationMethod_
)
delete
timeIntegrationMethod_
;
if
(
timeFilterManager_
->
need_reset
())
{
switch
(
timeIntegrationType_
)
{
case
FRACTIONAL_STEP:
{
timeFilter_
=
timeFilterManager_
->
construct
(
TimeFilterManager
::
EXPLICIT_IMPLICIT
);
atc_
->
set_mass_mat_time_filter
(
SPECIES_CONCENTRATION
,
TimeFilterManager
::
EXPLICIT
);
break
;
}
default
:
throw
ATC_Error
(
"Unknown time integration type in SpeciesTimeIntegrator::Initialize()"
);
}
}
if
(
timeFilterManager_
->
filter_dynamics
())
{
switch
(
timeIntegrationType_
)
{
case
FRACTIONAL_STEP:
{
timeIntegrationMethod_
=
new
SpeciesTimeIntegratorFractionalStepFiltered
(
this
,
moleculeIds_
);
}
default
:
throw
ATC_Error
(
"Unknown time integration type in SpeciesTimeIntegrator::Initialize()"
);
}
}
else
{
timeIntegrationMethod_
=
new
SpeciesTimeIntegratorFractionalStep
(
this
,
moleculeIds_
);
}
}
}
//--------------------------------------------------------
// pack_fields
// add persistent variables to data list
//--------------------------------------------------------
void
SpeciesTimeIntegrator
::
pack_fields
(
RESTART_LIST
&
data
)
{
TimeIntegrator
::
pack_fields
(
data
);
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class SpeciesIntegrationMethod
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
// Grab data from ATC
//--------------------------------------------------------
SpeciesIntegrationMethod
::
SpeciesIntegrationMethod
(
SpeciesTimeIntegrator
*
speciesTimeIntegrator
,
const
map
<
string
,
pair
<
MolSize
,
int
>
>
&
moleculeIds
)
:
TimeIntegrationMethod
(
speciesTimeIntegrator
),
timeFilter_
(
speciesTimeIntegrator
->
time_filter
()),
massDensity_
(
atc_
->
field
(
MASS_DENSITY
)),
nodalAtomicMassDensityOut_
(
atc_
->
nodal_atomic_field
(
MASS_DENSITY
)),
nodalAtomicMassDensity_
(
NULL
),
speciesConcentration_
(
atc_
->
field
(
SPECIES_CONCENTRATION
)),
nodalAtomicSpeciesConcentration_
(
NULL
),
nodalAtomicSpeciesConcentrationFiltered_
(
speciesTimeIntegrator
->
nodal_atomic_species_concentration_filtered
()),
moleculeIds_
(
moleculeIds
)
{
// do nothing
}
//--------------------------------------------------------
// construct_transfers
// sets up all the necessary transfer operators
//--------------------------------------------------------
void
SpeciesIntegrationMethod
::
construct_transfers
()
{
InterscaleManager
&
interscaleManager
=
atc_
->
interscale_manager
();
// get existing data
nodalAtomicMassDensity_
=
interscaleManager
.
dense_matrix
(
field_to_intrinsic_name
(
MASS_DENSITY
));
if
(
atc_
->
has_tracked_species
())
nodalAtomicSpeciesConcentration_
=
interscaleManager
.
dense_matrix
(
field_to_intrinsic_name
(
SPECIES_CONCENTRATION
));
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class SpeciesTimeIntegratorFractionalStep
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
SpeciesTimeIntegratorFractionalStep
::
SpeciesTimeIntegratorFractionalStep
(
SpeciesTimeIntegrator
*
speciesTimeIntegrator
,
const
map
<
string
,
pair
<
MolSize
,
int
>
>
&
moleculeIds
)
:
SpeciesIntegrationMethod
(
speciesTimeIntegrator
,
moleculeIds
)
{
// do nothing
}
//--------------------------------------------------------
// initialize
// initialize all data
//--------------------------------------------------------
void
SpeciesTimeIntegratorFractionalStep
::
initialize
()
{
SpeciesIntegrationMethod
::
initialize
();
TimeFilterManager
*
timeFilterManager
=
atc_
->
time_filter_manager
();
if
(
timeFilterManager
->
need_reset
())
{
timeFilter_
->
initialize
();
}
if
(
!
timeFilterManager
->
end_equilibrate
())
{
nodalAtomicSpeciesConcentrationFiltered_
=
nodalAtomicSpeciesConcentration_
->
quantity
();
}
pre_final_integrate1
(
0.
);
}
//--------------------------------------------------------
// pre_initial_integrate1
//--------------------------------------------------------
void
SpeciesTimeIntegratorFractionalStep
::
pre_initial_integrate1
(
double
dt
)
{
const
DENS_MAT
&
my
(
nodalAtomicSpeciesConcentration_
->
quantity
());
// updated filtered energy using explicit-implicit scheme
timeFilter_
->
apply_pre_step1
(
nodalAtomicSpeciesConcentrationFiltered_
.
set_quantity
(),
my
,
dt
);
}
//--------------------------------------------------------
// pre_final_integrate1
// first time integration computations
// before FractionalStep step 2
//--------------------------------------------------------
void
SpeciesTimeIntegratorFractionalStep
::
pre_final_integrate1
(
double
dt
)
{
// Compute MD contribution to FEM equation
massDensity_
=
nodalAtomicMassDensity_
->
quantity
();
speciesConcentration_
=
nodalAtomicSpeciesConcentration_
->
quantity
();
atc_
->
set_fixed_nodes
();
}
//--------------------------------------------------------
// post_final_integrate2
//--------------------------------------------------------
void
SpeciesTimeIntegratorFractionalStep
::
post_final_integrate2
(
double
dt
)
{
timeFilter_
->
apply_post_step1
(
nodalAtomicSpeciesConcentrationFiltered_
.
set_quantity
(),
nodalAtomicSpeciesConcentration_
->
quantity
(),
dt
);
speciesConcentration_
=
nodalAtomicSpeciesConcentrationFiltered_
.
quantity
();
}
//--------------------------------------------------------
// post_process
// post processing of variables before output
//--------------------------------------------------------
void
SpeciesTimeIntegratorFractionalStep
::
post_process
()
{
map
<
string
,
pair
<
MolSize
,
int
>
>::
const_iterator
molecule
;
for
(
molecule
=
moleculeIds_
.
begin
();
molecule
!=
moleculeIds_
.
end
();
molecule
++
)
{
DENS_MAN
&
nodalMoleculeMassDensityOut
(
atc_
->
tagged_dens_man
(
molecule
->
first
));
DENS_MAN
*
nodalMoleculeMassDensity
((
atc_
->
interscale_manager
()).
dense_matrix
(
"NodalMoleculeMassDensity"
+
molecule
->
first
));
nodalMoleculeMassDensityOut
=
nodalMoleculeMassDensity
->
quantity
();
}
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class SpeciesTimeIntegratorFractionalStepFiltered
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
// Grab data from ATC
//--------------------------------------------------------
SpeciesTimeIntegratorFractionalStepFiltered
::
SpeciesTimeIntegratorFractionalStepFiltered
(
SpeciesTimeIntegrator
*
speciesTimeIntegrator
,
const
map
<
string
,
pair
<
MolSize
,
int
>
>
&
moleculeIds
)
:
SpeciesTimeIntegratorFractionalStep
(
speciesTimeIntegrator
,
moleculeIds
)
{
throw
ATC_Error
(
"SpeciesTimeIntegratorFractionalStepFiltered work in progress"
);
// do nothing
}
//--------------------------------------------------------
// pre_initial_integrate1
//--------------------------------------------------------
void
SpeciesTimeIntegratorFractionalStepFiltered
::
pre_final_integrate1
(
double
dt
)
{
}
};
Event Timeline
Log In to Comment