From 21c56dcc9b9b1b4ef60c916aab055a5c2cc11fda Mon Sep 17 00:00:00 2001 From: wolf Date: Thu, 3 Feb 2000 14:03:24 +0000 Subject: [PATCH] Switch to new small-project Makefile. git-svn-id: https://svn.dealii.org/trunk@2336 0785d39b-7218-0410-832d-ea1e28bc413d --- .../Attic/examples/convergence/Makefile | 196 ++++++++++------- deal.II/deal.II/Attic/examples/dof/Makefile | 200 ++++++++++------- .../Attic/examples/error-estimation/Makefile | 203 ++++++++++------- deal.II/deal.II/Attic/examples/grid/Makefile | 206 +++++++++++------- .../deal.II/Attic/examples/multigrid/Makefile | 197 ++++++++++------- tests/big-tests/convergence/Makefile | 196 ++++++++++------- tests/big-tests/dof/Makefile | 200 ++++++++++------- tests/big-tests/error-estimation/Makefile | 203 ++++++++++------- tests/big-tests/grid/Makefile | 206 +++++++++++------- tests/big-tests/multigrid/Makefile | 197 ++++++++++------- 10 files changed, 1196 insertions(+), 808 deletions(-) diff --git a/deal.II/deal.II/Attic/examples/convergence/Makefile b/deal.II/deal.II/Attic/examples/convergence/Makefile index c0815b3799..3b00259d3f 100644 --- a/deal.II/deal.II/Attic/examples/convergence/Makefile +++ b/deal.II/deal.II/Attic/examples/convergence/Makefile @@ -1,73 +1,83 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = convergence -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = - -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = gnuplot make_ps -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = *gnuplot *.eps *ucd *history +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ +libs.o = $(lib-deal2-2d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) -endif - -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS.o) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif @@ -79,55 +89,81 @@ endif -# make rule for the target +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $^ $(user-libs) + @$(CXX) $(flags) -o $@ $^ -# rule how to run the program + +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + @./$(target) + gnuplot make_ps + + +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) -# rule to make object files +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/deal.II/deal.II/Attic/examples/dof/Makefile b/deal.II/deal.II/Attic/examples/dof/Makefile index 3f7be46d14..ee93d64e40 100644 --- a/deal.II/deal.II/Attic/examples/dof/Makefile +++ b/deal.II/deal.II/Attic/examples/dof/Makefile @@ -1,77 +1,87 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = dof_test -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = 2 $(target).prm ; $(target) 3 $(target).prm - -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = gnuplot make_ps -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = results/?d.* +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ - $(lib-deal2-3d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ + $(lib-deal2-3d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ - $(lib-deal2-3d.o) \ +libs.o = $(lib-deal2-2d.o) \ + $(lib-deal2-3d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) -endif # If in multithread mode, add the ACE library to the libraries which # we need to link with: @@ -80,55 +90,83 @@ ifneq ($(with-multithreading),no) endif -# make rule for the target + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $(libraries) $(user-libs) + @$(CXX) $(flags) -o $@ $^ + -# rule how to run the program +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + ./$(target) 2 $(target).prm + ./$(target) 3 $(target).prm + gnuplot make_ps -# rule to make object files +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) + + +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/deal.II/deal.II/Attic/examples/error-estimation/Makefile b/deal.II/deal.II/Attic/examples/error-estimation/Makefile index 3744bd3dbd..96921c2ca1 100644 --- a/deal.II/deal.II/Attic/examples/error-estimation/Makefile +++ b/deal.II/deal.II/Attic/examples/error-estimation/Makefile @@ -1,79 +1,85 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = error-estimation -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = ee.gauss.prm - -# To execute additional action apart from running the program, fill -# in this list: -run-action=\ - $(target) ee.gauss.prm; \ - $(target) ee.singular.prm; \ - $(target) ee.kink.prm; \ - gnuplot make_ps; \ - perl -pi -e 's/^\#.*$$\\${}n//g' data-*/*.inp -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = data-*/* +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ +libs.o = $(lib-deal2-2d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not + +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) -endif # If in multithread mode, add the ACE library to the libraries which # we need to link with: @@ -82,52 +88,85 @@ ifneq ($(with-multithreading),no) endif -# make rule for the target + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $^ $(user-libs) + @$(CXX) $(flags) -o $@ $^ -run: $(target) - $(run-action) - -# rule to make object files -%.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ - @$(CXX) $(CXXFLAGS.g) -c $< -o $@ -%.o : %.cc - @echo ============================ Compiling with optimization: $< - @echo $(CXX) ... -c $< -o $@ - @$(CXX) $(CXXFLAGS) -c $< -o $@ +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: +run: $(target) + @echo ============================ Running $< + ./$(target) ee.gauss.prm + ./(target) ee.singular.prm; \ + ./$(target) ee.kink.prm; \ + gnuplot make_ps; \ -# rules which files the libraries depend upon -Obj.a: ./Obj.a($(o-files)) -Obj.g.a: ./Obj.g.a($(go-files)) +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. clean: - -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files) + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. +%.go : %.cc + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/deal.II/deal.II/Attic/examples/grid/Makefile b/deal.II/deal.II/Attic/examples/grid/Makefile index 9bd38ee827..455e443c64 100644 --- a/deal.II/deal.II/Attic/examples/grid/Makefile +++ b/deal.II/deal.II/Attic/examples/grid/Makefile @@ -1,77 +1,87 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = grid_test -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = 2 1 -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = grid_test 2 2 ; grid_test 2 3 ; grid_test 2 4 ; grid_test 3 1 ; grid_test 3 2 ; grid_test 3 3 ; grid_test 3 4 - -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = results/[123]d* +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ - $(lib-deal2-3d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ + $(lib-deal2-3d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ - $(lib-deal2-3d.o) \ +libs.o = $(lib-deal2-2d.o) \ + $(lib-deal2-3d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) -endif # If in multithread mode, add the ACE library to the libraries which # we need to link with: @@ -80,55 +90,89 @@ ifneq ($(with-multithreading),no) endif -# make rule for the target + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $(libraries) $(user-libs) + @$(CXX) $(flags) -o $@ $^ + -# rule how to run the program +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + ./$(target) 2 1 + ./$(target) 2 2 + ./$(target) 2 3 + ./$(target) 2 4 + ./$(target) 3 1 + ./$(target) 3 2 + ./$(target) 3 3 + ./$(target) 3 4 + + + +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) -# rule to make object files +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/deal.II/deal.II/Attic/examples/multigrid/Makefile b/deal.II/deal.II/Attic/examples/multigrid/Makefile index 6ed598d433..c0b78a5d49 100644 --- a/deal.II/deal.II/Attic/examples/multigrid/Makefile +++ b/deal.II/deal.II/Attic/examples/multigrid/Makefile @@ -1,74 +1,83 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = multigrid -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = - -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = gnuplot make_ps -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = *gnuplot *.eps *ucd *history +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ +libs.o = $(lib-deal2-2d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) -endif - -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif @@ -78,55 +87,83 @@ ifneq ($(with-multithreading),no) libraries += $(lib-ACE) endif -# make rule for the target + + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $^ $(user-libs) + @$(CXX) $(flags) -o $@ $^ -# rule how to run the program + +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + @./$(target) + gnuplot make_ps -# rule to make object files +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) + + +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/tests/big-tests/convergence/Makefile b/tests/big-tests/convergence/Makefile index c0815b3799..3b00259d3f 100644 --- a/tests/big-tests/convergence/Makefile +++ b/tests/big-tests/convergence/Makefile @@ -1,73 +1,83 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = convergence -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = - -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = gnuplot make_ps -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = *gnuplot *.eps *ucd *history +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ +libs.o = $(lib-deal2-2d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) -endif - -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS.o) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif @@ -79,55 +89,81 @@ endif -# make rule for the target +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $^ $(user-libs) + @$(CXX) $(flags) -o $@ $^ -# rule how to run the program + +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + @./$(target) + gnuplot make_ps + + +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) -# rule to make object files +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/tests/big-tests/dof/Makefile b/tests/big-tests/dof/Makefile index 3f7be46d14..ee93d64e40 100644 --- a/tests/big-tests/dof/Makefile +++ b/tests/big-tests/dof/Makefile @@ -1,77 +1,87 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = dof_test -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = 2 $(target).prm ; $(target) 3 $(target).prm - -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = gnuplot make_ps -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = results/?d.* +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ - $(lib-deal2-3d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ + $(lib-deal2-3d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ - $(lib-deal2-3d.o) \ +libs.o = $(lib-deal2-2d.o) \ + $(lib-deal2-3d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) -endif # If in multithread mode, add the ACE library to the libraries which # we need to link with: @@ -80,55 +90,83 @@ ifneq ($(with-multithreading),no) endif -# make rule for the target + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $(libraries) $(user-libs) + @$(CXX) $(flags) -o $@ $^ + -# rule how to run the program +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + ./$(target) 2 $(target).prm + ./$(target) 3 $(target).prm + gnuplot make_ps -# rule to make object files +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) + + +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/tests/big-tests/error-estimation/Makefile b/tests/big-tests/error-estimation/Makefile index 3744bd3dbd..96921c2ca1 100644 --- a/tests/big-tests/error-estimation/Makefile +++ b/tests/big-tests/error-estimation/Makefile @@ -1,79 +1,85 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = error-estimation -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = ee.gauss.prm - -# To execute additional action apart from running the program, fill -# in this list: -run-action=\ - $(target) ee.gauss.prm; \ - $(target) ee.singular.prm; \ - $(target) ee.kink.prm; \ - gnuplot make_ps; \ - perl -pi -e 's/^\#.*$$\\${}n//g' data-*/*.inp -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = data-*/* +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ +libs.o = $(lib-deal2-2d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not + +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) -endif # If in multithread mode, add the ACE library to the libraries which # we need to link with: @@ -82,52 +88,85 @@ ifneq ($(with-multithreading),no) endif -# make rule for the target + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $^ $(user-libs) + @$(CXX) $(flags) -o $@ $^ -run: $(target) - $(run-action) - -# rule to make object files -%.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ - @$(CXX) $(CXXFLAGS.g) -c $< -o $@ -%.o : %.cc - @echo ============================ Compiling with optimization: $< - @echo $(CXX) ... -c $< -o $@ - @$(CXX) $(CXXFLAGS) -c $< -o $@ +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: +run: $(target) + @echo ============================ Running $< + ./$(target) ee.gauss.prm + ./(target) ee.singular.prm; \ + ./$(target) ee.kink.prm; \ + gnuplot make_ps; \ -# rules which files the libraries depend upon -Obj.a: ./Obj.a($(o-files)) -Obj.g.a: ./Obj.g.a($(go-files)) +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. clean: - -rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files) + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. +%.go : %.cc + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/tests/big-tests/grid/Makefile b/tests/big-tests/grid/Makefile index 9bd38ee827..455e443c64 100644 --- a/tests/big-tests/grid/Makefile +++ b/tests/big-tests/grid/Makefile @@ -1,77 +1,87 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = grid_test -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = 2 1 -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = grid_test 2 2 ; grid_test 2 3 ; grid_test 2 4 ; grid_test 3 1 ; grid_test 3 2 ; grid_test 3 3 ; grid_test 3 4 - -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = results/[123]d* +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ - $(lib-deal2-3d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ + $(lib-deal2-3d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ - $(lib-deal2-3d.o) \ +libs.o = $(lib-deal2-2d.o) \ + $(lib-deal2-3d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) -endif # If in multithread mode, add the ACE library to the libraries which # we need to link with: @@ -80,55 +90,89 @@ ifneq ($(with-multithreading),no) endif -# make rule for the target + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $(libraries) $(user-libs) + @$(CXX) $(flags) -o $@ $^ + -# rule how to run the program +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + ./$(target) 2 1 + ./$(target) 2 2 + ./$(target) 2 3 + ./$(target) 2 4 + ./$(target) 3 1 + ./$(target) 3 2 + ./$(target) 3 3 + ./$(target) 3 4 + + + +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) -# rule to make object files +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + diff --git a/tests/big-tests/multigrid/Makefile b/tests/big-tests/multigrid/Makefile index 6ed598d433..c0b78a5d49 100644 --- a/tests/big-tests/multigrid/Makefile +++ b/tests/big-tests/multigrid/Makefile @@ -1,74 +1,83 @@ # $Id$ -# Copyright W. Bangerth, University of Heidelberg, 1998 +# Copyright W. Bangerth, University of Heidelberg, 1998, 1999, 2000 -# Template for makefiles for the examples subdirectory. In principle, -# everything should be done automatically if you set the target file -# here correctly: + +# For the small projects Makefile, you basically need to fill in only +# four fields. +# +# The first is the name of the application. It is assumed that the +# application name is the same as the base file name of the single C++ +# file from which the application is generated. target = multigrid -# All dependencies between files should be updated by the included -# file Makefile.dep if necessary. Object files are compiled into -# the archives ./Obj.a and ./Obj.g.a. By default, the debug version -# is used to link. It you don't like that, change the following -# variable to "off" +# The second field determines whether you want to run your program in +# debug or optimized mode. The latter is significantly faster, but no +# run-time checking of parameters and internal states is performed, so +# you should set this value to `on' while you develop your program, +# and to `off' when running production computations. debug-mode = on -# If you want your program to be linked with extra object or library -# files, specify them here: -user-libs = - -# To run the program, use "make run"; to give parameters to the program, -# give the parameters to the following variable: -run-parameters = - -# To execute additional action apart from running the program, fill -# in this list: -additional-run-action = gnuplot make_ps -# To specify which files are to be deleted by "make clean" (apart from -# the usual ones: object files, executables, backups, etc), fill in the -# following list -delete-files = *gnuplot *.eps *ucd *history +# As third field, we need to give the path to the top-level deal.II +# directory. You need to adjust this to your needs. Since this path is +# probably the most often needed one in the Makefile internals, it is +# designated by a single-character variable, since that can be +# reference using $D only, i.e. without the parentheses that are +# required for most other parameters, as e.g. in $(target). +D = ../../.. +# The last field specifies the names of data and other files that +# shall be deleted when calling `make clean'. Object and backup files, +# executables and the like are removed anyway. Here, we give a list of +# files in the various output formats that deal.II supports. +clean-up-files = *gmv *gnuplot *gpl *eps *pov -############################################################################### -# Internals -#deal include base path -D = ../../.. +# +# +# Usually, you will not need to change something beyond this point. +# +# +# The next statement tell the `make' program where to find the +# deal.II top level directory and to include the file with the global +# settings include $D/common/Make.global_options -# get lists of files we need -cc-files = $(filter-out *%, $(shell echo *.cc)) -o-files = $(cc-files:.cc=.o) -go-files = $(cc-files:.cc=.go) -h-files = $(filter-out *%, $(shell echo *.h)) -lib-h-files = $(filter-out *%, $(shell echo ../../include/*/*.h)) - -# list of libraries needed to link with -libs.g = ./Obj.g.a \ - $(lib-deal2-2d.g) \ +# Since the whole project consists of only one file, we need not +# consider difficult dependencies. We only have to declare the +# libraries which we want to link to the object file, and there need +# to be two sets of libraries: one for the debug mode version of the +# application and one for the optimized mode. Here we have selected +# the versions for 2d. Note that the order in which the libraries are +# given here is important and that your applications won't link +# properly if they are given in another order. +# +# You may need to augment the lists of libraries when compiling your +# program for other dimensions, or when using third party libraries +libs.g = $(lib-deal2-2d.g) \ $(lib-lac.g) \ $(lib-base.g) -libs = ./Obj.a \ - $(lib-deal2-2d.o) \ +libs.o = $(lib-deal2-2d.o) \ $(lib-lac.o) \ $(lib-base.o) -# check whether we use debug mode or not +# We now use the variable defined above which switch between debug and +# optimized mode to select the correct compiler flags and the set of +# libraries to link with. Included in the list of libraries is the +# name of the object file which we will produce from the single C++ +# file. Note that by default we use the extension .go for object files +# compiled in debug mode and .o for object files in optimized mode. ifeq ($(debug-mode),on) -libraries = $(libs.g) -flags = $(CXXFLAGS.g) -endif - -ifeq ($(debug-mode),off) -libraries = $(libs) -flags = $(CXXFLAGS) + libraries = $(target).go $(libs.g) + flags = $(CXXFLAGS.g) +else + libraries = $(target).go $(libs.o) + flags = $(CXXFLAGS.o) endif @@ -78,55 +87,83 @@ ifneq ($(with-multithreading),no) libraries += $(lib-ACE) endif -# make rule for the target + + +# Now comes the first production rule: how to link the single object +# file produced from the single C++ file into the executable. Since +# this is the first rule in the Makefile, it is the one `make' selects +# if you call it without arguments. $(target) : $(libraries) @echo ============================ Linking $@ - @$(CXX) $(flags) -o $@ $^ $(user-libs) + @$(CXX) $(flags) -o $@ $^ -# rule how to run the program + +# To make running the application somewhat independent of the actual +# program name, we usually declare a rule `run' which simply runs the +# program. You can then run it by typing `make run'. This is also +# useful if you want to call the executable with arguments which do +# not change frequently. You may then want to add them to the +# following rule: run: $(target) - $(target) $(run-parameters) - $(additional-run-action) + @echo ============================ Running $< + @./$(target) + gnuplot make_ps -# rule to make object files +# As a last rule to the `make' program, we define what to do when +# cleaning up a directory. This usually involves deleting object files +# and other automatically created files such as the executable itself, +# backup files, and data files. Since the latter are not usually quite +# diverse, you needed to declare them at the top of this file. +clean: + -rm -f *.o *.go *~ Makefile.dep $(target) $(clean-up-files) + + +# Since we have not yet stated how to make an object file from a C++ +# file, we should do so now. Since the many flags passed to the +# compiler are usually not of much interest, we suppress the actual +# command line using the `at' sign in the first column of the rules +# and write the string indicating what we do instead. %.go : %.cc - @echo ============================ Compiling with debugging information: $< - @echo $(CXX) ... -c $< -o $@ + @echo ==============debug========= $( Makefile.dep - +# To make the dependencies known to `make', we finally have to include +# them: include Makefile.dep + -- 2.39.5