See the code on Github sahlinet/tumbo-demoapp
Try out the CLI.
pip install tumbo-server
Log into a Tumbo Instance by:
tumbo-cli.py env local http://localhost:8000
Welcome, {{ username }}. Thanks for logging in.
{% with "/userland/"|add:RUNTIME_USER|add:"/tumbo-demoapp/static/index.html" as next %} Logout {% endwith %} {% else %}Welcome, new user. Please log in.
Login {% endif %}Executor has no port allocated yet.
{% else %} {{SERVICE_IP}}:{{ SERVICE_PORT }} {% endif %}init
is called after starting a Base. You can check with an API Call the last transactions on
init
:
/core/api/base/tumbo-demoapp/transactions/?apy=init
Following text is included from
includes/include.html
Apy
scheduler
is configured with config
*/2 * * *
and following code:
def func(self):
data = {"message": "Hello people!"}
self.datastore.write_dict(data)
Datastore is empty - wait for the next scheduled run...
{% endfor %}


The most common type of loop that we've encountered in JavaScript so far is the for
loop:
for(var i = 0; i < 10; i++) {
   code_to_be_looped
};
This structure is concise and clean, and flexible enough to automatically repeat a simple task or to iterate through an arra.
While in Ruby, on the other hand, for
loops are available to us but are discouraged, for two significant reasons. The first reason, which is ample enough to cover almost all uses on its own, is that Ruby has other built-in methods that more specifically (and concisely) do what we would want a for
loop to be written for in the first place. each
, for example, iterates through arrays with less code than a for loop would require:
array.each { |item| code_to_be_looped }
In addition to the each
loop not needing to be explicitly told how to structure its looping mechanism (declaring a variable, setting start, end, and increment values), we are able to locally define a variable item
that will represent each item in the array as the code is looped. To do this in JavaScript:
for(var i = 0; i < array.length; i++) {
   var item = array[i]
   code_to_be_looped
};
The simpler syntax of Ruby's iterator each
leaves less room for error. It is elegant and terse.
Ruby does have a lovely for
loop, however, in case each
leaves you wanting more control over the details of your looping structure:
for i in 0...10
   code_to_be_looped
end
Since Ruby uses the two dot (..
) and three dot (...
) operators to create special Range objects (which is how we're able to write this for
loop so simply, we could just as easily write this:
(0...10).each { |i| code_to_be_looped }
In fact, what's the difference between the two? Is there any? Let's run them both in irb and see how they behave:
2.2.1 :001 > for i in 0...10
2.2.1 :002?> print "i: #{i} "
2.2.1 :003?> end
i: 0 i: 1 i: 2 i: 3 i: 4 i: 5 i: 6 i: 7 i: 8 i: 9 => 0...10
2.2.1 :001 > (0...10).each { |i| print "i: #{i} " }
i: 0 i: 1 i: 2 i: 3 i: 4 i: 5 i: 6 i: 7 i: 8 i: 9 => 0...10
Seems about the same, right? I guess one is interchangable with the other. Unless... let's just check for the residual value of i
:
2.2.1 :001 > for i in 0...10
2.2.1 :002?> print "i: #{i} "
2.2.1 :003?> end
i: 0 i: 1 i: 2 i: 3 i: 4 i: 5 i: 6 i: 7 i: 8 i: 9 => 0...10
2.2.1 :004 > print i
9 => nil
2.2.1 :001 > (0...10).each { |i| print "i: #{i} " }
i: 0 i: 1 i: 2 i: 3 i: 4 i: 5 i: 6 i: 7 i: 8 i: 9 => 0...10
2.2.1 :002 > print i
NameError: undefined local variable or method `i' for main:Object
from (irb):2
from /Users/bobby/.rvm/rubies/ruby-2.2.1/bin/irb:11:in `<main>'
This is the other reason why the for
loop is discouraged in Ruby. The variable declared as a counter is not local to the loop - it persists after the loop has finished! This could have unintended consequences and should be avoided unless we intend on using the persistent variable for another purpose.
(As a footnote, keep in mind that the above examples are two separate irb sessions - the each
loop doesn't obliterate the previous variable i
, but it does destroy its own upon completion.)


Introduction¶
| Release: | 0.2.2a |
|---|---|
| Date: | Jun 04, 2017 |
Laser Ablation Tools (latools
) is a Python toolbox for processing Laser Ablations Mass Spectrometry (LA-MS) data.
Why Use latools?¶
At present, most LA-MS data requires a degree of manual processing.
This introduces subjectivity in data analysis, and independent expert analysts can obtain significantly different results from the same raw data.
At present, there is no standard way of reporting LA-MS data analysis, which would allow an independent user to obtain the same results from the same raw data.
latools
is designed to tackle this problem.
latools
automatically handles all the routine aspects of LA-MS data reduction:
- Signal De-spiking
- Signal / Background Identification
- Background Subtraction
- Normalisation to internal standard
- Calibration to SRMs
These processing steps perform the same basic functions as other LA-MS processing software.
If your end goal is calibrated ablation profiles, these can be exported at this stage for external plotting an analysis.
The real strength of latools
comes in the systematic identification and removal of contaminant signals, and calculation of integrated values for ablation spots.
This is accomplished with two significant new features.
- Systematic data selection using quantitative data selection filters.
- Analyses can be fully reproduced by independent users through the export and import of analytical sessions.
These features provide the user with systematic tools to reduce laser ablation profiles to per-ablation integrated averages. At the end of processing, latools
can export a set of parameters describing your analysis, along with a minimal dataset containing the SRM table and all raw data required to reproduce your analysis (i.e. only analytes explicitly used during processing).
Very Important Warning¶
If used correctly, latools
will allow the high-throughput, semi-automated processing of LA-MS data in a systematic, reproducible manner.
Because it is semi-automated, it is very easy to treat it as a ‘black box’.
You must not do this.
The data you get at the end will only be valid if processed appropriately.
Because latools
brings reproducibility to LA-MS processing, it will be very easy for peers to examine your data processing methods, and identify any shortfalls.
In essence: to appropriately use latools
, you must understand how it works!
The best way to understand how it works will be to play around with data processing, but before you do that there are a few things you can do to start you off in the right direction:
- Read and understand the following ‘Overview’ section. This will give you a basic understanding of the architecture of
latools
, and how its various components relate to each other. - Work through the ‘Getting Started’ guide. This takes you step-by-step through the analysis of an example dataset.
- Be aware of the extensive documentation that describes the action of each function within
latools
, and tells you what each of the input parameters does.
Overview: Understand latools
¶
latools
is a Python ‘module’.
You do not need to be fluent in Python to understand latools
, as understanding what each processing step does to your data is more important than how it is done.
That said, an understanding of Python won’t hurt!
Architecture¶
The latools
module contains two core ‘objects’ that interact to process LA-MS data:
latools.D
is the most ‘basic’ object, and is a ‘container’ for the data imported from a single LA-MS data file.latools.analyse
is a higher-level object, containing numerouslatools.D
objects. This is the object you will interact with most when processing data, and it contains all the functions you need to perform your analysis.
This structure reflects the hierarchical nature of LA-MS analysis.
Each ablation contains an measurements of a single sample (i.e. the ‘D’ object), but data reduction requires consideration of multiple ablations of samples and standards collected over an analytical session (i.e. the ‘analyse’ object).
In line with this, some data processing steps (de-spiking, signal/background identification, normalisation to internal standard) can happen at the individual analysis level (i.e. within the latools.D
object), while others (background subtraction, calibration, filtering) require a more holistic approach that considers the entire analytical session (i.e. at the latools.analyse
level).
How it works¶
In practice, you will do all data processing using the latools.analyse
object, which contains all the data processing functionality you’ll need.
To start processing data, you create an latools.analyse
object and tell it which folder your data are stored in.
latools.analyse
then imports all the files in the data folder as latools.D
objects, and labels them by their file names.
The latools.analyse
object contains all of the latools.D
objects withing a ‘dictionary’ called latools.analyse.data_dict
, where the each individual latools.D
object can be accessed via its name.
Data processing therefore works best when ablations of each individual sample or standard are stored in a single data folder, named according to what was measured.
Todo
In the near future, latools
will also be able to cope with multiple ablations stored in a single, long data file, as long as a list of sample names is provided to identify each ablation.
When you’re performing a processing step that can happen at an individual-sample level (e.g. de-spiking), the latools.analyse
object passes the task directly on to the latools.D
objects,
whereas when you’re performing a step that requires consideration of the entire analytical session (e.g. calibration), the latools.analyse
object will coordinate the interaction of the different latools.D
objects (i.e. calculate calibration curves from SRM measurements, and apply them to quantify the compositions of your unknown samples).
Filtering¶
Finally, there is an additional ‘object’ attached to each latools.D
object, specifically for handling data filtering.
This latools.filt
object contains all the information about filters that have been calculated for the data, and allows you to switch filters on or off for individual samples, or subsets of samples.
This is best demonstrated by example, so we’ll return to this in more detail in the Data Selection and Filtering section of the Beginner’s Guide
Where next?¶
Hopefully, you now have a rudimentary understanding of how latools
works, and how it’s put together. To start using latools
, install it on your system, then work through the step-by-step example in the Beginner’s Guide guide to begin getting to grips with how latools
works. If you already know what you’re doing and are looking for more in-depth information, head to Advanced Topics, or use the search bar in the top left to find specific information.


Equivalent to clicking the reshape button on the Drawing toolbar and then inserting, moving, or deleting vertices of the selected polygon. A vertex is a point defined by a pair of coordinates in one row of the array that defines the polygon. The array is created by CREATE.OBJECT and EXTEND.POLYGON functions.
Syntax
FORMAT.SHAPE(vertex_num, insert, reference, x_offset, y_offset)
Vertex_num is a number corresponding to the vertex you want to insert, move, or delete.
Insert is a logical value specifying whether to insert a vertex, or move or delete a vertex.
If insert is TRUE, Microsoft Excel inserts a vertex between the vertices vertex_num and vertex_num-1. The number of the new vertex then becomes vertex_num. The number of the vertex previously identified by vertex_num becomes vertex_num+1, and so on.
If insert is FALSE, Microsoft Excel deletes the vertex (if the remaining arguments are omitted) or moves the vertex to the position specified by the remaining arguments.
Reference is the reference from which the vertex you are inserting or moving is measured; that is, the cell or range of cells to use as the basis for the x and y offsets.
If reference is a range of cells, only the upper-left cell is used.
If reference is omitted, the vertex is measured from the upper-left corner of the polygon's bounding rectangle.
X_offset is the horizontal distance from the upper-left corner of reference to the vertex. X_offset is measured in points. A point is 1/72nd of an inch. If reference is omitted, x_offset specifies the horizontal distance from the upper-left corner of the polygon bounding rectangle.
Y_offset is the vertical distance from the upper-left corner of reference to the vertex. Y_offset is measured in points. If reference is omitted, y_offset specifies the vertical distance from the upper-left corner of the polygon bounding rectangle.
Remarks
You cannot delete a vertex if only two vertices remain.
Examples
The following macro formula deletes the second vertex of the selected polygon:
FORMAT.SHAPE(2, FALSE)
The following macro formula moves the thirteenth vertex 6 points to the right and 4 points below the upper-left corner of cell B5 on the active worksheet:
FORMAT.SHAPE(13, FALSE, !$B$5, 6, 4)
The following macro formula inserts a new vertex between vertices 2 and 3. The new vertex is 60 points to the right and 75 points below the upper-left corner of the polygon's bounding rectangle:
FORMAT.SHAPE(3, TRUE, , 60, 75)
Related Functions
CREATE.OBJECT Creates an object
EXTEND.POLYGON Adds vertices to a polygon
Return to index


| summary.gam {mgcv} | R Documentation |
Takes a fitted gam
object produced by gam()
and produces various useful
summaries from it. (See sink
to divert output to a file.)
## S3 method for class 'gam' summary(object, dispersion=NULL, freq=FALSE, ...) ## S3 method for class 'summary.gam' print(x,digits = max(3, getOption("digits") - 3), signif.stars = getOption("show.signif.stars"),...)
object |
a fitted |
x |
a |
dispersion |
A known dispersion parameter. |
freq |
By default p-values for parametric terms are calculated using the Bayesian estimated
covariance matrix of the parameter estimators. If this is set to |
digits |
controls number of digits printed in output. |
signif.stars |
Should significance stars be printed alongside output. |
... |
other arguments. |
Model degrees of freedom are taken as the trace of the influence (or hat) matrix A for the model fit. Residual degrees of freedom are taken as number of data minus model degrees of freedom. Let P_i be the matrix giving the parameters of the ith smooth when applied to the data (or pseudodata in the generalized case) and let X be the design matrix of the model. Then tr(XP_i) is the edf for the ith term. Clearly this definition causes the edf's to add up properly! An alternative version of EDF is more appropriate for p-value computation, and is based on the trace of 2A - AA.
print.summary.gam
tries to print various bits of summary information useful for term selection in a pretty way.
P-values for smooth terms are usually based on a test statistic motivated by an extension of Nychka's (1988) analysis of the frequentist properties of Bayesian confidence intervals for smooths (Marra and Wood, 2012). These have better frequentist performance (in terms of power and distribution under the null) than the alternative strictly frequentist approximation. When the Bayesian intervals have good across the function properties then the p-values have close to the correct null distribution and reasonable power (but there are no optimality results for the power). Full details are in Wood (2013b), although what is computed is actually a slight variant in which the components of the test statistic are weighted by the iterative fitting weights.
Note that for terms with no unpenalized terms (such as Gaussian random effects) the Nychka (1988) requirement for smoothing bias to be substantially less than variance breaks down (see e.g. appendix of Marra and Wood, 2012), and this results in incorrect null distribution for p-values computed using the above approach. In this case it is necessary to use an alternative approach designed for random effects variance components, and this is done. See Wood (2013a) for details: the test is based on a likelihood ratio statistic (with the reference distribution appropriate for the null hypothesis on the boundary of the parameter space).
All p-values are computed without considering uncertainty in the smoothing parameter estimates.
In simulations the p-values have best behaviour under ML smoothness selection, with REML coming second. In general the p-values behave well, but neglecting smoothing parameter uncertainty means that they may be somewhat too low when smoothing parameters are highly uncertain. High uncertainty happens in particular when smoothing parameters are poorly identified, which can occur with nested smooths or highly correlated covariates (high concurvity).
By default the p-values for parametric model terms are also based on Wald tests using the Bayesian
covariance matrix for the coefficients. This is appropriate when there are "re" terms present, and is
otherwise rather similar to the results using the frequentist covariance matrix (freq=TRUE
), since
the parametric terms themselves are usually unpenalized. Default P-values for parameteric terms that are
penalized using the paraPen
argument will not be good. However if such terms represent conventional
random effects with full rank penalties, then setting freq=TRUE
is appropriate.
summary.gam
produces a list of summary information for a fitted gam
object.
p.coeff |
is an array of estimates of the strictly parametric model coefficients. |
p.t |
is an array of the |
p.pv |
is an array of p-values for the null hypothesis that the corresponding parameter is zero. Calculated with reference to the t distribution with the estimated residual degrees of freedom for the model fit if the dispersion parameter has been estimated, and the standard normal if not. |
m |
The number of smooth terms in the model. |
chi.sq |
An array of test statistics for assessing the significance of model smooth terms. See details. |
s.pv |
An array of approximate p-values for the null hypotheses that each smooth term is zero. Be warned, these are only approximate. |
se |
array of standard error estimates for all parameter estimates. |
r.sq |
The adjusted r-squared for the model. Defined as the proportion of variance explained, where original variance and
residual variance are both estimated using unbiased estimators. This quantity can be negative if your model is worse than a one
parameter constant model, and can be higher for the smaller of two nested models! The proportion null deviance
explained is probably more appropriate for non-normal errors. Note that |
dev.expl |
The proportion of the null deviance explained by the model. The null deviance is computed taking account of any offset, so
|
edf |
array of estimated degrees of freedom for the model terms. |
residual.df |
estimated residual degrees of freedom. |
n |
number of data. |
np |
number of model coefficients (regression coefficients, not smoothing parameters or other parameters of likelihood). |
rank |
apparent model rank. |
method |
The smoothing selection criterion used. |
sp.criterion |
The minimized value of the smoothness selection criterion. Note that for ML and REML methods, what is reported is the negative log marginal likelihood or negative log restricted likelihood. |
scale |
estimated (or given) scale parameter. |
family |
the family used. |
formula |
the original GAM formula. |
dispersion |
the scale parameter. |
pTerms.df |
the degrees of freedom associated with each parametric term (excluding the constant). |
pTerms.chi.sq |
a Wald statistic for testing the null hypothesis that the each parametric term is zero. |
pTerms.pv |
p-values associated with the tests that each term is zero. For penalized fits these are approximate. The reference distribution is an appropriate chi-squared when the scale parameter is known, and is based on an F when it is not. |
cov.unscaled |
The estimated covariance matrix of the parameters (or
estimators if |
cov.scaled |
The estimated covariance matrix of the parameters
(estimators if |
p.table |
significance table for parameters |
s.table |
significance table for smooths |
p.Terms |
significance table for parametric model terms |
The p-values are approximate and neglect smoothing parameter uncertainty. They are likely to be somewhat too low when smoothing parameter estimates are highly uncertain: do read the details section. If the exact values matter, read Wood (2013a or b).
P-values for terms penalized via ‘paraPen’ are unlikely to be correct.
Simon N. Wood<EMAIL_ADDRESS>with substantial improvements by Henric Nilsson.
Marra, G and S.N. Wood (2012) Coverage Properties of Confidence Intervals for Generalized Additive Model Components. Scandinavian Journal of Statistics, 39(1), 53-74.
Nychka (1988) Bayesian Confidence Intervals for Smoothing Splines. Journal of the American Statistical Association 83:1134-1143.
Wood, S.N. (2013a) A simple test for random effects in regression models. Biometrika 100:1005-1010
Wood, S.N. (2013b) On p-values for smooth components of an extended generalized additive model. Biometrika 100:221-228
Wood S.N. (2017) Generalized Additive Models: An Introduction with R (2nd edition). Chapman and Hall/CRC Press.
gam
, predict.gam
,
gam.check
, anova.gam
, gam.vcomp
, sp.vcov
library(mgcv) set.seed(0) dat <- gamSim(1,n=200,scale=2) ## simulate data b <- gam(y~s(x0)+s(x1)+s(x2)+s(x3),data=dat) plot(b,pages=1) summary(b) ## now check the p-values by using a pure regression spline..... b.d <- round(summary(b)$edf)+1 ## get edf per smooth b.d <- pmax(b.d,3) # can't have basis dimension less than 3! bc<-gam(y~s(x0,k=b.d[1],fx=TRUE)+s(x1,k=b.d[2],fx=TRUE)+ s(x2,k=b.d[3],fx=TRUE)+s(x3,k=b.d[4],fx=TRUE),data=dat) plot(bc,pages=1) summary(bc) ## Example where some p-values are less reliable... dat <- gamSim(6,n=200,scale=2) b <- gam(y~s(x0,m=1)+s(x1)+s(x2)+s(x3)+s(fac,bs="re"),data=dat) ## Here s(x0,m=1) can be penalized to zero, so p-value approximation ## cruder than usual... summary(b) ## p-value check - increase k to make this useful! k<-20;n <- 200;p <- rep(NA,k) for (i in 1:k) { b<-gam(y~te(x,z),data=data.frame(y=rnorm(n),x=runif(n),z=runif(n)), method="ML") p[i]<-summary(b)$s.p[1] } plot(((1:k)-0.5)/k,sort(p)) abline(0,1,col=2) ks.test(p,"punif") ## how close to uniform are the p-values? ## A Gamma example, by modify `gamSim' output... dat <- gamSim(1,n=400,dist="normal",scale=1) dat$f <- dat$f/4 ## true linear predictor Ey <- exp(dat$f);scale <- .5 ## mean and GLM scale parameter ## Note that `shape' and `scale' in `rgamma' are almost ## opposite terminology to that used with GLM/GAM... dat$y <- rgamma(Ey*0,shape=1/scale,scale=Ey*scale) bg <- gam(y~ s(x0)+ s(x1)+s(x2)+s(x3),family=Gamma(link=log), data=dat,method="REML") summary(bg)


| DOSE: |
70 mg |
oral |
2C-P |
(powder / crystals) |
The following account describes two 2C-P overdoses experienced by the same individual (me in this case) within a week. The first incident lead to a brief hospitalization, the second was overcome without medical attention, but made a longer period of recuperation necessary.
The circumstances leading to this tragedy were quite simple. I obtained samples of various psychoactive materials using a now defunct chemical supply company specialized in such products, and proceeded to test them in the following weeks. Among other chemicals they also sent me a mislabeled batch of 2C-P. The sticker on the vessel identified the compound falsely as Buphedrone. At that point I had gained enough experience and confidence conducting such experiments, to allow myself to get sloppy. Slowly ramping up doses and reagent tests before that in order to rule out obvious contaminations or mislabeling had given way to a less cautious approach.
One warm summerís evening I found myself without much to do, and decided to give the chemical I expected to be nothing more than another mildly underwhelming stimulant a go. In reality I started the evening by ingesting 70mg 2C-P on an empty stomach. Oh, and I chased it with plenty of fresh grapefruit juice.
Stimulating effects along with increases in pulse and blood pressure and sweating developed within the following half hour. It didnít feel particularly pleasant, but it wasnít totally at odds with reports about Buphedroneís supposed effects profile. Then visual activity started, and a subtle shift in perception encompassing all other senses followed within one hour of ingestion. I knew something was going terribly wrong. I hastily checked the equipment and vessels used to prepare the dose and came to the conclusion that I must have weighed out 2C-P instead of Buphedrone. Both compounds had the same appearance and came in (apart from the labeling) identical looking plastic bags.
The chemicals effects were taking hold in increasing intensity. I looked up the generally accepted dose chart for 2C-P and the uncharacteristically fast development of the effects and was convinced to be the victim of a massive poisoning, brought about by staggering stupidity on my part. I violently threw up approx. 90 minutes after dosing. It took a huge effort to stay coherent enough to call an ambulance, and convey what I had done. The hospital I was brought had never seen a poisoning like this. I was the drug-overdose freak of the month; everybody came to take a look. They were unsure what do do, but at least had sense enough to call some toxicologists at a nearby university hospital.
They of course mistook 2C-P with 2C-B, but I was too far gone to correct them. It made no difference anyhow. The muscle tremors in my lower extremities which had been the most pronounced side effect from the start developed into uncontrollable muscle spasms.
They moved me to an intensive care unit where I was stuffed with more tubes and medical gear than I could count. The experience meanwhile had reached and exceeded a solid +++ on the Shulgin scale. So the procedures the staff had to perform on me weren't just painful and uncomfortable, no, they were terrorizing and insufferable due to the influence of the chemical. It took a long while before I mercifully lost consciousness. After emptying my stomach and trying to stop further resorbation with charcoal. They laid a central port near the heart, took steps to keep heart and respiration going and constantly analyzed blood and urine to have a look at how my liver and kidneys were holding up against the assault.
I awoke the next day, still attached to an impressive machine park at the ICU. During the day they plugged me out, cleaned me up, and released me against their specific advice after a psychiatrist looked me over on my own recognizance. A trusted friend picked me up and looked after me the following weekend.
I could have died, but I didn't. The doctor said my kidneys and liver made it, probably without too much damage, how my brain did is anybodyís guess, but so far I havenít been able to discern any kind of impairment. Long-term damage of course has to be assessed but I doubt there will be much.
The second incident occurred one week later when I finally came around to test the stimulant as originally intended. There was no mistake this time. I weighed out of the vessel labeled Buphedrone.
The vendor had mislabeled the bags. I was able to get in contact with former staff months after the incident. They reached out to me after reading my trip report. They claimed that it was a mishap during packing, caused by negligence and overworked staff forced to keep 14h shifts. They further claimed that nine customers were sent contaminated product but six of them could be warned. NMR analysis of samples returned to them confirmed 2C-P to be the contaminant.
I put too much trust in the excellent reputation the operation maintained in the research chemical subculture. The whole thing reminded of the infamous tragedy surrounding Haupt RC that had cost several peopleís lives only a year before.
This time I overdosed on 80mg. Imagine the pure terror and despair when I realized I had to go through the same insane nightmare AGAIN within 6 days of stumbling out of a hospital! I couldn't cry and couldn't vomit, although I sincerely wished to perform at least one of the two. After sending an email to the vendor begging him to warn other customers and halt all sales and dropping warnings on several drug-related internet message boards decided to ride it out without calling an ambulance. This was not a smart decision, but the experience at the hospital was nothing short of traumatic, and my growing intoxication made rational thinking a challenge.
It took around five hours before I lost consciousness completely. It started with profuse sweating and again uncontrollable muscle spasms and got worse from there. The trip lasted over 30 hours, 24 of those at or beyond at a barely controllable level or way beyond that. The night was chaotic and apocalyptic. I did not sleep and was heavily disorientated. No music, no light, the visual and auditory distortions grew too intense to comprehend any external input anyway. Psychotic and delirious, would be an accurate descriptions of my mindset in those hours.
I loved the moment the sun came up.  The world around me looked like a churning and swirling Van-Gogh painting -only much sharper, more precise. A naked animal, poisoned and exhausted, but thanks to the very same poison every function of its being dialed up to 150%. I knew I would survive this, there was a way out. Felt great. I spend the day at +++, the evening at ++. I called in sick (and underneath the heavily distorted body-buzz I was), but had to type some emails, make a couple of phone calls and review some texts. In hindsight I actually produced decent work that day, enhanced by crystal clear, super precise psychedelic thinking.
In the evening following I called a friend, she picked me up and nursed me the following days. I needed several days to repair, spent mostly sleeping. 30 hours tripping hard without food or sleep took something out of me. At least no kidney pain or skin yellowing, so maybe not too much damage after all. I could not tell her what I had done to myself, same goes for close friends family and acquaintances so I faked a burnout episode, which was entirely believable, since I did have a 60h per week high stress job.
 I don't regret them, especially the second one was very insightful, but I could've done without those experiences. After those incidents I was at a juncture: either quitting these types of experiments altogether or continuing them in spite of having felt what the slightest mistake or careless oversight can cause. I chose to continue, but I am compulsively sticking to a long list of safety measures designed to spare myself and my loved ones another episode of this kind.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


{% extends "base.html" %} {% block title %}The West Virginia Party{% endblock %} {% block nav_events %}active{% endblock %} {% block content %}
The wild, wonderful West Virginia reception will be hosted by Bruce and Barbara Davis in their beautiful backyard the weekend following the ceremony. Dinner, beverages and West Virginia merriment will be provided.
Saturday, September 12th, 2015
6:00 – 10:00 pm
The Davis Home
306 Beechwood Est
Scott Depot, WV 25560
[ Map ]


NO-STATUS
The Load Progress example demonstrates how to listen for and handle events that occur while a NaCl module loads. This example listens for different load event types and dispatches different events to their respective handler. This example also checks for valid browser version and shows how to calculate and display loading progress.


All the words
Understandings
Definitions
Dreams
Plans
Medicines
Solutions
Futures
Are all found
Within our hearts
Hearts that are not alone
And are tiedly connected
From here to forever
Because
When God unites two soul
He is certain
With the rhythms and secrets of their hearts
They can create their future
Solve any problem
And write their own story.


Robin Care offers patients and caregivers comprehensive cancer support. Each patient has 24-7 access to a team of coaches and nurses to help them navigate the journey. Our web and mobile apps provide education, tools, and resources to empower patients every step of the way.
BUILT BY EXPERTS
Designed by oncologists, social workers, and health care industry veterans, Robin Care provides round-the-clock support to cancer patients.
DIAGNOSIS TO SURVIVORSHIP
Robin Care uses proven pathways and protocols to support patients. We bring clarity to the complex cancer journey.
PERSONALIZED TO EACH PATIENT
The cancer experience is different for every patient. We tailor information, resources, and advice for each unique journey.
THERE ARE 1.6 MILLION NEW CASES OF CANCER EVERY YEAR
LIFETIME RISK
Each person has a more than 40% chance of developing cancer in their lifetime
ECONOMIC BURDEN
Cancer costs are growing fast and expected to exceed $158B by 2020
INEFFICIENT USE
Less than 2% of cancer dollars are going towards improving the experience of cancer patients


About Me
Hi and welcome.
My name is Scott Johnson, and I'm currently working as an Operations Controller at DSM Dyneema where I do Finance things (MBA, East Carolina University) mixed with Engineer things (BS Industrial Engineering, West Virginia University). My experience in pharmaceutical and textile manufacturing has focused on process imprvovement and finance roles, but my long time interest in programming and web development has led me to also code things with the coding bootcamp at the University of North Carolina.
A West Virginia native (it's not western Virginia, go Mountaineers!), but a North Carolina resident (no shoveling snow here!). I love traveling with my family, attempting to play basketball, creating things that help people get things done, keeping notes in moleskine notebooks, and our 25lb Maine Coon cat (Max).


The 7D2D Launcher provides an effortless way to play your favorite mods for 7 Days To Die
The 7D2D Launcher provides a single file configuration that lets you specify your download links, website, and other information. By providing that file to your players, they will keep up to date with all your changes that you do, without having to hunt down forum posts.
The 7D2D Launcher provides you with a wider player base to use your mods.
My Mods introducing a concept to help players deploy mods from the 7 Days to Die modding community for single player instances. By following the My Mods Standard, modders can open up their mods to a wider player base, and provide a more consistent format.


|
|
|
Free
Raisins
Audrey Knuth (fiddle)
Jeff Kaufman (mandolin, trumpet, feet)
Amy Englesberg (piano, accordion)
An energetic
dance band from Boston, the Free Raisins fuse New
England roots with a modern groove. They promise a
versatile mix of supremely danceable
tunes.
Sarah VanNorstrand
Sarah, from Syracuse, NY, says: "Above all, my goal as a caller is to make sure the dancers are having as much fun as I am! I love dancing, community and music and I always try to communicate that enthusiasm in my calling." Watch her in action here.
Ukrainian Hall
405 Fairmount W.
(at Hutchison)
Montreal, H2V 4B4, Map
6:30 pm - 7 pm: Introductory session. Recommended
for new dancers.
7 pm - 10 pm: Dance
Regular: $14 (Members: $12)
Students: $10 (Members: $8)
Special offer:
First-time dancers receive a free pass for their
second dance
|


3 R and RStudio Basics
3.1 What is R?
In Chapter 2, I discussed many of the reasons why you should begin doing your analyses (especially those of the data type) using R. If you skipped over that chapter in the hopes of just diving in to learning about R, I suggest you go back and read it over carefully. As you begin building fluency in working with R, it is especially important to review that introductory chapter from time to time.
3.1.1 R beginnings
R was developed by a group of statisticians who wanted an open-source alternative to the costly proprietary options that were (and still are) popular. Because it was created by statisticians (instead of computer scientists), R has some quirky aspects to it that take some time to get used to. We’ll see that many packages have been developed to help with this, and these days, you don’t need an advanced degree in statistics to work with R.
Getting back to the development of R… R was created by Ross Ihaka and Robert Gentleman in New Zealand at the University of Auckland. It is a spin-off of the S programming language and was named partly after the first names of its developers (as you can see from the emphasis above). The beginning ideas for creating R came in 1992, and the first version of R was released in 1994. You can find much more about the background of R, its features, and its connections to the S language on Wikipedia.
3.1.2 R packages
I first learned to use R as a graduate student at Northern Arizona University from Dr. Philip Turk in 2007. At the time, I never thought that R could have exploded in users as we have seen since 2011. I never would have thought that students taking an introductory statistics course would be encouraged to learn to use R.
In 2007, R was still largely an esoteric and tricky language used by statisticians to do analyses. Getting used to the syntax for producing plots and working with data was especially tricky for those with little to no programming experience. So what has changed since 2007 about learning R?
I believe one of the biggest developments has been the creation of packages to make R easier to work with for newbies. Packages are add-ons created by users of R to increase the functionality of the base R installation. Packages created by Hadley Wickham and others recently have greatly expanded the capabilities of R, while also working to make beginning with R simpler. As of April 2017, more than 10,400 packages were available on common R repositories.1
Another great development is the graphical user interface called RStudio and a package developed by RStudio, Inc. called rmarkdown
. We will discuss rmarkdown
(also referred to as R Markdown) in a Chapter 4, and will now focus on discussing RStudio.
3.2 What is RStudio?
RStudio is a powerful, free, open-source integrated development environment for R. Development on RStudio began in 2010, and the first beta was released in February 2011. It is available in two editions: RStudio Desktop and RStudio Server. This book will focus mostly on RStudio Server, but both versions are nearly identical to work with.
Instructions for downloading and installing R and RStudio on Windows and Mac machines are linked below. If you are using RStudio Server, your professor or members of your organization’s IT department have done these steps for you. For RStudio Server, you log on using a web browser to an account on the cloud. There are many advantages to using the RStudio Server for beginning users, including sharing of R projects to help with feedback and error resolution. Installation of software can also cause its own headaches, which are eliminated by using the RStudio Server.
Note for advanced users: You can also install your very own RStudio Server for around $5 per month on Digital Ocean. Instructions to do so can be found from Dean Attali here and on the Digital Ocean site here.
After you complete a few months of work with the RStudio Server, it is recommended that you download RStudio Desktop to your computer. The instructions to do so are below.
3.2.1 Installing R and RStudio Desktop
It is worth noting that you can’t just install RStudio Desktop without first installing R, as RStudio needs to have R installed to run. Step-by-step guides to installing R and RStudio Desktop with screenshots are available
Unless you plan to create PDF documents (which requires a multiple gigabyte download of LaTeX), you can skip some of the later steps of the installation. It is recommended that you select HTML as the Default Output Format for R Markdown. You’ll see more about this in Chapter 4.
3.3 Working in RStudio Server
3.3.1 Logging in and initial screen
The RStudio Server provides a web-based interface to run analyses in R. This means that you will only need an internet connection and a web browser to run your analyses. Your professor or administrator will provide you with a link to the web location of your RStudio Server. After entering the link, you’ll see a page that looks something like:
After logging in with your username and password, you should see a layout similar to what follows.
For reference, a screenshot of RStudio Desktop looks similar:
This makes switching between the two RStudio set-ups painless. A discussion of each of the different RStudio panes and their corresponding tabs is in Chapter 4. You’ll find that a lot of what follows also applies to RStudio Desktop (except for the Shared Projects feature), but it is always recommended to create an RStudio project regardless of whether you are on the cloud or working locally.
3.3.2 Basic Workflow with RStudio
When starting a new R project, it is good practice to create a new RStudio project to go along with it. RStudio project files have the extension .Rproj
and store metadata and information about the R environment you are working in. More information about RStudio projects is available from RStudio, Inc.
If you are sharing homework or lab assignments with your instructor using RStudio Server, for example, it might make sense to create an RStudio project, share it with your instructor, and then create new folders for each lab. We will follow this example below.
The video below shows you how to create a new RStudio project called initial
and add your first R Markdown file. Note that you also may see a description about what version of R is running on your initial login, as shown in the screencast below in the Console pane.
We have our first_rmarkdown.Rmd file set up.
3.4 RStudio Layout
Initially, you may be a little overwhelmed by all the different panes and tabs that are available in RStudio, but you will soon learn to appreciate this layout. We will begin with the top left pane and proceed clockwise. The layout of these panes can be customized, but it is recommended that beginning users keep the standard layout.
3.4.1 Code Editor / View Window
The pane in which you will likely spend a majority of your time is the pane on the top left. When you first login, this pane isn’t there, but it appeared when we made the first_rmarkdown.Rmd. This pane serves as a place to view the contents of files and objects in R. In the screencast below, you can see that we can change the text in this file and then save the file.
Note that, when you edit the file, the tab with the file name changes from black to red, and an asterisk appears after the file name, indicating that the latest changes have not been saved. You should get in the habit of saving files frequently. You can have multiple tabs open and view different files in this pane. In Chapter 4, you’ll also see that you can View
datasets in this pane.
It may not be clear what these additions are really doing just yet. That’s ok! When finished, you’ll be pressing the Knit HTML button near the top of the pane to put all of your text, code, and its output together. We aren’t quite there just yet though!
3.4.2 Environment / History
By default, the top right pane includes an Environment tab and a History tab. To get a sense of what these tabs provide, we’ll need to also use the bottom left pane and the Console tab. I’ll show you how to create multiple objects in R using the Console. Initially, you will see that the Environment tab tells us that the “Environment is empty.” This means there are no objects (e.g., data) yet. If you click on the History tab, you should also see a blank screen with a few icons. We won’t go over all of these buttons here, but I encourage you to hover over them and click on them to get a sense for what they do. As I enter code into the Console, watch to see how the Environment and History tabs change.
You can think of the Console as a place to play around. It is your R sandbox. You can test your code to make sure it is working and then copy that text into your Rmd file once you are satisfied with it. We’ll see more examples of this in the chapters to come.
Note that, by default, when you enter the name of an object into the console like I did with sum_1_2
it displays the result. You’ve also been shown what is called the assignment operator denoted by <-
. You can read this as putting the contents of the right-hand-side into an object named whatever appears on the left-hand-side. In the example, num1
is the name of an object that stores the value 7.
A powerful feature of the R language has been introduced in the sum_1_2 <- sum(num1, num2)
line. sum
is a function. Functions are denoted by their name and then a parenthesis, followed by one or more arguments separated by commas, and then a closing parenthesis. You’ll see many examples of these going forward. Of course, we’ll be using R for more than just a basic calculator shown here but this should give you an idea of what the Environment and History tabs store.
3.4.3 Console
You’ll frequently use the Console as a way to check your work or experiment with how to solve a problem using R. Before RStudio, most users of R just had a window like the Console provides where they entered their commands and then looked at the results in different windows. We will see that the Console and the Code Editor/View Window will allow us to store all of our code in a file and then “run” that code through the Console to check that it works. The example video below shows how this is done.
Rules for naming objects
It is good practice to get in the habit of naming variables corresponding to what they actually represent. If you are dividing two different sums of numbers, you might want to choose a name like ratio_of_sums
to refer to that object. R has a few restrictions regarding what can be included in the name of R objects:
- Object names cannot begin with a number.
- Object names cannot contain symbols used for mathematics or to denote other operations native to R. These symbols include
$
,@
,!
,^
,+
,-
,/
, and*
.
Another important property of R is that is case-sensitive. You’ll see what this means in the video below that also includes examples of invalid names of objects. Note that we will continue to work inside the R chunk as we did in the last video. You’ll see that these code chunks provide a nice way to keep track of our important analyses.
You may have noticed that R will do some checks and alert you to potential errors by placing a red X to the left of lines of code with common syntax errors. These checks won’t catch all errors, but this can be helpful. Note also that Name
, name
, and nAme
refer to three different values.
Another thing to notice is that you can store numbers into an object with a given name like we did earlier with num1
. If we’d like to store a character string such as “Chester,” we can provide the name of the object on the left-hand-side of <-
and the string in quotation marks on the right-hand-side of <-
. There are more complex object types that you will see in Chapter 5, but it is always important to think about the difference between a number and a character in R.
It’s also a good idea to not call objects the names of functions that are built into R. You may want to call the addition of two numbers sum
and R will allow this, but it is HIGHLY recommended that you create more descriptive names and not choose to name objects the same as common R functions. Something like sum_densities
is better and less likely to be the name of a function.
3.4.4 The help
function (?
)
Of course, you won’t know what all of the names of built-in functions are until you practice, but it is something to think about. If you are ever wondering if a function is built-in or is in a package you have included, you can use the ?
function in the Console to check. Some examples are shown below as a screencast.
3.4.5 The bottom right pane
The bottom right pane in RStudio contains the most tabs by default and is a useful place to view a variety of miscellaneous information about your RStudio project and its files.
Files
The leftmost tab here shows the file and folder structure for the current working directory. In an RStudio project, this is the folder in which the project file was saved. This shows you where the files are stored, what they are called, and any folders that may exist in your project folder. This can be thought of as similar to going to My Computer on a PC or opening Finder on a Mac. Similarly, this tab lists the file and directory structure either on the cloud for RStudio Server or on your local machine for RStudio Desktop.
Plots / Viewer
You’ll see clearer examples of what the Plots and Viewer tabs provide in Chapter 4. As you likely guessed Plots will show you the resulting graphs/figures that your R code has generated. The Viewer tab can show you the resulting HTML file created from an R Markdown Knit.
Packages
The Packages tab lists all packages installed on your computer or cloud server. You can see which packages are loaded in the current working environment by looking to see if a check-mark exists next to the package name. Note that you may not have all of the packages loaded onto your machine that I do below in the video. That’s OK. This is just an example of what you may expect.
You’ll also notice a Description of the package as well as the Version number here. Packages are frequently updated and improved, so this is a way to check whether you have the most up-to-date version of a package. Remember, if you are using RStudio Server, this is likely taken care of for you. If you are using RStudio Desktop, you might find the Install and Update buttons useful for downloading new packages or updating currently installed ones.
Help
We also saw an example of using the Help tab when we invoked the ?
function. This will show you documentation on R functions, datasets, and packages. When (not if) you come across code and you aren’t sure what it does, it is often helpful to enter a question mark followed by the name, and see if the built-in documentation can help you out.


Life and art: which is the real and which is the represented?
Daniele d'Ingeo's practice explores the boundary between reality and fiction and their influence on one another. Focusing on intimacy and sexuality, he reflects on the way they are represented and thus experienced.
The Execution challenges the genre of pornographic films by documenting a live performance that displaces homo-erotic shapes and movements onto a different stage. This mise-en-scène questions the authenticity of the pattern of sexual interactions and reaches the performative core of the carnal acts. The actors engage in a unique choreography that unfolds as the line between performers and living sexual beings stays blurred.
Will the show go on once the curtain falls?