void ContributionScalarPluginFunction<Driver,PluginType>::doEvaluation()
{
    List<scalarField> values(Pstream::nProcs());
    values[Pstream::myProcNo()]=values_();
    List<vectorField> positions(Pstream::nProcs());
    positions[Pstream::myProcNo()]=positions_();

    Pstream::scatterList(values);
    Pstream::scatterList(positions);

    typedef typename PluginType::driverType PluginTypeDriverType;

    scalarField result(
        this->parentDriver().size()
    );

    autoPtr<vectorField> myPositions(
        makeParentPositions(
            dynamicCast<PluginTypeDriverType &>(
                this->parentDriver()
            )
        ).ptr()
    );

    forAll(result,cellI)
    {
        scalar sum=0;
        scalar distSum=0;
        bool found=false;
        const vector &here=myPositions()[cellI];

        forAll(values,valI)
        {
            const scalarField &localValues=values[valI];
            const vectorField &localPos=positions[valI];

            forAll(localValues,i)
            {
                const scalar dist=mag(localPos[i]-here);
                if(dist<SMALL) {
                    // Avoid divison by zero
                    result[cellI]=localValues[i];
                    found=true;
                    break;
                }
                //                const scalar weight=dist*dist;
                const scalar weight=dist;
                sum+=localValues[i]/weight;
                distSum+=1/weight;
            }

            if(found) {
                break;
            }
        }

        if(!found) {
            result[cellI]=sum/distSum;
        }
    }
コード例 #2
0
ファイル: resizable_matrix.hpp プロジェクト: fsohn/CT-HYB
 inline const Scalar& operator()(const int i, const int j) const {
   assert(is_allocated());
   assert(i<=size1_);
   assert(j<=size2_);
   return values_(i,j);
 }