JLAB Data Acquisition Run
Control System
Jefferson Lab
Vardan Gyurjyan
Run-control history



Eiffel
C++
Java
Run-control design requirements
Extendable.

distributed.
 Network
Maintainable
Integration
with
code
thereplicating
detector control
the oldand
run-control
legacy
 Platform independent.
functionality.
software
systems.
 Software centric.
 Flexible.
 Dynamic hierarchical.
 Synchronization via message passing.
 Real-time hardware actions and knowledge
processing.

Agent properties






Autonomy.
Proactive intelligence.
Adaptive intelligence.
Temporal continuity.
Mobility.
Rationality/benevolence.
Multi - Agent approach





Distributes computational resource.
Accommodates legacy systems.
Peer-to-peer model.
Global coordination.
High performance.
FIPA- Foundation for Intelligent Physical Agents






FIPA framework (http://www.fipa.org).
FIPA is a specification NOT an implementation.
Directory Facilitator (DF).
Agent Management System (AMS).
Agent Communication Channel (ACC) .
Java Agent DEvelopment framework (JADE) -FIPA
specification JAVA implementation
(http://sharon.cselt.it/projects/jade).
Run-Control Platform Architecture
Run-Control Front-End
Component Container
JVM2
Thalamus
Stemcell
Java RMI
vxWorks
Coda_roc
HV
Stemcell
Agent
JVM1
Java DP
Slow Control
GUI Agent
GUI
Slow Control Configuration.
Run configuration
file.
COOL file
COOL format.
AMS
Hepatic
DF
Stemcell
ROC 1
Communication
Message can contain
through
any
message
arbitrarypassing.
objects.
Cortex
ACC
GUI Agent
RMI Registery
Java RMI
NODE3
NODE 1
NODE 2
HV
hardware
COOL- Control Oriented Ontology Language






Based on RDFS (Resource Definition Framework Schema).
Control domain knowledge creation and reuse.
Knowledge base sharing.
Domain knowledge and operational knowledge separation.
Domain knowledge analyses.
Extensible via XML-namespaces and RDF modularization.
XML or RDF?


After all both are text constructs.
Duplet vs. triplet to transfer human knowledge.
XML
Tag
Resource
Subject
RDF
Value
Predicate
Property
Object
Value
COOL taxonomy
Subjects/Objects








Control
Component
Process
Command
Data
Node
Loop
Option
Predicates




















hasComponentName
resultNotify
hasCommandName
hasDataContent
hasNodename
hasDataFile
loopRepete
hasComponentType
acceptData
hasCommandType
hasDataType
hasIP
hasDataLimit
loopDelay
hasOption
hasPriority
acceptStatus
hasExpectedOk
hasDataCardinality
isLocal
hasEventLimit
stopAt
hasComponent
hasProcess
hasCommand
hasTimeOut
hasTimeStamp
hasUser
hasTokenInterval
acceptsComponent
Differentiate
hasCheckWith
hasLoop
hasSemantics
hasPasswd
Splitmb
hasScrupulosity
hasSession
isPartOf
returnData
hasRunType
hasData
inputdata
hasCode
hasNode
hasFirst
hasNext
hasInput
hasOutput
Extending run-control state machine






Any control process can be defined as a CODA component.
Every component can have associated processes.
Each process can be attached to the CODA standard state machine transition by means of
isPartOf COOL predicate.
COOL process is RDF subclass of the COOL component.
Every process has associated COOL command.
COOl command can have expectedOk predicate.
Control A >> hasProcess >> B
Process B >> isPartOf >> download
Process B >> hasProcess >> B1
Process B >> hasProcess >> Bn
B1 >> expectedOk >> Output String
JAS data server description in COOL
<rdf:RDF
xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'
xmlns:rdfs='http://www.w3.org/2000/01/rdf-schema#'
xmlns:cool='http://ankaa.jlab.org/~gurjyan/COOL/cool#'>
<cool:Control rdf:ID="JasDataServer">
<cool:hasCategory
rdf:resource="http://ankaa.jlab.org/~gurjyan/COOL/cool#internal"/>
<cool:hasDependency rdf:resource="#JDSDependency"/>
<cool:hasProcess rdf:resource="#StartServer"/>
<cool:hasProcess rdf:resource="#MonitorHistogram"/>
</cool:Control>
<cool:Dependency rdf:ID="JDSDependency">
<cool:hasHardware rdf:parseType="Resource">
<cool:hasIP>129.57.167.14</cool:hasIP>
<cool:hasNodeName>clon10.jlab.org</cool:hasNodeName>
</cool:hasHardware>
<cool:hasLibrary rdf:parseType = "Resource">
<cool:hasName>jas.server.HistogramServer</cool:hasName>
<cool:hasLocation>/usr/local/clas/jar/jas.jar</cool:hasLocation>
<cool:hasName>hep.analyses.Histogram</cool:hasName>
<cool:hasLocation>/usr/local/clas/jar/hep.jar</cool:hasLocation>
</cool:hasLibrary>
<cool:environment>JAVA</cool:environment>
</cool:Dependency>
<cool:Process rdf:ID="StartServer">
<cool:hasTransaction rdf:parseType="Resource" >
<cool:operationType rdf:resource="http://ankaa.jlab.org/~gurjyan/COOL/cool#construct"/>
<cool:fnactionName>HistogramServer</cool:functionName>
<cool:hasInput rdf:parseType="Resource">
<cool:Type rdf:resource="http://ankaa.jlab.org/~gurjyan/COOL/cool#string"/>
</cool:hasInput>
</cool:hasTransaction>
<cool:repeat>1</cool:repeat>
</cool:Process>
<cool:Process rdf:ID="MonitorHistogram">
<cool:hasTransaction rdf:parseType="Resource" >
<cool:operationType rdf:resource="http://ankaa.jlab.org/~gurjyan/COOL/cool#construct"/>
<cool:fnactionName>Histogram</cool:functionName>
<cool:hasInput rdf:parseType="Resource">
<cool:Type rdf:resource="http://ankaa.jlab.org/~gurjyan/COOL/cool#string"/>
</cool:hasInput>
</cool:hasTransaction>
<cool:hasTransaction rdf:parseType="Resource" >
<cool:functionName>fill</cool:functionName>
<cool:hasInput rdf:parseType="Resource">
<cool:Type rdf:resource="http://ankaa.jlab.org/~gurjyan/COOL/cool#long"/>
</cool:hasInput>
</cool:hasTransaction>
<cool:hasCategory rdf:resource= "http://ankaa.jlab.org/~gurjyan/COOL/cool#ondemand"/>
</cool:Process>
</rdf:RDF>
COOL GUI and knowledge auto-transfer from
mSQL to COOL
db2cool
Run-control GUI
Conclusion





Extended graphing and monitoring capabilities.
Backwards compatibility between old and new run configuration files.
Agent platform administration and fault tolerance.
Integration of the foreign processes through DP, vmeServer and Shell interfaces.
Process abstraction has been implemented through the newly developed control
oriented ontology language.
Future plans




Integration of the EPICS processes through the channel access interface.
Integration of the CAEN HV control systems through the CAEN OPC server
interface.
Develop agent supporting JXTA peer to peer specification.
Run-control web interface.