Request History

• Restore to current request
• introduction-to-microkinetics
• posts/view/31/How+to+compile+VASP+5.4.1+for+Linux+Debian+using+the+GNU+compiler
• posts/findByTag/15
• posts/view/35/Efficient+compression+of+CHGCAR+and+LOCPOT+files

Session

• 0(null)

Request

Cake Params

• plugin(null)
• controllerposts
• actionfindByTag
• named(empty)
• pass(array)
  • 021
• paging(array)
  • Post(array)
    • page1
    • current1
    • count1
    • prevPage(false)
    • nextPage(false)
    • pageCount1
    • order(array)
      • Post.createdDESC
    • limit24
    • options(array)
      • order(array)
        • Post.createdDESC
    • paramTypenamed
    • queryScope(null)

Post data

No post data.

Query string

No querystring data.

Cookie

To view Cookies, add CookieComponent to Controller

Current Route

• keys(array)
  • 0controller
  • 1action
• options(array)
  • defaultRoute(true)
• defaults(array)
  • plugin(null)
• template/:controller/:action/*

Sql Logs

Logs

View Variables

• tag(array)
  • Tag(array)
    • id21
    • nameMake
    • iconfa fa-cogs
    • colordefault
  • Post(array)
    • 0(array)
      • id19
      • titleUsing a Makefile for compiling your program
      • contentCompiling your source code files can be tedious, especially when you want to include several source/header files and have to type the compiling command every time you have made a small change to the source. On Linux, commonly the ```make``` program is used to handle this task. Make looks for a Makefile in your folder and then executes it. To illustrate the usage of make, we provide an example where we have a small program which does some matrix calculations. We will use the following directory structure: <pre> <code class="bash"> . |-- Makefile |-- bin | `-- matrix |-- include | `-- matrix.h |-- obj | |-- main.o | `-- matrix.o `-- src |-- main.cpp `-- matrix.cpp </code> </pre> In the ```bin``` folder, we will store our executable. Every .cpp file will be stored in the ```src``` folder, the .o files in the ```obj``` (objects) folder, and the header files in the ```inc``` (include) folder. We want make to execute the following compile instructions * Every .cpp file in the ```src``` folder should be compiled to an object file in the ```obj``` folder. * When compiling .cpp files, the compiler should look for header/include files in the ```src``` and ```inc``` folders. * After compilation, all the object files should be linked to generate an executable in the ```bin``` folder. * There should be a "clean" algorithm for removing all object files and the executable. * Everything should be modular, that is, if either a single file name of directory name is changed, there should be a minimum number of changes in the source code to address this change. Without further adieu, our ```Makefile``` looks like this: <pre> <code class="makefile"> # set compiler and compile options EXEC = matrix CXX = g++ # use the GNU C++ compiler OPTS = -O2 -Wall -g # use some optimization, report all warnings and enable debugging CFLAGS = $(OPTS) # add compile flags LDFLAGS = # specify link flags here # set a list of directories INCDIR =./include OBJDIR = ./obj BINDIR = ./bin SRCDIR = ./src # set the include folder where the .h files reside CFLAGS += -I$(INCDIR) -I$(SRCDIR) # add here the source files for the compilation SOURCES = main.cpp matrix.cpp # create the obj variable by substituting the extension of the sources # and adding a path _OBJ = $(SOURCES:.cpp=.o) OBJ = $(patsubst %,$(OBJDIR)/%,$(_OBJ)) all: $(BINDIR)/$(EXEC) $(BINDIR)/$(EXEC): $(OBJ) $(CXX) -o $(BINDIR)/$(EXEC) $(OBJ) $(LDFLAGS) $(OBJDIR)/%.o: $(SRCDIR)/%.cpp $(CXX) -c -o $@ $< $(CFLAGS) clean: rm -vf $(BINDIR)/$(EXEC) $(OBJ) </code> </pre> Commonly, you define your variables at the top of the script. This way, you don't have to scroll down too much to change any compilation parameters. At the top, we have defined the name of our executable, the compiler and compilation flags. Next, we define all the folder where the source files are kept or where we want our compiled files to go. Thereafter, we add some additional instructions to the compiler flags, namely the folders where the includes files are kept in. Note that we append this information to an already existing variable using the ```+=``` operator. The real magic comes next, where we use a very handy substitution method for setting the values to our variables. We take each item in the ```$(SOURCES)``` variable and convert the .cpp extension to an .o extension and prepend these files with the ```obj``` path. This gives us a list of object files that we need to generate and where the executable depends on. The last lines are the real compilation instructions. These are set up in such a way that you first define what you want to compile, followed by a colon (:) and then the dependencies the compiled file depends on. You indent the next line with a tab and then define there exactly the compilation instructions. For example, we set in the script that our executable depends on all the object files and in order to generate the executable, all these object files need to be linked. Likewise, every one of the object files depend on its corresponding .cpp file and needs to be compiled using only that particular .cpp file. Lastly, if we want to clean up all the object files and executables (for instance if we want to make a backup of only the source files), we provide a "clean" instructions which simply deletes all the compiled files using rm. I hope it is now clear how handy Make is. Extending the above script to use for instance external libraries to link against is very easy. There are many good tutorials and instructions available on the internet. (Google is your friend!) I have made a short list of resources below I have often used when I ran into trouble writing my Makefiles. * [A tutorial provided by the Computer Science Department Colby College](http://www.cs.colby.edu/maxwell/courses/tutorials/maketutor/) * [The official manual](http://www.gnu.org/software/make/manual/make.html)
      • watched12157
      • active(true)
      • created2014-06-29 12:00:00
      • modified2019-09-10 20:02:44
• posts(array)
  • 0(array)
    • Post(array)
      • id19
      • titleUsing a Makefile for compiling your program
      • contentCompiling your source code files can be tedious, especially when you want to include several source/header files and have to type the compiling command every time you have made a small change to the source. On Linux, commonly the ```make``` program is used to handle this task. Make looks for a Makefile in your folder and then executes it. To illustrate the usage of make, we provide an example where we have a small program which does some matrix calculations. We will use the following directory structure: <pre> <code class="bash"> . |-- Makefile |-- bin | `-- matrix |-- include | `-- matrix.h |-- obj | |-- main.o | `-- matrix.o `-- src |-- main.cpp `-- matrix.cpp </code> </pre> In the ```bin``` folder, we will store our executable. Every .cpp file will be stored in the ```src``` folder, the .o files in the ```obj``` (objects) folder, and the header files in the ```inc``` (include) folder. We want make to execute the following compile instructions * Every .cpp file in the ```src``` folder should be compiled to an object file in the ```obj``` folder. * When compiling .cpp files, the compiler should look for header/include files in the ```src``` and ```inc``` folders. * After compilation, all the object files should be linked to generate an executable in the ```bin``` folder. * There should be a "clean" algorithm for removing all object files and the executable. * Everything should be modular, that is, if either a single file name of directory name is changed, there should be a minimum number of changes in the source code to address this change. Without further adieu, our ```Makefile``` looks like this: <pre> <code class="makefile"> # set compiler and compile options EXEC = matrix CXX = g++ # use the GNU C++ compiler OPTS = -O2 -Wall -g # use some optimization, report all warnings and enable debugging CFLAGS = $(OPTS) # add compile flags LDFLAGS = # specify link flags here # set a list of directories INCDIR =./include OBJDIR = ./obj BINDIR = ./bin SRCDIR = ./src # set the include folder where the .h files reside CFLAGS += -I$(INCDIR) -I$(SRCDIR) # add here the source files for the compilation SOURCES = main.cpp matrix.cpp # create the obj variable by substituting the extension of the sources # and adding a path _OBJ = $(SOURCES:.cpp=.o) OBJ = $(patsubst %,$(OBJDIR)/%,$(_OBJ)) all: $(BINDIR)/$(EXEC) $(BINDIR)/$(EXEC): $(OBJ) $(CXX) -o $(BINDIR)/$(EXEC) $(OBJ) $(LDFLAGS) $(OBJDIR)/%.o: $(SRCDIR)/%.cpp $(CXX) -c -o $@ $< $(CFLAGS) clean: rm -vf $(BINDIR)/$(EXEC) $(OBJ) </code> </pre> Commonly, you define your variables at the top of the script. This way, you don't have to scroll down too much to change any compilation parameters. At the top, we have defined the name of our executable, the compiler and compilation flags. Next, we define all the folder where the source files are kept or where we want our compiled files to go. Thereafter, we add some additional instructions to the compiler flags, namely the folders where the includes files are kept in. Note that we append this information to an already existing variable using the ```+=``` operator. The real magic comes next, where we use a very handy substitution method for setting the values to our variables. We take each item in the ```$(SOURCES)``` variable and convert the .cpp extension to an .o extension and prepend these files with the ```obj``` path. This gives us a list of object files that we need to generate and where the executable depends on. The last lines are the real compilation instructions. These are set up in such a way that you first define what you want to compile, followed by a colon (:) and then the dependencies the compiled file depends on. You indent the next line with a tab and then define there exactly the compilation instructions. For example, we set in the script that our executable depends on all the object files and in order to generate the executable, all these object files need to be linked. Likewise, every one of the object files depend on its corresponding .cpp file and needs to be compiled using only that particular .cpp file. Lastly, if we want to clean up all the object files and executables (for instance if we want to make a backup of only the source files), we provide a "clean" instructions which simply deletes all the compiled files using rm. I hope it is now clear how handy Make is. Extending the above script to use for instance external libraries to link against is very easy. There are many good tutorials and instructions available on the internet. (Google is your friend!) I have made a short list of resources below I have often used when I ran into trouble writing my Makefiles. * [A tutorial provided by the Computer Science Department Colby College](http://www.cs.colby.edu/maxwell/courses/tutorials/maketutor/) * [The official manual](http://www.gnu.org/software/make/manual/make.html)
      • watched12157
      • active(true)
      • created2014-06-29 12:00:00
      • modified2019-09-10 20:02:44
    • Comment(empty)
    • Tag(array)
      • 0(array)
        • id21
        • nameMake
        • iconfa fa-cogs
        • colordefault
• title_for_layoutBlog
• meta_descriptionThis is the personal website of Ivo Filot. Ivo Filot is a theoretical chemist originating from the Netherlands.
• meta_keywordsIvo Filot, Personal website, Fischer-Tropsch, Microkinetic Modeling
• $request->data(empty)
• $this->validationErrors(array)
  • Tag(empty)
  • Post(empty)
  • Comment(empty)
  • PostsTag(empty)
• Loaded Helpers(array)
  • 0Auth
  • 1Navbar
  • 2Download
  • 3Flag
  • 4Markdown
  • 5Number
  • 6SimpleGraph
  • 7Paginator
  • 8DebugTimer
  • 9Toolbar
  • 10Html
  • 11Session
  • 12HtmlToolbar
  • 13Form

App Constants

CakePHP Constants

PHP Environment

Included Files

Include Paths

• 0/customers/e/2/e/ivofilot.nl/httpd.www/lib
• 2/usr/share/php
• 3-> /customers/e/2/e/ivofilot.nl/httpd.www/lib/Cake/

Included Files

• core(array)
  • Behavior(array)
    • 0CORE/Model/Behavior/TreeBehavior.php
  • Cache(array)
    • 0CORE/Cache/Cache.php
    • 1CORE/Cache/Engine/FileEngine.php
    • 2CORE/Cache/CacheEngine.php
  • Component(array)
    • 0CORE/Controller/Component/SessionComponent.php
    • 1CORE/Controller/Component/AuthComponent.php
    • 2CORE/Controller/Component/Auth/FormAuthenticate.php
    • 3CORE/Controller/Component/Auth/BaseAuthenticate.php
    • 4CORE/Controller/Component/PaginatorComponent.php
  • Config(array)
    • 0CORE/Config/routes.php
    • 1CORE/Config/config.php
  • Controller(array)
    • 0CORE/Controller/Controller.php
    • 1CORE/Controller/ComponentCollection.php
    • 2CORE/Controller/Component.php
  • Datasource(array)
    • 0CORE/Model/Datasource/CakeSession.php
    • 1CORE/Model/Datasource/Database/Mysql.php
    • 2CORE/Model/Datasource/DboSource.php
    • 3CORE/Model/Datasource/DataSource.php
  • Error(array)
    • 0CORE/Error/exceptions.php
    • 1CORE/Error/ErrorHandler.php
  • I18n(array)
    • 0CORE/I18n/I18n.php
    • 1CORE/I18n/L10n.php
  • Log(array)
    • 0CORE/Log/CakeLog.php
    • 1CORE/Log/LogEngineCollection.php
    • 2CORE/Log/Engine/FileLog.php
    • 3CORE/Log/Engine/BaseLog.php
    • 4CORE/Log/CakeLogInterface.php
  • Model(array)
    • 0CORE/Model/Model.php
    • 1CORE/Model/BehaviorCollection.php
    • 2CORE/Model/ConnectionManager.php
    • 3CORE/Model/ModelBehavior.php
  • Network(array)
    • 0CORE/Network/CakeRequest.php
    • 1CORE/Network/CakeResponse.php
  • Other(array)
    • 0CORE/bootstrap.php
    • 1CORE/basics.php
    • 2CORE/Core/App.php
    • 3CORE/Core/Configure.php
    • 4CORE/Core/CakePlugin.php
    • 5CORE/Event/CakeEventListener.php
    • 6CORE/Event/CakeEvent.php
    • 7CORE/Event/CakeEventManager.php
    • 8CORE/Core/CakeObject.php
  • Routing(array)
    • 0CORE/Routing/Dispatcher.php
    • 1CORE/Routing/Filter/AssetDispatcher.php
    • 2CORE/Routing/DispatcherFilter.php
    • 3CORE/Routing/Filter/CacheDispatcher.php
    • 4CORE/Routing/Router.php
    • 5CORE/Routing/Route/CakeRoute.php
    • 6CORE/Routing/Route/PluginShortRoute.php
  • Utility(array)
    • 0CORE/Utility/Hash.php
    • 1CORE/Utility/Inflector.php
    • 2CORE/Utility/ObjectCollection.php
    • 3CORE/Utility/Debugger.php
    • 4CORE/Utility/CakeText.php
    • 5CORE/Utility/ClassRegistry.php
  • View(array)
    • 0CORE/View/HelperCollection.php
• app(array)
  • Config(array)
    • 0APP/Config/core.php
    • 1APP/Config/bootstrap.php
    • 2APP/Config/routes.php
    • 3APP/Config/database.php
  • Controller(array)
    • 0APP/Controller/PostsController.php
    • 1APP/Controller/AppController.php
  • Model(array)
    • 0APP/Model/Tag.php
    • 1APP/Model/AppModel.php
    • 2APP/Model/Post.php
    • 3APP/Model/Comment.php
  • Other(array)
    • 0APP/webroot/index.php
• plugins(array)
  • DebugKit(array)
    • Component(array)
      • 0DebugKit/Controller/Component/ToolbarComponent.php
    • Plugin(array)
      • 0DebugKit/Lib/DebugMemory.php
      • 1DebugKit/Lib/Panel/HistoryPanel.php
      • 2DebugKit/Lib/DebugPanel.php
      • 3DebugKit/Lib/Panel/SessionPanel.php
      • 4DebugKit/Lib/Panel/RequestPanel.php
      • 5DebugKit/Lib/Panel/SqlLogPanel.php
      • 6DebugKit/Lib/Panel/TimerPanel.php
      • 7DebugKit/Lib/Panel/LogPanel.php
      • 8DebugKit/Lib/Log/Engine/DebugKitLog.php
      • 9DebugKit/Lib/Panel/VariablesPanel.php
      • 10DebugKit/Lib/Panel/EnvironmentPanel.php
      • 11DebugKit/Lib/Panel/IncludePanel.php
      • 12DebugKit/Lib/DebugTimer.php
  • Markdown(array)
    • Config(array)
      • 0Markdown/Config/bootstrap.php
    • Plugin(array)
      • 0Markdown/Lib/Error/MarkdownExceptions.php