by Samuele Lilliu | 3 February 2023
Setting up an Editorial Framework for a Peer-Reviewed Video Journal with WordPress (Toolset, Elementor) and MATLAB.
This is a summary of my experience in running a peer-reviewed journal using a WordPress+ plugins and custom MATLAB applications for the journal editorial process, typesetting, and publication. My honest suggestion is: stay away from WordPress (and similar database systems) and develop a custom serverless platform.
Here are a few reasons why you might not want to use WordPress for a peer-reviewed journal:
My plan is to migrate the entire site from WordPress to Hugo. Right now, I believe this WordPress website is ridiculously complicated. There will be many advantages in doing this, including cleaner code, faster website, and free hosting.
The peer-review process is an essential part of the publication of research articles in academic journals. This process ensures that research articles are rigorously evaluated by experts in the field before they are published, ensuring that only high-quality and reliable research is disseminated to the scientific community.
The peer-review process typically starts when a researcher submits a research article to a journal. The article is then assigned to an editor, who is responsible for ensuring that the article is suitable for publication and that it adheres to the journal’s guidelines and standards. If the editor determines that the article is suitable for publication, they will send it out for peer review.
Peer review is a critical step in the publication process. It involves sending the article to two or more experts in the field, who are asked to evaluate the quality and validity of the research. These experts will typically review the article for accuracy, clarity, and completeness, and they may also provide suggestions for improvement.
Once the peer-review process is complete, the editor will receive the reviewer’s comments and recommendations. Based on this feedback, the editor will make a decision about whether to accept, reject, or ask the author to revise the article. If the article is accepted, it will be prepared for publication, which typically involves copy-editing, proofreading, and formatting.
Once the article is published, it will be available for the scientific community to read, comment on, and cite. This is an important step in the dissemination of knowledge and helps to advance the field by making new research findings available to others.
A peer-reviewed video journal is a type of academic journal that specializes in publishing research articles in the form of videos. This format allows researchers to present their findings in a more interactive and visual way, and it can be especially useful for demonstrating complex processes, procedures, or techniques.
Just like traditional text-based academic journals, peer-reviewed video journals use a rigorous peer-review process to evaluate the quality and validity of submitted articles, from which the videos are produced.
The peer-review process is an important step in ensuring that only high-quality and reliable research is published in peer-reviewed video journals. It helps to ensure that the scientific community has access to the latest and most important research findings, and it helps to advance the field by making new research findings available to others.
Peer-reviewed video journals can be an excellent resource for researchers and students, as they provide an engaging and interactive way to learn about new research findings. They can also be a valuable tool for science communication, as they allow researchers to share their findings with a wider audience in an accessible and understandable way.
In summer 2017 I was contacted multiple times by a notorious peer-reviewed video journal, JOVE. The Journal of Visual Experiments (JOVE) is an academic, peer-reviewed video journal that specializes in publishing scientific research in the form of videos. JOVE is unique in that it focuses exclusively on publishing videos that demonstrate experimental techniques and procedures, making it an important resource for researchers and students in a wide range of scientific fields.
Since by then I had been working on video productions, my feeling was that the quality of the video productions offered by JOVE was suboptimal, especially considering their charges.
So, I decided to set up my own journal: Scientific Video Protocols.
The costs involved in setting up a peer-reviewed journal can vary widely depending on the size and scope of the journal, as well as the level of professional services and support you require. Some of the most common costs associated with setting up a peer-reviewed journal include:
It’s important to keep in mind that these costs can add up quickly, and that you’ll need to budget carefully to ensure that your journal is financially viable in the long term.
My main concern when I started working on Scientific Video Protocols, a peer-reviewed video journal, was to minimize the hosting and CMS costs. I did some research and spoke to retailers that normally serve the likes of Elsevier and Springer, and the required invested started somewhere around £5000 per year. The advantage of using existing publishing platforms is that you don’t need spend much time on the development side and you can theoretically just focus on setting up the editorial workflow and how the published articles will look like. However, £5000 or more was not an option, so I started exploring free options.
There are several free options for setting up a peer-reviewed journal:
These options allow you to set up and manage a peer-reviewed journal without incurring any significant costs, making them accessible to small, independent publishers and non-profit organizations, including predatory journals. Well, it turns out the majority of predatory journals use OJS.
Open Journal Systems (OJS) is a free, open-source software platform that is used to manage the publishing process of academic journals. It is designed to support the management of the submission, peer-review, and publication of articles, as well as the distribution of published content.
OJS is a complex platform that includes many features and functions, including user management, submission tracking, peer-review management, and more. It is designed to be highly flexible and customizable, but this flexibility can also make it challenging to modify.
One reason why OJS can be difficult to modify is because it is built using complex code and architecture. This code is often written in PHP. Additionally, the codebase for OJS is large and complex, making it difficult to locate and modify specific parts of the platform.
Overall, while OJS is a powerful and flexible platform for managing academic journals, it can be challenging to modify for users who are not familiar with the code and architecture of the platform. This is why it is often recommended that users seek the help of a developer or technical expert when making modifications to OJS.
Here are the steps involved for installing Open Journal Systems (OJS) on a local server using XAMPP:
Install XAMPP: To install OJS, you need to have a web server installed on your local computer. XAMPP is a free and open-source web server that you can use for this purpose.
Download OJS: Visit the Open Journal Systems website to download the latest version of OJS. Save the downloaded file to your local computer.
Extract the OJS files: Extract the OJS files from the downloaded archive to a directory of your choice.
Copy the OJS files to the XAMPP htdocs folder: Copy the extracted OJS files to the htdocs folder inside the XAMPP installation directory.
Start XAMPP: Launch the XAMPP control panel and start the Apache and MySQL modules.
Create a database: Use the XAMPP phpMyAdmin tool to create a database for OJS.
Configure OJS: Open a web browser and navigate to the OJS installation page by entering the URL http://localhost/[path to OJS directory]/index.php/install. Follow the on-screen instructions to configure OJS, including entering information about your database, administrator account, and journal settings.
Complete the installation: Once you have completed the configuration process, follow the on-screen instructions to complete the installation of OJS.
Log in to OJS: Once the installation is complete, you can log in to the OJS backend by navigating to the URL http://localhost/[path to OJS directory]/index.php/index/login and entering your administrator username and password.
With these steps, you can install OJS on a local server using XAMPP and use it to manage and publish academic journals. Keep in mind that you may need to make additional modifications to your server configuration depending on your specific needs and requirements.
My experience didn’t really last long, as modifying functionalities and style of this website without a decent guide was nearly impossible. I did also look into PKP, but it was essentially the same story as OJS.
WordPress is a free and open-source content management system (CMS) used to create and manage websites. It was first released in 2003 and has since become one of the most popular website building platforms in the world, with millions of websites using it for a wide range of purposes, including blogs, portfolios, online stores, and more.
WordPress is known for its user-friendly interface, extensive customization options, and large community of users and developers. It provides users with a range of tools and features for creating and managing content, including a built-in editor, themes, and plugins, which can be used to extend the functionality of the platform.
WordPress is designed to be highly customizable and can be used to create websites of all types, including complex and feature-rich websites, as well as simple and straightforward sites. Additionally, it is built on open-source technology, making it freely available for anyone to use and modify.
A peer-reviewed journal can be developed with WordPress. However, this may require additional plugins and customization to fully support the peer-review process and publication of articles.
There are several plugins available for WordPress that can be used to support the peer-review process, including plugins for submission management, review management, and publication management. Some of these plugins are free, while others require a fee or subscription.
In addition to plugins, you may also need to make modifications to the WordPress theme and custom code to support the specific needs and requirements of your peer-reviewed journal.
Keep in mind that hosting a peer-reviewed journal on WordPress may also require additional resources, including hosting and support, as well as expertise in using WordPress and related plugins. It may also require more time and effort to set up and manage than using a dedicated platform like Open Journal Systems.
Overall, while it is possible to host a peer-reviewed journal on WordPress, it may not be the best option for everyone, and you may need to consider the costs, resources, and expertise required to make it work effectively.
Since I already had a web hosting account with BlueHost with several WordPress websites already running in it. This step was relatively straightforward.
Here are the steps involved for installing WordPress from scratch on BlueHost:
http://[your domain name]/wp-admin and entering your username and password.You might also consider developing your WordPress site on a local machine. WordPress on its own is extremely slow. Editing on a remote live sever is even slower. There are several advantages to developing a WordPress site on a local machine, including:
If you already have a live WordPress website and you want to deploy it on a local XAMPP server, you can do the following:
http://localhost/phpmyadmin/ to access the PHPMyAdmin interface. Create a new database for your WordPress installation.C:\xampp\htdocs\new_folder)http://localhost/[your folder name]/installer.php to run the Duplicator installer.http://localhost/[your folder name] to access your local WordPress site. Verify that everything is working as expected.By following these steps, you can deploy an existing WordPress site on a local XAMPP server using the “Duplicator” plugin. This allows you to test and develop your site locally, before deploying it to a live server.
You can also check out this step-by-step guide.
Custom fields in WordPress are metadata fields that allow you to add extra information to your posts, pages, and custom post types. These fields can be used to store and display additional information such as date, location, and author information.
The Toolset plugin is useful because it makes it easy to create custom fields and custom post types in WordPress, without the need for any coding. With Toolset, you can create custom fields with a visual interface, which makes it easy to add and manage custom data on your WordPress site.
The Toolset plugin also offers a range of other features that are useful for customizing and extending your WordPress site, such as custom taxonomies, custom templates, and custom database tables. Additionally, Toolset integrates with other plugins and themes, making it easy to extend the functionality of your site without the need for complex coding.
Overall, the Toolset plugin is a powerful tool for customizing and extending your WordPress site, making it easier to add and manage custom fields, custom post types, and other custom data.
Cost: about £56/year (2023)
Elementor is a popular WordPress plugin that provides a visual page builder for creating custom pages and templates on your WordPress site. It allows you to design custom pages and posts using a drag-and-drop interface, without needing to write any code.
With Elementor, you can add various types of elements to your pages, including text, images, buttons, videos, and more. The plugin provides a range of pre-designed templates and blocks, which you can customize to fit your needs. You can also create custom headers, footers, and templates, which can be used across your entire site.
Elementor is designed to be user-friendly and accessible to users of all skill levels. It provides a live editing experience, so you can see your changes in real-time as you make them. The plugin is also fully responsive, so your pages will look great on all devices, including desktop, tablet, and mobile.
Overall, Elementor is a powerful tool for creating custom pages and templates on your WordPress site, without needing to write any code. It is a popular choice for web designers, website owners, and content creators who want to create professional-looking pages and templates quickly and easily.
Cost: about £80/year (2023)
Writing a custom plugin for WordPress involves several steps:
wp-content/plugins directory of your WordPress installation and name it after your plugin.plugin-name.php and add a header at the top of the file with plugin information, including the plugin name, author, version, and description.A shortcode in WordPress is a small piece of code that can be added to a post, page, or widget to execute a specific function or display dynamic content. To add a plugin to your page using a shortcode, you need to follow these steps:
Here is a sample plugin header:
<?php
/*
Plugin Name: My Custom Plugin
Plugin URI: http://www.mywebsite.com/my-custom-plugin
Description: This is a custom plugin that does XYZ.
Author: John Doe
Version: 1.0
Author URI: http://www.mywebsite.com
*/A shortcode in WordPress is a small piece of code that can be added to a post, page, or widget to execute a specific function or display dynamic content. To add a plugin to your page using a shortcode, you need to follow these steps:
You can take a look at this guide.
I designed a MATLAB application that take care of salient aspects of the typesetting process, one a manuscript is accepted for publication. With Scientific Video Protocols we publish both standard articles (HTML + pdf) and video articles (YouTube). This the application interface:
I’ve built this using MATLAB Guide. MATLAB’s “guide” is a GUI development environment that was included in earlier versions of MATLAB. It allowed users to create graphical user interfaces (GUIs) for their MATLAB applications using a simple drag-and-drop interface. Recently, MATLAB has replaced guide with a newer and more powerful GUI development environment called App Designer. App Designer provides a modern, streamlined interface for designing and coding MATLAB apps and provides more control over the look and behaviour of the app compared to guide. Additionally, App Designer uses object-oriented programming concepts and integrates with other MATLAB tools and features, making it easier to create more complex and sophisticated apps.
Moreover guide has been officially deprecated in recent versions of MATLAB and will no longer be supported in future releases. MathWorks, the company behind MATLAB, has encouraged users to transition to the newer App Designer for their GUI development needs. With its improved functionality and integration with other MATLAB tools, App Designer provides a more robust and efficient platform for creating MATLAB apps compared to guide.
The first step is to assign a suffix for the DOI. We assign DOIs with CrossRef and this is an example of URL: https://doi.org/10.32386/scivpro.000006.
Pressing Make Directories (Call back: MAKE_DIRECTORIES.m) creates a series of directories used throughout the editorial process.
%% Submission Directories
handles.data.dataDir.root = [handles.data.workDir handles.data.doi_suffix '\']; mkdir(handles.data.dataDir.root);
handles.data.dataDir.submission.root = [handles.data.dataDir.root 'submission\']; mkdir(handles.data.dataDir.submission.root);
handles.data.dataDir.submission.guidelines = [handles.data.dataDir.submission.root 'guidelines\']; mkdir(handles.data.dataDir.submission.guidelines);
handles.data.dataDir.submission.manuscript = [handles.data.dataDir.submission.root 'manuscript\']; mkdir(handles.data.dataDir.submission.manuscript );
handles.data.dataDir.submission.figures = [handles.data.dataDir.submission.root 'figures\']; mkdir(handles.data.dataDir.submission.figures);
handles.data.dataDir.submission.supporting = [handles.data.dataDir.submission.root 'supporting\']; mkdir(handles.data.dataDir.submission.supporting);
handles.data.dataDir.submission.agreement = [handles.data.dataDir.submission.root 'agreement\']; mkdir(handles.data.dataDir.submission.agreement);
% Transfer data to submission directories
handles.data.assetsDir = [handles.data.workDir 'assets\'];
copyfile([handles.data.assetsDir 'SciVPro_template_with_instructions.dotm'], [handles.data.dataDir.submission.guidelines 'SciVPro_template_with_instructions.dotm'], 'f');
copyfile([handles.data.assetsDir 'SciVPro_Ref.ens'], [handles.data.dataDir.submission.guidelines 'SciVPro_Ref.ens'], 'f');
%% Review Directories
handles.data.dataDir.review.root = [handles.data.dataDir.root 'review\']; mkdir(handles.data.dataDir.review.root);
handles.data.dataDir.review.reviewer1 = [handles.data.dataDir.review.root 'reviewer1\']; mkdir(handles.data.dataDir.review.reviewer1);
handles.data.dataDir.review.reviewer2 = [handles.data.dataDir.review.root 'reviewer2\']; mkdir(handles.data.dataDir.review.reviewer2);
%% Production Directories
handles.data.dataDir.production.root = [handles.data.dataDir.root 'production\']; mkdir(handles.data.dataDir.production.root);
handles.data.dataDir.production.paragraphs = [handles.data.dataDir.root 'paragraphs\']; mkdir(handles.data.dataDir.production.paragraphs);
handles.data.dataDir.production.submision.root = [handles.data.dataDir.production.root 'submission\']; mkdir(handles.data.dataDir.production.submision.root);
handles.data.dataDir.production.submision.manuscript = [handles.data.dataDir.production.submision.root 'manuscript\']; mkdir(handles.data.dataDir.production.submision.manuscript);
handles.data.dataDir.production.submision.figures = [handles.data.dataDir.production.submision.root 'figures\']; mkdir(handles.data.dataDir.production.submision.figures);
handles.data.dataDir.production.submision.supporting = [handles.data.dataDir.production.submision.root 'supporting\']; mkdir(handles.data.dataDir.production.submision.supporting);
handles.data.dataDir.production.submision.agreement = [handles.data.dataDir.production.submision.root 'agreement\']; mkdir(handles.data.dataDir.production.submision.agreement);
handles.data.dataDir.production.temp.root = [handles.data.dataDir.production.root 'temp\']; mkdir(handles.data.dataDir.production.temp.root);
handles.data.dataDir.production.temp.paragraphs = [handles.data.dataDir.production.temp.root 'paragraphs\']; mkdir(handles.data.dataDir.production.temp.paragraphs);
handles.data.dataDir.production.temp.captions = [handles.data.dataDir.production.temp.root 'captions\']; mkdir(handles.data.dataDir.production.temp.captions);
handles.data.dataDir.production.figures.root = [handles.data.dataDir.production.root 'figures\']; mkdir(handles.data.dataDir.production.figures.root);
handles.data.dataDir.production.figures.captions = [handles.data.dataDir.production.figures.root 'captions\']; mkdir(handles.data.dataDir.production.figures.captions);
handles.data.dataDir.production.figures.images = [handles.data.dataDir.production.figures.root 'images\']; mkdir(handles.data.dataDir.production.figures.images);
handles.data.dataDir.production.files = [handles.data.dataDir.production.root 'files\']; mkdir(handles.data.dataDir.production.files);
guidata(hObject, handles);I normally reduce the figures down to 150KB. The standard size for both manuscript and website figures is 939 x 495 pixels. For the thumbnails I use 150 x 150 pixels. This is not the best image size management. Deploying SRCSET is a better solution.
The first step is to build an article object by pressing Make article obj:
This is the corresponding button callback:
function pushbutton74_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton74 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.data.article = ClassArticle;
guidata(hObject, handles);This is ClassArticle:
% ClassArticle(name, image, datePublished, pageStart, doi, description, ...
% copyrightHolder, license, authors, publisher)
% On the class handle: it allows avoiding duplicates. In fact we separately
% create objects ClassArticle and ClassAffiliation. Then we assign a field
% of the Article object to a bunch of Affiliations. However if we modify
% the single Affiliations, changes won't be reflected on the Article unless
% the ClassArticle is a subclass of handle
classdef ClassArticle < handle
properties (Constant)
a_type = 'ScholarlyArticle'; % cannot be modified
end
properties
name
image
datePublished
pageStart
description
copyrightHolder
license
publisher = ClassPublisher;
author = ClassAuthor;
sameAs
url
keywords
isPartOf = ClassIssue;
citation
end
properties (Dependent)
headline
dateCreated
copyrightYear
end
methods
function obj = set.name(obj, Value)
if ischar(Value)
obj.name = Value;
else
error('Name must be a string');
end
end
%% Image
function obj = set.image(obj, Value)
%if checkIfImageExists( Value)
obj.image = Value;
%else
% error('Image is not a valid URL directing to an image');
%end
end
%% datePublished
function obj = set.datePublished(obj, Value)
obj.datePublished = Value;
end
%% dateCreated
function dateCreated = get.dateCreated(obj)
dateCreated = obj.datePublished;
end
%% pageStart
function obj = set.pageStart(obj, Value)
obj.pageStart = Value;
end
%% description
function obj = set.description(obj, Value)
if ischar(Value)
obj.description = Value;
else
error('Description must be a string');
end
end
%% copyrightHolder
function obj = set.copyrightHolder(obj, Value)
if ischar(Value)
obj.copyrightHolder = Value;
else
error('copyrightHolder must be a string');
end
end
%% copyrightYear
function copyrightYear = get.copyrightYear(obj)
if ~isempty(obj.datePublished)
copyrightYear = num2str(year(datetime(obj.datePublished,'InputFormat','dd-MM-yyyy')));
else
copyrightYear = '';
end
end
%% Authors
function obj = set.author(obj, Value)
if iscell(Value)
for i = 1 : numel(Value)
if isa(Value{1}, 'ClassAuthor')
obj.author{i} = Value{i};
else
error([num2str(i), '-th element not a ClassAuthor']);
end
end
else
if isa(Value, 'ClassAuthor')
obj.author = Value;
else
error('Not a ClassAuthor');
end
end
end
%% license
function obj = set.license(obj, Value)
obj.license = Value;
end
% publisher
function obj = set.publisher(obj, Value)
if isa(Value, 'ClassPublisher')
obj.publisher = Value;
else
error('Is not a valida Publisher Class');
end
end
%% Headline
function headline = get.headline(obj)
headline = obj.name;
end
% isPartOf
function obj = set.isPartOf(obj, Value)
if isa(Value, 'ClassIssue')
obj.isPartOf = Value;
else
error('Is not a valida Publisher Class');
end
end
% Keywords
function obj = set.keywords(obj, Value)
if true
obj.keywords = Value;
else
error('sdf');
end
end
% SameAs
function obj = set.sameAs(obj, Value)
obj.sameAs =Value;
end
function doi = getDOI(obj)
if ~isempty(obj.sameAs)
doi = erase(obj.sameAs,'https://doi.org/');
else
doi = [];
end
end
% url
function url = get.url(obj)
url = obj.sameAs;
end
% citation
function obj = set.citation(obj, Value)
if true
obj.citation = Value;
else
error('Is not a valida Publisher Class');
end
end
end
endThere are a series of subclasses within the class article: ClassPublisher, ClassAuthor, ClassIssue. This is were we store all the information related to this specific article. On the right-hand side of the GUI there a class explorer that allows you to visualize the object content. We can find its related code under the callback for the dropdown menu under Display Object Tree, which calls SHOW_STRUCT_TREE. This script makes a series of recursive calls to explore the full object tree. As you populate the fields in the app, values will be reflected in the object tree, this includes things like authors names, affiliations, etc.
root = uitreenode('v0','root','root',[],false);
mtree = uitree('v0','Root',root,'Parent');
set(mtree, 'Position', [730 250 480 610]);
switch handles.popupmenu12.Value
case 1
case 2 % article
article_ = struct();
article_ = recursiveStructConvert(handles.data.article,article_)
root_.article_ = article_;
case 3 % author
author_ = struct();
author_ = recursiveStructConvert(handles.data.author,author_)
root_.author_ = author_;
case 4
affiliation_ = struct();
affiliation_ = recursiveStructConvert(handles.data.affiliation,affiliation_)
root_.affiliation_ = affiliation_;
case 5
publisher_ = struct();
publisher_ = recursiveStructConvert(handles.data.publisher,publisher_)
root_.publisher_ = publisher_;
case 6
citations = struct();
for i = 1 : numel(handles.data.article.citation)
citations(i).citation_ = struct();
citations(i).citation_ = recursiveStructConvert(handles.data.article.citation{i},citations(i).citation_);
end
root_.citation_ = citations;
end
structTraverse(root_,root)
mtree.reloadNode(root)
expandChild(mtree, root, str2num(handles.edit93.String));
guidata(hObject, handles);The first two functions uitreenode and uitree simply take care of building the object three and displaying it. This is the recursive function:
function s = recursiveStructConvert(obj, s)
for i = 1:numel(obj)
properties_list = properties(obj(i));
for j = 1 : numel(properties_list)
if isobject(obj(i).(properties_list{j}))
s(i).(properties_list{j}) = '';
s(i).(properties_list{j}) = recursiveStructConvert(obj(i).(properties_list{j}),s(i).(properties_list{j}));
else
s(i).(properties_list{j}) = obj(i).(properties_list{j});
if isempty(obj(i).(properties_list{j}))
s(i).(properties_list{j}) = 'null';
end
end
end
endThe next step is to enter the number of figures, and click on Make Article Sec. Files. This will create txt files corresponding to each section of the manuscript. Manuscript sections are: abstract, introduction, protocol, results, etc.
We typically receive manuscripts in Microsoft Word. Authors are given Word template they can work with. This is handy because, if there’s any formatting and references we can convert the Word document directly into HTML using an HTML converter. Here are some of the steps we follow to ensure the conversion is correct:
SciVPro_Ref_HTML)Clicking on Open HTML converter will open Word to HTML. The HTML code must be copied and pasted into the MATLAB app using the MATLAB file editor. To do that select the right section from the dropdown next to input folder (for example 01_abstract.txt) and click on Open with Mat Editor. The reason why we are entering the HTML code from the editor is because entering it from an hypothetical text box would introduce, for unknown reasons, weird characters. After pasting the HTML into 01_abstract.txt and saving, you can visualise in the application:
You’ll have to repeat this step for all article sections. You’ll notice there are two *.txt files named references. In the first one 08_references.txt we enter the bit generated by EndNote at the end of the article after converting it into HTML, which should look like:
<p>[1] M. Dressel, N. Drichko, B. Gorshunov & A. Pimenov. THz spectroscopy of superconductors. <em>IEEE Journal on Selected Topics in Quantum Electronics</em> <strong>14</strong>, 399-406, (2008).</p>
<p>[2] R. A. Kaindl, M. A. Carnahan, J. Orenstein, D. S. Chemla, H. M. Christen, H.-Y. Zhai, M. Paranthaman & D. H. Lowndes. Far-Infrared Optical Conductivity Gap in Superconducting MgB2 Films. <em>Physical Review Letters</em> <strong>88</strong>, (2002).</p>
<p>[3] M. Beck, M. Klammer, S. Lang, P. Leiderer, V. V. Kabanov, G. N. Gol'Tsman & J. Demsar. Energy-gap dynamics of superconducting NbN thin films studied by time-resolved terahertz spectroscopy. <em>Physical Review Letters</em> <strong>107</strong>, (2011).</p>The second file is 09_references_DOI.txt and there you should paste the list of DOIs from the references, in the exact same order:
10.1109/JSTQE.2007.910764
10.1103/physrevlett.88.027003
10.1103/PhysRevLett.107.177007The way we get this list is by switching to the SciVPro_DOI style. This will show the list of references at the end of the Word document as a list of DOIs. If the reference DOI does not exist we can enter an ISBN (if it’s a book) or a URL (for anything else). Obviously you need to make sure each reference in EndNote has an associated DOI (or a ISBN or a URL).
Manuscript metadata in peer-reviewed articles refers to the descriptive information about the paper and its authors that is included in the article, typically in the header or footer of the manuscript. This information can include the title of the paper, the names and affiliations of the authors, the date the paper was submitted or accepted, the name and volume number of the journal in which the paper was published, and other information that is relevant to the paper or the publishing process. The purpose of manuscript metadata is to provide context and background information about the paper, to help readers understand the context in which the research was conducted and to provide a reference for future researchers.
RESTful APIs available with CrossRef (free) or Scopus (paid) allow developers to access such a metadata by providing a DOI as an input. When registering a DOI with CrossRef we enter this data in their system. In essence the manuscript metadata represents key bibliographic information.
From this panel we enter Author and Affiliation information. This is the boring part. Author and Affiliation objects can be saved and imported.
You create a new Author by pressing New. Tick the checkbox if the author is a corresponding author. The email of the corresponding author is assigned by linking a certain author to a certain affiliation where the email is provided (this is discussed below). Enter Name and Surname, then attempt a Search. This will open the ORCID website and does a search based on the Name and Surname you’ve just entered. This is the script SEARCH_ORCID that is called when pressing the button:
name = handles.edit4.String;
surname = handles.edit6.String;
[stat,handles.webh] = web(['https://orcid.org/orcid-search/quick-search?searchQuery=' name '+' surname])
guidata(hObject, handles);The query is relatively simple and it is done at the URL level.
When we press Grab ORCID the list of ORCIDs will be transferred to the dropdown menu next to ORCID attempt. This is done with GRAB_ORCIDS:
data = get(handles.webh, 'HtmlText');
close(handles.webh);
newStr = extractBetween(data,'<td class="search-result-orcid-id">','<!---->');
for i = 1: length(newStr)
s = extractBetween(newStr{i}, '','</td><td>');
s{1} = erase(s{1},'https://');
b = extractBetween(s{1}, '<a href="','">');
popupText{i} = [b{1} ', ' s{2} ', ' s{3}];
handles.data.tempORCIDlist{i} = b{1};
end
handles.popupmenu3.String = popupText;
guidata(hObject, handles);The code involves scraping some bits of HTML from the ORCID page to extract ORCID and corresponding name. Typically when a query is performed ORCID returns a list of names. It will be up to you to select the correct ORCID. Once you’ve identified the correct ORCID just select it from the dropdown menu and press Assign. This will trigger ASSIGN_ORCID:
handles.edit3.String = handles.data.tempORCIDlist{handles.popupmenu3.Value};
author_index = handles.popupmenu2.Value;
handles.data.author(author_index).sameAs = handles.edit3.String;
handles.data.author(author_index)
guidata(hObject, handles);As you can see we are populating a structure called data with fields like author and so on. You can add a new author by pressing again New. Authors can be deleted by pressing Delete. Authors order can be arranged with the Up and Down buttons.
Affiliation can be added in a similar fashion. Enter the institute name and attempt an institute search from the GRID website (GRID is a unique affiliation identifier). You can perform a search on the GRID database by clicking on Search. Select the appropriate GRID and perform a Check. If the GRID is correct press Assign. Note that fields will be automatically filled. You can also manually add the affiliation details (in case GRID is not available or in case GRID details are wrong). Add the email of the corresponding author here.
We assign affiliations to authors with this panel. You must select the appropriate author and affiliation from the respective popup menus and then click Assign. The order of the affiliation can be changed by pressing Up and Down. The link can be removed by pressing Delete. Make sure everything has been correctly assigned.
This is accessed by clicking on the Article Info tab:
Journal information data is entered here (self-explanatory). The copyright holder is always first_author_surname et al..
For the table of content (TOC) image we use a square image size of 200 x 200 pixels. The TOC must be saved in https://scivpro.com/wp-content/uploads/2019/02/000008_TOC.jpg (the year, month, and DOI suffix will change obviously).
Once you are done, you must press SAVE. This will call the following scripts:
GENERATE_PUBLISHER
GENERATE_JOURNAL_VOL_ISSUE
GENERATE_ARTICLE_INFOFor example GENERATE_PUBLISHER:
addressPublisher = ClassAddress;
addressPublisher.addressLocality = handles.edit34.String;
addressPublisher.addressRegion = handles.edit35.String;
addressPublisher.addressCountry = handles.edit36.String;
addressPublisher.postOfficeBoxNumber = handles.edit33.String;
addressPublisher.postalCode = handles.edit32.String;
addressPublisher.streetAddress = handles.edit37.String;
addressPublisher.email = handles.edit38.String;
handles.data.article.publisher = ClassPublisher;
handles.data.article.publisher.name =handles.edit30.String;
handles.data.article.publisher.url = handles.edit31.String;
handles.data.article.publisher.address = addressPublisher;
guidata(hObject, handles);References are managed via this panel:
The way this works is that the DOI (or ISBN or URL) list provided by pasting the list of DOIs in the file 09_references_DOI.txt is used to extract metadata relative to each DOIs. For DOIs we check the CrossRef database. If information is wrong, missing, or incorrect you can make appropriate modifications. Press Generate Ref Obj to retrieve references information from CrossRef. The reason why we do this is because we want to extract the metadata from each reference in a machine readable manner. This will be used on a later stage to build a JSON-LD file. I’ve noticed most publishers don’t bother including a JSON-LD file, however Nature does and this helps search engines; it is in fact suggested by Google.
filename = ([handles.data.dataDir.production.temp.paragraphs handles.popupmenu1.String{9}]); % open(filename)
DOIarray = importDOIfromTxt(filename);
% Examples of ISBN:
% '9783319966663' (3 authors)
% '9781860943492' (1 author)
for i = 1 : numel(DOIarray)
i
handles.data.article.citation{i} = check_doi(DOIarray{i});
end
% Citation can be the following Objects:
% DOI, BOOK, website, for arxiv just provide website info as it is not an
% article.
for i = 1 : numel(DOIarray)
switch handles.data.article.citation{i}.a_type
case 'ScholarlyArticle'
handles.popupmenu15.String{i} = [num2str(i) '. ' getDOI(handles.data.article.citation{i})];
case 'WebSite'
handles.popupmenu15.String{i} = [num2str(i) '. ' handles.data.article.citation{i}.url];
end
end
DISPLAY_CITATION
guidata(hObject, handles);
Here we first import the DOI string from the text file with importDOIfromTxt:
% Copy references into a txt file
function DOIarray = importDOIfromTxt(filename)
fid = fopen(filename);
counter = 1;
while ~feof(fid)
newLine = fgets(fid);
DOIarray{counter} = strtrim(newLine);
counter = counter + 1 ;
end
fclose(fid);Then we do the API call to CrossRef with check_doi.m:
function obj = check_doi(doi) % returns object and struct
options = weboptions;
options.Timeout = 15;
type =[];
request = ['http://api.crossref.org/works/' doi '/agency'];
try
data = webread(request, options);
doiAgency = data.message.agency.label;
catch ME
doiAgency = 'Not a DOI URL';
end
switch doiAgency
case 'DataCite'
request = ['https://api.datacite.org/works/' doi ];
data = webread(request, options);
data.data.attributes;
type = 'DOI';
case 'Crossref'
request = ['http://api.crossref.org/works/' doi ];
data = webread(request, options);
obj = ClassArticle;
obj.name = strrep(data.message.title{1},sprintf('\n'),'');
obj.datePublished = [num2str(day(datetime(data.message.created.date_parts))),'-'...
num2str(month(datetime(data.message.created.date_parts))),'-'...
num2str(year(datetime(data.message.created.date_parts)))];
obj.sameAs = ['https://doi.org/' doi];
try
temp = strsplit(data.message.page, '-');
obj.pageStart = temp{1};
catch
end
% Assign publisher
obj.publisher = ClassPublisher;
try
obj.publisher.name = data.message.publisher;
catch
end
% Assign journal
journal= ClassJournal;
try
journal.name = data.message.container_title{1};
catch
end
% Assign volume
volume = ClassVolume;
volume.isPartOf = journal;
try
volume.volumeNumber = data.message.volume;
catch
end
% Assign issue
issue = ClassIssue;
issue.isPartOf = volume;
try
issue.issueNumber = data.message.issue;
catch
end
obj.isPartOf = issue;
% Authors
nAuthors = numel(data.message.author);
if nAuthors > 30
nAuthors = 30;
end
for i = 1 : nAuthors
author(i) = ClassAuthor;
if iscell(data.message.author)
temp_auth = data.message.author{i};
else
temp_auth = data.message.author(i);
end
try
author(i).givenName = temp_auth.given;
catch
author(i).givenName = ' ';
end
try
author(i).sameAs = temp_auth.ORCID ;
catch
end
try
author(i).familyName = temp_auth.family;
author(i).familyName = ' ';
catch
end
try
author(i).additionalName = temp_auth.middle;
catch
end
end
obj.author = author;
type = 'DOI';
case 'Not a DOI URL'
% Check if it is a website
%[data, status] = isawebsite(doi);
%if ~isempty(data)
obj = ClassWebsite(doi);
obj_s = convertAndCleanObj(obj);
type = 'WEB';
%end
% Check if is a book, ISBN 812651681X (sze)
doi = strrep(doi,'-','');
if strlength(doi)==10 || strlength(doi)==13 % length of an ISBN
data = webread(['https://www.googleapis.com/books/v1/volumes?q=isbn:' doi], options);
if data.totalItems > 0 % is a book
obj = ClassBook;
obj.bookFormat = 'Hardcover';
try obj.datePublished = datetime(data.items.volumeInfo.publishedDate); catch end
obj.name = data.items.volumeInfo.title;
obj.inLanguage = data.items.volumeInfo.language;
obj.isbn = doi;
obj.numberOfPages = data.items.volumeInfo.pageCount;
obj.sameAs = data.items.volumeInfo.canonicalVolumeLink; % dependant
publisher = ClassPublisher;
try
publisher.name = data.items.volumeInfo.publisher;
catch
end
obj.publisher = publisher;
authors = data.items.volumeInfo.authors;
for i = 1 : length(authors)
nameSplit = strsplit(authors{i}, ' ');
if length(nameSplit) == 1
nameSplit = strsplit(authors{i}, '.');
end
author(i) = ClassAuthor;
if length(nameSplit) == 2
author(i).givenName = nameSplit{1};
author(i).familyName = nameSplit{2};
end
if length(nameSplit) > 2
author(i).givenName = nameSplit{1};
author(i).additionalName =nameSplit{2};
author(i).familyName = nameSplit{3};
end
end
obj.author = author;
type = 'BOOK';
end
end
endThis function builds an Article object just like our main Article object for each reference, and assigns it to handles.data.article.citation{i}.
We can view all metadata we’ve just entered with the object tree viewer:
After you have exported the figure files in the right format, move them to the local folder (where all other folders have been created) 000006\production\submission\figures (6 stands for manuscript number 6). Figure captions text files are automatically generated in one of the previous steps and are located in: 000005\production\temp. An example of caption would be <p>Figure 1 | Prof. X, Y University.</p>. These files are obviously empty, so you’ll need to write appropriate captions by dragging each of them into the MATLAB editor. Keep Figure X at the beginning of the caption.
Once all the txt files are ready press HTML (author), and press refresh… this will generate appropriate html files, which can be viewed from the popup next to HTML folder. The callback is:
GENERATE_AUTHORS_AFFILIATION_HTML
GENERATE_SECTIONS_HTML
GENERATE_REFERENCES_HTML
GENERATE_FIGURES_HTML
GENERATE_ARTICLE_LINE_HTML
GENERATE_AUTHOR_INFO_HTML
GENERATE_ARTICLE_INFO_HTML
GENERATE_YOUTUBE_HTMLThese new HTML files include extra elements that add extra functionalities to the article page. This includes things like internal links for references; for example when you click on a reference like [1] a tab on the right side scrolls down and shows you the corresponding reference.
The script GENERATE_AUTHORS_AFFILIATION_HTML is the following:
% Here we generate the Authors list with tooltips
author = handles.data.author;
affiliationLine = ['<a class="btn btn-primary" data-toggle="collapse" href="#collapseExample"'...
'role="button" aria-expanded="false" aria-controls="collapseExample">'...
'Show Affiliations</a>'];
affiliationLine = [affiliationLine '<div class="collapse" id="collapseExample">'...
'<div class="card card-body">'];
affiliationLine = [affiliationLine '<p><sup>*</sup> Corresponding authors</p>'];
nameList = ['<p>'];
aff_accumulator = []; aff_index = 0; letter = [];
for i = 1 : numel(author) % for each author
if ~(i == numel(author))
nameList = [nameList author(i).name ','];
else
nameList = [nameList author(i).name];
end
if isequal(author(i).roleName, 'Corresponding')
nameList = [nameList '<sup>' '*' '</sup>'];
end
for j = 1: numel(author(i).affiliation) % for each affiliation
% check if affiliation is part of accumulator
v = find(author(i).affiliation(j)== aff_accumulator);
if isempty(v)
aff_accumulator = [aff_accumulator author(i).affiliation(j)];
aff_index = aff_index + 1;
letter(aff_index) = char(aff_index+'a'-1);
nameList = [nameList '<sup>' letter(aff_index) '</sup>'];
else
nameList = [nameList '<sup>' letter(v) '</sup> '];
end
if numel(author(i).affiliation)>1 && j< numel(author(i).affiliation)
nameList = [nameList '<sup>,</sup>'];
end
if j == numel(author(i).affiliation)
nameList = [nameList ' '];
end
end
end
nameList = [nameList '</p>'];
for aff_index = 1 : numel(aff_accumulator)
affiliationLine = [affiliationLine '<p>'];
affiliationLine = [affiliationLine '<sup>' letter(aff_index) '</sup> '];
affiliationLine = buildAffiliationLine(affiliationLine, aff_accumulator, aff_index);
if ~isempty(aff_accumulator(aff_index).address.email)
affiliationLine = [affiliationLine '<br>' '<b>E-mail: </b>' aff_accumulator(aff_index).address.email];
end
affiliationLine = [affiliationLine '</p>'];
end
affiliationLine = [affiliationLine '</div></div>'];
fileID = fopen([handles.data.dataDir.production.paragraphs '11_author_line.txt'] ,'w');
fprintf(fileID, '%s', nameList);
fclose(fileID);
fileID = fopen([handles.data.dataDir.production.paragraphs '12_affiliation_line.txt'] ,'w');
fprintf(fileID, '%s', affiliationLine);
fclose(fileID);<a class="btn btn-primary" data-toggle="collapse" href="#collapseExample" role="button" aria-expanded="false"
aria-controls="collapseExample">Show Affiliations</a>
<div class="collapse" id="collapseExample">
<div class="card card-body">
<p><sup>*</sup> Corresponding authors</p>
<p><sup>a</sup> Cavendish Laboratory, University of Cambridge, CB3 0HE, Cambridge, United Kingdom<br><b>E-mail:
</b>fnk23@cam.ac.uk</p>
<p><sup>b</sup> Department of Engineering, University of Cambridge, CB3 0FA, Cambridge, United Kingdom</p>
<p><sup>c</sup> Department of Materials Science and Metallurgy, University of Cambridge, CB3 0FS, Cambridge,
United Kingdom</p>
</div>
</div>The newly generated files with the new HTML code will be pasted into specific fields created with Toolbox in WordPress. The can be opened directly from the app, by selecting the appropriate file next to HTML folder in the Processing tab and clicking on Open with Mat Editor.
Files to upload to the server include: pdf of the article (see below), citation files (*.ris), and figure. These need to be uploaded to the appropriate folder using Filezilla (e.g. https://scivpro.com/articles/000004/).
Pdf files must be named as 10_32386_scivpro_000006.pdf for example.
The general organisation of the article structure is controlled by a Toolset template. Templates are found under Toolset -> Layouts. Select the tab Templates for single posts or pages.
This is the template used for manuscript 000006:
Clearly if you are not happy about this layout, you can duplicate and rename it. It will be available under Unassigned Layouts. Change the slug and modify its scope to Sections.
In each blow we have bits of Toolset scripts like:
<h1 class="manuscriptTitle">[types field='title_manuscript'][/types]</h1>This means that whatever we enter in the field title_manuscript will be inserted here. There are many other fields throughout the template: authors-list, authors-affiliation, 13_article_line, etc. As you can see some of these fields correspond to the HTML files discussed above.
Depending on the sections we have in the actual article, we will need to modify the Sections tab on the right end side. This is navigation element on the right hand side of the article that allows you to view all figures in the article, navigate each section of the article, and view all references. This is how it is coded in the layout:
<div class = "chapterList">
<hr class ="hr2">
<p><a href ="#abstract">Abstract</a></p>
<hr class ="hr2">
<p><a href ="#par1">Introduction</a></p>
<hr class ="hr2">
<p><a href ="#par2">Time-Domain THz Spectroscopy Setup</a></p>
<hr class ="hr2">
<p><a href ="#par3">Protocol</a></p>
<hr class ="hr2">
<p><a href ="#par4">Results</a></p>
<hr class ="hr2">
<p><a href ="#references">References</a></p>
<hr class ="hr2">
<p><a href ="#acknowledgements">Acknowledgements</a></p>
<hr class ="hr2">
<p><a href ="#author_info">Author Information</a></p>
<hr class ="hr2">
<p><a href ="#article_info">Article Information</a></p>
</div>In HTML, # symbol is used in hyperlinks to indicate that the link is pointing to a specific location within the same web page. For example, when used in <a href='#par'>, the #par part after the # symbol is the target location’s ID (an anchor) within the web page. When the user clicks on the hyperlink, the browser will scroll to the target location (the element with the specified ID) on the same page. This is useful for creating navigation menus that jump to specific sections of a long web page.
As a note there was absolutely no reason for editing the layout here. This could have been done at a field level.
When we will edit the various fields, we will need to substitute the <h2>Introduction</h2> headings with something like:
<p class = "anchorChapter" id = "par1">
<h2 class = "Chapter">Introduction</h2>This is the target for the internal link <a href ="#par1">Introduction</a>.
Articles in this WordPress site are custom post types created with Toolset and called Manuscripts. They can be created from Toolset -> Post Types. Once a new custom post is created it will appear on the left navigation menu of WordPress:
Custom fields are accessible from Toolset->Custom Fields. Here we have a Field group for Manuscript that looks like:
Each field can be different things, for example a single line, rich text, or even a file. These are the fields we will fill up with the HTML text files once we create an instance of an Article (Manuscript). The way these fields are arranged in the Article page is controlled by the template I discussed above.
The easiest thing to do is probably to duplicate an existing one. Go to Manuscripts -> all items -> duplicate. This is the Manuscripts section:
This is the page for the article we’ve been discussing above:
These are exactly the fields were we paste the HTML text files.
We absolutely need to ensure that the permalink is something like: https://scivpro.com/manuscript/10_32386_scivpro_000006/. Once you register a DOI with CrossRef this permalink should never change.
On the right side of the page we also need to assign the right template to the present article. Here we also control if the page is public or private.
If you scroll to the bottom you will see a section for JSON-LD. JSON-LD (JavaScript Object Notation for Linked Data) is important for publishers displaying peer-reviewed articles on their journal pages because it provides a standardized way to represent structured data in a format that is both machine-readable and human-readable. For publishers, using JSON-LD to mark up their web pages can enhance the visibility and findability of their articles. Search engines, such as Google, can use the structured data provided by JSON-LD to understand the context of the content on a page and display it in a more meaningful way in search results. Additionally, JSON-LD provides a way for publishers to include information about the peer-review process, authors, and publication details that may not be readily available in the main article content. This information can help increase the credibility and trustworthiness of the article in the eyes of potential readers and researchers.
The MATLAB application generates the JSON-LD file (json_ld.txt) for the manuscript based on the article object parameters we entered earlier after you press Generate JSON LD. This calls the following:
article_ = struct();
article_ = recursiveStructConvert(handles.data.article,article_);
main.a_context = "http://schema.org";
main.a_graph{1} = article_;
main.a_graph{2} = [] ;
text = jsonencode(main);
newStr = strrep(text,'a_','@');
fileID = fopen([handles.data.dataDir.production.paragraphs 'json_ld.txt'],'w'); % open([workDir 'json_ld.txt'])
fprintf(fileID, '%s', newStr);
fclose(fileID);This code recursively explores the object tree, converts each object into a struct, and finally converts the struct into a JSON file.
This is done by combining an Adobe InDesign template I’ve created with a Word template. The Word field containing the article is imported in InDesign, which then automatically translates each article section, for example headings or Normal text, into custom paragraphs with specific fonts, font sizes, etc. This is the InDesign Template:
And this is how it looks like after importing the Word file:
The entire website styling is made with Elementor (+ custom CSS).
MATLAB source files will be available on GitHub.
