MIRACLE PLUS NECK AND SHOULDER PAIN RELIEF- capsaicin gel
Concept Laboratories, Inc.
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
Active ingredient
Capsicum Oleoresin 0.0625%
(Containing Capsaicin 0.025%)
Uses
for the temporary relief of minor aches and pains of muscles and joints associated with
- simple backache
- arthritis
- strains
- sprains
- bruises
Warnings
For external use only.
- do not apply to wounds or damaged skin
- do not bandage tightly
- do not use with heating pad, wrap, hot water bottle or any heating element.
When using this product do not get into eyes
- avoid contact with other mucous membranes
Discontinue use and ask a doctor if condition worsens or if symptoms persist for more than 7 days or clear up and occur again within a few days
Keep out of reach of children.
- if swallowed, get medical help or contact a Poison Control center right away
-
if pregnant or nursing, seek the advice of a health professional before using
Directions
- Children under 12 years of age consult a physician
- Apply a thin layer to affected area not more than 3 to 4 times daily
- Gently massage into the skin until fully absorbed
- Wash hands with soap and water after each application to avoid spreading to the eyes or other sensitive mucous membranes
Other information
- It is recommended to test for skin sensitivity prior to use. Apply product to a small area, follow the directions and wait 24 hours. Proceed with application if no adverse reaction.
- A burning sensation may occur upon initial application but generally disappears with continued use. For a severe burning discomfort, remove excess product with a soft cloth and cooking oil.
- If applying product to hands, wait 30 minutes before washing.
- Avoid water, heat, or direct sunlight while using product.
- If wearing contact lenses, insert prior to application and avoid touching them after applying product.
- If eye contact occurs, flush immediately with water.
Inactive ingredients
Water (Aqua), Glycerin, PEG-75 Lanolin, Aloe Barbadensis Leaf Juice, PEG-40 Hydrogenated Castor Oil, Acrylates/C10-30 Alkyl Acrylate Crosspolymer, Triethanolamine, Polysorbate 20, Glucosamine HCl, Emu Oil, Dimethyl Sulfone, Celosia Argentea Seed Extract, Ginkgo Biloba Extract, Panax Ginseng Root Extract, Medicago Sativa (Alfalfa) Extract, Cymbopogon Schoenanthus Extract, Tocopheryl Acetate, DMDM Hydantoin, Propylene Glycol, Methylparaben, Propylparaben.
Questions or comments?
Call 1-888-373-8831 or visit www.conceptlabs.org
Manufactured by Concept Laboratories, Inc., Chicago, IL 60642
PRINCIPAL DISPLAY PANEL - 113 g Bottle Label
MIRACLE
PLUS®
Neck & Shoulder
Pain Relief
with Capsaicin
Fast Relief from:
- Muscle Pain
- Joint Pain
- Backache
- Arthritis
Greaseless • Odorless • with Aloe Vera
NET WT 4 OZ (113 g)
Concept Laboratories, Inc.


JKS Foods and Restaurant, the Best in Town
Order Online +91-892-808-5056
Hey this is a template website. Made by Willis Digital this website is fullly functional and offers great help to begginers. This website was initially made for a client but due to some issues i am making it open source.


Flatsheet editor demo
Edit tabular data and get JSON/CSV.
Your work is automatically saved using IndexedDB.
row
column
json
csv
reset
Learn more about Flatsheet and this demo.
Add your first column to get started.
close


3.1.15. How to Execute a Request Unit Test (Sending Synchronous Message Process)¶
<IP_ADDRESS>. Structure and test scope of the output library (sending synchronous message process)¶
The request unit test for the sending synchronous message process is done in the request ID [1]unit granted to the process.
| [1] | Note that the request ID used here refers to an ID that is defined to uniquely identify the function of the destination system to which a message is sent, and has a different meaning from the request ID used in web applications and batch processes. The format, format of the request and response messages, send queue name, and receive queue name are determined based on this request ID. |
- In this section, a message sent by action to a queue is referred as a “request message” and a message received from the queue by an action is referred a “response message”.
The following is an image of a request unit test
Tip
The automated test framework does not use “send queue” or “receive queue” but asserts the request message and generates the response message before the queue. Therefore, no special middleware installation or configuration is required.
The features and advantages of the request unit test of the sending synchronous message process executed using the automated test framework are listed below.
- Easy-to-write test data
In most cases, the field length of the message layout is fixed, and it is difficult to describe it as test data like a fixed-length file. However, the automated test framework can describe test data according to the format definition of the external interface design document by using the Excel file.
In addition, a test data format for sending synchronous message processes is provided. By conforming to this, test data can be easily created. These features make it easy to create and maintain test data.
- No need to write test code for sending synchronous messages
Test data (expected value of request message and response message) can be described in Excel, and the automated test framework automatically asserts request message and returns response message based on the test data.
A super class that implements such a typical routine is provided, and by using it, test preparation, test target execution, and confirmation of test result are possible. As a result, the test can be executed with almost no coding using only the test data.
<IP_ADDRESS>. How to conduct the test¶
The testing of sending synchronous message process follows the testing architectures of web applications and batch processing. For information on how to write test classes and prepare various preparatory data, refer to How to conduct these tests.
This section describes only how to execute the sending synchronous message process.
<IP_ADDRESS>.1. How to write test data¶
The Excel file containing the test data should be stored in the same directory with the same name as the test source code, same as in the class unit test (only the extension differs).
For information on how to write test data, refer to Test data description using Excel.
<IP_ADDRESS>.1.1. The expected value of the request message and the preparation of the response message to be returned¶
When sending a sending synchronous message, the formats and data of the header and body parts of the request and response messages are defined for each request ID.
The test case, the expected value of the request message, and the response message are associated with the group ID. Specifically, the group IDs listed in the expectedMessage and responseMessage fields of the test case correspond to a table with the corresponding identifier.
If the expectedMessage and responseMessage fields are not found in the list of test cases, no verification is performed. If this field is blank and sending of the synchronous message process is performed, the test will fail. When sending of the synchronous message process is performed, expectedMessage and responseMessage must be included.
If more than one message with the same group ID and the same request ID is sent in a single test case, the data lines for the number of request and response messages should be described. The order of the no columns (sequential number) matches the order in which they are sent.
- See below for more information on how to write a test case.
The following is the test data written in Excel. (Group ID association is also shown)
Tip
In the sending synchronous message function provided as standard by Nablarch, the header part of the request message and response message uses a common format, so the format definition of the header part of the test data should also be unified for each request. Regarding the body part, different formats can be defined in the request message and the response message.
The table of expected value of the request message and response message to be returned are described in the following format.
| Identifier | |||
| Directive line | Directive configuration value | ||
| ... [2] | ... | ||
| no | Field name(1) | Field name(2) | ... [3] |
| Data type(1) | Data type(2) | ... | |
| Field length(1) | Field length(2) | ... | |
| Data(1-1) | Data(2-1) | ... | |
| Data(1-2) | Data(2-2) | ... | |
| ... [4] | ... | ... |
| [2] | Below this, the number of directives continues in the same way. |
| [3] | On the right side, the number of fields continues in the same way. |
| [4] | Below this, the number of data continues in the same way. |
| Name | Description |
|---|---|
| Identifier | Specifies an ID that indicates the message type. This item is associated with the group ID described in expectedMessage and responseMessage in the test case list. The format of the identifier is shown below.
|
| Directive line [5] | Describes the directive. The cell to the right of the directive name cell contains the configuration value (multiple lines are allowed). |
| no | Write “no” in the line below the directive line. |
| Field name | Describes the field name. Describes only the number of fields. |
| Data type | Describes the data type of the field. Describes only the number of fields. The data type is described with a Japanese name such as “half-width alphabets(半角英字)”. Refer to the member variable DEFAULT_TABLE of BasicDataTypeMapping for the mapping between data types in the format definition file and data types with Japanese names. |
| Field length | Describes the field type of the field. Describes only the number of fields. |
| Data | Describe the data stored in that field.If multiple records exist, the entry of data should be continued in the next line. Describe the data stored in that field.When the same request ID is sent synchronously multiple times in the same test case, the data is described following the next line. |
| [5] | When writing a directive, the contents corresponding to the following in the format definition file need not be described.
|
Important
Duplicate names are not allowed for field names. For example, there should be not more than 1 field named as “Name”. (Usually, in such cases, a unique field name is assigned, such as “member name” and “family member name”)
Tip
Field names, data types and field lengths can be efficiently created by copying and pasting them from the external interface design document. (Check the “transpose matrix” option when pasting)
The following is an example of a description of the expected value in the body of a specific request message.
The expected value of the header of a request message and the body and header of a response message are described in the same way as the expected value of the body of a request message, except for the identifier, which is described here.
In this example, it is expected that a request message that satisfies the following specifications will be sent.
- Request ID is
RM21AA0104
- Character code is
Windows-31J
- Record delimiting character is CRLF
CRLF
- Record classification is
1
,User ID is<PHONE_NUMBER>
,Login ID is nabura
Important
When there are multiple records in a request message, you may want to describe multiple business data in a single header as follows.
- Header
- Business data (first record)
- Business data (second record)
- Business data (third record)
However, in the automated test framework, it is necessary to describe the header and the record alternately as follows. If the header is not defined in duplicate, an assertion error occurs because the number of business data and the header does not match.
- Header
- Business data (first record)
- Header
- Business data (second record)
- Header
- Business data (third record)
When sending a message multiple times, the test should be written with attention to the following specifications of the testing framework.
- The same data types (
RESPONSE_HEADER_MESSAGES
andRESPONSE_BODY_MESSAGES
in the following example) are described together, respectively. For more information, see To describe the data of multiple test cases on a single sheet and Describing data by grouping together based on data types when using multiple data types. - For messages with the same request ID, the value of no is changed and the messages are described together.
The following is a description example of the expected value of the request message body when a message is sent multiple times.
Tip
If there are multiple request IDs to be sent, testing the order is not possible. In the above example, the test is successful even if ProjectInsert2Messag
is sent before ProjectInsertMessage
.
<IP_ADDRESS>.1.2. Failure pattern test¶
The failure pattern can be tested by configuring a specific value starting with “errorMode:” in the table of the response message.[6]
The correspondence between the configuration values and failure pattern tests is shown below.
Value to be configured for the first field Failure description Operation of the automated test framework errorMode:timeout
Test if timeout error occurs while sending the message Throws MessageSendSyncTimeoutException (subclass of MessagingException) errorMode:msgException
Test when a message send and receive error occurs Throws MessagingException
This value should be in the first field, excluding “no”, in both the header and the body of the table in the response message.
The following is an image of the setting in Excel.
| [6] | If the business action does not explicitly control MessagingException, there is no need to perform fault testing in individual request unit tests. |
<IP_ADDRESS>.2. Test result verification¶
When the expected value of the request message is defined, the following verification is performed in the automated test framework.
- Verification of the request message contents
- Verification of the number of send request messages


Distributed processing of a batch of tasks.
Overview
One common usage pattern for distributed computing involves processing a long list of commands (aka tasks):
( cd /path/to/workdir ; source SetupEnv ; myprog -a 0 -b 0 -c 0 ) &> task_0_0_0.log
( cd /path/to/workdir ; source SetupEnv ; myprog -a 0 -b 0 -c 1 ) &> task_0_0_1.log
...
( cd /path/to/workdir ; source SetupEnv ; myprog -a 9 -b 9 -c 8 ) &> task_9_9_8.log
( cd /path/to/workdir ; source SetupEnv ; myprog -a 9 -b 9 -c 9 ) &> task_9_9_9.log
One could do this by submitting 1,000 separate jobs to a cluster computer, but that may present problems for the queuing system and can behave badly if the system is configured to handle jobs in a simple first come, first serve fashion.
Another alternative is to use a resource management system’s native support for job arrays, but this often requires massaging the commands to reflect syntax specific to a particular system’s implementation of job arrays.
And what if you don’t have a cluster available, but do have a collection of networked computers? Or you just want to make use of multiple cores on your own computer?
In any event, when processing such a list of tasks, it is helpful to acquire metadata about the execution of each task: where it ran, how long it took, its exit return code, etc.
disBatch has been designed to support this usage in a simple and portable way, as well as to provide the sort of metadata that can be helpful for debugging and reissuing failed tasks.
It can take as input a file, each of whose lines is a task in the form of a command sequence. For example, the file could consists of the 1000 commands listed above. It launches the tasks one after the other until all specified execution resources are in use. Then as one executing task exits, the next task in the file is launched. This repeats until all the lines in the file have been processed.
Each task is run in a new shell. If you want to manipulate the execution environment of a task, add the appropriate operations to the command sequence—source SetupEnv
in the above is one example. For another, if you just need to set an environment variable, each task line would look something like:
export PYTHONPATH=/d0/d1/d2:$PYTHONPATH ; rest ; of ; command ; sequence
Or, for more complex set ups, command sequences and input/output redirection requirements, you could place everything in a small shell script with appropriate arguments for the parts that vary from task to task, say RunMyprog.sh:
#!/bin/bash
id=$1
shift
cd /path/to/workdir
module purge
module load gcc python3
export PYTHONPATH=/d0/d1/d2:$PYTHONPATH
myProg "$@" > results/${id}.out 2> logs/${id}.log
The task file would then contain:
./RunMyprog.sh 0_0_0 -a 0 -b 0 -c 0
./RunMyprog.sh 0_0_1 -a 0 -b 0 -c 1
...
./RunMyprog.sh 9_9_8 -a 9 -b 9 -c 8
./RunMyprog.sh 9_9_9 -a 9 -b 9 -c 9
See #DISBATCH directives below for ways to simplify task lines.
Once you have created the task file, running disBatch is straightforward. For example, working with a cluster managed by SLURM, all that needs to be done is to submit a job like the following:
sbatch -n 20 --ntasks-per-node 5 disBatch TaskFileName
This particular invocation will allocate sufficient resources to process 20 tasks at a time, with no more than five running concurrently on any given node. disBatch will use environment variables initialized by SLURM to determine the execution resources to use for the run. This invocation assumes an appropriately installed disBatch is in your PATH, see below for installation notes.
Various log files will be created as the run unfolds:
TaskFileName_134504_status.txt
(assuming the SLURM Job ID is134504
): status of every task (details below)disBatch_134504_driver.txt
(can be changed with-l
),TaskFileName_134504_worker032_engine.txt
: The disBatch log file contains details mostly of interest in case of a problem with disBatch itself. It can generally be ignored by end users (but keep it around in the event that something did go wrong—it will aid debugging). The ``*_engine.txt’’ files contain similar information for each node acting as an execution resourcedisBatch_134504_kvsinfo.txt
: TCP address of invoked KVS server if any (for additional advanced status monitoring)
Status file
The _status.txt
file contains tab-delimited lines of the form:
314 315 -1 worker032 8016 0 10.0486528873<PHONE_NUMBER>.78<PHONE_NUMBER>.83 0 "" 0 "" 'cd /path/to/workdir ; myprog -a 3 -b 1 -c 4 > task_3_1_4.log 2>&1'
These fields are:
Flags: The first field, blank in this case, may contain
E
,O
,R
,B
, orS
flags. Each program/task should be invoked in such a way that standard error and standard output end up in appropriate files. If that is not the caseE
orO
flags will be raised.R
indicates that the task returned a non-zero exit code.B
indicates a barrier (see below).S
indicates the job was skipped (this may happen during “resume” runs).Task ID: The
314
is the 0-based index of the task (starting from the beginning of the task file, incremented for each task, including repeats).Line number: The
315
is the 1-based line from the task file. Blank lines, comments, directives and repeats may cause this to drift considerably from the value of Task ID.Repeat index: The
-1
is the repeat index (as in this example,-1
indicates this task was not part of a repeat directive).Node:
worker032
identifies the node on which the task ran.PID:
8016
is the PID of the bash shell used to run the task.Exit code:
0
is the exit code returned.Elapsed time:
10.0486528873
(seconds),Start time:
1458660919.78
(epoch based),Finish time:
1458660929.83
(epoch based).Bytes of leaked output (not redirected to a file),
Output snippet (up to 80 bytes consisting of the prefix and suffix of the output),
Bytes of leaked error output,
Error snippet,
Command:
cd ...
is the text of the task (repeated from the task file, but see below).
Installation
Users of Flatiron resources: disBatch is available via the module system. You do not need to clone this repo to use it.
disBatch requires the kvsstcp
package, which should be installed in python’s path, or placed in this directory.
You can simply clone this git repository with --recursive
(or run git submodule update --init
if you’ve already cloned it) to get both.
No additional installation steps are required. You can run disBatch
directly from the top level directory of the git clone, but depending on your execution environment (e.g., using SLURM), the ability of disBatch to determine the location of itself and kvsstcp may be disrupted. To avoid such problems, set the environment variable PYTHONPATH
to include the path of the git clone (the directory containing this “Readme.md” file).
disBatch is designed to support a variety of execution environments, from your own desktop, to a local collection of workstations, to large clusters managed by job schedulers.
It currently supports SLURM and can be executed from sbatch
, but it is architected to make it simple to add support for other resource managers.
You can also run directly on one or more machines by setting an environment variable:
DISBATCH_SSH_NODELIST=localhost:7,otherhost:3
or specifying an invocation argument:
-s localhost:7,otherhost:3
This allows execution directly on your localhost
and via ssh for remote hosts without the need for a resource management system.
In this example, disBatch is told it can use seven CPUs on your local host and three on otherhost
. Assuming the default mapping of one task to one CPU applies in this example, seven tasks could be in progress at any given time on localhost
, and three on otherhost
. Note that localhost
is an actual name you can use to refer to the machine on which you are currently working. otherhost
is fictious.
Hosts used via ssh must be set up to allow ssh to work without a password and must share the working directory for the disBatch run.
disBatch refers to a collection of execution resources as a context and the resources proper as engines. So the earlier SLURM example created one context with four engines (capable of running five concurrent tasks each), while the SSH example created one context with two engines (capable of running seven and three concurrent tasks, respectively).
Invocation
usage: disBatch [-h] [-e] [--force-resume] [--kvsserver [HOST:PORT]]
[--logfile FILE] [--mailFreq N] [--mailTo ADDR] [-p PATH]
[-r STATUSFILE] [-R] [-S] [--status-header] [-w]
[--taskcommand COMMAND] [--taskserver [HOST:PORT]]
[-C TASK_LIMIT] [-c N] [--fill] [-g] [--no-retire]
[-l COMMAND] [--retire-cmd COMMAND] [-s HOST:COUNT] [-t N]
[taskfile]
Use batch resources to process a file of tasks, one task per line.
positional arguments:
taskfile File with tasks, one task per line ("-" for stdin)
optional arguments:
-h, --help show this help message and exit
-e, --exit-code When any task fails, exit with non-zero status
(default: only if disBatch itself fails)
--force-resume With -r, proceed even if task commands/lines are
different.
--kvsserver [HOST:PORT]
Use a running KVS server.
--logfile FILE Log file.
--mailFreq N Send email every N task completions (default: 1). "--
mailTo" must be given.
--mailTo ADDR Mail address for task completion notification(s).
-p PATH, --prefix PATH
Path for log, dbUtil, and status files (default: ".").
If ends with non-directory component, use as prefix
for these files names (default: TASKFILE_JOBID).
-r STATUSFILE, --resume-from STATUSFILE
Read the status file from a previous run and skip any
completed tasks (may be specified multiple times).
-R, --retry With -r, also retry any tasks which failed in previous
runs (non-zero return).
-S, --startup-only Startup only the disBatch server (and KVS server if
appropriate). Use "dbUtil..." script to add execution
contexts. Incompatible with "--ssh-node".
--status-header Add header line to status file.
-w, --web Enable web interface.
--taskcommand COMMAND
Tasks will come from the command specified via the KVS
server (passed in the environment).
--taskserver [HOST:PORT]
Tasks will come from the KVS server.
context specific arguments:
-C TASK_LIMIT, --context-task-limit TASK_LIMIT
Shutdown after running COUNT tasks (0 => no limit).
-c N, --cpusPerTask N
Number of cores used per task; may be fractional
(default: 1).
--fill Try to use extra cores if allocated cores exceeds
requested cores.
-g, --gpu Use assigned GPU resources
--no-retire Don't retire nodes from the batch system (e.g., if
running as part of a larger job); equivalent to -k ''.
-l COMMAND, --label COMMAND
Label for this context. Should be unique.
--retire-cmd COMMAND Shell command to run to retire a node (environment
includes $NODE being retired, remaining $ACTIVE node
list, $RETIRED node list; default based on batch
system). Incompatible with "--ssh-node".
-s HOST:COUNT, --ssh-node HOST:COUNT
Run tasks over SSH on the given nodes (can be
specified multiple times for additional hosts;
equivalent to setting DISBATCH_SSH_NODELIST)
-t N, --tasksPerNode N
Maximum concurrently executing tasks per node (up to
cores/cpusPerTask).
The options for mail will only work if your computing environment permits processes to access mail via SMTP.
A value for -c
< 1 effectively allows you to run more tasks concurrently than CPUs specified for the run. This is somewhat unusual, and generally not recommended, but could be appropriate in some cases.
The --no-retire
and --retire-cmd
flags allow you to control what disBatch does when a node is no longer needed to run jobs.
When running under slurm, disBatch will by default run the command:
scontrol update JobId="$SLURM_JOBID" NodeList="${DRIVER_NODE:+$DRIVER_NODE,}$ACTIVE"
which will tell slurm to release any nodes no longer being used.
You can set this to run a different command, or nothing at all.
While running this command, the follow environment variables will be set: NODE
(the node that is no longer needed), ACTIVE
(a comma-delimited list of nodes that are still active), RETIRED
(a comma-delimited list of nodes that are no longer active, including $NODE
), and possibly DRIVER_NODE
(the node still running the main disBatch script, if it’s not in ACTIVE
).
The -g
argument parses the CUDA environment varables (CUDA_VISIBLE_DEVICES
, GPU_DEVICE_ORDINAL
) provided on each node and divides the resources between the running tasks. For example, with slurm, if you want to run on n nodes, with t tasks per node, each using c CPUs and 1 GPU (that is, tc CPUs and t GPUs per node, or ntc CPUs and nt GPUs total), you can do:
sbatch -N$n -c$c --ntasks-per-node=$t --gres=gpu:$t -p gpu --wrap 'disBatch -g $taskfile'`
-S
Starts disBatch in a mode in which it waits for execution resources to be added. In this mode, disBatch starts up the task management system and
generates a script <Prefix>_dbUtil.sh
, where <Prefix>
refers to the -p
option or default, see above. We’ll call this simply dbUtils.sh
here,
but remember to include <Prefix>_
in actual use. You can add execution resources by doing one or more of the following multiple times:
Submit
dbUtils.sh
as a job, e.g.:sbatch -N 5 --ntasks-per-node 7 dbUtil.sh
Use ssh, e.g.:
./dbUtil.sh -s localhost:4,friendlyNeighbor:5
Each of these creates an execution context, which contains one of more execution engines (five engines in the first, two in the second).
An engine can run one or more tasks currently. In the first example, each of the five engines will run up to seven tasks concurrently, while in the
second example, the engine on localhost
will run up to four tasks concurrently and the engine on friendlyNeighbor
will run up to five.
./dbUtil.sh --mon
will start a simple ASCII-based monitor that tracks the overall state of the disBatch run, and the activity of the individual
contexts and engines. By cursoring over an engine, you can send a shutdown signal to the engine or its context. This signal is soft, triggering
a graceful shutdown that will occur only after currently assigned tasks are complete. Other execution resources are uneffected.
When a context is started, you can also supply the argument --context-task-limit N
. This will shutdown the context and all associated engines
after it has run N
tasks.
Taken together, these mechanisms enable disBatch to run on a dynamic pool of execution resources, so you can “borrow” a colleague’s workstation overnight, or
claim a large chunk of a currently idle partition, but return some if demands picks up, or chain together a series of time limited allocations to
accomplish a long run. When using this mode, keep in mind two caveats: (i) The time quantum is determined by your task duration. If any given task might
run for hours or days, then the utility of this is limited. You can still use standard means (kill, scancel) to terminate contexts and engines, but
you will likely have incomplete tasks to
reckon with; (ii) The task manangement system must itself be run in a setting where a long lived process is OK. Say in a screen
or tmux
session on
the login node of a cluster, or on your personal workstation (assuming it has the appropriate connectivity to reach the other resources you plan to use).
-r
uses the status file of a previous run to determine what tasks to run during this disBatch invocation. Only those tasks that haven’t yet run (or with -R
, those that haven’t run or did but returned a non-0 exit code) are run this time. By default, the numeric task identifier and the text of the command are used to determine if a current task is the same as one found in the status file. --force-resume
restricts the comparison to just the numeric identifier.
--kvsserver
, --taskcommand
, and --taskserver
implement advanced functionality (placing disBatch in an existing shared key store context and allowing for a programmatic rather than textual task interface). Contact the authors for more details.
Considerations for large runs
If you do submit jobs with order 10000 or more tasks, you should
carefully consider how you want to organize the output (and error) files
produced by each of the tasks. It is generally a bad idea to have more
than a few thousand files in any one directory, so you will probably
want to introduce at least one extra level of directory hierarchy so
that the files can be divided into smaller groups. Intermediate
directory 13
, say, might hold all the files for tasks 13000 to
13999.
#DISBATCH directives
PREFIX and SUFFIX
In order to simplify task files, disBatch supports a couple of directives to specify common task prefix strings and suffix strings. It also provides environment variables to identify various aspects of the submission. Here’s an example
# Note there is a space at the end of the next line.
#DISBATCH PREFIX ( cd /path/to/workdir ; source SetupEnv ;
#DISBATCH SUFFIX ) &> ${DISBATCH_NAMETASKS}_${DISBATCH_JOBID}_${DISBATCH_TASKID}.log
These are textually prepended and appended, respectively, to the text of
each subsequent task line. If the suffix includes redirection and a task is a proper command sequence (a series of
commands joined by ;
), then the task should be wrapped in ( ... )
, as in this example, so that the standard error and standard output of the whole sequence
will be redirected to the log file. If this is not done, only standard
error and standard output for the last component of the command sequence
will be captured. This is probably not what you want unless you have
redirected these outputs for the previous individual parts of the
command sequence.
Using these, the above commands could be replaced with:
myprog -a 0 -b 0 -c 0
myprog -a 0 -b 0 -c 1
...
myprog -a 9 -b 9 -c 8
myprog -a 9 -b 9 -c 9
Note: the log files will have a different naming scheme, but there will still be one per task.
Later occurrences of #DISBATCH PREFIX
or #DISBATCH SUFFIX
in a task
file simply replace previous ones. When these are used, the tasks
reported in the status file include the prefix and suffix in
force at the time the task was launched.
BARRIER
If your tasks fall into groups where a later group should only begin after all tasks of the previous group have completely finished, you can use this directive:
#DISBATCH BARRIER
When disBatch encounters this directive, it will not launch another task until all tasks in progress have completed. The following form:
#DISBATCH BARRIER CHECK
checks the exit status of the tasks done since the last barrier (or start of the run). If any task had a non-zero exit status, the run will exit once this barrier is met.
REPEAT
For those problems that are easily handled via a job-array-like approach:
#DISBATCH REPEAT 5 start 100 step 50 [command]
will expand into five tasks, each with the environment variable
DISBATCH_REPEAT_INDEX
set to one of 100, 150, 200, 250, or 300.
The tasks will consist of the concatenation of the prefix, command (if provided),
and the suffix currently in effect. start
defaults to 0, step
to 1. Note: the semantics here differ somewhat from many range
constructs, the number immediately following REPEAT
sets the
number of tasks that will be executed; the next two numbers affect
only the value that the repeat index will have in
the environment for each of the repeat task instances. So, returning to our earlier example, the task file
could be:
#DISBATCH PREFIX ( cd /path/to/workdir ; a=$((DISBATCH_REPEAT_INDEX/100)) b=$(((DISBATCH_REPEAT_INDEX%100)/10 )) c=$((DISBATCH_REPEAT_INDEX%10)) ; myprog -a $a -b $b -c $c ) &> task_${a}_${b}_${c}.log
#DISBATCH REPEAT 1000
This is not a model of clarify, but does illustrate that the repeat constuct can be relatively powerful. Many users may find it more convenient to use the tool of their choice to generate a text file with 1000 invocations explictly written out.
PERENGINE
#DISBATCH PERENGINE START { command ; sequence ; } &> engine_start_${DISBATCH_ENGINE_RANK}.log
#DISBATCH PERENGINE STOP { command ; sequence ; } &> engine_stop_${DISBATCH_ENGINE_RANK}.log
Use these to specify commands that should run at the time an engine joins a disBatch run or at the time the engine leaves the disBatch run, respectively. You could, for example, use these to bulk copy some heavily referenced read-only data to the engine’s local storage area before any tasks are run, and then delete that data when the engine shuts down. You can use the environment variable DISBATCH_ENGINE_RANK to distinguish one engine from another; for example, it is used here to keep log files separate.
These directives must come before any other tasks.
License
Copyright 2017 Simons Foundation
Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


Example Commandline Use¶
[1]:
! python -m idf_analysis -h
usage: __main__.py [-h] -i INPUT
[-ws {ATV-A_121,DWA-A_531,DWA-A_531_advektiv}]
[-kind {partial,annual}] [-t {>= 0.5 a and <= 100 a}]
[-d {>= 5 min and <= 8640 min}] [-r {>= 0 L/s*ha}]
[-h_N {>= 0 mm}] [--r_720_1] [--plot] [--export_table]
heavy rain as a function of the duration and the return period acc. to DWA-A
531 (2012) All files will be saved in the same directory of the input file but
in a subfolder called like the inputfile + "_idf_data". Inside this folder a
file called "idf_parameter.yaml"-file will be saved and contains interim-
calculation-results and will be automatically reloaded on the next call.
optional arguments:
-h, --help show this help message and exit
-i INPUT, --input INPUT
input file with the rain time-series (csv or parquet)
-ws {ATV-A_121,DWA-A_531,DWA-A_531_advektiv}, --worksheet {ATV-A_121,DWA-A_531,DWA-A_531_advektiv}
From which worksheet the recommendations for
calculating the parameters should be taken.
-kind {partial,annual}, --series_kind {partial,annual}
The kind of series used for the calculation.
(Calculation with partial series is more precise and
recommended.)
-t {>= 0.5 a and <= 100 a}, --return_period {>= 0.5 a and <= 100 a}
return period in years (If two of the three variables
(rainfall (height or flow-rate), duration, return
period) are given, the third variable is calculated.)
-d {>= 5 min and <= 8640 min}, --duration {>= 5 min and <= 8640 min}
duration in minutes (If two of the three variables
(rainfall (height or flow-rate), duration, return
period) are given, the third variable is calculated.)
-r {>= 0 L/(s*ha)}, --flow_rate_of_rainfall {>= 0 L/(s*ha)}
rainfall in Liter/(s * ha) (If two of the three
variables (rainfall (height or flow-rate), duration,
return period) are given, the third variable is
calculated.)
-h_N {>= 0 mm}, --height_of_rainfall {>= 0 mm}
rainfall in mm or Liter/m^2 (If two of the three
variables (rainfall (height or flow-rate), duration,
return period) are given, the third variable is
calculated.)
--r_720_1 design rainfall with a duration of 720 minutes (=12 h)
and a return period of 1 year
--plot get a plot of the idf relationship
--export_table get a table of the most frequent used values
I used the rain-time-series from ehyd.gv.at with the ID 112086 (Graz-Andritz)
[2]:
! python -m idf_analysis -i ehyd_112086.parquet
Using the subfolder "ehyd_112086_idf_data" for the interim- and final-results.
Found existing interim-results in "ehyd_112086_idf_data\idf_parameters.yaml" and using them for calculations.
[4]:
! python -m idf_analysis -i ehyd_112086.parquet --r_720_1
Using the subfolder "ehyd_112086_idf_data" for the interim- and final-results.
Found existing interim-results in "ehyd_112086_idf_data\idf_parameters.yaml" and using them for calculations.
Resultierende Regenhöhe h_N(T_n=1.0a, D=720.0min) = 49.29 mm
Resultierende Regenspende r_N(T_n=1.0a, D=720.0min) = 11.41 L/(s*ha)
[7]:
! python -m idf_analysis -i ehyd_112086.parquet -d 720 -t 1
Using the subfolder "ehyd_112086_idf_data" for the interim- and final-results.
Found existing interim-results in "ehyd_112086_idf_data\idf_parameters.yaml" and using them for calculations.
Resultierende Regenhöhe h_N(T_n=1.0a, D=720.0min) = 49.29 mm
Resultierende Regenspende r_N(T_n=1.0a, D=720.0min) = 11.41 L/(s*ha)
[8]:
! python -m idf_analysis -i ehyd_112086.parquet -d 720 -h_N 60
Using the subfolder "ehyd_112086_idf_data" for the interim- and final-results.
Found existing interim-results in "ehyd_112086_idf_data\idf_parameters.yaml" and using them for calculations.
The return period is 2.0 years.
Resultierende Regenhöhe h_N(T_n=2.0a, D=720.0min) = 60.00 mm
Resultierende Regenspende r_N(T_n=2.0a, D=720.0min) = 13.89 L/(s*ha)
[ ]:
! python -m idf_analysis -i ehyd_112086.parquet -t 5 -t 15
[5]:
! python -m idf_analysis -i ehyd_112086.parquet --plot
Using the subfolder "ehyd_112086_idf_data" for the interim- and final-results.
Found existing interim-results in "ehyd_112086_idf_data\idf_parameters.yaml" and using them for calculations.
Created the IDF-curves-plot and saved the file as "ehyd_112086_idf_data\idf__curves_plot.png".
[6]:
! python -m idf_analysis -i ehyd_112086.parquet --export_table
Using the subfolder "ehyd_112086_idf_data" for the interim- and final-results.
Found existing interim-results in "ehyd_112086_idf_data\idf_parameters.yaml" and using them for calculations.
return period (a) 1 2 3 5 10 20 25 30 50 75 100
frequency (1/a) 1.000 0.500 0.333 0.200 0.100 0.050 0.040 0.033 0.020 0.013 0.010
duration (min)
5.0 9.39 10.97 11.89 13.04 14.61 16.19 16.69 17.11 18.26 19.18 19.83
10.0 15.15 17.62 19.06 20.88 23.35 25.82 26.62 27.27 29.09 30.54 31.56
15.0 19.03 22.25 24.13 26.51 29.72 32.94 33.98 34.83 37.20 39.08 40.42
20.0 21.83 25.71 27.99 30.85 34.73 38.62 39.87 40.89 43.75 46.02 47.63
30.0 25.60 30.66 33.62 37.35 42.41 47.47 49.10 50.43 54.16 57.12 59.22
45.0 28.92 35.51 39.37 44.23 50.83 57.42 59.54 61.28 66.14 69.99 72.73
60.0 30.93 38.89 43.54 49.40 57.36 65.31 67.88 69.97 75.83 80.49 83.79
90.0 33.37 41.74 46.64 52.80 61.17 69.54 72.23 74.43 80.60 85.49 88.96
180.0 38.01 47.13 52.46 59.18 68.30 77.42 80.36 82.76 89.48 94.81 98.60
270.0 41.01 50.60 56.21 63.28 72.87 82.46 85.55 88.07 95.14 100.75 104.73
360.0 43.29 53.23 59.04 66.37 76.31 86.25 89.45 92.06 99.39 105.20 109.33
450.0 45.14 55.36 61.33 68.87 79.08 89.30 92.59 95.28 102.81 108.79 113.03
600.0 47.64 58.23 64.43 72.23 82.82 93.41 96.82 99.61 107.42 113.61 118.01
720.0 49.29 60.13 66.47 74.45 85.29 96.12 99.61 102.46 110.44 116.78 121.28
1080.0 54.41 64.97 71.15 78.94 89.50 100.06 103.46 106.24 114.02 120.20 124.58
1440.0 58.02 67.72 73.39 80.54 90.24 99.93 103.05 105.61 112.75 118.42 122.45
2880.0 66.70 77.41 83.68 91.57 102.29 113.00 116.45 119.26 127.16 133.42 137.87
4320.0 71.93 85.72 93.78 103.95 117.73 131.52 135.96 139.58 149.75 157.81 163.53
5760.0 78.95 95.65 105.42 117.72 134.43 151.13 156.50 160.89 173.20 182.97 189.90
7200.0 83.53 101.38 111.82 124.98 142.83 160.68 166.43 171.12 184.28 194.72 202.13
8640.0 85.38 104.95 116.40 130.82 150.38 169.95 176.25 181.40 195.82 207.27 215.39
Created the IDF-curves-plot and saved the file as "ehyd_112086_idf_data\idf_table.csv".


Definition at line 15 of file Motion.hpp.
|
| static int | accel_orient_enable (uint8_t enable=1, uint8_t threshold=0, uint8_t hyst=4, uint8_t count=128, uint8_t back_front_trip_angle=0, uint8_t zlock=0) |
| |
| static int | accel_intr_enable (uint8_t enable, uint8_t select=0, bool open_drain=true, bool active_high=true, uint8_t wake=0) |
| |
| static int | accel_pulse_enable (uint8_t enable, uint8_t threshold_x=32, uint8_t threshold_y=32, uint8_t threshold_z=32, uint8_t limit=100, uint8_t latency=80, uint8_t window=1) |
| |
| static int Motion::accel_intr_enable |
( |
uint8_t |
enable, |
|
|
uint8_t |
select = 0 , |
|
|
bool |
open_drain = true , |
|
|
bool |
active_high = true , |
|
|
uint8_t |
wake = 0 |
|
) |
| |
|
static |
- Parameters
-
| enable | Specifies which interrupts to enable e.g. (ITNR_PL) |
| select | If bit is set, interrupt is INT1 else interrupt is INT2 e.g. (ITNR_PL | INTR_PULSE) |
| open_drain | Interrupt is an open-drain if true and push-pull if false |
| active_high | Interrupt is active high if true and active low if false |
| wake | Specifies which interrupts can wake the device from sleep e.g. (INTR_WAKE_PL) |
| static int Motion::accel_orient_enable |
( |
uint8_t |
enable = 1 , |
|
|
uint8_t |
threshold = 0 , |
|
|
uint8_t |
hyst = 4 , |
|
|
uint8_t |
count = 128 , |
|
|
uint8_t |
back_front_trip_angle = 0 , |
|
|
uint8_t |
zlock = 0 |
|
) |
| |
|
static |
- Parameters
-
| threshold | portrait to landscape trip threshold (5 bits) |
| hyst | portrait to landscape hysteresis (3 bits) |
| count | debounce counter (8 bits) |
| back_front_trip_angle | back front trip angle (2 bits) |
| zlock | Z lock angle fixed threshold (3 bits) |
| static int Motion::accel_pulse_enable |
( |
uint8_t |
enable, |
|
|
uint8_t |
threshold_x = 32 , |
|
|
uint8_t |
threshold_y = 32 , |
|
|
uint8_t |
threshold_z = 32 , |
|
|
uint8_t |
limit = 100 , |
|
|
uint8_t |
latency = 80 , |
|
|
uint8_t |
window = 1 |
|
) |
| |
|
static |
- Parameters
-
| enable | Which pulses to enable e.g.: (PULSE_X_SINGLE | PULSE_Y_SINGLE) |
| threshold_x | 1 to 127 (7 bits) |
| threshold_y | 1 to 127 (7 bits) |
| threshold_z | 1 to 127 (7 bits) |
| limit | pulse time limit |
| latency | pulse latency window (pulses ignored in this time) |
| window | Time window between first pulse and second pulse |


Dashboard
Interface
Master
Master:
Add Shop type
View Shop type
Registration
Registration Form
Profile
Change Password
Logout
Register User
Ready to Leave?
×
Select "Logout" below if you are ready to end your current session.


Firefox
Firefox is a web browser. It's like Netscape but better.
It does emojis where Chrome does not 🎈🎁🧤 (If you're still using Windows 7)
And you can link using images too!
Unfortunately some websites' abuse ruined the ability to autoplay music though... (by default)


Your daily medication and healthcare needs delivered to your doorstep within 90 minutes.
Download Our App!Prescription Medicines. Sanitary. Baby Care. Personal Care. Ayurvedic. Homeopathic. Home Care Devices.
Get all medicines(Prescription and OTC). No searching for numbers to call and absolutely no shop hunting.
Delivery to your doorstep within 90 minutes.
Ayurvedic, Herbal, Patanjali, Pet Care, Baby Care, Nutrition Products and more.
Prescription reminders with instructions. Auto dosage refill. Electronic medical history.


During this experiment you will be visually presented with a series of sentences, one at a time. Initially, all of the words in the sentence will be replaced by dashes. By pressing the spacebar, you will reveal one word at a time in the sentence. Your task is to read each sentence as quickly as you can while ensuring you understand the sentence. After you have finished reading the sentence, you will be asked a 'Yes' or 'No' question that asks something about the sentence.
We will be measuring your reading time (how quickly you read each word) while you preform the task, so please try to read quickly, but make sure you understand the sentence.
A bar running along the bottom of the screen will track your progress. This experiment should take about three minutes to complete.
Press the spacebar when you are ready to begin!
This experiment was designed to examine sentence comprehension, the process of understanding the meaning of an entire sentence. In particular, it looked at the processing relative clauses, and why some appear to be more difficult than others.
To test this, the experiment used a self-paced reading task. During this task participants read sentences one word at a time. By varying the sentences, we can investigate how different syntactic structures affects the reading times for different parts of the sentence. In the case of relative clauses, we can compare two different types of relative clauses, those that are subject relative (e.g., the reporter that attacked the senator admitted the error) to those that are object relative (e.g., the reporter that the senator attacked admitted the error). In general, object relative clauses are harder to comprehend, possibly because they are intially misinterpreted and have to be reinterpreted when more of the sentence has been processed. By comparing object relative to subject relative sentences that have been carefully constructed to be as similar as possible, we can see at what point in reading the sentence readers slow down, and use this information to infer something about the underlying processing.
In a 2008 study, Justine Wells and colleagues had participants perform this task both before and after being exposed to lots of relative clauses. In analyzing the reading time data they broke the sentences up into four regions. The first comprised the first five words (e.g., the reporter that attacked the/the reporter that the senator), the second comprised of the first word which indicates that the clause is actually object or subject relative (e.g., senator/attacked), the third comprised of the main verb (e.g., admitted/admitted), and the fourth comprising the remainder of the sentence (e.g., the error/the error). We comparing the two types of sentences, they found no differences at time point one, and then slower reading times for all remaining time points for the object relatives compared to the subject relatives. How do you stack up? Below you can see your average response times for each of the sentence areas, or you can switch to viewing the original results from Wells and colleagues' study by clicking the 'Study Data' button.


Cards: Header/Footer
I'm a Header in a Card!
This is a basic Card with some text.
I'm a Footer in a Card!


--- layout: default title: About me ---
I grew up on a farm in Wales. As a child I watched my father balance the short-term productivity of the land against its long-term sustainability. I often thought about how we as a species interact with out environment - how we shape it, and it shapes us.
A farmer is utterly beholden to the weather. I wanted to understand what causes the vagaries of the atmosphere which so clearly impacted our livelihood, and how they might change in the future as a result of climate change. I was also decently good at mathematics and physics, so I decided to go to the University of Reading to study meteorology.
During my undergraduate degree, and after a brief summer stint on placement at the Met Office, I decided I wanted to try a career in scientific research. I started a PhD project, again at the University of Reading, on the climate impacts of stratospheric aerosol geoengineering. Initially I didn't want to touch the project because I was too unsettled by the concept of intentionally modifying the climate. However, my supervisors (Andrew Charlton-Perez and Ellie Highwood) pointed out a healthy scepticism is valuable in science, and I am glad they were so persuasive. The topic was a great frame through which to think about fundamental climate problems and prompted some fascinating investigations into science and policy problems.
After my PhD I moved to the University of Exeter to work as a post-doc with Mat Collins and Hugo Lambert. My work focuses on climate feedbacks and emergent constraints on climate sensitivity. I continue to work on geoengineering as well. See my list of projects for more details about my research.


Citizen prototypes BETA
(Dev) Features to be built
- Claimant - make claim
- Defendant - response
- Dashboard
- Offers
- Letters and sealed claim forms
- Cookies page 1
- Cookies page 2
Gov guidance structure and MCOL and Beta journeys
January 2021 prototype version
Sept 2020 prototype version
Accessibility Statement
Archived prototypes
Aug 2020 prototype
July 2 2020 prototype
July 1 2020 prototype
May 2020 prototype
February 2020 prototype
December 2019 prototype
November 2019 prototype
October 2019 prototype
September 2019 prototype
August 2019 prototype
July 2019 prototype
June 2019 prototype
May 2019 prototype
April 2019 prototype
March 2019 prototype
February 2019 prototype
January 2019 prototype
December 2018 prototype
Public Beta prototype - November 2018
Public Beta Sprint 13 - October 2018
Main changes this sprint
New features
- XXXX
Iteration from research
Finding: YYY.
Action: ZZZ.
Public Beta Sprints 10 & 11 - September 2018
Main changes this sprint
New features
- Warrants of control
Iteration from research
Finding: YYY.
Action: ZZZ.
Public Beta Sprint 9 & 10 - August 2018
Main changes this sprint
New features
- XXXX
Iteration from research
Finding: YYY.
Action: ZZZ.
Public Beta Sprint 7 & 8 - Jul II 2018
Main changes this sprint
New features
- Additional dashboard/claim details states
- New redetermination flow
Iteration from research
Finding: YYY.
Action: ZZZ.
Public Beta Sprint 6 - Jul 2018
Main changes this sprint
New features
- New defendant repsonse selection journey
- Updated counterclaims to work throguh new response selection journey. See flow.
Iteration from research
Finding: YYY.
Action: ZZZ.
Public Beta Sprint 5 - Jun II 2018
Main changes this sprint
New features
- Counterclaim journey
- New feature opt-in
- New dashboard states
- Added 'features to be built' folder
Iteration from research
Finding: YYY.
Action: ZZZ.
Public Beta Sprint 4 - Jun 2018
Main changes this sprint
New features
- Added certificates of cancellation/satisfaction
- Applications journeys (cancel/satisfy, vary an order & set aside ) + process map
- Dispute the claim - claimant response
- Paid less than claim amount - claimant response
- Paid in full journey
- Discontinuation journey
- New dashboard states
Iteration from research
Finding: YYY.
Action: ZZZ.
Public Beta Sprint 2 - May 2018
Main changes this sprint
New features
- Part admission defendant and claimant response
- States paid defendant and claimant response
- Added PDFs for settlement agreements and judgment orders
- Started paid in full journeys
- Started certificate of satisfaction/cancellation journeys
Iteration from research
Finding: Defendants didn't understand the repayment plan and settlement agreement were seperate things.
Action: Took the settlement agreement out of defendant flow and had it instigated by claimant.
Finding: Defendants felt it would be useful to work out income/outgoings before suggesting repayments.
Action: Moved SOM to before repayment plan.
Finding: Going from 'when will you pay' straight into statement of means a bit disorientating.
Action: SOM given own task list section.
Public Beta Sprint 1 - April 2018
Pre-public beta prototypes


Node and systemd
For a while now I’ve had my dashboard combo tv and dashboard combo, which runs on dashing and dashkiosk, running in screen sessions. This , of course, is not very managable. If something breaks, you have to ssh in and then find the screen session, re-run the command. In comes systemd. This makes managing services easy! You are able to make anything a system managed service, being able to manage the service via the systemctl
commands
Here are the systemd unit files I use for both dashing and dashkiosk. Just put them in /etc/systemd/system
and away you go
Dashkiosk
Dashing
As you can see here, I am starting my services as root, as I need to use port 80 for the dashboard. But you can probably just run these as a standard user if you do not need privileged ports


Add "=HYPERLINK(..." cruft to the digikey part num and manufacturer part num to inject the part url and datasheet url, respectively


About the Campus Ambassador Program
ECell, the Entrepreneurship Cell of IIITD, aspires to reach out to every college to develop an entrepreneurial ecosystem for all enthusiasts, and to encourage students to participate actively in any entrepreneurship-based event/workshop/activity conducted by the Cell. For this purpose, we require candidates who can represent ECell in their college, by working closely with the Cell and help raise its profile on their campus.
What will be your day-to-day responsibilities as a Campus Ambassador?
- Handling public image of ECell IIITD in your college
- Serve as a strategic link between students at your college and the Cell
- Spreading information about ECell IIITD in your college through various mediums and activities
- Forwarding emails and e-posters on social media platforms like Facebook and WhatsApp
- Ensure enthusiastic participation from your college in all events conducted by the ECell
- Help Ecell IIITD in understanding your college and student profiles better
- Help ECell IIITD connect with interested people/start-ups/newbies
- Cooperating and Coordinating with ECell IIITD throughout your tenure
Incentives to the Campus Ambassadors
- Certificate of Appreciation from Ecell IIITD
- Free passes for all events conducted by ECell IIITD
- Travel reimbursement for the selected campus ambassadors to participate in E-summit.
- Chance to organize events in IIITD.
- Chance to connect with experienced professionals from the corporate world
- Enhance your communication and interpersonal skills
- One-to-one interaction with the founders of leading start-ups
- Selected Campus Ambassadors will get a chance to work directly with Ecell IIITD
- Best Campus Ambassadors will receive recommendations, certificate of excellence, Ecell IIITD merchandise, goodies and much more!
- Many other incentives based on the performance.


A variation of Body Horror, where a creature is inside someone else, and then leaves through an established opening of the body (as in naturally, not a cut or piercing), even if it's not really an opening (like the navel). It could be the mouth, the nostrils, the ear, or through orifices below the belt. Pores could even count. The point is that the orifice is pretty much intact when the creature leaves.
Sometimes this can kill the "host", sometimes the host lives, or sometimes the host can already be dead.
Sometimes this can be horrific, but sometimes not. It depends on the nature of the evacuation. As the picture shows, it can even be Played for Laughs.
Compare Chest Burster (when the creature makes its own orifice to leave, or mutilates an orifice to get out), Giving Up the Ghost.
Contrast Orifice Invasion, Face Full of Alien Wing-Wong.
Examples
- A small devil leaves through a guy's mouth in an episode of Yu Yu Hakusho. Strangely enough, The Abridged Series let that moment slide by without a comment.
- In Naruto:
- When the tailed beasts are shown being removed from their hosts they exit from their mouth and eyes.
- In the anime, Itachi uses a genjutsu that makes the victim feel like a crow is crawling out of their mouth.
- When his body is about to be maimed beyond being able to simply reattach (via snakes... somehow), Orchimaru throws up himself with his clothes undamaged (thank Nicolas Cage), which usually works. He is very fond of this technique.
- Sasuke also uses this technique to escape being burned alive by Amaterasu, although his clothes don't regenerate.
- Namekians in Dragon Ball are a One-Gender Race of Little Green Men (though as adults they tend to be quite tall and don't fly ufos) that give birth to their kin by putting out eggs through the mouth. It tends to be quite Squicky to look at, especially since they visibly struggle with it. It's even possible (though not seen) that they can choke to death from it.
- In JoJo's Bizarre Adventure: Stardust Crusaders, Kakyoin uses his stand to control the body of a school nurse from the inside, before Jotaro uses his stand to pull it out of her mouth in the most dramatic fashion ever.
- The recent Titans Annual #1 has Kid Eternity being wrapped around a computer output input cable kind of combining this with naughty USB inputs, disabling his powers by going down his throat. Or summink.
- In the penultimate Story Arc of The Sandman, "The Kindly Ones", Cluracan spawns the wild Hart, his nemesis (and a full-grown stag), from his mouth. Its exit leaves him bleeding profusely but he survives.
- A common fairy tale punishment for rudeness and deceit is to have the afflicted spew toads and reptiles from their mouth when they try to speak.
- It's often paired with a good person rewarded by having roses and diamonds come out. Although the reward seems like Blessed With Suck, since roses and diamonds seem like they would be even more painful in one's throat then something smooth like a snake.
- A whole roomful of roaches leave Mr. Pratt's mouth, wounds, and so on in Creepshow.
 And after Bruce sets the other members away, he "returns home"...
- In the movie Evolution, Dr. Harry Block finds himself the unwilling home of a parasitic alien.  Not willingly, either.
- In the second segment in Tales from the Darkside: The Movie, a cat kills a hitman (sent to kill that very cat) by leaping into his mouth and crawling all the way inside as the hitman chokes. In the Stephen King story it was based on, the cat burrows out of the stomach, but in the movie, the cat waits there until morning, and crawls back out of the guy's mouth, just after its real intended victim comes home to witness this (and then has a heart attack).
- In Class of Nuke 'Em High, Chrissy smokes marijuana tainted by nuclear waste, and discovers later that it caused a rapidly-growing mutant creature to take up residence in her stomach—which she quickly vomits up.

- The Ceti eel crawling out of Chekov's ear in Star Trek II: The Wrath of Khan.
- A spider crawls out from a corpse's nose in Arachnophobia.
- In Poltergeist II: The Other Side, the father swallows an evil-possessed worm from a bottle of tequila, then barfs it back up when it starts growing larger inside him.
 It's about the size of a rat when it crawls out of the cat's mouth (although the cat looks like a toy puppet), then grows to about the size of a dog.
- In Resident Evil: Afterlife Albert Wesker is infested with... something that occasionally peeks out of his mouth.
- In Fantastic Voyage , the shrunken crew escapes via the patient's tear duct after the sub is destroyed.
- When Ron broke his wand in the second Harry Potter book, he tried to make Draco puke out slugs after he insulted Hermione, but it backfired on Ron.
- This scene was gruesomely recreated with loving detail in the second movie adaptation.
- The Death Eaters' symbol, a snake emerging from the mouth of a skull, is a variant of this.
- In book seven, after hiding inside the digestive tract of Bathilda Bagshot's reanimated corpse, Nagini the snake attacks Harry and Hermione after crawling out the corpse's mouth.
- The Yeerks in Animorphs enter through the ear to take control of the host's brain, and leave the same way every three days to feed on Kandrona rays.
- Rachel's burping up of the crocodile in "The Reaction". We aren't told exactly what orifice it came from, but she's definitely intact once it leaves.
- In one of Danish writer Jorn Riel's books, a parasitic worm leaves its host's body through his tear duct. It's not particularly painful or dangerous...at least for the host. Most of the damage is incurred by his mates, who argue about it so much the whole thing ends up in a fist fight.
- An episode of CSI had a rat leave a body through the mouth. This was the Cold Open, so it inspired a Quip to Black by Grissom.
- Another episode had a tapeworm crawl out of a corpse's mouth.
- Bones did the same thing with a crab, and averted it with a boa constrictor (which exited via a corpse's torn-open gut instead).
- On Buffy the Vampire Slayer Willow's resurrection of Buffy is accompanied by her choking out a large snake, apparently as a trial by Osiris.
- In Primeval, the parasites crawl out of the mouths of their victims' corpses.
- In the "Bound" episode of Fringe, a drink is spiked with a genetically altered cold virus that expands into a giant slug (about the size of a rabbit) within the victim's body before exiting via the throat, choking the victim in the process.
- In the Merlin (2008) episode "The Witchfinder" one of the witnesses the Witchfinder drugs to make hallucinate claims to have seen a sorcerer cough up a toad. Later on, Merlin makes the Witchfinder cough up a toad.
- In a real life incident recounted on Monsters Inside Me, a man who'd gone swimming in a pond in India started getting nosebleeds. Several days later, the leech that was causing them revealed its presence, extending its mouth out of the man's nostril.
- A popular trick for witches in Supernatural. Always involving Squick—one witch killed a man by hexing him to cough up razorblades.
- One of the escaped souls in Reaper could do this. While the soul could and did turn entirely into insects, one of the times was prefaced by the soul releasing a swarm of insects from a Skyward Scream.
- One of The X-Files monsters of the week was a guy with... some sort of... spider creature... implanted inside by ex-Nazi scientists on orders of The Conspiracy. The creature leaned out of the mouth, did the killing, then hid back in.
- In Falling Skies one of the things the invaders use to attack the survivors is a mass of spiders that seem to be able to infect someone, multiply inside their body and finally tens of them erupt from the victim's mouth. The victim is awake for much of this.
- In the music video for "Melancholy Hill" by Gorillaz, Cyborg Noodle throws up a live octopus after the group make their way underwater, squicking out her companion 2-D.
- The music video for Papa Roach's "Between Angels And Insects", in which cockroaches come out of Jacoby Shaddix's mouth when he screams. Don't search for that scene.
- This goes all the way back to the Hittite myth called Kingship in Heaven.  This made Kumarbi pregnant with three deities: Teshub (the storm god), Tigris (the river), and Tasmisus. Since he had no actual birth canal, they had to emerge by other means. Teshub came out via "the good place", although it's unstated where that is.
- SCP Foundation, SCP-695 ("Eels"). After SCP-695 eggs have grown to juvenile size inside a female human host, they may escape by exiting through her vagina, anus or mouth.
- Dungeons & Dragons:
- The spell Vipergout lets its casters do this to themselves on purpose as a weapon, for those problems that can be solved by projectile-vomiting snakes at them.
- The Vasharan worm pod is a gruesome Bio-Augmentation implant that lets its owner spit deadly parasitic worms.
- The first LEGO Island game. There's an in-game mission where you drive an ambulance around the island, making the occasional stop here and there. Apparently one of them is at the Pizzeria where you see a choking guy who after being helped by paramedics, barfs up a whole live Shark that's bigger than he is, and that shark then barfs up a live dog, and then the dog barfs up a live cat, and so on.
- In a Tradewinds Caravans story, the eldest Jasaret daughter's "curse" is to have all manner of frogs, insects, and other small animals constantly flowing from her mouth when it is open. (At least one NPC notices her sneeze out a hawk.)
- In Aliens vs. Predator (2010), Weyland-Yutani is farming aliens in human hosts, using canisters over the hosts' chests to capture the creatures as they emerge. One alien circumvents this trap by emerging through its host's mouth.
- In Resident Evil 5 the Majini are all infested with variant Plagas parasites.
- Ouroboros takes this trope Up to Eleven, emerging as a black slime creature from every pore of the victim's body. Then there's what it does to Excella, which you can watch here.
- In Five Nights at Freddy's: Sister Location Ennard uses this trope to expel themselves from Eggs Benedict in a cutscene that plays after finishing the 'Golden Freddy' challenge on Custom Night. Fortunately for the player, the cutscene is animated in an 8-bit, Atari-esque style.
- In one of Spirit Hunter: NG's Bad Ends, Kaoru is found dead in a bathtub with tiny, blood-soaked turtles spewing out of their mouth, the same ones that infest the Urashima Lake.
- One of Wonderella's powers is to spew a large octopus out of her mouth. The alt text made it clear if this was Anime, the octopus would be forcing its way in.
- In Gnoph, a Gnoph symbiote lives inside one of its host's lungs, and can enter and exit using the mouth. The host needs to take hormones to prevent the Gnoph from growing too large to fit comfortably, or else Body Horror ensues.
- Happens in Schlock Mercenary, during General Karl Tagon's backstory. A person is used (willingly or unknowingly) as a host for weaponized self-replicating nanorobots as part of an assassination attempt. The person is dies in horrible pain as the nanites activate, but their body appears mostly intact even as they belch out a stream of infectious killer nanites.
- Schlock also winds up spitting up a small patch of himself that was infected by nanites when he "took a sample" of Xinchub's corpse.
 After coitus, the Tapeworm Goddess leaves through her mouth, and offers to grant both of them a wish each for freeing her. The couple then requests Brain Bleach:
Woman: I'd like to forget I saw this, please.
Man: Yeah, me too.
- In Xiaolin Showdown, Omi escapes from Evil Dojo's body by shrinking himself and escaping through a sweat gland.
- Mr.  Most of these animals die, but one gerbil named Lemmiwinks manages to traverse Mr. Slave's entire digestive system and crawl out his mouth. Later, Paris Hilton has to try escaping the same way.
- In Futurama, Fry accidentally drinks the emperor of a race of liquid people. Several options are discussed for extracting the emperor, most of which he deems too undignified (although he did like the idea of being squeezed out by a bone-crushing centrifuge). He eventually settles for exiting via Fry's tear ducts.
- Lena's attempts to wrestle control of her body back from Magica in the season 1 finale of DuckTales (2017) has Magica's shadowy essence pouring out of her mouth and eyes◊. Made worse by the fact that she can't sever the connection, which leaves tendrils hanging from her lower eyelids and makes it look like she's both physically ill and weeping.
- Squicky in the extreme, but some internal parasites eventually leave the body this way, either as part of their life cycle or upon the death of their host.
- In 1726, a woman named Mary Toft became (in)famous in England, as she'd reportedly begun giving birth to rabbits. Investigation revealed that she was "birthing" pieces of dead rabbits, which she eventually confessed her husband had purchased; she'd inserted them into her birth canal for later expulsion, in a weird attempt to gain fame and a possible pension from the king.
- It's not unheard of for people with tapeworms to, ahem, expel, in whole or in part, their uninvited guest during a visit to the toilet.


|
Elektra
0.8.18
|
Meta data proposal+compatibility methods. More...
Functions | |
| const char * | keyComment (const Key *key) |
Return a pointer to the real internal key comment. More... | |
| ssize_t | keyGetCommentSize (const Key *key) |
| Calculates number of bytes needed to store a key comment, including final NULL. More... | |
| ssize_t | keyGetComment (const Key *key, char *returnedComment, size_t maxSize) |
| Get the key comment. More... | |
| ssize_t | keySetComment (Key *key, const char *newComment) |
| Set a comment for a key. More... | |
| uid_t | keyGetUID (const Key *key) |
| Get the user ID of a key. More... | |
| int | keySetUID (Key *key, uid_t uid) |
| Set the user ID of a key. More... | |
| gid_t | keyGetGID (const Key *key) |
| Get the group ID of a key. More... | |
| int | keySetGID (Key *key, gid_t gid) |
| Set the group ID of a key. More... | |
| int | keySetDir (Key *key) |
| Set mode so that key will be recognized as directory. More... | |
| mode_t | keyGetMode (const Key *key) |
| Return the key mode permissions. More... | |
| int | keySetMode (Key *key, mode_t mode) |
| Set the key mode permissions. More... | |
| time_t | keyGetATime (const Key *key) |
| Get last time the key data was read from disk. More... | |
| int | keySetATime (Key *key, time_t atime) |
| Update the atime information for a key. More... | |
| time_t | keyGetMTime (const Key *key) |
| Get last modification time of the key on disk. More... | |
| int | keySetMTime (Key *key, time_t mtime) |
| Update the mtime information for a key. More... | |
| time_t | keyGetCTime (const Key *key) |
| Get last time the key metadata was changed from disk. More... | |
| int | keySetCTime (Key *key, time_t ctime) |
| Update the ctime information for a key. More... | |
| int | elektraKeyCmpOrder (const Key *ka, const Key *kb) |
| Compare the order metadata of two keys. More... | |
| void | elektraMetaArrayAdd (Key *key, const char *metaName, const char *value) |
| creates an metadata array or appends another element to an existing metadata array e.g. More... | |
| KeySet * | elektraMetaArrayToKS (Key *key, const char *metaName) |
| creates a KeySet from a MetaKey array. More... | |
| int | elektraSortTopology (KeySet *ks, Key **array) |
| topological sorting More... | |
| char * | elektraMetaArrayToString (Key *key, const char *metaName, const char *delim) |
| returns the metakey array as a string separated by delim More... | |
Meta data proposal+compatibility methods.
In versions before Elektra 0.8 only limited meta data was available. Now any meta data can be added. These API methods are implementations of the 0.7 API using 0.8 meta data.
Additionally, new suggestions can be made here.
It is planned that these methods will be generated from doc/METADATA.ini and moved to a separate library. Currently, you should better avoid the methods and directly use metainfo instead.
| int elektraKeyCmpOrder | ( | const Key * | ka, |
| const Key * | kb | ||
| ) |
Compare the order metadata of two keys.
| ka | key to compare with |
| kb | other key to compare with |
| void elektraMetaArrayAdd | ( | Key * | key, |
| const char * | metaName, | ||
| const char * | value | ||
| ) |
creates an metadata array or appends another element to an existing metadata array e.g.
Key *key = keyNew("user/test", KEY_END); elektraMetaArrayAdd(key, "array", "test0"); key now has "test/#0" with value "test0" as metadata elektraMetaArrayAdd(key, "array", "test1"); appends "test/#1" with value "test1" to key
| key | the key the metadata should be added to |
| metaName | the name of the metakey array parent |
| value | the value of the newly appended metakey |
| KeySet* elektraMetaArrayToKS | ( | Key * | key, |
| const char * | metaName | ||
| ) |
creates a KeySet from a MetaKey array.
e.g. elektraMetaArrayToKS(keyNew ("/a", KEY_VALUE, "b, c", KEY_META, "dep", "#1", KEY_META, "dep/#0", "/b", KEY_META, "dep/#1", "/c", KEY_END), "dep"); returns a KeySet containing the keys "dep/#0" with value "/b" and "dep/#1" with value "/c" If no MetaKey array is found, null is returned. The returned KeySet must be free'd with ksDel
| key | the key containing the metakey array |
| metaName | the name of the metakey array parent |
| char* elektraMetaArrayToString | ( | Key * | key, |
| const char * | metaName, | ||
| const char * | delim | ||
| ) |
returns the metakey array as a string separated by delim
| key | the key containing the metakey array |
| metaName | the name of the metakey array parent |
| delim | delimiter for the records in the returned string |
| int elektraSortTopology | ( | KeySet * | ks, |
| Key ** | array | ||
| ) |
topological sorting
| array | the array where the sorted keys will be stored in topological order. Nothing will be written into an array if |
| ks | is the keyset that should be sorted. Dependencies and order is defined by metakeys. |
#0
array syntax.Duplicated and reflexive dep entries are ignored.
The algorithm used is a mixture of Kahn and BFS. Furthermore the algorithm does not use recursion.
First a BFS with the keys sorted by "order" is used. Then all dependencies (recursively) of every key is collected.
| 1 | on success |
| 0 | for cycles |
| -1 | for invalid dependencies |
| const char* keyComment | ( | const Key * | key | ) |
Return a pointer to the real internal key
comment.
This is a much more efficient version of keyGetComment() and you should use it if you are responsible enough to not mess up things. You are not allowed to change anything in the memory region the returned pointer points to.
keyComment() returns "" when there is no keyComment. The reason is
See keySetComment() for more information on comments.
| key | the key object to work with |
| "" | when there is no comment |
| 0 | on NULL pointer |
| time_t keyGetATime | ( | const Key * | key | ) |
Get last time the key data was read from disk.
Every kdbGet() might update the access time of a key. You get information when the key was read the last time from the database.
You will get 0 when the key was not read already.
Beware that multiple copies of keys with keyDup() might have different atimes because you kdbGet() one, but not the other. You can use this information to decide which key is the latest.
| key | Key to get information from. |
| 0 | on key that was never kdbGet() |
| (time_t)-1 | on NULL pointer |
| ssize_t keyGetComment | ( | const Key * | key, |
| char * | returnedComment, | ||
| size_t | maxSize | ||
| ) |
Get the key comment.
A Key comment is description for humans what this key is for. It may be a textual explanation of valid values, when and why a user or administrator changed the key or any other text that helps the user or administrator related to that key.
Don't depend on a comment in your program. A user is always allowed to remove or change it in any way he wants to. But you are allowed or even encouraged to always show the content of the comment to the user and allow him to change it.
| key | the key object to work with |
| returnedComment | pre-allocated memory to copy the comments to |
| maxSize | number of bytes that will fit returnedComment |
returnedString
, including final NULL | 1 | if the string is empty |
| -1 | on NULL pointer |
| -1 | if maxSize is 0, not enough to store the comment or when larger then SSIZE_MAX |
| ssize_t keyGetCommentSize | ( | const Key * | key | ) |
Calculates number of bytes needed to store a key comment, including final NULL.
Use this method to know to size for allocated memory to retrieve a key comment.
See keySetComment() for more information on comments.
For an empty key name you need one byte to store the ending NULL. For that reason 1 is returned.
| key | the key object to work with |
| 1 | if there is no comment |
| -1 | on NULL pointer |
| time_t keyGetCTime | ( | const Key * | key | ) |
Get last time the key metadata was changed from disk.
You will get 0 when the key was not read already.
Any changed field in metadata will influence the ctime of a key.
This time is not updated if only value or comment are changed.
Not changed keys will not update this time, even after kdbSet().
It is possible that other keys written to disc influence this time if the backend is not grained enough.
| key | Key to get information from. |
| (time_t)-1 | on NULL pointer |
| gid_t keyGetGID | ( | const Key * | key | ) |
Get the group ID of a key.
The group ID is a unique identification for every group present on a system. Keys will belong to root (0) as long as you did not get their real GID with kdbGet().
Unlike UID users might change their group. This makes it possible to share configuration between some users.
A fresh key will have (gid_t)-1 also known as the group nogroup. It means that the key is not related to a group ID at the moment.
| key | the key object to work with |
| (gid_t)-1 | on NULL key or currently unknown ID |
| mode_t keyGetMode | ( | const Key * | key | ) |
Return the key mode permissions.
Default is 0664 (octal) for keys and 0775 for directory keys which used keySetDir().
The defaults are defined with the macros KDB_FILE_MODE and KDB_DIR_MODE.
For more information about the mode permissions see Modes.
| key | the key object to work with |
| KDB_FILE_MODE | as defaults |
| (mode_t)-1 | on NULL pointer |
| time_t keyGetMTime | ( | const Key * | key | ) |
Get last modification time of the key on disk.
You will get 0 when the key was not read already.
Everytime you change value or comment and kdbSet() the key the mtime will be updated. When you kdbGet() the key, the atime is set appropriate.
Not changed keys may not even passed to kdbSet_backend() so it will not update this time, even after kdbSet().
It is possible that other keys written to disc influence this time if the backend is not grained enough.
If you add or remove a key the key thereunder in the hierarchy will update the mtime if written with kdbSet() to disc.
| key | Key to get information from. |
| (time_t)-1 | on NULL pointer |
| uid_t keyGetUID | ( | const Key * | key | ) |
Get the user ID of a key.
The user ID is a unique identification for every user present on a system. Keys will belong to root (0) as long as you did not get their real UID with kdbGet().
Although usually the same, the UID of a key is not related to its owner.
A fresh key will have no UID.
| key | the key object to work with |
| (uid_t)-1 | on NULL key |
| int keySetATime | ( | Key * | key, |
| time_t | atime | ||
| ) |
Update the atime information for a key.
When you do manual sync of keys you might also update the atime to make them indistinguishable.
It can also be useful if you work with keys not using a keydatabase.
| key | The Key object to work with |
| atime | The new access time for the key |
| 0 | on success |
| -1 | on NULL pointer |
| ssize_t keySetComment | ( | Key * | key, |
| const char * | newComment | ||
| ) |
Set a comment for a key.
A key comment is like a configuration file comment. See keySetComment() for more information.
| key | the key object to work with |
| newComment | the comment, that can be freed after this call. |
| 0 | when the comment was freed (newComment NULL or empty string) |
| -1 | on NULL pointer or memory problems |
| int keySetCTime | ( | Key * | key, |
| time_t | ctime | ||
| ) |
Update the ctime information for a key.
| key | The Key object to work with |
| ctime | The new change metadata time for the key |
| 0 | on success |
| -1 | on NULL pointer |
| int keySetDir | ( | Key * | key | ) |
Set mode so that key will be recognized as directory.
The function will add all executable bits.
The macro KDB_DIR_MODE (defined to 0111) will be used for that.
The executable bits show that child keys are allowed and listable. There is no way to have child keys which are not listable for anyone, but it is possible to restrict listing the keys to the owner only.
For more about mode see keySetMode().
It is not possible to access keys below a not executable key. If a key is not writeable and executable kdbSet() will fail to access the keys below. If a key is not readable and executable kdbGet() will fail to access the keys below.
| key | the key to set permissions to be recognized as directory. |
| 0 | on success |
| -1 | on NULL pointer |
| int keySetGID | ( | Key * | key, |
| gid_t | gid | ||
| ) |
Set the group ID of a key.
See GID for more information about group IDs.
| key | the key object to work with |
| gid | is the group ID |
| 0 | on success |
| -1 | on NULL key |
| int keySetMode | ( | Key * | key, |
| mode_t | mode | ||
| ) |
Set the key mode permissions.
The mode consists of 9 individual bits for mode permissions. In the following explanation the octal notation with leading zero will be used.
Default is 0664 (octal) for keys and 0775 for directory keys which used keySetDir().
The defaults are defined with the macros KDB_FILE_MODE and KDB_DIR_MODE.
0000 is the most restrictive mode. No user might read, write or execute the key.
Reading the key means to get the value by kdbGet().
Writing the key means to set the value by kdbSet().
Execute the key means to make a step deeper in the hierarchy. But you must be able to read the key to be able to list the keys below. See also keySetDir() in that context. But you must be able to write the key to be able to add or remove keys below.
0777 is the most relaxing mode. Every user is allowed to read, write and execute the key, if he is allowed to execute and read all keys below.
0700 allows every action for the current user, identified by the uid. See keyGetUID() and keySetUID().
To be more specific for the user the single bits can elect the mode for read, write and execute. 0100 only allows executing which gives the information that it is a directory for that user, but not accessable. 0200 only allows reading. This information may be combined to 0300, which allows execute and reading of the directory. Last 0400 decides about the writing permissions.
The same as above is also valid for the 2 other octal digits. 0070 decides about the group permissions, in that case full access. Groups are identified by the gid. See keyGetGID() and keySetGID(). In that example everyone with a different uid, but the gid of the the key, has full access.
0007 decides about the world permissions. This is taken into account when neighter the uid nor the gid matches. So that example would allow everyone with a different uid and gid of that key gains full access.
| key | the key to set mode permissions |
| mode | the mode permissions |
| 0 | on success |
| -1 | on NULL key |
| int keySetMTime | ( | Key * | key, |
| time_t | mtime | ||
| ) |
Update the mtime information for a key.
| key | The Key object to work with |
| mtime | The new modification time for the key |
| 0 | on success |
| int keySetUID | ( | Key * | key, |
| uid_t | uid | ||
| ) |
Set the user ID of a key.
See UID for more information about user IDs.
| key | the key object to work with |
| uid | the user ID to set |
| 0 | on success |
| -1 | on NULL key or conversion error |


Header text
Pentabox five
Pentabox four
Pentabox three
Pentabox two
Pentabox one
WB text
BOMT text
OIDIA text
DWAD text
Quadbox one
Quadbox two
Quadbox three
Quadbox four


Dear Eileen,
Thank you for your recent application to join us at the university of Awesome's science faculty to study as part of your PHD next year.I will answer your questions one by one,in the following sections.
We are happy to accomodate you starting your study with us at any time.however it would suit us better if you could start at the beginning of a semester;the start dates for each one are as follows:
Please let me know if this is ok,and if so which start date you would prefer.
You can find more information about important university dates on our website.
At the Awesome science Faculty ,we have a pretty open -minded research facility-as long as the subjects fail somewhere in the realm of science and technology.You seem like an intelligent,dedicated researcher,and just the kind of person we'd like to have on our team.Saying that,of the ideas you submitted we were most intrigued by are as follows,in order of priority:
So please can you provide more information on each of these subjets,including how long you'd expect the research to take,required staff and other resources,and anything else you think we'd need to know?Thanks.
Yes,you are right!As part of my post-doctrate work.I did study exotic tribal dances.To answer your question,my favourite dances are as follows,with difinitions:
A little known but very influential dance dating back as far as 300BC,a whole village would dance around in a circle like chickens,to encourage their livestock or be "friutful"
Before the icelanders develop fire as a means of getting warm,they used to prctice this dance,which involved huddling close together in a circle on the floor,and shuffling their bodies around in imperceptably tiny,very rapid movements.One of my fellow students used to say that he thought this dance inspired modern styles such as Twerking.
An interesting example of historic misinformation,English explorer in the 1960s believed to have discovered a new dance style characterised by "robotics",stilled movement,being practiced by inhabitants of Northern Alaska and canada.Later on however it was discovered that they were just moving like this because they were really cold.
For more of my reseach,see my exort dancer research page
University of Awesome motto:"Be excellent to each other"-Bill S Preston,Esa


The current analysis is filtered to show only reports where |
Question {{filter.question.number}}
{{filter.question.title|lstring}}
Has been answered as follows: {{filter.option.title|lstring}}


2.0 Sequence of Play
2.1 The Game Turn
A Game Turn is a series of events, the order of which is called the Sequence of Play. Each Game Turn consists of two Player Turns, one for each player. For reference, we call a player taking action in his own turn the “phasing” player; the one taking action during his opponent’s turn is the “non-phasing” player. A Player Turn consists of the sequence of steps listed below. Each step involves one player or the other—either phasing or non-phasing—taking action. At the end of the second Player Turn, advance the turn marker and begin the process again. The sequence of play must be strictly followed in the order given.
2.2 Outline Sequence of Play
- Pre-Turn Phase
- 1st Player, Player Turn
- Aircraft Refit Phase (15.1)
- Refit aircraft (1T/base; 2 aircraft/base level)
- Reinforcement Phase (2.3)
- Movement Phase (see 4.5 for ZOCs)
- Supply Phase (12.0)
- Reaction Phase (non-phasing player; reserve only) (7.0)
- Combat Phase (pay supply 12.4)
- Exploitation Phase (11.0)
- Clean Up Phase (2.3)
- Aircraft Refit Phase (15.1)
- 2nd Player, Player Turn
- Repeat for other player.
- Turn End (2.3)
- Advance turn marker
2.3 Narrative Sequence of Play
Pre-Turn Phase
Weather Determination Segment
One player, it is irrelevant which, rolls to determine the weather. The weather affects the entire Game Turn.
First Player Determination Segment
Each player rolls two dice. The player with the higher roll elects to be first or second in the Game Turn. Re-roll any ties.
1st Player, Player Turn
Aircraft Refit Phase
The phasing player refits his Inactive air units. Pay 1T per base at which the player desires to refit. At these bases, the player can refit up to two aircraft per base Level. An air base cannot refit aircraft if in an un-negated enemy Zone of Control (ZOC).
Reinforcement Phase
The phasing player places any new units in their entry points according to the Arrival Schedules. He rolls on his Supply Table to determine the number of new Supply Points available and places them on the map. He rolls on his Variable Reinforcement Table (sometimes called the Repl Table) and places any resulting reinforcements on the map. The phasing player conducts Unit Rebuilds and/or Unit Consolidations as desired.
Movement Phase
The phasing player may Breakout any combat units not in trace supply. He then moves his ships and ground units, individually or in stacks, making any voluntary mode changes as each unit starts to move. Restrictions are imposed by mode, supply, terrain, and enemy units. As they move, combat units can conduct overruns, a form of attack made on the move. They can also destroy or damage supply dumps and facilities, as well as build or improve air bases and hedgehogs. Units and supplies can move by rail or sea transport. The phasing player’s Active air units can perform missions throughout the phase: Fighter Sweep, Hip Shoot, and Air Transport/Drop during the movement segment; Barrage in the barrage segment (which is also when naval units execute barrages).
Supply Phase
The phasing player must replenish units with Low or Exhausted internal stocks, if possible. He then determines which of his combat units are in trace supply. Those out of trace must either expend on-map supply or be marked Out of Supply and be checked for attrition.
Reaction Phase
The non-phasing player can move his ships and aircraft and released Reserves. He can destroy supply dumps, but no other destruction or construction-type activities are allowed. Released units can move half their Movement Allowance (or MA) and overrun. The non-phasing player’s Active air units can perform missions throughout the phase: Fighter Sweep, Hip Shoot, and Air Transport in the movement segment; Barrage in the barrage segment (when ships and artillery also execute their barrages). This phase does not have a Combat Segment.
Combat Phase
The phasing player first resolves artillery barrages. Then his combat units make attacks, with restrictions imposed by mode, supply, and terrain. A combat result might cause retreat, advance, or mode change.
Exploitation Phase
The phasing player can move and fight with released Reserves (full MA) and with units in Exploitation Mode (half MA). He can destroy supply dumps, but no other construction-type activity is allowed. The phasing player’s Active air units can perform missions throughout the phase: Fighter Sweep, Hip Shoot, and Air Transport in the movement segment, and Barrage in the barrage segment (when ships and artillery units also execute their barrages). Finally there is a Combat Segment, when eligible combat units can attack.
Clean Up Phase
The phasing player removes all DG and Exploitation markers from his units and removes (or flips) all his Fuel markers. Remove Trainbusting markers generated by the non-Phasing Player.
2nd Player, Player Turn
Repeat the above steps for the second player with the roles reversed.
Turn End
Advance the Turn Record marker and begin the above sequence again.
2.4 Simulcast Turns
Some games contain periods where the major activity is logistical buildup on both sides. These periods can run much faster if both players declare the turn to be a “simulcast” turn and follow these rules:
- Players execute the turn sequence at the same time.
- No combat or barrage is allowed.
- Neither player executes anything which could be construed as an offensive, raid, or any other such activity on land, water, or air.
Design Note: The goal of the simulcast turn is to speed up the down periods— don’t screw up that goal by attempting to gain some sort of advantage. If you have some operations in mind, don’t agree to the simulcast turn in the first place. However, don’t waste time playing a regular turn for minor reasons.


# PostGIS topology exploration
---
## Test case
- AR5-data from Gjøvik municipality
## Simple features data
- ESRI Shape file
## PostGIS import
- import by means of *PostGIS 2.0 Shapefile and DBF loader exporter*.
- table: *ar5sf* in public schema
## Create PostGIS topology
### Install topology functions in database
```SQL
-- enable topology in PostGIS database
CREATE EXTENSION postgis_topology;
```
### Create topology schema
```SQL
-- create topology schema
SELECT topology.CreateTopology('ar5topo', 25832);
```
### From existing simpe features-geometry, populate topology-tables in topology schema
A new table, *ar5*, function as a integrator table for the topology information
```SQL
-- create a new table in public schema
CREATE TABLE ar5(gid serial primary key, artype smallint);
-- add a topogeometry column to it
-- integer AddTopoGeometryColumn(varchar topology_name, varchar schema_name, varchar table_name, varchar column_name, varchar feature_type);
SELECT topology.AddTopoGeometryColumn('ar5topo', 'public', 'ar5', 'topo', 'MULTIPOLYGON') AS new_layer_id;
-- use new layer id in populating the new topogeometry column
-- we add the topogeoms to the new layer with 0 tolerance
INSERT INTO ar5(artype, topo)
SELECT artype, topology.toTopoGeom(geom, 'ar5topo', 1)
FROM ar5sf;
```
### Verify and validate
```SQL
-- use to verify what has happened --
SELECT *
FROM topology.TopologySummary('ar5topo');
-- validate topology
SELECT * FROM topology.ValidateTopology('ar5topo');
```
### Use information in topology tables to extract outer borders
```SQL
-- extract outer edges - unordered, without sequence-info (useless)
CREATE TABLE leftnull AS
SELECT left_face, right_face, edge_id, geom
FROM ar5topo.edge_data
WHERE left_face = 0;
-- create a geometry-less table with sequence number and id's for the edges
CREATE TABLE ar5ring AS
SELECT * FROM topology.GetRingEdges('ar5topo', 90);
-- extract outer edges - with sequence-info
CREATE TABLE ar5ringgeom AS
SELECT public.ar5ring.sequence, ar5topo.edge_data.geom
FROM public.ar5ring, ar5topo.edge_data
WHERE left_face = 0
AND (public.ar5ring.edge = ar5topo.edge_data.edge_id)
-- join linestrings
create table ar5singleline as
SELECT ST_COLLECT(geom order by sequence) as geom
FROM ar5ringgeom
```
### Unfortunately, this linestring is not closed. Polygon creation is then more difficult, but hopefully possible.
```SQL
-- check - answer is 'f'
SELECT ST_ISCLOSED(geom)
FROM ar5singleline
```
## PostGIS topology and some other functions used
Function |Task
-- |--
[CreateTopology](http://postgis.net/docs/manual-dev/CreateTopology.html) | Creates a new topology schema and registers this new schema in the topology.topology table
[AddTopoGeometryColumn](http://postgis.net/docs/manual-dev/AddTopoGeometryColumn.html) |Adds a topogeometry column to an existing table, registers this new column as a layer in topology.layer and returns the new layer_id
[toTopoGeom](http://postgis.net/docs/manual-dev/toTopoGeom.html) |Converts a simple Geometry into a topo geometry
[ValidateTopology](http://postgis.net/docs/manual-dev/ValidateTopology.html) |Returns a set of validatetopology_returntype objects detailing issues with topology
[GetRingEdges](http://postgis.net/docs/manual-dev/GetRingEdges.html) |Returns the ordered set of signed edge identifiers met by walking on an a given edge side
[ST_Collect](http://postgis.net/docs/manual-dev/ST_Collect.html) |Return a specified ST_Geometry value from a collection of other geometries
[ST_IsClosed](http://postgis.net/docs/manual-dev/ST_IsClosed.html) |Returns TRUE if the LINESTRING's start and end points are coincident
## Visuals
*AR5 polygons:*
![AR5 polygons](./images/ar5-polygon.png)
*A closer look on faces, edges and nodes - geometry from ar5topo-schema tables:*
![face-edge-node](./images/face-edge-node.png)
*Outer border extracted by means of topology information:*
![ar5-outer-polygon](./images/ar5-ytre-polygon.png)
placeholder for javascript generated html