| Jump to DART Documentation Main Index |
This module provides subroutines which utilize the MPI (Message Passing Interface) parallel communications library. DART does not require MPI; to compile without using MPI substitute the null_mpi_utilities_mod.f90 file for this one. That file contains the same module name and public entry points as this one but implements a serial version of all the routines. However, to be able to run most larger models with a reasonable number of ensemble members (e.g. 30-100) MPI will be needed.
The main DART executable filter can be compiled and run as either a serial program or a parallel program. Most work directories in the DART distribution source tree have a quickbuild.csh script which can take a -mpi or a -nompi flag. This flag changes the list of files to be compiled to use either the module which uses the MPI library or the one which makes no MPI calls. No source code changes are required to switch between the two options.
A parallel program generally runs faster and requires less memory per CPU than the serial code. It requires an implementation of the MPI library and run-time system to pass data between different nodes on a parallel cluster or supercomputer. There is a lot of information about MPI on the web. See here for an intro to MPI and parallel programming, and here for downloads and technical help.
Most of the larger models need to be compiled and run with MPI because of limitations on total memory accessible by a single executable. The smaller models (e.g. any of the Lorenz models) can generally be run as a serial program without needing MPI.
The MPI distributions usually include a module named mpi which defines the public entry points and the types and names of the routine arguments. However there are build-time options and older distributions which only supply an mpi.h include file. If you get a compile-time error about the mpi module being missing, edit the source code in mpi_utilities/mpi_utilities_mod.f90 and comment out the use mpi line and comment in the include 'mpi.h' line. The 'use' line must be before the 'contains' line, while the 'include' line must be after, so do not move the existing lines. Just comment them in or out depending on which one you need to use.
To preserve backwards compatibility this code does not require a namelist. However there is a namelist defined in the source file which contains some useful run-time options. To enable it edit the source file in mpi_utilities/mpi_utilities_mod.f90 and set use_namelist to .TRUE. and recompile. The code will then read the namelist described below. Messages printed to the nml output log file will confirm whether the defaults are being used or if the namelist is being read in.
The source code defines a namelist, but for backwards compatibility it is not read in unless the source code in mpi_utilities/mpi_utilities_mod.f90 is edited, the module global variable use_namelist is changed from .FALSE. to .TRUE., and then all executables are recompiled.
If enabled, this namelist is read from the file input.nml. Namelists start with an ampersand '&' and terminate with a slash '/'. Character strings that contain a '/' must be enclosed in quotes to prevent them from prematurely terminating the namelist.
&mpi_utilities_nml reverse_task_layout = .false. all_tasks_print = .false. verbose = .false. async2_verbose = .false. async4_verbose = .false. shell_name = '' separate_node_sync = .false. create_local_comm = .true. make_copy_before_sendrecv = .false. /
| Item | Type | Description |
|---|---|---|
| reverse_task_layout | logical | The synchronizing mechanism between the job script and the parallel filter in async=4 mode relies on the script and task 0 running on the same node (in the same memory space if the nodes have multiple processors). Some MPI implementations (OpenMPI being the most commonly used one) lay the tasks out so that the last task is on the same node as the script. If the async 4 model advance never starts but there are no error messages, try setting this to .TRUE. before running. See also the 'async4_verbose' flag below. |
| all_tasks_print | logical | In the parallel filter, informational messages only print from task 0 to avoid N copies of the same messages. Error messages and warnings print no matter which task they occur in. If this variable is set to true, even messages will print from all tasks. |
| verbose | logical | USE WITH CAUTION! This flag enables debugging print messages for every MPI call - sends, receives, barriers - and is very, very verbose. In most cases the size of the output file will exceed the filesystem limits or will cause the executable to run so slowly that it will not be useful. However in small testcases this can be useful to trace problems. |
| async2_verbose | logical | Print out messages about the handshaking between filter and the advance model scripts when running in async=2 mode. Not anywhere as verbose as the flag above; in most cases the output volume is reasonable. |
| async4_verbose | logical | Print out messages about the handshaking between filter and the run script when running in async=4 mode. Not anywhere as verbose as the flag above; in most cases the output volume is reasonable. |
| shell_name | character(len=129) | If running on compute nodes which do not have the expected default shell for async=2 or async=4 mode, specify the full pathname of the shell to execute the script. Not normally needed on most systems we run on. (However, at least one type of Cray system has this need.) |
| separate_node_sync | logical | Not supported yet. Will use files to handshake between the filter executable and the run script in async=4 mode when the launch script is not running on any of the same nodes as the filter tasks. |
| create_local_comm | logical | The DART MPI routines normally create a separate local MPI communicator instead of using MPI_COMM_WORLD. This keeps DART communications separate from any other user code. To use the default world communicator set this to .FALSE. . Normal use should leave this true. |
| make_copy_before_sendrecv | logical | Workaround for old MPI bug. Should be .false. |
types_mod utilities_mod time_manager_mod mpi (or mpif.h if mpi module not available)
character(len=*), intent(in), optional :: progname character(len=*), intent(in), optional :: alternatename
Initializes the MPI library, creates a private communicator, stores the total number of tasks and the local task number for later use, and registers this module. This routine calls initialize_utilities() internally before returning, so the calling program need only call this one routine to initialize the DART internals.
On some implementations of MPI (in particular some variants of MPICH) it is best to initialize MPI before any I/O is done from any of the parallel tasks, so this routine should be called as close to the process startup as possible.
It is not an error to try to initialize the MPI library more than once. It is still necessary to call this routine even if the application itself has already initialized the MPI library. Thise routine creates a private communicator so internal communications are shielded from any other communication called outside the DART libraries.
It is an error to call any of the other routines in this file before calling this routine.
| progname | If given, written to the log file to document which program is being started. |
| alternatename | If given, use this name as the log file instead of the default dart_log.out. |
logical, intent(in), optional :: callfinalize integer, intent(in), optional :: async
Frees the local communicator, and shuts down the MPI library unless callfinalize is specified and is .FALSE.. On some hardware platforms it is problematic to try to call print or write from the parallel tasks after finalize has been executed, so this should only be called immediately before the process is ready to exit. This routine does an MPI_Barrier() call before calling MPI_Finalize() to ensure all tasks are finished writing.
If the application itself is using MPI the callfinalize argument can be used to defer closing the MPI library until the application does it itself. This routine does close the DART log file and releases the local communicator even if not calling MPI_Finalize, so no other DART routines which might generate output can be used after calling this routine.
It is an error to call any of the other routines in this file after calling this routine.
| callfinalize | If false, do not call the MPI_Finalize() routine. |
| async | If the model advance mode (selected by the async namelist value in the filter_nml section) requires any synchronization or actions at shutdown, this is done. Currently async=4 requires an additional set of actions at shutdown time. |
integer :: task_count
Returns the total number of MPI tasks this job was started with. Note that MPI task numbers start at 0, but this is a count. So a 4-task job will return 4 here, but the actual task numbers will be from 0 to 3.
| var | Total number of MPI tasks in this job. |
integer :: my_task_id
Returns the local MPI task number. This is one of the routines in which all tasks can make the same function call but each returns a different value. The return can be useful in creating unique filenames or otherwise distinguishing resources which are not shared amongst tasks. MPI task numbers start at 0, so valid task id numbers for a 4-task job will be 0 to 3.
| var | My unique MPI task id number. |
Synchronize tasks. This call does not return until all tasks have called this routine. This ensures all tasks have reached the same place in the code before proceeding. All tasks must make this call or the program will hang.
integer, intent(in) :: dest_id real(r8), dimension(:), intent(in) :: srcarray type(time_type), optional, intent(in) :: time
Use the MPI library to send a copy of an array of data from one task to another task. The sending task makes this call; the receiving task must make a corresponding call to receive_from().
If time is specified, it is also sent to the receiving task. The receiving call must match this sending call regarding this argument; if time is specified here it must also be specified in the receive; if not given here it cannot be given in the receive.
The current implementation uses MPI_Ssend() which does a synchronous send. That means this routine will not return until the receiving task has called the receive routine to accept the data. This may be subject to change; MPI has several other non-blocking options for send and receive.
| dest_id | The MPI task id of the receiver. |
| srcarray | The data to be copied to the receiver. |
| time | If specified, send the time as well. |
The send and receive subroutines must be used with care. These calls must be used in pairs; the sending task and the receiving task must make corresponding calls or the tasks will hang. Calling them with different array sizes will result in either a run-time error or a core dump. The optional time argument must either be given in both calls or in neither or one of the tasks will hang. (Executive summary: There are lots of ways to go wrong here.)
integer, intent(in) :: src_id real(r8), dimension(:), intent(out) :: destarray type(time_type), intent(out), optional :: time
Use the MPI library to receive a copy of an array of data from another task. The receiving task makes this call; the sending task must make a corresponding call to send_to(). Unpaired calls to these routines will result in the tasks hanging.
If time is specified, it is also received from the sending task. The sending call must match this receiving call regarding this argument; if time is specified here it must also be specified in the send; if not given here it cannot be given in the send.
The current implementation uses MPI_Recv() which does a synchronous receive. That means this routine will not return until the data has arrived in this task. This may be subject to change; MPI has several other non-blocking options for send and receive.
| src_id | The MPI task id of the sender. |
| destarray | The location where the data from the sender is to be placed. |
| time | If specified, receive the time as well. |
See the notes section of send_to().
integer, intent(in) :: exit_code
A replacement for calling the Fortran intrinsic exit.  This ensures one task does not exit silently and leave the rest hanging. This is not the same as calling finalize_mpi_utilities() which waits for the other tasks to finish, flushes all messages, closes log files cleanly, etc. This call immediately and abruptly halts all tasks associated with this job.
Depending on the MPI implementation and job control system, the exit code may or may not be passed back to the calling job script.
| exit_code | A numeric exit code. |
This routine is now called from the standard error handler. To avoid circular references this is NOT a module routine. Programs which are compiled without the mpi code must now compile with the null_mpi_utilities_mod.f90 file to satisfy the call to this routine in the error handler.
real(r8), dimension(:), intent(inout) :: array integer, intent(in) :: root
All tasks must make this call together, but the behavior in each task differs depending on whether it is the root or not. On the task which has a task id equal to root the contents of the array will be sent to all other tasks. On any task which has a task id not equal to root the array is the location where the data is to be received into. Thus array is intent(in) on root, and intent(out) on all other tasks.
When this routine returns, all tasks will have the contents of the root array in their own arrays.
| array | Array containing data to send to all other tasks, or the location in which to receive data. |
| root | Task ID which will be the data source. All others are destinations. |
This is another of the routines which must be called by all tasks. The MPI call used here is synchronous, so all tasks block here until everyone has called this routine.
logical :: iam_task0
Returns .TRUE. if called from the task with MPI task id 0. Returns .FALSE. in all other tasks. It is frequently the case that some code should execute only on a single task. This allows one to easily write a block surrounded by if (iam_task0()) then ... .
| var | Convenience function to easily test and execute code blocks on task 0 only. |
integer, intent(in) :: from real(r8), dimension(:), intent(inout) :: array1 real(r8), dimension(:), intent(inout), optional :: array2 real(r8), dimension(:), intent(inout), optional :: array3 real(r8), dimension(:), intent(inout), optional :: array4 real(r8), dimension(:), intent(inout), optional :: array5 real(r8), intent(inout), optional :: scalar1 real(r8), intent(inout), optional :: scalar2 real(r8), intent(inout), optional :: scalar3 real(r8), intent(inout), optional :: scalar4 real(r8), intent(inout), optional :: scalar5
Cover routine for array_broadcast(). This call must be matched with the companion call broadcast_recv(). This routine should only be called on the task which is the root of the broadcast; it will be the data source. All other tasks must call broadcast_recv(). This routine sends up to 5 data arrays and 5 scalars in a single call. A common pattern in the DART filter code is sending 2 arrays, but other combinations exist. This routine ensures that from is the same as the current task ID. The arguments to this call must be matched exactly in number and type with the companion call to broadcast_recv() or an error (or hang) will occur.
In reality the data here are intent(in) only but this routine will be calling array_broadcast() internally and so must be intent(inout) to match.
| from | Current task ID; the root task for the data broadcast. |
| array1 | First data array to be broadcast. |
| array2 | If given, second data array to be broadcast. |
| array3 | If given, third data array to be broadcast. |
| array4 | If given, fourth data array to be broadcast. |
| array5 | If given, fifth data array to be broadcast. |
| scalar1 | If given, first data scalar to be broadcast. |
| scalar2 | If given, second data scalar to be broadcast. |
| scalar3 | If given, third data scalar to be broadcast. |
| scalar4 | If given, fourth data scalar to be broadcast. |
| scalar5 | If given, fifth data scalar to be broadcast. |
This is another of the routines which must be called consistently; only one task makes this call and all other tasks call the companion broadcast_recv routine. The MPI call used here is synchronous, so all tasks block until everyone has called one of these two routines.
integer, intent(in) :: from real(r8), dimension(:), intent(inout) :: array1 real(r8), dimension(:), intent(inout), optional :: array2 real(r8), dimension(:), intent(inout), optional :: array3 real(r8), dimension(:), intent(inout), optional :: array4 real(r8), dimension(:), intent(inout), optional :: array5 real(r8), intent(inout), optional :: scalar1 real(r8), intent(inout), optional :: scalar2 real(r8), intent(inout), optional :: scalar3 real(r8), intent(inout), optional :: scalar4 real(r8), intent(inout), optional :: scalar5
Cover routine for array_broadcast(). This call must be matched with the companion call broadcast_send(). This routine must be called on all tasks which are not the root of the broadcast; the arguments specify the location in which to receive data from the root. (The root task should call broadcast_send().) This routine receives up to 5 data arrays and 5 scalars in a single call. A common pattern in the DART filter code is receiving 2 arrays, but other combinations exist. This routine ensures that from is not the same as the current task ID. The arguments to this call must be matched exactly in number and type with the companion call to broadcast_send() or an error (or hang) will occur.
In reality the data arrays here are intent(out) only but this routine will be calling array_broadcast() internally and so must be intent(inout) to match.
| from | The task ID for the data broadcast source. |
| array1 | First array location to receive data into. |
| array2 | If given, second data array to receive data into. |
| array3 | If given, third data array to receive data into. |
| array4 | If given, fourth data array to receive data into. |
| array5 | If given, fifth data array to receive data into. |
| scalar1 | If given, first data scalar to receive data into. |
| scalar2 | If given, second data scalar to receive data into. |
| scalar3 | If given, third data scalar to receive data into. |
| scalar4 | If given, fourth data scalar to receive data into. |
| scalar5 | If given, fifth data scalar to receive data into. |
This is another of the routines which must be called consistently; all tasks but one make this call and exactly one other task calls the companion broadcast_send routine. The MPI call used here is synchronous, so all tasks block until everyone has called one of these two routines.
integer, intent(in) :: addend integer, intent(out) :: sum
All tasks call this routine, each with their own different addend. The returned value in sum is the total of the values summed across all tasks, and is the same for each task.
| addend | Single input value per task to be summed up. |
| sum | The sum. |
This is another of those calls which must be made from each task, and the calls block until this is so.
Create a named pipe (fifo) and read from it to block the process in such a way that it consumes no CPU time. Beware that once you put yourself to sleep you cannot wake yourself up. Some other MPI program must call restart_task() on the same set of processors the original program was distributed over.
Even though fifos appear to be files, in reality they are implemented in the kernel. The write into the fifo must be executed on the same node as the read is pending on. See the man pages for the mkfifo(1) command for more details.
Write into the pipe to restart the reading task. Note that this must be an entirely separate executable from the one which called block_task(), because it is asleep like Sleeping Beauty and cannot wake itself. See filter and wakeup_filter for examples of a program pair which uses these calls in async=4 mode.
Even though fifos appear to be files, in reality they are implemented in the kernel. The write into the fifo must be executed on the same node as the read is pending on. See the man pages for the mkfifo(1) command for more details.
integer, intent(in) :: async
For async=4 and task id = 0, write into the main filter-to-script fifo to tell the run script that filter is exiting. Does nothing else otherwise.
Even though fifos appear to be files, in reality they are implemented in the kernel. The write into the fifo must be executed on the same node as the read is pending on. See the man pages for the mkfifo(1) command for more details.
integer :: shell_execute character(len=*), intent(in) :: execute_string logical, intent(in), optional :: serialize
Wrapper routine around the system() library function to execute shell level commands from inside the Fortran program. Will wait for the command to execute and will return the error code. 0 means ok, any other number indicates error.
| rc | Return code from the shell exit after the command has been executed. |
| execute_string | Command to be executed by the shell. |
| serialize | If specified and if .TRUE. run the command from each PE in turn, waiting for each to complete before beginning the next. The default is .FALSE. and does not require that all tasks call this routine. If given and .TRUE. then all tasks must make this call. |
real(r8), intent(in) :: naplength
Wrapper routine for the sleep command. Argument is a real in seconds. Some systems have different lower resolutions for the minimum time it will sleep. This routine can round up to even seconds if a smaller than 1.0 time is given.
| naplength | Number of seconds to sleep as a real value. |
The amount of time this routine will sleep is not precise and might be in units of whole seconds on some platforms.
integer :: get_dart_mpi_comm
This code creates a private communicator for DART MPI calls, in case other code in the executable is using the world communicator. This routine returns the private communicator. If it is called before the internal setup work is completed it returns MPI_COMM_WORLD. If it is called before MPI is initialized, it returns 0.
| comm | The private DART communicator. |
Depending on the implementation of MPI, the library routines are either defined in an include file (mpif.h) or in a proper Fortran 90 module (use mpi). If it is available the module is preferred; it allows for better argument checking and optional arguments support in the MPI library calls.
If MPI returns an error, the DART error handler is called with the numeric error code it received from MPI. See any of the MPI references for an up-to-date list of error codes.
After printing to the standard output and log files, the DART error handler calls the exit_all() routine which calls MPI_Abort() to make sure all tasks exit and the entire job does not hang if only one task has an error.
none at this time
none at this time
N/A
DART software - Copyright UCAR. This open source software is provided by UCAR, "as is", without charge, subject to all terms of use at http://www.image.ucar.edu/DAReS/DART/DART_download


Github.com
An error has occurred. To continue:
Press Enter to return to Github.com, or
Press CTRL+ALT+DEL to restart your computer. If you do this,
you will lose any unsaved information in all open applications.
Error: 13 : 37
Press any key to continue _


{% import 'partials/section.html' as section %} {% extends "layouts/_onecol.html" %} {% block page_title %}Completed surveys - ONS Business Surveys{% endblock %} {% block main %} {% include "partials/tab_list.html" %}


hit enter then wait a bit... then click c then wait some more... then type W then hit tab and then hit enter. then sit back and relax...
up
fire(ctrl)
left
alt(strafe)
right
down
use(space)


| DOSE: |
1 hit |
oral |
LSD |
(gel tab) |
| |
1 hit |
oral |
LSD |
(blotter / tab) |
I don’t get many opportunities to use psychedelics, so when they arise, I like to take advantage of them. About a month after I’d returned from Bonnaroo, my friend Steve announced his parents would be out of state for a week. Without hesitation, he, my girlfriend Jamie, and our friends Rene and Liam made plans to drop acid at Steve’s place.
Steve’s house is ideal for tripping. It’s located on a dead-end street in a quiet neighborhood surrounded by woods, orchards, farms, and meadows. It’s equipped with a hot tub, a sauna, a deck, a porch, a hammock, comfortable furniture, pool and ping-pong tables, and a high-quality sound system with speakers in just about every room.
3:45 PM - Jamie, Rene, and I arrive at Steve’s on a gorgeous Saturday in mid July, the day before my twentieth birthday. Steve and Liam have been chilling for a couple of hours, awaiting our arrival. We unpack our belongings from my car and make no effort to mask our excitement.
4:00 PM - We ingest the LSD in Steve’s basement. Steve, Rene, and Liam each take two hits of potent Bonnaroo blotter, while Jamie and I each take a strong Bonnaroo gel tab and a hit of weaker blotter.
4:20 PM - I’m beginning to feel the initial effects, that strange sensation of “something’s not quite right.” I’ve taken shrooms three times, but this is to be only my second time on LSD (though my first trip wasn’t very powerful). We decide to go for a hike.
4:45 PM - Walking down the street on our way to the trail, my breathing becomes heavy. I can feel happiness mounting from within, and it’s all I can do to suppress a huge grin. Liam begins laughing hysterically. This will be his first psychedelic experience.
As we make our way further down the street, the countryside becomes more and more picturesque and I can definitely feel the LSD “heaviness” in my chest and stomach. We see a dog in a yard, who barks at us and looks totally alien. Jamie finishes eating a banana and places the peel in the middle of the road, an act that will take on a strange significance on the return journey.
We turn left at the bottom of the hill. The road here is straight and follows a gentle, up-and-down sloping pattern for about a mile. I notice the colors of the sidewalk and grass, and wonder why they don’t always look this varied and pronounced. I also notice the many insects flying in the air and leaping in the grass, they seem foreign and somewhat hostile. Suddenly, I see small, winged creatures zooming frantically over the grass—which is now a Martian red—on the side of the road.  On second thought, I am not sure these zipping, winged bugs are real or just figments of my imagination. Only when one plows into my bare chest do I realize these things do exist. I shout an expletive and dash into the road to escape these airborne menaces.
Steve laughs and assures me they are just locusts. I am only slightly relieved. Seconds later, a motorcycle appears on the road in the distance, heading towards us. The sound of its engine is comical, it sounds much more like flatulence than anything else. The man riding it is overweight and astonishingly frog-like. When he passes us, Liam erupts in laughter and declares, “That man just frumpfucked my soul!”
Later, Liam comes up with a senseless bit of wisdom. “In the sands of time,” he declares, “we sit like rocks.” That sends the lot of us into a fit of laughter.
We reach a bridge overlooking a shallow river, where we pause and enjoy the wind on our bodies. I feel as though the gentle breeze is embracing me as a human would. It warms me and sends pleasant shivers down my spine. I am now in a definite state of euphoria.
Further along the way, Liam plucks a large yellow lily and hands it to me. Its stamens reach out at me in an explicitly sexual manner. This sends me on a new train of thought, and I turn the flower over in my hand, marveling at its natural, organic sexuality and the way it stains my fingers yellow. When I mention this to my comrades, they just laugh, and Rene jokingly calls me a pervert. I am not upset at my peers for their reaction, but I do begin to dislike speaking in this state. I dislike the sound of my own voice and, occasionally, the sound of others’. Throughout the trip, I will frequently recommit myself to vows of silence and request that others keep their voices low.
We pass a sign that reads, “ZELDA’S VEGETABLES.” A woman is working in a garden across the street from the sign, and I think, That must be Zelda. Everyone hushes as we approach the woman, all of us suspecting she must know we’re tripping. She doesn’t look up when we pass. Normally, I would enthusiastically greet her, but under the influence of LSD, I feel most awkward and remain quiet.
Shortly before arriving at the trail, we pass another sign, this one put here by the state. It says, “NO PARKING SUNRISE TO SUNSET.” I ponder the message and think it’s profound that, in order for one to understand the simple instructions, one must first understand what a sunrise and sunset are. I am in awe that such a basic traffic sign relies upon the human understanding of two beautiful, cosmic occurrences.
5:30 PM - The five of us reach the entrance to the trail. I set the flower down by the side of the road, perceiving it as a symbol assuring our safe return.
When we pass beneath the trees, I realize I’m tripping hard, harder than I’ve ever tripped before. Visuals kick in almost instantaneously, every plant continuously radiates copies of itself into the air, and when the wind rustles the leaves, bright green tracers flow in their wakes.
Before we start the hike, we head down a familiar side path to the edge of a lake where we’d had a campfire several months earlier. A rusty old barrel sits in the brush just off the trail, and I feel strangely comforted when I look upon it.
The visuals I perceive at the lake are probably the strongest of the whole trip. The surface of a large tree in front of me ripples as if tiny raindrops are disturbing its liquid bark, and the shapes of its trunk spiral and squirm as if they are alive. I feel as though I am seeing sound. Across the lake, the trees blend into one another, there are trunks where the canopy ought to be, and vice versa. I look to the opposite shore of the lake and expect to see a moose at any moment. Everything here is bathed in a golden, peaceful light.
6:00 PM - Soon after we begin hiking down the main trail, I realize I am not enjoying the trek. I feel like I am in a storybook but I have no control over the ending of the tale. The trees and on either side of me quiver and emit emerald vapors, crowding my vision. The Flaming Lips song “It Overtakes Me” comes to mind. I hum it for a while and it boosts my morale, but claustrophobia sets in when I notice how narrow the path is. Furthermore, I realize that every step I take I will have to retrace on the way back, since there is not enough daylight left to make the full loop around the lake.
As it turns out, I am not the only one with qualms about this hike. Everyone seems to be expressing their dislike for heading deeper into the woods, and we’re all tripping so hard we’re having great difficulty communicating simple sentences to one another. With great difficulty, I suggest we agree on a time to turn back, and we settle on 7:00 PM.
We continue moving forward.  Then I realize that everyone really is shouting and screaming. I can feel a headache coming on, and I’m starting to sweat. The mosquitoes are relentless. All I want is to turn back and get out of these damned woods, but I know that breaking our group’s unity will only make things worse.
The yelling escalates and so does my headache. There is still a great deal of disagreement about what to do. Should we leave the woods or continue hiking? All I know is that the chaos and confusion are mounting, and the trees are making me feel claustrophobic. Our group can’t make it fifty feet without stopping, splitting up, and going bonkers. At one point, Liam leaps off the path and perches himself on a rock. Another time, wanders off to find a tree he can climb. Further along, Jamie runs ahead on the trail and I fear she is lost. Steve is relatively silent the whole time, but I can tell he’s tripping just as hard as I am. The shouting continues and my head throbs. I sense that I’m teetering on the edge of a bad trip, and I pray I don’t start to panic. I am about to consider ditching everyone and getting the hell out of the woods, when somehow we come to a unanimous decision. We will turn around and head back. Hallelujah.
7:00 PM - We had probably only traveled a hundred yards in the span of an hour. Thankfully, going back is much quicker than going forward. My bad mood dissolves within moments, and I cheer up with every step I take. Liam and I walk ahead of the other three and express our relief at overcoming such a trying situation. I comment on how dynamic the trip has been, and resolve to think twice before going for another hike on LSD.
We return to the lake, and I am overcome with the same sense of peace and security as when I was first there. We relax and eat some food. I have some difficulty bringing myself to bite into an apple, it looks much more appealing whole. Eventually, though, I take a bite out of it, and I’m amazed at how carnivorous I feel. Words like “consume” and “devour” play through my mind. I feel like I am killing the apple, like I am tearing it apart, but I don’t feel any sympathy for it (which is good, because I am very hungry).
When I’m through, I toss the apple into the lake and read the first page of a book Steve brought along. I have a hard time doing so, because the words are moving too much for me to focus on them. I put the book down and take out a Magic Eye book. The images are astounding. Liam finds them hilarious, and laughs until he cries. Rene wants to order a pizza. Steve is fascinated by tiny holes in the log upon which we are sitting. Jamie squeals in lysergic bliss.
7:30 PM - At last, we pack up and head back to Steve’s house. On the way out of the woods, we pass a small group of kids about our age. Only a few minutes ago, I had jokingly asked my friends, “What’s the proper etiquette if you pass another hiker and you’re on acid?” I greet the kids, but my words feel empty and awkward. None of us speaks for a minute after passing the other group, then, when we are out of earshot, all of us burst out laughing. I hope I don’t have to encounter any more strangers.
Upon reaching the road, I spot the yellow lily I had placed on the side of the pavement. A frown crosses my face when I see it’s been flattened.
The rest of the walk is great. Now that we’re out of the woods entirely, my mood elevates considerably. I feel much more sociable, and there is much laughter among my companions and I. At one point, I spot a tractor ahead, coming towards us down the street, except in my current state I cannot tell that it’s a tractor. In fact, I have no idea what it is, just like what happened to me earlier with the locusts. My brain seems to be trying simultaneously to classify the red machine as a robot, ostrich, and police officer. Though the tractor is many yards ahead, I cower until it turns off the road.
A friend of ours calls one of our phones to see how we’re doing. I have great difficulty using a phone, so I give up and hand it to someone else.
At a four-way intersection, the unthinkable happens. A man stops his car next to us and politely asks for directions. We stare blankly at him, our jaws hanging. The man’s face is horribly disfigured. A few of us snicker. I try to take control of the situation and blurt out, “Uh, I’m sorry, I’m not from around here.” My voice sounds thin, awkward, and childlike. He waves in response, says “Thanks anyway,” and drives away. Well, most of him drives away. While his car and body speed forward down the road, his head reminds behind, suspended in midair, transparent and still dreadfully disproportionate. I blink, and then the head seems to realize it has been left behind and whizzes to catch up with its body.
The remainder of the walk back to Steve’s, while relatively uneventful, is full of beauty and companionship. I take in the full splendor of the countryside and we watch the sun on its descent to the horizon.
8:15 - We arrive back at Steve’s just as the daylight is beginning to decline. A realm of new possibilities opens, and suddenly there is so much to do. We’ve been tripping for about four hours now, and I want to make the best of the time I have left.
For the next hour or two, the five of us listen to music (primarily Jaco Pastorius’ self-titled album), relax in Steve’s hot tub, and sit on his back porch admiring nature. At one point, after smoking a Djarum, Steve turns pale and becomes ill. Though I know it isn’t his fault, his nausea and general feelings of sickness bring my mood down tremendously. For a while, I develop a new sensitivity to other persons’ voices, and I find myself seeking solitude. Eventually, Steve vomits and feels much better. After that, my good mood returns and my irritability vanishes.
I recall what a friend of mine had advised me to do if I take LSD. He suggested I lock myself in a bathroom and turn out the lights, promising me that I would “be transported.” I follow his advice. He’s right, as soon as the lights go out, the bathroom walls jettison away and I find myself on a vast, cold, empty plane surrounded by robots “breathing” heavily in my ears. Spirals and waves of spheres and colors fly around my vision, and I can make out prehistoric creatures roaming about in the distance. I emerge from the bathroom minutes later in a state of profound awe. I urge my friends to try what I’ve just experienced. They do, and they’re all amazed.
9:30 - Rene has been pestering us for almost an hour to invite two of our other friends to join us. Initially, all of us are opposed to the idea, as we had agreed earlier to limit the number of people to five. As time goes by, though, Rene’s insistence becomes unbearable and we agree to hang out with our other friends Tom and Seth. They arrive stoned out of their minds, and their arrival brings about a more sociable atmosphere.
For the rest of the night, as the trip mellows out, we sit around Steve’s table on his patio and smoke cigars, drink a beer or two (no one gets drunk), and engage in good conversation. We go for walks and talk about the day, sharing our experiences and introspections.
12:00 - I turn twenty years old. The seven of us celebrate by smoking two bowls of sour diesel. With the exceptions of Tom and Seth, who didn’t take LSD, all of our trips are boosted significantly. We freestyle, experiment with words and phrases, and dance around to Snooks Eaglin.
2:30 - We’re inside now, making food and listening to music. We lounge around Steve’s great room in darkness and listen to the entirety of Dark Side of the Moon. Boards of Canada, Incubus, and the Grateful Dead also find their way into our ears. To conclude the night, we watch Disney’s Fantasia.
Around 4:00 in the morning, the true enormity of the trip settles in, and I conclude without a trace of doubt that today I had the most intense experience of my entire life.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Use a content management system to quickly make clean webpages for your students to use.
Student? Search for already created sites:


See: Description
| Interface | Description |
|---|---|
| BackgroundRunnable |
This is the interface that a user periodically executed Task class must implement.
|
| Class | Description |
|---|---|
| BackgroundRunnableFactory |
This class is part of the framework and probably will not be accessed externally
|
| BackgroundThreadsRunner |
This class is part of the framework and probably will not be accessed externally.
|
| BaseBackgroundRunnable |
This is the base class for any user defined periodic Task classes See source code example in package
com.mgnt.lifecycle.management.backgroundrunner.example that demonstrates how it is done |
BaseBackgroundRunnable
class and override 4 methods:
BaseBackgroundRunnable.initParamsForSpecificImplementation()
BackgroundRunnable.getTaskExecutionInterval()
BackgroundRunnable.setParamValue(com.mgnt.utils.entities.TimeInterval,
java.lang.String)
Runnable.run()
@Scheduled
that can be used for any method and that would work just fine. Well The annotation
@Scheduled
takes time interval property i.e. the time between 2 sequential executions in milliseconds or as
a cron expression. Neither of those formats are user friendly. Imagine that you need to run a task each 9 hours.
So you parameter that you will have to provide to @Scheduled
annotation
would look like @Scheduled(fixedRate = 32400000)
. (32400000 is number of milliseconds in 9 hours) This is
hardly intuitive... What if you could write @Scheduled(fixedRate = 9h)
? Well, that would be great, but you
can not (at least with currently available latest versions). This is what this infrastructure provides. Especially
if you annotate one of your properties with annotation @Value("${task.execution.interval}")
and then you will
have a properties file that will have a property task.execution.interval=9h
instead of
task.execution.interval=32400000
. So there is a trade-off here. This infrastructure definitely requires more effort
from a programmer then mere method annotation with @Scheduled
, but provides very intuitive and humanly readable
way to define time interval properties. Internally this framework uses utility provided by this library to parse those
time intervals. (For details see TextUtils.parseStringToTimeInterval(java.lang.String)
) Also
this infrastructure allows you to parse other time interval properties (if you class has any) with the same format.
package com.mgnt.lifecycle.management.backgroundrunner.example
contains working source code that demonstrates
how this infrastructure is used. Assume that you have implemented your tasks
TypeOneTask
and
TypeTwoTask
(The same classes that are used in package
com.mgnt.lifecycle.management.backgroundrunner.example
). If you work in Spring environment you will need
to annotate those classes with annotation Component
(or define them as beans in your xml configuration files)
and you will need to add one more declaration in your xml configuration file:
<bean id="backgroundThreadsRunner" name="backgroundThreadsRunner"
class="com.mgnt.lifecycle.management.backgroundrunner.BackgroundThreadsRunner" depends-on="typeOneTask,typeTwoTask"/>
The reason is that your tasks must be instantiated before instance of
BackgroundThreadsRunner
is created by Spring
com.mgnt.lifecycle.management.backgroundrunner.example
the code there is concise and well commented with
detailed explanation


ICOMM - Inaccessible Constructor Or Method Matches
Overload resolution only considers constructors and methods are visible at the point of the call. If however, all the constructors and methods were considered, there may be more matches. This rule is violated in this case.
Imagine that ClassB is in a different package than ClassA. Then the allocation of ClassB violates this rule since the second constructor is not visible at the point of the allocation, but it still matches the allocation (based on signature). Also the call to oper in ClassB violates this rule since the second and the third declarations of oper is not visible at the point of the call, but it still matches the call (based on signature).
Wrong
public ClassA (int param) {}
ClassA (char param) {}
ClassA (short param) {}
public void oper (int param) {}
void oper (char param) {}
void oper (short param) {}
}
Tip: Either give such methods or constructors equal visibility or change their signature.
Right
ClassA (int param) {}
public ClassA (char param) {}
public ClassA (short param) {}
public void oper (int param) {}
void doOper (char param) {}
void doOper (short param) {}
}


DRAFT
Dictionary View:
ɔ
(Sorted by lexeme)
ɔ́dà
[ɔɗa]
n. 9/10
Tone:
[4a]
Root Tone Melody:
HL
1.
order, command (
Gloss:
order, command) [
SILCAWL Number:
0498]
ɔ́mɔ̀
[ɔmɔ]
n. 9/10
Tone:
[5a]
Root Tone Melody:
HL
1.
semen, sperm [
SILCAWL Number:
0100]
Home
Database View
Dictionary Navigation
Entries By First Letter:
a
|
b
|
c
|
d
|
e
|
ɛ
|
i
|
k
|
l
|
m
|
n
|
ŋ
|
o
|
ɔ
|
p
|
s
|
t
|
u
|
v
|
w
|
y
|
All Entries
Sort By:
Lexeme
|
Stem
Show Examples


This visualization shows all the accounts that have been active during the time period specified. Each rectangle represents one account, and it's size is determined by that account's total volume. Scrolling over each account will display further information about it, as well as highlighting its entry in the table at the bottom of the page. In that table, each entry corresponds to an account represented in the visualization. This table offers more in depth information about each account, including the total volume, the number of trades, and a buy/sell ratio.
Clicking on an account, either in the bottom table or the visualization, will show the breakdown of all the transactions made by that account during the specified time period. This breakdown includes the base and counter amounts and currencies, the rate they were traded at, and whether the transaction was a sell or a buy.


Package iot.mqtt
-
Interface Summary Interface Description MqttClientBasicApi Interface with basic API for a mqtt clientMqttMessageType interface to identify the mqtt message type -
Class Summary Class Description BasicMqttMessage MqttMessage that represent a message from anApplication
to theNetworkServer
LoraWanPacketWrapper Wrapper of aLoraWanPacket
as mqtt message.MqttBrokerMock Mock that represent a mqtt brokerMQTTClientFactory Factory to retrieve an instance ofMqttClientBasicApi
MqttMock Mock implementation of a mqtt clientMqttMock.MqttMessageConsumer<T extends MqttMessageType> PahoMqttClient Mqtt client for a real mqtt server.Topics Class of utils to manage all the mqtt topicsTransmissionWrapper Wrapper of aLoraTransmission
as mqtt message. -
Enum Summary Enum Description MQTTClientFactory.MqttClientType


Please read our Contributing guide lines first.
You can find any required library for this project in the requirements.txt:
autopep8==1.4.2
docutils==0.14
guzzle-sphinx-theme==0.7.11
m2r==0.2.1
pep8==1.7.1
pycodestyle==2.4.0
-e git://github.com/pytest-dev/pytest-cov@master#egg=pytestcov
six==1.11.0
Sphinx==1.8.1
sphinxcontrib-log-cabinet==1.0.0
sphinxcontrib-websupport==1.1.0
pip==18.1
twine==1.12.1
You can install them by
pip install -r requirements.txt --user
NOTE: Make sure to have also all the extensions listed in the docs/conf.py that are required for the SDK Documentation.
We suggest to use Visual Studio Code with installed plugins for Python Development described here. But if you prefer any other IDE / Editor, it is fine.
If you open a Pull Request (PR), we will trigger automated tests and pep8 style check in Travis CI. So nothing you have to worry about in your development. You can open your PR and prefix its title with WIP “Work In Progress” to access these checks in advance.
If there’s anything breaking, be so kind to fix it. If you’re not able to do it - feel free to ask for help.
Try to auto-fix pep8 styling issues by
# to autofix possible issues
./scripts/pep8fix.sh
# to check for issues left
./scripts/pep8check.sh
We care then about the rest - no need to worry about things like building current realease and versioning.
You can stop here.
The below sections are just for our reference. TIA for your PR and thus for your support of this project. As we have further SDKs in other languages, it might take a bit of time to check if we can role out that PR as we want to keep all our SDKs aligned.
We use SemVer for versioning. For the versions available, see the tags on this repository. New version numbers will be set automatically through npm module semantic-release which is part of our CI/CD.
Our Travis CI integration cares about checking the PR for issues. If all looks fine, please care about rebasing and if applicable about squashing. Now you can merge the PR into master branch. Travis CI and semantic-release care about releasing and uploading. This also includes automatic update of changelog and source code documentation.
Changes to the documentation will be auto-deployed by a webhook to readthedocs.org and to github pages.
The module can be accessed on the PyPi (Live) Index and the PyPi (Test) Index.
Have an eye on the generated SDK Documentation.
If you want to generate it from scratch out of the sources, please use the below script:
./scripts/generatedocs.sh
The generated files are then available in subfolder “docs/_build/html”. We regenerate the SDK Documentation whenever a new tag commit reaches the master branch.


Polls2k11 provides the latest poll information for the Portuguese legislative election 2011 in a machine readable format, currently JSON with JSONP support.
Wikipedia provides a pretty nice page showing opinion polls data relating to the 2011 Portuguese legislative elections. I had some ideas to use that information but I need that information structured in a decent format.
I built a script to get the data from Wikipedia and convert that information to JSON. I made this public so everyone can use and create nice apps.
Bruno Areal built a JS client for this API. A running version of this client is available at http://polls.simaomata.com/charts
You can install this script and host it yourself.
If you don't require JSONP, all you need to do is run polls.py every time you need to update the data.
If you need JSONP, you can deploy a pollserver.py and use the endpoints defined there.
Use can also use my installation to get the data, see below.
You can also use my installation at polls.simaomata.com
The following endpoints are available:
http://polls.simaomata.com/all - Returns latest known information about all 2011 polls
http://polls.simaomata.com/latest - Returns information about the most recent poll
All information provided by these endpoints is updated once a day.
All information can be obtained from a browser using JSONP. If you pass a GET parameter named "jsonp=callbackName", the response will be the following:
callbackName(pollData);
Check the example below for more information on this.
An example is provided in jsonp_example.html. This examples fetches data from /all using JSONP and jQuery and displays the result in a simple manner.
If you want to use the /latest endpoint from a browser, you can use /latest?jsonp=mycallback. This endpoint will return the following response:
mycallback({
"date": "8-10 April",
"source": {
"href": "http://www.tvi24.iol.pt/politica/sondagem-psd-ps-eleicoes-intercampos-tvi24/1245972-4072.html",
"name": "INTERCAMPUS"
},
"parties": {
"Lead": "5.6",
"Others / undecided": "3.1",
"Socialist": "33.1",
"People's Party": "9.4",
"Green-Communist": "8.1",
"Social Democratic": "38.7",
"Left Bloc": "7.6"
}
});
There are so many things everyone can do with this information, it's so freakin easy to use it!
GO BUILD SOMETHING! No excuses.
Copyright (C) 2011 by Simão Mata
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


{% load staticfiles %}
Asked by {% include 'eray/partials/_profile_link.html' with user=question.user %} @{{ question.created_at|date }}
{{ question.view_count }}
Views
{{ question.vote_count }}
Votes
{{ question.answer_count }}
Answers


An environmentally concious manufacturer, that strives to be the preffered precast supplier in the Pacific Northwest valuing safety, quality, and customer service.
Precast concrete has been around since the time of the ancient Romans(Not Spartans). Techniques and practices continue to evolve, and today there's a big emphasis on quality control, green manufacturing and cost effective production.
SMaRT CERTIFIED
SUSTAINABLE
AMERICAN MADE
Even though Rogue Valley Precas began in 2019, we have an unmatched pedigree when it comes to precast products and buried infastructure. Our crew has decades ofexperience in the industry, producing durable products with the cleanest methods and producing rock-solid engineering.
Our main focus is on industry-standard-products such as storm drains, utility vaults, and sewer and water disperal systems. However, our Rogue Valley facility is able to handle custom projects as well. We have state-of-the-art equipment that can be adapted for any job. We'll even pour in place if we have to.
But no matter what, you'll get a product that's strong, durable, and enviornmentally sound.
With our new facility, Southern Oregon now has a local precast concrete plant. Instead of going to Eugene or Nothern California, you'll be able to get your buried infastructure needs met here at home. Better turnarounds, better customer service, and better sustainability.
Because of our location, we're able to use locally sourced materials for all of our products. With Table Rock in the background, we can mass-produce manholes or create a specifically designed custom vault, complete with rungs, safety ladders, and shelving. If it can be made, we'll make it in the Rogue Valley.
Learn more about us.
We are dedicated to making a product that's not only good for our customers, but goo for the enviornment as well. Our Rogue Valley facility earned SMaRT Certification, which means we've taken extra steps to make sure our products and processes are eco-friendly.
This goes beyond using only natural or raw materials and recycling waste material. Our partners were chosen specifically with sustainability in mind. Even if it was as simple as looking for nearby Rogue Valley suppliers to cut down on delivery distances. Some may consider that kind of decision inconsequential - we consider it mandatory.
Browse our products and services.
Rogue Valley Precast is the only company in the Pacific Northwest to produce Stone Strong Systems products. These blocks can be made for any job, from landscaping for new residential communities to retaining walls along major thoroughfares. Let us know the measurements and we'll get to work.
We also work with Retain-It and Perfect Base brands for your water retention and sewer system needs. One of the best brands on the market, we keep several Retain-It modules on hand for fast ordering and quick deleveries.
Perfect Base manhole bases reduce the occurence of snags, blockages, and other impediments in your wastewater infastructure.
Rogue Valley Precast is filling a void in the Josephine an Jackson county areas. our facility is equipped with the newest equipment, we partner with the best brands, and our staff has been working with precast concrete for years. Have a need for buried infastructure or other precast products in Southern Oregon? Contact us today and find out how we can help.
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Pariatur, fuga repudiandae. Voluptates perferendis velit totam fugiat enim aliquid ad optio vitae quo. Facilis vel architecto, nesciunt voluptatibus incidunt sequi distinctio!


Before we begin
Stories
My story
Job stories
Your stories
1683
Charles
Charles
James
James
...
Today
11th of October
1993
Search
for anything
anywhere
cheap
calories
salt + fat + sugar
cheap
information
obesity?
new jobs
new tools
new methods
personal spaces
intellectual diaries
open conversations
1 to 1
1 web-log = 1 person
bandwagon
monetize & standardize
pre-fabricated
faces' books
Maybe
smaller disks
longer wires
time/place marker
connected events
people and feelings
promise
As a role
I want feature
So that value
As Little Red Riding Hood
I want to pick some flowers
so that I can bring something personal to granny
I want to pick some flowers
so that I can bring something personal to granny
no context
no casuality
When I'm sent out to deliver food
I want to pick some flowers
so that I can bring something personal to granny
When I'm sent out to deliver food
I want to add a personal note to the delivery
so that the recipient will be delighted
When context
I want motivation
So that outcome
Dig context
When I'm sent out to deliver food
and I'm in a rush
in the middle of a forest
goals
not solutions
I want to pick some flowers
I want to add a personal note to the delivery
questions?
5 job stories
Brunel Design Blog
In what contexts do your users operate?
What do they want to achieve?
What drives them?


title = "SBH Reunion" url = "/sbh-reunion" layout = "sbh-default" description = "St. Bernard High School Classes of 2000 and 2001 are hosting a reunion." hidden = "0" ==


IEEE - UMIT CHAPTER
IEEE Council
In this information age, where innovation has become a necessity, IEEE provides a platform to innovate for a better tomorrow. Comprising of more than 423,000 members in over 160 countries, along with highly cited publications, conferences, and technology standards, as well as professional and educational activities, IEEE inspires to pioneer in engineering, computing and technology information around the globe.IEEE- UMIT
IEEE UMIT is a student chapter of Usha Mittal Institute of Technology (SNDT University) which is the only women's engineering college in Mumbai.This chapter of IEEE was formed in December 1999, when UMIT was known as ITW. The council helps the members in developing technical skills as well as helps them transform into professional individuals, thus preparing them to face the world outside. Today IEEE UMIT has a large count of over 220+ members. The annual 360 DEGREES+ is not just a college fest but also a celebration of technology and with a foot fall of 500+ students it is definately one of the highlight events


Modify options on the fly or set them as data attributes
You can use data-overlap="..."
to allow or deny overlapping (defaults to false), data-compact="..."
to reduce vertical space as much as possible (defaults to true) or data-resize=".."
to resize the whole container to match its contents. This can also be done on the fly by using the option()
method e.g. $(...).ltGrid('option', 'overlap', true)
Here's how it looks in action:
<div
data-arrange="layout-grid"
data-overlap="false"
data-compact="true"
data-resize="true">
</div>


{% extends 'base.html' %} {% load static %} {% block body_class %} my_new_body_css_class {% endblock %} {% block content %}
This is an Ensemble Method. You can learn more about other ensemble methods bagging and boosting by clicking the links!
Stacking is our main method, the one that gives the best results and makes most accurate best predictions.
Stacking is also the most complicated ensemble method, as it uses multiple different base models.
The base models we have used are explained on the
classifiers page.
Luckily, we don't have to understand how each of the classifiers work to understand stacking.
We have implemented stacking with something called k-fold validation, which we will explain first.
K-fold validation is a way to get a lot of training out of just a little bit of data.
The tecnique is designed so that all training data is used both to test and to train classifiers,
without risking overfitting the models (overfitting is training a model to much to a specific data set,
so that it performs poorly on new data).
K-fold is illustrated in the figure below. What it does in our case is using 75% of training data
to train a model to test/predict on the other 25%. Then it creates a new copy of the same model, and
trains on another 75% of the data, testing on a new 25% part. After the model has made test predictions on
all the training data, its predictions is stored. We do this process for every classifier we use in the
stacing method.
After the different classifiers have made predictions on all the training data, their predictions are saved and used as additional input for training the stacking classifier. This classifier, by knowing what each of the models predicted, end up outperforming the models in total, making for a overall better classifier.


Honesty is more than not lying. It is truth telling, truth speaking, truth living, and truth loving.
PUP Sta. Mesa - Main Building South Wing
Wala syang ganon
Bahay nila Bomar


{% extends 'base.html' %} {% block page_title %}About{% endblock %} {% block content %} « Back to home
Messenger was created as a result of the feedback gathered by the college leadership team by residents.
The aim of Messenger is to allow anyone to communicate with an officer anonymously. Examples of why this might be needed:
Messenger can facilitate anonymous conversations with an officer, which improves on a simple one-way report.
Anyone can send an anonymous message and choose who to send it to.
If they choose to, they can enter a password so they can continue the 'conversation' with the officer(s) online. This process simply assigns a random user id number to the user, which they can use to log in and check for new messages.
Officers will check their messages regularly and reply to them as soon as they can.
Messages are not stored on your computer and are not associated with any personally identifiable information. Messenger strives to be truly anonymous and there is no way, short of identifying yourself in the message, for the officer to identify the author.
The website also uses secure technology such as HTTPS encryption and not caching data to ensure that malicious people cannot eavesdrop on your connection to the website.
A former resident of Burgmann College, Wayne Tsai. You can view the open-source code for the website here: Github. He is also the person you should email if there are any problems using this website.
« Back to home {% endblock %}


Our Story
Menu
Reservations
News
Rviews
resto restaurant home page website template
The Menu
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
Voluptate cillum fugiat.
Cheese, tomato, mushrooms, onions.
$50
load more
|
Featured Dishes
$30
Fugiat nulla sint
$24
Daute irure dolor
$60
Officia deserunt mollit
$17
Pim minim veniam
The Gallery


Natural health for your hair
Hair saloon, expert in natural treatments with natural products.
Hair saloon, expert in natural treatments with natural products.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
More than 10 years of experience, Beautysalon is already in customers hearts all around the country with its exclusive natural hair treatments only we can provide.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book


Get ready, Git set, Let's go. Time for a new developer vision. Full Stack Web Dev with that grey touch. FSWD on point! Independent Team Player. (That is a great oxymoron) Html 5, CSS 3, Less, Sass, PUG, FlexBox, Grid, Boot Strap, Git, Github, VS Code efficient!


--- project-id: 4 title: Love Letter type: UI/UX design, game design tag: datadesign date: 1000-01-04 img: main screen.jpg alt: landing page of the app description: A friend and I were bored and restless during the pandemic. So we implemented our favourite board game, Love Letter, onto a locally-hosted web platform to play with the rest of our friends over Zoom. The interface design included the layout and positioning of 18 cards and 3 screens which incorporated all gameplay controls (points, tokens) to support interactive online play for up to 8 players. ---
{% include head.html %} {% include js.html %} {% include stylesheets.html %} {% include nav.html coloured_back="transparent_back" %}"The good Princess Annette, heartbroken over the recent arrest of her mother Queen Marianna for high treason, has locked herself in the palace.  Since you cannot reach her immediately, you must rely on intermediaries to carry your message."
A friend and I were bored and restless during the pandemic. So we implemented our favourite board game, Love Letter, onto a locally-hosted web platform to play with the rest of our friends over Zoom. The interface design included the layout and positioning of 18 cards and 3 screens which incorporated all gameplay controls (points, tokens) to support interactive online play for up to 8 players.
Project Type: {{ page.type }}
Role: end-to-end UI design, front-end development, wireframing, prototyping, playtesting
Tools: Figma for wireframing and design, ReactJS for development
Date: June 2020
Code: GitHub
Our aim was to make a simple, intuitive web application that would bring back the experience of playing a cozy board game with our loved ones. Love Letter is a strategy card game at its core, so I focused on three main goals:
Since this is an online game, I went for a contemporary and friendly aesthetic. I went for a gentle colour palette, easy-to-read typography, and intuitive iconography (to indicate any status changes).
At any point in time, a player could either be playing, spectating, or eliminated (in which case they'd still be spectating but outside the game circle).
Some cards give players additional properties. For example, on playing the 'Handmaid' card, a player receives immunity until their next turn. This was indicated by a simple shield.
A common starting point
Community
With the game being virtual and server-hosted, there can be a disconnect between players which may lead to them not knowing what's going on.
Ensured that all player screens are in sync with each other. Each player could see what was going on as if they were sitting in a circle.
Simple and easy-to-grasp iconography
Clean, Simple
Users who do not often participate in the gaming community find it hard to understand what symbols mean.
Introduced simple icons which you would come across daily.


How does JavaScript compare to HTML and CSS?
JavaScript is the interactive elements of a website. If HTML is the structure or walls/foundations of a house, and CSS is the design/visual elements, then JavaScript would be the doors and cupboards opening when they are pulled and anything else that moves.
Explain control flow and loops using an example process from everyday life, for example 'waking up' or 'brushing your teeth'.
A control flow sets out the steps that need to be followed to brush your teeth. A loop is then an instruction for the control flow to be repeated when certain conditions are met and until a condition is met.
Explain the difference between accessing data from arrays and objects.
Data within an object is accessed by using a name while data within an array is accessed by using an index number.
Explain what functions are and why they are useful.
A function is a block of code that performs a task when it is called. It is useful because it can be reused with diffrerent input (arguments) to give a different result or data set.


All Classes and Interfaces
Class
Description
Abstract class for annotation listeners.
Abstract component instantiator.
Abstract registry of FluentLenium factories.
Abstract class conditions on list of elements.
Common interface for Integer conditions.
Abstract proxy handler supporting lazy loading and hooks on
WebElement
.
Abstract proxy handler supporting lazy loading and hooks on
WebElement
.
Abstract search matcher.
Abstract implementation supported negation and instantiation.
Abstract supplier providing toString() representation from elements proxy
and search filters.
A equivalent of JUnit @
After
.Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Extension of Selenium's own Alert interface to manage browser alert.
Default implementation for alert assertions.
Provide control for alert windows.
Manages a browser alert.
Listen to alert
Interface for asserting the state of alert boxes.
ConfigurationProperties
based on FluentConfiguration
annotation.
Exception to be thrown when an annotation cannot be found on an
element.
ElementLocator
retrieving a particular index element from
another locator.
Conditions for list of elements, matching when at least one element of
the list matches.
Base assertion interface for attribute validation within a single
attribute value or a list of attribute values.
Search filter based on attribute value.
Filter a FluentWebElement collection to return only the elements with the
same text
Control interface for fluent wait.
Base configuration class supporting setting of the global
configuration.
Common class form filling features storing the potential elements to
fill.
Base hook supporting
FluentWebElement
API.
Base hook implementation.
Base condition for list of objects
Common class for all wait conditions instances.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Add this annotation on a method to register it in
EventsRegistry
.
Static class that are in charge of analyzed the filter and matcher.
Control capabilities of the underlying Selenium WebDriver.
Factory of
Capabilities
A registry of
CapabilitiesFactory
.
Capabilities registry default implementation.
Desired capabilities factory.
Exception for when the chromium api is not supported by browser.
Control interface for chromium api.
Inspired by
Annotations
, but use a Class instead of a Field
to retrieve the annotations.
Stores and handles
SharedWebDriver
instances for test Class
es.
Utility methods for working with collections.
Commands for the Chromium DevTools API.
A component encapsulate a Selenium WebElement, the FluentLenium control
interface and FluentLenium instantiator.
Thrown when something wrong occurs with a component.
Proxy handler for
WebElement
.Factory building new components.
List of Component.
Accessor interface to retrieve a component from it's selenium element.
Listen to components registration to register their events annotations
couterparts.
Constructor
A listener interface for components registration.
Manage living components for a WebDriver instance.
A configuration composed with a writable configuration and list of read
configurations.
Common interface for conditions.
Wrap object inside a condition.
Base configuration interface that can be read and written.
Default configuration implementation.
Exception thrown when something wrong occurs because of the configuration
of FluentLenium.
Creates new configuration from a container class.
Provider of configuration factory.
Mutation interface of Configuration Properties.
FluentLenium can be configured in many ways through configuration
properties.
Driver lifecycle.
Trigger mode for Screenshots and HtmlDump features
Register event annotations from a container in the events registry.
Context for a container
Container global FluentLenium control interface.
Creates container instances.
Matcher checking that actual contains input value.
Matcher checking that actual contains word from input value.
Control interface for CSS related features.
Control interface for css related features.
Features related to CSS loaded in the active page.
Features related to CSS loaded in the active page.
Annotation configuration custom property.
Default component instantiator.
Creates new configuration from a container class.
Context for a container
Creates container instances
Mark a factory as default factory that can be overriden without throwing
an exception.
Default minimal implementation for
FluentContainer
.
Default
FluentControlContainer
implementation, using a simple variable to store the FluentDriver
instance.
Builder of hook chains from element supplier, element locator supplier
and hook definitions list.
Default implementation of
PerformanceTiming
.
Default implementation of
PerformanceTimingMetrics
storing the metrics value as a Map
.
Properties backend based on java
Properties
object.
Default implementation of
SharedMutator
,
returning unchanged parameters.
Utility class with default WebDriver factories.
Chrome WebDriver factory.
Edge WebDriver factory.
Firefox WebDriver factory.
HtmlUnit WebDriver factory.
Internet Explorer WebDriver factory.
Opera WebDriver factory.
Remote WebDriver factory.
Safari WebDriver factory.
List that delegates to another list
Handles XPath axes for an element (W3Schools XPath Axes).
Conditions for integer
Conditions for list of elements, matching when each element matches.
Assertion interface for element attribute validation.
ElementLocator
for an already found WebElement
instance.
Listen to element events.
ElementLocator
for an already found list of
WebElement
instance.
Element locator implemented by a
Supplier
of list of WebElement
.
Search context backed by an ElementLocator.
Interface for asserting the state of an element.
Element locator implemented by a
Supplier
of WebElement
.
Utility class for elements.
Matcher checking that actual ends with input value.
Properties backend based on environment variables.
Matcher checking that actual is equal to input value.
Thrown when something wrong occurs with event annotations.
Listener interface for events.
Control interface for events.
Registry of event listeners.
EventsSupport can be registered in Selenium
EventFiringWebDriver
to provide an
easier to use events interface.
Listen to exceptions.
Marker interface for factories.
Define names for a factory
Add names to a factory.
Defines the priority of the factory.
Default form filling features.
Provides functionality to select values in
<select>
elements.
Builder for search filters
Filter constructors.
Listener interface for FindBy events
ElementLocator
retrieving the first element from another
locator.
All actions that can be used on the list or on a web element.
Generic adapter to
FluentDriver
.
Base assertion interface.
Conditions API for elements.
Configure a FluentLenium test class with this annotation.
Boolean value used in annotation that can has a third DEFAULT value
equivalent to null.
Container object that can be initialized with a
FluentControl
.
Global control interface for FluentLenium.
Container for
FluentControl
of the actual test adapter.
Default implementation of
FluentControl
.
Provides the FluentControl for actual test.
Cucumber implementation of
SharedMutator
,
replacing testClass
with a null reference
as it doesn't make sense in case of Cucumber tests, and raising a
ConfigurationException
when
ConfigurationProperties.DriverLifecycle.CLASS
is given
to link WebDriver
instances with classes defining step definitions.
Cucumber FluentLenium Test Runner Adapter.
Wrapper class for a
WebDriver
instance which also offers
shortcut and convenience methods,
as well as methods to work with mouse, keyboard and windows.
Takes HTML dump.
Persists a screenshot to a target file.
Configures a
WebDriver
instance with timeouts from a Configuration
.
Provides wrapped WebDriver capabilities for
FluentDriver
.
Hook interface.
Control interface for FluentLenium injection.
Exception thrown when a Page can't be initialized.
Execute a script and map it's result.
Javascript actions that can be used on the list or on a web element.
Javascript actions that can be used on a list or on a web element.
FluentTest extension for JUnit Jupiter.
Apply label and label hints to element.
Apply label and label hints to element.
Provides label and label hints definitions.
FluentLenium assertions entry point.
Driver interface for
ConfigurationProperties.DriverLifecycle
based
SharedWebDriver
handling.
Wraps a list of
FluentWebElement
.
Default implementation for
FluentList
assertions.
Conditions API for list of elements.
Default implementation of
FluentList
and ComponentList
.
Builder for fluent list size assertion.
It is an object factory for creating Cucumber steps objects in
FluentLenium injection container.
Use the Page Object Pattern to have more resilient tests.
Provides controls for a Page Object.
State of the element locator proxy.
Create an instance of this class if you want to use FluentLenium as an
automation framework only.
Extend this class and implement
FluentStandaloneRunnable.doRun()
if you want to use FluentLenium as an automation framework only.
Used to locate a given frame or window.
Fluent wrapper for
WebDriver.TargetLocator
.JUnit 4 FluentLenium Test Runner Adapter.
JUnit 5 FluentLenium Test Runner Adapter.
Container class for
FluentCucumberTest
.
TestNG FluentLenium Test Runner Adapter.
TestNG FluentLenium Test Runner Adapter.
Equivalent of
TestWatcher
, but stop process if exception
occurs on
starting method call.
FluentLenium Test Runner Adapter.
A wait object wrapping default selenium
FluentWait
object
into a more
complete API, allowing to wait for any condition to be verified.
Conditions API for Fluent wait objects.
Configuration API of fluent wait object.
A wait object wrapping default selenium
FluentWait
object
into a more
complete API, allowing to wait for any condition to be verified on an underlying
element.
A wait object wrapping default selenium
FluentWait
object
into a more
complete API, allowing to wait for any condition to be verified on underlying elements.
Functional API of fluent wait.
Page wait conditions
Window wait conditions.
Wraps a Selenium
WebElement
.Default implementation for
FluentWebElement
assertions.
Listen to ScreenshotAs.
Annotation used to declared a hook on a test adapter, container or
element field.
Builder of hook chains from element supplier, element locator supplier
and hook definitions list.
Control interface for hooks.
Control implementation for hooks.
Definition of a hook, containing class of the hook and defined options
Exception that can occur when applying a hook.
Annotation used to declared hook options.
HtmlUnit specific implementation of
PerformanceTimingMetrics
.
Provides logic for screenshot and image manipulation and conversion.
Classes marked with this annotation will be ignored by automatic
registration in
Factory
Inspired by
Annotations
, but also supports annotations
defined on
return type class.
The injection element locator, which will lazily locate an element or an
element list on a page.
ElementLocator
factory used by FluentInjector
.
Access interface for input controls.
Conditions API for Integer.
Conditions for integer
Conditions for list of integers.
Deprecated.
Control interface to execute script, synchronously or asynchronously.
Stores and handles a
SharedWebDriver
instance for the whole JVM.
Execute actions with the keyboard.
Execute actions with the keyboard on a defined element.
Define a label on an injected
FluentWebElement
or
FluentList
.
Using this annotation, the value of
toString()
method of the
injected object will be
extended with the list of hints provided to the annotation.
ElementLocator
retrieving the last element from another
locator.
A list of component that lazy initialize from it's related list of
elements.

Listen to lazy components events.
Assertion interface for attribute validation within a list of elements.
Get actual condition elements list.
Listener attached to a container.
Support for priority between listeners.
Compare listeners implementing
ListenerPriority
.
Proxy handler for list of
WebElement
.Conditions API for FluentLists.
Interface for asserting the state of an element.
Utility class to create proxies of WebElement, Component, FluentList and
List of Components based on their locators.
Interface to control and retrieve the status of
LocatorHandler
s.
Matcher constructors.
Matcher types actually actually supported by the framework.
Message to generate.
Represent a call on the
MessageProxy
builder.
Invocation handler that builds message based on called performed.
Message context to append.
Provides message proxy implementations of interface that records calls to
build message from methods annotated with
Message
,
NotMessage
and MessageContext
.
Stores and handles
SharedWebDriver
instances for test methods.
CapabilitiesFactory
based on invocation of a defined method.
Exception to be thrown when a method cannot be found.
MockitoExtension
showcases the TestInstancePostProcessor
and ParameterResolver
extension APIs of JUnit 5 by providing
dependency injection support at the field level and at the method parameter
level via Mockito 2.x's @Mock
annotation.
Execute actions with the mouse.
Element specific mouse control interface.
Listener interface for Navigate events
Direction of the navigation
Listener interface for Navigate events
Listener interface for NavigateTo events
Control interface for navigation.
Marker annotation for negation of this object.
Remove current hook definitions from the container context.
When this annotation is applied on a field FluentLenium injection is
disabled for that.
Matcher checking that actual doesn't contain input value.
Matcher checking that actual doesn't end with input value.
Implementation of
LazyComponents
for a non lazy components wrapper.
Message to generate when negation is applied.
Matcher checking that actual doesn't start with input value.
Mark a field as a Page Object that should be automatically created by
FluentLenium.
Default implementation for asserting
FluentPage
objects.
Interface for asserting the state of
FluentPage
objects.
PageUrl is a class annotation used instead of getUrl method
of
FluentPage
object.
Stores a URL and URL parameters parsed from that URL for caching purposes
in
FluentPage
.
Mark a field whose class declaration is annotated with one of Selenium's
Find...
annotation,
with this annotation to inject the parent container.
Parsed URL template.
Interface representing the PerformanceTiming API defined by W3C under
Performance
Timing interface.
Control interface for accessing an API for querying W3C Performance
Timing event values.
Provides event types according to the
W3C Performance Timing interface. documentation.
Wraps the performance timing metrics returned by the
window.performance.timing
Javascript attribute
from the browser, and provides methods to access each value in it.
Factory for creating
PerformanceTimingMetrics
objects.
Utility methods for validating objects' status.
Search filter based on a predicate.
Configuration
based on JavaBean properties.
Reader interface for raw properties access.
Abstract properties configuration.
Proxy element listener.
Conditions API for Rectangle
Conditions for rectangle.
Conditions for list of rectangles.
Utility class for reflection.
A simple
CapabilitiesFactory
that create Capabilities
instances using reflection.
Reflective factory.
A simple
WebDriverFactory
that create WebDriver
instances using reflection.
Exception type to be thrown when a screenshot taking process couldn't
finish.
Listener interface for Script events
Perform element searchs in a given context.
Control interface to search for elements.
Search filter interface
Control interface for selenium underlying web driver.
Responsible for retrieving information about Selenium version from
pom.xml (if present).
Defines mutations of parameters used for
SharedWebDriverContainer
method calls.
Effective parameters used by the test.
A reference to a shared
WebDriver
used by a test.A singleton container for all running
SharedWebDriver
in the JVM.
Shutdown hook closing the Shared WebDriver container when JVM is
closing.
Control interface for Screenshot and HTML Dumps.
Matcher checking that actual starts with input value.
Conditions API from String.
Conditions for string
Conditions for list of string.
Supplier returning a defined instance, with toString() implementation
calling
toString() on the instance without wrapping it.
Listen to switch window
Properties backend based on java system properties.
TestNG attempts to run default methods from inherited interfaces when
there is class @Test annotation.
Stores and handles
SharedWebDriver
instances for test methods and thred ids.
Alternative
FluentControlContainer
implementation, using a ThreadLocal variable to store the
FluentDriver
instance.
Provides functionality to convert
TimeUnit
s
to
ChronoUnit
s.
Experimental: Find element in shadow root using CSS selector
URL Parameter.
A simple template engine for URL parameters.
Utils class for Url manipulation.
Annotation to enable the Wait Hook.
Invocation handler used to wait for a particular conditions call.
Provides proxy implementations of conditions that performs wait from
those conditions.
Hook that automatically wait for actions beeing available on the
underlying element.
Options for
WaitHook
.
Exception type to be thrown when the wait performed by FluentLenium is
interrupted.
Factory of
WebDriver
, that can be registered in WebDrivers
registry.
A registry of
WebDriverFactory
.
WebDrivers registry implementation.
Fluent object to handle
ExpectedConditions
on
FluentWebElement in fluentlenium API.
Execute actions on active window.
Allows to retrieve underlying wrapped elements.
FluentStandaloneRunnable
andFluentStandalone
.


Click here to go to the corresponding page for the latest version of DIALS
Installation¶
Stable Release: DIALS 2.0¶
The current stable release can be downloaded from Github, where you can also find further release notes.
Development Builds¶
Nightly build installers are available for Linux and Mac OS and may be downloaded from LBL or Diamond. Builds for Microsoft Windows are experimental and may not work as expected. For instructions on compiling from source or setting up a DIALS development environment, see Installation for Developers.
Installation¶
Mac graphical binary installers¶
We provide a graphical package installer for Mac users. Download the
Mac OS X 10.11
or
Mac OS X 10.6
installer and double click the .pkg
file to start the
graphical installer. Follow the instructions, which will install DIALS in the
/Applications/
directory. To use DIALS, open a new terminal window and type,
e.g.:
source /Applications/dials-dev20150903/dials_env.sh
to setup the DIALS environment.
Mac and Linux binary installers¶
We provide binary tar.gz
and tar.xz
files for various Mac and Linux
platforms, e.g. on Linux:
wget http://dials.diamond.ac.uk/diamond_builds/dials-linux-x86_64.tar.xz
tar -xJf dials-linux-x86_64.tar.xz
cd dials-installer-dev
Or on Mac:
curl http://dials.diamond.ac.uk/diamond_builds/dials-macosx.tar.gz > dials-macosx.tar.gz
tar -xzf dials-macosx.tar.gz
cd dials-installer-dev
Then to install in the /usr/local directory (you may need to add a sudo
before the command):
./install
or to install in a specified directory:
./install --prefix=/path/to/installation/directory/
To use DIALS, open a new terminal window and type, e.g.:
source /path/to/installation/directory/dials-dev/dials_env.sh
Windows installation¶
DIALS support on Windows is currently experimental and we do not provide Windows release binaries.
To use DIALS you need to unpack the .zip archive, open a command prompt, navigate to the dials-installer directory, and run:
dials_env


You can create a control to display local or remote web pages in your App using the CreateWebView method
of the app object:
web = app.CreateWebView( width, height );
If you are loading remote web pages, then you might want to use the SetOnProgress method to
set the name of a callback function that you want called to report the progress of loading the page.
You can use the LoadUrl method to load an internal or external web page or the LoadHtml
method to load text directly from within your App.
web.LoadUrl( url, options );
web.LoadHtml( html, baseFolder, options );
The supported options for LoadUrl and LoadHtml are: "allowzoom" (support zooming gestures), "autozoom" (zoom out the content to fit the WebView by width), "wide" (support the viewport meta tag, a wide viewport is used if the viewport meta tag is missing) and "nolongtouch" (WebView will not react to long touches).
Note: Using a WebView can be a good way of displaying colored and formatted text areas in your App. If you set the
BackColor to a transparent color you can show formatted text over a background image.
If you need to, you can use the Execute method to execute JavaScript code within the WebView.
web.Execute( text );
Example - Remote
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
web = app.CreateWebView( 0.8, 0.8 );
web.SetOnProgress( web_OnProgess );
lay.AddChild( web );
app.AddLayout( lay );
app.ShowProgress("Loading...");
web.LoadUrl( "http:///www.google.com" );
}
function web_OnProgess( progress )
{
app.Debug( "progress = " + progress );
if( progress==100 ) app.HideProgress();
}
Example - Local
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
web = app.CreateWebView( 0.8, 0.8 );
web.SetBackColor( "#00000000" );
lay.AddChild( web );
app.AddLayout( lay );
web.LoadUrl( "file:///Sys/Html/Page.htm" );
}
Example - Direct
function OnStart()
{
lay = app.CreateLayout( "linear", "VCenter,FillXY" );
web = app.CreateWebView( 0.8, 0.8 );
web.SetBackColor( "#00000000" );
lay.AddChild( web );
app.AddLayout( lay );
var html = "";
html += "<meta name='viewport' content='width=device-width'>";
html += "Hello World!
";
html += "";
html += "";
web.LoadHtml( html, "file:///Sys/" );
}
See 'CreateWebView for more informations and a complete function list