Commit 0c3f0329 authored by gsell's avatar gsell
Browse files

cleanup: comment-out unused variables in method definitions

parent 07185905
// -*- C++ -*-
/***************************************************************************
*
* The IPPL Framework
*
*
* Visit http://people.web.psi.ch/adelmann/ for more details
*
***************************************************************************/
#ifndef ANTI_SYM_TENZOR_H
......@@ -300,7 +296,7 @@ public:
AntiSymTenzor(DontInitialize) {}
// Construct from a Tenzor: still a no-op here:
AntiSymTenzor( const Tenzor<T,1>& t ) { }
AntiSymTenzor( const Tenzor<T,1>& /*t*/) { }
~AntiSymTenzor() {}
......@@ -418,7 +414,7 @@ public:
//----------------------------------------------------------------------
// Comparison operators.
bool operator==(const AntiSymTenzor<T,1>& that) const {
bool operator==(const AntiSymTenzor<T,1>& /*that*/) const {
return true;
}
bool operator!=(const AntiSymTenzor<T,1>& that) const {
......@@ -480,7 +476,7 @@ inline AntiSymTenzor<T,D> transpose(const AntiSymTenzor<T,D>& rhs) {
// For D=3, det is zero, because diagonal elements are zero:
template<class T>
inline T
det(const AntiSymTenzor<T,3>& t)
det(const AntiSymTenzor<T,3>&)
{
return T(0.0);
}
......@@ -496,7 +492,7 @@ det(const AntiSymTenzor<T,2>& t)
// For D=1, det is zero, because diagonal elements are zero:
template<class T>
inline T
det(const AntiSymTenzor<T,1>& t)
det(const AntiSymTenzor<T,1>& /*t*/)
{
return T(0.0);
}
......@@ -508,7 +504,7 @@ det(const AntiSymTenzor<T,1>& t)
// Only implement for 1D, 2D, 3D:
template <class T, unsigned D>
inline Tenzor<T,D> cofactors(const AntiSymTenzor<T,D>& rhs) {
inline Tenzor<T,D> cofactors(const AntiSymTenzor<T,D>& /*rhs*/) {
PInsist(D<4, "AntiSymTenzor cofactors() function not implemented for D>3!");
return Tenzor<T,D>(-999999.999999);
}
......@@ -545,7 +541,7 @@ inline Tenzor<T,2> cofactors(const AntiSymTenzor<T,2>& rhs) {
// For D=1, cofactor is the unit tensor, because det = single tensor element
// value:
template <class T>
inline Tenzor<T,1> cofactors(const AntiSymTenzor<T,1>& rhs) {
inline Tenzor<T,1> cofactors(const AntiSymTenzor<T,1>& /*rhs*/) {
Tenzor<T,1> result = Tenzor<T,1>(1);
return result;
}
......@@ -715,9 +711,9 @@ inline std::ostream& operator<<(std::ostream& out, const AntiSymTenzor<T,D>& rhs
#endif // ANTI_SYM_TENZOR_H
/***************************************************************************
* $RCSfile: AntiSymTenzor.h,v $
* $Revision: 1.1.1.1 $
* IPPL_VERSION_ID: $Id: AntiSymTenzor.h,v 1.1.1.1 2003/01/23 07:40:24 adelmann Exp $
***************************************************************************/
// vi: set et ts=4 sw=4 sts=4:
// Local Variables:
// mode:c
// c-basic-offset: 4
// indent-tabs-mode:nil
// End:
......@@ -298,7 +298,7 @@ inline SymTenzor<T,D> transpose(const SymTenzor<T,D> &rhs) {
// Determinant: only implement for 1D, 2D, 3D:
template <class T, unsigned D>
inline T det(const SymTenzor<T,D>& rhs) {
inline T det(const SymTenzor<T,D>& /*rhs*/) {
PInsist(D<3, "Tenzor det() function not implemented for D>3!");
return T(-999999.999999);
}
......@@ -333,7 +333,7 @@ inline T det(const SymTenzor<T,1>& rhs) {
// Only implement for 1D, 2D, 3D:
template <class T, unsigned D>
inline Tenzor<T,D> cofactors(const SymTenzor<T,D>& rhs) {
inline Tenzor<T,D> cofactors(const SymTenzor<T,D>& /*rhs*/) {
PInsist(D<4, "SymTenzor cofactors() function not implemented for D>3!");
return Tenzor<T,D>(-999999.999999);
}
......@@ -368,7 +368,7 @@ inline Tenzor<T,2> cofactors(const SymTenzor<T,2>& rhs) {
// For D=1, cofactor is the unit tensor, because det = single tensor element
// value:
template <class T>
inline Tenzor<T,1> cofactors(const SymTenzor<T,1>& rhs) {
inline Tenzor<T,1> cofactors(const SymTenzor<T,1>& /*rhs*/) {
Tenzor<T,1> result = Tenzor<T,1>(1);
return result;
}
......
......@@ -392,7 +392,7 @@ template<class T1, class T2, class OP>
struct TSV_MetaAssign< AntiSymTenzor<T1,1> , AntiSymTenzor<T2,1> , OP >
{
inline static void
apply( AntiSymTenzor<T1,1>& lhs, const AntiSymTenzor<T2,1>& rhs) {
apply( AntiSymTenzor<T1,1>& /*lhs*/, const AntiSymTenzor<T2,1>& /*rhs*/) {
}
};
......@@ -400,7 +400,7 @@ template<class T1, class T2, class OP>
struct TSV_MetaAssignScalar< AntiSymTenzor<T1,1> , T2 , OP >
{
inline static void
apply( AntiSymTenzor<T1,1>& lhs, T2 rhs ) {
apply( AntiSymTenzor<T1,1>& /*lhs*/, T2 /*rhs*/) {
}
};
......
......@@ -638,7 +638,7 @@ struct TSV_MetaBinary< AntiSymTenzor<T1,1> , AntiSymTenzor<T2,1> , OP >
{
typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
inline static AntiSymTenzor<T0,1>
apply(const AntiSymTenzor<T1,1>& lhs, const AntiSymTenzor<T2,1>& rhs) {
apply(const AntiSymTenzor<T1,1>& /*lhs*/, const AntiSymTenzor<T2,1>& /*rhs*/) {
typedef typename AntiSymTenzor<T0,1>::DontInitialize T;
return AntiSymTenzor<T0,1>( T() );
}
......@@ -649,7 +649,7 @@ struct TSV_MetaBinaryScalar< AntiSymTenzor<T1,1> , T2 , OP >
{
typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
inline static AntiSymTenzor<T0,1>
apply(const AntiSymTenzor<T1,1>& lhs, T2 rhs) {
apply(const AntiSymTenzor<T1,1>& /*lhs*/, T2 /*rhs*/) {
typedef typename AntiSymTenzor<T0,1>::DontInitialize T;
return AntiSymTenzor<T0,1>( T() );
}
......@@ -660,7 +660,7 @@ struct TSV_MetaBinaryScalar< T1, AntiSymTenzor<T2,1> , OP >
{
typedef typename PETEBinaryReturn<T1,T2,OP>::type T0;
inline static AntiSymTenzor<T0,1>
apply(T1 lhs, const AntiSymTenzor<T2,1>& rhs) {
apply(T1 /*lhs*/, const AntiSymTenzor<T2,1>& /*rhs*/) {
typedef typename AntiSymTenzor<T0,1>::DontInitialize T;
return AntiSymTenzor<T0,1>( T() );
}
......
......@@ -25,7 +25,7 @@ struct TSV_MetaCross< Vektor<T1,D> , Vektor<T2,D> >
{
typedef typename PETEBinaryReturn<T1,T2,OpMultipply>::type T0;
inline static Vektor<T0,D>
apply(const Vektor<T1,D>& a, const Vektor<T2,D>& b) {
apply(const Vektor<T1,D>& /*a*/, const Vektor<T2,D>& /*b*/) {
ERRORMSG("Cross-product *only* implemented for 3D; you're trying to"
<< " do it for " << D << "D." << endl);
Ippl::abortAllNodes("...aborting from cross()");
......
......@@ -283,7 +283,7 @@ inline Tenzor<T,D> transpose(const Tenzor<T,D>& rhs) {
// Determinant: only implement for 1D, 2D, 3D:
template <class T, unsigned D>
inline T det(const Tenzor<T,D>& rhs) {
inline T det(const Tenzor<T,D>& /*rhs*/) {
PInsist(D<4, "Tenzor det() function not implemented for D>3!");
return T(-999999.999999);
}
......@@ -318,7 +318,7 @@ inline T det(const Tenzor<T,1>& rhs) {
// Only implement for 1D, 2D, 3D:
template <class T, unsigned D>
inline Tenzor<T,D> cofactors(const Tenzor<T,D>& rhs) {
inline Tenzor<T,D> cofactors(const Tenzor<T,D>& /*rhs*/) {
PInsist(D<4, "Tenzor cofactors() function not implemented for D>3!");
return Tenzor<T,D>(-999999.999999);
}
......@@ -353,7 +353,7 @@ inline Tenzor<T,2> cofactors(const Tenzor<T,2>& rhs) {
// For D=1, cofactor is the unit tensor, because det = single tensor element
// value:
template <class T>
inline Tenzor<T,1> cofactors(const Tenzor<T,1>& rhs) {
inline Tenzor<T,1> cofactors(const Tenzor<T,1>& /*rhs*/) {
Tenzor<T,1> result = Tenzor<T,1>(1);
return result;
}
......
......@@ -579,14 +579,6 @@ for_each(const IndexedBareFieldIterator<T,D>& p,
return 0;
}
template<class T, class C, unsigned int D, unsigned int D1, class T1>
inline int
for_each(const BareFieldIterator<T,D>& p,
const FillGCIfNecessaryTag<D1,T1> &, C)
{
return 0;
}
template<class T, class C, unsigned int D, class T1>
inline int
for_each(const PETE_Scalar<T>&, const FillGCIfNecessaryTag<D,T1> &, C)
......
......@@ -3,24 +3,6 @@
*
* The IPPL Framework
*
* This program was prepared by PSI.
* All rights in the program are reserved by PSI.
* Neither PSI nor the author(s)
* makes any warranty, express or implied, or assumes any liability or
* responsibility for the use of this software
*
* Visit www.amas.web.psi for more details
*
***************************************************************************/
// -*- C++ -*-
/***************************************************************************
*
* The IPPL Framework
*
*
* Visit http://people.web.psi.ch/adelmann/ for more details
*
***************************************************************************/
// include files
......@@ -364,8 +346,9 @@ template<class T>
struct OpPeriodic
{
};
template<class T>
inline void PETE_apply(const OpPeriodic<T>& e, T& a, const T& b) {a = b; }
inline void PETE_apply(const OpPeriodic<T>& /*e*/, T& a, const T& b) {a = b; }
// Special, for applying to single component of multicomponent elemental type:
template<class T>
......@@ -421,8 +404,9 @@ template<class T>
struct OpInterpolation
{
};
template<class T>
inline void PETE_apply(const OpInterpolation<T>& e, T& a, const T& b) {a = a + b; }
inline void PETE_apply(const OpInterpolation<T>& /*e*/, T& a, const T& b) {a = a + b; }
// Special, for applying to single component of multicomponent elemental type:
template<class T>
......@@ -5768,41 +5752,6 @@ void LinearExtrapolateFace<T,D,M,C>::apply( Field<T,D,M,C>& A )
LinearExtrapolateFaceBCApply(*this, A);
}
template<class T, unsigned D, class M, class C>
inline void
LinearExtrapolateFaceBCApply2(const NDIndex<D> &dest,
const NDIndex<D> &src1,
const NDIndex<D> &src2,
LField<T,D> &fill,
LinearExtrapolateFace<T,D,M,C> &ef,
int slopeMultipplier)
{
// If 'fill' is compressed and applying the boundary condition on the
// compressed value would result in no change to 'fill' we don't need to
// uncompress. For this particular type of BC (linear extrapolation), this
// result would *never* happen, so we already know we're done:
if (fill.IsCompressed()) { return; } // Yea! We're outta here.
// Build iterators for the copy:
typedef typename LField<T,D>::iterator LFI;
LFI lhs = fill.begin(dest);
LFI rhs1 = fill.begin(src1);
LFI rhs2 = fill.begin(src2);
LFI endi = fill.end(); // Used for testing end of *any* sub-range iteration
// Couldn't figure out how to use BrickExpression here. Just iterate through
// all the elements in all 3 LField iterators (which are BrickIterators) and
// do the calculation one element at a time:
for ( ; lhs != endi, rhs1 != endi, rhs2 != endi;
++lhs, ++rhs1, ++rhs2) {
*lhs = (*rhs2 - *rhs1)*slopeMultipplier + *rhs1;
}
}
// ----------------------------------------------------------------------------
// This type of boundary condition (linear extrapolation) does very much the
// same thing for any centering; Doesn't seem to be a need for specializations
......@@ -5813,9 +5762,6 @@ template<class T, unsigned D, class M, class C>
void LinearExtrapolateFaceBCApply(LinearExtrapolateFace<T,D,M,C>& ef,
Field<T,D,M,C>& A )
{
// Find the slab that is the destination.
// That is, in English, get an NDIndex spanning elements in the guard layers
// on the face associated with the LinearExtrapaloteFace object:
......@@ -6212,9 +6158,3 @@ void PatchBC<T,D,M,C>::apply( Field<T,D,M,C>& A )
//----------------------------------------------------------------------
#undef COMPONENT_APPLY_BUILTIN
/***************************************************************************
* $RCSfile: BCond.cpp,v $ $Author: adelmann $
* $Revision: 1.1.1.1 $ $Date: 2003/01/23 07:40:26 $
* IPPL_VERSION_ID: $Id: BCond.cpp,v 1.1.1.1 2003/01/23 07:40:26 adelmann Exp $
***************************************************************************/
......@@ -53,7 +53,7 @@ public:
// S = exp means we cleared out all the points previously, so we know
// we do not need to worry about repeated points
static void apply(SIndex<Dim>& SI,
static void apply(SIndex<Dim>& /*SI*/,
typename SIndex<Dim>::iterator_iv& LSI,
const SOffset<Dim>& SO,
bool result) {
......@@ -280,7 +280,7 @@ struct AssignActions { };
template<unsigned Dim>
struct AssignActions<Dim, SIExprTag<true> > {
template<class RHS>
static void fillgc(RHS &bb, const NDIndex<Dim> &domain) {
static void fillgc(RHS &bb, const NDIndex<Dim> & /*domain*/) {
// ask each field on the RHS to fill its guard cells, if necessary
//tjw3/3/99 for_each(bb, FillGCIfNecessary(domain), PETE_NullCombiner());
for_each(bb, FillGCIfNecessary(FGCINTag<Dim,double>()), PETE_NullCombiner());
......@@ -331,8 +331,8 @@ struct AssignActions<Dim, SIExprTag<false> > {
// the given domain, find where it evaluates to true, and store the
// value of that index point.
template<unsigned Dim, class RHS, class Op, bool IsExpr>
void assign(SIndex<Dim>& a, RHS b, Op, const NDIndex<Dim> &domain,
SIExprTag<IsExpr> isexpr) {
void assign(SIndex<Dim>& a, RHS b, Op, const NDIndex<Dim> &domain,
SIExprTag<IsExpr> /*isexpr*/) {
......
......@@ -812,7 +812,7 @@ struct OpMeshPeriodic
{
};
template<class T>
inline void PETE_apply(OpMeshPeriodic<T> e, T& a, T b) { a = b; }
inline void PETE_apply(OpMeshPeriodic<T> /*e*/, T& a, T b) { a = b; }
// Reflective/None:
template<class T>
......@@ -1935,7 +1935,7 @@ getDeltaCellField(Field<Vektor<MFLOAT,Dim>,Dim,
template <unsigned Dim, class MFLOAT>
Vektor<MFLOAT,Dim>*
Cartesian<Dim,MFLOAT>::
getSurfaceNormals(const NDIndex<Dim>& ndi) const
getSurfaceNormals(const NDIndex<Dim>& /*ndi*/) const
{
Vektor<MFLOAT,Dim>* surfaceNormals = new Vektor<MFLOAT,Dim>[2*Dim];
unsigned int d, i;
......@@ -1979,7 +1979,7 @@ getSurfaceNormalFields(Field<Vektor<MFLOAT,Dim>, Dim,
template <unsigned Dim, class MFLOAT>
Vektor<MFLOAT,Dim>
Cartesian<Dim,MFLOAT>::
getSurfaceNormal(const NDIndex<Dim>& ndi, unsigned face) const
getSurfaceNormal(const NDIndex<Dim>& /*ndi*/, unsigned face) const
{
Vektor<MFLOAT,Dim> surfaceNormal;
unsigned int d;
......
......@@ -3,24 +3,6 @@
*
* The IPPL Framework
*
* This program was prepared by PSI.
* All rights in the program are reserved by PSI.
* Neither PSI nor the author(s)
* makes any warranty, express or implied, or assumes any liability or
* responsibility for the use of this software
*
* Visit www.amas.web.psi for more details
*
***************************************************************************/
// -*- C++ -*-
/***************************************************************************
*
* The IPPL Framework
*
*
* Visit http://people.web.psi.ch/adelmann/ for more details
*
***************************************************************************/
// UniformCartesian.cpp
......@@ -1174,7 +1156,7 @@ getDeltaCellField(Field<Vektor<MFLOAT,Dim>,Dim,
template <unsigned Dim, class MFLOAT>
Vektor<MFLOAT,Dim>*
UniformCartesian<Dim,MFLOAT>::
getSurfaceNormals(const NDIndex<Dim>& ndi) const
getSurfaceNormals(const NDIndex<Dim>& /*ndi*/) const
{
Vektor<MFLOAT,Dim>* surfaceNormals = new Vektor<MFLOAT,Dim>[2*Dim];
unsigned int d, i;
......@@ -1218,7 +1200,7 @@ getSurfaceNormalFields(Field<Vektor<MFLOAT,Dim>, Dim,
template <unsigned Dim, class MFLOAT>
Vektor<MFLOAT,Dim>
UniformCartesian<Dim,MFLOAT>::
getSurfaceNormal(const NDIndex<Dim>& ndi, unsigned face) const
getSurfaceNormal(const NDIndex<Dim>& /*ndi*/, unsigned face) const
{
Vektor<MFLOAT,Dim> surfaceNormal;
unsigned int d;
......@@ -2567,9 +2549,3 @@ Average(Field<T1,3U,UniformCartesian<3U,MFLOAT>,Vert>& x,
}
}
/***************************************************************************
* $RCSfile: UniformCartesian.cpp,v $ $Author: adelmann $
* $Revision: 1.1.1.1 $ $Date: 2003/01/23 07:40:28 $
* IPPL_VERSION_ID: $Id: UniformCartesian.cpp,v 1.1.1.1 2003/01/23 07:40:28 adelmann Exp $
***************************************************************************/
\ No newline at end of file
......@@ -9,7 +9,7 @@
template<typename> struct is_ippl_mpi_datatype: std::false_type {};
template <typename T> MPI_Datatype get_mpi_datatype(const T& x)
template <typename T> MPI_Datatype get_mpi_datatype(const T& /*x*/)
{
static_assert(is_ippl_mpi_datatype<T>::value,
"type isn't an MPI type");
......@@ -54,4 +54,4 @@ IPPL_MPI_DATATYPE(long double, MPI_LONG_DOUBLE);
IPPL_MPI_DATATYPE(bool, MPI_CXX_BOOL);
#endif
\ No newline at end of file
#endif
......@@ -46,7 +46,7 @@ public:
// scatter particle data into Field using particle position and mesh
template <class FT, class M, class C, class PT>
static
void scatter(const FT& pdata, Field<FT,Dim,M,C>& f,
void scatter(const FT& /*pdata*/, Field<FT,Dim,M,C>& f,
const Vektor<PT,Dim>& ppos, const M& mesh) {
CenteringTag<C> ctag;
Vektor<PT,Dim> gpos, dpos, delta;
......@@ -87,7 +87,7 @@ public:
// and cache mesh information for reuse
template <class FT, class M, class C, class PT>
static
void scatter(const FT& pdata, Field<FT,Dim,M,C>& f,
void scatter(const FT& /*pdata*/, Field<FT,Dim,M,C>& f,
const Vektor<PT,Dim>& ppos, const M& mesh,
NDIndex<Dim>& ngp, int lgpoff[Dim], Vektor<PT,Dim>& dpos) {
CenteringTag<C> ctag;
......@@ -126,9 +126,9 @@ public:
// scatter particle data into Field using cached mesh information
template <class FT, class M, class C, class PT>
static
void scatter(const FT& pdata, Field<FT,Dim,M,C>& f,
void scatter(const FT& /*pdata*/, Field<FT,Dim,M,C>& f,
const NDIndex<Dim>& ngp, const int lgpoff[Dim],
const Vektor<PT,Dim>& dpos) {
const Vektor<PT,Dim>& /*dpos*/) {
CompressedBrickIterator<FT,Dim> fiter;
// Try to find ngp in local fields and get iterator
fiter = getFieldIter(f,ngp);
......@@ -142,7 +142,7 @@ public:
// gather particle data from Field using particle position and mesh
template <class FT, class M, class C, class PT>
static
void gather(FT& pdata, const Field<FT,Dim,M,C>& f,
void gather(FT& /*pdata*/, const Field<FT,Dim,M,C>& f,
const Vektor<PT,Dim>& ppos, const M& mesh) {
CenteringTag<C> ctag;
Vektor<PT,Dim> gpos, dpos, delta;
......@@ -183,7 +183,7 @@ public:
// and cache mesh information for reuse
template <class FT, class M, class C, class PT>
static
void gather(FT& pdata, const Field<FT,Dim,M,C>& f,
void gather(FT& /*pdata*/, const Field<FT,Dim,M,C>& f,
const Vektor<PT,Dim>& ppos, const M& mesh,
NDIndex<Dim>& ngp, int lgpoff[Dim], Vektor<PT,Dim>& dpos) {
CenteringTag<C> ctag;
......@@ -222,9 +222,9 @@ public:
// gather particle data from Field using cached mesh information
template <class FT, class M, class C, class PT>
static
void gather(FT& pdata, const Field<FT,Dim,M,C>& f,
void gather(FT& /*pdata*/, const Field<FT,Dim,M,C>& f,
const NDIndex<Dim>& ngp, const int lgpoff[Dim],
const Vektor<PT,Dim>& dpos) {
const Vektor<PT,Dim>&) {
CompressedBrickIterator<FT,Dim> fiter;
// Try to find ngp in local fields and get iterator
fiter = getFieldIter(f,ngp);
......@@ -709,8 +709,8 @@ public:
template <class FT, class M, class PT>
static
void scatter(const FT& pdata, Field<FT,2U,M,Edge>& f,
const Vektor<PT,2U>& ppos, const M& mesh) {
void scatter(const FT& /*pdata*/, Field<FT,2U,M,Edge>& /*f*/,
const Vektor<PT,2U>& /*ppos*/, const M& /*mesh*/) {
ERRORMSG("IntCIC::scatter on Edge based field: not implemented for non-vectors!!"<<endl);
return;
}
......@@ -718,18 +718,18 @@ public:
// and cache mesh information for reuse
template <class FT, class M, class PT>
static
void scatter(const FT& pdata, Field<FT,2U,M,Edge>& f,
const Vektor<PT,2U>& ppos, const M& mesh,
NDIndex<2U>& ngp, int lgpoff[2U], Vektor<PT,2U>& dpos) {
void scatter(const FT& /*pdata*/, Field<FT,2U,M,Edge>& /*f*/,
const Vektor<PT,2U>& /*ppos*/, const M& /*mesh*/,
NDIndex<2U>& /*ngp*/, int /*lgpoff*/ [2U], Vektor<PT,2U>& /*dpos*/) {
ERRORMSG("IntCIC::scatter on Edge based field with cache: not implemented!!"<<endl);
return;
}
template <class FT, class M, class PT>
static
void scatter(const FT& pdata, Field<FT,2U,M,Edge>& f,
const NDIndex<2U>& ngp, const int lgpoff[2U],
const Vektor<PT,2U>& dpos) {
void scatter(const FT&, Field<FT,2U,M,Edge>&,
const NDIndex<2U>&, const int [2U],
const Vektor<PT,2U>&) {
ERRORMSG("IntCIC::scatter on Edge based field with cache: not implemented!!"<<endl);
return;
}
......@@ -773,8 +773,8 @@ public:
template <class FT, class M, class PT>
static
void gather(FT& pdata, const Field<FT,2U,M,Edge>& f,
const Vektor<PT,2U>& ppos, const M& mesh) {
void gather(FT& /*pdata*/, const Field<FT,2U,M,Edge>& /*f*/,
const Vektor<PT,2U>& /*ppos*/, const M& /*mesh*/) {
ERRORMSG("IntCIC::gather on Edge based field: not implemented for non-vectors!!"<<endl);
return;
}
......@@ -783,9 +783,9 @@ public:
// and cache mesh information for reuse
template <class FT, class M, class PT>
static
void gather(FT& pdata, const Field<FT,2U,M,Edge>& f,
const Vektor<PT,2U>& ppos, const M& mesh,
NDIndex<2U>& ngp, int lgpoff[2U], Vektor<PT,2U>& dpos) {
void gather(FT& /*pdata*/, const Field<FT,2U,M,Edge>& /*f*/,
const Vektor<PT,2U>& /*ppos*/, const M& /*mesh*/,
NDIndex<2U>& /*ngp*/, int /*lgpoff*/[2U], Vektor<PT,2U>& /*dpos*/) {
ERRORMSG("IntCIC::gather on Edge based field with cache: not implemented!!"<<endl);
return;
}
......@@ -793,9 +793,9 @@ public:
// gather particle data from Field using cached mesh information
template <class FT, class M, class PT>
static
void gather(FT& pdata, const Field<FT,2U,M,Edge>& f,
const NDIndex<2U>& ngp, const int lgpoff[2U],
const Vektor<PT,2U>& dpos) {
void gather(FT& /*pdata*/, const Field<FT,2U,M,Edge>& /*f*/,
const NDIndex<2U>& /*ngp*/, const int /*lgpoff*/[2U],
const Vektor<PT,2U>& /*dpos*/) {
ERRORMSG("IntCIC::gather on Edge based field with cache: not implemented!!"<<endl);
return;
}
......@@ -1090,8 +1090,8 @@ public:
template <class FT, class M, class PT>
static
void scatter(const FT& pdata, Field<FT,3U,M,Edge>& f,
const Vektor<PT,3U>& ppos, const M& mesh) {
void scatter(const FT& /*pdata*/, Field<FT,3U,M,Edge>& /*f*/,
const Vektor<PT,3U>& /*ppos*/, const M& /*mesh*/) {
ERRORMSG("IntCIC::scatter on Edge based field: not implemented for non-vectors!!"<<endl);
return;
}
......@@ -1099,18 +1099,18 @@ public:
// and cache mesh information for reuse
template <class FT, class M, class PT>
static
void scatter(const FT& pdata, Field<FT,3U,M,Edge>& f,
const Vektor<PT,3U>& ppos, const M& mesh,
NDIndex<3U>& ngp, int lgpoff[3U], Vektor<PT,3U>& dpos) {
void scatter(const FT& /*pdata*/, Field<FT,3U,M,Edge>& /*f*/,
const Vektor<PT,3U>& /*ppos*/, const M& /*mesh*/,
NDIndex<3U>& /*ngp*/, int /*lgpoff*/[3U], Vektor<PT,3U>& /*dpos*/) {
ERRORMSG("IntCIC::scatter on Edge based field with cache: not implemented!!"<<endl);
return;
}
template <class FT, class M, class PT>
static
void scatter(const FT& pdata, Field<FT,3U,M,Edge>& f,
const NDIndex<3U>& ngp, const int lgpoff[3U],
const Vektor<PT,3U>& dpos) {
void scatter(const FT& /*pdata*/, Field<FT,3U,M,Edge>& /*f*/,
const NDIndex<3U>& /*ngp*/, const int /*lgpoff*/[3U],
const Vektor<PT,3U>& /*dpos*/) {
ERRORMSG("IntCIC::scatter on Edge based field with cache: not implemented!!"&