void ESDIRK::getSourceTerm( const bool /*corrector*/, const int k, const int /*sweep*/, const scalar deltaT, fsi::vector & rhs, fsi::vector & qold ) { assert( k <= nbStages - 1 ); qold = this->qold; // Compute the time step from the stage deltaT if ( dt < 0 ) { // first time step, first prediction step dt = deltaT / A( k, k ); } assert( dt > 0 ); rhs.setZero(); // Calculate sum of the stage residuals for ( int iStage = 0; iStage < k; iStage++ ) rhs += A( k, iStage ) * F.row( iStage ).transpose(); rhs.array() *= dt; this->stageIndex = k; }
void ImplicitMultiLevelFsiSolver::optimize( const fsi::vector & y, const fsi::vector & x0, fsi::vector & xk ) { assert( init ); assert( y.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || y.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( x0.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || x0.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( xk.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || xk.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( x0.rows() == xk.rows() ); assert( y.rows() == xk.rows() ); fsi->newMeasurementSeries(); postProcessing->performPostProcessing( y, x0, xk ); }
void DataStorage::storeFunction( const fsi::vector & f, int substep ) { assert( f.rows() == F.cols() ); assert( substep <= F.rows() ); assert( not std::isnan( f.norm() ) ); F.row( substep ) = f; }
void DataStorage::storeSolution( const fsi::vector & sol, int substep ) { assert( sol.rows() == solStages.cols() ); assert( substep <= solStages.rows() ); assert( not std::isnan( sol.norm() ) ); solStages.row( substep ) = sol; }
void ImplicitMultiLevelFsiSolver::evaluate( const fsi::vector & x, fsi::vector & output, fsi::vector & R ) { assert( init ); assert( x.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || x.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( output.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || output.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( R.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || R.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( x.rows() == output.rows() ); assert( x.rows() == R.rows() ); fsi->evaluate( x, output, R ); }
virtual void optimize( const fsi::vector & y, const fsi::vector & /*x0*/, fsi::vector & xk ) { assert( y.rows() == 3 ); assert( xk.rows() == 2 ); // Analytical optimum xk( 0 ) = (y[2] - y[0]) / 2.0; xk( 1 ) = (y[0] + y[1] + y[2]) / 3.0; }
void SDCFsiSolver::setSolution( const fsi::vector & solution, const fsi::vector & f ) { Eigen::Map<const fsi::vector> solFluid( solution.data(), dofFluid ); Eigen::Map<const fsi::vector> solSolid( solution.data() + dofFluid, dofSolid ); Eigen::Map<const fsi::vector> fFluid( f.data(), dofFluid ); Eigen::Map<const fsi::vector> fSolid( f.data() + dofFluid, dofSolid ); fluid->setSolution( solFluid, fFluid ); solid->setSolution( solSolid, fSolid ); }
virtual void evaluate( const fsi::vector & x, fsi::vector & output, fsi::vector & R ) { assert( x.rows() == 2 ); assert( R.rows() == 3 ); fsi::vector t( 3 ); t << -1, 0, 1; R = x( 0 ) * t + x( 1 ) * Eigen::MatrixXd::Ones( 3, 1 ); output = R; }
virtual void evaluate( const fsi::vector & x, fsi::vector & output, fsi::vector & R ) { assert( x.rows() == 2 ); assert( R.rows() == 3 ); fsi::vector t( 3 ); t << -1, 0, 1; R = x( 0 ) * (x( 1 ) * t.array() + 1.0).pow( 2 ); output = R; }
virtual bool isConvergence( const fsi::vector & x, const fsi::vector & xprev ) { assert( x.rows() == xprev.rows() ); iter++; allConverged_ = false; if ( (x - xprev).norm() < tol * x.norm() ) allConverged_ = true; return allConverged_; }
void SDCFsiSolver::implicitSolve( bool corrector, const int k, const int kold, const scalar t, const scalar dt, const fsi::vector & qold, const fsi::vector & rhs, fsi::vector & f, fsi::vector & result ) { Eigen::Map<const fsi::vector> qoldFluid( qold.data(), dofFluid ); Eigen::Map<const fsi::vector> qoldSolid( qold.data() + dofFluid, dofSolid ); Eigen::Map<const fsi::vector> rhsFluid( rhs.data(), dofFluid ); Eigen::Map<const fsi::vector> rhsSolid( rhs.data() + dofFluid, dofSolid ); fluid->prepareImplicitSolve( corrector, k, kold, t, dt, qoldFluid, rhsFluid ); solid->prepareImplicitSolve( corrector, k, kold, t, dt, qoldSolid, rhsSolid ); // Perform FSI iterations to solve the coupled problem postProcessing->fsi->newMeasurementSeries(); // Initial solution fsi::vector x0; if ( corrector ) x0 = xStages.at( k + 1 ); else x0 = xStages.at( k ); postProcessing->initStage( k ); postProcessing->performPostProcessing( x0, postProcessing->fsi->x ); postProcessing->finalizeStage(); getSolution( result, f ); evaluateFunction( k, result, t, f ); xStages.at( k + 1 ) = postProcessing->fsi->x; fluid->finalizeImplicitSolve( k ); solid->finalizeImplicitSolve( k ); }
void SDCFsiSolver::evaluateFunction( const int k, const fsi::vector & q, const scalar t, fsi::vector & f ) { fsi::vector fFluid( dofFluid ), fSolid( dofSolid ); Eigen::Map<const fsi::vector> qFluid( q.data(), dofFluid ); Eigen::Map<const fsi::vector> qSolid( q.data() + dofFluid, dofSolid ); fluid->evaluateFunction( k, qFluid, t, fFluid ); solid->evaluateFunction( k, qSolid, t, fSolid ); f.head( dofFluid ) = fFluid; f.tail( dofSolid ) = fSolid; }
void ESDIRK::setFunction( const int k, const fsi::vector & f, const fsi::vector & result ) { assert( f.rows() == result.rows() ); assert( k <= nbStages - 1 ); if ( F.cols() == 0 ) F.resize( nbStages, f.rows() ); if ( solStages.cols() == 0 ) solStages.resize( nbStages, f.rows() ); F.row( k ) = f; solStages.row( k ) = result; }
void TubeFlowLinearizedFluidSolver::solve( const fsi::vector & a, fsi::vector & p ) { this->a = a.array() - a0; std::cout << "Solve fluid domain" << std::endl; // Construct right hand size of linear system fsi::vector b( 2 * N ), x( 2 * N ); b.setZero(); for ( int i = 1; i < N - 1; i++ ) { // Continuity equation rhs b( i ) = dx / dt * ( an( i ) - this->a( i ) ); b( i ) += 0.5 * u0 * ( this->a( i - 1 ) - this->a( i + 1 ) ); // Momentum equation rhs b( i + N ) = u0 * dx / dt * ( an( i ) - this->a( i ) ); b( i + N ) += 0.5 * u0 * u0 * ( this->a( i - 1 ) - this->a( i + 1 ) ); b( i + N ) += a0 * dx / dt * un( i ); } // Boundary conditions // Velocity inlet condition b( 0 ) = u0 / 10.0 * std::pow( std::sin( M_PI * timeIndex * tau ), 2 ); // Pressure inlet b( N ) = 0; // Velocity outlet condition b( N - 1 ) = 0; // Pressure outlet condition b( 2 * N - 1 ) = -cmk * rho * un( N - 1 ) + pn( N - 1 ); // Solve for x x = lu.solve( b ); // Retrieve solution u = x.head( N ); this->p = x.tail( N ); // Return pressure p p = this->p.array() + p0; data.col( 0 ) = p; }
int operator()( const fsi::vector & x, fsi::vector & fvec ) const { fsi::vector output( x.rows() ); model->evaluate( x, output, fvec ); fvec -= *y; return 0; }
void ESDIRK::setOldSolution( int timeIndex, const fsi::vector & result ) { assert( timeIndex >= this->timeIndex ); if ( qold.rows() == result.rows() ) qold = solStages.bottomRows( 1 ).transpose(); else if ( timeIndex > this->timeIndex ) qold = result; this->timeIndex = timeIndex; }
void SDCFsiSolver::getSolution( fsi::vector & solution, fsi::vector & f ) { assert( dofFluid > 0 ); assert( dofSolid >= 0 ); assert( dofFluid + dofSolid == solution.rows() ); assert( solution.rows() == f.rows() ); fsi::vector solFluid( dofFluid ), solSolid( dofSolid ), fFluid( dofFluid ), fSolid( dofSolid ); fluid->getSolution( solFluid, fFluid ); solid->getSolution( solSolid, fSolid ); solution.head( dofFluid ) = solFluid; solution.tail( dofSolid ) = solSolid; f.head( dofFluid ) = fFluid; f.tail( dofSolid ) = fSolid; }
bool ImplicitMultiLevelFsiSolver::isConvergence( const fsi::vector & x, const fsi::vector & xprev ) { assert( init ); assert( x.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || x.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( xprev.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim || xprev.rows() == fsi->solidSolver->couplingGridSize * fsi->solid->dim + fsi->fluidSolver->couplingGridSize * fsi->fluid->dim ); assert( x.rows() == xprev.rows() ); return fsi->isConvergence( x, xprev ); }