package BuildSystemRequirements {
  private import ScalarValues::*;
  private import Requirements::*;
  public import RequirementDerivation::*;
  public import ModelingMetadata::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def IncludeEupsTagInEmail {
    subject;
    doc /* The buildbot system shall include the eups-tag assigned to a build within the status email response. */
    attribute id : String = "REQ-001";
    attribute eups_tag : String;
    attribute email_contains_tag : Boolean;
    stakeholder developer : Developer;
    require constraint TagInclusionCheck { eups_tag != "" implies email_contains_tag == true }
    }

  requirement def UpgradeLsstPackages {
    subject;
    doc /* The system shall upgrade LSST external packages to match the versions tested by HSC. */
    attribute id : String = "REQ-002";
    attribute target_hsc_version : String;
    attribute current_lsst_version : String;
    attribute upgrade_completed : Boolean;
    stakeholder developer : Developer;
    require constraint VersionMatchAfterUpgrade { upgrade_completed == true implies current_lsst_version == target_hsc_version }
    }

  requirement def SaveManifestFile {
    subject;
    doc /* The buildbot CI system shall save the manifest file of failed builds to a well-known location before the next build commences. */
    attribute id : String = "REQ-003";
    attribute manifest_location : String;
    attribute build_failed : Boolean;
    attribute manifest_saved : Boolean;
    attribute next_build_started : Boolean;
    stakeholder developer : Developer;
    require constraint SaveBeforeNextBuild { build_failed == true implies manifest_saved == true }
    require constraint SavedBeforeNext { next_build_started == true implies manifest_saved == true }
    }

  requirement def ProvideManifestLocation {
    subject;
    doc /* The buildbot CI system shall provide the location of the saved manifest file to developers in the failure notification. */
    attribute id : String = "REQ-004";
    attribute manifest_file_location : String;
    attribute failure_notification_sent : Boolean;
    attribute location_included : Boolean;
    stakeholder developer : Developer;
    require constraint LocationInNotification { failure_notification_sent == true implies location_included == true }
    }

  requirement def ExecuteEupsDistribCreate {
    subject;
    doc /* The build system shall execute 'eups distrib create' to build Winter'14 release */
    attribute id : String = "REQ-016";
    attribute eups_command : String = "eups distrib create";
    attribute target_release : String = "Winter'14";
    attribute command_execution_successful : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint EupsCommandExecution { eups_command == "eups distrib create" and target_release == "Winter'14" implies command_execution_successful == true }
    }

  requirement def Winter14StackCompatibility {
    subject;
    doc /* The Winter'14 stack shall build successfully on OS X 10.8 */
    attribute id : String = "REQ-017";
    attribute target_os : String = "OS X 10.8";
    attribute stack_version : String = "Winter'14";
    attribute build_successful : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint StackCompatibilityCheck { target_os == "OS X 10.8" and stack_version == "Winter'14" implies build_successful == true }
    }

  requirement def ReuseBuildIds {
    subject;
    doc /* The lsst-build system shall reuse existing build IDs when a matching manifest is found in versiondb */
    attribute id : String = "REQ-007";
    attribute build_id_reuse_enabled : Boolean;
    attribute manifest_match_found : Boolean;
    attribute existing_build_id : String;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint BuildIdReuse { manifest_match_found == true implies build_id_reuse_enabled == true }
    }

  requirement def CompareManifests {
    subject;
    doc /* The lsst-build system shall compare newly built manifests against stored manifests in versiondb */
    attribute id : String = "REQ-006";
    attribute manifest_comparison_enabled : Boolean;
    attribute versiondb_accessible : Boolean;
    attribute comparison_result : String;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ManifestComparison { versiondb_accessible == true implies manifest_comparison_enabled == true }
    }

  requirement def RelinkAstrometryData {
    subject;
    doc /* The build system shall relink astrometry_net_data datasets to the 8.0.0.0 stack version */
    attribute id : String = "REQ-005";
    attribute target_stack_version : String = "8.0.0.0";
    attribute dataset_name : String = "astrometry_net_data";
    attribute relink_completed : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint AstrometryDataRelink { target_stack_version == "8.0.0.0" and dataset_name == "astrometry_net_data" implies relink_completed == true }
    }

  requirement def ExecuteLsstBuildScripts {
    subject;
    doc /* The build system shall execute lsst-build scripts to create Winter'14 release */
    attribute id : String = "REQ-015";
    attribute release_name : String = "Winter'14";
    attribute script_execution_successful : Boolean;
    attribute build_script_path : String;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint LsstBuildScriptExecution { release_name == "Winter'14" implies script_execution_successful == true }
    }

  requirement def ExecuteUnitTestsOnTarget {
    subject;
    doc /* The build system shall execute unit tests when the tests target is invoked */
    attribute id : String = "REQ-025";
    attribute target_name : String = "tests";
    attribute executes_unit_tests : Boolean = true;
    attribute target_invoked : Boolean;
    stakeholder developer : Developer;
    require constraint TestsExecutedOnTargetInvocation { target_invoked == true implies executes_unit_tests == true }
    }

  requirement def BuildUnitTestsOnTarget {
    subject;
    doc /* The build system shall build unit tests when the tests target is invoked */
    attribute id : String = "REQ-024";
    attribute target_name : String = "tests";
    attribute builds_unit_tests : Boolean = true;
    attribute target_invoked : Boolean;
    stakeholder developer : Developer;
    require constraint TestsBuiltOnTargetInvocation { target_invoked == true implies builds_unit_tests == true }
    }

  requirement def ConfigurableTestBinaryDirectory {
    subject;
    doc /* The build system shall provide a configurable installation directory for unit test binaries */
    attribute id : String = "REQ-023";
    attribute installation_directory : String;
    attribute is_configurable : Boolean = true;
    attribute directory_provided : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ConfigurableDirectoryProvided { is_configurable == true implies directory_provided == true }
    }

  requirement def UseCurrentDirectoryAsDefaultDestination {
    subject;
    doc /* The lsst-build tool shall use the current directory as the default clone destination */
    attribute id : String = "REQ-056";
    attribute default_destination : String = "current_directory";
    attribute uses_current_directory : Boolean;
    stakeholder developer : Developer;
    require constraint CurrentDirectoryDefault { default_destination == "current_directory" implies uses_current_directory == true }
    }

  requirement def RemoveDefaultRepositoryPattern {
    subject;
    doc /* The lsst-build tool shall remove the default REPOSITORY_PATTERN configuration */
    attribute id : String = "REQ-057";
    attribute repository_pattern_removed : Boolean;
    attribute default_pattern_exists : Boolean;
    stakeholder developer : Developer;
    require constraint PatternRemovalRequired { default_pattern_exists == true implies repository_pattern_removed == true }
    }

  requirement def SupportMultipleCameraSystems {
    subject;
    doc /* The LSST Software Stack shall support multiple camera systems beyond the primary LSST camera */
    attribute id : String = "REQ-100";
    attribute supports_multiple_cameras : Boolean;
    attribute beyond_primary_camera : Boolean;
    attribute camera_systems_supported : Integer;
    attribute min_camera_systems : Integer;
    stakeholder user : User;
    require constraint MultipleCameraSupport { supports_multiple_cameras == true and beyond_primary_camera == true and camera_systems_supported >= min_camera_systems }
    }

  requirement def SupportManifestFilenameOption {
    subject;
    doc /* The lsst-build tool shall support a --manifest=<filename> option for writing manifest files */
    attribute id : String = "REQ-060";
    attribute manifest_option_supported : Boolean;
    attribute filename_parameter_accepted : Boolean;
    attribute manifest_file_written : Boolean;
    stakeholder developer : Developer;
    require constraint ManifestOptionSupport { manifest_option_supported == true and filename_parameter_accepted == true implies manifest_file_written == true }
    }

  requirement def RenamePrepareToCLone {
    subject;
    doc /* The lsst-build tool shall rename the 'prepare' command to 'clone' */
    attribute id : String = "REQ-055";
    attribute old_command_name : String = "prepare";
    attribute new_command_name : String = "clone";
    attribute command_renamed : Boolean;
    stakeholder developer : Developer;
    require constraint CommandRenaming { old_command_name == "prepare" and new_command_name == "clone" implies command_renamed == true }
    }

  requirement def ReadConfigFromBtConfigFile {
    subject;
    doc /* The lsst-build tool shall read configuration from .btconfig file within the build directory */
    attribute id : String = "REQ-064";
    attribute config_file_name : String = ".btconfig";
    attribute reads_from_build_directory : Boolean;
    attribute configuration_loaded : Boolean;
    stakeholder developer : Developer;
    require constraint ConfigFileReading { config_file_name == ".btconfig" and reads_from_build_directory == true implies configuration_loaded == true }
    }

  requirement def ProvideHighPerformanceProcessing {
    subject;
    doc /* The LSST Software Stack shall provide high-performance processing capabilities */
    attribute id : String = "REQ-098";
    attribute high_performance_provided : Boolean;
    attribute processing_capabilities_available : Boolean;
    attribute performance_optimized : Boolean;
    stakeholder user : User;
    require constraint HighPerformanceCapabilities { high_performance_provided == true and processing_capabilities_available == true and performance_optimized == true }
    }

  requirement def RenameLsstBuildToBt {
    subject;
    doc /* The lsst-build binary shall be renamed to 'bt' */
    attribute id : String = "REQ-065";
    attribute old_binary_name : String = "lsst-build";
    attribute new_binary_name : String = "bt";
    attribute binary_renamed : Boolean;
    stakeholder developer : Developer;
    require constraint BinaryRenaming { old_binary_name == "lsst-build" and new_binary_name == "bt" implies binary_renamed == true }
    }

  requirement def LimitAstrometrySkyCoverage {
    subject;
    doc /* The astrometry_net_data index creation process shall support limiting sky coverage area to match user image processing requirements */
    attribute id : String = "REQ-043";
    attribute sky_coverage_limited : Boolean;
    attribute coverage_area_configurable : Boolean;
    attribute matches_user_requirements : Boolean;
    stakeholder user : User;
    require constraint SkyCoverageLimiting { sky_coverage_limited == true and coverage_area_configurable == true implies matches_user_requirements == true }
    }

  requirement def UseUsernameAsDefaultTagPrefix {
    subject;
    doc /* The lsst-build tool shall use the current username as the default build tag prefix */
    attribute id : String = "REQ-058";
    attribute uses_username_prefix : Boolean;
    attribute current_username : String;
    attribute tag_prefix_configured : Boolean;
    stakeholder developer : Developer;
    require constraint UsernameAsPrefix { uses_username_prefix == true implies tag_prefix_configured == true }
    }

  requirement def DisableManifestWritingByDefault {
    subject;
    doc /* The lsst-build tool shall not write manifest files by default */
    attribute id : String = "REQ-059";
    attribute writes_manifest_by_default : Boolean = false;
    attribute manifest_writing_disabled : Boolean;
    stakeholder developer : Developer;
    require constraint ManifestWritingDisabled { writes_manifest_by_default == false implies manifest_writing_disabled == true }
    }

  requirement def ImplementStateOfArtAlgorithms {
    subject;
    doc /* The LSST Software Stack shall implement state-of-the-art algorithms for systematic error control */
    attribute id : String = "REQ-097";
    attribute algorithms_state_of_art : Boolean;
    attribute systematic_error_controlled : Boolean;
    attribute error_control_implemented : Boolean;
    stakeholder user : User;
    require constraint StateOfArtImplemented { algorithms_state_of_art == true and systematic_error_controlled == true implies error_control_implemented == true }
    }

  requirement def RefuseChangesOnDirtyRepositories {
    subject;
    doc /* The lsst-build tool shall refuse to change repositories when they contain uncommitted changes */
    attribute id : String = "REQ-061";
    attribute has_uncommitted_changes : Boolean;
    attribute refuses_repository_changes : Boolean;
    attribute dirty_repository_detected : Boolean;
    stakeholder developer : Developer;
    require constraint RefuseChangesOnDirty { has_uncommitted_changes == true implies refuses_repository_changes == true }
    require constraint DirtyRepositoryDetection { has_uncommitted_changes == true implies dirty_repository_detected == true }
    }

  requirement def ScaleFromSingleToThousandsCores {
    subject;
    doc /* The LSST Software Stack shall be scalable from single core to tens of thousands of cores */
    attribute id : String = "REQ-099";
    attribute min_cores : Integer = 1;
    attribute max_cores : Integer = 10000;
    attribute scalable_architecture : Boolean;
    attribute actual_core_count : Integer;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ScalabilityRange { actual_core_count >= min_cores and actual_core_count <= max_cores implies scalable_architecture == true }
    }

  requirement def SupportForceOptionForDirtyRepos {
    subject;
    doc /* The lsst-build tool shall support a --force option to override dirty repository protection */
    attribute id : String = "REQ-062";
    attribute force_option_supported : Boolean;
    attribute overrides_dirty_protection : Boolean;
    attribute force_option_used : Boolean;
    stakeholder developer : Developer;
    require constraint ForceOptionSupported { force_option_supported == true implies overrides_dirty_protection == true }
    require constraint ForceOptionOverride { force_option_used == true implies overrides_dirty_protection == true }
    }

  requirement def ProvideSeparateVersionCommand {
    subject;
    doc /* The lsst-build tool shall provide a separate 'version' command */
    attribute id : String = "REQ-063";
    attribute version_command_exists : Boolean;
    attribute command_is_separate : Boolean;
    attribute version_displayed : Boolean;
    stakeholder developer : Developer;
    require constraint SeparateVersionCommand { version_command_exists == true and command_is_separate == true implies version_displayed == true }
    }

  requirement def ProvideSufficientFunctorKeys {
    subject;
    doc /* The system shall provide sufficient FunctorKeys implementations to support Slots */
    attribute id : String = "REQ-129";
    attribute sufficient_implementations : Boolean;
    attribute slots_supported : Boolean;
    attribute implementation_count : Integer;
    stakeholder developer : Developer;
    require constraint SufficientImplementationsForSlots { sufficient_implementations == true implies slots_supported == true }
    }

  requirement def ConfigureGaussianFluxAlgorithm {
    subject;
    doc /* The measurement system shall configure GaussianFlux algorithm for processCcd testing */
    attribute id : String = "REQ-110";
    attribute algorithm_name : String = "GaussianFlux";
    attribute target_process : String = "processCcd";
    attribute algorithm_configured : Boolean;
    attribute testing_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ConfigurationEnablesTesting { algorithm_configured == true implies testing_enabled == true }
    }

  requirement def MakeSdssCentroidOperational {
    subject;
    doc /* The measurement system shall make SdssCentroid algorithm fully operational with processCcd */
    attribute id : String = "REQ-119";
    attribute algorithm_name : String = "SdssCentroid";
    attribute target_process : String = "processCcd";
    attribute fully_operational : Boolean;
    attribute integration_complete : Boolean;
    stakeholder developer : Developer;
    require constraint OperationalRequiresIntegration { fully_operational == true implies integration_complete == true }
    }

  requirement def ImplementBasicFunctorKeys {
    subject;
    doc /* The system shall implement basic FunctorKeys mechanism */
    attribute id : String = "REQ-128";
    attribute functorkeys_implemented : Boolean;
    attribute basic_functionality_complete : Boolean;
    attribute mechanism_operational : Boolean;
    stakeholder developer : Developer;
    require constraint BasicFunctorKeysComplete { functorkeys_implemented == true and basic_functionality_complete == true implies mechanism_operational == true }
    }

  requirement def ImplementPythonExceptionHandling {
    subject;
    doc /* The measurement system shall implement exception handling for Python algorithms */
    attribute id : String = "REQ-105";
    attribute target_language : String = "Python";
    attribute exception_handling_implemented : Boolean;
    attribute algorithms_covered : Integer;
    stakeholder developer : Developer;
    require constraint PythonExceptionHandling { target_language == "Python" and exception_handling_implemented == true implies algorithms_covered > 0 }
    }

  requirement def ConfigureNaiveFluxAlgorithm {
    subject;
    doc /* The measurement system shall configure NaiveFlux algorithm for processCcd testing */
    attribute id : String = "REQ-111";
    attribute algorithm_name : String = "NaiveFlux";
    attribute target_process : String = "processCcd";
    attribute algorithm_configured : Boolean;
    attribute testing_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint NaiveFluxConfigurationEnablesTesting { algorithm_configured == true implies testing_enabled == true }
    }

  requirement def ImplementPixelsFlagsAlgorithm {
    subject;
    doc /* The measurement system shall implement PixelsFlags algorithm in C++ */
    attribute id : String = "REQ-102";
    attribute algorithm_name : String = "PixelsFlags";
    attribute implementation_language : String = "C++";
    attribute algorithm_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint PixelsFlagsImplementation { algorithm_name == "PixelsFlags" and implementation_language == "C++" implies algorithm_implemented == true }
    }

  requirement def MoveCallPluginFunctions {
    subject;
    doc /* The system shall move callPlugin free functions into common base class */
    attribute id : String = "REQ-144";
    attribute functions_moved : Boolean;
    attribute common_base_updated : Boolean;
    attribute free_functions_eliminated : Boolean;
    stakeholder developer : Developer;
    require constraint CallPluginRefactoring { functions_moved == true and common_base_updated == true implies free_functions_eliminated == true }
    }

  requirement def RespondToConfigurationOptions {
    subject;
    doc /* The measurement algorithms shall respond to major configuration options */
    attribute id : String = "REQ-122";
    attribute configuration_responsive : Boolean;
    attribute major_options_supported : Integer;
    attribute algorithms_affected : Integer;
    stakeholder developer : Developer;
    require constraint ConfigurationResponsiveness { configuration_responsive == true implies major_options_supported > 0 and algorithms_affected > 0 }
    }

  requirement def ImplementSingleValueGetters {
    subject;
    doc /* The SourceRecord shall implement single value getters (getX, getY, etc) using correct keys */
    attribute id : String = "REQ-126";
    attribute single_value_getters_implemented : Boolean;
    attribute getx_implemented : Boolean;
    attribute gety_implemented : Boolean;
    attribute correct_keys_used : Boolean;
    stakeholder developer : Developer;
    require constraint SingleValueGettersWithCorrectKeys { single_value_getters_implemented == true and getx_implemented == true and gety_implemented == true implies correct_keys_used == true }
    }

  requirement def ImplementSourceRecordGetters {
    subject;
    doc /* The SourceRecord shall implement get(Centroid, Flux, Shape) using correct keys */
    attribute id : String = "REQ-125";
    attribute centroid_getter_implemented : Boolean;
    attribute flux_getter_implemented : Boolean;
    attribute shape_getter_implemented : Boolean;
    attribute correct_keys_used : Boolean;
    stakeholder developer : Developer;
    require constraint SourceRecordGettersWithCorrectKeys { centroid_getter_implemented == true and flux_getter_implemented == true and shape_getter_implemented == true implies correct_keys_used == true }
    }

  requirement def SeparateForcedPhotometryTask {
    subject;
    doc /* The system shall separate forced photometry CmdLineTask from Measurement task */
    attribute id : String = "REQ-142";
    attribute tasks_separated : Boolean;
    attribute forced_photometry_isolated : Boolean;
    attribute measurement_task_independent : Boolean;
    stakeholder developer : Developer;
    require constraint TaskSeparation { tasks_separated == true implies forced_photometry_isolated == true and measurement_task_independent == true }
    }

  requirement def PersistSlotInformationToFits {
    subject;
    doc /* The system shall persist slot information to FITS files correctly based on table version */
    attribute id : String = "REQ-127";
    attribute slot_persistence_implemented : Boolean;
    attribute fits_format_correct : Boolean;
    attribute table_version_based : Boolean;
    stakeholder developer : Developer;
    require constraint SlotPersistenceBasedOnVersion { slot_persistence_implemented == true and table_version_based == true implies fits_format_correct == true }
    }

  requirement def ImplementSkyCoordAlgorithm {
    subject;
    doc /* The measurement system shall implement SkyCoordAlgorithm in Python */
    attribute id : String = "REQ-103";
    attribute algorithm_name : String = "SkyCoordAlgorithm";
    attribute implementation_language : String = "Python";
    attribute algorithm_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint SkyCoordAlgorithmImplementation { algorithm_name == "SkyCoordAlgorithm" and implementation_language == "Python" implies algorithm_implemented == true }
    }

  requirement def CompleteReasonableMeasurements {
    subject;
    doc /* The measurement algorithms shall complete measurements with reasonable results */
    attribute id : String = "REQ-121";
    attribute measurements_completed : Boolean;
    attribute results_reasonable : Boolean;
    attribute algorithm_count : Integer;
    stakeholder developer : Developer;
    require constraint MeasurementCompletionWithReasonableResults { measurements_completed == true implies results_reasonable == true and algorithm_count > 0 }
    }

  requirement def ShareCommonBaseClass {
    subject;
    doc /* The ForcedMeasurementTask shall share common base class with SingleFrameMeasurementTask */
    attribute id : String = "REQ-143";
    attribute common_base_shared : Boolean;
    attribute forced_measurement_derived : Boolean;
    attribute single_frame_derived : Boolean;
    stakeholder developer : Developer;
    require constraint CommonBaseClassSharing { common_base_shared == true implies forced_measurement_derived == true and single_frame_derived == true }
    }

  requirement def UseUnderscoreInFieldNames {
    subject;
    doc /* The system shall use underscore '_' in afw::table field names instead of dot '.' */
    attribute id : String = "REQ-137";
    attribute underscore_used : Boolean;
    attribute dot_replaced : Boolean;
    attribute field_names_updated : Boolean;
    attribute afw_table_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint UnderscoreFieldNaming { underscore_used == true and dot_replaced == true and field_names_updated == true implies afw_table_compliant == true }
    }

  requirement def MakePsfFluxOperational {
    subject;
    doc /* The measurement system shall make PsfFlux algorithm fully operational with processCcd */
    attribute id : String = "REQ-117";
    attribute algorithm_name : String = "PsfFlux";
    attribute target_process : String = "processCcd";
    attribute fully_operational : Boolean;
    attribute integration_complete : Boolean;
    stakeholder developer : Developer;
    require constraint PsfFluxOperationalRequiresIntegration { fully_operational == true implies integration_complete == true }
    }

  requirement def HandleExceptionsThroughFlags {
    subject;
    doc /* The measurement algorithms shall handle defined exceptions correctly through flags */
    attribute id : String = "REQ-123";
    attribute exception_handling_correct : Boolean;
    attribute flags_implemented : Boolean;
    attribute defined_exceptions_count : Integer;
    stakeholder developer : Developer;
    require constraint ExceptionHandlingThroughFlags { exception_handling_correct == true implies flags_implemented == true and defined_exceptions_count > 0 }
    }

  requirement def ImplementPythonFailMethods {
    subject;
    doc /* The measurement system shall implement base fail() methods for Python algorithms */
    attribute id : String = "REQ-106";
    attribute target_language : String = "Python";
    attribute base_fail_methods_implemented : Boolean;
    attribute algorithms_supported : Integer;
    stakeholder developer : Developer;
    require constraint PythonFailMethodsImplementation { target_language == "Python" and base_fail_methods_implemented == true implies algorithms_supported > 0 }
    }

  requirement def ImplementDerivativesBasedOptimizer {
    subject;
    doc /* The meas_multifit system shall implement derivatives-based optimizer */
    attribute id : String = "REQ-148";
    attribute optimizer_implemented : Boolean;
    attribute derivatives_based : Boolean;
    attribute meas_multifit_integrated : Boolean;
    stakeholder developer : Developer;
    require constraint DerivativesOptimizerImplementation { optimizer_implemented == true and derivatives_based == true implies meas_multifit_integrated == true }
    }

  requirement def ImplementProcessForcedCoaddTask {
    subject;
    doc /* The system shall implement ProcessForcedCoaddTask for coadd-level forced photometry */
    attribute id : String = "REQ-147";
    attribute task_implemented : Boolean;
    attribute coadd_level_support : Boolean;
    attribute forced_photometry_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ProcessForcedCoaddTaskImplementation { task_implemented == true and coadd_level_support == true implies forced_photometry_enabled == true }
    }

  requirement def EndDotToUnderscoreMapping {
    subject;
    doc /* The system shall end dot-to-underscore mapping in I/O operations */
    attribute id : String = "REQ-138";
    attribute mapping_ended : Boolean;
    attribute io_operations_updated : Boolean;
    attribute dot_underscore_conversion_disabled : Boolean;
    stakeholder developer : Developer;
    require constraint EndDotUnderscoreMapping { mapping_ended == true and io_operations_updated == true implies dot_underscore_conversion_disabled == true }
    }

  requirement def ProvideSlotKeyAlternative {
    subject;
    doc /* The slot mechanism shall provide alternative to KeyTuple for storing slot keys */
    attribute id : String = "REQ-124";
    attribute alternative_provided : Boolean;
    attribute keytuple_replaced : Boolean;
    attribute slot_keys_stored : Boolean;
    stakeholder developer : Developer;
    require constraint SlotKeyAlternativeProvision { alternative_provided == true and keytuple_replaced == true implies slot_keys_stored == true }
    }

  requirement def ImplementProcessForcedCcdTask {
    subject;
    doc /* The system shall implement ProcessForcedCcdTask for CCD-level forced photometry */
    attribute id : String = "REQ-146";
    attribute task_implemented : Boolean;
    attribute ccd_level_support : Boolean;
    attribute forced_photometry_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint TaskImplementationComplete { task_implemented == true and ccd_level_support == true and forced_photometry_enabled == true }
    }

  requirement def ImplementProcessImageForcedTask {
    subject;
    doc /* The system shall implement ProcessImageForcedTask as base command-line task */
    attribute id : String = "REQ-145";
    attribute task_implemented : Boolean;
    attribute base_cmdline_task : Boolean;
    attribute process_image_forced_operational : Boolean;
    stakeholder developer : Developer;
    require constraint BaseTaskImplementation { task_implemented == true and base_cmdline_task == true and process_image_forced_operational == true }
    }

  requirement def MakeSdssShapeOperational {
    subject;
    doc /* The measurement system shall make SdssShape algorithm fully operational with processCcd */
    attribute id : String = "REQ-118";
    attribute algorithm_name : String = "SdssShape";
    attribute target_process : String = "processCcd";
    attribute fully_operational : Boolean;
    attribute integration_complete : Boolean;
    stakeholder developer : Developer;
    require constraint AlgorithmOperational { integration_complete == true implies fully_operational == true }
    }

  requirement def EnableRoundTripCompatibility {
    subject;
    doc /* The system shall enable round-trip compatibility for meas_base field names */
    attribute id : String = "REQ-141";
    attribute round_trip_enabled : Boolean;
    attribute meas_base_compatible : Boolean;
    attribute field_names_preserved : Boolean;
    stakeholder developer : Developer;
    require constraint RoundTripCompatibility { round_trip_enabled == true and meas_base_compatible == true and field_names_preserved == true }
    }

  requirement def MakeSincFluxOperational {
    subject;
    doc /* The measurement system shall make SincFlux algorithm fully operational with processCcd */
    attribute id : String = "REQ-120";
    attribute algorithm_name : String = "SincFlux";
    attribute target_process : String = "processCcd";
    attribute fully_operational : Boolean;
    attribute integration_complete : Boolean;
    stakeholder developer : Developer;
    require constraint SincFluxOperational { integration_complete == true implies fully_operational == true }
    }

  requirement def ImplementClassificationAlgorithm {
    subject;
    doc /* The measurement system shall implement Classification algorithm in Python */
    attribute id : String = "REQ-104";
    attribute algorithm_name : String = "Classification";
    attribute implementation_language : String = "Python";
    attribute algorithm_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint ClassificationImplemented { algorithm_name == "Classification" and implementation_language == "Python" implies algorithm_implemented == true }
    }

  requirement def SubmitJobsOnIntegrationEvent {
    subject;
    doc /* The replicator shall submit jobs to the processing pool upon receiving startIntegration event */
    attribute id : String = "REQ-151";
    attribute triggerEvent : String = "startIntegration";
    attribute targetPool : String = "processing_pool";
    attribute jobSubmitted : Boolean;
    attribute eventReceived : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint SubmitJobsOnEvent { eventReceived == true implies jobSubmitted == true }
    }

  requirement def ReceiveStartReadoutEvents {
    subject;
    doc /* The replicator jobs shall receive startReadout events when sent by the Base DMCS */
    attribute id : String = "REQ-153";
    attribute eventType : String = "startReadout";
    attribute eventSource : String = "Base_DMCS";
    attribute eventReceived : Boolean;
    attribute eventSentBySource : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint ReceiveWhenSent { eventSentBySource == true implies eventReceived == true }
    }

  requirement def SendStartReadoutEvent {
    subject;
    doc /* The Base DMCS shall send a startReadout event to replicator jobs when readout begins */
    attribute id : String = "REQ-150";
    attribute eventType : String = "startReadout";
    attribute targetRecipients : String = "replicator_jobs";
    attribute eventSent : Boolean;
    attribute readoutActive : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint SendEventOnReadout { readoutActive == true implies eventSent == true }
    }

  requirement def PullDataOnReadoutEvent {
    subject;
    doc /* The replicator jobs shall pull data from the source upon receiving startReadout event */
    attribute id : String = "REQ-154";
    attribute triggerEvent : String = "startReadout";
    attribute dataSource : String = "source";
    attribute dataPulled : Boolean;
    attribute eventReceived : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint PullDataOnEvent { eventReceived == true implies dataPulled == true }
    }

  requirement def SendStartIntegrationEvent {
    subject;
    doc /* The Base DMCS shall send a startIntegration event to registered replicators when integration begins */
    attribute id : String = "REQ-149";
    attribute eventType : String = "startIntegration";
    attribute targetRecipients : String = "registered_replicators";
    attribute eventSent : Boolean;
    attribute integrationActive : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint SendEventOnIntegration { integrationActive == true implies eventSent == true }
    }

  requirement def SubscribeToStartReadoutEvents {
    subject;
    doc /* The replicator jobs shall subscribe to startReadout events from the Base DMCS */
    attribute id : String = "REQ-152";
    attribute eventType : String = "startReadout";
    attribute eventSource : String = "Base_DMCS";
    attribute subscriptionActive : Boolean;
    attribute subscriptionEstablished : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint SubscriptionActivation { subscriptionEstablished == true implies subscriptionActive == true }
    }

  requirement def RemoveObsoleteQmsCode {
    subject;
    doc /* The system shall remove all obsolete QMS-related code */
    attribute id : String = "REQ-181";
    attribute qms_code_removed : Boolean;
    attribute obsolete_code_cleaned : Boolean;
    stakeholder developer : Developer;
    require constraint QmsCodeRemovalComplete { qms_code_removed == true and obsolete_code_cleaned == true }
    }

  requirement def GroupIncludeStatements {
    subject;
    doc /* The include statements in Qserv core modules shall be grouped into standard library, boost, and local includes */
    attribute id : String = "REQ-210";
    attribute includes_grouped : Boolean;
    attribute grouping_standard_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint IncludeGroupingImplemented { includes_grouped == true and grouping_standard_implemented == true }
    }

  requirement def UnifyForwardDeclarations {
    subject;
    doc /* The forward declarations in Qserv core modules shall be unified and standardized */
    attribute id : String = "REQ-212";
    attribute forward_declarations_unified : Boolean;
    attribute standardization_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint ForwardDeclarationsStandardized { forward_declarations_unified == true and standardization_implemented == true }
    }

  requirement def ProvideCppGeometryApi {
    subject;
    doc /* The system shall provide a C++ API for C++ Geometry functionality */
    attribute id : String = "REQ-170";
    attribute cpp_api_available : Boolean;
    attribute geometry_functionality_exposed : Boolean;
    stakeholder developer : Developer;
    require constraint CppApiProvided { cpp_api_available == true and geometry_functionality_exposed == true }
    }

  requirement def UseConciseExceptionNames {
    subject;
    doc /* The CSS exception system shall use concise exception names like css::NoSuchTable and css::AuthError */
    attribute id : String = "REQ-163";
    attribute uses_concise_names : Boolean;
    attribute exception_naming_standard : String;
    stakeholder developer : Developer;
    require constraint ConciseNamingImplemented { uses_concise_names == true and exception_naming_standard != "" }
    }

  requirement def ValidateCssFacade {
    subject;
    doc /* The css and qproc modules shall validate cssFacade construction */
    attribute id : String = "REQ-184.1";
    attribute validates_css_facade : Boolean;
    attribute construction_validated : Boolean;
    stakeholder developer : Developer;
    require constraint CssFacadeValidation { validates_css_facade == true and construction_validated == true }
    }

  requirement def ManageZookeeperConnections {
    subject;
    doc /* The czar shall manage zookeeper connections to prevent excessive connection creation */
    attribute id : String = "REQ-175";
    attribute manages_connections : Boolean;
    attribute prevents_excessive_connections : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ConnectionManagement { manages_connections == true and prevents_excessive_connections == true }
    }

  requirement def SortIncludeStatements {
    subject;
    doc /* The include statements in Qserv core modules shall be sorted appropriately within each group */
    attribute id : String = "REQ-211";
    attribute includes_sorted : Boolean;
    attribute sorting_within_groups : Boolean;
    stakeholder developer : Developer;
    require constraint IncludeSortingImplemented { includes_sorted == true and sorting_within_groups == true }
    }

  requirement def UseSecureStringFormatting {
    subject;
    doc /* The logging system shall use vsnprintf() instead of vsprintf() for security when handling user-provided arguments */
    attribute id : String = "REQ-220";
    attribute uses_vsnprintf : Boolean;
    attribute secure_string_handling : Boolean;
    stakeholder developer : Developer;
    require constraint SecureStringHandling { uses_vsnprintf == true and secure_string_handling == true }
    }

  requirement def PreventUnnecessaryRebuilds {
    subject;
    doc /* The scons build system shall not rebuild unchanged targets when running scons install after scons build */
    attribute id : String = "REQ-190";
    attribute prevents_unnecessary_rebuilds : Boolean;
    attribute unchanged_targets_preserved : Boolean;
    stakeholder developer : Developer;
    require constraint BuildEfficiency { prevents_unnecessary_rebuilds == true and unchanged_targets_preserved == true }
    }

  requirement def SpecifyModuleNamesInIncludes {
    subject;
    doc /* The include statements shall specify module names in the format #include "module/header.h" */
    attribute id : String = "REQ-189";
    attribute specifies_module_names : Boolean;
    attribute include_format_standard : String = "module/header.h";
    stakeholder developer : Developer;
    require constraint ModuleNameSpecification { specifies_module_names == true and include_format_standard == "module/header.h" }
    }

  requirement def SplitKeyValueExceptions {
    subject;
    doc /* The css KvInterface.py shall split exceptions into key-value related exceptions */
    attribute id : String = "REQ-202.1";
    attribute key_value_exceptions_split : Boolean;
    attribute exception_categorization_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint ExceptionSplitting { key_value_exceptions_split == true and exception_categorization_implemented == true }
    }

  requirement def UseConfigurationTemplates {
    subject;
    doc /* The client configuration file shall use templates for configuration values */
    attribute id : String = "REQ-160";
    attribute uses_templates : Boolean;
    attribute template_support_enabled : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint TemplateUsage { uses_templates == true and template_support_enabled == true }
    }

  requirement def UseCzarInsteadOfMaster {
    subject;
    doc /* The system shall use lsst.qserv.czar instead of lsst.qserv.master in the czar module */
    attribute id : String = "REQ-194";
    attribute uses_czar_module : Boolean;
    attribute master_module_replaced : Boolean;
    stakeholder developer : Developer;
    require constraint CzarModuleUsage { uses_czar_module == true and master_module_replaced == true }
    }

  requirement def ReturnOrderedResults {
    subject;
    doc /* The query system shall return properly ordered results for ORDER BY queries */
    attribute id : String = "REQ-173";
    attribute returns_ordered_results : Boolean;
    attribute order_by_supported : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint OrderedResultsSupport { order_by_supported == true implies returns_ordered_results == true }
    }

  requirement def UseLog4cxxImplementation {
    subject;
    doc /* The logging system shall use log4cxx-based implementation with hierarchical logger names */
    attribute id : String = "REQ-218";
    attribute uses_log4cxx : Boolean;
    attribute hierarchical_logger_names : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint Log4cxxImplementation { uses_log4cxx == true and hierarchical_logger_names == true }
    }

  requirement def ManageConfigAsGlobalVariable {
    subject;
    doc /* The commons.config object shall be managed as a global variable accessible via config.getConfig() function */
    attribute id : String = "REQ-179";
    attribute managed_as_global : Boolean;
    attribute accessible_via_function : Boolean;
    stakeholder developer : Developer;
    require constraint GlobalConfigManagement { managed_as_global == true and accessible_via_function == true }
    }

  requirement def MoveClientPackageContents {
    subject;
    doc /* The client package contents shall be moved to the admin directory */
    attribute id : String = "REQ-185";
    attribute contents_moved : Boolean;
    attribute admin_directory_target : Boolean;
    stakeholder developer : Developer;
    require constraint PackageContentsMoved { contents_moved == true and admin_directory_target == true }
    }

  requirement def RemoveObsoleteStringUtilFunctions {
    subject;
    doc /* The system shall remove obsolete strToDoubleFunc and related functions from util/stringUtil.h */
    attribute id : String = "REQ-209";
    attribute obsolete_functions_removed : Boolean;
    attribute string_util_cleaned : Boolean;
    stakeholder developer : Developer;
    require constraint StringUtilCleanup { obsolete_functions_removed == true and string_util_cleaned == true }
    }

  requirement def UseCompactKeyDesign {
    subject;
    doc /* The CSS key design shall use a more compact version with merged keys instead of fine-grain individual keys */
    attribute id : String = "REQ-166";
    attribute uses_merged_keys : Boolean;
    attribute compact_design_implemented : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint CompactKeyDesign { uses_merged_keys == true and compact_design_implemented == true }
    }

  requirement def ValidateCssFacadeConstruction {
    subject;
    doc /* The css and qproc modules shall validate cssFacade construction and report errors early */
    attribute id : String = "REQ-184";
    attribute validates_construction : Boolean;
    attribute reports_errors_early : Boolean;
    stakeholder developer : Developer;
    require constraint ValidationAndReporting { validates_construction == true and reports_errors_early == true }
    }

  requirement def CheckChunkLevelBeforeQuery {
    subject;
    doc /* The query dispatcher shall check chunkLevel before sending queries to chunks */
    attribute id : String = "REQ-172";
    attribute checks_chunk_level : Boolean;
    attribute chunk_validation_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint ChunkLevelValidation { chunk_validation_enabled == true implies checks_chunk_level == true }
    }

  requirement def SplitKvInterfaceExceptions {
    subject;
    doc /* The css KvInterface.py shall split exceptions into key-value related exceptions and separate database/table exceptions */
    attribute id : String = "REQ-202";
    attribute exceptions_split : Boolean;
    attribute key_value_exceptions_separated : Boolean;
    attribute database_table_exceptions_separated : Boolean;
    stakeholder developer : Developer;
    require constraint ExceptionSeparation { exceptions_split == true and key_value_exceptions_separated == true and database_table_exceptions_separated == true }
    }

  requirement def IncludeSwiggedTargets {
    subject;
    doc /* The build system shall include swigged targets in the build alias */
    attribute id : String = "REQ-169";
    attribute includes_swigged_targets : Boolean;
    attribute build_alias_configured : Boolean;
    stakeholder developer : Developer;
    require constraint SwiggedTargetInclusion { build_alias_configured == true implies includes_swigged_targets == true }
    }

  requirement def RenameMasterLibToCzarLib {
    subject;
    doc /* The masterLib shall be renamed to czarLib */
    attribute id : String = "REQ-195";
    attribute library_renamed : Boolean;
    attribute new_library_name : String = "czarLib";
    stakeholder developer : Developer;
    require constraint LibraryRenaming { library_renamed == true and new_library_name == "czarLib" }
    }

  requirement def ReturnDistinctResults {
    subject;
    doc /* The query system shall return correct distinct results for DISTINCT queries */
    attribute id : String = "REQ-174";
    attribute returns_distinct_results : Boolean;
    attribute distinct_query_supported : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint DistinctQueryHandling { distinct_query_supported == true implies returns_distinct_results == true }
    }

  requirement def MoveCssWatcherFile {
    subject;
    doc /* The css/bin/watcher.py file shall be moved to the admin directory */
    attribute id : String = "REQ-186";
    attribute watcher_file_moved : Boolean;
    attribute file_relocated : Boolean;
    stakeholder developer : Developer;
    require constraint FileRelocation { watcher_file_moved == true and file_relocated == true }
    }

  requirement def HandleMysqlTimeouts {
    subject;
    doc /* The qserv system shall handle mysql connection timeouts gracefully without becoming unusable */
    attribute id : String = "REQ-214";
    attribute handles_timeouts_gracefully : Boolean;
    attribute remains_usable : Boolean;
    stakeholder administrator : Administrator;
    stakeholder user : User;
    require constraint TimeoutHandling { handles_timeouts_gracefully == true and remains_usable == true }
    }

  requirement def RemoveAntlrDependencyFromPredicate {
    subject;
    doc /* The predicate functionality shall not depend on ANTLR nodes */
    attribute id : String = "REQ-216";
    attribute antlr_dependency_removed : Boolean;
    attribute predicate_independent : Boolean;
    stakeholder developer : Developer;
    require constraint PredicateIndependence { antlr_dependency_removed == true and predicate_independent == true }
    }

  requirement def RetrieveTemplatedValues {
    subject;
    doc /* The client configuration file shall retrieve templated values from the mother configuration file */
    attribute id : String = "REQ-161";
    attribute retrieves_from_mother_config : Boolean;
    attribute mother_config_accessible : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint TemplatedValueRetrieval { mother_config_accessible == true implies retrieves_from_mother_config == true }
    }

  requirement def AutoReconnectToMysqld {
    subject;
    doc /* The qserv system shall automatically reconnect to mysqld when the connection is lost due to server restart */
    attribute id : String = "REQ-213";
    attribute auto_reconnects : Boolean;
    attribute handles_server_restart : Boolean;
    stakeholder administrator : Administrator;
    stakeholder user : User;
    require constraint AutoReconnection { handles_server_restart == true implies auto_reconnects == true }
    }

  requirement def PreventDuplicatedRows {
    subject;
    doc /* The query system shall not return duplicated rows for non-partitioned table queries */
    attribute id : String = "REQ-171";
    attribute prevents_duplicates : Boolean;
    attribute non_partitioned_query_handled : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint DuplicatePrevention { non_partitioned_query_handled == true implies prevents_duplicates == true }
    }

  requirement def RenameStartQservScript {
    subject;
    doc /* The startQserv script shall be renamed to startCzar */
    attribute id : String = "REQ-196";
    attribute script_renamed : Boolean;
    attribute new_script_name : String = "startCzar";
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ScriptRenaming { script_renamed == true and new_script_name == "startCzar" }
    }

  requirement def ReportErrorsEarly {
    subject;
    doc /* The css and qproc modules shall report errors early */
    attribute id : String = "REQ-184.2";
    attribute reports_early : Boolean;
    attribute early_error_detection : Boolean;
    stakeholder developer : Developer;
    require constraint EarlyErrorReporting { early_error_detection == true implies reports_early == true }
    }

  requirement def UseNewCssForMetadata {
    subject;
    doc /* The QservDataLoader class shall create metadata using the new CSS instead of old scripts */
    attribute id : String = "REQ-188";
    attribute uses_new_css : Boolean;
    attribute metadata_creation_updated : Boolean;
    stakeholder developer : Developer;
    require constraint NewCssUsage { metadata_creation_updated == true implies uses_new_css == true }
    }

  requirement def AvoidFormattingWhenDebugDisabled {
    subject;
    doc /* The logging system shall avoid executing formatting code when debug level is disabled */
    attribute id : String = "REQ-219";
    attribute avoids_formatting_when_disabled : Boolean;
    attribute debug_level_optimization : Boolean;
    stakeholder developer : Developer;
    require constraint FormattingOptimization { debug_level_optimization == true implies avoids_formatting_when_disabled == true }
    }

  requirement def HandleMetadataExceptions {
    subject;
    doc /* The qserv czar shall handle metadata exceptions without crashing */
    attribute id : String = "REQ-217";
    attribute handles_metadata_exceptions : Boolean;
    attribute prevents_crashes : Boolean;
    stakeholder administrator : Administrator;
    stakeholder user : User;
    require constraint MetadataExceptionHandling { handles_metadata_exceptions == true and prevents_crashes == true }
    }

  requirement def CompileQueryAnalyzerIndependently {
    subject;
    doc /* The query analyzer code shall compile independently of the parser and ANTLR dependencies */
    attribute id : String = "REQ-215";
    attribute compiles_independently : Boolean;
    attribute parser_dependency_removed : Boolean;
    attribute antlr_dependency_removed : Boolean;
    stakeholder developer : Developer;
    require constraint IndependentCompilation { compiles_independently == true and parser_dependency_removed == true and antlr_dependency_removed == true }
    }

  requirement def SplitDatabaseTableExceptions {
    subject;
    doc /* The css KvInterface.py shall split exceptions into separate database/table exceptions */
    attribute id : String = "REQ-202.2";
    attribute database_table_exceptions_split : Boolean;
    attribute separate_exception_handling : Boolean;
    stakeholder developer : Developer;
    require constraint DatabaseTableExceptionSeparation { database_table_exceptions_split == true and separate_exception_handling == true }
    }

  requirement def RenameQservAdminScript {
    subject;
    doc /* The script qserv_admin.py shall be renamed to qserv-admin.py */
    attribute id : String = "REQ-180";
    attribute script_renamed : Boolean;
    attribute new_name_format : String = "qserv-admin.py";
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint AdminScriptRenaming { script_renamed == true and new_name_format == "qserv-admin.py" }
    }

  requirement def AssociateReplicatorWithDistributor {
    subject;
    doc /* The simulator shall associate replicator nodes with distributor nodes */
    attribute id : String = "REQ-233";
    attribute replicator_nodes_associated : Boolean;
    attribute distributor_nodes_available : Boolean;
    attribute association_established : Boolean;
    stakeholder developer : Developer;
    require constraint AssociateWhenAvailable { distributor_nodes_available == true implies replicator_nodes_associated == true }
    require constraint EstablishAssociation { replicator_nodes_associated == true implies association_established == true }
    }

  requirement def EnableDataCopyToDistributor {
    subject;
    doc /* The simulator shall enable replicator jobs to copy data to distributor nodes */
    attribute id : String = "REQ-235";
    attribute data_copy_enabled : Boolean;
    attribute replicator_jobs_copying : Boolean;
    attribute distributor_nodes_accessible : Boolean;
    stakeholder developer : Developer;
    require constraint EnableCopyWhenAccessible { distributor_nodes_accessible == true implies data_copy_enabled == true }
    require constraint ReplicatorJobsCopy { data_copy_enabled == true implies replicator_jobs_copying == true }
    }

  requirement def IncludeDistributorComponent {
    subject;
    doc /* The simulator shall include a distributor component as part of the simulation architecture */
    attribute id : String = "REQ-232";
    attribute distributor_component_included : Boolean;
    attribute simulation_architecture_complete : Boolean;
    stakeholder developer : Developer;
    require constraint CompleteArchitectureWithDistributor { distributor_component_included == true implies simulation_architecture_complete == true }
    }

  requirement def EnableJobInformationTransfer {
    subject;
    doc /* The simulator shall enable replicator jobs to send job information to distributor nodes */
    attribute id : String = "REQ-234";
    attribute job_information_transfer_enabled : Boolean;
    attribute replicator_jobs_active : Boolean;
    attribute distributor_nodes_receiving : Boolean;
    stakeholder developer : Developer;
    require constraint EnableTransferWhenActive { replicator_jobs_active == true implies job_information_transfer_enabled == true }
    require constraint DistributorReceivesInfo { job_information_transfer_enabled == true implies distributor_nodes_receiving == true }
    }

  requirement def ReceiveRaftIdentification {
    subject;
    doc /* The Archive DMCS simulator shall receive raft identification information from the duplicator */
    attribute id : String = "REQ-242";
    attribute raft_id_received : Boolean;
    attribute raft_identification_valid : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ValidRaftIdentification { raft_id_received == true implies raft_identification_valid == true }
    }

  requirement def ReceiveNetworkAddress {
    subject;
    doc /* The Archive DMCS simulator shall receive network address information from the duplicator */
    attribute id : String = "REQ-243";
    attribute network_address_received : Boolean;
    attribute address_format_valid : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ValidNetworkAddress { network_address_received == true implies address_format_valid == true }
    }

  requirement def ReceiveVisitIdentification {
    subject;
    doc /* The Archive DMCS simulator shall receive visit identification information from the duplicator */
    attribute id : String = "REQ-240";
    attribute visit_id_received : Boolean;
    attribute duplicator_connected : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ReceiveVisitId { duplicator_connected == true implies visit_id_received == true }
    assume constraint DuplicatorConnected { duplicator_connected == true }
    }

  requirement def ReceiveExposureSequenceNumbers {
    subject;
    doc /* The Archive DMCS simulator shall receive exposure sequence numbers from the duplicator */
    attribute id : String = "REQ-241";
    attribute exposure_sequence_received : Boolean;
    attribute sequence_number_valid : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ValidExposureSequence { exposure_sequence_received == true implies sequence_number_valid == true }
    }

  requirement def PackageLog4cxxVersion {
    subject;
    doc /* The build system shall package log4cxx version 0.10.0 */
    attribute id : String = "REQ-264";
    attribute log4cxx_version : String = "0.10.0";
    attribute library_packaged : Boolean;
    stakeholder developer : Developer;
    require constraint CorrectVersionPackaged { log4cxx_version == "0.10.0" and library_packaged == true }
    }

  requirement def IncludeBoostDependencyInConfiguration {
    subject;
    doc /* The qserv.table configuration shall include boost dependency */
    attribute id : String = "REQ-252";
    attribute config_file : String = "qserv.table";
    attribute boost_dependency_included : Boolean;
    stakeholder developer : Developer;
    require constraint BoostDependencyIncluded { config_file == "qserv.table" implies boost_dependency_included == true }
    }

  requirement def PackageLoggingAsLogComponent {
    subject;
    doc /* The logging system shall be packaged as a component called 'log' */
    attribute id : String = "REQ-262";
    attribute component_name : String = "log";
    attribute logging_packaged : Boolean;
    stakeholder developer : Developer;
    require constraint LogComponentPackaged { component_name == "log" and logging_packaged == true }
    }

  requirement def UseEupsStackBoost {
    subject;
    doc /* The qserv system shall use boost from the EUPS stack instead of system-installed boost */
    attribute id : String = "REQ-251";
    attribute boost_source : String = "EUPS";
    attribute system_boost_disabled : Boolean;
    attribute eups_boost_enabled : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint EupsBoostUsage { boost_source == "EUPS" and system_boost_disabled == true and eups_boost_enabled == true }
    }

  requirement def UseGccUnusedTypedefsFlag {
    subject;
    doc /* The build system shall use the -Wno-unused-local-typedefs flag when compiling with gcc 4.8 */
    attribute id : String = "REQ-250";
    attribute compiler_flag : String = "-Wno-unused-local-typedefs";
    attribute gcc_version : String = "4.8";
    attribute flag_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint GccFlagUsage { gcc_version == "4.8" implies flag_enabled == true }
    }

  requirement def MigrateCzarToNewLogging {
    subject;
    doc /* The czar system shall migrate to the new logging system */
    attribute id : String = "REQ-279";
    attribute system_component : String = "czar";
    attribute new_logging_adopted : Boolean;
    attribute migration_complete : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint CzarLoggingMigration { system_component == "czar" implies new_logging_adopted == true and migration_complete == true }
    }

  requirement def ResolveQservCoreCircularDependencies {
    subject;
    doc /* The core architecture shall resolve circular dependencies between modules in qserv/core */
    attribute id : String = "REQ-274";
    attribute core_directory : String = "qserv/core";
    attribute circular_dependencies_resolved : Boolean;
    attribute module_dependencies_clean : Boolean;
    stakeholder developer : Developer;
    require constraint CoreDependenciesResolved { circular_dependencies_resolved == true and module_dependencies_clean == true }
    }

  requirement def EliminateQanaQprocQueryCircularDependencies {
    subject;
    doc /* The core architecture shall eliminate circular dependencies between qana, qproc, and query modules */
    attribute id : String = "REQ-277";
    attribute module_one : String = "qana";
    attribute module_two : String = "qproc";
    attribute module_three : String = "query";
    attribute circular_dependencies_eliminated : Boolean;
    stakeholder developer : Developer;
    require constraint ThreeModuleCircularDependencyEliminated { module_one == "qana" and module_two == "qproc" and module_three == "query" implies circular_dependencies_eliminated == true }
    }

  requirement def EliminateParserQueryCircularDependency {
    subject;
    doc /* The core architecture shall eliminate circular dependency between parser and query modules */
    attribute id : String = "REQ-278";
    attribute module_one : String = "parser";
    attribute module_two : String = "query";
    attribute circular_dependency_eliminated : Boolean;
    stakeholder developer : Developer;
    require constraint ParserQueryDependencyEliminated { module_one == "parser" and module_two == "query" implies circular_dependency_eliminated == true }
    }

  requirement def SupportSconsUnitTests {
    subject;
    doc /* The build system shall support running unit tests through scons */
    attribute id : String = "REQ-267";
    attribute build_tool : String = "scons";
    attribute unit_tests_supported : Boolean;
    attribute scons_test_execution : Boolean;
    stakeholder developer : Developer;
    require constraint SconsUnitTestSupport { build_tool == "scons" implies unit_tests_supported == true and scons_test_execution == true }
    }

  requirement def RestructureLog4cxxPrototype {
    subject;
    doc /* The logging system shall restructure the log4cxx-based prototype from branch u/protolog */
    attribute id : String = "REQ-261";
    attribute source_branch : String = "u/protolog";
    attribute logging_framework : String = "log4cxx";
    attribute prototype_restructured : Boolean;
    stakeholder developer : Developer;
    require constraint PrototypeRestructured { source_branch == "u/protolog" and logging_framework == "log4cxx" implies prototype_restructured == true }
    }

  requirement def RemoveSystemBoostConditionalCode {
    subject;
    doc /* The BoostChecker shall remove conditional code for system-installed boost */
    attribute id : String = "REQ-253";
    attribute component_name : String = "BoostChecker";
    attribute conditional_code_removed : Boolean;
    attribute system_boost_code_eliminated : Boolean;
    stakeholder developer : Developer;
    require constraint SystemBoostCodeRemoved { component_name == "BoostChecker" implies conditional_code_removed == true and system_boost_code_eliminated == true }
    }

  requirement def EliminateControlQdispCircularDependency {
    subject;
    doc /* The core architecture shall eliminate circular dependency between control and qdisp modules */
    attribute id : String = "REQ-276";
    attribute module_one : String = "control";
    attribute module_two : String = "qdisp";
    attribute circular_dependency_eliminated : Boolean;
    stakeholder developer : Developer;
    require constraint ControlQdispDependencyEliminated { module_one == "control" and module_two == "qdisp" implies circular_dependency_eliminated == true }
    }

  requirement def EliminateWschedWcontrolCircularDependency {
    subject;
    doc /* The core architecture shall eliminate circular dependency between wsched and wcontrol modules */
    attribute id : String = "REQ-275";
    attribute module_one : String = "wsched";
    attribute module_two : String = "wcontrol";
    attribute circular_dependency_eliminated : Boolean;
    stakeholder developer : Developer;
    require constraint WschedWcontrolDependencyEliminated { module_one == "wsched" and module_two == "wcontrol" implies circular_dependency_eliminated == true }
    }

  requirement def RewriteXRootDWithAsyncClient {
    subject;
    doc /* The XRootD interface shall be rewritten to use the new XRootD client with asynchronous interfaces */
    attribute id : String = "REQ-280";
    attribute interfaceType : String = "XRootD";
    attribute client_type : String = "asynchronous";
    attribute interface_rewritten : Boolean;
    attribute async_client_implemented : Boolean;
    stakeholder developer : Developer;
    require constraint XRootDAsyncRewrite { interfaceType == "XRootD" and client_type == "asynchronous" implies interface_rewritten == true and async_client_implemented == true }
    }

  requirement def CleanupXRootDInterfaceCode {
    subject;
    doc /* The XRootD interface code shall undergo major cleanup during the client migration */
    attribute id : String = "REQ-281";
    attribute interfaceType : String = "XRootD";
    attribute code_cleanup_complete : Boolean;
    attribute migration_cleanup_done : Boolean;
    stakeholder developer : Developer;
    require constraint CleanupDuringMigration { migration_cleanup_done == true implies code_cleanup_complete == true }
    }

  requirement def SeparateInstanceFromInstallationConfig {
    subject;
    doc /* The configuration system shall separate instance configuration from software installation directory */
    attribute id : String = "REQ-271";
    attribute instance_config_separated : Boolean;
    attribute installation_config_separated : Boolean;
    attribute config_separation_complete : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ConfigurationSeparation { instance_config_separated == true and installation_config_separated == true implies config_separation_complete == true }
    }

  requirement def OptionalResultInterface {
    subject;
    doc /* The algorithm API shall support optional Result objects as an alternative interface */
    attribute id : String = "REQ-290";
    attribute supports_optional_results : Boolean;
    attribute provides_alternative_interface : Boolean;
    stakeholder developer : Developer;
    require constraint OptionalResultSupport { supports_optional_results == true and provides_alternative_interface == true }
    }

  requirement def DirectRecordInterface {
    subject;
    doc /* The algorithm API shall provide a direct interface that sets record values without requiring intermediate Result objects */
    attribute id : String = "REQ-289";
    attribute supports_direct_interface : Boolean;
    attribute requires_result_objects : Boolean;
    stakeholder developer : Developer;
    require constraint DirectInterfaceWithoutResults { supports_direct_interface == true and requires_result_objects == false }
    }

  requirement def ObsPackagesCompatibility {
    subject;
    doc /* The obs* packages shall be compatible with the meas_base package */
    attribute id : String = "REQ-292";
    attribute obs_packages_compatible : Boolean;
    attribute meas_base_integration : Boolean;
    stakeholder developer : Developer;
    require constraint ObsPackageIntegration { obs_packages_compatible == true and meas_base_integration == true }
    }

  requirement def StringSubstitutionAlias {
    subject;
    doc /* The afw::table::Schema shall support string-substitution-based alias mechanism */
    attribute id : String = "REQ-295";
    attribute supports_string_substitution : Boolean;
    attribute alias_mechanism_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint StringSubstitutionSupport { supports_string_substitution == true and alias_mechanism_enabled == true }
    }

  requirement def PipeTasksCompatibility {
    subject;
    doc /* The pipe_tasks package shall be compatible with the meas_base package */
    attribute id : String = "REQ-291";
    attribute pipe_tasks_compatible : Boolean;
    attribute meas_base_compatible : Boolean;
    stakeholder developer : Developer;
    require constraint PipeTasksIntegration { pipe_tasks_compatible == true and meas_base_compatible == true }
    }

  requirement def TracingNamingConvention {
    subject;
    doc /* The measurement algorithms shall use the new naming convention that provides traceability */
    attribute id : String = "REQ-293";
    attribute uses_new_naming : Boolean;
    attribute provides_traceability : Boolean;
    stakeholder developer : Developer;
    require constraint NamingConventionTraceability { uses_new_naming == true implies provides_traceability == true }
    }

  requirement def PostConstructionAliasChanges {
    subject;
    doc /* The afw::table::Schema shall allow alias changes after table construction while maintaining schema immutability for other properties */
    attribute id : String = "REQ-296";
    attribute allows_alias_changes : Boolean;
    attribute maintains_schema_immutability : Boolean;
    attribute post_construction_modification : Boolean;
    stakeholder developer : Developer;
    require constraint PostConstructionFlexibility { post_construction_modification == true implies allows_alias_changes == true and maintains_schema_immutability == true }
    }

  requirement def SendVOEventsOnCompletion {
    subject;
    doc /* The worker job shall send VOEvents upon completion of processing */
    attribute id : String = "REQ-315";
    attribute processing_completed : Boolean;
    attribute vo_events_sent : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint EventsOnCompletion { processing_completed == true implies vo_events_sent == true }
    }

  requirement def ContactDistributorForImage {
    subject;
    doc /* The worker job shall contact the distributor via blocking call to request the image */
    attribute id : String = "REQ-313";
    attribute distributor_contacted : Boolean;
    attribute blocking_call_used : Boolean;
    attribute image_requested : Boolean;
    stakeholder developer : Developer;
    require constraint DistributorContactMethod { distributor_contacted == true and blocking_call_used == true and image_requested == true }
    }

  requirement def RetrieveDiaObjectsAndSources {
    subject;
    doc /* The worker shall retrieve DiaObjects, past DiaSources, and SSObjects that overlap the spatial region */
    attribute id : String = "REQ-310";
    attribute dia_objects_retrieved : Boolean;
    attribute past_dia_sources_retrieved : Boolean;
    attribute ss_objects_retrieved : Boolean;
    attribute spatial_overlap_verified : Boolean;
    stakeholder developer : Developer;
    require constraint CompleteDataRetrieval { spatial_overlap_verified == true implies (dia_objects_retrieved == true and past_dia_sources_retrieved == true and ss_objects_retrieved == true) }
    }

  requirement def ComputeSpatialRegionWithMargin {
    subject;
    doc /* The worker shall compute the spatial region covering the expected CCD area plus a margin */
    attribute id : String = "REQ-307";
    attribute spatial_region_computed : Boolean;
    attribute ccd_area_covered : Boolean;
    attribute margin_included : Boolean;
    stakeholder developer : Developer;
    require constraint SpatialRegionComputation { spatial_region_computed == true and ccd_area_covered == true and margin_included == true }
    }

  requirement def LaunchWorkerJobWithParameters {
    subject;
    doc /* Each worker job shall launch with visit id, number of exposures, foresight pointing, filter id, and CCD id parameters */
    attribute id : String = "REQ-306";
    attribute visit_id_provided : Boolean;
    attribute exposure_count_provided : Boolean;
    attribute foresight_pointing_provided : Boolean;
    attribute filter_id_provided : Boolean;
    attribute ccd_id_provided : Boolean;
    stakeholder developer : Developer;
    require constraint AllParametersProvided { visit_id_provided == true and exposure_count_provided == true and foresight_pointing_provided == true and filter_id_provided == true and ccd_id_provided == true }
    }

  requirement def LaunchWorkerJobsOnNextVisitEvent {
    subject;
    doc /* The Base DMCS shall launch worker jobs for each CCD (189 jobs) plus four additional jobs for wavefront sensors upon receiving a nextVisit event */
    attribute id : String = "REQ-305";
    attribute ccd_job_count : Integer = 189;
    attribute wavefront_sensor_job_count : Integer = 4;
    attribute total_job_count : Integer = 193;
    attribute nextvisit_event_received : Boolean;
    attribute jobs_launched : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint JobLaunchOnEvent { nextvisit_event_received == true implies jobs_launched == true }
    require constraint JobCountVerification { total_job_count == (ccd_job_count + wavefront_sensor_job_count) }
    }

  requirement def PerformImageRetrievalTwice {
    subject;
    doc /* The worker job shall perform image retrieval operations twice in normal science mode */
    attribute id : String = "REQ-314";
    attribute retrieval_operation_count : Integer = 2;
    attribute normal_science_mode : Boolean;
    attribute image_retrieval_completed : Boolean;
    stakeholder developer : Developer;
    require constraint RetrievalCountInScienceMode { normal_science_mode == true implies (image_retrieval_completed == true and retrieval_operation_count == 2) }
    }

  requirement def ManageMultipleDataDependencyTypes {
    subject;
    doc /* The system shall manage multiple types of data dependencies including calibrations, templates, and catalogs of sources/objects */
    attribute id : String = "REQ-303";
    attribute calibrations_managed : Boolean;
    attribute templates_managed : Boolean;
    attribute source_catalogs_managed : Boolean;
    attribute object_catalogs_managed : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint AllDataTypesManaged { calibrations_managed == true and templates_managed == true and source_catalogs_managed == true and object_catalogs_managed == true }
    }

  requirement def CacheHeterogeneousDataDependencies {
    subject;
    doc /* The system shall cache heterogeneous data dependencies for HTCondor ClassAds scenarios */
    attribute id : String = "REQ-304";
    attribute heterogeneous_data_cached : Boolean;
    attribute htcondor_classads_supported : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint HeterogeneousDataCaching { htcondor_classads_supported == true implies heterogeneous_data_cached == true }
    }

  requirement def RetrieveObjectsFromDataRelease {
    subject;
    doc /* The worker shall retrieve Objects from the last Data Release that overlap the computed spatial region */
    attribute id : String = "REQ-309";
    attribute objects_retrieved : Boolean;
    attribute data_release_accessed : Boolean;
    attribute spatial_overlap_checked : Boolean;
    stakeholder developer : Developer;
    require constraint ObjectRetrievalFromRelease { (data_release_accessed == true and spatial_overlap_checked == true) implies objects_retrieved == true }
    }

  requirement def ProvideStableExecutionPath {
    subject;
    doc /* The Rank expressions shall provide a path to stable execution when HTCondor slots are dynamically removed */
    attribute id : String = "REQ-302";
    attribute rank_expressions_configured : Boolean;
    attribute slots_dynamically_removed : Boolean;
    attribute stable_execution_path_available : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint StablePathOnSlotRemoval { (rank_expressions_configured == true and slots_dynamically_removed == true) implies stable_execution_path_available == true }
    }

  requirement def MaintainStableExecutionOnSlotRemoval {
    subject;
    doc /* The system shall maintain stable execution when an HTCondor slot is suddenly removed during job execution */
    attribute id : String = "REQ-301";
    attribute execution_stable : Boolean;
    attribute slot_removed_suddenly : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint StabilityOnSuddenRemoval { slot_removed_suddenly == true implies execution_stable == true }
    }

  requirement def AcceptSedDataForRefractionCalculations {
    subject;
    doc /* The system shall accept spectral energy distribution (SED) data as input for refraction amplitude calculations */
    attribute id : String = "REQ-322";
    attribute sed_data_accepted : Boolean;
    attribute refraction_calculation_enabled : Boolean = true;
    attribute input_data_format_supported : String;
    stakeholder developer : Developer;
    stakeholder astronomer : Astronomer;
    require constraint SedDataAcceptanceForRefraction { refraction_calculation_enabled == true implies sed_data_accepted == true }
    }

  requirement def AcceptSedDataForDcrCalculations {
    subject;
    doc /* The system shall accept spectral energy distribution (SED) data as input for DCR amplitude calculations */
    attribute id : String = "REQ-319";
    attribute sed_data_accepted : Boolean;
    attribute dcr_calculation_enabled : Boolean = true;
    attribute input_data_format_supported : String;
    stakeholder developer : Developer;
    stakeholder astronomer : Astronomer;
    require constraint SedDataAcceptanceForDcr { dcr_calculation_enabled == true implies sed_data_accepted == true }
    }

  requirement def ModelDcrAmplitudesFromSed {
    subject;
    doc /* The system shall model differential chromatic refraction (DCR) amplitudes as a mathematical function of spectral energy distribution (SED) */
    attribute id : String = "REQ-318";
    attribute sed_input_required : Boolean = true;
    attribute dcr_amplitude_output_enabled : Boolean = true;
    attribute mathematical_function_implemented : Boolean;
    stakeholder developer : Developer;
    stakeholder astronomer : Astronomer;
    require constraint DcrModelingCapability { sed_input_required == true and dcr_amplitude_output_enabled == true implies mathematical_function_implemented == true }
    }

  requirement def OutputRefractionAmplitudeValues {
    subject;
    doc /* The system shall output calculated refraction amplitude values based on the provided SED input */
    attribute id : String = "REQ-323";
    attribute refraction_amplitude_calculated : Boolean;
    attribute output_values_generated : Boolean;
    attribute sed_input_processed : Boolean;
    stakeholder developer : Developer;
    stakeholder astronomer : Astronomer;
    require constraint RefractionOutputGeneration { sed_input_processed == true and refraction_amplitude_calculated == true implies output_values_generated == true }
    }

  requirement def OutputDcrAmplitudeValues {
    subject;
    doc /* The system shall output calculated DCR amplitude values based on the provided SED input */
    attribute id : String = "REQ-320";
    attribute dcr_amplitude_calculated : Boolean;
    attribute output_values_generated : Boolean;
    attribute sed_input_processed : Boolean;
    stakeholder developer : Developer;
    stakeholder astronomer : Astronomer;
    require constraint DcrOutputGeneration { sed_input_processed == true and dcr_amplitude_calculated == true implies output_values_generated == true }
    }

  requirement def ModelAtmosphericRefractionAmplitudes {
    subject;
    doc /* The system shall model atmospheric refraction amplitudes as a mathematical function of spectral energy distribution (SED) */
    attribute id : String = "REQ-321";
    attribute sed_input_required : Boolean = true;
    attribute atmospheric_refraction_output_enabled : Boolean = true;
    attribute mathematical_function_implemented : Boolean;
    stakeholder developer : Developer;
    stakeholder astronomer : Astronomer;
    require constraint AtmosphericRefractionModelingCapability { sed_input_required == true and atmospheric_refraction_output_enabled == true implies mathematical_function_implemented == true }
    }

  requirement def AprBuildInstallStaticLibraries {
    subject;
    doc /* The apr package shall build and install static libraries */
    attribute id : String = "REQ-325.2";
    attribute package_name : String = "apr";
    attribute static_libraries_built : Boolean;
    attribute static_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildAndInstallStatic { static_libraries_built == true and static_libraries_installed == true }
    }

  requirement def AprInstallSharedLibraries {
    subject;
    doc /* The apr package shall install shared libraries */
    attribute id : String = "REQ-325.1.2";
    attribute package_name : String = "apr";
    attribute shared_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint InstallSharedLibraries { shared_libraries_installed == true }
    }

  requirement def AprBuildSharedLibraries {
    subject;
    doc /* The apr package shall build shared libraries */
    attribute id : String = "REQ-325.1.1";
    attribute package_name : String = "apr";
    attribute shared_libraries_built : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildSharedLibraries { shared_libraries_built == true }
    }

  requirement def AprUtilBuildStaticLibraries {
    subject;
    doc /* The apr_util package shall build static libraries */
    attribute id : String = "REQ-326.3";
    attribute package_name : String = "apr_util";
    attribute static_libraries_built : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildStaticLibraries { static_libraries_built == true }
    }

  requirement def AprBuildInstallLibraries {
    subject;
    doc /* The apr package shall build and install both shared and static libraries */
    attribute id : String = "REQ-325";
    attribute package_name : String = "apr";
    attribute shared_libraries_built : Boolean;
    attribute static_libraries_built : Boolean;
    attribute shared_libraries_installed : Boolean;
    attribute static_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildBothLibraryTypes { shared_libraries_built == true and static_libraries_built == true }
    require constraint InstallBothLibraryTypes { shared_libraries_installed == true and static_libraries_installed == true }
    }

  requirement def AprUtilBuildInstallSharedAndStaticLibraries {
    subject;
    doc /* The apr_util package shall build and install shared libraries in addition to static libraries */
    attribute id : String = "REQ-326";
    attribute package_name : String = "apr_util";
    attribute shared_libraries_built : Boolean;
    attribute static_libraries_built : Boolean;
    attribute shared_libraries_installed : Boolean;
    attribute static_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildSharedAndStatic { shared_libraries_built == true and static_libraries_built == true }
    require constraint InstallSharedAndStatic { shared_libraries_installed == true and static_libraries_installed == true }
    }

  requirement def PackageXrootdWithEups {
    subject;
    doc /* The build system shall package xrootd-4.0.0rc3-qsClient2 with eups package management system */
    attribute id : String = "REQ-324";
    attribute package_name : String = "xrootd-4.0.0rc3-qsClient2";
    attribute package_manager : String = "eups";
    attribute packaging_successful : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint PackagingSuccess { packaging_successful == true }
    }

  requirement def AprInstallStaticLibraries {
    subject;
    doc /* The apr package shall install static libraries */
    attribute id : String = "REQ-325.2.2";
    attribute package_name : String = "apr";
    attribute static_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint InstallStaticLibraries { static_libraries_installed == true }
    }

  requirement def AprBuildStaticLibraries {
    subject;
    doc /* The apr package shall build static libraries */
    attribute id : String = "REQ-325.2.1";
    attribute package_name : String = "apr";
    attribute static_libraries_built : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildStaticLibraries { static_libraries_built == true }
    }

  requirement def AprUtilInstallStaticLibraries {
    subject;
    doc /* The apr_util package shall install static libraries */
    attribute id : String = "REQ-326.4";
    attribute package_name : String = "apr_util";
    attribute static_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint InstallStaticLibraries { static_libraries_installed == true }
    }

  requirement def AprUtilInstallSharedLibrariesInAdditionToStatic {
    subject;
    doc /* The apr_util package shall install shared libraries in addition to static libraries */
    attribute id : String = "REQ-326.2";
    attribute package_name : String = "apr_util";
    attribute shared_libraries_installed : Boolean;
    attribute static_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint InstallSharedInAdditionToStatic { shared_libraries_installed == true and static_libraries_installed == true }
    }

  requirement def AprBuildInstallSharedLibraries {
    subject;
    doc /* The apr package shall build and install shared libraries */
    attribute id : String = "REQ-325.1";
    attribute package_name : String = "apr";
    attribute shared_libraries_built : Boolean;
    attribute shared_libraries_installed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildAndInstallShared { shared_libraries_built == true and shared_libraries_installed == true }
    }

  requirement def AprUtilBuildSharedLibrariesInAdditionToStatic {
    subject;
    doc /* The apr_util package shall build shared libraries in addition to static libraries */
    attribute id : String = "REQ-326.1";
    attribute package_name : String = "apr_util";
    attribute shared_libraries_built : Boolean;
    attribute static_libraries_built : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint BuildSharedInAdditionToStatic { shared_libraries_built == true and static_libraries_built == true }
    }

  requirement def RedesignPythonInterfaceForSmallerIntuitive {
    subject;
    doc /* The thread.cc and dispatcher.cc Python interface shall be redesigned to provide a smaller and more intuitive API surface */
    attribute id : String = "REQ-367";
    attribute current_api_method_count : Integer;
    attribute target_api_method_count : Integer;
    attribute api_complexity_score : Real;
    stakeholder developer : Developer;
    require constraint SmallerApiSurface { target_api_method_count < current_api_method_count }
    require constraint IntuitiveComplexity { api_complexity_score <= 5.0 }
    }

  requirement def RedesignPythonInterfaceForSmallerSurface {
    subject;
    doc /* The thread.cc and dispatcher.cc Python interface shall be redesigned to provide a smaller API surface */
    attribute id : String = "REQ-367.1";
    attribute current_api_method_count : Integer;
    attribute target_api_method_count : Integer;
    stakeholder developer : Developer;
    require constraint ReducedApiMethodCount { target_api_method_count < current_api_method_count }
    }

  requirement def EliminateCompilerWarningsInLogPackage {
    subject;
    doc /* The build system shall eliminate all compiler warnings generated by dependent libraries when building the log package */
    attribute id : String = "REQ-363";
    attribute warning_count : Integer;
    attribute target_warning_count : Integer = 0;
    stakeholder developer : Developer;
    require constraint ZeroWarnings { warning_count == target_warning_count }
    }

  requirement def RedesignPythonInterfaceForIntuitive {
    subject;
    doc /* The thread.cc and dispatcher.cc Python interface shall be redesigned to provide a more intuitive API surface */
    attribute id : String = "REQ-367.2";
    attribute api_complexity_score : Real;
    attribute user_experience_rating : Real;
    stakeholder developer : Developer;
    require constraint IntuitiveApiDesign { api_complexity_score <= 5.0 and user_experience_rating >= 7.0 }
    }

  requirement def MigrateQservWorkerToNewLogging {
    subject;
    doc /* The Qserv worker code shall be migrated to use the new logging system instead of legacy logging mechanisms */
    attribute id : String = "REQ-364";
    attribute legacy_logging_usage : Boolean;
    attribute new_logging_system_active : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint LoggingSystemMigration { legacy_logging_usage == false and new_logging_system_active == true }
    }

  requirement def SupportForcedMeasurementTask {
    subject;
    doc /* The base measurement task class shall support ForcedMeasurementTask implementations */
    attribute id : String = "REQ-376.2";
    attribute supports_forced_task : Boolean;
    stakeholder developer : Developer;
    require constraint ForcedTaskSupport { supports_forced_task == true }
    }

  requirement def SupportBothMeasurementTaskTypes {
    subject;
    doc /* The base measurement task class shall support both SingleFrameMeasurementTask and ForcedMeasurementTask implementations */
    attribute id : String = "REQ-376";
    attribute supports_single_frame : Boolean;
    attribute supports_forced_measurement : Boolean;
    stakeholder developer : Developer;
    require constraint BothTaskTypesSupported { supports_single_frame == true and supports_forced_measurement == true }
    }

  requirement def AcceptResultObjectAsOutput {
    subject;
    doc /* The measurement algorithm shall accept a Result object as an output argument to enable partial measurement results when error flags are set */
    attribute id : String = "REQ-373";
    attribute supports_result_output : Boolean;
    attribute enables_partial_results : Boolean;
    attribute handles_error_flags : Boolean;
    stakeholder developer : Developer;
    require constraint ResultOutputCapability { supports_result_output == true and enables_partial_results == true and handles_error_flags == true }
    }

  requirement def ProvidePythonExceptionHierarchy {
    subject;
    doc /* The system shall provide a Python exception hierarchy that mirrors the C++ exception hierarchy */
    attribute id : String = "REQ-382";
    attribute provides_python_hierarchy : Boolean;
    attribute mirrors_cpp_hierarchy : Boolean;
    stakeholder developer : Developer;
    require constraint ExceptionHierarchyMirroring { provides_python_hierarchy == true and mirrors_cpp_hierarchy == true }
    }

  requirement def ThrowableExceptionSyntax {
    subject;
    doc /* Python exceptions shall be throwable using the same syntax regardless of whether they originated in C++ or Python */
    attribute id : String = "REQ-383.1";
    attribute consistent_throw_syntax : Boolean;
    attribute supports_cpp_origin : Boolean;
    attribute supports_python_origin : Boolean;
    stakeholder developer : Developer;
    require constraint ConsistentThrowSyntax { consistent_throw_syntax == true and supports_cpp_origin == true and supports_python_origin == true }
    }

  requirement def SupportPartialMeasurementValues {
    subject;
    doc /* The measurement system shall support setting partial measurement values simultaneously with error flag activation */
    attribute id : String = "REQ-374";
    attribute supports_partial_values : Boolean;
    attribute simultaneous_flag_activation : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint PartialValueSimultaneousFlag { supports_partial_values == true and simultaneous_flag_activation == true }
    }

  requirement def UseVersionForSubschemaHandling {
    subject;
    doc /* The Schema object shall use the version number to determine whether Subschema objects split and join using underscores or periods */
    attribute id : String = "REQ-381";
    attribute uses_version_for_splitting : Boolean;
    attribute supports_underscore_format : Boolean;
    attribute supports_period_format : Boolean;
    stakeholder developer : Developer;
    require constraint VersionBasedFormatSupport { uses_version_for_splitting == true and supports_underscore_format == true and supports_period_format == true }
    }

  requirement def AssumeVersionOneWithoutAfwType {
    subject;
    doc /* The system shall assume FITS tables without version numbers and without AFW_TYPE key are version 1 */
    attribute id : String = "REQ-386";
    attribute assumes_version_one : Boolean;
    attribute without_afw_type_key : Boolean;
    attribute version_number : Integer = 1;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint VersionOneAssumption { without_afw_type_key == true implies assumes_version_one == true }
    }

  requirement def AssumeVersionZeroWithAfwType {
    subject;
    doc /* The system shall assume FITS tables without version numbers are version 0 only if they contain the AFW_TYPE key */
    attribute id : String = "REQ-385";
    attribute assumes_version_zero : Boolean;
    attribute requires_afw_type_key : Boolean;
    attribute version_number : Integer = 0;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint VersionZeroAssumption { requires_afw_type_key == true implies assumes_version_zero == true }
    }

  requirement def SupportCustomMeasurementExceptions {
    subject;
    doc /* The system shall support custom exceptions for different types of measurement errors */
    attribute id : String = "REQ-384";
    attribute supports_custom_exceptions : Boolean;
    attribute handles_measurement_errors : Boolean;
    stakeholder developer : Developer;
    require constraint CustomExceptionSupport { supports_custom_exceptions == true and handles_measurement_errors == true }
    }

  requirement def ImplementPeakLikelihoodFlux {
    subject;
    doc /* The PeakLikelihoodFlux algorithm shall be implemented using the meas_base framework */
    attribute id : String = "REQ-387";
    attribute implements_peak_likelihood : Boolean;
    attribute uses_meas_base_framework : Boolean;
    stakeholder developer : Developer;
    require constraint PeakLikelihoodImplementation { implements_peak_likelihood == true and uses_meas_base_framework == true }
    }

  requirement def SupportSingleFrameMeasurementTask {
    subject;
    doc /* The base measurement task class shall support SingleFrameMeasurementTask implementations */
    attribute id : String = "REQ-376.1";
    attribute supports_single_frame_task : Boolean;
    stakeholder developer : Developer;
    require constraint SingleFrameTaskSupport { supports_single_frame_task == true }
    }

  requirement def ConsistentExceptionSyntax {
    subject;
    doc /* Python exceptions shall have consistent syntax for throwing and catching regardless of origin */
    attribute id : String = "REQ-383";
    attribute consistent_throw_syntax : Boolean;
    attribute consistent_catch_syntax : Boolean;
    stakeholder developer : Developer;
    require constraint ExceptionSyntaxConsistency { consistent_throw_syntax == true and consistent_catch_syntax == true }
    }

  requirement def CatchableExceptionSyntax {
    subject;
    doc /* Python exceptions shall be catchable using the same syntax regardless of whether they originated in C++ or Python */
    attribute id : String = "REQ-383.2";
    attribute consistent_catch_syntax : Boolean;
    attribute supports_cpp_origin : Boolean;
    attribute supports_python_origin : Boolean;
    stakeholder developer : Developer;
    require constraint ConsistentCatchSyntax { consistent_catch_syntax == true and supports_cpp_origin == true and supports_python_origin == true }
    }

  requirement def ContainTableVersionNumber {
    subject;
    doc /* The Schema object shall contain the table version number for proper subschema handling */
    attribute id : String = "REQ-380";
    attribute contains_version_number : Boolean;
    attribute enables_subschema_handling : Boolean;
    stakeholder developer : Developer;
    require constraint VersionNumberForSubschema { contains_version_number == true implies enables_subschema_handling == true }
    }

  requirement def ProvideBaseMeasurementTaskClass {
    subject;
    doc /* The measurement framework shall provide a base class for measurement tasks that includes callMeasure methods */
    attribute id : String = "REQ-375";
    attribute provides_base_class : Boolean;
    attribute includes_call_measure : Boolean;
    stakeholder developer : Developer;
    require constraint BaseClassWithCallMeasure { provides_base_class == true and includes_call_measure == true }
    }

  requirement def Stub_REQ377_1 {
    subject;
    doc /* All meas_base Plugin documentation shall be accurate */
    attribute id : String = "REQ-377.1";
    stakeholder developer : Developer;
    }

  requirement def RespondToOcsCommands {
    subject;
    doc /* The OCS Interface shall respond to all incoming OCS commands from the OCS system */
    attribute id : String = "REQ-389";
    attribute incoming_command_received : Boolean;
    attribute response_generated : Boolean;
    attribute response_sent : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint CommandResponseSequence { incoming_command_received == true implies response_generated == true and response_sent == true }
    }

  requirement def SendOcsCommands {
    subject;
    doc /* The OCS Interface shall send all OCS commands to the target OCS system */
    attribute id : String = "REQ-388";
    attribute target_system : String;
    attribute command_sent : Boolean;
    attribute command_delivery_confirmed : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint CommandDeliveryVerification { command_sent == true implies command_delivery_confirmed == true }
    }

  #derivation dependency from BuildSystemRequirements::ProvideManifestLocation to BuildSystemRequirements::SaveManifestFile;
  #trace dependency from BuildSystemRequirements::IncludeEupsTagInEmail to BuildSystemRequirements::SaveManifestFile;
  #trace dependency from BuildSystemRequirements::IncludeEupsTagInEmail to BuildSystemRequirements::ProvideManifestLocation;
  #trace dependency from BuildSystemRequirements::UpgradeLsstPackages to BuildSystemRequirements::SaveManifestFile;
  #refinement dependency from BuildSystemRequirements::ExecuteEupsDistribCreate to BuildSystemRequirements::ExecuteLsstBuildScripts;
  #derivation dependency from BuildSystemRequirements::ReuseBuildIds to BuildSystemRequirements::CompareManifests;
  #trace dependency from BuildSystemRequirements::RelinkAstrometryData to BuildSystemRequirements::SaveManifestFile;
  #trace dependency from BuildSystemRequirements::CompareManifests to BuildSystemRequirements::SaveManifestFile;
  #trace dependency from BuildSystemRequirements::ConfigurableTestBinaryDirectory to BuildSystemRequirements::BuildUnitTestsOnTarget;
  #trace dependency from BuildSystemRequirements::BuildUnitTestsOnTarget to BuildSystemRequirements::ExecuteUnitTestsOnTarget;
  #refinement dependency from BuildSystemRequirements::LimitAstrometrySkyCoverage to DocumentationRequirements::CreateAstrometryIndexInstructions;
  #trace dependency from BuildSystemRequirements::RenamePrepareToCLone to BuildSystemRequirements::CompareManifests;
  #trace dependency from BuildSystemRequirements::ImplementStateOfArtAlgorithms to SystemArchitectureRequirements::ImplementSeparateExceptionClasses;
  #refinement dependency from BuildSystemRequirements::ImplementPixelsFlagsAlgorithm to BuildSystemRequirements::ImplementStateOfArtAlgorithms;
  #refinement dependency from BuildSystemRequirements::ImplementSkyCoordAlgorithm to BuildSystemRequirements::ImplementStateOfArtAlgorithms;
  #refinement dependency from BuildSystemRequirements::ImplementClassificationAlgorithm to BuildSystemRequirements::ImplementStateOfArtAlgorithms;
  #refinement dependency from BuildSystemRequirements::ImplementDerivativesBasedOptimizer to BuildSystemRequirements::ImplementStateOfArtAlgorithms;
  #trace dependency from BuildSystemRequirements::ImplementPythonExceptionHandling to SystemArchitectureRequirements::ImplementSeparateExceptionClasses;
  #trace dependency from BuildSystemRequirements::ImplementPythonExceptionHandling to SystemArchitectureRequirements::ProvideCommonBaseExceptionClass;
  #trace dependency from BuildSystemRequirements::ImplementPythonFailMethods to BuildSystemRequirements::ImplementPythonExceptionHandling;
  #trace dependency from BuildSystemRequirements::ConfigureGaussianFluxAlgorithm to BuildSystemRequirements::ConfigureNaiveFluxAlgorithm;
  #trace dependency from BuildSystemRequirements::MakePsfFluxOperational to BuildSystemRequirements::MakeSdssShapeOperational;
  #trace dependency from BuildSystemRequirements::MakePsfFluxOperational to BuildSystemRequirements::MakeSdssCentroidOperational;
  #trace dependency from BuildSystemRequirements::MakePsfFluxOperational to BuildSystemRequirements::MakeSincFluxOperational;
  #trace dependency from BuildSystemRequirements::CompleteReasonableMeasurements to BuildSystemRequirements::RespondToConfigurationOptions;
  #trace dependency from BuildSystemRequirements::CompleteReasonableMeasurements to BuildSystemRequirements::HandleExceptionsThroughFlags;
  #trace dependency from BuildSystemRequirements::ProvideSlotKeyAlternative to BuildSystemRequirements::ImplementSourceRecordGetters;
  #trace dependency from BuildSystemRequirements::ImplementSourceRecordGetters to BuildSystemRequirements::ImplementSingleValueGetters;
  #trace dependency from BuildSystemRequirements::PersistSlotInformationToFits to VersionManagementRequirements::PersistVersionToFitsFile;
  #trace dependency from BuildSystemRequirements::ImplementBasicFunctorKeys to BuildSystemRequirements::ProvideSufficientFunctorKeys;
  #trace dependency from BuildSystemRequirements::UseUnderscoreInFieldNames to BuildSystemRequirements::EndDotToUnderscoreMapping;
  #trace dependency from BuildSystemRequirements::SeparateForcedPhotometryTask to BuildSystemRequirements::ShareCommonBaseClass;
  #trace dependency from BuildSystemRequirements::ShareCommonBaseClass to BuildSystemRequirements::MoveCallPluginFunctions;
  #trace dependency from BuildSystemRequirements::ImplementProcessImageForcedTask to BuildSystemRequirements::ImplementProcessForcedCcdTask;
  #trace dependency from BuildSystemRequirements::ImplementProcessForcedCcdTask to BuildSystemRequirements::ImplementProcessForcedCoaddTask;
  #refinement dependency from BuildSystemRequirements::ReceiveStartReadoutEvents to BuildSystemRequirements::SubscribeToStartReadoutEvents;
  #derivation dependency from BuildSystemRequirements::SubmitJobsOnIntegrationEvent to BuildSystemRequirements::SendStartIntegrationEvent;
  #derivation dependency from BuildSystemRequirements::SubscribeToStartReadoutEvents to BuildSystemRequirements::SendStartReadoutEvent;
  #derivation dependency from BuildSystemRequirements::PullDataOnReadoutEvent to BuildSystemRequirements::ReceiveStartReadoutEvents;
  #trace dependency from BuildSystemRequirements::SendStartIntegrationEvent to BuildSystemRequirements::SendStartReadoutEvent;
  #trace dependency from BuildSystemRequirements::SubmitJobsOnIntegrationEvent to BuildSystemRequirements::PullDataOnReadoutEvent;
  #refinement dependency from BuildSystemRequirements::ValidateCssFacade to BuildSystemRequirements::ValidateCssFacadeConstruction;
  #refinement dependency from BuildSystemRequirements::ReportErrorsEarly to BuildSystemRequirements::ValidateCssFacadeConstruction;
  #refinement dependency from BuildSystemRequirements::SplitKeyValueExceptions to BuildSystemRequirements::SplitKvInterfaceExceptions;
  #refinement dependency from BuildSystemRequirements::SplitDatabaseTableExceptions to BuildSystemRequirements::SplitKvInterfaceExceptions;
  #refinement dependency from BuildSystemRequirements::UseConciseExceptionNames to DocumentationRequirements::CssExceptionNamingConventions;
  #derivation dependency from BuildSystemRequirements::RetrieveTemplatedValues to BuildSystemRequirements::UseConfigurationTemplates;
  #trace dependency from BuildSystemRequirements::UseConciseExceptionNames to SystemArchitectureRequirements::ProvideCommonBaseExceptionClass;
  #trace dependency from BuildSystemRequirements::PreventDuplicatedRows to BuildSystemRequirements::CheckChunkLevelBeforeQuery;
  #trace dependency from BuildSystemRequirements::ReturnOrderedResults to BuildSystemRequirements::ReturnDistinctResults;
  #trace dependency from BuildSystemRequirements::UseCzarInsteadOfMaster to BuildSystemRequirements::RenameMasterLibToCzarLib;
  #trace dependency from BuildSystemRequirements::RenameMasterLibToCzarLib to BuildSystemRequirements::RenameStartQservScript;
  #trace dependency from BuildSystemRequirements::GroupIncludeStatements to BuildSystemRequirements::SortIncludeStatements;
  #trace dependency from BuildSystemRequirements::AutoReconnectToMysqld to BuildSystemRequirements::HandleMysqlTimeouts;
  #trace dependency from BuildSystemRequirements::UseLog4cxxImplementation to BuildSystemRequirements::AvoidFormattingWhenDebugDisabled;
  #trace dependency from BuildSystemRequirements::IncludeDistributorComponent to BuildSystemRequirements::AssociateReplicatorWithDistributor;
  #trace dependency from BuildSystemRequirements::EnableJobInformationTransfer to BuildSystemRequirements::EnableDataCopyToDistributor;
  #trace dependency from BuildSystemRequirements::AssociateReplicatorWithDistributor to BuildSystemRequirements::EnableJobInformationTransfer;
  #trace dependency from BuildSystemRequirements::AssociateReplicatorWithDistributor to BuildSystemRequirements::EnableDataCopyToDistributor;
  #trace dependency from BuildSystemRequirements::SubmitJobsOnIntegrationEvent to BuildSystemRequirements::EnableJobInformationTransfer;
  #trace dependency from BuildSystemRequirements::PullDataOnReadoutEvent to BuildSystemRequirements::EnableDataCopyToDistributor;
  #trace dependency from BuildSystemRequirements::ReceiveVisitIdentification to BuildSystemRequirements::ReceiveExposureSequenceNumbers;
  #trace dependency from BuildSystemRequirements::ReceiveRaftIdentification to BuildSystemRequirements::ReceiveVisitIdentification;
  #trace dependency from BuildSystemRequirements::ReceiveNetworkAddress to BuildSystemRequirements::ReceiveRaftIdentification;
  #refinement dependency from BuildSystemRequirements::IncludeBoostDependencyInConfiguration to BuildSystemRequirements::UseEupsStackBoost;
  #refinement dependency from BuildSystemRequirements::RemoveSystemBoostConditionalCode to BuildSystemRequirements::UseEupsStackBoost;
  #refinement dependency from BuildSystemRequirements::PackageLoggingAsLogComponent to BuildSystemRequirements::RestructureLog4cxxPrototype;
  #refinement dependency from BuildSystemRequirements::CleanupXRootDInterfaceCode to BuildSystemRequirements::RewriteXRootDWithAsyncClient;
  #trace dependency from BuildSystemRequirements::IncludeBoostDependencyInConfiguration to BuildSystemRequirements::RemoveSystemBoostConditionalCode;
  #trace dependency from BuildSystemRequirements::RestructureLog4cxxPrototype to BuildSystemRequirements::PackageLog4cxxVersion;
  #trace dependency from BuildSystemRequirements::PackageLoggingAsLogComponent to BuildSystemRequirements::PackageLog4cxxVersion;
  #trace dependency from BuildSystemRequirements::ResolveQservCoreCircularDependencies to BuildSystemRequirements::EliminateWschedWcontrolCircularDependency;
  #trace dependency from BuildSystemRequirements::ResolveQservCoreCircularDependencies to BuildSystemRequirements::EliminateControlQdispCircularDependency;
  #trace dependency from BuildSystemRequirements::ResolveQservCoreCircularDependencies to BuildSystemRequirements::EliminateQanaQprocQueryCircularDependencies;
  #trace dependency from BuildSystemRequirements::ResolveQservCoreCircularDependencies to BuildSystemRequirements::EliminateParserQueryCircularDependency;
  #trace dependency from BuildSystemRequirements::EliminateWschedWcontrolCircularDependency to BuildSystemRequirements::EliminateControlQdispCircularDependency;
  #trace dependency from BuildSystemRequirements::EliminateWschedWcontrolCircularDependency to BuildSystemRequirements::EliminateQanaQprocQueryCircularDependencies;
  #trace dependency from BuildSystemRequirements::EliminateWschedWcontrolCircularDependency to BuildSystemRequirements::EliminateParserQueryCircularDependency;
  #trace dependency from BuildSystemRequirements::EliminateControlQdispCircularDependency to BuildSystemRequirements::EliminateQanaQprocQueryCircularDependencies;
  #trace dependency from BuildSystemRequirements::EliminateControlQdispCircularDependency to BuildSystemRequirements::EliminateParserQueryCircularDependency;
  #trace dependency from BuildSystemRequirements::EliminateQanaQprocQueryCircularDependencies to BuildSystemRequirements::EliminateParserQueryCircularDependency;
  #trace dependency from BuildSystemRequirements::RewriteXRootDWithAsyncClient to SystemArchitectureRequirements::ImplementAsynchronousXRootDClient;
  #trace dependency from BuildSystemRequirements::MigrateCzarToNewLogging to BuildSystemRequirements::RestructureLog4cxxPrototype;
  #refinement dependency from BuildSystemRequirements::PostConstructionAliasChanges to BuildSystemRequirements::StringSubstitutionAlias;
  #trace dependency from BuildSystemRequirements::DirectRecordInterface to BuildSystemRequirements::OptionalResultInterface;
  #trace dependency from BuildSystemRequirements::PipeTasksCompatibility to BuildSystemRequirements::ObsPackagesCompatibility;
  #trace dependency from BuildSystemRequirements::TracingNamingConvention to BuildSystemRequirements::CompleteReasonableMeasurements;
  #trace dependency from BuildSystemRequirements::PipeTasksCompatibility to BuildSystemRequirements::CompleteReasonableMeasurements;
  #trace dependency from BuildSystemRequirements::ObsPackagesCompatibility to BuildSystemRequirements::CompleteReasonableMeasurements;
  #refinement dependency from BuildSystemRequirements::LaunchWorkerJobsOnNextVisitEvent to BuildSystemRequirements::SendStartIntegrationEvent;
  #refinement dependency from BuildSystemRequirements::LaunchWorkerJobWithParameters to BuildSystemRequirements::LaunchWorkerJobsOnNextVisitEvent;
  #refinement dependency from BuildSystemRequirements::PerformImageRetrievalTwice to BuildSystemRequirements::ContactDistributorForImage;
  #derivation dependency from BuildSystemRequirements::MaintainStableExecutionOnSlotRemoval to TestingRequirements::ExecuteSlotRemovalScenario;
  #derivation dependency from BuildSystemRequirements::ProvideStableExecutionPath to BuildSystemRequirements::MaintainStableExecutionOnSlotRemoval;
  #trace dependency from BuildSystemRequirements::ManageMultipleDataDependencyTypes to BuildSystemRequirements::CacheHeterogeneousDataDependencies;
  #trace dependency from BuildSystemRequirements::ComputeSpatialRegionWithMargin to BuildSystemRequirements::RetrieveObjectsFromDataRelease;
  #trace dependency from BuildSystemRequirements::RetrieveObjectsFromDataRelease to BuildSystemRequirements::RetrieveDiaObjectsAndSources;
  #trace dependency from BuildSystemRequirements::ContactDistributorForImage to ProjectManagementRequirements::ContactArchiveDMCSForDistributor;
  #refinement dependency from BuildSystemRequirements::ModelDcrAmplitudesFromSed to TestingRequirements::ModelDcrAmplitudes;
  #refinement dependency from BuildSystemRequirements::AcceptSedDataForDcrCalculations to TestingRequirements::AcceptSedDataFormats;
  #refinement dependency from BuildSystemRequirements::OutputDcrAmplitudeValues to TestingRequirements::OutputRefractionAmplitudePrecision;
  #refinement dependency from BuildSystemRequirements::ModelAtmosphericRefractionAmplitudes to TestingRequirements::CalculateRefractionAmplitudes;
  #refinement dependency from BuildSystemRequirements::AcceptSedDataForRefractionCalculations to TestingRequirements::AcceptSedDataFormats;
  #refinement dependency from BuildSystemRequirements::OutputRefractionAmplitudeValues to TestingRequirements::OutputRefractionAmplitudePrecision;
  #trace dependency from BuildSystemRequirements::ModelDcrAmplitudesFromSed to BuildSystemRequirements::ModelAtmosphericRefractionAmplitudes;
  #trace dependency from BuildSystemRequirements::AcceptSedDataForDcrCalculations to BuildSystemRequirements::AcceptSedDataForRefractionCalculations;
  #trace dependency from BuildSystemRequirements::OutputDcrAmplitudeValues to BuildSystemRequirements::OutputRefractionAmplitudeValues;
  #refinement dependency from BuildSystemRequirements::AprBuildInstallSharedLibraries to BuildSystemRequirements::AprBuildInstallLibraries;
  #refinement dependency from BuildSystemRequirements::AprBuildInstallStaticLibraries to BuildSystemRequirements::AprBuildInstallLibraries;
  #refinement dependency from BuildSystemRequirements::AprBuildSharedLibraries to BuildSystemRequirements::AprBuildInstallSharedLibraries;
  #refinement dependency from BuildSystemRequirements::AprInstallSharedLibraries to BuildSystemRequirements::AprBuildInstallSharedLibraries;
  #refinement dependency from BuildSystemRequirements::AprBuildStaticLibraries to BuildSystemRequirements::AprBuildInstallStaticLibraries;
  #refinement dependency from BuildSystemRequirements::AprInstallStaticLibraries to BuildSystemRequirements::AprBuildInstallStaticLibraries;
  #refinement dependency from BuildSystemRequirements::AprUtilBuildSharedLibrariesInAdditionToStatic to BuildSystemRequirements::AprUtilBuildInstallSharedAndStaticLibraries;
  #refinement dependency from BuildSystemRequirements::AprUtilInstallSharedLibrariesInAdditionToStatic to BuildSystemRequirements::AprUtilBuildInstallSharedAndStaticLibraries;
  #refinement dependency from BuildSystemRequirements::AprUtilBuildStaticLibraries to BuildSystemRequirements::AprUtilBuildInstallSharedAndStaticLibraries;
  #refinement dependency from BuildSystemRequirements::AprUtilInstallStaticLibraries to BuildSystemRequirements::AprUtilBuildInstallSharedAndStaticLibraries;
  #trace dependency from BuildSystemRequirements::PackageXrootdWithEups to TestingRequirements::UtilizeNewXRootDImplementation;
  #trace dependency from BuildSystemRequirements::PackageXrootdWithEups to BuildSystemRequirements::RewriteXRootDWithAsyncClient;
  #refinement dependency from BuildSystemRequirements::RedesignPythonInterfaceForSmallerSurface to BuildSystemRequirements::RedesignPythonInterfaceForSmallerIntuitive;
  #refinement dependency from BuildSystemRequirements::RedesignPythonInterfaceForIntuitive to BuildSystemRequirements::RedesignPythonInterfaceForSmallerIntuitive;
  #trace dependency from BuildSystemRequirements::MigrateQservWorkerToNewLogging to TestingRequirements::ProvideComprehensiveLogPackageTests;
  #trace dependency from BuildSystemRequirements::EliminateCompilerWarningsInLogPackage to BuildSystemRequirements::BuildUnitTestsOnTarget;
  #refinement dependency from BuildSystemRequirements::SupportSingleFrameMeasurementTask to BuildSystemRequirements::SupportBothMeasurementTaskTypes;
  #refinement dependency from BuildSystemRequirements::SupportForcedMeasurementTask to BuildSystemRequirements::SupportBothMeasurementTaskTypes;
  #refinement dependency from BuildSystemRequirements::Stub_REQ377_1 to DocumentationRequirements::AccurateSpecificPluginDocumentation;
  #refinement dependency from BuildSystemRequirements::ThrowableExceptionSyntax to BuildSystemRequirements::ConsistentExceptionSyntax;
  #refinement dependency from BuildSystemRequirements::CatchableExceptionSyntax to BuildSystemRequirements::ConsistentExceptionSyntax;
  #trace dependency from BuildSystemRequirements::SupportBothMeasurementTaskTypes to BuildSystemRequirements::ShareCommonBaseClass;
  #trace dependency from BuildSystemRequirements::ProvideBaseMeasurementTaskClass to BuildSystemRequirements::ShareCommonBaseClass;
  #trace dependency from BuildSystemRequirements::AcceptResultObjectAsOutput to BuildSystemRequirements::DirectRecordInterface;
  #trace dependency from BuildSystemRequirements::SupportPartialMeasurementValues to BuildSystemRequirements::HandleExceptionsThroughFlags;
  #trace dependency from BuildSystemRequirements::ProvidePythonExceptionHierarchy to SystemArchitectureRequirements::ProvideCommonBaseExceptionClass;
  #trace dependency from BuildSystemRequirements::SupportCustomMeasurementExceptions to BuildSystemRequirements::ImplementPythonExceptionHandling;
  #trace dependency from BuildSystemRequirements::ContainTableVersionNumber to VersionManagementRequirements::PersistVersionToFitsFile;
  #trace dependency from BuildSystemRequirements::UseVersionForSubschemaHandling to BuildSystemRequirements::PersistSlotInformationToFits;
  #trace dependency from BuildSystemRequirements::AssumeVersionZeroWithAfwType to VersionManagementRequirements::AssignVersionZeroForLegacyTables;
  #trace dependency from BuildSystemRequirements::AssumeVersionOneWithoutAfwType to VersionManagementRequirements::AssignVersionOneForS14Tables;
  #trace dependency from BuildSystemRequirements::ImplementPeakLikelihoodFlux to BuildSystemRequirements::ImplementClassificationAlgorithm;
  #trace dependency from BuildSystemRequirements::SendOcsCommands to BuildSystemRequirements::RespondToOcsCommands;
  }

package InstallationRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def DetermineUrlLocation {
    subject;
    doc /* The project team shall determine the final URL location for Winter'14 stack files */
    attribute id : String = "REQ-020";
    attribute stack_version : String = "Winter'14";
    attribute url_location : String;
    attribute location_determined : Boolean;
    stakeholder manager : Manager;
    stakeholder user : User;
    require constraint UrlLocationDetermination { stack_version == "Winter'14" implies location_determined == true }
    }

  requirement def CheckPythonExistence {
    subject;
    doc /* The newinstall.sh script shall check for python existence on user machines */
    attribute id : String = "REQ-019";
    attribute script_name : String = "newinstall.sh";
    attribute python_available : Boolean;
    attribute check_performed : Boolean;
    stakeholder user : User;
    require constraint PythonExistenceCheck { script_name == "newinstall.sh" implies check_performed == true }
    }

  requirement def CheckGitExistence {
    subject;
    doc /* The newinstall.sh script shall check for git existence on user machines */
    attribute id : String = "REQ-018";
    attribute script_name : String = "newinstall.sh";
    attribute git_available : Boolean;
    attribute check_performed : Boolean;
    stakeholder user : User;
    require constraint GitExistenceCheck { script_name == "newinstall.sh" implies check_performed == true }
    }

  requirement def EnableStackSetupForAnyBuild {
    subject;
    doc /* The CI system shall enable users on lsst-dev to easily setup the stack for any build */
    attribute id : String = "REQ-087";
    attribute target_platform : String = "lsst-dev";
    attribute setup_complexity : String = "easy";
    attribute build_scope : String = "any";
    attribute setup_enabled : Boolean;
    attribute user_access_available : Boolean;
    stakeholder developer : Developer;
    require constraint EasySetupEnabled { target_platform == "lsst-dev" and setup_complexity == "easy" implies setup_enabled == true }
    require constraint UserAccessProvided { setup_enabled == true implies user_access_available == true }
    }

  requirement def UseGeomEupsPackage {
    subject;
    doc /* The Qserv configuration system shall use the geom eups package for installing geometry */
    attribute id : String = "REQ-158";
    attribute package_name : String = "geom";
    attribute package_manager : String = "eups";
    attribute installation_target : String = "geometry";
    attribute uses_geom_package : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint GeomPackageUsage { package_name == "geom" and package_manager == "eups" and installation_target == "geometry" implies uses_geom_package == true }
    }

  requirement def ImplementWaitForPidFunctionality {
    subject;
    doc /* The xrootd init.d script shall implement wait_for_pid functionality to properly detect startup failures */
    attribute id : String = "REQ-206";
    attribute script_name : String = "xrootd init.d";
    attribute functionality_name : String = "wait_for_pid";
    attribute detection_target : String = "startup failures";
    attribute wait_for_pid_implemented : Boolean;
    attribute startup_failure_detected : Boolean;
    stakeholder administrator : Administrator;
    require constraint WaitForPidImplementation { script_name == "xrootd init.d" and functionality_name == "wait_for_pid" implies (wait_for_pid_implemented == true and startup_failure_detected == true) }
    }

  requirement def ProvideEndToEndLoadingScript {
    subject;
    doc /* The system shall provide an end-to-end loading script for single node data loading */
    attribute id : String = "REQ-176";
    attribute script_type : String = "end-to-end loading";
    attribute target_configuration : String = "single node";
    attribute operation_type : String = "data loading";
    attribute script_provided : Boolean;
    stakeholder administrator : Administrator;
    stakeholder user : User;
    require constraint LoadingScriptProvision { script_type == "end-to-end loading" and target_configuration == "single node" and operation_type == "data loading" implies script_provided == true }
    }

  requirement def ProvideLsbCompliantInitScripts {
    subject;
    doc /* The Qserv services shall provide Linux Standard Base compliant init.d scripts */
    attribute id : String = "REQ-205";
    attribute compliance_standard : String = "Linux Standard Base";
    attribute script_location : String = "init.d";
    attribute target_services : String = "Qserv services";
    attribute lsb_compliant : Boolean;
    stakeholder administrator : Administrator;
    require constraint LsbComplianceCheck { compliance_standard == "Linux Standard Base" implies lsb_compliant == true }
    }

  requirement def PreventGeometryDownload {
    subject;
    doc /* The Qserv configuration system shall not download geometry.py during the configuration step */
    attribute id : String = "REQ-159";
    attribute target_file : String = "geometry.py";
    attribute configuration_phase : String = "configuration step";
    attribute downloads_geometry_file : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint GeometryDownloadPrevention { configuration_phase == "configuration step" implies downloads_geometry_file == false }
    }

  requirement def RefactorInstallDistributionProcedures {
    subject;
    doc /* The system shall refactor install and distribution procedures to use lsst-sw framework */
    attribute id : String = "REQ-329";
    attribute framework_name : String = "lsst-sw";
    attribute install_procedures_refactored : Boolean;
    attribute distribution_procedures_refactored : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint RefactorProcedures { install_procedures_refactored == true and distribution_procedures_refactored == true }
    }

  requirement def AutomatedMultiNodeQservSetup {
    subject;
    doc /* The installation scripts shall support automated setup of multi-node Qserv configurations */
    attribute id : String = "REQ-328";
    attribute automation_supported : Boolean;
    attribute multi_node_configuration : Boolean;
    attribute qserv_system : String = "Qserv";
    stakeholder administrator : Administrator;
    stakeholder systemOperator : SystemOperator;
    require constraint AutomatedMultiNodeSupport { automation_supported == true and multi_node_configuration == true }
    }

  requirement def MaintainStandbyArchiveDMCS {
    subject;
    doc /* The AP Simulator system shall maintain a standby Archive DMCS instance for fault tolerance */
    attribute id : String = "REQ-358";
    attribute standby_archive_instance_maintained : Boolean;
    attribute fault_tolerance_enabled : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint StandbyArchiveForFaultTolerance { fault_tolerance_enabled == true implies standby_archive_instance_maintained == true }
    }

  requirement def AutoActivateStandbyBaseDMCS {
    subject;
    doc /* The standby Base DMCS shall automatically activate when the primary Base DMCS fails */
    attribute id : String = "REQ-359";
    attribute automatic_activation_enabled : Boolean;
    attribute primary_dmcs_failed : Boolean;
    attribute standby_dmcs_activated : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint AutoActivateOnFailure { primary_dmcs_failed == true implies standby_dmcs_activated == true }
    assume constraint AutoActivationCapable { automatic_activation_enabled == true }
    }

  requirement def AutoActivateStandbyArchiveDMCS {
    subject;
    doc /* The standby Archive DMCS shall automatically activate when the primary Archive DMCS fails */
    attribute id : String = "REQ-360";
    attribute automatic_activation_enabled : Boolean;
    attribute primary_archive_dmcs_failed : Boolean;
    attribute standby_archive_dmcs_activated : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint AutoActivateArchiveOnFailure { primary_archive_dmcs_failed == true implies standby_archive_dmcs_activated == true }
    assume constraint ArchiveAutoActivationCapable { automatic_activation_enabled == true }
    }

  requirement def MaintainStandbyBaseDMCS {
    subject;
    doc /* The AP Simulator system shall maintain a standby Base DMCS instance for fault tolerance */
    attribute id : String = "REQ-357";
    attribute standby_instance_maintained : Boolean;
    attribute fault_tolerance_enabled : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint StandbyBaseForFaultTolerance { fault_tolerance_enabled == true implies standby_instance_maintained == true }
    }

  requirement def SupportOfflineQservDeployment {
    subject;
    doc /* The Qserv installation process shall support deployment on machines without external internet connectivity */
    attribute id : String = "REQ-366";
    attribute internet_connectivity_required : Boolean;
    attribute offline_deployment_supported : Boolean;
    attribute installation_success_rate : Real;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint OfflineDeploymentCapability { internet_connectivity_required == false implies offline_deployment_supported == true }
    require constraint OfflineInstallationReliability { offline_deployment_supported == true implies installation_success_rate >= 0.95 }
    }

  #trace dependency from InstallationRequirements::CheckGitExistence to InstallationRequirements::CheckPythonExistence;
  #trace dependency from InstallationRequirements::UseGeomEupsPackage to InstallationRequirements::PreventGeometryDownload;
  #trace dependency from InstallationRequirements::RefactorInstallDistributionProcedures to BuildSystemRequirements::ExecuteLsstBuildScripts;
  #trace dependency from InstallationRequirements::RefactorInstallDistributionProcedures to BuildSystemRequirements::ExecuteEupsDistribCreate;
  #refinement dependency from InstallationRequirements::AutoActivateStandbyBaseDMCS to InstallationRequirements::MaintainStandbyBaseDMCS;
  #refinement dependency from InstallationRequirements::AutoActivateStandbyArchiveDMCS to InstallationRequirements::MaintainStandbyArchiveDMCS;
  #trace dependency from InstallationRequirements::MaintainStandbyBaseDMCS to ProjectManagementRequirements::ImplementReplicatorHeartbeatMechanisms;
  #trace dependency from InstallationRequirements::MaintainStandbyArchiveDMCS to ProjectManagementRequirements::ImplementDistributorHeartbeatMechanisms;
  #trace dependency from InstallationRequirements::MaintainStandbyBaseDMCS to InstallationRequirements::MaintainStandbyArchiveDMCS;
  #trace dependency from InstallationRequirements::AutoActivateStandbyBaseDMCS to InstallationRequirements::AutoActivateStandbyArchiveDMCS;
  #trace dependency from InstallationRequirements::SupportOfflineQservDeployment to ProjectManagementRequirements::MultiNodeDeploymentSupport;
  }

package VersionManagementRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def ConvertIllegalCharacters {
    subject;
    doc /* The version generation system shall convert illegal characters in branch names to dots */
    attribute id : String = "REQ-010";
    attribute original_branch_name : String;
    attribute converted_branch_name : String;
    attribute illegal_chars_converted : Boolean;
    stakeholder developer : Developer;
    require constraint IllegalCharacterConversion { original_branch_name != "" implies illegal_chars_converted == true }
    }

  requirement def ReleaseEupsVersion {
    subject;
    doc /* The development team shall release EUPS version 1.3.0 in RHL's github repository */
    attribute id : String = "REQ-021";
    attribute eups_version : String = "1.3.0";
    attribute repository_location : String = "RHL's github repository";
    attribute release_completed : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint EupsVersionRelease { eups_version == "1.3.0" and repository_location == "RHL's github repository" implies release_completed == true }
    }

  requirement def AppendSuffixForDuplicates {
    subject;
    doc /* The version generation system shall append +N suffix when package with different dependencies already exists */
    attribute id : String = "REQ-011";
    attribute package_exists : Boolean;
    attribute dependencies_differ : Boolean;
    attribute suffix_value : Integer;
    attribute final_version : String;
    stakeholder developer : Developer;
    require constraint SuffixAppendForDuplicates { package_exists == true and dependencies_differ == true implies suffix_value > 0 }
    }

  requirement def UseTagAsVersion {
    subject;
    doc /* The version generation system shall use tag name as version when a tag exists on a commit */
    attribute id : String = "REQ-008";
    attribute tag_exists : Boolean;
    attribute tag_name : String;
    attribute generated_version : String;
    stakeholder developer : Developer;
    require constraint TagAsVersionUsage { tag_exists == true implies generated_version == tag_name }
    }

  requirement def UseBranchShaFormat {
    subject;
    doc /* The version generation system shall use branchname-gSHA1ABBREV format when no tag exists on a commit */
    attribute id : String = "REQ-009";
    attribute branch_name : String;
    attribute sha1_abbreviation : String;
    attribute version_format : String = "branchname-gSHA1ABBREV";
    attribute tag_exists : Boolean;
    stakeholder developer : Developer;
    require constraint BranchShaFormatUsage { tag_exists == false implies version_format == "branchname-gSHA1ABBREV" }
    }

  requirement def UseGitDatabaseForVersioning {
    subject;
    doc /* The versioner component shall use git database by default for version information */
    attribute id : String = "REQ-066";
    attribute default_version_source : String = "git_database";
    attribute git_database_available : Boolean;
    attribute version_source_used : String;
    stakeholder developer : Developer;
    require constraint GitDatabaseDefault { git_database_available == true implies version_source_used == "git_database" }
    }

  requirement def FallbackToHashBasedVersioning {
    subject;
    doc /* The versioner component shall fall back to hash-based version generation when git database is unavailable */
    attribute id : String = "REQ-067";
    attribute fallback_version_method : String = "hash_based";
    attribute git_database_available : Boolean;
    attribute version_generation_method : String;
    stakeholder developer : Developer;
    require constraint FallbackVersioning { git_database_available == false implies version_generation_method == "hash_based" }
    }

  requirement def IncludeVersionNumberInStructure {
    subject;
    doc /* The SourceTable shall include version number in its structure */
    attribute id : String = "REQ-130";
    attribute has_version_field : Boolean;
    attribute version_field_type : String;
    stakeholder developer : Developer;
    require constraint VersionFieldPresent { has_version_field == true and version_field_type != "" }
    }

  requirement def ContinueDotToUnderscoreMapping {
    subject;
    doc /* The system shall continue dot-to-underscore mapping for files without version or with version below threshold */
    attribute id : String = "REQ-140";
    attribute file_has_version : Boolean;
    attribute version_below_threshold : Boolean;
    attribute dot_to_underscore_mapping_active : Boolean;
    attribute version_threshold : Integer;
    stakeholder developer : Developer;
    require constraint MappingForLegacyFiles { (file_has_version == false or version_below_threshold == true) implies dot_to_underscore_mapping_active == true }
    }

  requirement def ProvideSetVersionMethod {
    subject;
    doc /* The SourceTable shall provide setVersion method for clients to modify version number */
    attribute id : String = "REQ-136";
    attribute set_version_method_available : Boolean;
    attribute method_accepts_version : Boolean;
    attribute client_modification_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint SetVersionMethodFunctionality { set_version_method_available == true and method_accepts_version == true implies client_modification_enabled == true }
    }

  requirement def AssignVersionZeroForLegacyTables {
    subject;
    doc /* The system shall assign version number 0 to tables created prior to versioning modification */
    attribute id : String = "REQ-133";
    attribute legacy_table_detected : Boolean;
    attribute assigned_version_number : Integer = 0;
    attribute created_before_versioning : Boolean;
    stakeholder developer : Developer;
    require constraint LegacyTableVersionAssignment { legacy_table_detected == true and created_before_versioning == true implies assigned_version_number == 0 }
    }

  requirement def ProvideGetVersionMethod {
    subject;
    doc /* The SourceTable shall provide getVersion method for clients to access version number */
    attribute id : String = "REQ-135";
    attribute get_version_method_available : Boolean;
    attribute method_returns_version : Boolean;
    attribute client_access_enabled : Boolean;
    stakeholder developer : Developer;
    require constraint GetVersionMethodFunctionality { get_version_method_available == true and method_returns_version == true implies client_access_enabled == true }
    }

  requirement def MaintainBackwardCompatibility {
    subject;
    doc /* The system shall maintain backward compatibility for files with version less than specified threshold */
    attribute id : String = "REQ-139";
    attribute version_threshold : Integer;
    attribute file_version : Integer;
    attribute backward_compatibility_maintained : Boolean;
    stakeholder developer : Developer;
    require constraint BackwardCompatibilityForOldVersions { file_version < version_threshold implies backward_compatibility_maintained == true }
    }

  requirement def AssignVersionOneForS14Tables {
    subject;
    doc /* The system shall assign version number 1 to tables created with S14 version */
    attribute id : String = "REQ-134";
    attribute s14_version_detected : Boolean;
    attribute assigned_version_number : Integer = 1;
    attribute created_with_s14 : Boolean;
    stakeholder developer : Developer;
    require constraint S14TableVersionAssignment { s14_version_detected == true and created_with_s14 == true implies assigned_version_number == 1 }
    }

  requirement def PersistVersionToFitsFile {
    subject;
    doc /* The system shall persist SourceTable version number to FITS file when table is saved */
    attribute id : String = "REQ-131";
    attribute version_persisted : Boolean;
    attribute fits_file_format : String;
    attribute save_operation_triggered : Boolean;
    stakeholder developer : Developer;
    require constraint VersionPersistenceOnSave { save_operation_triggered == true implies version_persisted == true }
    }

  requirement def RestoreVersionFromFitsFile {
    subject;
    doc /* The system shall restore SourceTable version number when table is loaded from FITS */
    attribute id : String = "REQ-132";
    attribute version_restored : Boolean;
    attribute fits_file_loaded : Boolean;
    attribute restored_version_number : Integer;
    stakeholder developer : Developer;
    require constraint VersionRestorationOnLoad { fits_file_loaded == true implies version_restored == true }
    }

  requirement def UpgradeKazooVersion {
    subject;
    doc /* The system shall use kazoo version 2.0b1 or later instead of version 1.3.1 */
    attribute id : String = "REQ-182";
    attribute current_version : String = "1.3.1";
    attribute required_min_version : String = "2.0b1";
    attribute installed_version : String;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint VersionUpgrade { current_version == "1.3.1" implies installed_version != "1.3.1" }
    require constraint MinimumVersionCompliance { required_min_version == "2.0b1" }
    }

  requirement def PreserveDataWhenSwitchingBranches {
    subject;
    doc /* The configuration system shall preserve MySQL and ZooKeeper data when switching software branches */
    attribute id : String = "REQ-272";
    attribute mysql_data_preserved : Boolean;
    attribute zookeeper_data_preserved : Boolean;
    attribute branch_switch_operation : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint DataPreservationOnBranchSwitch { branch_switch_operation == true implies mysql_data_preserved == true and zookeeper_data_preserved == true }
    }

  requirement def PreserveMySQLDataWhenSwitchingBranches {
    subject;
    doc /* The configuration system shall preserve MySQL data when switching software branches */
    attribute id : String = "REQ-272.1";
    attribute mysql_data_preserved : Boolean;
    attribute branch_switch_operation : Boolean;
    attribute mysql_connection_active : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint MySQLDataPreservationOnBranchSwitch { branch_switch_operation == true implies mysql_data_preserved == true }
    assume constraint MySQLConnectionActive { mysql_connection_active == true }
    }

  requirement def PreserveZooKeeperDataWhenSwitchingBranches {
    subject;
    doc /* The configuration system shall preserve ZooKeeper data when switching software branches */
    attribute id : String = "REQ-272.2";
    attribute zookeeper_data_preserved : Boolean;
    attribute branch_switch_operation : Boolean;
    attribute zookeeper_connection_active : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ZooKeeperDataPreservationOnBranchSwitch { branch_switch_operation == true implies zookeeper_data_preserved == true }
    assume constraint ZooKeeperConnectionActive { zookeeper_connection_active == true }
    }

  requirement def BackwardsSlotCompatibility {
    subject;
    doc /* The system shall provide backwards compatibility for code that uses slots to access measurements */
    attribute id : String = "REQ-294";
    attribute backwards_compatible : Boolean;
    attribute supports_slot_access : Boolean;
    attribute legacy_code_supported : Boolean;
    stakeholder developer : Developer;
    require constraint BackwardsCompatibilitySupport { backwards_compatible == true and supports_slot_access == true and legacy_code_supported == true }
    }

  requirement def UpdatePackagesForCompactExceptions {
    subject;
    doc /* All packages that use pex_exceptions shall be updated to conform to the new compact exception naming convention. */
    attribute id : String = "REQ-351";
    attribute dependent_packages_updated : Boolean;
    attribute naming_convention_compliance : Boolean;
    attribute pex_exceptions_usage_updated : Boolean;
    attribute package_count : Integer;
    stakeholder developer : Developer;
    require constraint PackageUpdateCompliance { dependent_packages_updated == true and naming_convention_compliance == true and pex_exceptions_usage_updated == true }
    }

  requirement def ImplementCompactExceptionNaming {
    subject;
    doc /* The pex_exceptions package shall implement a more compact naming convention for exceptions to reduce redundancy. */
    attribute id : String = "REQ-350";
    attribute package_name : String = "pex_exceptions";
    attribute compact_naming_implemented : Boolean;
    attribute redundancy_reduced : Boolean;
    attribute naming_convention_updated : Boolean;
    stakeholder developer : Developer;
    require constraint CompactNamingImplemented { compact_naming_implemented == true and redundancy_reduced == true and naming_convention_updated == true }
    }

  requirement def UpdateObsDecamPackage {
    subject;
    doc /* The obs_decam package shall be updated to reflect all changes in the camera geometry implementation. */
    attribute id : String = "REQ-352";
    attribute package_name : String = "obs_decam";
    attribute camera_geometry_changes_reflected : Boolean;
    attribute package_updated : Boolean;
    attribute geometry_implementation_current : Boolean;
    stakeholder developer : Developer;
    require constraint PackageUpdateComplete { package_updated == true implies (camera_geometry_changes_reflected == true and geometry_implementation_current == true) }
    }

  #refinement dependency from VersionManagementRequirements::UseBranchShaFormat to VersionManagementRequirements::UseTagAsVersion;
  #refinement dependency from VersionManagementRequirements::ConvertIllegalCharacters to VersionManagementRequirements::UseTagAsVersion;
  #refinement dependency from VersionManagementRequirements::AppendSuffixForDuplicates to VersionManagementRequirements::UseTagAsVersion;
  #derivation dependency from VersionManagementRequirements::FallbackToHashBasedVersioning to VersionManagementRequirements::UseGitDatabaseForVersioning;
  #trace dependency from VersionManagementRequirements::IncludeVersionNumberInStructure to VersionManagementRequirements::ProvideGetVersionMethod;
  #trace dependency from VersionManagementRequirements::ProvideGetVersionMethod to VersionManagementRequirements::ProvideSetVersionMethod;
  #trace dependency from VersionManagementRequirements::PersistVersionToFitsFile to VersionManagementRequirements::RestoreVersionFromFitsFile;
  #trace dependency from VersionManagementRequirements::AssignVersionZeroForLegacyTables to VersionManagementRequirements::AssignVersionOneForS14Tables;
  #trace dependency from VersionManagementRequirements::MaintainBackwardCompatibility to VersionManagementRequirements::ContinueDotToUnderscoreMapping;
  #refinement dependency from VersionManagementRequirements::PreserveMySQLDataWhenSwitchingBranches to VersionManagementRequirements::PreserveDataWhenSwitchingBranches;
  #refinement dependency from VersionManagementRequirements::PreserveZooKeeperDataWhenSwitchingBranches to VersionManagementRequirements::PreserveDataWhenSwitchingBranches;
  #trace dependency from VersionManagementRequirements::PreserveMySQLDataWhenSwitchingBranches to VersionManagementRequirements::PreserveZooKeeperDataWhenSwitchingBranches;
  #trace dependency from VersionManagementRequirements::BackwardsSlotCompatibility to BuildSystemRequirements::ProvideSlotKeyAlternative;
  #trace dependency from VersionManagementRequirements::ImplementCompactExceptionNaming to BuildSystemRequirements::UseConciseExceptionNames;
  #trace dependency from VersionManagementRequirements::UpdatePackagesForCompactExceptions to VersionManagementRequirements::ImplementCompactExceptionNaming;
  }

package DocumentationRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def ConsolidateDrpReport {
    subject;
    doc /* The documentation team shall consolidate all Split DRP report portions into a single coherent document */
    attribute id : String = "REQ-012";
    attribute report_type : String = "Split DRP";
    attribute consolidation_completed : Boolean;
    attribute single_document_created : Boolean;
    stakeholder developer : Developer;
    stakeholder manager : Manager;
    require constraint DrpReportConsolidation { consolidation_completed == true implies single_document_created == true }
    }

  requirement def UpdateConfluenceInstructions {
    subject;
    doc /* The documentation team shall update Confluence installation instructions for Winter'14 stack */
    attribute id : String = "REQ-014";
    attribute platform : String = "Confluence";
    attribute stack_version : String = "Winter'14";
    attribute instructions_updated : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint ConfluenceInstructionsUpdate { platform == "Confluence" and stack_version == "Winter'14" implies instructions_updated == true }
    }

  requirement def DocumentXrdSsiInterface {
    subject;
    doc /* The development team shall document the new XrdSsi interface capabilities */
    attribute id : String = "REQ-033.2";
    attribute team_type : String = "development";
    attribute interface_name : String = "XrdSsi";
    attribute interface_version : String = "new";
    attribute documentation_required : Boolean = true;
    attribute documentation_completed : Boolean;
    stakeholder developer : Developer;
    require constraint DocumentationCompleted { documentation_required == true implies documentation_completed == true }
    }

  requirement def InvestigateAndDocumentXrdSsiInterface {
    subject;
    doc /* The development team shall investigate and document the new XrdSsi interface capabilities */
    attribute id : String = "REQ-033";
    attribute team_type : String = "development";
    attribute interface_name : String = "XrdSsi";
    attribute interface_version : String = "new";
    attribute investigation_required : Boolean = true;
    attribute documentation_required : Boolean = true;
    attribute investigation_completed : Boolean;
    attribute documentation_completed : Boolean;
    stakeholder developer : Developer;
    require constraint InvestigationAndDocumentationCompleted { investigation_required == true and documentation_required == true implies investigation_completed == true and documentation_completed == true }
    }

  requirement def InvestigateXrdSsiInterface {
    subject;
    doc /* The development team shall investigate the new XrdSsi interface capabilities */
    attribute id : String = "REQ-033.1";
    attribute team_type : String = "development";
    attribute interface_name : String = "XrdSsi";
    attribute interface_version : String = "new";
    attribute investigation_required : Boolean = true;
    attribute investigation_completed : Boolean;
    stakeholder developer : Developer;
    require constraint InvestigationCompleted { investigation_required == true implies investigation_completed == true }
    }

  requirement def BuildDataRepositoriesInstructions {
    subject;
    doc /* The co-addition example shall include instructions for building necessary data repositories */
    attribute id : String = "REQ-074";
    attribute example_context : String = "co_addition";
    attribute repository_type : String = "data_repositories";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint DataRepositoryInstructionsRequired { example_context == "co_addition" and repository_type == "data_repositories" implies instructions_included == true }
    }

  requirement def ProcessRawFilesInstructions {
    subject;
    doc /* The LSSTsim processing example shall include instructions for processing raw files through processCdc including ISR and measurement */
    attribute id : String = "REQ-052";
    attribute example_context : String = "LSSTsim_processing";
    attribute processing_pipeline : String = "processCdc";
    attribute processing_steps : String = "ISR_and_measurement";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint ProcessingInstructionsRequired { example_context == "LSSTsim_processing" and processing_pipeline == "processCdc" and processing_steps == "ISR_and_measurement" implies instructions_included == true }
    }

  requirement def CreateMeasurementCatalogInstructions {
    subject;
    doc /* The LSSTsim processing example shall include instructions for creating a catalog of measurements */
    attribute id : String = "REQ-053";
    attribute example_context : String = "LSSTsim_processing";
    attribute catalog_type : String = "measurements";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint MeasurementCatalogInstructions { example_context == "LSSTsim_processing" and catalog_type == "measurements" implies instructions_included == true }
    }

  requirement def IncludeDataRepositoryInstructions {
    subject;
    doc /* The LSSTsim processing example shall include instructions for creating a data repository for the data */
    attribute id : String = "REQ-050";
    attribute example_context : String = "LSSTsim_processing";
    attribute repository_purpose : String = "data_storage";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint DataRepositoryInstructions { example_context == "LSSTsim_processing" and repository_purpose == "data_storage" implies instructions_included == true }
    }

  requirement def CreateAstrometryIndexInstructions {
    subject;
    doc /* The documentation system shall provide instructions for creating astrometry_net_data index files for arbitrary astronomical datasets */
    attribute id : String = "REQ-041";
    attribute instruction_type : String = "astrometry_net_data_index";
    attribute target_datasets : String = "arbitrary_astronomical";
    attribute instructions_provided : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint AstrometryIndexInstructions { instruction_type == "astrometry_net_data_index" and target_datasets == "arbitrary_astronomical" implies instructions_provided == true }
    }

  requirement def IdentifyRequiredSdssDataSubset {
    subject;
    doc /* The co-addition example shall include instructions for identifying required SDSS data subset */
    attribute id : String = "REQ-072";
    attribute example_context : String = "co_addition";
    attribute data_source : String = "SDSS";
    attribute subset_identification : Boolean;
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint SdssDataSubsetInstructions { example_context == "co_addition" and data_source == "SDSS" implies subset_identification == true and instructions_included == true }
    }

  requirement def CreateAstrometryRepositoryInstructions {
    subject;
    doc /* The documentation system shall provide instructions for creating a repository of astrometry_net_data to support LSST Stack processing */
    attribute id : String = "REQ-042";
    attribute repository_type : String = "astrometry_net_data";
    attribute supported_processing : String = "LSST_Stack";
    attribute instructions_provided : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint AstrometryRepositoryInstructions { repository_type == "astrometry_net_data" and supported_processing == "LSST_Stack" implies instructions_provided == true }
    }

  requirement def RunForcedPhotometryTasks {
    subject;
    doc /* The co-addition example shall include instructions for running forced photometry tasks */
    attribute id : String = "REQ-075.2";
    attribute example_context : String = "co_addition";
    attribute task_type : String = "forced_photometry";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint ForcedPhotometryInstructions { example_context == "co_addition" and task_type == "forced_photometry" implies instructions_included == true }
    }

  requirement def IncludeObsLsstSimExample {
    subject;
    doc /* The Software User Guide shall include a worked example of processing raw data with obs_lsstSim */
    attribute id : String = "REQ-048";
    attribute guide_name : String = "Software_User_Guide";
    attribute example_type : String = "worked_example";
    attribute processing_tool : String = "obs_lsstSim";
    attribute data_type : String = "raw_data";
    attribute example_included : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint ObsLsstSimExampleInclusion { guide_name == "Software_User_Guide" and example_type == "worked_example" and processing_tool == "obs_lsstSim" and data_type == "raw_data" implies example_included == true }
    }

  requirement def IdentifyLsstMachineAccessIssues {
    subject;
    doc /* The co-addition example documentation shall identify issues requiring LSST machine access rights */
    attribute id : String = "REQ-076";
    attribute documentation_context : String = "co_addition_example";
    attribute access_requirement : String = "LSST_machine_access_rights";
    attribute issues_identified : Boolean;
    stakeholder user : User;
    require constraint AccessIssueIdentification { documentation_context == "co_addition_example" and access_requirement == "LSST_machine_access_rights" implies issues_identified == true }
    }

  requirement def EnableMaintenanceActivities {
    subject;
    doc /* The LSST Software Stack documentation shall enable software maintenance activities by providing architecture, design, and implementation details. */
    attribute id : String = "REQ-096.2";
    attribute documentation_scope : String = "LSST_Software_Stack";
    attribute enabled_activities : String = "software_maintenance";
    attribute provided_details : String = "architecture_design_implementation";
    attribute activities_enabled : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint MaintenanceActivitiesEnabled { documentation_scope == "LSST_Software_Stack" and enabled_activities == "software_maintenance" and provided_details == "architecture_design_implementation" implies activities_enabled == true }
    }

  requirement def RunCoAddTasks {
    subject;
    doc /* The co-addition example shall include instructions for running Co-Add tasks */
    attribute id : String = "REQ-075.1";
    attribute example_context : String = "co_addition";
    attribute task_type : String = "Co_Add";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint CoAddTaskInstructions { example_context == "co_addition" and task_type == "Co_Add" implies instructions_included == true }
    }

  requirement def DownloadFilesToLocalMachines {
    subject;
    doc /* The co-addition example shall include instructions for downloading necessary files to local machines */
    attribute id : String = "REQ-073";
    attribute example_context : String = "co_addition";
    attribute download_target : String = "local_machines";
    attribute file_type : String = "necessary_files";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint InstructionsProvided { example_context == "co_addition" implies instructions_included == true }
    }

  requirement def DefineConfluenceOrganizationalStructure {
    subject;
    doc /* The DM team shall define an organizational structure for the DM Confluence space */
    attribute id : String = "REQ-079";
    attribute responsible_team : String = "DM_team";
    attribute structure_scope : String = "DM_Confluence_space";
    attribute structure_defined : Boolean;
    stakeholder manager : Manager;
    require constraint StructureDefinedByTeam { responsible_team == "DM_team" implies structure_defined == true }
    }

  requirement def IncludeVisualizationInstructions {
    subject;
    doc /* The LSSTsim processing example shall include instructions for visualizing output using existing tools */
    attribute id : String = "REQ-054";
    attribute example_context : String = "LSSTsim_processing";
    attribute visualization_method : String = "existing_tools";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint VisualizationInstructionsIncluded { example_context == "LSSTsim_processing" implies instructions_included == true }
    }

  requirement def EnableLevel3Usage {
    subject;
    doc /* The LSST Software Stack documentation shall enable Level 3 usage by providing user guides, API references, and operational procedures. */
    attribute id : String = "REQ-096.3";
    attribute documentation_scope : String = "LSST_Software_Stack";
    attribute usage_level : String = "Level_3";
    attribute provided_materials : String = "user_guides_API_references_operational_procedures";
    attribute usage_enabled : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint Level3UsageEnabled { usage_level == "Level_3" and provided_materials == "user_guides_API_references_operational_procedures" implies usage_enabled == true }
    }

  requirement def RunCoAddAndPhotometryTasks {
    subject;
    doc /* The co-addition example shall include instructions for running Co-Add and forced photometry tasks */
    attribute id : String = "REQ-075";
    attribute example_context : String = "co_addition";
    attribute task_types : String = "Co_Add_and_forced_photometry";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint TaskInstructionsIncluded { example_context == "co_addition" and task_types == "Co_Add_and_forced_photometry" implies instructions_included == true }
    }

  requirement def ProvideComprehensiveDocumentation {
    subject;
    doc /* The LSST Software Stack shall provide comprehensive documentation that meets defined quality standards for completeness, accuracy, and clarity. */
    attribute id : String = "REQ-096.1";
    attribute software_component : String = "LSST_Software_Stack";
    attribute documentation_type : String = "comprehensive";
    attribute quality_standards : String = "completeness_accuracy_clarity";
    attribute standards_met : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint QualityStandardsMet { documentation_type == "comprehensive" and quality_standards == "completeness_accuracy_clarity" implies standards_met == true }
    }

  requirement def ProvideSimplifiedCoAdditionExample {
    subject;
    doc /* The Software User Guide shall provide a simplified co-addition example that works on single-user machines */
    attribute id : String = "REQ-071";
    attribute guide_name : String = "Software_User_Guide";
    attribute example_type : String = "simplified_co_addition";
    attribute target_platform : String = "single_user_machines";
    attribute example_provided : Boolean;
    stakeholder user : User;
    require constraint SimplifiedExampleProvided { guide_name == "Software_User_Guide" and example_type == "simplified_co_addition" and target_platform == "single_user_machines" implies example_provided == true }
    }

  requirement def IncludeAstrometryRepositoryInstructions {
    subject;
    doc /* The LSSTsim processing example shall include instructions for creating an astrometry_net_data repository */
    attribute id : String = "REQ-051";
    attribute example_context : String = "LSSTsim_processing";
    attribute repository_type : String = "astrometry_net_data";
    attribute instructions_included : Boolean;
    stakeholder user : User;
    require constraint AstrometryInstructionsIncluded { example_context == "LSSTsim_processing" and repository_type == "astrometry_net_data" implies instructions_included == true }
    }

  requirement def IncludePhoSimDocumentPointers {
    subject;
    doc /* The LSSTsim processing example shall include pointers to documents for creating multi-band raw datasets with PhoSim */
    attribute id : String = "REQ-049";
    attribute example_context : String = "LSSTsim_processing";
    attribute document_type : String = "multi_band_raw_datasets";
    attribute creation_tool : String = "PhoSim";
    attribute pointers_included : Boolean;
    stakeholder user : User;
    require constraint PhoSimPointersIncluded { example_context == "LSSTsim_processing" and document_type == "multi_band_raw_datasets" and creation_tool == "PhoSim" implies pointers_included == true }
    }

  requirement def CreateConfluenceTaxonomy {
    subject;
    doc /* The DM team shall create a taxonomy for organizing DM Confluence content */
    attribute id : String = "REQ-080";
    attribute responsible_team : String = "DM_team";
    attribute taxonomy_scope : String = "DM_Confluence_content";
    attribute taxonomy_created : Boolean;
    stakeholder manager : Manager;
    require constraint TaxonomyCreated { responsible_team == "DM_team" and taxonomy_scope == "DM_Confluence_content" implies taxonomy_created == true }
    }

  requirement def ProvideWellDocumentedSoftwareStack {
    subject;
    doc /* The LSST Software Stack shall be well documented to enable maintenance and Level 3 usage */
    attribute id : String = "REQ-096";
    attribute software_component : String = "LSST_Software_Stack";
    attribute documentation_quality : String = "well_documented";
    attribute enabled_activities : String = "maintenance_and_Level_3_usage";
    attribute documentation_complete : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint WellDocumentedStack { software_component == "LSST_Software_Stack" and documentation_quality == "well_documented" implies documentation_complete == true }
    }

  requirement def MetadataTableIndexRelationship {
    subject;
    doc /* The metadata structure shall clarify the relationship between driving table and secondary index configuration */
    attribute id : String = "REQ-197";
    attribute driving_table_relationship_clarified : Boolean;
    attribute secondary_index_configuration_defined : Boolean;
    attribute metadata_structure_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint RelationshipClarificationComplete { driving_table_relationship_clarified == true and secondary_index_configuration_defined == true and metadata_structure_documented == true }
    }

  requirement def QservNodeConfigurationBootstrappingDesign {
    subject;
    doc /* The system shall provide a detailed design for node configuration and bootstrapping of Qserv components */
    attribute id : String = "REQ-221";
    attribute node_configuration_design_detailed : Boolean;
    attribute bootstrapping_design_detailed : Boolean;
    attribute qserv_components_covered : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint DesignCompleteness { node_configuration_design_detailed == true and bootstrapping_design_detailed == true and qserv_components_covered == true }
    }

  requirement def QservRuntimeConfigurationDesign {
    subject;
    doc /* The system shall provide a detailed design for runtime configuration of all Qserv components */
    attribute id : String = "REQ-223";
    attribute runtime_configuration_design_detailed : Boolean;
    attribute all_qserv_components_configurable : Boolean;
    attribute design_documentation_complete : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint RuntimeConfigurationDesignComplete { runtime_configuration_design_detailed == true and all_qserv_components_configurable == true and design_documentation_complete == true }
    }

  requirement def CssExceptionDocumentationAccuracy {
    subject;
    doc /* The CSS exception documentation shall match the actual CssException class implementation */
    attribute id : String = "REQ-164";
    attribute documentation_matches_implementation : Boolean;
    attribute css_exception_class_name : String = "CssException";
    stakeholder developer : Developer;
    require constraint DocumentationAccuracy { css_exception_class_name == "CssException" implies documentation_matches_implementation == true }
    }

  requirement def DoxygenAutomaticFileDetection {
    subject;
    doc /* The doxygen documentation system shall automatically detect file names without explicit @file statements */
    attribute id : String = "REQ-165";
    attribute automatic_file_detection_enabled : Boolean;
    attribute explicit_file_statements_required : Boolean = false;
    attribute doxygen_system_active : Boolean;
    stakeholder developer : Developer;
    require constraint AutomaticFileDetection { automatic_file_detection_enabled == true and explicit_file_statements_required == false }
    assume constraint DoxygenSystemActive { doxygen_system_active == true }
    }

  requirement def QservNodeConfigurationDesign {
    subject;
    doc /* The system shall provide a detailed design for node configuration of Qserv components */
    attribute id : String = "REQ-221.1";
    attribute node_configuration_design_provided : Boolean;
    attribute qserv_components_configuration_defined : Boolean;
    attribute design_detail_level_adequate : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint NodeConfigurationDesignComplete { node_configuration_design_provided == true and qserv_components_configuration_defined == true and design_detail_level_adequate == true }
    }

  requirement def QservBootstrappingDesign {
    subject;
    doc /* The system shall provide a detailed design for bootstrapping of Qserv components */
    attribute id : String = "REQ-221.2";
    attribute bootstrapping_design_provided : Boolean;
    attribute qserv_components_bootstrapping_defined : Boolean;
    attribute bootstrapping_process_documented : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint BootstrappingDesignComplete { bootstrapping_design_provided == true and qserv_components_bootstrapping_defined == true and bootstrapping_process_documented == true }
    }

  requirement def CssExceptionNamingConventions {
    subject;
    doc /* The CSS exception naming shall follow LSST C++ naming conventions */
    attribute id : String = "REQ-162";
    attribute naming_convention_standard : String = "LSST C++";
    attribute css_exception_names_compliant : Boolean;
    stakeholder developer : Developer;
    require constraint NamingConventionCompliance { naming_convention_standard == "LSST C++" implies css_exception_names_compliant == true }
    }

  requirement def OfflineNodeUpdateDesign {
    subject;
    doc /* The system shall provide a design for updating offline nodes when they rejoin the cluster */
    attribute id : String = "REQ-222";
    attribute offline_node_update_design_provided : Boolean;
    attribute cluster_rejoin_handling_defined : Boolean;
    stakeholder administrator : Administrator;
    require constraint OfflineNodeDesign { offline_node_update_design_provided == true and cluster_rejoin_handling_defined == true }
    }

  requirement def DisplayCommunityInformationSection {
    subject;
    doc /* The website shall display community information in a dedicated section */
    attribute id : String = "REQ-248.1";
    attribute section_type : String = "community information";
    attribute section_dedicated : Boolean;
    attribute display_implemented : Boolean;
    stakeholder user : User;
    stakeholder customer : Customer;
    require constraint DedicatedSectionDisplay { section_dedicated == true and display_implemented == true }
    }

  requirement def ImproveWebsiteWithCommunityAndSpeakers {
    subject;
    doc /* The website shall be improved with new context including community and speakers information */
    attribute id : String = "REQ-248";
    attribute community_info_included : Boolean;
    attribute speakers_info_included : Boolean;
    attribute website_improvement_completed : Boolean;
    stakeholder user : User;
    stakeholder customer : Customer;
    require constraint ComprehensiveImprovement { community_info_included == true and speakers_info_included == true and website_improvement_completed == true }
    }

  requirement def DisplaySpeakersInformationSection {
    subject;
    doc /* The website shall display speakers information in a dedicated section */
    attribute id : String = "REQ-248.2";
    attribute section_type : String = "speakers information";
    attribute section_dedicated : Boolean;
    attribute display_implemented : Boolean;
    stakeholder user : User;
    stakeholder customer : Customer;
    require constraint DedicatedSpeakersDisplay { section_dedicated == true and display_implemented == true }
    }

  requirement def ExposeQservDocumentationOnMultiplePlatforms {
    subject;
    doc /* The documentation system shall expose 'how to run qserv' documentation on multiple platforms */
    attribute id : String = "REQ-266";
    attribute documentation_topic : String = "how to run qserv";
    attribute platform_count : Integer;
    attribute min_platform_count : Integer = 2;
    attribute exposure_completed : Boolean;
    stakeholder user : User;
    stakeholder administrator : Administrator;
    require constraint MultiplePlatformExposure { platform_count >= min_platform_count and exposure_completed == true }
    }

  requirement def ProvidePermanentQservDocumentationLocation {
    subject;
    doc /* The documentation system shall provide a permanent location for 'how to run qserv' documentation in the code repository */
    attribute id : String = "REQ-265";
    attribute documentation_topic : String = "how to run qserv";
    attribute location_type : String = "code repository";
    attribute location_permanent : Boolean;
    attribute location_provided : Boolean;
    stakeholder administrator : Administrator;
    stakeholder user : User;
    require constraint PermanentLocationProvided { location_permanent == true and location_provided == true }
    }

  requirement def InvestigateDataDistributionToolsAndDocument {
    subject;
    doc /* The research team shall investigate off-the-shelf data distribution tools and produce a documentation page */
    attribute id : String = "REQ-273";
    attribute investigation_scope : String = "off-the-shelf data distribution tools";
    attribute deliverable_type : String = "documentation page";
    attribute investigation_completed : Boolean;
    attribute documentation_produced : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint InvestigationAndDocumentation { investigation_completed == true and documentation_produced == true }
    }

  requirement def ProduceDataDistributionToolsDocumentation {
    subject;
    doc /* The research team shall produce a documentation page for data distribution tools */
    attribute id : String = "REQ-273.2";
    attribute documentation_topic : String = "data distribution tools";
    attribute deliverable_type : String = "documentation page";
    attribute documentation_produced : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint DocumentationPageProduced { deliverable_type == "documentation page" and documentation_produced == true }
    }

  requirement def MigrateReadmeToRestructuredText {
    subject;
    doc /* The documentation system shall migrate README files to reStructuredText format */
    attribute id : String = "REQ-244";
    attribute source_format : String = "README";
    attribute target_format : String = "reStructuredText";
    attribute migration_completed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ReadmeMigrationCompleted { source_format == "README" and target_format == "reStructuredText" implies migration_completed == true }
    }

  requirement def CreateStrategicPositioningDocument {
    subject;
    doc /* The documentation team shall create a 1-pager document for strategic positioning */
    attribute id : String = "REQ-249";
    attribute document_length : String = "1-pager";
    attribute document_purpose : String = "strategic positioning";
    attribute document_created : Boolean;
    stakeholder manager : Manager;
    stakeholder customer : Customer;
    require constraint OnePagerDocumentCreated { document_length == "1-pager" and document_purpose == "strategic positioning" implies document_created == true }
    }

  requirement def ExposeQservDocumentationOnTracPages {
    subject;
    doc /* The documentation system shall expose 'how to run qserv' documentation on Qserv trac pages */
    attribute id : String = "REQ-266.1";
    attribute documentation_topic : String = "how to run qserv";
    attribute platform_name : String = "Qserv trac pages";
    attribute exposure_completed : Boolean;
    stakeholder user : User;
    stakeholder administrator : Administrator;
    require constraint TracPagesExposure { platform_name == "Qserv trac pages" and documentation_topic == "how to run qserv" implies exposure_completed == true }
    }

  requirement def ExposeQservDocumentationOnConfluencePages {
    subject;
    doc /* The documentation system shall expose 'how to run qserv' documentation on confluence pages */
    attribute id : String = "REQ-266.2";
    attribute documentation_topic : String = "how to run qserv";
    attribute platform_name : String = "confluence pages";
    attribute exposure_completed : Boolean;
    stakeholder user : User;
    stakeholder administrator : Administrator;
    require constraint DocumentationExposure { documentation_topic == "how to run qserv" and platform_name == "confluence pages" implies exposure_completed == true }
    }

  requirement def MigrateReadmeDevelToRestructuredText {
    subject;
    doc /* The documentation system shall migrate README-devel files to reStructuredText format */
    attribute id : String = "REQ-245";
    attribute source_format : String = "README-devel";
    attribute target_format : String = "reStructuredText";
    attribute migration_completed : Boolean;
    stakeholder developer : Developer;
    require constraint FormatMigration { source_format == "README-devel" and target_format == "reStructuredText" implies migration_completed == true }
    }

  requirement def IntegrateDm622ValueAddedRemarks {
    subject;
    doc /* The documentation system shall integrate DM-622 value-added remarks about Qserv embedded documentation */
    attribute id : String = "REQ-246";
    attribute document_reference : String = "DM-622";
    attribute content_type : String = "value-added remarks";
    attribute integration_target : String = "Qserv embedded documentation";
    attribute integration_completed : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ValueAddedRemarksIntegration { document_reference == "DM-622" and content_type == "value-added remarks" implies integration_completed == true }
    }

  requirement def DocumentJobResubmissionMechanism {
    subject;
    doc /* The HTCondor system shall document the automatic job resubmission mechanism when a job fails */
    attribute id : String = "REQ-333.2";
    attribute documentation_completed : Boolean;
    attribute resubmission_mechanism_documented : Boolean;
    attribute documentation_accuracy_verified : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DocumentationCompletion { documentation_completed == true implies resubmission_mechanism_documented == true }
    require constraint DocumentationAccuracy { resubmission_mechanism_documented == true implies documentation_accuracy_verified == true }
    }

  requirement def InvestigateDocumentJobResubmission {
    subject;
    doc /* The HTCondor system shall investigate and document the automatic job resubmission mechanism when a job fails */
    attribute id : String = "REQ-333";
    attribute investigation_completed : Boolean;
    attribute documentation_completed : Boolean;
    attribute resubmission_mechanism_analyzed : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint InvestigationAndDocumentation { investigation_completed == true and documentation_completed == true }
    require constraint InvestigationImpliesAnalysis { investigation_completed == true implies resubmission_mechanism_analyzed == true }
    }

  requirement def IsrTaskInputsDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for IsrTask including inputs specification. */
    attribute id : String = "REQ-346.3";
    attribute task_name : String = "IsrTask";
    attribute inputs_documented : Boolean;
    attribute input_specifications_complete : Boolean;
    stakeholder developer : Developer;
    require constraint InputsDocumentationComplete { inputs_documented == true and input_specifications_complete == true }
    }

  requirement def CompleteRepairTaskDocumentation {
    subject;
    doc /* The documentation system shall provide complete Task documentation for RepairTask including purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-344";
    attribute task_name : String = "RepairTask";
    attribute documentation_complete : Boolean;
    attribute includes_purpose : Boolean;
    attribute includes_parameters : Boolean;
    attribute includes_inputs : Boolean;
    attribute includes_outputs : Boolean;
    attribute includes_examples : Boolean;
    stakeholder developer : Developer;
    require constraint CompleteDocumentationRequirement { documentation_complete == true implies (includes_purpose == true and includes_parameters == true and includes_inputs == true and includes_outputs == true and includes_examples == true) }
    }

  requirement def AssembleCcdTaskParametersDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for AssembleCcdTask including parameters specification. */
    attribute id : String = "REQ-347.2";
    attribute task_name : String = "AssembleCcdTask";
    attribute parameters_documented : Boolean;
    attribute parameter_specifications_complete : Boolean;
    stakeholder developer : Developer;
    require constraint ParametersDocumentationComplete { parameters_documented == true and parameter_specifications_complete == true }
    }

  requirement def IsrTaskParametersDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for IsrTask including parameters specification. */
    attribute id : String = "REQ-346.2";
    attribute task_name : String = "IsrTask";
    attribute parameters_documented : Boolean;
    attribute parameter_specifications_complete : Boolean;
    stakeholder developer : Developer;
    require constraint ParametersDocumentationComplete { parameters_documented == true and parameter_specifications_complete == true }
    }

  requirement def CompleteAssembleCcdTaskDocumentation {
    subject;
    doc /* The documentation system shall provide complete Task documentation for AssembleCcdTask including purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-347";
    attribute task_name : String = "AssembleCcdTask";
    attribute documentation_complete : Boolean;
    attribute includes_purpose : Boolean;
    attribute includes_parameters : Boolean;
    attribute includes_inputs : Boolean;
    attribute includes_outputs : Boolean;
    attribute includes_examples : Boolean;
    stakeholder developer : Developer;
    require constraint CompleteDocumentationRequirement { documentation_complete == true implies (includes_purpose == true and includes_parameters == true and includes_inputs == true and includes_outputs == true and includes_examples == true) }
    }

  requirement def RepairTaskUsageExamples {
    subject;
    doc /* The documentation system shall provide usage examples for RepairTask. */
    attribute id : String = "REQ-344.2";
    attribute task_name : String = "RepairTask";
    attribute examples_provided : Boolean;
    attribute example_count : Integer;
    attribute min_example_count : Integer;
    stakeholder developer : Developer;
    require constraint ExamplesProvided { examples_provided == true and example_count >= min_example_count }
    }

  requirement def CompleteIsrTaskDocumentation {
    subject;
    doc /* The documentation system shall provide complete Task documentation for IsrTask including purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-346";
    attribute task_name : String = "IsrTask";
    attribute documentation_complete : Boolean;
    attribute includes_purpose : Boolean;
    attribute includes_parameters : Boolean;
    attribute includes_inputs : Boolean;
    attribute includes_outputs : Boolean;
    attribute includes_examples : Boolean;
    stakeholder developer : Developer;
    require constraint CompleteDocumentationRequirement { documentation_complete == true implies (includes_purpose == true and includes_parameters == true and includes_inputs == true and includes_outputs == true and includes_examples == true) }
    }

  requirement def AssembleCcdTaskOutputsDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for AssembleCcdTask including outputs specification. */
    attribute id : String = "REQ-347.4";
    attribute task_name : String = "AssembleCcdTask";
    attribute outputs_documented : Boolean;
    attribute output_specifications_complete : Boolean;
    stakeholder developer : Developer;
    require constraint OutputsDocumentationComplete { outputs_documented == true and output_specifications_complete == true }
    }

  requirement def AssembleCcdTaskInputsDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for AssembleCcdTask including inputs specification. */
    attribute id : String = "REQ-347.3";
    attribute task_name : String = "AssembleCcdTask";
    attribute inputs_documented : Boolean;
    attribute input_specifications_complete : Boolean;
    stakeholder developer : Developer;
    require constraint InputsDocumentationComplete { inputs_documented == true and input_specifications_complete == true }
    }

  requirement def IsrTaskUsageExamples {
    subject;
    doc /* The documentation system shall provide Task documentation for IsrTask including usage examples. */
    attribute id : String = "REQ-346.5";
    attribute task_name : String = "IsrTask";
    attribute examples_provided : Boolean;
    attribute example_count : Integer;
    attribute min_example_count : Integer;
    stakeholder developer : Developer;
    require constraint ExamplesProvided { examples_provided == true and example_count >= min_example_count }
    }

  requirement def CmdLineTaskUsageExamples {
    subject;
    doc /* The documentation system shall provide usage examples for CmdLineTask. */
    attribute id : String = "REQ-345.2";
    attribute task_name : String = "CmdLineTask";
    attribute examples_provided : Boolean;
    attribute example_count : Integer;
    attribute min_example_count : Integer;
    stakeholder developer : Developer;
    require constraint ExamplesProvided { examples_provided == true and example_count >= min_example_count }
    }

  requirement def AssembleCcdTaskUsageExamples {
    subject;
    doc /* The documentation system shall provide Task documentation for AssembleCcdTask including usage examples. */
    attribute id : String = "REQ-347.5";
    attribute task_name : String = "AssembleCcdTask";
    attribute examples_provided : Boolean;
    attribute example_count : Integer;
    attribute min_example_count : Integer;
    stakeholder developer : Developer;
    require constraint ExamplesProvided { examples_provided == true and example_count >= min_example_count }
    }

  requirement def CompleteCmdLineTaskDocumentation {
    subject;
    doc /* The documentation system shall provide complete Task documentation for CmdLineTask including purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-345";
    attribute task_name : String = "CmdLineTask";
    attribute documentation_complete : Boolean;
    attribute includes_purpose : Boolean;
    attribute includes_parameters : Boolean;
    attribute includes_inputs : Boolean;
    attribute includes_outputs : Boolean;
    attribute includes_examples : Boolean;
    stakeholder developer : Developer;
    require constraint CompleteDocumentationRequirement { documentation_complete == true implies (includes_purpose == true and includes_parameters == true and includes_inputs == true and includes_outputs == true and includes_examples == true) }
    }

  requirement def IsrTaskPurposeDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for IsrTask including purpose description. */
    attribute id : String = "REQ-346.1";
    attribute task_name : String = "IsrTask";
    attribute purpose_documented : Boolean;
    attribute purpose_description_complete : Boolean;
    stakeholder developer : Developer;
    require constraint PurposeDocumentationComplete { purpose_documented == true and purpose_description_complete == true }
    }

  requirement def RepairTaskBasicDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for RepairTask including purpose, parameters, inputs, and outputs. */
    attribute id : String = "REQ-344.1";
    attribute task_name : String = "RepairTask";
    attribute basic_documentation_complete : Boolean;
    attribute includes_purpose : Boolean;
    attribute includes_parameters : Boolean;
    attribute includes_inputs : Boolean;
    attribute includes_outputs : Boolean;
    stakeholder developer : Developer;
    require constraint BasicDocumentationComplete { basic_documentation_complete == true implies (includes_purpose == true and includes_parameters == true and includes_inputs == true and includes_outputs == true) }
    }

  requirement def IsrTaskOutputsDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for IsrTask including outputs specification. */
    attribute id : String = "REQ-346.4";
    attribute task_name : String = "IsrTask";
    attribute outputs_documented : Boolean;
    attribute output_specifications_complete : Boolean;
    stakeholder developer : Developer;
    require constraint OutputsDocumentationComplete { outputs_documented == true and output_specifications_complete == true }
    }

  requirement def CmdLineTaskBasicDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for CmdLineTask including purpose, parameters, inputs, and outputs. */
    attribute id : String = "REQ-345.1";
    attribute task_name : String = "CmdLineTask";
    attribute basic_documentation_complete : Boolean;
    attribute includes_purpose : Boolean;
    attribute includes_parameters : Boolean;
    attribute includes_inputs : Boolean;
    attribute includes_outputs : Boolean;
    stakeholder developer : Developer;
    require constraint BasicDocumentationComplete { basic_documentation_complete == true implies (includes_purpose == true and includes_parameters == true and includes_inputs == true and includes_outputs == true) }
    }

  requirement def AssembleCcdTaskPurposeDocumentation {
    subject;
    doc /* The documentation system shall provide Task documentation for AssembleCcdTask including purpose description. */
    attribute id : String = "REQ-347.1";
    attribute task_name : String = "AssembleCcdTask";
    attribute purpose_documented : Boolean;
    attribute purpose_description_complete : Boolean;
    stakeholder developer : Developer;
    require constraint PurposeDocumentationComplete { purpose_documented == true and purpose_description_complete == true }
    }

  requirement def DipoleMeasurementTaskUsageExamples {
    subject;
    doc /* The system shall provide task documentation for DipoleMeasurementTask that includes usage examples demonstrating how to use the task. */
    attribute id : String = "REQ-356.5";
    attribute task_name : String = "DipoleMeasurementTask";
    attribute section_type : String = "usage_examples";
    attribute usage_examples_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint UsageExamplesDocumented { usage_examples_documented == true }
    }

  requirement def PsfMatchTaskDocumentation {
    subject;
    doc /* The system shall provide comprehensive task documentation for PsfMatchTask that includes purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-355";
    attribute task_name : String = "PsfMatchTask";
    attribute documentation_sections_required : Integer = 5;
    attribute documentation_sections_completed : Integer;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ComprehensiveDocumentation { documentation_sections_completed >= documentation_sections_required }
    }

  requirement def ImagePsfMatchTaskOutputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for ImagePsfMatchTask that includes the outputs of the task. */
    attribute id : String = "REQ-354.4";
    attribute task_name : String = "ImagePsfMatchTask";
    attribute section_type : String = "outputs";
    attribute outputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint OutputsDocumented { outputs_documented == true }
    }

  requirement def PsfMatchTaskPurposeDocumentation {
    subject;
    doc /* The system shall provide task documentation for PsfMatchTask that includes the purpose of the task. */
    attribute id : String = "REQ-355.1";
    attribute task_name : String = "PsfMatchTask";
    attribute section_type : String = "purpose";
    attribute purpose_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint PurposeDocumented { purpose_documented == true }
    }

  requirement def SnapPsfMatchTaskInputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for SnapPsfMatchTask that includes the inputs of the task. */
    attribute id : String = "REQ-353.3";
    attribute task_name : String = "SnapPsfMatchTask";
    attribute section_type : String = "inputs";
    attribute inputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint InputsDocumented { inputs_documented == true }
    }

  requirement def ImagePsfMatchTaskParametersDocumentation {
    subject;
    doc /* The system shall provide task documentation for ImagePsfMatchTask that includes the parameters of the task. */
    attribute id : String = "REQ-354.2";
    attribute task_name : String = "ImagePsfMatchTask";
    attribute section_type : String = "parameters";
    attribute parameters_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ParametersDocumented { parameters_documented == true }
    }

  requirement def ImagePsfMatchTaskUsageExamples {
    subject;
    doc /* The system shall provide task documentation for ImagePsfMatchTask that includes usage examples of the task. */
    attribute id : String = "REQ-354.5";
    attribute task_name : String = "ImagePsfMatchTask";
    attribute section_type : String = "usage_examples";
    attribute usage_examples_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint UsageExamplesDocumented { usage_examples_documented == true }
    }

  requirement def PsfMatchTaskInputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for PsfMatchTask that includes the inputs of the task. */
    attribute id : String = "REQ-355.3";
    attribute task_name : String = "PsfMatchTask";
    attribute section_type : String = "inputs";
    attribute inputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint InputsDocumented { inputs_documented == true }
    }

  requirement def DipoleMeasurementTaskPurposeDocumentation {
    subject;
    doc /* The system shall provide task documentation for DipoleMeasurementTask that includes the purpose of the task. */
    attribute id : String = "REQ-356.1";
    attribute task_name : String = "DipoleMeasurementTask";
    attribute section_type : String = "purpose";
    attribute purpose_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint PurposeDocumented { purpose_documented == true }
    }

  requirement def ImagePsfMatchTaskDocumentation {
    subject;
    doc /* The system shall provide comprehensive task documentation for ImagePsfMatchTask that includes purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-354";
    attribute task_name : String = "ImagePsfMatchTask";
    attribute documentation_sections_required : Integer = 5;
    attribute documentation_sections_completed : Integer;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ComprehensiveDocumentation { documentation_sections_completed >= documentation_sections_required }
    }

  requirement def ImagePsfMatchTaskPurposeDocumentation {
    subject;
    doc /* The system shall provide task documentation for ImagePsfMatchTask that includes the purpose of the task. */
    attribute id : String = "REQ-354.1";
    attribute task_name : String = "ImagePsfMatchTask";
    attribute section_type : String = "purpose";
    attribute purpose_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint PurposeDocumented { purpose_documented == true }
    }

  requirement def SnapPsfMatchTaskUsageExamples {
    subject;
    doc /* The system shall provide task documentation for SnapPsfMatchTask that includes usage examples of the task. */
    attribute id : String = "REQ-353.5";
    attribute task_name : String = "SnapPsfMatchTask";
    attribute section_type : String = "usage_examples";
    attribute usage_examples_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint UsageExamplesDocumented { usage_examples_documented == true }
    }

  requirement def DipoleMeasurementTaskDocumentation {
    subject;
    doc /* The system shall provide comprehensive task documentation for DipoleMeasurementTask that includes purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-356";
    attribute task_name : String = "DipoleMeasurementTask";
    attribute documentation_sections_required : Integer = 5;
    attribute documentation_sections_completed : Integer;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ComprehensiveDocumentation { documentation_sections_completed >= documentation_sections_required }
    }

  requirement def SnapPsfMatchTaskOutputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for SnapPsfMatchTask that includes the outputs of the task. */
    attribute id : String = "REQ-353.4";
    attribute task_name : String = "SnapPsfMatchTask";
    attribute section_type : String = "outputs";
    attribute outputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint OutputsDocumented { outputs_documented == true }
    }

  requirement def PsfMatchTaskOutputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for PsfMatchTask that includes the outputs of the task. */
    attribute id : String = "REQ-355.4";
    attribute task_name : String = "PsfMatchTask";
    attribute section_type : String = "outputs";
    attribute outputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint OutputsDocumented { outputs_documented == true }
    }

  requirement def SnapPsfMatchTaskPurposeDocumentation {
    subject;
    doc /* The system shall provide task documentation for SnapPsfMatchTask that includes the purpose of the task. */
    attribute id : String = "REQ-353.1";
    attribute task_name : String = "SnapPsfMatchTask";
    attribute section_type : String = "purpose";
    attribute purpose_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint PurposeDocumented { purpose_documented == true }
    }

  requirement def SnapPsfMatchTaskDocumentation {
    subject;
    doc /* The system shall provide comprehensive task documentation for SnapPsfMatchTask that includes purpose, parameters, inputs, outputs, and usage examples. */
    attribute id : String = "REQ-353";
    attribute task_name : String = "SnapPsfMatchTask";
    attribute documentation_sections_required : Integer = 5;
    attribute documentation_sections_completed : Integer;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ComprehensiveDocumentation { documentation_sections_completed >= documentation_sections_required }
    }

  requirement def DipoleMeasurementTaskInputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for DipoleMeasurementTask that includes the inputs accepted by the task. */
    attribute id : String = "REQ-356.3";
    attribute task_name : String = "DipoleMeasurementTask";
    attribute section_type : String = "inputs";
    attribute inputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint InputsDocumented { inputs_documented == true }
    }

  requirement def ImagePsfMatchTaskInputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for ImagePsfMatchTask that includes the inputs of the task. */
    attribute id : String = "REQ-354.3";
    attribute task_name : String = "ImagePsfMatchTask";
    attribute section_type : String = "inputs";
    attribute inputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint InputsDocumented { inputs_documented == true }
    }

  requirement def PsfMatchTaskParametersDocumentation {
    subject;
    doc /* The system shall provide task documentation for PsfMatchTask that includes the parameters of the task. */
    attribute id : String = "REQ-355.2";
    attribute task_name : String = "PsfMatchTask";
    attribute section_type : String = "parameters";
    attribute parameters_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ParametersDocumented { parameters_documented == true }
    }

  requirement def DipoleMeasurementTaskOutputsDocumentation {
    subject;
    doc /* The system shall provide task documentation for DipoleMeasurementTask that includes the outputs produced by the task. */
    attribute id : String = "REQ-356.4";
    attribute task_name : String = "DipoleMeasurementTask";
    attribute section_type : String = "outputs";
    attribute outputs_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint OutputsDocumented { outputs_documented == true }
    }

  requirement def PsfMatchTaskUsageExamples {
    subject;
    doc /* The system shall provide task documentation for PsfMatchTask that includes usage examples of the task. */
    attribute id : String = "REQ-355.5";
    attribute task_name : String = "PsfMatchTask";
    attribute section_type : String = "usage_examples";
    attribute usage_examples_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint UsageExamplesDocumented { usage_examples_documented == true }
    }

  requirement def SnapPsfMatchTaskParametersDocumentation {
    subject;
    doc /* The system shall provide task documentation for SnapPsfMatchTask that includes the parameters of the task. */
    attribute id : String = "REQ-353.2";
    attribute task_name : String = "SnapPsfMatchTask";
    attribute section_type : String = "parameters";
    attribute parameters_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ParametersDocumented { parameters_documented == true }
    }

  requirement def DipoleMeasurementTaskParametersDocumentation {
    subject;
    doc /* The system shall provide task documentation for DipoleMeasurementTask that includes the parameters required by the task. */
    attribute id : String = "REQ-356.2";
    attribute task_name : String = "DipoleMeasurementTask";
    attribute section_type : String = "parameters";
    attribute parameters_documented : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint ParametersDocumented { parameters_documented == true }
    }

  requirement def ProvideDataDistributionFaultRecoveryDesign {
    subject;
    doc /* The system shall provide a detailed design specification for data distribution covering fault recovery mechanisms */
    attribute id : String = "REQ-369";
    attribute design_specification_complete : Boolean;
    attribute fault_recovery_coverage : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint DesignSpecificationWithFaultRecovery { design_specification_complete == true and fault_recovery_coverage == true }
    }

  requirement def ProvideDataDistributionReplicaDesign {
    subject;
    doc /* The system shall provide a detailed design specification for data distribution covering multiple replica management */
    attribute id : String = "REQ-368";
    attribute design_specification_complete : Boolean;
    attribute replica_management_coverage : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint DesignSpecificationWithReplicaManagement { design_specification_complete == true and replica_management_coverage == true }
    }

  requirement def DefineErrorMessagePassingDesign {
    subject;
    doc /* The system shall define a design specification for passing error messages from czar to end users */
    attribute id : String = "REQ-365";
    attribute design_specification_complete : Boolean;
    attribute error_message_path_defined : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint ErrorMessageDesignComplete { design_specification_complete == true and error_message_path_defined == true }
    }

  requirement def ProvideDataDistributionL3RegistrationDesign {
    subject;
    doc /* The system shall provide a detailed design specification for data distribution covering user data (L3) registration */
    attribute id : String = "REQ-372";
    attribute design_specification_complete : Boolean;
    attribute l3_registration_procedures_defined : Boolean;
    stakeholder user : User;
    stakeholder administrator : Administrator;
    require constraint L3RegistrationDesignComplete { design_specification_complete == true and l3_registration_procedures_defined == true }
    }

  requirement def ProvideDataDistributionNodeAdditionDesign {
    subject;
    doc /* The system shall provide a detailed design specification for data distribution covering cluster node addition procedures */
    attribute id : String = "REQ-370";
    attribute design_specification_complete : Boolean;
    attribute node_addition_procedures_defined : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint NodeAdditionDesignComplete { design_specification_complete == true and node_addition_procedures_defined == true }
    }

  requirement def ProvideLogPackageCodeExamples {
    subject;
    doc /* The Log package shall provide code examples demonstrating proper usage of all major logging features */
    attribute id : String = "REQ-362";
    attribute example_count : Integer;
    attribute feature_coverage_percentage : Real;
    attribute examples_provided : Boolean;
    stakeholder developer : Developer;
    require constraint CodeExamplesProvided { examples_provided == true and feature_coverage_percentage >= 80.0 and example_count >= 5 }
    }

  requirement def ProvideDataDistributionL2IngestDesign {
    subject;
    doc /* The system shall provide a detailed design specification for data distribution covering L2 ingest data registration */
    attribute id : String = "REQ-371";
    attribute design_specification_complete : Boolean;
    attribute l2_ingest_registration_defined : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder administrator : Administrator;
    require constraint L2IngestDesignComplete { design_specification_complete == true and l2_ingest_registration_defined == true }
    }

  requirement def AccurateSpecificAlgorithmDocumentation {
    subject;
    doc /* All meas_base Algorithm documentation shall be accurate and specific to the algorithm's functionality */
    attribute id : String = "REQ-378";
    attribute documentation_accurate : Boolean;
    attribute documentation_specific : Boolean;
    stakeholder developer : Developer;
    require constraint DocumentationQuality { documentation_accurate == true and documentation_specific == true }
    }

  requirement def DetailedTaskDocumentation {
    subject;
    doc /* All meas_base tasks shall have detailed documentation following established documentation standards */
    attribute id : String = "REQ-379";
    attribute documentation_detailed : Boolean;
    attribute follows_standards : Boolean;
    stakeholder developer : Developer;
    stakeholder user : User;
    require constraint DetailedStandardsCompliance { documentation_detailed == true and follows_standards == true }
    }

  requirement def SpecificAlgorithmDocumentation {
    subject;
    doc /* All meas_base Algorithm documentation shall be specific to the algorithm's functionality */
    attribute id : String = "REQ-378.2";
    attribute documentation_specific : Boolean;
    stakeholder developer : Developer;
    require constraint AlgorithmSpecificDocumentation { documentation_specific == true }
    }

  requirement def AccurateSpecificPluginDocumentation {
    subject;
    doc /* All meas_base Plugin documentation shall be accurate and specific to the plugin's functionality */
    attribute id : String = "REQ-377";
    attribute documentation_accurate : Boolean;
    attribute documentation_specific : Boolean;
    stakeholder developer : Developer;
    require constraint PluginDocumentationQuality { documentation_accurate == true and documentation_specific == true }
    }

  requirement def SpecificPluginDocumentation {
    subject;
    doc /* All meas_base Plugin documentation shall be specific to the plugin's functionality */
    attribute id : String = "REQ-377.2";
    attribute documentation_specific : Boolean;
    stakeholder developer : Developer;
    require constraint PluginSpecificDocumentation { documentation_specific == true }
    }

  requirement def AccurateAlgorithmDocumentation {
    subject;
    doc /* All meas_base Algorithm documentation shall be accurate to the algorithm's functionality */
    attribute id : String = "REQ-378.1";
    attribute documentation_accurate : Boolean;
    stakeholder developer : Developer;
    require constraint AlgorithmAccurateDocumentation { documentation_accurate == true }
    }

  #trace dependency from DocumentationRequirements::ConsolidateDrpReport to DocumentationRequirements::UpdateConfluenceInstructions;
  #refinement dependency from DocumentationRequirements::InvestigateXrdSsiInterface to DocumentationRequirements::InvestigateAndDocumentXrdSsiInterface;
  #refinement dependency from DocumentationRequirements::DocumentXrdSsiInterface to DocumentationRequirements::InvestigateAndDocumentXrdSsiInterface;
  #refinement dependency from DocumentationRequirements::CreateAstrometryRepositoryInstructions to DocumentationRequirements::CreateAstrometryIndexInstructions;
  #refinement dependency from DocumentationRequirements::IncludeAstrometryRepositoryInstructions to DocumentationRequirements::CreateAstrometryIndexInstructions;
  #refinement dependency from DocumentationRequirements::RunCoAddTasks to DocumentationRequirements::RunCoAddAndPhotometryTasks;
  #refinement dependency from DocumentationRequirements::RunForcedPhotometryTasks to DocumentationRequirements::RunCoAddAndPhotometryTasks;
  #refinement dependency from DocumentationRequirements::ProvideComprehensiveDocumentation to DocumentationRequirements::ProvideWellDocumentedSoftwareStack;
  #refinement dependency from DocumentationRequirements::EnableMaintenanceActivities to DocumentationRequirements::ProvideWellDocumentedSoftwareStack;
  #refinement dependency from DocumentationRequirements::EnableLevel3Usage to DocumentationRequirements::ProvideWellDocumentedSoftwareStack;
  #trace dependency from DocumentationRequirements::CreateAstrometryIndexInstructions to BuildSystemRequirements::RelinkAstrometryData;
  #trace dependency from DocumentationRequirements::IncludeObsLsstSimExample to DocumentationRequirements::ConsolidateDrpReport;
  #refinement dependency from DocumentationRequirements::QservNodeConfigurationDesign to DocumentationRequirements::QservNodeConfigurationBootstrappingDesign;
  #refinement dependency from DocumentationRequirements::QservBootstrappingDesign to DocumentationRequirements::QservNodeConfigurationBootstrappingDesign;
  #derivation dependency from DocumentationRequirements::CssExceptionDocumentationAccuracy to BuildSystemRequirements::UseConciseExceptionNames;
  #trace dependency from DocumentationRequirements::CssExceptionNamingConventions to SystemArchitectureRequirements::ImplementSeparateExceptionClasses;
  #trace dependency from DocumentationRequirements::CssExceptionDocumentationAccuracy to SystemArchitectureRequirements::ImplementSeparateExceptionClasses;
  #refinement dependency from DocumentationRequirements::MigrateReadmeToRestructuredText to DocumentationRequirements::EnableMaintenanceActivities;
  #refinement dependency from DocumentationRequirements::MigrateReadmeDevelToRestructuredText to DocumentationRequirements::EnableMaintenanceActivities;
  #refinement dependency from DocumentationRequirements::IntegrateDm622ValueAddedRemarks to DocumentationRequirements::EnableMaintenanceActivities;
  #refinement dependency from DocumentationRequirements::DisplayCommunityInformationSection to DocumentationRequirements::ImproveWebsiteWithCommunityAndSpeakers;
  #refinement dependency from DocumentationRequirements::DisplaySpeakersInformationSection to DocumentationRequirements::ImproveWebsiteWithCommunityAndSpeakers;
  #refinement dependency from DocumentationRequirements::ExposeQservDocumentationOnTracPages to DocumentationRequirements::ExposeQservDocumentationOnMultiplePlatforms;
  #refinement dependency from DocumentationRequirements::ExposeQservDocumentationOnConfluencePages to DocumentationRequirements::ExposeQservDocumentationOnMultiplePlatforms;
  #refinement dependency from DocumentationRequirements::ProduceDataDistributionToolsDocumentation to DocumentationRequirements::InvestigateDataDistributionToolsAndDocument;
  #trace dependency from DocumentationRequirements::MigrateReadmeToRestructuredText to DocumentationRequirements::MigrateReadmeDevelToRestructuredText;
  #trace dependency from DocumentationRequirements::MigrateReadmeToRestructuredText to DocumentationRequirements::IntegrateDm622ValueAddedRemarks;
  #trace dependency from DocumentationRequirements::MigrateReadmeDevelToRestructuredText to DocumentationRequirements::IntegrateDm622ValueAddedRemarks;
  #trace dependency from DocumentationRequirements::DisplayCommunityInformationSection to DocumentationRequirements::DisplaySpeakersInformationSection;
  #trace dependency from DocumentationRequirements::ExposeQservDocumentationOnTracPages to DocumentationRequirements::ExposeQservDocumentationOnConfluencePages;
  #trace dependency from DocumentationRequirements::ProvidePermanentQservDocumentationLocation to DocumentationRequirements::ExposeQservDocumentationOnMultiplePlatforms;
  #refinement dependency from DocumentationRequirements::DocumentJobResubmissionMechanism to DocumentationRequirements::InvestigateDocumentJobResubmission;
  #trace dependency from DocumentationRequirements::InvestigateDocumentJobResubmission to TestingRequirements::ExecuteFailedJobTestScenario;
  #refinement dependency from DocumentationRequirements::RepairTaskBasicDocumentation to DocumentationRequirements::CompleteRepairTaskDocumentation;
  #refinement dependency from DocumentationRequirements::RepairTaskUsageExamples to DocumentationRequirements::CompleteRepairTaskDocumentation;
  #refinement dependency from DocumentationRequirements::CmdLineTaskBasicDocumentation to DocumentationRequirements::CompleteCmdLineTaskDocumentation;
  #refinement dependency from DocumentationRequirements::CmdLineTaskUsageExamples to DocumentationRequirements::CompleteCmdLineTaskDocumentation;
  #refinement dependency from DocumentationRequirements::IsrTaskPurposeDocumentation to DocumentationRequirements::CompleteIsrTaskDocumentation;
  #refinement dependency from DocumentationRequirements::IsrTaskParametersDocumentation to DocumentationRequirements::CompleteIsrTaskDocumentation;
  #refinement dependency from DocumentationRequirements::IsrTaskInputsDocumentation to DocumentationRequirements::CompleteIsrTaskDocumentation;
  #refinement dependency from DocumentationRequirements::IsrTaskOutputsDocumentation to DocumentationRequirements::CompleteIsrTaskDocumentation;
  #refinement dependency from DocumentationRequirements::IsrTaskUsageExamples to DocumentationRequirements::CompleteIsrTaskDocumentation;
  #refinement dependency from DocumentationRequirements::AssembleCcdTaskPurposeDocumentation to DocumentationRequirements::CompleteAssembleCcdTaskDocumentation;
  #refinement dependency from DocumentationRequirements::AssembleCcdTaskParametersDocumentation to DocumentationRequirements::CompleteAssembleCcdTaskDocumentation;
  #refinement dependency from DocumentationRequirements::AssembleCcdTaskInputsDocumentation to DocumentationRequirements::CompleteAssembleCcdTaskDocumentation;
  #refinement dependency from DocumentationRequirements::AssembleCcdTaskOutputsDocumentation to DocumentationRequirements::CompleteAssembleCcdTaskDocumentation;
  #refinement dependency from DocumentationRequirements::AssembleCcdTaskUsageExamples to DocumentationRequirements::CompleteAssembleCcdTaskDocumentation;
  #trace dependency from DocumentationRequirements::CompleteRepairTaskDocumentation to DocumentationRequirements::CompleteCmdLineTaskDocumentation;
  #trace dependency from DocumentationRequirements::CompleteCmdLineTaskDocumentation to DocumentationRequirements::CompleteIsrTaskDocumentation;
  #trace dependency from DocumentationRequirements::CompleteIsrTaskDocumentation to DocumentationRequirements::CompleteAssembleCcdTaskDocumentation;
  #refinement dependency from DocumentationRequirements::SnapPsfMatchTaskPurposeDocumentation to DocumentationRequirements::SnapPsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::SnapPsfMatchTaskParametersDocumentation to DocumentationRequirements::SnapPsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::SnapPsfMatchTaskInputsDocumentation to DocumentationRequirements::SnapPsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::SnapPsfMatchTaskOutputsDocumentation to DocumentationRequirements::SnapPsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::SnapPsfMatchTaskUsageExamples to DocumentationRequirements::SnapPsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::ImagePsfMatchTaskPurposeDocumentation to DocumentationRequirements::ImagePsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::ImagePsfMatchTaskParametersDocumentation to DocumentationRequirements::ImagePsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::ImagePsfMatchTaskInputsDocumentation to DocumentationRequirements::ImagePsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::ImagePsfMatchTaskOutputsDocumentation to DocumentationRequirements::ImagePsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::ImagePsfMatchTaskUsageExamples to DocumentationRequirements::ImagePsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::PsfMatchTaskPurposeDocumentation to DocumentationRequirements::PsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::PsfMatchTaskParametersDocumentation to DocumentationRequirements::PsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::PsfMatchTaskInputsDocumentation to DocumentationRequirements::PsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::PsfMatchTaskOutputsDocumentation to DocumentationRequirements::PsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::PsfMatchTaskUsageExamples to DocumentationRequirements::PsfMatchTaskDocumentation;
  #refinement dependency from DocumentationRequirements::DipoleMeasurementTaskPurposeDocumentation to DocumentationRequirements::DipoleMeasurementTaskDocumentation;
  #refinement dependency from DocumentationRequirements::DipoleMeasurementTaskParametersDocumentation to DocumentationRequirements::DipoleMeasurementTaskDocumentation;
  #refinement dependency from DocumentationRequirements::DipoleMeasurementTaskInputsDocumentation to DocumentationRequirements::DipoleMeasurementTaskDocumentation;
  #refinement dependency from DocumentationRequirements::DipoleMeasurementTaskOutputsDocumentation to DocumentationRequirements::DipoleMeasurementTaskDocumentation;
  #refinement dependency from DocumentationRequirements::DipoleMeasurementTaskUsageExamples to DocumentationRequirements::DipoleMeasurementTaskDocumentation;
  #trace dependency from DocumentationRequirements::SnapPsfMatchTaskDocumentation to DocumentationRequirements::CompleteRepairTaskDocumentation;
  #trace dependency from DocumentationRequirements::ImagePsfMatchTaskDocumentation to DocumentationRequirements::CompleteCmdLineTaskDocumentation;
  #trace dependency from DocumentationRequirements::PsfMatchTaskDocumentation to DocumentationRequirements::CompleteIsrTaskDocumentation;
  #trace dependency from DocumentationRequirements::DipoleMeasurementTaskDocumentation to DocumentationRequirements::CompleteAssembleCcdTaskDocumentation;
  #trace dependency from DocumentationRequirements::SnapPsfMatchTaskDocumentation to DocumentationRequirements::ProvideComprehensiveDocumentation;
  #trace dependency from DocumentationRequirements::ImagePsfMatchTaskDocumentation to DocumentationRequirements::ProvideComprehensiveDocumentation;
  #trace dependency from DocumentationRequirements::PsfMatchTaskDocumentation to DocumentationRequirements::ProvideComprehensiveDocumentation;
  #trace dependency from DocumentationRequirements::DipoleMeasurementTaskDocumentation to DocumentationRequirements::ProvideComprehensiveDocumentation;
  #trace dependency from DocumentationRequirements::ProvideLogPackageCodeExamples to BuildSystemRequirements::EliminateCompilerWarningsInLogPackage;
  #trace dependency from DocumentationRequirements::ProvideDataDistributionReplicaDesign to DocumentationRequirements::ProvideDataDistributionFaultRecoveryDesign;
  #trace dependency from DocumentationRequirements::ProvideDataDistributionReplicaDesign to DocumentationRequirements::ProvideDataDistributionNodeAdditionDesign;
  #trace dependency from DocumentationRequirements::ProvideDataDistributionFaultRecoveryDesign to DocumentationRequirements::ProvideDataDistributionL2IngestDesign;
  #trace dependency from DocumentationRequirements::ProvideDataDistributionNodeAdditionDesign to DocumentationRequirements::ProvideDataDistributionL3RegistrationDesign;
  #trace dependency from DocumentationRequirements::DefineErrorMessagePassingDesign to BuildSystemRequirements::HandleMetadataExceptions;
  #refinement dependency from DocumentationRequirements::SpecificPluginDocumentation to DocumentationRequirements::AccurateSpecificPluginDocumentation;
  #refinement dependency from DocumentationRequirements::AccurateAlgorithmDocumentation to DocumentationRequirements::AccurateSpecificAlgorithmDocumentation;
  #refinement dependency from DocumentationRequirements::SpecificAlgorithmDocumentation to DocumentationRequirements::AccurateSpecificAlgorithmDocumentation;
  #trace dependency from DocumentationRequirements::DetailedTaskDocumentation to DocumentationRequirements::SnapPsfMatchTaskDocumentation;
  }

package RepositoryManagementRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Administrator;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def AllowIssueBranchPatterns {
    subject;
    doc /* The gitolite system shall allow creation of issue/DM-NNNN branch patterns */
    attribute id : String = "REQ-013";
    attribute branch_pattern : String = "issue/DM-NNNN";
    attribute gitolite_configured : Boolean;
    attribute pattern_creation_allowed : Boolean;
    stakeholder developer : Developer;
    require constraint IssueBranchPatternAllowance { gitolite_configured == true implies pattern_creation_allowed == true }
    }

  requirement def AutoSavePreviousBranchState {
    subject;
    doc /* The git system shall automatically save the previous branch state when a forced push is detected */
    attribute id : String = "REQ-089";
    attribute previous_state_saved : Boolean;
    attribute forced_push_detected : Boolean;
    attribute save_operation_automatic : Boolean;
    stakeholder developer : Developer;
    require constraint AutoSaveOnForcedPush { forced_push_detected == true implies previous_state_saved == true and save_operation_automatic == true }
    }

  requirement def SaveBackupBranchesWithNamingPattern {
    subject;
    doc /* The git system shall save backup branches with naming pattern backups/tickets/DM-AAAA/NNNN where NNNN is monotonically increasing */
    attribute id : String = "REQ-090";
    attribute backup_branch_saved : Boolean;
    attribute naming_pattern : String = "backups/tickets/DM-AAAA/NNNN";
    attribute sequence_number_monotonic : Boolean;
    attribute ticket_id_format : String = "DM-AAAA";
    stakeholder developer : Developer;
    require constraint BackupBranchNaming { backup_branch_saved == true implies naming_pattern == "backups/tickets/DM-AAAA/NNNN" and sequence_number_monotonic == true and ticket_id_format == "DM-AAAA" }
    }

  requirement def CreateGitoliteHookForForcedPushDetection {
    subject;
    doc /* The git system shall create a gitolite hook that detects forced pushes */
    attribute id : String = "REQ-088";
    attribute hook_created : Boolean;
    attribute forced_push_detected : Boolean;
    stakeholder developer : Developer;
    require constraint HookDetectsForcedPush { hook_created == true implies forced_push_detected == true }
    }

  requirement def RestoreKeyValueStoreFromAsciiFile {
    subject;
    doc /* The CSS system shall provide functionality to restore the entire contents of the key/value store from an ascii file */
    attribute id : String = "REQ-204";
    attribute restore_functionality_provided : Boolean;
    attribute input_file_format : String = "ascii";
    attribute entire_store_restored : Boolean;
    stakeholder administrator : Administrator;
    require constraint RestoreFunctionalityComplete { restore_functionality_provided == true and input_file_format == "ascii" implies entire_store_restored == true }
    }

  requirement def RunPartitionerOnSchemaAndData {
    subject;
    doc /* The loading script shall run the partitioner on SQL schema and CSV data files */
    attribute id : String = "REQ-178.1";
    attribute sql_schema_processed : Boolean;
    attribute csv_data_processed : Boolean;
    attribute partitioner_executed : Boolean;
    stakeholder administrator : Administrator;
    require constraint PartitionerExecution { partitioner_executed == true implies (sql_schema_processed == true and csv_data_processed == true) }
    }

  requirement def DistributeQservTestdataWithLsstSw {
    subject;
    doc /* The new qserv_testdata repository shall be distributed with the lsst-sw tool */
    attribute id : String = "REQ-168";
    attribute repository_name : String = "qserv_testdata";
    attribute distribution_tool : String = "lsst-sw";
    attribute repository_distributed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint RepositoryDistribution { repository_name == "qserv_testdata" and distribution_tool == "lsst-sw" implies repository_distributed == true }
    }

  requirement def ExecuteDataProcessingOperations {
    subject;
    doc /* The loading script shall execute data processing operations including partitioning and chunk table creation */
    attribute id : String = "REQ-178";
    attribute partitioning_executed : Boolean;
    attribute chunk_table_creation_executed : Boolean;
    attribute data_processing_completed : Boolean;
    stakeholder administrator : Administrator;
    require constraint DataProcessingExecution { data_processing_completed == true implies (partitioning_executed == true and chunk_table_creation_executed == true) }
    }

  requirement def RenameQservdataRepository {
    subject;
    doc /* The git repository qservdata shall be renamed to qserv_testdata */
    attribute id : String = "REQ-167";
    attribute old_repository_name : String = "qservdata";
    attribute new_repository_name : String = "qserv_testdata";
    attribute repository_renamed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint RepositoryRename { old_repository_name == "qservdata" and new_repository_name == "qserv_testdata" implies repository_renamed == true }
    }

  requirement def RenameDrivingTableToKeyTable {
    subject;
    doc /* The metadata structure shall rename drivingTable to keyTable for clarity */
    attribute id : String = "REQ-198";
    attribute old_field_name : String = "drivingTable";
    attribute new_field_name : String = "keyTable";
    attribute metadata_field_renamed : Boolean;
    stakeholder developer : Developer;
    require constraint FieldRename { old_field_name == "drivingTable" and new_field_name == "keyTable" implies metadata_field_renamed == true }
    }

  requirement def HandleConcurrentTableCreationDuringDrop {
    subject;
    doc /* The database drop process shall handle concurrent table creation operations without corruption */
    attribute id : String = "REQ-193";
    attribute concurrent_table_operations : Boolean;
    attribute data_corruption_prevented : Boolean;
    attribute drop_process_completed : Boolean;
    stakeholder administrator : Administrator;
    require constraint ConcurrentOperationSafety { concurrent_table_operations == true implies data_corruption_prevented == true }
    require constraint DropProcessIntegrity { concurrent_table_operations == true implies drop_process_completed == true }
    }

  requirement def DumpKeyValueStoreToAsciiFile {
    subject;
    doc /* The CSS system shall provide functionality to dump the entire contents of the key/value store to an ascii file */
    attribute id : String = "REQ-203";
    attribute dump_functionality_provided : Boolean;
    attribute output_file_format : String = "ascii";
    attribute entire_store_dumped : Boolean;
    stakeholder administrator : Administrator;
    require constraint DumpFunctionalityComplete { dump_functionality_provided == true and entire_store_dumped == true }
    require constraint OutputFormatCompliance { output_file_format == "ascii" }
    }

  requirement def PlaceMetadataIntoZookeeper {
    subject;
    doc /* The loading script shall place appropriate metadata into zookeeper given database and table parameters */
    attribute id : String = "REQ-177";
    attribute database_parameters_provided : Boolean;
    attribute table_parameters_provided : Boolean;
    attribute metadata_placed_in_zookeeper : Boolean;
    stakeholder administrator : Administrator;
    require constraint MetadataPlacement { database_parameters_provided == true and table_parameters_provided == true implies metadata_placed_in_zookeeper == true }
    }

  requirement def RenameDatabasePartitioningField {
    subject;
    doc /* The zookeeper metadata shall rename DATABASE_PARTITIONING to PARTITIONING */
    attribute id : String = "REQ-200";
    attribute old_zookeeper_field : String = "DATABASE_PARTITIONING";
    attribute new_zookeeper_field : String = "PARTITIONING";
    attribute zookeeper_field_renamed : Boolean;
    stakeholder developer : Developer;
    require constraint FieldRenaming { zookeeper_field_renamed == true and old_zookeeper_field == "DATABASE_PARTITIONING" and new_zookeeper_field == "PARTITIONING" }
    }

  requirement def RenameDatabasesFieldToDbs {
    subject;
    doc /* The zookeeper metadata shall rename DATABASES to DBS */
    attribute id : String = "REQ-201";
    attribute old_databases_field : String = "DATABASES";
    attribute new_databases_field : String = "DBS";
    attribute databases_field_renamed : Boolean;
    stakeholder developer : Developer;
    require constraint DatabasesFieldRenaming { databases_field_renamed == true and old_databases_field == "DATABASES" and new_databases_field == "DBS" }
    }

  requirement def PreventDatabaseCreationRaceConditions {
    subject;
    doc /* The database creation process shall prevent race conditions when multiple admins create the same database simultaneously */
    attribute id : String = "REQ-192";
    attribute concurrent_admin_count : Integer;
    attribute race_condition_prevented : Boolean;
    attribute database_creation_synchronized : Boolean;
    stakeholder administrator : Administrator;
    require constraint RaceConditionPrevention { concurrent_admin_count > 1 implies race_condition_prevented == true }
    require constraint DatabaseCreationSafety { concurrent_admin_count > 1 implies database_creation_synchronized == true }
    }

  requirement def CreateChunkTablesFromSchemaAndData {
    subject;
    doc /* The loading script shall create chunk tables from SQL schema and CSV data files */
    attribute id : String = "REQ-178.2";
    attribute sql_schema_used : Boolean;
    attribute csv_data_used : Boolean;
    attribute chunk_tables_created : Boolean;
    stakeholder administrator : Administrator;
    require constraint ChunkTableCreation { sql_schema_used == true and csv_data_used == true implies chunk_tables_created == true }
    }

  requirement def RenameDbGroupToStorageClass {
    subject;
    doc /* The CSS metadata shall rename dbGroup to storageClass */
    attribute id : String = "REQ-199";
    attribute old_metadata_field : String = "dbGroup";
    attribute new_metadata_field : String = "storageClass";
    attribute css_metadata_renamed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint MetadataFieldRenaming { css_metadata_renamed == true and old_metadata_field == "dbGroup" and new_metadata_field == "storageClass" }
    }

  #trace dependency from RepositoryManagementRequirements::CreateGitoliteHookForForcedPushDetection to RepositoryManagementRequirements::AllowIssueBranchPatterns;
  #refinement dependency from RepositoryManagementRequirements::RunPartitionerOnSchemaAndData to RepositoryManagementRequirements::ExecuteDataProcessingOperations;
  #refinement dependency from RepositoryManagementRequirements::CreateChunkTablesFromSchemaAndData to RepositoryManagementRequirements::ExecuteDataProcessingOperations;
  #trace dependency from RepositoryManagementRequirements::PlaceMetadataIntoZookeeper to RepositoryManagementRequirements::ExecuteDataProcessingOperations;
  #trace dependency from RepositoryManagementRequirements::RenameDrivingTableToKeyTable to RepositoryManagementRequirements::RenameDbGroupToStorageClass;
  #trace dependency from RepositoryManagementRequirements::RenameDatabasePartitioningField to RepositoryManagementRequirements::RenameDatabasesFieldToDbs;
  }

package ReleaseManagementRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Administrator;
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def ProvideBuildArtifactsInRelease {
    subject;
    doc /* The Qserv system shall provide build artifacts in the release package */
    attribute id : String = "REQ-029.1";
    attribute system_name : String = "Qserv";
    attribute package_type : String = "release";
    attribute includes_build_artifacts : Boolean = true;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ReleasePackageContainsBuildArtifacts { package_type == "release" implies includes_build_artifacts == true }
    }

  requirement def IncludeLatestFixesInRelease {
    subject;
    doc /* The Qserv system shall include latest fixes in the release package */
    attribute id : String = "REQ-029.4";
    attribute system_name : String = "Qserv";
    attribute package_type : String = "release";
    attribute includes_latest_fixes : Boolean = true;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ReleasePackageContainsLatestFixes { package_type == "release" implies includes_latest_fixes == true }
    }

  requirement def ProvideFunctioningReleasePackage {
    subject;
    doc /* The Qserv system shall provide a fully functioning release package */
    attribute id : String = "REQ-029";
    attribute system_name : String = "Qserv";
    attribute package_type : String = "release";
    attribute fully_functioning : Boolean = true;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ReleasePackageFullyFunctioning { package_type == "release" implies fully_functioning == true }
    }

  requirement def ProvideCssComponentsInRelease {
    subject;
    doc /* The Qserv system shall provide CSS components in the release package */
    attribute id : String = "REQ-029.3";
    attribute system_name : String = "Qserv";
    attribute package_type : String = "release";
    attribute includes_css_components : Boolean = true;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ReleasePackageContainsCssComponents { package_type == "release" implies includes_css_components == true }
    }

  requirement def ProvidePackagingComponentsInRelease {
    subject;
    doc /* The Qserv system shall provide packaging components in the release package */
    attribute id : String = "REQ-029.2";
    attribute system_name : String = "Qserv";
    attribute package_type : String = "release";
    attribute includes_packaging_components : Boolean = true;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint ReleasePackageContainsPackagingComponents { package_type == "release" implies includes_packaging_components == true }
    }

  requirement def ReleaseAsOpenSourceSoftware {
    subject;
    doc /* The LSST Software Stack shall be released as open source software */
    attribute id : String = "REQ-101";
    attribute is_open_source : Boolean;
    attribute license_type : String;
    attribute source_code_available : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint OpenSourceRelease { is_open_source == true and source_code_available == true }
    }

  requirement def CreateFinalQservReleaseBuild {
    subject;
    doc /* The build system shall create a final Qserv release build for version 12.04 */
    attribute id : String = "REQ-155";
    attribute target_version : String = "12.04";
    attribute build_system_active : Boolean;
    attribute release_build_created : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ReleaseBuildForTargetVersion { target_version == "12.04" implies release_build_created == true }
    assume constraint BuildSystemReady { build_system_active == true }
    }

  requirement def CutAndPackageFinalQservRelease {
    subject;
    doc /* The release system shall cut and package the final Qserv 12.04 release */
    attribute id : String = "REQ-157";
    attribute target_version : String = "12.04";
    attribute release_system_active : Boolean;
    attribute release_cut_completed : Boolean;
    attribute release_packaged : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ReleaseProcessComplete { target_version == "12.04" implies (release_cut_completed == true and release_packaged == true) }
    assume constraint ReleaseSystemReady { release_system_active == true }
    }

  requirement def PackageFinalQservRelease {
    subject;
    doc /* The release system shall package the final Qserv 12.04 release */
    attribute id : String = "REQ-157.2";
    attribute target_version : String = "12.04";
    attribute release_system_active : Boolean;
    attribute release_packaged : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint PackagingForTargetVersion { target_version == "12.04" implies release_packaged == true }
    assume constraint ReleaseSystemOperational { release_system_active == true }
    }

  requirement def CutFinalQservRelease {
    subject;
    doc /* The release system shall cut the final Qserv 12.04 release */
    attribute id : String = "REQ-157.1";
    attribute target_version : String = "12.04";
    attribute release_system_active : Boolean;
    attribute release_cut_completed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ReleaseCutting { release_system_active == true implies release_cut_completed == true }
    require constraint VersionCompliance { target_version == "12.04" }
    }

  #refinement dependency from ReleaseManagementRequirements::ProvideBuildArtifactsInRelease to ReleaseManagementRequirements::ProvideFunctioningReleasePackage;
  #refinement dependency from ReleaseManagementRequirements::ProvidePackagingComponentsInRelease to ReleaseManagementRequirements::ProvideFunctioningReleasePackage;
  #refinement dependency from ReleaseManagementRequirements::ProvideCssComponentsInRelease to ReleaseManagementRequirements::ProvideFunctioningReleasePackage;
  #refinement dependency from ReleaseManagementRequirements::IncludeLatestFixesInRelease to ReleaseManagementRequirements::ProvideFunctioningReleasePackage;
  #refinement dependency from ReleaseManagementRequirements::CutFinalQservRelease to ReleaseManagementRequirements::CutAndPackageFinalQservRelease;
  #refinement dependency from ReleaseManagementRequirements::PackageFinalQservRelease to ReleaseManagementRequirements::CutAndPackageFinalQservRelease;
  #trace dependency from ReleaseManagementRequirements::CreateFinalQservReleaseBuild to TestingRequirements::ExecuteQservReleaseTests;
  #trace dependency from ReleaseManagementRequirements::CutAndPackageFinalQservRelease to ReleaseManagementRequirements::CreateFinalQservReleaseBuild;
  }

package TestingRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import RequirementDerivation::*;
  public import ModelingMetadata::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Administrator;
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def PassQueryAnalysisTests {
    subject;
    doc /* The testQueryAnalysis module shall pass all defined test cases */
    attribute id : String = "REQ-026";
    attribute module_name : String = "testQueryAnalysis";
    attribute total_test_cases : Integer;
    attribute passed_test_cases : Integer;
    stakeholder developer : Developer;
    require constraint AllTestCasesPass { passed_test_cases == total_test_cases }
    }

  requirement def ResolveCssIntegrationIssues {
    subject;
    doc /* The testCppParser module shall resolve all 12 identified issues related to CSS integration */
    attribute id : String = "REQ-022";
    attribute module_name : String = "testCppParser";
    attribute total_issues : Integer = 12;
    attribute resolved_issues : Integer;
    attribute integration_type : String = "CSS";
    stakeholder developer : Developer;
    require constraint AllIssuesResolved { resolved_issues == total_issues }
    }

  requirement def ValidateFunctionalityWithQueries {
    subject;
    doc /* The development environment shall validate functionality through execution of simple queries */
    attribute id : String = "REQ-037";
    attribute environment_type : String = "development";
    attribute query_complexity : String = "simple";
    attribute validation_method : String = "query_execution";
    attribute functionality_validated : Boolean;
    stakeholder developer : Developer;
    require constraint FunctionalityValidatedThroughQueries { validation_method == "query_execution" implies functionality_validated == true }
    }

  requirement def UtilizeNewXRootDImplementation {
    subject;
    doc /* The reference test server shall utilize the new XRootD implementation */
    attribute id : String = "REQ-038";
    attribute server_type : String = "reference_test";
    attribute xrootd_version : String = "new";
    attribute implementation_utilized : Boolean = true;
    stakeholder developer : Developer;
    require constraint NewXRootDImplementationUtilized { xrootd_version == "new" implies implementation_utilized == true }
    }

  requirement def ProvideCompleteQservInstallation {
    subject;
    doc /* The development environment shall provide a complete Qserv installation with test dataset */
    attribute id : String = "REQ-036";
    attribute environment_type : String = "development";
    attribute installation_complete : Boolean = true;
    attribute includes_test_dataset : Boolean = true;
    stakeholder developer : Developer;
    require constraint CompleteInstallationWithTestDataset { installation_complete == true and includes_test_dataset == true }
    }

  requirement def SetupBuildSlavesOnCommonOs {
    subject;
    doc /* The CI system shall setup build slaves on common operating systems where DM stack runs */
    attribute id : String = "REQ-082";
    attribute supported_operating_systems : String = "common OS where DM stack runs";
    attribute build_slaves_configured : Boolean;
    attribute dm_stack_compatibility : Boolean;
    stakeholder developer : Developer;
    require constraint BuildSlaveSetup { dm_stack_compatibility == true implies build_slaves_configured == true }
    }

  requirement def SendEmailNotificationsOnBuildFailure {
    subject;
    doc /* The CI system shall send email notifications to lsst-data when builds fail */
    attribute id : String = "REQ-084";
    attribute notification_recipient : String = "lsst-data";
    attribute build_failed : Boolean;
    attribute email_notification_sent : Boolean;
    stakeholder developer : Developer;
    require constraint BuildFailureNotification { build_failed == true implies email_notification_sent == true }
    }

  requirement def SetupBuildbotForDmEnvironment {
    subject;
    doc /* The CI system shall setup Buildbot 0.8.8 for the DM environment */
    attribute id : String = "REQ-081";
    attribute buildbot_version : String = "0.8.8";
    attribute target_environment : String = "DM";
    attribute setup_completed : Boolean;
    stakeholder developer : Developer;
    require constraint BuildbotSetup { buildbot_version == "0.8.8" and target_environment == "DM" implies setup_completed == true }
    }

  requirement def TriggerBuildOnMasterChanges {
    subject;
    doc /* The CI system shall trigger a build of master for every git change to master branch */
    attribute id : String = "REQ-083";
    attribute target_branch : String = "master";
    attribute build_triggered_on_change : Boolean;
    attribute git_change_detected : Boolean;
    stakeholder developer : Developer;
    require constraint BuildTriggerOnMasterChange { git_change_detected == true and target_branch == "master" implies build_triggered_on_change == true }
    }

  requirement def SendBuildbotInternalIssuesToOwner {
    subject;
    doc /* The CI system shall send buildbot internal issues to the buildbot owner */
    attribute id : String = "REQ-085";
    attribute issue_recipient : String = "buildbot owner";
    attribute internal_issue_detected : Boolean;
    attribute issue_notification_sent : Boolean;
    stakeholder administrator : Administrator;
    require constraint InternalIssuesRouted { internal_issue_detected == true implies issue_notification_sent == true }
    }

  requirement def SupportUserTriggeredBuildsViaWebInterface {
    subject;
    doc /* The CI system shall support user-triggered builds via web interface with specified git references */
    attribute id : String = "REQ-086";
    attribute interface_type : String = "web interface";
    attribute user_triggered_build_supported : Boolean;
    attribute git_reference_specified : Boolean;
    attribute build_initiated : Boolean;
    stakeholder developer : Developer;
    require constraint UserTriggeredBuildsSupported { interface_type == "web interface" and git_reference_specified == true implies user_triggered_build_supported == true }
    require constraint BuildInitiation { user_triggered_build_supported == true implies build_initiated == true }
    }

  requirement def VerifyPsfFluxCompatibility {
    subject;
    doc /* The test system shall verify PsfFlux algorithm compatibility with meas_algorithms */
    attribute id : String = "REQ-109";
    attribute algorithm_name : String = "PsfFlux";
    attribute target_module : String = "meas_algorithms";
    attribute compatibility_verified : Boolean;
    stakeholder developer : Developer;
    require constraint CompatibilityVerification { algorithm_name == "PsfFlux" and target_module == "meas_algorithms" implies compatibility_verified == true }
    }

  requirement def VerifyNaiveFluxCompatibility {
    subject;
    doc /* The test system shall verify NaiveFlux algorithm compatibility with meas_algorithms */
    attribute id : String = "REQ-107";
    attribute algorithm_name : String = "NaiveFlux";
    attribute target_module : String = "meas_algorithms";
    attribute compatibility_verified : Boolean;
    stakeholder developer : Developer;
    require constraint NaiveFluxCompatibilityVerification { algorithm_name == "NaiveFlux" and target_module == "meas_algorithms" implies compatibility_verified == true }
    }

  requirement def CompareResultsBetweenMeasurementScripts {
    subject;
    doc /* The test system shall compare results between original measurement.py and sfm.py measurement task */
    attribute id : String = "REQ-116";
    attribute script_one : String = "measurement.py";
    attribute script_two : String = "sfm.py";
    attribute results_compared : Boolean;
    attribute comparison_completed : Boolean;
    stakeholder developer : Developer;
    require constraint ScriptResultsComparison { script_one == "measurement.py" and script_two == "sfm.py" implies results_compared == true and comparison_completed == true }
    }

  requirement def VerifyGaussianFluxCompatibility {
    subject;
    doc /* The test system shall verify GaussianFlux algorithm compatibility with meas_algorithms */
    attribute id : String = "REQ-108";
    attribute algorithm_name : String = "GaussianFlux";
    attribute target_module : String = "meas_algorithms";
    attribute compatibility_verified : Boolean;
    stakeholder developer : Developer;
    require constraint GaussianFluxCompatibilityVerification { algorithm_name == "GaussianFlux" and target_module == "meas_algorithms" implies compatibility_verified == true }
    }

  requirement def RunMeasurementTaskInSfm {
    subject;
    doc /* The test system shall run measurement task in sfm.py for compatibility testing */
    attribute id : String = "REQ-115";
    attribute target_script : String = "sfm.py";
    attribute task_type : String = "measurement_task";
    attribute task_executed : Boolean;
    attribute testing_purpose : String = "compatibility";
    stakeholder developer : Developer;
    require constraint SfmMeasurementTaskExecution { target_script == "sfm.py" and task_type == "measurement_task" and testing_purpose == "compatibility" implies task_executed == true }
    }

  requirement def ProvideFluxAlgorithmUnitTests {
    subject;
    doc /* The test system shall provide unit tests for major configuration options of flux algorithms */
    attribute id : String = "REQ-112";
    attribute test_type : String = "unit_tests";
    attribute target_algorithms : String = "flux_algorithms";
    attribute configuration_options_tested : Boolean;
    stakeholder developer : Developer;
    require constraint FluxAlgorithmUnitTesting { test_type == "unit_tests" and target_algorithms == "flux_algorithms" implies configuration_options_tested == true }
    }

  requirement def CreateSourceCatalogForCompatibility {
    subject;
    doc /* The test system shall create source catalog using original measurement.py for compatibility testing */
    attribute id : String = "REQ-114";
    attribute source_script : String = "measurement.py";
    attribute script_type : String = "original";
    attribute catalog_created : Boolean;
    attribute testing_purpose : String = "compatibility";
    stakeholder developer : Developer;
    require constraint SourceCatalogCreationForCompatibility { source_script == "measurement.py" and script_type == "original" and testing_purpose == "compatibility" implies catalog_created == true }
    }

  requirement def TestFluxAlgorithmExceptionFlags {
    subject;
    doc /* The test system shall test at least one exception flag for flux algorithms */
    attribute id : String = "REQ-113";
    attribute min_exception_flags : Integer = 1;
    attribute target_algorithms : String = "flux_algorithms";
    attribute exception_flags_tested : Integer;
    stakeholder developer : Developer;
    require constraint MinimumExceptionFlagTesting { exception_flags_tested >= min_exception_flags }
    }

  requirement def WorkWithNewCssMetadataSystem {
    subject;
    doc /* The automated tests shall work with the new CSS metadata system */
    attribute id : String = "REQ-187";
    attribute new_css_metadata_system_active : Boolean;
    attribute automated_tests_compatible : Boolean;
    attribute tests_execution_successful : Boolean;
    stakeholder developer : Developer;
    require constraint TestsWorkWithNewSystem { automated_tests_compatible == true and tests_execution_successful == true }
    assume constraint NewCssSystemActive { new_css_metadata_system_active == true }
    }

  requirement def PackageIntegrationTestsAsEupspkg {
    subject;
    doc /* The integration tests dataset shall be packaged as a qserv-integration-tests eupspkg */
    attribute id : String = "REQ-207";
    attribute integration_tests_dataset_available : Boolean;
    attribute packaged_as_eupspkg : Boolean;
    attribute package_name : String = "qserv-integration-tests";
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint EupspkgPackaging { package_name == "qserv-integration-tests" implies packaged_as_eupspkg == true }
    assume constraint DatasetAvailable { integration_tests_dataset_available == true }
    }

  requirement def ManageTestVersionDependencies {
    subject;
    doc /* The qserv-integration-tests package shall manage test version dependencies in ups/qserv.table */
    attribute id : String = "REQ-208";
    attribute qserv_integration_tests_package_exists : Boolean;
    attribute ups_qserv_table_file_present : Boolean;
    attribute version_dependencies_managed : Boolean;
    attribute dependency_file_path : String = "ups/qserv.table";
    stakeholder developer : Developer;
    require constraint DependencyManagement { qserv_integration_tests_package_exists == true and ups_qserv_table_file_present == true implies version_dependencies_managed == true }
    require constraint FilePathCompliance { dependency_file_path == "ups/qserv.table" }
    }

  requirement def ExecuteQservReleaseTests {
    subject;
    doc /* The testing system shall execute all required tests for Qserv release 12.04 */
    attribute id : String = "REQ-156";
    attribute target_release_version : String = "12.04";
    attribute tests_executed : Boolean;
    attribute all_tests_passed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint TestExecution { tests_executed == true and all_tests_passed == true }
    require constraint ReleaseVersionCompliance { target_release_version == "12.04" }
    }

  requirement def FailEarlyOnMissingCssKvmap {
    subject;
    doc /* The parse and analysis tests shall fail early if the css-kvmap file is missing or invalid */
    attribute id : String = "REQ-183";
    attribute css_kvmap_file_present : Boolean;
    attribute css_kvmap_file_valid : Boolean;
    attribute early_failure_triggered : Boolean;
    stakeholder developer : Developer;
    require constraint EarlyFailureOnMissingFile { css_kvmap_file_present == false implies early_failure_triggered == true }
    require constraint EarlyFailureOnInvalidFile { css_kvmap_file_valid == false implies early_failure_triggered == true }
    }

  requirement def ReturnMysqlCompatibleErrorCodes {
    subject;
    doc /* The query system shall return mysql-compatible error codes instead of diagnostic result tables for query errors */
    attribute id : String = "REQ-191";
    attribute query_error_occurred : Boolean;
    attribute mysql_compatible_error_code_returned : Boolean;
    attribute diagnostic_result_table_returned : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint MysqlCompatibleErrors { query_error_occurred == true implies mysql_compatible_error_code_returned == true }
    require constraint NoDiagnosticTables { query_error_occurred == true implies diagnostic_result_table_returned == false }
    }

  requirement def RecordJobPlacementDecisions {
    subject;
    doc /* The HTCondor simulator shall record job placement decisions made by Rank when the pool is not empty at job submission time */
    attribute id : String = "REQ-226";
    attribute pool_empty : Boolean;
    attribute placement_decisions_recorded : Boolean;
    attribute rank_decisions_captured : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint RecordWhenPoolNotEmpty { pool_empty == false implies placement_decisions_recorded == true }
    require constraint CaptureRankDecisions { placement_decisions_recorded == true implies rank_decisions_captured == true }
    }

  requirement def ExecuteSingleSlowWorkerScenario {
    subject;
    doc /* The HTCondor simulator shall execute a single slow worker scenario where one job for a chosen CCD stalls during execution */
    attribute id : String = "REQ-224";
    attribute chosen_ccd_id : String;
    attribute job_stalled : Boolean;
    attribute scenario_active : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ExecuteScenarioWithStall { scenario_active == true implies job_stalled == true }
    }

  requirement def MaintainNormalJobExecution {
    subject;
    doc /* The HTCondor simulator shall maintain jobs for other CCDs executing normally while one CCD job is stalled */
    attribute id : String = "REQ-225";
    attribute other_ccds_executing : Boolean;
    attribute normal_execution_maintained : Boolean;
    attribute stalled_job_present : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint MaintainNormalDuringStall { stalled_job_present == true implies other_ccds_executing == true }
    require constraint PreserveNormalExecution { other_ccds_executing == true implies normal_execution_maintained == true }
    }

  requirement def PlaceJobsAccordingToRank {
    subject;
    doc /* The HTCondor simulator shall place jobs according to Rank expression even when other open slots are available */
    attribute id : String = "REQ-230";
    attribute other_slots_available : Boolean;
    attribute rank_expression_followed : Boolean;
    attribute job_placement_correct : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint FollowRankDespiteSlots { other_slots_available == true implies rank_expression_followed == true }
    require constraint CorrectPlacementByRank { rank_expression_followed == true implies job_placement_correct == true }
    }

  requirement def ConsistentlyPlaceJobsNearData {
    subject;
    doc /* The HTCondor simulator shall consistently place jobs for a CCD on slots that advertise associated data files for that CCD */
    attribute id : String = "REQ-229";
    attribute ccd_id : String;
    attribute associated_data_files_present : Boolean;
    attribute job_placement_consistent : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint PlaceNearAssociatedData { associated_data_files_present == true implies job_placement_consistent == true }
    }

  requirement def VerifyJobExecutionInAppropriateSlots {
    subject;
    doc /* The HTCondor simulator shall verify that jobs for 4 CCDs execute within appropriate slots when 5 slots are available */
    attribute id : String = "REQ-231";
    attribute num_ccds : Integer = 4;
    attribute num_slots_available : Integer = 5;
    attribute jobs_in_appropriate_slots : Boolean;
    attribute execution_verified : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint VerifyAppropriateSlotUsage { num_slots_available == 5 and num_ccds == 4 implies jobs_in_appropriate_slots == true }
    require constraint ConfirmExecution { jobs_in_appropriate_slots == true implies execution_verified == true }
    }

  requirement def ExecuteBaselineClassAdsScenarios {
    subject;
    doc /* The HTCondor simulator shall execute baseline ClassAds scenarios to verify job placement near data functionality */
    attribute id : String = "REQ-228";
    attribute baseline_scenarios_executed : Boolean;
    attribute job_placement_verified : Boolean;
    attribute near_data_functionality_tested : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint VerifyPlacementThroughBaseline { baseline_scenarios_executed == true implies job_placement_verified == true }
    require constraint TestNearDataFunctionality { job_placement_verified == true implies near_data_functionality_tested == true }
    }

  requirement def TrackFileTransferOperations {
    subject;
    doc /* The HTCondor simulator shall track file transfer operations during the single slow worker scenario */
    attribute id : String = "REQ-227";
    attribute file_transfers_tracked : Boolean;
    attribute slow_worker_scenario_active : Boolean;
    attribute transfer_operations_logged : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint TrackDuringSlowWorker { slow_worker_scenario_active == true implies file_transfers_tracked == true }
    require constraint LogTransferOperations { file_transfers_tracked == true implies transfer_operations_logged == true }
    }

  requirement def DefineChunkReplicaLocationPatterns {
    subject;
    doc /* The system shall define access patterns for chunk replica locations in data distribution store */
    attribute id : String = "REQ-259";
    attribute defines_replica_access_patterns : Boolean;
    attribute tracks_chunk_replica_locations : Boolean;
    stakeholder administrator : Administrator;
    require constraint ReplicaPatternsDefined { defines_replica_access_patterns == true and tracks_chunk_replica_locations == true }
    }

  requirement def DefineChunkToNodeMappingPatterns {
    subject;
    doc /* The system shall define access patterns for data distribution store including chunk-to-node mapping */
    attribute id : String = "REQ-258";
    attribute defines_access_patterns : Boolean;
    attribute includes_chunk_to_node_mapping : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint AccessPatternsWithMapping { defines_access_patterns == true and includes_chunk_to_node_mapping == true }
    }

  requirement def UseParameterizedQueries {
    subject;
    doc /* The czar proxy system shall use parameterized queries instead of string formatting to prevent SQL injection */
    attribute id : String = "REQ-254";
    attribute uses_parameterized_queries : Boolean;
    attribute prevents_sql_injection : Boolean;
    stakeholder administrator : Administrator;
    stakeholder user : User;
    require constraint ParameterizedQueriesForSecurity { uses_parameterized_queries == true and prevents_sql_injection == true }
    }

  requirement def ProvideIgnoreHeadersOption {
    subject;
    doc /* The automated test runner shall provide an option to ignore column headers during result comparison */
    attribute id : String = "REQ-256";
    attribute provides_ignore_headers_option : Boolean;
    attribute ignores_column_headers : Boolean;
    stakeholder developer : Developer;
    require constraint IgnoreHeadersOptionProvided { provides_ignore_headers_option == true and ignores_column_headers == true }
    }

  requirement def IncludeQueryIdInLogging {
    subject;
    doc /* The logging system shall include queryId in all logging locations where needed */
    attribute id : String = "REQ-270";
    attribute includes_query_id : Boolean;
    attribute covers_all_logging_locations : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint QueryIdInAllLoggingLocations { includes_query_id == true and covers_all_logging_locations == true }
    }

  requirement def SupportDistinctAggregateOperations {
    subject;
    doc /* The query processor shall support DISTINCT aggregate operations */
    attribute id : String = "REQ-268";
    attribute supports_distinct_operations : Boolean;
    attribute supports_aggregate_operations : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint DistinctAggregateSupport { supports_distinct_operations == true and supports_aggregate_operations == true }
    }

  requirement def SupportJoinQueriesWithoutCrashing {
    subject;
    doc /* The query execution system shall support JOIN queries without crashing */
    attribute id : String = "REQ-255";
    attribute supports_join_queries : Boolean;
    attribute system_crashes : Boolean;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint JoinQueriesWithoutCrashing { supports_join_queries == true implies system_crashes == false }
    }

  requirement def IncorporateXRootDIntegrationTweaks {
    subject;
    doc /* The XRootD client integration shall incorporate tweaks discovered during integration testing */
    attribute id : String = "REQ-269";
    attribute incorporates_integration_tweaks : Boolean;
    attribute discovered_during_testing : Boolean;
    stakeholder developer : Developer;
    require constraint TweakIncorporation { discovered_during_testing == true implies incorporates_integration_tweaks == true }
    }

  requirement def DefineRuntimeNodeInfoPatterns {
    subject;
    doc /* The system shall define access patterns for runtime node information in data distribution store */
    attribute id : String = "REQ-260";
    attribute defines_runtime_access_patterns : Boolean;
    attribute tracks_node_information : Boolean;
    stakeholder administrator : Administrator;
    require constraint RuntimePatternDefinition { tracks_node_information == true implies defines_runtime_access_patterns == true }
    }

  requirement def CalculateRefractionAmplitudes {
    subject;
    doc /* The system shall calculate refraction amplitudes for each spectral energy distribution (SED) input provided */
    attribute id : String = "REQ-282";
    attribute sed_inputs_processed : Integer;
    attribute refraction_amplitudes_calculated : Integer;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint AmplitudeCalculationMatch { sed_inputs_processed == refraction_amplitudes_calculated }
    }

  requirement def IncorporateStellarMagnitudeDistributions {
    subject;
    doc /* The system shall incorporate stellar magnitude distributions representative of survey depth limits */
    attribute id : String = "REQ-286";
    attribute survey_depth_representative : Boolean;
    attribute magnitude_distributions_incorporated : Boolean;
    attribute depth_limit_magnitude : Real;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint RepresentativeDistributionsIncorporated { survey_depth_representative == true implies magnitude_distributions_incorporated == true }
    }

  requirement def AcceptSedDataFitsFormat {
    subject;
    doc /* The system shall accept SED data in FITS format */
    attribute id : String = "REQ-283.1";
    attribute fits_format_accepted : Boolean;
    attribute fits_files_processed : Integer;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint FitsFormatProcessing { fits_format_accepted == true implies fits_files_processed > 0 }
    }

  requirement def AcceptSedDataAsciiFormat {
    subject;
    doc /* The system shall accept SED data in ASCII table format */
    attribute id : String = "REQ-283.2";
    attribute ascii_format_accepted : Boolean;
    attribute ascii_files_processed : Integer;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint AsciiFormatProcessing { ascii_format_accepted == true implies ascii_files_processed > 0 }
    }

  requirement def AcceptSedDataFormats {
    subject;
    doc /* The system shall accept SED data in standard astronomical formats including FITS and ASCII tables */
    attribute id : String = "REQ-283";
    attribute supported_formats : String = "FITS, ASCII";
    attribute fits_format_supported : Boolean;
    attribute ascii_format_supported : Boolean;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint BothFormatsSupported { fits_format_supported == true and ascii_format_supported == true }
    }

  requirement def OutputRefractionAmplitudePrecision {
    subject;
    doc /* The system shall output refraction amplitude results with wavelength-dependent precision of at least 0.1 milliarcseconds */
    attribute id : String = "REQ-284";
    attribute min_precision_milliarcsec : Real = 0.1;
    attribute measured_precision_milliarcsec : Real;
    attribute wavelength_dependent : Boolean;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint PrecisionRequirement { measured_precision_milliarcsec <= min_precision_milliarcsec and wavelength_dependent == true }
    }

  requirement def GenerateStatisticalSummaries {
    subject;
    doc /* The system shall generate statistical summaries of DCR amplitude distributions including mean, median, and percentile values */
    attribute id : String = "REQ-288";
    attribute mean_calculated : Boolean;
    attribute median_calculated : Boolean;
    attribute percentiles_calculated : Boolean;
    attribute summary_statistics_generated : Boolean;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint AllStatisticsGenerated { mean_calculated == true and median_calculated == true and percentiles_calculated == true implies summary_statistics_generated == true }
    }

  requirement def ModelDcrAmplitudes {
    subject;
    doc /* The system shall model differential chromatic refraction (DCR) amplitudes using realistic stellar population distributions */
    attribute id : String = "REQ-285";
    attribute stellar_population_realistic : Boolean;
    attribute dcr_amplitudes_modeled : Boolean;
    attribute stellar_distributions_used : Integer;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint RealisticModelingRequired { stellar_population_realistic == true implies dcr_amplitudes_modeled == true }
    }

  requirement def IncludeStellarColorDistributions {
    subject;
    doc /* The system shall include stellar color distributions based on galactic stellar population models */
    attribute id : String = "REQ-287";
    attribute galactic_models_based : Boolean;
    attribute color_distributions_included : Boolean;
    attribute stellar_population_models_used : Integer;
    stakeholder astronomer : Astronomer;
    stakeholder dataAnalyst : DataAnalyst;
    require constraint GalacticModelBasedDistributions { galactic_models_based == true implies color_distributions_included == true }
    }

  requirement def AssessEventSystemLoads {
    subject;
    doc /* The system shall assess loads on the event system during worker operations */
    attribute id : String = "REQ-317";
    attribute event_system_loads_assessed : Boolean;
    attribute worker_operations_active : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint LoadAssessmentDuringOperations { worker_operations_active == true implies event_system_loads_assessed == true }
    }

  requirement def ExecuteHTCondorWorkaroundSolutions {
    subject;
    doc /* The test system shall execute HTCondor team's workaround solutions for the autoclustering bug identified in ticket #4403 */
    attribute id : String = "REQ-297";
    attribute ticket_number : String = "4403";
    attribute workaround_solutions_executed : Boolean;
    attribute autoclustering_bug_addressed : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint WorkaroundExecution { workaround_solutions_executed == true and autoclustering_bug_addressed == true }
    }

  requirement def ValidateHTCondorSolutions {
    subject;
    doc /* The test system shall validate HTCondor solutions implemented in version 8.2.1 and later for autoclustering issues */
    attribute id : String = "REQ-299";
    attribute min_version : String = "8.2.1";
    attribute solutions_validated : Boolean;
    attribute autoclustering_issues_resolved : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint SolutionValidation { solutions_validated == true and autoclustering_issues_resolved == true }
    }

  requirement def AssessFilesystemLoads {
    subject;
    doc /* The system shall assess execution loads on filesystems during worker operations */
    attribute id : String = "REQ-316";
    attribute filesystem_loads_assessed : Boolean;
    attribute worker_operations_monitored : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint FilesystemLoadAssessment { worker_operations_monitored == true implies filesystem_loads_assessed == true }
    }

  requirement def VerifyRankExpressionResults {
    subject;
    doc /* The test system shall verify that job Rank expressions deliver expected results after applying HTCondor autoclustering bug fixes */
    attribute id : String = "REQ-298";
    attribute rank_expressions_verified : Boolean;
    attribute autoclustering_fixes_applied : Boolean;
    attribute expected_results_delivered : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint RankExpressionVerification { autoclustering_fixes_applied == true implies (rank_expressions_verified == true and expected_results_delivered == true) }
    }

  requirement def ExecuteSlotRemovalScenario {
    subject;
    doc /* The simulator shall execute the single HTCondor slot removal scenario with 4 CCDs, 5 slots, 90-second job length, 2-minute submit interval, and cache size 1 */
    attribute id : String = "REQ-300";
    attribute ccd_count : Integer = 4;
    attribute slot_count : Integer = 5;
    attribute job_length_seconds : Integer = 90;
    attribute submit_interval_seconds : Integer = 120;
    attribute cache_size : Integer = 1;
    attribute scenario_executed : Boolean;
    stakeholder systemOperator : SystemOperator;
    stakeholder developer : Developer;
    require constraint ScenarioParametersAndExecution { (ccd_count == 4 and slot_count == 5 and job_length_seconds == 90 and submit_interval_seconds == 120 and cache_size == 1) implies scenario_executed == true }
    }

  requirement def ExecuteFailedJobTestScenario {
    subject;
    doc /* The HTCondor system shall execute a test scenario where a single HTCondor job fails due to application error returning a nonzero exit code */
    attribute id : String = "REQ-332";
    attribute exit_code : Integer;
    attribute job_failure_detected : Boolean;
    attribute test_scenario_executed : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint NonzeroExitDetection { exit_code != 0 implies job_failure_detected == true }
    require constraint TestScenarioExecution { test_scenario_executed == true and job_failure_detected == true }
    }

  requirement def InvestigateJobResubmissionMechanism {
    subject;
    doc /* The HTCondor system shall investigate the automatic job resubmission mechanism when a job fails */
    attribute id : String = "REQ-333.1";
    attribute investigation_completed : Boolean;
    attribute resubmission_mechanism_analyzed : Boolean;
    attribute failure_detection_time_ms : Real;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint InvestigationCompletion { investigation_completed == true implies resubmission_mechanism_analyzed == true }
    }

  requirement def ProvideComprehensiveLogPackageTests {
    subject;
    doc /* The Log package shall include comprehensive unit tests that verify all logging functionality with clear pass/fail criteria */
    attribute id : String = "REQ-361";
    attribute test_coverage_percentage : Real;
    attribute pass_fail_criteria_defined : Boolean;
    attribute all_functionality_tested : Boolean;
    stakeholder developer : Developer;
    require constraint ComprehensiveTestCoverage { test_coverage_percentage >= 90.0 and pass_fail_criteria_defined == true and all_functionality_tested == true }
    }

  #trace dependency from TestingRequirements::ResolveCssIntegrationIssues to SystemArchitectureRequirements::ImplementSeparateExceptionClasses;
  #trace dependency from TestingRequirements::ProvideCompleteQservInstallation to TestingRequirements::ValidateFunctionalityWithQueries;
  #trace dependency from TestingRequirements::UtilizeNewXRootDImplementation to SystemArchitectureRequirements::ImplementAsynchronousXRootDClient;
  #trace dependency from TestingRequirements::PassQueryAnalysisTests to TestingRequirements::ResolveCssIntegrationIssues;
  #trace dependency from TestingRequirements::SetupBuildbotForDmEnvironment to BuildSystemRequirements::IncludeEupsTagInEmail;
  #trace dependency from TestingRequirements::VerifyNaiveFluxCompatibility to TestingRequirements::PassQueryAnalysisTests;
  #trace dependency from TestingRequirements::VerifyGaussianFluxCompatibility to TestingRequirements::PassQueryAnalysisTests;
  #trace dependency from TestingRequirements::VerifyPsfFluxCompatibility to TestingRequirements::PassQueryAnalysisTests;
  #trace dependency from TestingRequirements::ProvideFluxAlgorithmUnitTests to BuildSystemRequirements::BuildUnitTestsOnTarget;
  #trace dependency from TestingRequirements::ProvideFluxAlgorithmUnitTests to BuildSystemRequirements::ExecuteUnitTestsOnTarget;
  #trace dependency from TestingRequirements::CreateSourceCatalogForCompatibility to TestingRequirements::CompareResultsBetweenMeasurementScripts;
  #trace dependency from TestingRequirements::RunMeasurementTaskInSfm to TestingRequirements::CompareResultsBetweenMeasurementScripts;
  #derivation dependency from TestingRequirements::ExecuteQservReleaseTests to ReleaseManagementRequirements::CreateFinalQservReleaseBuild;
  #refinement dependency from TestingRequirements::ExecuteSingleSlowWorkerScenario to TestingRequirements::ExecuteBaselineClassAdsScenarios;
  #refinement dependency from TestingRequirements::MaintainNormalJobExecution to TestingRequirements::ExecuteBaselineClassAdsScenarios;
  #refinement dependency from TestingRequirements::ConsistentlyPlaceJobsNearData to TestingRequirements::ExecuteBaselineClassAdsScenarios;
  #refinement dependency from TestingRequirements::PlaceJobsAccordingToRank to TestingRequirements::ExecuteBaselineClassAdsScenarios;
  #refinement dependency from TestingRequirements::VerifyJobExecutionInAppropriateSlots to TestingRequirements::ExecuteBaselineClassAdsScenarios;
  #trace dependency from TestingRequirements::RecordJobPlacementDecisions to TestingRequirements::ExecuteBaselineClassAdsScenarios;
  #trace dependency from TestingRequirements::TrackFileTransferOperations to TestingRequirements::ExecuteSingleSlowWorkerScenario;
  #trace dependency from TestingRequirements::DefineChunkToNodeMappingPatterns to TestingRequirements::DefineChunkReplicaLocationPatterns;
  #trace dependency from TestingRequirements::DefineChunkToNodeMappingPatterns to TestingRequirements::DefineRuntimeNodeInfoPatterns;
  #trace dependency from TestingRequirements::DefineChunkReplicaLocationPatterns to TestingRequirements::DefineRuntimeNodeInfoPatterns;
  #trace dependency from TestingRequirements::IncorporateXRootDIntegrationTweaks to SystemArchitectureRequirements::ImplementAsynchronousXRootDClient;
  #trace dependency from TestingRequirements::IncludeQueryIdInLogging to BuildSystemRequirements::RestructureLog4cxxPrototype;
  #refinement dependency from TestingRequirements::AcceptSedDataFitsFormat to TestingRequirements::AcceptSedDataFormats;
  #refinement dependency from TestingRequirements::AcceptSedDataAsciiFormat to TestingRequirements::AcceptSedDataFormats;
  #derivation dependency from TestingRequirements::OutputRefractionAmplitudePrecision to TestingRequirements::CalculateRefractionAmplitudes;
  #derivation dependency from TestingRequirements::GenerateStatisticalSummaries to TestingRequirements::ModelDcrAmplitudes;
  #trace dependency from TestingRequirements::CalculateRefractionAmplitudes to TestingRequirements::AcceptSedDataFormats;
  #trace dependency from TestingRequirements::ModelDcrAmplitudes to TestingRequirements::IncorporateStellarMagnitudeDistributions;
  #trace dependency from TestingRequirements::ModelDcrAmplitudes to TestingRequirements::IncludeStellarColorDistributions;
  #trace dependency from TestingRequirements::IncorporateStellarMagnitudeDistributions to TestingRequirements::IncludeStellarColorDistributions;
  #refinement dependency from TestingRequirements::ExecuteHTCondorWorkaroundSolutions to TestingRequirements::ExecuteSingleSlowWorkerScenario;
  #refinement dependency from TestingRequirements::VerifyRankExpressionResults to TestingRequirements::RecordJobPlacementDecisions;
  #refinement dependency from TestingRequirements::ValidateHTCondorSolutions to TestingRequirements::ExecuteHTCondorWorkaroundSolutions;
  #refinement dependency from TestingRequirements::ExecuteSlotRemovalScenario to TestingRequirements::ExecuteSingleSlowWorkerScenario;
  #trace dependency from TestingRequirements::AssessFilesystemLoads to TestingRequirements::AssessEventSystemLoads;
  #refinement dependency from TestingRequirements::InvestigateJobResubmissionMechanism to DocumentationRequirements::InvestigateDocumentJobResubmission;
  #trace dependency from TestingRequirements::ExecuteFailedJobTestScenario to TestingRequirements::ExecuteSingleSlowWorkerScenario;
  #trace dependency from TestingRequirements::ProvideComprehensiveLogPackageTests to DocumentationRequirements::ProvideLogPackageCodeExamples;
  #trace dependency from TestingRequirements::ProvideComprehensiveLogPackageTests to BuildSystemRequirements::EliminateCompilerWarningsInLogPackage;
  #trace dependency from TestingRequirements::ProvideComprehensiveLogPackageTests to TestingRequirements::ProvideFluxAlgorithmUnitTests;
  }

package SystemArchitectureRequirements {
  private import Requirements::*;
  public import ScalarValues::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Administrator;
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def SupportJoinOperationsWithRefMatchTables {
    subject;
    doc /* The query system shall support JOIN operations with Ref*Match tables */
    attribute id : String = "REQ-040";
    attribute system_component : String = "query_system";
    attribute operation_type : String = "JOIN";
    attribute table_pattern : String = "Ref*Match";
    attribute support_enabled : Boolean = true;
    stakeholder user : User;
    stakeholder developer : Developer;
    require constraint JoinOperationsSupported { operation_type == "JOIN" and table_pattern == "Ref*Match" implies support_enabled == true }
    }

  requirement def ImplementProperNamespaceScoping {
    subject;
    doc /* All Qserv core modules shall implement proper namespace scoping in implementation files */
    attribute id : String = "REQ-032";
    attribute scope_target : String = "all_qserv_core_modules";
    attribute file_type : String = "implementation";
    attribute namespace_scoping_proper : Boolean = true;
    stakeholder developer : Developer;
    require constraint NamespaceScopingImplemented { file_type == "implementation" implies namespace_scoping_proper == true }
    }

  requirement def ProvideCommonBaseExceptionClass {
    subject;
    doc /* The CSS module shall provide a common base exception class for all CSS-specific exceptions */
    attribute id : String = "REQ-028";
    attribute module_name : String = "CSS";
    attribute base_exception_class : String = "CSSBaseException";
    attribute covers_all_css_exceptions : Boolean = true;
    stakeholder developer : Developer;
    require constraint BaseExceptionClassProvided { module_name == "CSS" implies covers_all_css_exceptions == true }
    }

  requirement def HandleConfigExceptionsGracefully {
    subject;
    doc /* The AsyncQueryManager shall handle configuration exceptions gracefully in upstream components */
    attribute id : String = "REQ-035";
    attribute component_name : String = "AsyncQueryManager";
    attribute exception_handling : String = "graceful";
    attribute upstream_components : Boolean = true;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint GracefulExceptionHandling { upstream_components == true implies exception_handling == "graceful" }
    }

  requirement def ImplementSeparateExceptionClasses {
    subject;
    doc /* The CSS module shall implement separate exception classes for each distinct error type */
    attribute id : String = "REQ-027";
    attribute module_name : String = "CSS";
    attribute exception_classes_separate : Boolean = true;
    attribute error_types_distinct : Boolean = true;
    stakeholder developer : Developer;
    require constraint SeparateExceptionClassesImplemented { error_types_distinct == true implies exception_classes_separate == true }
    }

  requirement def ThrowExceptionsOnInvalidConfig {
    subject;
    doc /* The AsyncQueryManager shall throw exceptions when initialized with invalid configuration */
    attribute id : String = "REQ-034";
    attribute component_name : String = "AsyncQueryManager";
    attribute throws_exceptions : Boolean = true;
    attribute config_validation : Boolean = true;
    attribute config_invalid : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint ExceptionsThrownOnInvalidConfig { config_invalid == true implies throws_exceptions == true }
    }

  requirement def ImplementAsynchronousXRootDClient {
    subject;
    doc /* The system shall implement an asynchronous XRootD client interface */
    attribute id : String = "REQ-039";
    attribute interface_type : String = "XRootD_client";
    attribute is_asynchronous : Boolean = true;
    attribute implementation_required : Boolean = true;
    stakeholder developer : Developer;
    require constraint AsynchronousClientImplemented { implementation_required == true implies is_asynchronous == true }
    }

  requirement def RenameSqlConfigClass {
    subject;
    doc /* The sql module shall rename the SqlConfig class to MySqlConfig for consistency */
    attribute id : String = "REQ-031";
    attribute module_name : String = "sql";
    attribute old_class_name : String = "SqlConfig";
    attribute new_class_name : String = "MySqlConfig";
    attribute rename_completed : Boolean;
    stakeholder developer : Developer;
    require constraint ClassRenameCompleted { old_class_name == "SqlConfig" and new_class_name == "MySqlConfig" implies rename_completed == true }
    }

  #trace dependency from SystemArchitectureRequirements::ImplementSeparateExceptionClasses to SystemArchitectureRequirements::ProvideCommonBaseExceptionClass;
  #trace dependency from SystemArchitectureRequirements::ThrowExceptionsOnInvalidConfig to SystemArchitectureRequirements::HandleConfigExceptionsGracefully;
  }

package ProjectManagementRequirements {
  private import Requirements::*;
  public import ScalarValues::*;
  public import ModelingMetadata::*;
  public import RequirementDerivation::*;

  metadata def <trace> Trace { :>> annotatedElement : SysML::Dependency; }
  part def Administrator;
  part def Developer;
  part def Manager;
  part def SystemOperator;
  part def User;
  part def Customer;
  part def Astronomer;
  part def DataAnalyst;
  part def ProjectManager;
  part def SystemArchitect;

  requirement def ProvideJiraIntegration {
    subject;
    doc /* The project management system shall provide Jira integration for Qserv task tracking */
    attribute id : String = "REQ-030";
    attribute system_type : String = "project_management";
    attribute integration_platform : String = "Jira";
    attribute project_name : String = "Qserv";
    attribute tracking_type : String = "task";
    attribute integration_provided : Boolean;
    stakeholder manager : Manager;
    stakeholder developer : Developer;
    require constraint JiraIntegrationProvided { integration_platform == "Jira" and tracking_type == "task" implies integration_provided == true }
    }

  requirement def FinalizeMissionStatement {
    subject;
    doc /* The DM team shall finalize the mission statement for LSST Software Stack development */
    attribute id : String = "REQ-095";
    attribute subject_area : String = "LSST Software Stack development";
    attribute mission_statement_finalized : Boolean;
    stakeholder manager : Manager;
    require constraint MissionStatementCompletion { subject_area == "LSST Software Stack development" implies mission_statement_finalized == true }
    }

  requirement def ObtainLeadershipAgreement {
    subject;
    doc /* The project management system shall obtain leadership team agreement on backlog prioritization */
    attribute id : String = "REQ-046";
    attribute leadership_agreement_obtained : Boolean;
    attribute prioritization_approved : Boolean;
    stakeholder manager : Manager;
    require constraint LeadershipAgreementRequired { leadership_agreement_obtained == true and prioritization_approved == true }
    }

  requirement def MaintainInternalStaffList {
    subject;
    doc /* The organization shall maintain an internal DM-staff-only mailing list for confidential discussions */
    attribute id : String = "REQ-094";
    attribute access_level : String = "DM-staff-only";
    attribute purpose : String = "confidential discussions";
    attribute internal_list_maintained : Boolean;
    stakeholder manager : Manager;
    require constraint InternalListMaintenance { access_level == "DM-staff-only" and purpose == "confidential discussions" implies internal_list_maintained == true }
    }

  requirement def DefineMajorStoriesForCycle {
    subject;
    doc /* The project management system shall define all major stories for Summer 2014 cycle */
    attribute id : String = "REQ-044.2";
    attribute cycle_name : String = "Summer 2014";
    attribute major_stories_defined : Boolean;
    stakeholder manager : Manager;
    require constraint MajorStoriesDefinition { cycle_name == "Summer 2014" implies major_stories_defined == true }
    }

  requirement def RankOrderBacklogItems {
    subject;
    doc /* The project management system shall rank-order all Summer 2014 backlog items by priority */
    attribute id : String = "REQ-045";
    attribute cycle_name : String = "Summer 2014";
    attribute backlog_items_ranked : Boolean;
    attribute priority_order_established : Boolean;
    stakeholder manager : Manager;
    require constraint BacklogRanking { cycle_name == "Summer 2014" implies backlog_items_ranked == true and priority_order_established == true }
    }

  requirement def MaintainPublicStaffList {
    subject;
    doc /* The organization shall maintain a public list of current DM staff with pictures and names */
    attribute id : String = "REQ-077";
    attribute list_visibility : String = "public";
    attribute includes_pictures : Boolean = true;
    attribute includes_names : Boolean = true;
    attribute staff_list_maintained : Boolean;
    stakeholder manager : Manager;
    require constraint PublicStaffListMaintenance { list_visibility == "public" and includes_pictures == true and includes_names == true implies staff_list_maintained == true }
    }

  requirement def MaintainAlumniList {
    subject;
    doc /* The organization shall maintain a public list of DM alumni with their current locations */
    attribute id : String = "REQ-078";
    attribute list_visibility : String = "public";
    attribute includes_locations : Boolean = true;
    attribute alumni_list_maintained : Boolean;
    stakeholder manager : Manager;
    require constraint AlumniListMaintenance { list_visibility == "public" and includes_locations == true implies alumni_list_maintained == true }
    }

  requirement def CreatePublicSoftwareUsersList {
    subject;
    doc /* The organization shall create a public lsst-software-users mailing list equivalent to current lsst-dm-stack-users */
    attribute id : String = "REQ-093";
    attribute new_list_name : String = "lsst-software-users";
    attribute equivalent_to : String = "lsst-dm-stack-users";
    attribute access_level : String = "public";
    attribute list_created : Boolean;
    stakeholder user : User;
    require constraint PublicSoftwareUsersListCreation { new_list_name == "lsst-software-users" and equivalent_to == "lsst-dm-stack-users" and access_level == "public" implies list_created == true }
    }

  requirement def IdentifyTeamsForStories {
    subject;
    doc /* The project management system shall identify teams to execute each story */
    attribute id : String = "REQ-047.1";
    attribute teams_identified : Boolean;
    attribute story_team_mapping_complete : Boolean;
    stakeholder manager : Manager;
    require constraint TeamIdentification { teams_identified == true and story_team_mapping_complete == true }
    }

  requirement def ApproveHipChatLicense {
    subject;
    doc /* The procurement system shall approve HipChat license acquisition for the project */
    attribute id : String = "REQ-069";
    attribute license_type : String = "HipChat";
    attribute approval_obtained : Boolean;
    stakeholder manager : Manager;
    require constraint HipChatLicenseApproval { license_type == "HipChat" implies approval_obtained == true }
    }

  requirement def OpenMailingListsToPublic {
    subject;
    doc /* The organization shall open LSST software development mailing lists to public access */
    attribute id : String = "REQ-091";
    attribute mailing_list_type : String = "LSST software development";
    attribute access_level : String = "public";
    attribute lists_opened : Boolean;
    stakeholder manager : Manager;
    require constraint MailingListsOpened { mailing_list_type == "LSST software development" and access_level == "public" implies lists_opened == true }
    }

  requirement def DefineEpicsForCycle {
    subject;
    doc /* The project management system shall define all epics for Summer 2014 cycle */
    attribute id : String = "REQ-044.1";
    attribute cycle_name : String = "Summer 2014";
    attribute epics_defined : Boolean;
    stakeholder manager : Manager;
    require constraint EpicsDefinedForCycle { cycle_name == "Summer 2014" implies epics_defined == true }
    }

  requirement def CreatePublicSoftwareDevList {
    subject;
    doc /* The organization shall create a public lsst-software-dev mailing list equivalent to current lsst-data */
    attribute id : String = "REQ-092";
    attribute new_list_name : String = "lsst-software-dev";
    attribute equivalent_to : String = "lsst-data";
    attribute access_level : String = "public";
    attribute list_created : Boolean;
    stakeholder developer : Developer;
    require constraint PublicListCreated { access_level == "public" and new_list_name == "lsst-software-dev" implies list_created == true }
    }

  requirement def ManageTeamAssignments {
    subject;
    doc /* The project management system shall manage team assignments and story labeling for project execution */
    attribute id : String = "REQ-047";
    attribute team_assignments_managed : Boolean;
    attribute story_labeling_completed : Boolean;
    stakeholder manager : Manager;
    require constraint TeamManagementComplete { team_assignments_managed == true and story_labeling_completed == true }
    }

  requirement def DefineEpicsAndStories {
    subject;
    doc /* The project management system shall define all epics and major stories for Summer 2014 cycle */
    attribute id : String = "REQ-044";
    attribute cycle_name : String = "Summer 2014";
    attribute epics_defined : Boolean;
    attribute major_stories_defined : Boolean;
    stakeholder manager : Manager;
    require constraint EpicsAndStoriesDefined { cycle_name == "Summer 2014" implies epics_defined == true and major_stories_defined == true }
    }

  requirement def CreateJobAdvertisements {
    subject;
    doc /* The HR system shall create job advertisements for Tucson DM positions */
    attribute id : String = "REQ-068";
    attribute location : String = "Tucson";
    attribute position_type : String = "DM";
    attribute advertisements_created : Boolean;
    stakeholder manager : Manager;
    require constraint AdvertisementsCreated { location == "Tucson" and position_type == "DM" implies advertisements_created == true }
    }

  requirement def LabelStoriesWithTeams {
    subject;
    doc /* The project management system shall label stories with their assigned teams */
    attribute id : String = "REQ-047.2";
    attribute stories_labeled : Boolean;
    attribute team_labels_applied : Boolean;
    stakeholder manager : Manager;
    require constraint StoriesLabeledWithTeams { stories_labeled == true and team_labels_applied == true }
    }

  requirement def AcquireHipChatLicenses {
    subject;
    doc /* The procurement system shall acquire HipChat licenses for 26 initial users at $52 per month */
    attribute id : String = "REQ-070";
    attribute initial_user_count : Integer = 26;
    attribute monthly_cost_per_user : Real = 52.0;
    attribute licenses_acquired : Boolean;
    stakeholder manager : Manager;
    require constraint LicensesAcquired { initial_user_count == 26 and monthly_cost_per_user == 52.0 implies licenses_acquired == true }
    }

  requirement def RecordDataIdentifiersPerNode {
    subject;
    doc /* The monitoring system shall record data identifiers processed on each compute node */
    attribute id : String = "REQ-236";
    attribute node_count : Integer;
    attribute data_identifiers_recorded : Boolean;
    stakeholder administrator : Administrator;
    stakeholder systemOperator : SystemOperator;
    require constraint RecordingPerNode { node_count > 0 implies data_identifiers_recorded == true }
    assume constraint NodesAvailable { node_count > 0 }
    }

  requirement def IntegrateWithHTCondorMonitoring {
    subject;
    doc /* The monitoring system shall integrate with HTCondor STARTD_HISTORY monitoring standards */
    attribute id : String = "REQ-238";
    attribute htcondor_integration_enabled : Boolean;
    attribute startd_history_compliance : Boolean;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint HTCondorCompliance { htcondor_integration_enabled == true implies startd_history_compliance == true }
    }

  requirement def ImplementBlackboardRecords {
    subject;
    doc /* The monitoring system shall implement blackboard-type records via job update hooks on execute nodes */
    attribute id : String = "REQ-239";
    attribute blackboard_records_enabled : Boolean;
    attribute job_update_hooks_active : Boolean;
    attribute execute_node_count : Integer;
    stakeholder administrator : Administrator;
    stakeholder developer : Developer;
    require constraint BlackboardImplementation { blackboard_records_enabled == true and job_update_hooks_active == true }
    assume constraint ExecuteNodesAvailable { execute_node_count > 0 }
    }

  requirement def RecordDataIdentifiersPerSlot {
    subject;
    doc /* The monitoring system shall record data identifiers processed within each slot on a compute node */
    attribute id : String = "REQ-237";
    attribute slot_count : Integer;
    attribute data_identifiers_per_slot : Boolean;
    stakeholder administrator : Administrator;
    stakeholder systemOperator : SystemOperator;
    require constraint RecordingPerSlot { slot_count > 0 implies data_identifiers_per_slot == true }
    assume constraint SlotsAvailable { slot_count > 0 }
    }

  requirement def PrepareForXLDBSouthAmerica {
    subject;
    doc /* The team shall prepare for XLDB-South America conference in Rio */
    attribute id : String = "REQ-263.1";
    attribute conference_name : String = "XLDB-South America";
    attribute conference_location : String = "Rio";
    attribute preparation_completed : Boolean;
    stakeholder manager : Manager;
    stakeholder developer : Developer;
    require constraint ConferencePreparation { conference_name == "XLDB-South America" and conference_location == "Rio" implies preparation_completed == true }
    }

  requirement def EvaluateMySQLClusterNDB {
    subject;
    doc /* The research team shall evaluate MySQL Cluster NDB for data distribution storage capabilities */
    attribute id : String = "REQ-257";
    attribute team_type : String = "research";
    attribute technology_name : String = "MySQL Cluster NDB";
    attribute evaluation_focus : String = "data distribution storage capabilities";
    attribute evaluation_completed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint TechnologyEvaluationCompleted { team_type == "research" and technology_name == "MySQL Cluster NDB" implies evaluation_completed == true }
    }

  requirement def ConductStrategicPartnerDiscussions {
    subject;
    doc /* The strategic positioning team shall conduct discussions with strategic partners for XLDB */
    attribute id : String = "REQ-247";
    attribute team_type : String = "strategic positioning";
    attribute partner_type : String = "strategic partners";
    attribute discussion_topic : String = "XLDB";
    attribute discussions_conducted : Boolean;
    stakeholder manager : Manager;
    stakeholder customer : Customer;
    require constraint StrategicDiscussionsConducted { team_type == "strategic positioning" and partner_type == "strategic partners" implies discussions_conducted == true }
    }

  requirement def InvestigateDataDistributionTools {
    subject;
    doc /* The research team shall investigate off-the-shelf data distribution tools */
    attribute id : String = "REQ-273.1";
    attribute team_type : String = "research";
    attribute tool_category : String = "off-the-shelf data distribution tools";
    attribute investigation_completed : Boolean;
    stakeholder developer : Developer;
    stakeholder administrator : Administrator;
    require constraint DataDistributionToolsInvestigated { team_type == "research" and tool_category == "off-the-shelf data distribution tools" implies investigation_completed == true }
    }

  requirement def PrepareAndAttendXLDBSouthAmerica {
    subject;
    doc /* The team shall prepare for and attend XLDB-South America conference in Rio */
    attribute id : String = "REQ-263";
    attribute conference_name : String = "XLDB-South America";
    attribute conference_location : String = "Rio";
    attribute preparation_completed : Boolean;
    attribute attendance_completed : Boolean;
    stakeholder manager : Manager;
    stakeholder developer : Developer;
    require constraint ConferencePreparationAndAttendance { preparation_completed == true and attendance_completed == true }
    }

  requirement def AttendXLDBSouthAmerica {
    subject;
    doc /* The team shall attend XLDB-South America conference in Rio */
    attribute id : String = "REQ-263.2";
    attribute conference_name : String = "XLDB-South America";
    attribute conference_location : String = "Rio";
    attribute attendance_completed : Boolean;
    stakeholder manager : Manager;
    stakeholder developer : Developer;
    require constraint ConferenceAttendance { conference_name == "XLDB-South America" and conference_location == "Rio" implies attendance_completed == true }
    }

  requirement def RetrieveTemplateImagesByFilterAirmass {
    subject;
    doc /* The worker shall retrieve template images by filter and airmass using the Data Access Client Framework */
    attribute id : String = "REQ-308";
    attribute template_images_retrieved : Boolean;
    attribute filter_specified : Boolean;
    attribute airmass_specified : Boolean;
    attribute data_access_framework_used : Boolean;
    stakeholder developer : Developer;
    require constraint TemplateImageRetrieval { (filter_specified == true and airmass_specified == true and data_access_framework_used == true) implies template_images_retrieved == true }
    }

  requirement def ContactArchiveDMCSForDistributor {
    subject;
    doc /* The worker job shall contact the Archive DMCS via blocking call to determine the distributor for the image and raft */
    attribute id : String = "REQ-312";
    attribute archive_dmcs_contacted : Boolean;
    attribute blocking_call_executed : Boolean;
    attribute distributor_determined : Boolean;
    attribute image_distributor_identified : Boolean;
    attribute raft_distributor_identified : Boolean;
    stakeholder developer : Developer;
    require constraint ArchiveContactForDistributor { (archive_dmcs_contacted == true and blocking_call_executed == true) implies (distributor_determined == true and image_distributor_identified == true and raft_distributor_identified == true) }
    }

  requirement def RetrieveMasterCalibrationImages {
    subject;
    doc /* The worker shall retrieve master calibration images appropriate for the CCD and filter */
    attribute id : String = "REQ-311";
    attribute master_calibration_retrieved : Boolean;
    attribute ccd_appropriate : Boolean;
    attribute filter_appropriate : Boolean;
    stakeholder developer : Developer;
    require constraint AppropriateCalibrationRetrieval { (ccd_appropriate == true and filter_appropriate == true) implies master_calibration_retrieved == true }
    }

  requirement def NewMasterWorkerResultTransmissionSystem {
    subject;
    doc /* The Qserv system shall implement a new master-worker result transmission system that does not rely on mysqldump */
    attribute id : String = "REQ-330";
    attribute system_name : String = "Qserv";
    attribute mysqldump_dependency : Boolean = false;
    attribute new_transmission_system_implemented : Boolean;
    attribute result_transmission_functional : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint NewSystemImplemented { new_transmission_system_implemented == true and result_transmission_functional == true }
    require constraint NoMysqldumpDependency { mysqldump_dependency == false }
    }

  requirement def ImprovedEfficiencyMasterWorkerSystem {
    subject;
    doc /* The new master-worker result system shall provide improved efficiency compared to the current mysqldump-based implementation */
    attribute id : String = "REQ-331";
    attribute efficiency_improved : Boolean;
    attribute current_implementation : String = "mysqldump-based";
    attribute new_system_efficiency : Real;
    attribute baseline_efficiency : Real;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint EfficiencyImprovement { new_system_efficiency > baseline_efficiency and efficiency_improved == true }
    }

  requirement def MultiNodeDeploymentSupport {
    subject;
    doc /* The Qserv system shall support multi-node deployment with at least 4 worker nodes and 1 czar node */
    attribute id : String = "REQ-327";
    attribute system_name : String = "Qserv";
    attribute min_worker_nodes : Integer = 4;
    attribute min_czar_nodes : Integer = 1;
    attribute actual_worker_nodes : Integer;
    attribute actual_czar_nodes : Integer;
    attribute multi_node_deployment_supported : Boolean;
    stakeholder administrator : Administrator;
    stakeholder systemOperator : SystemOperator;
    require constraint MinimumWorkerNodes { actual_worker_nodes >= min_worker_nodes }
    require constraint MinimumCzarNodes { actual_czar_nodes >= min_czar_nodes }
    require constraint MultiNodeSupport { multi_node_deployment_supported == true }
    }

  requirement def SupportJobHoldingMechanism {
    subject;
    doc /* The HTCondor system shall support a job holding mechanism for failed job recovery */
    attribute id : String = "REQ-334.1";
    attribute job_holding_supported : Boolean;
    attribute hold_mechanism_active : Boolean;
    attribute failed_jobs_held : Integer;
    stakeholder systemOperator : SystemOperator;
    require constraint HoldingMechanismSupport { job_holding_supported == true implies hold_mechanism_active == true }
    }

  requirement def ImplementReplicatorOutputValidation {
    subject;
    doc /* The AP Simulator shall implement output validation checks for replicator components */
    attribute id : String = "REQ-341";
    attribute output_validation_implemented : Boolean;
    attribute validation_checks_passed : Boolean;
    attribute validation_failure_count : Integer;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint ValidationImplementationCheck { output_validation_implemented == true implies validation_checks_passed == true }
    }

  requirement def SupportJobReleasingMechanism {
    subject;
    doc /* The HTCondor system shall support a job releasing mechanism for failed job recovery */
    attribute id : String = "REQ-334.2";
    attribute job_releasing_supported : Boolean;
    attribute release_mechanism_active : Boolean;
    attribute jobs_released_count : Integer;
    stakeholder systemOperator : SystemOperator;
    require constraint ReleasingMechanismSupport { job_releasing_supported == true implies release_mechanism_active == true }
    }

  requirement def SupportMultipleReplicatorPools {
    subject;
    doc /* The AP Simulator shall support multiple replicator pools for redundancy */
    attribute id : String = "REQ-343";
    attribute multiple_pools_supported : Boolean;
    attribute replicator_pools_count : Integer;
    attribute redundancy_level : Real;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint MultiplePoolsSupport { multiple_pools_supported == true implies replicator_pools_count > 1 }
    }

  requirement def SupportRescueDAGsWorkflowRecovery {
    subject;
    doc /* The HTCondor system shall support rescue DAGs for automatic workflow recovery after failures */
    attribute id : String = "REQ-336";
    attribute rescue_dags_supported : Boolean;
    attribute automatic_recovery_enabled : Boolean;
    attribute workflow_recovery_time_ms : Real;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint RescueDAGsSupport { rescue_dags_supported == true implies automatic_recovery_enabled == true }
    }

  requirement def SupportDAGManRecovery {
    subject;
    doc /* The HTCondor system shall support DAGMan for job recovery */
    attribute id : String = "REQ-335.2";
    attribute dagman_recovery_supported : Boolean;
    attribute recovery_capability_enabled : Boolean;
    attribute recovered_jobs_count : Integer;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DAGManRecoverySupport { dagman_recovery_supported == true implies recovery_capability_enabled == true }
    }

  requirement def ImplementReplicatorLeaseMechanisms {
    subject;
    doc /* The AP Simulator shall implement lease mechanisms for replicator components */
    attribute id : String = "REQ-339";
    attribute lease_mechanism_implemented : Boolean;
    attribute lease_duration_ms : Real;
    attribute replicator_lease_active : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint LeaseMechanismImplementation { lease_mechanism_implemented == true implies replicator_lease_active == true }
    }

  requirement def SupportJobHoldingReleasingMechanisms {
    subject;
    doc /* The HTCondor system shall support job holding and releasing mechanisms for failed job recovery */
    attribute id : String = "REQ-334";
    attribute job_holding_supported : Boolean;
    attribute job_releasing_supported : Boolean;
    attribute recovery_mechanism_active : Boolean;
    stakeholder systemOperator : SystemOperator;
    require constraint HoldingAndReleasingSupport { job_holding_supported == true and job_releasing_supported == true }
    require constraint RecoveryMechanismActivation { (job_holding_supported == true and job_releasing_supported == true) implies recovery_mechanism_active == true }
    }

  requirement def SupportDAGManDependenciesRecovery {
    subject;
    doc /* The HTCondor system shall support DAGMan for managing job dependencies and recovery */
    attribute id : String = "REQ-335";
    attribute dagman_supported : Boolean;
    attribute dependency_management_active : Boolean;
    attribute recovery_capability_enabled : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DAGManSupport { dagman_supported == true implies dependency_management_active == true }
    require constraint DAGManRecoveryCapability { dagman_supported == true implies recovery_capability_enabled == true }
    }

  requirement def ImplementReplicatorHeartbeatMechanisms {
    subject;
    doc /* The AP Simulator shall implement replicator heartbeat mechanisms for fault tolerance */
    attribute id : String = "REQ-337";
    attribute heartbeat_mechanism_implemented : Boolean;
    attribute heartbeat_interval_ms : Real;
    attribute fault_tolerance_enabled : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint HeartbeatImplementation { heartbeat_mechanism_implemented == true implies fault_tolerance_enabled == true }
    }

  requirement def ImplementDistributorOutputValidation {
    subject;
    doc /* The AP Simulator shall implement output validation checks for distributor components */
    attribute id : String = "REQ-342";
    attribute output_validation_implemented : Boolean;
    attribute validation_checks_passed : Boolean;
    attribute validation_failure_count : Integer;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DistributorValidationImplementation { output_validation_implemented == true implies validation_checks_passed == true }
    }

  requirement def SupportDAGManDependencies {
    subject;
    doc /* The HTCondor system shall support DAGMan for managing job dependencies */
    attribute id : String = "REQ-335.1";
    attribute dagman_supported : Boolean;
    attribute dependency_management_active : Boolean;
    attribute managed_dependencies_count : Integer;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DAGManDependencySupport { dagman_supported == true implies dependency_management_active == true }
    }

  requirement def ImplementDistributorHeartbeatMechanisms {
    subject;
    doc /* The AP Simulator shall implement distributor heartbeat mechanisms for fault tolerance */
    attribute id : String = "REQ-338";
    attribute heartbeat_mechanism_implemented : Boolean;
    attribute heartbeat_interval_ms : Real;
    attribute fault_tolerance_enabled : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DistributorHeartbeatImplementation { heartbeat_mechanism_implemented == true implies fault_tolerance_enabled == true }
    }

  requirement def ImplementDistributorLeaseMechanisms {
    subject;
    doc /* The AP Simulator shall implement lease mechanisms for distributor components */
    attribute id : String = "REQ-340";
    attribute lease_mechanism_implemented : Boolean;
    attribute lease_duration_ms : Real;
    attribute distributor_lease_active : Boolean;
    stakeholder developer : Developer;
    stakeholder systemOperator : SystemOperator;
    require constraint DistributorLeaseMechanismImplementation { lease_mechanism_implemented == true implies distributor_lease_active == true }
    }

  requirement def AssessXY0ConventionImpact {
    subject;
    doc /* The development team shall assess the impact of removing parent/child arguments from XY0 convention on all dependent packages and components. */
    attribute id : String = "REQ-349";
    attribute impact_assessment_complete : Boolean;
    attribute dependent_packages_identified : Boolean;
    attribute parent_child_arguments_removed : Boolean;
    attribute component_dependencies_analyzed : Boolean;
    stakeholder developer : Developer;
    stakeholder systemArchitect : SystemArchitect;
    require constraint ImpactAssessmentComplete { impact_assessment_complete == true implies (dependent_packages_identified == true and component_dependencies_analyzed == true) }
    }

  requirement def AnalyzeXY0ConventionChanges {
    subject;
    doc /* The development team shall analyze and determine the complete scope of changes required for updating the XY0 convention implementation. */
    attribute id : String = "REQ-348";
    attribute analysis_complete : Boolean;
    attribute scope_determined : Boolean;
    attribute change_requirements_identified : Boolean;
    attribute xy0_convention_updated : Boolean;
    stakeholder developer : Developer;
    stakeholder projectManager : ProjectManager;
    require constraint AnalysisComplete { analysis_complete == true implies (scope_determined == true and change_requirements_identified == true) }
    }

  #refinement dependency from ProjectManagementRequirements::DefineEpicsForCycle to ProjectManagementRequirements::DefineEpicsAndStories;
  #refinement dependency from ProjectManagementRequirements::DefineMajorStoriesForCycle to ProjectManagementRequirements::DefineEpicsAndStories;
  #refinement dependency from ProjectManagementRequirements::IdentifyTeamsForStories to ProjectManagementRequirements::ManageTeamAssignments;
  #refinement dependency from ProjectManagementRequirements::LabelStoriesWithTeams to ProjectManagementRequirements::ManageTeamAssignments;
  #derivation dependency from ProjectManagementRequirements::ObtainLeadershipAgreement to ProjectManagementRequirements::RankOrderBacklogItems;
  #derivation dependency from ProjectManagementRequirements::AcquireHipChatLicenses to ProjectManagementRequirements::ApproveHipChatLicense;
  #trace dependency from ProjectManagementRequirements::CreatePublicSoftwareDevList to ProjectManagementRequirements::ProvideJiraIntegration;
  #trace dependency from ProjectManagementRequirements::RecordDataIdentifiersPerNode to ProjectManagementRequirements::RecordDataIdentifiersPerSlot;
  #trace dependency from ProjectManagementRequirements::IntegrateWithHTCondorMonitoring to ProjectManagementRequirements::RecordDataIdentifiersPerNode;
  #trace dependency from ProjectManagementRequirements::ImplementBlackboardRecords to ProjectManagementRequirements::IntegrateWithHTCondorMonitoring;
  #trace dependency from ProjectManagementRequirements::RecordDataIdentifiersPerNode to TestingRequirements::ExecuteSingleSlowWorkerScenario;
  #trace dependency from ProjectManagementRequirements::ImplementBlackboardRecords to TestingRequirements::RecordJobPlacementDecisions;
  #refinement dependency from ProjectManagementRequirements::PrepareForXLDBSouthAmerica to ProjectManagementRequirements::PrepareAndAttendXLDBSouthAmerica;
  #refinement dependency from ProjectManagementRequirements::AttendXLDBSouthAmerica to ProjectManagementRequirements::PrepareAndAttendXLDBSouthAmerica;
  #refinement dependency from ProjectManagementRequirements::InvestigateDataDistributionTools to DocumentationRequirements::InvestigateDataDistributionToolsAndDocument;
  #trace dependency from ProjectManagementRequirements::ConductStrategicPartnerDiscussions to DocumentationRequirements::CreateStrategicPositioningDocument;
  #trace dependency from ProjectManagementRequirements::EvaluateMySQLClusterNDB to TestingRequirements::DefineChunkToNodeMappingPatterns;
  #trace dependency from ProjectManagementRequirements::EvaluateMySQLClusterNDB to TestingRequirements::DefineChunkReplicaLocationPatterns;
  #trace dependency from ProjectManagementRequirements::EvaluateMySQLClusterNDB to TestingRequirements::DefineRuntimeNodeInfoPatterns;
  #trace dependency from ProjectManagementRequirements::PrepareForXLDBSouthAmerica to ProjectManagementRequirements::AttendXLDBSouthAmerica;
  #trace dependency from ProjectManagementRequirements::InvestigateDataDistributionTools to DocumentationRequirements::ProduceDataDistributionToolsDocumentation;
  #refinement dependency from ProjectManagementRequirements::ContactArchiveDMCSForDistributor to BuildSystemRequirements::ReceiveVisitIdentification;
  #trace dependency from ProjectManagementRequirements::RetrieveTemplateImagesByFilterAirmass to ProjectManagementRequirements::RetrieveMasterCalibrationImages;
  #derivation dependency from ProjectManagementRequirements::NewMasterWorkerResultTransmissionSystem to ProjectManagementRequirements::ImprovedEfficiencyMasterWorkerSystem;
  #trace dependency from ProjectManagementRequirements::MultiNodeDeploymentSupport to InstallationRequirements::AutomatedMultiNodeQservSetup;
  #refinement dependency from ProjectManagementRequirements::SupportJobHoldingMechanism to ProjectManagementRequirements::SupportJobHoldingReleasingMechanisms;
  #refinement dependency from ProjectManagementRequirements::SupportJobReleasingMechanism to ProjectManagementRequirements::SupportJobHoldingReleasingMechanisms;
  #refinement dependency from ProjectManagementRequirements::SupportDAGManDependencies to ProjectManagementRequirements::SupportDAGManDependenciesRecovery;
  #refinement dependency from ProjectManagementRequirements::SupportDAGManRecovery to ProjectManagementRequirements::SupportDAGManDependenciesRecovery;
  #derivation dependency from ProjectManagementRequirements::SupportRescueDAGsWorkflowRecovery to ProjectManagementRequirements::SupportDAGManDependenciesRecovery;
  #trace dependency from ProjectManagementRequirements::SupportJobHoldingReleasingMechanisms to TestingRequirements::ExecuteFailedJobTestScenario;
  #trace dependency from ProjectManagementRequirements::SupportDAGManDependenciesRecovery to TestingRequirements::ExecuteFailedJobTestScenario;
  #trace dependency from ProjectManagementRequirements::ImplementReplicatorHeartbeatMechanisms to BuildSystemRequirements::IncludeDistributorComponent;
  #trace dependency from ProjectManagementRequirements::ImplementDistributorHeartbeatMechanisms to BuildSystemRequirements::IncludeDistributorComponent;
  #trace dependency from ProjectManagementRequirements::ImplementReplicatorLeaseMechanisms to BuildSystemRequirements::AssociateReplicatorWithDistributor;
  #trace dependency from ProjectManagementRequirements::ImplementDistributorLeaseMechanisms to BuildSystemRequirements::AssociateReplicatorWithDistributor;
  #trace dependency from ProjectManagementRequirements::ImplementReplicatorOutputValidation to BuildSystemRequirements::EnableJobInformationTransfer;
  #trace dependency from ProjectManagementRequirements::ImplementDistributorOutputValidation to BuildSystemRequirements::EnableDataCopyToDistributor;
  #trace dependency from ProjectManagementRequirements::AnalyzeXY0ConventionChanges to ProjectManagementRequirements::AssessXY0ConventionImpact;
  }