void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix ( scalarField& result, const scalarField& psiInternal, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes ) const { const labelUList& nbrFaceCells = cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().faceCells(); scalarField pnf(psiInternal, nbrFaceCells); // Transform according to the transformation tensors transformCoupleField(pnf, cmpt); if (cyclicAMIPatch_.applyLowWeightCorrection()) { scalarField pif(psiInternal, cyclicAMIPatch_.faceCells()); pnf = cyclicAMIPatch_.interpolate(pnf, pif); } else { pnf = cyclicAMIPatch_.interpolate(pnf); } // Multiply the field by coefficients and add into the result const labelUList& faceCells = cyclicAMIPatch_.faceCells(); forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI]; }
void Foam::cyclicACMIFvPatchField<Type>::updateInterfaceMatrix ( gpuField<Type>& result, const gpuField<Type>& psiInternal, const scalargpuField& coeffs, const Pstream::commsTypes ) const { // note: only applying coupled contribution const labelgpuList& nbrFaceCellsCoupled = cyclicACMIPatch_.cyclicACMIPatch().neighbPatch().getFaceCells(); gpuField<Type> pnf(psiInternal, nbrFaceCellsCoupled); // Transform according to the transformation tensors transformCoupleField(pnf); pnf = cyclicACMIPatch_.interpolate(pnf); matrixPatchOperation ( this->patch().index(), result, this->patch().boundaryMesh().mesh().lduAddr(), matrixInterfaceFunctor<Type> ( coeffs.data(), pnf.data() ) ); }
void cyclicFvPatchField<Type>::updateInterfaceMatrix ( const scalarField& psiInternal, scalarField& result, const lduMatrix&, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes ) const { scalarField pnf(this->size()); label sizeby2 = this->size()/2; const unallocLabelList& faceCells = cyclicPatch_.faceCells(); for (label facei=0; facei<sizeby2; facei++) { pnf[facei] = psiInternal[faceCells[facei + sizeby2]]; pnf[facei + sizeby2] = psiInternal[faceCells[facei]]; } // Transform according to the transformation tensors transformCoupleField(pnf, cmpt); // Multiply the field by coefficients and add into the result forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI]; }
Foam::tmp<Foam::Field<Type>> Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const { const Field<Type>& iField = this->primitiveField(); const labelUList& nbrFaceCells = cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().faceCells(); Field<Type> pnf(iField, nbrFaceCells); tmp<Field<Type>> tpnf; if (cyclicAMIPatch_.applyLowWeightCorrection()) { tpnf = cyclicAMIPatch_.interpolate(pnf, this->patchInternalField()()); } else { tpnf = cyclicAMIPatch_.interpolate(pnf); } if (doTransform()) { tpnf.ref() = transform(forwardT(), tpnf()); } return tpnf; }
void Foam::processorGAMGInterfaceField::updateInterfaceMatrix ( const scalarField&, scalarField& result, const lduMatrix&, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes commsType, const bool switchToLhs ) const { scalarField pnf ( procInterface_.compressedReceive<scalar>(commsType, coeffs.size()) ); transformCoupleField(pnf, cmpt); const unallocLabelList& faceCells = procInterface_.faceCells(); if (switchToLhs) { forAll(faceCells, elemI) { result[faceCells[elemI]] += coeffs[elemI]*pnf[elemI]; } }
void processorFvPatchField<Type>::updateInterfaceMatrix ( const scalarField&, scalarField& result, const lduMatrix&, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes commsType, const bool switchToLhs ) const { scalarField pnf ( procPatch_.compressedReceive<scalar>(commsType, this->size())() ); // Transform according to the transformation tensor transformCoupleField(pnf, cmpt); // Multiply the field by coefficients and add into the result const unallocLabelList& faceCells = this->patch().faceCells(); if (switchToLhs) { forAll(faceCells, elemI) { result[faceCells[elemI]] += coeffs[elemI]*pnf[elemI]; } }
void Foam::cyclicGAMGInterfaceField::updateInterfaceMatrix ( const scalarField& psiInternal, scalarField& result, const lduMatrix&, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes ) const { scalarField pnf(size()); label sizeby2 = size()/2; const unallocLabelList& faceCells = cyclicInterface_.faceCells(); for (label facei=0; facei<sizeby2; facei++) { pnf[facei] = psiInternal[faceCells[facei + sizeby2]]; pnf[facei + sizeby2] = psiInternal[faceCells[facei]]; } transformCoupleField(pnf, cmpt); forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI]; }
void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix ( scalarField& result, const scalarField& psiInternal, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes ) const { // Get neighbouring field scalarField pnf ( cyclicACMIInterface_.neighbPatch().interfaceInternalField(psiInternal) ); // Transform according to the transformation tensors transformCoupleField(pnf, cmpt); if (cyclicACMIInterface_.owner()) { pnf = cyclicACMIInterface_.AMI().interpolateToSource(pnf); } else { pnf = cyclicACMIInterface_.neighbPatch().AMI().interpolateToTarget(pnf); } const labelUList& faceCells = cyclicACMIInterface_.faceCells(); forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI]; }
void Foam::processorCyclicPointPatchField<Type>::swapAddSeparated ( const Pstream::commsTypes commsType, Field<Type>& pField ) const { if (Pstream::parRun()) { Field<Type> pnf(this->size()); IPstream::read ( commsType, procPatch_.neighbProcNo(), reinterpret_cast<char*>(pnf.begin()), pnf.byteSize(), procPatch_.tag() ); if (doTransform()) { const processorCyclicPolyPatch& ppp = procPatch_.procCyclicPolyPatch(); const tensor& forwardT = ppp.forwardT()[0]; transform(pnf, forwardT, pnf); } // All points are separated this->addToInternalField(pField, pnf); } }
void Foam::cyclicACMIGAMGInterfaceField::updateInterfaceMatrix ( scalargpuField& result, const scalargpuField& psiInternal, const scalargpuField& coeffs, const direction cmpt, const Pstream::commsTypes ) const { // Get neighbouring field scalargpuField pnf ( cyclicACMIInterface_.neighbPatch().interfaceInternalField(psiInternal) ); // Transform according to the transformation tensors transformCoupleField(pnf, cmpt); if (cyclicACMIInterface_.owner()) { pnf = cyclicACMIInterface_.AMI().interpolateToSource(pnf); } else { pnf = cyclicACMIInterface_.neighbPatch().AMI().interpolateToTarget(pnf); } GAMGUpdateInterfaceMatrix ( result, coeffs, pnf, cyclicACMIInterface_ ); }
void Foam::processorGAMGInterfaceField::updateInterfaceMatrix ( solveScalarField& result, const bool add, const solveScalarField&, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes commsType ) const { if (updatedMatrix()) { return; } if ( commsType == Pstream::commsTypes::nonBlocking && !Pstream::floatTransfer ) { // Fast path. if ( outstandingRecvRequest_ >= 0 && outstandingRecvRequest_ < Pstream::nRequests() ) { UPstream::waitRequest(outstandingRecvRequest_); } // Recv finished so assume sending finished as well. outstandingSendRequest_ = -1; outstandingRecvRequest_ = -1; // Consume straight from scalarReceiveBuf_ // Transform according to the transformation tensor transformCoupleField(scalarReceiveBuf_, cmpt); // Multiply the field by coefficients and add into the result addToInternalField(result, !add, coeffs, scalarReceiveBuf_); } else { solveScalarField pnf ( procInterface_.compressedReceive<solveScalar> ( commsType, coeffs.size() ) ); transformCoupleField(pnf, cmpt); addToInternalField(result, !add, coeffs, pnf); } const_cast<processorGAMGInterfaceField&>(*this).updatedMatrix() = true; }
void Foam::jumpCyclicAMIFvPatchField<Type>::updateInterfaceMatrix ( gpuField<Type>& result, const gpuField<Type>& psiInternal, const scalargpuField& coeffs, const Pstream::commsTypes ) const { const labelgpuList& nbrFaceCells = this->cyclicAMIPatch().cyclicAMIPatch().neighbPatch().getFaceCells(); gpuField<Type> pnf(psiInternal, nbrFaceCells); if (this->cyclicAMIPatch().applyLowWeightCorrection()) { pnf = this->cyclicAMIPatch().interpolate ( pnf, this->patchInternalField()() ); } else { pnf = this->cyclicAMIPatch().interpolate(pnf); } // only apply jump to original field if (&psiInternal == &this->internalField()) { gpuField<Type> jf(this->jump()); if (!this->cyclicAMIPatch().owner()) { jf *= -1.0; } pnf -= jf; } // Transform according to the transformation tensors this->transformCoupleField(pnf); // Multiply the field by coefficients and add into the result matrixPatchOperation ( this->patch().index(), result, this->patch().boundaryMesh().mesh().lduAddr(), matrixInterfaceFunctor<Type> ( coeffs.data(), pnf.data() ) ); }
void Foam::jumpCyclicAMIFvPatchField<Type>::updateInterfaceMatrix ( Field<Type>& result, const Field<Type>& psiInternal, const scalarField& coeffs, const Pstream::commsTypes ) const { const labelUList& nbrFaceCells = this->cyclicAMIPatch().cyclicAMIPatch().neighbPatch().faceCells(); Field<Type> pnf(psiInternal, nbrFaceCells); if (this->cyclicAMIPatch().applyLowWeightCorrection()) { pnf = this->cyclicAMIPatch().interpolate ( pnf, this->patchInternalField()() ); } else { pnf = this->cyclicAMIPatch().interpolate(pnf); } // only apply jump to original field if (&psiInternal == &this->internalField()) { Field<Type> jf(this->jump()); if (!this->cyclicAMIPatch().owner()) { jf *= -1.0; } pnf -= jf; } // Transform according to the transformation tensors this->transformCoupleField(pnf); // Multiply the field by coefficients and add into the result const labelUList& faceCells = this->cyclicAMIPatch().faceCells(); forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI]; }
void ProcessorPointPatchField <PatchField, Mesh, PointPatch, ProcessorPointPatch, MatrixType, Type>:: swapAdd(Field<Type>& pField) const { Field<Type> pnf(this->size()); IPstream::read ( Pstream::blocking, procPatch_.neighbProcNo(), reinterpret_cast<char*>(pnf.begin()), pnf.byteSize() ); if (doTransform()) { const labelList& nonGlobalPatchPoints = procPatch_.nonGlobalPatchPoints(); const processorPolyPatch& ppp = procPatch_.procPolyPatch(); const labelListList& pointFaces = ppp.pointFaces(); const tensorField& forwardT = ppp.forwardT(); if (forwardT.size() == 1) { transform(pnf, forwardT[0], pnf); } else { forAll(nonGlobalPatchPoints, pfi) { pnf[pfi] = transform ( forwardT[pointFaces[nonGlobalPatchPoints[pfi]][0]], pnf[pfi] ); } } }
void Foam::cyclicGAMGInterfaceField::updateInterfaceMatrix ( scalarField& result, const scalarField& psiInternal, const scalarField& coeffs, const direction cmpt, const Pstream::commsTypes ) const { // Get neighbouring field scalarField pnf ( cyclicInterface_.neighbPatch().interfaceInternalField(psiInternal) ); transformCoupleField(pnf, cmpt); const labelUList& faceCells = cyclicInterface_.faceCells(); forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI]; }
Foam::tmp<Foam::Field<Type> > Foam::jumpCyclicAMIFvPatchField<Type>::patchNeighbourField() const { const Field<Type>& iField = this->internalField(); const labelUList& nbrFaceCells = this->cyclicAMIPatch().cyclicAMIPatch().neighbPatch().faceCells(); Field<Type> pnf(iField, nbrFaceCells); tmp<Field<Type> > tpnf; if (this->cyclicAMIPatch().applyLowWeightCorrection()) { tpnf = this->cyclicAMIPatch().interpolate ( pnf, this->patchInternalField()() ); } else { tpnf = this->cyclicAMIPatch().interpolate(pnf); } if (this->doTransform()) { tpnf = transform(this->forwardT(), tpnf); } tmp<Field<Type> > tjf = jump(); if (!this->cyclicAMIPatch().owner()) { tjf = -tjf; } return tpnf - tjf; }
void Foam::processorFvPatchField<Type>::updateInterfaceMatrix ( gpuField<Type>& result, const gpuField<Type>&, const scalargpuField& coeffs, const Pstream::commsTypes commsType ) const { if (this->updatedMatrix()) { return; } if (commsType == Pstream::nonBlocking && !Pstream::floatTransfer) { // Fast path. if ( outstandingRecvRequest_ >= 0 && outstandingRecvRequest_ < Pstream::nRequests() ) { UPstream::waitRequest(outstandingRecvRequest_); } // Recv finished so assume sending finished as well. outstandingSendRequest_ = -1; outstandingRecvRequest_ = -1; // Consume straight from receiveBuf_ // Transform according to the transformation tensor gpuReceiveBuf_ = receiveBuf_; transformCoupleField(gpuReceiveBuf_); // Multiply the field by coefficients and add into the result matrixPatchOperation ( this->patch().index(), result, this->patch().boundaryMesh().mesh().lduAddr(), processorFvPatchFunctor<Type> ( coeffs.data(), gpuReceiveBuf_.data() ) ); } else { gpuField<Type> pnf ( procPatch_.compressedReceive<Type>(commsType, this->size())() ); // Transform according to the transformation tensor transformCoupleField(pnf); // Multiply the field by coefficients and add into the result matrixPatchOperation ( this->patch().index(), result, this->patch().boundaryMesh().mesh().lduAddr(), processorFvPatchFunctor<Type> ( coeffs.data(), pnf.data() ) ); } const_cast<processorFvPatchField<Type>&>(*this).updatedMatrix() = true; }
void processorFvPatchField<scalar>::updateInterfaceMatrix ( scalargpuField& result, const scalargpuField&, const scalargpuField& coeffs, const direction, const Pstream::commsTypes commsType ) const { if (this->updatedMatrix()) { return; } if (commsType == Pstream::nonBlocking && !Pstream::floatTransfer) { // Fast path. if ( outstandingRecvRequest_ >= 0 && outstandingRecvRequest_ < Pstream::nRequests() ) { UPstream::waitRequest(outstandingRecvRequest_); } // Recv finished so assume sending finished as well. outstandingSendRequest_ = -1; outstandingRecvRequest_ = -1; scalargpuReceiveBuf_ = scalarReceiveBuf_; // Consume straight from scalarReceiveBuf_ /* forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*scalarReceiveBuf_[elemI]; } */ matrixPatchOperation(this->patch().index(), result, this->patch().boundaryMesh().mesh().lduAddr(), processorFvPatchScalarFunctor(coeffs.data(),scalargpuReceiveBuf_.data())); } else { scalargpuField pnf ( procPatch_.compressedReceive<scalar>(commsType, this->size())() ); /* forAll(faceCells, elemI) { result[faceCells[elemI]] -= coeffs[elemI]*pnf[elemI]; } */ matrixPatchOperation(this->patch().index(), result, this->patch().boundaryMesh().mesh().lduAddr(), processorFvPatchScalarFunctor(coeffs.data(),pnf.data())); } const_cast<processorFvPatchField<scalar>&>(*this).updatedMatrix() = true; }