ICODE-ADC/lammps
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

apply clang-tidy updates

Browse Source
This commit is contained in:
Axel Kohlmeyer
2022-04-10 11:31:49 -04:00
parent 1a2d83ab01
commit 413a01ade5
42 changed files with 106 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/atc/ATC_Coupling.cpp
View File

@ -775,7 +775,7 @@ namespace ATC {
//--------------------------------------------------
/** allow FE_Engine to construct data manager after mesh is constructed */
void ATC_Coupling::construct_prescribed_data_manager (void) {
void ATC_Coupling::construct_prescribed_data_manager () {
prescribedDataMgr_ = new PrescribedDataManager(feEngine_,fieldSizes_);
}
@ -1704,7 +1704,7 @@ namespace ATC {
//--------------------------------------------------------------
/** method to trigger construction of mesh data after mesh construction */
//--------------------------------------------------------------
void ATC_Coupling::initialize_mesh_data(void)
void ATC_Coupling::initialize_mesh_data()
{
int nelts = feEngine_->fe_mesh()->num_elements();
elementToMaterialMap_.reset(nelts);
@ -1715,7 +1715,7 @@ namespace ATC {
}
//--------------------------------------------------------
void ATC_Coupling::reset_flux_mask(void)
void ATC_Coupling::reset_flux_mask()
{
int i;
// this is exact only for uniform meshes and certain types of atomic weights

2
lib/atc/ATC_CouplingMomentum.cpp
View File

@ -357,7 +357,7 @@ namespace ATC {
// compute_scalar : added energy
// this is used in the line search
//--------------------------------------------------------------------
double ATC_CouplingMomentum::compute_scalar(void)
double ATC_CouplingMomentum::compute_scalar()
{
double energy = extrinsicModelManager_.compute_scalar();
return energy;

6
lib/atc/ATC_CouplingMomentumEnergy.cpp
View File

@ -327,7 +327,7 @@ namespace ATC {
//--------------------------------------------------------------------
// compute_scalar : added energy
//--------------------------------------------------------------------
double ATC_CouplingMomentumEnergy::compute_scalar(void)
double ATC_CouplingMomentumEnergy::compute_scalar()
{
double energy = 0.0;
energy += extrinsicModelManager_.compute_scalar();
@ -337,7 +337,7 @@ namespace ATC {
//--------------------------------------------------------------------
// total kinetic energy
//--------------------------------------------------------------------
double ATC_CouplingMomentumEnergy::kinetic_energy(void)
double ATC_CouplingMomentumEnergy::kinetic_energy()
{
const MATRIX & M = massMats_[VELOCITY].quantity();
@ -355,7 +355,7 @@ namespace ATC {
//--------------------------------------------------------------------
// total potential energy
//--------------------------------------------------------------------
double ATC_CouplingMomentumEnergy::potential_energy(void)
double ATC_CouplingMomentumEnergy::potential_energy()
{
Array<FieldName> mask(1);
mask(0) = VELOCITY;

10
lib/atc/ATC_Method.cpp
View File

@ -1674,7 +1674,7 @@ pecified
}
//-------------------------------------------------------------------
void ATC_Method::set_reference_potential_energy(void)
void ATC_Method::set_reference_potential_energy()
{
if (setRefPE_) {
if (setRefPEvalue_) {
@ -2170,7 +2170,7 @@ pecified
// }
}
//--------------------------------------------------------
void ATC_Method::compute_nodeset_output(void)
void ATC_Method::compute_nodeset_output()
{
map< pair <string, FieldName>, NodesetOperationType >::const_iterator iter;
for (iter = nsetData_.begin(); iter != nsetData_.end();iter++){
@ -2194,7 +2194,7 @@ pecified
}
}
//--------------------------------------------------------
void ATC_Method::compute_faceset_output(void)
void ATC_Method::compute_faceset_output()
{
map < pair<string,string>, FacesetIntegralType >::const_iterator iter;
DENS_MAT values;
@ -2223,7 +2223,7 @@ pecified
}
}
//--------------------------------------------------------
void ATC_Method::compute_elementset_output(void)
void ATC_Method::compute_elementset_output()
{
map< pair <string, FieldName>, ElementsetOperationType >::const_iterator iter;
for (iter = esetData_.begin(); iter != esetData_.end();iter++){
@ -2379,7 +2379,7 @@ pecified
}
//--------------------------------------------------------
void ATC_Method::remap_ghost_ref_positions(void)
void ATC_Method::remap_ghost_ref_positions()
{
int nlocal = lammpsInterface_->nlocal();

4
lib/atc/ATC_Transfer.cpp
View File

@ -916,12 +916,12 @@ namespace ATC {
}
//-------------------------------------------------------------------
void ATC_Transfer::compute_bond_matrix(void)
void ATC_Transfer::compute_bond_matrix()
{
bondMatrix_->reset();
}
//-------------------------------------------------------------------
void ATC_Transfer::compute_fields(void)
void ATC_Transfer::compute_fields()
{
// keep per-atom computes fresh. JAZ and REJ not sure why;

2
lib/atc/ATC_TransferKernel.cpp
View File

@ -83,7 +83,7 @@ using ATC_Utility::to_string;
}
//-------------------------------------------------------------------
void ATC_TransferKernel::compute_kernel_matrix_molecule(void) // KKM add
void ATC_TransferKernel::compute_kernel_matrix_molecule() // KKM add
{
int nLocalMol = smallMoleculeSet_->local_molecule_count();
if (nLocal_>0) {

2
lib/atc/AtomicRegulator.cpp
View File

@ -688,7 +688,7 @@ namespace ATC {
// compute_sparsity
// - creates sparsity template
//--------------------------------------------------------
void RegulatorShapeFunction::compute_sparsity(void)
void RegulatorShapeFunction::compute_sparsity()
{
// first get local pattern from N N^T

14
lib/atc/ChargeRegulator.cpp
View File

@ -198,7 +198,7 @@ namespace ATC {
// nomenclature might be a bit backwark: control --> nodes that exert the control, & influence --> atoms that feel the influence
void ChargeRegulatorMethod::initialize(void)
void ChargeRegulatorMethod::initialize()
{
interscaleManager_ = &(atc_->interscale_manager());
@ -220,7 +220,7 @@ namespace ATC {
int ChargeRegulatorMethod::nlocal() { return atc_->nlocal(); }
void ChargeRegulatorMethod::set_greens_functions(void)
void ChargeRegulatorMethod::set_greens_functions()
{
// set up Green's function per node
for (int i = 0; i < nNodes_; i++) {
@ -272,7 +272,7 @@ namespace ATC {
//--------------------------------------------------------
// Initialize
//--------------------------------------------------------
void ChargeRegulatorMethodFeedback::initialize(void)
void ChargeRegulatorMethodFeedback::initialize()
{
ChargeRegulatorMethod::initialize();
if (surfaceType_ != ChargeRegulator::CONDUCTOR)
@ -284,7 +284,7 @@ namespace ATC {
//--------------------------------------------------------
// Initialize
//--------------------------------------------------------
void ChargeRegulatorMethodFeedback::construct_transfers(void)
void ChargeRegulatorMethodFeedback::construct_transfers()
{
ChargeRegulatorMethod::construct_transfers();
@ -301,7 +301,7 @@ namespace ATC {
//--------------------------------------------------------
// find measurement atoms and nodes
//--------------------------------------------------------
void ChargeRegulatorMethodFeedback::set_influence(void)
void ChargeRegulatorMethodFeedback::set_influence()
{
// get nodes that overlap influence atoms & compact list of influence atoms
@ -321,7 +321,7 @@ namespace ATC {
//--------------------------------------------------------
// constuct a Green's submatrix
//--------------------------------------------------------
void ChargeRegulatorMethodFeedback::set_influence_matrix(void)
void ChargeRegulatorMethodFeedback::set_influence_matrix()
{
// construct control-influence matrix bar{G}^-1: ds{p} = G{p,m}^-1 dphi{m}
@ -434,7 +434,7 @@ namespace ATC {
//--------------------------------------------------------
// Initialize
//--------------------------------------------------------
void ChargeRegulatorMethodImageCharge::initialize(void)
void ChargeRegulatorMethodImageCharge::initialize()
{
ChargeRegulatorMethod::initialize();
if (surfaceType_ != ChargeRegulator::DIELECTRIC) throw ATC_Error("currently image charge can only mimic a dielectric");

10
lib/atc/ConcentrationRegulator.cpp
View File

@ -224,7 +224,7 @@ const double kMinScale_ = 10000.;
//--------------------------------------------------------
// Initialize
//--------------------------------------------------------
void ConcentrationRegulatorMethodTransition::initialize(void)
void ConcentrationRegulatorMethodTransition::initialize()
{
#ifdef ATC_VERBOSE
lammpsInterface_->print_msg_once(
@ -289,7 +289,7 @@ const double kMinScale_ = 10000.;
//--------------------------------------------------------
// pre exchange
//--------------------------------------------------------
void ConcentrationRegulatorMethodTransition::pre_exchange(void)
void ConcentrationRegulatorMethodTransition::pre_exchange()
{
// return if should not be called on this timestep
if ( ! lammpsInterface_->now(frequency_)) return;
@ -312,7 +312,7 @@ const double kMinScale_ = 10000.;
//--------------------------------------------------------
// pre force
//--------------------------------------------------------
void ConcentrationRegulatorMethodTransition::pre_force(void)
void ConcentrationRegulatorMethodTransition::pre_force()
{
transition();
}
@ -353,7 +353,7 @@ const double kMinScale_ = 10000.;
//--------------------------------------------------------
// excess
//--------------------------------------------------------
int ConcentrationRegulatorMethodTransition::excess(void) const
int ConcentrationRegulatorMethodTransition::excess() const
{
int nexcess = count()-targetCount_;
nexcess = max(min(nexcess,maxExchanges_),-maxExchanges_);
@ -362,7 +362,7 @@ const double kMinScale_ = 10000.;
//--------------------------------------------------------
// count
//--------------------------------------------------------
int ConcentrationRegulatorMethodTransition::count(void) const
int ConcentrationRegulatorMethodTransition::count() const
{
// integrate concentration over region
const DENS_MAT & c = (atc_->field(SPECIES_CONCENTRATION)).quantity();

4
lib/atc/ExtrinsicModel.cpp
View File

@ -181,7 +181,7 @@ namespace ATC {
//--------------------------------------------------------
// compute_scalar
//--------------------------------------------------------
double ExtrinsicModelManager::compute_scalar(void)
double ExtrinsicModelManager::compute_scalar()
{
double value = 0.;
vector<ExtrinsicModel *>::iterator imodel;
@ -360,7 +360,7 @@ namespace ATC {
//--------------------------------------------------------
// initialize
//--------------------------------------------------------
void ExtrinsicModel::initialize(void)
void ExtrinsicModel::initialize()
{
physicsModel_->initialize();
}

2
lib/atc/ExtrinsicModelElectrostatic.cpp
View File

@ -483,7 +483,7 @@ namespace ATC {
//--------------------------------------------------------
// compute_scalar : added energy = - f.x
//--------------------------------------------------------
double ExtrinsicModelElectrostatic::compute_scalar(void)
double ExtrinsicModelElectrostatic::compute_scalar()
{
//((atc_->interscale_manager()).fundamental_atom_quantity(LammpsInterface::ATOM_POSITION))->force_reset();
const DENS_MAT & atomPosition = ((atc_->interscale_manager()).fundamental_atom_quantity(LammpsInterface::ATOM_POSITION))->quantity();

4
lib/atc/FE_Engine.cpp
View File

@ -430,7 +430,7 @@ namespace ATC{
//-----------------------------------------------------------------
// write geometry
//-----------------------------------------------------------------
void FE_Engine::write_geometry(void)
void FE_Engine::write_geometry()
{
outputManager_.write_geometry(feMesh_->coordinates(),
feMesh_->connectivity());
@ -2373,7 +2373,7 @@ namespace ATC{
feMesh_->face_shape_function(face, _fN_, _fdN_, _nN_, _fweights_);
feMesh_->element_coordinates(elem, xCoords);
MultAB(xCoords,_fN_,xAtIPs,0,1); //xAtIPs = xCoords*(N.transpose());
MultAB(xCoords,_fN_,xAtIPs,false,true); //xAtIPs = xCoords*(N.transpose());
// interpolate prescribed flux at ips of this element

8
lib/atc/FE_Mesh.cpp
View File

@ -404,7 +404,7 @@ namespace ATC {
// -------------------------------------------------------------
// initialize
// -------------------------------------------------------------
void FE_Mesh::initialize(void)
void FE_Mesh::initialize()
{
bool aligned = is_aligned();
@ -469,7 +469,7 @@ namespace ATC {
// -------------------------------------------------------------
// test whether almost structured
// -------------------------------------------------------------
bool FE_Mesh::is_aligned(void) const
bool FE_Mesh::is_aligned() const
{
vector<bool> foundBestMatch(nSD_,false);
vector<DENS_VEC> tangents(nSD_);
@ -518,7 +518,7 @@ namespace ATC {
// -------------------------------------------------------------
// element_type
// -------------------------------------------------------------
string FE_Mesh::element_type(void) const {
string FE_Mesh::element_type() const {
int npe = feElement_->num_elt_nodes();
if (npe == 4) { return "TET4"; }
else if (npe == 8) { return "HEX8"; }
@ -1915,7 +1915,7 @@ namespace ATC {
return true;
}
void FE_3DMesh::set_unique_connectivity(void)
void FE_3DMesh::set_unique_connectivity()
{
int numEltNodes = feElement_->num_elt_nodes();
connectivityUnique_.reset(numEltNodes, nElts_);

16
lib/atc/LammpsInterface.cpp
View File

@ -483,7 +483,7 @@ void LammpsInterface::periodicity_correction(double * x) const
}
}
void LammpsInterface::set_reference_box(void) const
void LammpsInterface::set_reference_box() const
{
double * hi = lammps_->domain->boxhi;
double * lo = lammps_->domain->boxlo;
@ -570,7 +570,7 @@ void LammpsInterface::closest_image(const double * const xi, const double * cons
// -----------------------------------------------------------------
// update interface methods
// -----------------------------------------------------------------
LammpsInterface::UnitsType LammpsInterface::units_style(void) const
LammpsInterface::UnitsType LammpsInterface::units_style() const
{
if (strcmp(lammps_->update->unit_style,"lj") == 0) return LJ;
else if (strcmp(lammps_->update->unit_style,"real") == 0) return REAL;
@ -655,7 +655,7 @@ void LammpsInterface::basis_vectors(double **basis) const
}
//* gets the (max) lattice constant
double LammpsInterface::max_lattice_constant(void) const
double LammpsInterface::max_lattice_constant() const
{
double a1[3], a2[3], a3[3];
unit_cell(a1,a2,a3);
@ -666,7 +666,7 @@ double LammpsInterface::max_lattice_constant(void) const
}
//* computes a cutoff distance halfway between 1st and 2nd nearest neighbors
double LammpsInterface::near_neighbor_cutoff(void) const
double LammpsInterface::near_neighbor_cutoff() const
{
double cutoff;
double alat = LammpsInterface::max_lattice_constant();
@ -716,7 +716,7 @@ void LammpsInterface::unit_cell(double *a1, double *a2, double *a3) const
}
//* gets number of atoms in a unit cell
int LammpsInterface::num_atoms_per_cell(void) const
int LammpsInterface::num_atoms_per_cell() const
{
int naCell = 0;
LatticeType type = lattice_style();
@ -733,7 +733,7 @@ int LammpsInterface::num_atoms_per_cell(void) const
}
//* gets tributary volume for an atom
double LammpsInterface::volume_per_atom(void) const
double LammpsInterface::volume_per_atom() const
{
double naCell = num_atoms_per_cell();
double volPerAtom =
@ -1468,7 +1468,7 @@ LAMMPS_NS::Compute * LammpsInterface::const_to_active(COMPUTE_POINTER computePoi
// compute pe/atom interface methods
// - the only compute "owned" by ATC
// -----------------------------------------------------------------
int LammpsInterface::create_compute_pe_peratom(void) const
int LammpsInterface::create_compute_pe_peratom() const
{
char **list = new char*[4];
string atomPeName = compute_pe_name();
@ -1493,7 +1493,7 @@ int LammpsInterface::create_compute_pe_peratom(void) const
return icompute;
}
double * LammpsInterface::compute_pe_peratom(void) const
double * LammpsInterface::compute_pe_peratom() const
{
if (atomPE_) {
atomPE_->compute_peratom();

14
lib/atc/LinearSolver.cpp
View File

@ -84,7 +84,7 @@ LinearSolver::LinearSolver(
// --------------------------------------------------------------------
// Setup
// --------------------------------------------------------------------
void LinearSolver::setup(void)
void LinearSolver::setup()
{
tol_ = kTol;
nVariables_ = matrix_.nRows();
@ -113,7 +113,7 @@ void LinearSolver::setup(void)
// --------------------------------------------------------------------
// Initialize
// --------------------------------------------------------------------
void LinearSolver::allow_reinitialization(void)
void LinearSolver::allow_reinitialization()
{
if (constraintHandlerType_ == PENALIZE_CONSTRAINTS) {
if (matrixModified_ ) throw ATC_Error("LinearSolver: can't allow reinitialization after matrix has been modified");
@ -157,7 +157,7 @@ void LinearSolver::initialize(const BC_SET * bcs)
// --------------------------------------------------------------------
// initialize_matrix
// --------------------------------------------------------------------
void LinearSolver::initialize_matrix(void)
void LinearSolver::initialize_matrix()
{
if ( initializedMatrix_ ) return;
if (constraintHandlerType_ == PENALIZE_CONSTRAINTS) {
@ -172,7 +172,7 @@ void LinearSolver::initialize_matrix(void)
// --------------------------------------------------------------------
// initialize_inverse
// --------------------------------------------------------------------
void LinearSolver::initialize_inverse(void)
void LinearSolver::initialize_inverse()
{
if ( initializedInverse_ ) return;
if (solverType_ == ITERATIVE_SOLVE_SYMMETRIC
@ -196,7 +196,7 @@ void LinearSolver::initialize_inverse(void)
// --------------------------------------------------------------------
// initialize_rhs
// --------------------------------------------------------------------
void LinearSolver::initialize_rhs(void)
void LinearSolver::initialize_rhs()
{
if (! rhs_ ) return;
if (! bcs_ ) {
@ -215,7 +215,7 @@ void LinearSolver::initialize_rhs(void)
// add matrix penalty
// - change matrix for Dirichlet conditions: add penalty
// --------------------------------------------------------------------
void LinearSolver::add_matrix_penalty(void)
void LinearSolver::add_matrix_penalty()
{
penalty_ = kPenalty; // relative to matrix diagonal
SPAR_MAT & A = matrixCopy_;
@ -233,7 +233,7 @@ void LinearSolver::add_matrix_penalty(void)
// partition matrix
// - partition matrix based on Dirichlet constraints
// --------------------------------------------------------------------
void LinearSolver::partition_matrix(void)
void LinearSolver::partition_matrix()
{
fixedSet_.clear();
BC_SET::const_iterator itr;

6
lib/atc/OutputManager.cpp
View File

@ -172,7 +172,7 @@ void OutputManager::read_restart_file(string fileName, RESTART_LIST *data)
//-----------------------------------------------------------------------------
//*
//-----------------------------------------------------------------------------
void OutputManager::write_globals(void)
void OutputManager::write_globals()
{
if ( outputPrefix_ == "NULL") return;
string file = outputPrefix_ + ".GLOBALS";
@ -224,7 +224,7 @@ void OutputManager::write_geometry(const MATRIX *coordinates,
//-----------------------------------------------------------------------------
//*
//-----------------------------------------------------------------------------
void OutputManager::write_geometry_ensight(void)
void OutputManager::write_geometry_ensight()
{
// geometry based on a reference configuration
string geom_file_name = outputPrefix_ + ".geo";
@ -327,7 +327,7 @@ void OutputManager::write_geometry_ensight(void)
//-----------------------------------------------------------------------------
//*
//-----------------------------------------------------------------------------
void OutputManager::write_geometry_text(void)
void OutputManager::write_geometry_text()
{
if ( outputPrefix_ == "NULL") return;
// geometry based on a reference configuration

16
lib/atc/PerPairQuantity.cpp
View File

@ -18,7 +18,7 @@ PairMap::PairMap(LammpsInterface * lammpsInterface, int groupbit ):
nPairs_(0), nBonds_(0)
{
};
PairMap::~PairMap(void)
PairMap::~PairMap()
{
};
//==========================================================
@ -27,7 +27,7 @@ PairMapNeighbor::PairMapNeighbor(LammpsInterface * lammpsInterface, int groupbit
{
};
void PairMapNeighbor::reset(void) const
void PairMapNeighbor::reset() const
{
int inum = lammpsInterface_->neighbor_list_inum();
int *ilist = lammpsInterface_->neighbor_list_ilist();
@ -90,7 +90,7 @@ PairVirialEulerian::PairVirialEulerian(LammpsInterface * lammpsInterface,
};
void PairVirialEulerian::reset(void) const
void PairVirialEulerian::reset() const
{
int nPairs = pairMap_.size();
quantity_.reset(nPairs,nCols_);
@ -129,7 +129,7 @@ PairVirialLagrangian::PairVirialLagrangian(LammpsInterface * lammpsInterface,
};
void PairVirialLagrangian::reset(void) const
void PairVirialLagrangian::reset() const
{
int nPairs = pairMap_.size();
quantity_.reset(nPairs,nCols_);
@ -181,7 +181,7 @@ PairPotentialHeatFluxEulerian::PairPotentialHeatFluxEulerian(LammpsInterface * l
};
void PairPotentialHeatFluxEulerian::reset(void) const
void PairPotentialHeatFluxEulerian::reset() const
{
int nPairs = pairMap_.size();
quantity_.reset(nPairs,nCols_);
@ -217,7 +217,7 @@ PairPotentialHeatFluxLagrangian::PairPotentialHeatFluxLagrangian(LammpsInterface
};
void PairPotentialHeatFluxLagrangian::reset(void) const
void PairPotentialHeatFluxLagrangian::reset() const
{
int nPairs = pairMap_.size();
quantity_.reset(nPairs,nCols_);
@ -275,7 +275,7 @@ BondMatrixKernel::BondMatrixKernel(LammpsInterface * lammpsInterface,
if (kernelFunction_ == nullptr)
throw ATC_Error("No AtC kernel function initialized");
};
void BondMatrixKernel::reset(void) const
void BondMatrixKernel::reset() const
{
int nPairs = pairMap_.size(); // needs to come after quantity for reset
int nNodes = feMesh_->num_nodes_unique();
@ -328,7 +328,7 @@ BondMatrixPartitionOfUnity::BondMatrixPartitionOfUnity(LammpsInterface * lammpsI
lineWg_[i] *= 0.5;
}
};
void BondMatrixPartitionOfUnity::reset(void) const
void BondMatrixPartitionOfUnity::reset() const
{
int nNodes = feMesh_->num_nodes_unique();
int nPairs = pairMap_.size();

2
lib/atc/PhysicsModel.cpp
View File

@ -108,7 +108,7 @@ void PhysicsModel::parse_material_file(string fileName)
fileId.close();
}
void PhysicsModel::initialize(void)
void PhysicsModel::initialize()
{
// initialize materials
vector< Material* >::const_iterator iter;

2
lib/atc/PoissonSolver.cpp
View File

@ -111,7 +111,7 @@ PoissonSolver::~PoissonSolver()
// --------------------------------------------------------------------
// Initialize
// --------------------------------------------------------------------
void PoissonSolver::initialize(void)
void PoissonSolver::initialize()
{
nNodes_ = feEngine_->num_nodes();

2
lib/atc/PrescribedDataManager.cpp
View File

@ -523,7 +523,7 @@ namespace ATC {
// print
//-------------------------------------------------------------------------
void PrescribedDataManager::print(void)
void PrescribedDataManager::print()
{
// print and check consistency
enum dataType {FREE=0,FIELD,SOURCE};

2
lib/atc/SchrodingerSolver.cpp
View File

@ -735,7 +735,7 @@ double fermi_dirac(const double E, const double T)
else
ATC_Error("schrodinger-poisson solver:too many fixed");
}
GlobalSliceSchrodingerPoissonSolver::~GlobalSliceSchrodingerPoissonSolver(void) {
GlobalSliceSchrodingerPoissonSolver::~GlobalSliceSchrodingerPoissonSolver() {
if (solver_) delete solver_;
}
//--------------------------------------------------------------------------

6
lib/atc/Stress.cpp
View File

@ -237,7 +237,7 @@ StressCubicElastic::StressCubicElastic(fstream &fileId)
}
}
void StressCubicElastic::set_tangent(void)
void StressCubicElastic::set_tangent()
{
C_.reset(6,6);
C_(0,0)=C_(1,1)=C_(2,2) =c11_;
@ -374,7 +374,7 @@ StressCauchyBorn::~StressCauchyBorn()
//==============================================================================
// initialize
//==============================================================================
void StressCauchyBorn::initialize(void)
void StressCauchyBorn::initialize()
{
if (!initialized_) {
if (makeLinear_) linearize();
@ -393,7 +393,7 @@ void StressCauchyBorn::initialize(void)
//==============================================================================
// compute the bond stiffness consistent with the einstein freq
//==============================================================================
double StressCauchyBorn::stiffness(void) const
double StressCauchyBorn::stiffness() const
{
AtomCluster vac;
cblattice_->atom_cluster(eye<double>(3,3), potential_->cutoff_radius(), vac);

2
lib/atc/WeakEquationChargeDiffusion.cpp
View File

@ -19,7 +19,7 @@ WeakEquationChargeDiffusion::WeakEquationChargeDiffusion()
//--------------------------------------------------------------
// Destructor
//--------------------------------------------------------------
WeakEquationChargeDiffusion::~WeakEquationChargeDiffusion(void)
WeakEquationChargeDiffusion::~WeakEquationChargeDiffusion()
{}
//---------------------------------------------------------------------
// compute capacity

2
lib/atc/WeakEquationDiffusion.cpp
View File

@ -19,7 +19,7 @@ WeakEquationDiffusion::WeakEquationDiffusion()
//--------------------------------------------------------------
// Destructor
//--------------------------------------------------------------
WeakEquationDiffusion::~WeakEquationDiffusion(void)
WeakEquationDiffusion::~WeakEquationDiffusion()
{}
//---------------------------------------------------------------------
// compute capacity

4
lib/atc/WeakEquationElectronContinuity.cpp
View File

@ -18,7 +18,7 @@ WeakEquationElectronContinuity::WeakEquationElectronContinuity()
//--------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------
WeakEquationElectronContinuity::~WeakEquationElectronContinuity(void)
WeakEquationElectronContinuity::~WeakEquationElectronContinuity()
{}
//---------------------------------------------------------------------
@ -66,7 +66,7 @@ WeakEquationElectronEquilibrium::WeakEquationElectronEquilibrium()
//--------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------
WeakEquationElectronEquilibrium::~WeakEquationElectronEquilibrium(void)
WeakEquationElectronEquilibrium::~WeakEquationElectronEquilibrium()
{}
//---------------------------------------------------------------------

6
lib/atc/WeakEquationElectronTemperature.cpp
View File

@ -18,7 +18,7 @@ WeakEquationElectronTemperature::WeakEquationElectronTemperature()
//--------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------
WeakEquationElectronTemperature::~WeakEquationElectronTemperature(void)
WeakEquationElectronTemperature::~WeakEquationElectronTemperature()
{}
//---------------------------------------------------------------------
@ -93,7 +93,7 @@ WeakEquationElectronTemperatureJouleHeating::WeakEquationElectronTemperatureJoul
//--------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------
WeakEquationElectronTemperatureJouleHeating::~WeakEquationElectronTemperatureJouleHeating(void)
WeakEquationElectronTemperatureJouleHeating::~WeakEquationElectronTemperatureJouleHeating()
{}
//---------------------------------------------------------------------
@ -162,7 +162,7 @@ WeakEquationElectronTemperatureConvection::WeakEquationElectronTemperatureConvec
//--------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------
WeakEquationElectronTemperatureConvection::~WeakEquationElectronTemperatureConvection(void)
WeakEquationElectronTemperatureConvection::~WeakEquationElectronTemperatureConvection()
{
// do nothing
}

2
lib/atc/WeakEquationMassDiffusion.cpp
View File

@ -19,7 +19,7 @@ WeakEquationMassDiffusion::WeakEquationMassDiffusion()
//--------------------------------------------------------------
// Destructor
//--------------------------------------------------------------
WeakEquationMassDiffusion::~WeakEquationMassDiffusion(void)
WeakEquationMassDiffusion::~WeakEquationMassDiffusion()
{}
//---------------------------------------------------------------------
// compute capacity

4
lib/atc/WeakEquationPhononTemperature.cpp
View File

@ -19,7 +19,7 @@ WeakEquationPhononTemperature::WeakEquationPhononTemperature()
//--------------------------------------------------------------
// Destructor
//--------------------------------------------------------------
WeakEquationPhononTemperature::~WeakEquationPhononTemperature(void)
WeakEquationPhononTemperature::~WeakEquationPhononTemperature()
{}
//---------------------------------------------------------------------
// compute total energy
@ -67,7 +67,7 @@ WeakEquationPhononTemperatureExchange::WeakEquationPhononTemperatureExchange()
//--------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------
WeakEquationPhononTemperatureExchange::~WeakEquationPhononTemperatureExchange(void)
WeakEquationPhononTemperatureExchange::~WeakEquationPhononTemperatureExchange()
{}
//---------------------------------------------------------------------

2
lib/atc/WeakEquationSchrodinger.cpp
View File

@ -18,7 +18,7 @@ WeakEquationSchrodinger::WeakEquationSchrodinger()
//--------------------------------------------------------------
// Destructor
//---------------------------------------------------------------------
WeakEquationSchrodinger::~WeakEquationSchrodinger(void)
WeakEquationSchrodinger::~WeakEquationSchrodinger()
{}
//---------------------------------------------------------------------

4
src/COLVARS/colvarproxy_lammps.cpp
View File

@ -98,10 +98,10 @@ colvarproxy_lammps::colvarproxy_lammps(LAMMPS_NS::LAMMPS *lmp,
// try to extract a restart prefix from a potential restart command.
LAMMPS_NS::Output *outp = _lmp->output;
if ((outp->restart_every_single > 0) && (outp->restart1 != 0)) {
if ((outp->restart_every_single > 0) && (outp->restart1 != nullptr)) {
restart_frequency_engine = outp->restart_every_single;
restart_output_prefix_str = std::string(outp->restart1);
} else if ((outp->restart_every_double > 0) && (outp->restart2a != 0)) {
} else if ((outp->restart_every_double > 0) && (outp->restart2a != nullptr)) {
restart_frequency_engine = outp->restart_every_double;
restart_output_prefix_str = std::string(outp->restart2a);
}

2
src/COLVARS/ndx_group.cpp
View File

@ -121,7 +121,7 @@ void Ndx2Group::command(int narg, char **arg)
} else {
while (1) {
while (true) {
MPI_Bcast(&len,1,MPI_INT,0,world);
if (len < 0) break;
if (len > 1) {

2
src/GPU/fix_nh_gpu.cpp
View File

@ -47,7 +47,7 @@ typedef struct { double x,y,z; } dbl3_t;
FixNHGPU::FixNHGPU(LAMMPS *lmp, int narg, char **arg) :
FixNH(lmp, narg, arg)
{
_dtfm = 0;
_dtfm = nullptr;
_nlocal3 = 0;
_nlocal_max = 0;
}

8
src/GPU/fix_nve_asphere_gpu.cpp
View File

@ -154,11 +154,11 @@ using namespace FixConst;
FixNVEAsphereGPU::FixNVEAsphereGPU(LAMMPS *lmp, int narg, char **arg) :
FixNVE(lmp, narg, arg)
{
_dtfm = 0;
_dtfm = nullptr;
_nlocal_max = 0;
_inertia0 = 0;
_inertia1 = 0;
_inertia2 = 0;
_inertia0 = nullptr;
_inertia1 = nullptr;
_inertia2 = nullptr;
}
/* ---------------------------------------------------------------------- */

8
src/INTEL/fix_nve_asphere_intel.cpp
View File

@ -37,12 +37,12 @@ using namespace FixConst;
FixNVEAsphereIntel::FixNVEAsphereIntel(LAMMPS *lmp, int narg, char **arg) :
FixNVE(lmp, narg, arg)
{
_dtfm = 0;
_dtfm = nullptr;
_nlocal3 = 0;
_nlocal_max = 0;
_inertia0 = 0;
_inertia1 = 0;
_inertia2 = 0;
_inertia0 = nullptr;
_inertia1 = nullptr;
_inertia2 = nullptr;
}
/* ---------------------------------------------------------------------- */

2
src/INTEL/pair_airebo_intel.cpp
View File

@ -570,7 +570,7 @@ void PairAIREBOIntel::eval(
if (EVFLAG)
fix->add_result_array(f_start, ev_global, offload, eatom, 0, vflag);
else
fix->add_result_array(f_start, 0, offload);
fix->add_result_array(f_start, nullptr, offload);
}
/* ---------------------------------------------------------------------- */

2
src/INTEL/pair_dpd_intel.cpp
View File

@ -428,7 +428,7 @@ void PairDPDIntel::eval(const int offload, const int vflag,
if (EFLAG || vflag)
fix->add_result_array(f_start, ev_global, offload, eatom, 0, vflag);
else
fix->add_result_array(f_start, 0, offload);
fix->add_result_array(f_start, nullptr, offload);
}
/* ----------------------------------------------------------------------

4
src/INTEL/pair_eam_intel.cpp
View File

@ -44,7 +44,7 @@ using namespace LAMMPS_NS;
PairEAMIntel::PairEAMIntel(LAMMPS *lmp) : PairEAM(lmp)
{
suffix_flag |= Suffix::INTEL;
fp_float = 0;
fp_float = nullptr;
}
/* ---------------------------------------------------------------------- */
@ -656,7 +656,7 @@ void PairEAMIntel::eval(const int offload, const int vflag,
if (EFLAG || vflag)
fix->add_result_array(f_start, ev_global, offload, eatom, 0, vflag);
else
fix->add_result_array(f_start, 0, offload);
fix->add_result_array(f_start, nullptr, offload);
}
/* ----------------------------------------------------------------------

2
src/INTEL/pair_gayberne_intel.cpp
View File

@ -881,7 +881,7 @@ void PairGayBerneIntel::eval(const int offload, const int vflag,
if (EFLAG || vflag)
fix->add_result_array(f_start, ev_global, offload, eatom, 0, 2);
else
fix->add_result_array(f_start, 0, offload, 0, 0, 2);
fix->add_result_array(f_start, nullptr, offload, 0, 0, 2);
}
/* ---------------------------------------------------------------------- */

2
src/INTEL/pair_lj_charmm_coul_charmm_intel.cpp
View File

@ -448,7 +448,7 @@ void PairLJCharmmCoulCharmmIntel::eval(const int offload, const int vflag,
if (EFLAG || vflag)
fix->add_result_array(f_start, ev_global, offload, eatom, 0, vflag);
else
fix->add_result_array(f_start, 0, offload);
fix->add_result_array(f_start, nullptr, offload);
}
/* ---------------------------------------------------------------------- */

2
src/INTEL/pair_sw_intel.cpp
View File

@ -573,7 +573,7 @@ void PairSWIntel::eval(const int offload, const int vflag,
if (EFLAG || vflag)
fix->add_result_array(f_start, ev_global, offload, eatom, 0, vflag);
else
fix->add_result_array(f_start, 0, offload);
fix->add_result_array(f_start, nullptr, offload);
}
#else

8
src/MDI/mdi_engine.cpp
View File

@ -168,7 +168,7 @@ MDIEngine::MDIEngine(LAMMPS *_lmp, int narg, char ** /*arg*/) : Pointers(_lmp)
node_match = true;
exit_command = false;
while (1) {
while (true) {
// top-level mdi engine only recognizes three nodes
// DEFAULT, INIT_MD, INIT_OPTG
@ -760,7 +760,7 @@ void MDIEngine::mdi_optg()
timer->init();
timer->barrier_start();
while (1) {
while (true) {
update->minimize->run(1);
if (strcmp(mdicmd, "@COORDS") != 0 && strcmp(mdicmd, "@FORCES") != 0) break;
@ -956,9 +956,9 @@ void MDIEngine::create_system()
// optionally set charges if specified by ">CHARGES"
if (flag_velocities)
lammps_create_atoms(lmp, sys_natoms, NULL, sys_types, sys_coords, sys_velocities, NULL, 1);
lammps_create_atoms(lmp, sys_natoms, nullptr, sys_types, sys_coords, sys_velocities, nullptr, 1);
else
lammps_create_atoms(lmp, sys_natoms, NULL, sys_types, sys_coords, NULL, NULL, 1);
lammps_create_atoms(lmp, sys_natoms, nullptr, sys_types, sys_coords, nullptr, nullptr, 1);
if (flag_charges) lammps_scatter_atoms(lmp, (char *) "q", 1, 1, sys_charges);

4
src/PHONON/third_order.cpp
View File

@ -164,8 +164,8 @@ void ThirdOrder::command(int narg, char **arg)
folded = 0;
// set Neigborlist attributes to NULL
ijnum = NULL;
neighbortags = NULL;
ijnum = nullptr;
neighbortags = nullptr;
// read options from end of input line
if (style == REGULAR) options(narg-3,&arg[3]);