File: README

package info (click to toggle)
fet 5.11.0-1
  • links: PTS
  • area: main
  • in suites: squeeze
  • size: 95,508 kB
  • ctags: 6,476
  • sloc: cpp: 106,392; makefile: 51
file content (273 lines) | stat: -rw-r--r-- 14,622 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
FET (c) 2002-2009 Liviu Lalescu


Program description:

	FET is free timetabling software.
	This program aims to automatically generate the timetable of a school, high-school
	or university, by a heuristic algorithm.
	FET can mean "Free Educational Timetabling".
	FET webpage: http://lalescu.ro/liviu/fet/


Requirements:

	FET is created in the following environment: openSUSE 11.1 GNU/Linux distribution,
	Midnight Commander 4.6.2-pre1, Qt 4.5.2, gcc 4.4.1, Linux 2.6.27, KDiff3 0.9.92, other great free tools.
	FET can be run on any platform supported by the free software Qt (GNU/Linux, Windows, Mac OS X).

	GNU/Linux, Mac OS X and similar OS's:
	Software:
		make (GNU make command)
		gcc 4.4.1 or similar
		gcc-c++ (or g++, the name may vary)
		Qt 4.5.2 or compatible
		
	Note about Qt: FET should work OK with Qt 4.5.3 and any other Qt version, but: The Qt toolkit version 4.5.3 has a minor bug: the first row of
	a table is not updated correctly (for instance, in view timetable for students if you change the current students set 
	or in add constraint teacher not available table of not allowed times, if you click a cell in first row).
	I made a hack in FET: if the Qt version is 4.5.3, it applies an unnecessary operation to avoid this bug.
	I did not add this hack for other Qt versions. Qt team should solve this bug for future
	Qt versions, like 4.6.0 (in fact, I saw Qt snapshots for 4.6.0-2009-10-20 and they solved it). But, in the unlikely event that
	the bug is not solved for some future Qt versions, please don't blame me. Try with a not buggy Qt, like 4.5.2 or future versions.
	
	Microsoft Windows:
	For running, you need only the archive of FET compiled for Windows (which contains the MinGW and Qt dlls).
	For compiling, you need Qt and a compatible C++ compiler (MinGW probably an easy option)
	
	Important note about virtual memory: on Windows you might get the error message
	"The paging file is too small for this operation to complete" when trying to run fet.exe .
	Maybe on other systems you can get a similar problem.
	It seems that FET won't run without a decent amount of virtual memory.
	This is because FET allocates a large amount of static data (600MB), of which only about 50 MB are normally used.
	So the operating system must have virtual memory reserved (which will not be used normally,
	but that does not matter). So, if you disabled virtual memory, please enable it and/or increse maximum size
	if FET does not run.


Download:

	You can download the latest version from http://www.lalescu.ro/liviu/fet/
	Older versions: you will have to contact the author if you are interested.


Getting - compiling - installing GNU tools: make, gcc and gcc-c++ (or g++):

	GNU/Linux, Mac OS X: Most probably, your platform has these installed by default or available on the internet
	as precompiled packages. If you don't have them, please install them using YaST (on openSUSE), Adept Manager
	(on Ubuntu or Kubuntu) or other package manager.
	To verify that you have the correct packages, write "make --version", "gcc --version" and
	"g++ --version".
	
	Windows: you need a Qt compatible C++ compiler
	(maybe the easiest option the MinGW compiler, which is installed automatically by Qt) (see below)


Getting - compiling - installing Qt by Nokia (formerly by Trolltech):

	You will need Qt 4.5.2 or compatible to compile FET.
	You can get the corresponding version of Qt with your package manager or
	from http://qt.nokia.com/ (you can get the opensource version of Qt
	or other variants if you want). Note: newer Qt (4.5) has available LGPL and GPL
	variants, in SDK or Framework versions. Any variant should work.
	
	GNU/Linux: It is possible to use YaST (or Adept Manager) or other package managers to get
	your version of Qt, pre-compiled.
	Or you can download, compile and install Qt from http://qt.nokia.com/ .
	On my OpenSUSE GNU/Linux, which has pre-compiled packages on the internet, I need to install the packages
	libqt4 and libqt4-devel (libqt4 is installed by default, I think) - to compile+run FET.
	For Ubuntu GNU/Linux (advice from a user):
	sudo apt-get install qt4-qmake
	sudo apt-get build-dep qt4-qmake
	sudo apt-get install libqt4-dev
	sudo apt-get build-dep libqt4-dev
	
	Windows - Download latest Qt (maybe open source version for MinGW is the easiest option,
	but you can try also other variants) from http://qt.nokia.com/
	For MinGW version: Install and let Qt install also MinGW.
	Please make sure, after installing Qt and MinGW, that you have in the PATH environmental variable
	the path to qmake.exe (for 4.5.2 it is: C:\Qt\2009.03\qt\bin) and for mingw (C:\Qt\2009.03\mingw\bin).
	
	Mac OS X: 
	Maybe you can get pre-compiled packages for Mac. If not, get Qt from http://qt.nokia.com/ (maybe open source
	version is the easiest option).


Compiling FET:
	Note: compilation takes long (maybe even 1 hour, if you are using an older computer). The file
	rules.cpp takes the longest time to compile, maybe even 1 minute or more.
	
	Note2: under my openSUSE GNU/Linux, the intermediary files and the executable are very large, with default settings.
	(the fet executable is over 100 MB!). To avoid this, you need to modify the /usr/share/qt4/mkspecs/common/g++.conf
	line 10, remove the "-g" flag for the release version (from QMAKE_CFLAGS_RELEASE section)
	(root access needed to make this change).
	Under Fedora GNU/Linux for the same problem, a user told me that you need to modify /usr/lib/qt4/mkspecs/common/g++.conf
	and /usr/lib/qt4/mkspecs/linux-g++/qmake.conf (remove the -g flag from QMAKE_CFLAGS_RELEASE section).
	
	Currently FET can be compiled using Qt 4.5.2 or compatible.


	GNU/Linux and similar OS's:
	- You will need Qt 4.5.2 or compatible to compile this program.
	- type "qmake fet.pro" or simply "qmake". You have to use qmake from Qt 4 series, which on some systems
	might be named qmake-qt4 (this command is executed very fast,
	so don't worry if you get immediate return from it)
	- type "make" (this takes a long time, maybe even 1 hour)
	To remove the compiled objects/executable: "make clean" and/or "make distclean".
	
	
	Mac OS X:
	2 Variants:
	
	1. First variant, if you use gcc compiler:
	- You will need Qt 4.5.2 or compatible to compile this program.
	- type "qmake fet.pro" or simply "qmake". You have to use qmake from Qt 4 series, which on some systems
	might be named qmake-qt4. So, "qmake-qt4 fet.pro" might sometimes be needed.
	(this command is executed very fast, so don't worry if you get immediate return from it)
	- IMPORTANT: you might need to write: "qmake -spec macx-g++ fet.pro", if "qmake fet.pro" 
	does not produce a correct makefile. Please see 
	http://lists.trolltech.com/qt-interest/2007-04/thread01126-0.html for details.
	- type "make" (this takes a long time, maybe even 1 hour)
	To remove the compiled objects/executable: "make clean" and/or "make distclean".
	
	2. Another variant:
	- Type "qmake fet.pro" and then "xcodebuild".
	
	If you encounter problems, please see:
	http://lists.trolltech.com/qt-interest/2007-04/thread01126-0.html

	
	Microsoft Windows: MinGW C++ compiler: you need Qt 4.5.2 (2009.03) or compatible.
	You will have to download and install Qt with MinGW from http://qt.nokia.com/ .
	You might use other compilers if you want, please see the Qt web page http://qt.nokia.com/
	for other variants. Any C++ compiler that supports Qt is OK, as long as you can use it.
	You need to run "qmake fet.pro" or "qmake" (this command is executed very fast, so don't worry if you get
	immediate return from it) and then "mingw32-make" (this takes a long time, maybe even 1 hour) 
	in a command line in the FET directory.
	Then, you can remove directories "src" and "tmp", to save up space.
	For MinGW:
	If you want to obtain a version which can be run on other computers, 
	you have to copy these 7 files into the FET directory (in the same place as fet.exe):
	(QTDIR is an abbreviation for C:\Qt\2009.03\qt if you use Qt 2009.03, which is in fact Qt version 4.5.2)
	QTDIR\bin\mingwm10.dll,
	QTDIR\bin\Qt3Support4.dll, QTDIR\bin\QtCore4.dll, QTDIR\bin\QtGui4.dll,
	QTDIR\bin\QtNetwork4.dll, QTDIR\bin\QtSQl4.dll, QTDIR\bin\QtXml4.dll.
	
	
Installing FET:

	GNU/Linux and similar OS's:
	Please move the whole directory "fet-x.x.x" into the place where you like,
	for instance to the directory "/usr/local/".
	
	Microsoft Windows:
	Move the FET directory in a place of your choice.


Running FET:
	Note: The FET main form is empty, it just contains a menu with the items: File, Data, Statistics, Advanced,
	Timetable, Settings, Help. Everything is all right if you have that.
	
	Note: to run FET in interface more, you just need to run the executable named fet or fet.exe.
	No additional parameters are needed/allowed. If you give additional parameters, FET will
	consider that you want to run the command line version (see below instructions for command line version)

	GNU/Linux and similar OS's:
	Please chdir to the directory where fet executable is (for instance,
	"cd /home/liviu/fet-x.x.x/") and run "./fet". You may also run fet from
	another directory, but this is not thoroughly tested.
	
	Microsoft Windows:
	Run the executable fet.exe
	
	NOTE for MS Windows users: if you get the message "The paging file is too small for this operation to complete":
	If you disable virtual memory or have it low, it seems that the program won't start.
	The memory consumption of FET is maybe around 50 MB, but FET has defined approximately 600 MB of memory in internal
	variables (these are not used in normal cases). FET seems to need a good amount of virtual memory on Windows
	(maybe it is best to let Windows manage the virtual memory).
	
	COMMAND LINE: no GUI, just run "fet --inputfile=x [--outputdir=d] [--timelimitseconds=y] [--htmllevel=z] [--language=t] [--printnotavailable=u]
	 [--dividetimeaxisbydays=v] [--printsimultaneousactivities=w] [--randomseed=r] [--warnifusingnotperfectconstraints=s]",
	(under Windows, use fet.exe instead of fet)
	where	x is the input file, for instance "data.fet"
			d is the path to results directory, without trailing slash or backslash (default is current working path).
				Make sure you have write permissions there.
			y is integer (seconds) (default 2000000000, which is practically infinite).
			z is integer from 0 to 6 and represents the detail level for the generated html timetables
				(default 2, larger values have more details/facilities and larger file sizes).
			t is one of en_GB, ar, ca, de, el, es, fa, fr, hu, id, it, lt, mk, ms, nl, pl, ro, ru, tr (default en_GB).
			u is either "true" or "false" and represents if you want -x- (for true) or --- (for false) in the generated timetables for the
				not available slots (default true).
			v is either true or false, represents if you want html timetables with time-axis divided by days (default false).
			w is either true or false, represents if you want html timetables to show related activities which have constraints with same starting time (default false).
				(for instance, if A1 (T1, G1) and A2 (T2, G2) have constraint activities same starting time, then in T1's timetable will appear also A2, at the same slot
				as A1).
			r is the random seed, minimum 1 to maximum 2147483646 (you can get the same timetable if the random seed is the same).
			s is either true or false, represents whether you want a message box to be shown, with a warning, if the input file contains not perfect constraints
				(activity tag max hours daily or students max gaps per day) (default true).
	
	The result of the operation is logged into file outputdir/logs/result.txt.
	
	Also, you have in logs the initial order of activities and a list of maximum placed number of activities. If your timetable is impossible, say it stops
	at maximum n placed activities, look at the n+1-st activity in the initial order, for it or its students/teachers may be the problem.
		
	For the command line version, probably the most useful output to use internally in an application might be the activities_timetable.xml.
	You have of course also the xml timetables for students and teachers and the nicely formatted html timetables to present directly.
			
	On GNU/Linux and Mac OS X, you'll get a console output to help you with data, along with the files in the directory outputdir/logs/.
	
	On Windows, there is no console output, only the files in the directory outputdir\logs\ will guide you,
	I cannot make a console output on Windows (I could, but it would complicate the interface).
	

Languages (translations):
	
	FET will search for translations (fet_xx.qm files) in the following order:
	1) directly in the directory where the fet executable is,
	2) the directory "translations" in the directory where fet executable is,
	3) the directory /usr/share/fet/translations (under Unix like or Mac).
	
	So, on Windows: if fet.exe is in C:\fet-x.x.x, fet will search for file fet_xx.qm in
	C:\fet-x.x.x\ and then in C:\fet-x.x.x\translations
		On UNIX like: if fet executable is in /home/liviu/fet-x.x.x, fet will search for file fet_xx.qm in
	/home/liviu/fet-x.x.x, then in /home/liviu/fet-x.x.x/translations and then in
	/usr/share/fet/translations
	
	
Documentation:

	Some hints in the directory "/.../fet-x.x.x/doc/".
	Some other hints in the Help menu.


Input files:

	You can open a few sample input files in "/.../fet-x.x.x/examples/" directory
	(under GNU/Linux or Mac, they may be found in /usr/share/doc/fet/, or /usr/share/fet/)
	
	You can create/modify a file from FET's user interface or you can modify it by
	hand, if you like.
	

Un-installing FET:

	Remove the directory fet-x.x.x. Also, you may want to remove the directory with the fet results (default: $HOME/fet-results).
	This will leave the settings of FET on your system, certainly this is not a problem.
	FET stores a few bytes in your operating system settings. If you really want to get rid of everything FET created, read below.

	To remove the FET settings from your operating system (unnecessary step):
	
	GNU/Linux and similar OS's:
	Probably in $HOME/config directory you'll find a directory "fet" containing file "fettimetabling.conf". Remove the file and the directory.
	
	Microsoft Windows:
	Run regedit, search key "fet". You will find a section "fet" with sub-section "fettimetabling". Remove it.


Feed-back / help:
	- I would like to hear your oppinions/results about this program; any
	feed-back would be greatly appreciated.
	- Reporting bugs/wishes/patches: to forum, mailing list or author.
	
	This project is free software, so any sponsoring offer/donation would be great. You can
	contact the author for that.