# LLMs are Meaning-Typed Code Constructs

Jason Mars  University of Michigan
Jaseci Labs
<EMAIL_ADDRESS>Yiping Kang  University of Michigan
Jaseci Labs
<EMAIL_ADDRESS>Jayanaka Dantanarayana  University of Michigan
Jaseci Labs
<EMAIL_ADDRESS>Chandra Irugalbandara  Jaseci Labs
<EMAIL_ADDRESS>Kugesan Sivasothynathan  University Of
Moratuwa
Jaseci Labs
<EMAIL_ADDRESS>Lingjia Tang  University of Michigan
Jaseci Labs
<EMAIL_ADDRESS>
###### Abstract

Programming with Generative AI (GenAI) models is a type of Neurosymbolic
programming and has seen tremendous adoption across many domains. However,
leveraging GenAI models in code today can be complex, counter-intuitive and
often require specialized frameworks, leading to increased complexity. This is
because it is currently unclear as to the right abstractions through which we
should marry GenAI models with the nature of traditional programming code
constructs.

In this paper, we introduce a set of novel abstractions to help bridge the gap
between Neuro- and symbolic programming. We introduce $Meaning$, a new
specialized type that represents the underlying semantic value of traditional
types (e.g., string). We make the case that GenAI models, LLMs in particular,
should be reasoned as a $meaning$-type wrapped code construct at the language
level. We formulate the problem of translation between meaning and traditional
types and propose Automatic Meaning-Type Transformation (A-MTT), a runtime
feature that abstracts this translation away from the developers by
automatically converting between $Meaning$ and types at the interface of LLM
invocation. Leveraging this new set of code constructs and OTT, we demonstrate
example implementation of neurosymbolic programs that seamlessly utilizes LLMs
to solve problems in place of potentially complex traditional programming
logic.

###### Index Terms:

programming language, neurosymbolic, large language models

##  I Introduction

Generative AI models, in particular Large Language Models (LLM), have seen
tremendous adoption across many industries and are revolutionizing how
developers program. Enterprises and startups are gearing up to integrate LLMs
into their workflows. This raises the question “What will the future of
programming look like?”. Symbolic programming has been the main programming
paradigm, where symbolic code are used to express logic to complete a task or
solve a problem. On the other hand, with the fast adoption of LLMs, a new
programming paradigm, Neurosymbolic programming [1], has quickly gained
interests in academia and industry. In Neurosymbolic programs, Neural Networks
and traditional symbolic code are combined to create intelligent algorithm and
applications.

Figure 1: Comparison of LLM as Meaning Typed Code construct abstraction
(Right) with the present-day LLM abstraction (Middle) and Symbolic Programming
Abstraction (Left) of a programming function.

LLMs operates on text as input and generates text as output. Constructing the
input text, also known as prompt, is currently the main method of programming
with LLMs and is commonly referred to as prompt engineering. Programming with
LLMs today rely heavily on prompt engineering and this can introduce
significant complexity. Generating the right prompt from existing code
constructs and elements in your program can be complex, tedious and reduce
code readability and maintainability. There have been several efforts in open-
source and research community to assist with prompt engineering, such as
LangChain, Guidance, Language Model Programming Language (LMQL) [2] and SGLang
[3]. These libraries aim to facilitate the construction of prompt and help
with programming with LLMs. However, these approaches mostly still require the
developer to decide the type of prompt to use and what information should be
part of the prompt. In addition, there also exists non-trivial degree of
challenges in parsing the LLM outputs and converting it to operatable code
constructs. Overall, it remains unclear what is the right methodology for
programming with LLMs in neurosymbolic programming.

In this work, we postulate that the fundamental reason for the complexity of
programming with LLMs is the lack of abstraction for interfacing with LLMs. In
conventional symbolic programs, code are used to describe operations that are
conducted on variables or typed-values (Figure 1 left). LLMs do not directly
operate on variables. So variables are first converted to a prompt (a string),
then after the LLM inference, its output (also a string) are parsed are then
converted to variables (Figure 1 middle). This process represents how the
existing frameworks approach programming with LLMs. While this enables
integrating LLMs, additional logic and complexity are introduced with the
generation of the input prompt and parsing of the output response. We think
that this complexity exists because there exist a fundamental disagreement
between the abstractions on which the LLM operates and the existing
abstractions in conventional symbolic programming.

We introduce LLMs as new code constructs and provide syntax support for it at
the programming language level. We also introduce a new type called $meaning$
that serves as the abstractions with which LLM interact with. We define
$meaning$ as the semantic purpose underlying or intended by the symbolic data
(strings) that serve as the input and output of the LLMs. With $meaning$ in
hand, we define the process of translating between conventional code
constructs such as variables and functions and $meanings$ as the process of
Meaning-type Transformations (MTT). Figure 1 right visualizes this concept. We
propose that MTT should be automated by the language runtime and abstracted
away from the developers to reduce complexity. To that end, we introduce a
novel language feature called Semantic Strings (semstrings) that allow
developers to flexibly provide additional context and information to existing
conventional code constructs. We show, via real code examples, how an
Automatic Meaning-type Transformation (A-MTT) can be applied to streamline
leveraging LLMs for three of the most common symbolic code operations:
instantiating an object of a custom type, a standalone function call and
member method of a class. We make the following contributions:

  * •

We introduce a novel abstraction of treating LLMs as meaning-type wrapped code
constructs for seamless integration into conventional symbolic programming.

  * •

We introduce a new language-level feature $semstrings$ that allow developers
to annotate existing code constructs with additional context.

  * •

We propose a new runtime feature, Automatic Meaning-type Transformation, that
abstracts away many of the current complexity of programming with LLMs.

##  II Problem

There has been a surge in interest across the programming community in
adopting GenAI models to introduce new intelligent features to their programs.
Many libraries [3, 2], frameworks[4, 5] and new programming models and
languages have been introduced recently to help facilitate integrating GenAI
models, focusing particularly on LLMs. However, these approaches mainly
operate with a key principled concept that LLMs are essentially black-box
functions that take text as input (prompt) and generate text as output. As a
result, the resulting application implementation is often two disjoint
sections of a single program. On one side of the program is the conventional
symbolic code which is often large-scale pre-existing code of an application,
and on the other side, is the execution of the LLM. Connecting the two sides
is often complex and convoluted string manipulation logic that is required to
construct the input text to the LLM and parse the output text from the LLM.
This leads to significant complexity in the implementation and greatly impacts
the readability and maintainability of the program as a whole. While some
techniques [2, 5] try to alleviate this complexity with new abstractions and
language syntax, developers are often still required to heavily refactor their
existing code to gather all the necessary information to pass in and out of
this text-centric interface, which further exacerbates this issue.

We think that the complexity of programming with GenAI models is rooted in the
fundamental disagreement of abstractions between the traditional symbolic-
programming paradigm and neuro-programming paradigm with GenAI models. We
argue that, for LLMs, the textual interface is the manifestation of a more
fundamental abstraction with which LLMs operate. Properly defining this
abstraction is the key to effectively programming in a neurosymbolic way and
truly unlocking the potential of these powerful GenAI models. In the following
sections of this paper, we define such an abstraction, Meaning, and introduce
Meaning-type Transformation, a new language feature that serves as a seamless
interface between symbolic programs and neuro programs with LLMs that
optimizes the complexity away from the developers.

##  III LLMs are Meaning-typed Code Construct

We propose that LLMs should be reasoned as a new type of code construct and
treated as a first-degree citizen of the program language. We lay out this
concept and our reasoning for it in this section.

###  III-A Conventional Code Constructs

Figure 2: Code constructs in symbolic programs (value, type, variable) Figure
3: New code constructs in Neuro-symbolic programs (Meaning, LLM)

We first define existing code constructs that developers are familiar with in
conventional symbolic programming. Figure 2 shows these code constructs,
including type (T), typed-value (V-T) and variable (V-T with label).
Conventional symbolic programs perform operations that transform tuples of
typed-values to other tuples of typed-values with desired behaviors. We define
these operations as Operational Typed-value Transformations (OTT). Examples of
OTTs are functions and methods. The input and output of OTTs are tuples of
typed-values (Figure 1a).

###  III-B LLMs are Meaning-typed Code Constructs

Figure 4: Examples of meaning of traditional code constructs in symbolic
programs.

Since adoption, LLMs have been treated similarly to existing OTTs (e.g.,
functions) with strings (i.e., text) as their inputs and outputs. Recent
research focus on optimizing the process of constructing the input strings and
parsing the output strings of LLMs [2, 4]. We argue that LLMs differ from
conventional OTTs in three key aspects and should be considered as a new code
construct.

First, on a fundamental level, language models do not operate on text, but
instead operate on what the text means. Language models understand the intent
of input, conduct reasoning and generate an output that represents its
thoughts and conclusions. Second, the input and output to the LLMs can be
arbitrarily extended and modified without requiring updates to the LLM
interface. For conventional OTTs, their interface signature often need
updating to accommodate for change in the expected inputs or desired output.
Third, language models are inherently black boxes. The runtime behavior of the
language models are often implicitly encoded in its input and dynamically
constructed by the LMs after understanding of the meaning of the input during
execution. Reasoning methodologies such as Chain-of-thoughts[6] and ReACT[7]
are examples of this.

Considering these fundamental differences between LLMs and conventional OTTs
such as functions and methods, we argue that LLM is a brand new type of code
construct. We define that the LLM code construct is meaning-typed. In other
words, LLMs operate on meanings. We define meaning as the semantic purpose
underlying or intended by the symbolic data that serve as the input and output
of the language models. Figure 3 shows the annotations for these new concepts
which we will use throughout this paper.

Figure 4 illustrates three examples of meaning for a variable of a primitive
type, a function and a variable of a custom type. In the first (top) example,
the meaning of a primitive-typed variable is the description of an entity and
is derived from the type, value and label (name) of the variable. Note that
not only the variable names play a role in the meaning but also their types.
For a function, its meaning represents an action or operation and is derived
from the label of the function as well as the meaning of its input type and
output type. An combination of meanings of primitive-typed variables and
functions can then be used to realise the meaning of a variable of a custom
type (i.e., class) in the last example. Conceptualizing LLMs as a brand new
code construct that is wrapped with a new special meaning type creates a novel
framework under which we should design the right solution for reducing
complexity of programming with GenAI models.

##  IV Bridging the Gap between Conventional and Neuro-symbolic Programming

Now that we have defined LLM as a new code construct and its interface as
meanings, we can observe that, in a neurosymbolic program, the conversions
between traditional typed-values in conventional symbolic programs and
meanings is a key step in programming with GenAI models. This conversion can
be high-complexity, effort-intensive and highly impactful to the performance
of the program. In this section, we formally define this process and propose
that this process to be automated by the runtime and optimized away from the
developer.

###  IV-A Meaning-type Transformation (MTT)

Figure 5: Meaning-type Transformations (MTT) transforms between conventional
typed-values and meanings.

We define the process of conversion between symbolic typed-values and meanings
as Meaning-type Transformations (MTT). MTT has the following two general
variations.

  1. 1.

Meaning-type Raise (MTR) transforms typed-values to meanings (Figure 5a). MTR
usually happens before the inference of an LLM. MTR can leverage any and all
properties associated with a typed-value to generate its meaning, including
but not limited to its type, value and label.

  2. 2.

Meaning-type Lower (MTL) transforms meanings to typed-values (Figure 5b). MTL
usually happens after the inference of an LLM. MTL leverages already-defined
properties (e.g., type and label) about a variable to transform the meaning
into the value of the variable.

###  IV-B Manual Meaning-type Transformation

⬇

meaning:str = f"Write a short bio for this person,"

meaning += f"\nTheir name is {name} and they were born on {dob}".

meaning += "\nHere are some of this accomplishments."

for k,v in accomplishments.items():

meaning += f"On {k.strftime()},"

meaning += f"they accomplished {v}"

return llm.infer(meaning)

Figure 6: Manual Meaning-type Transformation using existing code constructs

Meaning-type transformation is currently being conducted manually, in the form
of prompt engineering. Figure 6 shows an example of a manual MTT. In this
example, we are applying MTT on the function $write_{b}io$. Compared to
relative simple nature of this LLM operation, the code and logic required for
MTT for this operation is noticeable more complex and hard to read. This
illustrates the high complexity that can be introduced into existing code base
from adopting LLM and transitioning to a neuro-symbolic program and its heavy
impact on code maintainability and readability. This is further exacerbated in
a real large-scale application for the following reasons:

  1. 1.

Selecting the right typed-values to transform is non-trivial, especially in a
complex application with many variables in the working space.

  2. 2.

For a given typed-value, selecting the proper properties and leveraging them
effectively to generate a meaning that best represents the underlying intent
of that typed-value can be difficult to get right. This can also vary greatly
depending on the scenario.

  3. 3.

The complexity of MTTs in your program increases with more LLMs inference you
leverage. In addition, duplicate code tends to occur when the same typed-
values are utilized for different LLM inferences throughout the program where
the meaning should be embedded.

  4. 4.

When using LLM functionality with other code constructs such as inter-
dependent custom types and class methods, the complexity of the MTT process
becomes extreme, which transfer the responsibility of maintaining accuracy and
reliability of response to the developer.

We think that the main source of complexity for programming with GenAI models
lies in designing and implementing the associated MTTs. Well-designed MTT are
crucial to the performance of the LLMs and quality of the overall application.
However, building a good MTT requires extensive hands-on experience of
programming with GenAI and deep knowledge of the application. MTTs are
currently done manually, which adds to developer effort and contribute to
overall application complexity. We propose that Meaning-type Transformations
should be automated for the developers. In the remaining sections of the
paper, we introduce our vision for an automated meaning-type transformations.

##  V Automated Meaning-type Transformation (A-MTT)

⬇

date_of_birth : str = ’2nd May, 1989’

# Unclear the exact meaning of the variable

item : str = ’apple’

Figure 7: Meaning Manifestation in conventional coding

In order to fully bridge the gap between neurosymbolic programming and
traditional programming and truly unlock the potential of GenAI, we think the
translation between traditional code constructs and neurosymbolic code
construct should be automated for the developers. In this section, we
introduce our vision for automated meaning-type transformation (A-MTT), which
consists of new language-level features and semantics. We demonstrate this
vision by modifying and augmenting Python with new language syntax and showing
code examples of GenAI-powered programs.

###  V-A Representing Meaning at the Language Level

In order to automate meaning-type transformations, elements required to build
the meaning of a code section should exist within the code itself i.e. the
meaning should manifest within the code. In a well written program, fragments
of the meaning are embedded within the code as meaningful variable names,
meaningful function names etc. This allows the code to become human readable
which in turn becomes AI readable. Line 2 in Figure 7 shows such an example,
where the variable name $date\\_of\\_birth$ is sufficient to derive the
meaning of the variable.

However, in conventional coding, the existing language level abstractions that
allows to embed meaning are limited. Line 4 in Figure 7 shows a variable named
$item$. This information, along with the type $str$ and the variable value
$apple$, are not sufficient in conveying the full meaning of this entity.
Depending on the context, $item$ could carry a number of different meanings.
This demonstrates a certain degree of lack of expressibility in modern
programming languages that prohibits the runtime to fully automate
transforming between symbolic code constructs and meanings. This limitation
extends to also functions and classes. In order to automatically infer
meanings, we need to provide developers with tools to annotate symbolic code
to provide rich context so they can be automatically converted to and from
meanings by the language runtime.

###  V-B Semantic Strings (Semstrings)

⬇

# variable : type = value

’available item to sell in the store’

item : str = ’apple’

Figure 8: Embedding meaning of variable as a semstring

We introduce Semantic Strings (semstrings), a new language feature that allows
developers to annotate their symbolic code to provide additional information
and context. A semstring is a string that describe the meaning of the code
construct much like comments and doc-strings. Semstrings are free-form text
that developers can write to describe a variable, function or class. The
concept of semstring is agnostic to the programming language. In this paper,
we use Python as an example to show how semstring can be implemented in a
modern programming language.

Semstrings aid the programmer to provide additional context of a code
construct and help clarify its meaning. Figure 8 shows a semstring-annotated
version of the $item$ example from Figure 7. The additional context in the
semstring alleviate much of the ambiguity in the meaning of $item$. The same
approach can be taken towards writing semstrings for object classes and
functions, which will represent their operation. Semantic strings can greatly
improve code readability and can be leveraged to automatically generate the
meaning of the code on which the LLMs will operate.

###  V-C LLM as a Code Construct

⬇

model_name: "gpt-4"

temperature: 0.7

do_sample: true

Figure 9: GenAI models as new code constructs

We introduce GenAI models as a new language-level code construct, model
(Figure 9). model operates as a keyword similar to $class$ which will define a
custom model type. The model name and other hyper-parameters can be mapped to
LLM inference. model are meaning-typed, as in they operates with meanings as
their inputs and outputs. The invocation of a $model$ type in the code will
inform the language runtime to apply A-MTT to integrate LLM inference with the
symbolic code portion of the program.

###  V-D A-MTT in Action

We show A-MTT in action, integrating LLM inference with conventional symbolic
code. We show three use cases where LLMs can replace symbolic code and reduce
code complexity: 1) instantiating objects of custom types, 2) standalone
functions and 3) class member methods. Figure 10 illustrates the three use
cases.

Figure 10: Three types of A-MTTs, for Type, Function and Method.

####  V-D1 Instantiating custom typed objects

⬇

name : str

’date of birth in format : DD/MM/YYYY’

dob : str

’Accomplishments’

accomp : list[str]

Einstein = Person(name="Einstein") by llm()

Figure 11: Instantiating object of a custom type using LLM

When instantiating a object of a custom type with multiple member attributes,
it is common to only explicitly provide some of the attributes and use logic
to infer the other attributes to fully creating the object. This inference can
be done automatically with LLM in place of more logic. In the example given in
Figure 11, a custom type called $Person$ is defined which has name, DOB and
accomplishments as attributes. When creating an object of this custom class,
labeled as Einstein, it can be seen that only the $name$ has been explicitly
provided as an initializing property of the object. The remaining attributes
($dob$, $accomp$) are automatically populated by an LLM. The LLM is invoked
with the syntax $by\ llm$.

The semstrings included in the code snippet describes the custom class and the
field variables. The $Person$ class has three attributes. $name$ is a variable
which is of string type. It does not need semstring because the variable name
itself is self-explanatory. $accomp$ and $dob$ variable require semstrings to
fully describe their meanings. Upon invocation of the LLM, an Automatic
Meaning-type Raise (A-MTR) process transforms the current context (including
the class label of $Person$, the attributes label and semstrings of $name$,
$dob$ and $accomp$ and the provided initialized value for $name$ attribute)
into the input $meaning$ for the LLM. After the LLM inference, the output
$meaning$ is then converted into the values for the attributes $dob$ and
$accomp$ through the Automatic Meaning-type Lower (A-MTL) process. These
values are then used to fully initialize the variable $Einstein$. This process
is illustrated in Figure 10 middle.

####  V-D2 Standalone functions

⬇

summarize (

’Accomplishments’ a: list[str]

) -> summary: str by llm()

accomp_summary = summarize(Einstein.accomp)

Figure 12: Embedding meaning of functions using semstrings.

A function in a program can be explained as a operation that transform a set
of typed-values (input parameters) to another set of typed-values (output
values). A neurosymbolic function will also inherit the same functionality of
a conventional function, except the operation is handled by an LLM which
replaces the body of the function. Figure 12 shows an example of using LLM as
the logic for a function. In this case, we annotate with semstrings, the
function label ($summarize$) and its input parameters ($a$). The function is
affixed with $by\ llm$, indicating that we want an LLM to handle the operation
intended by this function. Upon invocation of the function, the function label
and semstring and the label, value and semstring of its input parameters and
output values are converted to $meaning$ which is the input to the LLM. The
output $meaning$ of the LLM is converted to the output value and returned by
the function. Figure 10 left illustrates this process. When calling the
function the code will look similar to when calling a normal function.

####  V-D3 Class member methods

⬇

name : str

’Date of birth in format : Month DD, YYYY’

dob : str

age : int

def ’Calculate the Age of a Person’

calculate (

’Current Year’ cur_year: int

) -> ’Calculated Age’ ca: int by llm() :

self.age = calculated_age

Einstein = Person(name="Einstein", dob="March 14, 1879")

Einstein.calculate(cur_year=2024)

Figure 13: Embedding meaning of Methods in Objects using semstrings.

Using LLM for class methods combines techniques used for custom types and
functions. Different to functions, class methods can leverage the $meaning$ of
the member attributes of its class to improve the fidelity of $meaning$ of its
operation. In the code example in Figure 13, $name$, $dob$ and the $age$ are
the class attributes. The $calculate$ method is used here to calculate the age
of the person relative to the current year which is the input to the method.
Upon invocation of this method, a comprehensive $meaning$ is generated from
both the information of the $calculate$ method itself (e.g. label, semstring,
input parameters) and the surrounding contextual information provided by its
”peer” class attributes ($name$, $dob$, $age$) and its ”parent” class
($Person$). Figure 10 right illustrates the A-MTT process fo class methods.

##  VI Conclusion

Neurosymbolic programming has seen significant increase in interests and
adoption recently, thanks to the advancement of Generative AI and LLM.
However, leveraging GenAI models in a neurosymbolic program is complicated and
requires significant expertise and efforts. We think this is largely due to
the lack of language-level abstraction through which the symbolic side and
neurosymbolic side of a program should be bridged. In this paper, we introduce
LLMs as a new language-level code constructs and we argue that LLMs are
wrapped with a new type $meaning$. We postulate that main effort and
complexity involved with using GenAI models lies in the transformation between
conventional symbolic code constructs (i.e. types, variables, functions) and
their $meanings$, which we define as Meaning-type Transformation (MTT). We
introduce Automatic Meaning-type Transformation (A-MTT), where the language
runtime automatically transform between symbolic code constructs and
$meanings$ that are the interface of LLMs. This is done with the help of new
language syntax such as Semantic strings (semstrings). We demonstrate, with
real code examples, how A-MTT and semstrings significantly simplifies the
complexity of leveraging LLMs in programming.

## References

  * [1] S. Chaudhuri, K. Ellis, O. Polozov, R. Singh, A. Solar-Lezama, Y. Yue _et al._ , “Neurosymbolic programming,” _Foundations and Trends® in Programming Languages_ , vol. 7, no. 3, pp. 158–243, 2021.
  * [2] L. Beurer-Kellner, M. Fischer, and M. Vechev, “Prompting is programming: A query language for large language models,” _Proceedings of the ACM on Programming Languages_ , vol. 7, no. PLDI, pp. 1946–1969, 2023.
  * [3] L. Zheng, L. Yin, Z. Xie, J. Huang, C. Sun, C. H. Yu, S. Cao, C. Kozyrakis, I. Stoica, J. E. Gonzalez _et al._ , “Efficiently programming large language models using sglang,” _arXiv preprint arXiv:2312.07104_ , 2023.
  * [4] A. Følstad and M. Skjuve, “Chatbots for customer service: user experience and motivation,” in _Proceedings of the 1st international conference on conversational user interfaces_ , 2019, pp. 1–9.
  * [5] O. Khattab, A. Singhvi, P. Maheshwari, Z. Zhang, K. Santhanam, S. Vardhamanan, S. Haq, A. Sharma, T. T. Joshi, H. Moazam _et al._ , “Dspy: Compiling declarative language model calls into self-improving pipelines,” _arXiv preprint arXiv:2310.03714_ , 2023.
  * [6] J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. V. Le, D. Zhou _et al._ , “Chain-of-thought prompting elicits reasoning in large language models,” _Advances in neural information processing systems_ , vol. 35, pp. 24 824–24 837, 2022.
  * [7] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “React: Synergizing reasoning and acting in language models,” _arXiv preprint arXiv:2210.03629_ , 2022.


#  Multipactor suppression in dielectric-assist accelerating structures via
diamond-like carbon coatings

Shingo Mori<EMAIL_ADDRESS>KEK Accelerator department, Tsukuba, Ibaraki
305-0801, Japan  Mitsuhiro Yoshida<EMAIL_ADDRESS>KEK Accelerator
department, Tsukuba, Ibaraki 305-0801, Japan  Daisuke Satoh  dai-
<EMAIL_ADDRESS>Radiation Imaging Measurement Group Research Institute for
Measurement and Analytical Instrumentation, National Metrology Institute of
Japan, National Institute of Advanced Industrial Science and Technology (AIST)

###### Abstract

Multipactor discharges are widely observed in the accelerator field, and their
suppression has been studied to improve accelerator performance. A dielectric-
assist accelerating (DAA) cavity is a standing-wave accelerating cavity that
attains a Q-value of over 100,000 at room temperature by using the reflection
of the dielectric layer; the DAA cavity is expected to be used with a small RF
power source and high-duty operation. Thus far, the maximum accelerating field
of DAA cavities has been limited to a few MV/m by the multipactor. By applying
a diamond-like carbon (DLC) coating to reduce the secondary electron emission
coefficient without sacrificing the Q-value of the cavity, we have
demonstrated that a $6~{}[{\rm\mu s}]$ RF pulse can be injected into a DAA
cavity with a field of more than 10 [MV/m] while suppressing the multipactor.

Multipactors are a widespread phenomenon in the accelerator field and have
appeared in the development of RF windows, accelerator tubes, and beam pipes.
In the multipactor phenomenon, the number of electrons increases exponentially
owing to repeated resonant collisions of electrons on the surface of a
material in an alternating electric field; it occurs when the secondary
electron yield (SEY) of the material is greater than one. There are the
several classes of multipactor suppression methods that aim to reduce the SEY
through application of a coating of low SEY material such as TiN Nyaiesh  _et
al._ (1986); Kennedy  _et al._ (1997) or amorphous carbon Vallgren  _et al._
(2011, 2010); Shaposhnikova  _et al._ (2009), or by grooving Baglin  _et al._
(1998), reducing the tangential electric field on the surface, or applying a
solenoidal magnetic field Kulikov  _et al._ (2001); Jing  _et al._ (2016).

The RF accelerating cavity is widely used to generate high-energy beams in
numerous scientific and technological applications. One of the figures of
merit of an RF cavity is the Q-value, which represents the power efficiency of
the cavity and is determined according to the conductivity of the material and
the structure. The superconducting cavity has a high Q-value of greater than
order ${\cal O}(10^{10})$ at low temperature $T<4.2~{}[{\rm K}]$, while the
normal conducting cavity has a Q-value of ${\cal O}(10^{4})$ working at room
temperature, as determined by the ohmic loss of the metal. Recently, it was
proven that a dielectric-assist accelerating (DAA) structure could attain a
high Q-value of ${\cal O}(10^{5})$ at room temperature Satoh  _et al._ (2016,
2017) through a reduction in the surface magnetic field using the reflection
of a dielectric layer exceeding the limits of the Q-value determined by the
ohmic loss. Figure 1 (a) shows a five-cell DAA cavity with a $Q\sim 1.2\times
10^{5}$, which is one order of magnitude larger than the typical Q-value of a
normal conducting cavity.

The maximum accelerating field of a dielectric-based accelerating cavity is
limited by multipactors and breakdowns. Power  _et al._ (2004) Numerous high-
power tests of X-band dielectric-loaded accelerating structures (DLA) have
been performed, and accelerating fields of up to 20 MV/m have been achieved by
applying an axial magnetic field to suppress multipactors. Jing  _et al._
(2016) The study of photonic bandgap cavities using sapphire rods shows a
maximum electric field of 19.1 MV/m, which is limited by breakdowns in triple
junctions. Zhang  _et al._ (2016) In both examples, short RF pulses of
$100~{}[{\rm ns}]$ to $500~{}[{\rm ns}]$ in the X-band are fed in. In
contrast, in a DAA cavity, relatively long RF pulses of several $\mu s$ are
fed in at a lower frequency, the C-band. In the case of our DAA cavity, the
maximum value of the accelerating field was limited to approximately 1 or 2
MV/m without the SEY countermeasure. Attempts have been made to suppress the
multipactor effect in DLA structures by lowering the SEY with TiN coating.
However, in the case of DLA with TiN coating, it is not possible to completely
suppress the multipactor. Jing  _et al._ (2010) Recently, it has been shown
that a diamond-like carbon (DLC) coating is relatively more resistant to
multipacting than TiN as a coating for the inner surface of a metal standing-
wave accelerating cavity in the X-band. Xu  _et al._ (2019).

The ideal coating for a DAA cavity will be a material that has both very low
electrical conductivity and SEY. A coating of a material with high electrical
conductivity, such as the TiN coating, reduces the Q-value of the DAA cavity
by increasing the ohmic loss on the surface of the dielectric cells. In fact,
as shown in Table 1, when a TiN coating with a thickness of $10~{}[{\rm nm}]$
was applied to both sides of the ceramic cells of the five-cell DAA cavity
fabricated in our previous work Satoh  _et al._ (2017), the reduction in the
Q-value was approximately $40$ [%]. A TiN coating of a few nanometers in
thickness will not suffice because it will be displaced by the electrical
discharge occurring during conditioning. Jing  _et al._ (2010)

DLC has a low SEY and low electrical conductivity, and is composed of ${\rm
sp}^{2}$ (graphene-like) and ${\rm sp}^{3}$ (diamond-like) bounds of carbons.
The SEY of DLC coating is less than 1.5. Zhang  _et al._ (2019) We also
measured the SEY of the DLC coating on an MgO sample with a thickness of
$0.5~{}[{\rm\mu m}]$ using an SEM-based device at KEK Yamamoto  _et al._
(2019). Then, in the incident energy range between $0.5~{}[{\rm keV}]$ and
$2.0~{}[{\rm keV}]$, the measured SEY monotonically decreased from $1.4$ to
$0.7$, and the SEY was $\delta<1$ below the incident energy of $1.1~{}[{\rm
keV}]$; this was lower than the measured SEY of the TiN coating on the MgO.
Moreover, the DLC coating on the surface of a dielectric cell does not affect
the Q-value because the DLC coating has a high electrical resistance at room
temperature. Meyerson and Smith (1980) As shown in Table 1, the DLC coating of
$0.5~{}[{\rm\mu m}]$ thickness on both sides of the ceramic cells of the five-
cell DAA cavity resulted in a Q-value change of approximately $3~{}[\%]$,
which is within the error of low-power measurements.

Coating | $f_{0}~{}[{\rm MHz}]$ | $\beta$ | $Q_{0}$
---|---|---|---
w/o coating (set 1) | $5708.29$ | $1.4$ | $112000$
TiN (set 1) | $5713.01$ | $0.79$ | $64000$
w/o coating (set 2) | $5717.10$ | $0.93$ | $113000$
DLC (set 2) | $5717.07$ | $1.0$ | $116000$
Table 1:  Effect of TiN coating and DLC coating on the Q-value of the five-
cell DAA cavity. There are two sets of dielectric cells in the five-cell DAA
cavity, each with different dimensional errors. TiN coating was applied to
both sides of all cells in set 1, with a thickness of $10~{}[{\rm nm}]$. DLC
coating with a thickness of $0.5~{}[{\rm\mu m}]$ was applied on both sides of
all cells in set 2. The Q-value was measured via the coupler and mode
converter shown in Figure 1 (c) from $S_{11}$ using the Agilent N5230A network
analyzer.

Figure. 1 (e) shows the MgO cell after application of the DLC coating. We
applied DLC coating processed by the plasma CVD method with a thickness of
$0.5~{}[{\rm\mu m}]$, hydrogen content of $5\sim 50~{}[\%]$, and ${\rm
sp^{3}/(sp^{2}+sp^{3})}$ ratio of $20\sim 50~{}[\%]$.

Figure 1: (a) Schematic representation of the original DAA cavity Satoh  _et
al._ (2017). (b) Cross-section of the electric field of the accelerating mode
calculated using SuperFish. (c) Development view of the two-cell cavity. (d)
MgO cell without coating and (e) with DLC coating with a thickness of
$0.5~{}[{\rm\mu m}]$. (f) RF system of the high-power test from the klystron
to the measurement of stored power through the antenna.

In this study, we performed a high-power test of the two-cell DAA cavity with
low-SEY and low-conductivity DLC coating. The various conditions are described
as follows.

To focus on the effect of the surface treatment on the accelerating gradient,
we fabricated a DAA test cavity with two cells. In order to implement the
translational symmetric field configuration shown in Figure 1 (b) and reduce
the tangential electric field on the surface of the DAA cells, we did not
adopt the end cell structure to mitigate the power loss at the copper
endplate, as discussed in Satoh  _et al._ (2016). The Q-value of our
fabricated test cavity was $Q_{0}\sim 2.7\times 10^{4}$, which is
approximately $25~{}[\%]$ lower than the Q-values of the simulations assuming
electrical conductivity $\rho=1.72\times 10^{-8}~{}[{\rm\Omega/m}]$ and
dielectric loss $\tan\delta=6\times 10^{-6}$. This is due to the insufficient
contact and surface treatment of the metal cavity and end-plates.

As shown in Figure 1 (c), the test cavity is composed of a copper end-plate,
copper cylinder, coupler, the mode converter, and dielectric cell. Figure 1
(d) shows the MgO cell after machining with tolerances from $0.01~{}[{\rm
mm}]$ to $0.07~{}[{\rm mm}]$. The MgO ceramics had the same characteristics as
those used in the previous work Satoh  _et al._ (2017), i.e., a relative
permittivity of $\epsilon_{r}=9.64$ and a loss tangent of $\tan\delta=6\times
10^{-6}$.

Figure 1 (f) is an RF schematic showing the power source, waveguide,
acceleration cavity, and measurement system that comprise the C-band test
stand. The C-band RF was produced by a Tektronix TSG 4106A signal generator
(SG) and amplified by a solid-state amplifier and the klystron. The DAA cavity
was installed in the vacuum chamber and connected to the rectangular waveguide
via the mode converter. We placed a Faraday cup in front of the mode converter
to measure the dark current emitted from the beam hole in the coupler side. We
placed a pickup antenna composed of semi-rigid coax cable outside the copper
endplate, along the beam axis.

The stored power $P_{c}$ coupled to the antenna was transmitted through the
cable, the attenuator (Lucas Weinschel Model 47), and a Keysight 8472B crystal
diode, which generated a rectified voltage to be monitored by an oscilloscope
(Iwatsu DS-5514). The measurement using the signal generator indicated that
the attenuator damped the input RF power by $41~{}[{\rm dB}]$.

In the following, we describe the in situ measurements of the Q-value and the
transmission coefficient representing the coupling of the antennas. As shown
in Figure 1 (f), the 4-port circulator is equipped with two vacuum windows,
and the section between them is at atmospheric pressure and can be removed.
Thus, we could perform low-power measurements of the cavity through the
waveguide from the position of the vacuum window. The transmission coefficient
$S_{12}$ from the waveguide to the antenna and coaxial cable (Huber & Suhner
Sucoflex 104) could be measured directly to obtain information on the coupling
between the antenna and the cavity, including the transmission loss of the
coaxial cable. Neglecting the transmission loss by the rectangular waveguide,
we can obtain the ratio of the power observed by the antenna via the coaxial
cable and that stored inside the cavity from the transmission coefficient
$S_{12}$.

Coating | $f_{0}~{}[{\rm MHz}]$ | $Q_{L}~{}(\times 10^{4})$ | $\beta$ | $Q_{0}~{}(\times 10^{4})$ | $S_{21}~{}[{\rm dB}]$
---|---|---|---|---|---
uncoated | $5736.81$ | $1.1$ | $1.5$ | $2.7$ | $32.7$
DLC1 | $5739.72$ | $1.2$ | $1.1$ | $2.7$ | $26.7$
DLC2 | $5729.65$ | $0.88$ | $2.1$ | $2.7$ | $33.1$
Table 2: Results of the low-power test conducted using the network analyzer.

Table 2 shows the results of the low-power measurement described above. The
rows represent the coating conditions, i.e., without coating (uncoated) and
with DLC coating with a thickness of $0.5~{}[{\rm\mu m}]$ (DLC1, DLC2).
Different pairs of dielectric cells were used in each condition, and the
dimensional errors in the cells shifted the resonant frequency and coupling.
$f_{0}$ is the resonant frequency of the cavity.
$Q_{L}=Q_{0}/(1+\beta+\beta_{\rm a})$ is the loaded Q-value, where the
coupling between the cavity and the antenna satisfies $\beta_{\rm a}\ll 1$ and
$\beta$ is the coupling through the iris of the coupler.

The stored power $P_{c}$ can be reconstructed via two independent methods
using the measurements from the low-power test.

In the first method, the transient model is used to compute $P_{c}(t)$ from
the input waveforms $P_{\rm in}(t)$, and the measured loaded Q value $Q_{L}$.
We assume that there is no loss due to time-varying multipactors in the cavity
and then $Q_{L}$ is constant. By using the relation of power conservation
$dW_{c}/dt=P_{\rm in}-P_{\rm ref}-P_{c}^{B}$, $Q_{0}=\omega W_{c}/P_{c}^{\rm
B}$, $P_{\rm in}=G_{\rm wg}V_{\rm in}^{2}$, $P_{\rm ref}=G_{\rm
wg}(V_{c}-V_{\rm in})^{2}$, $P_{c}^{B}=(G_{\rm wg}/\beta)V_{\rm c}^{2}$, the
cavity voltage $V_{c}$, and waveguide voltage follow

$\displaystyle T_{f}\frac{dV_{c}}{dt}+V_{c}=\frac{2\beta}{1+\beta}V_{\rm in},$
(1)

where $T_{f}=Q_{L}/(\pi f_{0})$ and $G_{\rm wg}$ denotes the waveguide
admittance. By substituting the measured time variation of the incident power
$P_{\rm in}(t)$ into Eq. (1), we obtain the stored power $P_{c}^{B}(t)$.

The second method reconstructs the stored power $P_{c}^{A}$ using the
transmission coefficients $S_{21}$, attenuator, and crystal diode. Using the
signal generator, we measured the relation between the input power and the
output voltage, $f_{\rm dBm}(\ln V)$, for the crystal diode and RF power
meters, where $V$ is the voltage measured by the oscilloscope. Then, we can
reconstruct the stored power $P_{c}^{A}$ as

$\displaystyle P_{c}=1~{}[{\rm mW}]\cdot 10^{f_{\rm dBm}(\ln V)/10}\cdot
10^{-S_{21}~{}[{\rm dB}]/10}\cdot 10^{\Delta_{Att}/10},$ (2)

where $\Delta_{Att}\sim 41$ is the power reduction measured by the attenuator.

From the simulation using Superfish, the fraction of shunt impedance per unit
length in the Q-value is obtained as $Z/Q_{0}=4.25~{}[{\rm k\Omega/m}]$, which
is independent of the properties of the materials. To obtain the shunt
impedance per unit length $Z$, we multiplied the measured $Q_{0}$ by the
fraction. Combining the above quantities, we can obtain the peak accelerating
voltage as $E_{z,{\rm max}}=\sqrt{Z\cdot P_{c}/L}$, where we use a cavity
length of $L=52.485~{}[{\rm mm}]$.

The repetition rate of the RF pulses is $50~{}[{\rm Hz}]$. During the
experiment, the RF frequency, magnitude of the incident power, and pulse
length of the RF input from the klystron to the DAA cavity can be changed at
any time. We investigated the upper limit of the stored power by increasing
the incident power from approximately 100 [W] to 100 [kW]. In this process,
the RF frequency and pulse length were repeatedly adjusted to maximize the
power waveform in the cavity measured by the antenna. In the case of DLC1 and
DLC2, the conditioning time to reach an accelerating field of 10 MV/m was
approximately 6 h, which is shorter than the conditioning time of the normal-
conducting cavity.

Coating | $P_{c}^{A}~{}[{\rm kW}]$ | $P_{c}^{A}/P_{c}^{B}$ | $P_{c}^{A}/P_{c}^{C}$ | $E_{z}^{A}~{}[{\rm MV/m}]$ | $N_{\rm shot}(\times 10^{6})$
---|---|---|---|---|---
uncoated | $0.89$ | $0.010$ | $0.013$ | $1.4$ | $1.5$
DLC1 | $56$ | $0.92$ | $0.74$ | $11$ | $1.5$
DLC2 | $48$ | $1.2$ | $1.0$ | $10$ | $3.8$
Table 3: Peak stored power in the cavity is calculated by two methods: (1)
using signals from the pickup antenna and (2) using the pulse of the incident
RF power. $P_{c}^{C}={\rm max}(P_{\rm in}(t)-P_{\rm ref}(t))$. $E_{z}^{A}$ is
the peak accelerating gradient calculated by $P_{c}^{A}$. DLC1 and DLC2 denote
the DLC-coated cells, with a thickness of $0.5~{}[{\rm\mu m}]$ on both sides.
Figure 2: uncoated cells with multipactor Figure 3: DLC1 Figure 4: DLC2
---
Figure 5: Waveforms of the measured incident power (blue), reflected power
(red), and the stored power reconstructed by the antenna (yellow),
$P_{c}^{A}$, and by the incident power (green), $P_{c}^{B}$. For uncoated
cells, typical waveforms with multipactors are shown. For DLC1 and DLC2, the
waveforms show stable stored power with an accelerating gradient exceeding 10
MV/m.

In Figures 5, 5, and 5, we show the waveforms of the measured incident power
(blue), reflected power (red), and the stored power reconstructed by the
antenna (yellow), $P_{c}^{A}$, and by the incident power (green), $P_{c}^{B}$.

As shown in Figures 5 and 5, power equivalent to an accelerating electric
field of over $10~{}[{\rm MV/m}]$ could be input when approximately
$0.5~{}[{\rm\mu m}]$ of DLC was applied. Table 3 shows each measured maximum
stored power value and its conversion to the maximum accelerating electric
field corresponding to these waveforms. In the DLC1 test, when the
accelerating electric field was increased further, a large discharge occurred
and the pulses stopped coming in. In the DLC2 test, the pulse length was
extended to approximately $7~{}[{\rm\mu s}]$ while maintaining $10~{}[{\rm
MV/m}]$, resulting in a waveform similar to that of DLC1.

Figure 6:  DLC-coated MgO cell after a breakdown in a high-power test. Black
marks were observed at the corners of the cylindrical part of the cell. Black
marks were also observed at the contact point between the dielectric cell and
the adjacent dielectric cell and at the contact point between the dielectric
and the copper end-plate.

In an uncoated MgO cell, the stored power is saturated when the accelerating
electric field is at the maximum electric field $E_{z,{\rm max}}\sim 2~{}[{\rm
MV/m}]$. In this case, the saturation value of the stored power does not
change even if $P_{\rm in}$ increases with the same pulse length $T_{p}$. When
the stored power is saturated, extending the pulse length $T_{p}$ can extend
the region where the stored power waveform is flattened to $10~{}[{\rm
MV/m}]$. The reflected waveform is not consistent with the transient model;
above $1~{}[{\rm MV/m}]$, the waveform is maintained at the same depth after a
slight absorption.

When DLC coating was applied, the stored power increased in stages until a
breakdown occurred in the cavity. Once the breakdown occurred, the stored
power waveform became unstable and did not improve with further conditioning.
After the test, some traces of electric discharge remained at the cell contact
area and at the contact area between the cell and the metal end-plates, as
shown in Figure. 6. Therefore, we consider that the microgap discharges at the
cell junctions determine the maximum accelerating electric field in the DLC-
coated DAA cavity. In order to obtain a higher accelerating field,
countermeasures against breakdowns at the cell junctions are required. For
example, methods of separating the dielectric cells from each other or
separating the dielectric cells from the metal end-plates have been proposed
in Mori  _et al._ (2019); Wei and Grudiev (2020).

In conclusion, By applying a DLC that lowers the SEY without reducing the
Q-value, we have demonstrated that accelerating fields above $10~{}[{\rm
MV/m}]$ can be applied for pulses as long as $6~{}[{\rm\mu s}]$, thus
suppressing the multipactor that has limited the accelerating field of the DAA
cavity. We have also demonstrated that, owing to the very high resistance of
the DLC coating, even a $0.5~{}[{\rm\mu m}]$-thick DLC coating on both sides
of a dielectric cell does not reduce the Q-value ${\cal O}(10^{5})$ of a five-
cell DAA cavity. One possible application of the DAA cavity is as a compact
power source for X-ray and RI production, as DAA cavities have a power
efficiency one order of magnitude higher than that of a normal-conducting
cavity. In the future, if the anti-breakdown treatment is successful and the
accelerating field can be further extended to tens of MV/m, a linear
accelerator facility such as an FEL may be able to operate at room temperature
without RF pulse compression by the SLED cavity.

## Acknowledgements

We would like to acknowledge Hiroyasu Ego for helpful discussions. This work
was supported by JSPS KAKENHI Grant-in-Aid for Scientific Research (A) (No.
16H02134), JSPS KAKENHI Grant Number 19K20609, and Mitsubishi Heavy Industries
Machinery Systems, Ltd.

The data that support the findings of this study are available from the
corresponding author upon reasonable request.

## References

  * Nyaiesh  _et al._ (1986) A. Nyaiesh, E. Garwin, F. King, and R. Kirby, Journal of Vacuum Science & Technology A: Vacuum, Surfaces, and Films 4, 2356 (1986).
  * Kennedy  _et al._ (1997) K. Kennedy, B. Harteneck, G. Millos, M. Benapfl, F. King, and R. Kirby, in  _Proceedings of the 1997 Particle Accelerator Conference (Cat. No. 97CH36167)_ , Vol. 3 (IEEE, 1997) pp. 3568–3570.
  * Vallgren  _et al._ (2011) C. Y. Vallgren, G. Arduini, J. Bauche, S. Calatroni, P. Chiggiato, K. Cornelis, P. C. Pinto, B. Henrist, E. Métral, H. Neupert, _et al._ , Physical Review Special Topics-Accelerators and Beams 14, 071001 (2011).
  * Vallgren  _et al._ (2010) C. Y. Vallgren, G. Arduini, J. Bauche, S. Calatroni, P. Chiggiato, K. Cornelis, P. C. Pinto, E. Métral, G. Rumolo, E. Shaposhnikova, _et al._ , in  _1st International Particle Accelerator Conference: IPAC_ , Vol. 10 (2010).
  * Shaposhnikova  _et al._ (2009) E. Shaposhnikova, G. Rumolo, K. Cornelis, J. Axensalva, J. Jiménez, M. Taborelli, P. Chiggiato, S. Calatroni, G. Arduini, C. Yin Vallgren, _et al._ ,  _Experimental studies of carbon coatings as possible means of suppressing beam induced electron multipacting in the CERN SPS_ , Tech. Rep. (2009).
  * Baglin  _et al._ (1998) V. Baglin, I. Collins, and O. Gröbner,  _Photoelectron yield and photon reflectivity from candidate LHC vacuum chamber materials with implications to the vacuum chamber design_ , Tech. Rep. (1998).
  * Kulikov  _et al._ (2001) A. Kulikov, A. Fisher, S. Heifets, J. Seeman, M. Sullivan, U. Wienands, and W. Kozanecki, in  _PACS2001. Proceedings of the 2001 Particle Accelerator Conference (Cat. No. 01CH37268)_ , Vol. 3 (IEEE, 2001) pp. 1903–1905.
  * Jing  _et al._ (2016) C. Jing, S. Gold, R. Fischer, and W. Gai, Applied Physics Letters 108, 193501 (2016).
  * Satoh  _et al._ (2016) D. Satoh, M. Yoshida, and N. Hayashizaki, Physical Review Accelerators and Beams 19, 011302 (2016).
  * Satoh  _et al._ (2017) D. Satoh, M. Yoshida, and N. Hayashizaki, Physical Review Accelerators and Beams 20, 091302 (2017).
  * Power  _et al._ (2004) J. Power, W. Gai, S. Gold, A. Kinkead, R. Konecny, C. Jing, W. Liu, and Z. Yusof, Physical review letters 92, 164801 (2004).
  * Zhang  _et al._ (2016) J. Zhang, B. J. Munroe, H. Xu, M. A. Shapiro, and R. J. Temkin, Physical Review Accelerators and Beams 19, 081304 (2016).
  * Jing  _et al._ (2010) C. Jing, W. Gai, J. G. Power, R. Konecny, W. Liu, S. H. Gold, A. K. Kinkead, S. G. Tantawi, V. Dolgashev, and A. Kanareykin, IEEE transactions on plasma science 38, 1354 (2010).
  * Xu  _et al._ (2019) H. Xu, M. Shapiro, and R. J. Temkin, Physical Review Accelerators and Beams 22, 021002 (2019).
  * Zhang  _et al._ (2019) Y. Zhang, Y. Wang, X. Ge, B. Zhang, W. Wei, S. Wang, B. Zhu, J. Shao, W. Li, and Y. Wang, in  _Journal of Physics: Conference Series_ , Vol. 1350 (IOP Publishing, 2019) p. 012177.
  * Yamamoto  _et al._ (2019) Y. Yamamoto, E. Cenni, A. Four, E. Kako, S. Michizono, and Y. Okii, in  _29 $\backslash$textsuperscript $\\{$th$\\}$ Linear Accelerator Conf.(LINAC’18), Beijing, China, 16-21 September 2018_ (JACOW Publishing, Geneva, Switzerland, 2019) pp. 905–907.
  * Meyerson and Smith (1980) B. Meyerson and F. Smith, Journal of Non-Crystalline Solids 35, 435 (1980).
  * Mori  _et al._ (2019) S. Mori, M. Yoshida, and J. D. Satoh, in  _10th Int. Partile Accelerator Conf.(IPAC’19), Melbourne, Australia, 19-24 May 2019_ (JACOW Publishing, Geneva, Switzerland, 2019) pp. 1179–1181.
  * Wei and Grudiev (2020) Y. Wei and A. Grudiev, arXiv preprint arXiv:2006.07276 (2020).