Info << "\nReading coupling properties" << endl;
    IOdictionary couplingProperties
    (
        IOobject
        (
            "couplingProperties",
            runTime.constant(),
            mesh,
            IOobject::MUST_READ_IF_MODIFIED,
            IOobject::NO_WRITE
        )
    );


    // Read solid patch data
    word solidPatchName(couplingProperties.lookup("solidPatch"));

    label solidPatchID
    (
        stressMesh.boundaryMesh().findPatchID(solidPatchName)
    );

    if (solidPatchID < 0)
    {
        FatalErrorIn(args.executable())
            << "Problem with finding solid patch"
                << abort(FatalError);
    }

    word solidZoneName(couplingProperties.lookup("solidZone"));

    label solidZoneID =
        stressMesh.faceZones().findZoneID(solidZoneName);

    if (solidZoneID < 0)
    {
        FatalErrorIn(args.executable())
            << "Problem with finding solid zone"
                << abort(FatalError);
    }

//     const label solidPatchStart =
//         stressMesh.boundaryMesh()[solidPatchID].start();

//     const faceZone& solidZone = stressMesh.faceZones()[solidZoneID];


    // Read fluid patch data
    word fluidPatchName(couplingProperties.lookup("fluidPatch"));

    label fluidPatchID =
        mesh.boundaryMesh().findPatchID(fluidPatchName);

    if (fluidPatchID < 0)
    {
        FatalErrorIn(args.executable())
            << "Problem with finding fluid patch"
            << abort(FatalError);
    }

    word fluidZoneName(couplingProperties.lookup("fluidZone"));

    label fluidZoneID =
        mesh.faceZones().findZoneID(fluidZoneName);

    if (fluidZoneID < 0)
    {
        FatalErrorIn(args.executable())
            << "Problem with finding fluid zone"
                << abort(FatalError);
    }

//     const label fluidPatchStart =
//         mesh.boundaryMesh()[fluidPatchID].start();

//     const faceZone& fluidZone = mesh.faceZones()[fluidZoneID];


    // Check mesh motion solver type
    bool feMotionSolver =
        mesh.objectRegistry::foundObject<tetPointVectorField>
        (
            "motionU"
        );
    bool fvMotionSolver =
        mesh.objectRegistry::foundObject<pointVectorField>
        (
            "pointMotionU"
        );


    // Grab solid patch field
    if
    (
        DU.boundaryField()[solidPatchID].type()
     != solidTractionFvPatchVectorField::typeName
    //!= tractionDisplacementIncrementFvPatchVectorField::typeName
    )
    {
        FatalErrorIn(args.executable())
            << "Bounary condition on " << DU.name()
                <<  " is "
                << DU.boundaryField()[solidPatchID].type()
                << "for fluid -solid interface patch, instead "
            << solidTractionFvPatchVectorField::typeName
            //<< tractionDisplacementIncrementFvPatchVectorField::typeName
                << abort(FatalError);
    }

    //tractionDisplacementIncrementFvPatchVectorField& tForce =
    //      refCast<tractionDisplacementIncrementFvPatchVectorField>
    solidTractionFvPatchVectorField& tForce =
        refCast<solidTractionFvPatchVectorField>
        (
            DU.boundaryField()[solidPatchID]
        );


    // Accumulated fluid interface displacement
    IOobject accumulatedFluidInterfaceDisplacementHeader
    (
        "accumulatedFluidInterfaceDisplacement",
        runTime.timeName(),
        mesh,
        IOobject::MUST_READ
    );

    vectorField* accumulatedFluidInterfaceDisplacementPtr = nullptr;

    if(accumulatedFluidInterfaceDisplacementHeader.headerOk())
    {
        Pout << "Reading accumulated fluid interface displacement" << endl;

        accumulatedFluidInterfaceDisplacementPtr =
            new vectorIOField
            (
                IOobject
                (
                    "accumulatedFluidInterfaceDisplacement",
                    runTime.timeName(),
                    mesh,
                    IOobject::MUST_READ,
                    IOobject::AUTO_WRITE
                )
            );
    }
    else
    {
        accumulatedFluidInterfaceDisplacementPtr =
            new vectorIOField
            (
                IOobject
                (
                    "accumulatedFluidInterfaceDisplacement",
                    runTime.timeName(),
                    mesh,
                    IOobject::NO_READ,
                    IOobject::AUTO_WRITE
                ),
                vectorField
                (
                    mesh.boundaryMesh()[fluidPatchID].nPoints(),
                    vector::zero
                )
            );
    }

    vectorField& accumulatedFluidInterfaceDisplacement
        = *accumulatedFluidInterfaceDisplacementPtr;