Page MenuHomec4science
Files F65330235

ThermalTimeIntegrator.cpp
No OneTemporary
Actions

File Metadata

Created
Mon, Jun 3, 00:28

ThermalTimeIntegrator.cpp
View Options

// ATC transfer headers
#include "ThermalTimeIntegrator.h"
#include "TransferOperator.h"
#include "ATC_Coupling.h"
#include "TimeFilter.h"
#include "ATC_Error.h"
#include "PerAtomQuantityLibrary.h"
namespace ATC {
//--------------------------------------------------------
//--------------------------------------------------------
// Class ThermalTimeIntegrator
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
ThermalTimeIntegrator::ThermalTimeIntegrator(ATC_Coupling * atc,
TimeIntegrationType timeIntegrationType) :
TimeIntegrator(atc, timeIntegrationType)
{
// do nothing
}
//--------------------------------------------------------
// modify
// parses inputs and modifies state of the integrator
//--------------------------------------------------------
bool ThermalTimeIntegrator::modify(int narg, char **arg)
{
bool foundMatch = false;
int argIndex = 0;
// time integration scheme
/*! \page man_thermal_time_integration fix_modify AtC time_integration (thermal)
\section syntax
fix_modify AtC time_integration <descriptor> \n
- descriptor (string) = time integration type \n
various time integration methods for the finite elements\n
\section description
gear - atomic velocity update with 2nd order Verlet, nodal temperature update with 3rd or 4th order Gear, thermostats based on controlling power \n
fractional_step - atomic velocity update with 2nd order Verlet, mixed nodal temperature update, 3/4 Gear for continuum and 2 Verlet for atomic contributions, thermostats based on controlling discrete energy changes\n
\section examples
<TT> fix_modify atc time_integration gear </TT> \n
<TT> fix_modify atc time_integration fractional_step </TT> \n
\section description
\section related
see \ref man_fix_atc
\section default
none
*/
if (strcmp(arg[argIndex],"gear")==0) {
timeIntegrationType_ = GEAR;
needReset_ = true;
foundMatch = true;
}
else if (strcmp(arg[argIndex],"fractional_step")==0) {
timeIntegrationType_ = FRACTIONAL_STEP;
needReset_ = true;
foundMatch = true;
}
return foundMatch;
}
//--------------------------------------------------------
// construct_methods
// creates algorithm objects
//--------------------------------------------------------
void ThermalTimeIntegrator::construct_methods()
{
if (atc_->reset_methods()) {
if (timeIntegrationMethod_) delete timeIntegrationMethod_;
if (timeFilterManager_->need_reset()) {
switch (timeIntegrationType_) {
case GEAR: {
timeFilter_ = timeFilterManager_->construct(TimeFilterManager::IMPLICIT);
atc_->set_mass_mat_time_filter(TEMPERATURE,TimeFilterManager::EXPLICIT);
break;
}
case FRACTIONAL_STEP: {
timeFilter_ = timeFilterManager_->construct(TimeFilterManager::EXPLICIT_IMPLICIT);
atc_->set_mass_mat_time_filter(TEMPERATURE,TimeFilterManager::EXPLICIT_IMPLICIT);
break;
}
default:
throw ATC_Error("Uknown time integration type in ThermalTimeIntegrator::Initialize()");
}
}
if (timeFilterManager_->filter_dynamics()) {
switch (timeIntegrationType_) {
case GEAR: {
timeIntegrationMethod_ = new ThermalTimeIntegratorGearFiltered(this);
break;
}
case FRACTIONAL_STEP: {
timeIntegrationMethod_ = new ThermalTimeIntegratorFractionalStepFiltered(this);
break;
}
default:
throw ATC_Error("Uknown time integration type in ThermalTimeIntegrator::Initialize()");
}
}
else {
switch (timeIntegrationType_) {
case GEAR: {
timeIntegrationMethod_ = new ThermalTimeIntegratorGear(this);
break;
}
case FRACTIONAL_STEP: {
timeIntegrationMethod_ = new ThermalTimeIntegratorFractionalStep(this);
break;
}
default:
throw ATC_Error("Uknown time integration type in ThermalTimeIntegrator::Initialize()");
}
}
}
}
//--------------------------------------------------------
// pack_fields
// add persistent variables to data list
//--------------------------------------------------------
void ThermalTimeIntegrator::pack_fields(RESTART_LIST & data)
{
data["NodalAtomicPowerFiltered"] = & nodalAtomicPowerFiltered_.set_quantity();
data["NodalAtomicEnergyFiltered"] = & nodalAtomicEnergyFiltered_.set_quantity();
TimeIntegrator::pack_fields(data);
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class ThermalIntegrationMethod
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
// Grab data from ATC
//--------------------------------------------------------
ThermalIntegrationMethod::ThermalIntegrationMethod(ThermalTimeIntegrator * thermalTimeIntegrator) :
TimeIntegrationMethod(thermalTimeIntegrator),
timeFilter_(thermalTimeIntegrator->time_filter()),
temperature_(atc_->field(TEMPERATURE)),
temperatureRoc_(atc_->field_roc(TEMPERATURE)),
temperature2Roc_(atc_->field_2roc(TEMPERATURE)),
nodalAtomicTemperatureOut_(atc_->nodal_atomic_field(TEMPERATURE)),
nodalAtomicTemperature_(NULL),
temperatureRhs_(atc_->field_rhs(TEMPERATURE)),
nodalAtomicPowerOut_(atc_->nodal_atomic_field_roc(TEMPERATURE))
{
// do nothing
}
//--------------------------------------------------------
// construct_transfers
// Grab existing managed quantities,
// create the rest
//--------------------------------------------------------
void ThermalIntegrationMethod::construct_transfers()
{
nodalAtomicTemperature_ =
(atc_->interscale_manager()).dense_matrix("NodalAtomicTemperature");
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class ThermalIntegratorGear
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
ThermalTimeIntegratorGear::ThermalTimeIntegratorGear(ThermalTimeIntegrator * thermalTimeIntegrator) :
ThermalIntegrationMethod(thermalTimeIntegrator),
nodalAtomicPowerFiltered_(thermalTimeIntegrator->nodal_atomic_power_filtered())
{
// do nothing
}
//--------------------------------------------------------
// construct_transfers
// Grab existing managed quantities,
// create the rest
//--------------------------------------------------------
void ThermalTimeIntegratorGear::construct_transfers()
{
ThermalIntegrationMethod::construct_transfers();
InterscaleManager & interscaleManager = atc_->interscale_manager();
// add in power computation
DotTwiceKineticEnergy * dotTwiceKineticEnergy =
new DotTwiceKineticEnergy(atc_);
interscaleManager.add_per_atom_quantity(dotTwiceKineticEnergy,"DotTwiceKineticEnergy");
nodalAtomicPower_ = new AtfShapeFunctionRestriction(atc_,
dotTwiceKineticEnergy,
interscaleManager.per_atom_sparse_matrix("Interpolant"));
interscaleManager.add_dense_matrix(nodalAtomicPower_,"NodalAtomicPower");
}
//--------------------------------------------------------
// initialize
// initialize all data
//--------------------------------------------------------
void ThermalTimeIntegratorGear::initialize()
{
ThermalIntegrationMethod::initialize();
// sets up time filter for cases where variables temporally filtered
// this time integrator should use an implicit filter
TimeFilterManager * timeFilterManager = atc_->time_filter_manager();
if (timeFilterManager->need_reset()) {
// Some time filters need the old value for the power
timeFilter_->initialize(nodalAtomicPower_->quantity());
}
if (!timeFilterManager->end_equilibrate()) {
nodalAtomicPowerFiltered_.reset(atc_->num_nodes(),1);
}
if (!timeFilterManager->filter_dynamics()) {
temperatureRhs_ = nodalAtomicPower_->quantity();
}
}
//--------------------------------------------------------
// pre_initial_integrate2
/// time integration before Verlet step 1
//--------------------------------------------------------
void ThermalTimeIntegratorGear::pre_initial_integrate2(double dt)
{
// Predict nodal temperatures and time derivatives based on FE data
// use 3rd order Gear
gear1_3_predict(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.quantity(),dt);
}
//--------------------------------------------------------
// post_final_integrate1
// time integration after Verlet step 2
//--------------------------------------------------------
void ThermalTimeIntegratorGear::post_final_integrate1(double dt)
{
const DENS_MAT & myNodalAtomicPower(nodalAtomicPower_->quantity());
timeFilter_->apply_post_step2(nodalAtomicPowerFiltered_.set_quantity(),
myNodalAtomicPower,dt);
temperatureRhs_ += myNodalAtomicPower;
// Finish updating temperature
_temperatureResidual_.resize(atc_->num_nodes(),1);
atc_->apply_inverse_mass_matrix(temperatureRhs_.quantity(),
_temperatureResidual_,
TEMPERATURE);
_temperatureResidual_ -= temperatureRoc_.quantity();
_temperatureResidual_ *= dt;
gear1_3_correct(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.set_quantity(),
_temperatureResidual_,dt);
}
//--------------------------------------------------------
// post_process
// do any post-processing calculations required for
// output phase
//--------------------------------------------------------
void ThermalTimeIntegratorGear::post_process()
{
nodalAtomicPowerOut_ = nodalAtomicPower_->quantity();
nodalAtomicTemperatureOut_ = nodalAtomicTemperature_->quantity();
}
//--------------------------------------------------------
// finish
// finalize state of nodal atomic quantities
//--------------------------------------------------------
void ThermalTimeIntegratorGear::finish()
{
post_process();
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class ThermalTimeIntegratorGearFiltered
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
// Grab data from ATC
//--------------------------------------------------------
ThermalTimeIntegratorGearFiltered::ThermalTimeIntegratorGearFiltered(ThermalTimeIntegrator * thermalTimeIntegrator) :
ThermalTimeIntegratorGear(thermalTimeIntegrator),
temperature3Roc_(atc_->field_3roc(TEMPERATURE))
{
// do nothing
// specifically if history data is required and we need another time filter object for the fields
}
//--------------------------------------------------------
// pre_initial_integrate2
// time integration before Verlet step 1
//--------------------------------------------------------
void ThermalTimeIntegratorGearFiltered::pre_initial_integrate2(double dt)
{
// Predict nodal temperatures and time derivatives based on FE data
// use 3rd order Gear
gear1_4_predict(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.set_quantity(),
temperature3Roc_.quantity(),dt);
}
//--------------------------------------------------------
// post_final_integrate1
// first time integration computations
// after Verlet step 2
//--------------------------------------------------------
void ThermalTimeIntegratorGearFiltered::post_final_integrate1(double dt)
{
DENS_MAT & myNodalAtomicPowerFiltered(nodalAtomicPowerFiltered_.set_quantity());
timeFilter_->apply_post_step2(myNodalAtomicPowerFiltered,nodalAtomicPower_->quantity(),dt);
temperatureRhs_ += myNodalAtomicPowerFiltered;
// Finish updating temperature
_temperatureResidual_.resize(atc_->num_nodes(),1);
atc_->apply_inverse_mass_matrix(temperatureRhs_.quantity(),
_temperatureResidual_,
TEMPERATURE);
_temperatureResidual_ -= temperatureRoc_.quantity();
_temperatureResidual_ *= dt;
gear1_4_correct(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.set_quantity(),
temperature3Roc_.set_quantity(),
_temperatureResidual_,dt);
}
//--------------------------------------------------------
// post_final_integrate3
// third time integration computations
// after Verlet step 2
//--------------------------------------------------------
void ThermalTimeIntegratorGearFiltered::post_final_integrate3(double dt)
{
// update filtered atomic temperature
timeFilter_->apply_post_step2(nodalAtomicTemperatureOut_.set_quantity(),
nodalAtomicTemperature_->quantity(),dt);
}
//--------------------------------------------------------
// post_process
// do any post-processing calculations required for
// output phase
//--------------------------------------------------------
void ThermalTimeIntegratorGearFiltered::post_process()
{
nodalAtomicPowerOut_ = nodalAtomicPowerFiltered_.quantity();
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class ThermalIntegratorFractionalStep
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
// Grab data from ATC
//--------------------------------------------------------
ThermalTimeIntegratorFractionalStep::ThermalTimeIntegratorFractionalStep(ThermalTimeIntegrator * thermalTimeIntegrator) :
ThermalIntegrationMethod(thermalTimeIntegrator),
nodalAtomicEnergyFiltered_(thermalTimeIntegrator->nodal_atomic_energy_filtered()),
nodalAtomicPowerFiltered_(thermalTimeIntegrator->nodal_atomic_power_filtered()),
atomicTemperatureDelta_(atc_->num_nodes(),1),
nodalAtomicEnergy_(NULL),
nodalAtomicEnergyOld_(atc_->num_nodes(),1),
nodalAtomicTemperatureOld_(atc_->num_nodes(),1)
{
// do nothing
}
//--------------------------------------------------------
// construct_transfers
// Grab existing managed quantities,
// create the rest
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::construct_transfers()
{
ThermalIntegrationMethod::construct_transfers();
InterscaleManager & interscaleManager(atc_->interscale_manager());
nodalAtomicEnergy_ = interscaleManager.dense_matrix("NodalAtomicEnergy");
}
//--------------------------------------------------------
// initialize
// initialize all data
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::initialize()
{
ThermalIntegrationMethod::initialize();
// initial power to zero
nodalAtomicPower_.reset(atc_->num_nodes(),1);
// sets up time filter for cases where variables temporally filtered
// this time integrator should use Crank-Nicholson filter for 2nd order accuracy
TimeFilterManager * timeFilterManager = atc_->time_filter_manager();
if (timeFilterManager->need_reset()) {
// the form of this integrator implies no time filters that require history data can be used
timeFilter_->initialize();
}
// sets up time filter for post-processing the filtered power
// this time integrator should use an explicit-implicit filter
// to mirror the 2nd order Verlet integration scheme
// It requires no history information so initial value just sizes arrays
if (!timeFilterManager->end_equilibrate()) {
// implies an initial condition of the instantaneous atomic energy
// for the corresponding filtered variable, consistent with the temperature
nodalAtomicEnergyFiltered_ = nodalAtomicEnergy_->quantity();
nodalAtomicPowerFiltered_.reset(atc_->num_nodes(),1);
}
}
//--------------------------------------------------------
// pre_initial_integrate1
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::pre_initial_integrate1(double dt)
{
const DENS_MAT & myNodalAtomicEnergy(nodalAtomicEnergy_->quantity());
// updated filtered energy using explicit-implicit scheme
timeFilter_->apply_pre_step1(nodalAtomicEnergyFiltered_.set_quantity(),
myNodalAtomicEnergy,dt);
}
//--------------------------------------------------------
// pre_initial_integrate2
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::pre_initial_integrate2(double dt)
{
// used for updating change in temperature from mass matrix change
this->compute_old_time_data();
// update FE contributions
apply_gear_predictor(dt);
// update filtered nodal atomic power
// that way thermostat and integrator can be consistent
timeFilter_->apply_pre_step1(nodalAtomicPowerFiltered_.set_quantity(),
nodalAtomicPower_,dt);
// store current energy for use later
nodalAtomicPower_ = nodalAtomicEnergy_->quantity();
nodalAtomicPower_ *= -1.;
}
//--------------------------------------------------------
// pre_final_integrate1
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::pre_final_integrate1(double dt)
{
// before the new rhs is computed but after atomic velocity is updated
// to allow for general notions of temperature beyond kinetic.
// compute change in restricted atomic energy
nodalAtomicPower_ += nodalAtomicEnergy_->quantity();
// update FE temperature with change in temperature from MD
compute_temperature_delta(nodalAtomicPower_,dt);
temperature_ += atomicTemperatureDelta_.quantity();
// approximation to power for output
nodalAtomicPower_ /= dt;
timeFilter_->apply_post_step1(nodalAtomicPowerFiltered_.set_quantity(),
nodalAtomicPower_,dt);
// make sure nodes are fixed
atc_->set_fixed_nodes();
}
//--------------------------------------------------------
// post_final_integrate1
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::post_final_integrate1(double dt)
{
// Finish updating temperature with FE contributions
atc_->apply_inverse_mass_matrix(temperatureRhs_.quantity(),
_temperatureResidual_,TEMPERATURE);
_temperatureResidual_ -= temperatureRoc_.quantity();
_temperatureResidual_ *= dt;
apply_gear_corrector(_temperatureResidual_,dt);
}
//--------------------------------------------------------
// post_final_integrate3
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::post_final_integrate3(double dt)
{
// update filtered atomic energy
timeFilter_->apply_post_step1(nodalAtomicEnergyFiltered_.set_quantity(),
nodalAtomicEnergy_->quantity(),dt);
}
//--------------------------------------------------------
// output
// add variables to output list
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::post_process()
{
nodalAtomicPowerOut_ = nodalAtomicPower_;
nodalAtomicTemperatureOut_ = nodalAtomicTemperature_->quantity();
}
//--------------------------------------------------------
// finish
// finalize state of nodal atomic quantities
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::finish()
{
post_process();
}
//--------------------------------------------------------
// apply_gear_predictor
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::apply_gear_predictor(double dt)
{
gear1_3_predict(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.quantity(),dt);
}
//--------------------------------------------------------
// apply_gear_corrector
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::apply_gear_corrector(const DENS_MAT & R_theta, double dt)
{
gear1_3_correct(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.set_quantity(),
R_theta,dt);
}
//--------------------------------------------------------
// compute_old_time_data
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::compute_old_time_data()
{
const DENS_MAT & myNodalAtomicEnergy(nodalAtomicEnergy_->quantity());
atc_->apply_inverse_mass_matrix(myNodalAtomicEnergy,
nodalAtomicTemperatureOld_.set_quantity(),
TEMPERATURE);
nodalAtomicEnergyOld_ = myNodalAtomicEnergy;
}
//--------------------------------------------------------
// compute_temperature_delta
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::compute_temperature_delta(const DENS_MAT & atomicEnergyDelta,
double dt)
{
DENS_MAT & myAtomicTemperatureDelta(atomicTemperatureDelta_.set_quantity());
myAtomicTemperatureDelta = nodalAtomicEnergyOld_.quantity() + atomicEnergyDelta;
atc_->apply_inverse_mass_matrix(myAtomicTemperatureDelta,
TEMPERATURE);
myAtomicTemperatureDelta += -1.*(nodalAtomicTemperatureOld_.quantity());
}
//--------------------------------------------------------
//--------------------------------------------------------
// Class ThermalTimeIntegratorFracionalStepFiltered
//--------------------------------------------------------
//--------------------------------------------------------
//--------------------------------------------------------
// Constructor
// Grab data from ATC
//--------------------------------------------------------
ThermalTimeIntegratorFractionalStepFiltered::ThermalTimeIntegratorFractionalStepFiltered(ThermalTimeIntegrator * thermalTimeIntegrator) :
ThermalTimeIntegratorFractionalStep(thermalTimeIntegrator),
temperature3Roc_(atc_->field_3roc(TEMPERATURE))
{
// do nothing
}
//--------------------------------------------------------
// Destructor
//--------------------------------------------------------
ThermalTimeIntegratorFractionalStepFiltered::~ThermalTimeIntegratorFractionalStepFiltered()
{
// do nothing
}
//--------------------------------------------------------
// pre_initial_integrate1
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStepFiltered::pre_initial_integrate1(double dt)
{
// determine change in temperature if no forces were applied over this timestep
// relevant coefficients from time filter
double coefF1 = timeFilter_->filtered_coefficient_pre_s1(dt);
double coefF2 = timeFilter_->filtered_coefficient_post_s1(dt);
double coefU1 = timeFilter_->unfiltered_coefficient_pre_s1(dt);
double coefU2 = timeFilter_->unfiltered_coefficient_post_s1(dt);
DENS_MAT & myAtomicTemperatureDelta(atomicTemperatureDelta_.set_quantity());
DENS_MAT & myNodalAtomicEnergyFiltered(nodalAtomicEnergyFiltered_.set_quantity());
const DENS_MAT & myNodalAtomicEnergy(nodalAtomicEnergy_->quantity());
// composite from change after two step update of current filtered energy
myAtomicTemperatureDelta = (coefF1*coefF2-1.)*myNodalAtomicEnergyFiltered;
// change in filtered temperature from current energy from this and next time levels
myAtomicTemperatureDelta += (coefU1*coefF2+coefU2)*myNodalAtomicEnergy;
// updated filtered energy using explicit-implicit scheme
// nodalAtomicEnergy_ is either set from initialization or from the end of the last timestep
timeFilter_->apply_pre_step1(myNodalAtomicEnergyFiltered,myNodalAtomicEnergy,dt);
}
//--------------------------------------------------------
// output
// add variables to output list
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStepFiltered::output(OUTPUT_LIST & outputData)
{
atc_->apply_inverse_md_mass_matrix(nodalAtomicEnergyFiltered_.quantity(),
nodalAtomicTemperatureOut_.set_quantity(),
TEMPERATURE);
DENS_MAT & nodalAtomicPower(nodalAtomicPowerFiltered_.set_quantity());
if ((atc_->lammps_interface())->rank_zero()) {
outputData["NodalAtomicPower"] = &nodalAtomicPower;
}
}
//--------------------------------------------------------
// apply_gear_predictor
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStepFiltered::apply_gear_predictor(double dt)
{
gear1_4_predict(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.set_quantity(),
temperature3Roc_.quantity(),dt);
}
//--------------------------------------------------------
// apply_gear_corrector
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStepFiltered::apply_gear_corrector(const DENS_MAT & R_theta, double dt)
{
gear1_4_correct(temperature_.set_quantity(),
temperatureRoc_.set_quantity(),
temperature2Roc_.set_quantity(),
temperature3Roc_.set_quantity(),
R_theta,dt);
}
//--------------------------------------------------------
// compute_temperature_delta
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStepFiltered::compute_old_time_data()
{
const DENS_MAT & myNodalAtomicEnergyFiltered(nodalAtomicEnergyFiltered_.quantity());
atc_->apply_inverse_mass_matrix(myNodalAtomicEnergyFiltered,
nodalAtomicTemperatureOld_.set_quantity(),
TEMPERATURE);
nodalAtomicEnergyOld_ = myNodalAtomicEnergyFiltered;
}
//--------------------------------------------------------
// compute_old_time_data
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStepFiltered::compute_temperature_delta(const DENS_MAT & atomicEnergyDelta,
double dt)
{
DENS_MAT & myAtomicTemperatureDelta(atomicTemperatureDelta_.set_quantity());
double coefU2 = timeFilter_->unfiltered_coefficient_post_s1(dt);
myAtomicTemperatureDelta += nodalAtomicEnergyOld_.quantity() + coefU2*atomicEnergyDelta;
atc_->apply_inverse_mass_matrix(myAtomicTemperatureDelta,
TEMPERATURE);
myAtomicTemperatureDelta += -1.*nodalAtomicTemperatureOld_.quantity();
}
};

Event Timeline

c4science · Help