Lotus is a web tool to help researchers build and manage their online longitudinal research.
When a research consists of several measurements over time with online questionnaires or tasks, it is then important to be sure that each participant carry out the right task in due time. For example, if participants must run some online task once per week, with a pause of at least 2 days, they should not be able to do the task before these 2 days, but they must be warned before the end of the week that they should do this task.
If you have many participants, and that each participant may start the research at different time, it becomes quite difficult (and time consuming) for the researcher to follow the participants and to take care that they do the right things at the right time. You need then a tool to automate this management.
Moreover, you need to keep some parameters for each participant: for example their condition, gender, birthdate, etc. These parameters can influence the task they have to do. Or on the other way, the results of a task can modify these parameters.
You may also need a web page where the participants can log in to identify themselves. And another web page, where it states what they have to do.
Lotus has been built for all these issues: the researcher can define what for tasks/questionnaires the participant has to do, and when it has to be done. You can define which E-Mail or SMS has to be sent to warn the participants (or the researchers). You can define parameters for each participant, which can be automatically updated due to some action done by the participant. You can also define web pages so that participants can register, login, or any kind of pages you would like to show to the participants.
When you have built your project in Lotus, and participants are running it, Lotus let you see what the participants have done: you can see in which state they are, and also when and which tasks they have done, when and which E-Mails they have received. If needed, you can also change some parameters for them: you can monitor them. On top of that, if you work with different researchers, you can define different roles so that some researchers are allowed to see or change only some parameters of the participants.
What Lotus is not: it does not build the questionnaires of tasks. For this, you need to use another tool: for example Qualtrics for an online questionnaire, or Flash or a JavaScript tool for an online task.
Let’s explain in more details the main concepts used by Lotus: Session, Task, Status, Timestamp, Timed Event, User Event, Action and Participant Parameters.
A participant is always in a session. A session can be seen as a timespan where the participant must carry out one or several tasks. A session is delimited by at least 3 timestamps: the StateInitialized (when this session has been initialized), SessionOpen (when the participant may start the task, this can be later than the initialization), SessionClose (when the session will close even if the participant did not finish the task).
A participant has also a status, which indicates in which state he is in the session or the project. The status can be:
The SessionClosed is always an ephemeral status: when the session is closed, Lotus set automatically the participant to the next session, and sets his status to StateInitialized. If no next session is defined, then the status is set to ProjectCompleted.
When a participant finishes a task of his session, he is set automatically to the next task of the session if it exists (his status is then set to SessionOpen). If there is no task anymore in the session, the participant is set per default to the next session (you can change this behaviour by unchecking the 'Close Session When Tasks Finished' parameter of the session: in this case the status of the participant stays at TaskFinished, and the session is closed only when the SessionClose timestamp has passed).
So the state of the participant is defined at least by a session, a task, a status, and at least 3 timestamps. More timestamps can be added during the time of a session: for example, each time a participant is set to a new status, a timestamp corresponding to this status is added. In this way, when a participant starts the task of the session, then his status is set to TaskStarted and a new timestamp TaskStarted is added.
These timestamps are important for the timed events: they are used to trigger some actions during a session. A timed event contains a list of actions. For example, an email is sent 2 days after the session is opened to remind the participant that he has a task to do. For this an action ‘Send reminder to participant’ is first defined. Then a Timed Event containing this action, is set to be triggered 2 days after the SessionOpen timestamp of the session. A timed event can be set for a particular session, or for all sessions.
A typical timed event is for example the 'Open Session' timed event: this timed event is triggered when the SessionOpen timestamp has passed (this can be immediately after the initialization of the session), and executes the ‘Set Status to Session Open’ action.
Another kind of event exists in Lotus: the user event. The timed event is triggered by a timer, which compares the current time with timestamps defined for a participant in a session. A user event is triggered by the user self: each time that the user interacts directly with Lotus, the handling is covered by a user event. For example, when the user logs in, when he starts a task, but also when he finishes a task, all those events are handled by a user event: the Login event, the Start Task and the End Task event. Of course, you may define as many events as you need to for your project. Those events are triggered by the user and execute also a list of actions.
All kinds of actions are possible in Lotus, here is a description of all what is possible.
Participant parameters can be added to define a participant. Lotus allows you to define as many parameters as you want. This can be a username, a password, an email, a phone number, the gender, the birthdate, the condition (control or experiment), or any parameters that are necessary for your experiment. These parameters can be of different type. Here is an overview the parameter types.
You can also add some constraints for these parameters. For example, you want the username or the email address to be unique amongst the participants. You want the email address to be a valid email address, etc. Here you have an overview of all the constraints you may use. These constraints are used when the participant himself set directly a value for one of this parameter. Typically, if the participant is allowed to register himself, then he will fill in a form with input related to some participant parameters. If for example, in the registration form, he wants to use a username that already exists, the unique constraint on the username parameter will be fired, and a related error message will be displayed.
Lotus allows also to define parameter at session level and at project level: a project parameter may be typically the email address used by the project (used in the ‘From’ or ‘Reply-to’ parameters of the emails), and a session parameter may be the session type (screening, training, floow-up, etc…).
As already explained, all interactions with participants are defined by the user events. If a user event has a URL, it can be called from anywhere in the web via https://www.test.uva.nl/lotus/<MyProject>/event/<MyEvent>.
But of course, you may want to define your own web pages for your project. Lotus predefines already 3 pages (you may want to use or not), the Login, the Registration, and the Forgot Password pages. You can modify these pages as you want. For this you can use a HTML editor.
To relate an input to a participant parameter, you must use an input placeholder. For example, if you want the email address in the registration form, and you have a parameter called email, then use ${input.email}. These placeholders will automatically create an HTML input according to the type of the parameter. If the type is for example a string, then a text input HTML element is created, if the type is enumerative, a dropdown is automatically created containing all possible values of the parameter.
Placeholders can be also used to display any information about the participant: in which session is the participant ${session.name} or his username ${user.username}. An overview of placeholders can be seen here.
Lotus allows you to customize these pages as will: for example in the Login page, you may want to use the email address in place of a username, or to add an extra input parameters as ‘School’ or ‘Hospital’ if your participants come from schools or hospitals.
You may add as many pages as you want, by using the Custom pages. A page can be anonymous, that means that you don’t have to be logged in to be able to see this page. The Login, Registration and the Forgot Password pages are anonymous.
If your page is a form containing HTML input, you can set which user event will be fired if the form is submitted.
You can also create other buttons or links in your page, so that when clicked, another user event will be triggered, or a new page will be displayed.
A special page is also pre-defined by Lotus: the status page. This is per default the page displayed when the participant logs in. This page is quite special, because it does not define just one page, but many pages according to the state of the participant. The status page is defined by a list of condition/page pair: when a condition turns out to be true, the corresponding page is used. For example, if the participant is still in StateInitialized, he must wait that the session opens. So the Status page has a condition ${user.status} == STATE_INITIALIZED, and the page will display something like:
Dear ${user.username},
You must wait until ${timestamp.SessionOpen} to be able to start the task.
If the session is opened, then the participant must see a link where he can start the task. The condition will be ${user.status} == SESSION_OPENED and the page will display something like this:
Dear ${user.username}
You may start the task by clicking <a href=”${link.event(Start Task}”>here</a>
When you create a project, Lotus defines for you some standard condition/page pairs, but you can define of course as many condition/page pairs as you need to.
There exists also another way to interact with a participant: the invitation link. This technique is used when you want to generate a special link for a participant (mainly sent via an email) so that this participant by clicking it, will be recognized by Lotus, some specific actions will be executed, and maybe a specific web page will be displayed. The invitation link can be generated via the placeholder ${link.invitation()}. See here for more details.
Lotus does not define the tasks self, it just calls them. If the task is defined somewhere on the web, then an Online type task must be added in Lotus. You must set the URL where this task can be found, and maybe other parameters needed as input by the task. The task must call Lotus back at the end of the task. Typically, it will call the ‘End Task’ user event.
For example, it the task is a survey in Qualtrics, then the URL of the Qualtrics survey must be set. In Qualtrics, you must set the Survey Termination option to ‘Redirect to a URL’ and set it to a user event of your project (something like https://www.test.uva.nl/lotus/<project>/event/end_task, but you can choose of course which event should be called).
Lotus send also always the user ID as URL query parameter. But if you add other parameter in the definition of the task, this parameter will be also added in the URL: https://domain.com/my_task?id=<participant_ID>¶m1=<value1>¶m2=value2.
Lotus supports also Flash and Jasmin tasks. Flash and Jasmin task need a server to run, and lotus offers this possibility. In this case, the results of a task will be also stored in the Lotus database. For this, you need
There is also the possibility to define an expression (using placeholders) that will be resolved at run-time to the right task.
If necessary, you can even build your own task by using the Custom Task type.