[Rhea Ray]

Dear Foamers,

I want to build a floating body model in a water tank, modifying the v1906 - overInterDyMFoam - floatingBody case. I changed the original 5 wall boundaries to inlet, outlet, and 3 walls. I added the waveProperties file in constant folder. The wave type is StokesI.
The program runs, but the results are confusing. Using waveAlpha as the inlet boundaryField. The result of alpha.water shows the water level line fluctuates up and down in the inlet face, proving that the wave-making is successful. However, the waves seem to accumulate at the frontend and backend (as shown in the figure) and do not propagate forward.

I checked the U results. In the accumulated part, U is very large, but it seems difficult to transmit.
I haven't checked the Courant number (I'm still learning how to add new outputs). In the controlDict, I set maxCo = 1; maxAlphaCo = 1; maxDeltaT = 0.01. The minimum mesh size δx is 0.01m (there is little difference between the background and the floating body), deltaT = 0.005, and adjustTimeStep is open.
The relevant files are as follows:

[alpha.water]

boundaryField
{
    #includeEtc "caseDicts/setConstraintTypes"
    oversetPatch
    {
        type            overset;
    }
    inlet
    {
        type            waveAlpha;
        waveDictName    waveProperties;
        value           uniform 0;
    }
    outlet
    {
        type            zeroGradient;
    }
    stationaryWalls
    {
        type            zeroGradient;
    }
    atmosphere
    {
        type            inletOutlet;
        inletValue      uniform 0;
        value           uniform 0;
    }
    floatingObject
    {
        type            zeroGradient;
    }
}
// ************************************************************************* //

[p_rgh]

boundaryField
{
    oversetPatch
    {
        patchType       overset;
        type            overset;
    }
    inlet
    {
        type            fixedFluxPressure;
        gradient        uniform 0;
        value           uniform 0;
    }
    outlet
    {
        type            fixedFluxPressure;
        gradient        uniform 0;
        value           uniform 0;
    }
    stationaryWalls
    {
        type            fixedFluxPressure;
        value           uniform 0;
    }
    atmosphere
    {
        type            totalPressure;
        p0              uniform 0;
        U               U;
        phi             phi;
        rho             rho;
        psi             none;
        gamma           1;
        value           uniform 0;
    }
    floatingObject
    {
        type            fixedFluxPressure;
    }
    overset
    {
        patchType       overset;
        type            fixedFluxPressure;
    }
}
// ************************************************************************* //

[U]

boundaryField
{
    #includeEtc "caseDicts/setConstraintTypes"
    oversetPatch
    {
        patchType       overset;
        type            zeroGradient;
    }
    inlet
    {
        type            waveVelocity;
        waveDictName    waveProperties;
        value           uniform (0 0 0);
    }
    outlet
    {
        type            waveVelocity;
        waveDictName    waveProperties;
        value           uniform (0 0 0);
    }
    stationaryWalls
    {
        type            fixedValue;
        value           uniform (0 0 0);
    }
    atmosphere
    {
        type            pressureInletOutletVelocity;
        value           uniform (0 0 0);
    }
    floatingObject
    {
        type            movingWallVelocity;
        value           uniform (0 0 0);
    }
}
// ************************************************************************* //

[zoneID]

boundaryField
{
    #includeEtc "caseDicts/setConstraintTypes"

    inlet
    {
        type            zeroGradient;
    }
    outlet
    {
        type            zeroGradient;
    }
    stationaryWalls
    {
        type            zeroGradient;
    }
    atmosphere
    {
        type            zeroGradient;
    }
    floatingObject
    {
        type            zeroGradient;
    }
    oversetPatch
    {
        patchType       overset;
        type            zeroGradient;
    }
}
// ************************************************************************* //

[waveProperties]

inlet
{
    alpha           alpha.water;
    waveModel       StokesI;
    nPaddle         1;
    waveHeight      0.1;
    waveAngle       90.0;
    rampTime        3.0;
    activeAbsorption yes;
    wavePeriod      0.5;
}
outlet
{
    alpha           alpha.water;
    waveModel       shallowWaterAbsorption;
    nPaddle         1;
}
// ************************************************************************* //

[controlDict]

libs            ("liboverset.so" "libfvMotionSolvers.so");

application     overInterDyMFoam ;

startFrom       latestTime;

startTime       0.0;

stopAt          endTime;

endTime         4.0;

deltaT          0.005;

writeControl    adjustableRunTime;

writeInterval   0.1;

purgeWrite      0;

writeFormat     ascii;

writePrecision  12;

writeCompression off;

timeFormat      general;

timePrecision   6;

runTimeModifiable yes;

adjustTimeStep  yes;

maxCo           1;
maxAlphaCo      1;
maxDeltaT       0.01;

functions
{
    probes
    {
        type            probes;
        libs            ("libsampling.so");

        // Name of the directory for probe data
        name            probes;

        // Write at same frequency as fields
        writeControl    timeStep;
        writeInterval   1;

        // Fields to be probed
        fields          (p U);

        // Optional: interpolation scheme to use (default is cell)
        interpolationScheme cell;

        probeLocations
        (
            (0.00132  0.0009 0.005)
        );

    }

    alphaVol
    {
        libs            ("libutilityFunctionObjects.so");
        type            coded;
        name            alphaVolume;
        writeControl    timeStep;
        writeInterval   10;

        codeWrite
        #{

            const volScalarField& alpha =
                mesh().lookupObject<volScalarField>("alpha.water");

            Info<< "Alpha volume = " << alpha.weightedAverage(mesh().Vsc()) << endl;

        #};
    }
}
// ************************************************************************* //

I made the following attempts, but none of them works:
1. Reduce the time step;
2. Shorten/lengthen the calculation domain;
3. Changed the wave generation boundary to variableHeightFlowRate, but the result was not satisfactory;
4. Calculated different wave height inputs, ranging from 0.01m to 0.4m;
5. Changed the position of overSetPatch;
6. Change the div(rhoPhi,U) in flie.fvSchemes from "Gauss linear" to "Gauss linearUpwind grad(U)";
The entire case file is attached.

Thank you in advance for your help.