libceed-sys 0.12.0

Low-level bindings for libCEED library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// Copyright (c) 2017-2022, 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

#include "ceed-occa-operator.hpp"

#include "ceed-occa-basis.hpp"
#include "ceed-occa-cpu-operator.hpp"
#include "ceed-occa-elem-restriction.hpp"
#include "ceed-occa-gpu-operator.hpp"
#include "ceed-occa-qfunction.hpp"

namespace ceed {
namespace occa {
Operator::Operator() : ceedQ(0), ceedElementCount(0), qfunction(NULL), needsInitialSetup(true) {}

Operator::~Operator() {}

Operator *Operator::getOperator(CeedOperator op, const bool assertValid) {
  if (!op) {
    return NULL;
  }

  int       ierr;
  Operator *operator_ = NULL;

  ierr = CeedOperatorGetData(op, (void **)&operator_);
  if (assertValid) {
    CeedOccaFromChk(ierr);
  }

  return operator_;
}

Operator *Operator::from(CeedOperator op) {
  Operator *operator_ = getOperator(op);
  if (!operator_) {
    return NULL;
  }

  CeedCallOcca(CeedOperatorGetCeed(op, &operator_->ceed));

  operator_->qfunction = QFunction::from(op);
  if (!operator_->qfunction) {
    return NULL;
  }

  CeedCallOcca(CeedOperatorGetNumQuadraturePoints(op, &operator_->ceedQ));
  CeedCallOcca(CeedOperatorGetNumElements(op, &operator_->ceedElementCount));

  operator_->args.setupArgs(op);
  if (!operator_->args.isValid()) {
    return NULL;
  }

  return operator_;
}

bool Operator::isApplyingIdentityFunction() { return qfunction->ceedIsIdentity; }

int Operator::applyAdd(Vector *in, Vector *out, CeedRequest *request) {
  // TODO: Cache kernel objects rather than relying on OCCA kernel caching
  applyAddKernel = buildApplyAddKernel();

  if (needsInitialSetup) {
    initialSetup();
    needsInitialSetup = false;
  }

  applyAdd(in, out);

  return CEED_ERROR_SUCCESS;
}

//---[ Virtual Methods ]------------
void Operator::initialSetup() {}

//---[ Ceed Callbacks ]-------------
int Operator::registerCeedFunction(Ceed ceed, CeedOperator op, const char *fname, ceed::occa::ceedFunction f) {
  return CeedSetBackendFunction(ceed, "Operator", op, fname, f);
}

int Operator::ceedCreate(CeedOperator op) {
  Ceed ceed;
  CeedCallBackend(CeedOperatorGetCeed(op, &ceed));

#if 1
  Operator *operator_ = new CpuOperator();
#else
  // TODO: Add GPU specific operator
  Operator *operator_ = (Context::from(ceed)->usingCpuDevice() ? ((Operator *)new CpuOperator()) : ((Operator *)new GpuOperator()));
#endif

  CeedCallBackend(CeedOperatorSetData(op, operator_));

  CeedOccaRegisterFunction(op, "LinearAssembleQFunction", Operator::ceedLinearAssembleQFunction);
  CeedOccaRegisterFunction(op, "LinearAssembleQFunctionUpdate", Operator::ceedLinearAssembleQFunction);
  CeedOccaRegisterFunction(op, "LinearAssembleAddDiagonal", Operator::ceedLinearAssembleAddDiagonal);
  CeedOccaRegisterFunction(op, "LinearAssembleAddPointBlockDiagonal", Operator::ceedLinearAssembleAddPointBlockDiagonal);
  CeedOccaRegisterFunction(op, "CreateFDMElementInverse", Operator::ceedCreateFDMElementInverse);
  CeedOccaRegisterFunction(op, "ApplyAdd", Operator::ceedApplyAdd);
  CeedOccaRegisterFunction(op, "Destroy", Operator::ceedDestroy);

  return CEED_ERROR_SUCCESS;
}

int Operator::ceedCreateComposite(CeedOperator op) {
  Ceed ceed;
  CeedCallBackend(CeedOperatorGetCeed(op, &ceed));

  CeedOccaRegisterFunction(op, "LinearAssembleAddDiagonal", Operator::ceedLinearAssembleAddDiagonal);
  CeedOccaRegisterFunction(op, "LinearAssembleAddPointBlockDiagonal", Operator::ceedLinearAssembleAddPointBlockDiagonal);

  return CEED_ERROR_SUCCESS;
}

int Operator::ceedLinearAssembleQFunction(CeedOperator op) { return staticCeedError("(OCCA) Backend does not implement LinearAssembleQFunction"); }

int Operator::ceedLinearAssembleQFunctionUpdate(CeedOperator op) {
  return staticCeedError("(OCCA) Backend does not implement LinearAssembleQFunctionUpdate");
}

int Operator::ceedLinearAssembleAddDiagonal(CeedOperator op) { return staticCeedError("(OCCA) Backend does not implement LinearAssembleDiagonal"); }

int Operator::ceedLinearAssembleAddPointBlockDiagonal(CeedOperator op) {
  return staticCeedError("(OCCA) Backend does not implement LinearAssemblePointBlockDiagonal");
}

int Operator::ceedCreateFDMElementInverse(CeedOperator op) { return staticCeedError("(OCCA) Backend does not implement CreateFDMElementInverse"); }

int Operator::ceedApplyAdd(CeedOperator op, CeedVector invec, CeedVector outvec, CeedRequest *request) {
  Operator *operator_ = Operator::from(op);
  Vector   *in        = Vector::from(invec);
  Vector   *out       = Vector::from(outvec);

  if (!operator_) {
    return staticCeedError("Incorrect CeedOperator argument: op");
  }

  return operator_->applyAdd(in, out, request);
}

int Operator::ceedDestroy(CeedOperator op) {
  delete getOperator(op, false);
  return CEED_ERROR_SUCCESS;
}
}  // namespace occa
}  // namespace ceed