Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "ADFParser.h"
      11             : #include "MooseUtils.h"
      12             : #include "ExecutablePath.h"
      13             : 
      14        1792 : ADFParser::ADFParser() : FunctionParserAD(), _epsilon(1e-12) {}
      15             : 
      16        2811 : ADFParser::ADFParser(const ADFParser & cpy) : FunctionParserAD(cpy), _epsilon(1e-12) {}
      17             : 
      18             : #ifndef ADFPARSER_INCLUDES
      19             : #error ... \
      20             :        The ADFPARSER_INCLUDES macro is not defined. A possible reason is that you       \
      21             :        are compiling MOOSE from a custom application. Please check your application     \
      22             :        Makefile and make sure that you are appending options to ADDITIONAL_CPPFLAGS     \
      23             :        using the += operator, rather than overwriting the variable with the := operator.
      24             : #endif
      25             : 
      26             : bool
      27        4366 : ADFParser::JITCompile()
      28             : {
      29             : #if LIBMESH_HAVE_FPARSER_JIT
      30        4366 :   std::string includes;
      31        4366 :   const auto type_hash = typeid(ADReal).hash_code();
      32             :   bool result;
      33             : 
      34        4366 :   std::string fopenmp;
      35             : #if defined(_OPENMP)
      36        4366 :   fopenmp = "-fopenmp";
      37             : #endif
      38             : 
      39        4366 :   const auto include_path_env = std::getenv("MOOSE_ADFPARSER_JIT_INCLUDE");
      40        4366 :   if (include_path_env)
      41           0 :     result = JITCompileHelper(
      42           0 :         "ADReal", fopenmp, "#include \"" + std::string(include_path_env) + "\"\n", type_hash);
      43             :   else
      44             :   {
      45             :     // check if we can find an installed version of the monolithic include
      46             :     const std::string include_path =
      47        4366 :         MooseUtils::pathjoin(Moose::getExecutablePath(), "../include/moose/ADRealMonolithic.h");
      48        4366 :     if (MooseUtils::checkFileReadable(include_path, false, false, false))
      49             :       result =
      50           0 :           JITCompileHelper("ADReal", fopenmp, "#include \"" + include_path + "\"\n", type_hash);
      51             :     else
      52             :       // otherwise use the compiled in location from the source tree
      53       13098 :       result = JITCompileHelper(
      54        8732 :           "ADReal", fopenmp + " " + ADFPARSER_INCLUDES, "#include \"ADReal.h\"\n", type_hash);
      55        4366 :   }
      56             : 
      57        4366 :   if (!result)
      58             : #endif
      59           0 :     mooseError("ADFParser::JITCompile() failed. Evaluation not possible.");
      60             : 
      61        4366 :   return true;
      62        4366 : }
      63             : 
      64             : ADReal
      65     5390692 : ADFParser::Eval(const ADReal * vars)
      66             : {
      67             :   mooseAssert(compiledFunction, "ADFParser objects must be JIT compiled before evaluation!");
      68     5390692 :   ADReal ret;
      69     5390692 :   (*reinterpret_cast<CompiledFunctionPtr<ADReal>>(compiledFunction))(&ret, vars, pImmed, _epsilon);
      70     5390692 :   return ret;
      71           0 : }