ceed_operator.py - OpenGrok cross reference for /libCEED/python/ceed

ceed_operator.py (572ff09c85e1de07bdd8bed4adbe59486604f1e4)	ceed_operator.py (d99fa3c5cd91a1690aedf0679cbf290d44fec74c)
1# Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at 2# the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights 3# reserved. See files LICENSE and NOTICE for details. 4# 5# This file is part of CEED, a collection of benchmarks, miniapps, software 6# libraries and APIs for efficient high-order finite element and spectral 7# element discretizations for exascale applications. For more information and 8# source code availability see http://github.com/ceed. --- 132 unchanged lines hidden (view full) --- 141 or CEED_VECTOR_NONE if there are no active outputs 142 **request: Ceed request, default CEED_REQUEST_IMMEDIATE""" 143 144 # libCEED call 145 err_code = lib.CeedOperatorApplyAdd(self._pointer[0], u._pointer[0], v._pointer[0], 146 request) 147 self._ceed._check_error(err_code) 148	1# Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at 2# the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights 3# reserved. See files LICENSE and NOTICE for details. 4# 5# This file is part of CEED, a collection of benchmarks, miniapps, software 6# libraries and APIs for efficient high-order finite element and spectral 7# element discretizations for exascale applications. For more information and 8# source code availability see http://github.com/ceed. --- 132 unchanged lines hidden (view full) --- 141 or CEED_VECTOR_NONE if there are no active outputs 142 **request: Ceed request, default CEED_REQUEST_IMMEDIATE""" 143 144 # libCEED call 145 err_code = lib.CeedOperatorApplyAdd(self._pointer[0], u._pointer[0], v._pointer[0], 146 request) 147 self._ceed._check_error(err_code) 148
	149 # Create Multigrid Level 150 def multigrid_create(self, p_mult_fine, rstr_coarse, basis_coarse): 151 """ Create a multigrid coarse operator and level transfer operators 152 for a CeedOperator with a Lagrange tensor basis for the active basis 153 154 Args: 155 p_mult_fine: L-vector multiplicity in parallel gather/scatter 156 basis_coarse: Coarse grid active vector basis 157 degree_coarse: Coarse grid basis polynomial order""" 158 159 # Operator pointers 160 opCoarsePointer = ffi.new("CeedOperator ") 161 opProlongPointer = ffi.new("CeedOperator ") 162 opRestrictPointer = ffi.new("CeedOperator ") 163 164 # libCEED call 165 lib.CeedOperatorMultigridLevelCreate(self._pointer[0], 166 p_mult_fine._pointer[0], 167 rstr_coarse._pointer[0], 168 basis_coarse._pointer[0], 169 opCoarsePointer, 170 opProlongPointer, 171 opRestrictPointer) 172 173 # Wrap operators 174 opCoarse = _OperatorWrap( 175 self._ceed, opCoarsePointer) 176 opProlong = _OperatorWrap( 177 self._ceed, opProlongPointer) 178 opRestrict = _OperatorWrap( 179 self._ceed, opRestrictPointer) 180 181 # Return 182 return [opCoarse, opProlong, opRestrict] 183 184 # Create Multigrid Level 185 def multigrid_create_tensor_h1(self, p_mult_fine, rstr_coarse, basis_coarse, 186 interp_C_to_F): 187 """ Create a multigrid coarse operator and level transfer operators 188 for a CeedOperator with a non-tensor basis for the active basis 189 190 Args: 191 p_mult_fine: L-vector multiplicity in parallel gather/scatter 192 rstr_coarse: Coarse grid restriction 193 basis_coarse: Coarse grid active vector basis 194 interp_C_to_F: Matrix for coarse to fine interpolation""" 195 196 # Setup arguments 197 interpCtoF_pointer = ffi.new("CeedScalar ") 198 interpCtoF_pointer = ffi.cast( 199 "CeedScalar ", 200 interp_C_to_F.__array_interface__['data'][0]) 201 202 # Operator pointers 203 opCoarsePointer = ffi.new("CeedOperator ") 204 opProlongPointer = ffi.new("CeedOperator ") 205 opRestrictPointer = ffi.new("CeedOperator ") 206 207 # libCEED call 208 lib.CeedOperatorMultigridLevelCreateTensorH1(self._pointer[0], 209 p_mult_fine._pointer[0], 210 rstr_coarse._pointer[0], 211 basis_coarse._pointer[0], 212 interpCtoF_pointer, 213 opCoarsePointer, 214 opProlongPointer, 215 opRestrictPointer) 216 217 # Wrap operators 218 opCoarse = _OperatorWrap( 219 self._ceed, opCoarsePointer) 220 opProlong = _OperatorWrap( 221 self._ceed, opProlongPointer) 222 opRestrict = _OperatorWrap( 223 self._ceed, opRestrictPointer) 224 225 # Return 226 return [opCoarse, opProlong, opRestrict] 227 228 # Create Multigrid Level 229 def multigrid_create_h1(self, p_mult_fine, rstr_coarse, basis_coarse, 230 interp_C_to_F): 231 """ Create a multigrid coarse operator and level transfer operators 232 for a CeedOperator with a Lagrange tensor basis for the active basis 233 234 Args: 235 p_mult_fine: L-vector multiplicity in parallel gather/scatter 236 rstr_coarse: Coarse grid restriction 237 basis_coarse: Coarse grid active vector basis 238 interp_C_to_F: Matrix for coarse to fine interpolation""" 239 240 # Setup arguments 241 interpCtoF_pointer = ffi.new("CeedScalar ") 242 interpCtoF_pointer = ffi.cast( 243 "CeedScalar ", 244 interp_C_to_F.__array_interface__['data'][0]) 245 246 # Operator pointers 247 opCoarsePointer = ffi.new("CeedOperator ") 248 opProlongPointer = ffi.new("CeedOperator ") 249 opRestrictPointer = ffi.new("CeedOperator *") 250 251 # libCEED call 252 lib.CeedOperatorMultigridLevelCreateH1(self._pointer[0], 253 p_mult_fine._pointer[0], 254 rstr_coarse._pointer[0], 255 basis_coarse._pointer[0], 256 interpCtoF_pointer, 257 opCoarsePointer, 258 opProlongPointer, 259 opRestrictPointer) 260 261 # Wrap operators 262 opCoarse = _OperatorWrap( 263 self._ceed, opCoarsePointer) 264 opProlong = _OperatorWrap( 265 self._ceed, opProlongPointer) 266 opRestrict = _OperatorWrap( 267 self._ceed, opRestrictPointer) 268 269 # Return 270 return [opCoarse, opProlong, opRestrict] 271 272
149# ------------------------------------------------------------------------------ 150 151 152class Operator(_OperatorBase): 153 """Ceed Operator: composed FE-type operations on vectors.""" 154 155 # Constructor 156 def __init__(self, ceed, qf, dqf=None, dqfT=None): --- 57 unchanged lines hidden (view full) --- 214 subop: sub-operator Operator""" 215 216 # libCEED call 217 err_code = lib.CeedCompositeOperatorAddSub( 218 self._pointer[0], subop._pointer[0]) 219 self._ceed._check_error(err_code) 220 221# ------------------------------------------------------------------------------	273# ------------------------------------------------------------------------------ 274 275 276class Operator(_OperatorBase): 277 """Ceed Operator: composed FE-type operations on vectors.""" 278 279 # Constructor 280 def __init__(self, ceed, qf, dqf=None, dqfT=None): --- 57 unchanged lines hidden (view full) --- 338 subop: sub-operator Operator""" 339 340 # libCEED call 341 err_code = lib.CeedCompositeOperatorAddSub( 342 self._pointer[0], subop._pointer[0]) 343 self._ceed._check_error(err_code) 344 345# ------------------------------------------------------------------------------
	346 347 348class _OperatorWrap(Operator): 349 """Wrap a CeedOperator pointer in a Operator object.""" 350 351 # Constructor 352 def __init__(self, ceed, pointer): 353 # CeedOperator object 354 self._pointer = pointer 355 356 # Reference to Ceed 357 self._ceed = ceed 358 359# ------------------------------------------------------------------------------

1# Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
2# the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
3# reserved. See files LICENSE and NOTICE for details.
4#
5# This file is part of CEED, a collection of benchmarks, miniapps, software
6# libraries and APIs for efficient high-order finite element and spectral
7# element discretizations for exascale applications. For more information and
8# source code availability see http://github.com/ceed.

--- 132 unchanged lines hidden (view full) ---

141 or CEED_VECTOR_NONE if there are no active outputs
142 **request: Ceed request, default CEED_REQUEST_IMMEDIATE"""
143
144 # libCEED call
145 err_code = lib.CeedOperatorApplyAdd(self._pointer[0], u._pointer[0], v._pointer[0],
146 request)
147 self._ceed._check_error(err_code)
148

149 # Create Multigrid Level
150 def multigrid_create(self, p_mult_fine, rstr_coarse, basis_coarse):
151 """ Create a multigrid coarse operator and level transfer operators
152 for a CeedOperator with a Lagrange tensor basis for the active basis
153
154 Args:
155 p_mult_fine: L-vector multiplicity in parallel gather/scatter
156 basis_coarse: Coarse grid active vector basis
157 degree_coarse: Coarse grid basis polynomial order"""
158
159 # Operator pointers
160 opCoarsePointer = ffi.new("CeedOperator *")
161 opProlongPointer = ffi.new("CeedOperator *")
162 opRestrictPointer = ffi.new("CeedOperator *")
163
164 # libCEED call
165 lib.CeedOperatorMultigridLevelCreate(self._pointer[0],
166 p_mult_fine._pointer[0],
167 rstr_coarse._pointer[0],
168 basis_coarse._pointer[0],
169 opCoarsePointer,
170 opProlongPointer,
171 opRestrictPointer)
172
173 # Wrap operators
174 opCoarse = _OperatorWrap(
175 self._ceed, opCoarsePointer)
176 opProlong = _OperatorWrap(
177 self._ceed, opProlongPointer)
178 opRestrict = _OperatorWrap(
179 self._ceed, opRestrictPointer)
180
181 # Return
182 return [opCoarse, opProlong, opRestrict]
183
184 # Create Multigrid Level
185 def multigrid_create_tensor_h1(self, p_mult_fine, rstr_coarse, basis_coarse,
186 interp_C_to_F):
187 """ Create a multigrid coarse operator and level transfer operators
188 for a CeedOperator with a non-tensor basis for the active basis
189
190 Args:
191 p_mult_fine: L-vector multiplicity in parallel gather/scatter
192 rstr_coarse: Coarse grid restriction
193 basis_coarse: Coarse grid active vector basis
194 interp_C_to_F: Matrix for coarse to fine interpolation"""
195
196 # Setup arguments
197 interpCtoF_pointer = ffi.new("CeedScalar *")
198 interpCtoF_pointer = ffi.cast(
199 "CeedScalar *",
200 interp_C_to_F.__array_interface__['data'][0])
201
202 # Operator pointers
203 opCoarsePointer = ffi.new("CeedOperator *")
204 opProlongPointer = ffi.new("CeedOperator *")
205 opRestrictPointer = ffi.new("CeedOperator *")
206
207 # libCEED call
208 lib.CeedOperatorMultigridLevelCreateTensorH1(self._pointer[0],
209 p_mult_fine._pointer[0],
210 rstr_coarse._pointer[0],
211 basis_coarse._pointer[0],
212 interpCtoF_pointer,
213 opCoarsePointer,
214 opProlongPointer,
215 opRestrictPointer)
216
217 # Wrap operators
218 opCoarse = _OperatorWrap(
219 self._ceed, opCoarsePointer)
220 opProlong = _OperatorWrap(
221 self._ceed, opProlongPointer)
222 opRestrict = _OperatorWrap(
223 self._ceed, opRestrictPointer)
224
225 # Return
226 return [opCoarse, opProlong, opRestrict]
227
228 # Create Multigrid Level
229 def multigrid_create_h1(self, p_mult_fine, rstr_coarse, basis_coarse,
230 interp_C_to_F):
231 """ Create a multigrid coarse operator and level transfer operators
232 for a CeedOperator with a Lagrange tensor basis for the active basis
233
234 Args:
235 p_mult_fine: L-vector multiplicity in parallel gather/scatter
236 rstr_coarse: Coarse grid restriction
237 basis_coarse: Coarse grid active vector basis
238 interp_C_to_F: Matrix for coarse to fine interpolation"""
239
240 # Setup arguments
241 interpCtoF_pointer = ffi.new("CeedScalar *")
242 interpCtoF_pointer = ffi.cast(
243 "CeedScalar *",
244 interp_C_to_F.__array_interface__['data'][0])
245
246 # Operator pointers
247 opCoarsePointer = ffi.new("CeedOperator *")
248 opProlongPointer = ffi.new("CeedOperator *")
249 opRestrictPointer = ffi.new("CeedOperator *")
250
251 # libCEED call
252 lib.CeedOperatorMultigridLevelCreateH1(self._pointer[0],
253 p_mult_fine._pointer[0],
254 rstr_coarse._pointer[0],
255 basis_coarse._pointer[0],
256 interpCtoF_pointer,
257 opCoarsePointer,
258 opProlongPointer,
259 opRestrictPointer)
260
261 # Wrap operators
262 opCoarse = _OperatorWrap(
263 self._ceed, opCoarsePointer)
264 opProlong = _OperatorWrap(
265 self._ceed, opProlongPointer)
266 opRestrict = _OperatorWrap(
267 self._ceed, opRestrictPointer)
268
269 # Return
270 return [opCoarse, opProlong, opRestrict]
271
272

149# ------------------------------------------------------------------------------
150
151
152class Operator(_OperatorBase):
153 """Ceed Operator: composed FE-type operations on vectors."""
154
155 # Constructor
156 def __init__(self, ceed, qf, dqf=None, dqfT=None):

--- 57 unchanged lines hidden (view full) ---

214 subop: sub-operator Operator"""
215
216 # libCEED call
217 err_code = lib.CeedCompositeOperatorAddSub(
218 self._pointer[0], subop._pointer[0])
219 self._ceed._check_error(err_code)
220
221# ------------------------------------------------------------------------------

273# ------------------------------------------------------------------------------
274
275
276class Operator(_OperatorBase):
277 """Ceed Operator: composed FE-type operations on vectors."""
278
279 # Constructor
280 def __init__(self, ceed, qf, dqf=None, dqfT=None):

--- 57 unchanged lines hidden (view full) ---

338 subop: sub-operator Operator"""
339
340 # libCEED call
341 err_code = lib.CeedCompositeOperatorAddSub(
342 self._pointer[0], subop._pointer[0])
343 self._ceed._check_error(err_code)
344
345# ------------------------------------------------------------------------------

346
347
348class _OperatorWrap(Operator):
349 """Wrap a CeedOperator pointer in a Operator object."""
350
351 # Constructor
352 def __init__(self, ceed, pointer):
353 # CeedOperator object
354 self._pointer = pointer
355
356 # Reference to Ceed
357 self._ceed = ceed
358
359# ------------------------------------------------------------------------------