From e3d8d48990873a8964aeb8f2ed278488ed09f74d Mon Sep 17 00:00:00 2001 From: Martin Diehl Date: Sat, 21 May 2016 15:06:01 +0200 Subject: [PATCH] currently, only BUILD_CMD_TYPE release works --- CMakeLists.txt | 160 ++++++++++++++--------------- Makefile | 4 +- src/CMakeLists.txt | 246 ++++++++++++++++++++++----------------------- 3 files changed, 200 insertions(+), 210 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 75b11ede9..ff6992b8d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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") diff --git a/Makefile b/Makefile index e9c242748..4d2d9bf74 100644 --- a/Makefile +++ b/Makefile @@ -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: diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b2fc87418..8b4ee59f3 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -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,138 +9,165 @@ 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" - "plastic_disloUCLA.f90" - "plastic_isotropic.f90" - "plastic_phenopowerlaw.f90" - "plastic_titanmod.f90" - "plastic_nonlocal.f90" - "plastic_none.f90" - "plastic_phenoplus.f90") -target_link_libraries(DAMASK_PLASTIC DAMASK_DRIVERS) +add_library (PLASTIC + "plastic_dislotwin.f90" + "plastic_disloUCLA.f90" + "plastic_isotropic.f90" + "plastic_phenopowerlaw.f90" + "plastic_titanmod.f90" + "plastic_nonlocal.f90" + "plastic_none.f90" + "plastic_phenoplus.f90") +target_link_libraries(PLASTIC DAMASK_HELPERS) -add_library (DAMASK_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) +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(KINEMATICS DAMASK_HELPERS) -add_library (DAMASK_SOURCE "source_thermal_dissipation.f90" - "source_thermal_externalheat.f90" - "source_damage_isoBrittle.f90" - "source_damage_isoDuctile.f90" - "source_damage_anisoBrittle.f90" - "source_damage_anisoDuctile.f90" - "source_vacancy_phenoplasticity.f90" - "source_vacancy_irradiation.f90" - "source_vacancy_thermalfluc.f90") -target_link_libraries(DAMASK_SOURCE DAMASK_DRIVERS) +add_library (SOURCE + "source_thermal_dissipation.f90" + "source_thermal_externalheat.f90" + "source_damage_isoBrittle.f90" + "source_damage_isoDuctile.f90" + "source_damage_anisoBrittle.f90" + "source_damage_anisoDuctile.f90" + "source_vacancy_phenoplasticity.f90" + "source_vacancy_irradiation.f90" + "source_vacancy_thermalfluc.f90") +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" - "homogenization_isostrain.f90" - "homogenization_none.f90") -target_link_libraries(DAMASK_HOMOGENIZATION DAMASK_CRYSTALLITE) +add_library(HOMOGENIZATION + "homogenization_RGC.f90" + "homogenization_isostrain.f90" + "homogenization_none.f90") +target_link_libraries(HOMOGENIZATION CRYSTALLITE) -add_library(DAMASK_HYDROGENFLUX "hydrogenflux_isoconc.f90" - "hydrogenflux_cahnhilliard.f90") -target_link_libraries(DAMASK_HYDROGENFLUX DAMASK_CRYSTALLITE) +add_library(HYDROGENFLUX + "hydrogenflux_isoconc.f90" + "hydrogenflux_cahnhilliard.f90") +target_link_libraries(HYDROGENFLUX CRYSTALLITE) -add_library(DAMASK_POROSITY "porosity_none.f90" - "porosity_phasefield.f90") -target_link_libraries(DAMASK_POROSITY DAMASK_CRYSTALLITE) +add_library(POROSITY + "porosity_none.f90" + "porosity_phasefield.f90") +target_link_libraries(POROSITY CRYSTALLITE) -add_library(DAMASK_VACANCYFLUX "vacancyflux_isoconc.f90" - "vacancyflux_isochempot.f90" - "vacancyflux_cahnhilliard.f90") -target_link_libraries(DAMASK_VACANCYFLUX DAMASK_CRYSTALLITE) +add_library(VACANCYFLUX + "vacancyflux_isoconc.f90" + "vacancyflux_isochempot.f90" + "vacancyflux_cahnhilliard.f90") +target_link_libraries(VACANCYFLUX CRYSTALLITE) -add_library(DAMASK_DAMAGE "damage_none.f90" - "damage_local.f90" - "damage_nonlocal.f90") -target_link_libraries(DAMASK_DAMAGE DAMASK_CRYSTALLITE) +add_library(DAMAGE + "damage_none.f90" + "damage_local.f90" + "damage_nonlocal.f90") +target_link_libraries(DAMAGE CRYSTALLITE) -add_library(DAMASK_THERMAL "thermal_isothermal.f90" - "thermal_adiabatic.f90" - "thermal_conduction.f90") -target_link_libraries(DAMASK_THERMAL DAMASK_CRYSTALLITE) +add_library(THERMAL + "thermal_isothermal.f90" + "thermal_adiabatic.f90" + "thermal_conduction.f90") +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()