openfoam — Как мне предотвратить переопределение класса? Переполнение стека

Я пытаюсь скомпилировать C ++ для программного обеспечения CFD с открытым исходным кодом, однако я получаю некоторые ошибки переопределения:

    jumpCyclicMHFvPatchField.C:31:2: error: redefinition of ‘Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField(const Foam::fvPatch&, const Foam::DimensionedField<Type, Foam::volMesh>&)’
Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField
^
In file included from jumpCyclicMHFvPatchField.H:181:0,
from jumpCyclicMHFvPatchField.C:26:
jumpCyclicMHFvPatchField.C:31:2: note: ‘Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField(const Foam::fvPatch&, const Foam::DimensionedField<Type, Foam::volMesh>&)’ previously declared here
Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField

Я вижу, что я определяю jumpCyclicMHFvPatchField в заголовке и файле C, но, к сожалению, мои навыки C ++ очень ограничены, и я не могу понять, почему это происходит.

Есть ли простой способ предотвратить переопределение класса?

Заголовочный файл:

#ifndef jumpCyclicMHFvPatchField_H
#define jumpCyclicMHFvPatchField_H

#include "cyclicFvPatchField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

/*---------------------------------------------------------------------------*\
Class jumpCyclicMHFvPatchField Declaration
\*---------------------------------------------------------------------------*/

template<class Type>
class jumpCyclicMHFvPatchField
:
public cyclicFvPatchField<Type>
{

public:

//- Runtime type information
TypeName("jumpCyclic");// Constructors

//- Construct from patch and internal field
jumpCyclicMHFvPatchField
(
const fvPatch&,
const DimensionedField<Type, volMesh>&
);

//- Construct from patch, internal field and dictionary
jumpCyclicMHFvPatchField
(
const fvPatch&,
const DimensionedField<Type, volMesh>&,
const dictionary&
);

//- Construct by mapping given jumpCyclicMHFvPatchField onto a new patch
jumpCyclicMHFvPatchField
(
const jumpCyclicMHFvPatchField<Type>&,
const fvPatch&,
const DimensionedField<Type, volMesh>&,
const fvPatchFieldMapper&
);

//- Construct as copy
jumpCyclicMHFvPatchField
(
const jumpCyclicMHFvPatchField<Type>&
);

//- Construct as copy setting internal field reference
jumpCyclicMHFvPatchField
(
const jumpCyclicMHFvPatchField<Type>&,
const DimensionedField<Type, volMesh>&
);// Member functions

// Access

//- Return the interface type
virtual const word& interfaceFieldType() const
{
return cyclicFvPatchField<Type>::type();
}

//- Return the "jump" across the patch as a "half" field
virtual tmp<Field<Type>> jump() const = 0;// Evaluation functions

//- Return neighbour coupled given internal cell data
tmp<Field<Type>> patchNeighbourField() const;

//- Update result field based on interface functionality
virtual void updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const;

//- Update result field based on interface functionality
virtual void updateInterfaceMatrix
(
Field<Type>&,
const bool add,
const Field<Type>&,
const scalarField&,
const Pstream::commsTypes commsType
) const;
};

//- Update result field based on interface functionality
template<>
void jumpCyclicMHFvPatchField<scalar>::updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const;template<>
void jumpCyclicMHFvPatchField<vector>::updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes commsType
) const;// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#ifdef NoRepository
#include "jumpCyclicMHFvPatchField.C"#endif

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

Файл C:

#include "jumpCyclicMHFvPatchField.H"
// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //

template<class Type>
Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
:
cyclicFvPatchField<Type>(p, iF)
{}template<class Type>
Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField
(
const jumpCyclicMHFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
cyclicFvPatchField<Type>(ptf, p, iF, mapper)
{}template<class Type>
Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
cyclicFvPatchField<Type>(p, iF, dict)
{
// Call this evaluation in derived classes
//this->evaluate(Pstream::commsTypes::blocking);
}template<class Type>
Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField
(
const jumpCyclicMHFvPatchField<Type>& ptf
)
:
cyclicFvPatchField<Type>(ptf)
{}template<class Type>
Foam::jumpCyclicMHFvPatchField<Type>::jumpCyclicMHFvPatchField
(
const jumpCyclicMHFvPatchField<Type>& ptf,
const DimensionedField<Type, volMesh>& iF
)
:
cyclicFvPatchField<Type>(ptf, iF)
{}// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //

template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::jumpCyclicMHFvPatchField<Type>::patchNeighbourField() const
{
const Field<Type>& iField = this->primitiveField();
const labelUList& nbrFaceCells =
this->cyclicPatch().neighbFvPatch().faceCells();

tmp<Field<Type>> tpnf(new Field<Type>(this->size()));
Field<Type>& pnf = tpnf.ref();

Field<Type> jf(this->jump());
if (!this->cyclicPatch().owner())
{
jf *= -1.0;
}

if (this->doTransform())
{
forAll(*this, facei)
{
pnf[facei] = transform
(
this->forwardT()[0], iField[nbrFaceCells[facei]]
) - jf[facei];
}
}
else
{
forAll(*this, facei)
{
pnf[facei] = iField[nbrFaceCells[facei]] - jf[facei];
}
}

return tpnf;
}template<class Type>
void Foam::jumpCyclicMHFvPatchField<Type>::updateInterfaceMatrix
(
scalarField& result,
const bool add,
const scalarField& psiInternal,
const scalarField& coeffs,
const direction cmpt,
const Pstream::commsTypes
) const
{
NotImplemented;
}template<class Type>
void Foam::jumpCyclicMHFvPatchField<Type>::updateInterfaceMatrix
(
Field<Type>& result,
const bool add,
const Field<Type>& psiInternal,
const scalarField& coeffs,
const Pstream::commsTypes
) const
{
Field<Type> pnf(this->size());

const labelUList& nbrFaceCells =
this->cyclicPatch().neighbFvPatch().faceCells();

// only apply jump to original field
if (&psiInternal == &this->primitiveField())
{
Field<Type> jf(this->jump());

if (!this->cyclicPatch().owner())
{
jf *= -1.0;
}

forAll(*this, facei)
{
pnf[facei] = psiInternal[nbrFaceCells[facei]] - jf[facei];
}
}
else
{
forAll(*this, facei)
{
pnf[facei] = psiInternal[nbrFaceCells[facei]];
}
}

// Transform according to the transformation tensors
this->transformCoupleField(pnf);

// Multiply the field by coefficients and add into the result
const labelUList& faceCells = this->cyclicPatch().faceCells();
forAll(faceCells, elemI)
{
result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI];
}
}