Use Cases - Confluence by lanyuehua


									 UC#    Name                                                          UC      UC Status         Summary                             Description                                          Assumptions                                                       Scenario                                                                                                                                       UX Exposure           Subsy
                                                                   Priority                                                                                                                                                                                                                                                                                                                                                     stem
        short as possible while still distinct                      1 << 5    Identified, Draft, one-line summary, appears in       A brief description of the scenario (enough to                                                                                                                                                                                                                        who sees results?
                                                                      (5      Draft+MM, User- many tables                           give its overall flavor, but not all the details).                                                                                                                                                                                                                    end user, operator,
                                                                   highest)   Prioritized, LCO,                                                                                                                                                                                                                                                                                                           app, gui, internal
Marine Systems: Instruments and Marine Infrastructure
  1.1   Integrate user-provided instrumentation                       1       Draft             User integrates non-core            Someone external to the OOI team wants to add        * OOI policy, process, procedures, and resources supporting       Steps:                                                                                                                                         end user              SA
                                                                                                instrument and instrument           an instrument to the OOI infrastructure. In          this endeavor exist --- whether it is through an NSF OOI          # _Acquire Instrument Driver_: For instrument/plaform models not known to OOI, load new user-developed driver into Integrated
                                                                                                agent with OOI, completing all      addition to the activities that are already          Infrastructure Extension grant process , or independently         Observatory
                                                                                                life cycle activities               performed for OOI instruments, support the           financed.                                                         # _Assign/verify Instrument Provider role_: Give instrument provider role that allows appropriate control of the instrument.
                                                                                                                                    special activities required for this class of user   * The process to register core OOI instruments (see R2 use        # _Register and Connect Instrument_: (R2) Perform UC.R2.05 Register and Connect Instrument
                                                                                                                                    and instrument.                                      cases) is extensible to non-OOI instruments                       # _Activate instrument driver_: (R2) Perform UC.R2.09 Activate Instrument Driver
                                                                                                                                                                                         * External and internal costs are both funded, consistent with    # _Approve instrument commissioning_: Upon completion of OOI processes and agreement of Instrument provider, indicate instrument
                                                                                                                                                                                         the policies and procedures referenced above.                     is commissioned.
                                                                                                                                                                                         * OOI project can "scale" to meet resouce/skills demands          #_ Install instrument_: (R2) Perform normal instrumentation steps
                                                                                                                                                                                                                                                           # _Acquire data from instrument_: (R2) Perform UC.R2.13 Acquire Data From Instrument
                                                                                                                                                                                                                                                           # _Conclude instrument acceptance period_: When instrument acceptance period ends, undeploy instrument, set lifecycle state
                                                                                                                                                                                                                                                           appropriately, and remove Instrument Provider role from instrument provider (if not already done).
  1.2   Monitor marine communications infrastructure                  5       Draft             Operator provides, obtains, and     The marine communications network is defined                                                                           # _Describe marine network_: A Marine Operator describes in the Integrated Observatory a change to the marine network communication            operator              SA/UX
                                                                                                views relations and status of the   as any linkage allowing commands or data to be                                                                         path.
                                                                                                marine communications               transferred between marine assets and the                                                                              # _View marine network configuration_: A Marine Operator or any Registered User browses to textual and visual representations of the
                                                                                                network                             Integrated Observatory terrestrial network. The                                                                        new marine network configuration.
                                                                                                                                    designers and operators begin by specifying this                                                                       # _Collect marine network traffic data_: The Integrated Observatory collects data from each reporting marine network node about node
                                                                                                                                    network in enough detail to provide operational                                                                        status and traffic.
                                                                                                                                    context and understanding. Users may view the                                                                          # _Calculate marine network status_: The Integrated Observatory calculates operational status and utilization statistics for each network
                                                                                                                                    operational condition of the network's                                                                                 segment.
                                                                                                                                    connections, and the connected components in                                                                           # _Flag changes in network segment status_: The Integrated Observatory issues events for any change in operational status of a network
                                                                                                                                    the context of the network.                                                                                            segment.
                                                                                                                                                                                                                                                           # _View status of marine network segment_: A Registered User views the status of each marine network segment on both textual and
                                                                                                                                                                                                                                                           visual representations.
  1.3   Assure instrument performance                                 4       Draft             Operator establishes and            For example: An operator defines automated           * Instruments of this model can overheat and fail if stuck in a   # _Specify service event_: Operator or system enters a service event, or other instrument-specific event, into Integrated Observatory          operator              SA/UX
                                                                                                maintains performance               algorithms to monitor instrument output based        certain mode. (Hypothetical, for purpose of scenario)             # _View service events_: Operator or user views indications of service and other instrument events in a timeline, data graph, or log
                                                                                                algorithms, parameters, and         on parameters and generate an event and              * Data product algorithms already flag when instrument is         history.
                                                                                                event reporting to detect and       corresponding alert when the instrument's            operating outside of pre-defined "operational" specs              # _Define failure detection process_: (R2) Operator defines and activates a process that generates an event when a certain temperature
                                                                                                respond to instrument and           measurements become unstable, enters                 * Vendor may provide updated "operational" specs which can        from a given instrument model exceeds an operator-defined threshold, and subscribes to the event.
                                                                                                platform failures.                  parameters that are specific to the instrument,      be used to update Integrated Observatory parameters.              # _Configure alarm indication_: (R2) Operator configures an alarm to be issued whenever the temperature exception event is detected;
                                                                                                                                    and defines a recovery plan (that possibly           * In R3, calibration data from vendor and/or an OOI               the alarm is associated with the instrument generating the temperature exception.
                                                                                                                                    precludes access by other users during certain       technician can be entered by technician into the Integrated       # _Define autorecovery mission plan_: Operator defines a mission plan that stops operations of an instrument, powers it down, powers it
                                                                                                                                    conditions) to be executed whenever the event        Observatory                                                       back up, and reinitializes it, and sends a message to the Observatory Operators mailing list.
                                                                                                                                    happens. Initially manual responses may be           * In R3, service history data provided by vendor and/or an        # _Associate event to mission execution_: Operator sets up the temperature exception event as the trigger for execution of the mission
                                                                                                                                    performed, which with experience become              OOI technician is entered by technician into the Integrated       plan.
                                                                                                                                    automated responses.                                 Observatory.                                                      # _Define status-based access restriction_: Operator defines a policy that instruments of model X that are actively sampling, or in direct
  1.4   Track physical resource location using integrated system      4       Draft             User or External asset tracking     Integrated Observatory provides best known           * At least one external asset tracking system maintains           # _Specify new non-deployed location_: Instrument Operator, or ION, or External system specifies a new terrestrial or ship-board location      operator, end user    SA/UX
                                                                                                system provides and obtains         information about device whereabouts,                business data about resources.                                    (e.g., a special type of site) where resources may be stored or maintained.
                                                                                                general (business) and precise      integrating information from OL or other external    * Integrated Observatory derives resource locations based on      # _Specify new mobile resource regime_: Mobile resource user specifies complex region representing an expected working area for the
                                                                                                (operational) component             systems as needed. Mobile assets are located         Release 2 capabilities for defining sites and assigning marine    mobile resource (may be in one, two, or three dimensions).
                                                                                                location                            both by their range, and by their best estimated     physical resources to sites, or to other resources that are       # _Synchronize asset location_: Integrated Observatory communicates with external asset tracking system, synchronizing latest coarse
                                                                                                                                    position.                                            assigned to sites. (Configurations of sensors, instruments        resource location updates in both systems.
                                                                                                                                                                                         and control elements for an integrated platform (e.g. a glider)   # _Allocate resource to non-deployed location_: Marine Operator indicates resource has been put into non-deployed location (like site, but
                                                                                                                                                                                         is registered in ION, and the aggregated configuration            without marine connotation).
                                                                                                                                                                                         ("deployment") associates all relevant "nested" components        # _View non-deployed location_: User views location of resource, seeing the name of the location, other location information (GPS and/or
                                                                                                                                                                                         into a single defined configuration (e.g., Glider 247). Data      street address), and that it is a non-marine location.
                                                                                                                                                                                         and metadata are associated to the appopriate marine              # _Obtain asset location_: Asset tracking system user can see coarse location (deployment, storage, or maintenance site) as updated by
                                                                                                                                                                                         resources.                                                        asset tracking system user, or the Integrated Observatory.
  1.5   Enable plug-and-work instrument installation                  4       Draft             Marine operator installs an         An instrument that has sufficient self-describing                                                                      # _Define on-board instrument metadata_: Manufacturer and/or Marine Operator inserts descriptive metadata on board instrument,                 operator              SA
                                                                                                instrument with little or no pre-   metadata may be installed directly on an OOI                                                                           sufficient for full OOI registration.
                                                                                                registration (self-describing)      system (see Assumptions). With approval of an                                                                          # _Enroll instrument in OOI_: (Optional) Marine Operator registers instrument (by unique identifier only) as an OOI asset, optionally
                                                                                                                                    Operator, the instrument's internal description                                                                        specifying life cycle state.
                                                                                                                                    may be used by the Integrated Observatory to                                                                           # _Install instrument on Observatory system_: Marine Operator or Cyber Operator connects instrument to component of Integrated
                                                                                                                                    fully register the instrument and its                                                                                  Observatory, notifying Integrated Observatory that a component (optionally uniquely identified) has been attached.
                                                                                                                                    characteristics.                                                                                                       # _Establish instrument communications_: Integrated Observatory automatically initiates communication with instrument, ascertaining
                                                                                                                                                                                                                                                           whether on-board metadata are accessible.
                                                                                                                                                                                                                                                           # _Obtain instrument definition_: Assuming on-board metadata are accessible, Integrated Observatory downloads metadata and uses
                                                                                                                                                                                                                                                           them to update any existing instrument description and confirm instrument is recognized as an OOI asset (if not, Marine Operator may be
                                                                                                                                                                                                                                                           queried as to whether this instrument is the approved or desired unit).
                                                                                                                                                                                                                                                           # _Confirm appropriate life cycle state_: Integrated Observatory confirms instrument's life cycle state is consistent with policy (e.g., an
  1.6   Perform advanced instrument management                        4       Draft             Operator performs sophisticated     An operator sets up processes, policies,             * Instruments of this model have conflict with the mission        # _Define sampling strategy_: User sets up instrument to sample every hour with priority medium (only operators can set high priorities),      end user, operator    SA
                                                                                                instrument management               configurations, or mission plans that result in      plan, as indicated in the scenario steps.                         and intervening half-hour intervals with priority low, and activates the sampling schedule.
                                                                                                activities specialized for          complex instrument or platform behaviors, for                                                                          # _Detect mission conflicts_: The mission scheduling process detects an acoustic conflict with an acoustic instrument that samples every
                                                                                                instrument models                   example executing sampling activities in                                                                               half-hour at low priority; issues an event with a corresponding warning; and sends email to the users who set the corresponding
                                                                                                                                    accordance with sampling priorities and                                                                                schedules.
                                                                                                                                    operating constraints (power available, data                                                                           # _View mission conflict warnings on relevant pages_: Operator sees the corresponding warnings on the pages of the affected
                                                                                                                                    volume, etc.).                                                                                                         instruments and platforms, but takes no action due to the issue's low operational priority.
                                                                                                                                                                                                                                                           # _Prioritize missions per priority_: On the hour, the system allocates the sampling priority to the new instrument, because it has a higher
                                                                                                                                                                                                                                                           priority; events are generated accordingly.
                                                                                                                                                                                                                                                           # _Prioritize missions per role_: On the half-hour, the system allocates the sampling priority to the existing acoustic system, because its
                                                                                                                                                                                                                                                           priority was set by an operator, which trumps the equal priority set by the user; events are generated accordingly.
                                                                                                                                                                                                                                                           # _Reschedule sampling time_: The user modifies the new instrument sampling schedule to be 15 minutes past each half-hour,
  1.7   Autonomously control platforms                                3       Draft             User defines mission plans and      The user, or a planning agent on the                 * Definition of platform mission and constraints may be           # _Define platform objective(s)_: Mission Planner describes operational objectives for platform using appropriate platform mission             operator, end user    PP
                                                                                                environmental constraints that      observatory, defines mission objectives and          performed manually, or by higher-level observing mission          language.
                                                                                                provide for automatic platform      constraints for the platform. Embedded software      planners.                                                         # _Define platform mission constraints_: Mission Planner describes characteristics of platform operations that must be satisfied during
                                                                                                navigation and control.             on the platform accepts these definitions, and       * Mission Planner is Marine Operator or Instrument                this mission.
                                                                                                                                    navigates and controls the platform and its          Operator.                                                         # _Define environmental constraints(s)_: Mission Planner describes environmental constraints that must be satisfied.
                                                                                                                                    components to achieve the mission, while                                                                               # _Load and activate platform plans_: Mission Planner loads defined plans and constraints into platform, and activates their operation.
                                                                                                                                    monitoring science and engineering                                                                                     # _Platform executes mission plans_: Platform autonomously acts upon mission plan to achieve objectives while satisfying constraints.
                                                                                                                                    environmental conditions.
Marine Systems: Marine Observatory Operation and Mission Planning
  2.1   Plan and execute observing missions                       4           Draft             User enters, validates,             Create the higher level mission plans that can                                                                         # _Define instrument-environment operational interactions_: Define operational interactions between the instrument and its operating           end user, operator    PP
                                                                                                manages, and activates context-     plan across multiple marine resources. This                                                                            environment, characterizing how environmental conditions (heat, cold, vibration, etc.) can affect the instrument, and how operation of the
                                                                                                aware mission plans, with time      work includes everything to do with Mission                                                                            instrument (without making observations) can affect the environmental regimes (sound, light, chemistry, temperature, etc.) around it.
                                                                                                or event triggers                   Planning except the detailed services needed on                                                                        # _Define instrument-environment observation interactions_: Define observation interactions between the instrument and its operating
                                                                                                                                    board the platforms.                                                                                                   environment, characterizing how environmental conditions (heat, cold, vibration, etc.) can affect the instrument's observations, and how
                                                                                                                                                                                                                                                           making observations with the instrument can affect the environmental regimes (sound, light, chemistry, temperature, etc.) around it.
                                                                                                                                                                                                                                                           # _Define mission plan_: Define a plan for the mission that describes all of the following that apply for each platform/instrument (or suite):
                                                                                                                                                                                                                                                           where to go, what measurements to make, what communications to perform, what environmental features to detect or other conditions to
                                                                                                                                                                                                                                                           optimize, what environmental and/or system events to respond to, and what internal and external conditions to avoid.
                                                                                                                                                                                                                                                           # _Validate mission plan_: User submits plan for validation, in which the Integrated Observatory checks to see whether any aspects of the
                                                                                                                                                                                                                                                           plan can not be executed or introduce conflicts (with other mission plans or observatory policies).
                                                                                                                                                                                                                                                           # _Activate mission plan_: Mission Operator activates the mission plan, optionally awaiting time or event triggers)
                                                                                                                                                                                                                                                           # _Monitor mission plan execution_: User monitors the mission as it executes, seeing updates for each component of the plan at each
  2.2   Manage trouble tickets from Integrated System                 3       Draft             User performs basic Jira trouble Perform basic trouble ticket activities from            * All advanced routing, escalation, disposition, tracking, and    # _View trouble tickets for resource_: User views finds, shares, associated shared resource presently being viewed in the Integrated
                                                                                                                                                                                                                                                           # _Organize mission plans_: User saves, names, trouble tickets and reuses with themission plans.                                               end user              UX
                                                                                                ticket management from within Integrated Observatory. Display tickets relevant           other trouble ticket functionality is provided as Jira            Observatory.
                                                                                                Integrated Observatory           to present context. Fill out contextual information     deployment configurations in Release 2. (The IOs must             # _View filtered trouble tickets for resource_: User views the trouble tickets associated with the given resource being viewed, filtered
                                                                                                                                 in a new ticket that is already known to the            collaborate with the Integrated Observatory operations team       according to principal criteria (Resolution, at least) selected by user.
                                                                                                                                 Observatory. Perform simple modifications to            to define, deploy, and operate the needed functionality.)         # _Autofill new trouble ticket_: User requests new trouble ticket from a particular resource page, and initial ticket is autofilled with the
                                                                                                                                 status of a particular ticket.                          * The functionality will likely be implemented by wrapping        resource identifier, the resource page, the user ID, and any other available background that may prove useful in troubleshooting the ticket.
                                                                                                                                                                                         simple Jira commands/responses for presentation in an             # _Change trouble ticket status_: User can select any trouble ticket presented in Integrated Observatory, and change its status via a form
                                                                                                                                                                                         Integrated Observatory window.                                    presented in the Integrated Observatory (including resolution and comment fields).
                                                                                                                                                                                                                                                           # _Specify addition resource information_: User can specify additional resource identifiers in Jira, which should have additional fields for
                                                                                                                                                                                                                                                           major types of marine resources (instruments, platforms, deployments, sites, others as desirable).
 UC#    Name                                                            UC      UC Status         Summary                              Description                                          Assumptions                                                           Scenario                                                                                                                                      UX Exposure           Subsy
                                                                     Priority                                                                                                                                                                                                                                                                                                                                                         stem
        short as possible while still distinct                        1 << 5    Identified, Draft, one-line summary, appears in        A brief description of the scenario (enough to                                                                                                                                                                                                                           who sees results?
                                                                        (5      Draft+MM, User- many tables                            give its overall flavor, but not all the details).                                                                                                                                                                                                                       end user, operator,
                                                                     highest)   Prioritized, LCO,                                                                                                                                                                                                                                                                                                               app, gui, internal
  2.3   Use checklists in observatory operations                        5       Draft              User creates a checklist            Provide capability to create checklist templates,    * It will be particularly nice to support linking of checklists and   # _Create checklist template_: Registered User creates a list of items that can be checked off, and registers it in the system.               operator, end user    OS/UX
                                                                                                   template, which other users         instantiate individual checklists from the           their items to resource operations activities and workflows,          # _Instantiate checklist_: Registered User finds desired checklist template, and creates an instance of it with a unique name.
                                                                                                   instantiate and complete over       template, check off items within the checklist,      so that system processes may review and change state of               # _Mark items as checked_: Registered User checks off items in the checklist over time; each mark has a timestamp and the user who
                                                                                                   time                                and view the state of items in a checklist and of    checked items.                                                        made it.
                                                                                                                                       the checklist as a whole.                                                                                                  # _View checklist item state_: At any time, other users can find and inspect checklist instances to determine what items have been
                                                                                                                                                                                                                                                                  # _Access checklist item state_: At any time, system processes can view the state of any item of a checklist instance.
  2.4   Run integrated observatory software off-network                 3       Draft             Operator sets up, and user           Provide observatory management capabilities          * Access to Integrated Observatory is required to operate             # _Instantiate off-network system_: Integrated Observatory Operator generates instance of Integrated Observatory software that can run        operator              OS
                                                                                                  operates, observatory software       when disconnected from internet, mirroring           marine physical resources. (If it is possible to communicate          while disconnected from the Internet, using copy of resources in their most current state.
                                                                                                  in off-network sites (e.g., ship-    observatory state to off-line system and             with and operate those resources without having immediate             # _Use off-network system_: Marine Operator, and other local users, use off-network Integrated Observatory to modify system
                                                                                                  board or isolated)                   synchronizing changes when connection                access to the Integrated Observatory, then the need for the           configurations and manage resources, communicating with with marine assets as required.
                                                                                                                                       restored.                                            use case is largely eliminated, though it is potentially useful       # _Reconnect off-network system to network_: Integrated Observatory Operator re-establishes connection from off-network system to
                                                                                                                                                                                            for other reasons.)                                                   network, ensuring previously off-network system does not start directly communicating to networked resources.
                                                                                                                                                                                            * There is likely to be an operational overhead associated            # _Upload off-network changes to network_: Integrated Observatory Operator initiates upload of resource modifications, data, events,
                                                                                                                                                                                            with instantiating and reconciling off-network observatory            current status, and command histories are uploaded to (fully networked) Integrated Observatory.
                                                                                                                                                                                            instances. The overhead level will depend on the                      # _Resolve synchronization conflicts_: When uploaded information is in conflict with information already in the (networked) Integrated
                                                                                                                                                                                            thoroughness of the developed feature, but may be high.               Observatory, system resolves conflicts by policy or by querying Integrated Observatory Operator.
                                                                                                                                                                                                                                                                  # _Update off-network system_: (Optional) Integrated Observatory Operator commands data in the just-networked system be updated
                                                                                                                                                                                                                                                                  from the Integrated Observatory, allowing the remote system to be disconnected and used again as a standalone element of the
                                                                                                                                                                                                                                                                  Integrated Observatory.

Data Systems: Data Acquisition, Curation, and Externalization
  3.1   Obtain real-time high-rate streamed data                        4       Draft             User obtains video, acoustic,   The Integrated Observatory must address all the                                                                                 # _See high-rate stream on product resource page_: User visits the product's resource page, and sees either a miniature version of a live end user                  SA/UX
                                                                                                  seismic, and audio data streams end-to-end concerns to achieve a usable user                                                                                    stream, or a button to play it.
                                                                                                  in near-real time and playback  product. This includes tuning the communication                                                                                 # _Activate playback_: If stream is not being played, user presses play button, seeing video or waveform as appropriate, and hearing
                                                                                                                                  paths as needed, establishing archival solutions,                                                                               audio as appropriate.
                                                                                                                                  and presenting the streams in user-friendly                                                                                     # _Pause playback_: User pauses the playback of the stream, and any images or sounds stop.
                                                                                                                                  formats (video, audio+waveform, waveform, and                                                                                   # _Display buffering_: User sees indication that system is buffering new data (buffer indicator grows as more data are buffered).
                                                                                                                                  audio) in near-real-time and (with selection                                                                                    # _Resume playback_: User resumes playback and sees that the image, sound, and/or chart picks up from where it left off.
                                                                                                                                  capabilities) in playback.                                                                                                      # _Stop playback_: User stops playback, and sees that the display is inert and no buffering is occurring.
                                                                                                                                                                                                                                                                  # _Adjust playback_: After resuming, user adjusts characteristics of the playback: the sound level, signal fidelity, or visualization update
                                                                                                                                                                                                                                                                  # _Monitor stream_: User monitors characteristics of the data stream that indicate their status: frame rates, error rates, volume and signal
                                                                                                                                                                                                                                                                  variance indications.
                                                                                                                                                                                                                                                                  # _Replay past data_: User navigates to or specifies a time before the present, and begins playback from that point.
                                                                                                                                                                                                                                                                  # _Obtain past data_: User uses in-page widget to specify and request range of data to be downloaded, and receives the corresponding
  3.2   Discover and access external data                               4       Draft             User discovers and accesses          Data can be ingested from three different types                                                                            data in the external resources in search_: If not current setting, User requests that resources external to OOI be included in search
                                                                                                                                                                                                                                                                  # _Enable requested format.                                                                                                                     end user            DM
                                                                                                  data which have been ingested        of external sources: sources (or direct upload)                                                                            results.
                                                                                                  into OOI from external sources       as specified by individual users; sources                                                                                  # _(Optional) Disable internal resources in search_: User optionally chooses not to see resources generated by to OOI (so as to focus
                                                                                                  (e.g., from IOOS, Neptune CA         configured for routine ingest by OOI operators;                                                                            exclusively on external resources).
                                                                                                  and WMO)                             and partner organizations with their own data                                                                              # _Discover external data_: User specifies query and sees results from IOOS, NEPTUNE CA, or WMO in the displayed results.
                                                                                                                                       holdings. Users can find out about data from any                                                                           # _Ingest user-specified data_: Registered User specifies external data source, which are ingested by system.
                                                                                                                                       of these sources, and obtain data from the                                                                                 # _Enable external user-specified resources in search_: If not current setting, User requests that resources specified by individual OOI
                                                                                                                                       sources if they are available in the system.                                                                               members be included in search results.
                                                                                                                                                                                                                                                                  # _Discover external user resources_: User specifies query and sees cached results specified by individual contributors in the displayed
                                                                                                                                                                                                                                                                  # _(Optional) Specify data cacheing policy_: Registered User requests, or operator specifies, that specified data are to be cached in
                                                                                                                                                                                                                                                                  system for a period of time.
                                                                                                                                                                                                                                                                  # _Request externally provided data_: User requests data that originate externally; if data are not already cached in the system, data are
                                                                                                                                                                                                                                                                  requested from its source and provided to user.
  3.3   Publish OOI data to external systems                            4       Draft             Data Curator publishes OOI           For each partner system (planned partners            * Each partner organization or national data center has a             # _Define publication specification_: Data Curator operator specification; if no specification is provided, data are not saved in system.
                                                                                                                                                                                                                                                                  # _Cache data_: System caches data according toor developer defines the data to be published, their format including metadata, and the end user                     DM
                                                                                                  data to partner systems and          include NEPTUNE CA, IOOS, WMO, and                   supported data format, which the OOI must support.                    destination, as well as default frequency of publication (by time, data quantity to publish, or manual).
                                                                                                  National Data Centers                national data centers), the system must support                                                                            # _Enable publication to external system_: Data Curator enables the publication, including manually initiating the first publication if
                                                                                                                                       publication of data and metadata in a format                                                                               necessary, and the system publishes data to the partner organization.
                                                                                                                                       consistent with that partner. The data curator                                                                             # _Obtain publication reference_: (Optional) Data Curator or Integrated Observatory receives reference to the published data from the
                                                                                                                                       must specify what data to publish to each                                                                                  partner organization, and associates the reference with the data that have been published.
                                                                                                                                       partner system, and the format, location, and                                                                              # _Review fidelity of partner product_: (Optional) Data Curator views published data to ensure that they reflect OOI holdings.
                                                                                                                                       frequency of publication. Any reference or                                                                                 # _Review product publication status_: User views publication status of a given data product to see which partner organizations have
                                                                                                                                       receipt from the partner system should be                                                                                  received them, and at what times.
                                                                                                                                       associated with the published material in OOI.                                                                             # _Review collected partner publication_: User finds all data products published in a particular publication event, or to a particular partner.
                                                                                                                                       Users can then view each data product's
                                                                                                                                       publication status at any time.
  3.4   Obtain publishable and trackable immutable data references      4       Draft             User identifies a unique data set    A URL or DOI can be obtained by a user for                                                                                 # _See complete information resource documentation_: User visiting an information resource facepage sees all relevant descriptive          end user                 DM/UX
                                                                                                  or subset, gives them a unique       information resources, including both open-                                                                                information and associations, including a URI that names the resource and will, when entered, navigate to the resource in the Integrated
                                                                                                  publishable identifier, and tracks   ended resources that are still aggregating data,                                                                           Observatory interface ##subject to policy##. (R2)
                                                                                                  access statistics for them.          and resources whose data are constrained by                                                                                # _View observation-constrained information resource_: User specifies constraints on the data in an information resource (e.g., start
                                                                                                                                       their observation time, and/or their time of                                                                               and/or end times that data was observed), and views the data that satisfies the constraint. (R2)
                                                                                                                                       ingestion into the Integrated Observatory. Any                                                                             # _Get URL of observation-constrained information resource_: User requests URL for an observation-constrained information resource,
                                                                                                                                       URL of this sort will resolve to a page displayed                                                                          and receives URL that, when entered, navigates to the resource and shows the data with observation constraints applied.
                                                                                                                                       by the Integrated Observatory that shows the                                                                               # _Review description of observation-constrained information resource_: As part of a download or exported description, user obtains a
                                                                                                                                       resource and its constraints. If a DOI is                                                                                  description of an observation-constrained information resource that characterizes its geospatiotemporal range and other metadata.
                                                                                                                                       requested, the corresponding URL is generated                                                                              # _View ingestion-constrained information resource_: User specifies constraints on the data in an information resource (e.g., start and/or
                                                                                                                                       automatically, and the appropriate metadata are                                                                            end times that data were ingested), and views the data of the resource that satisfy the constraint.
                                                                                                                                       registered with the DOI registrar.                                                                                         # _Get URL of ingestion-constrained information resource_: User requests URL for an ingestion-constrained information resource, and
                                                                                                                                                                                                                                                                  receives URL that, when entered, navigates to the resource page and shows the data with ingestion constraints applied.
                                                                                                                                                                                                                                                                  # _Download dereferenced information resource_: From the resulting display page, a user immediately requests data corresponding to the
                                                                                                                                                                                                                                                                  dereferenced information resource.
                                                                                                                                                                                                                                                                  # _Review description of ingestion-constrained information resource_: As part of a download or exported description, user obtains a
                                                                                                                                                                                                                                                                  description of an ingestion-constrained information resource that characterizes their geospatiotemporal range and other metadata.
                                                                                                                                                                                                                                                                  # _Get DOI for any information resource_: User requests and receives a Digital Object Identifier (DOI) corresponding to any of the
                                                                                                                                                                                                                                                                  information resources above, and registered with the same metadata as the information resources, plus the URL for that resource.
                                                                                                                                                                                                                                                                  # _Get accession statistics_: View a display or report of accession statistics for a URL corresponding to any OOI resource, including any
                                                                                                                                                                                                                                                                  of the information resource URLs above.
                                                                                                                                                                                                                                                                  # _Get accession events_: View a display or report of accession events for a URL corresponding to any OOI resource, including any of
                                                                                                                                                                                                                                                                  the information resource URLs above.

  3.5   Query and group resources                                       3       Draft             User refines queries based on        Perform advanced and multi-stage searches,                                                                                 # _Group query results_: User indicates (with query) what parameter should be used to group the results, and receives grouped results.      end user                DM
                                                                                                  context or constraints, and          including deployment-related and semantic                                                                                  # _Iterate on query_: Given existing query (possibly already executed) or collection, add constraints that further limit the result set.
                                                                                                  groups responses according to        searches. Work with the semantic resources                                                                                 # _Find resources from deployment_: User searches for, and receives list of, data or resources related to a cruise, dive, or mission, using
                                                                                                  selected attributes                  required to support semantic searches.                                                                                     either the org-specified or Integrated Observatory-generated unique identifier.
                                                                                                                                                                                                                                                                  # _Find resources by meaning_: User searches for resources using terms from a controlled vocabulary, and obtains appropriate results
                                                                                                                                                                                                                                                                  that include resources without those explicit terms.
                                                                                                                                                                                                                                                                  # _View OOI semantic resources_: User views information about any term used to specify search filters, or any term's embedding
                                                                                                                                                                                                                                                                  # _Add or change term in OOI vocabulary_: User with proper authority adds or changes a term in an existing OOI vocabulary.
                                                                                                                                                                                                                                                                  # _Propose term addition or change_: User with insufficient authority proposes a term for a vocabulary used by OOI, resulting in
                                                                                                                                                                                                                                                                  notification to appropriate OOI operator.
                                                                                                                                                                                                                                                                  # _Propose new-to-OOI vocabulary_: User proposes a new or existing vocabulary for use in OOI.
                                                                                                                                                                                                                                                                  # _Manage OOI semantic resources_: Observatory Operator adds OOI vocabulary, adds an OOI reference to external vocabulary,
                                                                                                                                                                                                                                                                  synchronizes OOI-related vocabulary with external reference, or updates metadata for an OOI vocabulary.
 UC#    Name                                               UC      UC Status         Summary                             Description                                           Assumptions                                                    Scenario                                                                                                                                     UX Exposure           Subsy
                                                        Priority                                                                                                                                                                                                                                                                                                                                                 stem
        short as possible while still distinct           1 << 5    Identified, Draft, one-line summary, appears in       A brief description of the scenario (enough to                                                                                                                                                                                                                    who sees results?
                                                           (5      Draft+MM, User- many tables                           give its overall flavor, but not all the details).                                                                                                                                                                                                                end user, operator,
                                                        highest)   Prioritized, LCO,                                                                                                                                                                                                                                                                                                       app, gui, internal
  3.6   Obtain enhanced observation time and position      3       Draft              User obtains well-characterized    Given one or more observations within a data          * The user is interested in time and/or location for some or all # _View observation time_: User obtains the best known observation time for each of the data points (all steps are performed with respect end user               DM/UX
                                                                                      location and time of any           set, the user may obtain precise information          data point(s) of interest in a data set.                         to the data points of interest).
                                                                                      observation                        about the time and location at which the                                                                               # _View observation time source_: User learns how the observation time was obtained (source timestamp, platform timestamp,
                                                                                                                         observation was made. In addition to                                                                                   driver/agent timestamp, driver/agent calculation (deterministic), or driver/agent estimation; and whether post-calibration was applied to
                                                                                                                         time/location values, the source of the values                                                                         improve the timestamp.
                                                                                                                         and the potential error of the values is available.                                                                    # _View observation time error_: User obtains estimated error (the maximum expected differences between the reported value and the
                                                                                                                         Any improvements in time or location obtained                                                                          true value) of the observation time.
                                                                                                                         by post-processing of observations should be                                                                           # _View observation location_: User obtains the best known position (lat, lon, Z) for each of the data points.
                                                                                                                         accessible to the user.                                                                                                # _View observation location source_: User learns how the observation location was obtained (source data, platform data, driver/agent
                                                                                                                                                                                                                                                calculation (deterministic), driver/agent estimation, ION system estimation, or other; and whether post-calibration was applied to improve
                                                                                                                                                                                                                                                the location.
                                                                                                                                                                                                                                                # _View observation location error_: User obtains estimated error (the maximum expected differences between the reported value and the
  3.7   Perform end-to-end data curation                   2       Draft             Data Curator performs               The Data Curator, Observatory Manager, and            * Data access holds are expressed as the period of time data # _Implement the observation location. Curator evaluates request from user or operator for data access hold, including OOI policy
                                                                                                                                                                                                                                                true value) of data access hold_: Data                                                                                                      operator             DM/UX
                                                                                     advanced data management            User roles leverage services that simplify            remain unavailable after they are collected.                     concerns, and approves or denies the request (approval puts the terms of the hold into effect).
                                                                                     operations at scale using policy    management of the OOI data holdings. These            * Resource removal is a planned process only for very large # _Define data access hold policy_: Data Curator defines a custom policy for effecting a data access hold, for example allowing access by
                                                                                     and automation                      include management of data holds, data                resources, or resources that by policy will only be persisted    a certain class of users.
                                                                                                                         persistence, data deletion, and data accession.       for a period of time. By policy, data originated by OOI are      # _Receive data hold event notification_: Data Curator defines events and alerts related to data holds, including an event indicating
                                                                                                                                                                               maintained permanently, except for unmanageably large            upcoming data hold expiration, and an event when expiration occurs.
                                                                                                                                                                               resources like HD video. There may be occasions when             # _Review accesses to held data_: Data Curator inspects the accession list for data that are under a data hold, learning who accessed the
                                                                                                                                                                               system or operator errors cause the creation of information      data and when.
                                                                                                                                                                               resources which are entirely spurious, and these may be          # _Review data access statistics_: User views summary statistics (over various time ranges, optionally sorted by quantity) for accesses to
                                                                                                                                                                               permanently removed with the approval of the Observatory         information resources, including number of active subscriptions, dormant subscriptions, views, full and partial downloads, and export
                                                                                                                                                                               Manager and Data Curator.                                        events to partner institutions or National Data Centers.
                                                                                                                                                                                                                                                # _Review data access logs_: Observatory Operator views access logs for information resources, including subscription requests, full and
                                                                                                                                                                                                                                                partial downloads, and export events to partner institutions or National Data Centers.
                                                                                                                                                                                                                                                # _Define resource persistence policy_: Data Curator defines policy for persisting an individual resource or resource group, indicating
                                                                                                                                                                                                                                                whether and for how long the resource should be persisted, under what circumstances, and what deletion process to follow when the
                                                                                                                                                                                                                                                persistence period expires.
                                                                                                                                                                                                                                                # _Fully delete information resource_: Data Curator initiates deletion of an information resource, to remove the actual resource content
                                                                                                                                                                                                                                                (and optionally metadata) entirely from the system.
                                                                                                                                                                                                                                                # _Approve information resource deletion_: Observatory Manager approves deletion of the information resource specified by the Data
                                                                                                                                                                                                                                                Curator, and the system removes the resource and, if appropriate, its metadata.
                                                                                                                                                                                                                                                # _Define routine information resource deletion_: Data Curator defines a routine deletion activity for an information resource (e.g., video
                                                                                                                                                                                                                                                after 6 months, or personal data of past members after 2 years), subject to defined constraints or validations, and including timed early
                                                                                                                                                                                                                                                notification events.
Data Systems: Data Processing and Visualization
  4.1   Obtain real-time and reprocessed products          5       Draft             User obtains calibrated and         Specify calibration or quality control                                                                         # _Define automatic data calibration process_: Data Operator defines a data calibration procedure that is applied when new uncalibrated end user                         SA/UX
                                                                                     quality controlled data products,   transformations and apply them to both newly                                                                   data ##uncalibrated means raw?## arrive, or when a new calibration is obtained for the relevant instrument.
                                                                                     in real time or (as versions)       obtained data, and to data that have been                                                                      # _Calibrate instrument or sensor_: Marine Operator (or automated system process) executes calibration procedure for an instrument or
                                                                                     after later reprocessing.           previously processed. Manage changes to the                                                                    sensor; system obtains, tags, and stores calibration results.
                                                                                                                         specified transformations. Handle data product                                                                 # _Obtain calibrated data from past calibration_: When new data arrive, system automatically applies the most recent available calibration
                                                                                                                         versions, where one product deprecates its                                                                     for the observing instrument, and user sees the results.
                                                                                                                         conceptually identical predecessor, or two                                                                     # _Create recalibrated data_: When a new calibration is available, system automatically reanalyzes all data starting from the previous
                                                                                                                         conceptually identical products exist as branch                                                                calibration, assuming an estimated drift from the previous calibration results to the new calibration results (any existing data taken after
                                                                                                                         versions. Perform quality control interactively.                                                               the new calibration was made is also reprocessed, up to any later calibration). ##dangerous to use this blindly. The resource provider
                                                                                                                                                                                                                                        ought to specify how the drift is assumed to occur, or if it is##
                                                                                                                                                                                                                                        # _Receive product deprecation notification_: When a newly calibrated product version is created, subscribed user is notified of the
                                                                                                                                                                                                                                        deprecation of the previous version.
                                                                                                                                                                                                                                        # _View recalibrated data as new version_: User requesting calibrated data product sees the latest recalibrated results, identified as a new
                                                                                                                                                                                                                                        version of the product.
                                                                                                                                                                                                                                        # _View calibration event and effect_: User views previous and new calibrated data product version, optionally viewing flags marking
                                                                                                                                                                                                                                        calibration event(s).
                                                                                                                                                                                                                                        # _Modify data transformation_: User redefines a transformation, creating a new version of a data process and deprecating the previous
                                                                                                                                                                                                                                        # _Create data transformation branch_: User redefines a transformation but specifies this is a parallel branch, thereby creating a new
                                                                                                                                                                                                                                        version but without deprecating the previous version of the data product.
                                                                                                                                                                                                                                        # _Process data with new transformation_: System issues event for transformation redefinition, to which users of the transformed data
                                                                                                                                                                                                                                        are automatically subscribed, and produces the resulting transformed data as a new product version.
                                                                                                                                                                                                                                        # _Reprocess data with new transformation_: Data Operator applies new data processes to historic data, producing new or updated (new
                                                                                                                                                                                                                                        version) data products.
                                                                                                                                                                                                                                        # _Automatically fulfill processing chain_: System automatically recomputes, or obtains from the persistent store, predecessor products
                                                                                                                                                                                                                                        as needed to satisfy processing chain.
                                                                                                                                                                                                                                        # _View all data calibration or quality control processes_: User views processes for data calibration or quality control as a collection.
                                                                                                                                                                                                                                        # _Define interactive quality control_: Data Operator defines an interactive quality control process that is applied when new data arrive,
                                                                                                                                                                                                                                        and prompts user when review is needed.
  4.2   Manage data processes and associated metadata      5       Draft             Operators and users manage      When a user views data and reviews their         * A process exists and already provides metadata for the data # _Change process and product metadata_: Registered User modifies an existing data process to use best input data that are abnormal
                                                                                                                                                                                                                                        # _Perform interactive quality control_: User performs interactive quality control, flagging points or sequences of value (e.g., for pressure) end user, operator        SA/UX
                                                                                     data process execution and      provenance, the user must have access to         product it creates.                                               instead of a particular input value, and changes the description that the process defines for the resulting data product to read "based on
                                                                                     parameterization, and metadata information about processing changes that could                                                                     best available value for pressure".
                                                                                     production for data and         affect the data values. These changes may be                                                                       # _Update provenance metadata_: System updates appropriate attributes for the data product, to specify the latest version of the data
                                                                                     samples.                        captured as part of (for example) metadata                                                                         process, change the description of the data product, and add a timestamped line to its "provenance log" reflecting the changes to the
                                                                                                                     descriptions, transform descriptions,instrument                                                                    source calculation and the product description.
                                                                                                                     configuration, or instrument replacement; and                                                                      # _View updated metadata_: In the user's next access to the data product, the version of the source process has changed, the product
                                                                                                                     may be about the immediately preceding                                                                             description is different, and if the product is downloaded, the downloaded file includes a provenance log that reflects the date and nature
                                                                                                                     process, or a process several steps earlier. The                                                                   of the changes.
                                                                                                                     system must equally provide access to the                                                                          # _View provenance changes_: User views events that may affect the product (a source instrument reconfiguration, change in instrument
                                                                                                                     metadata for data and for samples; in the case                                                                     model of a source instrument, modification of a parameter used by the calculation, or update of the calculation process itself) as part of a
                                                                                                                     of samples, the user must be able to see                                                                           (optionally recursive) provenance log, or as flags in a visualization of the product's data.
                                                                                                                     information about each sample in its own                                                                           # _Modify product metadata_: Data curator determines that product metadata are incomplete, modifying one of the metadata fields to
                                                                                                                     context.                                                                                                           conform to ISO 19115 standards.
                                                                                                                                                                                                                                        # _Characterize OOI sample_: Sample collection system, process, or user registers new physical sample with OOI, specifying available
                                                                                                                                                                                                                                        and appropriate metadata (include project and ISGN ##pls define acronym## sample identifiers) as available.
                                                                                                                                                                                                                                        # _Obtain OOI sample identifiers_: On registration of new physical sample, OOI generates unique identifier(s) for sample per marine
                                                                                                                                                                                                                                        observatory, OOI, and ISGN unique identifier processes.
                                                                                                                                                                                                                                        # _Characterize OOI sample analysis_: Sample analysis system, process, or user registers new analysis of a physical sample with OOI,
                                                                                                                                                                                                                                        providing a unique sample identifier as a tracking key; the integrated observatory stores the analysis as an attachment to the sample
                                                                                                                                                                                                                                        ##information resource (not the actual sample!)## to which it applies.
                                                                                                                                                                                                                                        # _View OOI samples and analyses_: User obtains a list of OOI samples or sample analyses meeting certain criteria, viewing any
                                                                                                                                                                                                                                        relations between sample, between analyses, and between samples and the analyses.
  4.3   Visualize any data stream(s)                       5       Draft             User sees a real-time,          Provide flexible and dynamic control of charting * All charts are updated in real time as source streams are       # _View OOI sample information_: View all User saves a chartan OOI sample making the context (e.g., on a facepage for that sample).
                                                                                                                                                                                                                                          _Save a chart configuration_: Registered information about configuration, in a single settings reusable.                                     end user                  AS
                                                                                     customized visualization of any options for visualizing real-time data from any  updated.                                                          # _Share a chart configuration_: Registered User shares a chart configuration, making the chart usable by others and on customized or
                                                                                     parameters from any data        stream.                                          * The exact list of desired chart features, and their priorities, general web pages.
                                                                                     stream                                                                           is likely to be updated based on user feedback.                   # _Reuse a chart configuration_: Registered User selects a chart configuration to use on a one-time basis, or on a personal or system
                                                                                                                                                                      * Options may be mixed and matched on a single chart,             web page, optionally modifying the default inputs in the original.
                                                                                                                                                                      where feasible.                                                   # _Plot multi-parameter chart_: User configures chart to plot multiple parameters, optionally including axes for each parameter.
                                                                                                                                                                                                                                        # _Plot real-time chart with history_: User configures real-time chart to include historical information.
                                                                                                                                                                                                                                        # _Plot parameter-parameter chart_: User configures chart to plot points at X, Y locations corresponding to values for 2 parameters,
                                                                                                                                                                                                                                        optionally using color of point for a third parameter.
                                                                                                                                                                                                                                        # _Plot parameter from any data stream_: User configures chart to plot any parameter(s) from any data stream, using unique name for
                                                                                                                                                                                                                                        each parameter in its data stream.
                                                                                                                                                                                                                                        # _Plot 2D and 3D visualizations_: User configures chart to show parameters as colors or vectors in 2D grid, optionally with map
                                                                                                                                                                                                                                        boundaries in background.
                                                                                                                                                                                                                                        # _Plot shaded color map_: User configures chart to show points as colors blended together to form fully shaded surface.
                                                                                                                                                                                                                                        # _View time series values vs norm_: User views graph of parameter values plotted against year-over-year or day-over-day averaged
 UC#     Name                                                      UC      UC Status         Summary                            Description                                          Assumptions                                                       Scenario                                                                                                                                       UX Exposure            Subsy
                                                                Priority                                                                                                                                                                                                                                                                                                                                                     stem
         short as possible while still distinct                  1 << 5    Identified, Draft, one-line summary, appears in      A brief description of the scenario (enough to                                                                                                                                                                                                                        who sees results?
                                                                   (5      Draft+MM, User- many tables                          give its overall flavor, but not all the details).                                                                                                                                                                                                                    end user, operator,
                                                                highest)   Prioritized, LCO,                                                                                                                                                                                                                                                                                                          app, gui, internal
  4.4    Access long-term time series                             4*       Draft              User accesses an ongoing data     Accommodate minor changes in instrument              * All time series are automatically maintained by the system  # _View time series spanning instrument models and instances_: User views data product derived from a series of 2 or more instrument end user                             AS
                                                                                              product that bridges equipment    model, instrument class, measurement                 (not built manually by aggregating data).                     models and/or instances.
                                                                                              and process changes over time     technique, or processing technique, when                                                                           # _View time series spanning processing algorithms_: User views data product derived from a series of contemporaneous "standard
                                                                                                                                                                                     * Capabilities may be needed at any time, but will certainly be
                                                                                                                                creating a core data product.                        necessary after a few years of operations.                    calculations" (where the standard calculation technique has changed, but insufficient supporting data exist to go back and recalculate the
                                                                                                                                                                                                                                                   older data).
                                                                                                                                                                                                                                                   # _View time series spanning measurement technique_: User views data product derived from more than one measurement technique
                                                                                                                                                                                                                                                   (implying different instrument types and measurement strategies).
                                                                                                                                                                                                                                                   # _View significant events in long time series_: User views long time series data and can see (visually or via event list) significant events
  4.5    Share and reuse user workflows, tools, and functions      3       Draft             User develops, shares, finds,     User-developed workflows in the system are          * User has developed a workflow in the usual way; it is visible during the time series (instrument replacement, instrument model replacement, algorithm replacement, failurevisualization workflow, as
                                                                                                                                                                                                                                                   # _Explicitly share developed resource_: Registered User marks their developed OOI resource, for example a events, environmental               end user                   AS
                                                                                             and uses workflows, tools, and registered by default and their metadata are           to other users but not explicitly reusable or copyable.         shared, making it directly reusable and copyable by other users.
                                                                                             services for scientific           visible to others. To see the details of and reuse * A third-party developer has developed an application usable # _Find and request unshared resource_: Registered User finds developed resource of another user that is not shared, therefore not fully
                                                                                             visualization and analysis in the those workflows, the author must either share       by the Integrated Observatory, and an OOI developer or          visible or reusable; requests permission to use it from the owner (if granted, user may treat that resource as a shared resource).
                                                                                             Integrated Observatory            them (giving permission to all), or grant specific registered user has determined and documented how it can # _Find and reuse shared workflow_: Registered User discovers a visualization workflow of another user that has been shared, and
                                                                                                                               permission to an individual, at which point they be integrated with OOI workflows.                                  instantiates it against a particular data input to see the resulting visualization.
                                                                                                                               can be used in the same way as any other                                                                            # _Find and use data analysis function_: Registered User discovers and applies system-provided capability to aggregate, align, interpolate,
                                                                                                                               system workflow. External tools require explicit                                                                    filter, decimate, scale, transform, and/or transform coordinate systems of data resources.
                                                                                                                               registration in the system, including definition of                                                                 # _Register visualization or analytic tool_: Developer or Registered User registers external tool for use in OOI, specifying its name, source,
                                                                                                                               appropriate instructions for their integration, in                                                                  and installation and integration instructions as part of the registration.
                                                                                                                               order that others can find information about                                                                        # _Discover visualization or analytic tool_: User searching the Integrated Observatory for compatible tools discovers a tool of interest,
                                                                                                                               them and their use. System functions (services)                                                                     navigates to its installation and integration instructions, and prepares it on a local environment.
                                                                                                                               to process data are available for any to use.                                                                       # _Create workflow using external tool_: Registered user creates a workflow that follows the provided integration instructions for the
                                                                                                                                                                                                                                                   external tool, and sees the workflow interact with the locally installed tool to accomplish the intended scientific processing.
Data Systems: Data Workflows and Model Integration
  5.1   User detects environmental events                          4       Draft             User generates environmental       Users can develop their own analysis routines to     * The generated event types either exist already in the           # _Define event detection transform_: Registered User defines a transformation which analyzes values in one or more data streams, and end user, operator              AS/PP
                                                                                             events based on analysis and       detect environmental events and express them         system, or can be added by the Registered User.                   generates outputs of OOI type 'event' when certain conditions are met.
                                                                                             correlation of data streams        as OOI events, to which other users can              * The necessary event relation predicates either already exist    # _Document event derivation and relation_: For each new event type generated by the transform, Registered User documents its nature
                                                                                                                                subscribe.                                           in OOI, or can be added by OOI operators.                         (e.g., subtype = environmental_event), derivation, and its relation to other events, in the event metadata.
                                                                                                                                                                                     * Typically operators need not be notified of environmental       # _Enable transform in workflow_: Registered User sets up the transform within a workflow in the system, configuring actual input
                                                                                                                                                                                     events, but some events are of significance for the OOI           sources corresponding to the transform's expected inputs, and enables its execution.
                                                                                                                                                                                     systems, or of major scientific interest, and appropriate roles   # _Augment data sent with event type_: Registered User modifies event generation (and description) to add custom information for a
                                                                                                                                                                                     should be notified of those.                                      particular type of event, for example auxiliary error string when certain conditions are met.
                                                                                                                                                                                                                                                       # _Specify recommended event notifications_: For each generated event type that is new to the system, Registered User indicates what
                                                                                                                                                                                                                                                       roles should receive notification by default.
                                                                                                                                                                                                                                                       # _Acknowledge recommended event notifications_: Observatory Operator is notified of recommended event notifications when transform
                                                                                                                                                                                                                                                       is registered, and makes final assessment of default event subscription/notification setups for the relevant system roles.

  5.2    Manage and execute workflows                              5       Draft             User defines (or finds and         Query Integrated Observatory for software            * Some steps may only be available through Integrated             # _Discover existing workflow_: (Optional) Registered User discovers existing workflow to use as a basis for new one.                           end user              AS
                                                                                             extends), registers, validates,    (processes) that can address specific needs.         Observatory, some may only be available working directly          # _Create new workflow_: Registered User defines and registers a new workflow, including the inputs it needs and the outputs it
                                                                                             schedules, and activates a         Define and validate workflow for workflow            with certain workflow engines (e.g., Kepler), and many will       produces.
                                                                                             system or user workflow            engine (e.g., Kepler) in association with the        be available in both environments.                                # _Validate workflow_: Registered User requests that Integrated Observatory evaluate workflow for completeness, executability, and
                                                                                                                                Integrated Observatory. Verify that a workflow is                                                                      consistency, and fixes any errors that are reported.
                                                                                                                                operating properly without creating permanent                                                                          # _Instantiate workflow_: User configures workflow to ingest specific inputs, creating an executable workflow instance.
                                                                                                                                data products or side effects. Step through a                                                                          # _Test workflow_: User requests that the workflow run in test mode, so that the user can see and verify the results without having them
                                                                                                                                workflow interactively via a user interface, and                                                                       become visible to other system users; user may optionally mark workflow as tested when satisfied it is working correctly.
                                                                                                                                trigger them based on OOI events.                                                                                      # _Step through workflow_: User steps through the workflow one operation at a time, examining results at each step.
                                                                                                                                                                                                                                                       # _Schedule workflow_: (Optional) User defines triggers, such as arrival of particular data stream update, or time trigger (interval or
                                                                                                                                                                                                                                                       specific time), that will cause the workflow to execute at the desired times.
                                                                                                                                                                                                                                                       # _Activate workflow_: User enables workflow for execution, so that it will run and produce OOI data when the triggers occur.
  5.3    Integrate numerical models                                4       Draft             User registers and executes        Register models in the Integrated Observatory, * Numerical model exists and produces results in a format               # _Register numerical model_: User marks the numerical model with the observatory, specifying its name, workflow as a whole location
                                                                                                                                                                                                                                                       # _Share workflow_: (Optional) User registers a workflow as shared, making all of its content visible and thecapabilities, operating reusable end user                AS
                                                                                             their numerical model via          for execution on OOI compute resources or user- that can be ingested by Integrated Observatory.                        and frequency, required operating environment, and other metadata relevant for discovery and provenance.
                                                                                             Integrated Observatory             provided resources. Incorporate models as part                                                                         # _Specify model interfaces_: User specifies the interfaces for executing the model (the command to execute, and any necessary
                                                                                                                                of workflows. Trigger model execution based on                                                                         environmental context) and for obtaining and parsing the model's outputs.##this should include specifying any data streams required as
                                                                                                                                OOI events                                                                                                             inputs to the model##
                                                                                                                                                                                                                                                       # _Specify desired model execution environment_: User requests OOI compute resource environment, or indicates local execution
                                                                                                                                                                                                                                                       environment, where resource is to be executed.
                                                                                                                                                                                                                                                       # _Specify cost recovery process_: If OOI compute resource environment is used, Registered User specifies mechanism (credit card,
                                                                                                                                                                                                                                                       purchase order, cost account #, ...) by which resource costs will be billed and paid.
                                                                                                                                                                                                                                                       # _Specify model execution trigger_: User specifies how model is to be triggered: by OOI or locally triggered, via arrival of external data, or
                                                                                                                                                                                                                                                       by time.
                                                                                                                                                                                                                                                       # _Validate model integration_: Registered User requests that Integrated Observatory evaluate numerical model integration for validity,
Observatory Systems: Organizations and Commitments                                                                                                                                                                                                     and addresses any errors that are reported. ##not clear how CI could do this without a behavior model for the numerical model##
  6.1   Create virtual observatory, laboratory, or classroom       3       Draft             User creates a virtual             Create a virtual workspace tuned to observing        * Templates exist for each collaborative type of virtual          # _Define virtual workspace_: Registered User requests a virtual workspace, defining its name, collaboration type, and parent Org               end user, operator    AS
                                                                                             workspace targeting a shared       collaboration, scientific or technical               workspace.                                                        (Integrated or Marine Observatory), and is made the owner/manager of the created workspace.
                                                                                             social network                     collaboration, or educational collaboration.         * Resource types, individual resources, policies, roles, and      # _Define roles for workspace_: Workspace Manager chooses from templated roles, or defines roles based upon the templates, to create
                                                                                                                                Create a community with defined members and          life cycles of the parent organization are available to the       workspace roles.
                                                                                                                                policy, and shared access to events of common        virtual workspace unless specifically kept private.               # _Assign roles to users_: Workspace Manager chooses default role for new users, as well as any additional role(s) for specific users, to
                                                                                                                                interest (similar to social networks). Users add     * In Release 3, the parent organization is either the             be included as part of invitation to join.
                                                                                                                                and control their own or shared resources.           Integrated Observatory itself (which shares access to, but        # _Add people to workspace_: Workspace Manager accepts requests to join, issues invitations to join, and processes invitation approvals
                                                                                                                                                                                     does not own, marine resources), or a specific Marine             to add members to the workspace.
                                                                                                                                                                                     Observatory.                                                      # _Define policies for workspace_: Workspace Manager chooses from templated policies, optionally defining additional policies, to apply
                                                                                                                                                                                     * Permission to add resources from external users or              within the org.
                                                                                                                                                                                     communities is granted automatically through application of       # _Define initial workspace resources_: Workspace Manager populates initial resources in workspace with any of the following: all shared
                                                                                                                                                                                     policy, or through negotiation by explicit agreement.             resources in a collaborating org; specific shared resources in collaborating Orgs (see UC.R3.62); or new resources owned by the
                                                                                                                                                                                                                                                       # _Define additional workspace resources_: Registered Users of workspace add resources (their own or, with permission, those of
                                                                                                                                                                                                                                                       collaborating Orgs and individuals).
                                                                                                                                                                                                                                                       # _Define new resource type_: Workspace Manager defines a new resource type with its own resource life cycle and policies.
  6.2    Collaborate with other communities                        2       Draft             User (representing a               Find resources in other organizations and get                                                                          # _Define new events and event Registered User searches for defines new events,(by community description) with shared interest or
                                                                                                                                                                                                                                                          _Find community of interest_: types_: Workspace Manager other communities and if necessary new event types, unique to this                   end user, operator,   COI/A
                                                                                             community, or Org) finds and       permission to use them. Electronically agree on                                                                        potential value.                                                                                                                                internal              S
                                                                                             interacts with other               and track protocols, commitments, and topics                                                                           # _Find external resources of interest_: Registered User searches for useful resources in other communities.
                                                                                             communities, such as virtual       between two organizations. Delegate authorities.                                                                       # _Obtain access to external resource_: Registered User requests access to selected resource(s) from external community, is granted
                                                                                             observatories, to achieve shared                                                                                                                          access (as member of own community), and uses the resource.
                                                                                             goals.                                                                                                                                                    # _Obtain access to community's resources_: Workspace Manager requests access to all resources from external community, is granted
                                                                                                                                                                                                                                                       access on behalf of all members, who then use the resource.
                                                                                                                                                                                                                                                       # _Define mutual protocol_: Manager defines interaction protocol, which org proposes on Manager's behalf (directly, or if so configured,
                                                                                                                                                                                                                                                       autonomously) to another Org or member community, possibly leading to mutual negotation of agreed interaction protocol.
                                                                                                                                                                                                                                                       # _Define mutual commitment_: Manager defines commitment(s), which org proposes on Manager's behalf (directly, or if so configured,
                                                                                                                                                                                                                                                       autonomously) to another Org or member community, possibly leading to mutual negotation of contract containing set of commitments.
                                                                                                                                                                                                                                                       # _Monitor commitment fulfillment_: Registered User views the satisfaction of commitment(s) between two organizations.
                                                                                                                                                                                                                                                       # _Penalize commitment failure_: Upon failure of organization to meet commitment, Org (possibly at direction of Manager) imposes a
                                                                                                                                                                                                                                                       liability, or penalty, per sanction clause(s) of agreed contract.
                                                                                                                                                                                                                                                       # _Authorize external management of local resource_: Based on policy or agreement of local resource manager, Org delegates its
                                                                                                                                                                                                                                                       resources management (implementation of policy) to remote Org.
                                                                                                                                                                                                                                                       # _View management status and policies_: Registered User views the policies affecting management of any resource, and the
                                                                                                                                                                                                                                                       implemented agreements affecting sharing of the resource and delegation of its management.
                                                                                                                                                                                                                                                       # _Negotiate topics_: Manager defines topics (terms defined by their relation to agreed terms, and in human-readable text), which Org
                                                                                                                                                                                                                                                       proposes on Manager's behalf (directly, or if so configured, autonomously) to another Org or member community, possibly leading to
  6.3    Manage computation service-level agreements               3       Draft             User registers, finds,             Specify an agreement about computations              * Initial agreements may be textual; final deliverable targets    mutual negotation of agreed set of topics (i.e., one or more agreed controlled vocabularies).
                                                                                                                                                                                                                                                       # _Register service-level agreement (SLA)_: Registered User/Agent documents an agreement covering the provision of computation                  end user, operator,   CEI
                                                                                             negotiates, and activates          services provided to the OOI; register the           electronic agreements, negotiated as describe in UC.R3.62.        resources (disk space, CPU cycles, services) to the Integrated Observatory.                                                                     internal
                                                                                             agreements about                   agreement; and activate the agreement. Users                                                                           # _Negotiate revision of SLA_: Through subsequent negotiations, Registered User/Agent refines the agreement,and agrees on a new
                                                                                             computational resources.           can find agreements, and qualified users can                                                                           version, which is registered in the Integrated Observatory.
                                                                                                                                view the details and status of them.                                                                                   # _Activate SLA_: Registered User/Agent requests activation of the agreement by the Integrated Observatory, which sets the agreement
                                                                                                                                                                                                                                                       state to activated.
                                                                                                                                                                                                                                                       # _Find service-level agreement_: Any User discovers the existence of a service-level agreement by searching in the Integrated
                                                                                                                                                                                                                                                       Observatory, and sees its description.
                                                                                                                                                                                                                                                       # _View SLA status_: Agreement Owner or Observatory Operator views the status of a given service-level agreement, including its
                                                                                                                                                                                                                                                       operational state (registered, activated in good standing, activated with issues).
 UC#    Name                                                        UC      UC Status         Summary                             Description                                          Assumptions                                                        Scenario                                                                                                                                        UX Exposure           Subsy
                                                                 Priority                                                                                                                                                                                                                                                                                                                                                       stem
        short as possible while still distinct                    1 << 5    Identified, Draft, one-line summary, appears in       A brief description of the scenario (enough to                                                                                                                                                                                                                          who sees results?
                                                                    (5      Draft+MM, User- many tables                           give its overall flavor, but not all the details).                                                                                                                                                                                                                      end user, operator,
                                                                 highest)   Prioritized, LCO,                                                                                                                                                                                                                                                                                                             app, gui, internal
Observatory Systems: Integrated Observatory Network Management
  7.1   Operate highly available system across multiple sites       4       Draft             Operator launches, maintains,       Start and run a system across multiple execution                                                                        # _Launch distributed system_: Integrated Observatory Operator initiates system operations, with process distributed across multiple           operator               COI/U
                                                                                              monitors and upgrades a             sites, including non-OOI sites. Fix problems,                                                                           internal (and possibly externa)l execution sites.                                                                                                                     X
                                                                                              system across multiple              optimize execution resource use, and ensure                                                                             # _View multiple execution sites_: Integrated Observatory Operator sees all execution sites, including their status, load, and satisfaction of
                                                                                              execution sites                     inter-site messaging is optimal.                                                                                        constraints.
                                                                                                                                                                                                                                                          # _Fix execution failures_: Integrated Observatory Operator takes corrective action when executing process, component, or execution site
                                                                                                                                                                                                                                                          fails, bringing replacement execution resources online quickly and with minimal loss of system state.
                                                                                                                                                                                                                                                          # _Optimize resource balancing_: Integrated Observatory Operator ensures executing processes are balanced across execution
                                                                                                                                                                                                                                                          resources, and that loads automatically remain balanced as demands change.
                                                                                                                                                                                                                                                          # _Distribute messages fast to all sites_: Integrated Observatory Operator ensures messages from each execution site are received with
                                                                                                                                                                                                                                                          minimal possible delays at other execution sites, monitoring message latencies and troubleshooting unusual conditions.
  7.2   Execute process on external execution provider              4       Draft             Operator runs integrated            Register external software execution provider,                                                                          # _Register execution provider_: Integrated Observatory Manager registers an external software execution provider (a 'cloud' site that can      operator              CEI
                                                                                              observatory processes on            qualify it against OOI requirements, activate it                                                                        run Integrated Observatory software).
                                                                                              registered external execution       and start using it.                                                                                                     # _Qualify execution provider_: Integrated Observatory Operator verifies that external execution site satisfies OOI requirements,
                                                                                              providers                                                                                                                                                   commitments, and processes, including test service operations on the provider's systems.
                                                                                                                                                                                                                                                          # _Configure execution provider_: Integrated Observatory Operator configures the execution provider for the intended operations.
                                                                                                                                                                                                                                                          # _Activate execution provider_: Integrated Observatory Operator activates the execution site for Integrated Observatory operations.
                                                                                                                                                                                                                                                          # _Allocate executable resources to execution provider_: Integrated Observatory Operator or Observatory System chooses to execute
                                                                                                                                                                                                                                                          services on the execution provider. (See UC.R3.73.)

  7.3   Monitor and control user processes                          3       Draft             User interacts with data            A Registered User can create a process,              * All steps can be performed at any of the distributed OOI         # _Define user process_: Registered User creates a process definition and registers it in the system, associating it with an execution           end user, operator   CEI
                                                                                              processes at any distributed        associate with an execution environment, and         sites (in fact, it should be invisible to the user which site is   engine type.
                                                                                              location                            run it (even scaled to demand), with appropriate     actually the primary).                                             # _Share user process_: (Optional) Registered User marks process definition as shared, making it reusable by other Registered Users.
                                                                                                                                  validation. Operators must monitor the               * Some human OOI validation may be necessary; it will              # _Configure process to scale_: Registered User configures the new process definition so that it can be scaled automatically to meet
                                                                                                                                  processes to ensure they are behaving.               certainly be necessary for processes run on remote                 demand.
                                                                                                                                  Processes can be run on any software execution       platforms.                                                         # _Validate, instantiate, and test user process: Registered User requests that Integrated Observatory evaluate user processes for
                                                                                                                                  provider, at the discretion of the operator.                                                                            completeness, executability, and consistency, and runs it in test mode, so that the user can see and verify the results without having them
                                                                                                                                                                                                                                                          become visible to other system users; user must mark workflow as tested when satisfied it is working correctly.
                                                                                                                                                                                                                                                          # _Activate user process_: Registered User enables user process with a suitable execution engine, so that it is providing services to other
                                                                                                                                                                                                                                                          OOI processes.
  7.4   Allocate and schedule integrated observatory resources      4       Draft             Operator plans, controls, and       Interact with taskable resources using common                                                                           # _Define user processes_: Integrated Observatory Operator sees and monitors user processes (life cycle state and operational status)
                                                                                                                                                                                                                                                          # _Monitorplans for heterogenous resources_: Marine Operator describes operational plan for varied resources using common command operator                            PP
                                                                                              activates taskable resources        control and state protocols. Commands are                                                                               and state language.
                                                                                              autonomously and with user          triggered using common scheduling techniques.                                                                           # _Issue commands to heterogenous resources_: Marine Operator and Cyber Operator issue common commands in sequence to a wide
                                                                                              interaction                                                                                                                                                 range of taskable resource types (e.g., instruments, platforms, and assets, executable processes).
                                                                                                                                                                                                                                                          # _Issue parallel commands to multiple resources_: Marine Operator or Cyber Operator issue common commands simultaneously to a list
                                                                                                                                                                                                                                                          of taskable resources of different types.
                                                                                                                                                                                                                                                          # _Activate heterogenous resources_: Marine Operator and Cyber Operator activate taskable resources of any type.
                                                                                                                                                                                                                                                          # _Schedule command execution for hetergenous resources_: Marine Operator and Cyber Operator define execution triggers that execute
                                                                                                                                                                                                                                                          common commands on multiple taskable resources of any type.
  7.5   Upgrade system resources during operations                  5       Draft             Operator modifies and replaces      Modify metadata and content of information and                                                                          # _Modify resource_: Registered User makes modifications to the resource and submits them, creating a new version of the resource.               end user, internal   COI
                                                                                              resources on the fly, while         taskable resources, keeping track of the                                                                                # _Activate resource_: Registered User makes resource active, making it the primary visible version of the information resource or
                                                                                              Integrated Observatory is           revisions for backward compatibility and                                                                                primary usable service version of the taskable resource.
                                                                                              running                             accountability. Support parallel operation with                                                                         # _Use primary information resource_: User newly viewing the resource sees the modified version, with detailed views referencing the
                                                                                                                                  multiple resource versions. Retire resources that                                                                       previous version as a deprecated or historical; users already viewing the older resource will continue to see that version (until e.g. a
                                                                                                                                  are inactive and no longer current.                                                                                     browser refresh), but may get a warning that a new version exists.
                                                                                                                                                                                                                                                          # _Use primary taskable resource_: Software newly requesting the service accesses the modified version, while the previous version
                                                                                                                                                                                                                                                          completes its active tasks.
                                                                                                                                                                                                                                                          # _View resource in search or list_: User obtaining search results or listing including resource sees its prior version only while it has active
                                                                                                                                                                                                                                                          users, or when explicitly asking to see all versions.
                                                                                                                                                                                                                                                          # _Retire inactive prior versions_: System sets life cycle of prior resource to retired as soon as it is no longer in active use.
  7.6   Use user agents outside the system                          3       Draft             User accesses the system and        Using a local (desktop, laptop, or mobile)                                                                              # _Install OOI agent_: Registered User obtains OOI user agent software and installs it on a local client.                                        end user             COI
                                                                                              its resources computationally       application (user agent), users control or access                                                                       # _Develop and install custom agent_: Registered User develops user agent leveraging OOI libraries to access OOI capabilities, registers
                                                                                              from external locations using       OOI resources. Users can develop a user agent,                                                                          it with OOI, and installs it on a local client.
                                                                                              local 'agents'                      following OOI guidelines, and make it available                                                                         # _Access OOI through user agent_: Registered user authenticates to local user agent, which authenticates user to OOI system and
                                                                                                                                  to other users of the system.                                                                                           makes intended OOI services available.
                                                                                                                                                                                                                                                          # _Use OOI resources through user agent_: Registered User uses OOI resources via the local user agent.
                                                                                                                                                                                                                                                          # _Share custom-developed agent_: Developer of custom user agent designates it as shared, making it available for other users.
                                                                                                                                                                                                                                                          # _Reuse custom-developed agent_: Other users find, download, and use a shared custom-developed agent.
  7.7   Annotate and associate resources                            5       Draft             User attaches a comment,            A user or software component makes                   * In Release 3, the principal way of subsetting a data set is      # _Identify data subset_: Any Registered User identifies a unique resource or data subset of a resource (the _target_).                    end user                   DM/UX
                                                                                              ranking, additional metadata,       statements (free text comments, attachments, or      by time.                                                           # _Choose to annotate_: The Registered User selects the button to annotate that target; if the target is not pre-selected, the user must
                                                                                              cross-reference or similar to any   associations to other resources) about any           * Depending on the system role of the original annotator and       enter its unique identification.
                                                                                              resource, including subsets of      resource, or for information resources, about        the viewer, the statements may or may not be shown by              # _Enter annotation_: The Registered User enters the annotation text for the target in a provided data entry field on the annotation entry
                                                                                              data resources.                     any definable subset of the resource's data. The     default.                                                           window.
                                                                                                                                  statements are visible to other viewers of any                                                                          # _Add attachments and associations_: The Registered User incorporates attachments and associations, either through explicit
                                                                                                                                  part of that resource or definable subset of data.                                                                      references (identifiers for resources and relations) or using tools provided in the annotation entry window.
                                                                                                                                                                                                                                                          # _Specify annotation keywords_: The Registered User optionally specifies keywords for the annotation (both controlled and free-text
                                                                                                                                                                                                                                                          keywords are allowed).
                                                                                                                                                                                                                                                          # _Submit complete annotation_: The Registered User submits the completed annotation; the Integrated Observatory registers it with the
                                                                                                                                                                                                                                                          targeted data.
                                                                                                                                                                                                                                                          # _See relevant annotations_: Any user viewing any part of the annotated unique data subset may see an indication of the annotation,
                                                                                                                                                                                                                                                          according to policy.
                                                                                                                                                                                                                                                          # _View selected annotation_: Any user seeing an annotation indication may choose to view it, either by mousing over it (pop-up view) or
                                                                                                                                                                                                                                                          clicking on it (detailed view).
                                                                                                                                                                                                                                                          # _Customize annotation viewing defaults_: Any Registered User may customize the default settings for viewing annotations, for example
  7.8   Leverage improved observatory usability                     3       Draft             User gets on-line help for          A user can obtain on-line help in many different                                                                        to hide system help_: From any
                                                                                                                                                                                                                                                          # _Visitthem or show more in Integrated Observatory or any help page, User can select a button to view the top-level,          end user                   UX
                                                                                              Observatory and accesses            ways (browsable system help, contextual help                                                                            browsable system help page.
                                                                                              system with mobile devices          regarding the page or page element, user                                                                                # _Browse system help_: From top-level page in help, user can browse to other sections and features of help, including FAQs, search,
                                                                                                                                  manual, searchable help, or pop-up help). User                                                                          and user manual.
                                                                                                                                  interfaces for the system can be effectively                                                                            # _Get page context help_: From any page in Integrated Observatory, User can select a button to view contextual help related to that page
                                                                                                                                  viewed on most mobile devices.                                                                                          type.
                                                                                                                                                                                                                                                          # _Get item contextual help_: From many icons or fields, user can select a button to view contextual help related to that page element.
                                                                                                                                                                                                                                                          # _Get pop-up help_: For most icons or fields, user can hover over the page element to see a brief pop-up explanation.
                                                                                                                                                                                                                                                          # _Access with mobile device_: User with supported mobile device sees an observatory interface optimized for that device (where
UC#   Name                                        UC      UC Status         Summary                         Description                                          Assumptions   Scenario   UX Exposure           Subsy
                                               Priority                                                                                                                                                         stem
      short as possible while still distinct    1 << 5    Identified, Draft, one-line summary, appears in   A brief description of the scenario (enough to                                who sees results?
                                                  (5      Draft+MM, User- many tables                       give its overall flavor, but not all the details).                            end user, operator,
                                               highest)   Prioritized, LCO,                                                                                                               app, gui, internal

To top