currently, only BUILD_CMD_TYPE release works

This commit is contained in:
Martin Diehl 2016-05-21 15:06:01 +02:00
parent 0810295fe9
commit e3d8d48990
3 changed files with 200 additions and 210 deletions

View File

@ -30,8 +30,9 @@ include ${petsc_conf_rules}
include ${petsc_conf_variables}
INCLUDE_DIRS := \${PETSC_FC_INCLUDES}
LIBRARIES := \${PETSC_WITH_EXTERNAL_LIB}
COMPILERF ?= \${FC}
LINKERNAME ?= \${FLINKER}
COMPILERF := \${FC}
COMPILERC := \${CC}
LINKERNAME := \${FLINKER}
includes:
\t@echo \${INCLUDE_DIRS}
extlibs:
@ -60,10 +61,15 @@ execute_process(COMMAND ${MAKE_EXECUTABLE} --no-print-directory -f ${petsc_confi
RESULT_VARIABLE PETSC_EXTERNAL_LIB_RETURN
OUTPUT_VARIABLE petsc_external_lib
OUTPUT_STRIP_TRAILING_WHITESPACE)
# PETSc specified compiler
# PETSc specified fortran compiler
execute_process(COMMAND ${MAKE_EXECUTABLE} --no-print-directory -f ${petsc_config_makefile} "compilerf"
RESULT_VARIABLE MPIFC_RETURN
OUTPUT_VARIABLE MPIFC
RESULT_VARIABLE PETSC_MPIFC_RETURN
OUTPUT_VARIABLE PETSC_MPIFC
OUTPUT_STRIP_TRAILING_WHITESPACE)
# PETSc specified C compiler
execute_process(COMMAND ${MAKE_EXECUTABLE} --no-print-directory -f ${petsc_config_makefile} "compilerc"
RESULT_VARIABLE PETSC_MPICC_RETURN
OUTPUT_VARIABLE PETSC_MPICC
OUTPUT_STRIP_TRAILING_WHITESPACE)
# PETSc specified linker (MPIF90 + PETSc linking flags)
execute_process(COMMAND ${MAKE_EXECUTABLE} --no-print-directory -f ${petsc_config_makefile} "linker"
@ -85,51 +91,37 @@ foreach (exlib ${TMP_LIST})
set(PETSC_EXTERNAL_LIB "${PETSC_EXTERNAL_LIB} ${exlib}")
endforeach(exlib)
set(CMAKE_Fortran_COMPILER "${MPIFC}")
# DAMASK DRIVER SELECTION
if ("${DAMASK_DRIVER}" STREQUAL "SPECTRAL")
project(DAMASK_spectral Fortran)
add_definitions(-DSpectral)
message("***Configuring Spectral Solver\n")
elseif ("${DAMASK_DRIVER}" STREQUAL "FEM")
project(DAMASK_FEM Fortran)
add_definitions(-DFEM)
message("***Configuring FEM Solver\n")
endif()
# Find DAMASK version (DAMASK_V) in DAMASK_ROOT
find_program (CAT_EXECUTABLE NAMES cat)
execute_process(COMMAND ${CAT_EXECUTABLE} ${PROJECT_SOURCE_DIR}/VERSION
RESULT_VARIABLE DAMASK_VERSION_RETURN
OUTPUT_VARIABLE DAMASK_V
OUTPUT_STRIP_TRAILING_WHITESPACE)
# https://cmake.org/Wiki/CMake_FAQ#How_do_I_use_a_different_compiler.3F
set(CMAKE_Fortran_COMPILER "${PETSC_MPIFC}")
set(CMAKE_C_COMPILER "${PETSC_MPICC}")
set(CMAKE_LINKER "${PETSC_LINKER}")
message("***Found PETSC_DIR:\n${PETSC_DIR}\n" )
message("***Found PETSC_INCLUDES:\n${PETSC_INCLUDES}\n" )
message("***Found PETSC_EXTERNAL_LIB:\n${PETSC_EXTERNAL_LIB}\n")
message("***Found PETSC_LINKER:\n${PETSC_LINKER}\n" )
message("***Found FORTRAN MPI COMPILER:\n${MPIFC}\n" )
message("***Found MPI FORTRAN COMPILER:\n${PETSC_MPIFC}\n" )
message("***Found MPI C COMPILER:\n${PETSC_MPICC}\n" )
# # https://cmake.org/Wiki/CMake_FAQ#How_do_I_use_a_different_compiler.3F
#---------------------------------------------------------------------------------------
# Now start to care about DAMASK
# DAMASK Solver selection
if ("${DAMASK_DRIVER}" STREQUAL "SPECTRAL")
project(DAMASK_spectral Fortran C)
add_definitions(-DSpectral)
message("***Configuring Spectral Solver\n")
elseif ("${DAMASK_DRIVER}" STREQUAL "FEM")
project(DAMASK_FEM Fortran C)
add_definitions(-DFEM)
message("***Configuring FEM Solver\n")
endif()
# Built-in options for DAMASK build system
# -> can be overwritten from commandline/install_script
option(OPENMP "Use OpenMP libaries for DAMASK" ON )
option(OPTIMIZATION "DAMASK optimization level [OFF,DEFENSIVE,AGGRESSIVE]" "DEFENSIVE" )
if (NOT DEFINED CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Release)
endif(NOT DEFINED CMAKE_BUILD_TYPE)
# COMPILE VARIABLES
add_definitions(-DDAMASKVERSION="${DAMASK_V}")
add_definitions(-DPETSc)
add_definitions(-DFLOAT=8)
add_definitions(-DINT=4)
# Setting installation prefix
if (DEFINED DAMASK_INSTALL)
set (CMAKE_INSTALL_PREFIX "${DAMASK_INSTALL}")
@ -138,6 +130,23 @@ else(DEFINED DAMASK_INSTALL)
endif(DEFINED DAMASK_INSTALL)
message("\n***The binary will be installed at\n${CMAKE_INSTALL_PREFIX}\n")
# Set build options
if (NOT DEFINED CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Release)
endif(NOT DEFINED CMAKE_BUILD_TYPE)
# Find DAMASK version (DAMASK_V) in DAMASK_ROOT
find_program (CAT_EXECUTABLE NAMES cat)
execute_process(COMMAND ${CAT_EXECUTABLE} ${PROJECT_SOURCE_DIR}/VERSION
RESULT_VARIABLE DAMASK_VERSION_RETURN
OUTPUT_VARIABLE DAMASK_V
OUTPUT_STRIP_TRAILING_WHITESPACE)
add_definitions(-DDAMASKVERSION="${DAMASK_V}")
# definition of other macros
add_definitions(-DPETSc)
add_definitions(-DFLOAT=8)
add_definitions(-DINT=4)
set (DAMASK_INCLUDE_FLAGS "${DAMASK_INCLUDE_FLAGS} ${PETSC_INCLUDES}" )
set (DAMASK_INCLUDE_FLAGS "${DAMASK_INCLUDE_FLAGS} -I${PROJECT_SOURCE_DIR}/lib")
@ -164,8 +173,6 @@ if(${CMAKE_Fortran_COMPILER_ID} STREQUAL "Intel")
#------------------------------------------------------------------------------------------------
# COMPILE SWITCHES
# -fpp: preprocessor
# -ftz: flush unterflow to zero, automatically set if O<0,1,2,3> >0
# -assume byterecl record length is given in bytes (also set by -standard-semantics)
# fpe_summary print list of floating point exceptions occured during execution
# -fimplicit-none: assume "implicit-none" even if not present in source
@ -181,14 +188,9 @@ if(${CMAKE_Fortran_COMPILER_ID} STREQUAL "Intel")
# unused: declared variables that are never used
# stderrors: warnings about Fortran standard violations are changed to errors (STANDARD_CHECK)
#
# MORE OPTIONS FOR DEBUGGING DURING COMPILATION
# -warn: enables warnings, where
# truncated_source: Determines whether warnings occur when source exceeds the maximum column width in fixed-format files. (too many warnings because we have comments beyond character 132)
# uncalled: Determines whether warnings occur when a statement function is never called
# all:
# -name as_is: case sensitive Fortran!
set (COMPILE_FLAGS "${COMPILE_FLAGS} -fpp" )
set (COMPILE_FLAGS "${COMPILE_FLAGS} -ftz" )
set (COMPILE_FLAGS "${COMPILE_FLAGS} -fpp" )# preprocessor
set (COMPILE_FLAGS "${COMPILE_FLAGS} -ftz" )# flush unterflow to zero, automatically set if O<0,1,2,3> >0
set (COMPILE_FLAGS "${COMPILE_FLAGS} -assume byterecl,fpe_summary")
set (COMPILE_FLAGS "${COMPILE_FLAGS} -diag-disable 5268" )
set (COMPILE_FLAGS "${COMPILE_FLAGS} -warn declarations" )
@ -198,42 +200,37 @@ if(${CMAKE_Fortran_COMPILER_ID} STREQUAL "Intel")
set (COMPILE_FLAGS "${COMPILE_FLAGS} -warn ignore_loc" )
set (COMPILE_FLAGS "${COMPILE_FLAGS} -warn alignments" )
set (COMPILE_FLAGS "${COMPILE_FLAGS} -warn unused" )
# MORE OPTIONS FOR DEBUGGING DURING COMPILATION
# -warn: enables warnings, where
# truncated_source: Determines whether warnings occur when source exceeds the maximum column width in fixed-format files. (too many warnings because we have comments beyond character 132)
# uncalled: Determines whether warnings occur when a statement function is never called
# all:
# -name as_is: case sensitive Fortran!
#------------------------------------------------------------------------------------------------
# COMPILE SWITCHES FOR RUNTIME DEBUGGING
# -g: Generate symbolic debugging information in the object file
# -traceback: Generate extra information in the object file to provide source file traceback information when a severe error occurs at run time.
# -gen-interfaces: Generate an interface block for each routine. http://software.intel.com/en-us/blogs/2012/01/05/doctor-fortran-gets-explicit-again/
# -fp-stack-check: Generate extra code after every function call to ensure that the floating-point (FP) stack is in the expected state.
# -ftrapuv Trap uninitalized variables
# -check: checks at runtime, where
# bounds: check if an array index is too small (<1) or too large!
# format: Checking for the data type of an item being formatted for output.
# output_conversion: Checking for the fit of data items within a designated format descriptor field.
# pointers: Checking for certain disassociated or uninitialized pointers or unallocated allocatable objects.
# uninit: Checking for uninitialized variables.
# -fpe-all0 capture all floating-point exceptions, sets -ftz automatically
# -warn: enables warnings, where
# errors: warnings are changed to errors
# stderrors: warnings about Fortran standard violations are changed to errors
# information on http://software.intel.com/en-us/articles/determining-root-cause-of-sigsegv-or-sigbus-errors/
#
set (DEBUG_FLAGS "${DEBUG_FLAGS} -g" )# Generate symbolic debugging information in the object file
set (DEBUG_FLAGS "${DEBUG_FLAGS} -traceback" )# Generate extra information in the object file to provide source file traceback information when a severe error occurs at run time.
set (DEBUG_FLAGS "${DEBUG_FLAGS} -gen-interfaces" )# Generate an interface block for each routine. http://software.intel.com/en-us/blogs/2012/01/05/doctor-fortran-gets-explicit-again/
set (DEBUG_FLAGS "${DEBUG_FLAGS} -fp-stack-check" )# Generate extra code after every function call to ensure that the floating-point (FP) stack is in the expected state.
set (DEBUG_FLAGS "${DEBUG_FLAGS} -fp-model strict" )# Trap uninitalized variables
set (DEBUG_FLAGS "${DEBUG_FLAGS} -check bounds,format,output_conversion,pointers,uninit" )# Checks at runtime, where
# bounds: if an array index is too small (<1) or too large!
# format: for the data type of an item being formatted for output.
# output_conversion: for the fit of data items within a designated format descriptor field.
# pointers: for certain disassociated or uninitialized pointers or unallocated allocatable objects.
# uninit: for uninitialized variables.
set (DEBUG_FLAGS "${DEBUG_FLAGS} -ftrapuv" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -fpe-all0" )# Capture all floating-point exceptions, sets -ftz automatically
set (DEBUG_FLAGS "${DEBUG_FLAGS} -warn errors,stderrors" )# Configures warnings, where
# errors: warnings are changed to errors
# stderrors: warnings about Fortran standard violations are changed to errors
set (DEBUG_FLAGS "${DEBUG_FLAGS} -debug-parameters all" )
# MORE OPTIONS FOR RUNTIME DEBUGGING
# -heap-arrays: should not be done for OpenMP, but set "ulimit -s unlimited" on shell. Probably it helps also to unlimit other limits
# -check: checks at runtime, where
# -heap-arrays: Should not be done for OpenMP, but set "ulimit -s unlimited" on shell. Probably it helps also to unlimit other limits
# -check: Checks at runtime, where
# arg_temp_created: will cause a lot of warnings because we create a bunch of temporary arrays (performance?)
# stack:
set (DEBUG_FLAGS "${DEBUG_FLAGS} -g" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -traceback" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -gen-interfaces" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -fp-stack-check" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -fp-model strict" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -check bounds,format,output_conversion,pointers,uninit" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -ftrapuv" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -fpe-all0" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -warn errors" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -warn stderrors" )
set (DEBUG_FLAGS "${DEBUG_FLAGS} -debug-parameters all" )
#------------------------------------------------------------------------------------------------
# PRECISION SETTINGS
@ -384,12 +381,12 @@ elseif(${CMAKE_Fortran_COMPILER_ID} STREQUAL "GNU")
endif()
set (CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} ${OPENMP_FLAGS}")
set (CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} ${STANDARD_CHECK}")
set (CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} ${OPTIMIZATION_FLAGS}")
set (CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} ${COMPILE_FLAGS}")
set (CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} ${PRECISION_FLAGS}")
set (CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${OPENMP_FLAGS}" )
set (CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${STANDARD_CHECK}")
set (CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${OPTIMIZATION_FLAGS}" )
@ -400,7 +397,7 @@ set (CMAKE_Fortran_FLAGS_DEBUG "${CMAKE_Fortran_FLAGS_DEBUG} ${DEBUG_FLAGS
set (CMAKE_Fortran_FLAGS_RELEASE "${BUILDCMD_PRE} ${CMAKE_Fortran_FLAGS_RELEASE} ${DAMASK_INCLUDE_FLAGS} ${BUILDCMD_POST}")
set (CMAKE_Fortran_FLAGS_DEBUG "${BUILDCMD_PRE} ${CMAKE_Fortran_FLAGS_DEBUG} ${DAMASK_INCLUDE_FLAGS} ${BUILDCMD_POST}")
set (CMAKE_LINKER "${PETSC_LINKER}")
if ("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
set (CMAKE_Fortran_LINK_EXECUTABLE
@ -417,11 +414,10 @@ message("***LINKER:\n${CMAKE_Fortran_LINK_EXECUTABLE}\n")
add_subdirectory(src)
# INSTALL BUILT BINARIES
if (SPECTRAL)
if ("${PROJECT_NAME}" STREQUAL "DAMASK_spectral")
INSTALL(PROGRAMS ${PROJECT_BINARY_DIR}/src/DAMASK_spectral
DESTINATION ${CMAKE_INSTALL_PREFIX})
elseif (FEM)
elseif ("${PROJECT_NAME}" STREQUAL "DAMASK_FEM")
INSTALL(PROGRAMS ${PROJECT_BINARY_DIR}/src/DAMASK_FEM
DESTINATION ${CMAKE_INSTALL_PREFIX})
endif(SPECTRAL)
endif("${PROJECT_NAME}" STREQUAL "DAMASK_spectral")

View File

@ -10,7 +10,7 @@ spectral: build/spectral
build/spectral: build
@mkdir build/spectral
@(cd build/spectral; cmake -Wno-dev -DCMAKE_BUILD_TYPE=RELEASE -DDAMASK_DRIVER=SPECTRAL ../..;)
@(cd build/spectral; cmake -Wno-dev -DDAMASK_DRIVER=SPECTRAL ../..;)
build: bin
@mkdir build
@ -23,7 +23,7 @@ FEM: build/FEM
build/FEM: build
@mkdir build
@(cd build/FEM; cmake -Wno-dev -DCMAKE_BUILD_TYPE=RELEASE -DDAMASK_DRIVER=FEM ../..;)
@(cd build/FEM; cmake -Wno-dev -DDAMASK_DRIVER=FEM ../..;)
.PHONY: clean
clean:

View File

@ -1,13 +1,5 @@
# The dependency detection in CMake is not functioning for Fortran
# !!! EXPLICIT DEPENDENCY DECLARATION !!!
# SOME FILES REQUIRE SPECIAL FLAGS
if (${CMAKE_Fortran_COMPILER_ID} STREQUAL "Intel")
# -diag-disable 7410 should disable warning about directory statement
# in inquire function, but does not work. hence the other 2 statements
SET_SOURCE_FILES_PROPERTIES( "spectral_interface.f90" PROPERTIES
COMPILE_FLAGS "-diag-remark 7410 -stand none -warn nostderrors" )
elseif (${CMAKE_Fortran_COMPILER_ID} STREQUAL "GNU")
if (${CMAKE_Fortran_COMPILER_ID} STREQUAL "GNU")
# fno-range-check: Disable range checking on results of simplification of constant expressions during compilation
# --> allows the definition of DAMASK_NaN
#-fall-intrinsics: all intrinsic procedures (including the GNU-specific extensions) are accepted. -Wintrinsics-std will be ignored
@ -17,65 +9,69 @@ elseif (${CMAKE_Fortran_COMPILER_ID} STREQUAL "GNU")
# --> otherwise, when setting -ffast-math, isnan always evaluates to false (I would call it a bug)
SET_SOURCE_FILES_PROPERTIES( "prec.f90" PROPERTIES
COMPILE_FLAGS "-fno-range-check -fall-intrinsics -fno-fast-math")
#-fall-intrinsics: all intrinsic procedures (including the GNU-specific extensions) are accepted. -Wintrinsics-std will be ignored
# and no user-defined procedure with the same name as any intrinsic will be called except when it is explicitly declared external
# --> allows the use of 'getcwd'
SET_SOURCE_FILES_PROPERTIES( "spectral_interface.f90" PROPERTIES
COMPILE_FLAGS "-fall-intrinsics")
# long lines for interaction matrix
SET_SOURCE_FILES_PROPERTIES( "lattice.f90" PROPERTIES
COMPILE_FLAGS "-ffree-line-length-240")
endif()
add_library(DAMASK_PREC "prec.f90")
# The dependency detection in CMake is not functioning for Fortran,
# hence we declare the dependencies from top to bottom in the following
add_library(C_ROUTINES "C_routines.c")
add_library(SYSTEM_ROUTINES "system_routines.f90")
target_link_libraries(SYSTEM_ROUTINES C_ROUTINES)
add_library(PREC "prec.f90")
target_link_libraries(PREC SYSTEM_ROUTINES)
if ("${PROJECT_NAME}" STREQUAL "DAMASK_spectral")
add_library(DAMASK_INTERFACE "spectral_interface.f90")
elseif ("${PROJECT_NAME}" STREQUAL "DAMASK_FEM")
add_library(DAMASK_INTERFACE "DAMASK_FEM_interface.f90")
endif()
target_link_libraries(DAMASK_INTERFACE DAMASK_PREC)
target_link_libraries(DAMASK_INTERFACE PREC)
add_library(DAMASK_IO "IO.f90")
target_link_libraries(DAMASK_IO DAMASK_INTERFACE)
add_library(IO "IO.f90")
target_link_libraries(IO DAMASK_INTERFACE)
add_library(DAMASK_LIBS "libs.f90")
target_link_libraries(DAMASK_LIBS DAMASK_IO)
add_library(EXTERNALLIBS "libs.f90")
target_link_libraries(EXTERNALLIBS IO)
add_library(DAMASK_NUMERICS "numerics.f90")
target_link_libraries(DAMASK_NUMERICS DAMASK_LIBS)
add_library(NUMERICS "numerics.f90")
target_link_libraries(NUMERICS EXTERNALLIBS)
add_library(DAMASK_DEBUG "debug.f90")
target_link_libraries(DAMASK_DEBUG DAMASK_NUMERICS)
add_library(DEBUG "debug.f90")
target_link_libraries(DEBUG NUMERICS)
add_library(DAMASK_FEsolving "FEsolving.f90")
target_link_libraries(DAMASK_FEsolving DAMASK_DEBUG)
add_library(FEsolving "FEsolving.f90")
target_link_libraries(FEsolving DEBUG)
add_library(DAMASK_MATH "math.f90")
target_link_libraries(DAMASK_MATH DAMASK_FEsolving)
target_link_libraries(DAMASK_MATH FEsolving)
# SPECTRAL solver and FEM solver use different mesh
# source files
if ("${PROJECT_NAME}" STREQUAL "DAMASK_spectral")
add_library(DAMASK_MESH "mesh.f90")
target_link_libraries(DAMASK_MESH DAMASK_MATH)
add_library(MESH "mesh.f90")
target_link_libraries(MESH DAMASK_MATH)
elseif ("${PROJECT_NAME}" STREQUAL "DAMASK_FEM")
add_library(DAMASK_FEZoo "FEZoo.f90")
target_link_libraries(DAMASK_FEZoo DAMASK_MATH)
add_library(DAMASK_MESH "meshFEM.f90")
target_link_libraries(DAMASK_MESH DAMASK_FEZoo)
add_library(FEZoo "FEZoo.f90")
target_link_libraries(FEZoo DAMASK_MATH)
add_library(MESH "meshFEM.f90")
target_link_libraries(MESH FEZoo)
endif()
add_library(MATERIAL "material.f90")
target_link_libraries(MATERIAL MESH)
add_library(DAMASK_MATERIAL "material.f90")
target_link_libraries(DAMASK_MATERIAL DAMASK_MESH)
add_library(DAMASK_LATTICE "lattice.f90")
target_link_libraries(DAMASK_LATTICE DAMASK_MATERIAL)
add_library(DAMASK_DRIVERS ALIAS DAMASK_LATTICE)
add_library(LATTICE "lattice.f90")
target_link_libraries(LATTICE MATERIAL)
add_library(DAMASK_HELPERS ALIAS LATTICE)
# For each modular section
add_library (DAMASK_PLASTIC "plastic_dislotwin.f90"
add_library (PLASTIC
"plastic_dislotwin.f90"
"plastic_disloUCLA.f90"
"plastic_isotropic.f90"
"plastic_phenopowerlaw.f90"
@ -83,16 +79,18 @@ add_library (DAMASK_PLASTIC "plastic_dislotwin.f90"
"plastic_nonlocal.f90"
"plastic_none.f90"
"plastic_phenoplus.f90")
target_link_libraries(DAMASK_PLASTIC DAMASK_DRIVERS)
target_link_libraries(PLASTIC DAMASK_HELPERS)
add_library (DAMASK_KINEMATICS "kinematics_cleavage_opening.f90"
add_library (KINEMATICS
"kinematics_cleavage_opening.f90"
"kinematics_slipplane_opening.f90"
"kinematics_thermal_expansion.f90"
"kinematics_vacancy_strain.f90"
"kinematics_hydrogen_strain.f90")
target_link_libraries(DAMASK_KINEMATICS DAMASK_DRIVERS)
target_link_libraries(KINEMATICS DAMASK_HELPERS)
add_library (DAMASK_SOURCE "source_thermal_dissipation.f90"
add_library (SOURCE
"source_thermal_dissipation.f90"
"source_thermal_externalheat.f90"
"source_damage_isoBrittle.f90"
"source_damage_isoDuctile.f90"
@ -101,54 +99,75 @@ add_library (DAMASK_SOURCE "source_thermal_dissipation.f90"
"source_vacancy_phenoplasticity.f90"
"source_vacancy_irradiation.f90"
"source_vacancy_thermalfluc.f90")
target_link_libraries(DAMASK_SOURCE DAMASK_DRIVERS)
target_link_libraries(SOURCE DAMASK_HELPERS)
add_library(DAMASK_CONSTITUTIVE "constitutive.f90")
target_link_libraries(DAMASK_CONSTITUTIVE DAMASK_PLASTIC )
target_link_libraries(DAMASK_CONSTITUTIVE DAMASK_KINEMATICS)
target_link_libraries(DAMASK_CONSTITUTIVE DAMASK_SOURCE )
add_library(CONSTITUTIVE "constitutive.f90")
target_link_libraries(CONSTITUTIVE PLASTIC)
target_link_libraries(CONSTITUTIVE KINEMATICS)
target_link_libraries(CONSTITUTIVE SOURCE)
add_library(DAMASK_CRYSTALLITE "crystallite.f90")
target_link_libraries(DAMASK_CRYSTALLITE DAMASK_CONSTITUTIVE)
add_library(CRYSTALLITE "crystallite.f90")
target_link_libraries(CRYSTALLITE CONSTITUTIVE)
add_library(DAMASK_HOMOGENIZATION "homogenization_RGC.f90"
add_library(HOMOGENIZATION
"homogenization_RGC.f90"
"homogenization_isostrain.f90"
"homogenization_none.f90")
target_link_libraries(DAMASK_HOMOGENIZATION DAMASK_CRYSTALLITE)
target_link_libraries(HOMOGENIZATION CRYSTALLITE)
add_library(DAMASK_HYDROGENFLUX "hydrogenflux_isoconc.f90"
add_library(HYDROGENFLUX
"hydrogenflux_isoconc.f90"
"hydrogenflux_cahnhilliard.f90")
target_link_libraries(DAMASK_HYDROGENFLUX DAMASK_CRYSTALLITE)
target_link_libraries(HYDROGENFLUX CRYSTALLITE)
add_library(DAMASK_POROSITY "porosity_none.f90"
add_library(POROSITY
"porosity_none.f90"
"porosity_phasefield.f90")
target_link_libraries(DAMASK_POROSITY DAMASK_CRYSTALLITE)
target_link_libraries(POROSITY CRYSTALLITE)
add_library(DAMASK_VACANCYFLUX "vacancyflux_isoconc.f90"
add_library(VACANCYFLUX
"vacancyflux_isoconc.f90"
"vacancyflux_isochempot.f90"
"vacancyflux_cahnhilliard.f90")
target_link_libraries(DAMASK_VACANCYFLUX DAMASK_CRYSTALLITE)
target_link_libraries(VACANCYFLUX CRYSTALLITE)
add_library(DAMASK_DAMAGE "damage_none.f90"
add_library(DAMAGE
"damage_none.f90"
"damage_local.f90"
"damage_nonlocal.f90")
target_link_libraries(DAMASK_DAMAGE DAMASK_CRYSTALLITE)
target_link_libraries(DAMAGE CRYSTALLITE)
add_library(DAMASK_THERMAL "thermal_isothermal.f90"
add_library(THERMAL
"thermal_isothermal.f90"
"thermal_adiabatic.f90"
"thermal_conduction.f90")
target_link_libraries(DAMASK_THERMAL DAMASK_CRYSTALLITE)
target_link_libraries(THERMAL CRYSTALLITE)
add_library(DAMASK_ENGINE "homogenization.f90")
target_link_libraries(DAMASK_ENGINE DAMASK_THERMAL )
target_link_libraries(DAMASK_ENGINE DAMASK_DAMAGE )
target_link_libraries(DAMASK_ENGINE DAMASK_VACANCYFLUX )
target_link_libraries(DAMASK_ENGINE DAMASK_POROSITY )
target_link_libraries(DAMASK_ENGINE DAMASK_HYDROGENFLUX )
target_link_libraries(DAMASK_ENGINE DAMASK_HOMOGENIZATION)
target_link_libraries(DAMASK_ENGINE THERMAL )
target_link_libraries(DAMASK_ENGINE DAMAGE )
target_link_libraries(DAMASK_ENGINE VACANCYFLUX )
target_link_libraries(DAMASK_ENGINE POROSITY )
target_link_libraries(DAMASK_ENGINE HYDROGENFLUX )
target_link_libraries(DAMASK_ENGINE HOMOGENIZATION)
if (FEM)
if ("${PROJECT_NAME}" STREQUAL "DAMASK_spectral")
add_library(DAMASK_CPFE "CPFEM2.f90")
target_link_libraries(DAMASK_CPFE DAMASK_ENGINE)
add_library(SPECTRAL_UTILITIES spectral_utilities.f90)
target_link_libraries(SPECTRAL_UTILITIES DAMASK_CPFE)
add_library(SPECTRAL_SOLVER "spectral_thermal.f90"
"spectral_damage.f90"
"spectral_mech_AL.f90"
"spectral_mech_Polarisation.f90"
"spectral_mech_Basic.f90")
target_link_libraries(SPECTRAL_SOLVER SPECTRAL_UTILITIES)
add_executable(DAMASK_spectral "DAMASK_spectral.f90")
target_link_libraries(DAMASK_spectral SPECTRAL_SOLVER)
elseif ("${PROJECT_NAME}" STREQUAL "DAMASK_FEM")
add_library(DAMASK_CPFE "CPFEM.f90")
target_link_libraries(DAMASK_CPFE DAMASK_ENGINE)
@ -167,30 +186,5 @@ if (FEM)
target_link_libraries(DAMASK_FEM_DRIVER DAMASK_FEM_BASE)
add_executable(DAMASK_FEM "DAMASK_FEM_driver.f90")
target_link_libraries(DAMASK_FEM DAMASK_FEM_DRIVER)
endif(FEM)
if (SPECTRAL)
add_library(DAMASK_CPFE "CPFEM2.f90")
target_link_libraries(DAMASK_CPFE DAMASK_ENGINE)
add_library(DAMASK_SPECTRAL_UTILITY spectral_utilities.f90)
target_link_libraries(DAMASK_SPECTRAL_UTILITY DAMASK_CPFE)
add_library(DAMASK_SPECTRAL_BASE "spectral_thermal.f90"
"spectral_damage.f90")
target_link_libraries(DAMASK_SPECTRAL_BASE DAMASK_SPECTRAL_UTILITY)
add_library(DAMASK_SPECTRAL_MECH "spectral_mech_AL.f90"
"spectral_mech_Polarisation.f90"
"spectral_mech_Basic.f90")
target_link_libraries(DAMASK_SPECTRAL_MECH DAMASK_SPECTRAL_UTILITY)
add_library(DAMASK_EXE "DAMASK_spectral.f90")
target_link_libraries(DAMASK_EXE DAMASK_CPFE )
target_link_libraries(DAMASK_EXE DAMASK_SPECTRAL_BASE)
target_link_libraries(DAMASK_EXE DAMASK_SPECTRAL_MECH)
add_executable(DAMASK_spectral "DAMASK_spectral.f90")
target_link_libraries(DAMASK_spectral DAMASK_EXE)
endif(SPECTRAL)
target_link_libraries(DAMASK_FEM DAMASK_FEM_EXE)
endif()