Method postprocessIntegrateData

src/IB/CIBMethod.cpp:369–464

} // preprocessIntegrateData

void
CIBMethod::postprocessIntegrateData(double current_time, double new_time, int num_cycles)
{
    // Compute net rigid generalized force for structures.
    const int finest_ln = d_hierarchy->getFinestLevelNumber();
    Pointer<LData> ptr_lagmultpr = d_l_data_manager->getLData("lambda", finest_ln);
    Vec L_vec = ptr_lagmultpr->getVec();
    for (unsigned int part = 0; part < d_num_rigid_parts; ++part)
    {
        computeNetRigidGeneralizedForce(part, L_vec, d_net_rigid_generalized_force[part]);
    }

    // Destroy the free DOFs.
    VecDestroy(&d_U);
    VecDestroy(&d_F);

    // Dump Lagrange multiplier data.
    if (d_lambda_dump_interval && ((d_ib_solver->getIntegratorStep() + 1) % d_lambda_dump_interval == 0))
    {
        Vec lambda_petsc_vec_parallel = ptr_lagmultpr->getVec();
        Vec lambda_lag_vec_parallel = nullptr;
        Vec lambda_lag_vec_seq = nullptr;

        VecDuplicate(lambda_petsc_vec_parallel, &lambda_lag_vec_parallel);
        d_l_data_manager->scatterPETScToLagrangian(lambda_petsc_vec_parallel, lambda_lag_vec_parallel, finest_ln);
        d_l_data_manager->scatterToZero(lambda_lag_vec_parallel, lambda_lag_vec_seq);

        if (IBTK_MPI::getRank() == 0)
        {
            const PetscScalar* L;
            VecGetArrayRead(lambda_lag_vec_seq, &L);
            int counter_L = -1;
            Eigen::Vector3d total_lambda = Eigen::Vector3d::Zero();

            d_lambda_stream << new_time << std::endl << std::endl;
            for (unsigned int struct_no = 0; struct_no < d_num_rigid_parts; ++struct_no)
            {
                const int no_ib_pts = getNumberOfNodes(struct_no);
                d_lambda_stream << "structure: " << struct_no << " ib_pts: " << no_ib_pts << std::endl;

                for (int i = 0; i < no_ib_pts; ++i)
                {
                    for (int d = 0; d < NDIM; ++d)
                    {
                        d_lambda_stream << L[++counter_L] << "\t";
                        total_lambda[d] += L[counter_L];
                    }
                    d_lambda_stream << std::endl;
                }
                d_lambda_stream << "Net resultant lambda for structure: " << struct_no << " ";

                for (int d = 0; d < NDIM; ++d) d_lambda_stream << total_lambda[d] << "\t";
                d_lambda_stream << std::endl;
                total_lambda.setZero();
            }
            VecRestoreArrayRead(lambda_lag_vec_seq, &L);
        }
        VecDestroy(&lambda_lag_vec_parallel);