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

resolve unused parameter warnings in USER-ATC package

Browse Source
This commit is contained in:
Axel Kohlmeyer
2019-10-20 11:24:13 -04:00
parent 118c2e5be3
commit b705525734
97 changed files with 550 additions and 531 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/atc/ATC_Coupling.cpp
View File

@ -1693,7 +1693,7 @@ namespace ATC {
extrinsicModelManager_.construct_transfers();
}
//--------------------------------------------------
void ATC_Coupling::delete_mass_mat_time_filter(FieldName thisField)
void ATC_Coupling::delete_mass_mat_time_filter(FieldName /* thisField */)
{
}
//--------------------------------------------------

2
lib/atc/ATC_Coupling.h
View File

@ -131,7 +131,7 @@ namespace ATC {
virtual void initialize_mesh_data(void);
// public for FieldIntegrator
bool source_atomic_quadrature(FieldName field)
bool source_atomic_quadrature(FieldName /* field */)
{ return (sourceIntegration_ == FULL_DOMAIN_ATOMIC_QUADRATURE_SOURCE); }
ATC::IntegrationDomainType source_integration()
{ return sourceIntegration_; }

2
lib/atc/ATC_CouplingMomentumEnergy.cpp
View File

@ -319,7 +319,7 @@ namespace ATC {
// modify
// parses inputs and modifies state of the filter
//--------------------------------------------------------
bool ATC_CouplingMomentumEnergy::modify(int narg, char **arg)
bool ATC_CouplingMomentumEnergy::modify(int /* narg */, char ** /* arg */)
{
return false;
}

8
lib/atc/ATC_Method.h
View File

@ -140,9 +140,9 @@ namespace ATC {
/** compute scalar for output */
virtual double compute_scalar() {return 0.;}
/** compute vector for output */
virtual double compute_vector(int n) {return 0.;}
virtual double compute_vector(int /* n */) {return 0.;}
/** compute vector for output */
virtual double compute_array(int irow, int icol) {return 0.;};
virtual double compute_array(int /* irow */, int /* icol */) {return 0.;};
int scalar_flag() const {return scalarFlag_;}
int vector_flag() const {return vectorFlag_;}
int size_vector() const {return sizeVector_;}
@ -398,8 +398,8 @@ namespace ATC {
// /** determine weighting method for atomic integration */
// void compute_consistent_md_mass_matrix(const SPAR_MAT & shapeFunctionMatrix,
// SPAR_MAT & mdMassMatrix);
virtual void compute_md_mass_matrix(FieldName thisField,
DIAG_MAT & massMat) {};
virtual void compute_md_mass_matrix(FieldName /* thisField */,
DIAG_MAT & /* massMat */) {};
/** access to md mass matrices */
DIAG_MAN &mass_mat_md_inv(FieldName thisField)

2
lib/atc/ATC_Transfer.cpp
View File

@ -1658,7 +1658,7 @@ namespace ATC {
}
//--------------------------------------------------------------------
void ATC_Transfer::compute_vacancy_concentration(DENS_MAT & Cv,
const DENS_MAT & H, const DENS_MAT & rhoN)
const DENS_MAT & H, const DENS_MAT & /* rhoN */)
{
int * type = lammpsInterface_->atom_type();
DENS_MAT new_rho(nNodes_,1);

2
lib/atc/ATC_TransferPartitionOfUnity.cpp
View File

@ -54,7 +54,7 @@ namespace ATC {
//-------------------------------------------------------------------
void ATC_TransferPartitionOfUnity::compute_projection(
const DENS_MAT & atomData, DENS_MAT & nodeData)
const DENS_MAT & /* atomData */, DENS_MAT & /* nodeData */)
{
throw ATC_Error("unimplemented function");
}

2
lib/atc/AtomicRegulator.cpp
View File

@ -158,7 +158,7 @@ namespace ATC {
// parses and adjusts controller state based on
// user input, in the style of LAMMPS user input
//--------------------------------------------------------
bool AtomicRegulator::modify(int narg, char **arg)
bool AtomicRegulator::modify(int /* narg */, char **arg)
{
bool foundMatch = false;

35
lib/atc/AtomicRegulator.h
View File

@ -90,7 +90,7 @@ namespace ATC {
/** add output information */
virtual void output(OUTPUT_LIST & outputData) const;
virtual double compute_vector(int n) const {return 0;}
virtual double compute_vector(int /* n */) const {return 0;}
/** final work at the end of a run */
virtual void finish();
@ -123,14 +123,15 @@ namespace ATC {
virtual void pack_fields(RESTART_LIST & data);
/** thermo output */
virtual int size_vector(int s) const {return 0;};
virtual int size_vector(int /* s */) const {return 0;};
// coupling to FE state
/** FE state variable regulator is applied to */
virtual RegulatorTargetType regulator_target() const {return regulatorTarget_;};
/** type of boundary coupling */
//TEMP_JAT field variable should be removed
virtual RegulatorCouplingType coupling_mode(const FieldName field=NUM_TOTAL_FIELDS) const {return couplingMode_;};
virtual RegulatorCouplingType coupling_mode(const FieldName /* field */) const {return couplingMode_;};
virtual RegulatorCouplingType coupling_mode() const {return couplingMode_;};
/** compute the thermal boundary flux, must be consistent with regulator */
virtual void compute_boundary_flux(FIELDS & fields);
/** add contributions (if any) to the finite element right-hand side */
@ -140,7 +141,7 @@ namespace ATC {
/** returns a pointer to the DENS_MAN associated with the tag, creates a new data member if necessary */
DENS_MAN * regulator_data(const std::string tag, int nCols);
/** can externally set regulator dynamic contributions */
virtual void reset_lambda_contribution(const DENS_MAT & target, const FieldName field) {};
virtual void reset_lambda_contribution(const DENS_MAT & /* target */, const FieldName /* field */) {};
virtual void reset_lambda_contribution(const DENS_MAT & target) { reset_lambda_contribution(target,NUM_TOTAL_FIELDS); }
/** returns a const pointer to the DENS_MAN associated with the tag, or NULL */
const DENS_MAN * regulator_data(const std::string tag) const;
@ -291,29 +292,29 @@ namespace ATC {
virtual void reset_nlocal(){};
/** set up atom to material identification */
virtual void reset_atom_materials(const Array<int> & elementToMaterialMap,
const MatrixDependencyManager<DenseMatrix, int> * atomElement){};
virtual void reset_atom_materials(const Array<int> & /* elementToMaterialMap */,
const MatrixDependencyManager<DenseMatrix, int> * /* atomElement */){};
/** applies regulator to atoms in the pre-predictor phase */
virtual void apply_pre_predictor(double dt){};
virtual void apply_pre_predictor(double /* dt */){};
/** applies regulator to atoms in the mid-predictor phase */
virtual void apply_mid_predictor(double dt){};
virtual void apply_mid_predictor(double /* dt */){};
/** applies regulator to atoms in the post-predictor phase */
virtual void apply_post_predictor(double dt){};
virtual void apply_post_predictor(double /* dt */){};
/** applies regulator to atoms in the pre-corrector phase */
virtual void apply_pre_corrector(double dt){};
virtual void apply_pre_corrector(double /* dt */){};
/** applies regulator to atoms in the post-corrector phase */
virtual void apply_post_corrector(double dt){};
virtual void apply_post_corrector(double /* dt */){};
/** applies regulator to atoms in the pre-corrector phase */
virtual void apply_pre_force(double dt){};
virtual void apply_pre_force(double /* dt */){};
/** applies regulator to atoms in the post-corrector phase */
virtual void apply_post_force(double dt){};
virtual void apply_post_force(double /* dt */){};
/** applies regulator in pre-force phase */
virtual void pre_force(){};
@ -328,17 +329,17 @@ namespace ATC {
virtual void compute_boundary_flux(FIELDS & fields);
/** add contributions (if any) to the finite element right-hand side */
virtual void add_to_rhs(FIELDS & rhs){};
virtual void add_to_rhs(FIELDS & /* rhs */){};
/** get data for output */
virtual void output(OUTPUT_LIST & outputData){};
virtual double compute_vector(int n) const {return 0;}
virtual void output(OUTPUT_LIST & /* outputData */){};
virtual double compute_vector(int /* n */) const {return 0;}
/** final work at the end of a run */
virtual void finish(){};
/** pack fields for restart */
virtual void pack_fields(RESTART_LIST & data){};
virtual void pack_fields(RESTART_LIST & /* data */){};
protected:

6
lib/atc/BodyForce.h
View File

@ -18,8 +18,8 @@ namespace ATC {
public:
BodyForce() {};
virtual ~BodyForce() {};
virtual bool body_force(const FIELD_MATS &fields,
DENS_MAT &flux) const { return false; };
virtual bool body_force(const FIELD_MATS & /* fields */,
DENS_MAT & /* flux */) const { return false; };
};
/**
@ -49,7 +49,7 @@ namespace ATC {
class BodyForceElectricField : public BodyForce
{
public:
BodyForceElectricField(std::fstream &matfile,std::map<std::string,double> & parameters)
BodyForceElectricField(std::fstream & /* matfile */,std::map<std::string,double> & /* parameters */)
{ throw ATC_Error("unimplemented due to issues with accessing electric field"); }
virtual ~BodyForceElectricField() {};
virtual bool body_force(const FIELD_MATS &fields,

8
lib/atc/CbPotential.h
View File

@ -40,7 +40,7 @@ namespace ATC
//! @name Pairwise interaction term and derivatives.
//@{
virtual double phi (const double &r) const { return 0.0; }
virtual double phi (const double & /* r */) const { return 0.0; }
virtual double phi_r (const double &r) const;
virtual double phi_rr (const double &r) const;
virtual double phi_rrr(const double &r) const;
@ -48,11 +48,11 @@ namespace ATC
//! @name Embedding terms. Electron cloud density and embedding functions
//@{
virtual double rho (const double &r) const { return 0.0; }
virtual double rho (const double & /* r */) const { return 0.0; }
virtual double rho_r (const double &r) const;
virtual double rho_rr(const double &r) const;
virtual double rho_rrr(const double &r) const;
virtual double F (const double &p) const { return 0.0; }
virtual double F (const double & /* p */) const { return 0.0; }
virtual double F_p (const double &p) const;
virtual double F_pp(const double &p) const;
virtual double F_ppp(const double &p) const;
@ -60,7 +60,7 @@ namespace ATC
//! @name Three-body terms and derivatives
//@{
virtual double phi3 (const double &q) const {return 0.0; }
virtual double phi3 (const double & /* q */) const {return 0.0; }
virtual double phi3_q (const double &q) const;
virtual double phi3_qq(const double &q) const;
//@}

10
lib/atc/ChargeRegulator.cpp
View File

@ -53,7 +53,7 @@ namespace ATC {
// parses and adjusts charge regulator state based on
// user input, in the style of LAMMPS user input
//--------------------------------------------------------
bool ChargeRegulator::modify(int narg, char **arg)
bool ChargeRegulator::modify(int /* narg */, char ** /* arg */)
{
bool foundMatch = false;
return foundMatch;
@ -241,7 +241,7 @@ namespace ATC {
//--------------------------------------------------------
// output
//--------------------------------------------------------
void ChargeRegulatorMethod::output(OUTPUT_LIST & outputData)
void ChargeRegulatorMethod::output(OUTPUT_LIST & /* outputData */)
{
//vector<double> localSum(sum_.size());
//lammpsInteface_->allsum(localSum.pointer,sum_.pointer,sum_.size());
@ -383,7 +383,7 @@ namespace ATC {
//--------------------------------------------------------
// change potential/charge pre-force calculation
//--------------------------------------------------------
void ChargeRegulatorMethodFeedback::apply_pre_force(double dt)
void ChargeRegulatorMethodFeedback::apply_pre_force(double /* dt */)
{
sum_ = 0;
@ -455,7 +455,7 @@ namespace ATC {
//--------------------------------------------------------
// change potential/charge post-force calculation
//--------------------------------------------------------
void ChargeRegulatorMethodImageCharge::apply_post_force(double dt)
void ChargeRegulatorMethodImageCharge::apply_post_force(double /* dt */)
{
sum_ = 0;
apply_local_forces();
@ -644,7 +644,7 @@ namespace ATC {
//--------------------------------------------------------
// add effective forces post LAMMPS force call
//--------------------------------------------------------
void ChargeRegulatorMethodEffectiveCharge::apply_post_force(double dt)
void ChargeRegulatorMethodEffectiveCharge::apply_post_force(double /* dt */)
{
apply_local_forces();
}

6
lib/atc/ChargeRegulator.h
View File

@ -65,7 +65,7 @@ namespace ATC {
virtual void apply_pre_force(double dt);
virtual void apply_post_force(double dt);
virtual void output(OUTPUT_LIST & outputData) const;
virtual double compute_vector(int n) const {return 0;} // TODO
virtual double compute_vector(int /* n */) const {return 0;} // TODO
void assign_poisson_solver(PoissonSolver * solver) { poissonSolver_ = solver;}
PoissonSolver * poisson_solver(void) { return poissonSolver_;}
@ -97,8 +97,8 @@ namespace ATC {
~ChargeRegulatorMethod(){};
virtual void initialize(void);
void set_greens_functions();
virtual void apply_pre_force(double dt){};
virtual void apply_post_force(double dt){};
virtual void apply_pre_force(double /* dt */){};
virtual void apply_post_force(double /* dt */){};
virtual void set_weights() {};
const DENS_VEC & total_influence() const { return sum_;}
virtual void output(OUTPUT_LIST & outputData);

6
lib/atc/CloneVector.h
View File

@ -72,7 +72,7 @@ CloneVector<T>::CloneVector(const Matrix<T> &c, int dim, INDEX idx)
// Construct from a DiagonalMatrix
//-----------------------------------------------------------------------------
template<typename T>
CloneVector<T>::CloneVector(const DiagonalMatrix<T> &c, INDEX idx)
CloneVector<T>::CloneVector(const DiagonalMatrix<T> &c, INDEX /* idx */)
: Vector<T>(), _baseV(NULL), _baseM(const_cast<DiagonalMatrix<T>*>(&c))
, _clone_type(CLONE_DIAG), _idx(0)
{}
@ -80,7 +80,7 @@ CloneVector<T>::CloneVector(const DiagonalMatrix<T> &c, INDEX idx)
// value (const) indexing operator
//-----------------------------------------------------------------------------
template<typename T>
T CloneVector<T>::operator()(INDEX i, INDEX j) const
T CloneVector<T>::operator()(INDEX i, INDEX /* j */) const
{
return (*this)[i];
}
@ -88,7 +88,7 @@ T CloneVector<T>::operator()(INDEX i, INDEX j) const
// reference index operator
//-----------------------------------------------------------------------------
template<typename T>
T& CloneVector<T>::operator()(INDEX i, INDEX j)
T& CloneVector<T>::operator()(INDEX i, INDEX /* j */)
{
return (*this)[i];
}

8
lib/atc/ConcentrationRegulator.cpp
View File

@ -47,7 +47,7 @@ const double kMinScale_ = 10000.;
// parses and adjusts charge regulator state based on
// user input, in the style of LAMMPS user input
//--------------------------------------------------------
bool ConcentrationRegulator::modify(int narg, char **arg)
bool ConcentrationRegulator::modify(int /* narg */, char ** /* arg */)
{
bool foundMatch = false;
return foundMatch;
@ -166,7 +166,7 @@ const double kMinScale_ = 10000.;
//--------------------------------------------------------
// size vector
//--------------------------------------------------------
int ConcentrationRegulator::size_vector(int i) const
int ConcentrationRegulator::size_vector(int /* i */) const
{
int n = (regulators_.size())*5;
if (n==0) n = 20;
@ -319,7 +319,7 @@ const double kMinScale_ = 10000.;
//--------------------------------------------------------
// accept
//--------------------------------------------------------
bool ConcentrationRegulatorMethodTransition::accept(double energy, double T) const
bool ConcentrationRegulatorMethodTransition::accept(double energy, double /* T */) const
{
#ifdef ATC_VERBOSE2
if (energy < maxEnergy_) lammpsInterface_->print_msg(" energy "+to_string(energy)+" "+to_string(rngCounter_));
@ -423,7 +423,7 @@ const double kMinScale_ = 10000.;
int * tag = lammpsInterface_->atom_tag();
for (itr = list.begin(); itr != list.end(); itr++) {
int atag = tag[itr->second];
double d = abs(atag-r);
double d = fabs(atag-r);
if (d < min) {
min = d;
idx = i;

20
lib/atc/ConcentrationRegulator.h
View File

@ -60,19 +60,19 @@ namespace ATC {
//WIP_JAT need a nicer way to consistently handle sets of regulators, not sure how yet
// application steps
/** apply the regulator in the pre-predictor phase */
virtual void apply_pre_predictor(double dt, int timeStep){};
virtual void apply_pre_predictor(double /* dt */, int /* timeStep */){};
/** apply the regulator in the mid-predictor phase */
virtual void apply_mid_predictor(double dt, int timeStep){};
virtual void apply_mid_predictor(double /* dt */, int /* timeStep */){};
/** apply the regulator in the post-predictor phase */
virtual void apply_post_predictor(double dt, int timeStep){};
virtual void apply_post_predictor(double /* dt */, int /* timeStep */){};
/** apply the regulator in the pre-correction phase */
virtual void apply_pre_corrector(double dt, int timeStep){};
virtual void apply_pre_corrector(double /* dt */, int /* timeStep */){};
/** apply the regulator in the post-correction phase */
virtual void apply_post_corrector(double dt, int timeStep){};
virtual void apply_post_corrector(double /* dt */, int /* timeStep */){};
/** compute the thermal boundary flux, must be consistent with regulator */
virtual void compute_boundary_flux(FIELDS & fields){};
virtual void compute_boundary_flux(FIELDS & /* fields */){};
/** add contributions (if any) to the finite element right-hand side */
virtual void add_to_rhs(FIELDS & rhs){};
virtual void add_to_rhs(FIELDS & /* rhs */){};
/** prior to exchanges */
virtual void pre_force();
@ -113,8 +113,8 @@ namespace ATC {
virtual void pre_exchange() {};
virtual void finish() {};
virtual void set_weights() {};
virtual double compute_vector(int n) const { return 0;}
virtual void output(OUTPUT_LIST & outputData){};
virtual double compute_vector(int /* n */) const { return 0;}
virtual void output(OUTPUT_LIST & /* outputData */){};
private:
ConcentrationRegulatorMethod(); // DO NOT define this
};
@ -144,7 +144,7 @@ namespace ATC {
virtual double compute_vector(int n) const;
protected:
/** set transition state: epsilon and charge */
int mask(int type, int groupbit) {return 0;}
int mask(int /* type */, int /* groupbit */) {return 0;}
int count(void) const;
int excess(void) const;
double energy(int id) const;

8
lib/atc/DenseVector.h
View File

@ -31,8 +31,10 @@ public:
// overloaded inline virtual functions
T operator[](INDEX i) const { VICK(i) return _data[i]; }
T& operator[](INDEX i) { VICK(i) return _data[i]; }
T operator()(INDEX i, INDEX j=0) const { VICK(i) return _data[i]; }
T& operator()(INDEX i, INDEX j=0) { VICK(i) return _data[i]; }
T operator()(INDEX i, INDEX /* j */) const { VICK(i) return _data[i]; }
T& operator()(INDEX i, INDEX /* j */) { VICK(i) return _data[i]; }
T operator()(INDEX i) const { VICK(i) return _data[i]; }
T& operator()(INDEX i) { VICK(i) return _data[i]; }
void set_all_elements_to(const T &v) {
int sz = this->size();
for (INDEX i = 0; i < sz; i++) _data[i] = v;
@ -62,7 +64,7 @@ private:
// resizes the matrix and optionally copies over what still fits, ignores cols
//-----------------------------------------------------------------------------
template <typename T>
void DenseVector<T>::resize(INDEX rows, INDEX cols, bool copy)
void DenseVector<T>::resize(INDEX rows, INDEX /* cols */, bool copy)
{
if (_size==rows) return; // if is correct size, done
if (!copy)

13
lib/atc/DiagonalMatrix.h
View File

@ -49,7 +49,8 @@ class DiagonalMatrix : public Matrix<T>
void write_restart(FILE *f) const;
// Dump matrix contents to screen (not defined for all datatypes)
std::string to_string(int p=myPrecision) const { return _data->to_string(); }
std::string to_string(int /* p */) const { return _data->to_string(); }
std::string to_string() const { return _data->to_string(); }
using Matrix<T>::matlab;
void matlab(std::ostream &o, const std::string &s="D") const;
@ -78,8 +79,8 @@ class DiagonalMatrix : public Matrix<T>
protected:
void _set_equal(const Matrix<T> &r);
DiagonalMatrix& operator=(const Vector<T> &c) {}
DiagonalMatrix& operator=(const Matrix<T> &c) {}
DiagonalMatrix& operator=(const Vector<T> /* &c */) {}
DiagonalMatrix& operator=(const Matrix<T> /* &c */) {}
private:
void _delete();
@ -246,7 +247,7 @@ void DiagonalMatrix<T>::_delete()
// resizes the matrix, ignores nCols, optionally zeros
//-----------------------------------------------------------------------------
template<typename T>
void DiagonalMatrix<T>::reset(INDEX rows, INDEX cols, bool zero)
void DiagonalMatrix<T>::reset(INDEX rows, INDEX /* cols */, bool zero)
{
_delete();
_data = new DenseVector<T>(rows, zero);
@ -255,7 +256,7 @@ void DiagonalMatrix<T>::reset(INDEX rows, INDEX cols, bool zero)
// resizes the matrix, ignores nCols, optionally copies what fits
//-----------------------------------------------------------------------------
template<typename T>
void DiagonalMatrix<T>::resize(INDEX rows, INDEX cols, bool copy)
void DiagonalMatrix<T>::resize(INDEX rows, INDEX /* cols */, bool copy)
{
_data->resize(rows, copy);
}
@ -327,7 +328,7 @@ void DiagonalMatrix<T>::shallowreset(const DenseMatrix<T> &c)
// reference indexing operator - must throw an error if i!=j
//-----------------------------------------------------------------------------
template<typename T>
T& DiagonalMatrix<T>::operator()(INDEX i, INDEX j)
T& DiagonalMatrix<T>::operator()(INDEX i, INDEX /* j */)
{
GCK(*this,*this,i!=j,"DiagonalMatrix: tried to index off diagonal");
return (*this)[i];

6
lib/atc/ElasticTimeIntegrator.cpp
View File

@ -27,7 +27,7 @@ namespace ATC {
// modify
// parses inputs and modifies state of the integrator
//--------------------------------------------------------
bool MomentumTimeIntegrator::modify(int narg, char **arg)
bool MomentumTimeIntegrator::modify(int /* narg */, char **arg)
{
bool foundMatch = false;
int argIndex = 0;
@ -611,7 +611,7 @@ namespace ATC {
// compute_velocity_delta
//--------------------------------------------------------
void ElasticTimeIntegratorFractionalStep::compute_velocity_delta(const DENS_MAT & atomicMomentumDelta,
double dt)
double /* dt */)
{
DENS_MAT & myAtomicVelocityDelta(atomicVelocityDelta_.set_quantity());
myAtomicVelocityDelta = nodalAtomicMomentumOld_ + atomicMomentumDelta;
@ -832,7 +832,7 @@ namespace ATC {
// compute_velocity_delta
//--------------------------------------------------------
void FluidsTimeIntegratorGear::compute_velocity_delta(const DENS_MAT & atomicMomentumDelta,
double dt)
double /* dt */)
{
DENS_MAT & myAtomicVelocityDelta(atomicVelocityDelta_.set_quantity());
myAtomicVelocityDelta = nodalAtomicMomentumOld_ + atomicMomentumDelta;

2
lib/atc/ElectronChargeDensity.cpp
View File

@ -14,7 +14,7 @@ using std::vector;
namespace ATC {
ElectronChargeDensityInterpolation::ElectronChargeDensityInterpolation(
fstream &fileId, map<string,double> & parameters)
fstream &fileId, map<string,double> & /* parameters */)
: ElectronChargeDensity(), n_()
{
if (!fileId.is_open()) throw ATC_Error("cannot open material file");

22
lib/atc/ElectronChargeDensity.h
View File

@ -21,17 +21,17 @@ namespace ATC {
public:
ElectronChargeDensity() {};
virtual ~ElectronChargeDensity() {};
virtual bool electron_charge_density(const FIELD_MATS &fields,
DENS_MAT &flux) const { return false; };
virtual bool electron_charge_density(const FIELD_MATS & /* fields */,
DENS_MAT & /* flux */) const { return false; };
virtual void D_electron_charge_density(const FieldName fieldName,
const FIELD_MATS &fields,
DENS_MAT &flux) const
virtual void D_electron_charge_density(const FieldName /* fieldName */,
const FIELD_MATS & /* fields */,
DENS_MAT & /* flux */) const
{ throw ATC_Error("Charge density D_electron_charge_density unimplemented function");}
virtual void band_edge_potential(const FIELD_MATS &fields,
DENS_MAT &density) const
virtual void band_edge_potential(const FIELD_MATS & /* fields */,
DENS_MAT & /* density */) const
{ throw ATC_Error("Charge density band_edge_potential unimplemented function");}
};
//-----------------------------------------------------------------------
@ -58,7 +58,7 @@ namespace ATC {
flux *= -1.;
return true;
};
virtual void D_electron_charge_density(const FieldName field,
virtual void D_electron_charge_density(const FieldName /* field */,
const FIELD_MATS &fields,
DENS_MAT &coef) const
{
@ -94,7 +94,7 @@ namespace ATC {
flux *= -C_;
return true;
};
virtual void D_electron_charge_density(const FieldName field,
virtual void D_electron_charge_density(const FieldName /* field */,
const FIELD_MATS &fields,
DENS_MAT &coef) const
{
@ -150,7 +150,7 @@ namespace ATC {
density *= -1.;
return true;
};
virtual void D_electron_charge_density(const FieldName field,
virtual void D_electron_charge_density(const FieldName /* field */,
const FIELD_MATS &fields,
DENS_MAT &coef) const
{
@ -235,7 +235,7 @@ namespace ATC {
}
return true;
};
virtual void D_electron_charge_density(const FieldName fieldName,
virtual void D_electron_charge_density(const FieldName /* fieldName */,
const FIELD_MATS &fields,
DENS_MAT &coef) const
{

2
lib/atc/ElectronDragPower.cpp
View File

@ -39,7 +39,7 @@ ElectronDragPowerLinear::ElectronDragPowerLinear(fstream &fileId,
}
bool ElectronDragPowerLinear::electron_drag_power(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
const GRAD_FIELD_MATS & /* gradFields */,
DENS_MAT & flux)
{

6
lib/atc/ElectronDragPower.h
View File

@ -21,9 +21,9 @@ namespace ATC {
ElectronDragPower() {};
virtual ~ElectronDragPower() {};
/** computes drag power */
virtual bool electron_drag_power(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT & flux)
virtual bool electron_drag_power(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & /* gradFields */,
DENS_MAT & /* flux */)
{
return false;
};

2
lib/atc/ElectronFlux.cpp
View File

@ -79,7 +79,7 @@ ElectronFluxThermopower::ElectronFluxThermopower(
}
ElectronFluxConvection::ElectronFluxConvection(
fstream &fileId, map<string,double> & parameters)
fstream &fileId, map<string,double> & /* parameters */)
: ElectronFlux()
{
if (!fileId.is_open()) throw ATC_Error("cannot open material file");

4
lib/atc/ElectronFlux.h
View File

@ -19,7 +19,7 @@ namespace ATC {
virtual ~ElectronFlux() {};
/** computes flux */
virtual void electron_flux(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
const GRAD_FIELD_MATS & /* gradFields */,
DENS_MAT_VEC &flux)
{
@ -211,7 +211,7 @@ namespace ATC {
ElectronFluxConvection(std::fstream &matfile,std::map<std::string,double> & parameters);
virtual ~ElectronFluxConvection() {};
virtual void electron_flux(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
const GRAD_FIELD_MATS & /* gradFields */,
DENS_MAT_VEC &flux)
{
// flux = n v

4
lib/atc/ElectronHeatCapacity.h
View File

@ -51,7 +51,7 @@ namespace ATC {
capacity = electronHeatCapacity_;
};
virtual void D_electron_heat_capacity(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
const GRAD_FIELD_MATS & /* gradFields */,
DENS_MAT_VEC & Dcapacity)
{
FIELD_MATS::const_iterator etField = fields.find(ELECTRON_TEMPERATURE);
@ -91,7 +91,7 @@ namespace ATC {
const DENS_MAT & T = etField->second;
capacity = electronHeatCapacity_*T;
};
virtual void D_electron_heat_capacity(const FIELD_MATS &fields,
virtual void D_electron_heat_capacity(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &Dcapacity)
{

4
lib/atc/ElectronHeatFlux.h
View File

@ -21,7 +21,7 @@ namespace ATC {
virtual ~ElectronHeatFlux() {};
/** computes heat flux */
virtual void electron_heat_flux(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
const GRAD_FIELD_MATS & /* gradFields */,
DENS_MAT_VEC &flux)
{
@ -70,7 +70,7 @@ namespace ATC {
ElectronHeatFluxLinear(std::fstream &matfile,std::map<std::string,double> & parameters,
/*const*/ ElectronHeatCapacity * electronHeatCapacity = NULL);
virtual ~ElectronHeatFluxLinear() {};
virtual void electron_heat_flux(const FIELD_MATS &fields,
virtual void electron_heat_flux(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &flux)
{

4
lib/atc/ElectronPhononExchange.h
View File

@ -21,8 +21,8 @@ namespace ATC {
ElectronPhononExchange() {};
virtual ~ElectronPhononExchange() {};
/** computes heat capacity */
virtual bool electron_phonon_exchange(const FIELD_MATS &fields,
DENS_MAT &flux) { return false; }
virtual bool electron_phonon_exchange(const FIELD_MATS & /* fields */,
DENS_MAT & /* flux */) { return false; }
};
//-------------------------------------------------------------------

4
lib/atc/ExtrinsicModel.cpp
View File

@ -114,7 +114,7 @@ namespace ATC {
ATC::LammpsInterface::instance()->print_msg_once(ss.str());
myModel = new ExtrinsicModelElectrostatic
(this,modelType,matFileName);
}
} else myModel = NULL;
extrinsicModels_.push_back(myModel);
// add new fields to fields data
@ -339,7 +339,7 @@ namespace ATC {
//--------------------------------------------------------
ExtrinsicModel::ExtrinsicModel(ExtrinsicModelManager * modelManager,
ExtrinsicModelType modelType,
string matFileName) :
string /* matFileName */) :
atc_(modelManager->atc()),
modelManager_(modelManager),
modelType_(modelType),

10
lib/atc/ExtrinsicModel.h
View File

@ -221,7 +221,7 @@ namespace ATC {
virtual ~ExtrinsicModel();
/** parser/modifier */
virtual bool modify(int narg, char **arg) {return false;};
virtual bool modify(int /* narg */, char ** /* arg */) {return false;};
/** construct transfers needed by the model */
virtual void construct_transfers(){};
@ -230,11 +230,11 @@ namespace ATC {
virtual void initialize();
/** set up LAMMPS display variables */
virtual int size_vector(int externalSize) {return 0;};
virtual int size_vector(int /* externalSize */) {return 0;};
/** get LAMMPS display variables */
virtual double compute_scalar(void) { return 0.0; }
virtual bool compute_vector(int n, double & value) {return false;};
virtual bool compute_vector(int /* n */, double & /* value */) {return false;};
/** post integration run */
// is this called at end of run or simulation
@ -259,10 +259,10 @@ namespace ATC {
virtual void post_final_integrate(){};
/** Set sources to AtC equation */
virtual void set_sources(FIELDS & fields, FIELDS & sources){};
virtual void set_sources(FIELDS & /* fields */, FIELDS & /* sources */){};
/** Add model-specific output data */
virtual void output(OUTPUT_LIST & outputData){};
virtual void output(OUTPUT_LIST & /* outputData */){};
/** get the fields and their sizes */
void num_fields(std::map<FieldName,int> & fieldSizes);

2
lib/atc/ExtrinsicModelElectrostatic.cpp
View File

@ -827,7 +827,7 @@ namespace ATC {
// apply_charged_surfaces
//--------------------------------------------------------
void ExtrinsicModelElectrostatic::apply_charged_surfaces
(MATRIX & potential)
(MATRIX & /* potential */)
{
//double qE2f = LammpsInterface::instance()->qe2f();
double qV2e = LammpsInterface::instance()->qv2e();

6
lib/atc/FE_Engine.cpp
View File

@ -721,7 +721,7 @@ namespace ATC{
const SPAR_MAT &N,
const SPAR_MAT_VEC &dN,
SPAR_MAT &tangent,
const DenseMatrix<bool> *elementMask ) const
const DenseMatrix<bool> * /* elementMask */ ) const
{
int nn = nNodesUnique_;
FieldName rowField = row_col.first;
@ -1298,7 +1298,7 @@ namespace ATC{
const PhysicsModel * physicsModel,
const Array<int> & elementMaterials,
FIELDS &rhs,
bool freeOnly,
bool /* freeOnly */,
const DenseMatrix<bool> *elementMask) const
{
vector<FieldName> usedFields;
@ -2503,7 +2503,7 @@ namespace ATC{
// previously computed nodal sources
//-----------------------------------------------------------------
void FE_Engine::add_sources(const Array<bool> &fieldMask,
const double time,
const double /* time */,
const FIELDS &sources,
FIELDS &nodalSources) const
{

5
lib/atc/FE_Engine.h
View File

@ -345,7 +345,7 @@ namespace ATC {
/** integrate a nodal field over an face set */
DENS_VEC integrate(const DENS_MAT &field, const FSET & fset) const
DENS_VEC integrate(const DENS_MAT & /* field */, const FSET & /* fset */) const
{ throw ATC_Error(FILELINE,"unimplemented function"); }
/*@}*/
@ -496,7 +496,8 @@ namespace ATC {
/** set kernel */
void set_kernel(KernelFunction* ptr);
KernelFunction *kernel(int i=0) { return kernelFunction_; }
KernelFunction *kernel(int /* i */) { return kernelFunction_; }
KernelFunction *kernel() { return kernelFunction_; }
private:
//----------------------------------------------------------------

7
lib/atc/FE_Mesh.cpp
View File

@ -797,7 +797,7 @@ namespace ATC {
{
int node = element_connectivity_unique(ielem, inode);
nodeSet.insert(node);
inode++;
inode++; // XXX: is this correct?
}
}
}
@ -832,7 +832,7 @@ namespace ATC {
{
int node = element_connectivity_unique(ielem, inode);
nodeSet.erase(node);
inode++;
inode++; // XXX: is this correct?
}
}
}
@ -1788,7 +1788,7 @@ namespace ATC {
// -------------------------------------------------------------
// setup_periodicity
// -------------------------------------------------------------
void FE_3DMesh::setup_periodicity(double tol)
void FE_3DMesh::setup_periodicity(double /* tol */)
{
// unique <-> global id maps
globalToUniqueMap_.reset(nNodes_);
@ -2119,7 +2119,6 @@ namespace ATC {
// divide between all processors, we get the next-highest
// power of 2.
vector<vector<int> > procEltLists = tree_->getElemIDs(depth);
int numEltLists = procEltLists.size();
// Make sure the KD tree is behaving as expected.
assert(numEltLists >= nProcs);

2
lib/atc/FE_Mesh.h
View File

@ -691,7 +691,7 @@ namespace ATC {
void departition_mesh(void);
virtual void element_size(const int ielem,
virtual void element_size(const int /* ielem */,
double &hx, double &hy, double &hz)
{ hx = L_[0]/n_[0]; hy = L_[1]/n_[1]; hz = L_[2]/n_[2]; }

10
lib/atc/FieldEulerIntegrator.cpp
View File

@ -46,7 +46,7 @@ FieldExplicitEulerIntegrator::FieldExplicitEulerIntegrator(
// --------------------------------------------------------------------
// update
// --------------------------------------------------------------------
void FieldExplicitEulerIntegrator::update(const double dt, double time,
void FieldExplicitEulerIntegrator::update(const double dt, double /* time */,
FIELDS & fields, FIELDS & rhs)
{
// write and add update mass matrix to handled time variation
@ -81,7 +81,7 @@ FieldImplicitEulerIntegrator::FieldImplicitEulerIntegrator(
// update
// --------------------------------------------------------------------
void FieldImplicitEulerIntegrator::update(const double dt, double time,
FIELDS & fields, FIELDS & rhs)
FIELDS & fields, FIELDS & /* rhs */)
{ // solver handles bcs
FieldImplicitSolveOperator solver(atc_,
fields, fieldName_, rhsMask_, physicsModel_,
@ -127,8 +127,8 @@ FieldImplicitDirectEulerIntegrator::~FieldImplicitDirectEulerIntegrator()
// --------------------------------------------------------------------
// initialize
// --------------------------------------------------------------------
void FieldImplicitDirectEulerIntegrator::initialize(const double dt, double time,
FIELDS & fields)
void FieldImplicitDirectEulerIntegrator::initialize(const double dt, double /* time */,
FIELDS & /* fields */)
{
std::pair<FieldName,FieldName> p(fieldName_,fieldName_);
Array2D <bool> rmask = atc_->rhs_mask();
@ -140,7 +140,7 @@ void FieldImplicitDirectEulerIntegrator::initialize(const double dt, double time
// --------------------------------------------------------------------
// update
// --------------------------------------------------------------------
void FieldImplicitDirectEulerIntegrator::update(const double dt, double time,
void FieldImplicitDirectEulerIntegrator::update(const double /* dt */, double /* time */,
FIELDS & fields, FIELDS & rhs)
{
atc_->compute_rhs_vector(rhsMask_, fields, rhs,

4
lib/atc/FieldEulerIntegrator.h
View File

@ -41,8 +41,8 @@ class FieldEulerIntegrator {
virtual ~FieldEulerIntegrator() {};
/** initialize */
virtual void initialize(const double dt, const double time,
FIELDS & fields) {};
virtual void initialize(const double /* dt */, const double /* time */,
FIELDS & /* fields */) {};
/** update */
virtual void update(const double dt, const double time,

2
lib/atc/FieldManager.cpp
View File

@ -298,7 +298,7 @@ typedef PerAtomQuantity<double> PAQ;
//-----------------------------------------------------------------------------
//* REFERENCE_POTENTIAL_ENERGY
//-----------------------------------------------------------------------------
DENS_MAN * FieldManager::reference_potential_energy(string name)
DENS_MAN * FieldManager::reference_potential_energy(string /* name */)
{
DENS_MAN * rpe = interscaleManager_.dense_matrix(field_to_string(REFERENCE_POTENTIAL_ENERGY));
if (! rpe ) {

2
lib/atc/FieldManager.h
View File

@ -123,7 +123,7 @@ namespace ATC {
DENS_MAN * projected_atom_quantity(FieldName field,std::string name, PAQ * atomic, DIAG_MAN * normalization = NULL);
DENS_MAN * scaled_projected_atom_quantity(FieldName field,std::string name, PAQ * atomic, double scale, DIAG_MAN * normalization = NULL);
DENS_MAN * referenced_projected_atom_quantity(FieldName field, std::string name, PAQ * atomic, DENS_MAN * reference, DIAG_MAN * normalization = NULL);
DENS_MAN * inferred_atom_quantity(FieldName field, std::string name, PAQ * atomic){return NULL;};
DENS_MAN * inferred_atom_quantity(FieldName /* field */, std::string /* name */, PAQ * /* atomic */){return NULL;};
PAQ * prolonged_field(FieldName field);
private:
FieldManager(void);

8
lib/atc/Function.cpp
View File

@ -16,7 +16,7 @@ namespace ATC {
//====================================================================
// UXT_Function
//===================================================================
UXT_Function::UXT_Function(int narg, double* args) { }
UXT_Function::UXT_Function(int /* narg */, double* /* args */) { }
//====================================================================
// UXT_Function_Mgr
//====================================================================
@ -312,7 +312,7 @@ XT_Function_Mgr * XT_Function_Mgr::myInstance_ = NULL;
}
ATC::LammpsInterface::instance()->print_msg_once(ss.str());
}
double PiecewiseLinearFunction::f(double * x, double t)
double PiecewiseLinearFunction::f(double * x, double /* t */)
{
double s = mask[0]*(x[0]-x0[0])+mask[1]*(x[1]-x0[1])+mask[2]*(x[2]-x0[2]);
@ -355,7 +355,7 @@ XT_Function_Mgr * XT_Function_Mgr::myInstance_ = NULL;
return slope[0]*(x[0]-x0[0])+slope[1]*(x[1]-x0[1])+slope[2]*(x[2]-x0[2]) + C0;
}
double LinearTemporalRamp::dfdt(double* x, double t) {
double LinearTemporalRamp::dfdt(double* x, double /* t */) {
return mask_slope[0]*(x[0]-x0[0])+mask_slope[1]*(x[1]-x0[1])+mask_slope[2]*(x[2]-x0[2]) + C0_slope;
}
@ -499,7 +499,7 @@ XT_Function_Mgr * XT_Function_Mgr::myInstance_ = NULL;
if (i == 0) { dx = xs_(1)-xs_(0); }
else if (i+1 == npts_) { dx = xs_(npts_-1)-xs_(npts_-2); }
else { dx= 0.5*(xs_(i+1)-xs_(i-1)); }
if (abs(dx-dx0) > 1.e-8) throw ATC_Error("InterpolationFunction::initialize non-uniform data spacing not handled currently");
if (fabs(dx-dx0) > 1.e-8) throw ATC_Error("InterpolationFunction::initialize non-uniform data spacing not handled currently");
fps_(i) *= dx;
}
// options: calculate / adjust tangents for monotonicity

38
lib/atc/Function.h
View File

@ -29,8 +29,8 @@ namespace ATC {
virtual inline ARG_NAMES args(void) {ARG_NAMES names; return names;};
/** (1st) derivative of function wrt to a field */
virtual inline double dfd(FieldName field, ARGS& args ) {return 0.0;};
virtual inline void dfd(FieldName field, ARGS& args, DENS_MAT vals ) {};
virtual inline double dfd(FieldName /* field */, ARGS& /* args */) {return 0.0;};
virtual inline void dfd(FieldName /* field */, ARGS& /* args */, DENS_MAT /* vals */ ) {};
// addl: d2fd2(field1, field2, args), linearization(), grad_args
@ -70,8 +70,8 @@ namespace ATC {
LinearFieldFunction(int nargs, char** args);
virtual ~LinearFieldFunction(void) {};
inline double f(double* u, double* x, double t) {return c1_*u[0]-c0_;}
inline double dfd(FieldName field, ARGS& args) {return c1_;}
inline double f(double* u, double* /* x */, double /* t */) {return c1_*u[0]-c0_;}
inline double dfd(FieldName /* field */, ARGS& /* args */) {return c1_;}
private :
double c0_,c1_;
@ -90,9 +90,9 @@ namespace ATC {
const std::string & tag() { return tag_;}
/** function value */
virtual inline double f(double * u, double* x, double t) {return 0.0;};
virtual inline double f(double * /* u */, double* /* x */, double /* t */) {return 0.0;};
/** derivative of function wrt to field */
virtual inline double dfdu(double * u, double* x, double t) {return 0.0;};
virtual inline double dfdu(double * /* u */, double* /* x */, double /* t */) {return 0.0;};
protected:
/** tag : name of function */
@ -136,8 +136,8 @@ namespace ATC {
//inline double f(double* u, double* x, double t) {return c1_*(u[0]-c0_);}
inline double f(double* u, double* x, double t) {return c1_*u[0]+c0_;}
inline double dfdu(double* u, double* x, double t) {return c1_;}
inline double f(double* u, double* /* x */, double /* t */) {return c1_*u[0]+c0_;}
inline double dfdu(double* /* u */, double* /* x */, double /* t */) {return c1_;}
private :
double c0_,c1_;
@ -156,13 +156,13 @@ namespace ATC {
const std::string & tag() { return tag_;}
/** function value */
virtual inline double f(double* x, double t) {return 0.0;};
virtual inline double f(double* /* x */, double /* t */) {return 0.0;};
/** time derivative of function */
virtual inline double dfdt(double* x, double t) {return 0.0;};
virtual inline double dfdt(double* /* x */, double /* t */) {return 0.0;};
/** 2nd time derivative of function */
virtual inline double ddfdt(double* x, double t) {return 0.0;};
virtual inline double ddfdt(double* /* x */, double /* t */) {return 0.0;};
/** 3rd time derivative of function */
virtual inline double dddfdt(double* x, double t) {return 0.0;};
virtual inline double dddfdt(double* /* x */, double /* t */) {return 0.0;};
protected:
/** mask : masks x,y,z dependence, x0 : origin */
@ -210,7 +210,7 @@ namespace ATC {
ConstantFunction(double arg);
virtual ~ConstantFunction(void) {};
inline double f(double* x, double t)
inline double f(double* /* x */, double /* t */)
{return C0;};
private :
@ -227,7 +227,7 @@ namespace ATC {
LinearFunction(int nargs, double* args);
virtual ~LinearFunction(void) {};
double f(double* x, double t)
double f(double* x, double /* t */)
{return mask[0]*(x[0]-x0[0])+mask[1]*(x[1]-x0[1])+mask[2]*(x[2]-x0[2]) + C0;};
private :
@ -280,7 +280,7 @@ namespace ATC {
QuadraticFunction(int nargs, double* args);
virtual ~QuadraticFunction(void) {};
inline double f(double* x, double t)
inline double f(double* x, double /* t */)
{return
C2[0]*(x[0]-x0[0])*(x[0]-x0[0])+
C2[1]*(x[1]-x0[1])*(x[1]-x0[1])+
@ -324,7 +324,7 @@ namespace ATC {
virtual ~GaussianFunction(void){};
// 1/(2 pi \sigma)^(n/2) exp(-1/2 x.x/\sigma^2 ) for n = dimension
inline double f(double* x, double t)
inline double f(double* x, double /* t */)
{return C*exp(-(mask[0]*(x[0]-x0[0])*(x[0]-x0[0])
+mask[1]*(x[1]-x0[1])*(x[1]-x0[1])
+mask[2]*(x[2]-x0[2])*(x[2]-x0[2]))/tau/tau) + C0;};
@ -362,10 +362,10 @@ namespace ATC {
TemporalRamp(int nargs, double* args);
virtual ~TemporalRamp(void) {};
inline double f(double* x, double t)
inline double f(double* /* x */, double t)
{return f_initial + slope*t;};
inline double dfdt(double* x, double t)
inline double dfdt(double* /* x */, double /* t */)
{return slope;};
private :
@ -382,7 +382,7 @@ namespace ATC {
RadialPower(int nargs, double* args);
virtual ~RadialPower(void) {};
inline double f(double* x, double t)
inline double f(double* x, double /* t */)
{
double dx = x[0]-x0[0]; double dy = x[1]-x0[1]; double dz = x[2]-x0[2];
double r = mask[0]*dx*dx+mask[1]*dy*dy+mask[2]*dz*dz; r = sqrt(r);

38
lib/atc/FundamentalAtomicQuantity.h
View File

@ -82,43 +82,43 @@ namespace ATC {
virtual ~AtomMass() {};
/** sets the quantity to a given value */
virtual void operator=(const DENS_MAT & target)
virtual void operator=(const DENS_MAT & /* target */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** sets the quantity to a given constant value */
virtual void operator=(const double & target)
virtual void operator=(const double & /* target */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DENS_MAT & addition)
virtual void operator+=(const DENS_MAT & /* addition */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(double addition)
virtual void operator+=(double /* addition */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DENS_MAT & subtraction)
virtual void operator-=(const DENS_MAT & /* subtraction */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(double subtracts)
virtual void operator-=(double /* subtracts */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DENS_MAT & multiplier)
virtual void operator*=(const DENS_MAT & /* multiplier */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(double multiplier)
virtual void operator*=(double /* multiplier */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DENS_MAT & divisor)
virtual void operator/=(const DENS_MAT & /* divisor */)
{throw ATC_Error("Cannot modify type-based atom mass");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(double divisor)
virtual void operator/=(double /* divisor */)
{throw ATC_Error("Cannot modify type-based atom mass");};
protected:
@ -182,39 +182,39 @@ namespace ATC {
{throw ATC_Error("ComputedAtomQuantity::set_quantity - Cannot modify computed per atom quantities"); return quantity_;};
/** sets the quantity to a given constant value */
virtual void operator=(const DENS_MAT & target)
virtual void operator=(const DENS_MAT & /* target */)
{throw ATC_Error("ComputedAtomQuantity::operator= - Cannot modify computed per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DENS_MAT & addition)
virtual void operator+=(const DENS_MAT & /* addition */)
{throw ATC_Error("ComputedAtomQuantity::operator+= - Cannot modify computed per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(double addition)
virtual void operator+=(double /* addition */)
{throw ATC_Error("ComputedAtomQuantity::operator+= - Cannot modify computed per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DENS_MAT & subtraction)
virtual void operator-=(const DENS_MAT & /* subtraction */)
{throw ATC_Error("ComputedAtomQuantity::operator-= - Cannot modify computed per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(double subtraction)
virtual void operator-=(double /* subtraction */)
{throw ATC_Error("ComputedAtomQuantity::operator-= - Cannot modify computed per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DENS_MAT & multiplier)
virtual void operator*=(const DENS_MAT & /* multiplier */)
{throw ATC_Error("ComputedAtomQuantity::operator*= - Cannot modify computed per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(double multiplier)
virtual void operator*=(double /* multiplier */)
{throw ATC_Error("ComputedAtomQuantity::operator*= - Cannot modify computed per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DENS_MAT & divisor)
virtual void operator/=(const DENS_MAT & /* divisor */)
{throw ATC_Error("ComputedAtomQuantity::operator/= - Cannot modify computed per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(double divisor)
virtual void operator/=(double /* divisor */)
{throw ATC_Error("ComputedAtomQuantity::operator/= - Cannot modify computed per atom quantities");};
protected:

18
lib/atc/KernelFunction.cpp
View File

@ -123,7 +123,7 @@ namespace ATC {
// KernelFunction
//------------------------------------------------------------------------
// constructor
KernelFunction::KernelFunction(int nparameters, double* parameters):
KernelFunction::KernelFunction(int /* nparameters */, double* parameters):
Rc_(0),invRc_(0),nsd_(3),
lammpsInterface_(LammpsInterface::instance())
{
@ -286,7 +286,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionStep::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionStep::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}
@ -378,7 +378,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionCell::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionCell::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}
@ -518,7 +518,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionCubicSphere::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionCubicSphere::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}
@ -548,7 +548,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionQuarticSphere::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionQuarticSphere::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}
@ -581,7 +581,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionCubicCyl::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionCubicCyl::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}
@ -614,7 +614,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionQuarticCyl::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionQuarticCyl::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}
@ -646,7 +646,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionCubicBar::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionCubicBar::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}
@ -719,7 +719,7 @@ namespace ATC {
}
// function derivative value
void KernelFunctionQuarticBar::derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const
void KernelFunctionQuarticBar::derivative(const DENS_VEC& /* x_atom */, DENS_VEC& deriv) const
{
deriv.reset(nsd_);
}

4
lib/atc/KernelFunction.h
View File

@ -83,7 +83,7 @@ namespace ATC {
// function derivative
virtual void derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const;
// bond function value
virtual double bond(DENS_VEC& xa, DENS_VEC&xb, double lam1, double lam2) const
virtual double bond(DENS_VEC& /* xa */, DENS_VEC& /* xb */, double lam1, double lam2) const
{ return lam2-lam1; }
};
@ -105,7 +105,7 @@ namespace ATC {
// function derivative
virtual void derivative(const DENS_VEC& x_atom, DENS_VEC& deriv) const;
// bond function value
virtual double bond(DENS_VEC& xa, DENS_VEC&xb, double lam1, double lam2) const
virtual double bond(DENS_VEC& /* xa */, DENS_VEC& /* xb */, double lam1, double lam2) const
{return lam2 -lam1;}
// bond intercept values : origin is the node position
void bond_intercepts(DENS_VEC& xa, DENS_VEC& xb,

10
lib/atc/KinetoThermostat.cpp
View File

@ -32,7 +32,7 @@ namespace ATC {
// parses and adjusts thermostat state based on
// user input, in the style of LAMMPS user input
//--------------------------------------------------------
bool KinetoThermostat::modify(int narg, char **arg)
bool KinetoThermostat::modify(int /* narg */, char ** /* arg */)
{
bool foundMatch = false;
return foundMatch;
@ -171,7 +171,7 @@ namespace ATC {
// sets up the right-hand side of the
// kinetostat equations
//--------------------------------------------------------
void VelocityRescaleCombined::set_kinetostat_rhs(DENS_MAT & rhs, double dt)
void VelocityRescaleCombined::set_kinetostat_rhs(DENS_MAT & rhs, double /* dt */)
{
rhs = ((atc_->mass_mat_md(VELOCITY)).quantity())*(velocity_.quantity());
rhs -= thermostatCorrection_->quantity();
@ -682,8 +682,8 @@ namespace ATC {
// sets up and solves linear system for lambda, if the
// bool is true it iterators to a non-linear solution
//--------------------------------------------------------
void KinetoThermostatGlcFs::compute_lambda(double dt,
bool iterateSolution)
void KinetoThermostatGlcFs::compute_lambda(double /* dt */,
bool /* iterateSolution */)
{
// ITERATIVE SOLUTION
}
@ -692,7 +692,7 @@ namespace ATC {
// output:
// adds all relevant output to outputData
//--------------------------------------------------------
void KinetoThermostatGlcFs::output(OUTPUT_LIST & outputData)
void KinetoThermostatGlcFs::output(OUTPUT_LIST & /* outputData */)
{
// DO NOT CALL INDIVIDUAL REGULATORS
// OUTPUT TOTAL FORCE AND TOTAL POWER

33
lib/atc/KinetoThermostat.h
View File

@ -75,8 +75,11 @@ namespace ATC {
KinetoThermostatShapeFunction(AtomicRegulator * kinetoThermostat,
int couplingMaxIterations,
const std::string & regulatorPrefix = "") : RegulatorMethod(kinetoThermostat),
const std::string & /* regulatorPrefix */) : RegulatorMethod(kinetoThermostat),
couplingMaxIterations_(couplingMaxIterations) {};
KinetoThermostatShapeFunction(AtomicRegulator * kinetoThermostat,
int couplingMaxIterations)
: RegulatorMethod(kinetoThermostat), couplingMaxIterations_(couplingMaxIterations) {};
virtual ~KinetoThermostatShapeFunction() {};
@ -120,9 +123,9 @@ namespace ATC {
virtual void initialize();
/** applies kinetostat to atoms */
virtual void apply_mid_predictor(double dt){};
virtual void apply_mid_predictor(double /* dt */){};
/** applies kinetostat to atoms */
virtual void apply_post_corrector(double dt){};
virtual void apply_post_corrector(double /* dt */){};
/** local shape function matrices are incompatible with this mode */
virtual bool use_local_shape_functions() const {return false;};
@ -142,15 +145,17 @@ namespace ATC {
// disable un-needed functionality
/** does initial filtering operations before main computation */
virtual void apply_pre_filtering(double dt){};
virtual void apply_pre_filtering(double /* dt */){};
/** applies kinetostat correction to atoms */
virtual void apply_kinetostat(double dt) {};
virtual void apply_kinetostat(double /* dt */) {};
/** computes the nodal FE force applied by the kinetostat */
virtual void compute_nodal_lambda_force(double dt){};
virtual void compute_nodal_lambda_force(double /* dt */){};
/** apply any required corrections for localized kinetostats */
virtual void apply_localization_correction(const DENS_MAT & source,
DENS_MAT & nodalField,
double weight = 1.){};
virtual void apply_localization_correction(const DENS_MAT & /* source */,
DENS_MAT & /* nodalField */,
double /* weight */){};
virtual void apply_localization_correction(const DENS_MAT & /* source */,
DENS_MAT & /* nodalField */){};
private:
@ -177,7 +182,7 @@ namespace ATC {
// deactivate un-needed methods
/** applies thermostat to atoms in the post-corrector phase */
virtual void apply_post_corrector(double dt){};
virtual void apply_post_corrector(double /* dt */){};
protected:
@ -187,7 +192,7 @@ namespace ATC {
// deactivate un-needed methods
/** apply solution to atomic quantities */
virtual void apply_to_atoms(PerAtomQuantity<double> * atomVelocities){};
virtual void apply_to_atoms(PerAtomQuantity<double> * /* atomVelocities */){};
/** construct the RHS vector */
virtual void set_rhs(DENS_MAT & rhs);
@ -223,7 +228,7 @@ namespace ATC {
virtual void apply_post_corrector(double dt);
/** compute boundary flux, requires thermostat input since it is part of the coupling scheme */
virtual void compute_boundary_flux(FIELDS & fields)
virtual void compute_boundary_flux(FIELDS & /* fields */)
{boundaryFlux_[TEMPERATURE] = 0.; boundaryFlux_[VELOCITY] = 0.;};
/** get data for output */
@ -291,7 +296,7 @@ namespace ATC {
// deactivate un-needed methods
/** applies thermostat to atoms in the post-corrector phase */
virtual void apply_post_corrector(double dt){};
virtual void apply_post_corrector(double /* dt */){};
protected:
@ -301,7 +306,7 @@ namespace ATC {
// deactivate un-needed methods
/** apply solution to atomic quantities */
virtual void apply_to_atoms(PerAtomQuantity<double> * atomVelocities){};
virtual void apply_to_atoms(PerAtomQuantity<double> * /* atomVelocities */){};
/** construct the RHS vector */
virtual void set_rhs(DENS_MAT & rhs);

20
lib/atc/Kinetostat.cpp
View File

@ -445,7 +445,7 @@ namespace ATC {
//--------------------------------------------------------
void GlcKinetostat::apply_to_atoms(PerAtomQuantity<double> * quantity,
const DENS_MAT & lambdaAtom,
double dt)
double /* dt */)
{
*quantity -= lambdaAtom;
}
@ -576,7 +576,7 @@ namespace ATC {
// sets up the right-hand side of the
// kinetostat equations
//--------------------------------------------------------
void DisplacementGlc::set_kinetostat_rhs(DENS_MAT & rhs, double dt)
void DisplacementGlc::set_kinetostat_rhs(DENS_MAT & rhs, double /* dt */)
{
// form rhs : sum_a (hatN_Ia * x_ai) - (Upsilon)_Ii
rhs = nodalAtomicMassWeightedDisplacement_->quantity();
@ -922,7 +922,7 @@ namespace ATC {
// sets up the right-hand side of the
// kinetostat equations
//--------------------------------------------------------
void VelocityGlc::set_kinetostat_rhs(DENS_MAT & rhs, double dt)
void VelocityGlc::set_kinetostat_rhs(DENS_MAT & rhs, double /* dt */)
{
// form rhs : sum_a (hatN_Ia * x_ai) - (\dot{Upsilon})_Ii
rhs = nodalAtomicMomentum_->quantity();
@ -1252,7 +1252,7 @@ namespace ATC {
// sets up the RHS of the kinetostat equations
// for the coupling parameter lambda
//--------------------------------------------------------
void StressFlux::set_kinetostat_rhs(DENS_MAT & rhs, double dt)
void StressFlux::set_kinetostat_rhs(DENS_MAT & rhs, double /* dt */)
{
// (a) for flux based :
// form rhs : \int N_I r dV - \sum_g N_Ig^* f_g
@ -1381,7 +1381,7 @@ namespace ATC {
// computes the boundary flux to be consistent with
// the controller
//--------------------------------------------------------
void StressFluxGhost::compute_boundary_flux(FIELDS & fields)
void StressFluxGhost::compute_boundary_flux(FIELDS & /* fields */)
{
// This is only used in computation of atomic sources
boundaryFlux_[VELOCITY] = 0.;
@ -1407,7 +1407,7 @@ namespace ATC {
// sets up the RHS of the kinetostat equations
// for the coupling parameter lambda
//--------------------------------------------------------
void StressFluxGhost::set_kinetostat_rhs(DENS_MAT & rhs, double dt)
void StressFluxGhost::set_kinetostat_rhs(DENS_MAT & rhs, double /* dt */)
{
// (a) for flux based :
// form rhs : \int N_I r dV - \sum_g N_Ig^* f_g
@ -1985,7 +1985,7 @@ namespace ATC {
// sets up the RHS of the kinetostat equations
// for the coupling parameter lambda
//--------------------------------------------------------
void KinetostatFlux::set_kinetostat_rhs(DENS_MAT & rhs, double dt)
void KinetostatFlux::set_kinetostat_rhs(DENS_MAT & rhs, double /* dt */)
{
// (a) for flux based :
// form rhs : \int N_I r dV - \sum_g N_Ig^* f_g
@ -2056,7 +2056,7 @@ namespace ATC {
// computes the boundary flux to be consistent with
// the controller
//--------------------------------------------------------
void KinetostatFluxGhost::compute_boundary_flux(FIELDS & fields)
void KinetostatFluxGhost::compute_boundary_flux(FIELDS & /* fields */)
{
// This is only used in computation of atomic sources
boundaryFlux_[VELOCITY] = 0.;
@ -2086,7 +2086,7 @@ namespace ATC {
// sets up the RHS of the kinetostat equations
// for the coupling parameter lambda
//--------------------------------------------------------
void KinetostatFluxGhost::set_kinetostat_rhs(DENS_MAT & rhs, double dt)
void KinetostatFluxGhost::set_kinetostat_rhs(DENS_MAT & rhs, double /* dt */)
{
// (a) for flux based :
// form rhs : \int N_I r dV - \sum_g N_Ig^* f_g
@ -2348,7 +2348,7 @@ namespace ATC {
//--------------------------------------------------------
void KinetostatFixed::add_to_momentum(const DENS_MAT & nodalLambdaForce,
DENS_MAT & deltaMomentum,
double dt)
double /* dt */)
{
deltaMomentum.resize(nNodes_,nsd_);
const set<int> & regulatedNodes(regulatedNodes_->quantity());

10
lib/atc/Kinetostat.h
View File

@ -129,9 +129,11 @@ namespace ATC {
double dt=0.);
/** apply any required corrections for localized kinetostats */
virtual void apply_localization_correction(const DENS_MAT & source,
DENS_MAT & nodalField,
double weight = 1.){};
virtual void apply_localization_correction(const DENS_MAT & /* source */,
DENS_MAT & /* nodalField */,
double /* weight */){};
virtual void apply_localization_correction(const DENS_MAT & /* source */,
DENS_MAT & /* nodalField */){};
// member data
/** nodeset corresponding to Hoover coupling */
@ -761,7 +763,7 @@ namespace ATC {
virtual void apply_post_corrector(double dt);
/** compute boundary flux, requires thermostat input since it is part of the coupling scheme */
virtual void compute_boundary_flux(FIELDS & fields)
virtual void compute_boundary_flux(FIELDS & /* fields */)
{boundaryFlux_[VELOCITY] = 0.;};
/** determine if local shape function matrices are needed */

4
lib/atc/LammpsInterface.cpp
View File

@ -902,7 +902,7 @@ int LammpsInterface::reset_ghosts(int deln) const
//* energy for interactions within the shortrange cutoff
double LammpsInterface::shortrange_energy(double *coord,
int itype, int id, double max) const
int itype, int id, double /* max */) const
{
LAMMPS_NS::Atom * atom = lammps_->atom;
double **x = atom->x;
@ -1293,7 +1293,7 @@ int LammpsInterface::nsteps() const { return lammps_->update->nsteps; }
int LammpsInterface::sbmask(int j) const {return j >> SBBITS & 3; }
void LammpsInterface::set_list(int id, LAMMPS_NS::NeighList *ptr) { list_ = ptr; }
void LammpsInterface::set_list(int /* id */, LAMMPS_NS::NeighList *ptr) { list_ = ptr; }
int LammpsInterface::neighbor_list_inum() const { return list_->inum; }

8
lib/atc/Material.cpp
View File

@ -816,7 +816,7 @@ void Material::inv_effective_mass(
};
//---------------------------------------------------------------------
void Material::heat_flux(
const FIELD_MATS & fields,
const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & gradFields,
DENS_MAT_VEC & flux) const
{
@ -865,7 +865,7 @@ bool Material::electron_drag_power(
//---------------------------------------------------------------------
bool Material::electron_recombination(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
const GRAD_FIELD_MATS & /* gradFields */,
DENS_MAT & recombination) const
{
// 1/tau (n - n0)
@ -937,7 +937,7 @@ void Material::electron_flux(
}
//---------------------------------------------------------------------
void Material::electric_field(
const FIELD_MATS &fields,
const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &flux) const
{
@ -950,7 +950,7 @@ void Material::electric_field(
}
//---------------------------------------------------------------------
void Material::electric_displacement(
const FIELD_MATS &fields,
const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &flux) const
{

2
lib/atc/Matrix.h
View File

@ -248,7 +248,7 @@ DenseMatrix<T> operator-(const Matrix<T> &A, const Matrix<T> &B)
//* performs a matrix-matrix multiply with general type implementation
template<typename T>
void MultAB(const Matrix<T> &A, const Matrix<T> &B, DenseMatrix<T> &C,
const bool At, const bool Bt, T a, T b)
const bool At, const bool Bt, T /* a */, T b)
{
const INDEX sA[2] = {A.nRows(), A.nCols()}; // m is sA[At] k is sA[!At]
const INDEX sB[2] = {B.nRows(), B.nCols()}; // k is sB[Bt] n is sB[!Bt]

2
lib/atc/MeshReader.cpp
View File

@ -20,7 +20,7 @@ namespace ATC {
/** constructor, takes a filename */
MeshReader::MeshReader(string filename,
Array<bool> periodicity,
double tol)
double /* tol */)
: meshfile_(filename),
periodicity_(periodicity),
nNodes_(0),

2
lib/atc/MoleculeSet.cpp
View File

@ -165,7 +165,7 @@ namespace ATC {
// Constructor
//--------------------------------------------------------
SmallMoleculeSet::SmallMoleculeSet(ATC_Method * atc, int groupBit,
PerAtomQuantity<int> * bondList, PerAtomQuantity<int> * numBond) :
PerAtomQuantity<int> * bondList, PerAtomQuantity<int> * /* numBond */) :
MoleculeSet(atc,groupBit),
bondList_(bondList)
{

2
lib/atc/NonLinearSolver.h
View File

@ -20,7 +20,7 @@ class TangentOperator {
public:
TangentOperator(){};
virtual ~TangentOperator(){};
virtual void function(const VECTOR & x, DENS_VEC & f) {}; // =0;
virtual void function(const VECTOR & /* x */, DENS_VEC & /* f */) {}; // =0;
virtual void tangent(const VECTOR & x, DENS_VEC & f, MATRIX & dfdx) =0;
//virtual void function(const VECTOR & x, VECTOR & f) {}; // =0;
//virtual void tangent(const VECTOR & x, VECTOR & f, MATRIX & dfdx) {}; // =0;

2
lib/atc/OutputManager.cpp
View File

@ -792,7 +792,7 @@ void OutputManager::write_data_vtk(OUTPUT_LIST *data)
}
/** write (ensight gold : ASCII "C" format) dictionary */
void OutputManager::write_dictionary(double time, OUTPUT_LIST *data)
void OutputManager::write_dictionary(double /* time */, OUTPUT_LIST *data)
{
// file names
string dict_file_name = outputPrefix_ + ".case";

12
lib/atc/PerAtomQuantity-inl.h
View File

@ -177,7 +177,7 @@ namespace ATC {
//-----------------------------------------------------------------
template <typename T>
int PerAtomQuantity<T>::pack_comm(int index, double *buf,
int pbc_flag, int *pbc)
int /* pbc_flag */, int * /* pbc */)
{
if (this->need_reset()) this->reset();
DenseMatrix<T> & myQuantity(this->quantity_);
@ -256,7 +256,7 @@ namespace ATC {
//-----------------------------------------------------------------
template <typename T>
int LammpsAtomQuantity<T>::pack_comm(int index, double *buf,
int pbc_flag, int *pbc)
int /* pbc_flag */, int * /* pbc */)
{
if (this->need_reset()) this->reset();
int bufIdx = 0;
@ -550,7 +550,7 @@ namespace ATC {
//-----------------------------------------------------------------
template <typename T>
int PerAtomDiagonalMatrix<T>::pack_comm(int index, double *buf,
int pbc_flag, int *pbc)
int /* pbc_flag */, int * /* pbc */)
{
if (this->need_reset()) this->reset();
DiagonalMatrix<T> & myQuantity(this->quantity_);
@ -756,8 +756,8 @@ namespace ATC {
// pack values in local atom-based arrays for passing to ghosts on another proc
//-----------------------------------------------------------------
template <typename T>
int PerAtomSparseMatrix<T>::pack_comm(int index, double *buf,
int pbc_flag, int *pbc)
int PerAtomSparseMatrix<T>::pack_comm(int /* index */, double * /* buf */,
int /* pbc_flag */, int */* pbc */)
{
return 0;
}
@ -766,7 +766,7 @@ namespace ATC {
// unpack values in local atom-based arrays for passing to ghosts on another proc
//-----------------------------------------------------------------
template <typename T>
int PerAtomSparseMatrix<T>::unpack_comm(int index, double *buf)
int PerAtomSparseMatrix<T>::unpack_comm(int /* index */, double * /* buf */)
{
return 0;
}

144
lib/atc/PerAtomQuantity.h
View File

@ -274,26 +274,26 @@ namespace ATC {
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer) {return 0;};
virtual int pack_exchange(int /* i */, double */* buffer */) {return 0;};
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
virtual int unpack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc) {return 0;};
virtual int pack_comm(int /* index */, double * /* buf */,
int /* pbc_flag */, int * /* pbc */) {return 0;};
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf) {return 0;};
virtual int unpack_comm(int /* index */, double * /* buf */) {return 0;};
/** returns size of per-atom communication */
virtual int size_comm() const {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
virtual void grow_lammps_array(int /* nmax */, const std::string & /* tag */) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
virtual void copy_lammps_array(int /* i */, int /* j */) {};
protected:
@ -396,43 +396,43 @@ namespace ATC {
{throw ATC_Error("ProtectedClonedAtomQuantity::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
virtual void operator=(const DenseMatrix<T> & /* target */)
{throw ATC_Error("ProtectedClonedAtomQuantity::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
virtual void operator+=(const DenseMatrix<T> & /* addition */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
virtual void operator-=(const DenseMatrix<T> & /* subtraction */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
virtual void operator*=(const DenseMatrix<T> & /* multiplier */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
virtual void operator/=(const DenseMatrix<T> & /* divisor */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("ProtectedClonedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
protected:
@ -517,43 +517,43 @@ namespace ATC {
{throw ATC_Error("ProtectedAtomQuantity::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
virtual void operator=(const DenseMatrix<T> & /* target */)
{throw ATC_Error("ProtectedAtomQuantity::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("ProtectedAtomQuantity::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
virtual void operator+=(const DenseMatrix<T> & /* addition */)
{throw ATC_Error("ProtectedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("ProtectedAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
virtual void operator-=(const DenseMatrix<T> & /* subtraction */)
{throw ATC_Error("ProtectedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("ProtectedAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
virtual void operator*=(const DenseMatrix<T> & /* multiplier */)
{throw ATC_Error("ProtectedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("ProtectedAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
virtual void operator/=(const DenseMatrix<T> & /* divisor */)
{throw ATC_Error("ProtectedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("ProtectedAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
protected:
@ -646,43 +646,43 @@ namespace ATC {
{throw ATC_Error("ProtectedLammpsAtomQuantity::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
virtual void operator=(const DenseMatrix<T> & /* target */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
virtual void operator+=(const DenseMatrix<T> & /* addition */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
virtual void operator-=(const DenseMatrix<T> & /* subtraction */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
virtual void operator*=(const DenseMatrix<T> & /* multiplier */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
virtual void operator/=(const DenseMatrix<T> & /* divisor */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("ProtectedLammpsAtomQuantity::operator/= - Cannot modify protected per atom quantities");};
protected:
@ -734,16 +734,16 @@ namespace ATC {
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer */
virtual int pack_exchange(int i, double *buffer) {return 0;};
virtual int pack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** unpacks data after parallel transfer */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
virtual int unpack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
virtual void grow_lammps_array(int /* nmax */, const std::string & /* tag */) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
virtual void copy_lammps_array(int /* i */, int /* j */) {};
protected:
@ -791,16 +791,16 @@ namespace ATC {
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer */
virtual int pack_exchange(int i, double *buffer) {return 0;};
virtual int pack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** unpacks data after parallel transfer */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
virtual int unpack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
virtual void grow_lammps_array(int /* nmax */, const std::string & /* tag */) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
virtual void copy_lammps_array(int /* i */, int /* j */) {};
protected:
@ -1066,43 +1066,43 @@ namespace ATC {
{throw ATC_Error("ProtectedAtomDiagonalMatrix::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const DiagonalMatrix<T> & target)
virtual void operator=(const DiagonalMatrix<T> & /* target */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DiagonalMatrix<T> & addition)
virtual void operator+=(const DiagonalMatrix<T> & /* addition */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DiagonalMatrix<T> & subtraction)
virtual void operator-=(const DiagonalMatrix<T> & /* subtraction */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DiagonalMatrix<T> & multiplier)
virtual void operator*=(const DiagonalMatrix<T> & /* multiplier */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DiagonalMatrix<T> & divisor)
virtual void operator/=(const DiagonalMatrix<T> & /* divisor */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("ProtectedAtomDiagonalMatrix::operator/= - Cannot modify protected per atom quantities");};
protected:
@ -1331,43 +1331,43 @@ namespace ATC {
{throw ATC_Error("ProtectedAtomSparseMatrix::set_quantity - Cannot modify protected per atom quantities"); return this->quantity_;};
/** sets the quantity to a given value */
virtual void operator=(const SparseMatrix<T> & target)
virtual void operator=(const SparseMatrix<T> & /* target */)
{throw ATC_Error("ProtectedAtomSparseMatrix::set_quantity - Cannot modify protected per atom quantities");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator= - Cannot modify protected per atom quantities");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const SparseMatrix<T> & addition)
virtual void operator+=(const SparseMatrix<T> & /* addition */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator+= - Cannot modify protected per atom quantities");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator+= - Cannot modify protected per atom quantities");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const SparseMatrix<T> & subtraction)
virtual void operator-=(const SparseMatrix<T> & /* subtraction */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator-= - Cannot modify protected per atom quantities");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator-= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const SparseMatrix<T> & multiplier)
virtual void operator*=(const SparseMatrix<T> & /* multiplier */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator*= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const SparseMatrix<T> & divisor)
virtual void operator/=(const SparseMatrix<T> & /* divisor */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator/= - Cannot modify protected per atom quantities");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("ProtectedAtomSparseMatrix::operator/= - Cannot modify protected per atom quantities");};
protected:
@ -1420,27 +1420,27 @@ namespace ATC {
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer) {return 0;};
virtual int pack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
virtual int unpack_exchange(int /* i */, double * /* buffer */) {return 0;};
// pack/unpack_comm only valid if the quantity is over all real and processor ghost atoms
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc) {return 0;};
virtual int pack_comm(int /* index */, double * /* buf */,
int /* pbc_flag */, int * /* pbc */) {return 0;};
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf) {return 0;};
virtual int unpack_comm(int /* index */, double * /* buf */) {return 0;};
/** returns per-atom size of communicated data */
virtual int size_comm() const {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
virtual void grow_lammps_array(int /* nmax */, const std::string & /* tag */) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
virtual void copy_lammps_array(int /* i */, int /* j */) {};
protected:

2
lib/atc/PerAtomQuantityLibrary.cpp
View File

@ -1129,7 +1129,7 @@ namespace ATC {
FluctuatingKineticTensor::FluctuatingKineticTensor(ATC_Method * atc,
PerAtomQuantity<double> * atomVelocities,
PerAtomQuantity<double> * atomMasses,
PerAtomQuantity<double> * atomMeanVelocities,
PerAtomQuantity<double> * /* atomMeanVelocities */,
AtomType atomType) :
ProtectedAtomQuantity<double>(atc,6,atomType),
atomVelocities_(atomVelocities),

14
lib/atc/PerAtomQuantityLibrary.h
View File

@ -1045,26 +1045,26 @@ namespace ATC {
virtual int memory_usage() const {return 0;};
/** packs up data for parallel transfer when atoms change processors */
virtual int pack_exchange(int i, double *buffer) {return 0;};
virtual int pack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** unpacks data after parallel transfer when atoms change processors */
virtual int unpack_exchange(int i, double *buffer) {return 0;};
virtual int unpack_exchange(int /* i */, double * /* buffer */) {return 0;};
/** packs up data for parallel transfer to ghost atoms on other processors */
virtual int pack_comm(int index, double *buf,
int pbc_flag, int *pbc) {return 0;};
virtual int pack_comm(int /* index */, double * /* buf */,
int /* pbc_flag */, int * /* pbc */) {return 0;};
/** unpacks data after parallel transfer to ghost atoms on other processors */
virtual int unpack_comm(int index, double *buf) {return 0;};
virtual int unpack_comm(int /* index */, double * /* buf */) {return 0;};
/** returns size of per-atom communication */
virtual int size_comm() const {return 0;};
/** changes size of temperary lammps storage data if transfer is being used */
virtual void grow_lammps_array(int nmax, const std::string & tag) {};
virtual void grow_lammps_array(int /* nmax */, const std::string & /* tag */) {};
/** rearrange memory of temporary lammps storage data, called from copy_array */
virtual void copy_lammps_array(int i, int j) {};
virtual void copy_lammps_array(int /* i */, int /* j */) {};
protected:

2
lib/atc/PerPairQuantity.cpp
View File

@ -281,7 +281,6 @@ void BondMatrixKernel::reset(void) const
int nNodes = feMesh_->num_nodes_unique();
quantity_.reset(nNodes,nPairs);
double lam1,lam2;
std::pair< int,int > pair_jk;
int heartbeatFreq = (nNodes <= 10 ? 1 : (int) nNodes / 10);
HeartBeat beat("computing bond matrix ",heartbeatFreq);
beat.start();
@ -337,7 +336,6 @@ void BondMatrixPartitionOfUnity::reset(void) const
int nodes_per_element = feMesh_->num_nodes_per_element();
Array<int> node_list(nodes_per_element);
DENS_VEC shp(nodes_per_element);
std::pair< int,int > pair_jk;
int heartbeatFreq = (int) nPairs / 10;
HeartBeat beat("computing bond matrix ",heartbeatFreq);
beat.start();

2
lib/atc/PhysicsModel.h
View File

@ -47,7 +47,7 @@ namespace ATC
void initialize(void);
// set timescale parameters based on a given lengthscale
virtual void set_timescales(const double lengthscale) {};
virtual void set_timescales(const double /* lengthscale */) {};
/** access number of materials */
int nMaterials(void) const { return materials_.size(); }

2
lib/atc/PoissonSolver.cpp
View File

@ -71,7 +71,7 @@ PoissonSolver::~PoissonSolver()
// Parser
// --------------------------------------------------------------------
bool PoissonSolver::modify(int narg, char **arg)
bool PoissonSolver::modify(int /* narg */, char **arg)
{
bool match = false;
/*! \page man_poisson_solver fix_modify AtC poisson_solver

2
lib/atc/PolynomialSolver.cpp
View File

@ -104,7 +104,7 @@ namespace ATC {
// solve ode with polynomial source : y'n + a_n-1 y'n-1 + ... = b_n x^n +...
void integrate_ode(double x,
int na, double * a, double * y0, double * y, int nb, double *b )
int na, double * a, double * y0, double * y, int nb, double * /* b */ )
{
if (na == 2) {
// particular

10
lib/atc/SchrodingerSolver.cpp
View File

@ -66,7 +66,7 @@ double fermi_dirac(const double E, const double T)
M_ = sparseM.dense_copy();
}
//-----------------------------------------------------
bool SchrodingerSolver::solve(FIELDS & fields)
bool SchrodingerSolver::solve(FIELDS & /* fields */)
{
// typedef struct{float real, imag;} COMPLEX;
@ -132,7 +132,7 @@ double fermi_dirac(const double E, const double T)
//--------------------------------------------------------
// compute charge density per slice
//--------------------------------------------------------
bool SliceSchrodingerSolver::solve(FIELDS & fields)
bool SliceSchrodingerSolver::solve(FIELDS & /* fields */)
{
// fields
DENS_MAT & psi = (atc_->field(ELECTRON_WAVEFUNCTION)).set_quantity();
@ -250,7 +250,7 @@ double fermi_dirac(const double E, const double T)
{
}
//----------------------------------------------------------
bool SchrodingerPoissonManager::modify(int narg, char **arg)
bool SchrodingerPoissonManager::modify(int /* narg */, char **arg)
{
bool match = false;
int argIndx = 0;
@ -350,7 +350,7 @@ double fermi_dirac(const double E, const double T)
}
//----------------------------------------------------------------------
void SchrodingerPoissonSolver::solve(FIELDS & rhs, GRAD_FIELD_MATS & fluxes)
void SchrodingerPoissonSolver::solve(FIELDS & rhs, GRAD_FIELD_MATS & /* fluxes */)
{
if ((atc_->prescribed_data_manager()->all_fixed(ELECTRON_WAVEFUNCTION))
&& (atc_->prescribed_data_manager()->all_fixed(ELECTRIC_POTENTIAL))) {
@ -739,7 +739,7 @@ double fermi_dirac(const double E, const double T)
if (solver_) delete solver_;
}
//--------------------------------------------------------------------------
void GlobalSliceSchrodingerPoissonSolver::solve(FIELDS & rhs, GRAD_FIELD_MATS & fluxes)
void GlobalSliceSchrodingerPoissonSolver::solve(FIELDS & rhs, GRAD_FIELD_MATS & /* fluxes */)
{
const DENS_MAT & phi = (atc_->fields_[ELECTRIC_POTENTIAL]).quantity();
const DENS_MAT & n = (atc_->fields_[ELECTRON_DENSITY] ).quantity();

4
lib/atc/SchrodingerSolver.h
View File

@ -41,7 +41,7 @@ class SchrodingerSolver {
virtual ~SchrodingerSolver(){};
/** parser */
bool modify(int narg, char **arg){ return false;}
bool modify(int /* narg */, char ** /* arg */){ return false;}
/** initialize */
void initialize(void);
@ -103,7 +103,7 @@ class SliceSchrodingerSolver : public SchrodingerSolver {
virtual ~SliceSchrodingerSolver(){};
/** parser */
bool modify(int narg, char **arg){return false;}
bool modify(int /* narg */, char ** /* arg */){return false;}
/** initialize */
void initialize(void);

4
lib/atc/SparseMatrix-inl.h
View File

@ -498,7 +498,7 @@ TRIPLET<T> SparseMatrix<T>::triplet(INDEX i) const
// full reset - completely wipes out all SparseMatrix data, zero is ignored
//-----------------------------------------------------------------------------
template<typename T>
void SparseMatrix<T>::reset(INDEX rows, INDEX cols, bool zero)
void SparseMatrix<T>::reset(INDEX rows, INDEX cols, bool /* zero */)
{
_delete();
_nRows = rows;
@ -545,7 +545,7 @@ void SparseMatrix<T>::reset(const DenseMatrix<T>& D, double TOL)
// copy - dangerous: ignores rows & columns
//-----------------------------------------------------------------------------
template<typename T>
void SparseMatrix<T>::copy(const T * ptr, INDEX rows, INDEX cols)
void SparseMatrix<T>::copy(const T * /* ptr */, INDEX /* rows */, INDEX /* cols */)
{
std::cout << "SparseMatrix<T>::copy() has no effect.\n";
throw;

14
lib/atc/SparseVector-inl.h
View File

@ -106,7 +106,7 @@ std::string SparseVector<T>::to_string() const
// Indexes the ith component of the vector or returns zero if not found.
template<class T>
T SparseVector<T>::operator()(INDEX i, INDEX j) const
T SparseVector<T>::operator()(INDEX i, INDEX /* j */) const
{
STORE::const_iterator it = data_.find(i);
if (it == data_.end()) return 0.0;
@ -115,7 +115,7 @@ T SparseVector<T>::operator()(INDEX i, INDEX j) const
// Indexes the ith component of the vector or returns zero if not found.
template<class T>
T& SparseVector<T>::operator()(INDEX i, INDEX j)
T& SparseVector<T>::operator()(INDEX i, INDEX /* j */)
{
return data_[i];
}
@ -129,7 +129,7 @@ template<class T> T SparseVector<T>::operator[](INDEX i) const
// Indexes the ith component of the vector or returns zero if not found.
template<class T> T& SparseVector<T>::operator[](INDEX i)
{
return (*this)[i];
return (*this)(i);
}
// Returns a pair (index, value) for a nonzero in the vector.
@ -177,7 +177,7 @@ SparseVector<T>& SparseVector<T>::operator=(const SparseVector<T> &c)
// Changes the size of the SparseVector
template<class T>
void SparseVector<T>::resize(INDEX nRows, INDEX nCols, bool copy)
void SparseVector<T>::resize(INDEX nRows, INDEX /* nCols */, bool copy)
{
length_ = nRows;
STORE::iterator it;
@ -202,16 +202,14 @@ void SparseVector<T>::zero()
template<class T>
void SparseVector<T>::copy(const T* ptr, INDEX nRows, INDEX nCols)
void SparseVector<T>::copy(const T* /* ptr */, INDEX /* nRows */, INDEX /* nCols */)
{
}
template<class T>
void SparseVector<T>::write_restart(FILE *F) const
void SparseVector<T>::write_restart(FILE */* F */) const
{
}
// writes a stream to a matlab script to recreate this variable

6
lib/atc/SpeciesTimeIntegrator.cpp
View File

@ -37,7 +37,7 @@ namespace ATC {
// modify
// parses inputs and modifies state of the filter
//--------------------------------------------------------
bool SpeciesTimeIntegrator::modify(int narg, char **arg)
bool SpeciesTimeIntegrator::modify(int /* narg */, char ** /* arg */)
{
bool match = false;
@ -185,7 +185,7 @@ namespace ATC {
// first time integration computations
// before FractionalStep step 2
//--------------------------------------------------------
void SpeciesTimeIntegratorFractionalStep::pre_final_integrate1(double dt)
void SpeciesTimeIntegratorFractionalStep::pre_final_integrate1(double /* dt */)
{
// Compute MD contribution to FEM equation
@ -244,7 +244,7 @@ namespace ATC {
//--------------------------------------------------------
// pre_initial_integrate1
//--------------------------------------------------------
void SpeciesTimeIntegratorFractionalStepFiltered::pre_final_integrate1(double dt)
void SpeciesTimeIntegratorFractionalStepFiltered::pre_final_integrate1(double /* dt */)
{
}

8
lib/atc/Stress.cpp
View File

@ -62,7 +62,7 @@ void deformation_gradient(const DENS_MAT_VEC &du, INDEX q, MATRIX &F)
// E = 1/2 stress*strain for linear elastic models
//=============================================================================
void Stress::elastic_energy(const FIELD_MATS &fields,
void Stress::elastic_energy(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT &energy) const
{
@ -103,7 +103,7 @@ StressLinearElastic::StressLinearElastic(fstream &fileId)
// compute the stress at N integration points from the displacement gradient
// T_{ij} = 1/2*C_{ijkl}* (u_{k,l} + u_{l,k})
//=============================================================================
void StressLinearElastic::stress(const FIELD_MATS &fields,
void StressLinearElastic::stress(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &sigma)
{
@ -159,7 +159,7 @@ StressCubicElastic::StressCubicElastic(fstream &fileId)
// compute the stress at N integration points from the displacement gradient
// T_{ij} = 1/2*C_{ijkl}*(u_{k,l} + u_{l,k})
//---------------------------------------------------------------------------
void StressCubicElastic::stress(const FIELD_MATS &fields,
void StressCubicElastic::stress(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &sigma)
{
@ -200,7 +200,7 @@ void StressCubicElastic::stress(const FIELD_MATS &fields,
// = 1/2 (4 c44 (u12^2 + u13^2 + u23^2) + 2 c12 (u11 u22 + u11 u33 + u22 u33)
// + c11 (u11^2 + u22^2 + u33^2))
//---------------------------------------------------------------------------
void StressCubicElastic::elastic_energy(const FIELD_MATS &fields,
void StressCubicElastic::elastic_energy(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT &energy) const
{

6
lib/atc/Stress.h
View File

@ -24,7 +24,7 @@ namespace ATC {
virtual ~Stress() {};
virtual void initialize(void){};
//* Returns parameter values, (Nothing uses this).
virtual void parameters(std::map<std::string,double> &parameters) {}
virtual void parameters(std::map<std::string,double> & /* parameters */) {}
//* Computes stress given a displacement gradient.
//* Units: mvv/L^3 (i.e. for units Real: g/(mol ps^2 A^2) )
virtual void stress(const FIELD_MATS &fields,
@ -36,7 +36,7 @@ namespace ATC {
const GRAD_FIELD_MATS &gradFields,
DENS_MAT &energy) const;
//* Returns the material tangent at a given deformation gradient.
virtual void tangent(const MATRIX &F, MATRIX &C) const
virtual void tangent(const MATRIX & /* F */, MATRIX & /* C */) const
{throw ATC_Error("Stress::tangent: unimplemented function");}
};
@ -59,7 +59,7 @@ namespace ATC {
virtual void elastic_energy(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT &energy) const;
virtual void tangent(const MATRIX &F, MATRIX &C) const {C=C_;}
virtual void tangent(const MATRIX & /* F */, MATRIX &C) const {C=C_;}
protected:
double c11_, c12_, c44_;
DENS_MAT C_;

4
lib/atc/ThermalTimeIntegrator.cpp
View File

@ -28,7 +28,7 @@ namespace ATC {
// modify
// parses inputs and modifies state of the integrator
//--------------------------------------------------------
bool ThermalTimeIntegrator::modify(int narg, char **arg)
bool ThermalTimeIntegrator::modify(int /* narg */, char **arg)
{
bool foundMatch = false;
int argIndex = 0;
@ -570,7 +570,7 @@ namespace ATC {
// compute_temperature_delta
//--------------------------------------------------------
void ThermalTimeIntegratorFractionalStep::compute_temperature_delta(const DENS_MAT & atomicEnergyDelta,
double dt)
double /* dt */)
{
DENS_MAT & myAtomicTemperatureDelta(atomicTemperatureDelta_.set_quantity());
myAtomicTemperatureDelta = nodalAtomicEnergyOld_.quantity() + atomicEnergyDelta;

12
lib/atc/Thermostat.cpp
View File

@ -483,7 +483,7 @@ namespace ATC {
// manages the solution of the
// thermostat equations and variables
//--------------------------------------------------------
void ThermostatRescale::compute_thermostat(double dt)
void ThermostatRescale::compute_thermostat(double /* dt */)
{
// compute right-hand side
this->set_rhs(_rhs_);
@ -738,7 +738,7 @@ namespace ATC {
// Constructor
//--------------------------------------------------------
ThermostatGlcFs::ThermostatGlcFs(AtomicRegulator * thermostat,
int lambdaMaxIterations,
int /* lambdaMaxIterations */,
const string & regulatorPrefix) :
RegulatorMethod(thermostat,regulatorPrefix),
lambdaSolver_(NULL),
@ -1225,7 +1225,7 @@ namespace ATC {
// fixed (uncoupled) nodes
//--------------------------------------------------------
void ThermostatIntegratorFlux::set_thermostat_rhs(DENS_MAT & rhs,
double dt)
double /* dt */)
{
// only tested with flux != 0 + ess bc = 0
@ -1586,7 +1586,7 @@ namespace ATC {
//--------------------------------------------------------
void ThermostatIntegratorFixed::add_to_energy(const DENS_MAT & nodalLambdaPower,
DENS_MAT & deltaEnergy,
double dt)
double /* dt */)
{
deltaEnergy.resize(nNodes_,1);
@ -2387,7 +2387,7 @@ namespace ATC {
// determines the power exerted by the Hoover
// thermostat at each FE node
//--------------------------------------------------------
void ThermostatHooverVerlet::add_to_lambda_power(const DENS_MAT & myLambdaForce,
void ThermostatHooverVerlet::add_to_lambda_power(const DENS_MAT & /* myLambdaForce */,
double dt)
{
_myNodalLambdaPower_ = nodalAtomicHooverLambdaPower_->quantity();
@ -2593,7 +2593,7 @@ namespace ATC {
// determines the power exerted by the Hoover
// thermostat at each FE node
//--------------------------------------------------------
void ThermostatHooverVerletFiltered::add_to_lambda_power(const DENS_MAT & myLambdaForce,
void ThermostatHooverVerletFiltered::add_to_lambda_power(const DENS_MAT & /* myLambdaForce */,
double dt)
{
_myNodalLambdaPower_ = nodalAtomicHooverLambdaPower_->quantity();

8
lib/atc/Thermostat.h
View File

@ -128,7 +128,7 @@ namespace ATC {
virtual void apply_post_corrector(double dt);
/** compute boundary flux, requires thermostat input since it is part of the coupling scheme */
virtual void compute_boundary_flux(FIELDS & fields)
virtual void compute_boundary_flux(FIELDS & /* fields */)
{boundaryFlux_[TEMPERATURE] = 0.;};
/** get data for output */
@ -540,7 +540,7 @@ namespace ATC {
virtual void apply_post_corrector(double dt);
/** compute boundary flux, requires thermostat input since it is part of the coupling scheme */
virtual void compute_boundary_flux(FIELDS & fields)
virtual void compute_boundary_flux(FIELDS & /* fields */)
{boundaryFlux_[TEMPERATURE] = 0.;};
/** determine if local shape function matrices are needed */
@ -917,7 +917,7 @@ namespace ATC {
virtual void finish() {};
/** compute boundary flux, requires thermostat input since it is part of the coupling scheme */
virtual void compute_boundary_flux(FIELDS & fields)
virtual void compute_boundary_flux(FIELDS & /* fields */)
{boundaryFlux_[TEMPERATURE] = 0.;};
protected:
@ -1022,7 +1022,7 @@ namespace ATC {
virtual void finish() {};
/** compute boundary flux, requires thermostat input since it is part of the coupling scheme */
virtual void compute_boundary_flux(FIELDS & fields)
virtual void compute_boundary_flux(FIELDS & /* fields */)
{boundaryFlux_[TEMPERATURE] = 0.;};
protected:

4
lib/atc/TimeFilter.cpp
View File

@ -40,7 +40,7 @@ namespace ATC {
// modify
// parses input commands
//--------------------------------------------------------
bool TimeFilterManager::modify(int narg, char ** arg)
bool TimeFilterManager::modify(int /* narg */, char ** arg)
{
bool foundMatch = false;
@ -210,7 +210,7 @@ namespace ATC {
}
else if (filterType_ == STEP_FILTER) {
newTimeFilter = new TimeFilterStep(*this);
}
} else newTimeFilter = NULL;
}
else { // default to return base class
newTimeFilter = new TimeFilter(*this);

99
lib/atc/TimeFilter.h
View File

@ -143,62 +143,62 @@ namespace ATC {
virtual void initialize(){};
/** pre time integration with a target for an initial condition */
virtual void initialize(const MATRIX & target){initialize();};
virtual void initialize(const MATRIX & /* target */){initialize();};
/** Step 1:
apply first step in a time filter update in the pre integration phase */
virtual void apply_pre_step1(MATRIX & filteredQuantity,
virtual void apply_pre_step1(MATRIX & /* filteredQuantity */,
const MATRIX & unFilteredQuantity,
double dt)
double /* dt */)
{ TimeFilter::unFilteredQuantityOld_ = unFilteredQuantity;}
/** Step 2:
apply second step in a time filter update in pre integration phase */
virtual void apply_pre_step2(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_pre_step2(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** Step 3:
apply first step in a time filter update in post integration phase */
virtual void apply_post_step1(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt)
double /* dt */)
{ filteredQuantity = unFilteredQuantity;};
/** Step 4:
apply second step in a time filter update in post integration phase */
virtual void apply_post_step2(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt)
double /* dt */)
{ filteredQuantity = unFilteredQuantity;}
/** coefficient multipling unfiltered terms in apply_pre_step1 method */
virtual double unfiltered_coefficient_pre_s1(double dt){return 0.;};
virtual double unfiltered_coefficient_pre_s1(double /* dt */){return 0.;};
/** coefficient multipling old filtered terms in apply_pre_step1 method */
virtual double filtered_coefficient_pre_s1(double dt){return 0.;};
virtual double filtered_coefficient_pre_s1(double /* dt */){return 0.;};
/** coefficient multipling unfiltered terms in apply_post_step1 method */
virtual double unfiltered_coefficient_post_s1(double dt){return 0.;};
virtual double unfiltered_coefficient_post_s1(double /* dt */){return 0.;};
/** coefficient multipling old filtered terms in apply_post_step1 method */
virtual double filtered_coefficient_post_s1(double dt){return 0.;};
virtual double filtered_coefficient_post_s1(double /* dt */){return 0.;};
/** coefficient multipling unfiltered terms in apply_pre_step2 method */
virtual double unfiltered_coefficient_pre_s2(double dt){return 0.;};
virtual double unfiltered_coefficient_pre_s2(double /* dt */){return 0.;};
/** coefficient multipling old filtered terms in apply_pre_step2 method */
virtual double filtered_coefficient_pre_s2(double dt){return 0.;};
virtual double filtered_coefficient_pre_s2(double /* dt */){return 0.;};
/** coefficient multipling unfiltered terms in apply_post_step2 method */
virtual double unfiltered_coefficient_post_s2(double dt){return 0.;};
virtual double unfiltered_coefficient_post_s2(double /* dt */){return 0.;};
/** coefficient multipling old filtered terms in apply_post_step2 method */
virtual double filtered_coefficient_post_s2(double dt){return 0.;};
virtual double filtered_coefficient_post_s2(double /* dt */){return 0.;};
/** rate of filtered quantity to be called in post integration phase */
virtual void rate(MATRIX & rate,
const MATRIX & filteredQuantity,
const MATRIX & /* filteredQuantity */,
const MATRIX & unFilteredQuantity,
double dt = 0.0)
{ rate = 1/dt*(unFilteredQuantity - TimeFilter::unFilteredQuantityOld_);};
@ -243,30 +243,36 @@ namespace ATC {
// destructor
virtual ~TimeFilterExponential(){};
/** apply first step in a time filter update in the pre integration phase */
virtual void apply_pre_step1(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_pre_step1(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** apply second step in a time filter update in pre integration phase */
virtual void apply_pre_step2(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_pre_step2(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** apply first step in a time filter update in post integration phase */
virtual void apply_post_step1(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_post_step1(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** apply second step in a time filter update in post integration phase */
virtual void apply_post_step2(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_post_step2(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** time rate of filtered quantity */
virtual void rate(MATRIX & rate,
const MATRIX & filteredQuantity,
const MATRIX & unfilteredQuantity,
double dt = 0)
const MATRIX & filteredQuantity,
const MATRIX & unfilteredQuantity,
double /* dt */)
{ double tau = TimeFilter::filterScale_;
rate = 1/tau*(unfilteredQuantity - filteredQuantity); };
virtual void rate(MATRIX & rate,
const MATRIX & filteredQuantity,
const MATRIX & unfilteredQuantity)
{ double tau = TimeFilter::filterScale_;
rate = 1/tau*(unfilteredQuantity - filteredQuantity); };
@ -702,19 +708,19 @@ namespace ATC {
virtual void initialize(const MATRIX & target);
/** apply first step in a time filter update in the pre integration phase */
virtual void apply_pre_step1(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_pre_step1(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** apply second step in a time filter update in pre integration phase */
virtual void apply_pre_step2(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_pre_step2(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** apply first step in a time filter update in post integration phase */
virtual void apply_post_step1(MATRIX & filteredQuantity,
const MATRIX & unFilteredQuantity,
double dt) {};
virtual void apply_post_step1(MATRIX & /* filteredQuantity */,
const MATRIX & /* unFilteredQuantity */,
double /* dt */) {};
/** apply second step in a time filter update in post integration phase */
virtual void apply_post_step2(MATRIX & filteredQuantity,
@ -726,9 +732,14 @@ namespace ATC {
/** time rate of filtered quantity */
virtual void rate(MATRIX & rate,
const MATRIX & filteredQuantity,
const MATRIX & unfilteredQuantity,
double dt = 0)
const MATRIX & filteredQuantity,
const MATRIX & unfilteredQuantity,
double /* dt */)
{ rate = 1/elapsedTime_*(unfilteredQuantity - filteredQuantity); }
virtual void rate(MATRIX & rate,
const MATRIX & filteredQuantity,
const MATRIX & unfilteredQuantity)
{ rate = 1/elapsedTime_*(unfilteredQuantity - filteredQuantity); }
protected:

30
lib/atc/TimeIntegrator.h
View File

@ -31,13 +31,13 @@ namespace ATC {
virtual void construct_transfers(){};
/** Predictor phase, Verlet first step for velocity */
virtual void init_integrate_velocity(double dt){};
virtual void init_integrate_velocity(double /* dt */){};
/** Predictor phase, Verlet first step for position */
virtual void init_integrate_position(double dt){};
virtual void init_integrate_position(double /* dt */){};
/** Corrector phase, Verlet second step for velocity */
virtual void final_integrate(double dt){};
virtual void final_integrate(double /* dt */){};
};
@ -128,7 +128,7 @@ namespace ATC {
virtual ~TimeIntegrator();
/** parser/modifier */
virtual bool modify(int narg, char **arg){return false;};
virtual bool modify(int /* narg */, char ** /* arg */){return false;};
/** create objects to implement requested numerical method */
virtual void construct_methods() = 0;
@ -251,26 +251,26 @@ namespace ATC {
// time step methods, corresponding to ATC_Coupling and TimeIntegrator
/** first part of pre_initial_integrate */
virtual void pre_initial_integrate1(double dt){};
virtual void pre_initial_integrate1(double /* dt */){};
/** second part of pre_initial_integrate */
virtual void pre_initial_integrate2(double dt){};
virtual void pre_initial_integrate2(double /* dt */){};
/** first part of post_initial_integrate */
virtual void post_initial_integrate1(double dt){};
virtual void post_initial_integrate1(double /* dt */){};
/** second part of post_initial_integrate */
virtual void post_initial_integrate2(double dt){};
virtual void post_initial_integrate2(double /* dt */){};
/** first part of pre_final_integrate */
virtual void pre_final_integrate1(double dt){};
virtual void pre_final_integrate1(double /* dt */){};
/** second part of pre_final_integrate */
virtual void pre_final_integrate2(double dt){};
virtual void pre_final_integrate2(double /* dt */){};
/** first part of post_final_integrate */
virtual void post_final_integrate1(double dt){};
virtual void post_final_integrate1(double /* dt */){};
/** second part of post_final_integrate */
virtual void post_final_integrate2(double dt){};
virtual void post_final_integrate2(double /* dt */){};
/** third part of post_final_integrate */
virtual void post_final_integrate3(double dt){};
virtual void post_final_integrate3(double /* dt */){};
/** checks to see if first RHS computation is needed */
virtual bool has_final_predictor() {return false;};
@ -282,9 +282,9 @@ namespace ATC {
/** post processing step */
virtual void post_process(){};
/** add output data */
virtual void output(OUTPUT_LIST & outputData){};
virtual void output(OUTPUT_LIST & /* outputData */){};
/** pack persistent fields */
virtual void pack_fields(RESTART_LIST & data){};
virtual void pack_fields(RESTART_LIST & /* data */){};
/** finalize any states */
virtual void finish(){};

8
lib/atc/TransferLibrary.cpp
View File

@ -705,7 +705,7 @@ namespace ATC {
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
ReducedSparseMatrix::ReducedSparseMatrix(ATC_Method * atc,
ReducedSparseMatrix::ReducedSparseMatrix(ATC_Method * /* atc */,
SPAR_MAN * source,
LargeToSmallAtomMap * map) :
SparseMatrixTransfer<double>(),
@ -782,7 +782,7 @@ namespace ATC {
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
RowMappedSparseMatrixVector::RowMappedSparseMatrixVector(ATC_Method * atc,
RowMappedSparseMatrixVector::RowMappedSparseMatrixVector(ATC_Method * /* atc */,
VectorDependencyManager<SPAR_MAT * > * source,
LargeToSmallAtomMap * map) :
VectorTransfer<SPAR_MAT * >(),
@ -846,7 +846,7 @@ namespace ATC {
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
MappedDiagonalMatrix::MappedDiagonalMatrix(ATC_Method * atc,
MappedDiagonalMatrix::MappedDiagonalMatrix(ATC_Method * /* atc */,
DIAG_MAN * source,
LargeToSmallAtomMap * map) :
DiagonalMatrixTransfer<double>(),
@ -892,7 +892,7 @@ namespace ATC {
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
MappedQuantity::MappedQuantity(ATC_Method * atc,
MappedQuantity::MappedQuantity(ATC_Method * /* atc */,
DENS_MAN * source,
LargeToSmallMap * map) :
DenseMatrixTransfer<double>(),

2
lib/atc/TransferOperator.cpp
View File

@ -868,7 +868,7 @@ namespace ATC {
//--------------------------------------------------------
// Constructor
//--------------------------------------------------------
MatToGradBySparse::MatToGradBySparse(ATC_Method * atc,
MatToGradBySparse::MatToGradBySparse(ATC_Method * /* atc */,
DENS_MAN * source,
VectorDependencyManager<SPAR_MAT * > * gradientMatrices) :
MatToMatTransfer<double>(source),

60
lib/atc/TransferOperator.h
View File

@ -42,43 +42,43 @@ namespace ATC {
/** sets the quantity to a given value */
virtual void operator=(const DenseMatrix<T> & target)
virtual void operator=(const DenseMatrix<T> & /* target */)
{throw ATC_Error("DenseMatrixTransfer::set_quantity - Cannot modify transfer-based matrices");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("DenseMatrixTransfer::operator= - Cannot modify transfer-based matrices");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DenseMatrix<T> & addition)
virtual void operator+=(const DenseMatrix<T> & /* addition */)
{throw ATC_Error("DenseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("DenseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DenseMatrix<T> & subtraction)
virtual void operator-=(const DenseMatrix<T> & /* subtraction */)
{throw ATC_Error("DenseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("DenseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DenseMatrix<T> & multiplier)
virtual void operator*=(const DenseMatrix<T> & /* multiplier */)
{throw ATC_Error("DenseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("DenseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DenseMatrix<T> & divisor)
virtual void operator/=(const DenseMatrix<T> & /* divisor */)
{throw ATC_Error("DenseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("DenseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
protected:
@ -113,43 +113,43 @@ namespace ATC {
/** sets the quantity to a given value */
virtual void operator=(const SparseMatrix<T> & target)
virtual void operator=(const SparseMatrix<T> & /* target */)
{throw ATC_Error("SparseMatrixTransfer::set_quantity - Cannot modify transfer-based matrices");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("SparseMatrixTransfer::operator= - Cannot modify transfer-based matrices");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const SparseMatrix<T> & addition)
virtual void operator+=(const SparseMatrix<T> & /* addition */)
{throw ATC_Error("SparseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("SparseMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const SparseMatrix<T> & subtraction)
virtual void operator-=(const SparseMatrix<T> & /* subtraction */)
{throw ATC_Error("SparseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("SparseMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const SparseMatrix<T> & multiplier)
virtual void operator*=(const SparseMatrix<T> & /* multiplier */)
{throw ATC_Error("SparseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("SparseMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const SparseMatrix<T> & divisor)
virtual void operator/=(const SparseMatrix<T> & /* divisor */)
{throw ATC_Error("SparseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("SparseMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
protected:
@ -184,43 +184,43 @@ namespace ATC {
/** sets the quantity to a given value */
virtual void operator=(const DiagonalMatrix<T> & target)
virtual void operator=(const DiagonalMatrix<T> & /* target */)
{throw ATC_Error("DiagonalMatrixTransfer::set_quantity - Cannot modify transfer-based matrices");};
/** sets the quantity to a given constant value */
virtual void operator=(const T & target)
virtual void operator=(const T & /* target */)
{throw ATC_Error("DiagonalMatrixTransfer::operator= - Cannot modify transfer-based matrices");};
/** adds the given data to the Lammps quantity */
virtual void operator+=(const DiagonalMatrix<T> & addition)
virtual void operator+=(const DiagonalMatrix<T> & /* addition */)
{throw ATC_Error("DiagonalMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** adds the scalar data to the Lammps quantity for AtC atoms */
virtual void operator+=(T addition)
virtual void operator+=(T /* addition */)
{throw ATC_Error("DiagonalMatrixTransfer::operator+= - Cannot modify transfer-based matrices");};
/** subtracts the given data from the Lammps quantity */
virtual void operator-=(const DiagonalMatrix<T> & subtraction)
virtual void operator-=(const DiagonalMatrix<T> & /* subtraction */)
{throw ATC_Error("DiagonalMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** subtracts the scalar data from the Lammps quantity for AtC atoms */
virtual void operator-=(T subtraction)
virtual void operator-=(T /* subtraction */)
{throw ATC_Error("DiagonalMatrixTransfer::operator-= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(const DiagonalMatrix<T> & multiplier)
virtual void operator*=(const DiagonalMatrix<T> & /* multiplier */)
{throw ATC_Error("DiagonalMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator*=(T multiplier)
virtual void operator*=(T /* multiplier */)
{throw ATC_Error("DiagonalMatrixTransfer::operator*= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(const DiagonalMatrix<T> & divisor)
virtual void operator/=(const DiagonalMatrix<T> & /* divisor */)
{throw ATC_Error("DiagonalMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
/** multiples the Lammps quantity by the given data, input is indexed in AtC atom counts */
virtual void operator/=(T divisor)
virtual void operator/=(T /* divisor */)
{throw ATC_Error("DiagonalMatrixTransfer::operator/= - Cannot modify transfer-based matrices");};
protected:

4
lib/atc/Utility.h
View File

@ -59,10 +59,10 @@ namespace ATC_Utility
return ( (dblL > dblR) ||
((dblL <= (dblR + \
std::numeric_limits<double>::epsilon() * \
tolMult * std::max(abs(dblL), abs(dblR)))) &&
tolMult * std::max(fabs(dblL), fabs(dblR)))) &&
(dblR <= (dblL + \
std::numeric_limits<double>::epsilon() * \
tolMult * std::max(abs(dblL), abs(dblR))))));
tolMult * std::max(fabs(dblL), fabs(dblR))))));
}
inline double tolerance(double x, double tol = parsetol_) {

2
lib/atc/Vector.h
View File

@ -61,7 +61,7 @@ public:
//* performs a matrix-vector multiply with default naive implementation
template<typename T>
void MultMv(const Matrix<T> &A, const Vector<T> &v, DenseVector<T> &c,
const bool At, T a, T b)
const bool At, T /* a */, T b)
{
const INDEX sA[2] = {A.nRows(), A.nCols()}; // m is sA[At] k is sA[!At]
const INDEX M=sA[At], K=sA[!At];

2
lib/atc/ViscousStress.cpp
View File

@ -34,7 +34,7 @@ ViscousStressConstant::ViscousStressConstant(fstream &fileId)
// compute the stress at N integration points from the velocity gradients
// T_{ij} = viscosity * du_i/dx_j
//=============================================================================
void ViscousStressConstant::viscous_stress(const FIELD_MATS &fields,
void ViscousStressConstant::viscous_stress(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &sigma)
{

8
lib/atc/ViscousStress.h
View File

@ -22,17 +22,17 @@ namespace ATC {
virtual ~ViscousStress() {};
virtual void initialize(void){};
//* Returns parameter values, (Nothing uses this).
virtual void parameters(std::map<std::string,double> &parameters) {}
virtual void parameters(std::map<std::string,double> & /* parameters */) {}
//* Computes viscous stress given a strain rate tensor.
//* Units: mvv/L^3 (i.e. for units Real: g/(mol ps^2 A^2) )
virtual void viscous_stress(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
DENS_MAT_VEC &stress)=0;
virtual void viscosity(const FIELD_MATS & fields,
DENS_MAT & coefs) const
virtual void viscosity(const FIELD_MATS & /* fields */,
DENS_MAT & /* coefs */) const
{throw ATC_Error("ViscousStress::viscosity: unimplemented function");}
//* Returns the derivative of the stress tensor for a given strain-rate tensor.
virtual void tangent(const MATRIX &F, MATRIX &C) const
virtual void tangent(const MATRIX & /* F */, MATRIX & /* C */) const
{throw ATC_Error("ViscousStress::tangent: unimplemented function");}
};

58
lib/atc/WeakEquation.h
View File

@ -32,52 +32,52 @@ class WeakEquation {
/** integrand that used to form the energy */
virtual bool has_E_integrand(void) const {return false;}
virtual void E_integrand(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const Material * material,
DENS_MAT &energy ) const {};
virtual void E_integrand(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * /* material */,
DENS_MAT & /* energy */ ) const {};
/** density that used to form the mass matrix */
virtual bool has_M_integrand(void) const {return false;}
virtual void M_integrand(const FIELD_MATS &fields,
const Material * material,
DENS_MAT &density ) const {};
virtual void M_integrand(const FIELD_MATS & /* fields */,
const Material * /* material */,
DENS_MAT & /* density */ ) const {};
/** flux that is integrated with B = Grad N as its weight */
virtual bool has_B_integrand(void) const {return false;}
virtual void B_integrand(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const Material * material,
DENS_MAT_VEC &flux) const {};
virtual void B_integrand(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * /* material */,
DENS_MAT_VEC & /* flux */) const {};
/** flux that is integrated with N as its weight */
virtual bool has_N_integrand(void) const {return false;}
// N_integrand bool is for masking in FE_Engine
virtual bool N_integrand(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const Material * material,
DENS_MAT &flux) const {return false;};
virtual bool N_integrand(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * /* material */,
DENS_MAT & /* flux */) const {return false;};
/** stiffness matrix */
// linear
virtual void BB_tangent_coefficients(const FieldName field,
const Material * material,
DENS_MAT &coefs) const {};
virtual void NN_tangent_coefficients(const FieldName field,
const Material * material,
DENS_MAT &coefs) const {};
virtual void BB_tangent_coefficients(const FieldName /* field */,
const Material * /* material */,
DENS_MAT & /* coefs */) const {};
virtual void NN_tangent_coefficients(const FieldName /* field */,
const Material * /* material */,
DENS_MAT & /* coefs */) const {};
// non-linear
virtual bool has_BB_tangent_coefficients(void) const {return false;}
virtual void BB_tangent_coefficients(const FieldName field,
const FIELD_MATS &fields,
const Material * material,
DENS_MAT &coefs) const {};
virtual void BB_tangent_coefficients(const FieldName /* field */,
const FIELD_MATS & /* fields */,
const Material * /* material */,
DENS_MAT & /* coefs */) const {};
virtual bool has_NN_tangent_coefficients(void) const {return false;}
virtual void NN_tangent_coefficients(const FieldName field,
const FIELD_MATS &fields,
const Material * material,
DENS_MAT &coefs) const {};
virtual void NN_tangent_coefficients(const FieldName /* field */,
const FIELD_MATS & /* fields */,
const Material * /* material */,
DENS_MAT & /* coefs */) const {};
/** type of equation */
PDE_Type type(void) const {return type_;}

2
lib/atc/WeakEquationChargeDiffusion.cpp
View File

@ -26,7 +26,7 @@ WeakEquationChargeDiffusion::~WeakEquationChargeDiffusion(void)
//---------------------------------------------------------------------
void WeakEquationChargeDiffusion::M_integrand(
const FIELD_MATS &fields,
const Material * material,
const Material * /* material */,
DENS_MAT & capacity ) const
{
FIELD_MATS::const_iterator rhoField = fields.find(CHARGE_DENSITY);

10
lib/atc/WeakEquationDiffusion.cpp
View File

@ -26,7 +26,7 @@ WeakEquationDiffusion::~WeakEquationDiffusion(void)
//---------------------------------------------------------------------
void WeakEquationDiffusion::M_integrand(
const FIELD_MATS &fields,
const Material * material,
const Material * /* material */,
DENS_MAT & capacity ) const
{
FIELD_MATS::const_iterator rhoField = fields.find(SPECIES_CONCENTRATION);
@ -38,10 +38,10 @@ void WeakEquationDiffusion::M_integrand(
// compute flux
//--------------------------------------------------------------
void WeakEquationDiffusion::B_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const Material * material,
DENS_MAT_VEC &flux) const
const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * /* material */,
DENS_MAT_VEC & /* flux */) const
{
// material->diffusion_flux(fields, grad_fields, flux[SPECIES_CONCENTRATION]);
}

6
lib/atc/WeakEquationElectronContinuity.cpp
View File

@ -24,7 +24,7 @@ WeakEquationElectronContinuity::~WeakEquationElectronContinuity(void)
//---------------------------------------------------------------------
void WeakEquationElectronContinuity::M_integrand(
const FIELD_MATS &fields,
const Material * material,
const Material * /* material */,
DENS_MAT & density ) const
{
FIELD_MATS::const_iterator nField = fields.find(ELECTRON_DENSITY);
@ -72,7 +72,7 @@ WeakEquationElectronEquilibrium::~WeakEquationElectronEquilibrium(void)
//---------------------------------------------------------------------
void WeakEquationElectronEquilibrium::M_integrand(
const FIELD_MATS &fields,
const Material * material,
const Material * /* material */,
DENS_MAT & density ) const
{
FIELD_MATS::const_iterator nField = fields.find(ELECTRON_DENSITY);
@ -85,7 +85,7 @@ void WeakEquationElectronEquilibrium::M_integrand(
bool WeakEquationElectronEquilibrium::N_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * material,
DENS_MAT &flux) const
{

2
lib/atc/WeakEquationElectronMomentum.cpp
View File

@ -79,7 +79,7 @@ void WeakEquationElectronMomentum::M_integrand(
//--------------------------------------------------------------
void WeakEquationElectronMomentum::B_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * material,
DENS_MAT_VEC &flux) const
{

8
lib/atc/WeakEquationElectronMomentum.h
View File

@ -78,10 +78,10 @@ namespace ATC{
/** flux that is integrated with grad N as its weight */
virtual bool has_B_integrand(void) const {return false;}
virtual void B_integrand(const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const Material * material,
DENS_MAT_VEC &flux) const {};
virtual void B_integrand(const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * /* material */,
DENS_MAT_VEC &/* flux */) const {};
/** flux that is integrated with N as its weight */
virtual bool has_N_integrand(void) const {return true;}

4
lib/atc/WeakEquationElectronTemperature.cpp
View File

@ -26,7 +26,7 @@ WeakEquationElectronTemperature::~WeakEquationElectronTemperature(void)
//---------------------------------------------------------------------
void WeakEquationElectronTemperature::E_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * material,
DENS_MAT & energy ) const
{
@ -61,7 +61,7 @@ void WeakEquationElectronTemperature::B_integrand(
//---------------------------------------------------------------------
bool WeakEquationElectronTemperature::N_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * material,
DENS_MAT &flux) const
{

10
lib/atc/WeakEquationMassDiffusion.cpp
View File

@ -26,7 +26,7 @@ WeakEquationMassDiffusion::~WeakEquationMassDiffusion(void)
//---------------------------------------------------------------------
void WeakEquationMassDiffusion::M_integrand(
const FIELD_MATS &fields,
const Material * material,
const Material * /* material */,
DENS_MAT & capacity ) const
{
FIELD_MATS::const_iterator dField = fields.find(MASS_DENSITY);
@ -38,10 +38,10 @@ void WeakEquationMassDiffusion::M_integrand(
// compute flux
//--------------------------------------------------------------
void WeakEquationMassDiffusion::B_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const Material * material,
DENS_MAT_VEC &flux) const
const FIELD_MATS & /* fields */,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * /* material */,
DENS_MAT_VEC & /* flux */) const
{
// material->mass_flux(fields, grad_fields, flux[MASS_DENSITY]);
}

6
lib/atc/WeakEquationMomentum.cpp
View File

@ -45,7 +45,7 @@ void WeakEquationMomentum::B_integrand(
//--------------------------------------------------------------
bool WeakEquationMomentum::N_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * material,
DENS_MAT &flux) const
{
@ -137,7 +137,7 @@ void WeakEquationMomentumDiffusion::B_integrand(
//---------------------------------------------------------------------
void WeakEquationMomentumDiffusion::BB_tangent_coefficients(
const FieldName field,
const FieldName /* field */,
const FIELD_MATS &fields,
const Material* material,
DENS_MAT &coefs) const
@ -148,7 +148,7 @@ void WeakEquationMomentumDiffusion::BB_tangent_coefficients(
//--------------------------------------------------------------
bool WeakEquationMomentumDiffusion::N_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * material,
DENS_MAT &flux) const
{

2
lib/atc/WeakEquationPhononTemperature.cpp
View File

@ -26,7 +26,7 @@ WeakEquationPhononTemperature::~WeakEquationPhononTemperature(void)
//---------------------------------------------------------------------
void WeakEquationPhononTemperature::E_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &gradFields,
const GRAD_FIELD_MATS & /* gradFields */,
const Material * material,
DENS_MAT &energy) const
{

10
lib/atc/WeakEquationPoisson.cpp
View File

@ -36,7 +36,7 @@ void WeakEquationPoisson::B_integrand(
//---------------------------------------------------------------------
void WeakEquationPoisson::BB_tangent_coefficients(
const FieldName field,
const FieldName /* field */,
const FIELD_MATS &fields,
const Material* material,
DENS_MAT &coefs) const
@ -47,7 +47,7 @@ void WeakEquationPoisson::BB_tangent_coefficients(
//---------------------------------------------------------------------
bool WeakEquationPoisson::N_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * material,
DENS_MAT &flux) const
{
@ -56,7 +56,7 @@ bool WeakEquationPoisson::N_integrand(
//---------------------------------------------------------------------
void WeakEquationPoisson::NN_tangent_coefficients(
const FieldName field,
const FieldName /* field */,
const FIELD_MATS &fields,
const Material* material,
DENS_MAT &coefs) const
@ -78,8 +78,8 @@ WeakEquationPoissonConstantRHS::WeakEquationPoissonConstantRHS()
//---------------------------------------------------------------------
bool WeakEquationPoissonConstantRHS::N_integrand(
const FIELD_MATS &fields,
const GRAD_FIELD_MATS &grad_fields,
const Material * material,
const GRAD_FIELD_MATS & /* grad_fields */,
const Material * /* material */,
DENS_MAT &flux) const
{

8
lib/atc/WeakEquationPoisson.h
View File

@ -98,10 +98,10 @@ class WeakEquationPoissonConstantRHS : public WeakEquationPoisson {
/** rhs is constant */
virtual bool has_NN_tangent_coefficients(void) const {return false;}
virtual void NN_tangent_coefficients(const FieldName field,
const FIELD_MATS &fields,
const Material * material,
DENS_MAT &coefs) const {};
virtual void NN_tangent_coefficients(const FieldName /* field */,
const FIELD_MATS & /* fields */,
const Material * /* material */,
DENS_MAT & /* coefs */) const {};
virtual std::set<std::string> needs_material_functions(void) const
{

4
lib/atc/WeakEquationSchrodinger.cpp
View File

@ -23,7 +23,7 @@ WeakEquationSchrodinger::~WeakEquationSchrodinger(void)
//---------------------------------------------------------------------
void WeakEquationSchrodinger::BB_tangent_coefficients(
const FieldName field,
const FieldName /* field */,
const FIELD_MATS & fields,
const Material* material,
DENS_MAT &coefs) const
@ -33,7 +33,7 @@ void WeakEquationSchrodinger::BB_tangent_coefficients(
//---------------------------------------------------------------------
void WeakEquationSchrodinger::NN_tangent_coefficients(
const FieldName field,
const FieldName /* field */,
const FIELD_MATS & fields,
const Material* material,
DENS_MAT & V) const

1
lib/message/cslib/src/cslib.cpp
View File

@ -641,6 +641,7 @@ void CSlib::onefield(int ftype, int flen, int &nbytes, int &nbytesround)
else if (ftype == 3) bigbytes = biglen * sizeof(float);
else if (ftype == 4) bigbytes = biglen * sizeof(double);
else if (ftype == 5) bigbytes = biglen * sizeof(char);
else bigbytes = 0;
bigbytesround = roundup(bigbytes,8);
if (nbuf + bigbytesround > INT_MAX)

24
src/USER-ATC/fix_atc.cpp
View File

@ -581,7 +581,7 @@ void FixATC::min_setup(int vflag)
setup(vflag);
}
void FixATC::setup(int vflag)
void FixATC::setup(int /* vflag */)
{
comm->forward_comm_fix(this);
@ -642,7 +642,7 @@ void FixATC::grow_arrays(int nmax)
atc_->grow_arrays(nmax);
}
void FixATC::copy_arrays(int i, int j, int delflag)
void FixATC::copy_arrays(int i, int j, int /* delflag */)
{
atc_->copy_arrays(i,j);
}
@ -675,7 +675,7 @@ void FixATC::unpack_forward_comm(int n, int first, double *buf)
pack values in local atom-based arrays for restart file
------------------------------------------------------------------------- */
int FixATC::pack_restart(int i, double *buf){
int FixATC::pack_restart(int /* i */, double * /* buf */){
return 0;
}
@ -683,7 +683,7 @@ int FixATC::pack_restart(int i, double *buf){
unpack values from atom->extra array to restart the fix
------------------------------------------------------------------------- */
void FixATC::unpack_restart(int nlocal, int nth){
void FixATC::unpack_restart(int /* nlocal */, int /* nth */){
}
/* ----------------------------------------------------------------------
@ -698,7 +698,7 @@ int FixATC::maxsize_restart(){
size of atom nlocal's restart data
------------------------------------------------------------------------- */
int FixATC::size_restart(int nlocal){
int FixATC::size_restart(int /* nlocal */){
return 0;
}
@ -706,7 +706,7 @@ int FixATC::size_restart(int nlocal){
pack entire state of Fix into one write
------------------------------------------------------------------------- */
void FixATC::write_restart(FILE *fp){
void FixATC::write_restart(FILE * /* fp */){
char ** args = new char*[2];
args[0] = new char[50];
@ -728,7 +728,7 @@ void FixATC::write_restart(FILE *fp){
use state info from restart file to restart the Fix
------------------------------------------------------------------------- */
void FixATC::restart(char *buf){
void FixATC::restart(char * /* buf */){
char ** args = new char*[2];
args[0] = new char[50];
@ -750,7 +750,7 @@ void FixATC::restart(char *buf){
allow for both per-type and per-atom mass
------------------------------------------------------------------------- */
void FixATC::initial_integrate(int vflag)
void FixATC::initial_integrate(int /* vflag */)
{
try {
atc_->pre_init_integrate();
@ -836,7 +836,7 @@ void FixATC::pre_neighbor()
}
}
/* ---------------------------------------------------------------------- */
void FixATC::pre_force(int vflag)
void FixATC::pre_force(int /* vflag */)
{
try {
@ -848,7 +848,7 @@ void FixATC::pre_force(int vflag)
}
}
/* ---------------------------------------------------------------------- */
void FixATC::post_force(int vflag)
void FixATC::post_force(int /* vflag */)
{
try {
@ -884,7 +884,7 @@ void FixATC::setup_pre_neighbor()
}
}
/* ---------------------------------------------------------------------- */
void FixATC::min_pre_force(int vflag)
void FixATC::min_pre_force(int /* vflag */)
{
try {
atc_->min_pre_force();
@ -896,7 +896,7 @@ void FixATC::min_pre_force(int vflag)
}
/* ---------------------------------------------------------------------- */
void FixATC::min_post_force(int vflag)
void FixATC::min_post_force(int /* vflag */)
{
try {
atc_->min_post_force();