diff --git a/Makefile b/Makefile index 5331ca3dc5..2fd059ce8f 100644 --- a/Makefile +++ b/Makefile @@ -876,6 +876,7 @@ install : $(libceed) $(OBJDIR)/ceed.pc "$(includedir)/ceed/jit-source/gallery/" "$(includedir)/ceed/jit-source/magma/"\ "$(includedir)/ceed/jit-source/sycl/" "$(libdir)" "$(pkgconfigdir)") $(INSTALL_DATA) include/ceed/ceed.h "$(DESTDIR)$(includedir)/ceed/" + $(INSTALL_DATA) include/ceed/deprecated.h "$(DESTDIR)$(includedir)/ceed/" $(INSTALL_DATA) include/ceed/types.h "$(DESTDIR)$(includedir)/ceed/" $(INSTALL_DATA) include/ceed/ceed-f32.h "$(DESTDIR)$(includedir)/ceed/" $(INSTALL_DATA) include/ceed/ceed-f64.h "$(DESTDIR)$(includedir)/ceed/" diff --git a/backends/cuda-gen/ceed-cuda-gen-operator.c b/backends/cuda-gen/ceed-cuda-gen-operator.c index 7965b2a70f..c6791807ac 100644 --- a/backends/cuda-gen/ceed-cuda-gen-operator.c +++ b/backends/cuda-gen/ceed-cuda-gen-operator.c @@ -302,8 +302,8 @@ static int CeedOperatorApplyAddComposite_Cuda_gen(CeedOperator op, CeedVector in CeedOperator *sub_operators; CeedCallBackend(CeedOperatorGetCeed(op, &ceed)); - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); if (input_vec != CEED_VECTOR_NONE) CeedCallBackend(CeedVectorGetArrayRead(input_vec, CEED_MEM_DEVICE, &input_arr)); if (output_vec != CEED_VECTOR_NONE) CeedCallBackend(CeedVectorGetArray(output_vec, CEED_MEM_DEVICE, &output_arr)); for (CeedInt i = 0; i < num_suboperators; i++) { @@ -515,7 +515,7 @@ static int CeedOperatorLinearAssembleQFunctionCore_Cuda_gen(CeedOperator op, boo CeedDebug(CeedOperatorReturnCeed(op), "\nFalling back to /gpu/cuda/ref CeedOperator for LinearAssemblyQFunction\n"); CeedCallBackend(CeedOperatorGetFallback(op, &op_fallback)); - CeedCallBackend(CeedOperatorFallbackLinearAssembleQFunctionBuildOrUpdate(op_fallback, assembled, rstr, request)); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionBuildOrUpdateFallback(op_fallback, assembled, rstr, request)); return CEED_ERROR_SUCCESS; } return CEED_ERROR_SUCCESS; @@ -695,7 +695,7 @@ static int CeedOperatorLinearAssembleAddDiagonalAtPoints_Cuda_gen(CeedOperator o //------------------------------------------------------------------------------ // AtPoints full assembly //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssembleAtPoints_Cuda_gen(CeedOperator op, CeedInt offset, CeedVector assembled) { +static int CeedOperatorAssembleSingleAtPoints_Cuda_gen(CeedOperator op, CeedInt offset, CeedVector assembled) { Ceed ceed; CeedOperator_Cuda_gen *data; @@ -851,7 +851,7 @@ static int CeedSingleOperatorAssembleAtPoints_Cuda_gen(CeedOperator op, CeedInt CeedDebug(CeedOperatorReturnCeed(op), "\nFalling back to /gpu/cuda/ref CeedOperator for AtPoints SingleOperatorAssemble\n"); CeedCallBackend(CeedOperatorGetFallback(op, &op_fallback)); - CeedCallBackend(CeedSingleOperatorAssemble(op_fallback, offset, assembled)); + CeedCallBackend(CeedOperatorAssembleSingle(op_fallback, offset, assembled)); return CEED_ERROR_SUCCESS; } return CEED_ERROR_SUCCESS; @@ -878,7 +878,7 @@ int CeedOperatorCreate_Cuda_gen(CeedOperator op) { if (is_at_points) { CeedCallBackend( CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleAddDiagonal", CeedOperatorLinearAssembleAddDiagonalAtPoints_Cuda_gen)); - CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedSingleOperatorAssembleAtPoints_Cuda_gen)); + CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedOperatorAssembleSingleAtPoints_Cuda_gen)); } if (!is_at_points) { CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleQFunction", CeedOperatorLinearAssembleQFunction_Cuda_gen)); diff --git a/backends/cuda-ref/ceed-cuda-ref-operator.c b/backends/cuda-ref/ceed-cuda-ref-operator.c index de6129fc25..b278f37643 100644 --- a/backends/cuda-ref/ceed-cuda-ref-operator.c +++ b/backends/cuda-ref/ceed-cuda-ref-operator.c @@ -1501,7 +1501,7 @@ static int CeedOperatorLinearAssembleAddPointBlockDiagonal_Cuda(CeedOperator op, //------------------------------------------------------------------------------ // Single Operator Assembly Setup //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssembleSetup_Cuda(CeedOperator op, CeedInt use_ceedsize_idx) { +static int CeedOperatorAssembleSingleSetup_Cuda(CeedOperator op, CeedInt use_ceedsize_idx) { Ceed ceed; Ceed_Cuda *cuda_data; CeedInt num_input_fields, num_output_fields, num_eval_modes_in = 0, num_eval_modes_out = 0; @@ -1707,7 +1707,7 @@ static int CeedSingleOperatorAssembleSetup_Cuda(CeedOperator op, CeedInt use_cee // (could have multiple basis eval modes). // TODO: allow multiple active input restrictions/basis objects //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssemble_Cuda(CeedOperator op, CeedInt offset, CeedVector values) { +static int CeedOperatorAssembleSingle_Cuda(CeedOperator op, CeedInt offset, CeedVector values) { Ceed ceed; CeedSize values_length = 0, assembled_qf_length = 0; CeedInt use_ceedsize_idx = 0, num_elem_in, num_elem_out, elem_size_in, elem_size_out; @@ -1733,7 +1733,7 @@ static int CeedSingleOperatorAssemble_Cuda(CeedOperator op, CeedInt offset, Ceed if ((values_length > INT_MAX) || (assembled_qf_length > INT_MAX)) use_ceedsize_idx = 1; // Setup - if (!impl->asmb) CeedCallBackend(CeedSingleOperatorAssembleSetup_Cuda(op, use_ceedsize_idx)); + if (!impl->asmb) CeedCallBackend(CeedOperatorAssembleSingleSetup_Cuda(op, use_ceedsize_idx)); CeedOperatorAssemble_Cuda *asmb = impl->asmb; assert(asmb != NULL); @@ -2077,7 +2077,7 @@ int CeedOperatorCreate_Cuda(CeedOperator op) { CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleAddDiagonal", CeedOperatorLinearAssembleAddDiagonal_Cuda)); CeedCallBackend( CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleAddPointBlockDiagonal", CeedOperatorLinearAssembleAddPointBlockDiagonal_Cuda)); - CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedSingleOperatorAssemble_Cuda)); + CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedOperatorAssembleSingle_Cuda)); CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "ApplyAdd", CeedOperatorApplyAdd_Cuda)); CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "Destroy", CeedOperatorDestroy_Cuda)); CeedCallBackend(CeedDestroy(&ceed)); diff --git a/backends/hip-gen/ceed-hip-gen-operator.c b/backends/hip-gen/ceed-hip-gen-operator.c index bf673730db..e4c2634a66 100644 --- a/backends/hip-gen/ceed-hip-gen-operator.c +++ b/backends/hip-gen/ceed-hip-gen-operator.c @@ -30,7 +30,7 @@ static int CeedOperatorDestroy_Hip_gen(CeedOperator op) { if (is_composite) { CeedInt num_suboperators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); for (CeedInt i = 0; i < num_suboperators; i++) { if (impl->streams[i]) CeedCallHip(ceed, hipStreamDestroy(impl->streams[i])); impl->streams[i] = NULL; @@ -262,8 +262,8 @@ static int CeedOperatorApplyAddComposite_Hip_gen(CeedOperator op, CeedVector inp CeedCallBackend(CeedOperatorGetCeed(op, &ceed)); CeedCallBackend(CeedOperatorGetData(op, &impl)); - CeedCallBackend(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCallBackend(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCallBackend(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCallBackend(CeedOperatorCompositeGetSubList(op, &sub_operators)); if (input_vec != CEED_VECTOR_NONE) CeedCallBackend(CeedVectorGetArrayRead(input_vec, CEED_MEM_DEVICE, &input_arr)); if (output_vec != CEED_VECTOR_NONE) CeedCallBackend(CeedVectorGetArray(output_vec, CEED_MEM_DEVICE, &output_arr)); for (CeedInt i = 0; i < num_suboperators; i++) { @@ -491,7 +491,7 @@ static int CeedOperatorLinearAssembleQFunctionCore_Hip_gen(CeedOperator op, bool CeedDebug(CeedOperatorReturnCeed(op), "\nFalling back to /gpu/hip/ref CeedOperator for LineearAssembleQFunction\n"); CeedCallBackend(CeedOperatorGetFallback(op, &op_fallback)); - CeedCallBackend(CeedOperatorFallbackLinearAssembleQFunctionBuildOrUpdate(op_fallback, assembled, rstr, request)); + CeedCallBackend(CeedOperatorLinearAssembleQFunctionBuildOrUpdateFallback(op_fallback, assembled, rstr, request)); return CEED_ERROR_SUCCESS; } return CEED_ERROR_SUCCESS; @@ -684,7 +684,7 @@ static int CeedOperatorLinearAssembleAddDiagonalAtPoints_Hip_gen(CeedOperator op //------------------------------------------------------------------------------ // AtPoints full assembly //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssembleAtPoints_Hip_gen(CeedOperator op, CeedInt offset, CeedVector assembled) { +static int CeedOperatorAssembleSingleAtPoints_Hip_gen(CeedOperator op, CeedInt offset, CeedVector assembled) { Ceed ceed; CeedOperator_Hip_gen *data; @@ -860,7 +860,7 @@ static int CeedSingleOperatorAssembleAtPoints_Hip_gen(CeedOperator op, CeedInt o CeedDebug(CeedOperatorReturnCeed(op), "\nFalling back to /gpu/hip/ref CeedOperator for AtPoints SingleOperatorAssemble\n"); CeedCallBackend(CeedOperatorGetFallback(op, &op_fallback)); - CeedCallBackend(CeedSingleOperatorAssemble(op_fallback, offset, assembled)); + CeedCallBackend(CeedOperatorAssembleSingle(op_fallback, offset, assembled)); return CEED_ERROR_SUCCESS; } return CEED_ERROR_SUCCESS; @@ -886,7 +886,7 @@ int CeedOperatorCreate_Hip_gen(CeedOperator op) { CeedCall(CeedOperatorIsAtPoints(op, &is_at_points)); if (is_at_points) { CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleAddDiagonal", CeedOperatorLinearAssembleAddDiagonalAtPoints_Hip_gen)); - CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedSingleOperatorAssembleAtPoints_Hip_gen)); + CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedOperatorAssembleSingleAtPoints_Hip_gen)); } if (!is_at_points) { CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleQFunction", CeedOperatorLinearAssembleQFunction_Hip_gen)); diff --git a/backends/hip-ref/ceed-hip-ref-operator.c b/backends/hip-ref/ceed-hip-ref-operator.c index 15fc21b73a..8c37aba61b 100644 --- a/backends/hip-ref/ceed-hip-ref-operator.c +++ b/backends/hip-ref/ceed-hip-ref-operator.c @@ -1498,7 +1498,7 @@ static int CeedOperatorLinearAssembleAddPointBlockDiagonal_Hip(CeedOperator op, //------------------------------------------------------------------------------ // Single Operator Assembly Setup //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssembleSetup_Hip(CeedOperator op, CeedInt use_ceedsize_idx) { +static int CeedOperatorAssembleSingleSetup_Hip(CeedOperator op, CeedInt use_ceedsize_idx) { Ceed ceed; Ceed_Hip *hip_data; CeedInt num_input_fields, num_output_fields, num_eval_modes_in = 0, num_eval_modes_out = 0; @@ -1704,7 +1704,7 @@ static int CeedSingleOperatorAssembleSetup_Hip(CeedOperator op, CeedInt use_ceed // (could have multiple basis eval modes). // TODO: allow multiple active input restrictions/basis objects //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssemble_Hip(CeedOperator op, CeedInt offset, CeedVector values) { +static int CeedOperatorAssembleSingle_Hip(CeedOperator op, CeedInt offset, CeedVector values) { Ceed ceed; CeedSize values_length = 0, assembled_qf_length = 0; CeedInt use_ceedsize_idx = 0, num_elem_in, num_elem_out, elem_size_in, elem_size_out; @@ -1730,7 +1730,7 @@ static int CeedSingleOperatorAssemble_Hip(CeedOperator op, CeedInt offset, CeedV if ((values_length > INT_MAX) || (assembled_qf_length > INT_MAX)) use_ceedsize_idx = 1; // Setup - if (!impl->asmb) CeedCallBackend(CeedSingleOperatorAssembleSetup_Hip(op, use_ceedsize_idx)); + if (!impl->asmb) CeedCallBackend(CeedOperatorAssembleSingleSetup_Hip(op, use_ceedsize_idx)); CeedOperatorAssemble_Hip *asmb = impl->asmb; assert(asmb != NULL); @@ -2076,7 +2076,7 @@ int CeedOperatorCreate_Hip(CeedOperator op) { CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleAddDiagonal", CeedOperatorLinearAssembleAddDiagonal_Hip)); CeedCallBackend( CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleAddPointBlockDiagonal", CeedOperatorLinearAssembleAddPointBlockDiagonal_Hip)); - CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedSingleOperatorAssemble_Hip)); + CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedOperatorAssembleSingle_Hip)); CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "ApplyAdd", CeedOperatorApplyAdd_Hip)); CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "Destroy", CeedOperatorDestroy_Hip)); CeedCallBackend(CeedDestroy(&ceed)); diff --git a/backends/ref/ceed-ref-operator.c b/backends/ref/ceed-ref-operator.c index 89fd47df76..4769d34d68 100644 --- a/backends/ref/ceed-ref-operator.c +++ b/backends/ref/ceed-ref-operator.c @@ -1527,7 +1527,7 @@ static int CeedOperatorLinearAssembleAddDiagonalAtPoints_Ref(CeedOperator op, Ce //------------------------------------------------------------------------------ // Assemble Operator AtPoints //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssembleAtPoints_Ref(CeedOperator op, CeedInt offset, CeedVector values) { +static int CeedOperatorAssembleSingleAtPoints_Ref(CeedOperator op, CeedInt offset, CeedVector values) { CeedInt num_points_offset = 0, num_input_fields, num_output_fields, num_elem, num_comp_active = 1; CeedScalar *e_data[2 * CEED_FIELD_MAX] = {0}, *assembled; Ceed ceed; @@ -1798,7 +1798,7 @@ int CeedOperatorCreateAtPoints_Ref(CeedOperator op) { CeedCallBackend( CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleQFunctionUpdate", CeedOperatorLinearAssembleQFunctionAtPointsUpdate_Ref)); CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleAddDiagonal", CeedOperatorLinearAssembleAddDiagonalAtPoints_Ref)); - CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedSingleOperatorAssembleAtPoints_Ref)); + CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "LinearAssembleSingle", CeedOperatorAssembleSingleAtPoints_Ref)); CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "ApplyAdd", CeedOperatorApplyAddAtPoints_Ref)); CeedCallBackend(CeedSetBackendFunction(ceed, "Operator", op, "Destroy", CeedOperatorDestroy_Ref)); CeedCallBackend(CeedDestroy(&ceed)); diff --git a/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp b/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp index 1bf91636db..9833e2a837 100644 --- a/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp +++ b/backends/sycl-ref/ceed-sycl-ref-operator.sycl.cpp @@ -997,7 +997,7 @@ static int CeedOperatorLinearAssembleAddPointBlockDiagonal_Sycl(CeedOperator op, //------------------------------------------------------------------------------ // Single operator assembly setup //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssembleSetup_Sycl(CeedOperator op) { +static int CeedOperatorAssembleSingleSetup_Sycl(CeedOperator op) { Ceed ceed; CeedInt num_input_fields, num_output_fields, num_eval_mode_in = 0, dim = 1, num_B_in_mats_to_load = 0, size_B_in = 0, num_eval_mode_out = 0, num_B_out_mats_to_load = 0, size_B_out = 0, num_qpts = 0, elem_size = 0, num_elem, num_comp, @@ -1337,7 +1337,7 @@ static int CeedOperatorLinearAssembleFallback_Sycl(sycl::queue &sycl_queue, cons // input restriction/basis per operator (could have multiple basis eval modes). // TODO: allow multiple active input restrictions/basis objects //------------------------------------------------------------------------------ -static int CeedSingleOperatorAssemble_Sycl(CeedOperator op, CeedInt offset, CeedVector values) { +static int CeedOperatorAssembleSingle_Sycl(CeedOperator op, CeedInt offset, CeedVector values) { Ceed ceed; Ceed_Sycl *sycl_data; CeedScalar *values_array; @@ -1353,7 +1353,7 @@ static int CeedSingleOperatorAssemble_Sycl(CeedOperator op, CeedInt offset, Ceed // Setup if (!impl->asmb) { - CeedCallBackend(CeedSingleOperatorAssembleSetup_Sycl(op)); + CeedCallBackend(CeedOperatorAssembleSingleSetup_Sycl(op)); assert(impl->asmb != NULL); } @@ -1397,7 +1397,7 @@ int CeedOperatorCreate_Sycl(CeedOperator op) { CeedCallBackend(CeedSetBackendFunctionCpp(ceed, "Operator", op, "LinearAssembleAddDiagonal", CeedOperatorLinearAssembleAddDiagonal_Sycl)); CeedCallBackend( CeedSetBackendFunctionCpp(ceed, "Operator", op, "LinearAssembleAddPointBlockDiagonal", CeedOperatorLinearAssembleAddPointBlockDiagonal_Sycl)); - CeedCallBackend(CeedSetBackendFunctionCpp(ceed, "Operator", op, "LinearAssembleSingle", CeedSingleOperatorAssemble_Sycl)); + CeedCallBackend(CeedSetBackendFunctionCpp(ceed, "Operator", op, "LinearAssembleSingle", CeedOperatorAssembleSingle_Sycl)); CeedCallBackend(CeedSetBackendFunctionCpp(ceed, "Operator", op, "ApplyAdd", CeedOperatorApplyAdd_Sycl)); CeedCallBackend(CeedSetBackendFunctionCpp(ceed, "Operator", op, "Destroy", CeedOperatorDestroy_Sycl)); CeedCallBackend(CeedDestroy(&ceed)); diff --git a/doc/sphinx/source/releasenotes.md b/doc/sphinx/source/releasenotes.md index 2e329e54d7..0a4be0b959 100644 --- a/doc/sphinx/source/releasenotes.md +++ b/doc/sphinx/source/releasenotes.md @@ -15,6 +15,8 @@ On this page we provide a summary of the main API changes, new features and exam - Add `CEED_RUNNING_JIT_PASS` compiler definition for wrapping header files that device JiT compilers cannot read - Users should now prefer `#include ` rather than `#include ` in QFunction source files - Require use of `Ceed*Destroy()` on Ceed objects returned from `Ceed*Get*()`. +- Rename `CeedCompositeOperatorCreate()` to `CeedOperatorCreateComposite()` for uniformity. +- Rename `CeedCompositeOperator*()` to `CeedOperatorComposite*()` for uniformity. ### New features diff --git a/examples/fluids/problems/advection.c b/examples/fluids/problems/advection.c index 09d444dd01..7047fd6b66 100644 --- a/examples/fluids/problems/advection.c +++ b/examples/fluids/problems/advection.c @@ -35,7 +35,7 @@ PetscErrorCode CreateKSPMassOperator_AdvectionStabilized(User user, CeedOperator CeedOperatorField field; PetscInt sub_op_index = 0; // will be 0 for the volume op - PetscCallCeed(ceed, CeedCompositeOperatorGetSubList(user->op_rhs_ctx->op, &sub_ops)); + PetscCallCeed(ceed, CeedOperatorCompositeGetSubList(user->op_rhs_ctx->op, &sub_ops)); PetscCallCeed(ceed, CeedOperatorGetFieldByName(sub_ops[sub_op_index], "q", &field)); PetscCallCeed(ceed, CeedOperatorFieldGetData(field, NULL, &elem_restr_q, &basis_q, NULL)); diff --git a/examples/fluids/problems/newtonian.c b/examples/fluids/problems/newtonian.c index f02cc949e8..e13df731c2 100644 --- a/examples/fluids/problems/newtonian.c +++ b/examples/fluids/problems/newtonian.c @@ -171,7 +171,7 @@ PetscErrorCode CreateKSPMassOperator_NewtonianStabilized(User user, CeedOperator CeedOperatorField field; PetscInt sub_op_index = 0; // will be 0 for the volume op - PetscCallCeed(ceed, CeedCompositeOperatorGetSubList(user->op_rhs_ctx->op, &sub_ops)); + PetscCallCeed(ceed, CeedOperatorCompositeGetSubList(user->op_rhs_ctx->op, &sub_ops)); PetscCallCeed(ceed, CeedOperatorGetFieldByName(sub_ops[sub_op_index], "q", &field)); PetscCallCeed(ceed, CeedOperatorFieldGetData(field, NULL, &elem_restr_q, &basis_q, NULL)); diff --git a/examples/fluids/src/differential_filter.c b/examples/fluids/src/differential_filter.c index 8d0b1e6949..0727a39b75 100644 --- a/examples/fluids/src/differential_filter.c +++ b/examples/fluids/src/differential_filter.c @@ -96,7 +96,7 @@ PetscErrorCode DifferentialFilterCreateOperators(Ceed ceed, User user, CeedData // -- Get Grid anisotropy tensor PetscCall(GridAnisotropyTensorCalculateCollocatedVector(ceed, user, ceed_data, &elem_restr_grid_aniso, &grid_aniso_ceed, &num_comp_grid_aniso)); - PetscCallCeed(ceed, CeedCompositeOperatorCreate(ceed, &op_lhs)); + PetscCallCeed(ceed, CeedOperatorCreateComposite(ceed, &op_lhs)); for (PetscInt i = 0; i < diff_filter->num_filtered_fields; i++) { CeedQFunction qf_lhs; PetscInt num_comp_filter = diff_filter->num_field_components[i]; @@ -149,7 +149,7 @@ PetscErrorCode DifferentialFilterCreateOperators(Ceed ceed, User user, CeedData PetscCallCeed(ceed, CeedOperatorSetField(op_lhs_sub, "v", elem_restr_filter, basis_filter, CEED_VECTOR_ACTIVE)); PetscCallCeed(ceed, CeedOperatorSetField(op_lhs_sub, "Grad_v", elem_restr_filter, basis_filter, CEED_VECTOR_ACTIVE)); - PetscCallCeed(ceed, CeedCompositeOperatorAddSub(op_lhs, op_lhs_sub)); + PetscCallCeed(ceed, CeedOperatorCompositeAddSub(op_lhs, op_lhs_sub)); PetscCallCeed(ceed, CeedElemRestrictionDestroy(&elem_restr_filter)); PetscCallCeed(ceed, CeedBasisDestroy(&basis_filter)); PetscCallCeed(ceed, CeedQFunctionDestroy(&qf_lhs)); diff --git a/examples/fluids/src/mat-ceed.c b/examples/fluids/src/mat-ceed.c index bf2f52b006..5e8ebef86f 100644 --- a/examples/fluids/src/mat-ceed.c +++ b/examples/fluids/src/mat-ceed.c @@ -406,8 +406,8 @@ PetscErrorCode MatCreateCeed(DM dm_x, DM dm_y, CeedOperator op_mult, CeedOperato CeedInt num_sub_operators; CeedOperator *sub_operators; - PetscCallCeed(ctx->ceed, CeedCompositeOperatorGetNumSub(op_mult, &num_sub_operators)); - PetscCallCeed(ctx->ceed, CeedCompositeOperatorGetSubList(op_mult, &sub_operators)); + PetscCallCeed(ctx->ceed, CeedOperatorCompositeGetNumSub(op_mult, &num_sub_operators)); + PetscCallCeed(ctx->ceed, CeedOperatorCompositeGetSubList(op_mult, &sub_operators)); for (CeedInt i = 0; i < num_sub_operators; i++) { CeedInt num_bases, num_comp; CeedBasis *active_bases; diff --git a/examples/fluids/src/setuplibceed.c b/examples/fluids/src/setuplibceed.c index 7c172a3abc..026b496878 100644 --- a/examples/fluids/src/setuplibceed.c +++ b/examples/fluids/src/setuplibceed.c @@ -28,7 +28,7 @@ static PetscErrorCode CreateKSPMassOperator_Unstabilized(User user, CeedOperator CeedOperatorField field; PetscInt sub_op_index = 0; // will be 0 for the volume op - PetscCallCeed(ceed, CeedCompositeOperatorGetSubList(user->op_rhs_ctx->op, &sub_ops)); + PetscCallCeed(ceed, CeedOperatorCompositeGetSubList(user->op_rhs_ctx->op, &sub_ops)); PetscCallCeed(ceed, CeedOperatorGetFieldByName(sub_ops[sub_op_index], "q", &field)); PetscCallCeed(ceed, CeedOperatorFieldGetData(field, NULL, &elem_restr_q, &basis_q, NULL)); @@ -134,8 +134,8 @@ static PetscErrorCode AddBCSubOperator(Ceed ceed, DM dm, CeedData ceed_data, DML } // Apply Sub-Operator for Physics - PetscCallCeed(ceed, CeedCompositeOperatorAddSub(op_apply, op_apply_bc)); - if (op_apply_bc_jacobian) PetscCallCeed(ceed, CeedCompositeOperatorAddSub(op_apply_ijacobian, op_apply_bc_jacobian)); + PetscCallCeed(ceed, CeedOperatorCompositeAddSub(op_apply, op_apply_bc)); + if (op_apply_bc_jacobian) PetscCallCeed(ceed, CeedOperatorCompositeAddSub(op_apply_ijacobian, op_apply_bc_jacobian)); PetscCallCeed(ceed, CeedVectorDestroy(&q_data_sur)); PetscCallCeed(ceed, CeedVectorDestroy(&jac_data_sur)); @@ -197,7 +197,7 @@ static PetscErrorCode AddBCSubOperators(User user, Ceed ceed, DM dm, SimpleBC bc PetscInt sub_op_index = 0; // will be 0 for the volume op CeedElemRestriction elem_restr_q, elem_restr_x; - PetscCallCeed(ceed, CeedCompositeOperatorGetSubList(op_apply, &sub_ops)); + PetscCallCeed(ceed, CeedOperatorCompositeGetSubList(op_apply, &sub_ops)); PetscCallCeed(ceed, CeedOperatorGetFieldByName(sub_ops[sub_op_index], "q", &field)); PetscCallCeed(ceed, CeedOperatorFieldGetElemRestriction(field, &elem_restr_q)); PetscCallCeed(ceed, CeedElemRestrictionGetNumComponents(elem_restr_q, &num_comp_q)); @@ -440,8 +440,8 @@ PetscErrorCode SetupLibceed(Ceed ceed, CeedData ceed_data, DM dm, User user, App if (!user->phys->implicit) { // RHS CeedOperator op_rhs; - PetscCallCeed(ceed, CeedCompositeOperatorCreate(ceed, &op_rhs)); - PetscCallCeed(ceed, CeedCompositeOperatorAddSub(op_rhs, op_rhs_vol)); + PetscCallCeed(ceed, CeedOperatorCreateComposite(ceed, &op_rhs)); + PetscCallCeed(ceed, CeedOperatorCompositeAddSub(op_rhs, op_rhs_vol)); PetscCall(AddBCSubOperators(user, ceed, dm, bc, problem, ceed_data, op_rhs, NULL)); PetscCall(OperatorApplyContextCreate(dm, dm, ceed, op_rhs, user->q_ceed, user->g_ceed, user->Q_loc, NULL, &user->op_rhs_ctx)); @@ -456,11 +456,11 @@ PetscErrorCode SetupLibceed(Ceed ceed, CeedData ceed_data, DM dm, User user, App CeedOperator op_ijacobian = NULL; // Create Composite Operaters - PetscCallCeed(ceed, CeedCompositeOperatorCreate(ceed, &user->op_ifunction)); - PetscCallCeed(ceed, CeedCompositeOperatorAddSub(user->op_ifunction, op_ifunction_vol)); + PetscCallCeed(ceed, CeedOperatorCreateComposite(ceed, &user->op_ifunction)); + PetscCallCeed(ceed, CeedOperatorCompositeAddSub(user->op_ifunction, op_ifunction_vol)); if (op_ijacobian_vol) { - PetscCallCeed(ceed, CeedCompositeOperatorCreate(ceed, &op_ijacobian)); - PetscCallCeed(ceed, CeedCompositeOperatorAddSub(op_ijacobian, op_ijacobian_vol)); + PetscCallCeed(ceed, CeedOperatorCreateComposite(ceed, &op_ijacobian)); + PetscCallCeed(ceed, CeedOperatorCompositeAddSub(op_ijacobian, op_ijacobian_vol)); } PetscCall(AddBCSubOperators(user, ceed, dm, bc, problem, ceed_data, user->op_ifunction, op_ijacobian)); diff --git a/examples/fluids/src/strong_boundary_conditions.c b/examples/fluids/src/strong_boundary_conditions.c index 2e52a2ae8f..69a8558f78 100644 --- a/examples/fluids/src/strong_boundary_conditions.c +++ b/examples/fluids/src/strong_boundary_conditions.c @@ -104,7 +104,7 @@ PetscErrorCode SetupStrongSTG_Ceed(Ceed ceed, CeedData ceed_data, DM dm, Problem PetscCallCeed(ceed, CeedOperatorSetField(op_strong_bc_sub, "q", elem_restr_q_sur, CEED_BASIS_NONE, CEED_VECTOR_ACTIVE)); // -- Add to composite operator - PetscCallCeed(ceed, CeedCompositeOperatorAddSub(op_strong_bc, op_strong_bc_sub)); + PetscCallCeed(ceed, CeedOperatorCompositeAddSub(op_strong_bc, op_strong_bc_sub)); PetscCallCeed(ceed, CeedVectorDestroy(&multiplicity)); PetscCallCeed(ceed, CeedVectorDestroy(&x_stored)); @@ -168,7 +168,7 @@ PetscErrorCode SetupStrongBC_Ceed(Ceed ceed, CeedData ceed_data, DM dm, User use PetscCall(DMRestoreGlobalVector(dm, &global_vec)); } - PetscCallCeed(ceed, CeedCompositeOperatorCreate(ceed, &op_strong_bc)); + PetscCallCeed(ceed, CeedOperatorCreateComposite(ceed, &op_strong_bc)); { PetscBool use_strongstg = PETSC_FALSE; PetscCall(PetscOptionsGetBool(NULL, NULL, "-stg_strong", &use_strongstg, NULL)); diff --git a/include/ceed/backend.h b/include/ceed/backend.h index c48e0d4666..fd861702bb 100644 --- a/include/ceed/backend.h +++ b/include/ceed/backend.h @@ -461,9 +461,9 @@ CEED_EXTERN int CeedOperatorReference(CeedOperator op); CEED_EXTERN int CeedOperatorGetFallback(CeedOperator op, CeedOperator *op_fallback); CEED_EXTERN int CeedOperatorGetFallbackParent(CeedOperator op, CeedOperator *parent); CEED_EXTERN int CeedOperatorGetFallbackParentCeed(CeedOperator op, Ceed *parent); -CEED_EXTERN int CeedOperatorFallbackLinearAssembleQFunctionBuildOrUpdate(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, +CEED_EXTERN int CeedOperatorLinearAssembleQFunctionBuildOrUpdateFallback(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request); -CEED_INTERN int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVector values); +CEED_INTERN int CeedOperatorAssembleSingle(CeedOperator op, CeedInt offset, CeedVector values); CEED_EXTERN int CeedOperatorSetSetupDone(CeedOperator op); CEED_INTERN int CeedMatrixMatrixMultiply(Ceed ceed, const CeedScalar *mat_A, const CeedScalar *mat_B, CeedScalar *mat_C, CeedInt m, CeedInt n, diff --git a/include/ceed/ceed.h b/include/ceed/ceed.h index ce6284b910..65e94ce43a 100644 --- a/include/ceed/ceed.h +++ b/include/ceed/ceed.h @@ -409,7 +409,7 @@ CEED_EXTERN int CeedQFunctionContextDestroy(CeedQFunctionContext *ctx); CEED_EXTERN int CeedOperatorCreate(Ceed ceed, CeedQFunction qf, CeedQFunction dqf, CeedQFunction dqfT, CeedOperator *op); CEED_EXTERN int CeedOperatorCreateAtPoints(Ceed ceed, CeedQFunction qf, CeedQFunction dqf, CeedQFunction dqfT, CeedOperator *op); -CEED_EXTERN int CeedCompositeOperatorCreate(Ceed ceed, CeedOperator *op); +CEED_EXTERN int CeedOperatorCreateComposite(Ceed ceed, CeedOperator *op); CEED_EXTERN int CeedOperatorReferenceCopy(CeedOperator op, CeedOperator *op_copy); CEED_EXTERN int CeedOperatorSetField(CeedOperator op, const char *field_name, CeedElemRestriction rstr, CeedBasis basis, CeedVector vec); CEED_EXTERN int CeedOperatorGetFields(CeedOperator op, CeedInt *num_input_fields, CeedOperatorField **input_fields, CeedInt *num_output_fields, @@ -418,10 +418,10 @@ CEED_EXTERN int CeedOperatorGetFields(CeedOperator op, CeedInt *num_input_fields CEED_EXTERN int CeedOperatorAtPointsSetPoints(CeedOperator op, CeedElemRestriction rstr_points, CeedVector point_coords); CEED_EXTERN int CeedOperatorAtPointsGetPoints(CeedOperator op, CeedElemRestriction *rstr_points, CeedVector *point_coords); CEED_EXTERN int CeedOperatorIsAtPoints(CeedOperator op, bool *is_at_points); -CEED_EXTERN int CeedCompositeOperatorAddSub(CeedOperator composite_op, CeedOperator sub_op); -CEED_EXTERN int CeedCompositeOperatorGetNumSub(CeedOperator op, CeedInt *num_suboperators); -CEED_EXTERN int CeedCompositeOperatorGetSubList(CeedOperator op, CeedOperator **sub_operators); -CEED_EXTERN int CeedCompositeOperatorGetSubByName(CeedOperator op, const char *op_name, CeedOperator *sub_op); +CEED_EXTERN int CeedOperatorCompositeAddSub(CeedOperator composite_op, CeedOperator sub_op); +CEED_EXTERN int CeedOperatorCompositeGetNumSub(CeedOperator op, CeedInt *num_suboperators); +CEED_EXTERN int CeedOperatorCompositeGetSubList(CeedOperator op, CeedOperator **sub_operators); +CEED_EXTERN int CeedOperatorCompositeGetSubByName(CeedOperator op, const char *op_name, CeedOperator *sub_op); CEED_EXTERN int CeedOperatorCheckReady(CeedOperator op); CEED_EXTERN int CeedOperatorGetActiveVectorLengths(CeedOperator op, CeedSize *input_size, CeedSize *output_size); CEED_EXTERN int CeedOperatorSetQFunctionAssemblyReuse(CeedOperator op, bool reuse_assembly_data); @@ -436,7 +436,7 @@ CEED_EXTERN int CeedOperatorLinearAssembleAddPointBlockDiagonal(CeedOperator op CEED_EXTERN int CeedOperatorLinearAssemblePointBlockDiagonalSymbolic(CeedOperator op, CeedSize *num_entries, CeedInt **rows, CeedInt **cols); CEED_EXTERN int CeedOperatorLinearAssembleSymbolic(CeedOperator op, CeedSize *num_entries, CeedInt **rows, CeedInt **cols); CEED_EXTERN int CeedOperatorLinearAssemble(CeedOperator op, CeedVector values); -CEED_EXTERN int CeedCompositeOperatorGetMultiplicity(CeedOperator op, CeedInt num_skip_indices, CeedInt *skip_indices, CeedVector mult); +CEED_EXTERN int CeedOperatorCompositeGetMultiplicity(CeedOperator op, CeedInt num_skip_indices, CeedInt *skip_indices, CeedVector mult); CEED_EXTERN int CeedOperatorMultigridLevelCreate(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse, CeedBasis basis_coarse, CeedOperator *op_coarse, CeedOperator *op_prolong, CeedOperator *op_restrict); @@ -473,6 +473,9 @@ CEED_EXTERN int CeedOperatorApplyAddActive(CeedOperator op, CeedVector in, Ceed CEED_EXTERN int CeedOperatorAssemblyDataStrip(CeedOperator op); CEED_EXTERN int CeedOperatorDestroy(CeedOperator *op); +// Compatibility with previous composite CeedOperator naming +#include "deprecated.h" + CEED_EXTERN int CeedOperatorGetFieldByName(CeedOperator op, const char *field_name, CeedOperatorField *op_field); CEED_EXTERN int CeedOperatorFieldGetName(CeedOperatorField op_field, const char **field_name); CEED_EXTERN int CeedOperatorFieldGetElemRestriction(CeedOperatorField op_field, CeedElemRestriction *rstr); diff --git a/include/ceed/deprecated.h b/include/ceed/deprecated.h new file mode 100644 index 0000000000..4f54f5c606 --- /dev/null +++ b/include/ceed/deprecated.h @@ -0,0 +1,38 @@ +/// Copyright (c) 2017-2025, Lawrence Livermore National Security, LLC and other CEED contributors. +/// All Rights Reserved. See the top-level LICENSE and NOTICE files for details. +/// +/// SPDX-License-Identifier: BSD-2-Clause +/// +/// This file is part of CEED: http://github.com/ceed + +/// @file +/// Public header for user and utility components of libCEED +#pragma once + +#if __STDC_VERSION__ >= 202311L +#define DEPRECATED(msg) [[deprecated(msg)]] +#elif defined(__GNUC__) || defined(__clang__) +#define DEPRECATED(msg) __attribute__((deprecated(msg))) +#else +#define DEPRECATED(msg) +#endif + +// Compatibility with previous composite CeedOperator naming +DEPRECATED("Use CeedOperatorCreateComposite()") +static inline int CeedCompositeOperatorCreate(Ceed a, CeedOperator *b) { return CeedOperatorCreateComposite(a, b); } +DEPRECATED("Use CeedOperatorCompositeAddSub()") +static inline int CeedCompositeOperatorAddSub(CeedOperator a, CeedOperator b) { return CeedOperatorCompositeAddSub(a, b); } +DEPRECATED("Use CeedOperatorCompositeGetNumSub()") +static inline int CeedCompositeOperatorGetNumSub(CeedOperator a, CeedInt *b) { return CeedOperatorCompositeGetNumSub(a, b); } +DEPRECATED("Use CeedOperatorCompositeGetSubList()") +static inline int CeedCompositeOperatorGetSubList(CeedOperator a, CeedOperator **b) { return CeedOperatorCompositeGetSubList(a, b); } +DEPRECATED("Use CeedCompositeOperatorGetSubByName()") +static inline int CeedCompositeOperatorGetSubByName(CeedOperator a, const char *b, CeedOperator *c) { + return CeedOperatorCompositeGetSubByName(a, b, c); +} +DEPRECATED("Use CeedOperatorCompositeGetMultiplicity()") +static inline int CeedCompositeOperatorGetMultiplicity(CeedOperator a, CeedInt b, CeedInt *c, CeedVector d) { + return CeedOperatorCompositeGetMultiplicity(a, b, c, d); +} + +#undef DEPRECATED diff --git a/interface/ceed-fortran.c b/interface/ceed-fortran.c index 73f8c801b9..e62cb30360 100644 --- a/interface/ceed-fortran.c +++ b/interface/ceed-fortran.c @@ -951,8 +951,8 @@ CEED_EXTERN void fCeedOperatorCreate(int *ceed, int *qf, int *dqf, int *dqfT, in CeedOperator_n++; } -#define fCeedCompositeOperatorCreate FORTRAN_NAME(ceedcompositeoperatorcreate, CEEDCOMPOSITEOPERATORCREATE) -CEED_EXTERN void fCeedCompositeOperatorCreate(int *ceed, int *op, int *err) { +#define fCeedOperatorCreateComposite FORTRAN_NAME(ceedoperatorcreatecomposite, CEEDOPERATORCREATECOMPOSITE) +CEED_EXTERN void fCeedOperatorCreateComposite(int *ceed, int *op, int *err) { if (CeedOperator_count == CeedOperator_count_max) { CeedOperator_count_max += CeedOperator_count_max / 2 + 1; CeedRealloc(CeedOperator_count_max, &CeedOperator_dict); @@ -960,7 +960,7 @@ CEED_EXTERN void fCeedCompositeOperatorCreate(int *ceed, int *op, int *err) { CeedOperator *op_ = &CeedOperator_dict[CeedOperator_count]; - *err = CeedCompositeOperatorCreate(Ceed_dict[*ceed], op_); + *err = CeedOperatorCreateComposite(Ceed_dict[*ceed], op_); if (*err) return; *op = CeedOperator_count++; CeedOperator_n++; @@ -1003,12 +1003,12 @@ CEED_EXTERN void fCeedOperatorSetField(int *op, const char *field_name, int *r, *err = CeedOperatorSetField(op_, field_name_c, r_, b_, v_); } -#define fCeedCompositeOperatorAddSub FORTRAN_NAME(ceedcompositeoperatoraddsub, CEEDCOMPOSITEOPERATORADDSUB) -CEED_EXTERN void fCeedCompositeOperatorAddSub(int *compositeop, int *subop, int *err) { +#define fCeedOperatorCompositeAddSub FORTRAN_NAME(ceedoperatorcompositeaddsub, CEEDOPERATORCOMPOSITEADDSUB) +CEED_EXTERN void fCeedOperatorCompositeAddSub(int *compositeop, int *subop, int *err) { CeedOperator compositeop_ = CeedOperator_dict[*compositeop]; CeedOperator subop_ = CeedOperator_dict[*subop]; - *err = CeedCompositeOperatorAddSub(compositeop_, subop_); + *err = CeedOperatorCompositeAddSub(compositeop_, subop_); } #define fCeedOperatorSetName FORTRAN_NAME(ceedoperatorsetname, CEEDOPERATORSETNAME) diff --git a/interface/ceed-operator.c b/interface/ceed-operator.c index 039f8522db..3a0a0ddfe7 100644 --- a/interface/ceed-operator.c +++ b/interface/ceed-operator.c @@ -376,8 +376,8 @@ static int CeedOperatorContextSetGeneric(CeedOperator op, CeedContextFieldLabel CeedInt num_sub; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_sub)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); CeedCheck(num_sub == field_label->num_sub_labels, CeedOperatorReturnCeed(op), CEED_ERROR_UNSUPPORTED, "Composite operator modified after ContextFieldLabel created"); @@ -443,8 +443,8 @@ static int CeedOperatorContextGetGenericRead(CeedOperator op, CeedContextFieldLa CeedInt num_sub; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_sub)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); CeedCheck(num_sub == field_label->num_sub_labels, CeedOperatorReturnCeed(op), CEED_ERROR_UNSUPPORTED, "Composite operator modified after ContextFieldLabel created"); @@ -506,8 +506,8 @@ static int CeedOperatorContextRestoreGenericRead(CeedOperator op, CeedContextFie CeedInt num_sub; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_sub)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); CeedCheck(num_sub == field_label->num_sub_labels, CeedOperatorReturnCeed(op), CEED_ERROR_UNSUPPORTED, "Composite operator modified after ContextFieldLabel created"); @@ -831,13 +831,13 @@ int CeedOperatorCreateAtPoints(Ceed ceed, CeedQFunction qf, CeedQFunction dqf, C @ref User */ -int CeedCompositeOperatorCreate(Ceed ceed, CeedOperator *op) { +int CeedOperatorCreateComposite(Ceed ceed, CeedOperator *op) { if (!ceed->CompositeOperatorCreate) { Ceed delegate; CeedCall(CeedGetObjectDelegate(ceed, &delegate, "Operator")); if (delegate) { - CeedCall(CeedCompositeOperatorCreate(delegate, op)); + CeedCall(CeedOperatorCreateComposite(delegate, op)); CeedCall(CeedDestroy(&delegate)); return CEED_ERROR_SUCCESS; } @@ -1263,7 +1263,7 @@ int CeedOperatorFieldGetData(CeedOperatorField op_field, const char **field_name @ref User */ -int CeedCompositeOperatorAddSub(CeedOperator composite_op, CeedOperator sub_op) { +int CeedOperatorCompositeAddSub(CeedOperator composite_op, CeedOperator sub_op) { bool is_immutable; CeedCheck(composite_op->is_composite, CeedOperatorReturnCeed(composite_op), CEED_ERROR_MINOR, "CeedOperator is not a composite operator"); @@ -1303,7 +1303,7 @@ int CeedCompositeOperatorAddSub(CeedOperator composite_op, CeedOperator sub_op) @ref Backend **/ -int CeedCompositeOperatorGetNumSub(CeedOperator op, CeedInt *num_suboperators) { +int CeedOperatorCompositeGetNumSub(CeedOperator op, CeedInt *num_suboperators) { bool is_composite; CeedCall(CeedOperatorIsComposite(op, &is_composite)); @@ -1322,7 +1322,7 @@ int CeedCompositeOperatorGetNumSub(CeedOperator op, CeedInt *num_suboperators) { @ref Backend **/ -int CeedCompositeOperatorGetSubList(CeedOperator op, CeedOperator **sub_operators) { +int CeedOperatorCompositeGetSubList(CeedOperator op, CeedOperator **sub_operators) { bool is_composite; CeedCall(CeedOperatorIsComposite(op, &is_composite)); @@ -1346,7 +1346,7 @@ int CeedCompositeOperatorGetSubList(CeedOperator op, CeedOperator **sub_operator @ref Advanced **/ -int CeedCompositeOperatorGetSubByName(CeedOperator op, const char *op_name, CeedOperator *sub_op) { +int CeedOperatorCompositeGetSubByName(CeedOperator op, const char *op_name, CeedOperator *sub_op) { bool is_composite; CeedInt num_sub_ops; CeedOperator *sub_ops; @@ -1354,8 +1354,8 @@ int CeedCompositeOperatorGetSubByName(CeedOperator op, const char *op_name, Ceed CeedCall(CeedOperatorIsComposite(op, &is_composite)); CeedCheck(is_composite, CeedOperatorReturnCeed(op), CEED_ERROR_MINOR, "Only defined for a composite operator"); *sub_op = NULL; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_sub_ops)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_ops)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub_ops)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_ops)); for (CeedInt i = 0; i < num_sub_ops; i++) { if (sub_ops[i]->name && !strcmp(op_name, sub_ops[i]->name)) { *sub_op = sub_ops[i]; @@ -1386,7 +1386,7 @@ int CeedOperatorCheckReady(CeedOperator op) { if (is_composite) { CeedInt num_suboperators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); if (!num_suboperators) { // Empty operator setup op->input_size = 0; @@ -1394,7 +1394,7 @@ int CeedOperatorCheckReady(CeedOperator op) { } else { CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt i = 0; i < num_suboperators; i++) { CeedCall(CeedOperatorCheckReady(sub_operators[i])); } @@ -1448,8 +1448,8 @@ int CeedOperatorGetActiveVectorLengths(CeedOperator op, CeedSize *input_size, Ce CeedInt num_suboperators; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt i = 0; i < num_suboperators; i++) { CeedSize sub_input_size, sub_output_size; @@ -1516,8 +1516,8 @@ int CeedOperatorSetQFunctionAssemblyDataUpdateNeeded(CeedOperator op, bool needs CeedInt num_suboperators; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt i = 0; i < num_suboperators; i++) { CeedCall(CeedOperatorSetQFunctionAssemblyDataUpdateNeeded(sub_operators[i], needs_data_update)); } @@ -1599,8 +1599,8 @@ static int CeedOperatorView_Core(CeedOperator op, FILE *stream, bool is_full) { CeedInt num_suboperators; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); fprintf(stream, "Composite CeedOperator%s%s\n", has_name ? " - " : "", has_name ? name : ""); for (CeedInt i = 0; i < num_suboperators; i++) { @@ -1729,9 +1729,9 @@ int CeedOperatorGetFlopsEstimate(CeedOperator op, CeedSize *flops) { if (is_composite) { CeedInt num_suboperators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); // FLOPs for each suboperator for (CeedInt i = 0; i < num_suboperators; i++) { @@ -1906,8 +1906,8 @@ int CeedOperatorGetContextFieldLabel(CeedOperator op, const char *field_name, Ce CeedContextFieldLabel new_field_label; CeedCall(CeedCalloc(1, &new_field_label)); - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_sub)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); CeedCall(CeedCalloc(num_sub, &new_field_label->sub_labels)); new_field_label->num_sub_labels = num_sub; @@ -2209,8 +2209,8 @@ int CeedOperatorApplyAdd(CeedOperator op, CeedVector in, CeedVector out, CeedReq CeedInt num_suboperators; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt i = 0; i < num_suboperators; i++) { CeedCall(CeedOperatorApplyAdd(sub_operators[i], in, out, request)); } @@ -2250,8 +2250,8 @@ int CeedOperatorApplyAddActive(CeedOperator op, CeedVector in, CeedVector out, C CeedInt num_suboperators; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); // Zero all output vectors for (CeedInt i = 0; i < num_suboperators; i++) { @@ -2308,8 +2308,8 @@ int CeedOperatorAssemblyDataStrip(CeedOperator op) { CeedInt num_suboperators; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt i = 0; i < num_suboperators; i++) { CeedCall(CeedQFunctionAssemblyDataDestroy(&sub_operators[i]->qf_assembled)); CeedCall(CeedOperatorAssemblyDataDestroy(&sub_operators[i]->op_assembled)); diff --git a/interface/ceed-preconditioning.c b/interface/ceed-preconditioning.c index cffa77d2ae..bbc031d6ce 100644 --- a/interface/ceed-preconditioning.c +++ b/interface/ceed-preconditioning.c @@ -124,14 +124,14 @@ static int CeedOperatorCreateFallback(CeedOperator op) { CeedInt num_suboperators; CeedOperator *sub_operators; - CeedCall(CeedCompositeOperatorCreate(ceed_fallback, &op_fallback)); - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCreateComposite(ceed_fallback, &op_fallback)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt i = 0; i < num_suboperators; i++) { CeedOperator op_sub_fallback; CeedCall(CeedOperatorGetFallback(sub_operators[i], &op_sub_fallback)); - CeedCall(CeedCompositeOperatorAddSub(op_fallback, op_sub_fallback)); + CeedCall(CeedOperatorCompositeAddSub(op_fallback, op_sub_fallback)); } } else { bool is_at_points = false; @@ -213,7 +213,7 @@ static int CeedOperatorCreateFallback(CeedOperator op) { @ref Developer **/ -static inline int CeedSingleOperatorLinearAssembleAddDiagonal_Mesh(CeedOperator op, CeedRequest *request, const bool is_point_block, +static inline int CeedOperatorLinearAssembleAddDiagonalSingle_Mesh(CeedOperator op, CeedRequest *request, const bool is_point_block, CeedVector assembled) { bool is_composite; @@ -398,13 +398,13 @@ static inline int CeedSingleOperatorLinearAssembleAddDiagonal_Mesh(CeedOperator @ref Developer **/ -static inline int CeedSingleOperatorLinearAssembleAddDiagonal(CeedOperator op, CeedRequest *request, const bool is_point_block, +static inline int CeedOperatorLinearAssembleAddDiagonalSingle(CeedOperator op, CeedRequest *request, const bool is_point_block, CeedVector assembled) { bool is_at_points; CeedCall(CeedOperatorIsAtPoints(op, &is_at_points)); CeedCheck(!is_at_points, CeedOperatorReturnCeed(op), CEED_ERROR_UNSUPPORTED, "AtPoints operator not supported"); - CeedCall(CeedSingleOperatorLinearAssembleAddDiagonal_Mesh(op, request, is_point_block, assembled)); + CeedCall(CeedOperatorLinearAssembleAddDiagonalSingle_Mesh(op, request, is_point_block, assembled)); return CEED_ERROR_SUCCESS; } @@ -420,13 +420,13 @@ static inline int CeedSingleOperatorLinearAssembleAddDiagonal(CeedOperator op, C @ref Developer **/ -static inline int CeedCompositeOperatorLinearAssembleAddDiagonal(CeedOperator op, CeedRequest *request, const bool is_point_block, +static inline int CeedOperatorLinearAssembleAddDiagonalComposite(CeedOperator op, CeedRequest *request, const bool is_point_block, CeedVector assembled) { CeedInt num_sub; CeedOperator *suboperators; - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_sub)); - CeedCall(CeedCompositeOperatorGetSubList(op, &suboperators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub)); + CeedCall(CeedOperatorCompositeGetSubList(op, &suboperators)); for (CeedInt i = 0; i < num_sub; i++) { if (is_point_block) { CeedCall(CeedOperatorLinearAssembleAddPointBlockDiagonal(suboperators[i], assembled, request)); @@ -451,7 +451,7 @@ static inline int CeedCompositeOperatorLinearAssembleAddDiagonal(CeedOperator op @ref Developer **/ -static int CeedSingleOperatorAssembleSymbolic(CeedOperator op, CeedInt offset, CeedInt *rows, CeedInt *cols) { +static int CeedOperatorAssembleSymbolicSingle(CeedOperator op, CeedInt offset, CeedInt *rows, CeedInt *cols) { Ceed ceed; bool is_composite; CeedSize num_nodes_in, num_nodes_out, local_num_entries, count = 0; @@ -650,7 +650,7 @@ static int CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(CeedOperator op @ref Developer **/ -int CeedOperatorFallbackLinearAssembleQFunctionBuildOrUpdate(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, +int CeedOperatorLinearAssembleQFunctionBuildOrUpdateFallback(CeedOperator op, CeedVector *assembled, CeedElemRestriction *rstr, CeedRequest *request) { return CeedOperatorLinearAssembleQFunctionBuildOrUpdate_Core(op, false, assembled, rstr, request); } @@ -668,7 +668,7 @@ int CeedOperatorFallbackLinearAssembleQFunctionBuildOrUpdate(CeedOperator op, Ce @ref Developer **/ -int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVector values) { +int CeedOperatorAssembleSingle(CeedOperator op, CeedInt offset, CeedVector values) { bool is_composite, is_at_points; CeedCall(CeedOperatorIsComposite(op, &is_composite)); @@ -690,10 +690,10 @@ int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVector value // Operator fallback CeedOperator op_fallback; - CeedDebug(CeedOperatorReturnCeed(op), "\nFalling back for CeedSingleOperatorAssemble\n"); + CeedDebug(CeedOperatorReturnCeed(op), "\nFalling back for CeedOperatorAssembleSingle\n"); CeedCall(CeedOperatorGetFallback(op, &op_fallback)); if (op_fallback) { - CeedCall(CeedSingleOperatorAssemble(op_fallback, offset, values)); + CeedCall(CeedOperatorAssembleSingle(op_fallback, offset, values)); return CEED_ERROR_SUCCESS; } } @@ -925,7 +925,7 @@ int CeedSingleOperatorAssemble(CeedOperator op, CeedInt offset, CeedVector value @ref Utility **/ -static int CeedSingleOperatorAssemblyCountEntries(CeedOperator op, CeedSize *num_entries) { +static int CeedOperatorAssemblyCountEntriesSingle(CeedOperator op, CeedSize *num_entries) { bool is_composite; CeedInt num_elem_in, elem_size_in, num_comp_in, num_elem_out, elem_size_out, num_comp_out; CeedElemRestriction rstr_in, rstr_out; @@ -972,8 +972,9 @@ static int CeedSingleOperatorAssemblyCountEntries(CeedOperator op, CeedSize *num @ref Developer **/ -static int CeedSingleOperatorMultigridLevel(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse, CeedBasis basis_coarse, - CeedBasis basis_c_to_f, CeedOperator *op_coarse, CeedOperator *op_prolong, CeedOperator *op_restrict) { +static int CeedOperatorMultigridLevelCreateSingle_Core(CeedOperator op_fine, CeedVector p_mult_fine, CeedElemRestriction rstr_coarse, + CeedBasis basis_coarse, CeedBasis basis_c_to_f, CeedOperator *op_coarse, + CeedOperator *op_prolong, CeedOperator *op_restrict) { bool is_composite; Ceed ceed; CeedInt num_comp, num_input_fields, num_output_fields; @@ -2107,7 +2108,7 @@ int CeedOperatorLinearAssembleDiagonal(CeedOperator op, CeedVector assembled, Ce } else if (is_composite) { // Default to summing contributions of suboperators CeedCall(CeedVectorSetValue(assembled, 0.0)); - CeedCall(CeedCompositeOperatorLinearAssembleAddDiagonal(op, request, false, assembled)); + CeedCall(CeedOperatorLinearAssembleAddDiagonalComposite(op, request, false, assembled)); return CEED_ERROR_SUCCESS; } else { // Operator fallback @@ -2167,7 +2168,7 @@ int CeedOperatorLinearAssembleAddDiagonal(CeedOperator op, CeedVector assembled, return CEED_ERROR_SUCCESS; } else if (is_composite) { // Default to summing contributions of suboperators - CeedCall(CeedCompositeOperatorLinearAssembleAddDiagonal(op, request, false, assembled)); + CeedCall(CeedOperatorLinearAssembleAddDiagonalComposite(op, request, false, assembled)); return CEED_ERROR_SUCCESS; } else { // Operator fallback @@ -2181,7 +2182,7 @@ int CeedOperatorLinearAssembleAddDiagonal(CeedOperator op, CeedVector assembled, } } // Default interface implementation - CeedCall(CeedSingleOperatorLinearAssembleAddDiagonal(op, request, false, assembled)); + CeedCall(CeedOperatorLinearAssembleAddDiagonalSingle(op, request, false, assembled)); return CEED_ERROR_SUCCESS; } @@ -2217,8 +2218,8 @@ int CeedOperatorLinearAssemblePointBlockDiagonalSymbolic(CeedOperator op, CeedSi CeedCheck(input_size == output_size, CeedOperatorReturnCeed(op), CEED_ERROR_DIMENSION, "Operator must be square"); if (is_composite) { - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_sub_operators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_sub_operators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); } else { sub_operators = &op; num_sub_operators = 1; @@ -2406,9 +2407,9 @@ int CeedOperatorLinearAssembleAddPointBlockDiagonal(CeedOperator op, CeedVector } // Default interface implementation if (is_composite) { - CeedCall(CeedCompositeOperatorLinearAssembleAddDiagonal(op, request, true, assembled)); + CeedCall(CeedOperatorLinearAssembleAddDiagonalComposite(op, request, true, assembled)); } else { - CeedCall(CeedSingleOperatorLinearAssembleAddDiagonal(op, request, true, assembled)); + CeedCall(CeedOperatorLinearAssembleAddDiagonalSingle(op, request, true, assembled)); } return CEED_ERROR_SUCCESS; } @@ -2463,14 +2464,14 @@ int CeedOperatorLinearAssembleSymbolic(CeedOperator op, CeedSize *num_entries, C // Count entries and allocate rows, cols arrays *num_entries = 0; if (is_composite) { - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt k = 0; k < num_suboperators; ++k) { - CeedCall(CeedSingleOperatorAssemblyCountEntries(sub_operators[k], &single_entries)); + CeedCall(CeedOperatorAssemblyCountEntriesSingle(sub_operators[k], &single_entries)); *num_entries += single_entries; } } else { - CeedCall(CeedSingleOperatorAssemblyCountEntries(op, &single_entries)); + CeedCall(CeedOperatorAssemblyCountEntriesSingle(op, &single_entries)); *num_entries += single_entries; } CeedCall(CeedCalloc(*num_entries, rows)); @@ -2478,15 +2479,15 @@ int CeedOperatorLinearAssembleSymbolic(CeedOperator op, CeedSize *num_entries, C // Assemble nonzero locations if (is_composite) { - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt k = 0; k < num_suboperators; ++k) { - CeedCall(CeedSingleOperatorAssembleSymbolic(sub_operators[k], offset, *rows, *cols)); - CeedCall(CeedSingleOperatorAssemblyCountEntries(sub_operators[k], &single_entries)); + CeedCall(CeedOperatorAssembleSymbolicSingle(sub_operators[k], offset, *rows, *cols)); + CeedCall(CeedOperatorAssemblyCountEntriesSingle(sub_operators[k], &single_entries)); offset += single_entries; } } else { - CeedCall(CeedSingleOperatorAssembleSymbolic(op, offset, *rows, *cols)); + CeedCall(CeedOperatorAssembleSymbolicSingle(op, offset, *rows, *cols)); } return CEED_ERROR_SUCCESS; } @@ -2533,17 +2534,17 @@ int CeedOperatorLinearAssemble(CeedOperator op, CeedVector values) { } else if (is_composite) { // Default to summing contributions of suboperators CeedCall(CeedVectorSetValue(values, 0.0)); - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); for (CeedInt k = 0; k < num_suboperators; k++) { - CeedCall(CeedSingleOperatorAssemble(sub_operators[k], offset, values)); - CeedCall(CeedSingleOperatorAssemblyCountEntries(sub_operators[k], &single_entries)); + CeedCall(CeedOperatorAssembleSingle(sub_operators[k], offset, values)); + CeedCall(CeedOperatorAssemblyCountEntriesSingle(sub_operators[k], &single_entries)); offset += single_entries; } return CEED_ERROR_SUCCESS; } else if (op->LinearAssembleSingle) { CeedCall(CeedVectorSetValue(values, 0.0)); - CeedCall(CeedSingleOperatorAssemble(op, offset, values)); + CeedCall(CeedOperatorAssembleSingle(op, offset, values)); return CEED_ERROR_SUCCESS; } else { // Operator fallback @@ -2559,7 +2560,7 @@ int CeedOperatorLinearAssemble(CeedOperator op, CeedVector values) { // Default to interface version if non-composite and no fallback CeedCall(CeedVectorSetValue(values, 0.0)); - CeedCall(CeedSingleOperatorAssemble(op, offset, values)); + CeedCall(CeedOperatorAssembleSingle(op, offset, values)); return CEED_ERROR_SUCCESS; } @@ -2577,7 +2578,7 @@ int CeedOperatorLinearAssemble(CeedOperator op, CeedVector values) { @ref User **/ -int CeedCompositeOperatorGetMultiplicity(CeedOperator op, CeedInt num_skip_indices, CeedInt *skip_indices, CeedVector mult) { +int CeedOperatorCompositeGetMultiplicity(CeedOperator op, CeedInt num_skip_indices, CeedInt *skip_indices, CeedVector mult) { Ceed ceed; CeedInt num_suboperators; CeedSize l_vec_len; @@ -2592,9 +2593,9 @@ int CeedCompositeOperatorGetMultiplicity(CeedOperator op, CeedInt num_skip_indic CeedCall(CeedVectorSetValue(mult, 0.0)); // Get suboperators - CeedCall(CeedCompositeOperatorGetNumSub(op, &num_suboperators)); + CeedCall(CeedOperatorCompositeGetNumSub(op, &num_suboperators)); if (num_suboperators == 0) return CEED_ERROR_SUCCESS; - CeedCall(CeedCompositeOperatorGetSubList(op, &sub_operators)); + CeedCall(CeedOperatorCompositeGetSubList(op, &sub_operators)); // Work vector CeedCall(CeedVectorGetLength(mult, &l_vec_len)); @@ -2670,7 +2671,8 @@ int CeedOperatorMultigridLevelCreate(CeedOperator op_fine, CeedVector p_mult_fin } // Core code - CeedCall(CeedSingleOperatorMultigridLevel(op_fine, p_mult_fine, rstr_coarse, basis_coarse, basis_c_to_f, op_coarse, op_prolong, op_restrict)); + CeedCall( + CeedOperatorMultigridLevelCreateSingle_Core(op_fine, p_mult_fine, rstr_coarse, basis_coarse, basis_c_to_f, op_coarse, op_prolong, op_restrict)); return CEED_ERROR_SUCCESS; } @@ -2735,7 +2737,8 @@ int CeedOperatorMultigridLevelCreateTensorH1(CeedOperator op_fine, CeedVector p_ } // Core code - CeedCall(CeedSingleOperatorMultigridLevel(op_fine, p_mult_fine, rstr_coarse, basis_coarse, basis_c_to_f, op_coarse, op_prolong, op_restrict)); + CeedCall( + CeedOperatorMultigridLevelCreateSingle_Core(op_fine, p_mult_fine, rstr_coarse, basis_coarse, basis_c_to_f, op_coarse, op_prolong, op_restrict)); CeedCall(CeedDestroy(&ceed)); return CEED_ERROR_SUCCESS; } @@ -2799,7 +2802,8 @@ int CeedOperatorMultigridLevelCreateH1(CeedOperator op_fine, CeedVector p_mult_f } // Core code - CeedCall(CeedSingleOperatorMultigridLevel(op_fine, p_mult_fine, rstr_coarse, basis_coarse, basis_c_to_f, op_coarse, op_prolong, op_restrict)); + CeedCall( + CeedOperatorMultigridLevelCreateSingle_Core(op_fine, p_mult_fine, rstr_coarse, basis_coarse, basis_c_to_f, op_coarse, op_prolong, op_restrict)); CeedCall(CeedDestroy(&ceed)); return CEED_ERROR_SUCCESS; } diff --git a/julia/LibCEED.jl/src/Operator.jl b/julia/LibCEED.jl/src/Operator.jl index d1de710c54..2ad8f41b1c 100644 --- a/julia/LibCEED.jl/src/Operator.jl +++ b/julia/LibCEED.jl/src/Operator.jl @@ -69,11 +69,11 @@ collection `ops`. """ function create_composite_operator(c::Ceed, ops) ref = Ref{C.CeedOperator}() - C.CeedCompositeOperatorCreate(c[], ref) + C.CeedOperatorCreateComposite(c[], ref) comp_op = Operator(ref, QFunctionNone(), QFunctionNone(), QFunctionNone()) comp_op.sub_ops = ops for op ∈ ops - C.CeedCompositeOperatorAddSub(comp_op[], op[]) + C.CeedOperatorCompositeAddSub(comp_op[], op[]) end comp_op end diff --git a/julia/LibCEED.jl/src/generated/libceed_bindings.jl b/julia/LibCEED.jl/src/generated/libceed_bindings.jl index 9cbf889dd9..d4bba38974 100644 --- a/julia/LibCEED.jl/src/generated/libceed_bindings.jl +++ b/julia/LibCEED.jl/src/generated/libceed_bindings.jl @@ -658,8 +658,8 @@ function CeedOperatorCreate(ceed, qf, dqf, dqfT, op) ccall((:CeedOperatorCreate, libceed), Cint, (Ceed, CeedQFunction, CeedQFunction, CeedQFunction, Ptr{CeedOperator}), ceed, qf, dqf, dqfT, op) end -function CeedCompositeOperatorCreate(ceed, op) - ccall((:CeedCompositeOperatorCreate, libceed), Cint, (Ceed, Ptr{CeedOperator}), ceed, op) +function CeedOperatorCreateComposite(ceed, op) + ccall((:CeedOperatorCreateComposite, libceed), Cint, (Ceed, Ptr{CeedOperator}), ceed, op) end function CeedOperatorReferenceCopy(op, op_copy) @@ -674,16 +674,16 @@ function CeedOperatorGetFields(op, num_input_fields, input_fields, num_output_fi ccall((:CeedOperatorGetFields, libceed), Cint, (CeedOperator, Ptr{CeedInt}, Ptr{Ptr{CeedOperatorField}}, Ptr{CeedInt}, Ptr{Ptr{CeedOperatorField}}), op, num_input_fields, input_fields, num_output_fields, output_fields) end -function CeedCompositeOperatorAddSub(composite_op, sub_op) - ccall((:CeedCompositeOperatorAddSub, libceed), Cint, (CeedOperator, CeedOperator), composite_op, sub_op) +function CeedOperatorCompositeAddSub(composite_op, sub_op) + ccall((:CeedOperatorCompositeAddSub, libceed), Cint, (CeedOperator, CeedOperator), composite_op, sub_op) end -function CeedCompositeOperatorGetNumSub(op, num_suboperators) - ccall((:CeedCompositeOperatorGetNumSub, libceed), Cint, (CeedOperator, Ptr{CeedInt}), op, num_suboperators) +function CeedOperatorCompositeGetNumSub(op, num_suboperators) + ccall((:CeedOperatorCompositeGetNumSub, libceed), Cint, (CeedOperator, Ptr{CeedInt}), op, num_suboperators) end -function CeedCompositeOperatorGetSubList(op, sub_operators) - ccall((:CeedCompositeOperatorGetSubList, libceed), Cint, (CeedOperator, Ptr{Ptr{CeedOperator}}), op, sub_operators) +function CeedOperatorCompositeGetSubList(op, sub_operators) + ccall((:CeedOperatorCompositeGetSubList, libceed), Cint, (CeedOperator, Ptr{Ptr{CeedOperator}}), op, sub_operators) end function CeedOperatorCheckReady(op) @@ -738,8 +738,8 @@ function CeedOperatorLinearAssemble(op, values) ccall((:CeedOperatorLinearAssemble, libceed), Cint, (CeedOperator, CeedVector), op, values) end -function CeedCompositeOperatorGetMultiplicity(op, num_skip_indices, skip_indices, mult) - ccall((:CeedCompositeOperatorGetMultiplicity, libceed), Cint, (CeedOperator, CeedInt, Ptr{CeedInt}, CeedVector), op, num_skip_indices, skip_indices, mult) +function CeedOperatorCompositeGetMultiplicity(op, num_skip_indices, skip_indices, mult) + ccall((:CeedOperatorCompositeGetMultiplicity, libceed), Cint, (CeedOperator, CeedInt, Ptr{CeedInt}, CeedVector), op, num_skip_indices, skip_indices, mult) end function CeedOperatorMultigridLevelCreate(op_fine, p_mult_fine, rstr_coarse, basis_coarse, op_coarse, op_prolong, op_restrict) diff --git a/julia/LibCEED.jl/test/rundevtests.jl b/julia/LibCEED.jl/test/rundevtests.jl index 9527d8d2dc..59d0e4840e 100644 --- a/julia/LibCEED.jl/test/rundevtests.jl +++ b/julia/LibCEED.jl/test/rundevtests.jl @@ -8,4 +8,36 @@ function checkoutput(str, fname) return true end -@testset "LibCEED Development Tests" begin end +@testset "LibCEED Development Tests" begin + @testset "Operator" begin + c = Ceed() + @interior_qf id = ( + c, + (input, :in, EVAL_INTERP), + (output, :out, EVAL_INTERP), + begin + output[] = input + end, + ) + b = create_tensor_h1_lagrange_basis(c, 3, 1, 3, 3, GAUSS_LOBATTO) + n = getnumnodes(b) + offsets = Vector{CeedInt}(0:n-1) + r = create_elem_restriction(c, 1, n, 1, 1, n, offsets) + op = Operator( + c; + qf=id, + fields=[ + (:input, r, b, CeedVectorActive()), + (:output, r, b, CeedVectorActive()), + ], + ) + + v = rand(CeedScalar, n) + v1 = CeedVector(c, v) + v2 = CeedVector(c, n) + + comp_op = create_composite_operator(c, [op]) + apply!(comp_op, v1, v2) + @test @witharray_read(a1 = v1, @witharray_read(a2 = v2, a1 == a2)) + end +end diff --git a/julia/LibCEED.jl/test/runtests.jl b/julia/LibCEED.jl/test/runtests.jl index 83c7598ecd..724240d786 100644 --- a/julia/LibCEED.jl/test/runtests.jl +++ b/julia/LibCEED.jl/test/runtests.jl @@ -256,10 +256,6 @@ else LibCEED.assemble_add_diagonal!(op, diag_vector) @test @witharray(a = diag_vector, a == fill(1.0, n)) - comp_op = create_composite_operator(c, [op]) - apply!(comp_op, v1, v2) - @test @witharray_read(a1 = v1, @witharray_read(a2 = v2, a1 == a2)) - @test showstr(op) == """ CeedOperator 1 elements with 27 quadrature points each diff --git a/python/build_ceed_cffi.py b/python/build_ceed_cffi.py index cf302c85a1..a802357303 100644 --- a/python/build_ceed_cffi.py +++ b/python/build_ceed_cffi.py @@ -34,6 +34,7 @@ def get_ceed_dirs(): lines += [line.strip() for line in f if not (line.startswith("#") and not line.startswith("#include")) and not line.startswith(" static") and + not line.startswith("#include \"deprecated.h\"") and not line.startswith(" CEED_QFUNCTION_ATTR") and "CeedErrorImpl" not in line and "const char *, ...);" not in line and diff --git a/python/ceed_operator.py b/python/ceed_operator.py index cce2ee5ae5..e3053439f0 100644 --- a/python/ceed_operator.py +++ b/python/ceed_operator.py @@ -331,7 +331,7 @@ def __init__(self, ceed): # Reference to Ceed self._ceed = ceed # libCEED call - err_code = lib.CeedCompositeOperatorCreate( + err_code = lib.CeedOperatorCreateComposite( self._ceed._pointer[0], self._pointer) self._ceed._check_error(err_code) @@ -343,7 +343,7 @@ def add_sub(self, subop): subop: sub-operator Operator""" # libCEED call - err_code = lib.CeedCompositeOperatorAddSub( + err_code = lib.CeedOperatorCompositeAddSub( self._pointer[0], subop._pointer[0]) self._ceed._check_error(err_code) diff --git a/rust/libceed/src/operator.rs b/rust/libceed/src/operator.rs index bd480c3936..e82e92a393 100644 --- a/rust/libceed/src/operator.rs +++ b/rust/libceed/src/operator.rs @@ -2119,7 +2119,7 @@ impl<'a> CompositeOperator<'a> { // Constructor pub fn create(ceed: &crate::Ceed) -> crate::Result { let mut ptr = std::ptr::null_mut(); - ceed.check_error(unsafe { bind_ceed::CeedCompositeOperatorCreate(ceed.ptr, &mut ptr) })?; + ceed.check_error(unsafe { bind_ceed::CeedOperatorCreateComposite(ceed.ptr, &mut ptr) })?; Ok(Self { op_core: OperatorCore { ptr, @@ -2401,7 +2401,7 @@ impl<'a> CompositeOperator<'a> { #[allow(unused_mut)] pub fn sub_operator(mut self, subop: &Operator) -> crate::Result { self.op_core.check_error(unsafe { - bind_ceed::CeedCompositeOperatorAddSub(self.op_core.ptr, subop.op_core.ptr) + bind_ceed::CeedOperatorCompositeAddSub(self.op_core.ptr, subop.op_core.ptr) })?; Ok(self) } diff --git a/tests/t520-operator-f.f90 b/tests/t520-operator-f.f90 index 628ce3735c..3882ddc1e0 100644 --- a/tests/t520-operator-f.f90 +++ b/tests/t520-operator-f.f90 @@ -211,13 +211,13 @@ program test & buhex,ceed_vector_active,err) ! Composite Operators - call ceedcompositeoperatorcreate(ceed,op_setup,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuptet,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuphex,err) + call ceedoperatorcreatecomposite(ceed,op_setup,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuptet,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuphex,err) - call ceedcompositeoperatorcreate(ceed,op_mass,err) - call ceedcompositeoperatoraddsub(op_mass,op_masstet,err) - call ceedcompositeoperatoraddsub(op_mass,op_masshex,err) + call ceedoperatorcreatecomposite(ceed,op_mass,err) + call ceedoperatorcompositeaddsub(op_mass,op_masstet,err) + call ceedoperatorcompositeaddsub(op_mass,op_masshex,err) ! Apply Setup Operator call ceedoperatorapply(op_setup,x,ceed_vector_none,& diff --git a/tests/t520-operator.c b/tests/t520-operator.c index 31fceb9c97..5632b3e2d6 100644 --- a/tests/t520-operator.c +++ b/tests/t520-operator.c @@ -159,25 +159,25 @@ int main(int argc, char **argv) { // Set up Composite Operators // -- Create - CeedCompositeOperatorCreate(ceed, &op_setup); + CeedOperatorCreateComposite(ceed, &op_setup); // -- Add SubOperators - CeedCompositeOperatorAddSub(op_setup, op_setup_tet); - CeedCompositeOperatorAddSub(op_setup, op_setup_hex); + CeedOperatorCompositeAddSub(op_setup, op_setup_tet); + CeedOperatorCompositeAddSub(op_setup, op_setup_hex); // -- Create - CeedCompositeOperatorCreate(ceed, &op_mass); + CeedOperatorCreateComposite(ceed, &op_mass); // -- Add SubOperators - CeedCompositeOperatorAddSub(op_mass, op_mass_tet); - CeedCompositeOperatorAddSub(op_mass, op_mass_hex); + CeedOperatorCompositeAddSub(op_mass, op_mass_tet); + CeedOperatorCompositeAddSub(op_mass, op_mass_hex); - { // Test CeedCompositeOperatorGetSubByName + { // Test CeedOperatorCompositeGetSubByName CeedOperator op_byname; - CeedCompositeOperatorGetSubByName(op_mass, "mass hex", &op_byname); - if (op_byname != op_mass_hex) printf("CeedCompositeOperatorGetSubByName returned incorrect Sub Operator"); + CeedOperatorCompositeGetSubByName(op_mass, "mass hex", &op_byname); + if (op_byname != op_mass_hex) printf("CeedOperatorCompositeGetSubByName returned incorrect Sub Operator"); - CeedCompositeOperatorGetSubByName(op_mass, "asdf", &op_byname); - if (op_byname != NULL) printf("CeedCompositeOperatorGetSubByName returned non-NULL for non-existent Sub Operator"); + CeedOperatorCompositeGetSubByName(op_mass, "asdf", &op_byname); + if (op_byname != NULL) printf("CeedOperatorCompositeGetSubByName returned non-NULL for non-existent Sub Operator"); } // Apply Setup Operator diff --git a/tests/t521-operator-f.f90 b/tests/t521-operator-f.f90 index 20ab09eb7b..73fff92d7a 100644 --- a/tests/t521-operator-f.f90 +++ b/tests/t521-operator-f.f90 @@ -213,13 +213,13 @@ program test & buhex,ceed_vector_active,err) ! Composite Operators - call ceedcompositeoperatorcreate(ceed,op_setup,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuptet,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuphex,err) + call ceedoperatorcreatecomposite(ceed,op_setup,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuptet,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuphex,err) - call ceedcompositeoperatorcreate(ceed,op_mass,err) - call ceedcompositeoperatoraddsub(op_mass,op_masstet,err) - call ceedcompositeoperatoraddsub(op_mass,op_masshex,err) + call ceedoperatorcreatecomposite(ceed,op_mass,err) + call ceedoperatorcompositeaddsub(op_mass,op_masstet,err) + call ceedoperatorcompositeaddsub(op_mass,op_masshex,err) ! Apply Setup Operator call ceedoperatorapply(op_setup,x,ceed_vector_none,& diff --git a/tests/t521-operator.c b/tests/t521-operator.c index 1fff943186..dd13ea5589 100644 --- a/tests/t521-operator.c +++ b/tests/t521-operator.c @@ -156,13 +156,13 @@ int main(int argc, char **argv) { CeedOperatorSetField(op_mass_hex, "v", elem_restriction_u_hex, basis_u_hex, CEED_VECTOR_ACTIVE); // Composite Operators - CeedCompositeOperatorCreate(ceed, &op_setup); - CeedCompositeOperatorAddSub(op_setup, op_setup_tet); - CeedCompositeOperatorAddSub(op_setup, op_setup_hex); + CeedOperatorCreateComposite(ceed, &op_setup); + CeedOperatorCompositeAddSub(op_setup, op_setup_tet); + CeedOperatorCompositeAddSub(op_setup, op_setup_hex); - CeedCompositeOperatorCreate(ceed, &op_mass); - CeedCompositeOperatorAddSub(op_mass, op_mass_tet); - CeedCompositeOperatorAddSub(op_mass, op_mass_hex); + CeedOperatorCreateComposite(ceed, &op_mass); + CeedOperatorCompositeAddSub(op_mass, op_mass_tet); + CeedOperatorCompositeAddSub(op_mass, op_mass_hex); // Apply Setup Operator CeedOperatorApply(op_setup, x, CEED_VECTOR_NONE, CEED_REQUEST_IMMEDIATE); diff --git a/tests/t522-operator-f.f90 b/tests/t522-operator-f.f90 index 4ea3773f7b..98b9089edb 100644 --- a/tests/t522-operator-f.f90 +++ b/tests/t522-operator-f.f90 @@ -215,13 +215,13 @@ program test & buhex,ceed_vector_active,err) ! Composite Operators - call ceedcompositeoperatorcreate(ceed,op_setup,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuptet,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuphex,err) + call ceedoperatorcreatecomposite(ceed,op_setup,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuptet,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuphex,err) - call ceedcompositeoperatorcreate(ceed,op_diff,err) - call ceedcompositeoperatoraddsub(op_diff,op_difftet,err) - call ceedcompositeoperatoraddsub(op_diff,op_diffhex,err) + call ceedoperatorcreatecomposite(ceed,op_diff,err) + call ceedoperatorcompositeaddsub(op_diff,op_difftet,err) + call ceedoperatorcompositeaddsub(op_diff,op_diffhex,err) ! Apply Setup Operator call ceedoperatorapply(op_setup,x,ceed_vector_none,& diff --git a/tests/t522-operator.c b/tests/t522-operator.c index b2e1da90ac..8572c0d687 100644 --- a/tests/t522-operator.c +++ b/tests/t522-operator.c @@ -159,13 +159,13 @@ int main(int argc, char **argv) { CeedOperatorSetField(op_diff_hex, "v", elem_restriction_u_hex, basis_u_hex, CEED_VECTOR_ACTIVE); // Composite Operators - CeedCompositeOperatorCreate(ceed, &op_setup); - CeedCompositeOperatorAddSub(op_setup, op_setup_tet); - CeedCompositeOperatorAddSub(op_setup, op_setup_hex); + CeedOperatorCreateComposite(ceed, &op_setup); + CeedOperatorCompositeAddSub(op_setup, op_setup_tet); + CeedOperatorCompositeAddSub(op_setup, op_setup_hex); - CeedCompositeOperatorCreate(ceed, &op_diff); - CeedCompositeOperatorAddSub(op_diff, op_diff_tet); - CeedCompositeOperatorAddSub(op_diff, op_diff_hex); + CeedOperatorCreateComposite(ceed, &op_diff); + CeedOperatorCompositeAddSub(op_diff, op_diff_tet); + CeedOperatorCompositeAddSub(op_diff, op_diff_hex); // Apply Setup Operator CeedOperatorApply(op_setup, x, CEED_VECTOR_NONE, CEED_REQUEST_IMMEDIATE); diff --git a/tests/t523-operator-f.f90 b/tests/t523-operator-f.f90 index 0431b60ee7..ea20128d3c 100644 --- a/tests/t523-operator-f.f90 +++ b/tests/t523-operator-f.f90 @@ -205,15 +205,15 @@ program test & buhex,ceed_vector_active,err) ! Composite Operators - call ceedcompositeoperatorcreate(ceed,op_setup,err) + call ceedoperatorcreatecomposite(ceed,op_setup,err) call ceedoperatorsetname(op_setup,'setup',err) - call ceedcompositeoperatoraddsub(op_setup,op_setuptet,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuphex,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuptet,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuphex,err) - call ceedcompositeoperatorcreate(ceed,op_mass,err) + call ceedoperatorcreatecomposite(ceed,op_mass,err) call ceedoperatorsetname(op_mass,'mass',err) - call ceedcompositeoperatoraddsub(op_mass,op_masstet,err) - call ceedcompositeoperatoraddsub(op_mass,op_masshex,err) + call ceedoperatorcompositeaddsub(op_mass,op_masstet,err) + call ceedoperatorcompositeaddsub(op_mass,op_masshex,err) ! View call ceedoperatorview(op_setup,err) diff --git a/tests/t523-operator.c b/tests/t523-operator.c index 9b614ec360..2e9dd5c264 100644 --- a/tests/t523-operator.c +++ b/tests/t523-operator.c @@ -150,18 +150,18 @@ int main(int argc, char **argv) { // Set up Composite Operators // -- Create - CeedCompositeOperatorCreate(ceed, &op_setup); + CeedOperatorCreateComposite(ceed, &op_setup); CeedOperatorSetName(op_setup, "setup"); // -- Add SubOperators - CeedCompositeOperatorAddSub(op_setup, op_setup_tet); - CeedCompositeOperatorAddSub(op_setup, op_setup_hex); + CeedOperatorCompositeAddSub(op_setup, op_setup_tet); + CeedOperatorCompositeAddSub(op_setup, op_setup_hex); // -- Create - CeedCompositeOperatorCreate(ceed, &op_mass); + CeedOperatorCreateComposite(ceed, &op_mass); CeedOperatorSetName(op_mass, "mass"); // -- Add SubOperators - CeedCompositeOperatorAddSub(op_mass, op_mass_tet); - CeedCompositeOperatorAddSub(op_mass, op_mass_hex); + CeedOperatorCompositeAddSub(op_mass, op_mass_tet); + CeedOperatorCompositeAddSub(op_mass, op_mass_hex); // View CeedOperatorViewTerse(op_setup, stdout); diff --git a/tests/t524-operator-f.f90 b/tests/t524-operator-f.f90 index 4639442a5c..16b041c09a 100644 --- a/tests/t524-operator-f.f90 +++ b/tests/t524-operator-f.f90 @@ -215,13 +215,13 @@ program test & buhex,ceed_vector_active,err) ! Composite Operators - call ceedcompositeoperatorcreate(ceed,op_setup,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuptet,err) - call ceedcompositeoperatoraddsub(op_setup,op_setuphex,err) + call ceedoperatorcreatecomposite(ceed,op_setup,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuptet,err) + call ceedoperatorcompositeaddsub(op_setup,op_setuphex,err) - call ceedcompositeoperatorcreate(ceed,op_mass,err) - call ceedcompositeoperatoraddsub(op_mass,op_masstet,err) - call ceedcompositeoperatoraddsub(op_mass,op_masshex,err) + call ceedoperatorcreatecomposite(ceed,op_mass,err) + call ceedoperatorcompositeaddsub(op_mass,op_masstet,err) + call ceedoperatorcompositeaddsub(op_mass,op_masshex,err) ! Apply Setup Operator call ceedoperatorapply(op_setup,x,ceed_vector_none,& diff --git a/tests/t524-operator.c b/tests/t524-operator.c index fec0fe6ccd..3d61a563b3 100644 --- a/tests/t524-operator.c +++ b/tests/t524-operator.c @@ -155,13 +155,13 @@ int main(int argc, char **argv) { CeedOperatorSetField(op_mass_hex, "v", elem_restriction_u_hex, basis_u_hex, CEED_VECTOR_ACTIVE); // Composite Operators - CeedCompositeOperatorCreate(ceed, &op_setup); - CeedCompositeOperatorAddSub(op_setup, op_setup_tet); - CeedCompositeOperatorAddSub(op_setup, op_setup_hex); + CeedOperatorCreateComposite(ceed, &op_setup); + CeedOperatorCompositeAddSub(op_setup, op_setup_tet); + CeedOperatorCompositeAddSub(op_setup, op_setup_hex); - CeedCompositeOperatorCreate(ceed, &op_mass); - CeedCompositeOperatorAddSub(op_mass, op_mass_tet); - CeedCompositeOperatorAddSub(op_mass, op_mass_hex); + CeedOperatorCreateComposite(ceed, &op_mass); + CeedOperatorCompositeAddSub(op_mass, op_mass_tet); + CeedOperatorCompositeAddSub(op_mass, op_mass_hex); // Apply Setup Operator CeedOperatorApply(op_setup, x, CEED_VECTOR_NONE, CEED_REQUEST_IMMEDIATE); diff --git a/tests/t525-operator.c b/tests/t525-operator.c index 9617d94f32..bed1365a77 100644 --- a/tests/t525-operator.c +++ b/tests/t525-operator.c @@ -73,9 +73,9 @@ int main(int argc, char **argv) { CeedOperatorCreate(ceed, qf_sub_2, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE, &op_sub_2); // Composite operator - CeedCompositeOperatorCreate(ceed, &op_composite); - CeedCompositeOperatorAddSub(op_composite, op_sub_1); - CeedCompositeOperatorAddSub(op_composite, op_sub_2); + CeedOperatorCreateComposite(ceed, &op_composite); + CeedOperatorCompositeAddSub(op_composite, op_sub_1); + CeedOperatorCompositeAddSub(op_composite, op_sub_2); // Check setting field in context of single sub-operator for composite operator CeedOperatorGetContextFieldLabel(op_composite, "time", &time_label); diff --git a/tests/t526-operator.c b/tests/t526-operator.c index 6d66590d15..8e68ab89b3 100644 --- a/tests/t526-operator.c +++ b/tests/t526-operator.c @@ -114,10 +114,10 @@ int main(int argc, char **argv) { // Set up Composite Operator // -- Create - CeedCompositeOperatorCreate(ceed, &op_mass); + CeedOperatorCreateComposite(ceed, &op_mass); // -- Add SubOperators - CeedCompositeOperatorAddSub(op_mass, op_mass_tet); - CeedCompositeOperatorAddSub(op_mass, op_mass_hex); + CeedOperatorCompositeAddSub(op_mass, op_mass_tet); + CeedOperatorCompositeAddSub(op_mass, op_mass_hex); // Estimate FLOPs CeedQFunctionSetUserFlopsEstimate(qf_mass, 1); diff --git a/tests/t538-operator.c b/tests/t538-operator.c index 45e86ecdff..0e5267019c 100644 --- a/tests/t538-operator.c +++ b/tests/t538-operator.c @@ -104,9 +104,9 @@ int main(int argc, char **argv) { CeedOperatorSetField(op_diff, "dv", elem_restriction_u, basis_u, CEED_VECTOR_ACTIVE); // Composite operator - CeedCompositeOperatorCreate(ceed, &op_apply); - CeedCompositeOperatorAddSub(op_apply, op_mass); - CeedCompositeOperatorAddSub(op_apply, op_diff); + CeedOperatorCreateComposite(ceed, &op_apply); + CeedOperatorCompositeAddSub(op_apply, op_mass); + CeedOperatorCompositeAddSub(op_apply, op_diff); // Assemble diagonal CeedVectorCreate(ceed, num_dofs, &assembled); diff --git a/tests/t554-operator.c b/tests/t554-operator.c index 0ca19605a9..d63c548696 100644 --- a/tests/t554-operator.c +++ b/tests/t554-operator.c @@ -33,10 +33,10 @@ int main(int argc, char **argv) { CeedVectorCreate(ceed, num_comp * num_dofs_u_fine, &v_fine); // Composite operators - CeedCompositeOperatorCreate(ceed, &op_mass_coarse); - CeedCompositeOperatorCreate(ceed, &op_mass_fine); - CeedCompositeOperatorCreate(ceed, &op_prolong); - CeedCompositeOperatorCreate(ceed, &op_restrict); + CeedOperatorCreateComposite(ceed, &op_mass_coarse); + CeedOperatorCreateComposite(ceed, &op_mass_fine); + CeedOperatorCreateComposite(ceed, &op_prolong); + CeedOperatorCreateComposite(ceed, &op_restrict); // Setup fine suboperators for (CeedInt i = 0; i < num_sub_ops; i++) { @@ -99,7 +99,7 @@ int main(int argc, char **argv) { CeedOperatorApply(sub_op_setup, x, q_data, CEED_REQUEST_IMMEDIATE); // -- Composite operators - CeedCompositeOperatorAddSub(op_mass_fine, sub_op_mass_fine); + CeedOperatorCompositeAddSub(op_mass_fine, sub_op_mass_fine); // -- Cleanup CeedVectorDestroy(&q_data); @@ -116,7 +116,7 @@ int main(int argc, char **argv) { // Scale for suboperator multiplicity CeedVectorCreate(ceed, num_comp * num_dofs_u_fine, &p_mult_fine); - CeedCompositeOperatorGetMultiplicity(op_mass_fine, 0, NULL, p_mult_fine); + CeedOperatorCompositeGetMultiplicity(op_mass_fine, 0, NULL, p_mult_fine); // Setup coarse and prolong/restriction suboperators for (CeedInt i = 0; i < num_sub_ops; i++) { @@ -125,7 +125,7 @@ int main(int argc, char **argv) { CeedOperator *sub_ops_mass_fine, sub_op_mass_coarse, sub_op_prolong, sub_op_restrict; // -- Fine grid operator - CeedCompositeOperatorGetSubList(op_mass_fine, &sub_ops_mass_fine); + CeedOperatorCompositeGetSubList(op_mass_fine, &sub_ops_mass_fine); // -- Restrictions CeedInt offset = num_elem_sub * i * (p_coarse - 1); @@ -145,9 +145,9 @@ int main(int argc, char **argv) { &sub_op_prolong, &sub_op_restrict); // -- Composite operators - CeedCompositeOperatorAddSub(op_mass_coarse, sub_op_mass_coarse); - CeedCompositeOperatorAddSub(op_prolong, sub_op_prolong); - CeedCompositeOperatorAddSub(op_restrict, sub_op_restrict); + CeedOperatorCompositeAddSub(op_mass_coarse, sub_op_mass_coarse); + CeedOperatorCompositeAddSub(op_prolong, sub_op_prolong); + CeedOperatorCompositeAddSub(op_restrict, sub_op_restrict); // -- Cleanup CeedElemRestrictionDestroy(&elem_restriction_u_coarse); diff --git a/tests/t565-operator.c b/tests/t565-operator.c index b5a542451f..8ed3e0ea5f 100644 --- a/tests/t565-operator.c +++ b/tests/t565-operator.c @@ -107,9 +107,9 @@ int main(int argc, char **argv) { CeedOperatorSetField(op_diff, "dv", elem_restriction_u, basis_u, CEED_VECTOR_ACTIVE); // Composite operator - CeedCompositeOperatorCreate(ceed, &op_apply); - CeedCompositeOperatorAddSub(op_apply, op_mass); - CeedCompositeOperatorAddSub(op_apply, op_diff); + CeedOperatorCreateComposite(ceed, &op_apply); + CeedOperatorCompositeAddSub(op_apply, op_mass); + CeedOperatorCompositeAddSub(op_apply, op_diff); // Fully assemble operator CeedSize num_entries;