[katiuskas]

Dear foamers,

I am currently working on a custom type of source term (via a new library), which the user can specify through fvOptions. The idea is that the applied force field depends on the position and velocity of a rigid body, which is defined in dynamicMeshDict using the sixDoFRigidBody library:

...
dynamicFvMesh dynamicMotionSolverFvMesh;
motionSolverLibs 
(
  "libsixDoFRigidBodyMotion.so"
);
solver sixDoFRigidBodyMotion;
diffusivity     quadratic inverseDistance ( cylinder );
 
 sixDoFRigidBodyMotionCoeffs
 {
...
 }

My main concern is how to access the solid body motion state (at each time-step) from the library I am currently implementing. I know the state of the rigid body is stored by the classes sixDoFRigidBodyMotionState and sixDoFRigidBodyState, but I have no idea how to access the motion object and its properties.

I have seen a similar issue tackled in a 2015 post, but unfortunately, I cannot understand it fully. I think they propose modifying the original sixDoF library to export a motion dictionary, which can then be accessed from their custom program.

I think there has to be a well-defined manner to access and pass object information between different libraries, but I am very new to programming in OpenFOAM and such things still escape my understanding. Thus, I would really appreciate any guidance in this regard.

Thank you very much!

[katiuskas]

I finally went through the 2015 post and adapted the proposal from yuhan1991 (reply #5). Just in case anyone is trying to do something similar, this is what I did:

• Create a copy of the rigid body library so that I can modify it without affecting the original one. Just called it mySixDoFRigidBodyMotion.
  
• Modify the sixDoFRigidBodyMotion.C file so that every time the rigid body equations are solved, an IOdictonary (which I called "sixDoFMotion") is updated with its information.
  
  For this purpose, two new functions must be defined: one for creating the IOdictionary (to be called only once at the class constructor) and a second one for updating it with the rigid body motion information.

void Foam::sixDoFRigidBodyMotion::createDict()
{
    // Create dictionary if it has not been created before
    if(!time_.foundObject<IOdictionary>("sixDoFMotion"))
    {
        dictionary motionDict;
        time_.store
        (   
            new IOdictionary
            (   
                IOobject
                (   
                    "sixDoFMotion",
                    time_.timeName(),
                    time_,
                    IOobject::NO_READ,
                    IOobject::AUTO_WRITE
                ),
                motionDict
            )
        );

        Info << "Rigid body IOdictionary 'sixDoFMotion' created" << endl;

        updateDict();

    }
}

void Foam::sixDoFRigidBodyMotion::updateDict()
{
    if(time_.foundObject<IOdictionary>("sixDoFMotion"))
    {
        // Open and write
        const dictionary& motionDict = 
            time_.lookupObject<IOdictionary>("sixDoFMotion");

        // Update for the motion solver
        dictionary updateDbDictionary = &motionDict;
        updateDbDictionary.set("centreOfRotation", centreOfRotation());
        updateDbDictionary.set("orientation", orientation());
        updateDbDictionary.set("velocity", v());
        updateDbDictionary.set("omega", omega());

        // Needed to update the IOdictionary
        const_cast<dictionary& > (motionDict) = updateDbDictionary;
        
        Info << "Updating 'sixDoFMotion' IOdictionary" << endl;
       
    }
}

Here the const_cast is very important as it allows us overwrite the IOdictionary.

The createDict() function is called only once inside the constructor, whereas updateDict() is called inside sixDoFRigidBodyMotion::update():

...
    if (Pstream::master())
    {
        solver_->solve(firstIter, fGlobal, tauGlobal, deltaT, deltaT0);

        if (report_)
        {
            status();
        }

        updateDict();
    }

• Finally, in the custom library, I access the newly created dictionary:

void Foam::fv::myLib::readRigidBodyDict(const fvMesh& mesh)
{
    // If rigid body dictionary exists
    if(mesh.time().foundObject<IOdictionary>("sixDoFMotion"))
    {
        // Access dictionary
        const dictionary& motionDict = mesh.time().lookupObject<IOdictionary>("sixDoFMotion");
        // Save its reference
        rigidBodyDict_ = motionDict;
    }
    else
    {
        Info << "Rigid body IOdictionary ('sixDoFMotion') could not be accessed." << endl;
    }
}

The data contained in the dictionary can then be accessed via the usual lookup action, eg. "rigidBodyDict_.lookup("centreOfRotation") >> rotCenter_".
Note that in sixDoFRigidBodyMotion.C, I had access to the runtime variable time_ whereas in my custom library I have access to the fvMesh object mesh. Thus, the syntax to access the dictionary in both cases might be slightly different.

This is, as of now, the only way I know to transfer data between classes. I am very open to any suggestions! I hope this can help someone in a similar situation.

[isulovsky]

Dear Katiuskas,

Thank you so much for posting the solution as I am dealing with something similar. Are you willing to share the .C file of the sixDoFRigidBodyMotion ?

I am also trying to inherit the rigid body state in my custom library and I think I have declared something wrong in the sixDoF file.

Kind regards,

Ivan