void swakExpressionAverageDistributionFunctionObject::write()
{
    if(verbose()) {
        Info << "AverageDistributionExpression " << name() << " : ";
    }

    clearDistributions();

    driver_->clearVariables();

    driver_->parse(weightExpression_);
    if(
        driver_->CommonValueExpressionDriver::getResultType()
        ==
        pTraits<scalar>::typeName
    ) {
        weightValues_.reset(
            driver_->getResult<scalar>().ptr()
        );
    } else {
        FatalErrorIn("swakExpressionAverageDistributionFunctionObject::write()")
            << "Don't know how to handle weight expressions of type "
                << driver_->CommonValueExpressionDriver::getResultType()
                << endl
                << exit(FatalError);

    }

    driver_->parse(maskExpression_);
    if(
        driver_->CommonValueExpressionDriver::getResultType()
        ==
        pTraits<bool>::typeName
    ) {
        maskValues_.reset(
            driver_->getResult<bool>().ptr()
        );
    } else if(
        driver_->CommonValueExpressionDriver::getResultType()
        ==
        pTraits<scalar>::typeName
    ) {
        scalarField rawMask=driver_->getResult<scalar>();
        maskValues_.reset(
            new Field<bool>(rawMask.size(),false)
        );
        forAll(rawMask,i) {
            if(rawMask[i]>SMALL) {
                maskValues_()[i]=true;
            }
        }
    } else {
void distributionFunctionObject::write() {
    clearDistributions();

    getDistribution();

    if(writeTimeline() && startup_) {
        timelineFunctionObject::start();
    }
    startup_=false;

    bool zeroDistribution=false;

    if(
        distScalar_.valid()
        &&
        distScalar_->maxNrBins()<=0
    ) {
        zeroDistribution=true;
    }
    if(
        distVector_.valid()
        &&
        distVector_->maxNrBins()<=0
    ) {
        zeroDistribution=true;
    }
    if(
        distTensor_.valid()
        &&
        distTensor_->maxNrBins()<=0
    ) {
        zeroDistribution=true;
    }
    if(
        distSymmTensor_.valid()
        &&
        distSymmTensor_->maxNrBins()<=0
    ) {
        zeroDistribution=true;
    }
    if(
        distSphericalTensor_.valid()
        &&
        distSphericalTensor_->maxNrBins()<=0
    ) {
        zeroDistribution=true;
    }

    if(zeroDistribution) {
        WarningIn("distributionFunctionObject::write")
            << "Distribution for " << name() << " has size 0. "
                << "Doing nothing"
                << endl;
        return;
    }
    if(Pstream::master()) {
        if(writeTimeline()) {
            writeATimeline(distScalar_);
            writeATimeline(distVector_);
            writeATimeline(distTensor_);
            writeATimeline(distSymmTensor_);
            writeATimeline(distSphericalTensor_);
        }

        if(writeDistribution()) {
            writeADistribution(distScalar_);
            writeADistribution(distVector_);
            writeADistribution(distTensor_);
            writeADistribution(distSymmTensor_);
            writeADistribution(distSphericalTensor_);
        }

        if(verbose()) {
            reportADistribution(distScalar_);
            reportADistribution(distVector_);
            reportADistribution(distTensor_);
            reportADistribution(distSymmTensor_);
            reportADistribution(distSphericalTensor_);
        }
    }
}