[sharifi]

Dear openFoamers,

I want OpenFOAM performs during the parallel simulation "reconstructPar" , so that I can look at the results without problem.
I found a Function " systemCall"

http://openfoamwiki.net/index.php/Ti...ect_systemCall

It looks promising but It can do the commands after a time iteration or/and before the simulation is over. I studied the code (http://foam.sourceforge.net/docs/cpp/a02231.html)
and i didn't find, where it asks for time?
could it have to do with this command "
TypeName ( "systemCall" )"

have anyone any idea ,how can I extend that library to make it able to do the command after (for example) 10 iteration?

thx

[Tobi]

Hi,

why don t you use paraview with decomposed case?
There you can have a look at the results too!

easy and good.
Otherwise open a other terminal and use reconstructPar.

Maybe I missunderstood you?!

[sharifi]

Originally Posted by Tobi

Hi,

why don t you use paraview with decomposed case?
There you can have a look at the results too!

easy and good.
Otherwise open a other terminal and use reconstructPar.

Maybe I missunderstood you?!

thanks for the answer

the idea is, during the parallel processing in a cluster the result is automatically written out . Thus the effort each time "entering the command reconstructPar" is saved.

[Sylv]

Originally Posted by sharifi

thanks for the answer

the idea is, during the parallel processing in a cluster the result is automatically written out . Thus the effort each time "entering the command reconstructPar" is saved.

Hello sharifi,

I am in the same position as you (doing stuff during the parallel run on a cluster). sysCall works really well for such operation. Here is a short example of a python script named "doStuff.py" used by the sysCall function of OpenFOAM:

# import library
import os
import subprocess

# find master processor and then do something only on this one
if os.environ['OMPI_COMM_WORLD_RANK']=='0':
    # do something directly on the master processor, like reconstruction (not nice)
    proc = subprocess.Popen('reconstructPar -time 1.23', stdout=subprocess.PIPE, shell=True)
    (out, err) = proc.communicate()
    # do something directly on the master processor, like restart a reconstruction job (much clever because you can really do stuffs in parallel)
    proc = subprocess.Popen('qsub myReconstructionJob.sh', stdout=subprocess.PIPE, shell=True)
    (out, err) = proc.communicate()

The environment variable to find the master processor depends on mpi protocol used by your OpenFOAM. My conrtolDict looks like:

sysCallJobs
{
    type systemCall;
    functionObjectLibs ( "libsystemCall.so" );
    executeCalls 0();
    endCalls 0();
    writeCalls 1("./doStuff.py");
    outputControl outputTime;
}

[sharifi]

thanks for the answer.
I found another way to do that. It might be interesting for you.
code:
I've made one or two modification in the original code.

/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.

OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.

Class
Foam::systemCall

Description
Executes system calls, entered in the form of a string list

SourceFiles
systemCall.C
IOsystemCall.H

\*---------------------------------------------------------------------------*/

#ifndef systemCall_H
#define systemCall_H

#include "stringList.H"
#include "pointFieldFwd.H"



// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

// Forward declaration of classes
class objectRegistry;
class dictionary;
class mapPolyMesh;

/*---------------------------------------------------------------------------*\
Class systemCall Declaration
\*---------------------------------------------------------------------------*/

class systemCall
{
protected:

// Private data

//- Name of this set of system calls
word name_;

//- List of calls to execute - every step
stringList executeCalls_;

//- List of calls to execute when exiting the time-loop
stringList endCalls_;

//- List of calls to execute - write steps
stringList writeCalls_;

//\\---------------------------------------------------\\//


const objectRegistry& obr_;

label writeInterval_;



//\\---------------------------------------------------\\//

// Private Member Functions

//- Disallow default bitwise copy construct
systemCall(const systemCall&);

//- Disallow default bitwise assignment
void operator=(const systemCall&);


public:

//- Runtime type information
TypeName("systemCall");


// Constructors
//\\---------------------------------------------------\\//
//- Construct for given objectRegistry and dictionary.
// Allow the possibility to load fields from files
systemCall
(
const word& name,
const objectRegistry& obr,//unused
const dictionary&,
const bool loadFromFilesUnused = false
);
//\\---------------------------------------------------\\//

//- Destructor
virtual ~systemCall();


// Member Functions

//- Return name of the system call set
virtual const word& name() const
{
return name_;
}

//- Read the system calls
virtual void read(const dictionary&);

//- Execute the "executeCalls" at each time-step
virtual void execute();

//- Execute the "endCalls" at the final time-loop
virtual void end();




//- Write, execute the "writeCalls"
virtual void write();




//- Update for changes of mesh
virtual void updateMesh(const mapPolyMesh&)
{}

//- Update for changes of mesh
virtual void movePoints(const pointField&)
{}
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************** *********************** //

/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.

OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.

\*---------------------------------------------------------------------------*/
#include "systemCall.H"
#include "Time.H"
#include "dynamicCode.H"


// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //

defineTypeNameAndDebug(Foam::systemCall, 0);


// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //

Foam::systemCall::systemCall
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFilesUnused
)
:
name_(name),
executeCalls_(),
endCalls_(),
writeCalls_(),

//\\---------------------------------------------------\\//
obr_(obr)

//\\---------------------------------------------------\\//
{
read(dict);
}


// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //

Foam::systemCall::~systemCall()
{}


// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //

void Foam::systemCall::read(const dictionary& dict)
{
dict.readIfPresent("executeCalls", executeCalls_);
dict.readIfPresent("endCalls", endCalls_);
dict.readIfPresent("writeCalls", writeCalls_);

//\\---------------------------------------------------\\//

dict.lookup("writeInterval") >> writeInterval_;


//\\---------------------------------------------------\\//


if (executeCalls_.empty() && endCalls_.empty() && writeCalls_.empty())
{
WarningIn("Foam::system::read(const dictionary&)")
<< "no executeCalls, endCalls or writeCalls defined."
<< endl;
}
else if (!dynamicCode::allowSystemOperations)
{
FatalErrorIn
(
"systemCall::read(const dictionary&)"
) << "Executing user-supplied system calls is not"
<< " enabled by default" << endl
<< "because of security issues. If you trust the case you can"
<< " enable this" << endl
<< "facility be adding to the InfoSwitches setting in the system"
<< " controlDict:" << endl
<< endl
<< " allowSystemOperations 1" << endl
<< endl
<< "The system controlDict is either" << endl
<< endl
<< " ~/.OpenFOAM/$WM_PROJECT_VERSION/controlDict" << endl
<< endl
<< "or" << endl
<< endl
<< " $WM_PROJECT_DIR/etc/controlDict" << endl
<< endl
<< exit(FatalError);
}
}


void Foam::systemCall::execute()
{
forAll(executeCalls_, callI)
{
Foam::system(executeCalls_[callI]);
}
}


void Foam::systemCall::end()
{
forAll(endCalls_, callI)
{

Foam::system(endCalls_[callI]);

}

}

//\\---------------------------------------------------\\//
void Foam::systemCall::write()
{

if (obr_.time().timeIndex() % writeInterval_==0)
{
forAll(writeCalls_, callI)
{

Foam::system(writeCalls_[callI]);

}
}

}
//\\---------------------------------------------------\\//

// ************************************************** *********************** //

(don't forget : wmake libso)

you should now add in the controlDict of your problem writeInterval the desirable Interval.