void SDCMovingWallVelocityFvPatchVectorField::init()
{
string filename = static_cast<std::string>( this->db().time().rootPath() ) + "/" + static_cast<std::string>( this->db().time().caseName() ) + "/constant/fsi.yaml";
if ( Pstream::nProcs() > 1 )
filename = static_cast<std::string>( this->db().time().rootPath() ) + "/" + static_cast<std::string>( this->db().time().caseName() ) + "/../constant/fsi.yaml";
YAML::Node config = YAML::LoadFile( filename );
assert( config["sdc"] || config["esdirk"] );
if ( config["sdc"] )
{
YAML::Node sdcConfig( config["sdc"] );
assert( sdcConfig["convergence-tolerance"] );
assert( sdcConfig["number-of-points"] );
assert( sdcConfig["quadrature-rule"] );
int n = sdcConfig["number-of-points"].as<int>();
double tol = sdcConfig["convergence-tolerance"].as<double>();
std::string quadratureRule = sdcConfig["quadrature-rule"].as<std::string>();
std::shared_ptr<fsi::quadrature::IQuadrature<scalar> > quadrature;
if ( quadratureRule == "gauss-radau" )
quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::GaussRadau<scalar>( n ) );
if ( quadratureRule == "gauss-lobatto" )
quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::GaussLobatto<scalar>( n ) );
if ( quadratureRule == "clenshaw-curtis" )
quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::ClenshawCurtis<scalar>( n ) );
if ( quadratureRule == "uniform" )
quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::Uniform<scalar>( n ) );
timeIntegrationScheme = std::shared_ptr<sdc::TimeIntegrationScheme> ( new sdc::SDC( quadrature, tol ) );
}
if ( config["esdirk"] )
{
YAML::Node esdirkConfig( config["esdirk"] );
assert( esdirkConfig["method"] );
std::string method = esdirkConfig["method"].as<std::string>();
timeIntegrationScheme = std::shared_ptr<sdc::TimeIntegrationScheme> ( new sdc::ESDIRK( method ) );
}
}
int main(
int argc,
char * argv[]
)
{
std::shared_ptr<argList> args( new argList( argc, argv ) );
if ( !args->checkRootCase() )
{
FatalError.exit();
}
std::shared_ptr<Time> runTime( new Time
(
Time::controlDictName,
args->rootPath(),
args->caseName()
) );
string filename = static_cast<std::string>( args->rootPath() ) + "/" + static_cast<std::string>( args->globalCaseName() ) + "/constant/fsi.yaml";
YAML::Node config = YAML::LoadFile( filename );
assert( config["fluid-solver"] );
std::string fluidSolver = config["fluid-solver"].as<std::string>();
assert( fluidSolver == "coupled-pressure-velocity-solver" || fluidSolver == "pimple-solver" || fluidSolver == "compressible-solver" || fluidSolver == "sdc-pimple-solver" || fluidSolver == "sdc-laplacian-solver" || fluidSolver == "esdirk-pimple-solver" );
std::shared_ptr<foamFluidSolver> fluid;
std::shared_ptr<sdc::SDC> sdc;
std::shared_ptr<sdc::ESDIRK> esdirk;
if ( fluidSolver == "coupled-pressure-velocity-solver" )
fluid = std::shared_ptr<foamFluidSolver> ( new CoupledFluidSolver( Foam::fvMesh::defaultRegion, args, runTime ) );
if ( fluidSolver == "pimple-solver" )
fluid = std::shared_ptr<foamFluidSolver> ( new FluidSolver( Foam::fvMesh::defaultRegion, args, runTime ) );
if ( fluidSolver == "compressible-solver" )
fluid = std::shared_ptr<foamFluidSolver> ( new CompressibleFluidSolver( Foam::fvMesh::defaultRegion, args, runTime ) );
std::shared_ptr<sdc::AdaptiveTimeStepper> adaptiveTimeStepper;
if ( fluidSolver == "sdc-pimple-solver" || fluidSolver == "esdirk-pimple-solver" || fluidSolver == "sdc-laplacian-solver" )
{
YAML::Node adaptiveTimeConfig( config["adaptive-time-stepping"] );
assert( adaptiveTimeConfig["enabled"] );
bool adaptiveTimeStepping = adaptiveTimeConfig["enabled"].as<bool>();
std::string filter = "elementary";
double adaptiveTolerance = 1.0e-3;
double safetyFactor = 0.5;
if ( adaptiveTimeStepping )
{
assert( adaptiveTimeConfig["filter"] );
assert( adaptiveTimeConfig["tolerance"] );
assert( adaptiveTimeConfig["safety-factor"] );
filter = adaptiveTimeConfig["filter"].as<std::string>();
adaptiveTolerance = adaptiveTimeConfig["tolerance"].as<double>();
safetyFactor = adaptiveTimeConfig["safety-factor"].as<double>();
}
adaptiveTimeStepper = std::shared_ptr<sdc::AdaptiveTimeStepper> ( new sdc::AdaptiveTimeStepper( adaptiveTimeStepping, filter, adaptiveTolerance, safetyFactor ) );
}
if ( fluidSolver == "sdc-pimple-solver" || fluidSolver == "sdc-laplacian-solver" )
{
YAML::Node sdcConfig( config["sdc"] );
assert( sdcConfig["convergence-tolerance"] );
assert( sdcConfig["number-of-points"] );
assert( sdcConfig["quadrature-rule"] );
assert( adaptiveTimeStepper );
int n = sdcConfig["number-of-points"].as<int>();
double tol = sdcConfig["convergence-tolerance"].as<double>();
std::string quadratureRule = sdcConfig["quadrature-rule"].as<std::string>();
std::shared_ptr<sdc::SDCSolver> solver;
if ( fluidSolver == "sdc-pimple-solver" )
solver = std::shared_ptr<sdc::SDCSolver>( new SDCFluidSolver( Foam::fvMesh::defaultRegion, args, runTime ) );
if ( fluidSolver == "sdc-laplacian-solver" )
solver = std::shared_ptr<sdc::SDCSolver>( new SDCLaplacianSolver( Foam::fvMesh::defaultRegion, args, runTime ) );
sdc = std::shared_ptr<sdc::SDC> ( new sdc::SDC( solver, adaptiveTimeStepper, quadratureRule, n, tol ) );
}
if ( fluidSolver == "esdirk-pimple-solver" )
{
YAML::Node esdirkConfig( config["esdirk"] );
assert( esdirkConfig["method"] );
assert( adaptiveTimeStepper );
std::string method = esdirkConfig["method"].as<std::string>();
std::shared_ptr<sdc::SDCSolver> solver;
solver = std::shared_ptr<sdc::SDCSolver>( new SDCFluidSolver( Foam::fvMesh::defaultRegion, args, runTime ) );
esdirk = std::shared_ptr<sdc::ESDIRK>( new sdc::ESDIRK( solver, method, adaptiveTimeStepper ) );
}
assert( fluid || sdc || esdirk );
if ( fluid )
fluid->run();
if ( sdc )
sdc->run();
if ( esdirk )
esdirk->run();
Info << "End\n" << endl;
return 0;
}
